net/third_party/nss/ssl/sslmutex.c

   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