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

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

CA认证

开发平台：

WINDOWS

sslsock.c：源码内容
  1. /*
  2.  * vtables (and methods that call through them) for the 4 types of 
  3.  * SSLSockets supported.  Only one type is still supported.
  4.  * Various other functions.
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public
  7.  * License Version 1.1 (the "License"); you may not use this file
  8.  * except in compliance with the License. You may obtain a copy of
  9.  * the License at http://www.mozilla.org/MPL/
  10.  * 
  11.  * Software distributed under the License is distributed on an "AS
  12.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  13.  * implied. See the License for the specific language governing
  14.  * rights and limitations under the License.
  15.  * 
  16.  * The Original Code is the Netscape security libraries.
  17.  * 
  18.  * The Initial Developer of the Original Code is Netscape
  19.  * Communications Corporation.  Portions created by Netscape are 
  20.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  21.  * Rights Reserved.
  22.  * 
  23.  * Contributor(s):
  24.  * 
  25.  * Alternatively, the contents of this file may be used under the
  26.  * terms of the GNU General Public License Version 2 or later (the
  27.  * "GPL"), in which case the provisions of the GPL are applicable 
  28.  * instead of those above.  If you wish to allow use of your 
  29.  * version of this file only under the terms of the GPL and not to
  30.  * allow others to use your version of this file under the MPL,
  31.  * indicate your decision by deleting the provisions above and
  32.  * replace them with the notice and other provisions required by
  33.  * the GPL.  If you do not delete the provisions above, a recipient
  34.  * may use your version of this file under either the MPL or the
  35.  * GPL.
  36.  *
  37.  * $Id: sslsock.c,v 1.5 2000/09/12 20:15:43 jgmyers%netscape.com Exp $
  38.  */
  39. #include "seccomon.h"
  40. #include "cert.h"
  41. #include "keyhi.h"
  42. #include "ssl.h"
  43. #include "sslimpl.h"
  44. #include "sslproto.h"
  45. #include "nspr.h"
  47. #define SET_ERROR_CODE   /* reminder */
  49. struct cipherPolicyStr {
  50. int cipher;
  51. unsigned char  export; /* policy value for export policy */
  52. unsigned char  france; /* policy value for france policy */
  53. };
  55. typedef struct cipherPolicyStr cipherPolicy;
  57. /* this table reflects Netscape's browser policies. */
  58. static cipherPolicy ssl_ciphers[] = {    /*   Export           France   */
  59.  {  SSL_EN_RC4_128_WITH_MD5,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  60.  {  SSL_EN_RC4_128_EXPORT40_WITH_MD5,     SSL_ALLOWED,     SSL_ALLOWED },
  61.  {  SSL_EN_RC2_128_CBC_WITH_MD5,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  62.  {  SSL_EN_RC2_128_CBC_EXPORT40_WITH_MD5,   SSL_ALLOWED,     SSL_ALLOWED },
  63.  {  SSL_EN_DES_64_CBC_WITH_MD5,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  64.  {  SSL_EN_DES_192_EDE3_CBC_WITH_MD5,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  65.  {  SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA, SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  66.  {  SSL_FORTEZZA_DMS_WITH_RC4_128_SHA,      SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  67.  {  SSL_RSA_WITH_RC4_128_MD5,     SSL_RESTRICTED,  SSL_NOT_ALLOWED },
  68.  {  SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  69.  {  SSL_RSA_WITH_3DES_EDE_CBC_SHA,     SSL_RESTRICTED,  SSL_NOT_ALLOWED },
  70.  {  SSL_RSA_FIPS_WITH_DES_CBC_SHA,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  71.  {  SSL_RSA_WITH_DES_CBC_SHA,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  72.  {  SSL_RSA_EXPORT_WITH_RC4_40_MD5,     SSL_ALLOWED,     SSL_ALLOWED },
  73.  {  SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5,     SSL_ALLOWED,     SSL_ALLOWED },
  74.  {  SSL_FORTEZZA_DMS_WITH_NULL_SHA,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED },
  75.  {  SSL_RSA_WITH_NULL_MD5,     SSL_ALLOWED,     SSL_ALLOWED },
  76.  {  TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA,    SSL_ALLOWED,     SSL_NOT_ALLOWED },
  77.  {  TLS_RSA_EXPORT1024_WITH_RC4_56_SHA,     SSL_ALLOWED,     SSL_NOT_ALLOWED },
  78.  {  0,     SSL_NOT_ALLOWED, SSL_NOT_ALLOWED }
  79. };
  81. static
  82. sslSocketOps ssl_default_ops = { /* No SSL, No Socks. */
  83.     ssl_DefConnect,
  84.     NULL,
  85.     ssl_DefBind,
  86.     ssl_DefListen,
  87.     ssl_DefShutdown,
  88.     ssl_DefClose,
  89.     ssl_DefRecv,
  90.     ssl_DefSend,
  91.     ssl_DefRead,
  92.     ssl_DefWrite,
  93.     ssl_DefGetpeername,
  94.     ssl_DefGetsockname
  95. };
  97. static
  98. sslSocketOps ssl_socks_ops = { /* No SSL, has socks. */
  99.     ssl_SocksConnect,
  100.     ssl_SocksAccept,
  101.     ssl_SocksBind,
  102.     ssl_SocksListen,
  103.     ssl_DefShutdown,
  104.     ssl_DefClose,
  105.     ssl_SocksRecv,
  106.     ssl_SocksSend,
  107.     ssl_SocksRead,
  108.     ssl_SocksWrite,
  109.     ssl_DefGetpeername,
  110.     ssl_SocksGetsockname
  111. };
  113. static
  114. sslSocketOps ssl_secure_ops = { /* SSL, no socks. */
  115.     ssl_SecureConnect,
  116.     NULL,
  117.     ssl_DefBind,
  118.     ssl_DefListen,
  119.     ssl_SecureShutdown,
  120.     ssl_SecureClose,
  121.     ssl_SecureRecv,
  122.     ssl_SecureSend,
  123.     ssl_SecureRead,
  124.     ssl_SecureWrite,
  125.     ssl_DefGetpeername,
  126.     ssl_DefGetsockname
  127. };
  129. static
  130. sslSocketOps ssl_secure_socks_ops = { /* Both SSL and Socks. */
  131.     ssl_SecureSocksConnect,
  132.     ssl_SecureSocksAccept,
  133.     ssl_SocksBind,
  134.     ssl_SocksListen,
  135.     ssl_SecureShutdown,
  136.     ssl_SecureClose,
  137.     ssl_SecureRecv,
  138.     ssl_SecureSend,
  139.     ssl_SecureRead,
  140.     ssl_SecureWrite,
  141.     ssl_DefGetpeername,
  142.     ssl_SocksGetsockname
  143. };
  145. /*
  146. ** default settings for socket enables
  147. */
  148. static sslOptions ssl_defaults = {
  149.     PR_TRUE,  /* useSecurity        */
  150.     PR_FALSE, /* useSocks           */
  151.     PR_FALSE, /* requestCertificate */
  152.     2,         /* requireCertificate */
  153.     PR_FALSE, /* handshakeAsClient  */
  154.     PR_FALSE, /* handshakeAsServer  */
  155.     PR_TRUE, /* enableSSL2         */
  156.     PR_TRUE, /* enableSSL3         */
  157.     PR_TRUE,  /* enableTLS          */ /* now defaults to on in NSS 3.0 */
  158.     PR_FALSE, /* noCache            */
  159.     PR_FALSE, /* fdx                */
  160.     PR_TRUE, /* v2CompatibleHello  */
  161.     PR_TRUE, /* detectRollBack     */
  162. };
  164. sslSessionIDLookupFunc  ssl_sid_lookup;
  165. sslSessionIDCacheFunc   ssl_sid_cache;
  166. sslSessionIDUncacheFunc ssl_sid_uncache;
  168. static PRBool ssl_inited = PR_FALSE;
  169. static PRDescIdentity ssl_layer_id;
  171. int                     ssl_lock_readers = 1; /* default true. */
  172. char                    ssl_debug;
  173. char                    ssl_trace;
  176. /* forward declarations. */
  177. static sslSocket *ssl_NewSocket(void);
  178. static PRStatus   ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, 
  179.                                   PRDescIdentity id);
  181. /************************************************************************/
  183. /*
  184. ** Lookup a socket structure from a file descriptor.
  185. */
  186. static sslSocket *
  187. ssl_GetPrivate(PRFileDesc *fd)
  188. {
  189.     sslSocket *ss;
  191.     PORT_Assert(fd != NULL);
  192.     PORT_Assert(fd->methods->file_type == PR_DESC_LAYERED);
  193.     PORT_Assert(fd->identity == ssl_layer_id);
  195.     ss = (sslSocket *)fd->secret;
  196.     ss->fd = fd;
  197.     return ss;
  198. }
  200. sslSocket *
  201. ssl_FindSocket(PRFileDesc *fd)
  202. {
  203.     PRFileDesc *layer;
  204.     sslSocket *ss;
  206.     PORT_Assert(fd != NULL);
  207.     PORT_Assert(ssl_layer_id != 0);
  209.     layer = PR_GetIdentitiesLayer(fd, ssl_layer_id);
  210.     if (layer == NULL)
  211. return NULL;
  213.     ss = (sslSocket *)layer->secret;
  214.     ss->fd = layer;
  215.     return ss;
  216. }
  218. #if 0 /* dead code. */
  219. PRFileDesc *
  220. ssl_FindTop(sslSocket *ss)
  221. {
  222.     PRFileDesc *fd = ss->fd;
  224.     while (fd->higher != NULL)
  225. fd = fd->higher;
  227.     return fd;
  228. }
  229. #endif
  231. sslSocket *
  232. ssl_DupSocket(sslSocket *os)
  233. {
  234.     sslSocket *ss;
  235.     SECStatus rv;
  237.     ss = ssl_NewSocket();
  238.     if (ss) {
  239. ss->useSocks           = os->useSocks;
  240. ss->useSecurity        = os->useSecurity;
  241. ss->requestCertificate = os->requestCertificate;
  242. ss->requireCertificate = os->requireCertificate;
  243. ss->handshakeAsClient  = os->handshakeAsClient;
  244. ss->handshakeAsServer  = os->handshakeAsServer;
  245. ss->enableSSL2         = os->enableSSL2;
  246. ss->enableSSL3         = os->enableSSL3;
  247. ss->enableTLS          = os->enableTLS;
  248. ss->noCache            = os->noCache;
  249. ss->fdx                = os->fdx;
  250. ss->v2CompatibleHello  = os->v2CompatibleHello;
  251. ss->detectRollBack     = os->detectRollBack;
  252. ss->peerID             = !os->peerID ? NULL : PORT_Strdup(os->peerID);
  253. ss->url                = !os->url    ? NULL : PORT_Strdup(os->url);
  255. ss->ops      = os->ops;
  256. ss->peer     = os->peer;
  257. ss->port     = os->port;
  258. ss->rTimeout = os->rTimeout;
  259. ss->wTimeout = os->wTimeout;
  260. ss->cTimeout = os->cTimeout;
  261. ss->dbHandle = os->dbHandle;
  263. /* copy ssl2&3 policy & prefs, even if it's not selected (yet) */
  264. ss->allowedByPolicy = os->allowedByPolicy;
  265. ss->maybeAllowedByPolicy= os->maybeAllowedByPolicy;
  266. ss->chosenPreference  = os->chosenPreference;
  267. PORT_Memcpy(ss->cipherSuites, os->cipherSuites, sizeof os->cipherSuites);
  269. if (os->cipherSpecs) {
  270.     ss->cipherSpecs  = (unsigned char*)PORT_Alloc(os->sizeCipherSpecs);
  271.     if (ss->cipherSpecs) 
  272.      PORT_Memcpy(ss->cipherSpecs, os->cipherSpecs, 
  273.             os->sizeCipherSpecs);
  274.     ss->sizeCipherSpecs    = os->sizeCipherSpecs;
  275.     ss->preferredCipher    = os->preferredCipher;
  276. } else {
  277.     ss->cipherSpecs        = NULL;  /* produced lazily */
  278.     ss->sizeCipherSpecs    = 0;
  279.     ss->preferredCipher    = NULL;
  280. }
  281. if (ss->useSecurity) {
  282.     /* This int should be SSLKEAType, but CC on Irix complains,
  283.      * during the for loop.
  284.      */
  285.     int i;
  287.     for (i=kt_null; i < kt_kea_size; i++) {
  288. if (os->serverCert[i] && os->serverCertChain[i]) {
  289.     ss->serverCert[i] = CERT_DupCertificate(os->serverCert[i]);
  290.     ss->serverCertChain[i] = CERT_DupCertList(
  291.                                        os->serverCertChain[i]);
  292. } else {
  293.     ss->serverCert[i]      = NULL;
  294.     ss->serverCertChain[i] = NULL;
  295. }
  296. ss->serverKey[i] = os->serverKey[i] ?
  297. SECKEY_CopyPrivateKey(os->serverKey[i]) : NULL;
  298.     }
  299.     ss->stepDownKeyPair = !os->stepDownKeyPair ? NULL :
  300.                   ssl3_GetKeyPairRef(os->stepDownKeyPair);
  301. /*
  302.  * XXX the preceeding CERT_ and SECKEY_ functions can fail and return NULL.
  303.  * XXX We should detect this, and not just march on with NULL pointers.
  304.  */
  305.     ss->authCertificate       = os->authCertificate;
  306.     ss->authCertificateArg    = os->authCertificateArg;
  307.     ss->getClientAuthData     = os->getClientAuthData;
  308.     ss->getClientAuthDataArg  = os->getClientAuthDataArg;
  309.     ss->handleBadCert         = os->handleBadCert;
  310.     ss->badCertArg            = os->badCertArg;
  311.     ss->handshakeCallback     = os->handshakeCallback;
  312.     ss->handshakeCallbackData = os->handshakeCallbackData;
  313.     ss->pkcs11PinArg          = os->pkcs11PinArg;
  314.     
  315.     /* Create security data */
  316.     rv = ssl_CopySecurityInfo(ss, os);
  317.     if (rv != SECSuccess) {
  318. goto losage;
  319.     }
  320. }
  321. if (ss->useSocks) {
  322.     /* Create security data */
  323.     rv = ssl_CopySocksInfo(ss, os);
  324.     if (rv != SECSuccess) {
  325. goto losage;
  326.     }
  327. }
  328.     }
  329.     return ss;
  331.   losage:
  332.     return NULL;
  333. }
  335. /*
  336.  * free an sslSocket struct, and all the stuff that hangs off of it
  337.  */
  338. void
  339. ssl_FreeSocket(sslSocket *ss)
  340. {
  341.     /* "i" should be of type SSLKEAType, but CC on IRIX complains during
  342.      * the for loop.
  343.      */
  344.     int        i;
  346.     sslSocket *fs;
  347.     sslSocket  lSock;
  349. /* Get every lock you can imagine!
  350. ** Caller already holds these:
  351. **  SSL_LOCK_READER(ss);
  352. **  SSL_LOCK_WRITER(ss);
  353. */
  354.     ssl_Get1stHandshakeLock(ss);
  355.     ssl_GetRecvBufLock(ss);
  356.     ssl_GetSSL3HandshakeLock(ss);
  357.     ssl_GetXmitBufLock(ss);
  358.     ssl_GetSpecWriteLock(ss);
  360. #ifdef DEBUG
  361.     fs = &lSock;
  362.     *fs = *ss; /* Copy the old socket structure, */
  363.     PORT_Memset(ss, 0x1f, sizeof *ss);  /* then blast the old struct ASAP. */
  364. #else
  365.     fs = ss;
  366. #endif
  368.     /* Free up socket */
  369.     ssl_DestroySocksInfo(fs->socks);
  370.     ssl_DestroySecurityInfo(fs->sec);
  371.     ssl3_DestroySSL3Info(fs->ssl3);
  372.     PORT_Free(fs->saveBuf.buf);
  373.     PORT_Free(fs->pendingBuf.buf);
  374.     if (fs->gather) {
  375. ssl_DestroyGather(fs->gather);
  376.     }
  377.     if (fs->peerID != NULL)
  378. PORT_Free(fs->peerID);
  379.     if (fs->url != NULL)
  380. PORT_Free((void *)fs->url); /* CONST */
  382.     /* Clean up server configuration */
  383.     for (i=kt_null; i < kt_kea_size; i++) {
  384. if (fs->serverCert[i] != NULL)
  385.     CERT_DestroyCertificate(fs->serverCert[i]);
  386. if (fs->serverCertChain[i] != NULL)
  387.     CERT_DestroyCertificateList(fs->serverCertChain[i]);
  388. if (fs->serverKey[i] != NULL)
  389.     SECKEY_DestroyPrivateKey(fs->serverKey[i]);
  390.     }
  391.     if (fs->stepDownKeyPair) {
  392. ssl3_FreeKeyPair(fs->stepDownKeyPair);
  393. fs->stepDownKeyPair = NULL;
  394.     }
  397.     /* Release all the locks acquired above.  */
  398.     SSL_UNLOCK_READER(fs);
  399.     SSL_UNLOCK_WRITER(fs);
  400.     ssl_Release1stHandshakeLock(fs);
  401.     ssl_ReleaseRecvBufLock(fs);
  402.     ssl_ReleaseSSL3HandshakeLock(fs);
  403.     ssl_ReleaseXmitBufLock(fs);
  404.     ssl_ReleaseSpecWriteLock(fs);
  406.     /* Destroy locks. */
  407.     if (fs->firstHandshakeLock) {
  408.      PR_DestroyMonitor(fs->firstHandshakeLock);
  409. fs->firstHandshakeLock = NULL;
  410.     }
  411.     if (fs->ssl3HandshakeLock) {
  412.      PR_DestroyMonitor(fs->ssl3HandshakeLock);
  413. fs->ssl3HandshakeLock = NULL;
  414.     }
  415.     if (fs->specLock) {
  416.      NSSRWLock_Destroy(fs->specLock);
  417. fs->specLock = NULL;
  418.     }
  420.     if (fs->recvLock) {
  421.      PR_DestroyLock(fs->recvLock);
  422. fs->recvLock = NULL;
  423.     }
  424.     if (fs->sendLock) {
  425.      PR_DestroyLock(fs->sendLock);
  426. fs->sendLock = NULL;
  427.     }
  428.     if (fs->xmitBufLock) {
  429.      PR_DestroyMonitor(fs->xmitBufLock);
  430. fs->xmitBufLock = NULL;
  431.     }
  432.     if (fs->recvBufLock) {
  433.      PR_DestroyMonitor(fs->recvBufLock);
  434. fs->recvBufLock = NULL;
  435.     }
  436.     if (fs->cipherSpecs) {
  437. PORT_Free(fs->cipherSpecs);
  438. fs->cipherSpecs     = NULL;
  439. fs->sizeCipherSpecs = 0;
  440.     }
  442.     PORT_Free(ss); /* free the caller's copy, not ours. */
  443.     return;
  444. }
  446. /************************************************************************/
  448. static void
  449. ssl_ChooseOps(sslSocket *ss)
  450. {
  451.     if (ss->useSocks)  {
  452.      ss->ops = ss->useSecurity ? &ssl_secure_socks_ops : &ssl_socks_ops ;
  453.     } else {
  454.      ss->ops = ss->useSecurity ? &ssl_secure_ops       : &ssl_default_ops;
  455.     }
  456. }
  458. /* Called from SSL_Enable (immediately below) */
  459. static SECStatus
  460. PrepareSocket(sslSocket *ss)
  461. {
  462.     SECStatus     rv = SECSuccess;
  464.     if (ss->useSocks) {
  465. rv = ssl_CreateSocksInfo(ss);
  466. if (rv != SECSuccess) {
  467.     return rv;
  468. }
  469.     }
  470.     if (ss->useSecurity) {
  471. rv = ssl_CreateSecurityInfo(ss);
  472. if (rv != SECSuccess) {
  473.     return rv;
  474. }
  475.     }
  477.     ssl_ChooseOps(ss);
  478.     return rv;
  479. }
  481. SECStatus
  482. SSL_Enable(PRFileDesc *fd, int which, PRBool on)
  483. {
  484.     return SSL_OptionSet(fd, which, on);
  485. }
  487. SECStatus
  488. SSL_OptionSet(PRFileDesc *fd, PRInt32 which, PRBool on)
  489. {
  490.     sslSocket *ss = ssl_FindSocket(fd);
  491.     SECStatus  rv = SECSuccess;
  493.     if (!ss) {
  494. SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd));
  495. PORT_SetError(PR_BAD_DESCRIPTOR_ERROR);
  496. return SECFailure;
  497.     }
  499.     ssl_Get1stHandshakeLock(ss);
  500.     ssl_GetSSL3HandshakeLock(ss);
  502.     switch (which) {
  503.       case SSL_SOCKS:
  504. ss->useSocks = on;
  505. rv = PrepareSocket(ss);
  506. break;
  508.       case SSL_SECURITY:
  509. ss->useSecurity = on;
  510. rv = PrepareSocket(ss);
  511. break;
  513.       case SSL_REQUEST_CERTIFICATE:
  514. ss->requestCertificate = on;
  515. break;
  517.       case SSL_REQUIRE_CERTIFICATE:
  518. ss->requireCertificate = on;
  519. break;
  521.       case SSL_HANDSHAKE_AS_CLIENT:
  522. if ( ss->handshakeAsServer && on ) {
  523.     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  524.     rv = SECFailure;
  525.     break;
  526. }
  527. ss->handshakeAsClient = on;
  528. break;
  530.       case SSL_HANDSHAKE_AS_SERVER:
  531. if ( ss->handshakeAsClient && on ) {
  532.     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  533.     rv = SECFailure;
  534.     break;
  535. }
  536. ss->handshakeAsServer = on;
  537. break;
  539.       case SSL_ENABLE_TLS:
  540. ss->enableTLS           = on;
  541. ss->preferredCipher     = NULL;
  542. if (ss->cipherSpecs) {
  543.     PORT_Free(ss->cipherSpecs);
  544.     ss->cipherSpecs     = NULL;
  545.     ss->sizeCipherSpecs = 0;
  546. }
  547. break;
  549.       case SSL_ENABLE_SSL3:
  550. ss->enableSSL3          = on;
  551. ss->preferredCipher     = NULL;
  552. if (ss->cipherSpecs) {
  553.     PORT_Free(ss->cipherSpecs);
  554.     ss->cipherSpecs     = NULL;
  555.     ss->sizeCipherSpecs = 0;
  556. }
  557. break;
  559.       case SSL_ENABLE_SSL2:
  560. ss->enableSSL2          = on;
  561. if (on) {
  562.     ss->v2CompatibleHello = on;
  563. }
  564. ss->preferredCipher     = NULL;
  565. if (ss->cipherSpecs) {
  566.     PORT_Free(ss->cipherSpecs);
  567.     ss->cipherSpecs     = NULL;
  568.     ss->sizeCipherSpecs = 0;
  569. }
  570. break;
  572.       case SSL_NO_CACHE:
  573. ss->noCache = on;
  574. break;
  576.       case SSL_ENABLE_FDX:
  577.        ss->fdx = on;
  578. break;
  580.       case SSL_V2_COMPATIBLE_HELLO:
  581.        ss->v2CompatibleHello = on;
  582. if (!on) {
  583.     ss->enableSSL2    = on;
  584. }
  585. break;
  587.       case SSL_ROLLBACK_DETECTION:  
  588. ss->detectRollBack = on;
  589.         break;
  591.       default:
  592. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  593. rv = SECFailure;
  594.     }
  596.     ssl_ReleaseSSL3HandshakeLock(ss);
  597.     ssl_Release1stHandshakeLock(ss);
  599.     return rv;
  600. }
  602. SECStatus
  603. SSL_OptionGet(PRFileDesc *fd, PRInt32 which, PRBool *pOn)
  604. {
  605.     sslSocket *ss = ssl_FindSocket(fd);
  606.     SECStatus  rv = SECSuccess;
  607.     PRBool     on = PR_FALSE;
  609.     if (!pOn) {
  610. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  611. return SECFailure;
  612.     }
  613.     if (!ss) {
  614. SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd));
  615. PORT_SetError(PR_BAD_DESCRIPTOR_ERROR);
  616. *pOn = PR_FALSE;
  617. return SECFailure;
  618.     }
  620.     ssl_Get1stHandshakeLock(ss);
  621.     ssl_GetSSL3HandshakeLock(ss);
  623.     switch (which) {
  624.     case SSL_SOCKS:               on = ss->useSocks;           break;
  625.     case SSL_SECURITY:            on = ss->useSecurity;        break;
  626.     case SSL_REQUEST_CERTIFICATE: on = ss->requestCertificate; break;
  627.     case SSL_REQUIRE_CERTIFICATE: on = ss->requireCertificate; break;
  628.     case SSL_HANDSHAKE_AS_CLIENT: on = ss->handshakeAsClient;  break;
  629.     case SSL_HANDSHAKE_AS_SERVER: on = ss->handshakeAsServer;  break;
  630.     case SSL_ENABLE_TLS:          on = ss->enableTLS;          break;
  631.     case SSL_ENABLE_SSL3:         on = ss->enableSSL3;         break;
  632.     case SSL_ENABLE_SSL2:         on = ss->enableSSL2;         break;
  633.     case SSL_NO_CACHE:            on = ss->noCache;            break;
  634.     case SSL_ENABLE_FDX:          on = ss->fdx;                break;
  635.     case SSL_V2_COMPATIBLE_HELLO: on = ss->v2CompatibleHello;  break;
  636.     case SSL_ROLLBACK_DETECTION:  on = ss->detectRollBack;     break;
  638.     default:
  639. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  640. rv = SECFailure;
  641.     }
  643.     ssl_ReleaseSSL3HandshakeLock(ss);
  644.     ssl_Release1stHandshakeLock(ss);
  646.     *pOn = on;
  647.     return rv;
  648. }
  650. SECStatus
  651. SSL_OptionGetDefault(PRInt32 which, PRBool *pOn)
  652. {
  653.     SECStatus  rv = SECSuccess;
  654.     PRBool     on = PR_FALSE;
  656.     if (!pOn) {
  657. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  658. return SECFailure;
  659.     }
  661.     switch (which) {
  662.     case SSL_SOCKS:               on = ssl_defaults.useSocks;           break;
  663.     case SSL_SECURITY:            on = ssl_defaults.useSecurity;        break;
  664.     case SSL_REQUEST_CERTIFICATE: on = ssl_defaults.requestCertificate; break;
  665.     case SSL_REQUIRE_CERTIFICATE: on = ssl_defaults.requireCertificate; break;
  666.     case SSL_HANDSHAKE_AS_CLIENT: on = ssl_defaults.handshakeAsClient;  break;
  667.     case SSL_HANDSHAKE_AS_SERVER: on = ssl_defaults.handshakeAsServer;  break;
  668.     case SSL_ENABLE_TLS:          on = ssl_defaults.enableTLS;          break;
  669.     case SSL_ENABLE_SSL3:         on = ssl_defaults.enableSSL3;         break;
  670.     case SSL_ENABLE_SSL2:         on = ssl_defaults.enableSSL2;         break;
  671.     case SSL_NO_CACHE:            on = ssl_defaults.noCache; break;
  672.     case SSL_ENABLE_FDX:          on = ssl_defaults.fdx;                break;
  673.     case SSL_V2_COMPATIBLE_HELLO: on = ssl_defaults.v2CompatibleHello;  break;
  674.     case SSL_ROLLBACK_DETECTION:  on = ssl_defaults.detectRollBack;     break;
  676.     default:
  677. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  678. rv = SECFailure;
  679.     }
  681.     *pOn = on;
  682.     return rv;
  683. }
  685. /* XXX Use Global Lock to protect this stuff. */
  686. SECStatus
  687. SSL_EnableDefault(int which, PRBool on)
  688. {
  689.     return SSL_OptionSetDefault(which, on);
  690. }
  692. SECStatus
  693. SSL_OptionSetDefault(PRInt32 which, PRBool on)
  694. {
  695.     switch (which) {
  696.       case SSL_SOCKS:
  697. ssl_defaults.useSocks = on;
  698. break;
  700.       case SSL_SECURITY:
  701. ssl_defaults.useSecurity = on;
  702. break;
  704.       case SSL_REQUEST_CERTIFICATE:
  705. ssl_defaults.requestCertificate = on;
  706. break;
  708.       case SSL_REQUIRE_CERTIFICATE:
  709. ssl_defaults.requireCertificate = on;
  710. break;
  712.       case SSL_HANDSHAKE_AS_CLIENT:
  713. if ( ssl_defaults.handshakeAsServer && on ) {
  714.     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  715.     return SECFailure;
  716. }
  717. ssl_defaults.handshakeAsClient = on;
  718. break;
  720.       case SSL_HANDSHAKE_AS_SERVER:
  721. if ( ssl_defaults.handshakeAsClient && on ) {
  722.     PORT_SetError(SEC_ERROR_INVALID_ARGS);
  723.     return SECFailure;
  724. }
  725. ssl_defaults.handshakeAsServer = on;
  726. break;
  728.       case SSL_ENABLE_TLS:
  729. ssl_defaults.enableTLS = on;
  730. break;
  732.       case SSL_ENABLE_SSL3:
  733. ssl_defaults.enableSSL3 = on;
  734. break;
  736.       case SSL_ENABLE_SSL2:
  737. ssl_defaults.enableSSL2 = on;
  738. if (on) {
  739.     ssl_defaults.v2CompatibleHello = on;
  740. }
  741. break;
  743.       case SSL_NO_CACHE:
  744. ssl_defaults.noCache = on;
  745. break;
  747.       case SSL_ENABLE_FDX:
  748.        ssl_defaults.fdx = on;
  750.       case SSL_V2_COMPATIBLE_HELLO:
  751.        ssl_defaults.v2CompatibleHello = on;
  752. if (!on) {
  753.     ssl_defaults.enableSSL2    = on;
  754. }
  755. break;
  757.       case SSL_ROLLBACK_DETECTION:  
  758. ssl_defaults.detectRollBack = on;
  759. break;
  761.       default:
  762. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  763. return SECFailure;
  764.     }
  765.     return SECSuccess;
  766. }
  768. /* Part of the public NSS API.
  769.  * Since this is a global (not per-socket) setting, we cannot use the
  770.  * HandshakeLock to protect this.  Probably want a global lock.
  771.  */
  772. SECStatus
  773. SSL_SetPolicy(long which, int policy)
  774. {
  775.     if ((which & 0xfffe) == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) {
  776.      /* one of the two old FIPS ciphers */
  777. if (which == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) 
  778.     which = SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA;
  779. else if (which == SSL_RSA_OLDFIPS_WITH_DES_CBC_SHA)
  780.     which = SSL_RSA_FIPS_WITH_DES_CBC_SHA;
  781.     }
  782.     return SSL_CipherPolicySet(which, policy);
  783. }
  785. SECStatus
  786. SSL_CipherPolicySet(PRInt32 which, PRInt32 policy)
  787. {
  788.     SECStatus rv;
  790.     if (SSL_IS_SSL2_CIPHER(which)) {
  791. rv = ssl2_SetPolicy(which, policy);
  792.     } else {
  793. rv = ssl3_SetPolicy((ssl3CipherSuite)which, policy);
  794.     }
  795.     return rv;
  796. }
  798. SECStatus
  799. SSL_CipherPolicyGet(PRInt32 which, PRInt32 *oPolicy)
  800. {
  801.     SECStatus rv;
  803.     if (!oPolicy) {
  804. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  805. return SECFailure;
  806.     }
  807.     if (SSL_IS_SSL2_CIPHER(which)) {
  808. rv = ssl2_GetPolicy(which, oPolicy);
  809.     } else {
  810. rv = ssl3_GetPolicy((ssl3CipherSuite)which, oPolicy);
  811.     }
  812.     return rv;
  813. }
  815. /* Part of the public NSS API.
  816.  * Since this is a global (not per-socket) setting, we cannot use the
  817.  * HandshakeLock to protect this.  Probably want a global lock.
  818.  * These changes have no effect on any sslSockets already created. 
  819.  */
  820. SECStatus
  821. SSL_EnableCipher(long which, PRBool enabled)
  822. {
  823.     if ((which & 0xfffe) == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) {
  824.      /* one of the two old FIPS ciphers */
  825. if (which == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) 
  826.     which = SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA;
  827. else if (which == SSL_RSA_OLDFIPS_WITH_DES_CBC_SHA)
  828.     which = SSL_RSA_FIPS_WITH_DES_CBC_SHA;
  829.     }
  830.     return SSL_CipherPrefSetDefault(which, enabled);
  831. }
  833. SECStatus
  834. SSL_CipherPrefSetDefault(PRInt32 which, PRBool enabled)
  835. {
  836.     SECStatus rv;
  837.     
  838.     if (SSL_IS_SSL2_CIPHER(which)) {
  839. rv = ssl2_CipherPrefSetDefault(which, enabled);
  840.     } else {
  841. rv = ssl3_CipherPrefSetDefault((ssl3CipherSuite)which, enabled);
  842.     }
  843.     return rv;
  844. }
  846. SECStatus 
  847. SSL_CipherPrefGetDefault(PRInt32 which, PRBool *enabled)
  848. {
  849.     SECStatus  rv;
  850.     
  851.     if (!enabled) {
  852. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  853. return SECFailure;
  854.     }
  855.     if (SSL_IS_SSL2_CIPHER(which)) {
  856. rv = ssl2_CipherPrefGetDefault(which, enabled);
  857.     } else {
  858. rv = ssl3_CipherPrefGetDefault((ssl3CipherSuite)which, enabled);
  859.     }
  860.     return rv;
  861. }
  863. SECStatus
  864. SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 which, PRBool enabled)
  865. {
  866.     SECStatus rv;
  867.     sslSocket *ss = ssl_FindSocket(fd);
  868.     
  869.     if (!ss) {
  870. SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefSet", SSL_GETPID(), fd));
  871. PORT_SetError(PR_BAD_DESCRIPTOR_ERROR);
  872. return SECFailure;
  873.     }
  874.     if (SSL_IS_SSL2_CIPHER(which)) {
  875. rv = ssl2_CipherPrefSet(ss, which, enabled);
  876.     } else {
  877. rv = ssl3_CipherPrefSet(ss, (ssl3CipherSuite)which, enabled);
  878.     }
  879.     return rv;
  880. }
  882. SECStatus 
  883. SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 which, PRBool *enabled)
  884. {
  885.     SECStatus  rv;
  886.     sslSocket *ss = ssl_FindSocket(fd);
  887.     
  888.     if (!enabled) {
  889. PORT_SetError(SEC_ERROR_INVALID_ARGS);
  890. return SECFailure;
  891.     }
  892.     if (!ss) {
  893. SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefGet", SSL_GETPID(), fd));
  894. PORT_SetError(PR_BAD_DESCRIPTOR_ERROR);
  895. *enabled = PR_FALSE;
  896. return SECFailure;
  897.     }
  898.     if (SSL_IS_SSL2_CIPHER(which)) {
  899. rv = ssl2_CipherPrefGet(ss, which, enabled);
  900.     } else {
  901. rv = ssl3_CipherPrefGet(ss, (ssl3CipherSuite)which, enabled);
  902.     }
  903.     return rv;
  904. }
  906. SECStatus
  907. NSS_SetDomesticPolicy(void)
  908. {
  909. #ifndef EXPORT_VERSION
  910.     SECStatus      status = SECSuccess;
  911.     cipherPolicy * policy;
  913.     for (policy = ssl_ciphers; policy->cipher != 0; ++policy) {
  914. status = SSL_SetPolicy(policy->cipher, SSL_ALLOWED);
  915. if (status != SECSuccess)
  916.     break;
  917.     }
  918.     return status;
  919. #else
  920.     return NSS_SetExportPolicy();
  921. #endif
  922. }
  924. SECStatus
  925. NSS_SetExportPolicy(void)
  926. {
  927.     SECStatus      status = SECSuccess;
  928.     cipherPolicy * policy;
  930.     for (policy = ssl_ciphers; policy->cipher != 0; ++policy) {
  931. status = SSL_SetPolicy(policy->cipher, policy->export);
  932. if (status != SECSuccess)
  933.     break;
  934.     }
  935.     return status;
  936. }
  938. SECStatus
  939. NSS_SetFrancePolicy(void)
  940. {
  941.     SECStatus      status = SECSuccess;
  942.     cipherPolicy * policy;
  944.     for (policy = ssl_ciphers; policy->cipher != 0; ++policy) {
  945. status = SSL_SetPolicy(policy->cipher, policy->france);
  946. if (status != SECSuccess)
  947.     break;
  948.     }
  949.     return status;
  950. }
  954. /* LOCKS ??? XXX */
  955. PRFileDesc *
  956. SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd)
  957. {
  958.     sslSocket * ns = NULL;
  959.     PRStatus    rv;
  961.     if (model == NULL) {
  962. /* Just create a default socket if we're given NULL for the model */
  963. ns = ssl_NewSocket();
  964.     } else {
  965. sslSocket * ss = ssl_FindSocket(model);
  966. if (ss == NULL) {
  967.     SSL_DBG(("%d: SSL[%d]: bad model socket in ssl_ImportFD", 
  968.            SSL_GETPID(), model));
  969.     SET_ERROR_CODE
  970.     return NULL;
  971. }
  972. ns = ssl_DupSocket(ss);
  973.     }
  974.     if (ns == NULL)
  975.      return NULL;
  977.     rv = ssl_PushIOLayer(ns, fd, PR_TOP_IO_LAYER);
  978.     if (rv != PR_SUCCESS) {
  979. ssl_FreeSocket(ns);
  980. SET_ERROR_CODE
  981. return NULL;
  982.     }
  983. #ifdef _WIN32
  984.     PR_Sleep(PR_INTERVAL_NO_WAIT);     /* workaround NT winsock connect bug. */
  985. #endif
  986.     return fd;
  987. }
  989. /************************************************************************/
  990. /* The following functions are the TOP LEVEL SSL functions.
  991. ** They all get called through the NSPRIOMethods table below.
  992. */
  994. static PRFileDesc * PR_CALLBACK
  995. ssl_Accept(PRFileDesc *fd, PRNetAddr *sockaddr, PRIntervalTime timeout)
  996. {
  997.     sslSocket  *ss;
  998.     sslSocket  *ns  = NULL;
  999.     PRFileDesc *newfd  = NULL;
  1000.     PRFileDesc *osfd;
  1001.     PRStatus    status;
  1003.     ss = ssl_GetPrivate(fd);
  1004.     if (!ss) {
  1005. SSL_DBG(("%d: SSL[%d]: bad socket in accept", SSL_GETPID(), fd));
  1006. return NULL;
  1007.     }
  1009.     /* IF this is a listen socket, there shouldn't be any I/O going on */
  1010.     SSL_LOCK_READER(ss);
  1011.     SSL_LOCK_WRITER(ss);
  1012.     ssl_Get1stHandshakeLock(ss);
  1013.     ssl_GetSSL3HandshakeLock(ss);
  1015.     ss->cTimeout = timeout;
  1017.     osfd = ss->fd->lower;
  1019.     /* First accept connection */
  1020.     newfd = osfd->methods->accept(osfd, sockaddr, timeout);
  1021.     if (newfd == NULL) {
  1022. SSL_DBG(("%d: SSL[%d]: accept failed, errno=%d",
  1023.  SSL_GETPID(), ss->fd, PORT_GetError()));
  1024.     } else {
  1025. /* Create ssl module */
  1026. ns = ssl_DupSocket(ss);
  1027.     }
  1029.     ssl_ReleaseSSL3HandshakeLock(ss);
  1030.     ssl_Release1stHandshakeLock(ss);
  1031.     SSL_UNLOCK_WRITER(ss);
  1032.     SSL_UNLOCK_READER(ss); /* ss isn't used below here. */
  1034.     if (ns == NULL)
  1035. goto loser;
  1037.     /* push ssl module onto the new socket */
  1038.     status = ssl_PushIOLayer(ns, newfd, PR_TOP_IO_LAYER);
  1039.     if (status != PR_SUCCESS)
  1040. goto loser;
  1042.     /* Now start server connection handshake with client.
  1043.     ** Don't need locks here because nobody else has a reference to ns yet.
  1044.     */
  1045.     if ( ns->useSecurity ) {
  1046. if ( ns->handshakeAsClient ) {
  1047.     ns->handshake = ssl2_BeginClientHandshake;
  1048. } else {
  1049.     ns->handshake = ssl2_BeginServerHandshake;
  1050. }
  1051.     }
  1052.     return newfd;
  1054. loser:
  1055.     if (ns != NULL)
  1056. ssl_FreeSocket(ns);
  1057.     if (newfd != NULL)
  1058. PR_Close(newfd);
  1059.     return NULL;
  1060. }
  1062. static PRStatus PR_CALLBACK
  1063. ssl_Connect(PRFileDesc *fd, const PRNetAddr *sockaddr, PRIntervalTime timeout)
  1064. {
  1065.     sslSocket *ss;
  1066.     PRStatus   rv;
  1068.     ss = ssl_GetPrivate(fd);
  1069.     if (!ss) {
  1070. SSL_DBG(("%d: SSL[%d]: bad socket in connect", SSL_GETPID(), fd));
  1071. return PR_FAILURE;
  1072.     }
  1074.     /* IF this is a listen socket, there shouldn't be any I/O going on */
  1075.     SSL_LOCK_READER(ss);
  1076.     SSL_LOCK_WRITER(ss);
  1078.     ss->cTimeout = timeout;
  1079.     rv = (PRStatus)(*ss->ops->connect)(ss, sockaddr);
  1080. #ifdef _WIN32
  1081.     PR_Sleep(PR_INTERVAL_NO_WAIT);     /* workaround NT winsock connect bug. */
  1082. #endif
  1084.     SSL_UNLOCK_WRITER(ss);
  1085.     SSL_UNLOCK_READER(ss);
  1087.     return rv;
  1088. }
  1090. static PRStatus PR_CALLBACK
  1091. ssl_Bind(PRFileDesc *fd, const PRNetAddr *addr)
  1092. {
  1093.     sslSocket * ss = ssl_GetPrivate(fd);
  1094.     PRStatus    rv;
  1096.     if (!ss) {
  1097. SSL_DBG(("%d: SSL[%d]: bad socket in bind", SSL_GETPID(), fd));
  1098. return PR_FAILURE;
  1099.     }
  1100.     SSL_LOCK_READER(ss);
  1101.     SSL_LOCK_WRITER(ss);
  1103.     rv = (PRStatus)(*ss->ops->bind)(ss, addr);
  1105.     SSL_UNLOCK_WRITER(ss);
  1106.     SSL_UNLOCK_READER(ss);
  1107.     return rv;
  1108. }
  1110. static PRStatus PR_CALLBACK
  1111. ssl_Listen(PRFileDesc *fd, PRIntn backlog)
  1112. {
  1113.     sslSocket * ss = ssl_GetPrivate(fd);
  1114.     PRStatus    rv;
  1116.     if (!ss) {
  1117. SSL_DBG(("%d: SSL[%d]: bad socket in listen", SSL_GETPID(), fd));
  1118. return PR_FAILURE;
  1119.     }
  1120.     SSL_LOCK_READER(ss);
  1121.     SSL_LOCK_WRITER(ss);
  1123.     rv = (PRStatus)(*ss->ops->listen)(ss, backlog);
  1125.     SSL_UNLOCK_WRITER(ss);
  1126.     SSL_UNLOCK_READER(ss);
  1127.     return rv;
  1128. }
  1130. static PRStatus PR_CALLBACK
  1131. ssl_Shutdown(PRFileDesc *fd, PRIntn how)
  1132. {
  1133.     sslSocket * ss = ssl_GetPrivate(fd);
  1134.     PRStatus    rv;
  1136.     if (!ss) {
  1137. SSL_DBG(("%d: SSL[%d]: bad socket in shutdown", SSL_GETPID(), fd));
  1138. return PR_FAILURE;
  1139.     }
  1140.     if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) {
  1141.      SSL_LOCK_READER(ss);
  1142.     }
  1143.     if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) {
  1144.      SSL_LOCK_WRITER(ss);
  1145.     }
  1147.     rv = (PRStatus)(*ss->ops->shutdown)(ss, how);
  1149.     if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) {
  1150.      SSL_UNLOCK_WRITER(ss);
  1151.     }
  1152.     if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) {
  1153.      SSL_UNLOCK_READER(ss);
  1154.     }
  1155.     return rv;
  1156. }
  1158. static PRStatus PR_CALLBACK
  1159. ssl_Close(PRFileDesc *fd)
  1160. {
  1161.     sslSocket *ss;
  1162.     PRStatus   rv;
  1164.     ss = ssl_GetPrivate(fd);
  1165.     if (!ss) {
  1166. SSL_DBG(("%d: SSL[%d]: bad socket in close", SSL_GETPID(), fd));
  1167. return PR_FAILURE;
  1168.     }
  1170.     /* There must not be any I/O going on */
  1171.     SSL_LOCK_READER(ss);
  1172.     SSL_LOCK_WRITER(ss);
  1174.     /* By the time this function returns, 
  1175.     ** ss is an invalid pointer, and the locks to which it points have 
  1176.     ** been unlocked and freed.  So, this is the ONE PLACE in all of SSL
  1177.     ** where the LOCK calls and the corresponding UNLOCK calls are not in
  1178.     ** the same function scope.  The unlock calls are in ssl_FreeSocket().
  1179.     */
  1180.     rv = (PRStatus)(*ss->ops->close)(ss);
  1182.     return rv;
  1183. }
  1185. static int PR_CALLBACK
  1186. ssl_Recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
  1187.  PRIntervalTime timeout)
  1188. {
  1189.     sslSocket *ss;
  1190.     int        rv;
  1192.     ss = ssl_GetPrivate(fd);
  1193.     if (!ss) {
  1194. SSL_DBG(("%d: SSL[%d]: bad socket in recv", SSL_GETPID(), fd));
  1195. return SECFailure;
  1196.     }
  1197.     SSL_LOCK_READER(ss);
  1198.     ss->rTimeout = timeout;
  1199.     rv = (*ss->ops->recv)(ss, (unsigned char*)buf, len, flags);
  1200.     SSL_UNLOCK_READER(ss);
  1201.     return rv;
  1202. }
  1204. static int PR_CALLBACK
  1205. ssl_Send(PRFileDesc *fd, const void *buf, PRInt32 len, PRIntn flags,
  1206.  PRIntervalTime timeout)
  1207. {
  1208.     sslSocket *ss;
  1209.     int        rv;
  1211.     ss = ssl_GetPrivate(fd);
  1212.     if (!ss) {
  1213. SSL_DBG(("%d: SSL[%d]: bad socket in send", SSL_GETPID(), fd));
  1214. return SECFailure;
  1215.     }
  1216.     SSL_LOCK_WRITER(ss);
  1217.     ss->wTimeout = timeout;
  1218.     rv = (*ss->ops->send)(ss, (const unsigned char*)buf, len, flags);
  1219.     SSL_UNLOCK_WRITER(ss);
  1220.     return rv;
  1221. }
  1223. static int PR_CALLBACK
  1224. ssl_Read(PRFileDesc *fd, void *buf, PRInt32 len)
  1225. {
  1226.     sslSocket *ss;
  1227.     int        rv;
  1229.     ss = ssl_GetPrivate(fd);
  1230.     if (!ss) {
  1231. SSL_DBG(("%d: SSL[%d]: bad socket in read", SSL_GETPID(), fd));
  1232. return SECFailure;
  1233.     }
  1234.     SSL_LOCK_READER(ss);
  1235.     ss->rTimeout = PR_INTERVAL_NO_TIMEOUT;
  1236.     rv = (*ss->ops->read)(ss, (unsigned char*)buf, len);
  1237.     SSL_UNLOCK_READER(ss);
  1238.     return rv;
  1239. }
  1241. static int PR_CALLBACK
  1242. ssl_Write(PRFileDesc *fd, const void *buf, PRInt32 len)
  1243. {
  1244.     sslSocket *ss;
  1245.     int        rv;
  1247.     ss = ssl_GetPrivate(fd);
  1248.     if (!ss) {
  1249. SSL_DBG(("%d: SSL[%d]: bad socket in write", SSL_GETPID(), fd));
  1250. return SECFailure;
  1251.     }
  1252.     SSL_LOCK_WRITER(ss);
  1253.     ss->wTimeout = PR_INTERVAL_NO_TIMEOUT;
  1254.     rv = (*ss->ops->write)(ss, (const unsigned char*)buf, len);
  1255.     SSL_UNLOCK_WRITER(ss);
  1256.     return rv;
  1257. }
  1259. static PRStatus PR_CALLBACK
  1260. ssl_GetPeerName(PRFileDesc *fd, PRNetAddr *addr)
  1261. {
  1262.     sslSocket *ss;
  1264.     ss = ssl_GetPrivate(fd);
  1265.     if (!ss) {
  1266. SSL_DBG(("%d: SSL[%d]: bad socket in getpeername", SSL_GETPID(), fd));
  1267. return PR_FAILURE;
  1268.     }
  1269.     return (PRStatus)(*ss->ops->getpeername)(ss, addr);
  1270. }
  1272. /*
  1273. ** XXX this code doesn't work properly inside a Socks server.
  1274. */
  1275. SECStatus
  1276. ssl_GetPeerInfo(sslSocket *ss)
  1277. {
  1278.     sslConnectInfo *  ci;
  1279.     PRNetAddr         sin;
  1280.     int               rv;
  1281.     PRFileDesc *      osfd;
  1283.     PORT_Assert((ss->sec != 0));
  1285.     osfd = ss->fd->lower;
  1286.     ci   = &ss->sec->ci;
  1288.     /* If ssl_SocksConnect() has previously recorded the peer's IP & port,
  1289.      * use that.
  1290.      */
  1291.     if ((ss->port != 0) &&
  1292. ((ss->peer.pr_s6_addr32[0] != 0) || (ss->peer.pr_s6_addr32[1] != 0) ||
  1293.  (ss->peer.pr_s6_addr32[2] != 0) || (ss->peer.pr_s6_addr32[3] != 0))) {
  1294. /* SOCKS code has already recorded the peer's IP addr and port.
  1295.  * (NOT the proxy's addr and port) in ss->peer & port.
  1296.  */
  1297. ci->peer = ss->peer;
  1298. ci->port = ss->port;
  1299. return SECSuccess;
  1300.     }
  1302.     PORT_Memset(&sin, 0, sizeof(sin));
  1303.     rv = osfd->methods->getpeername(osfd, &sin);
  1304.     if (rv < 0) {
  1305. return SECFailure;
  1306.     }
  1307.     /* we have to mask off the high byte because AIX is lame */
  1308.     if ((sin.inet.family & 0xff) == PR_AF_INET) {
  1309.         PR_ConvertIPv4AddrToIPv6(sin.inet.ip, &ci->peer);
  1310. ci->port = sin.inet.port;
  1311.     } else {
  1312.         PORT_Assert(sin.ipv6.family == PR_AF_INET6);
  1313. ci->peer = sin.ipv6.ip;
  1314. ci->port = sin.ipv6.port;
  1315.     }
  1316.     return SECSuccess;
  1317. }
  1319. static PRStatus PR_CALLBACK
  1320. ssl_GetSockName(PRFileDesc *fd, PRNetAddr *name)
  1321. {
  1322.     sslSocket *ss;
  1324.     ss = ssl_GetPrivate(fd);
  1325.     if (!ss) {
  1326. SSL_DBG(("%d: SSL[%d]: bad socket in getsockname", SSL_GETPID(), fd));
  1327. return PR_FAILURE;
  1328.     }
  1329.     return (PRStatus)(*ss->ops->getsockname)(ss, name);
  1330. }
  1332. int PR_CALLBACK
  1333. SSL_SetSockPeerID(PRFileDesc *fd, char *peerID)
  1334. {
  1335.     sslSocket *ss;
  1337.     ss = ssl_GetPrivate(fd);
  1338.     if (!ss) {
  1339. SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetCacheIndex",
  1340.  SSL_GETPID(), fd));
  1341. return SECFailure;
  1342.     }
  1344.     ss->peerID = PORT_Strdup(peerID);
  1345.     return 0;
  1346. }
  1348. static PRInt16 PR_CALLBACK
  1349. ssl_Poll(PRFileDesc *fd, PRInt16 how_flags, PRInt16 *out_flags)
  1350. {
  1351.     sslSocket *ss;
  1352.     PRInt16    ret_flags = how_flags; /* should select on these flags. */
  1354.     *out_flags = 0;
  1355.     ss = ssl_GetPrivate(fd);
  1356.     if (!ss) {
  1357. SSL_DBG(("%d: SSL[%d]: bad socket in SSL_Poll",
  1358.  SSL_GETPID(), fd));
  1359. return 0; /* don't poll on this socket */
  1360.     }
  1362.     if ((ret_flags & PR_POLL_WRITE) && 
  1363.         ( (ss->useSocks && ss->handshake) || 
  1364.   (ss->useSecurity && !ss->connected && 
  1365.    /* XXX There needs to be a better test than the following. */
  1366.    /* Don't check ss->securityHandshake. */
  1367.    (ss->handshake || ss->nextHandshake)))) {
  1368.      /* The user is trying to write, but the handshake is blocked waiting
  1369.  * to read, so tell NSPR NOT to poll on write.
  1370.  */
  1371. ret_flags ^=  PR_POLL_WRITE; /* don't select on write. */
  1372. ret_flags |=  PR_POLL_READ; /* do    select on read. */
  1373.     }
  1375.     if ((ret_flags & PR_POLL_READ) && (SSL_DataPending(fd) > 0)) {
  1376. *out_flags = PR_POLL_READ; /* it's ready already. */
  1378.     } else if (ret_flags && (fd->lower->methods->poll != NULL)) {
  1379.         ret_flags = fd->lower->methods->poll(fd->lower, ret_flags, out_flags);
  1380.     }
  1382.     return ret_flags;
  1383. }
  1386. PRBool
  1387. ssl_FdIsBlocking(PRFileDesc *fd)
  1388. {
  1389.     PRSocketOptionData opt;
  1390.     PRStatus           status;
  1392.     opt.option             = PR_SockOpt_Nonblocking;
  1393.     opt.value.non_blocking = PR_FALSE;
  1394.     status = PR_GetSocketOption(fd, &opt);
  1395.     if (status != PR_SUCCESS)
  1396. return PR_FALSE;
  1397.     return (PRBool)!opt.value.non_blocking;
  1398. }
  1400. PRBool
  1401. ssl_SocketIsBlocking(sslSocket *ss)
  1402. {
  1403.     return ssl_FdIsBlocking(ss->fd);
  1404. }
  1406. PRInt32  sslFirstBufSize = 8 * 1024;
  1407. PRInt32  sslCopyLimit    = 1024;
  1409. static PRInt32 PR_CALLBACK
  1410. ssl_WriteV(PRFileDesc *fd, const PRIOVec *iov, PRInt32 vectors, 
  1411.            PRIntervalTime timeout)
  1412. {
  1413.     PRInt32            bufLen;
  1414.     PRInt32            left;
  1415.     PRInt32            rv;
  1416.     PRInt32            sent      =  0;
  1417.     const PRInt32      first_len = sslFirstBufSize;
  1418.     const PRInt32      limit     = sslCopyLimit;
  1419.     PRBool             blocking;
  1420.     PRIOVec            myIov  = { 0, 0 };
  1421.     char               buf[MAX_FRAGMENT_LENGTH];
  1423.     if (vectors > PR_MAX_IOVECTOR_SIZE) {
  1424.      PORT_SetError(PR_BUFFER_OVERFLOW_ERROR);
  1425. return -1;
  1426.     }
  1427.     blocking = ssl_FdIsBlocking(fd);
  1429. #define K16 sizeof(buf)
  1430. #define KILL_VECTORS while (vectors && !iov->iov_len) { ++iov; --vectors; }
  1431. #define GET_VECTOR   do { myIov = *iov++; --vectors; KILL_VECTORS } while (0)
  1432. #define HANDLE_ERR(rv, len) 
  1433.     if (rv != len) { 
  1434. if (rv < 0) { 
  1435.     if (blocking 
  1436. && (PR_GetError() == PR_WOULD_BLOCK_ERROR) 
  1437. && (sent > 0)) { 
  1438. return sent; 
  1439.     } else { 
  1440. return -1; 
  1441.     } 
  1442. } 
  1443. /* Only a nonblocking socket can have partial sends */ 
  1444. PR_ASSERT(blocking); 
  1445. return sent; 
  1446.     } 
  1447. #define SEND(bfr, len) 
  1448.     do { 
  1449. rv = ssl_Send(fd, bfr, len, 0, timeout); 
  1450. HANDLE_ERR(rv, len) 
  1451. sent += len; 
  1452.     } while (0)
  1454.     /* Make sure the first write is at least 8 KB, if possible. */
  1455.     KILL_VECTORS
  1456.     if (!vectors)
  1457. return 0;
  1458.     GET_VECTOR;
  1459.     if (!vectors) {
  1460. return ssl_Send(fd, myIov.iov_base, myIov.iov_len, 0, timeout);
  1461.     }
  1462.     if (myIov.iov_len < first_len) {
  1463. PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len);
  1464. bufLen = myIov.iov_len;
  1465. left = first_len - bufLen;
  1466. while (vectors && left) {
  1467.     int toCopy;
  1468.     GET_VECTOR;
  1469.     toCopy = PR_MIN(left, myIov.iov_len);
  1470.     PORT_Memcpy(buf + bufLen, myIov.iov_base, toCopy);
  1471.     bufLen         += toCopy;
  1472.     left           -= toCopy;
  1473.     myIov.iov_base += toCopy;
  1474.     myIov.iov_len  -= toCopy;
  1475. }
  1476. SEND( buf, bufLen );
  1477.     }
  1479.     while (vectors || myIov.iov_len) {
  1480. PRInt32   addLen;
  1481. if (!myIov.iov_len) {
  1482.     GET_VECTOR;
  1483. }
  1484. while (myIov.iov_len >= K16) {
  1485.     SEND(myIov.iov_base, K16);
  1486.     myIov.iov_base += K16;
  1487.     myIov.iov_len  -= K16;
  1488. }
  1489. if (!myIov.iov_len)
  1490.     continue;
  1492. if (!vectors || myIov.iov_len > limit) {
  1493.     addLen = 0;
  1494. } else if ((addLen = iov->iov_len % K16) + myIov.iov_len <= limit) {
  1495.     /* Addlen is already computed. */;
  1496. } else if (vectors > 1 && 
  1497.      iov[1].iov_len % K16 + addLen + myIov.iov_len <= 2 * limit) {
  1498.      addLen = limit - myIov.iov_len;
  1499. } else 
  1500.     addLen = 0;
  1502. if (!addLen) {
  1503.     SEND( myIov.iov_base, myIov.iov_len );
  1504.     myIov.iov_len = 0;
  1505.     continue;
  1506. }
  1507. PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len);
  1508. bufLen = myIov.iov_len;
  1509. do {
  1510.     GET_VECTOR;
  1511.     PORT_Memcpy(buf + bufLen, myIov.iov_base, addLen);
  1512.     myIov.iov_base += addLen;
  1513.     myIov.iov_len  -= addLen;
  1514.     bufLen         += addLen;
  1516.     left = PR_MIN( limit, K16 - bufLen);
  1517.     if (!vectors  /* no more left */
  1518.     ||  myIov.iov_len > 0 /* we didn't use that one all up */
  1519.     ||  bufLen >= K16 /* it's full. */
  1520.     ) {
  1521. addLen = 0;
  1522.     } else if ((addLen = iov->iov_len % K16) <= left) {
  1523. /* Addlen is already computed. */;
  1524.     } else if (vectors > 1 && 
  1525.  iov[1].iov_len % K16 + addLen <= left + limit) {
  1526.  addLen = left;
  1527.     } else 
  1528. addLen = 0;
  1530. } while (addLen);
  1531. SEND( buf, bufLen );
  1532.     } 
  1533.     return sent;
  1534. }
  1536. /*
  1537.  * These functions aren't implemented.
  1538.  */
  1540. static PRInt32 PR_CALLBACK
  1541. ssl_Available(PRFileDesc *fd)
  1542. {
  1543.     PORT_Assert(0);
  1544.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1545.     return SECFailure;
  1546. }
  1548. static PRInt64 PR_CALLBACK
  1549. ssl_Available64(PRFileDesc *fd)
  1550. {
  1551.     PRInt64 res;
  1553.     PORT_Assert(0);
  1554.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1555.     LL_I2L(res, -1L);
  1556.     return res;
  1557. }
  1559. static PRStatus PR_CALLBACK
  1560. ssl_FSync(PRFileDesc *fd)
  1561. {
  1562.     PORT_Assert(0);
  1563.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1564.     return PR_FAILURE;
  1565. }
  1567. static PRInt32 PR_CALLBACK
  1568. ssl_Seek(PRFileDesc *fd, PRInt32 offset, PRSeekWhence how) {
  1569.     PORT_Assert(0);
  1570.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1571.     return SECFailure;
  1572. }
  1574. static PRInt64 PR_CALLBACK
  1575. ssl_Seek64(PRFileDesc *fd, PRInt64 offset, PRSeekWhence how) {
  1576.     PRInt64 res;
  1578.     PORT_Assert(0);
  1579.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1580.     LL_I2L(res, -1L);
  1581.     return res;
  1582. }
  1584. static PRStatus PR_CALLBACK
  1585. ssl_FileInfo(PRFileDesc *fd, PRFileInfo *info)
  1586. {
  1587.     PORT_Assert(0);
  1588.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1589.     return PR_FAILURE;
  1590. }
  1592. static PRStatus PR_CALLBACK
  1593. ssl_FileInfo64(PRFileDesc *fd, PRFileInfo64 *info)
  1594. {
  1595.     PORT_Assert(0);
  1596.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1597.     return PR_FAILURE;
  1598. }
  1600. static PRInt32 PR_CALLBACK
  1601. ssl_RecvFrom(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags,
  1602.      PRNetAddr *addr, PRIntervalTime timeout)
  1603. {
  1604.     PORT_Assert(0);
  1605.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1606.     return SECFailure;
  1607. }
  1609. static PRInt32 PR_CALLBACK
  1610. ssl_SendTo(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags,
  1611.    const PRNetAddr *addr, PRIntervalTime timeout)
  1612. {
  1613.     PORT_Assert(0);
  1614.     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  1615.     return SECFailure;
  1616. }
  1618. static const PRIOMethods ssl_methods = {
  1619.     PR_DESC_LAYERED,
  1620.     ssl_Close,            /* close        */
  1621.     ssl_Read,             /* read         */
  1622.     ssl_Write,            /* write        */
  1623.     ssl_Available,        /* available    */
  1624.     ssl_Available64,      /* available64  */
  1625.     ssl_FSync,            /* fsync        */
  1626.     ssl_Seek,             /* seek         */
  1627.     ssl_Seek64,           /* seek64       */
  1628.     ssl_FileInfo,         /* fileInfo     */
  1629.     ssl_FileInfo64,       /* fileInfo64   */
  1630.     ssl_WriteV,           /* writev       */
  1631.     ssl_Connect,          /* connect      */
  1632.     ssl_Accept,           /* accept       */
  1633.     ssl_Bind,             /* bind         */
  1634.     ssl_Listen,           /* listen       */
  1635.     ssl_Shutdown,         /* shutdown     */
  1636.     ssl_Recv,             /* recv         */
  1637.     ssl_Send,             /* send         */
  1638.     ssl_RecvFrom,         /* recvfrom     */
  1639.     ssl_SendTo,           /* sendto       */
  1640.     ssl_Poll,             /* poll         */
  1641.     ssl_EmulateAcceptRead,      /* acceptread   */
  1642.     ssl_EmulateTransmitFile,    /* transmitfile */
  1643.     ssl_GetSockName,      /* getsockname  */
  1644.     ssl_GetPeerName,      /* getpeername  */
  1645.     NULL,                 /* getsockopt   OBSOLETE */
  1646.     NULL,                 /* setsockopt   OBSOLETE */
  1647.     NULL,                 /* getsocketoption   */
  1648.     NULL,                 /* setsocketoption   */
  1649.     ssl_EmulateSendFile,  /* Send a (partial) file with header/trailer*/
  1650.     NULL,                 /* reserved for future use */
  1651.     NULL,                 /* reserved for future use */
  1652.     NULL,                 /* reserved for future use */
  1653.     NULL,                 /* reserved for future use */
  1654.     NULL                  /* reserved for future use */
  1655. };
  1658. static PRIOMethods combined_methods;
  1660. static void
  1661. ssl_SetupIOMethods(void)
  1662. {
  1663.           PRIOMethods *new_methods  = &combined_methods;
  1664.     const PRIOMethods *nspr_methods = PR_GetDefaultIOMethods();
  1665.     const PRIOMethods *my_methods   = &ssl_methods;
  1667.     *new_methods = *nspr_methods;
  1669.     new_methods->file_type         = my_methods->file_type;
  1670.     new_methods->close             = my_methods->close;
  1671.     new_methods->read              = my_methods->read;
  1672.     new_methods->write             = my_methods->write;
  1673.     new_methods->available         = my_methods->available;
  1674.     new_methods->available64       = my_methods->available64;
  1675.     new_methods->fsync             = my_methods->fsync;
  1676.     new_methods->seek              = my_methods->seek;
  1677.     new_methods->seek64            = my_methods->seek64;
  1678.     new_methods->fileInfo          = my_methods->fileInfo;
  1679.     new_methods->fileInfo64        = my_methods->fileInfo64;
  1680.     new_methods->writev            = my_methods->writev;
  1681.     new_methods->connect           = my_methods->connect;
  1682.     new_methods->accept            = my_methods->accept;
  1683.     new_methods->bind              = my_methods->bind;
  1684.     new_methods->listen            = my_methods->listen;
  1685.     new_methods->shutdown          = my_methods->shutdown;
  1686.     new_methods->recv              = my_methods->recv;
  1687.     new_methods->send              = my_methods->send;
  1688.     new_methods->recvfrom          = my_methods->recvfrom;
  1689.     new_methods->sendto            = my_methods->sendto;
  1690.     new_methods->poll              = my_methods->poll;
  1691.     new_methods->acceptread        = my_methods->acceptread;
  1692.     new_methods->transmitfile      = my_methods->transmitfile;
  1693.     new_methods->getsockname       = my_methods->getsockname;
  1694.     new_methods->getpeername       = my_methods->getpeername;
  1695. /*  new_methods->getsocketoption   = my_methods->getsocketoption; */
  1696. /*  new_methods->setsocketoption   = my_methods->setsocketoption; */
  1697.     new_methods->sendfile          = my_methods->sendfile;
  1699. }
  1701. static PRCallOnceType initIoLayerOnce;
  1703. static PRStatus  
  1704. ssl_InitIOLayer(void)
  1705. {
  1706.     ssl_layer_id = PR_GetUniqueIdentity("SSL");
  1707.     ssl_SetupIOMethods();
  1708.     ssl_inited = PR_TRUE;
  1709.     return PR_SUCCESS;
  1710. }
  1712. static PRStatus
  1713. ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, PRDescIdentity id)
  1714. {
  1715.     PRFileDesc *layer = NULL;
  1716.     PRStatus    status;
  1718.     if (!ssl_inited) {
  1719. PR_CallOnce(&initIoLayerOnce, &ssl_InitIOLayer);
  1720.     }
  1722.     if (ns == NULL)
  1723. goto loser;
  1725.     layer = PR_CreateIOLayerStub(ssl_layer_id, &combined_methods);
  1726.     if (layer == NULL)
  1727. goto loser;
  1728.     layer->secret = (PRFilePrivate *)ns;
  1730.     /* Here, "stack" points to the PRFileDesc on the top of the stack.
  1731.     ** "layer" points to a new FD that is to be inserted into the stack.
  1732.     ** If layer is being pushed onto the top of the stack, then 
  1733.     ** PR_PushIOLayer switches the contents of stack and layer, and then
  1734.     ** puts stack on top of layer, so that after it is done, the top of 
  1735.     ** stack is the same "stack" as it was before, and layer is now the 
  1736.     ** FD for the former top of stack.
  1737.     ** After this call, stack always points to the top PRFD on the stack.
  1738.     ** If this function fails, the contents of stack and layer are as 
  1739.     ** they were before the call.
  1740.     */
  1741.     status = PR_PushIOLayer(stack, id, layer);
  1742.     if (status != PR_SUCCESS)
  1743. goto loser;
  1745.     ns->fd = (id == PR_TOP_IO_LAYER) ? stack : layer;
  1746.     return PR_SUCCESS;
  1748. loser:
  1749.     if (layer) {
  1750. layer->dtor(layer); /* free layer */
  1751.     }
  1752.     return PR_FAILURE;
  1753. }
  1755. /*
  1756. ** Create a newsocket structure for a file descriptor.
  1757. */
  1758. static sslSocket *
  1759. ssl_NewSocket(void)
  1760. {
  1761.     sslSocket *ss;
  1762. #ifdef DEBUG
  1763.     static int firsttime = 1;
  1764. #endif
  1766. #ifdef DEBUG
  1767. #if defined(XP_UNIX) || defined(XP_WIN32)
  1768.     if (firsttime) {
  1769. firsttime = 0;
  1771. {
  1772.     char *ev = getenv("SSLDEBUG");
  1773.     if (ev && ev[0]) {
  1774. ssl_debug = atoi(ev);
  1775. SSL_TRACE(("SSL: debugging set to %d", ssl_debug));
  1776.     }
  1777. }
  1778. #ifdef TRACE
  1779. {
  1780.     char *ev = getenv("SSLTRACE");
  1781.     if (ev && ev[0]) {
  1782. ssl_trace = atoi(ev);
  1783. SSL_TRACE(("SSL: tracing set to %d", ssl_trace));
  1784.     }
  1785. }
  1786. #endif /* TRACE */
  1787.     }
  1788. #endif /* XP_UNIX || XP_WIN32 */
  1789. #endif /* DEBUG */
  1791.     /* Make a new socket and get it ready */
  1792.     ss = (sslSocket*) PORT_ZAlloc(sizeof(sslSocket));
  1793.     if (ss) {
  1794.         /* This should be of type SSLKEAType, but CC on IRIX
  1795.  * complains during the for loop.
  1796.  */
  1797. int i;
  1798.  
  1799. ss->useSecurity        = ssl_defaults.useSecurity;
  1800. ss->useSocks           = ssl_defaults.useSocks;
  1801. ss->requestCertificate = ssl_defaults.requestCertificate;
  1802. ss->requireCertificate = ssl_defaults.requireCertificate;
  1803. ss->handshakeAsClient  = ssl_defaults.handshakeAsClient;
  1804. ss->handshakeAsServer  = ssl_defaults.handshakeAsServer;
  1805. ss->enableSSL2         = ssl_defaults.enableSSL2;
  1806. ss->enableSSL3         = ssl_defaults.enableSSL3;
  1807. ss->enableTLS          = ssl_defaults.enableTLS ;
  1808. ss->fdx                = ssl_defaults.fdx;
  1809. ss->v2CompatibleHello  = ssl_defaults.v2CompatibleHello;
  1810. ss->detectRollBack     = ssl_defaults.detectRollBack;
  1811. memset(&ss->peer, 0, sizeof(ss->peer));
  1812. ss->port               = 0;
  1813. ss->noCache            = ssl_defaults.noCache;
  1814. ss->peerID             = NULL;
  1815. ss->rTimeout        = PR_INTERVAL_NO_TIMEOUT;
  1816. ss->wTimeout        = PR_INTERVAL_NO_TIMEOUT;
  1817. ss->cTimeout        = PR_INTERVAL_NO_TIMEOUT;
  1818. ss->cipherSpecs        = NULL;
  1819.         ss->sizeCipherSpecs    = 0;  /* produced lazily */
  1820.         ss->preferredCipher    = NULL;
  1821.         ss->url                = NULL;
  1823. for (i=kt_null; i < kt_kea_size; i++) {
  1824.     ss->serverCert[i]      = NULL;
  1825.     ss->serverCertChain[i] = NULL;
  1826.     ss->serverKey[i]       = NULL;
  1827. }
  1828. ss->stepDownKeyPair    = NULL;
  1829. ss->dbHandle           = CERT_GetDefaultCertDB();
  1831. /* Provide default implementation of hooks */
  1832. ss->authCertificate    = SSL_AuthCertificate;
  1833. ss->authCertificateArg = (void *)ss->dbHandle;
  1834. ss->getClientAuthData  = NULL;
  1835. ss->handleBadCert      = NULL;
  1836. ss->badCertArg         = NULL;
  1837. ss->pkcs11PinArg       = NULL;
  1839. ssl_ChooseOps(ss);
  1840. ssl2_InitSocketPolicy(ss);
  1841. ssl3_InitSocketPolicy(ss);
  1843. ss->firstHandshakeLock = PR_NewMonitor();
  1844. ss->ssl3HandshakeLock  = PR_NewMonitor();
  1845. ss->specLock           = NSSRWLock_New(SSL_LOCK_RANK_SPEC, NULL);
  1846. ss->recvBufLock        = PR_NewMonitor();
  1847. ss->xmitBufLock        = PR_NewMonitor();
  1848. if (ssl_lock_readers) {
  1849.     ss->recvLock       = PR_NewLock();
  1850.     ss->sendLock       = PR_NewLock();
  1851. }
  1852.     }
  1853.     return ss;
  1854. }