1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
diff --git a/ssl/ssl3con.c b/ssl/ssl3con.c
index adaa9a4..708a4c7 100644
--- a/ssl/ssl3con.c
+++ b/ssl/ssl3con.c
@@ -5733,7 +5733,6 @@ SSL3_ShutdownServerCache(void)
}
PZ_Unlock(symWrapKeysLock);
- ssl_FreeSessionCacheLocks();
return SECSuccess;
}
@@ -5785,7 +5784,7 @@ getWrappingKey( sslSocket * ss,
pSymWrapKey = &symWrapKeys[symWrapMechIndex].symWrapKey[exchKeyType];
- ssl_InitSessionCacheLocks(PR_TRUE);
+ ssl_InitSessionCacheLocks();
PZ_Lock(symWrapKeysLock);
diff --git a/ssl/sslimpl.h b/ssl/sslimpl.h
index 643570f..62f822a 100644
--- a/ssl/sslimpl.h
+++ b/ssl/sslimpl.h
@@ -1917,9 +1917,7 @@ extern SECStatus ssl_InitSymWrapKeysLock(void);
extern SECStatus ssl_FreeSymWrapKeysLock(void);
-extern SECStatus ssl_InitSessionCacheLocks(PRBool lazyInit);
-
-extern SECStatus ssl_FreeSessionCacheLocks(void);
+extern SECStatus ssl_InitSessionCacheLocks(void);
/***************** platform client auth ****************/
diff --git a/ssl/sslnonce.c b/ssl/sslnonce.c
index 1326a8b..c45849d 100644
--- a/ssl/sslnonce.c
+++ b/ssl/sslnonce.c
@@ -35,91 +35,55 @@ static PZLock * cacheLock = NULL;
#define LOCK_CACHE lock_cache()
#define UNLOCK_CACHE PZ_Unlock(cacheLock)
-static SECStatus
-ssl_InitClientSessionCacheLock(void)
-{
- cacheLock = PZ_NewLock(nssILockCache);
- return cacheLock ? SECSuccess : SECFailure;
-}
-
-static SECStatus
-ssl_FreeClientSessionCacheLock(void)
-{
- if (cacheLock) {
- PZ_DestroyLock(cacheLock);
- cacheLock = NULL;
- return SECSuccess;
- }
- PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
- return SECFailure;
-}
-
-static PRBool LocksInitializedEarly = PR_FALSE;
+static PRCallOnceType lockOnce;
+/* FreeSessionCacheLocks is a callback from NSS_RegisterShutdown which destroys
+ * the session cache locks on shutdown and resets them to their initial
+ * state. */
static SECStatus
-FreeSessionCacheLocks()
+FreeSessionCacheLocks(void* appData, void* nssData)
{
- SECStatus rv1, rv2;
- rv1 = ssl_FreeSymWrapKeysLock();
- rv2 = ssl_FreeClientSessionCacheLock();
- if ( (SECSuccess == rv1) && (SECSuccess == rv2) ) {
- return SECSuccess;
- }
- return SECFailure;
-}
+ static const PRCallOnceType pristineCallOnce;
+ SECStatus rv;
-static SECStatus
-InitSessionCacheLocks(void)
-{
- SECStatus rv1, rv2;
- PRErrorCode rc;
- rv1 = ssl_InitSymWrapKeysLock();
- rv2 = ssl_InitClientSessionCacheLock();
- if ( (SECSuccess == rv1) && (SECSuccess == rv2) ) {
- return SECSuccess;
- }
- rc = PORT_GetError();
- FreeSessionCacheLocks();
- PORT_SetError(rc);
- return SECFailure;
-}
-
-/* free the session cache locks if they were initialized early */
-SECStatus
-ssl_FreeSessionCacheLocks()
-{
- PORT_Assert(PR_TRUE == LocksInitializedEarly);
- if (!LocksInitializedEarly) {
+ if (!cacheLock) {
PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
return SECFailure;
}
- FreeSessionCacheLocks();
- LocksInitializedEarly = PR_FALSE;
- return SECSuccess;
-}
-static PRCallOnceType lockOnce;
+ PZ_DestroyLock(cacheLock);
+ cacheLock = NULL;
-/* free the session cache locks if they were initialized lazily */
-static SECStatus ssl_ShutdownLocks(void* appData, void* nssData)
-{
- PORT_Assert(PR_FALSE == LocksInitializedEarly);
- if (LocksInitializedEarly) {
- PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
- return SECFailure;
+ rv = ssl_FreeSymWrapKeysLock();
+ if (rv != SECSuccess) {
+ return rv;
}
- FreeSessionCacheLocks();
- memset(&lockOnce, 0, sizeof(lockOnce));
+
+ lockOnce = pristineCallOnce;
return SECSuccess;
}
-static PRStatus initSessionCacheLocksLazily(void)
+/* InitSessionCacheLocks is called, protected by lockOnce, to create the
+ * session cache locks. */
+static PRStatus
+InitSessionCacheLocks(void)
{
- SECStatus rv = InitSessionCacheLocks();
- if (SECSuccess != rv) {
+ SECStatus rv;
+
+ cacheLock = PZ_NewLock(nssILockCache);
+ if (cacheLock == NULL) {
return PR_FAILURE;
}
- rv = NSS_RegisterShutdown(ssl_ShutdownLocks, NULL);
+ rv = ssl_InitSymWrapKeysLock();
+ if (rv != SECSuccess) {
+ PRErrorCode error = PORT_GetError();
+ PZ_DestroyLock(cacheLock);
+ cacheLock = NULL;
+ PORT_SetError(error);
+ return PR_FAILURE;
+ }
+
+ rv = NSS_RegisterShutdown(FreeSessionCacheLocks, NULL);
PORT_Assert(SECSuccess == rv);
if (SECSuccess != rv) {
return PR_FAILURE;
@@ -127,34 +91,18 @@ static PRStatus initSessionCacheLocksLazily(void)
return PR_SUCCESS;
}
-/* lazyInit means that the call is not happening during a 1-time
- * initialization function, but rather during dynamic, lazy initialization
- */
SECStatus
-ssl_InitSessionCacheLocks(PRBool lazyInit)
+ssl_InitSessionCacheLocks(void)
{
- if (LocksInitializedEarly) {
- return SECSuccess;
- }
-
- if (lazyInit) {
- return (PR_SUCCESS ==
- PR_CallOnce(&lockOnce, initSessionCacheLocksLazily)) ?
- SECSuccess : SECFailure;
- }
-
- if (SECSuccess == InitSessionCacheLocks()) {
- LocksInitializedEarly = PR_TRUE;
- return SECSuccess;
- }
-
- return SECFailure;
+ return (PR_SUCCESS ==
+ PR_CallOnce(&lockOnce, InitSessionCacheLocks)) ?
+ SECSuccess : SECFailure;
}
-static void
+static void
lock_cache(void)
{
- ssl_InitSessionCacheLocks(PR_TRUE);
+ ssl_InitSessionCacheLocks();
PZ_Lock(cacheLock);
}
diff --git a/ssl/sslsnce.c b/ssl/sslsnce.c
index 4d9ef38..3279200 100644
--- a/ssl/sslsnce.c
+++ b/ssl/sslsnce.c
@@ -1352,7 +1352,7 @@ SSL_ConfigServerSessionIDCache( int maxCacheEntries,
PRUint32 ssl3_timeout,
const char * directory)
{
- ssl_InitSessionCacheLocks(PR_FALSE);
+ ssl_InitSessionCacheLocks();
return SSL_ConfigServerSessionIDCacheInstance(&globalCache,
maxCacheEntries, ssl2_timeout, ssl3_timeout, directory, PR_FALSE);
}
@@ -1466,7 +1466,7 @@ SSL_ConfigServerSessionIDCacheWithOpt(
PRBool enableMPCache)
{
if (!enableMPCache) {
- ssl_InitSessionCacheLocks(PR_FALSE);
+ ssl_InitSessionCacheLocks();
return ssl_ConfigServerSessionIDCacheInstanceWithOpt(&globalCache,
ssl2_timeout, ssl3_timeout, directory, PR_FALSE,
maxCacheEntries, maxCertCacheEntries, maxSrvNameCacheEntries);
@@ -1511,7 +1511,7 @@ SSL_InheritMPServerSIDCacheInstance(cacheDesc *cache, const char * envString)
return SECSuccess; /* already done. */
}
- ssl_InitSessionCacheLocks(PR_FALSE);
+ ssl_InitSessionCacheLocks();
ssl_sid_lookup = ServerSessionIDLookup;
ssl_sid_cache = ServerSessionIDCache;
|
