auth: Use unqualified encode/decode

This is a portion of the namespace project.

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/auth/Auth.h b/src/auth/Auth.h
index c5bda0ccaf49f11b763842870afc37898ccb0923..71dd5434ecb69b61ed93968820e3808310cf11e0 100644 (file)
--- a/src/auth/Auth.h
+++ b/src/auth/Auth.h
@@ -29,19 +29,21 @@ struct EntityAuth {
 
   void encode(bufferlist& bl) const {
     __u8 struct_v = 2;
-    ::encode(struct_v, bl);
-    ::encode(auid, bl);
-    ::encode(key, bl);
-    ::encode(caps, bl);
+    using ceph::encode;
+    encode(struct_v, bl);
+    encode(auid, bl);
+    encode(key, bl);
+    encode(caps, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
+    decode(struct_v, bl);
     if (struct_v >= 2)
-      ::decode(auid, bl);
+      decode(auid, bl);
     else auid = CEPH_AUTH_UID_DEFAULT;
-    ::decode(key, bl);
-    ::decode(caps, bl);
+    decode(key, bl);
+    decode(caps, bl);
   }
 };
 WRITE_CLASS_ENCODER(EntityAuth)
@@ -57,19 +59,21 @@ struct AuthCapsInfo {
   AuthCapsInfo() : allow_all(false) {}
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
+    encode(struct_v, bl);
     __u8 a = (__u8)allow_all;
-    ::encode(a, bl);
-    ::encode(caps, bl);
+    encode(a, bl);
+    encode(caps, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
+    decode(struct_v, bl);
     __u8 a;
-    ::decode(a, bl);
+    decode(a, bl);
     allow_all = (bool)a;
-    ::decode(caps, bl);
+    decode(caps, bl);
   }
 };
 WRITE_CLASS_ENCODER(AuthCapsInfo)
@@ -98,28 +102,30 @@ struct AuthTicket {
   }
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 2;
-    ::encode(struct_v, bl);
-    ::encode(name, bl);
-    ::encode(global_id, bl);
-    ::encode(auid, bl);
-    ::encode(created, bl);
-    ::encode(expires, bl);
-    ::encode(caps, bl);
-    ::encode(flags, bl);
+    encode(struct_v, bl);
+    encode(name, bl);
+    encode(global_id, bl);
+    encode(auid, bl);
+    encode(created, bl);
+    encode(expires, bl);
+    encode(caps, bl);
+    encode(flags, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(name, bl);
-    ::decode(global_id, bl);
+    decode(struct_v, bl);
+    decode(name, bl);
+    decode(global_id, bl);
     if (struct_v >= 2)
-      ::decode(auid, bl);
+      decode(auid, bl);
     else auid = CEPH_AUTH_UID_DEFAULT;
-    ::decode(created, bl);
-    ::decode(expires, bl);
-    ::decode(caps, bl);
-    ::decode(flags, bl);
+    decode(created, bl);
+    decode(expires, bl);
+    decode(caps, bl);
+    decode(flags, bl);
   }
 };
 WRITE_CLASS_ENCODER(AuthTicket)
@@ -149,16 +155,18 @@ struct ExpiringCryptoKey {
   utime_t expiration;
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(key, bl);
-    ::encode(expiration, bl);
+    encode(struct_v, bl);
+    encode(key, bl);
+    encode(expiration, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(key, bl);
-    ::decode(expiration, bl);
+    decode(struct_v, bl);
+    decode(key, bl);
+    decode(expiration, bl);
   }
 };
 WRITE_CLASS_ENCODER(ExpiringCryptoKey)
@@ -175,16 +183,18 @@ struct RotatingSecrets {
   RotatingSecrets() : max_ver(0) {}
   
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(secrets, bl);
-    ::encode(max_ver, bl);
+    encode(struct_v, bl);
+    encode(secrets, bl);
+    encode(max_ver, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(secrets, bl);
-    ::decode(max_ver, bl);
+    decode(struct_v, bl);
+    decode(secrets, bl);
+    decode(max_ver, bl);
   }
   
   uint64_t add(ExpiringCryptoKey& key) {
@@ -235,7 +245,7 @@ public:
                                  CryptoKey& secret) const = 0;
 };
 
