自学教程：C++ ssl_GetSSL3HandshakeLock函数代码示例

/* For SSLv2, does nothing but return an error.** For SSLv3, flushes SID cache entry (if requested),** and then starts new client hello or hello request.** Acquires and releases HandshakeLock.*/SECStatusSSL_ReHandshake(PRFileDesc *fd, PRBool flushCache){    sslSocket *ss;    SECStatus rv;    ss = ssl_FindSocket(fd);    if (!ss) {        SSL_DBG(("%d: SSL[%d]: bad socket in RedoHandshake", SSL_GETPID(), fd));        return SECFailure;    }    if (!ss->opt.useSecurity)        return SECSuccess;    ssl_Get1stHandshakeLock(ss);    ssl_GetSSL3HandshakeLock(ss);    rv = ssl3_RedoHandshake(ss, flushCache); /* force full handshake. */    ssl_ReleaseSSL3HandshakeLock(ss);    ssl_Release1stHandshakeLock(ss);    return rv;}

/* Register an application callback to be called when false start may happen.** Acquires and releases HandshakeLock.*/SECStatusSSL_SetCanFalseStartCallback(PRFileDesc *fd, SSLCanFalseStartCallback cb,			     void *arg){    sslSocket *ss;    ss = ssl_FindSocket(fd);    if (!ss) {	SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetCanFalseStartCallback",		 SSL_GETPID(), fd));	return SECFailure;    }    if (!ss->opt.useSecurity) {	PORT_SetError(SEC_ERROR_INVALID_ARGS);	return SECFailure;    }    ssl_Get1stHandshakeLock(ss);    ssl_GetSSL3HandshakeLock(ss);    ss->canFalseStartCallback     = cb;    ss->canFalseStartCallbackData = arg;    ssl_ReleaseSSL3HandshakeLock(ss);    ssl_Release1stHandshakeLock(ss);    return SECSuccess;}

SECItem *SSL_GetSessionID(PRFileDesc *fd){    sslSocket *    ss;    SECItem *      item = NULL;    ss = ssl_FindSocket(fd);    if (ss) {	ssl_Get1stHandshakeLock(ss);	ssl_GetSSL3HandshakeLock(ss);	if (ss->opt.useSecurity && ss->firstHsDone && ss->sec.ci.sid) {	    item = (SECItem *)PORT_Alloc(sizeof(SECItem));	    if (item) {		sslSessionID * sid = ss->sec.ci.sid;		if (sid->version < SSL_LIBRARY_VERSION_3_0) {		    item->len = SSL2_SESSIONID_BYTES;		    item->data = (unsigned char*)PORT_Alloc(item->len);		    PORT_Memcpy(item->data, sid->u.ssl2.sessionID, item->len);		} else {		    item->len = sid->u.ssl3.sessionIDLength;		    item->data = (unsigned char*)PORT_Alloc(item->len);		    PORT_Memcpy(item->data, sid->u.ssl3.sessionID, item->len);		}	    }	}	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_Release1stHandshakeLock(ss);    }    return item;}

/* * Allow the application to pass the set of trust anchors */SECStatusSSL_SetTrustAnchors(PRFileDesc *fd, CERTCertList *certList){    sslSocket *ss = ssl_FindSocket(fd);    CERTDistNames *names = NULL;    if (!certList) {        PORT_SetError(SEC_ERROR_INVALID_ARGS);        return SECFailure;    }    if (!ss) {        SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetTrustAnchors",                 SSL_GETPID(), fd));        return SECFailure;    }    names = CERT_DistNamesFromCertList(certList);    if (names == NULL) {        return SECFailure;    }    ssl_Get1stHandshakeLock(ss);    ssl_GetSSL3HandshakeLock(ss);    if (ss->ssl3.ca_list) {        CERT_FreeDistNames(ss->ssl3.ca_list);    }    ss->ssl3.ca_list = names;    ssl_ReleaseSSL3HandshakeLock(ss);    ssl_Release1stHandshakeLock(ss);    return SECSuccess;}

/* * Allow the application to pass the url or hostname into the SSL library * so that we can do some checking on it. It will be used for the value in * SNI extension of client hello message. */SECStatusSSL_SetURL(PRFileDesc *fd, const char *url){    sslSocket *   ss = ssl_FindSocket(fd);    SECStatus     rv = SECSuccess;    if (!ss) {	SSL_DBG(("%d: SSL[%d]: bad socket in SSLSetURL",		 SSL_GETPID(), fd));	return SECFailure;    }    ssl_Get1stHandshakeLock(ss);    ssl_GetSSL3HandshakeLock(ss);    if ( ss->url ) {	PORT_Free((void *)ss->url);	/* CONST */    }    ss->url = (const char *)PORT_Strdup(url);    if ( ss->url == NULL ) {	rv = SECFailure;    }    ssl_ReleaseSSL3HandshakeLock(ss);    ssl_Release1stHandshakeLock(ss);    return rv;}

/* For SSLv2, does nothing but return an error.** For SSLv3, flushes SID cache entry (if requested),** and then starts new client hello or hello request.** Acquires and releases HandshakeLock.*/SECStatusSSL_ReHandshake(PRFileDesc *fd, PRBool flushCache){    sslSocket *ss;    SECStatus  rv;        ss = ssl_FindSocket(fd);    if (!ss) {	SSL_DBG(("%d: SSL[%d]: bad socket in RedoHandshake", SSL_GETPID(), fd));	return SECFailure;    }    if (!ss->opt.useSecurity)	return SECSuccess;        ssl_Get1stHandshakeLock(ss);    /* SSL v2 protocol does not support subsequent handshakes. */    if (ss->version < SSL_LIBRARY_VERSION_3_0) {	PORT_SetError(SEC_ERROR_INVALID_ARGS);	rv = SECFailure;    } else {	ssl_GetSSL3HandshakeLock(ss);	rv = ssl3_RedoHandshake(ss, flushCache); /* force full handshake. */	ssl_ReleaseSSL3HandshakeLock(ss);    }    ssl_Release1stHandshakeLock(ss);    return rv;}

SECStatusSSL_HandshakeNegotiatedExtension(PRFileDesc * socket,                                  SSLExtensionType extId,                                 PRBool *pYes){  /* some decisions derived from SSL_GetChannelInfo */  sslSocket * sslsocket = NULL;  PRBool enoughFirstHsDone = PR_FALSE;  if (!pYes) {    PORT_SetError(SEC_ERROR_INVALID_ARGS);    return SECFailure;  }  sslsocket = ssl_FindSocket(socket);  if (!sslsocket) {    SSL_DBG(("%d: SSL[%d]: bad socket in HandshakeNegotiatedExtension",             SSL_GETPID(), socket));    return SECFailure;  }  *pYes = PR_FALSE;  if (sslsocket->firstHsDone) {    enoughFirstHsDone = PR_TRUE;  } else if (sslsocket->ssl3.initialized && ssl3_CanFalseStart(sslsocket)) {    enoughFirstHsDone = PR_TRUE;  }  /* according to public API SSL_GetChannelInfo, this doesn't need a lock */  if (sslsocket->opt.useSecurity && enoughFirstHsDone) {    if (sslsocket->ssl3.initialized) { /* SSL3 and TLS */      /* now we know this socket went through ssl3_InitState() and       * ss->xtnData got initialized, which is the only member accessed by       * ssl3_ExtensionNegotiated();       * Member xtnData appears to get accessed in functions that handle       * the handshake (hello messages and extension sending),       * therefore the handshake lock should be sufficient.       */      ssl_GetSSL3HandshakeLock(sslsocket);      *pYes = ssl3_ExtensionNegotiated(sslsocket, extId);      ssl_ReleaseSSL3HandshakeLock(sslsocket);    }  }  return SECSuccess;}

SECStatusSSL_CacheSession(PRFileDesc *fd){    sslSocket *   ss = ssl_FindSocket(fd);    SECStatus     rv = SECFailure;    if (ss) {	ssl_Get1stHandshakeLock(ss);	ssl_GetSSL3HandshakeLock(ss);	ssl3_CacheSessionUnlocked(ss);	rv = SECSuccess;	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_Release1stHandshakeLock(ss);    }    return rv;}

PRBool SSLInt_SendNewSessionTicket(PRFileDesc *fd) {  sslSocket *ss = ssl_FindSocket(fd);  if (!ss) {    return PR_FALSE;  }  ssl_GetSSL3HandshakeLock(ss);  ssl_GetXmitBufLock(ss);  SECStatus rv = tls13_SendNewSessionTicket(ss);  if (rv == SECSuccess) {    rv = ssl3_FlushHandshake(ss, 0);  }  ssl_ReleaseXmitBufLock(ss);  ssl_ReleaseSSL3HandshakeLock(ss);  return rv == SECSuccess;}

SECStatusSSL_InvalidateSession(PRFileDesc *fd){    sslSocket *   ss = ssl_FindSocket(fd);    SECStatus     rv = SECFailure;    if (ss) {	ssl_Get1stHandshakeLock(ss);	ssl_GetSSL3HandshakeLock(ss);	if (ss->sec.ci.sid && ss->sec.uncache) {	    ss->sec.uncache(ss->sec.ci.sid);	    rv = SECSuccess;	}	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_Release1stHandshakeLock(ss);    }    return rv;}

/*** Returns Negative number on error, zero or greater on success.** Returns the amount of data immediately available to be read.*/intSSL_DataPending(PRFileDesc *fd){    sslSocket *ss;    int        rv  = 0;    ss = ssl_FindSocket(fd);    if (ss && ss->opt.useSecurity) {	ssl_Get1stHandshakeLock(ss);	ssl_GetSSL3HandshakeLock(ss);	ssl_GetRecvBufLock(ss);	rv = ss->gs.writeOffset - ss->gs.readOffset;	ssl_ReleaseRecvBufLock(ss);	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_Release1stHandshakeLock(ss);    }    return rv;}

/* Caller holds the SSL Socket's write lock. SSL_LOCK_WRITER(ss) */intssl_SecureSend(sslSocket *ss, const unsigned char *buf, int len, int flags){    int rv = 0;    PRBool falseStart = PR_FALSE;    SSL_TRC(2, ("%d: SSL[%d]: SecureSend: sending %d bytes",		SSL_GETPID(), ss->fd, len));    if (ss->shutdownHow & ssl_SHUTDOWN_SEND) {	PORT_SetError(PR_SOCKET_SHUTDOWN_ERROR);    	rv = PR_FAILURE;	goto done;    }    if (flags) {	PORT_SetError(PR_INVALID_ARGUMENT_ERROR);    	rv = PR_FAILURE;	goto done;    }    ssl_GetXmitBufLock(ss);    if (ss->pendingBuf.len != 0) {	PORT_Assert(ss->pendingBuf.len > 0);	rv = ssl_SendSavedWriteData(ss);	if (rv >= 0 && ss->pendingBuf.len != 0) {	    PORT_Assert(ss->pendingBuf.len > 0);	    PORT_SetError(PR_WOULD_BLOCK_ERROR);	    rv = SECFailure;	}    }    ssl_ReleaseXmitBufLock(ss);    if (rv < 0) {	goto done;    }    if (len > 0)     	ss->writerThread = PR_GetCurrentThread();    /* If any of these is non-zero, the initial handshake is not done. */    if (!ss->firstHsDone) {	ssl_Get1stHandshakeLock(ss);	if (ss->opt.enableFalseStart &&	    ss->version >= SSL_LIBRARY_VERSION_3_0) {	    ssl_GetSSL3HandshakeLock(ss);	    falseStart = ss->ssl3.hs.canFalseStart;	    ssl_ReleaseSSL3HandshakeLock(ss);	}	if (!falseStart &&	    (ss->handshake || ss->nextHandshake || ss->securityHandshake)) {	    rv = ssl_Do1stHandshake(ss);	}	ssl_Release1stHandshakeLock(ss);    }    if (rv < 0) {    	ss->writerThread = NULL;	goto done;    }    /* Check for zero length writes after we do housekeeping so we make forward     * progress.     */    if (len == 0) {    	rv = 0;	goto done;    }    PORT_Assert(buf != NULL);    if (!buf) {	PORT_SetError(PR_INVALID_ARGUMENT_ERROR);    	rv = PR_FAILURE;	goto done;    }    if (!ss->firstHsDone) {	PORT_Assert(ss->version >= SSL_LIBRARY_VERSION_3_0);#ifdef DEBUG	ssl_GetSSL3HandshakeLock(ss);	PORT_Assert(ss->ssl3.hs.canFalseStart);	ssl_ReleaseSSL3HandshakeLock(ss);#endif	SSL_TRC(3, ("%d: SSL[%d]: SecureSend: sending data due to false start",		    SSL_GETPID(), ss->fd));    }    /* Send out the data using one of these functions:     *	ssl2_SendClear, ssl2_SendStream, ssl2_SendBlock,      *  ssl3_SendApplicationData     */    ssl_GetXmitBufLock(ss);    rv = (*ss->sec.send)(ss, buf, len, flags);    ssl_ReleaseXmitBufLock(ss);    ss->writerThread = NULL;done:    if (rv < 0) {	SSL_TRC(2, ("%d: SSL[%d]: SecureSend: returning %d count, error %d",		    SSL_GETPID(), ss->fd, rv, PORT_GetError()));    } else {	SSL_TRC(2, ("%d: SSL[%d]: SecureSend: returning %d count",		    SSL_GETPID(), ss->fd, rv));    }    return rv;//.........这里部分代码省略.........

/* Caller holds the SSL Socket's write lock. SSL_LOCK_WRITER(ss) */intssl_SecureSend(sslSocket *ss, const unsigned char *buf, int len, int flags){    int rv = 0;    SSL_TRC(2, ("%d: SSL[%d]: SecureSend: sending %d bytes",                SSL_GETPID(), ss->fd, len));    if (ss->shutdownHow & ssl_SHUTDOWN_SEND) {        PORT_SetError(PR_SOCKET_SHUTDOWN_ERROR);        rv = PR_FAILURE;        goto done;    }    if (flags) {        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);        rv = PR_FAILURE;        goto done;    }    ssl_GetXmitBufLock(ss);    if (ss->pendingBuf.len != 0) {        PORT_Assert(ss->pendingBuf.len > 0);        rv = ssl_SendSavedWriteData(ss);        if (rv >= 0 && ss->pendingBuf.len != 0) {            PORT_Assert(ss->pendingBuf.len > 0);            PORT_SetError(PR_WOULD_BLOCK_ERROR);            rv = SECFailure;        }    }    ssl_ReleaseXmitBufLock(ss);    if (rv < 0) {        goto done;    }    if (len > 0)        ss->writerThread = PR_GetCurrentThread();    /* Check to see if we can write even though we're not finished.     *     * Case 1: False start     * Case 2: TLS 1.3 0-RTT     */    if (!ss->firstHsDone) {        PRBool falseStart = PR_FALSE;        ssl_Get1stHandshakeLock(ss);        if (ss->opt.enableFalseStart ||            (ss->opt.enable0RttData && !ss->sec.isServer)) {            ssl_GetSSL3HandshakeLock(ss);            /* The client can sometimes send before the handshake is fully             * complete. In TLS 1.2: false start; in TLS 1.3: 0-RTT. */            falseStart = ss->ssl3.hs.canFalseStart ||                         ss->ssl3.hs.zeroRttState == ssl_0rtt_sent ||                         ss->ssl3.hs.zeroRttState == ssl_0rtt_accepted;            ssl_ReleaseSSL3HandshakeLock(ss);        }        if (!falseStart && ss->handshake) {            rv = ssl_Do1stHandshake(ss);        }        ssl_Release1stHandshakeLock(ss);    }    if (rv < 0) {        ss->writerThread = NULL;        goto done;    }    /* Check for zero length writes after we do housekeeping so we make forward     * progress.     */    if (len == 0) {        rv = 0;        goto done;    }    PORT_Assert(buf != NULL);    if (!buf) {        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);        rv = PR_FAILURE;        goto done;    }    if (!ss->firstHsDone) {#ifdef DEBUG        ssl_GetSSL3HandshakeLock(ss);        PORT_Assert(!ss->sec.isServer &&                    (ss->ssl3.hs.canFalseStart ||                     ss->ssl3.hs.zeroRttState == ssl_0rtt_sent ||                     ss->ssl3.hs.zeroRttState == ssl_0rtt_accepted));        ssl_ReleaseSSL3HandshakeLock(ss);#endif        SSL_TRC(3, ("%d: SSL[%d]: SecureSend: sending data due to false start",                    SSL_GETPID(), ss->fd));    }    ssl_GetXmitBufLock(ss);    rv = ssl3_SendApplicationData(ss, buf, len, flags);    ssl_ReleaseXmitBufLock(ss);    ss->writerThread = NULL;done:    if (rv < 0) {        SSL_TRC(2, ("%d: SSL[%d]: SecureSend: returning %d count, error %d",//.........这里部分代码省略.........

intssl3_GatherCompleteHandshake(sslSocket *ss, int flags){    SSL3Ciphertext cText;    int            rv;    PRBool         keepGoing = PR_TRUE;    SSL_TRC(30, ("ssl3_GatherCompleteHandshake"));    PORT_Assert( ss->opt.noLocks || ssl_Have1stHandshakeLock(ss) );    PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) );    do {        PRBool handleRecordNow = PR_FALSE;        ssl_GetSSL3HandshakeLock(ss);        if (ss->ssl3.hs.restartTarget) {            ssl_ReleaseSSL3HandshakeLock(ss);            PORT_SetError(PR_WOULD_BLOCK_ERROR);            return (int) SECFailure;        }        if (ss->ssl3.hs.msgState.buf) {            if (ss->ssl3.hs.msgState.len == 0) {                ss->ssl3.hs.msgState.buf = NULL;            } else {                handleRecordNow = PR_TRUE;            }        }        ssl_ReleaseSSL3HandshakeLock(ss);        if (handleRecordNow) {            rv = ssl3_HandleRecord(ss, NULL, &ss->gs.buf);        } else {            if (!IS_DTLS(ss)) {                rv = ssl3_GatherData(ss, &ss->gs, flags);            } else {                rv = dtls_GatherData(ss, &ss->gs, flags);                if (rv == SECFailure &&                        (PORT_GetError() == PR_WOULD_BLOCK_ERROR)) {                    ssl_GetSSL3HandshakeLock(ss);                    dtls_CheckTimer(ss);                    ssl_ReleaseSSL3HandshakeLock(ss);                    PORT_SetError(PR_WOULD_BLOCK_ERROR);                }            }            if (rv <= 0) {                return rv;            }            cText.type    = (SSL3ContentType)ss->gs.hdr[0];            cText.version = (ss->gs.hdr[1] << 8) | ss->gs.hdr[2];            if (IS_DTLS(ss)) {                int i;                cText.version = dtls_DTLSVersionToTLSVersion(cText.version);                cText.seq_num.high = 0;                cText.seq_num.low = 0;                for (i = 0; i < 4; i++) {                    cText.seq_num.high <<= 8;                    cText.seq_num.low <<= 8;                    cText.seq_num.high |= ss->gs.hdr[3 + i];                    cText.seq_num.low |= ss->gs.hdr[7 + i];                }            }            cText.buf     = &ss->gs.inbuf;            rv = ssl3_HandleRecord(ss, &cText, &ss->gs.buf);            if (rv == (int) SECSuccess && ss->gs.buf.len > 0) {                PORT_Assert(ss->firstHsDone);                PORT_Assert(cText.type == content_application_data);                break;            }        }        if (rv < 0) {            return ss->recvdCloseNotify ? 0 : rv;        }        PORT_Assert(keepGoing);        ssl_GetSSL3HandshakeLock(ss);        if (ss->ssl3.hs.ws == idle_handshake) {            PORT_Assert(ss->firstHsDone);            PORT_Assert(!ss->ssl3.hs.canFalseStart);            keepGoing = PR_FALSE;        } else if (ss->ssl3.hs.canFalseStart) {            PORT_Assert(!ss->firstHsDone);            if (ssl3_WaitingForStartOfServerSecondRound(ss)) {                keepGoing = PR_FALSE;            } else {                ss->ssl3.hs.canFalseStart = PR_FALSE;//.........这里部分代码省略.........

intssl_SecureSend(sslSocket *ss, const unsigned char *buf, int len, int flags){    int rv = 0;    PRBool falseStart = PR_FALSE;    SSL_TRC(2, ("%d: SSL[%d]: SecureSend: sending %d bytes",		SSL_GETPID(), ss->fd, len));    if (ss->shutdownHow & ssl_SHUTDOWN_SEND) {	PORT_SetError(PR_SOCKET_SHUTDOWN_ERROR);    	rv = PR_FAILURE;	goto done;    }    if (flags) {	PORT_SetError(PR_INVALID_ARGUMENT_ERROR);    	rv = PR_FAILURE;	goto done;    }    ssl_GetXmitBufLock(ss);    if (ss->pendingBuf.len != 0) {	PORT_Assert(ss->pendingBuf.len > 0);	rv = ssl_SendSavedWriteData(ss);	if (rv >= 0 && ss->pendingBuf.len != 0) {	    PORT_Assert(ss->pendingBuf.len > 0);	    PORT_SetError(PR_WOULD_BLOCK_ERROR);	    rv = SECFailure;	}    }    ssl_ReleaseXmitBufLock(ss);    if (rv < 0) {	goto done;    }    if (len > 0)     	ss->writerThread = PR_GetCurrentThread();        if (!ss->firstHsDone) {	ssl_Get1stHandshakeLock(ss);	if (ss->opt.enableFalseStart &&	    ss->version >= SSL_LIBRARY_VERSION_3_0) {	    ssl_GetSSL3HandshakeLock(ss);	    falseStart = ss->ssl3.hs.canFalseStart;	    ssl_ReleaseSSL3HandshakeLock(ss);	}	if (!falseStart &&	    (ss->handshake || ss->nextHandshake || ss->securityHandshake)) {	    rv = ssl_Do1stHandshake(ss);	}	ssl_Release1stHandshakeLock(ss);    }    if (rv < 0) {    	ss->writerThread = NULL;	goto done;    }    if (len == 0) {    	rv = 0;	goto done;    }    PORT_Assert(buf != NULL);    if (!buf) {	PORT_SetError(PR_INVALID_ARGUMENT_ERROR);    	rv = PR_FAILURE;	goto done;    }    if (!ss->firstHsDone) {	PORT_Assert(ss->version >= SSL_LIBRARY_VERSION_3_0);#ifdef DEBUG	ssl_GetSSL3HandshakeLock(ss);	PORT_Assert(ss->ssl3.hs.canFalseStart);	ssl_ReleaseSSL3HandshakeLock(ss);#endif	SSL_TRC(3, ("%d: SSL[%d]: SecureSend: sending data due to false start",		    SSL_GETPID(), ss->fd));    }    ssl_GetXmitBufLock(ss);    rv = (*ss->sec.send)(ss, buf, len, flags);    ssl_ReleaseXmitBufLock(ss);    ss->writerThread = NULL;done:    if (rv < 0) {	SSL_TRC(2, ("%d: SSL[%d]: SecureSend: returning %d count, error %d",		    SSL_GETPID(), ss->fd, rv, PORT_GetError()));    } else {	SSL_TRC(2, ("%d: SSL[%d]: SecureSend: returning %d count",		    SSL_GETPID(), ss->fd, rv));    }    return rv;}

SECStatusSSL_ExportKeyingMaterial(PRFileDesc *fd,                         const char *label, unsigned int labelLen,                         PRBool hasContext,                         const unsigned char *context, unsigned int contextLen,                         unsigned char *out, unsigned int outLen){    sslSocket *ss;    unsigned char *val = NULL;    unsigned int valLen, i;    SECStatus rv = SECFailure;    ss = ssl_FindSocket(fd);    if (!ss) {	SSL_DBG(("%d: SSL[%d]: bad socket in ExportKeyingMaterial",		 SSL_GETPID(), fd));	return SECFailure;    }    ssl_GetRecvBufLock(ss);    ssl_GetSSL3HandshakeLock(ss);    if (ss->version < SSL_LIBRARY_VERSION_3_1_TLS) {	PORT_SetError(SSL_ERROR_FEATURE_NOT_SUPPORTED_FOR_VERSION);	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_ReleaseRecvBufLock(ss);	return SECFailure;    }    /* construct PRF arguments */    valLen = SSL3_RANDOM_LENGTH * 2;    if (hasContext) {	valLen += 2 /* PRUint16 length */ + contextLen;    }    val = PORT_Alloc(valLen);    if (!val) {	ssl_ReleaseSSL3HandshakeLock(ss);	ssl_ReleaseRecvBufLock(ss);	return SECFailure;    }    i = 0;    PORT_Memcpy(val + i, &ss->ssl3.hs.client_random.rand, SSL3_RANDOM_LENGTH);    i += SSL3_RANDOM_LENGTH;    PORT_Memcpy(val + i, &ss->ssl3.hs.server_random.rand, SSL3_RANDOM_LENGTH);    i += SSL3_RANDOM_LENGTH;    if (hasContext) {	val[i++] = contextLen >> 8;	val[i++] = contextLen;	PORT_Memcpy(val + i, context, contextLen);	i += contextLen;    }    PORT_Assert(i == valLen);    /* Allow TLS keying material to be exported sooner, when the master     * secret is available and we have sent ChangeCipherSpec.     */    ssl_GetSpecReadLock(ss);    if (!ss->ssl3.cwSpec->master_secret && !ss->ssl3.cwSpec->msItem.len) {	PORT_SetError(SSL_ERROR_HANDSHAKE_NOT_COMPLETED);	rv = SECFailure;    } else {	rv = ssl3_TLSPRFWithMasterSecret(ss->ssl3.cwSpec, label, labelLen, val,					 valLen, out, outLen);    }    ssl_ReleaseSpecReadLock(ss);    ssl_ReleaseSSL3HandshakeLock(ss);    ssl_ReleaseRecvBufLock(ss);    PORT_ZFree(val, valLen);    return rv;}

/* Sends out the initial client Hello message on the connection. * Acquires and releases the socket's xmitBufLock. */SECStatusssl_BeginClientHandshake(sslSocket *ss){    sslSessionID *sid;    SECStatus rv;    PORT_Assert(ss->opt.noLocks || ssl_Have1stHandshakeLock(ss));    ss->sec.isServer = PR_FALSE;    ssl_ChooseSessionIDProcs(&ss->sec);    rv = ssl_CheckConfigSanity(ss);    if (rv != SECSuccess)        goto loser;    /* Get peer name of server */    rv = ssl_GetPeerInfo(ss);    if (rv < 0) {#ifdef HPUX11        /*         * On some HP-UX B.11.00 systems, getpeername() occasionally         * fails with ENOTCONN after a successful completion of         * non-blocking connect.  I found that if we do a write()         * and then retry getpeername(), it will work.         */        if (PR_GetError() == PR_NOT_CONNECTED_ERROR) {            char dummy;            (void)PR_Write(ss->fd->lower, &dummy, 0);            rv = ssl_GetPeerInfo(ss);            if (rv < 0) {                goto loser;            }        }#else        goto loser;#endif    }    SSL_TRC(3, ("%d: SSL[%d]: sending client-hello", SSL_GETPID(), ss->fd));    /* Try to find server in our session-id cache */    if (ss->opt.noCache) {        sid = NULL;    } else {        sid = ssl_LookupSID(&ss->sec.ci.peer, ss->sec.ci.port, ss->peerID,                            ss->url);    }    if (sid) {        if (sid->version >= ss->vrange.min && sid->version <= ss->vrange.max) {            PORT_Assert(!ss->sec.localCert);            ss->sec.localCert = CERT_DupCertificate(sid->localCert);        } else {            ss->sec.uncache(sid);            ssl_FreeSID(sid);            sid = NULL;        }    }    if (!sid) {        sid = PORT_ZNew(sslSessionID);        if (!sid) {            goto loser;        }        sid->references = 1;        sid->cached = never_cached;        sid->addr = ss->sec.ci.peer;        sid->port = ss->sec.ci.port;        if (ss->peerID != NULL) {            sid->peerID = PORT_Strdup(ss->peerID);        }        if (ss->url != NULL) {            sid->urlSvrName = PORT_Strdup(ss->url);        }    }    ss->sec.ci.sid = sid;    PORT_Assert(sid != NULL);    ss->gs.state = GS_INIT;    ss->handshake = ssl_GatherRecord1stHandshake;    /* ssl3_SendClientHello will override this if it succeeds. */    ss->version = SSL_LIBRARY_VERSION_3_0;    ssl_GetSSL3HandshakeLock(ss);    ssl_GetXmitBufLock(ss);    rv = ssl3_SendClientHello(ss, client_hello_initial);    ssl_ReleaseXmitBufLock(ss);    ssl_ReleaseSSL3HandshakeLock(ss);    return rv;loser:    return SECFailure;}

/* Gather in a record and when complete, Handle that record. * Repeat this until the handshake is complete, * or until application data is available. * * Returns  1 when the handshake is completed without error, or *                 application data is available. * Returns  0 if ssl3_GatherData hits EOF. * Returns -1 on read error, or PR_WOULD_BLOCK_ERROR, or handleRecord error. * Returns -2 on SECWouldBlock return from ssl3_HandleRecord. * * Called from ssl_GatherRecord1stHandshake       in sslcon.c, *    and from SSL_ForceHandshake in sslsecur.c *    and from ssl3_GatherAppDataRecord below (<- DoRecv in sslsecur.c). * * Caller must hold the recv buf lock. */intssl3_GatherCompleteHandshake(sslSocket *ss, int flags){    SSL3Ciphertext cText;    int rv;    PRBool keepGoing = PR_TRUE;    SSL_TRC(30, ("ssl3_GatherCompleteHandshake"));    /* ssl3_HandleRecord may end up eventually calling ssl_FinishHandshake,     * which requires the 1stHandshakeLock, which must be acquired before the     * RecvBufLock.     */    PORT_Assert(ss->opt.noLocks || ssl_Have1stHandshakeLock(ss));    PORT_Assert(ss->opt.noLocks || ssl_HaveRecvBufLock(ss));    do {        PRBool handleRecordNow = PR_FALSE;        ssl_GetSSL3HandshakeLock(ss);        /* Without this, we may end up wrongly reporting         * SSL_ERROR_RX_UNEXPECTED_* errors if we receive any records from the         * peer while we are waiting to be restarted.         */        if (ss->ssl3.hs.restartTarget) {            ssl_ReleaseSSL3HandshakeLock(ss);            PORT_SetError(PR_WOULD_BLOCK_ERROR);            return (int)SECFailure;        }        /* Treat an empty msgState like a NULL msgState. (Most of the time         * when ssl3_HandleHandshake returns SECWouldBlock, it leaves         * behind a non-NULL but zero-length msgState).         * Test: async_cert_restart_server_sends_hello_request_first_in_separate_record         */        if (ss->ssl3.hs.msgState.buf) {            if (ss->ssl3.hs.msgState.len == 0) {                ss->ssl3.hs.msgState.buf = NULL;            } else {                handleRecordNow = PR_TRUE;            }        }        ssl_ReleaseSSL3HandshakeLock(ss);        if (handleRecordNow) {            /* ssl3_HandleHandshake previously returned SECWouldBlock and the             * as-yet-unprocessed plaintext of that previous handshake record.             * We need to process it now before we overwrite it with the next             * handshake record.             */            rv = ssl3_HandleRecord(ss, NULL, &ss->gs.buf);        } else {            /* bring in the next sslv3 record. */            if (ss->recvdCloseNotify) {                /* RFC 5246 Section 7.2.1:                 *   Any data received after a closure alert is ignored.                 */                return 0;            }            if (!IS_DTLS(ss)) {                rv = ssl3_GatherData(ss, &ss->gs, flags);            } else {                rv = dtls_GatherData(ss, &ss->gs, flags);                /* If we got a would block error, that means that no data was                 * available, so we check the timer to see if it's time to                 * retransmit */                if (rv == SECFailure &&                    (PORT_GetError() == PR_WOULD_BLOCK_ERROR)) {                    ssl_GetSSL3HandshakeLock(ss);                    dtls_CheckTimer(ss);                    ssl_ReleaseSSL3HandshakeLock(ss);                    /* Restore the error in case something succeeded */                    PORT_SetError(PR_WOULD_BLOCK_ERROR);                }            }            if (rv <= 0) {                return rv;            }            /* decipher it, and handle it if it's a handshake.//.........这里部分代码省略.........

/* Gather in a record and when complete, Handle that record. * Repeat this until the handshake is complete,  * or until application data is available. * * Returns  1 when the handshake is completed without error, or  *                 application data is available. * Returns  0 if ssl3_GatherData hits EOF. * Returns -1 on read error, or PR_WOULD_BLOCK_ERROR, or handleRecord error. * Returns -2 on SECWouldBlock return from ssl3_HandleRecord. * * Called from ssl_GatherRecord1stHandshake       in sslcon.c,  *    and from SSL_ForceHandshake in sslsecur.c *    and from ssl3_GatherAppDataRecord below (<- DoRecv in sslsecur.c). * * Caller must hold the recv buf lock. */intssl3_GatherCompleteHandshake(sslSocket *ss, int flags){    SSL3Ciphertext cText;    int            rv;    PRBool         canFalseStart = PR_FALSE;    PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) );    do {	/* Without this, we may end up wrongly reporting	 * SSL_ERROR_RX_UNEXPECTED_* errors if we receive any records from the	 * peer while we are waiting to be restarted.	 */	ssl_GetSSL3HandshakeLock(ss);	rv = ss->ssl3.hs.restartTarget == NULL ? SECSuccess : SECFailure;	ssl_ReleaseSSL3HandshakeLock(ss);	if (rv != SECSuccess) {	    PORT_SetError(PR_WOULD_BLOCK_ERROR);	    return (int) SECFailure;	}	/* Treat an empty msgState like a NULL msgState. (Most of the time	 * when ssl3_HandleHandshake returns SECWouldBlock, it leaves	 * behind a non-NULL but zero-length msgState).	 * Test: async_cert_restart_server_sends_hello_request_first_in_separate_record	 */	if (ss->ssl3.hs.msgState.buf != NULL) {	    if (ss->ssl3.hs.msgState.len == 0) {		ss->ssl3.hs.msgState.buf = NULL;	    }	}	if (ss->ssl3.hs.msgState.buf != NULL) {	    /* ssl3_HandleHandshake previously returned SECWouldBlock and the	     * as-yet-unprocessed plaintext of that previous handshake record.	     * We need to process it now before we overwrite it with the next	     * handshake record.	     */	    rv = ssl3_HandleRecord(ss, NULL, &ss->gs.buf);	} else {	    /* bring in the next sslv3 record. */	    rv = ssl3_GatherData(ss, &ss->gs, flags);	    if (rv <= 0) {		return rv;	    }	    /* decipher it, and handle it if it's a handshake.	     * If it's application data, ss->gs.buf will not be empty upon return.	     * If it's a change cipher spec, alert, or handshake message,	     * ss->gs.buf.len will be 0 when ssl3_HandleRecord returns SECSuccess.	     */	    cText.type    = (SSL3ContentType)ss->gs.hdr[0];	    cText.version = (ss->gs.hdr[1] << 8) | ss->gs.hdr[2];	    cText.buf     = &ss->gs.inbuf;	    rv = ssl3_HandleRecord(ss, &cText, &ss->gs.buf);	}	if (rv < 0) {	    return ss->recvdCloseNotify ? 0 : rv;	}	/* If we kicked off a false start in ssl3_HandleServerHelloDone, break	 * out of this loop early without finishing the handshake.	 */	if (ss->opt.enableFalseStart) {	    ssl_GetSSL3HandshakeLock(ss);	    canFalseStart = (ss->ssl3.hs.ws == wait_change_cipher ||			     ss->ssl3.hs.ws == wait_new_session_ticket) &&		            ssl3_CanFalseStart(ss);	    ssl_ReleaseSSL3HandshakeLock(ss);	}    } while (ss->ssl3.hs.ws != idle_handshake &&             !canFalseStart &&             ss->gs.buf.len == 0);    ss->gs.readOffset = 0;    ss->gs.writeOffset = ss->gs.buf.len;    return 1;}