encode(*slo_info, manifest_bl);
emplace_attr(RGW_ATTR_SLO_MANIFEST, std::move(manifest_bl));
- hash.Update((unsigned char *)slo_info->raw_data, slo_info->raw_data_len);
+ hash.Update((unsigned char *)(slo_info->raw_data.c_str()), slo_info->raw_data.length());
complete_etag(hash, &etag);
ldpp_dout(this, 10) << __func__ << ": calculated md5 for user manifest: " << etag << dendl;
}
RGWACLXMLParser_S3 parser(s->cct);
RGWAccessControlPolicy_S3 new_policy(s->cct);
stringstream ss;
- char *new_data = NULL;
rgw_obj obj;
op_ret = 0; /* XXX redundant? */
return;
}
- ldpp_dout(this, 15) << "read len=" << len << " data=" << (data ? data : "") << dendl;
+ char* buf = data.c_str();
+ ldpp_dout(this, 15) << "read len=" << data.length() << " data=" << (buf ? buf : "") << dendl;
- if (!s->canned_acl.empty() && len) {
+ if (!s->canned_acl.empty() && data.length() > 0) {
op_ret = -EINVAL;
return;
}
if (op_ret < 0)
return;
- new_data = strdup(ss.str().c_str());
- free(data);
- data = new_data;
- len = ss.str().size();
+ data.clear();
+ data.append(ss.str());
}
- if (!parser.parse(data, len, 1)) {
+ if (!parser.parse(data.c_str(), data.length(), 1)) {
op_ret = -EINVAL;
return;
}
bufferlist in_data;
// include acl data unless it was generated from a canned_acl
if (s->canned_acl.empty()) {
- in_data.append(data, len);
+ in_data.append(data);
}
op_ret = forward_request_to_master(s, NULL, store, in_data, NULL);
if (op_ret < 0) {
if (op_ret < 0)
return;
- ldpp_dout(this, 15) << "read len=" << len << " data=" << (data ? data : "") << dendl;
+ char* buf = data.c_str();
+ ldpp_dout(this, 15) << "read len=" << data.length() << " data=" << (buf ? buf : "") << dendl;
MD5 data_hash;
unsigned char data_hash_res[CEPH_CRYPTO_MD5_DIGESTSIZE];
- data_hash.Update(reinterpret_cast<const unsigned char*>(data), len);
+ data_hash.Update(reinterpret_cast<const unsigned char*>(buf), data.length());
data_hash.Final(data_hash_res);
if (memcmp(data_hash_res, content_md5_bin.c_str(), CEPH_CRYPTO_MD5_DIGESTSIZE) != 0) {
return;
}
- if (!parser.parse(data, len, 1)) {
+ if (!parser.parse(buf, data.length(), 1)) {
op_ret = -ERR_MALFORMED_XML;
return;
}
return;
}
- if (!data || !len) {
+ if (!data.length()) {
op_ret = -ERR_MALFORMED_XML;
return;
}
return;
}
- if (!parser.parse(data, len, 1)) {
+ if (!parser.parse(data.c_str(), data.length(), 1)) {
op_ret = -ERR_MALFORMED_XML;
return;
}
vector<rgw_obj_key>::iterator iter;
RGWMultiDelXMLParser parser;
RGWObjectCtx *obj_ctx = static_cast<RGWObjectCtx *>(s->obj_ctx);
+ char* buf;
op_ret = get_params();
if (op_ret < 0) {
goto error;
}
- if (!data) {
+ buf = data.c_str();
+ if (!buf) {
op_ret = -EINVAL;
goto error;
}
goto error;
}
- if (!parser.parse(data, len, 1)) {
+ if (!parser.parse(buf, data.length(), 1)) {
op_ret = -EINVAL;
goto error;
}
done:
// will likely segfault if begin_response() has not been called
end_response();
- free(data);
return;
error:
send_status();
- free(data);
return;
}
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
// At some point when I have more time I want to make a version of
// rgw_rest_read_all_input that doesn't use malloc.
- op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, max_size, false);
+
// And throws exceptions.
return op_ret;
}
return;
}
- bufferlist in_data = bufferlist::static_from_mem(data, len);
-
if (!store->is_meta_master()) {
- op_ret = forward_request_to_master(s, NULL, store, in_data, nullptr);
+ op_ret = forward_request_to_master(s, NULL, store, data, nullptr);
if (op_ret < 0) {
ldpp_dout(this, 20) << "forward_request_to_master returned ret=" << op_ret << dendl;
return;
}
try {
- const Policy p(s->cct, s->bucket_tenant, in_data);
+ const Policy p(s->cct, s->bucket_tenant, data);
op_ret = retry_raced_bucket_write(store, s, [&p, this] {
auto attrs = s->bucket_attrs;
attrs[RGW_ATTR_IAM_POLICY].clear();
uint64_t total_size;
/* in memory only */
- char *raw_data;
- int raw_data_len;
+ bufferlist raw_data;
- RGWSLOInfo() : total_size(0), raw_data(NULL), raw_data_len(0) {}
- ~RGWSLOInfo() {
- free(raw_data);
- }
+ RGWSLOInfo() : total_size(0) {}
+ ~RGWSLOInfo() {}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
class RGWPutACLs : public RGWOp {
protected:
- int len;
- char *data;
+ bufferlist data;
ACLOwner owner;
public:
- RGWPutACLs() {
- len = 0;
- data = NULL;
- }
- ~RGWPutACLs() override {
- free(data);
- }
+ RGWPutACLs() {}
+ ~RGWPutACLs() override {}
int verify_permission() override;
void pre_exec() override;
class RGWPutLC : public RGWOp {
protected:
- int len;
- char *data;
+ bufferlist data;
const char *content_md5;
string cookie;
public:
RGWPutLC() {
- len = 0;
- data = nullptr;
content_md5 = nullptr;
}
- ~RGWPutLC() override {
- free(data);
- }
+ ~RGWPutLC() override {}
void init(RGWRados *store, struct req_state *s, RGWHandler *dialect_handler) override {
#define COOKIE_LEN 16
string upload_id;
string etag;
string version_id;
- char *data;
- int len;
+ bufferlist data;
struct MPSerializer {
librados::IoCtx ioctx;
} serializer;
public:
- RGWCompleteMultipart() {
- data = NULL;
- len = 0;
- }
- ~RGWCompleteMultipart() override {
- free(data);
- }
+ RGWCompleteMultipart() {}
+ ~RGWCompleteMultipart() override {}
int verify_permission() override;
void pre_exec() override;
class RGWDeleteMultiObj : public RGWOp {
protected:
- int len;
- char *data;
+ bufferlist data;
rgw_bucket bucket;
bool quiet;
bool status_dumped;
public:
RGWDeleteMultiObj() {
- len = 0;
- data = NULL;
quiet = false;
status_dumped = false;
}
};
class RGWPutBucketPolicy : public RGWOp {
- int len = 0;
- char *data = nullptr;
+ bufferlist data;
public:
RGWPutBucketPolicy() = default;
~RGWPutBucketPolicy() {
- if (data) {
- free(static_cast<void*>(data));
- }
}
void send_response() override;
int verify_permission() override;
int RGWPutACLs_ObjStore::get_params()
{
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, max_size, false);
+ ldout(s->cct, 0) << "RGWPutACLs_ObjStore::get_params read data is: " << data.c_str() << dendl;
return op_ret;
}
int RGWPutLC_ObjStore::get_params()
{
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, max_size, false);
return op_ret;
}
-static int read_all_chunked_input(req_state *s, char **pdata, int *plen, const uint64_t max_read)
+static std::tuple<int, bufferlist> read_all_chunked_input(req_state *s, const uint64_t max_read)
{
#define READ_CHUNK 4096
#define MAX_READ_CHUNK (128 * 1024)
int need_to_read = READ_CHUNK;
int total = need_to_read;
- char *data = (char *)malloc(total + 1);
- if (!data)
- return -ENOMEM;
+ bufferlist bl;
int read_len = 0, len = 0;
do {
- read_len = recv_body(s, data + len, need_to_read);
+ bufferptr bp(need_to_read + 1);
+ read_len = recv_body(s, bp.c_str(), need_to_read);
if (read_len < 0) {
- free(data);
- return read_len;
+ return std::make_tuple(read_len, std::move(bl));
}
+ bp.c_str()[read_len] = '\0';
+ bp.set_length(read_len);
+ bl.append(bp);
len += read_len;
if (read_len == need_to_read) {
need_to_read *= 2;
if ((unsigned)total > max_read) {
- free(data);
- return -ERANGE;
+ return std::make_tuple(-ERANGE, std::move(bl));
}
total += need_to_read;
-
- void *p = realloc(data, total + 1);
- if (!p) {
- free(data);
- return -ENOMEM;
- }
- data = (char *)p;
} else {
break;
}
-
} while (true);
- data[len] = '\0';
- *pdata = data;
- *plen = len;
-
- return 0;
+ return std::make_tuple(0, std::move(bl));
}
-int rgw_rest_read_all_input(struct req_state *s, char **pdata, int *plen,
- const uint64_t max_len, const bool allow_chunked)
+std::tuple<int, bufferlist > rgw_rest_read_all_input(struct req_state *s,
+ const uint64_t max_len,
+ const bool allow_chunked)
{
size_t cl = 0;
int len = 0;
- char *data = NULL;
+ bufferlist bl;
if (s->length)
cl = atoll(s->length);
else if (!allow_chunked)
- return -ERR_LENGTH_REQUIRED;
+ return std::make_tuple(-ERR_LENGTH_REQUIRED, std::move(bl));
if (cl) {
if (cl > (size_t)max_len) {
- return -ERANGE;
+ return std::make_tuple(-ERANGE, std::move(bl));
}
- data = (char *)malloc(cl + 1);
- if (!data) {
- return -ENOMEM;
- }
- len = recv_body(s, data, cl);
+
+ bufferptr bp(cl + 1);
+
+ len = recv_body(s, bp.c_str(), cl);
if (len < 0) {
- free(data);
- return len;
+ return std::make_tuple(len, std::move(bl));
}
- data[len] = '\0';
+
+ bp.c_str()[len] = '\0';
+ bp.set_length(len);
+ bl.append(bp);
+
} else if (allow_chunked && !s->length) {
const char *encoding = s->info.env->get("HTTP_TRANSFER_ENCODING");
if (!encoding || strcmp(encoding, "chunked") != 0)
- return -ERR_LENGTH_REQUIRED;
+ return std::make_tuple(-ERR_LENGTH_REQUIRED, std::move(bl));
- int ret = read_all_chunked_input(s, &data, &len, max_len);
+ int ret = 0;
+ std::tie(ret, bl) = read_all_chunked_input(s, max_len);
if (ret < 0)
- return ret;
+ return std::make_tuple(ret, std::move(bl));
}
- *plen = len;
- *pdata = data;
-
- return 0;
+ return std::make_tuple(0, std::move(bl));
}
int RGWCompleteMultipart_ObjStore::get_params()
}
#define COMPLETE_MULTIPART_MAX_LEN (1024 * 1024) /* api defines max 10,000 parts, this should be enough */
- op_ret = rgw_rest_read_all_input(s, &data, &len, COMPLETE_MULTIPART_MAX_LEN);
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, COMPLETE_MULTIPART_MAX_LEN);
if (op_ret < 0)
return op_ret;
bucket = s->bucket;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, max_size, false);
return op_ret;
}
extern void rgw_flush_formatter(struct req_state *s,
ceph::Formatter *formatter);
-extern int rgw_rest_read_all_input(struct req_state *s, char **data, int *plen,
- uint64_t max_len, bool allow_chunked=true);
+std::tuple<int, bufferlist > rgw_rest_read_all_input(struct req_state *s,
+ const uint64_t max_len,
+ const bool allow_chunked=true);
template <class T>
int rgw_rest_get_json_input(CephContext *cct, req_state *s, T& out,
uint64_t max_len, bool *empty)
{
- int rv, data_len;
- char *data;
-
if (empty)
*empty = false;
- if ((rv = rgw_rest_read_all_input(s, &data, &data_len, max_len)) < 0) {
+ int rv = 0;
+ bufferlist data;
+ std::tie(rv, data) = rgw_rest_read_all_input(s, max_len);
+ if (rv < 0) {
return rv;
}
- if (!data_len) {
+ if (!data.length()) {
if (empty) {
*empty = true;
}
JSONParser parser;
- if (!parser.parse(data, data_len)) {
- free(data);
+ if (!parser.parse(data.c_str(), data.length())) {
return -EINVAL;
}
- free(data);
-
try {
decode_json_obj(out, &parser);
} catch (JSONDecoder::err& e) {
}
template <class T>
-int rgw_rest_get_json_input_keep_data(CephContext *cct, req_state *s, T& out, uint64_t max_len, char **pdata, int *len)
+std::tuple<int, bufferlist > rgw_rest_get_json_input_keep_data(CephContext *cct, req_state *s, T& out, uint64_t max_len)
{
- int rv, data_len;
- char *data;
-
- if ((rv = rgw_rest_read_all_input(s, &data, &data_len, max_len)) < 0) {
- return rv;
+ int rv = 0;
+ bufferlist data;
+ std::tie(rv, data) = rgw_rest_read_all_input(s, max_len);
+ if (rv < 0) {
+ return std::make_tuple(rv, std::move(data));
}
- if (!data_len) {
- return -EINVAL;
+ if (!data.length()) {
+ return std::make_tuple(-EINVAL, std::move(data));
}
- *len = data_len;
-
JSONParser parser;
- if (!parser.parse(data, data_len)) {
- free(data);
- return -EINVAL;
+ if (!parser.parse(data.c_str(), data.length())) {
+ return std::make_tuple(-EINVAL, std::move(data));
}
try {
decode_json_obj(out, &parser);
} catch (JSONDecoder::err& e) {
- free(data);
- return -EINVAL;
+ return std::make_tuple(-EINVAL, std::move(data));
}
- *pdata = data;
- return 0;
+ return std::make_tuple(0, std::move(data));
}
class RESTArgs {
}
void RGWOp_MDLog_Notify::execute() {
- char *data;
- int len = 0;
#define LARGE_ENOUGH_BUF (128 * 1024)
- int r = rgw_rest_read_all_input(s, &data, &len, LARGE_ENOUGH_BUF);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, LARGE_ENOUGH_BUF);
if (r < 0) {
http_ret = r;
return;
}
- ldout(s->cct, 20) << __func__ << "(): read data: " << string(data, len) << dendl;
+ char* buf = data.c_str();
+ ldout(s->cct, 20) << __func__ << "(): read data: " << buf << dendl;
JSONParser p;
- r = p.parse(data, len);
- free(data);
+ r = p.parse(buf, data.length());
if (r < 0) {
ldout(s->cct, 0) << "ERROR: failed to parse JSON" << dendl;
http_ret = r;
void RGWOp_DATALog_Notify::execute() {
string source_zone = s->info.args.get("source-zone");
- char *data;
- int len = 0;
#define LARGE_ENOUGH_BUF (128 * 1024)
- int r = rgw_rest_read_all_input(s, &data, &len, LARGE_ENOUGH_BUF);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, LARGE_ENOUGH_BUF);
if (r < 0) {
http_ret = r;
return;
}
- ldout(s->cct, 20) << __func__ << "(): read data: " << string(data, len) << dendl;
+ char* buf = data.c_str();
+ ldout(s->cct, 20) << __func__ << "(): read data: " << buf << dendl;
JSONParser p;
- r = p.parse(data, len);
- free(data);
+ r = p.parse(buf, data.length());
if (r < 0) {
ldout(s->cct, 0) << "ERROR: failed to parse JSON" << dendl;
http_ret = r;
return -EINVAL;
}
- char *data=nullptr;
- int len=0;
-
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- int r = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, max_size, false);
if (r < 0)
return r;
- auto data_deleter = std::unique_ptr<char, decltype(free)*>{data, free};
-
- if (!parser.parse(data, len, 1)) {
+ if (!parser.parse(data.c_str(), data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
int RGWSetBucketVersioning_ObjStore_S3::get_params()
{
- char *data = nullptr;
- int len = 0;
- int r =
- rgw_rest_read_all_input(s, &data, &len, s->cct->_conf->rgw_max_put_param_size, false);
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) =
+ rgw_rest_read_all_input(s, s->cct->_conf->rgw_max_put_param_size, false);
if (r < 0) {
return r;
}
-
- auto data_deleter = std::unique_ptr<char, decltype(free)*>{data, free};
r = do_aws4_auth_completion();
if (r < 0) {
return -EIO;
}
- if (!parser.parse(data, len, 1)) {
- ldout(s->cct, 10) << "NOTICE: failed to parse data: " << data << dendl;
+ char* buf = data.c_str();
+ if (!parser.parse(buf, data.length(), 1)) {
+ ldout(s->cct, 10) << "NOTICE: failed to parse data: " << buf << dendl;
r = -EINVAL;
return r;
}
if (!store->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
- in_data.append(data, len);
+ in_data.append(data);
}
versioning_status = status_conf.status;
int RGWSetBucketWebsite_ObjStore_S3::get_params()
{
- char *data = nullptr;
- int len = 0;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- int r = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, max_size, false);
if (r < 0) {
return r;
}
- auto data_deleter = std::unique_ptr<char, decltype(free)*>{data, free};
-
r = do_aws4_auth_completion();
if (r < 0) {
return r;
}
- bufferptr in_ptr(data, len);
- in_data.append(in_ptr);
+ in_data.append(data);
RGWXMLDecoder::XMLParser parser;
if (!parser.init()) {
return -EIO;
}
- if (!parser.parse(data, len, 1)) {
- string str(data, len);
- ldout(s->cct, 5) << "failed to parse xml: " << str << dendl;
+ char* buf = data.c_str();
+ if (!parser.parse(buf, data.length(), 1)) {
+ ldout(s->cct, 5) << "failed to parse xml: " << buf << dendl;
return -EINVAL;
}
try {
RGWXMLDecoder::decode_xml("WebsiteConfiguration", website_conf, &parser, true);
} catch (RGWXMLDecoder::err& err) {
- string str(data, len);
- ldout(s->cct, 5) << "unexpected xml: " << str << dendl;
+ ldout(s->cct, 5) << "unexpected xml: " << buf << dendl;
return -EINVAL;
}
policy = s3policy;
- int len = 0;
- char *data = nullptr;
-
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+
+ int op_ret = 0;
+ bufferlist data;
+ std::tie(op_ret, data) = rgw_rest_read_all_input(s, max_size, false);
if ((op_ret < 0) && (op_ret != -ERR_LENGTH_REQUIRED))
return op_ret;
- auto data_deleter = std::unique_ptr<char, decltype(free)*>{data, free};
-
const int auth_ret = do_aws4_auth_completion();
if (auth_ret < 0) {
return auth_ret;
}
- bufferptr in_ptr(data, len);
- in_data.append(in_ptr);
+ in_data.append(data);
- if (len) {
+ if (data.length()) {
RGWCreateBucketParser parser;
if (!parser.init()) {
return -EIO;
}
- bool success = parser.parse(data, len, 1);
- ldout(s->cct, 20) << "create bucket input data=" << data << dendl;
+ char* buf = data.c_str();
+ bool success = parser.parse(buf, data.length(), 1);
+ ldout(s->cct, 20) << "create bucket input data=" << buf << dendl;
if (!success) {
- ldout(s->cct, 0) << "failed to parse input: " << data << dendl;
+ ldout(s->cct, 0) << "failed to parse input: " << buf << dendl;
return -EINVAL;
}
int RGWPutCORS_ObjStore_S3::get_params()
{
- int r;
- char *data = nullptr;
- int len = 0;
RGWCORSXMLParser_S3 parser(s->cct);
RGWCORSConfiguration_S3 *cors_config;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- r = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, max_size, false);
if (r < 0) {
return r;
}
- auto data_deleter = std::unique_ptr<char, decltype(free)*>{data, free};
-
r = do_aws4_auth_completion();
if (r < 0) {
return r;
return -EINVAL;
}
- if (!data || !parser.parse(data, len, 1)) {
+ char* buf = data.c_str();
+ if (!buf || !parser.parse(buf, data.length(), 1)) {
return -ERR_MALFORMED_XML;
}
cors_config =
// forward bucket cors requests to meta master zone
if (!store->is_meta_master()) {
/* only need to keep this data around if we're not meta master */
- in_data.append(data, len);
+ in_data.append(data);
}
if (s->cct->_conf->subsys.should_gather<ceph_subsys_rgw, 15>()) {
int RGWSetRequestPayment_ObjStore_S3::get_params()
{
- char *data;
- int len = 0;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- int r = rgw_rest_read_all_input(s, &data, &len, max_size, false);
+
+ int r = 0;
+ bufferlist data;
+ std::tie(r, data) = rgw_rest_read_all_input(s, max_size, false);
if (r < 0) {
return r;
if (!parser.init()) {
ldout(s->cct, 0) << "ERROR: failed to initialize parser" << dendl;
- r = -EIO;
- goto done;
+ return -EIO;
}
- if (!parser.parse(data, len, 1)) {
- ldout(s->cct, 10) << "failed to parse data: " << data << dendl;
- r = -EINVAL;
- goto done;
+ char* buf = data.c_str();
+ if (!parser.parse(buf, data.length(), 1)) {
+ ldout(s->cct, 10) << "failed to parse data: " << buf << dendl;
+ return -EINVAL;
}
- r = parser.get_request_payment_payer(&requester_pays);
-
-done:
- free(data);
-
- return r;
+ return parser.get_request_payment_payer(&requester_pays);
}
void RGWSetRequestPayment_ObjStore_S3::send_response()
RGWOp *RGWHandler_REST_STS::op_post()
{
- int len = 0;
- char *data = nullptr;
const auto max_size = s->cct->_conf->rgw_max_put_param_size;
- auto ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
- if (ret < 0) {
- return nullptr;
- }
- ldout(s->cct, 0) << "Content of POST: " << data << dendl;
- string post_body = data;
-
- if (post_body.find("Action") != string::npos) {
- boost::char_separator<char> sep("&");
- boost::tokenizer<boost::char_separator<char>> tokens(post_body, sep);
- for (const auto& t : tokens) {
- auto pos = t.find("=");
- if (pos != string::npos) {
- std::string key = t.substr(0, pos);
- std::string value = t.substr(pos + 1, t.size() - 1);
- ldout(s->cct, 0) << "Key: " << key << "Value: " << value << dendl;
- s->info.args.append(key, value);
+
+ int ret = 0;
+ bufferlist data;
+ std::tie(ret, data) = rgw_rest_read_all_input(s, max_size, false);
+ if (data.length() > 0) {
+ string post_body = data.to_str();
+ ldout(s->cct, 10) << "Content of POST: " << post_body << dendl;
+
+ if (post_body.find("Action") != string::npos) {
+ boost::char_separator<char> sep("&");
+ boost::tokenizer<boost::char_separator<char>> tokens(post_body, sep);
+ for (const auto& t : tokens) {
+ auto pos = t.find("=");
+ if (pos != string::npos) {
+ std::string key = t.substr(0, pos);
+ std::string value = t.substr(pos + 1, t.size() - 1);
+ ldout(s->cct, 10) << "Key: " << key << "Value: " << value << dendl;
+ s->info.args.append(key, value);
+ }
}
- }
+ }
}
- free(data);
-
if (s->info.args.exists("Action")) {
string action = s->info.args.get("Action");
if (action == "AssumeRole") {
slo_info = new RGWSLOInfo;
- int r = rgw_rest_get_json_input_keep_data(s->cct, s, slo_info->entries, max_len, &slo_info->raw_data, &slo_info->raw_data_len);
+ int r = 0;
+ std::tie(r, slo_info->raw_data) = rgw_rest_get_json_input_keep_data(s->cct, s, slo_info->entries, max_len);
if (r < 0) {
ldout(s->cct, 5) << "failed to read input for slo r=" << r << dendl;
return r;
complete_etag(etag_sum, &lo_etag);
slo_info->total_size = total_size;
- ofs = slo_info->raw_data_len;
+ ofs = slo_info->raw_data.length();
}
return RGWPutObj_ObjStore::get_params();
projects / ceph.git / commitdiff