-static inline bool auth_principal_needs_rotating_keys(EntityName& name)
+inline bool auth_principal_needs_rotating_keys(EntityName& name)
 {
   uint32_t ty(name.get_type());
   return ((ty == CEPH_ENTITY_TYPE_OSD)

diff --git a/src/auth/Crypto.cc b/src/auth/Crypto.cc
index 228a99b34c2b811d048d3b26c49ca6d4f61a928d..48f19689d61e3bdb65650c075f3f50c64c1e6c8e 100644 (file)
--- a/src/auth/Crypto.cc
+++ b/src/auth/Crypto.cc
@@ -387,19 +387,21 @@ CryptoKeyHandler *CryptoAES::get_key_handler(const bufferptr& secret,
 
 void CryptoKey::encode(bufferlist& bl) const
 {
-  ::encode(type, bl);
-  ::encode(created, bl);
+  using ceph::encode;
+  encode(type, bl);
+  encode(created, bl);
   __u16 len = secret.length();
-  ::encode(len, bl);
+  encode(len, bl);
   bl.append(secret);
 }
 
 void CryptoKey::decode(bufferlist::iterator& bl)
 {
-  ::decode(type, bl);
-  ::decode(created, bl);
+  using ceph::decode;
+  decode(type, bl);
+  decode(created, bl);
   __u16 len;
-  ::decode(len, bl);
+  decode(len, bl);
   bufferptr tmp;
   bl.copy_deep(len, tmp);
   if (_set_secret(type, tmp) < 0)

diff --git a/src/auth/KeyRing.cc b/src/auth/KeyRing.cc
index 06d5a291a1496aec19a0ff51bc9238eea9006e8b..b8f5de5c3ea474bf8ed106059fa3828a8027b537 100644 (file)
--- a/src/auth/KeyRing.cc
+++ b/src/auth/KeyRing.cc
@@ -106,7 +106,7 @@ int KeyRing::set_modifier(const char *type, const char *val, EntityName& name, m
       return -EINVAL;
     string l(val);
     bufferlist bl;
-    ::encode(l, bl);
+    encode(l, bl);
     caps[caps_entity] = bl;
     set_caps(name, caps);
   } else if (strcmp(type, "auid") == 0) {
@@ -143,11 +143,12 @@ void KeyRing::encode_formatted(string label, Formatter *f, bufferlist& bl)
       f->dump_int("auid", p->second.auid);
     f->open_object_section("caps");
     for (map<string, bufferlist>::iterator q = p->second.caps.begin();
-        q != p->second.caps.end();
+        q != p->second.caps.end();
         ++q) {
       bufferlist::iterator dataiter = q->second.begin();
       string caps;
-      ::decode(caps, dataiter);
+      using ceph::decode;
+      decode(caps, dataiter);
       f->dump_string(q->first.c_str(), caps);
     }
     f->close_section();        /* caps */
@@ -204,8 +205,9 @@ void KeyRing::decode(bufferlist::iterator& bl) {
   __u8 struct_v;
   bufferlist::iterator start_pos = bl;
   try {
-    ::decode(struct_v, bl);
-    ::decode(keys, bl);
+    using ceph::decode;
+    decode(struct_v, bl);
+    decode(keys, bl);
   } catch (buffer::error& err) {
     keys.clear();
     decode_plaintext(start_pos);
@@ -253,7 +255,8 @@ void KeyRing::print(ostream& out)
         ++q) {
       bufferlist::iterator dataiter = q->second.begin();
       string caps;
-      ::decode(caps, dataiter);
+      using ceph::decode;
+      decode(caps, dataiter);
       out << "\tcaps " << q->first << " = \"" << caps << '"' << std::endl;
     }
   }

diff --git a/src/auth/cephx/CephxClientHandler.cc b/src/auth/cephx/CephxClientHandler.cc
index 327ca878b31592308d81c91f7bd720e27819b6ed..1eb9303a2a73d6a1369900cd5f22e464b96a45a0 100644 (file)
--- a/src/auth/cephx/CephxClientHandler.cc
+++ b/src/auth/cephx/CephxClientHandler.cc
@@ -38,7 +38,7 @@ int CephxClientHandler::build_request(bufferlist& bl) const
     /* authenticate */
     CephXRequestHeader header;
     header.request_type = CEPHX_GET_AUTH_SESSION_KEY;
-    ::encode(header, bl);
+    encode(header, bl);
 
     CryptoKey secret;
     const bool got = keyring->get_secret(cct->_conf->name, secret);
@@ -69,7 +69,7 @@ int CephxClientHandler::build_request(bufferlist& bl) const
       ldout(cct, 20) << "old ticket len=" << req.old_ticket.blob.length() << dendl;
     }
 
-    ::encode(req, bl);
+    encode(req, bl);
 
     ldout(cct, 10) << "get auth session key: client_challenge "
                   << hex << req.client_challenge << dendl;
@@ -82,7 +82,7 @@ int CephxClientHandler::build_request(bufferlist& bl) const
 
     CephXRequestHeader header;
     header.request_type = CEPHX_GET_PRINCIPAL_SESSION_KEY;
-    ::encode(header, bl);
+    encode(header, bl);
 
     CephXAuthorizer *authorizer = ticket_handler->build_authorizer(global_id);
     if (!authorizer)
@@ -92,7 +92,7 @@ int CephxClientHandler::build_request(bufferlist& bl) const
 
     CephXServiceTicketRequest req;
     req.keys = need;
-    ::encode(req, bl);
+    encode(req, bl);
   }
 
   return 0;
@@ -117,7 +117,7 @@ int CephxClientHandler::handle_response(int ret, bufferlist::iterator& indata)
 
   if (starting) {
     CephXServerChallenge ch;
-    ::decode(ch, indata);
+    decode(ch, indata);
     server_challenge = ch.server_challenge;
     ldout(cct, 10) << " got initial server challenge "
                   << hex << server_challenge << dendl;
@@ -128,7 +128,7 @@ int CephxClientHandler::handle_response(int ret, bufferlist::iterator& indata)
   }
 
   struct CephXResponseHeader header;
-  ::decode(header, indata);
+  decode(header, indata);
 
   switch (header.request_type) {
   case CEPHX_GET_AUTH_SESSION_KEY:
@@ -215,7 +215,7 @@ bool CephxClientHandler::build_rotating_request(bufferlist& bl) const
   ldout(cct, 10) << "build_rotating_request" << dendl;
   CephXRequestHeader header;
   header.request_type = CEPHX_GET_ROTATING_KEY;
-  ::encode(header, bl);
+  encode(header, bl);
   return true;
 }
 
@@ -249,4 +249,3 @@ bool CephxClientHandler::need_tickets()
 
   return _need_tickets();
 }
-

diff --git a/src/auth/cephx/CephxKeyServer.cc b/src/auth/cephx/CephxKeyServer.cc
index e99d78e759fe4863711157f2649b1a49d5635f60..492c99f913b09123fd222c0366861f026a05cdb5 100644 (file)
--- a/src/auth/cephx/CephxKeyServer.cc
+++ b/src/auth/cephx/CephxKeyServer.cc
@@ -329,7 +329,8 @@ int KeyServer::encode_secrets(Formatter *f, stringstream *ds) const
       bufferlist *bl = const_cast<bufferlist*>(&capsiter->second);
       bufferlist::iterator dataiter = bl->begin();
       string caps;
-      ::decode(caps, dataiter);
+      using ceph::decode;
+      decode(caps, dataiter);
       if (ds)
         *ds << "\tcaps: [" << capsiter->first << "] " << caps << std::endl;
       if (f)

diff --git a/src/auth/cephx/CephxKeyServer.h b/src/auth/cephx/CephxKeyServer.h
index ff91e96d5825a762388e1f6d4dd0b01c263e32e9..896e6e770eaeb809f3b5aede4f5c714262f5cf8d 100644 (file)
--- a/src/auth/cephx/CephxKeyServer.h
+++ b/src/auth/cephx/CephxKeyServer.h
@@ -40,33 +40,37 @@ struct KeyServerData {
 
   void encode(bufferlist& bl) const {
      __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(version, bl);
-    ::encode(rotating_ver, bl);
-    ::encode(secrets, bl);
-    ::encode(rotating_secrets, bl);
+    using ceph::encode;
+    encode(struct_v, bl);
+    encode(version, bl);
+    encode(rotating_ver, bl);
+    encode(secrets, bl);
+    encode(rotating_secrets, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(version, bl);
-    ::decode(rotating_ver, bl);
-    ::decode(secrets, bl);
-    ::decode(rotating_secrets, bl);
+    decode(struct_v, bl);
+    decode(version, bl);
+    decode(rotating_ver, bl);
+    decode(secrets, bl);
+    decode(rotating_secrets, bl);
   }
 
   void encode_rotating(bufferlist& bl) const {
+    using ceph::encode;
      __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(rotating_ver, bl);
-    ::encode(rotating_secrets, bl);
+    encode(struct_v, bl);
+    encode(rotating_ver, bl);
+    encode(rotating_secrets, bl);
   }
   void decode_rotating(bufferlist& rotating_bl) {
+    using ceph::decode;
     bufferlist::iterator iter = rotating_bl.begin();
     __u8 struct_v;
-    ::decode(struct_v, iter);
-    ::decode(rotating_ver, iter);
-    ::decode(rotating_secrets, iter);
+    decode(struct_v, iter);
+    decode(rotating_ver, iter);
+    decode(rotating_secrets, iter);
   }
 
   bool contains(const EntityName& name) const {
@@ -128,29 +132,31 @@ struct KeyServerData {
     EntityAuth auth;
     
     void encode(bufferlist& bl) const {
+      using ceph::encode;
       __u8 struct_v = 1;
-      ::encode(struct_v, bl);
+      encode(struct_v, bl);
      __u32 _op = (__u32)op;
-      ::encode(_op, bl);
+      encode(_op, bl);
       if (op == AUTH_INC_SET_ROTATING) {
-       ::encode(rotating_bl, bl);
+       encode(rotating_bl, bl);
       } else {
-       ::encode(name, bl);
-       ::encode(auth, bl);
+       encode(name, bl);
+       encode(auth, bl);
       }
     }
     void decode(bufferlist::iterator& bl) {
+      using ceph::decode;
       __u8 struct_v;
-      ::decode(struct_v, bl);
+      decode(struct_v, bl);
       __u32 _op;
-      ::decode(_op, bl);
+      decode(_op, bl);
       op = (IncrementalOp)_op;
       assert(op >= AUTH_INC_NOP && op <= AUTH_INC_SET_ROTATING);
       if (op == AUTH_INC_SET_ROTATING) {
-       ::decode(rotating_bl, bl);
+       decode(rotating_bl, bl);
       } else {
-       ::decode(name, bl);
-       ::decode(auth, bl);
+       decode(name, bl);
+       decode(auth, bl);
       }
     }
   };
@@ -222,11 +228,13 @@ public:
   bool generate_secret(EntityName& name, CryptoKey& secret);
 
   void encode(bufferlist& bl) const {
-    ::encode(data, bl);
+    using ceph::encode;
+    encode(data, bl);
   }
   void decode(bufferlist::iterator& bl) {
     Mutex::Locker l(lock);
-    ::decode(data, bl);
+    using ceph::decode;
+    decode(data, bl);
   }
   bool contains(const EntityName& name) const;
   int encode_secrets(Formatter *f, stringstream *ds) const;

diff --git a/src/auth/cephx/CephxProtocol.cc b/src/auth/cephx/CephxProtocol.cc
index 5836a33bd531e7a31e662d6d93a5098150a4625b..765d48f846c95cbe76f06234a3fedebcbfd756d0 100644 (file)
--- a/src/auth/cephx/CephxProtocol.cc
+++ b/src/auth/cephx/CephxProtocol.cc
@@ -88,10 +88,10 @@ bool cephx_build_service_ticket_reply(CephContext *cct,
                      bufferlist& reply)
 {
   __u8 service_ticket_reply_v = 1;
-  ::encode(service_ticket_reply_v, reply);
+  encode(service_ticket_reply_v, reply);
 
   uint32_t num = ticket_info_vec.size();
-  ::encode(num, reply);
+  encode(num, reply);
   ldout(cct, 10) << "build_service_ticket_reply encoding " << num
           << " tickets with secret " << principal_secret << dendl;
 
@@ -99,10 +99,10 @@ bool cephx_build_service_ticket_reply(CephContext *cct,
        ticket_iter != ticket_info_vec.end();
        ++ticket_iter) {
     CephXSessionAuthInfo& info = *ticket_iter;
-    ::encode(info.service_id, reply);
+    encode(info.service_id, reply);
 
     __u8 service_ticket_v = 1;
-    ::encode(service_ticket_v, reply);
+    encode(service_ticket_v, reply);
 
     CephXServiceTicket msg_a;
     msg_a.session_key = info.session_key;
@@ -118,20 +118,20 @@ bool cephx_build_service_ticket_reply(CephContext *cct,
     if (!cephx_build_service_ticket_blob(cct, info, blob)) {
       return false;
     }
-    ::encode(blob, service_ticket_bl);
+    encode(blob, service_ticket_bl);
 
     ldout(cct, 30) << "service_ticket_blob is ";
     service_ticket_bl.hexdump(*_dout);
     *_dout << dendl;
 
-    ::encode((__u8)should_encrypt_ticket, reply);
+    encode((__u8)should_encrypt_ticket, reply);
     if (should_encrypt_ticket) {
       if (encode_encrypt(cct, service_ticket_bl, ticket_enc_key, reply, error)) {
        ldout(cct, -1) << "error encoding encrypted ticket: " << error << dendl;
         return false;
       }
     } else {
-      ::encode(service_ticket_bl, reply);
+      encode(service_ticket_bl, reply);
     }
   }
   return true;
@@ -145,7 +145,7 @@ bool CephXTicketHandler::verify_service_ticket_reply(CryptoKey& secret,
                                                     bufferlist::iterator& indata)
 {
   __u8 service_ticket_v;
-  ::decode(service_ticket_v, indata);
+  decode(service_ticket_v, indata);
 
   CephXServiceTicket msg_a;
   std::string error;
@@ -155,7 +155,7 @@ bool CephXTicketHandler::verify_service_ticket_reply(CryptoKey& secret,
   }
   
   __u8 ticket_enc;
-  ::decode(ticket_enc, indata);
+  decode(ticket_enc, indata);
 
   bufferlist service_ticket_bl;
   if (ticket_enc) {
@@ -167,10 +167,10 @@ bool CephXTicketHandler::verify_service_ticket_reply(CryptoKey& secret,
       return false;
     }
   } else {
-    ::decode(service_ticket_bl, indata);
+    decode(service_ticket_bl, indata);
   }
   bufferlist::iterator iter = service_ticket_bl.begin();
-  ::decode(ticket, iter);
+  decode(ticket, iter);
   ldout(cct, 10) << " ticket.secret_id=" <<  ticket.secret_id << dendl;
 
   ldout(cct, 10) << "verify_service_ticket_reply service " << ceph_entity_type_name(service_id)
@@ -264,15 +264,15 @@ bool CephXTicketManager::verify_service_ticket_reply(CryptoKey& secret,
                                                     bufferlist::iterator& indata)
 {
   __u8 service_ticket_reply_v;
-  ::decode(service_ticket_reply_v, indata);
+  decode(service_ticket_reply_v, indata);
 
   uint32_t num;
-  ::decode(num, indata);
+  decode(num, indata);
   ldout(cct, 10) << "verify_service_ticket_reply got " << num << " keys" << dendl;
 
   for (int i=0; i<(int)num; i++) {
     uint32_t type;
-    ::decode(type, indata);
+    decode(type, indata);
     ldout(cct, 10) << "got key for service_id " << ceph_entity_type_name(type) << dendl;
     CephXTicketHandler& handler = get_handler(type);
     if (!handler.verify_service_ticket_reply(secret, indata)) {
@@ -299,11 +299,11 @@ CephXAuthorizer *CephXTicketHandler::build_authorizer(uint64_t global_id) const
   a->nonce = ((uint64_t)rand() << 32) + rand();
 
   __u8 authorizer_v = 1;
-  ::encode(authorizer_v, a->bl);
-  ::encode(global_id, a->bl);
-  ::encode(service_id, a->bl);
+  encode(authorizer_v, a->bl);
+  encode(global_id, a->bl);
+  encode(service_id, a->bl);
 
-  ::encode(ticket, a->bl);
+  encode(ticket, a->bl);
 
   CephXAuthorize msg;
   msg.nonce = a->nonce;
@@ -401,10 +401,10 @@ bool cephx_verify_authorizer(CephContext *cct, KeyStore *keys,
 
 
   try {
-    ::decode(authorizer_v, indata);
-    ::decode(global_id, indata);
-    ::decode(service_id, indata);
-    ::decode(ticket, indata);
+    decode(authorizer_v, indata);
+    decode(global_id, indata);
+    decode(service_id, indata);
+    decode(ticket, indata);
   } catch (buffer::end_of_buffer &e) {
     // Unable to decode!
     return false;

diff --git a/src/auth/cephx/CephxProtocol.h b/src/auth/cephx/CephxProtocol.h
index c82206989906155ba8400187ee87535dbc2ff627..7abc16d7628d0169d7d7032fe7d0aabcff8d22eb 100644 (file)
--- a/src/auth/cephx/CephxProtocol.h
+++ b/src/auth/cephx/CephxProtocol.h
@@ -98,14 +98,16 @@ struct CephXServerChallenge {
   uint64_t server_challenge;
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(server_challenge, bl);
+    encode(struct_v, bl);
+    encode(server_challenge, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(server_challenge, bl);
+    decode(struct_v, bl);
+    decode(server_challenge, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXServerChallenge)
@@ -117,10 +119,12 @@ struct CephXRequestHeader {
   __u16 request_type;
 
   void encode(bufferlist& bl) const {
-    ::encode(request_type, bl);
+    using ceph::encode;
+    encode(request_type, bl);
   }
   void decode(bufferlist::iterator& bl) {
-    ::decode(request_type, bl);
+    using ceph::decode;
+    decode(request_type, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXRequestHeader)
@@ -130,12 +134,14 @@ struct CephXResponseHeader {
   int32_t status;
 
   void encode(bufferlist& bl) const {
-    ::encode(request_type, bl);
-    ::encode(status, bl);
+    using ceph::encode;
+    encode(request_type, bl);
+    encode(status, bl);
   }
   void decode(bufferlist::iterator& bl) {
-    ::decode(request_type, bl);
-    ::decode(status, bl);
+    using ceph::decode;
+    decode(request_type, bl);
+    decode(status, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXResponseHeader)
@@ -147,17 +153,19 @@ struct CephXTicketBlob {
   CephXTicketBlob() : secret_id(0) {}
 
   void encode(bufferlist& bl) const {
+     using ceph::encode;
      __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(secret_id, bl);
-    ::encode(blob, bl);
+     encode(struct_v, bl);
+     encode(secret_id, bl);
+     encode(blob, bl);
   }
 
   void decode(bufferlist::iterator& bl) {
-    __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(secret_id, bl);
-    ::decode(blob, bl);
+     using ceph::decode;
+     __u8 struct_v;
+     decode(struct_v, bl);
+     decode(secret_id, bl);
+     decode(blob, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXTicketBlob)
@@ -169,18 +177,20 @@ struct CephXAuthenticate {
   CephXTicketBlob old_ticket;
 
   void encode(bufferlist& bl) const {
-    __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(client_challenge, bl);
-    ::encode(key, bl);
-    ::encode(old_ticket, bl);
+     using ceph::encode;
+     __u8 struct_v = 1;
+     encode(struct_v, bl);
+     encode(client_challenge, bl);
+     encode(key, bl);
+     encode(old_ticket, bl);
   }
   void decode(bufferlist::iterator& bl) {
-    __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(client_challenge, bl);
-    ::decode(key, bl);
-    ::decode(old_ticket, bl);
+     using ceph::decode;
+     __u8 struct_v;
+     decode(struct_v, bl);
+     decode(client_challenge, bl);
+     decode(key, bl);
+     decode(old_ticket, bl);
  }
 };
 WRITE_CLASS_ENCODER(CephXAuthenticate)
@@ -189,12 +199,14 @@ struct CephXChallengeBlob {
   uint64_t server_challenge, client_challenge;
   
   void encode(bufferlist& bl) const {
-    ::encode(server_challenge, bl);
-    ::encode(client_challenge, bl);
+     using ceph::encode;
+    encode(server_challenge, bl);
+    encode(client_challenge, bl);
   }
   void decode(bufferlist::iterator& bl) {
-    ::decode(server_challenge, bl);
-    ::decode(client_challenge, bl);
+    using ceph::decode;
+    decode(server_challenge, bl);
+    decode(client_challenge, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXChallengeBlob)
@@ -235,14 +247,16 @@ struct CephXServiceTicketRequest {
   uint32_t keys;
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(keys, bl);
+    encode(struct_v, bl);
+    encode(keys, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(keys, bl);
+    decode(struct_v, bl);
+    decode(keys, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicketRequest)
@@ -255,14 +269,16 @@ WRITE_CLASS_ENCODER(CephXServiceTicketRequest)
 struct CephXAuthorizeReply {
   uint64_t nonce_plus_one;
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(nonce_plus_one, bl);
+    encode(struct_v, bl);
+    encode(nonce_plus_one, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(nonce_plus_one, bl);
+    decode(struct_v, bl);
+    decode(nonce_plus_one, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXAuthorizeReply)
@@ -350,16 +366,18 @@ struct CephXServiceTicket {
   utime_t validity;
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(session_key, bl);
-    ::encode(validity, bl);
+    encode(struct_v, bl);
+    encode(session_key, bl);
+    encode(validity, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(session_key, bl);
-    ::decode(validity, bl);
+    decode(struct_v, bl);
+    decode(session_key, bl);
+    decode(validity, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicket)
@@ -370,16 +388,18 @@ struct CephXServiceTicketInfo {
   CryptoKey session_key;
 
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(ticket, bl);
-    ::encode(session_key, bl);
+    encode(struct_v, bl);
+    encode(ticket, bl);
+    encode(session_key, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(ticket, bl);
-    ::decode(session_key, bl);
+    decode(struct_v, bl);
+    decode(ticket, bl);
+    decode(session_key, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicketInfo)
@@ -387,14 +407,16 @@ WRITE_CLASS_ENCODER(CephXServiceTicketInfo)
 struct CephXAuthorize {
   uint64_t nonce;
   void encode(bufferlist& bl) const {
+    using ceph::encode;
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(nonce, bl);
+    encode(struct_v, bl);
+    encode(nonce, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     __u8 struct_v;
-    ::decode(struct_v, bl);
-    ::decode(nonce, bl);
+    decode(struct_v, bl);
+    decode(nonce, bl);
   }
 };
 WRITE_CLASS_ENCODER(CephXAuthorize)
@@ -435,8 +457,8 @@ void decode_decrypt_enc_bl(CephContext *cct, T& t, CryptoKey key, bufferlist& bl
 
   bufferlist::iterator iter2 = bl.begin();
   __u8 struct_v;
-  ::decode(struct_v, iter2);
-  ::decode(magic, iter2);
+  decode(struct_v, iter2);
+  decode(magic, iter2);
   if (magic != AUTH_ENC_MAGIC) {
     ostringstream oss;
     oss << "bad magic in decode_decrypt, " << magic << " != " << AUTH_ENC_MAGIC;
@@ -444,7 +466,7 @@ void decode_decrypt_enc_bl(CephContext *cct, T& t, CryptoKey key, bufferlist& bl
     return;
   }
 
-  ::decode(t, iter2);
+  decode(t, iter2);
 }
 
 template <typename T>
@@ -453,10 +475,10 @@ void encode_encrypt_enc_bl(CephContext *cct, const T& t, const CryptoKey& key,
 {
   bufferlist bl;
   __u8 struct_v = 1;
-  ::encode(struct_v, bl);
+  encode(struct_v, bl);
   uint64_t magic = AUTH_ENC_MAGIC;
-  ::encode(magic, bl);
-  ::encode(t, bl);
+  encode(magic, bl);
+  encode(t, bl);
 
   key.encrypt(cct, bl, out, &error);
 }
@@ -467,7 +489,7 @@ int decode_decrypt(CephContext *cct, T& t, const CryptoKey& key,
 {
   bufferlist bl_enc;
   try {
-    ::decode(bl_enc, iter);
+    decode(bl_enc, iter);
     decode_decrypt_enc_bl(cct, t, key, bl_enc, error);
   }
   catch (buffer::error &e) {
@@ -487,9 +509,8 @@ int encode_encrypt(CephContext *cct, const T& t, const CryptoKey& key,
   if (!error.empty()){
     return CEPHX_CRYPT_ERR;
   }
-  ::encode(bl_enc, out);
+  encode(bl_enc, out);
   return 0;
 }
 
-
 #endif

diff --git a/src/auth/cephx/CephxServiceHandler.cc b/src/auth/cephx/CephxServiceHandler.cc
index 2fefe1de933bf8a495fd4c786ec71399deec6c97..2e749796b48aaa46b18711e24432bda6f9324efc 100644 (file)
--- a/src/auth/cephx/CephxServiceHandler.cc
+++ b/src/auth/cephx/CephxServiceHandler.cc
@@ -38,7 +38,7 @@ int CephxServiceHandler::start_session(EntityName& name, bufferlist::iterator& i
 
   CephXServerChallenge ch;
   ch.server_challenge = server_challenge;
-  ::encode(ch, result_bl);
+  encode(ch, result_bl);
   return CEPH_AUTH_CEPHX;
 }
 
@@ -47,7 +47,7 @@ int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist
   int ret = 0;
 
   struct CephXRequestHeader cephx_header;
-  ::decode(cephx_header, indata);
+  decode(cephx_header, indata);
 
 
   switch (cephx_header.request_type) {
@@ -56,7 +56,7 @@ int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist
       ldout(cct, 10) << "handle_request get_auth_session_key for " << entity_name << dendl;
 
       CephXAuthenticate req;
-      ::decode(req, indata);
+      decode(req, indata);
 
       CryptoKey secret;
       if (!key_server->get_secret(entity_name, secret)) {
@@ -159,7 +159,7 @@ int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist
       }
 
       CephXServiceTicketRequest ticket_req;
-      ::decode(ticket_req, indata);
+      decode(ticket_req, indata);
       ldout(cct, 10) << " ticket_req.keys = " << ticket_req.keys << dendl;
 
       ret = 0;
@@ -219,5 +219,5 @@ void CephxServiceHandler::build_cephx_response_header(int request_type, int stat
   struct CephXResponseHeader header;
   header.request_type = request_type;
   header.status = status;
-  ::encode(header, bl);
+  encode(header, bl);
 }

diff --git a/src/auth/cephx/CephxSessionHandler.cc b/src/auth/cephx/CephxSessionHandler.cc
index 5694a22c0766eac87103ce0b157391b70578f5a2..00b11338df5d2a8240f6ba4aaaaac402554990e7 100644 (file)
--- a/src/auth/cephx/CephxSessionHandler.cc
+++ b/src/auth/cephx/CephxSessionHandler.cc
@@ -55,7 +55,7 @@ int CephxSessionHandler::_calc_signature(Message *m, uint64_t *psig)
   }
 
   bufferlist::iterator ci = bl_ciphertext.begin();
-  ::decode(*psig, ci);
+  decode(*psig, ci);
 
   ldout(cct, 10) << __func__ << " seq " << m->get_seq()
                 << " front_crc_ = " << footer.front_crc

diff --git a/src/auth/none/AuthNoneAuthorizeHandler.cc b/src/auth/none/AuthNoneAuthorizeHandler.cc
index 8b55e9e9ba8b44eed8101fcde13635fb3ea00407..929bf165c15151f3fa5181bd2e73b065995e2dee 100644 (file)
--- a/src/auth/none/AuthNoneAuthorizeHandler.cc
+++ b/src/auth/none/AuthNoneAuthorizeHandler.cc
@@ -26,9 +26,9 @@ uint64_t *auid)
 
   try {
     __u8 struct_v = 1;
-    ::decode(struct_v, iter);
-    ::decode(entity_name, iter);
-    ::decode(global_id, iter);
+    decode(struct_v, iter);
+    decode(entity_name, iter);
+    decode(global_id, iter);
   } catch (const buffer::error &err) {
     ldout(cct, 0) << "AuthNoneAuthorizeHandle::verify_authorizer() failed to decode" << dendl;
     return false;

diff --git a/src/auth/none/AuthNoneProtocol.h b/src/auth/none/AuthNoneProtocol.h
index 8683c567416e7af4db397af4c765ea83cf3e7fe5..a507ef75afda1b56b48712c5b335743614e44f3b 100644 (file)
--- a/src/auth/none/AuthNoneProtocol.h
+++ b/src/auth/none/AuthNoneProtocol.h
@@ -21,9 +21,9 @@ struct AuthNoneAuthorizer : public AuthAuthorizer {
   AuthNoneAuthorizer() : AuthAuthorizer(CEPH_AUTH_NONE) { }
   bool build_authorizer(const EntityName &ename, uint64_t global_id) {
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(ename, bl);
-    ::encode(global_id, bl);
+    encode(struct_v, bl);
+    encode(ename, bl);
+    encode(global_id, bl);
     return 0;
   }
   bool verify_reply(bufferlist::iterator& reply) override { return true; }

diff --git a/src/auth/unknown/AuthUnknownProtocol.h b/src/auth/unknown/AuthUnknownProtocol.h
index 6781ef62f95e68eca77bab66fb261ce5b8f45ba4..bba48d35431ee25f23564ab089957e3b79991e0f 100644 (file)
--- a/src/auth/unknown/AuthUnknownProtocol.h
+++ b/src/auth/unknown/AuthUnknownProtocol.h
@@ -21,9 +21,9 @@ struct AuthUnknownAuthorizer : public AuthAuthorizer {
   AuthUnknownAuthorizer() : AuthAuthorizer(CEPH_AUTH_UNKNOWN) { }
   bool build_authorizer(const EntityName &ename, uint64_t global_id) {
     __u8 struct_v = 1;
-    ::encode(struct_v, bl);
-    ::encode(ename, bl);
-    ::encode(global_id, bl);
+    encode(struct_v, bl);
+    encode(ename, bl);
+    encode(global_id, bl);
     return 0;
   }
   bool verify_reply(bufferlist::iterator& reply) { return true; }