#include "squid.h"
#include "acl/Gadgets.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "Debug.h"
#include "event.h"
#include "SquidConfig.h"
namespace Auth {
-CBDATA_CLASS_INIT(UserNameCache);
+CBDATA_CLASS_INIT(CredentialsCache);
-UserNameCache::UserNameCache(const char *name) :
- cachename(name), cacheCleanupEventName("User cache cleanup: ")
+CredentialsCache::CredentialsCache(const char *name) :
+ cachename(name),
+ cacheCleanupEventName("User cache cleanup: ")
{
debugs(29, 5, "initializing " << name << " username cache");
cacheCleanupEventName.append(name);
- eventAdd(cacheCleanupEventName.c_str(), &UserNameCache::Cleanup,
+ eventAdd(cacheCleanupEventName.c_str(), &CredentialsCache::Cleanup,
this, ::Config.authenticateGCInterval, 1);
RegisterRunner(this);
}
Auth::User::Pointer
-UserNameCache::lookup(const SBuf &userKey) const
+CredentialsCache::lookup(const SBuf &userKey) const
{
debugs(29, 6, "lookup for " << userKey);
auto p = store_.find(userKey);
}
void
-UserNameCache::Cleanup(void *data)
+CredentialsCache::Cleanup(void *data)
{
debugs(29, 5, "checkpoint");
// data is this in disguise
- UserNameCache *self = static_cast<UserNameCache *>(data);
+ CredentialsCache *self = static_cast<CredentialsCache *>(data);
self->cleanup();
}
void
-UserNameCache::cleanup()
+CredentialsCache::cleanup()
{
// cache entries with expiretime <= expirationTime are to be evicted
const time_t expirationTime = current_time.tv_sec - ::Config.authenticateTTL;
++i;
}
}
- eventAdd(cacheCleanupEventName.c_str(), &UserNameCache::Cleanup,
+ eventAdd(cacheCleanupEventName.c_str(), &CredentialsCache::Cleanup,
this, ::Config.authenticateGCInterval, 1);
}
void
-UserNameCache::insert(Auth::User::Pointer anAuth_user)
+CredentialsCache::insert(Auth::User::Pointer anAuth_user)
{
debugs(29, 6, "adding " << anAuth_user->userKey());
store_[anAuth_user->userKey()] = anAuth_user;
}
// generates the list of cached usernames in a format that is convenient
-// to merge with equivalent lists obtained from other UserNameCaches.
+// to merge with equivalent lists obtained from other CredentialsCaches.
std::vector<Auth::User::Pointer>
-UserNameCache::sortedUsersList() const
+CredentialsCache::sortedUsersList() const
{
std::vector<Auth::User::Pointer> rv(size(), nullptr);
std::transform(store_.begin(), store_.end(), rv.begin(),
}
void
-UserNameCache::endingShutdown()
+CredentialsCache::endingShutdown()
{
debugs(29, 5, "Shutting down username cache " << cachename);
- eventDelete(&UserNameCache::Cleanup, this);
+ eventDelete(&CredentialsCache::Cleanup, this);
reset();
}
void
-UserNameCache::syncConfig()
+CredentialsCache::syncConfig()
{
debugs(29, 5, "Reconfiguring username cache " << cachename);
for (auto i : store_) {
* Please see the COPYING and CONTRIBUTORS files for details.
*/
-#ifndef SQUID_SRC_AUTH_UERNAMECACHE_H
-#define SQUID_SRC_AUTH_UERNAMECACHE_H
+#ifndef SQUID_SRC_AUTH_CREDENTIALSCACHE_H
+#define SQUID_SRC_AUTH_CREDENTIALSCACHE_H
#include "auth/User.h"
#include "base/RunnersRegistry.h"
namespace Auth {
/// Cache of Auth::User credentials, keyed by Auth::User::userKey
-class UserNameCache : public RegisteredRunner
+class CredentialsCache : public RegisteredRunner
{
private:
- CBDATA_CLASS(UserNameCache);
+ CBDATA_CLASS(CredentialsCache);
/// key is User::userKey(), mapped value is User::Pointer
typedef std::unordered_map<SBuf, Auth::User::Pointer> StoreType;
public:
- UserNameCache() = delete;
- explicit UserNameCache(const char *name);
+ CredentialsCache() = delete;
+ explicit CredentialsCache(const char *name);
- ~UserNameCache() = default;
- UserNameCache(const UserNameCache& ) = delete;
- UserNameCache& operator=(const UserNameCache&) = delete;
+ ~CredentialsCache() = default;
+ CredentialsCache(const CredentialsCache& ) = delete;
+ CredentialsCache& operator=(const CredentialsCache&) = delete;
/// obtain pointer to user if present, or Pointer(nullptr) if not
/// \returns a pointer to cached credentials, or nil if none found
} /* namespace Auth */
-#endif /* SQUID_SRC_AUTH_UERNAMECACHE_H */
+#endif /* SQUID_SRC_AUTH_CREDENTIALSCACHE_H */
#include "auth/ntlm/User.h"
#include "auth/Scheme.h"
#include "auth/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "auth/UserRequest.h"
#include "client_side.h"
#include "globals.h"
State.cc \
User.h \
User.cc \
- UserNameCache.h \
- UserNameCache.cc \
+ CredentialsCache.h \
+ CredentialsCache.cc \
UserRequest.h \
UserRequest.cc
#include "auth/Config.h"
#include "auth/Gadgets.h"
#include "auth/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "auth/UserRequest.h"
#include "event.h"
#include "globals.h"
* Dump the username cache statictics for viewing...
*/
void
-Auth::User::UsernameCacheStats(StoreEntry *output)
+Auth::User::CredentialsCacheStats(StoreEntry *output)
{
auto userlist = authenticateCachedUsersList();
storeAppendPrintf(output, "Cached Usernames: %d", static_cast<int32_t>(userlist.size()));
{
class Config;
-class UserNameCache;
+class CredentialsCache;
/**
* \ingroup AuthAPI
/// add the Auth::User to the protocol-specific username cache.
virtual void addToNameCache() = 0;
- static void UsernameCacheStats(StoreEntry * output);
+ static void CredentialsCacheStats(StoreEntry * output);
// userKey ->Auth::User::Pointer cache
// must be reimplemented in subclasses
- static CbcPointer<Auth::UserNameCache> Cache();
+ static CbcPointer<Auth::CredentialsCache> Cache();
CredentialState credentials() const;
void credentials(CredentialState);
#include "auth/basic/UserRequest.h"
#include "auth/Gadgets.h"
#include "auth/State.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "cache_cf.h"
#include "charset.h"
#include "helper.h"
#include "squid.h"
#include "auth/basic/Config.h"
#include "auth/basic/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "Debug.h"
#include "SquidConfig.h"
#include "SquidTime.h"
}
}
-CbcPointer<Auth::UserNameCache>
+CbcPointer<Auth::CredentialsCache>
Auth::Basic::User::Cache()
{
- static CbcPointer<Auth::UserNameCache> p(new Auth::UserNameCache("basic"));
+ static CbcPointer<Auth::CredentialsCache> p(new Auth::CredentialsCache("basic"));
return p;
}
virtual int32_t ttl() const;
/* Auth::User API */
- static CbcPointer<Auth::UserNameCache> Cache();
+ static CbcPointer<Auth::CredentialsCache> Cache();
virtual void addToNameCache() override;
char *passwd;
#include "auth/digest/UserRequest.h"
#include "auth/Gadgets.h"
#include "auth/State.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "base/LookupTable.h"
#include "base64.h"
#include "cache_cf.h"
#include "squid.h"
#include "auth/digest/Config.h"
#include "auth/digest/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "Debug.h"
#include "dlink.h"
#include "SquidConfig.h"
return nonce;
}
-CbcPointer<Auth::UserNameCache>
+CbcPointer<Auth::CredentialsCache>
Auth::Digest::User::Cache()
{
- static CbcPointer<Auth::UserNameCache> p(new Auth::UserNameCache("digest"));
+ static CbcPointer<Auth::CredentialsCache> p(new Auth::CredentialsCache("digest"));
return p;
}
virtual int32_t ttl() const;
/* Auth::User API */
- static CbcPointer<Auth::UserNameCache> Cache();
+ static CbcPointer<Auth::CredentialsCache> Cache();
virtual void addToNameCache() override;
HASH HA1;
#include "squid.h"
#include "auth/Config.h"
#include "auth/negotiate/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "Debug.h"
Auth::Negotiate::User::User(Auth::Config *aConfig, const char *aRequestRealm) :
return -1; // Negotiate cannot be cached.
}
-CbcPointer<Auth::UserNameCache>
+CbcPointer<Auth::CredentialsCache>
Auth::Negotiate::User::Cache()
{
- static CbcPointer<Auth::UserNameCache> p(new Auth::UserNameCache("negotiate"));
+ static CbcPointer<Auth::CredentialsCache> p(new Auth::CredentialsCache("negotiate"));
return p;
}
virtual int32_t ttl() const;
/* Auth::User API */
- static CbcPointer<Auth::UserNameCache> Cache();
+ static CbcPointer<Auth::CredentialsCache> Cache();
virtual void addToNameCache() override;
dlink_list proxy_auth_list;
#include "auth/negotiate/UserRequest.h"
#include "auth/State.h"
#include "auth/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "client_side.h"
#include "fatal.h"
#include "format/Format.h"
#include "squid.h"
#include "auth/Config.h"
#include "auth/ntlm/User.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "Debug.h"
Auth::Ntlm::User::User(Auth::Config *aConfig, const char *aRequestRealm) :
return -1; // NTLM credentials cannot be cached.
}
-CbcPointer<Auth::UserNameCache>
+CbcPointer<Auth::CredentialsCache>
Auth::Ntlm::User::Cache()
{
- static CbcPointer<Auth::UserNameCache> p(new Auth::UserNameCache("ntlm"));
+ static CbcPointer<Auth::CredentialsCache> p(new Auth::CredentialsCache("ntlm"));
return p;
}
virtual int32_t ttl() const;
/* Auth::User API */
- static CbcPointer<Auth::UserNameCache> Cache();
+ static CbcPointer<Auth::CredentialsCache> Cache();
virtual void addToNameCache() override;
dlink_list proxy_auth_list;
#include "auth/ntlm/User.h"
#include "auth/ntlm/UserRequest.h"
#include "auth/State.h"
-#include "auth/UserNameCache.h"
+#include "auth/CredentialsCache.h"
#include "cbdata.h"
#include "client_side.h"
#include "fatal.h"
#if USE_AUTH
Mgr::RegisterAction("username_cache",
"Active Cached Usernames",
- Auth::User::UsernameCacheStats, 0, 1);
+ Auth::User::CredentialsCacheStats, 0, 1);
#endif
#if DEBUG_OPENFD
Mgr::RegisterAction("openfd_objects", "Objects with Swapout files open",
void Auth::User::clearIp() STUB
void Auth::User::removeIp(Ip::Address) STUB
void Auth::User::addIp(Ip::Address) STUB
-void Auth::User::addToNameCache() STUB
-void Auth::User::UsernameCacheStats(StoreEntry *) STUB
+void Auth::User::CredentialsCacheStats(StoreEntry *) STUB
#include "auth/UserRequest.h"
char const * Auth::UserRequest::username() const STUB_RETVAL("stub_username")