The Tor Browser / file comparison

comparison: security/nss/lib/ssl/sslmutex.c

security/nss/lib/ssl/sslmutex.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:d7e27649db21
1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5 #include "seccomon.h"
6 /* This ifdef should match the one in sslsnce.c */
7 #if defined(XP_UNIX) || defined(XP_WIN32) || defined (XP_OS2) || defined(XP_BEOS)
8
9 #include "sslmutex.h"
10 #include "prerr.h"
11
12 static SECStatus single_process_sslMutex_Init(sslMutex* pMutex)
13 {
14 PR_ASSERT(pMutex != 0 && pMutex->u.sslLock == 0 );
15
16 pMutex->u.sslLock = PR_NewLock();
17 if (!pMutex->u.sslLock) {
18 return SECFailure;
19 }
20 return SECSuccess;
21 }
22
23 static SECStatus single_process_sslMutex_Destroy(sslMutex* pMutex)
24 {
25 PR_ASSERT(pMutex != 0);
26 PR_ASSERT(pMutex->u.sslLock!= 0);
27 if (!pMutex->u.sslLock) {
28 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
29 return SECFailure;
30 }
31 PR_DestroyLock(pMutex->u.sslLock);
32 return SECSuccess;
33 }
34
35 static SECStatus single_process_sslMutex_Unlock(sslMutex* pMutex)
36 {
37 PR_ASSERT(pMutex != 0 );
38 PR_ASSERT(pMutex->u.sslLock !=0);
39 if (!pMutex->u.sslLock) {
40 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
41 return SECFailure;
42 }
43 PR_Unlock(pMutex->u.sslLock);
44 return SECSuccess;
45 }
46
47 static SECStatus single_process_sslMutex_Lock(sslMutex* pMutex)
48 {
49 PR_ASSERT(pMutex != 0);
50 PR_ASSERT(pMutex->u.sslLock != 0 );
51 if (!pMutex->u.sslLock) {
52 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
53 return SECFailure;
54 }
55 PR_Lock(pMutex->u.sslLock);
56 return SECSuccess;
57 }
58
59 #if defined(LINUX) || defined(AIX) || defined(BEOS) || defined(BSDI) || (defined(NETBSD) && __NetBSD_Version__ < 500000000) || defined(OPENBSD)
60
61 #include <unistd.h>
62 #include <fcntl.h>
63 #include <string.h>
64 #include <errno.h>
65 #include "unix_err.h"
66 #include "pratom.h"
67
68 #define SSL_MUTEX_MAGIC 0xfeedfd
69 #define NONBLOCKING_POSTS 1 /* maybe this is faster */
70
71 #if NONBLOCKING_POSTS
72
73 #ifndef FNONBLOCK
74 #define FNONBLOCK O_NONBLOCK
75 #endif
76
77 static int
78 setNonBlocking(int fd, int nonBlocking)
79 {
80 int flags;
81 int err;
82
83 flags = fcntl(fd, F_GETFL, 0);
84 if (0 > flags)
85 return flags;
86 if (nonBlocking)
87 flags |= FNONBLOCK;
88 else
89 flags &= ~FNONBLOCK;
90 err = fcntl(fd, F_SETFL, flags);
91 return err;
92 }
93 #endif
94
95 SECStatus
96 sslMutex_Init(sslMutex *pMutex, int shared)
97 {
98 int err;
99 PR_ASSERT(pMutex);
100 pMutex->isMultiProcess = (PRBool)(shared != 0);
101 if (!shared) {
102 return single_process_sslMutex_Init(pMutex);
103 }
104 pMutex->u.pipeStr.mPipes[0] = -1;
105 pMutex->u.pipeStr.mPipes[1] = -1;
106 pMutex->u.pipeStr.mPipes[2] = -1;
107 pMutex->u.pipeStr.nWaiters = 0;
108
109 err = pipe(pMutex->u.pipeStr.mPipes);
110 if (err) {
111 nss_MD_unix_map_default_error(errno);
112 return err;
113 }
114 #if NONBLOCKING_POSTS
115 err = setNonBlocking(pMutex->u.pipeStr.mPipes[1], 1);
116 if (err)
117 goto loser;
118 #endif
119
120 pMutex->u.pipeStr.mPipes[2] = SSL_MUTEX_MAGIC;
121
122 #if defined(LINUX) && defined(i386)
123 /* Pipe starts out empty */
124 return SECSuccess;
125 #else
126 /* Pipe starts with one byte. */
127 return sslMutex_Unlock(pMutex);
128 #endif
129
130 loser:
131 nss_MD_unix_map_default_error(errno);
132 close(pMutex->u.pipeStr.mPipes[0]);
133 close(pMutex->u.pipeStr.mPipes[1]);
134 return SECFailure;
135 }
136
137 SECStatus
138 sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
139 {
140 if (PR_FALSE == pMutex->isMultiProcess) {
141 return single_process_sslMutex_Destroy(pMutex);
142 }
143 if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
144 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
145 return SECFailure;
146 }
147 close(pMutex->u.pipeStr.mPipes[0]);
148 close(pMutex->u.pipeStr.mPipes[1]);
149
150 if (processLocal) {
151 return SECSuccess;
152 }
153
154 pMutex->u.pipeStr.mPipes[0] = -1;
155 pMutex->u.pipeStr.mPipes[1] = -1;
156 pMutex->u.pipeStr.mPipes[2] = -1;
157 pMutex->u.pipeStr.nWaiters = 0;
158
159 return SECSuccess;
160 }
161
162 #if defined(LINUX) && defined(i386)
163 /* No memory barrier needed for this platform */
164
165 /* nWaiters includes the holder of the lock (if any) and the number
166 ** threads waiting for it. After incrementing nWaiters, if the count
167 ** is exactly 1, then you have the lock and may proceed. If the
168 ** count is greater than 1, then you must wait on the pipe.
169 */
170
171
172 SECStatus
173 sslMutex_Unlock(sslMutex *pMutex)
174 {
175 PRInt32 newValue;
176 if (PR_FALSE == pMutex->isMultiProcess) {
177 return single_process_sslMutex_Unlock(pMutex);
178 }
179
180 if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
181 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
182 return SECFailure;
183 }
184 /* Do Memory Barrier here. */
185 newValue = PR_ATOMIC_DECREMENT(&pMutex->u.pipeStr.nWaiters);
186 if (newValue > 0) {
187 int cc;
188 char c = 1;
189 do {
190 cc = write(pMutex->u.pipeStr.mPipes[1], &c, 1);
191 } while (cc < 0 && (errno == EINTR || errno == EAGAIN));
192 if (cc != 1) {
193 if (cc < 0)
194 nss_MD_unix_map_default_error(errno);
195 else
196 PORT_SetError(PR_UNKNOWN_ERROR);
197 return SECFailure;
198 }
199 }
200 return SECSuccess;
201 }
202
203 SECStatus
204 sslMutex_Lock(sslMutex *pMutex)
205 {
206 PRInt32 newValue;
207 if (PR_FALSE == pMutex->isMultiProcess) {
208 return single_process_sslMutex_Lock(pMutex);
209 }
210
211 if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
212 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
213 return SECFailure;
214 }
215 newValue = PR_ATOMIC_INCREMENT(&pMutex->u.pipeStr.nWaiters);
216 /* Do Memory Barrier here. */
217 if (newValue > 1) {
218 int cc;
219 char c;
220 do {
221 cc = read(pMutex->u.pipeStr.mPipes[0], &c, 1);
222 } while (cc < 0 && errno == EINTR);
223 if (cc != 1) {
224 if (cc < 0)
225 nss_MD_unix_map_default_error(errno);
226 else
227 PORT_SetError(PR_UNKNOWN_ERROR);
228 return SECFailure;
229 }
230 }
231 return SECSuccess;
232 }
233
234 #else
235
236 /* Using Atomic operations requires the use of a memory barrier instruction
237 ** on PowerPC, Sparc, and Alpha. NSPR's PR_Atomic functions do not perform
238 ** them, and NSPR does not provide a function that does them (e.g. PR_Barrier).
239 ** So, we don't use them on those platforms.
240 */
241
242 SECStatus
243 sslMutex_Unlock(sslMutex *pMutex)
244 {
245 int cc;
246 char c = 1;
247
248 if (PR_FALSE == pMutex->isMultiProcess) {
249 return single_process_sslMutex_Unlock(pMutex);
250 }
251
252 if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
253 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
254 return SECFailure;
255 }
256 do {
257 cc = write(pMutex->u.pipeStr.mPipes[1], &c, 1);
258 } while (cc < 0 && (errno == EINTR || errno == EAGAIN));
259 if (cc != 1) {
260 if (cc < 0)
261 nss_MD_unix_map_default_error(errno);
262 else
263 PORT_SetError(PR_UNKNOWN_ERROR);
264 return SECFailure;
265 }
266
267 return SECSuccess;
268 }
269
270 SECStatus
271 sslMutex_Lock(sslMutex *pMutex)
272 {
273 int cc;
274 char c;
275
276 if (PR_FALSE == pMutex->isMultiProcess) {
277 return single_process_sslMutex_Lock(pMutex);
278 }
279
280 if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
281 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
282 return SECFailure;
283 }
284
285 do {
286 cc = read(pMutex->u.pipeStr.mPipes[0], &c, 1);
287 } while (cc < 0 && errno == EINTR);
288 if (cc != 1) {
289 if (cc < 0)
290 nss_MD_unix_map_default_error(errno);
291 else
292 PORT_SetError(PR_UNKNOWN_ERROR);
293 return SECFailure;
294 }
295
296 return SECSuccess;
297 }
298
299 #endif
300
301 #elif defined(WIN32)
302
303 #include "win32err.h"
304
305 /* on Windows, we need to find the optimal type of locking mechanism to use
306 for the sslMutex.
307
308 There are 3 cases :
309 1) single-process, use a PRLock, as for all other platforms
310 2) Win95 multi-process, use a Win32 mutex
311 3) on WINNT multi-process, use a PRLock + a Win32 mutex
312
313 */
314
315 #ifdef WINNT
316
317 SECStatus sslMutex_2LevelInit(sslMutex *sem)
318 {
319 /* the following adds a PRLock to sslMutex . This is done in each
320 process of a multi-process server and is only needed on WINNT, if
321 using fibers. We can't tell if native threads or fibers are used, so
322 we always do it on WINNT
323 */
324 PR_ASSERT(sem);
325 if (sem) {
326 /* we need to reset the sslLock in the children or the single_process init
327 function below will assert */
328 sem->u.sslLock = NULL;
329 }
330 return single_process_sslMutex_Init(sem);
331 }
332
333 static SECStatus sslMutex_2LevelDestroy(sslMutex *sem)
334 {
335 return single_process_sslMutex_Destroy(sem);
336 }
337
338 #endif
339
340 SECStatus
341 sslMutex_Init(sslMutex *pMutex, int shared)
342 {
343 #ifdef WINNT
344 SECStatus retvalue;
345 #endif
346 HANDLE hMutex;
347 SECURITY_ATTRIBUTES attributes =
348 { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
349
350 PR_ASSERT(pMutex != 0 && (pMutex->u.sslMutx == 0 ||
351 pMutex->u.sslMutx == INVALID_HANDLE_VALUE) );
352
353 pMutex->isMultiProcess = (PRBool)(shared != 0);
354
355 if (PR_FALSE == pMutex->isMultiProcess) {
356 return single_process_sslMutex_Init(pMutex);
357 }
358
359 #ifdef WINNT
360 /* we need a lock on WINNT for fibers in the parent process */
361 retvalue = sslMutex_2LevelInit(pMutex);
362 if (SECSuccess != retvalue)
363 return SECFailure;
364 #endif
365
366 if (!pMutex || ((hMutex = pMutex->u.sslMutx) != 0 &&
367 hMutex != INVALID_HANDLE_VALUE)) {
368 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
369 return SECFailure;
370 }
371 attributes.bInheritHandle = (shared ? TRUE : FALSE);
372 hMutex = CreateMutex(&attributes, FALSE, NULL);
373 if (hMutex == NULL) {
374 hMutex = INVALID_HANDLE_VALUE;
375 nss_MD_win32_map_default_error(GetLastError());
376 return SECFailure;
377 }
378 pMutex->u.sslMutx = hMutex;
379 return SECSuccess;
380 }
381
382 SECStatus
383 sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
384 {
385 HANDLE hMutex;
386 int rv;
387 int retvalue = SECSuccess;
388
389 PR_ASSERT(pMutex != 0);
390 if (PR_FALSE == pMutex->isMultiProcess) {
391 return single_process_sslMutex_Destroy(pMutex);
392 }
393
394 /* multi-process mode */
395 #ifdef WINNT
396 /* on NT, get rid of the PRLock used for fibers within a process */
397 retvalue = sslMutex_2LevelDestroy(pMutex);
398 #endif
399
400 PR_ASSERT( pMutex->u.sslMutx != 0 &&
401 pMutex->u.sslMutx != INVALID_HANDLE_VALUE);
402 if (!pMutex || (hMutex = pMutex->u.sslMutx) == 0
403 || hMutex == INVALID_HANDLE_VALUE) {
404 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
405 return SECFailure;
406 }
407
408 rv = CloseHandle(hMutex); /* ignore error */
409 if (!processLocal && rv) {
410 pMutex->u.sslMutx = hMutex = INVALID_HANDLE_VALUE;
411 }
412 if (!rv) {
413 nss_MD_win32_map_default_error(GetLastError());
414 retvalue = SECFailure;
415 }
416 return retvalue;
417 }
418
419 int
420 sslMutex_Unlock(sslMutex *pMutex)
421 {
422 BOOL success = FALSE;
423 HANDLE hMutex;
424
425 PR_ASSERT(pMutex != 0 );
426 if (PR_FALSE == pMutex->isMultiProcess) {
427 return single_process_sslMutex_Unlock(pMutex);
428 }
429
430 PR_ASSERT(pMutex->u.sslMutx != 0 &&
431 pMutex->u.sslMutx != INVALID_HANDLE_VALUE);
432 if (!pMutex || (hMutex = pMutex->u.sslMutx) == 0 ||
433 hMutex == INVALID_HANDLE_VALUE) {
434 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
435 return SECFailure;
436 }
437 success = ReleaseMutex(hMutex);
438 if (!success) {
439 nss_MD_win32_map_default_error(GetLastError());
440 return SECFailure;
441 }
442 #ifdef WINNT
443 return single_process_sslMutex_Unlock(pMutex);
444 /* release PRLock for other fibers in the process */
445 #else
446 return SECSuccess;
447 #endif
448 }
449
450 int
451 sslMutex_Lock(sslMutex *pMutex)
452 {
453 HANDLE hMutex;
454 DWORD event;
455 DWORD lastError;
456 SECStatus rv;
457 SECStatus retvalue = SECSuccess;
458 PR_ASSERT(pMutex != 0);
459
460 if (PR_FALSE == pMutex->isMultiProcess) {
461 return single_process_sslMutex_Lock(pMutex);
462 }
463 #ifdef WINNT
464 /* lock first to preserve from other threads/fibers
465 in the same process */
466 retvalue = single_process_sslMutex_Lock(pMutex);
467 #endif
468 PR_ASSERT(pMutex->u.sslMutx != 0 &&
469 pMutex->u.sslMutx != INVALID_HANDLE_VALUE);
470 if (!pMutex || (hMutex = pMutex->u.sslMutx) == 0 ||
471 hMutex == INVALID_HANDLE_VALUE) {
472 PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
473 return SECFailure; /* what else ? */
474 }
475 /* acquire the mutex to be the only owner accross all other processes */
476 event = WaitForSingleObject(hMutex, INFINITE);
477 switch (event) {
478 case WAIT_OBJECT_0:
479 case WAIT_ABANDONED:
480 rv = SECSuccess;
481 break;
482
483 case WAIT_TIMEOUT:
484 #if defined(WAIT_IO_COMPLETION)
485 case WAIT_IO_COMPLETION:
486 #endif
487 default: /* should never happen. nothing we can do. */
488 PR_ASSERT(!("WaitForSingleObject returned invalid value."));
489 PORT_SetError(PR_UNKNOWN_ERROR);
490 rv = SECFailure;
491 break;
492
493 case WAIT_FAILED: /* failure returns this */
494 rv = SECFailure;
495 lastError = GetLastError(); /* for debugging */
496 nss_MD_win32_map_default_error(lastError);
497 break;
498 }
499
500 if (! (SECSuccess == retvalue && SECSuccess == rv)) {
501 return SECFailure;
502 }
503
504 return SECSuccess;
505 }
506
507 #elif defined(XP_UNIX)
508
509 #include <errno.h>
510 #include "unix_err.h"
511
512 SECStatus
513 sslMutex_Init(sslMutex *pMutex, int shared)
514 {
515 int rv;
516 PR_ASSERT(pMutex);
517 pMutex->isMultiProcess = (PRBool)(shared != 0);
518 if (!shared) {
519 return single_process_sslMutex_Init(pMutex);
520 }
521 do {
522 rv = sem_init(&pMutex->u.sem, shared, 1);
523 } while (rv < 0 && errno == EINTR);
524 if (rv < 0) {
525 nss_MD_unix_map_default_error(errno);
526 return SECFailure;
527 }
528 return SECSuccess;
529 }
530
531 SECStatus
532 sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
533 {
534 int rv;
535 if (PR_FALSE == pMutex->isMultiProcess) {
536 return single_process_sslMutex_Destroy(pMutex);
537 }
538
539 /* semaphores are global resources. See SEM_DESTROY(3) man page */
540 if (processLocal) {
541 return SECSuccess;
542 }
543 do {
544 rv = sem_destroy(&pMutex->u.sem);
545 } while (rv < 0 && errno == EINTR);
546 if (rv < 0) {
547 nss_MD_unix_map_default_error(errno);
548 return SECFailure;
549 }
550 return SECSuccess;
551 }
552
553 SECStatus
554 sslMutex_Unlock(sslMutex *pMutex)
555 {
556 int rv;
557 if (PR_FALSE == pMutex->isMultiProcess) {
558 return single_process_sslMutex_Unlock(pMutex);
559 }
560 do {
561 rv = sem_post(&pMutex->u.sem);
562 } while (rv < 0 && errno == EINTR);
563 if (rv < 0) {
564 nss_MD_unix_map_default_error(errno);
565 return SECFailure;
566 }
567 return SECSuccess;
568 }
569
570 SECStatus
571 sslMutex_Lock(sslMutex *pMutex)
572 {
573 int rv;
574 if (PR_FALSE == pMutex->isMultiProcess) {
575 return single_process_sslMutex_Lock(pMutex);
576 }
577 do {
578 rv = sem_wait(&pMutex->u.sem);
579 } while (rv < 0 && errno == EINTR);
580 if (rv < 0) {
581 nss_MD_unix_map_default_error(errno);
582 return SECFailure;
583 }
584 return SECSuccess;
585 }
586
587 #else
588
589 SECStatus
590 sslMutex_Init(sslMutex *pMutex, int shared)
591 {
592 PR_ASSERT(pMutex);
593 pMutex->isMultiProcess = (PRBool)(shared != 0);
594 if (!shared) {
595 return single_process_sslMutex_Init(pMutex);
596 }
597 PORT_Assert(!("sslMutex_Init not implemented for multi-process applications !"));
598 PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
599 return SECFailure;
600 }
601
602 SECStatus
603 sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
604 {
605 PR_ASSERT(pMutex);
606 if (PR_FALSE == pMutex->isMultiProcess) {
607 return single_process_sslMutex_Destroy(pMutex);
608 }
609 PORT_Assert(!("sslMutex_Destroy not implemented for multi-process applications !"));
610 PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
611 return SECFailure;
612 }
613
614 SECStatus
615 sslMutex_Unlock(sslMutex *pMutex)
616 {
617 PR_ASSERT(pMutex);
618 if (PR_FALSE == pMutex->isMultiProcess) {
619 return single_process_sslMutex_Unlock(pMutex);
620 }
621 PORT_Assert(!("sslMutex_Unlock not implemented for multi-process applications !"));
622 PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
623 return SECFailure;
624 }
625
626 SECStatus
627 sslMutex_Lock(sslMutex *pMutex)
628 {
629 PR_ASSERT(pMutex);
630 if (PR_FALSE == pMutex->isMultiProcess) {
631 return single_process_sslMutex_Lock(pMutex);
632 }
633 PORT_Assert(!("sslMutex_Lock not implemented for multi-process applications !"));
634 PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
635 return SECFailure;
636 }
637
638 #endif
639
640 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial