void init_meta_info(bool *found_nad_meta);
};
+struct rgw_obj_key {
+ string name;
+ string instance;
+
+ rgw_obj_key() {}
+ rgw_obj_key(const string& n) {
+ set(n);
+ }
+ rgw_obj_key(const string& n, const string& i) {
+ set(n, i);
+ }
+
+ void set(const cls_rgw_obj_key& k) {
+ name = k.name;
+ instance = k.instance;
+ }
+
+ void transform(cls_rgw_obj_key *k) {
+ k->name = name;
+ k->instance = instance;
+ }
+
+ void set(const string& n) {
+ name = n;
+ instance.clear();
+ }
+
+ void set(const string& n, const string& i) {
+ name = n;
+ instance = i;
+ }
+
+ bool empty() {
+ return name.empty();
+ }
+ bool operator==(const rgw_obj_key& k) const {
+ return (name.compare(k.name) == 0) &&
+ (instance.compare(k.instance) == 0);
+ }
+ bool operator<(const rgw_obj_key& k) const {
+ int r = name.compare(k.name);
+ if (r == 0) {
+ r = instance.compare(k.instance);
+ }
+ return (r < 0);
+ }
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ ::encode(name, bl);
+ ::encode(instance, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::iterator& bl) {
+ DECODE_START(1, bl);
+ ::decode(name, bl);
+ ::decode(instance, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+};
+WRITE_CLASS_ENCODER(rgw_obj_key)
+
+inline ostream& operator<<(ostream& out, const rgw_obj_key &o) {
+ if (o.instance.empty()) {
+ return out << o.name;
+ } else {
+ return out << o.name << "[" << o.instance << "]";
+ }
+}
+
/** Store all the state necessary to complete and respond to an HTTP request*/
struct req_state {
CephContext *cct;
rgw_bucket bucket;
string bucket_name_str;
- string object_str;
+ rgw_obj_key object;
string src_bucket_name;
- string src_object;
+ rgw_obj_key src_object;
ACLOwner bucket_owner;
ACLOwner owner;
~req_state();
};
-struct rgw_obj_key {
- string name;
- string instance;
-
- rgw_obj_key() {}
- rgw_obj_key(const string& n) {
- set(n);
- }
- rgw_obj_key(const string& n, const string& i) {
- set(n, i);
- }
-
- void set(const cls_rgw_obj_key& k) {
- name = k.name;
- instance = k.instance;
- }
-
- void transform(cls_rgw_obj_key *k) {
- k->name = name;
- k->instance = instance;
- }
-
- void set(const string& n) {
- name = n;
- instance.clear();
- }
-
- void set(const string& n, const string& i) {
- name = n;
- instance = i;
- }
-
- bool empty() {
- return name.empty();
- }
- bool operator==(const rgw_obj_key& k) const {
- return (name.compare(k.name) == 0) &&
- (instance.compare(k.instance) == 0);
- }
- bool operator<(const rgw_obj_key& k) const {
- int r = name.compare(k.name);
- if (r == 0) {
- r = instance.compare(k.instance);
- }
- return (r < 0);
- }
-};
-
/** Store basic data on an object */
struct RGWObjEnt {
rgw_obj_key key;
e->bucket = "bucket";
e->remote_addr = "1.2.3.4";
e->user = "user";
- e->obj = "obj";
+ e->obj = rgw_obj_key("obj");
e->uri = "http://uri/bucket/obj";
e->http_status = "200";
e->error_code = "error_code";
f->dump_stream("time") << time;
f->dump_string("remote_addr", remote_addr);
f->dump_string("user", user);
- f->dump_string("obj", obj);
+ stringstream s;
+ s << obj;
+ f->dump_string("obj", s.str());
f->dump_string("op", op);
f->dump_string("uri", uri);
f->dump_string("http_status", http_status);
return 0;
}
- if (!s->object_str.empty())
- entry.obj = s->object_str.c_str();
- else
- entry.obj = "-";
+ if (!s->object.empty()) {
+ entry.obj = s->object;
+ } else {
+ entry.obj = rgw_obj_key("-");
+ }
entry.obj_size = s->obj_size;
utime_t time;
string remote_addr;
string user;
- string obj;
+ rgw_obj_key obj;
string op;
string uri;
string http_status;
string bucket_id;
void encode(bufferlist &bl) const {
- ENCODE_START(6, 5, bl);
+ ENCODE_START(7, 5, bl);
::encode(object_owner, bl);
::encode(bucket_owner, bl);
::encode(bucket, bl);
::encode(time, bl);
::encode(remote_addr, bl);
::encode(user, bl);
- ::encode(obj, bl);
+ ::encode(obj.name, bl);
::encode(op, bl);
::encode(uri, bl);
::encode(http_status, bl);
::encode(referrer, bl);
::encode(bytes_received, bl);
::encode(bucket_id, bl);
+ ::encode(obj, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &p) {
- DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, p);
+ DECODE_START_LEGACY_COMPAT_LEN(7, 5, 5, p);
::decode(object_owner, p);
if (struct_v > 3)
::decode(bucket_owner, p);
::decode(time, p);
::decode(remote_addr, p);
::decode(user, p);
- ::decode(obj, p);
+ ::decode(obj.name, p);
::decode(op, p);
::decode(uri, p);
::decode(http_status, p);
} else {
::decode(bucket_id, p);
}
- } else
+ } else {
bucket_id = "";
+ }
+ if (struct_v >= 7) {
+ ::decode(obj, p);
+ }
DECODE_FINISH(p);
}
void dump(Formatter *f) const;
static int read_policy(RGWRados *store, struct req_state *s,
RGWBucketInfo& bucket_info, map<string, bufferlist>& bucket_attrs,
- RGWAccessControlPolicy *policy, rgw_bucket& bucket, string& object)
+ RGWAccessControlPolicy *policy, rgw_bucket& bucket, rgw_obj_key& object)
{
string upload_id;
upload_id = s->info.args.get("uploadId");
- string oid = object;
rgw_obj obj;
if (!s->system_request && bucket_info.flags & BUCKET_SUSPENDED) {
return -ERR_USER_SUSPENDED;
}
- if (!oid.empty() && !upload_id.empty()) {
- RGWMPObj mp(oid, upload_id);
- oid = mp.get_meta();
+ if (!object.empty() && !upload_id.empty()) {
+ /* multipart upload */
+ RGWMPObj mp(object.name, upload_id);
+ string oid = mp.get_meta();
obj.init_ns(bucket, oid, mp_ns);
obj.set_in_extra_data(true);
} else {
- obj.init(bucket, oid);
+ obj = rgw_obj(bucket, object);
}
int ret = get_policy_from_attr(s->cct, store, s->obj_ctx, bucket_info, bucket_attrs, policy, obj);
- if (ret == -ENOENT && object.size()) {
+ if (ret == -ENOENT && !object.empty()) {
/* object does not exist checking the bucket's ACL to make sure
that we send a proper error code */
RGWAccessControlPolicy bucket_policy(s->cct);
static int rgw_build_policies(RGWRados *store, struct req_state *s, bool only_bucket, bool prefetch_data)
{
int ret = 0;
- string obj_str;
+ rgw_obj_key obj;
RGWUserInfo bucket_owner_info;
s->bucket_instance_id = s->info.args.get(RGW_SYS_PARAM_PREFIX "bucket-instance");
s->bucket = s->bucket_info.bucket;
if (s->bucket_exists) {
- string no_obj;
+ rgw_obj_key no_obj;
ret = read_policy(store, s, s->bucket_info, s->bucket_attrs, s->bucket_acl, s->bucket, no_obj);
} else {
s->bucket_acl->create_default(s->user.user_id, s->user.display_name);
/*If the operation is delete and if this is the master, don't redirect*/
} else if (!s->local_source ||
(s->op != OP_PUT && s->op != OP_COPY) ||
- s->object_str.empty()) {
+ s->object.empty()) {
return -ERR_PERMANENT_REDIRECT;
}
}
/* we're passed only_bucket = true when we specifically need the bucket's
acls, that happens on write operations */
- if (!only_bucket && !s->object_str.empty()) {
+ if (!only_bucket && !s->object.empty()) {
if (!s->bucket_exists) {
return -ERR_NO_SUCH_BUCKET;
}
s->object_acl = new RGWAccessControlPolicy(s->cct);
- obj_str = s->object_str;
- rgw_obj obj(s->bucket, obj_str);
+ rgw_obj obj(s->bucket, s->object);
store->set_atomic(s->obj_ctx, obj);
if (prefetch_data) {
store->set_prefetch_data(s->obj_ctx, obj);
}
- ret = read_policy(store, s, s->bucket_info, s->bucket_attrs, s->object_acl, s->bucket, obj_str);
+ ret = read_policy(store, s, s->bucket_info, s->bucket_attrs, s->object_acl, s->bucket, s->object);
}
return ret;
int RGWGetObj::verify_permission()
{
- obj.init(s->bucket, s->object_str);
+ obj = rgw_obj(s->bucket, s->object);
store->set_atomic(s->obj_ctx, obj);
store->set_prefetch_data(s->obj_ctx, obj);
}
/* only interested in object related ops */
- if (s->object_str.empty()) {
+ if (s->object.empty()) {
return 0;
}
return r;
}
bucket = bucket_info.bucket;
- string no_obj;
+ rgw_obj_key no_obj;
bucket_policy = &_bucket_policy;
r = read_policy(store, s, bucket_info, bucket_attrs, bucket_policy, bucket, no_obj);
if (r < 0) {
public:
bool immutable_head() { return true; }
RGWPutObjProcessor_Multipart(const string& bucket_owner, uint64_t _p, req_state *_s) :
- RGWPutObjProcessor_Atomic(bucket_owner, _s->bucket, _s->object_str, _p, _s->req_id, false), s(_s) {}
+ RGWPutObjProcessor_Atomic(bucket_owner, _s->bucket, _s->object.name, _p, _s->req_id, false), s(_s) {}
};
int RGWPutObjProcessor_Multipart::prepare(RGWRados *store, void *obj_ctx, string *oid_rand)
const string& bucket_owner = s->bucket_owner.get_id();
if (!multipart) {
- processor = new RGWPutObjProcessor_Atomic(bucket_owner, s->bucket, s->object_str, part_size, s->req_id, s->bucket_info.versioning_enabled);
+ processor = new RGWPutObjProcessor_Atomic(bucket_owner, s->bucket, s->object.name, part_size, s->req_id, s->bucket_info.versioning_enabled);
} else {
processor = new RGWPutObjProcessor_Multipart(bucket_owner, part_size, s);
}
perfcounter->inc(l_rgw_put);
ret = -EINVAL;
- if (s->object_str.empty()) {
+ if (s->object.empty()) {
goto done;
}
uint64_t part_size = s->cct->_conf->rgw_obj_stripe_size;
- processor = new RGWPutObjProcessor_Atomic(s->bucket_owner.get_id(), s->bucket, s->object_str, part_size, s->req_id, s->bucket_info.versioning_enabled);
+ processor = new RGWPutObjProcessor_Atomic(s->bucket_owner.get_id(), s->bucket, s->object.name, part_size, s->req_id, s->bucket_info.versioning_enabled);
return processor;
}
int RGWPutMetadata::verify_permission()
{
- if (!s->object_str.empty()) {
+ if (!s->object.empty()) {
if (!verify_object_permission(s, RGW_PERM_WRITE))
return -EACCES;
} else {
map<string, bufferlist>::iterator iter;
bufferlist bl, cors_bl;
- rgw_obj obj(s->bucket, s->object_str);
+ rgw_obj obj(s->bucket, s->object);
store->set_atomic(s->obj_ctx, obj);
rgw_get_request_metadata(s->cct, s->info, attrs);
/* no need to track object versioning, need it for bucket's data only */
- RGWObjVersionTracker *ptracker = (!s->object_str.empty() ? NULL : &s->bucket_info.objv_tracker);
+ RGWObjVersionTracker *ptracker = (!s->object.empty() ? NULL : &s->bucket_info.objv_tracker);
if (s->object) {
/* check if obj exists, read orig attrs */
cors_config.encode(cors_bl);
attrs[RGW_ATTR_CORS] = cors_bl;
}
- if (!s->object_str.empty()) {
+ if (!s->object.empty()) {
ret = store->set_attrs(s->obj_ctx, obj, attrs, &rmattrs, ptracker);
} else {
ret = rgw_bucket_set_attrs(store, s->bucket_info, attrs, &rmattrs, ptracker);
void RGWDeleteObj::execute()
{
ret = -EINVAL;
- rgw_obj obj(s->bucket, s->object_str);
- if (!s->object_str.empty()) {
+ rgw_obj obj(s->bucket, s->object);
+ if (!s->object.empty()) {
store->set_atomic(s->obj_ctx, obj);
ret = store->delete_obj(s->obj_ctx, s->bucket_owner.get_id(), obj);
}
}
-bool RGWCopyObj::parse_copy_location(const char *src, string& bucket_name, string& object)
+bool RGWCopyObj::parse_copy_location(const char *src, string& bucket_name, rgw_obj_key& object)
{
string url_src(src);
string dec_src;
return false;
bucket_name = str.substr(0, pos);
- object = str.substr(pos + 1);
+ string key = str.substr(pos + 1);
- if (object.size() == 0)
+ if (key.empty())
return false;
+ object = rgw_obj_key(key);
+
return true;
}
int RGWCopyObj::verify_permission()
{
- string empty_str;
RGWAccessControlPolicy src_policy(s->cct);
ret = get_params();
if (ret < 0)
rgw_obj dest_obj(dest_bucket, dest_object);
store->set_atomic(s->obj_ctx, dest_obj);
+ rgw_obj_key no_obj;
+
/* check dest bucket permissions */
- ret = read_policy(store, s, dest_bucket_info, dest_attrs, &dest_bucket_policy, dest_bucket, empty_str);
+ ret = read_policy(store, s, dest_bucket_info, dest_attrs, &dest_bucket_policy, dest_bucket, no_obj);
if (ret < 0)
return ret;
void RGWCopyObj::execute()
{
- rgw_obj src_obj, dst_obj;
-
if (init_common() < 0)
return;
- src_obj.init(src_bucket, src_object);
- dst_obj.init(dest_bucket, dest_object);
+ rgw_obj src_obj(src_bucket, src_object);
+ rgw_obj dst_obj(dest_bucket, dest_object);
store->set_atomic(s->obj_ctx, src_obj);
store->set_atomic(s->obj_ctx, dst_obj);
int RGWGetACLs::verify_permission()
{
bool perm;
- if (!s->object_str.empty()) {
+ if (!s->object.empty()) {
perm = verify_object_permission(s, RGW_PERM_READ_ACP);
} else {
perm = verify_bucket_permission(s, RGW_PERM_READ_ACP);
void RGWGetACLs::execute()
{
stringstream ss;
- RGWAccessControlPolicy *acl = (!s->object_str.empty() ? s->object_acl : s->bucket_acl);
+ RGWAccessControlPolicy *acl = (!s->object.empty() ? s->object_acl : s->bucket_acl);
RGWAccessControlPolicy_S3 *s3policy = static_cast<RGWAccessControlPolicy_S3 *>(acl);
s3policy->to_xml(ss);
acls = ss.str();
int RGWPutACLs::verify_permission()
{
bool perm;
- if (!s->object_str.empty()) {
+ if (!s->object.empty()) {
perm = verify_object_permission(s, RGW_PERM_WRITE_ACP);
} else {
perm = verify_bucket_permission(s, RGW_PERM_WRITE_ACP);
*_dout << dendl;
}
- RGWObjVersionTracker *ptracker = (!s->object_str.empty() ? NULL : &s->bucket_info.objv_tracker);
+ RGWObjVersionTracker *ptracker = (!s->object.empty() ? NULL : &s->bucket_info.objv_tracker);
new_policy.encode(bl);
- obj.init(s->bucket, s->object_str);
+ obj = rgw_obj(s->bucket, s->object);
map<string, bufferlist> attrs;
attrs[RGW_ATTR_ACL] = bl;
store->set_atomic(s->obj_ctx, obj);
- if (!s->object_str.empty()) {
+ if (!s->object.empty()) {
ret = store->set_attrs(s->obj_ctx, obj, attrs, NULL, ptracker);
} else {
ret = rgw_bucket_set_attrs(store, s->bucket_info, attrs, NULL, ptracker);
if (ret < 0)
return;
- RGWObjVersionTracker *ptracker = (!s->object_str.empty() ? NULL : &s->bucket_info.objv_tracker);
+ RGWObjVersionTracker *ptracker = (!s->object.empty() ? NULL : &s->bucket_info.objv_tracker);
store->get_bucket_instance_obj(s->bucket, obj);
store->set_atomic(s->obj_ctx, obj);
map<string, bufferlist> orig_attrs, attrs, rmattrs;
map<string, bufferlist>::iterator iter;
- RGWObjVersionTracker *ptracker = (!s->object_str.empty() ? NULL : &s->bucket_info.objv_tracker);
+ RGWObjVersionTracker *ptracker = (!s->object.empty() ? NULL : &s->bucket_info.objv_tracker);
/* check if obj exists, read orig attrs */
ret = get_obj_attrs(store, s, obj, orig_attrs, NULL, ptracker);
if (get_params() < 0)
return;
ret = -EINVAL;
- if (s->object_str.empty())
+ if (s->object.empty())
return;
policy.encode(aclbl);
upload_id.append(buf);
string tmp_obj_name;
- RGWMPObj mp(s->object_str, upload_id);
+ RGWMPObj mp(s->object.name, upload_id);
tmp_obj_name = mp.get_meta();
obj.init_ns(s->bucket, tmp_obj_name, mp_ns);
return;
}
- mp.init(s->object_str, upload_id);
+ mp.init(s->object.name, upload_id);
meta_oid = mp.get_meta();
int total_parts = 0;
attrs[RGW_ATTR_ETAG] = etag_bl;
- target_obj.init(s->bucket, s->object_str);
+ target_obj.init(s->bucket, s->object.name);
store->set_atomic(s->obj_ctx, target_obj);
RGWMPObj mp;
const string& owner = s->bucket_owner.get_id();
- if (upload_id.empty() || s->object_str.empty())
+ if (upload_id.empty() || s->object.empty())
return;
- mp.init(s->object_str, upload_id);
+ mp.init(s->object.name, upload_id);
meta_oid = mp.get_meta();
ret = get_multipart_info(store, s, meta_oid, NULL, attrs);
if (ret < 0)
return;
- mp.init(s->object_str, upload_id);
+ mp.init(s->object.name, upload_id);
meta_oid = mp.get_meta();
ret = get_multipart_info(store, s, meta_oid, &policy, xattrs);
int ret = rgw_build_policies(store, s, only_bucket, op->prefetch_data());
if (ret < 0) {
- ldout(s->cct, 10) << "read_permissions on " << s->bucket << ":" <<s->object_str << " only_bucket=" << only_bucket << " ret=" << ret << dendl;
+ ldout(s->cct, 10) << "read_permissions on " << s->bucket << ":" <<s->object << " only_bucket=" << only_bucket << " ret=" << ret << dendl;
if (ret == -ENODATA)
ret = -EACCES;
}
map<string, bufferlist> attrs;
string src_bucket_name;
rgw_bucket src_bucket;
- string src_object;
+ rgw_obj_key src_object;
string dest_bucket_name;
rgw_bucket dest_bucket;
string dest_object;
last_ofs = 0;
}
- static bool parse_copy_location(const char *src, string& bucket_name, string& object);
+ static bool parse_copy_location(const char *src, string& bucket_name, rgw_obj_key& object);
virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
RGWOp::init(store, s, h);
if (!s->bucket_name_str.empty()) {
location += s->bucket_name_str;
location += "/";
- if (!s->object_str.empty()) {
- location += s->object_str;
+ if (!s->object.empty()) {
+ location += s->object.name;
s->cio->print("Location: %s\r\n", location.c_str());
}
}
env.add_var(part.name, part_str);
} while (!done);
- if (!part_str("key", &s->object_str)) {
+ string object_str;
+ if (!part_str("key", &object_str)) {
err_msg = "Key not specified";
return -EINVAL;
}
- rebuild_key(s->object_str);
+ s->object = rgw_obj_key(object_str);
- if (s->object_str.empty()) {
+ rebuild_key(s->object.name);
+
+ if (s->object.empty()) {
err_msg = "Empty object name";
return -EINVAL;
}
- env.add_var("key", s->object_str);
+ env.add_var("key", s->object.name);
part_str("Content-Type", &content_type);
env.add_var("Content-Type", content_type);
string etag_url;
url_encode(s->bucket_name_str, bucket);
- url_encode(s->object_str, key);
+ url_encode(s->object.name, key);
url_encode(etag_str, etag_url);
redirect.append("?bucket=");
if (ret == STATUS_CREATED) {
s->formatter->open_object_section("PostResponse");
if (g_conf->rgw_dns_name.length())
- s->formatter->dump_format("Location", "%s/%s", s->info.script_uri.c_str(), s->object_str.c_str());
+ s->formatter->dump_format("Location", "%s/%s", s->info.script_uri.c_str(), s->object.name.c_str());
s->formatter->dump_string("Bucket", s->bucket_name_str);
- s->formatter->dump_string("Key", s->object_str);
+ s->formatter->dump_string("Key", s->object.name);
s->formatter->close_section();
}
s->err.message = err_msg;
src_bucket_name = s->src_bucket_name;
src_object = s->src_object;
dest_bucket_name = s->bucket.name;
- dest_object = s->object_str;
+ dest_object = s->object.name;
if (s->system_request) {
source_zone = s->info.args.get(RGW_SYS_PARAM_PREFIX "source-zone");
if (source_zone.empty() &&
(dest_bucket_name.compare(src_bucket_name) == 0) &&
- (dest_object.compare(src_object) == 0) &&
+ (dest_object.compare(src_object.name) == 0) &&
+ src_object.instance.empty() &&
!replace_attrs) {
/* can only copy object into itself if replacing attrs */
ldout(s->cct, 0) << "can't copy object into itself if not replacing attrs" << dendl;
RGWAccessControlPolicy_S3 s3policy(s->cct);
// bucket-* canned acls do not apply to bucket
- if (s->object_str.empty()) {
+ if (s->object.empty()) {
if (s->canned_acl.find("bucket") != string::npos)
s->canned_acl.clear();
}
s->formatter->open_object_section_in_ns("InitiateMultipartUploadResult",
"http://s3.amazonaws.com/doc/2006-03-01/");
s->formatter->dump_string("Bucket", s->bucket_name_str);
- s->formatter->dump_string("Key", s->object_str);
+ s->formatter->dump_string("Key", s->object.name);
s->formatter->dump_string("UploadId", upload_id);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
if (g_conf->rgw_dns_name.length())
s->formatter->dump_format("Location", "%s.%s", s->bucket_name_str.c_str(), g_conf->rgw_dns_name.c_str());
s->formatter->dump_string("Bucket", s->bucket_name_str);
- s->formatter->dump_string("Key", s->object_str);
+ s->formatter->dump_string("Key", s->object.name);
s->formatter->dump_string("ETag", etag);
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
cur_max = test_iter->first;
}
s->formatter->dump_string("Bucket", s->bucket_name_str);
- s->formatter->dump_string("Key", s->object_str);
+ s->formatter->dump_string("Key", s->object.name);
s->formatter->dump_string("UploadId", upload_id);
s->formatter->dump_string("StorageClass", "STANDARD");
s->formatter->dump_int("PartNumberMarker", marker);
if (pos >= 0) {
string encoded_obj_str = req.substr(pos+1);
- s->object_str = encoded_obj_str;
+ s->object = rgw_obj_key(encoded_obj_str, s->info.args.get("versionId"));
}
} else {
- s->object_str = req_name;
+ s->object = rgw_obj_key(req_name, s->info.args.get("versionId"));
}
return 0;
}
int RGWHandler_ObjStore_S3::init(RGWRados *store, struct req_state *s, RGWClientIO *cio)
{
- dout(10) << "s->object=" << (!s->object_str.empty() ? s->object_str : "<NULL>") << " s->bucket=" << (!s->bucket_name_str.empty() ? s->bucket_name_str : "<NULL>") << dendl;
+ dout(10) << "s->object=" << (!s->object.empty() ? s->object : rgw_obj_key("<NULL>")) << " s->bucket=" << (!s->bucket_name_str.empty() ? s->bucket_name_str : "<NULL>") << dendl;
bool relaxed_names = s->cct->_conf->rgw_relaxed_s3_bucket_names;
int ret = validate_bucket_name(s->bucket_name_str, relaxed_names);
if (ret)
return ret;
- ret = validate_object_name(s->object_str);
+ ret = validate_object_name(s->object.name);
if (ret)
return ret;
if (s->bucket_name_str.empty())
return new RGWHandler_ObjStore_Service_S3;
- if (s->object_str.empty())
+ if (s->object.empty())
return new RGWHandler_ObjStore_Bucket_S3;
return new RGWHandler_ObjStore_Obj_S3;
snprintf(buf, sizeof(buf), "%lld", (long long)bucket.size_rounded);
s->cio->print("X-Container-Bytes-Used-Actual: %s\r\n", buf);
- if (s->object_str.empty()) {
+ if (s->object.empty()) {
RGWAccessControlPolicy_SWIFT *swift_policy = static_cast<RGWAccessControlPolicy_SWIFT *>(s->bucket_acl);
string read_acl, write_acl;
swift_policy->to_str(read_acl, write_acl);
if (!s->generic_attrs.count(RGW_ATTR_CONTENT_TYPE)) {
dout(5) << "content type wasn't provided, trying to guess" << dendl;
- const char *suffix = strrchr(s->object_str.c_str(), '.');
+ const char *suffix = strrchr(s->object.name.c_str(), '.');
if (suffix) {
suffix++;
if (*suffix) {
if (s->has_bad_meta)
return -EINVAL;
- if (s->object_str.c_str()) {
+ if (s->object.empty()) {
int r = get_swift_container_settings(s, store, &policy, &has_policy, &cors_config, &has_cors);
if (r < 0) {
return r;
src_bucket_name = s->src_bucket_name;
src_object = s->src_object;
dest_bucket_name = s->bucket_name_str;
- dest_object = s->object_str;
+ dest_object = s->object.name;
return 0;
}
} else {
if (strncmp(name, RGW_ATTR_META_PREFIX, sizeof(RGW_ATTR_META_PREFIX)-1) == 0) {
name += sizeof(RGW_ATTR_META_PREFIX) - 1;
- s->cio->print("X-%s-Meta-%s: %s\r\n", (!s->object_str.empty() ? "Object" : "Container"), name, iter->second.c_str());
+ s->cio->print("X-%s-Meta-%s: %s\r\n", (!s->object.empty() ? "Object" : "Container"), name, iter->second.c_str());
}
}
}
s->info.effective_uri = "/" + s->bucket_name_str;
if (req.size()) {
- s->object_str = req;
- s->info.effective_uri.append("/" + s->object_str);
+ s->object = rgw_obj_key(req, s->info.env->get("HTTP_X_OBJECT_VERSION_ID")); /* rgw swift extension */
+ s->info.effective_uri.append("/" + s->object.name);
}
return 0;
int RGWHandler_ObjStore_SWIFT::init(RGWRados *store, struct req_state *s, RGWClientIO *cio)
{
- dout(10) << "s->object=" << (!s->object_str.empty() ? s->object_str : "<NULL>") << " s->bucket=" << (!s->bucket_name_str.empty() ? s->bucket_name_str : "<NULL>") << dendl;
+ dout(10) << "s->object=" << (!s->object.empty() ? s->object : rgw_obj_key("<NULL>")) << " s->bucket=" << (!s->bucket_name_str.empty() ? s->bucket_name_str : "<NULL>") << dendl;
int ret = validate_bucket_name(s->bucket_name_str.c_str());
if (ret)
return ret;
- ret = validate_object_name(s->object_str);
+ ret = validate_object_name(s->object.name);
if (ret)
return ret;
return -ERR_BAD_URL;
string dest_bucket_name;
- string dest_object;
- bool result = RGWCopyObj::parse_copy_location(req_dest, dest_bucket_name, dest_object);
+ rgw_obj_key dest_obj_key;
+ bool result = RGWCopyObj::parse_copy_location(req_dest, dest_bucket_name, dest_obj_key);
if (!result)
return -ERR_BAD_URL;
+ string dest_object = dest_obj_key.name;
if (dest_bucket_name != s->bucket_name_str) {
ret = validate_bucket_name(dest_bucket_name.c_str());
if (ret < 0)
/* convert COPY operation into PUT */
s->src_bucket_name = s->bucket_name_str;
- s->src_object = s->object_str;
+ s->src_object = s->object;
s->bucket_name_str = dest_bucket_name;
- s->object_str = dest_object;
+ s->object = rgw_obj_key(dest_object);
s->op = OP_PUT;
}
if (s->bucket_name_str.empty())
return new RGWHandler_ObjStore_Service_SWIFT;
- if (s->object_str.empty())
+ if (s->object.empty())
return new RGWHandler_ObjStore_Bucket_SWIFT;
return new RGWHandler_ObjStore_Obj_SWIFT;
if (s->bucket_name_str.empty())
return -EPERM;
- if (s->object_str.empty())
+ if (s->object.empty())
return -EPERM;
string temp_url_sig = s->info.args.get("temp_url_sig");
projects / ceph.git / commitdiff