开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
sslsnce.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：54k
源码类别：

CA认证

开发平台：

WINDOWS

sslsnce.c：源码内容
  1. /* This file implements the SERVER Session ID cache. 
  2.  * NOTE:  The contents of this file are NOT used by the client.
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public
  5.  * License Version 1.1 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.mozilla.org/MPL/
  8.  * 
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  * 
  14.  * The Original Code is the Netscape security libraries.
  15.  * 
  16.  * The Initial Developer of the Original Code is Netscape
  17.  * Communications Corporation.  Portions created by Netscape are 
  18.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  19.  * Rights Reserved.
  20.  * 
  21.  * Contributor(s):
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the
  24.  * terms of the GNU General Public License Version 2 or later (the
  25.  * "GPL"), in which case the provisions of the GPL are applicable 
  26.  * instead of those above.  If you wish to allow use of your 
  27.  * version of this file only under the terms of the GPL and not to
  28.  * allow others to use your version of this file under the MPL,
  29.  * indicate your decision by deleting the provisions above and
  30.  * replace them with the notice and other provisions required by
  31.  * the GPL.  If you do not delete the provisions above, a recipient
  32.  * may use your version of this file under either the MPL or the
  33.  * GPL.
  34.  *
  35.  * $Id: sslsnce.c,v 1.4 2000/09/12 20:15:43 jgmyers%netscape.com Exp $
  36.  */
  38. /* Note: ssl_FreeSID() in sslnonce.c gets used for both client and server 
  39.  * cache sids!
  40.  *
  41.  * About record locking among different server processes:
  42.  *
  43.  * All processes that are part of the same conceptual server (serving on 
  44.  * the same address and port) MUST share a common SSL session cache. 
  45.  * This code makes the content of the shared cache accessible to all
  46.  * processes on the same "server".  This code works on Unix and Win32 only,
  47.  * and is platform specific. 
  48.  *
  49.  * Unix: Multiple processes share a single (inherited) FD for a disk 
  50.  * file all share one single file position.  If one lseeks, the position for 
  51.  * all processes is changed.  Since the set of platforms we support do not 
  52.  * all share portable lseek-and-read or lseek-and-write functions, a global 
  53.  * lock must be used to make the lseek call and the subsequent read or write 
  54.  * call be one atomic operation.  It is no longer necessary for cache element 
  55.  * sizes to be a power of 2, or a multiple of a sector size.
  56.  *
  57.  * For Win32, where (a) disk I/O is not atomic, and (b) we use memory-mapped
  58.  * files and move data to & from memory instead of calling read or write,
  59.  * we must do explicit locking of the records for all reads and writes.
  60.  * We have just one lock, for the entire file, using an NT semaphore.
  61.  * We avoid blocking on "local threads" since it's bad to block on a local 
  62.  * thread - If NSPR offered portable semaphores, it would handle this itself.
  63.  *
  64.  * Since this file has to do lots of platform specific I/O, the system
  65.  * dependent error codes need to be mapped back into NSPR error codes.
  66.  * Since NSPR's error mapping functions are private, the code is necessarily
  67.  * duplicated in libSSL.
  68.  *
  69.  * Note, now that NSPR provides portable anonymous shared memory, for all
  70.  * platforms except Mac, the implementation below should be replaced with 
  71.  * one that uses anonymous shared memory ASAP.  This will eliminate most 
  72.  * platform dependent code in this file, and improve performance big time.
  73.  *
  74.  * Now that NSPR offers portable cross-process locking (semaphores) on Unix
  75.  * and Win32, semaphores should be used here for all platforms.
  76.  */
  77. #include "seccomon.h"
  79. #if defined(XP_UNIX) || defined(XP_WIN32)
  80. #ifndef NADA_VERISON
  82. #include "cert.h"
  83. #include "ssl.h"
  84. #include "sslimpl.h"
  85. #include "sslproto.h"
  86. #include "pk11func.h"
  87. #include "base64.h"
  89. #include <stdio.h>
  91. #ifdef XP_UNIX
  93. #include <syslog.h>
  94. #include <fcntl.h>
  95. #include <unistd.h>
  96. #include "unix_err.h"
  98. #else /* XP_WIN32 */
  99. #ifdef MC_HTTPD
  100. #include <ereport.h>
  101. #endif /* MC_HTTPD */
  102. #include <wtypes.h>
  103. #include "win32err.h"
  104. #endif /* XP_WIN32 */
  105. #include <sys/types.h>
  107. #define SET_ERROR_CODE /* reminder */
  109. #include "nspr.h"
  110. #include "nsslocks.h"
  112. static PRLock *cacheLock;
  114. /*
  115. ** The server session-id cache uses a simple flat cache. The cache is
  116. ** sized during initialization. We hash the ip-address + session-id value
  117. ** into an index into the cache and do the lookup. No buckets, nothing
  118. ** fancy.
  119. */
  121. static PRBool isMultiProcess  = PR_FALSE;
  123. static PRUint32 numSIDCacheEntries  = 10000; 
  124. static PRUint32 sidCacheFileSize;
  125. static PRUint32 sidCacheWrapOffset;
  127. static PRUint32 numCertCacheEntries = 250;
  128. static PRUint32 certCacheFileSize;
  130. #define MIN_CERT_CACHE_ENTRIES 125 /* the effective size in old releases. */
  133. /*
  134. ** Format of a cache entry.
  135. */ 
  136. typedef struct SIDCacheEntryStr SIDCacheEntry;
  137. struct SIDCacheEntryStr {
  138.     PRIPv6Addr addr;
  139.     PRUint32 time;
  141.     union {
  142. struct {
  143.     /* This is gross.  We have to have version and valid in both arms
  144.      * of the union for alignment reasons.  This probably won't work
  145.      * on a 64-bit machine. XXXX
  146.      */
  147. /*  2 */    uint16        version;
  148. /*  1 */    unsigned char valid;
  149. /*  1 */    unsigned char cipherType;
  151. /* 16 */    unsigned char sessionID[SSL_SESSIONID_BYTES];
  152. /* 64 */    unsigned char masterKey[SSL_MAX_MASTER_KEY_BYTES];
  153. /* 32 */    unsigned char cipherArg[SSL_MAX_CYPHER_ARG_BYTES];
  155. /*  1 */    unsigned char masterKeyLen;
  156. /*  1 */    unsigned char keyBits;
  158. /*  1 */    unsigned char secretKeyBits;
  159. /*  1 */    unsigned char cipherArgLen;
  160. /*120 */} ssl2;
  162. struct {
  163. /*  2 */    uint16           version;
  164. /*  1 */    unsigned char    valid;
  165. /*  1 */    uint8            sessionIDLength;
  167. /* 32 */    unsigned char    sessionID[SSL3_SESSIONID_BYTES];
  169. /*  2 */    ssl3CipherSuite  cipherSuite;
  170. /*  2 */    uint16           compression;  /* SSL3CompressionMethod */
  172. /*122 */    ssl3SidKeys      keys; /* keys and ivs, wrapped as needed. */
  173. /*  4 */    PRUint32         masterWrapMech; 
  174. /*  4 */    SSL3KEAType      exchKeyType;
  176. /*  2 */    int16            certIndex;
  177. /*  1 */    uint8            hasFortezza;
  178. /*  1 */    uint8            resumable;
  179. } ssl3;
  180. /* We can't make this struct fit in 128 bytes 
  181.  * so, force the struct size up to the next power of two.
  182.  */
  183. struct {
  184.     unsigned char filler[256 - sizeof(PRIPv6Addr) - sizeof(PRUint32)];
  185. } force256;
  186.     } u;
  187. };
  190. typedef struct CertCacheEntryStr CertCacheEntry;
  192. /* The length of this struct is supposed to be a power of 2, e.g. 4KB */
  193. struct CertCacheEntryStr {
  194.     uint16        certLength; /*    2 */
  195.     uint16        sessionIDLength; /*    2 */
  196.     unsigned char sessionID[SSL3_SESSIONID_BYTES]; /*   32 */
  197.     unsigned char cert[SSL_MAX_CACHED_CERT_LEN]; /* 4060 */
  198. }; /* total   4096 */
  201. static void IOError(int rv, char *type);
  202. static PRUint32 Offset(const PRIPv6Addr *addr, unsigned char *s, unsigned nl);
  203. static void Invalidate(SIDCacheEntry *sce);
  204. /************************************************************************/
  206. static const char envVarName[] = { SSL_ENV_VAR_NAME };
  208. #ifdef _WIN32
  210. struct winInheritanceStr {
  211.     PRUint32 numSIDCacheEntries;
  212.     PRUint32 sidCacheFileSize;
  213.     PRUint32 sidCacheWrapOffset;
  214.     PRUint32 numCertCacheEntries;
  215.     PRUint32 certCacheFileSize;
  217.     DWORD         parentProcessID;
  218.     HANDLE        parentProcessHandle;
  219.     HANDLE        SIDCacheFDMAP;
  220.     HANDLE        certCacheFDMAP;
  221.     HANDLE        svrCacheSem;
  222. };
  223. typedef struct winInheritanceStr winInheritance;
  225. static HANDLE svrCacheSem    = INVALID_HANDLE_VALUE;
  227. static char * SIDCacheData    = NULL;
  228. static HANDLE SIDCacheFD      = INVALID_HANDLE_VALUE;
  229. static HANDLE SIDCacheFDMAP   = INVALID_HANDLE_VALUE;
  231. static char * certCacheData   = NULL;
  232. static HANDLE certCacheFD     = INVALID_HANDLE_VALUE;
  233. static HANDLE certCacheFDMAP  = INVALID_HANDLE_VALUE;
  235. static PRUint32 myPid;
  237. /* The presence of the TRUE element in this struct makes the semaphore 
  238.  * inheritable. The NULL means use process's default security descriptor. 
  239.  */
  240. static SECURITY_ATTRIBUTES semaphoreAttributes = 
  241. { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
  243. static SECURITY_ATTRIBUTES sidCacheFDMapAttributes = 
  244. { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
  246. static SECURITY_ATTRIBUTES certCacheFDMapAttributes = 
  247. { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
  249. #define DEFAULT_CACHE_DIRECTORY "\temp"
  251. static SECStatus
  252. createServerCacheSemaphore(void)
  253. {
  254.     PR_ASSERT(svrCacheSem == INVALID_HANDLE_VALUE);
  256.     /* inheritable, starts signalled, 1 signal max, no file name. */
  257.     svrCacheSem = CreateSemaphore(&semaphoreAttributes, 1, 1, NULL);
  258.     if (svrCacheSem == NULL) {
  259. svrCacheSem = INVALID_HANDLE_VALUE;
  260. /* We could get the error code, but what could be do with it ? */
  261. nss_MD_win32_map_default_error(GetLastError());
  262.      return SECFailure;
  263.     }
  264.     return SECSuccess;
  265. }
  267. static SECStatus
  268. _getServerCacheSemaphore(void)
  269. {
  270.     DWORD     event;
  271.     DWORD     lastError;
  272.     SECStatus rv;
  274.     PR_ASSERT(svrCacheSem != INVALID_HANDLE_VALUE);
  275.     if (svrCacheSem == INVALID_HANDLE_VALUE &&
  276.      SECSuccess   != createServerCacheSemaphore()) {
  277. return SECFailure; /* what else ? */
  278.     }
  279.     event = WaitForSingleObject(svrCacheSem, INFINITE);
  280.     switch (event) {
  281.     case WAIT_OBJECT_0:
  282.     case WAIT_ABANDONED:
  283. rv = SECSuccess;
  284.      break;
  286.     case WAIT_TIMEOUT:
  287.     case WAIT_IO_COMPLETION:
  288.     default:  /* should never happen. nothing we can do. */
  289. PR_ASSERT(("WaitForSingleObject returned invalid value.", 0));
  290. /* fall thru */
  292.     case WAIT_FAILED: /* failure returns this */
  293. rv = SECFailure;
  294. lastError = GetLastError(); /* for debugging */
  295. nss_MD_win32_map_default_error(lastError);
  296. break;
  297.     }
  298.     return rv;
  299. }
  301. static void
  302. _doGetServerCacheSemaphore(void * arg)
  303. {
  304.     SECStatus * rv = (SECStatus *)arg;
  305.     *rv = _getServerCacheSemaphore();
  306. }
  308. static SECStatus
  309. getServerCacheSemaphore(void)
  310. {
  311.     PRThread *    selectThread;
  312.     PRThread *    me     = PR_GetCurrentThread();
  313.     PRThreadScope scope  = PR_GetThreadScope(me);
  314.     SECStatus     rv     = SECFailure;
  316.     if (scope == PR_GLOBAL_THREAD) {
  317.         rv = _getServerCacheSemaphore();
  318.     } else {
  319.         selectThread = PR_CreateThread(PR_USER_THREAD,
  320.        _doGetServerCacheSemaphore, &rv,
  321.        PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
  322.        PR_JOINABLE_THREAD, 0);
  323.         if (selectThread != NULL) {
  324.     /* rv will be set by _doGetServerCacheSemaphore() */
  325.     PR_JoinThread(selectThread);
  326.         }
  327.     }
  328.     return rv;
  329. }
  331. static SECStatus
  332. releaseServerCacheSemaphore(void)
  333. {
  334.     BOOL success = FALSE;
  336.     PR_ASSERT(svrCacheSem != INVALID_HANDLE_VALUE);
  337.     if (svrCacheSem != INVALID_HANDLE_VALUE) {
  338. /* Add 1, don't want previous value. */
  339. success = ReleaseSemaphore(svrCacheSem, 1, NULL);
  340.     }
  341.     if (!success) {
  342. nss_MD_win32_map_default_error(GetLastError());
  343. return SECFailure;
  344.     }
  345.     return SECSuccess;
  346. }
  348. static void
  349. destroyServerCacheSemaphore(void)
  350. {
  351.     PR_ASSERT(svrCacheSem != INVALID_HANDLE_VALUE);
  352.     if (svrCacheSem != INVALID_HANDLE_VALUE) {
  353. CloseHandle(svrCacheSem);
  354. /* ignore error */
  355. svrCacheSem = INVALID_HANDLE_VALUE;
  356.     }
  357. }
  359. #define GET_SERVER_CACHE_READ_LOCK(fd, offset, size) 
  360.     if (isMultiProcess) getServerCacheSemaphore();
  362. #define GET_SERVER_CACHE_WRITE_LOCK(fd, offset, size) 
  363.     if (isMultiProcess) getServerCacheSemaphore();
  365. #define RELEASE_SERVER_CACHE_LOCK(fd, offset, size) 
  366.     if (isMultiProcess) releaseServerCacheSemaphore();
  368. #endif /* _win32 */
  370. /************************************************************************/
  372. #ifdef XP_UNIX
  373. static int    SIDCacheFD      = -1;
  374. static int    certCacheFD     = -1;
  376. static pid_t  myPid;
  378. struct unixInheritanceStr {
  379.     PRUint32 numSIDCacheEntries;
  380.     PRUint32 sidCacheFileSize;
  381.     PRUint32 sidCacheWrapOffset;
  382.     PRUint32 numCertCacheEntries;
  383.     PRUint32 certCacheFileSize;
  385.     PRInt32  SIDCacheFD;
  386.     PRInt32  certCacheFD;
  387. };
  389. typedef struct unixInheritanceStr unixInheritance;
  392. #define DEFAULT_CACHE_DIRECTORY "/tmp"
  394. #ifdef TRACE
  395. static void 
  396. fcntlFailed(struct flock *lock) 
  397. {
  398.     fprintf(stderr,
  399.     "fcntl failed, errno = %d, PR_GetError = %d, lock.l_type = %dn",
  400. errno, PR_GetError(), lock->l_type);
  401.     fflush(stderr);
  402. }
  403. #define FCNTL_FAILED(lock) fcntlFailed(lock)
  404. #else
  405. #define FCNTL_FAILED(lock) 
  406. #endif
  408. /* NOTES:  Because there are no atomic seek-and-read and seek-and-write
  409. ** functions that are supported on all our UNIX platforms, we need
  410. ** to prevent all simultaeous seek-and-read operations.  For that reason,
  411. ** we use mutually exclusive (write) locks for read and write operations,
  412. ** and use them all at the same offset (zero).
  413. */
  414. static SECStatus
  415. _getServerCacheLock(int fd, short type, PRUint32 offset, PRUint32 size)
  416. {
  417.     int          result;
  418.     struct flock lock;
  420.     memset(&lock, 0, sizeof lock);
  421.     lock.l_type   = /* type */ F_WRLCK;
  422.     lock.l_whence = SEEK_SET; /* absolute file offsets. */
  423.     lock.l_start  = 0;
  424.     lock.l_len    = 128;
  426. #ifdef TRACE
  427.     if (ssl_trace) {
  428. fprintf(stderr, "%d: %s lock, offset %8x, size %4dn", myPid,
  429.     (type == F_RDLCK) ? "read " : "write", offset, size);
  430. fflush(stderr);
  431.     }
  432. #endif
  433.     result = fcntl(fd, F_SETLKW, &lock);
  434.     if (result == -1) {
  435.         nss_MD_unix_map_default_error(errno);
  436. FCNTL_FAILED(&lock);
  437.      return SECFailure;
  438.     }
  439. #ifdef TRACE
  440.     if (ssl_trace) {
  441. fprintf(stderr, "%d:   got lock, offset %8x, size %4dn", 
  442.     myPid, offset, size);
  443. fflush(stderr);
  444.     }
  445. #endif
  446.     return SECSuccess;
  447. }
  449. typedef struct sslLockArgsStr {
  450.     PRUint32    offset;
  451.     PRUint32    size;
  452.     PRErrorCode err;
  453.     SECStatus   rv;
  454.     int         fd;
  455.     short       type;
  456. } sslLockArgs;
  458. static void
  459. _doGetServerCacheLock(void * arg)
  460. {
  461.     sslLockArgs * args = (sslLockArgs *)arg;
  462.     args->rv = _getServerCacheLock(args->fd, args->type, args->offset, 
  463.    args->size );
  464.     if (args->rv != SECSuccess) {
  465. args->err = PR_GetError();
  466.     }
  467. }
  469. static SECStatus
  470. getServerCacheLock(int fd, short type, PRUint32 offset, PRUint32 size)
  471. {
  472.     PRThread *    selectThread;
  473.     PRThread *    me     = PR_GetCurrentThread();
  474.     PRThreadScope scope  = PR_GetThreadScope(me);
  475.     SECStatus     rv     = SECFailure;
  477.     if (scope == PR_GLOBAL_THREAD) {
  478.         rv = _getServerCacheLock(fd, type, offset, size);
  479.     } else {
  480. /* Ib some platforms, one thread cannot read local/automatic 
  481. ** variables from another thread's stack.  So, get this space
  482. ** from the heap, not the stack.
  483. */
  484. sslLockArgs * args = PORT_New(sslLockArgs);
  486. if (!args)
  487.     return rv;
  489. args->offset = offset;
  490. args->size   = size;
  491. args->rv     = SECFailure;
  492. args->fd     = fd;
  493. args->type   = type;
  494.         selectThread = PR_CreateThread(PR_USER_THREAD,
  495.        _doGetServerCacheLock, args,
  496.        PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
  497.        PR_JOINABLE_THREAD, 0);
  498.         if (selectThread != NULL) {
  499.     /* rv will be set by _doGetServerCacheLock() */
  500.     PR_JoinThread(selectThread);
  501.     rv = args->rv;
  502.     if (rv != SECSuccess) {
  503. PORT_SetError(args->err);
  504.     }
  505.         }
  506. PORT_Free(args);
  507.     }
  508.     return rv;
  509. }
  511. static SECStatus
  512. releaseServerCacheLock(int fd, PRUint32 offset, PRUint32 size)
  513. {
  514.     int          result;
  515.     struct flock lock;
  517.     memset(&lock, 0, sizeof lock);
  518.     lock.l_type   = F_UNLCK;
  519.     lock.l_whence = SEEK_SET; /* absolute file offsets. */
  520.     lock.l_start  = 0;
  521.     lock.l_len    = 128;
  523. #ifdef TRACE
  524.     if (ssl_trace) {
  525. fprintf(stderr, "%d:     unlock, offset %8x, size %4dn", 
  526.     myPid, offset, size);
  527. fflush(stderr);
  528.     }
  529. #endif
  530.     result = fcntl(fd, F_SETLK, &lock);
  531.     if (result == -1) {
  532.         nss_MD_unix_map_default_error(errno);
  533. FCNTL_FAILED(&lock);
  534.      return SECFailure;
  535.     }
  536.     return SECSuccess;
  537. }
  540. /* these defines take the arguments needed to do record locking, 
  541.  * however the present implementation does only file locking.
  542.  */
  544. #define GET_SERVER_CACHE_READ_LOCK( fd, offset, size) 
  545.     if (isMultiProcess) getServerCacheLock(fd, F_RDLCK, offset, size);
  547. #define GET_SERVER_CACHE_WRITE_LOCK(fd, offset, size) 
  548.     if (isMultiProcess) getServerCacheLock(fd, F_WRLCK, offset, size);
  550. #define RELEASE_SERVER_CACHE_LOCK(  fd, offset, size) 
  551.     if (isMultiProcess) releaseServerCacheLock(fd, offset, size);
  553. /*
  554. ** Zero a file out to nb bytes
  555. */
  556. static SECStatus 
  557. ZeroFile(int fd, int nb)
  558. {
  559.     off_t off;
  560.     int amount, rv;
  561.     char buf[16384];
  563.     PORT_Memset(buf, 0, sizeof(buf));
  564.     off = lseek(fd, 0, SEEK_SET);
  565.     if (off != 0) {
  566. if (off == -1) 
  567.     nss_MD_unix_map_lseek_error(errno);
  568.      else
  569.     PORT_SetError(PR_FILE_SEEK_ERROR);
  570.      return SECFailure;
  571.     }
  573.     while (nb > 0) {
  574. amount = (nb > sizeof buf) ? sizeof buf : nb;
  575. rv = write(fd, buf, amount);
  576. if (rv <= 0) {
  577.     if (!rv)
  578.      PORT_SetError(PR_IO_ERROR);
  579.     else
  580. nss_MD_unix_map_write_error(errno);
  581.     IOError(rv, "zero-write");
  582.     return SECFailure;
  583. }
  584. nb -= rv;
  585.     }
  586.     return SECSuccess;
  587. }
  589. #endif /* XP_UNIX */
  592. /************************************************************************/
  594. /*
  595. ** Reconstitute a cert from the cache
  596. ** This is only called from ConvertToSID().
  597. ** Caller must hold the cache lock before calling this.
  598. */
  599. static CERTCertificate *
  600. GetCertFromCache(SIDCacheEntry *sce, CERTCertDBHandle *dbHandle)
  601. {
  602.     CERTCertificate *cert;
  603.     PRUint32         offset;
  604.     int              rv;
  605. #ifdef XP_UNIX
  606.     off_t            off;
  607. #endif
  608.     SECItem          derCert;
  609.     CertCacheEntry   cce;
  611.     offset = (PRUint32)sce->u.ssl3.certIndex * sizeof(CertCacheEntry);
  612.     GET_SERVER_CACHE_READ_LOCK(certCacheFD, offset, sizeof(CertCacheEntry));
  613. #ifdef XP_UNIX
  614.     off = lseek(certCacheFD, offset, SEEK_SET);
  615.     rv = -1;
  616.     if (off != offset) {
  617. if (off == -1) 
  618.     nss_MD_unix_map_lseek_error(errno);
  619. else 
  620.     PORT_SetError(PR_FILE_SEEK_ERROR);
  621.     } else {
  622. rv = read(certCacheFD, &cce, sizeof(CertCacheEntry));
  623. if (rv != sizeof(CertCacheEntry)) {
  624.     if (rv == -1)
  625. nss_MD_unix_map_read_error(errno);
  626.     else
  627.      PORT_SetError(PR_IO_ERROR);
  628. }
  629.     }
  630. #else /* XP_WIN32 */
  631.     /* Use memory mapped I/O and just memcpy() the data */
  632.     CopyMemory(&cce, &certCacheData[offset], sizeof(CertCacheEntry));
  633.     rv = sizeof cce;
  634. #endif /* XP_WIN32 */
  635.     RELEASE_SERVER_CACHE_LOCK(certCacheFD, offset, sizeof(CertCacheEntry))
  637.     if (rv != sizeof(CertCacheEntry)) {
  638. IOError(rv, "read"); /* error set above */
  639. return NULL;
  640.     }
  642.     /* See if the session ID matches with that in the sce cache. */
  643.     if((cce.sessionIDLength != sce->u.ssl3.sessionIDLength) ||
  644.        PORT_Memcmp(cce.sessionID, sce->u.ssl3.sessionID, cce.sessionIDLength)) {
  645.         /* this is a cache miss, not an error */
  646. PORT_SetError(SSL_ERROR_SESSION_NOT_FOUND);
  647. return NULL;
  648.     }
  650.     derCert.len  = cce.certLength;
  651.     derCert.data = cce.cert;
  653.     cert = CERT_NewTempCertificate(dbHandle, &derCert, NULL,
  654.    PR_FALSE, PR_TRUE);
  656.     return cert;
  657. }
  659. /* Put a certificate in the cache.  We assume that the certIndex in
  660. ** sid is valid.
  661. */
  662. static void
  663. CacheCert(CERTCertificate *cert, SIDCacheEntry *sce)
  664. {
  665.     PRUint32       offset;
  666.     CertCacheEntry cce;
  667. #ifdef XP_UNIX
  668.     off_t          off;
  669.     int            rv;
  670. #endif
  672.     offset = (PRUint32)sce->u.ssl3.certIndex * sizeof(CertCacheEntry);
  673.     if (cert->derCert.len > SSL_MAX_CACHED_CERT_LEN)
  674. return;
  675.     
  676.     cce.sessionIDLength = sce->u.ssl3.sessionIDLength;
  677.     PORT_Memcpy(cce.sessionID, sce->u.ssl3.sessionID, cce.sessionIDLength);
  679.     cce.certLength = cert->derCert.len;
  680.     PORT_Memcpy(cce.cert, cert->derCert.data, cce.certLength);
  682.     GET_SERVER_CACHE_WRITE_LOCK(certCacheFD, offset, sizeof cce);
  683. #ifdef XP_UNIX
  684.     off = lseek(certCacheFD, offset, SEEK_SET);
  685.     if (off != offset) {
  686. if (off == -1) 
  687.     nss_MD_unix_map_lseek_error(errno);
  688. else 
  689.     PORT_SetError(PR_FILE_SEEK_ERROR);
  690.     } else {
  691. rv = write(certCacheFD, &cce, sizeof cce);
  692. if (rv != sizeof(CertCacheEntry)) {
  693.     if (rv == -1)
  694. nss_MD_unix_map_write_error(errno);
  695.     else
  696.      PORT_SetError(PR_IO_ERROR);
  697.     IOError(rv, "cert-write");
  698.     Invalidate(sce);
  699. }
  700.     }
  701. #else /* WIN32 */
  702.     /* Use memory mapped I/O and just memcpy() the data */
  703.     CopyMemory(&certCacheData[offset], &cce, sizeof cce);
  704. #endif /* XP_UNIX */
  706.     RELEASE_SERVER_CACHE_LOCK(certCacheFD, offset, sizeof cce);
  707.     return;
  708. }
  710. /*
  711. ** Convert memory based SID to file based one
  712. */
  713. static void 
  714. ConvertFromSID(SIDCacheEntry *to, sslSessionID *from)
  715. {
  716.     to->u.ssl2.valid = 1;
  717.     to->u.ssl2.version = from->version;
  718.     to->addr = from->addr;
  719.     to->time = from->time;
  721.     if (from->version < SSL_LIBRARY_VERSION_3_0) {
  722. if ((from->u.ssl2.masterKey.len > SSL_MAX_MASTER_KEY_BYTES) ||
  723.     (from->u.ssl2.cipherArg.len > SSL_MAX_CYPHER_ARG_BYTES)) {
  724.     SSL_DBG(("%d: SSL: masterKeyLen=%d cipherArgLen=%d",
  725.      myPid, from->u.ssl2.masterKey.len,
  726.      from->u.ssl2.cipherArg.len));
  727.     to->u.ssl2.valid = 0;
  728.     return;
  729. }
  731. to->u.ssl2.cipherType    = from->u.ssl2.cipherType;
  732. to->u.ssl2.masterKeyLen  = from->u.ssl2.masterKey.len;
  733. to->u.ssl2.cipherArgLen  = from->u.ssl2.cipherArg.len;
  734. to->u.ssl2.keyBits       = from->u.ssl2.keyBits;
  735. to->u.ssl2.secretKeyBits = from->u.ssl2.secretKeyBits;
  736. PORT_Memcpy(to->u.ssl2.sessionID, from->u.ssl2.sessionID,
  737.   sizeof(to->u.ssl2.sessionID));
  738. PORT_Memcpy(to->u.ssl2.masterKey, from->u.ssl2.masterKey.data,
  739.   from->u.ssl2.masterKey.len);
  740. PORT_Memcpy(to->u.ssl2.cipherArg, from->u.ssl2.cipherArg.data,
  741.   from->u.ssl2.cipherArg.len);
  742. #ifdef DEBUG
  743. PORT_Memset(to->u.ssl2.masterKey+from->u.ssl2.masterKey.len, 0,
  744.   sizeof(to->u.ssl2.masterKey) - from->u.ssl2.masterKey.len);
  745. PORT_Memset(to->u.ssl2.cipherArg+from->u.ssl2.cipherArg.len, 0,
  746.   sizeof(to->u.ssl2.cipherArg) - from->u.ssl2.cipherArg.len);
  747. #endif
  748. SSL_TRC(8, ("%d: SSL: ConvertSID: masterKeyLen=%d cipherArgLen=%d "
  749.     "time=%d addr=0x%08x%08x%08x%08x cipherType=%d", myPid,
  750.     to->u.ssl2.masterKeyLen, to->u.ssl2.cipherArgLen,
  751.     to->time, to->addr.pr_s6_addr32[0], 
  752.     to->addr.pr_s6_addr32[1], to->addr.pr_s6_addr32[2],
  753.     to->addr.pr_s6_addr32[3], to->u.ssl2.cipherType));
  754.     } else {
  755. /* This is an SSL v3 session */
  757. to->u.ssl3.sessionIDLength  = from->u.ssl3.sessionIDLength;
  758. to->u.ssl3.cipherSuite      = from->u.ssl3.cipherSuite;
  759. to->u.ssl3.compression      = (uint16)from->u.ssl3.compression;
  760. to->u.ssl3.resumable        = from->u.ssl3.resumable;
  761. to->u.ssl3.hasFortezza      = from->u.ssl3.hasFortezza;
  762. to->u.ssl3.keys             = from->u.ssl3.keys;
  763. to->u.ssl3.masterWrapMech   = from->u.ssl3.masterWrapMech;
  764. to->u.ssl3.exchKeyType      = from->u.ssl3.exchKeyType;
  766. PORT_Memcpy(to->u.ssl3.sessionID, 
  767.             from->u.ssl3.sessionID,
  768.     from->u.ssl3.sessionIDLength);
  770. SSL_TRC(8, ("%d: SSL3: ConvertSID: time=%d addr=0x%08x%08x%08x%08x cipherSuite=%d",
  771.     myPid, to->time, to->addr.pr_s6_addr32[0],
  772.     to->addr.pr_s6_addr32[1], to->addr.pr_s6_addr32[2],
  773.     to->addr.pr_s6_addr32[3], to->u.ssl3.cipherSuite));
  774.     }
  775. }
  777. /*
  778. ** Convert file based cache-entry to memory based one
  779. ** This is only called from ServerSessionIDLookup().
  780. ** Caller must hold cache lock when calling this.
  781. */
  782. static sslSessionID *
  783. ConvertToSID(SIDCacheEntry *from, CERTCertDBHandle * dbHandle)
  784. {
  785.     sslSessionID *to;
  786.     uint16 version = from->u.ssl2.version;
  788.     to = (sslSessionID*) PORT_ZAlloc(sizeof(sslSessionID));
  789.     if (!to) {
  790. return 0;
  791.     }
  793.     if (version < SSL_LIBRARY_VERSION_3_0) {
  794. /* This is an SSL v2 session */
  795. to->u.ssl2.masterKey.data =
  796.     (unsigned char*) PORT_Alloc(from->u.ssl2.masterKeyLen);
  797. if (!to->u.ssl2.masterKey.data) {
  798.     goto loser;
  799. }
  800. if (from->u.ssl2.cipherArgLen) {
  801.     to->u.ssl2.cipherArg.data = (unsigned char*)
  802. PORT_Alloc(from->u.ssl2.cipherArgLen);
  803.     if (!to->u.ssl2.cipherArg.data) {
  804. goto loser;
  805.     }
  806.     PORT_Memcpy(to->u.ssl2.cipherArg.data, from->u.ssl2.cipherArg,
  807.       from->u.ssl2.cipherArgLen);
  808. }
  810. to->u.ssl2.cipherType    = from->u.ssl2.cipherType;
  811. to->u.ssl2.masterKey.len = from->u.ssl2.masterKeyLen;
  812. to->u.ssl2.cipherArg.len = from->u.ssl2.cipherArgLen;
  813. to->u.ssl2.keyBits       = from->u.ssl2.keyBits;
  814. to->u.ssl2.secretKeyBits = from->u.ssl2.secretKeyBits;
  815. PORT_Memcpy(to->u.ssl2.sessionID, from->u.ssl2.sessionID,
  816.   sizeof from->u.ssl2.sessionID);
  817. PORT_Memcpy(to->u.ssl2.masterKey.data, from->u.ssl2.masterKey,
  818.   from->u.ssl2.masterKeyLen);
  820. SSL_TRC(8, ("%d: SSL: ConvertToSID: masterKeyLen=%d cipherArgLen=%d "
  821.     "time=%d addr=0x%08x%08x%08x%08x cipherType=%d",
  822.     myPid, to->u.ssl2.masterKey.len,
  823.     to->u.ssl2.cipherArg.len, to->time, 
  824.     to->addr.pr_s6_addr32[0], to->addr.pr_s6_addr32[1],
  825.     to->addr.pr_s6_addr32[2], to->addr.pr_s6_addr32[3], 
  826.     to->u.ssl2.cipherType));
  827.     } else {
  828. /* This is an SSL v3 session */
  830. to->u.ssl3.sessionIDLength  = from->u.ssl3.sessionIDLength;
  831. to->u.ssl3.cipherSuite      = from->u.ssl3.cipherSuite;
  832. to->u.ssl3.compression      = (SSL3CompressionMethod)from->u.ssl3.compression;
  833. to->u.ssl3.resumable        = from->u.ssl3.resumable;
  834. to->u.ssl3.hasFortezza      = from->u.ssl3.hasFortezza;
  835. to->u.ssl3.keys             = from->u.ssl3.keys;
  836. to->u.ssl3.masterWrapMech   = from->u.ssl3.masterWrapMech;
  837. to->u.ssl3.exchKeyType      = from->u.ssl3.exchKeyType;
  839. PORT_Memcpy(to->u.ssl3.sessionID, 
  840.             from->u.ssl3.sessionID,
  841.     from->u.ssl3.sessionIDLength);
  843. /* the portions of the SID that are only restored on the client
  844.  * are set to invalid values on the server.
  845.  */
  846. to->u.ssl3.clientWriteKey   = NULL;
  847. to->u.ssl3.serverWriteKey   = NULL;
  848. to->u.ssl3.tek              = NULL;
  849. to->urlSvrName              = NULL;
  851. to->u.ssl3.masterModuleID   = (SECMODModuleID)-1; /* invalid value */
  852. to->u.ssl3.masterSlotID     = (CK_SLOT_ID)-1;     /* invalid value */
  853. to->u.ssl3.masterWrapIndex  = 0;
  854. to->u.ssl3.masterWrapSeries = 0;
  855. to->u.ssl3.masterValid      = PR_FALSE;
  857. to->u.ssl3.clAuthModuleID   = (SECMODModuleID)-1; /* invalid value */
  858. to->u.ssl3.clAuthSlotID     = (CK_SLOT_ID)-1;     /* invalid value */
  859. to->u.ssl3.clAuthSeries     = 0;
  860. to->u.ssl3.clAuthValid      = PR_FALSE;
  862. to->u.ssl3.clientWriteSaveLen = 0;
  864. if (from->u.ssl3.certIndex != -1) {
  865.     to->peerCert = GetCertFromCache(from, dbHandle);
  866.     if (to->peerCert == NULL)
  867. goto loser;
  868. }
  869.     }
  871.     to->version    = from->u.ssl2.version;
  872.     to->time       = from->time;
  873.     to->cached     = in_server_cache;
  874.     to->addr       = from->addr;
  875.     to->references = 1;
  876.     
  877.     return to;
  879.   loser:
  880.     Invalidate(from);
  881.     if (to) {
  882. if (version < SSL_LIBRARY_VERSION_3_0) {
  883.     if (to->u.ssl2.masterKey.data)
  884. PORT_Free(to->u.ssl2.masterKey.data);
  885.     if (to->u.ssl2.cipherArg.data)
  886. PORT_Free(to->u.ssl2.cipherArg.data);
  887. }
  888. PORT_Free(to);
  889.     }
  890.     return NULL;
  891. }
  894. /* Invalidate a SID cache entry. 
  895.  * Called from CacheCert, ConvertToSid, and ServerSessionIDUncache. 
  896.  */
  897. static void 
  898. Invalidate(SIDCacheEntry *sce)
  899. {
  900.     PRUint32 offset;
  901. #ifdef XP_UNIX
  902.     off_t off;
  903.     int  rv;
  904. #endif
  906.     if (sce == NULL) return;
  908.     if (sce->u.ssl2.version < SSL_LIBRARY_VERSION_3_0) {
  909. offset = Offset(&sce->addr, sce->u.ssl2.sessionID,
  910. sizeof sce->u.ssl2.sessionID); 
  911.     } else {
  912. offset = Offset(&sce->addr, sce->u.ssl3.sessionID,
  913. sce->u.ssl3.sessionIDLength); 
  914.     }
  916.     sce->u.ssl2.valid = 0;
  917.     SSL_TRC(7, ("%d: SSL: uncaching session-id at offset %ld",
  918.     myPid, offset));
  920.     GET_SERVER_CACHE_WRITE_LOCK(SIDCacheFD, offset, sizeof *sce);
  922. #ifdef XP_UNIX
  923.     off = lseek(SIDCacheFD, offset, SEEK_SET);
  924.     if (off != offset) {
  925. if (off == -1) 
  926.     nss_MD_unix_map_lseek_error(errno);
  927. else 
  928.     PORT_SetError(PR_FILE_SEEK_ERROR);
  929.     } else {
  930. rv = write(SIDCacheFD, sce, sizeof *sce);
  931. if (rv != sizeof *sce) {
  932.     if (rv == -1)
  933. nss_MD_unix_map_write_error(errno);
  934.     else
  935.      PORT_SetError(PR_IO_ERROR);
  936.     IOError(rv, "invalidate-write");
  937.      }
  938.     }
  939. #else /* WIN32 */
  940.     /* Use memory mapped I/O and just memcpy() the data */
  941.     CopyMemory(&SIDCacheData[offset], sce, sizeof *sce);
  942. #endif /* XP_UNIX */
  944.     RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof *sce);
  945. }
  948. static void 
  949. IOError(int rv, char *type)
  950. {
  951. #ifdef XP_UNIX
  952.     syslog(LOG_ALERT,
  953.    "SSL: %s error with session-id cache, pid=%d, rv=%d, error='%m'",
  954.    type, myPid, rv);
  955. #else /* XP_WIN32 */
  956. #ifdef MC_HTTPD 
  957.     ereport(LOG_FAILURE, "%s error with session-id cache rv=%dn",type, rv);
  958. #endif /* MC_HTTPD */
  959. #endif /* XP_UNIX */
  960. }
  962. static void 
  963. lock_cache(void)
  964. {
  965.     PR_Lock(cacheLock);
  966. }
  968. static void 
  969. unlock_cache(void)
  970. {
  971.     PR_Unlock(cacheLock);
  972. }
  974. /*
  975. ** Perform some mumbo jumbo on the ip-address and the session-id value to
  976. ** compute a hash value.
  977. */
  978. static PRUint32 
  979. Offset(const PRIPv6Addr *addr, unsigned char *s, unsigned nl)
  980. {
  981.     PRUint32 rv;
  983.     rv = addr->pr_s6_addr32[3] ^ (((PRUint32)s[0] << 24) | ((PRUint32)s[1] << 16)
  984.  | (s[2] << 8) | s[nl-1]);
  985.     return (rv % numSIDCacheEntries) * sizeof(SIDCacheEntry);
  986. }
  990. /*
  991. ** Look something up in the cache. This will invalidate old entries
  992. ** in the process. Caller has locked the cache!
  993. ** Returns PR_TRUE if found a valid match.  PR_FALSE otherwise.
  994. */
  995. static PRBool 
  996. FindSID(const PRIPv6Addr *addr, unsigned char *sessionID,
  997. unsigned sessionIDLength, SIDCacheEntry *sce)
  998. {
  999.     PRUint32      offset;
  1000.     PRUint32      now;
  1001.     int           rv;
  1002. #ifdef XP_UNIX
  1003.     off_t         off;
  1004. #endif
  1006.     /* Read in cache entry after hashing ip address and session-id value */
  1007.     offset = Offset(addr, sessionID, sessionIDLength); 
  1008.     now = ssl_Time();
  1009.     GET_SERVER_CACHE_READ_LOCK(SIDCacheFD, offset, sizeof *sce);
  1010. #ifdef XP_UNIX
  1011.     off = lseek(SIDCacheFD, offset, SEEK_SET);
  1012.     rv = -1;
  1013.     if (off != offset) {
  1014. if (off == -1) 
  1015.     nss_MD_unix_map_lseek_error(errno);
  1016. else 
  1017.     PORT_SetError(PR_FILE_SEEK_ERROR);
  1018.     } else {
  1019. rv = read(SIDCacheFD, sce, sizeof *sce);
  1020. if (rv != sizeof *sce) {
  1021.     if (rv == -1) 
  1022. nss_MD_unix_map_read_error(errno);
  1023.     else 
  1024. PORT_SetError(PR_IO_ERROR);
  1025.      }
  1026.     }
  1027. #else /* XP_WIN32 */
  1028.     /* Use memory mapped I/O and just memcpy() the data */
  1029.     CopyMemory(sce, &SIDCacheData[offset], sizeof *sce);
  1030.     rv = sizeof *sce;
  1031. #endif /* XP_WIN32 */
  1032.     RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof *sce);
  1034.     if (rv != sizeof *sce) {
  1035. IOError(rv, "server sid cache read");
  1036. return PR_FALSE;
  1037.     }
  1039.     if (!sce->u.ssl2.valid) {
  1040. /* Entry is not valid */
  1041. PORT_SetError(SSL_ERROR_SESSION_NOT_FOUND);
  1042. return PR_FALSE;
  1043.     }
  1045.     if (((sce->u.ssl2.version < SSL_LIBRARY_VERSION_3_0) &&
  1046.  (now > sce->time + ssl_sid_timeout)) ||
  1047. ((sce->u.ssl2.version >= SSL_LIBRARY_VERSION_3_0) &&
  1048.  (now > sce->time + ssl3_sid_timeout))) {
  1049. /* SessionID has timed out. Invalidate the entry. */
  1050. SSL_TRC(7, ("%d: timed out sid entry addr=%08x%08x%08x%08x now=%x time+=%x",
  1051.     myPid, sce->addr.pr_s6_addr32[0],
  1052.     sce->addr.pr_s6_addr32[1], sce->addr.pr_s6_addr32[2],
  1053.     sce->addr.pr_s6_addr32[3], now, 
  1054.     sce->time + ssl_sid_timeout));
  1055. sce->u.ssl2.valid = 0;
  1057. GET_SERVER_CACHE_WRITE_LOCK(SIDCacheFD, offset, sizeof *sce);
  1058. #ifdef XP_UNIX
  1059. off = lseek(SIDCacheFD, offset, SEEK_SET);
  1060. rv = -1;
  1061. if (off != offset) {
  1062.     if (off == -1) 
  1063. nss_MD_unix_map_lseek_error(errno);
  1064.     else
  1065.      PORT_SetError(PR_IO_ERROR);
  1066. } else {
  1067.     rv = write(SIDCacheFD, sce, sizeof *sce);
  1068.     if (rv != sizeof *sce) {
  1069. if (rv == -1) 
  1070.     nss_MD_unix_map_write_error(errno);
  1071. else 
  1072.     PORT_SetError(PR_IO_ERROR);
  1073. IOError(rv, "timeout-write");
  1074.     }
  1075. }
  1076. #else /* WIN32 */
  1077. /* Use memory mapped I/O and just memcpy() the data */
  1078. CopyMemory(&SIDCacheData[offset], sce, sizeof *sce);
  1079. rv = sizeof *sce;
  1080. #endif /* XP_UNIX */
  1081. RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof *sce);
  1082. if (rv == sizeof *sce)
  1083.     PORT_SetError(SSL_ERROR_SESSION_NOT_FOUND);
  1084. return PR_FALSE;
  1085.     }
  1087.     /*
  1088.     ** Finally, examine specific session-id/addr data to see if the cache
  1089.     ** entry matches our addr+session-id value
  1090.     */
  1091.     if (!memcmp(&sce->addr, addr, sizeof(PRIPv6Addr)) &&
  1092. (PORT_Memcmp(sce->u.ssl2.sessionID, sessionID, sessionIDLength) == 0)) {
  1093. /* Found it */
  1094. return PR_TRUE;
  1095.     }
  1096.     PORT_SetError(SSL_ERROR_SESSION_NOT_FOUND);
  1097.     return PR_FALSE;
  1098. }
  1100. /************************************************************************/
  1102. /* This is the primary function for finding entries in the server's sid cache.
  1103.  * Although it is static, this function is called via the global function 
  1104.  * pointer ssl_sid_lookup.
  1105.  */
  1106. static sslSessionID *
  1107. ServerSessionIDLookup( const PRIPv6Addr  *addr,
  1108. unsigned char *sessionID,
  1109. unsigned int   sessionIDLength,
  1110.                         CERTCertDBHandle * dbHandle)
  1111. {
  1112.     SIDCacheEntry sce;
  1113.     sslSessionID *sid;
  1115.     sid = 0;
  1116.     lock_cache();
  1117.     if (FindSID(addr, sessionID, sessionIDLength, &sce)) {
  1118. /* Found it. Convert file format to internal format */
  1119. sid = ConvertToSID(&sce, dbHandle);
  1120.     }
  1121.     unlock_cache();
  1122.     return sid;
  1123. }
  1125. /*
  1126. ** Place an sid into the cache, if it isn't already there. Note that if
  1127. ** some other server process has replaced a session-id cache entry that has
  1128. ** the same cache index as this sid, then all is ok. Somebody has to lose
  1129. ** when this condition occurs, so it might as well be this sid.
  1130. */
  1131. static void 
  1132. ServerSessionIDCache(sslSessionID *sid)
  1133. {
  1134.     SIDCacheEntry sce;
  1135.     PRUint32      offset;
  1136. #ifdef XP_UNIX
  1137.     off_t         off;
  1138.     int           rv;
  1139. #endif
  1140.     uint16 version = sid->version;
  1142.     if ((version >= SSL_LIBRARY_VERSION_3_0) &&
  1143. (sid->u.ssl3.sessionIDLength == 0)) {
  1144. return;
  1145.     }
  1147.     if (sid->cached == never_cached || sid->cached == invalid_cache) {
  1148. lock_cache();
  1150. sid->time = ssl_Time();
  1151. if (version < SSL_LIBRARY_VERSION_3_0) {
  1152.     SSL_TRC(8, ("%d: SSL: CacheMT: cached=%d addr=0x%08x%08x%08x%08x time=%x "
  1153. "cipher=%d", myPid, sid->cached, 
  1154. sid->addr.pr_s6_addr32[0], sid->addr.pr_s6_addr32[1],
  1155. sid->addr.pr_s6_addr32[2], sid->addr.pr_s6_addr32[3],
  1156. sid->time, sid->u.ssl2.cipherType));
  1157.     PRINT_BUF(8, (0, "sessionID:", sid->u.ssl2.sessionID,
  1158.   sizeof(sid->u.ssl2.sessionID)));
  1159.     PRINT_BUF(8, (0, "masterKey:", sid->u.ssl2.masterKey.data,
  1160.   sid->u.ssl2.masterKey.len));
  1161.     PRINT_BUF(8, (0, "cipherArg:", sid->u.ssl2.cipherArg.data,
  1162.   sid->u.ssl2.cipherArg.len));
  1164.     /* Write out new cache entry */
  1165.     offset = Offset(&sid->addr, sid->u.ssl2.sessionID,
  1166.     sizeof(sid->u.ssl2.sessionID)); 
  1167. } else {
  1168.     SSL_TRC(8, ("%d: SSL: CacheMT: cached=%d addr=0x%08x%08x%08x%08x time=%x "
  1169. "cipherSuite=%d", myPid, sid->cached, 
  1170. sid->addr.pr_s6_addr32[0], sid->addr.pr_s6_addr32[1],
  1171. sid->addr.pr_s6_addr32[2], sid->addr.pr_s6_addr32[3], 
  1172. sid->time, sid->u.ssl3.cipherSuite));
  1173.     PRINT_BUF(8, (0, "sessionID:", sid->u.ssl3.sessionID,
  1174.   sid->u.ssl3.sessionIDLength));
  1176.     offset = Offset(&sid->addr, sid->u.ssl3.sessionID,
  1177.     sid->u.ssl3.sessionIDLength);
  1178.     
  1179. }
  1181. ConvertFromSID(&sce, sid);
  1182. if (version >= SSL_LIBRARY_VERSION_3_0) {
  1183.     if (sid->peerCert == NULL) {
  1184. sce.u.ssl3.certIndex = -1;
  1185.     } else {
  1186. sce.u.ssl3.certIndex = (int16)
  1187.     ((offset / sizeof(SIDCacheEntry)) % numCertCacheEntries);
  1188.     }
  1189. }
  1191. GET_SERVER_CACHE_WRITE_LOCK(SIDCacheFD, offset, sizeof sce);
  1192. #ifdef XP_UNIX
  1193. off = lseek(SIDCacheFD, offset, SEEK_SET);
  1194. if (off != offset) {
  1195.     if (off == -1) 
  1196. nss_MD_unix_map_lseek_error(errno);
  1197.     else
  1198.      PORT_SetError(PR_IO_ERROR);
  1199. } else {
  1200.     rv = write(SIDCacheFD, &sce, sizeof sce);
  1201.     if (rv != sizeof(sce)) {
  1202. if (rv == -1) 
  1203.     nss_MD_unix_map_write_error(errno);
  1204. else 
  1205.     PORT_SetError(PR_IO_ERROR);
  1206. IOError(rv, "update-write");
  1207.     }
  1208. }
  1209. #else /* WIN32 */
  1210. CopyMemory(&SIDCacheData[offset], &sce, sizeof sce);
  1211. #endif /* XP_UNIX */
  1212. RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof sce);
  1214. if ((version >= SSL_LIBRARY_VERSION_3_0) && 
  1215.     (sid->peerCert != NULL)) {
  1216.     CacheCert(sid->peerCert, &sce);
  1217. }
  1219. sid->cached = in_server_cache;
  1220. unlock_cache();
  1221.     }
  1222. }
  1224. static void 
  1225. ServerSessionIDUncache(sslSessionID *sid)
  1226. {
  1227.     SIDCacheEntry sce;
  1228.     PRErrorCode   err;
  1229.     int rv;
  1231.     if (sid == NULL) return;
  1232.     
  1233.     /* Uncaching a SID should never change the error code. 
  1234.     ** So save it here and restore it before exiting.
  1235.     */
  1236.     err = PR_GetError();
  1237.     lock_cache();
  1238.     if (sid->version < SSL_LIBRARY_VERSION_3_0) {
  1239. SSL_TRC(8, ("%d: SSL: UncacheMT: valid=%d addr=0x%08x%08x%08x%08x time=%x "
  1240.     "cipher=%d", myPid, sid->cached, 
  1241.     sid->addr.pr_s6_addr32[0], sid->addr.pr_s6_addr32[1],
  1242.     sid->addr.pr_s6_addr32[2], sid->addr.pr_s6_addr32[3], 
  1243.     sid->time, sid->u.ssl2.cipherType));
  1244. PRINT_BUF(8, (0, "sessionID:", sid->u.ssl2.sessionID,
  1245.       sizeof(sid->u.ssl2.sessionID)));
  1246. PRINT_BUF(8, (0, "masterKey:", sid->u.ssl2.masterKey.data,
  1247.       sid->u.ssl2.masterKey.len));
  1248. PRINT_BUF(8, (0, "cipherArg:", sid->u.ssl2.cipherArg.data,
  1249.       sid->u.ssl2.cipherArg.len));
  1250. rv = FindSID(&sid->addr, sid->u.ssl2.sessionID,
  1251.      sizeof(sid->u.ssl2.sessionID), &sce);
  1252.     } else {
  1253. SSL_TRC(8, ("%d: SSL3: UncacheMT: valid=%d addr=0x%08x%08x%08x%08x time=%x "
  1254.     "cipherSuite=%d", myPid, sid->cached, 
  1255.     sid->addr.pr_s6_addr32[0], sid->addr.pr_s6_addr32[1],
  1256.     sid->addr.pr_s6_addr32[2], sid->addr.pr_s6_addr32[3], 
  1257.     sid->time, sid->u.ssl3.cipherSuite));
  1258. PRINT_BUF(8, (0, "sessionID:", sid->u.ssl3.sessionID,
  1259.       sid->u.ssl3.sessionIDLength));
  1260. rv = FindSID(&sid->addr, sid->u.ssl3.sessionID,
  1261.      sid->u.ssl3.sessionIDLength, &sce);
  1262.     }
  1263.     
  1264.     if (rv) {
  1265. Invalidate(&sce);
  1266.     }
  1267.     sid->cached = invalid_cache;
  1268.     unlock_cache();
  1269.     PORT_SetError(err);
  1270. }
  1272. static SECStatus
  1273. InitSessionIDCache(int maxCacheEntries, PRUint32 timeout,
  1274.    PRUint32 ssl3_timeout, const char *directory)
  1275. {
  1276.     char *cfn;
  1277. #ifdef XP_UNIX
  1278.     int rv;
  1279.     if (SIDCacheFD >= 0) {
  1280. /* Already done */
  1281. return SECSuccess;
  1282.     }
  1283. #else /* WIN32 */
  1284. if(SIDCacheFDMAP != INVALID_HANDLE_VALUE) {
  1285. /* Already done */
  1286. return SECSuccess;
  1287. }
  1288. #endif /* XP_UNIX */
  1291.     if (maxCacheEntries) {
  1292. numSIDCacheEntries = maxCacheEntries;
  1293.     }
  1294.     sidCacheWrapOffset = numSIDCacheEntries * sizeof(SIDCacheEntry);
  1295.     sidCacheFileSize = sidCacheWrapOffset +
  1296.          (kt_kea_size * SSL_NUM_WRAP_MECHS * sizeof(SSLWrappedSymWrappingKey));
  1298.     /* Create file names */
  1299.     cfn = (char*) PORT_Alloc(PORT_Strlen(directory) + 100);
  1300.     if (!cfn) {
  1301. return SECFailure;
  1302.     }
  1303. #ifdef XP_UNIX
  1304.     sprintf(cfn, "%s/.sslsidc.%d", directory, getpid());
  1305. #else /* XP_WIN32 */
  1306. sprintf(cfn, "%s\ssl.sidc.%d.%d", directory,
  1307. GetCurrentProcessId(), GetCurrentThreadId());
  1308. #endif /* XP_WIN32 */
  1310.     /* Create session-id cache file */
  1311. #ifdef XP_UNIX
  1312.     do {
  1313. (void) unlink(cfn);
  1314. SIDCacheFD = open(cfn, O_EXCL|O_CREAT|O_RDWR, 0600);
  1315.     } while (SIDCacheFD < 0 && errno == EEXIST);
  1316.     if (SIDCacheFD < 0) {
  1317. nss_MD_unix_map_open_error(errno);
  1318. IOError(SIDCacheFD, "create");
  1319. goto loser;
  1320.     }
  1321.     rv = unlink(cfn);
  1322.     if (rv < 0) {
  1323. nss_MD_unix_map_unlink_error(errno);
  1324. IOError(rv, "unlink");
  1325. goto loser;
  1326.     }
  1327. #else  /* WIN32 */
  1328.     SIDCacheFDMAP = 
  1329.      CreateFileMapping(INVALID_HANDLE_VALUE, /* allocate in swap file */
  1330.   &sidCacheFDMapAttributes, /* inheritable. */
  1331.   PAGE_READWRITE,
  1332.   0,                    /* size, high word. */
  1333.   sidCacheFileSize,     /* size, low  word. */
  1334.   NULL); /* no map name in FS */
  1335.     if(! SIDCacheFDMAP) {
  1336. nss_MD_win32_map_default_error(GetLastError());
  1337. goto loser;
  1338.     }
  1339.     SIDCacheData = (char *)MapViewOfFile(SIDCacheFDMAP, 
  1340.                                          FILE_MAP_ALL_ACCESS,  /* R/W    */
  1341.  0, 0,  /* offset */
  1342.          sidCacheFileSize); /* size   */
  1343.     if (! SIDCacheData) {
  1344. nss_MD_win32_map_default_error(GetLastError());
  1345. goto loser;
  1346.     }
  1347. #endif /* XP_UNIX */
  1349.     if (!cacheLock)
  1350. nss_InitLock(&cacheLock);
  1351.     if (!cacheLock) {
  1352. SET_ERROR_CODE
  1353. goto loser;
  1354.     }
  1355. #ifdef _WIN32
  1356.     if (isMultiProcess  && (SECSuccess != createServerCacheSemaphore())) {
  1357. SET_ERROR_CODE
  1358. goto loser;
  1359.     }
  1360. #endif
  1362.     if (timeout) {   
  1363. if (timeout > 100) {
  1364.     timeout = 100;
  1365. }
  1366. if (timeout < 5) {
  1367.     timeout = 5;
  1368. }
  1369. ssl_sid_timeout = timeout;
  1370.     }
  1372.     if (ssl3_timeout) {   
  1373. if (ssl3_timeout > 86400L) {
  1374.     ssl3_timeout = 86400L;
  1375. }
  1376. if (ssl3_timeout < 5) {
  1377.     ssl3_timeout = 5;
  1378. }
  1379. ssl3_sid_timeout = ssl3_timeout;
  1380.     }
  1382.     GET_SERVER_CACHE_WRITE_LOCK(SIDCacheFD, 0, sidCacheFileSize);
  1383. #ifdef XP_UNIX
  1384.     /* Initialize the files */
  1385.     if (ZeroFile(SIDCacheFD, sidCacheFileSize)) {
  1386. /* Bummer */
  1387. close(SIDCacheFD);
  1388. SIDCacheFD = -1;
  1389. goto loser;
  1390.     }
  1391. #else /* XP_WIN32 */
  1392.     ZeroMemory(SIDCacheData, sidCacheFileSize);
  1393. #endif /* XP_UNIX */
  1394.     RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, 0, sidCacheFileSize);
  1395.     PORT_Free(cfn);
  1396.     return SECSuccess;
  1398.   loser:
  1399. #ifdef _WIN32
  1400.     if (svrCacheSem)
  1401. destroyServerCacheSemaphore();
  1402. #endif
  1403.     if (cacheLock) {
  1404. PR_DestroyLock(cacheLock);
  1405. cacheLock = NULL;
  1406.     }
  1407.     PORT_Free(cfn);
  1408.     return SECFailure;
  1409. }
  1411. static SECStatus 
  1412. InitCertCache(const char *directory)
  1413. {
  1414.     char *cfn;
  1415. #ifdef XP_UNIX
  1416.     int rv;
  1417.     if (certCacheFD >= 0) {
  1418. /* Already done */
  1419. return SECSuccess;
  1420.     }
  1421. #else /* WIN32 */
  1422.     if(certCacheFDMAP != INVALID_HANDLE_VALUE) {
  1423. /* Already done */
  1424. return SECSuccess;
  1425.     }
  1426. #endif /* XP_UNIX */
  1428.     numCertCacheEntries = sidCacheFileSize / sizeof(CertCacheEntry);
  1429.     if (numCertCacheEntries < MIN_CERT_CACHE_ENTRIES)
  1430.      numCertCacheEntries = MIN_CERT_CACHE_ENTRIES;
  1431.     certCacheFileSize = numCertCacheEntries * sizeof(CertCacheEntry);
  1433.     /* Create file names */
  1434.     cfn = (char*) PORT_Alloc(PORT_Strlen(directory) + 100);
  1435.     if (!cfn) {
  1436. return SECFailure;
  1437.     }
  1438. #ifdef XP_UNIX
  1439.     sprintf(cfn, "%s/.sslcertc.%d", directory, getpid());
  1440. #else /* XP_WIN32 */
  1441.     sprintf(cfn, "%s\ssl.certc.%d.%d", directory,
  1442.     GetCurrentProcessId(), GetCurrentThreadId());
  1443. #endif /* XP_WIN32 */
  1445.     /* Create certificate cache file */
  1446. #ifdef XP_UNIX
  1447.     do {
  1448. (void) unlink(cfn);
  1449. certCacheFD = open(cfn, O_EXCL|O_CREAT|O_RDWR, 0600);
  1450.     } while (certCacheFD < 0 && errno == EEXIST);
  1451.     if (certCacheFD < 0) {
  1452. nss_MD_unix_map_open_error(errno);
  1453. IOError(certCacheFD, "create");
  1454. goto loser;
  1455.     }
  1456.     rv = unlink(cfn);
  1457.     if (rv < 0) {
  1458. nss_MD_unix_map_unlink_error(errno);
  1459. IOError(rv, "unlink");
  1460. goto loser;
  1461.     }
  1462. #else  /* WIN32 */
  1463.     certCacheFDMAP = 
  1464.      CreateFileMapping(INVALID_HANDLE_VALUE, /* allocate in swap file */
  1465.   &certCacheFDMapAttributes, /* inheritable. */
  1466.   PAGE_READWRITE,
  1467.   0,                /* size, high word. */
  1468.   certCacheFileSize, /* size, low word. */
  1469.   NULL);           /* no map name in FS */
  1470.     if (! certCacheFDMAP) {
  1471. nss_MD_win32_map_default_error(GetLastError());
  1472. goto loser;
  1473.     }
  1474.     certCacheData = (char *) MapViewOfFile(certCacheFDMAP, 
  1475.                                            FILE_MAP_ALL_ACCESS, /* R/W    */
  1476.    0, 0,  /* offset */
  1477.    certCacheFileSize); /* size   */
  1478.     if (! certCacheData) {
  1479. nss_MD_win32_map_default_error(GetLastError());
  1480. goto loser;
  1481.     }
  1482. #endif /* XP_UNIX */
  1484. /*  GET_SERVER_CACHE_WRITE_LOCK(certCacheFD, 0, certCacheFileSize); */
  1485. #ifdef XP_UNIX
  1486.     /* Initialize the files */
  1487.     if (ZeroFile(certCacheFD, certCacheFileSize)) {
  1488. /* Bummer */
  1489. close(certCacheFD);
  1490. certCacheFD = -1;
  1491. goto loser;
  1492.     }
  1493. #else /* XP_WIN32 */
  1494.     ZeroMemory(certCacheData, certCacheFileSize);
  1495. #endif /* XP_UNIX */
  1496. /*  RELEASE_SERVER_CACHE_LOCK(certCacheFD, 0, certCacheFileSize);   */
  1497.     PORT_Free(cfn);
  1498.     return SECSuccess;
  1500.   loser:
  1501.     PORT_Free(cfn);
  1502.     return SECFailure;
  1503. }
  1505. int
  1506. SSL_ConfigServerSessionIDCache( int      maxCacheEntries, 
  1507. PRUint32 timeout,
  1508.         PRUint32 ssl3_timeout, 
  1509.   const char *   directory)
  1510. {
  1511.     SECStatus rv;
  1513.     PORT_Assert(sizeof(SIDCacheEntry) == 256);
  1514.     PORT_Assert(sizeof(CertCacheEntry) == 4096);
  1516.     myPid = SSL_GETPID();
  1517.     if (!directory) {
  1518. directory = DEFAULT_CACHE_DIRECTORY;
  1519.     }
  1520.     rv = InitSessionIDCache(maxCacheEntries, timeout, ssl3_timeout, directory);
  1521.     if (rv) {
  1522. SET_ERROR_CODE
  1523.      return SECFailure;
  1524.     }
  1525.     rv = InitCertCache(directory);
  1526.     if (rv) {
  1527. SET_ERROR_CODE
  1528.      return SECFailure;
  1529.     }
  1531.     ssl_sid_lookup  = ServerSessionIDLookup;
  1532.     ssl_sid_cache   = ServerSessionIDCache;
  1533.     ssl_sid_uncache = ServerSessionIDUncache;
  1534.     return SECSuccess;
  1535. }
  1537. /* Use this function, instead of SSL_ConfigServerSessionIDCache,
  1538.  * if the cache will be shared by multiple processes.
  1539.  */
  1540. int
  1541. SSL_ConfigMPServerSIDCache( int      maxCacheEntries, 
  1542. PRUint32 timeout,
  1543.         PRUint32 ssl3_timeout, 
  1544.           const char *   directory)
  1545. {
  1546.     char * envValue;
  1547.     int  result;
  1548.     SECStatus putEnvFailed;
  1550.     isMultiProcess = PR_TRUE;
  1551.     result = SSL_ConfigServerSessionIDCache(maxCacheEntries, timeout, 
  1552.                                             ssl3_timeout, directory);
  1553.     if (result == SECSuccess) {
  1554. #ifdef _WIN32
  1555. winInheritance winherit;
  1557. winherit.numSIDCacheEntries = numSIDCacheEntries;
  1558. winherit.sidCacheFileSize = sidCacheFileSize;
  1559. winherit.sidCacheWrapOffset = sidCacheWrapOffset;
  1560. winherit.numCertCacheEntries = numCertCacheEntries;
  1561. winherit.certCacheFileSize = certCacheFileSize;
  1562. winherit.SIDCacheFDMAP = SIDCacheFDMAP;
  1563. winherit.certCacheFDMAP = certCacheFDMAP;
  1564. winherit.svrCacheSem = svrCacheSem;
  1565. winherit.parentProcessID = GetCurrentProcessId();
  1566. winherit.parentProcessHandle = 
  1567.     OpenProcess(PROCESS_DUP_HANDLE, TRUE, winherit.parentProcessID);
  1568.         if (winherit.parentProcessHandle == NULL) {
  1569.     SET_ERROR_CODE
  1570.     return SECFailure;
  1571. }
  1572.         envValue = BTOA_DataToAscii((unsigned char *)&winherit, 
  1573.                              sizeof winherit);
  1574.      if (!envValue) {
  1575.     SET_ERROR_CODE
  1576.     return SECFailure;
  1577. }
  1578. #else
  1579. unixInheritance uinherit;
  1581. uinherit.numSIDCacheEntries = numSIDCacheEntries;
  1582. uinherit.sidCacheFileSize = sidCacheFileSize;
  1583. uinherit.sidCacheWrapOffset = sidCacheWrapOffset;
  1584. uinherit.numCertCacheEntries = numCertCacheEntries;
  1585. uinherit.certCacheFileSize = certCacheFileSize;
  1586. uinherit.SIDCacheFD = SIDCacheFD;
  1587. uinherit.certCacheFD = certCacheFD;
  1589.         envValue = BTOA_DataToAscii((unsigned char *)&uinherit, 
  1590.                              sizeof uinherit);
  1591.      if (!envValue) {
  1592.     SET_ERROR_CODE
  1593.     return SECFailure;
  1594. }
  1595. #endif
  1596.     }
  1597.     putEnvFailed = (SECStatus)NSS_PutEnv(envVarName, envValue);
  1598.     PORT_Free(envValue);
  1599.     if (putEnvFailed) {
  1600.         SET_ERROR_CODE
  1601.         result = SECFailure;
  1602.     }
  1603.     return result;
  1604. }
  1606. SECStatus
  1607. SSL_InheritMPServerSIDCache(const char * envString)
  1608. {
  1609.     unsigned char * decoString = NULL;
  1610.     unsigned int    decoLen;
  1611. #ifdef _WIN32
  1612.     winInheritance  inherit;
  1613. #else
  1614.     unixInheritance inherit;
  1615. #endif
  1617.     myPid = SSL_GETPID();
  1618.     if (isMultiProcess)
  1619.      return SECSuccess; /* already done. */
  1621.     ssl_sid_lookup  = ServerSessionIDLookup;
  1622.     ssl_sid_cache   = ServerSessionIDCache;
  1623.     ssl_sid_uncache = ServerSessionIDUncache;
  1625.     if (!envString) {
  1626.      envString  = getenv(envVarName);
  1627. if (!envString) {
  1628.     SET_ERROR_CODE
  1629.     return SECFailure;
  1630. }
  1631.     }
  1633.     decoString = ATOB_AsciiToData(envString, &decoLen);
  1634.     if (!decoString) {
  1635.      SET_ERROR_CODE
  1636. return SECFailure;
  1637.     }
  1638.     if (decoLen != sizeof inherit) {
  1639.      SET_ERROR_CODE
  1640.      goto loser;
  1641.     }
  1643.     PORT_Memcpy(&inherit, decoString, sizeof inherit);
  1644.     PORT_Free(decoString);
  1646.     numSIDCacheEntries = inherit.numSIDCacheEntries;
  1647.     sidCacheFileSize = inherit.sidCacheFileSize;
  1648.     sidCacheWrapOffset = inherit.sidCacheWrapOffset;
  1649.     numCertCacheEntries = inherit.numCertCacheEntries;
  1650.     certCacheFileSize = inherit.certCacheFileSize;
  1652. #ifdef _WIN32
  1653.     SIDCacheFDMAP = inherit.SIDCacheFDMAP;
  1654.     certCacheFDMAP = inherit.certCacheFDMAP;
  1655.     svrCacheSem = inherit.svrCacheSem;
  1657. #if 0
  1658.     /* call DuplicateHandle ?? */
  1659.     inherit.parentProcessID;
  1660.     inherit.parentProcessHandle;
  1661. #endif
  1663.     if(!SIDCacheFDMAP) {
  1664.      SET_ERROR_CODE
  1665.      goto loser;
  1666.     }
  1667.     SIDCacheData = (char *)MapViewOfFile(SIDCacheFDMAP, 
  1668.                                          FILE_MAP_ALL_ACCESS,  /* R/W    */
  1669.  0, 0,  /* offset */
  1670.          sidCacheFileSize); /* size   */
  1671.     if(!SIDCacheData) {
  1672. nss_MD_win32_map_default_error(GetLastError());
  1673.      goto loser;
  1674.     }
  1676.     if(!certCacheFDMAP) {
  1677.      SET_ERROR_CODE
  1678.      goto loser;
  1679.     }
  1680.     certCacheData = (char *) MapViewOfFile(certCacheFDMAP, 
  1681.                                            FILE_MAP_ALL_ACCESS, /* R/W    */
  1682.    0, 0,  /* offset */
  1683.    certCacheFileSize); /* size   */
  1684.     if(!certCacheData) {
  1685. nss_MD_win32_map_default_error(GetLastError());
  1686.      goto loser;
  1687.     }
  1689. #else /* must be unix */
  1690.     SIDCacheFD = inherit.SIDCacheFD;
  1691.     certCacheFD = inherit.certCacheFD;
  1692.     if (SIDCacheFD < 0 || certCacheFD < 0) {
  1693.      SET_ERROR_CODE
  1694.      goto loser;
  1695.     }
  1696. #endif
  1698.     if (!cacheLock) {
  1699. nss_InitLock(&cacheLock);
  1700. if (!cacheLock) 
  1701.     goto loser;
  1702.     }
  1703.     isMultiProcess = PR_TRUE;
  1704.     return SECSuccess;
  1706. loser:
  1707.     if (decoString) 
  1708. PORT_Free(decoString);
  1709. #if _WIN32
  1710.     if (SIDCacheFDMAP) {
  1711. CloseHandle(SIDCacheFDMAP);
  1712. SIDCacheFDMAP = NULL;
  1713.     }
  1714.     if (certCacheFDMAP) {
  1715. CloseHandle(certCacheFDMAP);
  1716. certCacheFDMAP = NULL;
  1717.     }
  1718. #else
  1719.     if (SIDCacheFD >= 0) {
  1720. close(SIDCacheFD);
  1721. SIDCacheFD = -1;
  1722.     }
  1723.     if (certCacheFD >= 0) {
  1724. close(certCacheFD);
  1725. certCacheFD = -1;
  1726.     }
  1727. #endif
  1728.     return SECFailure;
  1730. }
  1732. /************************************************************************
  1733.  *  Code dealing with shared wrapped symmetric wrapping keys below      *
  1734.  ************************************************************************/
  1737. static PRBool
  1738. getWrappingKey(PRInt32                   symWrapMechIndex,
  1739.                SSL3KEAType               exchKeyType, 
  1740.                SSLWrappedSymWrappingKey *wswk, 
  1741.                PRBool                    grabSharedLock)
  1742. {
  1743.     PRUint32      offset = sidCacheWrapOffset + 
  1744.        ((exchKeyType * SSL_NUM_WRAP_MECHS + symWrapMechIndex) *
  1745.    sizeof(SSLWrappedSymWrappingKey));
  1746.     PRBool        rv     = PR_TRUE;
  1747. #ifdef XP_UNIX
  1748.     off_t         lrv;
  1749.     ssize_t       rrv;
  1750. #endif
  1752.     if (grabSharedLock) {
  1753. GET_SERVER_CACHE_READ_LOCK(SIDCacheFD, offset, sizeof *wswk);
  1754.     }
  1756. #ifdef XP_UNIX
  1757.     lrv = lseek(SIDCacheFD, offset, SEEK_SET);
  1758.     if (lrv != offset) {
  1759. if (lrv == -1) 
  1760.     nss_MD_unix_map_lseek_error(errno);
  1761. else
  1762.     PORT_SetError(PR_IO_ERROR);
  1763.     IOError(rv, "wrapping-read");
  1764. rv = PR_FALSE;
  1765.     } else {
  1766. rrv = read(SIDCacheFD, wswk, sizeof *wswk);
  1767. if (rrv != sizeof *wswk) {
  1768.     if (rrv == -1) 
  1769. nss_MD_unix_map_read_error(errno);
  1770.     else 
  1771. PORT_SetError(PR_IO_ERROR);
  1772.     IOError(rv, "wrapping-read");
  1773.     rv = PR_FALSE;
  1774. }
  1775.     }
  1776. #else /* XP_WIN32 */
  1777.     /* Use memory mapped I/O and just memcpy() the data */
  1778.     CopyMemory(wswk, &SIDCacheData[offset], sizeof *wswk);
  1779. #endif /* XP_WIN32 */
  1780.     if (grabSharedLock) {
  1781. RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof *wswk);
  1782.     }
  1783.     if (rv) {
  1784.      if (wswk->exchKeyType      != exchKeyType || 
  1785.     wswk->symWrapMechIndex != symWrapMechIndex ||
  1786.     wswk->wrappedSymKeyLen == 0) {
  1787.     memset(wswk, 0, sizeof *wswk);
  1788.     rv = PR_FALSE;
  1789. }
  1790.     }
  1791.     return rv;
  1792. }
  1794. PRBool
  1795. ssl_GetWrappingKey( PRInt32                   symWrapMechIndex,
  1796.                     SSL3KEAType               exchKeyType, 
  1797.     SSLWrappedSymWrappingKey *wswk)
  1798. {
  1799.     PRBool rv;
  1801.     lock_cache();
  1803.     PORT_Assert( (unsigned)exchKeyType < kt_kea_size);
  1804.     PORT_Assert( (unsigned)symWrapMechIndex < SSL_NUM_WRAP_MECHS);
  1805.     if ((unsigned)exchKeyType < kt_kea_size &&
  1806.         (unsigned)symWrapMechIndex < SSL_NUM_WRAP_MECHS) {
  1807. rv = getWrappingKey(symWrapMechIndex, exchKeyType, wswk, PR_TRUE);
  1808.     } else {
  1809.      rv = PR_FALSE;
  1810.     }
  1811.     unlock_cache();
  1812.     return rv;
  1813. }
  1815. /* The caller passes in the new value it wants
  1816.  * to set.  This code tests the wrapped sym key entry in the file on disk.  
  1817.  * If it is uninitialized, this function writes the caller's value into 
  1818.  * the disk entry, and returns false.  
  1819.  * Otherwise, it overwrites the caller's wswk with the value obtained from 
  1820.  * the disk, and returns PR_TRUE.  
  1821.  * This is all done while holding the locks/semaphores necessary to make 
  1822.  * the operation atomic.
  1823.  */
  1824. PRBool
  1825. ssl_SetWrappingKey(SSLWrappedSymWrappingKey *wswk)
  1826. {
  1827.     PRBool        rv;
  1828.     SSL3KEAType   exchKeyType      = wswk->exchKeyType;   
  1829.                                 /* type of keys used to wrap SymWrapKey*/
  1830.     PRInt32       symWrapMechIndex = wswk->symWrapMechIndex;
  1831.     PRUint32      offset;
  1832.     SSLWrappedSymWrappingKey myWswk;
  1834.     PORT_Assert( (unsigned)exchKeyType < kt_kea_size);
  1835.     if ((unsigned)exchKeyType >= kt_kea_size)
  1836.      return 0;
  1838.     PORT_Assert( (unsigned)symWrapMechIndex < SSL_NUM_WRAP_MECHS);
  1839.     if ((unsigned)symWrapMechIndex >=  SSL_NUM_WRAP_MECHS)
  1840.      return 0;
  1842.     offset = sidCacheWrapOffset + 
  1843.        ((exchKeyType * SSL_NUM_WRAP_MECHS + symWrapMechIndex) *
  1844.    sizeof(SSLWrappedSymWrappingKey));
  1845.     PORT_Memset(&myWswk, 0, sizeof myWswk); /* eliminate UMRs. */
  1846.     lock_cache();
  1847.     GET_SERVER_CACHE_WRITE_LOCK(SIDCacheFD, offset, sizeof *wswk);
  1849.     rv = getWrappingKey(wswk->symWrapMechIndex, wswk->exchKeyType, &myWswk, 
  1850.                         PR_FALSE);
  1851.     if (rv) {
  1852. /* we found it on disk, copy it out to the caller. */
  1853. PORT_Memcpy(wswk, &myWswk, sizeof *wswk);
  1854.     } else {
  1855. /* Wasn't on disk, and we're still holding the lock, so write it. */
  1857. #ifdef XP_UNIX
  1858. off_t         lrv;
  1859. ssize_t       rrv;
  1861. lrv = lseek(SIDCacheFD, offset, SEEK_SET);
  1862. if (lrv != offset) {
  1863.     if (lrv == -1) 
  1864. nss_MD_unix_map_lseek_error(errno);
  1865.     else
  1866. PORT_SetError(PR_IO_ERROR);
  1867.     IOError(rv, "wrapping-read");
  1868.     rv = PR_FALSE;
  1869. } else {
  1870.     rrv = write(SIDCacheFD, wswk, sizeof *wswk);
  1871.     if (rrv != sizeof *wswk) {
  1872. if (rrv == -1) 
  1873.     nss_MD_unix_map_read_error(errno);
  1874. else 
  1875.     PORT_SetError(PR_IO_ERROR);
  1876. IOError(rv, "wrapping-read");
  1877. rv = PR_FALSE;
  1878.     }
  1879. }
  1880. #else /* XP_WIN32 */
  1881. /* Use memory mapped I/O and just memcpy() the data */
  1882. CopyMemory(&SIDCacheData[offset], wswk, sizeof *wswk);
  1883. #endif /* XP_WIN32 */
  1884.     }
  1885.     RELEASE_SERVER_CACHE_LOCK(SIDCacheFD, offset, sizeof *wswk);
  1886.     unlock_cache();
  1887.     return rv;
  1888. }
  1891. #endif /* NADA_VERISON */
  1892. #else
  1894. #include "seccomon.h"
  1895. #include "cert.h"
  1896. #include "ssl.h"
  1897. #include "sslimpl.h"
  1899. PRBool
  1900. ssl_GetWrappingKey( PRInt32                   symWrapMechIndex,
  1901.                     SSL3KEAType               exchKeyType, 
  1902.     SSLWrappedSymWrappingKey *wswk)
  1903. {
  1904.     PRBool rv = PR_FALSE;
  1905.     PR_ASSERT(!"SSL servers are not supported on the Mac. (ssl_GetWrappingKey)");    
  1906.     return rv;
  1907. }
  1909. /* This is a kind of test-and-set.  The caller passes in the new value it wants
  1910.  * to set.  This code tests the wrapped sym key entry in the file on disk.  
  1911.  * If it is uninitialized, this function writes the caller's value into 
  1912.  * the disk entry, and returns false.  
  1913.  * Otherwise, it overwrites the caller's wswk with the value obtained from 
  1914.  * the disk, and returns PR_TRUE.  
  1915.  * This is all done while holding the locks/semaphores necessary to make 
  1916.  * the operation atomic.
  1917.  */
  1918. PRBool
  1919. ssl_SetWrappingKey(SSLWrappedSymWrappingKey *wswk)
  1920. {
  1921.     PRBool        rv = PR_FALSE;
  1922.     PR_ASSERT(!"SSL servers are not supported on the Mac. (ssl_SetWrappingKey)");
  1923.     return rv;
  1924. }
  1926. #endif /* XP_UNIX || XP_WIN32 */