OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/ssl/ssl_client_session_cache_openssl.h" | 5 #include "net/ssl/ssl_client_session_cache.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/time/clock.h" | 9 #include "base/time/clock.h" |
10 #include "base/time/default_clock.h" | 10 #include "base/time/default_clock.h" |
11 | 11 |
12 namespace net { | 12 namespace net { |
13 | 13 |
14 SSLClientSessionCacheOpenSSL::SSLClientSessionCacheOpenSSL(const Config& config) | 14 SSLClientSessionCache::SSLClientSessionCache(const Config& config) |
15 : clock_(new base::DefaultClock), | 15 : clock_(new base::DefaultClock), |
16 config_(config), | 16 config_(config), |
17 cache_(config.max_entries), | 17 cache_(config.max_entries), |
18 lookups_since_flush_(0) { | 18 lookups_since_flush_(0) {} |
19 } | |
20 | 19 |
21 SSLClientSessionCacheOpenSSL::~SSLClientSessionCacheOpenSSL() { | 20 SSLClientSessionCache::~SSLClientSessionCache() { |
22 Flush(); | 21 Flush(); |
23 } | 22 } |
24 | 23 |
25 size_t SSLClientSessionCacheOpenSSL::size() const { | 24 size_t SSLClientSessionCache::size() const { |
26 return cache_.size(); | 25 return cache_.size(); |
27 } | 26 } |
28 | 27 |
29 ScopedSSL_SESSION SSLClientSessionCacheOpenSSL::Lookup( | 28 ScopedSSL_SESSION SSLClientSessionCache::Lookup(const std::string& cache_key) { |
30 const std::string& cache_key) { | |
31 base::AutoLock lock(lock_); | 29 base::AutoLock lock(lock_); |
32 | 30 |
33 // Expire stale sessions. | 31 // Expire stale sessions. |
34 lookups_since_flush_++; | 32 lookups_since_flush_++; |
35 if (lookups_since_flush_ >= config_.expiration_check_count) { | 33 if (lookups_since_flush_ >= config_.expiration_check_count) { |
36 lookups_since_flush_ = 0; | 34 lookups_since_flush_ = 0; |
37 FlushExpiredSessions(); | 35 FlushExpiredSessions(); |
38 } | 36 } |
39 | 37 |
40 CacheEntryMap::iterator iter = cache_.Get(cache_key); | 38 CacheEntryMap::iterator iter = cache_.Get(cache_key); |
41 if (iter == cache_.end()) | 39 if (iter == cache_.end()) |
42 return nullptr; | 40 return nullptr; |
43 if (IsExpired(iter->second.get(), clock_->Now())) { | 41 if (IsExpired(iter->second.get(), clock_->Now())) { |
44 cache_.Erase(iter); | 42 cache_.Erase(iter); |
45 return nullptr; | 43 return nullptr; |
46 } | 44 } |
47 return ScopedSSL_SESSION(SSL_SESSION_up_ref(iter->second->session.get())); | 45 return ScopedSSL_SESSION(SSL_SESSION_up_ref(iter->second->session.get())); |
48 } | 46 } |
49 | 47 |
50 void SSLClientSessionCacheOpenSSL::Insert(const std::string& cache_key, | 48 void SSLClientSessionCache::Insert(const std::string& cache_key, |
51 SSL_SESSION* session) { | 49 SSL_SESSION* session) { |
52 base::AutoLock lock(lock_); | 50 base::AutoLock lock(lock_); |
53 | 51 |
54 // Make a new entry. | 52 // Make a new entry. |
55 std::unique_ptr<CacheEntry> entry(new CacheEntry); | 53 std::unique_ptr<CacheEntry> entry(new CacheEntry); |
56 entry->session.reset(SSL_SESSION_up_ref(session)); | 54 entry->session.reset(SSL_SESSION_up_ref(session)); |
57 entry->creation_time = clock_->Now(); | 55 entry->creation_time = clock_->Now(); |
58 | 56 |
59 // Takes ownership. | 57 // Takes ownership. |
60 cache_.Put(cache_key, std::move(entry)); | 58 cache_.Put(cache_key, std::move(entry)); |
61 } | 59 } |
62 | 60 |
63 void SSLClientSessionCacheOpenSSL::Flush() { | 61 void SSLClientSessionCache::Flush() { |
64 base::AutoLock lock(lock_); | 62 base::AutoLock lock(lock_); |
65 | 63 |
66 cache_.Clear(); | 64 cache_.Clear(); |
67 } | 65 } |
68 | 66 |
69 void SSLClientSessionCacheOpenSSL::SetClockForTesting( | 67 void SSLClientSessionCache::SetClockForTesting( |
70 std::unique_ptr<base::Clock> clock) { | 68 std::unique_ptr<base::Clock> clock) { |
71 clock_ = std::move(clock); | 69 clock_ = std::move(clock); |
72 } | 70 } |
73 | 71 |
74 SSLClientSessionCacheOpenSSL::CacheEntry::CacheEntry() { | 72 SSLClientSessionCache::CacheEntry::CacheEntry() {} |
75 } | |
76 | 73 |
77 SSLClientSessionCacheOpenSSL::CacheEntry::~CacheEntry() { | 74 SSLClientSessionCache::CacheEntry::~CacheEntry() {} |
78 } | |
79 | 75 |
80 bool SSLClientSessionCacheOpenSSL::IsExpired( | 76 bool SSLClientSessionCache::IsExpired(SSLClientSessionCache::CacheEntry* entry, |
81 SSLClientSessionCacheOpenSSL::CacheEntry* entry, | 77 const base::Time& now) { |
82 const base::Time& now) { | |
83 return now < entry->creation_time || | 78 return now < entry->creation_time || |
84 entry->creation_time + config_.timeout < now; | 79 entry->creation_time + config_.timeout < now; |
85 } | 80 } |
86 | 81 |
87 void SSLClientSessionCacheOpenSSL::FlushExpiredSessions() { | 82 void SSLClientSessionCache::FlushExpiredSessions() { |
88 base::Time now = clock_->Now(); | 83 base::Time now = clock_->Now(); |
89 CacheEntryMap::iterator iter = cache_.begin(); | 84 CacheEntryMap::iterator iter = cache_.begin(); |
90 while (iter != cache_.end()) { | 85 while (iter != cache_.end()) { |
91 if (IsExpired(iter->second.get(), now)) { | 86 if (IsExpired(iter->second.get(), now)) { |
92 iter = cache_.Erase(iter); | 87 iter = cache_.Erase(iter); |
93 } else { | 88 } else { |
94 ++iter; | 89 ++iter; |
95 } | 90 } |
96 } | 91 } |
97 } | 92 } |
98 | 93 |
99 } // namespace net | 94 } // namespace net |
OLD | NEW |