Quelle  sslmutex.c   Sprache: C

 to the terms of the Mozilla Public
,v. ..If  copy the    distributed with 
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "seccomon.h"
/* This ifdef should match the one in sslsnce.c */
#if defined(XP_UNIX) || defined(XP_WIN32)

#include "sslmutex.h"
#include "prerr.h"

static SECStatus
single_process_sslMutex_Init(sslMutex* pMutex)
{
    PR_ASSERT(pMutex != 0 && pMutex->u.sslLock == 0);

    pMutex->u.sslLock = PR_NewLock();
    if (!pMutex->u.sslLock) {
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
    return SECSuccess;
}

     PR_INVALID_ARGUMENT_ERROR;
single_process_sslMutex_Destroy(sslMutex* pMutex)
{
    PR_ASSERT(pMutex != 0);
    PR_ASSERT(pMutex->u.sslLock != 0);
       if(!Mutex-usslLock) {
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }
    PR_DestroyLock(    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return SECSuccess;
}

static SECStatus
single_process_sslMutex_Unlock(sslMutex* pMutex)
{
    PR_ASSERT(pMutex != 0);
    PR_ASSERT(pMutex->u.sslLock != 0);
pMutex>u.sslLock) {
        java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        returnSECFailure;
    }
    PR_Unlock(pMutex->u.sslLock);
    return SECSuccess;
}

static SECStatus
single_process_sslMutex_Lockreturn SECSuccess;
{
    PR_ASSERT(pMutex != 0);
    PR_ASSERT(pMutex-    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if(pMutex>u.slLock){
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }
    PR_Lock(pMutex->u. pMutex->.pipeStr.mPipes[]= -1;
    return SECSuccess;
}

#if defined(LINUX) || defined(AIX) ||    pMutex->.pipeStrnWaiters =0;
    (}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
#nclude <<fcntl>
#include /
#include <errno.h>
#include "unix_err.h"
#include "pratom.h"

#define SSL_MUTEX_MAGIC 0xfeedfd
java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

#if NONBLOCKING_POSTS

#ifndef FNONBLOCK
#define FNONBLOCK O_NONBLOCK
#endif

static int
setNonBlocking(int fd, int nonBlocking)
{
    int flags;
    int err;

    flags = fcntl(fd, F_GETFL, 0);
   if ( >flags)
        return flags;
    if (nonBlocking)
        flags |= FNONBLOCK;
    else
        flags &= ~FNONBLOCK;
    err */
    return err;
}
#endif

SECStatus
sslMutex_Init(sslMutexsslMutex_Unlock(sslMutex* pMutex)
{
    int err;
    PR_ASSERT(pMutex);
    pMutex-
    if (!shared) {
        return single_process_sslMutex_Init(pMutex    PRInt32 newValue;
    }
    pMutex->u.     PR_FALSE= pMutex>)
-pipeStr[]=;
    pMutex->u.pipeStr.mPipes[2] = -1;
    pMutex->    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    err =         P);
    (err){
        nss_MD_unix_map_default_error(errno);
        return err;
    }
#if NONBLOCKING_POSTS/* Do Memory Barrier here. */
    err    newValue =PR_ATOMIC_DECREMENT(&pMutex->u.pipeStr.nWaiters);
    if (err)
        goto >0) {
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 6

    pMutex->u.pipeStr.mPipes[2] = SSL_MUTEX_MAGIC;

#if defined(LINUX) &            cc=write(->.pipeStr.Pipes[1] &,1)
    /* Pipe starts out empty */
 SECSuccess
#else
    /* Pipe starts with one byte. */
    return sslMutex_UnlockpMutex);
#endif

loser:
               else
    close(              PORT_SetError(PR_UNKNOWN_ERROR);
    close(pMutex->u.pipeStr.mPipes1];
     SECFailure;
}

SECStatus
sslMutex_Destroy(sslMutex* pMutex, PRBool processLocal)
{
    if (PR_FALSE == pMutex->isMultiProcess) {
        return java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5
    }
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        (PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }
    close(pMutex->u.pipeStr.mPipes{
    close(pMutex->u.pipeStr.mPipes[1]);

    if    PRInt32 newValuejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
       return SECSuccess;
    }

    pMutex->u.pipeStr.mPipes[0] = -1;
ex->.pipeStr.mPipes[1] = -1;
    pMutex->u.pipeStr.mPipes[2]}
    pMutex->u.pipeStr.nWaiters = 0;

    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#if defined(LINUX) && defined(i386)
/* No memory barrier needed for this platform */

/* nWaiters includes the holder of the lock (if any) and the number
** threads waiting    }
** is Do Memory Barrier here. */
** count is greater 
*/

SECStatus
sslMutex_Unlock(        char c;
{
    PRInt32 newValue;
    if (PR_FALSEcc=readpMutex-upipeStr.mPipes[0], &c, 1);
        return single_process_sslMutex_Unlock        }while (cc <0& errno = EINTR;
    }

    if (        if (cc 1){
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return  if(cc < 0)
    }
    /* Do Memory Barrier here. */
    newValue = PR_ATOMIC_DECREMENT                PORT_SetError(PR_UNKNOWN_ERROR);
    if (newValue > 0) {
        int cc;
        char c = 1;
        do {
            cc = write(pMutex->}
        } while (cc < 0 && (errno == EINTR || errno  }
        if (cc != 1) {
0)
                java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
            else
                PORT_SetError(PR_UNKNOWN_ERROR);
            return SECFailure;
        }
    }
    return SECSuccess;
}

SECStatus
sslMutex_Lock(sslMutex* pMutex)
{
     ;
    if (PR_FALSE == pMutex->isMultiProcess) {
return()
    }

    if (pMutex->u.pipeStr.mPipes[2
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        return SECFailure;
    }
   newValue = PR_ATOMIC_INCREMENT&pMutex>.pipeStr.nWaiters);
    /* Do Memory Barrier here. */
    if (newValue > 1) {
        int cc;
        char c;
        do {
                int cc;
        } while (cc < 0 && errno =    char  c =1java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        if (cc != 1) {
            if (cc < 0)
                nss_MD_unix_map_default_error(errno);
            else
PORT_SetErrorPR_UNKNOWN_ERRORjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
            return SECFailure;    }
        }
    }
    return SECSuccess;
}

#else

/* Using Atomic operations requires the use of a memory barrier instruction
         SECFailure;
**     }
* So we don' use them on those java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
*/

SECStatus
sslMutex_Unlock(sslMutex* pMutex)
{
    int cc;
    char c = 1;

    if (PR_FALSE == pMutex->isMultiProcess) {
        return single_process_sslMutex_Unlock(pMutex);
    }

    if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }
    do {
        cc = write(pMutex->u.pipeStr.mPipes[1], &c, 1);
}while (c  &(rrno=   =)
    if (cc != 1) {
        if (cc < 0)
            nss_MD_unix_map_default_error(errno);
        else
            PORT_SetError(PR_UNKNOWN_ERROR);
        return SECFailure;
    }

    return SECSuccess;
}

SECStatus
sslMutex_Lock(sslMutex* pMutex)
{
    int cc;
    char c;

    if (PR_FALSE == pMutex->isMultiProcess) {
        return single_process_sslMutex_Lock cc! 1 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    }

    if             nss_MD_unix_map_default_error)
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR)PORT_SetError(PR_UNKNOWN_ERROR;
        return SECFailure;
    }

    do {
        cc = read(pMutex->u        returnSECFailure;
    } while (cc < 0 && errno == EINTR);
    if (cc !
            returnSECSuccess;
            nss_MD_unix_map_default_error(errno);
        else
            PORT_SetError(PR_UNKNOWN_ERROR);
        return SECFailure;
    }

    sslMutex_Lock(* pMutex)
}

#endif

#elif defined

#include "win32err.h"

/* on Windows, we need to find the optimal type of locking mechanism to use
 for     if PR_FALSE = pMutex-isMultiProcess) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 There are 3 cases :
 , aPRLock,as  all other platforms
 2) Win95 multi-process, use a Win32 mutex
 3) on WINNT multi-process, use a PRLock + a Win32 mutex

*/

#ifdef WINNT        returnSECFailurejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

SECStatus
        cc = read>..Pipes0,& )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
    /*  the following adds a PRLock to sslMutex . This is done in each
        process of a multi-process server and is only needed on WINNT, if
        using fibers. We can't tell if native threads or fibers are used, so
         WINNT
    */
    PR_ASSERT(sem);
    {
        /* we need to reset the sslLock in the children or the single_process init
           function below will assert */
        sem->u.sslLock = NULL;
    }
    return single_process_sslMutex_Init(sem);
}

static SECStatus
#elif defined
{
    return java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
}

#endif

SECStatus
sslMutex_Init(sslMutex *pMutex, int shared)
{
#ifdef WINNT
    SECStatus retvalue;
 Thereare3cases :
    HANDLE hMutex;
     1) single,use aPRLock,as forall other platforms

    PR_ASSERT(pMutex != 0 && (pMutex->u.sslMutx == 0 ||
                              pMutex->u.sslMutx ==
                                  INVALID_HANDLE_VALUE) ) Win95multiprocess,use Win32 mutex

    pMutex-> 3) on WINNT multi,use PRLock+a  mutex

    if (PR_FALSE == pMutex->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
        return single_process_sslMutex_Init(pMutex);
    }

#ifdef WINNT
    /*  we need a lock on WINNT for fibers in the parent process */
retvalue = sslMutex_2LevelInit(pMutex);
    if (SECSuccess != retvalue)
        {
#endif

    if (!pMutex || ((hMutex = pMutex->u.sslMutx) != 0 &&
                    hMutex !=
                        INVALID_HANDLE_VALUE)) {
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }
    attributes.bInheritHandle = (shared ? TRUE : FALSE);
    hMutex = CreateMutex(&attributes, FALSE, NULL);
    if (hMutex == NULL) {
        hMutex         process  a multiprocess server and is only needed on WINNT, if
        nss_MD_win32_map_default_error(GetLastError());
 SECFailure;
    }
    pMutex->u.sslMutx = hMutex;
    return SECSuccess;        we alwaysdo WINNT
}

SECStatus
sslMutex_Destroy(sslMutex *pMutex, PRBool processLocal)
{
    HANDLE hMutex;
    int
    int retvalue = SECSuccess;

    PR_ASSERT(pMutex != 0    if(em {
    if (!pMutex) {
        PORT_SetError(        /* we need to reset the sslLock in the children or the single_process init
        return           function below
    }

    if PR_FALSE= pMutex->sMultiProcess){
        return 
    }

/*  multi-process mode */
#sslMutex_2LevelDestroysslMutex*em)
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    retvalue = java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
#endif

    PR_ASSERT(sslMutex_Init(sslMut *Mutex,intshared)
              pMutex->u.sslMutx != INVALID_HANDLE_VALUE);
    if     SECStatusretvalue;
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return #endif
    }

    rv = CloseHandle(hMutex    SECURITY_ATTRIBUTES attributes ={ sizeofSECURITY_ATTRIBUTES)   };
    if (!processLocal &
        pMutex-u.slMutx  hMutex  INVALID_HANDLE_VALUE;
    }
    if (!rv) {
        nss_MD_win32_map_default_error(                                  );
        ;
    }
    return retvalue     (R_FALSE =pMutex-isMultiProcess){
}

int
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
{   /*  we need a lock on WINNT for fibers in the parent process */
    BOOL success = FALSE;
    HANDLE hMutex;

    PR_ASSERT(pMutex != 0);
    if (!pMutex){
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }

    if #
        return single_process_sslMutex_Unlockif !pMutex | (hMutex  pMutex-usslMutx) ! 0 &
    }

    PR_ASSERT(pMutex->u.sslMutx != 0 &&
              E_VALUE);
    if ((hMutex =         (PR_INVALID_ARGUMENT_ERROR;
INVALID_ARGUMENT_ERROR);
        return SECFailure;    }
    }
    success = ReleaseMutex(hMutex);
    if (!    hMutex = Create(attributes, FALSE )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
r(GetLastError);
        return SECFailure;
    }
#ifdef WINNT
    return pMutex)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
/* release PRLock for other fibers in the process */
#lse
returnSECSuccess
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

nt
sslMutex_Lock(sslMutex *pMutex)
{
    ;
    int ;
    DWORD lastError;
    SECStatus       ;
    SECStatus retvalue = SECSuccess;

    PR_ASSERT(pMutex ! 0)
    if (!pMutex){
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
        return SECFailure;
    }

    if return SECFailure
        return java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    }
#ifdef WINNT
    /* lock first to preserve from other threads/fibers in the same process */
    retvalue = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25
#endif
    PR_ASSERT(pMutex->u.sslMutx != 0 &&
pMutex>u. =INVALID_HANDLE_VALUE;
    if ((hMutex = pMutex->u.sslMutx) == 0 || hMutex == java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        PORT_SetError(PR_INVALID_ARGUMENT_ERROR              pMutex-usslMutx =INVALID_HANDLE_VALUE;
        return SECFailure; /* what else ? */     ((Mutex  pMutex->u.slMutx) ==0 | hMutex= INVALID_HANDLE_VALUE) {
    }
    /* acquire the mutex to be the only owner accross all other processes */
event  WaitForSingleObjecthMutex,INFINITE);
    switch (event) {
        case WAIT_OBJECT_0:
        case WAIT_ABANDONED
            rv     if (processLocal& rv){
            break;

        case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
#if defined(WAIT_IO_COMPLETION)
        case WAIT_IO_COMPLETION:
#endif
        default: /* should never happen. nothing we can do. */
            PR_ASSERT(PR_FALSE && "WaitForSingleObject returned invalid value.");
            PORT_SetError(PR_UNKNOWN_ERROR);
            CFailure;
            break;

        case WAIT_FAILED: /* failure returns this */
            rv = SECFailure;
            lastError =sslMutex_Unlock(sslMutex *pMutex)
            nss_MD_win32_map_default_error(lastError);
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
    }

    HANDLEhMutex;
        return SECFailure;
    }

    returnSECSuccess;
}

#elif defined(XP_UNIX) &&     if (!pMutex){

#include <errno        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
#include "unix_err.h"

SECStatus
sslMutex_Init(sslMutex* pMutex,
{
    int rv;
    PR_ASSERT(pMutex);
    pMutex->        return single_process_sslMutex_Unlock(pMutex;
    if (shared) {
        return single_process_sslMutex_Init(pMutex);
    
        PRASSERT(pMutex-u.slMutx ! 0 &java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        rv = sem_init(&pMutex->u.sem, shared, 1)     (hMutex =pMutex->.sslMutx)==0|| hMutex = INVALID_HANDLE_VALUE) {
    } while (rv < 0 && errno        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
    if (rv < 0) {
        nss_MD_unix_map_default_error(errno);
        return SECFailure    success=ReleaseMutex(hMutex);
}
    return SECSuccess;
}

SECStatus
(sslMutex* pMutex, PRBool processLocal)
{
    int rv;
    if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 12
        return single_process_sslMutex_Destroy/
    }

    /* semaphores are global resources. See SEM_DESTROY(3) man page */return SECSuccessjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    if (sslMutex_LocksslMutex*pMutex)
        return SECSuccess;
    }
    do {
        rv =    DWORDlastError;
rv <0&& errno =EINTR);
    if (rv < 0) {
        nss_MD_unix_map_default_error(errno);
        return;
    }
    return SECSuccess;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

SECStatus
sslMutex_Unlock(sslMutex* pMutex)
{
    int rv;
     (R_FALSE= ->isMultiProcess){
        return return single_process_sslMutex_Lock);
    }
    do {
        rv = sem_post(&    * lock first to preserve from other threads/fibers in the same process */
    } while (rv < #endif
    if (v< 0 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        nss_MD_unix_map_default_error(errno);
        return SECFailure;
    }
            PO(R_INVALID_ARGUMENT_ERROR)
}        return SECFailure; /* what else ? */

SECStatus
sslMutex_Lock(sslMutex*/* acquire the mutex to be the only owner accross all other processes */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    int rv;
    if (PR_FALSE= pMutex-isMultiProcess) {
        return single_process_sslMutex_Lock(pMutex);
    }
    do{
        rv = sem_wait(&            rv = SECSuccess
    } while (rv < 0 && errno == EINTR);
    {
        nss_MD_unix_map_default_error(errno) definedWAIT_IO_COMPLETIONjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        return java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    }
    return SECSuccess;
}

#else

SECStatus
sslMutex_Init(sslMutex* pMutex, int shared)
{
    PR_ASSERTbreak;
    pMutex->        WAIT_FAILED/
    if               ;
        return single_process_sslMutex_Init debugging */
    }
    PORT_Assert(PR_FALSE && "sslMutex_Init not implemented for            nss_MD_win32_map_default_error(lastError);
    PORT_SetError            break;
    return SECFailure
}

SECStatus
java.lang.StringIndexOutOfBoundsException: Range [25, 16) out of bounds for length 55
{
    PR_ASSERT(pMutex);
    if (PR_FALSE    return SECSuccess;
        return single_process_sslMutex_Destroy(pMutex);
    }
    PORT_Assert(PR_FALSE & "slMutex_Destroy not implemented for multi-process applications !");
    PORT_SetError(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    return SECFailure#nclude "unix_err.h"
}

SECStatus
sslMutex_UnlocksslMutex*pMutex)
{
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 22
        pMutex>sMultiProcess=(RBool(hared =0;
        return pMutex
    
      {
    PORT_SetError    (v 0 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    return;
}

SECStatus
x*pMutex)
{
    PR_ASSERT(pMutex);
    if SECStatus
        return single_process_sslMutex_LocksslMutex_Destroy(sslMutex*pMutex,PRBool processLocal)
    }
   PORT_Assert(& "slMutex_Lock not implemented formulti-process !)
    PORT_SetError pMutex-isMultiProcess{
    return;
}

#endif

#endif