lib_LTLIBRARIES += librados.la
if WITH_RADOSGW
-libradosgw_la_SOURCES = \
+libradosgw_a_SOURCES = \
radosgw/rgw_fs.cc \
radosgw/rgw_rados.cc \
radosgw/rgw_acl.cc \
radosgw/rgw_op.cc \
radosgw/rgw_rest.cc \
radosgw/rgw_common.cc
-libradosgw_la_CFLAGS = ${AM_CFLAGS}
-lib_LTLIBRARIES += libradosgw.la
+libradosgw_a_CFLAGS = ${AM_CFLAGS}
+# lib_LTLIBRARIES += libradosgw.a
endif
rados_SOURCES = rados.cc
if WITH_RADOSGW
rgw_SOURCES = radosgw/rgw_main.cc
-rgw_LDADD = libradosgw.la librados.la libcrush.la -lfcgi -lcrypto -lexpat
+rgw_LDADD = libradosgw.a librados.la libcrush.la -lfcgi -lcrypto -lexpat
rgw_admin_SOURCES = radosgw/rgw_admin.cc
-rgw_admin_LDADD = libradosgw.la librados.la libcrush.la -lfcgi -lcrypto -lexpat
+rgw_admin_LDADD = libradosgw.a librados.la libcrush.la -lfcgi -lcrypto -lexpat
rgw_aclparser_SOURCES = radosgw/rgw_aclparser.cc
-rgw_aclparser_LDADD = libradosgw.la librados.la libcrush.la -lfcgi -lcrypto -lexpat
+rgw_aclparser_LDADD = libradosgw.a librados.la libcrush.la -lfcgi -lcrypto -lexpat
bin_PROGRAMS += rgw rgw_admin rgw_aclparser
endif
noinst_LIBRARIES = \
libcommon.a libcrush.a \
libmon.a libmds.a libosdc.a libosd.a libclient.a \
- libos.a
+ libos.a libradosgw.a
noinst_LIBRARIES += #libcephclient_so.a
#include "rgw_fs.h"
#include "rgw_rados.h"
-static S3FS fs_provider;
-static S3Rados rados_provider;
+static RGWFS fs_provider;
+static RGWRados rados_provider;
-S3Access* S3Access::store;
+RGWAccess* RGWAccess::store;
-S3Access *S3Access::init_storage_provider(const char *type, int argc, char *argv[])
+RGWAccess *RGWAccess::init_storage_provider(const char *type, int argc, char *argv[])
{
if (strcmp(type, "rados") == 0) {
store = &rados_provider;
-#ifndef __S3ACCESS_H
-#define __S3ACCESS_H
+#ifndef __RGWACCESS_H
+#define __RGWACCESS_H
#include <time.h>
#include <string>
#include "rgw_common.h"
-class S3Access {
+class RGWAccess {
public:
virtual int initialize(int argc, char *argv[]) { return 0; }
- virtual int list_buckets_init(std::string& id, S3AccessHandle *handle) = 0;
- virtual int list_buckets_next(std::string& id, S3ObjEnt& obj, S3AccessHandle *handle) = 0;
+ virtual int list_buckets_init(std::string& id, RGWAccessHandle *handle) = 0;
+ virtual int list_buckets_next(std::string& id, RGWObjEnt& obj, RGWAccessHandle *handle) = 0;
virtual int list_objects(std::string& id, std::string& bucket, int max, std::string& prefix, std::string& delim,
- std::string& marker, std::vector<S3ObjEnt>& result, map<string, bool>& common_prefixes) = 0;
+ std::string& marker, std::vector<RGWObjEnt>& result, map<string, bool>& common_prefixes) = 0;
virtual int create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs) = 0;
virtual int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
const char *if_match,
const char *if_nomatch,
map<nstring, bufferlist>& attrs,
- struct s3_err *err) = 0;
+ struct rgw_err *err) = 0;
virtual int delete_bucket(std::string& id, std::string& bucket) = 0;
virtual int delete_obj(std::string& id, std::string& bucket, std::string& obj) = 0;
const char *if_match,
const char *if_nomatch,
bool get_data,
- struct s3_err *err) = 0;
+ struct rgw_err *err) = 0;
virtual int get_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& dest) = 0;
virtual int set_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& bl) = 0;
- static S3Access *init_storage_provider(const char *type, int argc, char *argv[]);
- static S3Access *store;
+ static RGWAccess *init_storage_provider(const char *type, int argc, char *argv[]);
+ static RGWAccess *store;
};
-#define s3store S3Access::store
+#define rgwstore RGWAccess::store
using namespace std;
-static string s3_uri_all_users = S3_URI_ALL_USERS;
-static string s3_uri_auth_users = S3_URI_AUTH_USERS;
+static string rgw_uri_all_users = RGW_URI_ALL_USERS;
+static string rgw_uri_auth_users = RGW_URI_AUTH_USERS;
ostream& operator<<(ostream& out, XMLObj& obj) {
out << obj.type << ": " << obj.data;
void ACLPermission::xml_end(const char *el) {
const char *s = data.c_str();
if (strcasecmp(s, "READ") == 0) {
- flags |= S3_PERM_READ;
+ flags |= RGW_PERM_READ;
} else if (strcasecmp(s, "WRITE") == 0) {
- flags |= S3_PERM_WRITE;
+ flags |= RGW_PERM_WRITE;
} else if (strcasecmp(s, "READ_ACP") == 0) {
- flags |= S3_PERM_READ_ACP;
+ flags |= RGW_PERM_READ_ACP;
} else if (strcasecmp(s, "WRITE_ACP") == 0) {
- flags |= S3_PERM_WRITE_ACP;
+ flags |= RGW_PERM_WRITE_ACP;
} else if (strcasecmp(s, "FULL_CONTROL") == 0) {
- flags |= S3_PERM_FULL_CONTROL;
+ flags |= RGW_PERM_FULL_CONTROL;
}
}
};
}
-void S3AccessControlList::init_user_map()
+void RGWAccessControlList::init_user_map()
{
multimap<string, ACLGrant>::iterator iter;
acl_user_map.clear();
user_map_initialized = true;
}
-void S3AccessControlList::add_grant(ACLGrant *grant)
+void RGWAccessControlList::add_grant(ACLGrant *grant)
{
string id = grant->get_id();
if (id.size() > 0) {
}
}
-void S3AccessControlList::xml_end(const char *el) {
+void RGWAccessControlList::xml_end(const char *el) {
XMLObjIter iter = find("Grant");
ACLGrant *grant = (ACLGrant *)iter.get_next();
while (grant) {
init_user_map();
}
-int S3AccessControlList::get_perm(string& id, int perm_mask) {
+int RGWAccessControlList::get_perm(string& id, int perm_mask) {
cerr << "searching permissions for uid=" << id << " mask=" << perm_mask << std::endl;
if (!user_map_initialized)
init_user_map();
return 0;
}
-bool S3AccessControlList::create_canned(string id, string name, string canned_acl)
+bool RGWAccessControlList::create_canned(string id, string name, string canned_acl)
{
acl_user_map.clear();
grant_map.clear();
/* owner gets full control */
ACLGrant grant;
- grant.set_canon(id, name, S3_PERM_FULL_CONTROL);
+ grant.set_canon(id, name, RGW_PERM_FULL_CONTROL);
add_grant(&grant);
if (canned_acl.size() == 0 || canned_acl.compare("private") == 0) {
ACLGrant group_grant;
if (canned_acl.compare("public-read") == 0) {
- group_grant.set_group(s3_uri_all_users, S3_PERM_READ);
+ group_grant.set_group(rgw_uri_all_users, RGW_PERM_READ);
add_grant(&group_grant);
} else if (canned_acl.compare("public-read-write") == 0) {
- group_grant.set_group(s3_uri_all_users, S3_PERM_READ);
+ group_grant.set_group(rgw_uri_all_users, RGW_PERM_READ);
add_grant(&group_grant);
- group_grant.set_group(s3_uri_all_users, S3_PERM_WRITE);
+ group_grant.set_group(rgw_uri_all_users, RGW_PERM_WRITE);
add_grant(&group_grant);
} else if (canned_acl.compare("authenticated-read") == 0) {
- group_grant.set_group(s3_uri_auth_users, S3_PERM_READ);
+ group_grant.set_group(rgw_uri_auth_users, RGW_PERM_READ);
add_grant(&group_grant);
} else {
return false;
}
-void S3AccessControlPolicy::xml_end(const char *el) {
- acl = *(S3AccessControlList *)find_first("AccessControlList");
+void RGWAccessControlPolicy::xml_end(const char *el) {
+ acl = *(RGWAccessControlList *)find_first("AccessControlList");
owner = *(ACLOwner *)find_first("Owner");
}
-int S3AccessControlPolicy::get_perm(string& id, int perm_mask) {
+int RGWAccessControlPolicy::get_perm(string& id, int perm_mask) {
int perm = acl.get_perm(id, perm_mask);
if (perm == perm_mask)
return perm;
- if (perm_mask & (S3_PERM_READ_ACP | S3_PERM_WRITE_ACP)) {
+ if (perm_mask & (RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP)) {
/* this is the owner, it has implicit permissions */
if (id.compare(owner.get_id()) == 0) {
- perm |= S3_PERM_READ_ACP | S3_PERM_WRITE_ACP;
+ perm |= RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP;
perm &= perm_mask;
}
}
/* should we continue looking up? */
if ((perm & perm_mask) != perm_mask) {
- perm |= acl.get_perm(s3_uri_all_users, perm_mask);
+ perm |= acl.get_perm(rgw_uri_all_users, perm_mask);
- if (id.compare(S3_USER_ANON_ID)) {
+ if (id.compare(RGW_USER_ANON_ID)) {
/* this is not the anonymous user */
- perm |= acl.get_perm(s3_uri_auth_users, perm_mask);
+ perm |= acl.get_perm(rgw_uri_auth_users, perm_mask);
}
}
}
void xml_start(void *data, const char *el, const char **attr) {
- S3XMLParser *handler = (S3XMLParser *)data;
+ RGWXMLParser *handler = (RGWXMLParser *)data;
handler->xml_start(el, attr);
}
-void S3XMLParser::xml_start(const char *el, const char **attr) {
+void RGWXMLParser::xml_start(const char *el, const char **attr) {
XMLObj * obj;
if (strcmp(el, "AccessControlPolicy") == 0) {
- obj = new S3AccessControlPolicy();
+ obj = new RGWAccessControlPolicy();
} else if (strcmp(el, "Owner") == 0) {
obj = new ACLOwner();
} else if (strcmp(el, "AccessControlList") == 0) {
- obj = new S3AccessControlList();
+ obj = new RGWAccessControlList();
} else if (strcmp(el, "ID") == 0) {
obj = new ACLID();
} else if (strcmp(el, "DisplayName") == 0) {
}
void xml_end(void *data, const char *el) {
- S3XMLParser *handler = (S3XMLParser *)data;
+ RGWXMLParser *handler = (RGWXMLParser *)data;
handler->xml_end(el);
}
-void S3XMLParser::xml_end(const char *el) {
+void RGWXMLParser::xml_end(const char *el) {
XMLObj *parent_obj = cur_obj->get_parent();
cur_obj->xml_end(el);
cur_obj = parent_obj;
void handle_data(void *data, const char *s, int len)
{
- S3XMLParser *handler = (S3XMLParser *)data;
+ RGWXMLParser *handler = (RGWXMLParser *)data;
handler->handle_data(s, len);
}
-void S3XMLParser::handle_data(const char *s, int len)
+void RGWXMLParser::handle_data(const char *s, int len)
{
cur_obj->xml_handle_data(s, len);
}
-bool S3XMLParser::init()
+bool RGWXMLParser::init()
{
p = XML_ParserCreate(NULL);
if (!p) {
- cerr << "S3XMLParser::init(): ERROR allocating memory" << std::endl;
+ cerr << "RGWXMLParser::init(): ERROR allocating memory" << std::endl;
return false;
}
XML_SetElementHandler(p, ::xml_start, ::xml_end);
return true;
}
-bool S3XMLParser::parse(const char *_buf, int len, int done)
+bool RGWXMLParser::parse(const char *_buf, int len, int done)
{
int pos = buf_len;
buf = (char *)realloc(buf, buf_len + len);
#if 0
int main(int argc, char **argv) {
- S3XMLParser parser;
+ RGWXMLParser parser;
if (!parser.init())
exit(1);
break;
}
- S3AccessControlPolicy *policy = (S3AccessControlPolicy *)parser.find_first("AccessControlPolicy");
+ RGWAccessControlPolicy *policy = (RGWAccessControlPolicy *)parser.find_first("AccessControlPolicy");
if (policy) {
string id="79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be";
- cout << hex << policy->get_perm(id, S3_PERM_ALL) << dec << endl;
+ cout << hex << policy->get_perm(id, RGW_PERM_ALL) << dec << endl;
policy->to_xml(cout);
}
cout << parser.get_xml() << endl;
- S3AccessControlPolicy def;
+ RGWAccessControlPolicy def;
string id="thisistheid!";
string name="foobar";
def.create_default(id, name);
-#ifndef __S3_ACL_H
-#define __S3_ACL_H
+#ifndef __RGW_ACL_H
+#define __RGW_ACL_H
#include <map>
#include <string>
using namespace std;
-#define S3_URI_ALL_USERS "http://acs.amazonaws.com/groups/global/AllUsers"
-#define S3_URI_AUTH_USERS "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
+#define RGW_URI_ALL_USERS "http://acs.amazonaws.com/groups/global/AllUsers"
+#define RGW_URI_AUTH_USERS "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
-#define S3_PERM_READ 0x01
-#define S3_PERM_WRITE 0x02
-#define S3_PERM_READ_ACP 0x04
-#define S3_PERM_WRITE_ACP 0x08
-#define S3_PERM_FULL_CONTROL ( S3_PERM_READ | S3_PERM_WRITE | \
- S3_PERM_READ_ACP | S3_PERM_WRITE_ACP )
-#define S3_PERM_ALL S3_PERM_FULL_CONTROL
+#define RGW_PERM_READ 0x01
+#define RGW_PERM_WRITE 0x02
+#define RGW_PERM_READ_ACP 0x04
+#define RGW_PERM_WRITE_ACP 0x08
+#define RGW_PERM_FULL_CONTROL ( RGW_PERM_READ | RGW_PERM_WRITE | \
+ RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP )
+#define RGW_PERM_ALL RGW_PERM_FULL_CONTROL
class XMLObj;
::decode(flags, bl);
}
void to_xml(ostream& out) {
- if ((flags & S3_PERM_FULL_CONTROL) == S3_PERM_FULL_CONTROL) {
+ if ((flags & RGW_PERM_FULL_CONTROL) == RGW_PERM_FULL_CONTROL) {
out << "<Permission>FULL_CONTROL</Permission>";
} else {
- if (flags & S3_PERM_READ)
+ if (flags & RGW_PERM_READ)
out << "<Permission>READ</Permission>";
- if (flags & S3_PERM_WRITE)
+ if (flags & RGW_PERM_WRITE)
out << "<Permission>WRITE</Permission>";
- if (flags & S3_PERM_READ_ACP)
+ if (flags & RGW_PERM_READ_ACP)
out << "<Permission>READ_ACP</Permission>";
- if (flags & S3_PERM_WRITE_ACP)
+ if (flags & RGW_PERM_WRITE_ACP)
out << "<Permission>WRITE_ACP</Permission>";
}
}
};
WRITE_CLASS_ENCODER(ACLGrant)
-class S3AccessControlList : public XMLObj
+class RGWAccessControlList : public XMLObj
{
map<string, int> acl_user_map;
multimap<string, ACLGrant> grant_map;
void init_user_map();
public:
- S3AccessControlList() : user_map_initialized(false) {}
- ~S3AccessControlList() {}
+ RGWAccessControlList() : user_map_initialized(false) {}
+ ~RGWAccessControlList() {}
void xml_end(const char *el);
int get_perm(string& id, int perm_mask);
grant_map.clear();
ACLGrant grant;
- grant.set_canon(id, name, S3_PERM_FULL_CONTROL);
+ grant.set_canon(id, name, RGW_PERM_FULL_CONTROL);
add_grant(&grant);
}
bool create_canned(string id, string name, string canned_acl);
};
-WRITE_CLASS_ENCODER(S3AccessControlList)
+WRITE_CLASS_ENCODER(RGWAccessControlList)
class ACLOwner : public XMLObj
{
};
WRITE_CLASS_ENCODER(ACLOwner)
-class S3AccessControlPolicy : public XMLObj
+class RGWAccessControlPolicy : public XMLObj
{
- S3AccessControlList acl;
+ RGWAccessControlList acl;
ACLOwner owner;
public:
- S3AccessControlPolicy() {}
- ~S3AccessControlPolicy() {}
+ RGWAccessControlPolicy() {}
+ ~RGWAccessControlPolicy() {}
void xml_end(const char *el);
return ret;
}
- S3AccessControlList& get_acl() {
+ RGWAccessControlList& get_acl() {
return acl;
}
};
-WRITE_CLASS_ENCODER(S3AccessControlPolicy)
+WRITE_CLASS_ENCODER(RGWAccessControlPolicy)
-class S3XMLParser : public XMLObj
+class RGWXMLParser : public XMLObj
{
XML_Parser p;
char *buf;
XMLObj *cur_obj;
vector<XMLObj *> objs;
public:
- S3XMLParser() : buf(NULL), buf_len(0), cur_obj(NULL) {}
- ~S3XMLParser() {
+ RGWXMLParser() : buf(NULL), buf_len(0), cur_obj(NULL) {}
+ ~RGWXMLParser() {
free(buf);
vector<XMLObj *>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
using namespace std;
int main(int argc, char **argv) {
- S3XMLParser parser;
+ RGWXMLParser parser;
if (!parser.init())
exit(1);
break;
}
- S3AccessControlPolicy *policy = (S3AccessControlPolicy *)parser.find_first("AccessControlPolicy");
+ RGWAccessControlPolicy *policy = (RGWAccessControlPolicy *)parser.find_first("AccessControlPolicy");
if (policy) {
string id="79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be";
- cout << hex << policy->get_perm(id, S3_PERM_ALL) << dec << endl;
+ cout << hex << policy->get_perm(id, RGW_PERM_ALL) << dec << endl;
policy->to_xml(cout);
}
bufferlist bl;
policy->encode(bl);
- S3AccessControlPolicy newpol;
+ RGWAccessControlPolicy newpol;
bufferlist::iterator iter = bl.begin();
newpol.decode(iter);
void usage()
{
- cerr << "usage: s3admin <--user-gen | --user-modify | --read-policy | --list-buckets > [options...]" << std::endl;
+ cerr << "usage: rgw_admin <--user-gen | --user-modify | --read-policy | --list-buckets > [options...]" << std::endl;
cerr << "options:" << std::endl;
cerr << " --uid=<id>" << std::endl;
cerr << " --key=<key>" << std::endl;
return 0;
}
-static int rebuild_policy(S3AccessControlPolicy& src, S3AccessControlPolicy& dest)
+static int rebuild_policy(RGWAccessControlPolicy& src, RGWAccessControlPolicy& dest)
{
ACLOwner *owner = (ACLOwner *)src.find_first("Owner");
if (!owner)
return -EINVAL;
- S3UserInfo owner_info;
- if (s3_get_user_info(owner->get_id(), owner_info) < 0) {
+ RGWUserInfo owner_info;
+ if (rgw_get_user_info(owner->get_id(), owner_info) < 0) {
cerr << "owner info does not exist" << std::endl;
return -EINVAL;
}
new_owner.set_id(owner->get_id());
new_owner.set_name(owner_info.display_name);
- S3AccessControlList& src_acl = src.get_acl();
- S3AccessControlList& acl = dest.get_acl();
+ RGWAccessControlList& src_acl = src.get_acl();
+ RGWAccessControlList& acl = dest.get_acl();
XMLObjIter iter = src_acl.find("Grant");
ACLGrant *src_grant = (ACLGrant *)iter.get_next();
while (src_grant) {
string id = src_grant->get_id();
- S3UserInfo grant_user;
- if (s3_get_user_info(id, grant_user) < 0) {
+ RGWUserInfo grant_user;
+ if (rgw_get_user_info(id, grant_user) < 0) {
cerr << "grant user does not exist:" << id << std::endl;
} else {
ACLGrant new_grant;
vector<const char*> args;
argv_to_vec(argc, (const char **)argv, args);
env_to_vec(args);
- common_init(args, "s3a", true);
+ common_init(args, "rgw", true);
const char *user_id = 0;
const char *secret_key = 0;
bool read_policy = false;
bool list_buckets = false;
int actions = 0 ;
- S3UserInfo info;
- S3Access *store;
+ RGWUserInfo info;
+ RGWAccess *store;
if (g_conf.clock_tare) g_clock.tare();
}
}
- store = S3Access::init_storage_provider("rados", argc, argv);
+ store = RGWAccess::init_storage_provider("rados", argc, argv);
if (!store) {
cerr << "couldn't init storage provider" << std::endl;
}
string user_id_str = user_id;
- if (s3_get_user_info(user_id_str, info) < 0) {
+ if (rgw_get_user_info(user_id_str, info) < 0) {
cerr << "error reading user info, aborting" << std::endl;
exit(1);
}
if (user_email)
info.user_email = user_email;
- if (s3_store_user_info(info) < 0) {
+ if (rgw_store_user_info(info) < 0) {
cerr << "error storing user info" << std::endl;
} else {
cout << "User ID: " << info.user_id << std::endl;
string bucket_str(bucket);
string object_str(object);
int ret = store->get_attr(bucket_str, object_str,
- S3_ATTR_ACL, bl);
+ RGW_ATTR_ACL, bl);
- S3AccessControlPolicy policy;
+ RGWAccessControlPolicy policy;
if (ret >= 0) {
bufferlist::iterator iter = bl.begin();
policy.decode(iter);
if (list_buckets) {
actions++;
string id;
- S3AccessHandle handle;
+ RGWAccessHandle handle;
if (user_id) {
- S3UserBuckets buckets;
- if (s3_get_user_buckets(user_id, buckets) < 0) {
+ RGWUserBuckets buckets;
+ if (rgw_get_user_buckets(user_id, buckets) < 0) {
cout << "could not get buckets for uid " << user_id << std::endl;
} else {
cout << "listing buckets for uid " << user_id << std::endl;
- map<string, S3ObjEnt>& m = buckets.get_buckets();
- map<string, S3ObjEnt>::iterator iter;
+ map<string, RGWObjEnt>& m = buckets.get_buckets();
+ map<string, RGWObjEnt>::iterator iter;
for (iter = m.begin(); iter != m.end(); ++iter) {
- S3ObjEnt obj = iter->second;
+ RGWObjEnt obj = iter->second;
cout << obj.name << std::endl;
}
}
if (store->list_buckets_init(id, &handle) < 0) {
cout << "list-buckets: no entries found" << std::endl;
} else {
- S3ObjEnt obj;
+ RGWObjEnt obj;
cout << "listing all buckets" << std::endl;
while (store->list_buckets_next(id, obj, &handle) >= 0) {
cout << obj.name << std::endl;
return get(s);
}
-bool verify_permission(S3AccessControlPolicy *policy, string& uid, int perm)
+bool verify_permission(RGWAccessControlPolicy *policy, string& uid, int perm)
{
if (!policy)
return false;
-#ifndef __S3COMMON_H
-#define __S3COMMON_H
+#ifndef __RGWCOMMON_H
+#define __RGWCOMMON_H
#include "fcgiapp.h"
using namespace std;
-#define SERVER_NAME "S3FS"
+#define SERVER_NAME "RGWFS"
-#define S3_ATTR_PREFIX "user.s3."
+#define RGW_ATTR_PREFIX "user.rgw."
-#define S3_ATTR_ACL S3_ATTR_PREFIX "acl"
-#define S3_ATTR_ETAG S3_ATTR_PREFIX "etag"
-#define S3_ATTR_BUCKETS S3_ATTR_PREFIX "buckets"
-#define S3_ATTR_META_PREFIX S3_ATTR_PREFIX "x-amz-meta-"
-#define S3_ATTR_CONTENT_TYPE S3_ATTR_PREFIX "content_type"
+#define RGW_ATTR_ACL RGW_ATTR_PREFIX "acl"
+#define RGW_ATTR_ETAG RGW_ATTR_PREFIX "etag"
+#define RGW_ATTR_BUCKETS RGW_ATTR_PREFIX "buckets"
+#define RGW_ATTR_META_PREFIX RGW_ATTR_PREFIX "x-amz-meta-"
+#define RGW_ATTR_CONTENT_TYPE RGW_ATTR_PREFIX "content_type"
#define USER_INFO_VER 1
-typedef void *S3AccessHandle;
+typedef void *RGWAccessHandle;
-struct s3_err {
+struct rgw_err {
const char *num;
const char *code;
const char *message;
- s3_err() : num(NULL), code(NULL), message(NULL) {}
+ rgw_err() : num(NULL), code(NULL), message(NULL) {}
};
class NameVal
FCGX_Stream *err;
};
-class S3AccessControlPolicy;
+class RGWAccessControlPolicy;
-struct S3UserInfo
+struct RGWUserInfo
{
string user_id;
string secret_key;
user_email.clear();
}
};
-WRITE_CLASS_ENCODER(S3UserInfo)
+WRITE_CLASS_ENCODER(RGWUserInfo)
struct req_state {
const char *length;
const char *content_type;
bool err_exist;
- struct s3_err err;
+ struct rgw_err err;
XMLArgs args;
vector<pair<string, string> > x_amz_meta;
- S3UserInfo user;
- S3AccessControlPolicy *acl;
+ RGWUserInfo user;
+ RGWAccessControlPolicy *acl;
string canned_acl;
const char *copy_source;
req_state() : acl(NULL) {}
};
-struct S3ObjEnt {
+struct RGWObjEnt {
std::string name;
size_t size;
time_t mtime;
::decode(mtime, bl);
}
};
-WRITE_CLASS_ENCODER(S3ObjEnt)
+WRITE_CLASS_ENCODER(RGWObjEnt)
static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
{
}
extern int parse_time(const char *time_str, time_t *time);
-extern bool verify_permission(S3AccessControlPolicy *policy, string& uid, int perm);
+extern bool verify_permission(RGWAccessControlPolicy *policy, string& uid, int perm);
extern bool verify_permission(struct req_state *s, int perm);
extern bool url_decode(string& src_str, string& dest_str);
using namespace std;
-struct s3fs_state {
+struct rgwfs_state {
DIR *dir;
};
#define DIR_NAME "/tmp/radosgw"
-int S3FS::list_buckets_init(string& id, S3AccessHandle *handle)
+int RGWFS::list_buckets_init(string& id, RGWAccessHandle *handle)
{
DIR *dir = opendir(DIR_NAME);
- struct s3fs_state *state;
+ struct rgwfs_state *state;
if (!dir)
return -errno;
- state = (struct s3fs_state *)malloc(sizeof(struct s3fs_state));
+ state = (struct rgwfs_state *)malloc(sizeof(struct rgwfs_state));
if (!state)
return -ENOMEM;
state->dir = dir;
- *handle = (S3AccessHandle)state;
+ *handle = (RGWAccessHandle)state;
return 0;
}
-int S3FS::list_buckets_next(string& id, S3ObjEnt& obj, S3AccessHandle *handle)
+int RGWFS::list_buckets_next(string& id, RGWObjEnt& obj, RGWAccessHandle *handle)
{
- struct s3fs_state *state;
+ struct rgwfs_state *state;
struct dirent *dirent;
#define BUF_SIZE 512
if (!handle)
return -EINVAL;
- state = *(struct s3fs_state **)handle;
+ state = *(struct rgwfs_state **)handle;
if (!state)
return -EINVAL;
}
}
-int S3FS::list_objects(string& id, string& bucket, int max, string& prefix, string& delim,
- string& marker, vector<S3ObjEnt>& result, map<string, bool>& common_prefixes)
+int RGWFS::list_objects(string& id, string& bucket, int max, string& prefix, string& delim,
+ string& marker, vector<RGWObjEnt>& result, map<string, bool>& common_prefixes)
{
map<string, bool> dir_map;
char path[BUF_SIZE];
result.clear();
int i;
for (i=0; i<max && iter != dir_map.end(); i++, ++iter) {
- S3ObjEnt obj;
+ RGWObjEnt obj;
char buf[BUF_SIZE];
struct stat statbuf;
obj.name = iter->first;
obj.mtime = statbuf.st_mtime;
obj.size = statbuf.st_size;
char *etag;
- if (get_attr(S3_ATTR_ETAG, buf, &etag) >= 0) {
+ if (get_attr(RGW_ATTR_ETAG, buf, &etag) >= 0) {
strncpy(obj.etag, etag, sizeof(obj.etag));
obj.etag[sizeof(obj.etag)-1] = '\0';
free(etag);
}
-int S3FS::create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs)
+int RGWFS::create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1;
char buf[len];
return 0;
}
-int S3FS::put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
+int RGWFS::put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
time_t *mtime,
map<nstring, bufferlist>& attrs)
{
return 0;
}
-int S3FS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
+int RGWFS::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
std::string& src_bucket, std::string& src_obj,
time_t *mtime,
const time_t *mod_ptr,
const char *if_match,
const char *if_nomatch,
map<nstring, bufferlist>& attrs,
- struct s3_err *err)
+ struct rgw_err *err)
{
int ret;
char *data;
}
-int S3FS::delete_bucket(std::string& id, std::string& bucket)
+int RGWFS::delete_bucket(std::string& id, std::string& bucket)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1;
char buf[len];
}
-int S3FS::delete_obj(std::string& id, std::string& bucket, std::string& obj)
+int RGWFS::delete_obj(std::string& id, std::string& bucket, std::string& obj)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
char buf[len];
return 0;
}
-int S3FS::get_attr(const char *name, int fd, char **attr)
+int RGWFS::get_attr(const char *name, int fd, char **attr)
{
char *attr_buf;
#define ETAG_LEN 32
return attr_len;
}
-int S3FS::get_attr(const char *name, const char *path, char **attr)
+int RGWFS::get_attr(const char *name, const char *path, char **attr)
{
char *attr_buf;
size_t len = ETAG_LEN;
return attr_len;
}
-int S3FS::get_attr(std::string& bucket, std::string& obj,
+int RGWFS::get_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& dest)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
return r;
}
-int S3FS::set_attr(std::string& bucket, std::string& obj,
+int RGWFS::set_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& bl)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
return ret;
}
-int S3FS::get_obj(std::string& bucket, std::string& obj,
+int RGWFS::get_obj(std::string& bucket, std::string& obj,
char **data, off_t ofs, off_t end,
map<nstring, bufferlist> *attrs,
const time_t *mod_ptr,
const char *if_match,
const char *if_nomatch,
bool get_data,
- struct s3_err *err)
+ struct rgw_err *err)
{
int len = strlen(DIR_NAME) + 1 + bucket.size() + 1 + obj.size() + 1;
char buf[len];
}
}
if (if_match || if_nomatch) {
- r = get_attr(S3_ATTR_ETAG, fd, &etag);
+ r = get_attr(RGW_ATTR_ETAG, fd, &etag);
if (r < 0)
goto done;
-#ifndef __S3FS_H
-#define __S3FS_H
+#ifndef __RGWFS_H
+#define __RGWFS_H
#include "rgw_access.h"
-class S3FS : public S3Access
+class RGWFS : public RGWAccess
{
public:
- int list_buckets_init(std::string& id, S3AccessHandle *handle);
- int list_buckets_next(std::string& id, S3ObjEnt& obj, S3AccessHandle *handle);
+ int list_buckets_init(std::string& id, RGWAccessHandle *handle);
+ int list_buckets_next(std::string& id, RGWObjEnt& obj, RGWAccessHandle *handle);
int list_objects(std::string& id, std::string& bucket, int max, std::string& prefix, std::string& delim,
- std::string& marker, std::vector<S3ObjEnt>& result, map<string, bool>& common_prefixes);
+ std::string& marker, std::vector<RGWObjEnt>& result, map<string, bool>& common_prefixes);
int create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs);
int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
const char *if_match,
const char *if_nomatch,
map<nstring, bufferlist>& attrs,
- struct s3_err *err);
+ struct rgw_err *err);
int delete_bucket(std::string& id, std::string& bucket);
int delete_obj(std::string& id, std::string& bucket, std::string& obj);
const char *if_match,
const char *if_nomatch,
bool get_data,
- struct s3_err *err);
+ struct rgw_err *err);
};
#endif
qsr = true;
} else {
/* anonymous access */
- s3_get_anon_user(s->user);
+ rgw_get_anon_user(s->user);
return true;
}
} else {
}
/* first get the user info */
- if (s3_get_user_info(auth_id, s->user) < 0) {
+ if (rgw_get_user_info(auth_id, s->user) < 0) {
cerr << "error reading user info, uid=" << auth_id << " can't authenticate" << std::endl;
return false;
}
{
struct req_state s;
struct fcgx_state fcgx;
- S3Handler_REST s3handler;
+ RGWHandler_REST rgwhandler;
- if (!S3Access::init_storage_provider("rados", argc, argv)) {
+ if (!RGWAccess::init_storage_provider("rados", argc, argv)) {
cerr << "couldn't init storage provider" << std::endl;
}
while (FCGX_Accept(&fcgx.in, &fcgx.out, &fcgx.err, &fcgx.envp) >= 0)
{
- s3handler.init_state(&s, &fcgx);
+ rgwhandler.init_state(&s, &fcgx);
int ret = read_acls(&s);
if (ret < 0) {
continue;
}
- ret = s3handler.read_permissions();
+ ret = rgwhandler.read_permissions();
if (ret < 0) {
abort_early(&s, ret);
continue;
}
- S3Op *op = s3handler.get_op();
+ RGWOp *op = rgwhandler.get_op();
if (op) {
op->execute();
}
string& val = iter->second;
bufferlist bl;
bl.append(val.c_str(), val.size() + 1);
- string attr_name = S3_ATTR_PREFIX;
+ string attr_name = RGW_ATTR_PREFIX;
attr_name.append(name);
attrs[attr_name.c_str()] = bl;
}
}
}
-int read_acls(S3AccessControlPolicy *policy, string& bucket, string& object)
+int read_acls(RGWAccessControlPolicy *policy, string& bucket, string& object)
{
bufferlist bl;
int ret = 0;
if (bucket.size()) {
- ret = s3store->get_attr(bucket, object,
- S3_ATTR_ACL, bl);
+ ret = rgwstore->get_attr(bucket, object,
+ RGW_ATTR_ACL, bl);
if (ret >= 0) {
bufferlist::iterator iter = bl.begin();
string obj_str;
if (!s->acl) {
- s->acl = new S3AccessControlPolicy;
+ s->acl = new RGWAccessControlPolicy;
if (!s->acl)
return -ENOMEM;
}
return ret;
}
-void S3GetObj::execute()
+void RGWGetObj::execute()
{
- if (!verify_permission(s, S3_PERM_READ)) {
+ if (!verify_permission(s, RGW_PERM_READ)) {
ret = -EACCES;
goto done;
}
init_common();
- len = s3store->get_obj(s->bucket_str, s->object_str, &data, ofs, end, &attrs,
+ len = rgwstore->get_obj(s->bucket_str, s->object_str, &data, ofs, end, &attrs,
mod_ptr, unmod_ptr, if_match, if_nomatch, get_data, &err);
if (len < 0)
ret = len;
send_response();
}
-int S3GetObj::init_common()
+int RGWGetObj::init_common()
{
if (range_str) {
int r = parse_range(range_str, ofs, end);
return 0;
}
-void S3ListBuckets::execute()
+void RGWListBuckets::execute()
{
- ret = s3_get_user_buckets(s->user.user_id, buckets);
+ ret = rgw_get_user_buckets(s->user.user_id, buckets);
if (ret < 0) {
/* hmm.. something wrong here.. the user was authenticated, so it
should exist, just try to recreate */
- cerr << "WARNING: failed on s3_get_user_buckets uid=" << s->user.user_id << std::endl;
- s3_put_user_buckets(s->user.user_id, buckets);
+ cerr << "WARNING: failed on rgw_get_user_buckets uid=" << s->user.user_id << std::endl;
+ rgw_put_user_buckets(s->user.user_id, buckets);
ret = 0;
}
send_response();
}
-void S3ListBucket::execute()
+void RGWListBucket::execute()
{
- if (!verify_permission(s, S3_PERM_READ)) {
+ if (!verify_permission(s, RGW_PERM_READ)) {
ret = -EACCES;
goto done;
}
max = -1;
}
delimiter = s->args.get("delimiter");
- ret = s3store->list_objects(s->user.user_id, s->bucket_str, max, prefix, delimiter, marker, objs, common_prefixes);
+ ret = rgwstore->list_objects(s->user.user_id, s->bucket_str, max, prefix, delimiter, marker, objs, common_prefixes);
done:
send_response();
}
-void S3CreateBucket::execute()
+void RGWCreateBucket::execute()
{
- S3AccessControlPolicy policy;
+ RGWAccessControlPolicy policy;
map<nstring, bufferlist> attrs;
bufferlist aclbl;
}
policy.encode(aclbl);
- attrs[S3_ATTR_ACL] = aclbl;
+ attrs[RGW_ATTR_ACL] = aclbl;
- ret = s3store->create_bucket(s->user.user_id, s->bucket_str, attrs);
+ ret = rgwstore->create_bucket(s->user.user_id, s->bucket_str, attrs);
if (ret == 0) {
- S3UserBuckets buckets;
+ RGWUserBuckets buckets;
- int r = s3_get_user_buckets(s->user.user_id, buckets);
- S3ObjEnt new_bucket;
+ int r = rgw_get_user_buckets(s->user.user_id, buckets);
+ RGWObjEnt new_bucket;
switch (r) {
case 0:
new_bucket.size = 0;
time(&new_bucket.mtime);
buckets.add(new_bucket);
- ret = s3_put_user_buckets(s->user.user_id, buckets);
+ ret = rgw_put_user_buckets(s->user.user_id, buckets);
break;
default:
- cerr << "s3_get_user_buckets returned " << ret << std::endl;
+ cerr << "rgw_get_user_buckets returned " << ret << std::endl;
break;
}
}
send_response();
}
-void S3DeleteBucket::execute()
+void RGWDeleteBucket::execute()
{
ret = -EINVAL;
- if (!verify_permission(s, S3_PERM_WRITE)) {
+ if (!verify_permission(s, RGW_PERM_WRITE)) {
abort_early(s, -EACCES);
return;
}
if (s->bucket) {
- ret = s3store->delete_bucket(s->user.user_id, s->bucket_str);
+ ret = rgwstore->delete_bucket(s->user.user_id, s->bucket_str);
if (ret == 0) {
- S3UserBuckets buckets;
+ RGWUserBuckets buckets;
- int r = s3_get_user_buckets(s->user.user_id, buckets);
+ int r = rgw_get_user_buckets(s->user.user_id, buckets);
if (r == 0 || r == -ENOENT) {
buckets.remove(s->bucket_str);
- ret = s3_put_user_buckets(s->user.user_id, buckets);
+ ret = rgw_put_user_buckets(s->user.user_id, buckets);
}
}
}
send_response();
}
-void S3PutObj::execute()
+void RGWPutObj::execute()
{
ret = -EINVAL;
- struct s3_err err;
+ struct rgw_err err;
if (!s->object) {
goto done;
} else {
if (ret < 0)
goto done;
- S3AccessControlPolicy policy;
+ RGWAccessControlPolicy policy;
- if (!verify_permission(s, S3_PERM_WRITE)) {
+ if (!verify_permission(s, RGW_PERM_WRITE)) {
ret = -EACCES;
goto done;
}
map<nstring, bufferlist> attrs;
bufferlist bl;
bl.append(md5_str.c_str(), md5_str.size() + 1);
- attrs[S3_ATTR_ETAG] = bl;
- attrs[S3_ATTR_ACL] = aclbl;
+ attrs[RGW_ATTR_ETAG] = bl;
+ attrs[RGW_ATTR_ACL] = aclbl;
if (s->content_type) {
bl.clear();
bl.append(s->content_type, strlen(s->content_type) + 1);
- attrs[S3_ATTR_CONTENT_TYPE] = bl;
+ attrs[RGW_ATTR_CONTENT_TYPE] = bl;
}
get_request_metadata(s, attrs);
- ret = s3store->put_obj(s->user.user_id, s->bucket_str, s->object_str, data, len, NULL, attrs);
+ ret = rgwstore->put_obj(s->user.user_id, s->bucket_str, s->object_str, data, len, NULL, attrs);
}
done:
free(data);
send_response();
}
-void S3DeleteObj::execute()
+void RGWDeleteObj::execute()
{
ret = -EINVAL;
if (s->object) {
- ret = s3store->delete_obj(s->user.user_id, s->bucket_str, s->object_str);
+ ret = rgwstore->delete_obj(s->user.user_id, s->bucket_str, s->object_str);
}
send_response();
return true;
}
-int S3CopyObj::init_common()
+int RGWCopyObj::init_common()
{
- struct s3_err err;
- S3AccessControlPolicy dest_policy;
+ struct rgw_err err;
+ RGWAccessControlPolicy dest_policy;
bool ret;
bufferlist aclbl;
map<nstring, bufferlist> attrs;
bufferlist bl;
- S3AccessControlPolicy src_policy;
+ RGWAccessControlPolicy src_policy;
string empty_str;
time_t mod_time;
time_t unmod_time;
time_t *mod_ptr = NULL;
time_t *unmod_ptr = NULL;
- if (!verify_permission(s, S3_PERM_WRITE)) {
+ if (!verify_permission(s, RGW_PERM_WRITE)) {
ret = -EACCES;
return ret;
}
if (ret < 0)
return ret;
- if (!verify_permission(&src_policy, s->user.user_id, S3_PERM_READ)) {
+ if (!verify_permission(&src_policy, s->user.user_id, RGW_PERM_READ)) {
ret = -EACCES;
return ret;
}
unmod_ptr = &unmod_time;
}
- attrs[S3_ATTR_ACL] = aclbl;
+ attrs[RGW_ATTR_ACL] = aclbl;
get_request_metadata(s, attrs);
return 0;
}
-void S3CopyObj::execute()
+void RGWCopyObj::execute()
{
ret = get_params();
if (ret < 0)
if (init_common() < 0)
goto done;
- ret = s3store->copy_obj(s->user.user_id,
+ ret = rgwstore->copy_obj(s->user.user_id,
s->bucket_str, s->object_str,
src_bucket, src_object,
&mtime,
send_response();
}
-void S3GetACLs::execute()
+void RGWGetACLs::execute()
{
- if (!verify_permission(s, S3_PERM_READ_ACP)) {
+ if (!verify_permission(s, RGW_PERM_READ_ACP)) {
abort_early(s, -EACCES);
return;
}
send_response();
}
-static int rebuild_policy(S3AccessControlPolicy& src, S3AccessControlPolicy& dest)
+static int rebuild_policy(RGWAccessControlPolicy& src, RGWAccessControlPolicy& dest)
{
ACLOwner *owner = (ACLOwner *)src.find_first("Owner");
if (!owner)
return -EINVAL;
- S3UserInfo owner_info;
- if (s3_get_user_info(owner->get_id(), owner_info) < 0) {
+ RGWUserInfo owner_info;
+ if (rgw_get_user_info(owner->get_id(), owner_info) < 0) {
cerr << "owner info does not exist" << std::endl;
return -EINVAL;
}
new_owner.set_id(owner->get_id());
new_owner.set_name(owner_info.display_name);
- S3AccessControlList& src_acl = src.get_acl();
- S3AccessControlList& acl = dest.get_acl();
+ RGWAccessControlList& src_acl = src.get_acl();
+ RGWAccessControlList& acl = dest.get_acl();
XMLObjIter iter = src_acl.find("Grant");
ACLGrant *src_grant = (ACLGrant *)iter.get_next();
{
string email = src_grant->get_id();
cerr << "grant user email=" << email << std::endl;
- if (s3_get_uid_by_email(email, id) < 0) {
+ if (rgw_get_uid_by_email(email, id) < 0) {
cerr << "grant user email not found or other error" << std::endl;
break;
}
if (type.get_type() == ACL_TYPE_CANON_USER)
id = src_grant->get_id();
- S3UserInfo grant_user;
- if (s3_get_user_info(id, grant_user) < 0) {
+ RGWUserInfo grant_user;
+ if (rgw_get_user_info(id, grant_user) < 0) {
cerr << "grant user does not exist:" << id << std::endl;
} else {
ACLPermission& perm = src_grant->get_permission();
case ACL_TYPE_GROUP:
{
string group = src_grant->get_id();
- if (group.compare(S3_URI_ALL_USERS) == 0 ||
- group.compare(S3_URI_AUTH_USERS) == 0) {
+ if (group.compare(RGW_URI_ALL_USERS) == 0 ||
+ group.compare(RGW_URI_AUTH_USERS) == 0) {
new_grant = *src_grant;
grant_ok = true;
cerr << "new grant: " << new_grant.get_id() << std::endl;
return 0;
}
-void S3PutACLs::execute()
+void RGWPutACLs::execute()
{
bufferlist bl;
char *data = NULL;
- S3AccessControlPolicy *policy;
- S3XMLParser parser;
- S3AccessControlPolicy new_policy;
+ RGWAccessControlPolicy *policy;
+ RGWXMLParser parser;
+ RGWAccessControlPolicy new_policy;
- if (!verify_permission(s, S3_PERM_WRITE_ACP)) {
+ if (!verify_permission(s, RGW_PERM_WRITE_ACP)) {
ret = -EACCES;
goto done;
}
}
if (!s->acl) {
- s->acl = new S3AccessControlPolicy;
+ s->acl = new RGWAccessControlPolicy;
if (!s->acl) {
ret = -ENOMEM;
goto done;
ret = -EACCES;
goto done;
}
- policy = (S3AccessControlPolicy *)parser.find_first("AccessControlPolicy");
+ policy = (RGWAccessControlPolicy *)parser.find_first("AccessControlPolicy");
if (!policy) {
ret = -EINVAL;
goto done;
/* FIXME: make some checks around checks and fix policy */
new_policy.encode(bl);
- ret = s3store->set_attr(s->bucket_str, s->object_str,
- S3_ATTR_ACL, bl);
+ ret = rgwstore->set_attr(s->bucket_str, s->object_str,
+ RGW_ATTR_ACL, bl);
done:
free(data);
}
-void S3Handler::init_state(struct req_state *s, struct fcgx_state *fcgx)
+void RGWHandler::init_state(struct req_state *s, struct fcgx_state *fcgx)
{
this->s = s;
memset(&s->err, 0, sizeof(s->err));
if (s->acl) {
delete s->acl;
- s->acl = new S3AccessControlPolicy;
+ s->acl = new RGWAccessControlPolicy;
}
s->canned_acl.clear();
provider_init_state();
}
-int S3Handler::do_read_permissions(bool only_bucket)
+int RGWHandler::do_read_permissions(bool only_bucket)
{
int ret = read_acls(s, only_bucket);
-#ifndef __S3OP_H
-#define __S3OP_H
+#ifndef __RGWOP_H
+#define __RGWOP_H
#include <string>
struct req_state;
extern void get_request_metadata(struct req_state *s, map<nstring, bufferlist>& attrs);
-extern int read_acls(S3AccessControlPolicy *policy, string& bucket, string& object);
+extern int read_acls(RGWAccessControlPolicy *policy, string& bucket, string& object);
extern int read_acls(struct req_state *s, bool only_bucket = false);
-class S3Op {
+class RGWOp {
protected:
struct req_state *s;
public:
- S3Op() {}
- ~S3Op() {}
+ RGWOp() {}
+ ~RGWOp() {}
virtual void init(struct req_state *s) { this->s = s; }
virtual void execute() = 0;
};
-class S3GetObj : public S3Op {
+class RGWGetObj : public RGWOp {
protected:
const char *range_str;
const char *if_mod;
map<nstring, bufferlist> attrs;
char *data;
int ret;
- struct s3_err err;
+ struct rgw_err err;
bool get_data;
int init_common();
public:
- S3GetObj() {}
- ~S3GetObj() {}
+ RGWGetObj() {}
+ ~RGWGetObj() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ofs = 0;
len = 0;
end = -1;
virtual int send_response() = 0;
};
-class S3ListBuckets : public S3Op {
+class RGWListBuckets : public RGWOp {
protected:
int ret;
- S3UserBuckets buckets;
+ RGWUserBuckets buckets;
public:
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
}
- S3ListBuckets() {}
- ~S3ListBuckets() {}
+ RGWListBuckets() {}
+ ~RGWListBuckets() {}
void execute();
virtual void send_response() = 0;
};
-class S3ListBucket : public S3Op {
+class RGWListBucket : public RGWOp {
protected:
string prefix;
string marker;
string delimiter;
int max;
int ret;
- vector<S3ObjEnt> objs;
+ vector<RGWObjEnt> objs;
map<string, bool> common_prefixes;
public:
- S3ListBucket() {}
- ~S3ListBucket() {}
+ RGWListBucket() {}
+ ~RGWListBucket() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
prefix.clear();
marker.clear();
max_keys.clear();
virtual void send_response() = 0;
};
-class S3CreateBucket : public S3Op {
+class RGWCreateBucket : public RGWOp {
protected:
int ret;
public:
- S3CreateBucket() {}
- ~S3CreateBucket() {}
+ RGWCreateBucket() {}
+ ~RGWCreateBucket() {}
void execute();
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
}
virtual void send_response() = 0;
};
-class S3DeleteBucket : public S3Op {
+class RGWDeleteBucket : public RGWOp {
protected:
int ret;
public:
- S3DeleteBucket() {}
- ~S3DeleteBucket() {}
+ RGWDeleteBucket() {}
+ ~RGWDeleteBucket() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
}
void execute();
virtual void send_response() = 0;
};
-class S3PutObj : public S3Op {
+class RGWPutObj : public RGWOp {
protected:
int ret;
size_t len;
char *data;
- struct s3_err err;
+ struct rgw_err err;
char *supplied_md5_b64;
public:
- S3PutObj() {}
- ~S3PutObj() {}
+ RGWPutObj() {}
+ ~RGWPutObj() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
len = 0;
data = NULL;
virtual void send_response() = 0;
};
-class S3DeleteObj : public S3Op {
+class RGWDeleteObj : public RGWOp {
protected:
int ret;
public:
- S3DeleteObj() {}
- ~S3DeleteObj() {}
+ RGWDeleteObj() {}
+ ~RGWDeleteObj() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
}
void execute();
virtual void send_response() = 0;
};
-class S3CopyObj : public S3Op {
+class RGWCopyObj : public RGWOp {
protected:
const char *if_mod;
const char *if_unmod;
time_t *unmod_ptr;
int ret;
map<nstring, bufferlist> attrs;
- struct s3_err err;
+ struct rgw_err err;
string src_bucket;
string src_object;
time_t mtime;
int init_common();
public:
- S3CopyObj() {}
- ~S3CopyObj() {}
+ RGWCopyObj() {}
+ ~RGWCopyObj() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
if_mod = NULL;
if_unmod = NULL;
if_match = NULL;
virtual void send_response() = 0;
};
-class S3GetACLs : public S3Op {
+class RGWGetACLs : public RGWOp {
protected:
int ret;
string acls;
public:
- S3GetACLs() {}
- ~S3GetACLs() {}
+ RGWGetACLs() {}
+ ~RGWGetACLs() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
acls.clear();
}
virtual void send_response() = 0;
};
-class S3PutACLs : public S3Op {
+class RGWPutACLs : public RGWOp {
protected:
int ret;
size_t len;
char *data;
public:
- S3PutACLs() {}
- ~S3PutACLs() {}
+ RGWPutACLs() {}
+ ~RGWPutACLs() {}
virtual void init(struct req_state *s) {
- S3Op::init(s);
+ RGWOp::init(s);
ret = 0;
len = 0;
data = NULL;
virtual void send_response() = 0;
};
-class S3Handler {
+class RGWHandler {
protected:
struct req_state *s;
virtual void provider_init_state() = 0;
int do_read_permissions(bool only_bucket);
public:
- S3Handler() {}
- virtual ~S3Handler() {}
+ RGWHandler() {}
+ virtual ~RGWHandler() {}
void init_state(struct req_state *s, struct fcgx_state *fcgx);
- S3Op *get_op();
+ RGWOp *get_op();
virtual int read_permissions() = 0;
};
static Rados *rados = NULL;
-#define ROOT_BUCKET ".s3"
+#define ROOT_BUCKET ".rgw"
static string root_bucket(ROOT_BUCKET);
static rados_pool_t root_pool;
-int S3Rados::initialize(int argc, char *argv[])
+int RGWRados::initialize(int argc, char *argv[])
{
rados = new Rados();
if (!rados)
return ret;
}
-int S3Rados::open_root_pool(rados_pool_t *pool)
+int RGWRados::open_root_pool(rados_pool_t *pool)
{
int r = rados->open_pool(root_bucket.c_str(), pool);
if (r < 0) {
return r;
}
-class S3RadosListState {
+class RGWRadosListState {
public:
vector<string> list;
unsigned int pos;
- S3RadosListState() : pos(0) {}
+ RGWRadosListState() : pos(0) {}
};
-int S3Rados::list_buckets_init(std::string& id, S3AccessHandle *handle)
+int RGWRados::list_buckets_init(std::string& id, RGWAccessHandle *handle)
{
- S3RadosListState *state = new S3RadosListState();
+ RGWRadosListState *state = new RGWRadosListState();
if (!state)
return -ENOMEM;
if (r < 0)
return r;
- *handle = (S3AccessHandle)state;
+ *handle = (RGWAccessHandle)state;
return 0;
}
-int S3Rados::list_buckets_next(std::string& id, S3ObjEnt& obj, S3AccessHandle *handle)
+int RGWRados::list_buckets_next(std::string& id, RGWObjEnt& obj, RGWAccessHandle *handle)
{
- S3RadosListState *state = (S3RadosListState *)*handle;
+ RGWRadosListState *state = (RGWRadosListState *)*handle;
if (state->pos == state->list.size()) {
delete state;
return rados->open_pool(bucket.c_str(), pool);
}
-int S3Rados::list_objects(string& id, string& bucket, int max, string& prefix, string& delim,
- string& marker, vector<S3ObjEnt>& result, map<string, bool>& common_prefixes)
+int RGWRados::list_objects(string& id, string& bucket, int max, string& prefix, string& delim,
+ string& marker, vector<RGWObjEnt>& result, map<string, bool>& common_prefixes)
{
rados_pool_t pool;
map<string, object_t> dir_map;
result.clear();
int i, count = 0;
for (i=0; i<max && map_iter != dir_map.end(); i++, ++map_iter) {
- S3ObjEnt obj;
+ RGWObjEnt obj;
obj.name = map_iter->first;
if (!delim.empty()) {
bufferlist bl;
obj.etag[0] = '\0';
- if (rados->getxattr(pool, map_iter->second, S3_ATTR_ETAG, bl) >= 0) {
+ if (rados->getxattr(pool, map_iter->second, RGW_ATTR_ETAG, bl) >= 0) {
strncpy(obj.etag, bl.c_str(), sizeof(obj.etag));
obj.etag[sizeof(obj.etag)-1] = '\0';
}
}
-int S3Rados::create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs)
+int RGWRados::create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs)
{
object_t bucket_oid(bucket.c_str());
return ret;
}
-int S3Rados::put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
+int RGWRados::put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
time_t *mtime,
map<nstring, bufferlist>& attrs)
{
return 0;
}
-int S3Rados::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
+int RGWRados::copy_obj(std::string& id, std::string& dest_bucket, std::string& dest_obj,
std::string& src_bucket, std::string& src_obj,
time_t *mtime,
const time_t *mod_ptr,
const char *if_match,
const char *if_nomatch,
map<nstring, bufferlist>& attrs, /* in/out */
- struct s3_err *err)
+ struct rgw_err *err)
{
/* FIXME! this should use a special rados->copy() method */
int ret;
}
-int S3Rados::delete_bucket(std::string& id, std::string& bucket)
+int RGWRados::delete_bucket(std::string& id, std::string& bucket)
{
/* TODO! */
#if 0
}
-int S3Rados::delete_obj(std::string& id, std::string& bucket, std::string& obj)
+int RGWRados::delete_obj(std::string& id, std::string& bucket, std::string& obj)
{
rados_pool_t pool;
return 0;
}
-int S3Rados::get_attr(std::string& bucket, std::string& obj,
+int RGWRados::get_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& dest)
{
rados_pool_t pool;
return 0;
}
-int S3Rados::set_attr(std::string& bucket, std::string& obj,
+int RGWRados::set_attr(std::string& bucket, std::string& obj,
const char *name, bufferlist& bl)
{
rados_pool_t pool;
return 0;
}
-int S3Rados::get_obj(std::string& bucket, std::string& obj,
+int RGWRados::get_obj(std::string& bucket, std::string& obj,
char **data, off_t ofs, off_t end,
map<nstring, bufferlist> *attrs,
const time_t *mod_ptr,
const char *if_match,
const char *if_nomatch,
bool get_data,
- struct s3_err *err)
+ struct rgw_err *err)
{
int r = -EINVAL;
size_t size, len;
}
}
if (if_match || if_nomatch) {
- r = get_attr(bucket, obj, S3_ATTR_ETAG, etag);
+ r = get_attr(bucket, obj, RGW_ATTR_ETAG, etag);
if (r < 0)
goto done;
-#ifndef __S3RADOS_H
-#define __S3RADOS_H
+#ifndef __RGWRADOS_H
+#define __RGWRADOS_H
#include "include/librados.h"
#include "rgw_access.h"
-class S3Rados : public S3Access
+class RGWRados : public RGWAccess
{
int open_root_pool(rados_pool_t *pool);
public:
int initialize(int argc, char *argv[]);
- int list_buckets_init(std::string& id, S3AccessHandle *handle);
- int list_buckets_next(std::string& id, S3ObjEnt& obj, S3AccessHandle *handle);
+ int list_buckets_init(std::string& id, RGWAccessHandle *handle);
+ int list_buckets_next(std::string& id, RGWObjEnt& obj, RGWAccessHandle *handle);
int list_objects(std::string& id, std::string& bucket, int max, std::string& prefix, std::string& delim,
- std::string& marker, std::vector<S3ObjEnt>& result, map<string, bool>& common_prefixes);
+ std::string& marker, std::vector<RGWObjEnt>& result, map<string, bool>& common_prefixes);
int create_bucket(std::string& id, std::string& bucket, map<nstring, bufferlist>& attrs);
int put_obj(std::string& id, std::string& bucket, std::string& obj, const char *data, size_t size,
const char *if_match,
const char *if_nomatch,
map<nstring, bufferlist>& attrs,
- struct s3_err *err);
+ struct rgw_err *err);
int delete_bucket(std::string& id, std::string& bucket);
int delete_obj(std::string& id, std::string& bucket, std::string& obj);
const char *if_match,
const char *if_nomatch,
bool get_data,
- struct s3_err *err);
+ struct rgw_err *err);
};
#endif
{ ERANGE, "416", "InvalidRange" },
{ 0, NULL }};
-void dump_errno(struct req_state *s, int err, struct s3_err *s3err)
+void dump_errno(struct req_state *s, int err, struct rgw_err *rgwerr)
{
const char *err_str;
- const char *code = (s3err ? s3err->code : NULL);
+ const char *code = (rgwerr ? rgwerr->code : NULL);
- if (!s3err || !s3err->num) {
+ if (!rgwerr || !rgwerr->num) {
err_str = "500";
if (err < 0)
i++;
}
} else {
- err_str = s3err->num;
+ err_str = rgwerr->num;
}
dump_status(s, err_str);
if (err) {
s->err_exist = true;
s->err.code = code;
- s->err.message = (s3err ? s3err->message : NULL);
+ s->err.message = (rgwerr ? rgwerr->message : NULL);
}
}
CGI_PRINTF(s->fcgx->out,"Content-type: %s\r\n\r\n", content_type);
if (s->err_exist) {
dump_start_xml(s);
- struct s3_err &err = s->err;
+ struct rgw_err &err = s->err;
open_section(s, "Error");
if (err.code)
dump_value(s, "Code", err.code);
close_section(s, "ListAllMyBucketsResult");
}
-void dump_bucket(struct req_state *s, S3ObjEnt& obj)
+void dump_bucket(struct req_state *s, RGWObjEnt& obj)
{
open_section(s, "Bucket");
dump_value(s, "Name", obj.name.c_str());
end_header(s);
}
-int S3GetObj_REST::get_params()
+int RGWGetObj_REST::get_params()
{
range_str = FCGX_GetParam("HTTP_RANGE", s->fcgx->envp);
if_mod = FCGX_GetParam("HTTP_IF_MODIFIED_SINCE", s->fcgx->envp);
return 0;
}
-int S3GetObj_REST::send_response()
+int RGWGetObj_REST::send_response()
{
const char *content_type = NULL;
dump_content_length(s, len);
}
if (!ret) {
- map<nstring, bufferlist>::iterator iter = attrs.find(S3_ATTR_ETAG);
+ map<nstring, bufferlist>::iterator iter = attrs.find(RGW_ATTR_ETAG);
if (iter != attrs.end()) {
bufferlist& bl = iter->second;
if (bl.length()) {
}
for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
const char *name = iter->first.c_str();
- if (strncmp(name, S3_ATTR_META_PREFIX, sizeof(S3_ATTR_META_PREFIX)-1) == 0) {
- name += sizeof(S3_ATTR_PREFIX) - 1;
+ if (strncmp(name, RGW_ATTR_META_PREFIX, sizeof(RGW_ATTR_META_PREFIX)-1) == 0) {
+ name += sizeof(RGW_ATTR_PREFIX) - 1;
CGI_PRINTF(s->fcgx->out,"%s: %s\r\n", name, iter->second.c_str());
- } else if (!content_type && strcmp(name, S3_ATTR_CONTENT_TYPE) == 0) {
+ } else if (!content_type && strcmp(name, RGW_ATTR_CONTENT_TYPE) == 0) {
content_type = iter->second.c_str();
}
}
return 0;
}
-void S3ListBuckets_REST::send_response()
+void RGWListBuckets_REST::send_response()
{
dump_errno(s, ret);
end_header(s, "application/xml");
list_all_buckets_start(s);
dump_owner(s, s->user.user_id, s->user.display_name);
- map<string, S3ObjEnt>& m = buckets.get_buckets();
- map<string, S3ObjEnt>::iterator iter;
+ map<string, RGWObjEnt>& m = buckets.get_buckets();
+ map<string, RGWObjEnt>::iterator iter;
open_section(s, "Buckets");
for (iter = m.begin(); iter != m.end(); ++iter) {
- S3ObjEnt obj = iter->second;
+ RGWObjEnt obj = iter->second;
dump_bucket(s, obj);
}
close_section(s, "Buckets");
list_all_buckets_end(s);
}
-void S3ListBucket_REST::send_response()
+void RGWListBucket_REST::send_response()
{
dump_errno(s, (ret < 0 ? ret : 0));
dump_value(s, "Delimiter", delimiter.c_str());
if (ret >= 0) {
- vector<S3ObjEnt>::iterator iter;
+ vector<RGWObjEnt>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
open_section(s, "Contents");
dump_value(s, "Key", iter->name.c_str());
close_section(s, "ListBucketResult");
}
-void S3CreateBucket_REST::send_response()
+void RGWCreateBucket_REST::send_response()
{
dump_errno(s, ret);
end_header(s);
}
-void S3DeleteBucket_REST::send_response()
+void RGWDeleteBucket_REST::send_response()
{
dump_errno(s, ret);
end_header(s);
}
-int S3PutObj_REST::get_params()
+int RGWPutObj_REST::get_params()
{
size_t cl = atoll(s->length);
if (cl) {
return 0;
}
-void S3PutObj_REST::send_response()
+void RGWPutObj_REST::send_response()
{
dump_errno(s, ret, &err);
end_header(s);
}
-void S3DeleteObj_REST::send_response()
+void RGWDeleteObj_REST::send_response()
{
dump_errno(s, ret);
end_header(s);
}
-int S3CopyObj_REST::get_params()
+int RGWCopyObj_REST::get_params()
{
if_mod = FCGX_GetParam("HTTP_X_AMZ_COPY_IF_MODIFIED_SINCE", s->fcgx->envp);
if_unmod = FCGX_GetParam("HTTP_X_AMZ_COPY_IF_UNMODIFIED_SINCE", s->fcgx->envp);
return 0;
}
-void S3CopyObj_REST::send_response()
+void RGWCopyObj_REST::send_response()
{
dump_errno(s, ret, &err);
if (ret == 0) {
open_section(s, "CopyObjectResult");
dump_time(s, "LastModified", &mtime);
- map<nstring, bufferlist>::iterator iter = attrs.find(S3_ATTR_ETAG);
+ map<nstring, bufferlist>::iterator iter = attrs.find(RGW_ATTR_ETAG);
if (iter != attrs.end()) {
bufferlist& bl = iter->second;
if (bl.length()) {
}
}
-void S3GetACLs_REST::send_response()
+void RGWGetACLs_REST::send_response()
{
end_header(s, "application/xml");
dump_start_xml(s);
FCGX_PutStr(acls.c_str(), acls.size(), s->fcgx->out);
}
-int S3PutACLs_REST::get_params()
+int RGWPutACLs_REST::get_params()
{
size_t cl = atoll(s->length);
if (cl) {
return ret;
}
-void S3PutACLs_REST::send_response()
+void RGWPutACLs_REST::send_response()
{
dump_errno(s, ret);
end_header(s, "application/xml");
}
}
-void S3Handler_REST::provider_init_state()
+void RGWHandler_REST::provider_init_state()
{
s->path_name = FCGX_GetParam("SCRIPT_NAME", s->fcgx->envp);
s->path_name_url = FCGX_GetParam("REQUEST_URI", s->fcgx->envp);
return s->args.exists("acl");
}
-S3Op *S3Handler_REST::get_retrieve_obj_op(struct req_state *s, bool get_data)
+RGWOp *RGWHandler_REST::get_retrieve_obj_op(struct req_state *s, bool get_data)
{
if (is_acl_op(s)) {
return &get_acls_op;
return &list_bucket_op;
}
-S3Op *S3Handler_REST::get_retrieve_op(struct req_state *s, bool get_data)
+RGWOp *RGWHandler_REST::get_retrieve_op(struct req_state *s, bool get_data)
{
if (s->bucket) {
if (is_acl_op(s)) {
return &list_buckets_op;
}
-S3Op *S3Handler_REST::get_create_op(struct req_state *s)
+RGWOp *RGWHandler_REST::get_create_op(struct req_state *s)
{
if (is_acl_op(s)) {
return &put_acls_op;
return NULL;
}
-S3Op *S3Handler_REST::get_delete_op(struct req_state *s)
+RGWOp *RGWHandler_REST::get_delete_op(struct req_state *s)
{
if (s->object)
return &delete_obj_op;
return NULL;
}
-S3Op *S3Handler_REST::get_op()
+RGWOp *RGWHandler_REST::get_op()
{
- S3Op *op;
+ RGWOp *op;
switch (s->op) {
case OP_GET:
op = get_retrieve_op(s, true);
return op;
}
-int S3Handler_REST::read_permissions()
+int RGWHandler_REST::read_permissions()
{
bool only_bucket;
-#ifndef __S3REST_H
-#define __S3REST_H
+#ifndef __RGWREST_H
+#define __RGWREST_H
#include "rgw_op.h"
-class S3GetObj_REST : public S3GetObj
+class RGWGetObj_REST : public RGWGetObj
{
public:
- S3GetObj_REST() {}
- ~S3GetObj_REST() {}
+ RGWGetObj_REST() {}
+ ~RGWGetObj_REST() {}
int get_params();
int send_response();
};
-class S3ListBuckets_REST : public S3ListBuckets {
+class RGWListBuckets_REST : public RGWListBuckets {
public:
- S3ListBuckets_REST() {}
- ~S3ListBuckets_REST() {}
+ RGWListBuckets_REST() {}
+ ~RGWListBuckets_REST() {}
void send_response();
};
-class S3ListBucket_REST : public S3ListBucket {
+class RGWListBucket_REST : public RGWListBucket {
public:
- S3ListBucket_REST() {}
- ~S3ListBucket_REST() {}
+ RGWListBucket_REST() {}
+ ~RGWListBucket_REST() {}
void send_response();
};
-class S3CreateBucket_REST : public S3CreateBucket {
+class RGWCreateBucket_REST : public RGWCreateBucket {
public:
- S3CreateBucket_REST() {}
- ~S3CreateBucket_REST() {}
+ RGWCreateBucket_REST() {}
+ ~RGWCreateBucket_REST() {}
void send_response();
};
-class S3DeleteBucket_REST : public S3DeleteBucket {
+class RGWDeleteBucket_REST : public RGWDeleteBucket {
public:
- S3DeleteBucket_REST() {}
- ~S3DeleteBucket_REST() {}
+ RGWDeleteBucket_REST() {}
+ ~RGWDeleteBucket_REST() {}
void send_response();
};
-class S3PutObj_REST : public S3PutObj
+class RGWPutObj_REST : public RGWPutObj
{
public:
- S3PutObj_REST() {}
- ~S3PutObj_REST() {}
+ RGWPutObj_REST() {}
+ ~RGWPutObj_REST() {}
int get_params();
void send_response();
};
-class S3DeleteObj_REST : public S3DeleteObj {
+class RGWDeleteObj_REST : public RGWDeleteObj {
public:
- S3DeleteObj_REST() {}
- ~S3DeleteObj_REST() {}
+ RGWDeleteObj_REST() {}
+ ~RGWDeleteObj_REST() {}
void send_response();
};
-class S3CopyObj_REST : public S3CopyObj {
+class RGWCopyObj_REST : public RGWCopyObj {
public:
- S3CopyObj_REST() {}
- ~S3CopyObj_REST() {}
+ RGWCopyObj_REST() {}
+ ~RGWCopyObj_REST() {}
int get_params();
void send_response();
};
-class S3GetACLs_REST : public S3GetACLs {
+class RGWGetACLs_REST : public RGWGetACLs {
public:
- S3GetACLs_REST() {}
- ~S3GetACLs_REST() {}
+ RGWGetACLs_REST() {}
+ ~RGWGetACLs_REST() {}
void send_response();
};
-class S3PutACLs_REST : public S3PutACLs {
+class RGWPutACLs_REST : public RGWPutACLs {
public:
- S3PutACLs_REST() {}
- ~S3PutACLs_REST() {}
+ RGWPutACLs_REST() {}
+ ~RGWPutACLs_REST() {}
int get_params();
void send_response();
};
-class S3Handler_REST : public S3Handler {
- S3GetObj_REST get_obj_op;
- S3ListBuckets_REST list_buckets_op;
- S3ListBucket_REST list_bucket_op;
- S3CreateBucket_REST create_bucket_op;
- S3DeleteBucket_REST delete_bucket_op;
- S3PutObj_REST put_obj_op;
- S3DeleteObj_REST delete_obj_op;
- S3CopyObj_REST copy_obj_op;
- S3GetACLs_REST get_acls_op;
- S3PutACLs_REST put_acls_op;
+class RGWHandler_REST : public RGWHandler {
+ RGWGetObj_REST get_obj_op;
+ RGWListBuckets_REST list_buckets_op;
+ RGWListBucket_REST list_bucket_op;
+ RGWCreateBucket_REST create_bucket_op;
+ RGWDeleteBucket_REST delete_bucket_op;
+ RGWPutObj_REST put_obj_op;
+ RGWDeleteObj_REST delete_obj_op;
+ RGWCopyObj_REST copy_obj_op;
+ RGWGetACLs_REST get_acls_op;
+ RGWPutACLs_REST put_acls_op;
- S3Op *get_retrieve_obj_op(struct req_state *s, bool get_data);
- S3Op *get_retrieve_op(struct req_state *s, bool get_data);
- S3Op *get_create_op(struct req_state *s);
- S3Op *get_delete_op(struct req_state *s);
+ 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);
protected:
void provider_init_state();
public:
- S3Handler_REST() : S3Handler() {}
- ~S3Handler_REST() {}
- S3Op *get_op();
+ RGWHandler_REST() : RGWHandler() {}
+ ~RGWHandler_REST() {}
+ RGWOp *get_op();
int read_permissions();
};
-extern void dump_errno(struct req_state *s, int err, struct s3_err *s3err = NULL);
+extern void dump_errno(struct req_state *s, int err, struct rgw_err *rgwerr = NULL);
extern void end_header(struct req_state *s, const char *content_type = NULL);
extern void dump_start_xml(struct req_state *s);
extern void list_all_buckets_start(struct req_state *s);
extern void dump_owner(struct req_state *s, string& id, string& name);
extern void open_section(struct req_state *s, const char *name);
extern void close_section(struct req_state *s, const char *name);
-extern void dump_bucket(struct req_state *s, S3ObjEnt& obj);
+extern void dump_bucket(struct req_state *s, RGWObjEnt& obj);
extern void abort_early(struct req_state *s, int err);
extern void list_all_buckets_end(struct req_state *s);
extern void dump_value(struct req_state *s, const char *name, const char *fmt, ...);
static string ui_bucket = USER_INFO_BUCKET_NAME;
static string ui_email_bucket = USER_INFO_EMAIL_BUCKET_NAME;
-int s3_get_user_info(string user_id, S3UserInfo& info)
+int rgw_get_user_info(string user_id, RGWUserInfo& info)
{
bufferlist bl;
int ret;
char *data;
- struct s3_err err;
+ struct rgw_err err;
- ret = s3store->get_obj(ui_bucket, user_id, &data, 0, -1, NULL, NULL, NULL, NULL, NULL, true, &err);
+ ret = rgwstore->get_obj(ui_bucket, user_id, &data, 0, -1, NULL, NULL, NULL, NULL, NULL, true, &err);
if (ret < 0) {
return ret;
}
return 0;
}
-void s3_get_anon_user(S3UserInfo& info)
+void rgw_get_anon_user(RGWUserInfo& info)
{
- info.user_id = S3_USER_ANON_ID;
+ info.user_id = RGW_USER_ANON_ID;
info.display_name.clear();
info.secret_key.clear();
}
-int s3_store_user_info(S3UserInfo& info)
+int rgw_store_user_info(RGWUserInfo& info)
{
bufferlist bl;
info.encode(bl);
int ret;
map<nstring,bufferlist> attrs;
- ret = s3store->put_obj(info.user_id, ui_bucket, info.user_id, data, bl.length(), NULL, attrs);
+ ret = rgwstore->put_obj(info.user_id, ui_bucket, info.user_id, data, bl.length(), NULL, attrs);
if (ret == -ENOENT) {
- ret = s3store->create_bucket(info.user_id, ui_bucket, attrs);
+ ret = rgwstore->create_bucket(info.user_id, ui_bucket, attrs);
if (ret >= 0)
- ret = s3store->put_obj(info.user_id, ui_bucket, info.user_id, data, bl.length(), NULL, attrs);
+ ret = rgwstore->put_obj(info.user_id, ui_bucket, info.user_id, data, bl.length(), NULL, attrs);
}
if (ret < 0)
if (!info.user_email.size())
return ret;
- S3UID ui;
+ RGWUID ui;
ui.user_id = info.user_id;
bufferlist uid_bl;
ui.encode(uid_bl);
- ret = s3store->put_obj(info.user_id, ui_email_bucket, info.user_email, uid_bl.c_str(), uid_bl.length(), NULL, attrs);
+ ret = rgwstore->put_obj(info.user_id, ui_email_bucket, info.user_email, uid_bl.c_str(), uid_bl.length(), NULL, attrs);
if (ret == -ENOENT) {
map<nstring, bufferlist> attrs;
- ret = s3store->create_bucket(info.user_id, ui_email_bucket, attrs);
+ ret = rgwstore->create_bucket(info.user_id, ui_email_bucket, attrs);
if (ret >= 0)
- ret = s3store->put_obj(info.user_id, ui_email_bucket, info.user_email, uid_bl.c_str(), uid_bl.length(), NULL, attrs);
+ ret = rgwstore->put_obj(info.user_id, ui_email_bucket, info.user_email, uid_bl.c_str(), uid_bl.length(), NULL, attrs);
}
return ret;
}
-int s3_get_uid_by_email(string& email, string& user_id)
+int rgw_get_uid_by_email(string& email, string& user_id)
{
bufferlist bl;
int ret;
char *data;
- struct s3_err err;
- S3UID uid;
+ struct rgw_err err;
+ RGWUID uid;
- ret = s3store->get_obj(ui_email_bucket, email, &data, 0, -1, NULL, NULL, NULL, NULL, NULL, true, &err);
+ ret = rgwstore->get_obj(ui_email_bucket, email, &data, 0, -1, NULL, NULL, NULL, NULL, NULL, true, &err);
if (ret < 0) {
return ret;
}
return 0;
}
-int s3_get_user_buckets(string user_id, S3UserBuckets& buckets)
+int rgw_get_user_buckets(string user_id, RGWUserBuckets& buckets)
{
bufferlist bl;
- int ret = s3store->get_attr(ui_bucket, user_id, S3_ATTR_BUCKETS, bl);
+ int ret = rgwstore->get_attr(ui_bucket, user_id, RGW_ATTR_BUCKETS, bl);
switch (ret) {
case 0:
break;
return 0;
}
-int s3_put_user_buckets(string user_id, S3UserBuckets& buckets)
+int rgw_put_user_buckets(string user_id, RGWUserBuckets& buckets)
{
bufferlist bl;
buckets.encode(bl);
- int ret = s3store->set_attr(ui_bucket, user_id, S3_ATTR_BUCKETS, bl);
+ int ret = rgwstore->set_attr(ui_bucket, user_id, RGW_ATTR_BUCKETS, bl);
return ret;
}
#define USER_INFO_BUCKET_NAME ".users"
#define USER_INFO_EMAIL_BUCKET_NAME ".users.email"
-#define S3_USER_ANON_ID "anonymous"
+#define RGW_USER_ANON_ID "anonymous"
-struct S3UID
+struct RGWUID
{
string user_id;
void encode(bufferlist& bl) const {
::decode(user_id, bl);
}
};
-WRITE_CLASS_ENCODER(S3UID)
+WRITE_CLASS_ENCODER(RGWUID)
-extern int s3_get_user_info(string user_id, S3UserInfo& info);
-extern void s3_get_anon_user(S3UserInfo& info);
-extern int s3_store_user_info(S3UserInfo& info);
-extern int s3_get_uid_by_email(string& email, string& user_id);
+extern int rgw_get_user_info(string user_id, RGWUserInfo& info);
+extern void rgw_get_anon_user(RGWUserInfo& info);
+extern int rgw_store_user_info(RGWUserInfo& info);
+extern int rgw_get_uid_by_email(string& email, string& user_id);
-class S3UserBuckets
+class RGWUserBuckets
{
- map<string, S3ObjEnt> buckets;
+ map<string, RGWObjEnt> buckets;
public:
- S3UserBuckets() {}
+ RGWUserBuckets() {}
void encode(bufferlist& bl) const {
::encode(buckets, bl);
}
}
bool owns(string& name) {
- map<string, S3ObjEnt>::iterator iter;
+ map<string, RGWObjEnt>::iterator iter;
iter = buckets.find(name);
return (iter != buckets.end());
}
- void add(S3ObjEnt& bucket) {
+ void add(RGWObjEnt& bucket) {
buckets[bucket.name] = bucket;
}
void remove(string& name) {
- map<string, S3ObjEnt>::iterator iter;
+ map<string, RGWObjEnt>::iterator iter;
iter = buckets.find(name);
if (iter != buckets.end()) {
buckets.erase(iter);
}
}
- map<string, S3ObjEnt>& get_buckets() { return buckets; }
+ map<string, RGWObjEnt>& get_buckets() { return buckets; }
};
-WRITE_CLASS_ENCODER(S3UserBuckets)
+WRITE_CLASS_ENCODER(RGWUserBuckets)
-extern int s3_get_user_buckets(string user_id, S3UserBuckets& buckets);
-extern int s3_put_user_buckets(string user_id, S3UserBuckets& buckets);
+extern int rgw_get_user_buckets(string user_id, RGWUserBuckets& buckets);
+extern int rgw_put_user_buckets(string user_id, RGWUserBuckets& buckets);
#endif
projects / ceph.git / commitdiff