PKIX_Error * PKIX_PL_RWLock_Create( PKIX_PL_RWLock **pNewLock, void *plContext) { PKIX_PL_RWLock *rwLock = NULL; PKIX_ENTER(RWLOCK, "PKIX_PL_RWLock_Create"); PKIX_NULLCHECK_ONE(pNewLock); PKIX_CHECK(PKIX_PL_Object_Alloc (PKIX_RWLOCK_TYPE, sizeof (PKIX_PL_RWLock), (PKIX_PL_Object **)&rwLock, plContext), PKIX_ERRORALLOCATINGRWLOCK); PKIX_RWLOCK_DEBUG("\tCalling PR_NewRWLock)\n"); rwLock->lock = PR_NewRWLock(PR_RWLOCK_RANK_NONE, "PKIX RWLock"); if (rwLock->lock == NULL) { PKIX_DECREF(rwLock); PKIX_ERROR(PKIX_OUTOFMEMORY); } rwLock->readCount = 0; rwLock->writeLocked = PKIX_FALSE; *pNewLock = rwLock; cleanup: PKIX_RETURN(RWLOCK); }
/* ** Add an sid to the cache or return a previously cached entry to the cache. ** Although this is static, it is called via ss->sec.cache(). */ static void CacheSID(sslSessionID *sid) { PRUint32 expirationPeriod; PORT_Assert(sid->cached == never_cached); SSL_TRC(8, ("SSL: Cache: sid=0x%x cached=%d addr=0x%08x%08x%08x%08x port=0x%04x " "time=%x cached=%d", sid, sid->cached, sid->addr.pr_s6_addr32[0], sid->addr.pr_s6_addr32[1], sid->addr.pr_s6_addr32[2], sid->addr.pr_s6_addr32[3], sid->port, sid->creationTime, sid->cached)); if (!sid->urlSvrName) { /* don't cache this SID because it can never be matched */ return; } /* XXX should be different trace for version 2 vs. version 3 */ if (sid->version < SSL_LIBRARY_VERSION_3_0) { expirationPeriod = ssl_sid_timeout; PRINT_BUF(8, (0, "sessionID:", sid->u.ssl2.sessionID, sizeof(sid->u.ssl2.sessionID))); PRINT_BUF(8, (0, "masterKey:", sid->u.ssl2.masterKey.data, sid->u.ssl2.masterKey.len)); PRINT_BUF(8, (0, "cipherArg:", sid->u.ssl2.cipherArg.data, sid->u.ssl2.cipherArg.len)); } else { if (sid->u.ssl3.sessionIDLength == 0 && sid->u.ssl3.locked.sessionTicket.ticket.data == NULL) return; /* Client generates the SessionID if this was a stateless resume. */ if (sid->u.ssl3.sessionIDLength == 0) { SECStatus rv; rv = PK11_GenerateRandom(sid->u.ssl3.sessionID, SSL3_SESSIONID_BYTES); if (rv != SECSuccess) return; sid->u.ssl3.sessionIDLength = SSL3_SESSIONID_BYTES; } expirationPeriod = ssl3_sid_timeout; PRINT_BUF(8, (0, "sessionID:", sid->u.ssl3.sessionID, sid->u.ssl3.sessionIDLength)); sid->u.ssl3.lock = PR_NewRWLock(PR_RWLOCK_RANK_NONE, NULL); if (!sid->u.ssl3.lock) { return; } } PORT_Assert(sid->creationTime != 0 && sid->expirationTime != 0); if (!sid->creationTime) sid->lastAccessTime = sid->creationTime = ssl_Time(); if (!sid->expirationTime) sid->expirationTime = sid->creationTime + expirationPeriod; /* * Put sid into the cache. Bump reference count to indicate that * cache is holding a reference. Uncache will reduce the cache * reference. */ LOCK_CACHE; sid->references++; sid->cached = in_client_cache; sid->next = cache; cache = sid; UNLOCK_CACHE; }
} extern "C" { void CSFLogRegisterThread(const cprThread_t thread); void CSFLogUnregisterThread(const cprThread_t thread); #ifndef WIN32 pthread_t cprGetThreadId(cprThread_t thread); #endif } #ifdef WIN32 typedef unsigned int thread_key_t; #else typedef pthread_t thread_key_t; #endif static PRRWLock *maplock = PR_NewRWLock(0,"thread map"); typedef std::map<thread_key_t,const cpr_thread_t*> threadMap_t; static threadMap_t threadMap; void CSFLogRegisterThread(const cprThread_t thread) { const cpr_thread_t *t = reinterpret_cast<cpr_thread_t *>(thread); thread_key_t key; #ifdef WIN32 key = t->threadId; #else key = cprGetThreadId(thread); #endif CSFLog(CSF_LOG_DEBUG, __FILE__, __LINE__, "log", "Registering new thread with logging system: %s", t->name); PR_RWLock_Wlock(maplock);