From 0593001d83bfe456e3bfea4de93b556cc5c1820c Mon Sep 17 00:00:00 2001 From: Yehuda Sadeh Date: Thu, 14 Jul 2011 15:29:36 -0700 Subject: [PATCH] rgw: cleanup, remove globals and static craft --- src/rgw/rgw_common.cc | 24 +++++++++++++++ src/rgw/rgw_common.h | 3 +- src/rgw/rgw_main.cc | 34 +++++++++++--------- src/rgw/rgw_op.cc | 25 +++------------ src/rgw/rgw_op.h | 7 ++--- src/rgw/rgw_os_auth.cc | 6 +++- src/rgw/rgw_os_auth.h | 3 +- src/rgw/rgw_rest.cc | 70 +++++++++++++++++++++++------------------- src/rgw/rgw_rest.h | 34 ++++++++++++++------ src/rgw/rgw_rest_os.cc | 45 ++++++++++++++------------- src/rgw/rgw_rest_os.h | 24 ++++----------- src/rgw/rgw_rest_s3.cc | 55 +++++++++++++++++---------------- src/rgw/rgw_rest_s3.h | 29 ++++------------- 13 files changed, 186 insertions(+), 173 deletions(-) diff --git a/src/rgw/rgw_common.cc b/src/rgw/rgw_common.cc index 2fe42d285c212..d44e310c45294 100644 --- a/src/rgw/rgw_common.cc +++ b/src/rgw/rgw_common.cc @@ -6,6 +6,7 @@ #include "common/ceph_crypto.h" #include "common/armor.h" #include "common/errno.h" +#include "common/Clock.h" #include "auth/Crypto.h" using namespace ceph::crypto; @@ -42,6 +43,29 @@ is_err() const return (http_ret != 200 && http_ret != 204); } + +req_state::req_state() : acl(NULL), os_auth_token(NULL), os_user(NULL), os_groups(NULL) +{ + should_log = rgwconf->should_log; + content_started = false; + format = 0; + acl = new RGWAccessControlPolicy; + expect_cont = false; + + os_auth_token = NULL; + os_user = NULL; + os_groups = NULL; + time = ceph_clock_now(g_ceph_context); + perm_mask = 0; +} + +req_state::~req_state() { + delete acl; + delete formatter; + free(os_user); + free(os_groups); +} + std::ostream& operator<<(std::ostream& oss, const rgw_err &err) { oss << "rgw_err(http_ret=" << err.http_ret << ", s3='" << err.s3_code << "') "; diff --git a/src/rgw/rgw_common.h b/src/rgw/rgw_common.h index f8da951ca5c5e..de0c3201db03c 100644 --- a/src/rgw/rgw_common.h +++ b/src/rgw/rgw_common.h @@ -440,7 +440,8 @@ struct req_state { int pool_id; - req_state() : acl(NULL), os_auth_token(NULL), os_user(NULL), os_groups(NULL) {} + req_state(); + ~req_state(); }; /** Store basic data on an object */ diff --git a/src/rgw/rgw_main.cc b/src/rgw/rgw_main.cc index 36b9d7c88daad..f21fae99bb2e6 100644 --- a/src/rgw/rgw_main.cc +++ b/src/rgw/rgw_main.cc @@ -56,7 +56,6 @@ static void godown_alarm(int signum) */ int main(int argc, const char **argv) { - struct req_state s; struct fcgx_state fcgx; curl_global_init(CURL_GLOBAL_ALL); @@ -87,33 +86,37 @@ int main(int argc, const char **argv) sighandler_usr1 = signal(SIGUSR1, godown_handler); sighandler_alrm = signal(SIGALRM, godown_alarm); + RGWRESTMgr rest; + while (FCGX_Accept(&fcgx.in, &fcgx.out, &fcgx.err, &fcgx.envp) >= 0) { rgw_env.reinit(fcgx.envp); + struct req_state *s = new req_state; + RGWOp *op; int init_error = 0; - RGWHandler *handler = RGWHandler_REST::init_handler(&s, &fcgx, &init_error); + RGWHandler *handler = rest.get_handler(s, &fcgx, &init_error); int ret; if (init_error != 0) { - abort_early(&s, init_error); + abort_early(s, init_error); goto done; } - if (!handler->authorize(&s)) { + if (!handler->authorize()) { RGW_LOG(10) << "failed to authorize request" << dendl; - abort_early(&s, -EPERM); + abort_early(s, -EPERM); goto done; } - if (s.user.suspended) { - RGW_LOG(10) << "user is suspended, uid=" << s.user.user_id << dendl; - abort_early(&s, -ERR_USER_SUSPENDED); + if (s->user.suspended) { + RGW_LOG(10) << "user is suspended, uid=" << s->user.user_id << dendl; + abort_early(s, -ERR_USER_SUSPENDED); goto done; } ret = handler->read_permissions(); if (ret < 0) { - abort_early(&s, ret); + abort_early(s, ret); goto done; } @@ -121,19 +124,22 @@ int main(int argc, const char **argv) if (op) { ret = op->verify_permission(); if (ret < 0) { - abort_early(&s, ret); + abort_early(s, ret); goto done; } - if (s.expect_cont) - dump_continue(&s); + if (s->expect_cont) + dump_continue(s); op->execute(); } else { - abort_early(&s, -ERR_METHOD_NOT_ALLOWED); + abort_early(s, -ERR_METHOD_NOT_ALLOWED); } done: - rgw_log_op(&s); + rgw_log_op(s); + + handler->put_op(op); + delete s; } return 0; } diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc index 45ad6df6335fa..2936561d46fab 100644 --- a/src/rgw/rgw_op.cc +++ b/src/rgw/rgw_op.cc @@ -1378,13 +1378,13 @@ done: send_response(); } -void RGWHandler::init_state(struct req_state *s, struct fcgx_state *fcgx) +int RGWHandler::init(struct req_state *_s, struct fcgx_state *fcgx) { + s = _s; + if (rgwconf->log_level >= 0) g_conf->rgw_log = rgwconf->log_level; - s->should_log = rgwconf->should_log; - if (g_conf->rgw_log >= 20) { char *p; for (int i=0; (p = fcgx->envp[i]); ++i) { @@ -1392,24 +1392,7 @@ void RGWHandler::init_state(struct req_state *s, struct fcgx_state *fcgx) } } s->fcgx = fcgx; - s->content_started = false; - s->err.clear(); - s->format = 0; - if (s->acl) { - delete s->acl; - s->acl = new RGWAccessControlPolicy; - } - s->canned_acl.clear(); - s->expect_cont = false; - - free(s->os_user); - free(s->os_groups); - s->os_auth_token = NULL; - s->os_user = NULL; - s->os_groups = NULL; - s->time = ceph_clock_now(g_ceph_context); - s->user.clear(); - s->perm_mask = 0; + return 0; } int RGWHandler::do_read_permissions(bool only_bucket) diff --git a/src/rgw/rgw_op.h b/src/rgw/rgw_op.h index 324d90d9f0ce1..af5d23a312d55 100644 --- a/src/rgw/rgw_op.h +++ b/src/rgw/rgw_op.h @@ -554,13 +554,12 @@ protected: public: RGWHandler() {} virtual ~RGWHandler() {} - static void init_state(struct req_state *s, struct fcgx_state *fcgx); - - void set_state(struct req_state *_s) { s = _s; } + virtual int init(struct req_state *_s, struct fcgx_state *fcgx); virtual RGWOp *get_op() = 0; + virtual void put_op(RGWOp *op) = 0; virtual int read_permissions() = 0; - virtual bool authorize(struct req_state *s) = 0; + virtual bool authorize() = 0; }; #endif diff --git a/src/rgw/rgw_os_auth.cc b/src/rgw/rgw_os_auth.cc index ce5e7125979be..2d410e1345dbd 100644 --- a/src/rgw/rgw_os_auth.cc +++ b/src/rgw/rgw_os_auth.cc @@ -170,7 +170,7 @@ done: end_header(s); } -bool RGWHandler_OS_Auth::authorize(struct req_state *s) +bool RGWHandler_OS_Auth::authorize() { return true; } @@ -192,3 +192,7 @@ RGWOp *RGWHandler_OS_Auth::get_op() return op; } +void RGWHandler_OS_Auth::put_op(RGWOp *op) +{ +} + diff --git a/src/rgw/rgw_os_auth.h b/src/rgw/rgw_os_auth.h index 68329b86b975f..f40784715c8c6 100644 --- a/src/rgw/rgw_os_auth.h +++ b/src/rgw/rgw_os_auth.h @@ -21,8 +21,9 @@ public: RGWHandler_OS_Auth() {} ~RGWHandler_OS_Auth() {} RGWOp *get_op(); + void put_op(RGWOp *op); - bool authorize(struct req_state *s); + bool authorize(); int read_permissions() { return 0; } }; diff --git a/src/rgw/rgw_rest.cc b/src/rgw/rgw_rest.cc index e87f7d27bca07..0311c4869f21f 100644 --- a/src/rgw/rgw_rest.cc +++ b/src/rgw/rgw_rest.cc @@ -12,16 +12,6 @@ #include "rgw_formats.h" - -static RGWHandler_REST_S3 rgwhandler_s3; -static RGWHandler_REST_OS rgwhandler_os; -static RGWHandler_OS_Auth rgwhandler_os_auth; - -static RGWFormatter_Plain formatter_plain; -static RGWFormatter_XML formatter_xml; -static RGWFormatter_JSON formatter_json; - - static void dump_status(struct req_state *s, const char *status) { CGI_PRINTF(s,"Status: %s\n", status); @@ -393,7 +383,7 @@ void init_entities_from_header(struct req_state *s) /* this is the default, might change in a few lines */ s->format = RGW_FORMAT_XML; - s->formatter = &formatter_xml; + s->formatter = new RGWFormatter_XML; int pos; if (s->host) { @@ -453,14 +443,14 @@ void init_entities_from_header(struct req_state *s) if (s->prot_flags & RGW_REST_OPENSTACK) { s->format = 0; - s->formatter = &formatter_plain; + s->formatter = new RGWFormatter_Plain; string format_str = s->args.get("format"); if (format_str.compare("xml") == 0) { s->format = RGW_FORMAT_XML; - s->formatter = &formatter_xml; + s->formatter = new RGWFormatter_XML; } else if (format_str.compare("json") == 0) { s->format = RGW_FORMAT_JSON; - s->formatter = &formatter_json; + s->formatter = new RGWFormatter_JSON; } } @@ -674,10 +664,11 @@ static int validate_object_name(const char *object) return 0; } -int RGWHandler_REST::init_rest(struct req_state *s, struct fcgx_state *fcgx) +int RGWHandler_REST::init(struct req_state *s, struct fcgx_state *fcgx) { - int ret = 0; - RGWHandler::init_state(s, fcgx); + int ret = RGWHandler::init(s, fcgx); + if (ret < 0) + return ret; s->path_name = rgw_env.get("SCRIPT_NAME"); s->path_name_url = rgw_env.get("REQUEST_URI"); @@ -744,7 +735,7 @@ int RGWHandler_REST::read_permissions() case OP_PUT: case OP_POST: /* is it a 'create bucket' request? */ - if (is_acl_op(s)) { + if (is_acl_op()) { only_bucket = false; break; } @@ -765,19 +756,19 @@ RGWOp *RGWHandler_REST::get_op() RGWOp *op; switch (s->op) { case OP_GET: - op = get_retrieve_op(s, true); + op = get_retrieve_op(true); break; case OP_PUT: - op = get_create_op(s); + op = get_create_op(); break; case OP_DELETE: - op = get_delete_op(s); + op = get_delete_op(); break; case OP_HEAD: - op = get_retrieve_op(s, false); + op = get_retrieve_op(false); break; case OP_POST: - op = get_post_op(s); + op = get_post_op(); break; default: return NULL; @@ -790,22 +781,39 @@ RGWOp *RGWHandler_REST::get_op() } -RGWHandler *RGWHandler_REST::init_handler(struct req_state *s, struct fcgx_state *fcgx, - int *init_error) +RGWRESTMgr::RGWRESTMgr() { - RGWHandler *handler; + m_os_handler = new RGWHandler_REST_OS; + m_os_auth_handler = new RGWHandler_OS_Auth; + m_s3_handler = new RGWHandler_REST_S3; +} - *init_error = init_rest(s, fcgx); +RGWRESTMgr::~RGWRESTMgr() +{ + delete m_os_handler; + delete m_os_auth_handler; + delete m_s3_handler; +} + +RGWHandler *RGWRESTMgr::get_handler(struct req_state *s, struct fcgx_state *fcgx, + int *init_error) +{ + RGWHandler *handler; if (s->prot_flags & RGW_REST_OPENSTACK) - handler = &rgwhandler_os; + handler = m_os_handler; else if (s->prot_flags & RGW_REST_OPENSTACK_AUTH) - handler = &rgwhandler_os_auth; + handler = m_os_auth_handler; else - handler = &rgwhandler_s3; + handler = m_s3_handler; - handler->set_state(s); + *init_error = handler->init(s, fcgx); return handler; } +void RGWHandler_REST::put_op(RGWOp *op) +{ + delete op; +} + diff --git a/src/rgw/rgw_rest.h b/src/rgw/rgw_rest.h index 4d35d5ede67d6..dd64d3cdb02b3 100644 --- a/src/rgw/rgw_rest.h +++ b/src/rgw/rgw_rest.h @@ -128,25 +128,39 @@ public: class RGWHandler_REST : public RGWHandler { protected: - bool is_acl_op(struct req_state *s) { + bool is_acl_op() { return s->args.exists("acl"); } - virtual RGWOp *get_retrieve_obj_op(struct req_state *s, bool get_data) = 0; - virtual RGWOp *get_retrieve_op(struct req_state *s, bool get_data) = 0; - virtual RGWOp *get_create_op(struct req_state *s) = 0; - virtual RGWOp *get_delete_op(struct req_state *s) = 0; - virtual RGWOp *get_post_op(struct req_state *s) = 0; + virtual RGWOp *get_retrieve_obj_op(bool get_data) = 0; + virtual RGWOp *get_retrieve_op(bool get_data) = 0; + virtual RGWOp *get_create_op() = 0; + virtual RGWOp *get_delete_op() = 0; + virtual RGWOp *get_post_op() = 0; - static int init_rest(struct req_state *s, struct fcgx_state *fcgx); public: int read_permissions(); RGWOp *get_op(); + void put_op(RGWOp *op); - virtual bool authorize(struct req_state *s) = 0; + int init(struct req_state *s, struct fcgx_state *fcgx); + virtual bool authorize() = 0; +}; + +class RGWHandler_REST_OS; +class RGWHandler_OS_Auth; +class RGWHandler_REST_S3; - static RGWHandler *init_handler(struct req_state *s, struct fcgx_state *fcgx, - int *init_error); +class RGWRESTMgr { + RGWHandler_REST_OS *m_os_handler; + RGWHandler_OS_Auth *m_os_auth_handler; + RGWHandler_REST_S3 *m_s3_handler; + +public: + RGWRESTMgr(); + ~RGWRESTMgr(); + RGWHandler *get_handler(struct req_state *s, struct fcgx_state *fcgx, + int *init_error); }; extern void set_req_state_err(struct req_state *s, int err_no); diff --git a/src/rgw/rgw_rest_os.cc b/src/rgw/rgw_rest_os.cc index 2853024be2b84..a394eec803c3f 100644 --- a/src/rgw/rgw_rest_os.cc +++ b/src/rgw/rgw_rest_os.cc @@ -231,64 +231,65 @@ send_data: return 0; } -RGWOp *RGWHandler_REST_OS::get_retrieve_obj_op(struct req_state *s, bool get_data) +RGWOp *RGWHandler_REST_OS::get_retrieve_obj_op(bool get_data) { - if (is_acl_op(s)) { - return &get_acls_op; + if (is_acl_op()) { + return new RGWGetACLs_REST_OS; } if (s->object) { - get_obj_op.set_get_data(get_data); - return &get_obj_op; + RGWGetObj_REST_OS *get_obj_op = new RGWGetObj_REST_OS; + get_obj_op->set_get_data(get_data); + return get_obj_op; } else if (!s->bucket) { return NULL; } if (get_data) - return &list_bucket_op; + return new RGWListBucket_REST_OS; else - return &stat_bucket_op; + return new RGWStatBucket_REST_OS; } -RGWOp *RGWHandler_REST_OS::get_retrieve_op(struct req_state *s, bool get_data) +RGWOp *RGWHandler_REST_OS::get_retrieve_op(bool get_data) { if (s->bucket) { - if (is_acl_op(s)) { - return &get_acls_op; + if (is_acl_op()) { + return new RGWGetACLs_REST_OS; } - return get_retrieve_obj_op(s, get_data); + return get_retrieve_obj_op(get_data); } - return &list_buckets_op; + return new RGWListBuckets_REST_OS; } -RGWOp *RGWHandler_REST_OS::get_create_op(struct req_state *s) +RGWOp *RGWHandler_REST_OS::get_create_op() { - if (is_acl_op(s)) { - return &put_acls_op; + if (is_acl_op()) { + return new RGWPutACLs_REST_OS; } else if (s->object) { if (!s->copy_source) - return &put_obj_op; + return new RGWPutObj_REST_OS; else - return ©_obj_op; + return new RGWCopyObj_REST_OS; } else if (s->bucket) { - return &create_bucket_op; + return new RGWCreateBucket_REST_OS; } return NULL; } -RGWOp *RGWHandler_REST_OS::get_delete_op(struct req_state *s) +RGWOp *RGWHandler_REST_OS::get_delete_op() { if (s->object) - return &delete_obj_op; + return new RGWDeleteObj_REST_OS; else if (s->bucket) - return &delete_bucket_op; + return new RGWDeleteBucket_REST_OS; return NULL; } -bool RGWHandler_REST_OS::authorize(struct req_state *s) +bool RGWHandler_REST_OS::authorize() { return rgw_verify_os_token(s); } diff --git a/src/rgw/rgw_rest_os.h b/src/rgw/rgw_rest_os.h index dad18e83ce4e7..86b24a95b32b8 100644 --- a/src/rgw/rgw_rest_os.h +++ b/src/rgw/rgw_rest_os.h @@ -98,31 +98,19 @@ public: class RGWHandler_REST_OS : public RGWHandler_REST { - RGWGetObj_REST_OS get_obj_op; - RGWListBuckets_REST_OS list_buckets_op; - RGWListBucket_REST_OS list_bucket_op; - RGWStatBucket_REST_OS stat_bucket_op; - RGWCreateBucket_REST_OS create_bucket_op; - RGWDeleteBucket_REST_OS delete_bucket_op; - RGWPutObj_REST_OS put_obj_op; - RGWDeleteObj_REST_OS delete_obj_op; - RGWCopyObj_REST_OS copy_obj_op; - RGWGetACLs_REST_OS get_acls_op; - RGWPutACLs_REST_OS put_acls_op; - protected: - RGWOp *get_retrieve_obj_op(struct req_state *s, bool get_data); - RGWOp *get_retrieve_op(struct req_state *s, bool get_data); - RGWOp *get_create_op(struct req_state *s); - RGWOp *get_delete_op(struct req_state *s); - RGWOp *get_post_op(struct req_state *s) { return NULL; } + RGWOp *get_retrieve_obj_op(bool get_data); + RGWOp *get_retrieve_op(bool get_data); + RGWOp *get_create_op(); + RGWOp *get_delete_op(); + RGWOp *get_post_op() { return NULL; } public: RGWHandler_REST_OS() : RGWHandler_REST() {} virtual ~RGWHandler_REST_OS() {} - bool authorize(struct req_state *s); + bool authorize(); }; #endif diff --git a/src/rgw/rgw_rest_s3.cc b/src/rgw/rgw_rest_s3.cc index 4acdc3f75ca70..0af3edc466046 100644 --- a/src/rgw/rgw_rest_s3.cc +++ b/src/rgw/rgw_rest_s3.cc @@ -401,76 +401,77 @@ void RGWListBucketMultiparts_REST_S3::send_response() s->formatter->flush(s); } -RGWOp *RGWHandler_REST_S3::get_retrieve_obj_op(struct req_state *s, bool get_data) +RGWOp *RGWHandler_REST_S3::get_retrieve_obj_op(bool get_data) { - if (is_acl_op(s)) { - return &get_acls_op; + if (is_acl_op()) { + return new RGWGetACLs_REST_S3; } if (s->object) { - get_obj_op.set_get_data(get_data); - return &get_obj_op; + RGWGetObj_REST_S3 *get_obj_op = new RGWGetObj_REST_S3; + get_obj_op->set_get_data(get_data); + return get_obj_op; } else if (!s->bucket) { return NULL; } if (s->args.exists("uploads")) - return &list_bucket_multiparts; + return new RGWListBucketMultiparts_REST_S3; - return &list_bucket_op; + return new RGWListBucket_REST_S3; } -RGWOp *RGWHandler_REST_S3::get_retrieve_op(struct req_state *s, bool get_data) +RGWOp *RGWHandler_REST_S3::get_retrieve_op(bool get_data) { if (s->bucket) { - if (is_acl_op(s)) { - return &get_acls_op; + if (is_acl_op()) { + return new RGWGetACLs_REST_S3; } else if (s->args.exists("uploadId")) { - return &list_multipart; + return new RGWListMultipart_REST_S3; } - return get_retrieve_obj_op(s, get_data); + return get_retrieve_obj_op(get_data); } - return &list_buckets_op; + return new RGWListBuckets_REST_S3; } -RGWOp *RGWHandler_REST_S3::get_create_op(struct req_state *s) +RGWOp *RGWHandler_REST_S3::get_create_op() { - if (is_acl_op(s)) { - return &put_acls_op; + if (is_acl_op()) { + return new RGWPutACLs_REST_S3; } else if (s->object) { if (!s->copy_source) - return &put_obj_op; + return new RGWPutObj_REST_S3; else - return ©_obj_op; + return new RGWCopyObj_REST_S3; } else if (s->bucket) { - return &create_bucket_op; + return new RGWCreateBucket_REST_S3; } return NULL; } -RGWOp *RGWHandler_REST_S3::get_delete_op(struct req_state *s) +RGWOp *RGWHandler_REST_S3::get_delete_op() { string upload_id = s->args.get("uploadId"); if (s->object) { if (upload_id.empty()) - return &delete_obj_op; + return new RGWDeleteObj_REST_S3; else - return &abort_multipart; + return new RGWAbortMultipart_REST_S3; } else if (s->bucket) - return &delete_bucket_op; + return new RGWDeleteBucket_REST_S3; return NULL; } -RGWOp *RGWHandler_REST_S3::get_post_op(struct req_state *s) +RGWOp *RGWHandler_REST_S3::get_post_op() { if (s->object) { if (s->args.exists("uploadId")) - return &complete_multipart; + return new RGWCompleteMultipart_REST_S3; else - return &init_multipart; + return new RGWInitMultipart_REST_S3; } return NULL; @@ -567,7 +568,7 @@ static void get_auth_header(struct req_state *s, string& dest, bool qsr) * verify that a signed request comes from the keyholder * by checking the signature against our locally-computed version */ -bool RGWHandler_REST_S3::authorize(struct req_state *s) +bool RGWHandler_REST_S3::authorize() { bool qsr = false; string auth_id; diff --git a/src/rgw/rgw_rest_s3.h b/src/rgw/rgw_rest_s3.h index 925afc4ceecd1..fa1a0c99a277d 100644 --- a/src/rgw/rgw_rest_s3.h +++ b/src/rgw/rgw_rest_s3.h @@ -132,29 +132,12 @@ public: }; class RGWHandler_REST_S3 : public RGWHandler_REST { - RGWGetObj_REST_S3 get_obj_op; - RGWListBuckets_REST_S3 list_buckets_op; - RGWListBucket_REST_S3 list_bucket_op; - RGWCreateBucket_REST_S3 create_bucket_op; - RGWDeleteBucket_REST_S3 delete_bucket_op; - RGWPutObj_REST_S3 put_obj_op; - RGWDeleteObj_REST_S3 delete_obj_op; - RGWCopyObj_REST_S3 copy_obj_op; - RGWGetACLs_REST_S3 get_acls_op; - RGWPutACLs_REST_S3 put_acls_op; - RGWInitMultipart_REST_S3 init_multipart; - RGWCompleteMultipart_REST_S3 complete_multipart; - RGWAbortMultipart_REST_S3 abort_multipart; - RGWListMultipart_REST_S3 list_multipart; - RGWListBucketMultiparts_REST_S3 list_bucket_multiparts; - protected: - - RGWOp *get_retrieve_obj_op(struct req_state *s, bool get_data); - RGWOp *get_retrieve_op(struct req_state *s, bool get_data); - RGWOp *get_create_op(struct req_state *s); - RGWOp *get_delete_op(struct req_state *s); - RGWOp *get_post_op(struct req_state *s); + RGWOp *get_retrieve_obj_op(bool get_data); + RGWOp *get_retrieve_op(bool get_data); + RGWOp *get_create_op(); + RGWOp *get_delete_op(); + RGWOp *get_post_op(); bool expect100cont; @@ -162,7 +145,7 @@ public: RGWHandler_REST_S3() : RGWHandler_REST() {} virtual ~RGWHandler_REST_S3() {} - bool authorize(struct req_state *s); + bool authorize(); }; #endif -- 2.39.5