feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

Refactor WOLF_SSL_ to WOLFSSL_ (much better).

Browse Source
This commit is contained in:
David Garske
2017-10-11 09:09:52 -07:00
parent 6707be2b0e
commit 6021c37ec7
19 changed files with 1985 additions and 1985 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
examples/client/client.c
View File

@@ -106,14 +106,14 @@ static int NonBlockingSSL_Connect(WOLFSSL* ssl)
error = wolfSSL_get_error(ssl, 0);
sockfd = (SOCKET_T)wolfSSL_get_fd(ssl);
while (ret != WOLF_SSL_SUCCESS && (error == WOLF_SSL_ERROR_WANT_READ ||
error == WOLF_SSL_ERROR_WANT_WRITE ||
while (ret != WOLFSSL_SUCCESS && (error == WOLFSSL_ERROR_WANT_READ ||
error == WOLFSSL_ERROR_WANT_WRITE ||
error == WC_PENDING_E)) {
int currTimeout = 1;
if (error == WOLF_SSL_ERROR_WANT_READ)
if (error == WOLFSSL_ERROR_WANT_READ)
printf("... client would read block\n");
else if (error == WOLF_SSL_ERROR_WANT_WRITE)
else if (error == WOLFSSL_ERROR_WANT_WRITE)
printf("... client would write block\n");
#ifdef WOLFSSL_ASYNC_CRYPT
else if (error == WC_PENDING_E) {
@@ -139,16 +139,16 @@ static int NonBlockingSSL_Connect(WOLFSSL* ssl)
error = wolfSSL_get_error(ssl, 0);
}
else if (select_ret == TEST_TIMEOUT && !wolfSSL_dtls(ssl)) {
error = WOLF_SSL_ERROR_WANT_READ;
error = WOLFSSL_ERROR_WANT_READ;
}
#ifdef WOLFSSL_DTLS
else if (select_ret == TEST_TIMEOUT && wolfSSL_dtls(ssl) &&
wolfSSL_dtls_got_timeout(ssl) >= 0) {
error = WOLF_SSL_ERROR_WANT_READ;
error = WOLFSSL_ERROR_WANT_READ;
}
#endif
else {
error = WOLF_SSL_FATAL_ERROR;
error = WOLFSSL_FATAL_ERROR;
}
}
@@ -162,7 +162,7 @@ static void ShowCiphers(void)
int ret = wolfSSL_get_ciphers(ciphers, (int)sizeof(ciphers));
if (ret == WOLF_SSL_SUCCESS)
if (ret == WOLFSSL_SUCCESS)
printf("%s\n", ciphers);
}
@@ -232,20 +232,20 @@ static int ClientBenchmarkConnections(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
#endif
#endif
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLFSSL_SUCCESS) {
err_sys("error in setting fd");
}
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -255,7 +255,7 @@ static int ClientBenchmarkConnections(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
}
} while (err == WC_PENDING_E);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err_sys("SSL_connect failed");
}
@@ -307,7 +307,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
err_sys("unable to get SSL object");
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, ssl);
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLFSSL_SUCCESS) {
err_sys("error in setting fd");
}
@@ -316,7 +316,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
@@ -326,7 +326,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -336,7 +336,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
}
} while (err == WC_PENDING_E);
if (ret == WOLF_SSL_SUCCESS) {
if (ret == WOLFSSL_SUCCESS) {
/* Perform throughput test */
char *tx_buffer, *rx_buffer;
@@ -411,7 +411,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
}
else
#endif
if (err != WOLF_SSL_ERROR_WANT_READ) {
if (err != WOLFSSL_ERROR_WANT_READ) {
printf("SSL_read bench error %d\n", err);
err_sys("SSL_read failed");
}
@@ -528,7 +528,7 @@ static int StartTLS_Init(SOCKET_T* sockfd)
err_sys("incorrect STARTTLS command received, expected 220");
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/* Closes down the SMTP connection */
@@ -581,10 +581,10 @@ static int SMTP_Shutdown(WOLFSSL* ssl, int wc_shutdown)
printf("%s\n", tmpBuf);
ret = wolfSSL_shutdown(ssl);
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(ssl); /* bidirectional shutdown */
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
static void ClientWrite(WOLFSSL* ssl, char* msg, int msgSz)
@@ -629,13 +629,13 @@ static void ClientRead(WOLFSSL* ssl, char* reply, int replyLen, int mustRead)
}
else
#endif
if (err != WOLF_SSL_ERROR_WANT_READ) {
if (err != WOLFSSL_ERROR_WANT_READ) {
printf("SSL_read reply error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
err_sys("SSL_read failed");
}
}
} while (err == WC_PENDING_E || (mustRead && err == WOLF_SSL_ERROR_WANT_READ));
} while (err == WC_PENDING_E || (mustRead && err == WOLFSSL_ERROR_WANT_READ));
if (ret > 0) {
reply[ret] = 0;
printf("%s\n", reply);
@@ -1411,14 +1411,14 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
err_sys("unable to get ctx");
#ifdef SINGLE_THREADED
if (wolfSSL_CTX_new_rng(ctx) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_new_rng(ctx) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("Single Threaded new rng at CTX failed");
}
#endif
if (cipherList && !useDefCipherList) {
if (wolfSSL_CTX_set_cipher_list(ctx, cipherList) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, cipherList) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 1");
}
@@ -1461,7 +1461,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (wolfSSL_CTX_set_cipher_list(ctx,defaultCipherList)
!=WOLF_SSL_SUCCESS) {
!=WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 2");
}
@@ -1477,7 +1477,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (cipherList == NULL || (cipherList && useDefCipherList)) {
wolfSSL_CTX_allow_anon_cipher(ctx);
if (wolfSSL_CTX_set_cipher_list(ctx,"ADH-AES128-SHA")
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 4");
}
@@ -1500,7 +1500,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(WOLFSSL_SNIFFER)
if (cipherList == NULL) {
/* don't use EDH, can't sniff tmp keys */
if (wolfSSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 3");
}
@@ -1531,14 +1531,14 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (useClientCert){
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_use_certificate_chain_file(ctx, ourCert)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load client cert file, check file and run from"
" wolfSSL home dir");
}
if (wolfSSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load client private key file, check file and run "
"from wolfSSL home dir");
@@ -1552,7 +1552,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (!usePsk && !useAnon && !useVerifyCb) {
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(ctx, verifyCert,0)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load ca file, Please run from wolfSSL home dir");
}
@@ -1562,7 +1562,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_ECC
/* load ecc verify too, echoserver uses it by default w/ ecc */
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load ecc ca file, Please run from wolfSSL home dir");
}
@@ -1573,7 +1573,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(WOLFSSL_TRUST_PEER_CERT) && !defined(NO_FILESYSTEM)
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
WOLFSSL_FILETYPE_PEM)) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load trusted peer cert file");
}
@@ -1581,11 +1581,11 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif /* WOLFSSL_TRUST_PEER_CERT && !NO_FILESYSTEM */
}
if (useVerifyCb)
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER, myVerify);
wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER, myVerify);
else if (!usePsk && !useAnon && doPeerCheck == 0)
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_NONE, 0);
else if (!usePsk && !useAnon && overrideDateErrors == 1)
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER, myDateCb);
wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER, myDateCb);
#endif /* !defined(NO_CERTS) */
#ifdef WOLFSSL_ASYNC_CRYPT
@@ -1599,34 +1599,34 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_SNI
if (sniHostName)
if (wolfSSL_CTX_UseSNI(ctx, 0, sniHostName, XSTRLEN(sniHostName))
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseSNI failed");
}
#endif
#ifdef HAVE_MAX_FRAGMENT
if (maxFragment)
if (wolfSSL_CTX_UseMaxFragment(ctx, maxFragment) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_UseMaxFragment(ctx, maxFragment) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseMaxFragment failed");
}
#endif
#ifdef HAVE_TRUNCATED_HMAC
if (truncatedHMAC)
if (wolfSSL_CTX_UseTruncatedHMAC(ctx) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_UseTruncatedHMAC(ctx) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseTruncatedHMAC failed");
}
#endif
#ifdef HAVE_SESSION_TICKET
if (wolfSSL_CTX_UseSessionTicket(ctx) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_UseSessionTicket(ctx) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseSessionTicket failed");
}
#endif
#ifdef HAVE_EXTENDED_MASTER
if (disableExtMasterSecret)
if (wolfSSL_CTX_DisableExtendedMasterSecret(ctx) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_DisableExtendedMasterSecret(ctx) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("DisableExtendedMasterSecret failed");
}
@@ -1634,11 +1634,11 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(HAVE_CURVE25519) && defined(HAVE_SUPPORTED_CURVES)
if (useX25519) {
if (wolfSSL_CTX_UseSupportedCurve(ctx, WOLFSSL_ECC_X25519)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to support X25519");
}
if (wolfSSL_CTX_UseSupportedCurve(ctx, WOLFSSL_ECC_SECP256R1)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to support secp256r1");
}
}
@@ -1662,7 +1662,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
#if defined(WOLFSSL_MDK_ARM)
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_NONE, 0);
#endif
#if defined(OPENSSL_EXTRA)
@@ -1670,7 +1670,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
wolfSSL_CTX_free(ctx);
err_sys("bad read ahead default value");
}
if (wolfSSL_CTX_set_read_ahead(ctx, 1) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_set_read_ahead(ctx, 1) != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("error setting read ahead value");
}
@@ -1688,7 +1688,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (doMcast) {
#ifdef WOLFSSL_MULTICAST
wolfSSL_CTX_mcast_set_member_id(ctx, mcastID);
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("Couldn't set multicast cipher list.");
}
@@ -1711,7 +1711,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
@@ -1719,13 +1719,13 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_ECC
#if defined(HAVE_ECC256) || defined(HAVE_ALL_CURVES)
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_SECP256R1)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to use curve secp256r1");
}
#endif
#if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_SECP384R1)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys("unable to use curve secp384r1");
}
#endif
@@ -1733,7 +1733,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
if (onlyKeyShare == 0 || onlyKeyShare == 1) {
#ifdef HAVE_FFDHE_2048
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_FFDHE_2048) != WOLF_SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_FFDHE_2048) != WOLFSSL_SUCCESS) {
err_sys("unable to use DH 2048-bit parameters");
}
#endif
@@ -1756,7 +1756,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
XMEMSET(sr, 0x5A, sizeof(sr));
if (wolfSSL_set_secret(ssl, 1, pms, sizeof(pms), cr, sr, suite)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("unable to set mcast secret");
}
@@ -1778,7 +1778,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
switch (statusRequest) {
case WOLFSSL_CSR_OCSP:
if (wolfSSL_UseOCSPStapling(ssl, WOLFSSL_CSR_OCSP,
WOLFSSL_CSR_OCSP_USE_NONCE) != WOLF_SSL_SUCCESS) {
WOLFSSL_CSR_OCSP_USE_NONCE) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@@ -1796,7 +1796,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
case WOLFSSL_CSR2_OCSP:
if (wolfSSL_UseOCSPStaplingV2(ssl,
WOLFSSL_CSR2_OCSP, WOLFSSL_CSR2_OCSP_USE_NONCE)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@@ -1805,7 +1805,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
case WOLFSSL_CSR2_OCSP_MULTI:
if (wolfSSL_UseOCSPStaplingV2(ssl,
WOLFSSL_CSR2_OCSP_MULTI, 0)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@@ -1819,7 +1819,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, ssl);
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error in setting fd");
@@ -1827,7 +1827,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
/* STARTTLS */
if (doSTARTTLS) {
if (StartTLS_Init(&sockfd) != WOLF_SSL_SUCCESS) {
if (StartTLS_Init(&sockfd) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error during STARTTLS protocol");
@@ -1840,18 +1840,18 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
wolfIO_SetTimeout(DEFAULT_TIMEOUT_SEC);
#endif
if (wolfSSL_EnableCRL(ssl, WOLFSSL_CRL_CHECKALL) != WOLF_SSL_SUCCESS) {
if (wolfSSL_EnableCRL(ssl, WOLFSSL_CRL_CHECKALL) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't enable crl check");
}
if (wolfSSL_LoadCRL(ssl, crlPemDir, WOLF_SSL_FILETYPE_PEM, 0)
!= WOLF_SSL_SUCCESS) {
if (wolfSSL_LoadCRL(ssl, crlPemDir, WOLFSSL_FILETYPE_PEM, 0)
!= WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't load crl, check crlfile and date validity");
}
if (wolfSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLF_SSL_SUCCESS) {
if (wolfSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't set crl callback");
@@ -1860,7 +1860,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
#ifdef HAVE_SECURE_RENEGOTIATION
if (scr) {
if (wolfSSL_UseSecureRenegotiation(ssl) != WOLF_SSL_SUCCESS) {
if (wolfSSL_UseSecureRenegotiation(ssl) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't enable secure renegotiation");
@@ -1887,7 +1887,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -1903,7 +1903,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
timeout.tv_usec = 0;
ret = NonBlockingSSL_Connect(ssl); /* will keep retrying on timeout */
#endif
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
printf("wolfSSL_connect error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(ssl);
@@ -1953,7 +1953,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (doSTARTTLS) {
if (XSTRNCMP(starttlsProt, "smtp", 4) == 0) {
if (SMTP_Shutdown(ssl, wc_shutdown) != WOLF_SSL_SUCCESS) {
if (SMTP_Shutdown(ssl, wc_shutdown) != WOLFSSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error closing STARTTLS connection");
@@ -1975,7 +1975,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
word16 protocol_nameSz = 0;
err = wolfSSL_ALPN_GetProtocol(ssl, &protocol_name, &protocol_nameSz);
if (err == WOLF_SSL_SUCCESS)
if (err == WOLFSSL_SUCCESS)
printf("Received ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@@ -1991,7 +1991,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
printf("not doing secure renegotiation on example with"
" nonblocking yet");
} else {
if (wolfSSL_Rehandshake(ssl) != WOLF_SSL_SUCCESS) {
if (wolfSSL_Rehandshake(ssl) != WOLFSSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
printf("err = %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
@@ -2056,7 +2056,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (dtlsUDP == 0) { /* don't send alert after "break" command */
ret = wolfSSL_shutdown(ssl);
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(ssl); /* bidirectional shutdown */
}
#ifdef ATOMIC_USER
@@ -2078,7 +2078,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
}
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, sslResume);
if (wolfSSL_set_fd(sslResume, sockfd) != WOLF_SSL_SUCCESS) {
if (wolfSSL_set_fd(sslResume, sockfd) != WOLFSSL_SUCCESS) {
wolfSSL_free(sslResume);
wolfSSL_CTX_free(ctx);
err_sys("error in setting fd");
@@ -2092,7 +2092,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
#ifdef HAVE_SECURE_RENEGOTIATION
if (scr) {
if (wolfSSL_UseSecureRenegotiation(sslResume) != WOLF_SSL_SUCCESS) {
if (wolfSSL_UseSecureRenegotiation(sslResume) != WOLFSSL_SUCCESS) {
wolfSSL_free(sslResume);
wolfSSL_CTX_free(ctx);
err_sys("can't enable secure renegotiation");
@@ -2108,23 +2108,23 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef WOLFSSL_TLS13
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519) != WOLF_SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519) != WOLFSSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
#endif
#ifdef HAVE_ECC
if (wolfSSL_UseKeyShare(sslResume,
WOLFSSL_ECC_SECP256R1) != WOLF_SSL_SUCCESS) {
WOLFSSL_ECC_SECP256R1) != WOLFSSL_SUCCESS) {
err_sys("unable to use curve secp256r1");
}
if (wolfSSL_UseKeyShare(sslResume,
WOLFSSL_ECC_SECP384R1) != WOLF_SSL_SUCCESS) {
WOLFSSL_ECC_SECP384R1) != WOLFSSL_SUCCESS) {
err_sys("unable to use curve secp384r1");
}
#endif
#ifdef HAVE_FFDHE_2048
if (wolfSSL_UseKeyShare(sslResume, WOLFSSL_FFDHE_2048) != WOLF_SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(sslResume, WOLFSSL_FFDHE_2048) != WOLFSSL_SUCCESS) {
err_sys("unable to use DH 2048-bit parameters");
}
#endif
@@ -2193,7 +2193,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
do {
err = 0; /* reset error */
ret = wolfSSL_connect(sslResume);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = wolfSSL_get_error(sslResume, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -2210,7 +2210,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
timeout.tv_usec = 0;
ret = NonBlockingSSL_Connect(ssl); /* will keep retrying on timeout */
#endif
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
printf("wolfSSL_connect resume error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(sslResume);
@@ -2233,7 +2233,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
printf("Sending ALPN accepted list : %s\n", alpnList);
err = wolfSSL_ALPN_GetProtocol(sslResume, &protocol_name,
&protocol_nameSz);
if (err == WOLF_SSL_SUCCESS)
if (err == WOLFSSL_SUCCESS)
printf("Received ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@@ -2329,7 +2329,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
}
if (ret < 0) {
if (err != WOLF_SSL_ERROR_WANT_READ) {
if (err != WOLFSSL_ERROR_WANT_READ) {
printf("SSL_read resume error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(sslResume);
@@ -2354,7 +2354,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
} while (err == WC_PENDING_E);
ret = wolfSSL_shutdown(sslResume);
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(sslResume); /* bidirectional shutdown */
wolfSSL_free(sslResume);

12
examples/echoclient/echoclient.c
View File

@@ -135,11 +135,11 @@ void echoclient_test(void* args)
#ifndef NO_FILESYSTEM
#ifndef NO_RSA
if (SSL_CTX_load_verify_locations(ctx, caCertFile, 0) != WOLF_SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, caCertFile, 0) != WOLFSSL_SUCCESS)
err_sys("can't load ca file, Please run from wolfSSL home dir");
#endif
#ifdef HAVE_ECC
if (SSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLF_SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLFSSL_SUCCESS)
err_sys("can't load ca file, Please run from wolfSSL home dir");
#endif
#elif !defined(NO_CERTS)
@@ -163,7 +163,7 @@ void echoclient_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (CyaSSL_CTX_set_cipher_list(ctx,defaultCipherList) !=WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_set_cipher_list(ctx,defaultCipherList) !=WOLFSSL_SUCCESS)
err_sys("client can't set cipher list 2");
#endif
}
@@ -173,7 +173,7 @@ void echoclient_test(void* args)
#endif
#if defined(WOLFSSL_MDK_ARM)
CyaSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
CyaSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_NONE, 0);
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
@@ -196,7 +196,7 @@ void echoclient_test(void* args)
do {
err = 0; /* Reset error */
ret = SSL_connect(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -206,7 +206,7 @@ void echoclient_test(void* args)
#endif
}
} while (err == WC_PENDING_E);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
printf("SSL_connect error %d, %s\n", err,
ERR_error_string(err, buffer));
err_sys("SSL_connect failed");

34
examples/echoserver/echoserver.c
View File

@@ -151,7 +151,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#error "no valid server method built in"
#endif
ctx = CyaSSL_CTX_new(method);
/* CyaSSL_CTX_set_session_cache_mode(ctx, WOLF_SSL_SESS_CACHE_OFF); */
/* CyaSSL_CTX_set_session_cache_mode(ctx, WOLFSSL_SESS_CACHE_OFF); */
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
CyaSSL_CTX_set_default_passwd_cb(ctx, PasswordCallBack);
@@ -168,37 +168,37 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
if (doPSK == 0) {
#if defined(HAVE_NTRU) && defined(WOLFSSL_STATIC_RSA)
/* ntru */
if (CyaSSL_CTX_use_certificate_file(ctx, ntruCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, ntruCertFile, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys("can't load ntru cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_NTRUPrivateKey_file(ctx, ntruKeyFile)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys("can't load ntru key file, "
"Please run from wolfSSL home dir");
#elif defined(HAVE_ECC) && !defined(CYASSL_SNIFFER)
/* ecc */
if (CyaSSL_CTX_use_certificate_file(ctx, eccCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, eccCertFile, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, eccKeyFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_use_PrivateKey_file(ctx, eccKeyFile, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from wolfSSL home dir");
#elif defined(NO_CERTS)
/* do nothing, just don't load cert files */
#else
/* normal */
if (CyaSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from wolfSSL home dir");
#endif
@@ -228,7 +228,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (CyaSSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLF_SSL_SUCCESS)
if (CyaSSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLFSSL_SUCCESS)
err_sys("server can't set cipher list 2");
#endif
}
@@ -280,7 +280,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
wolfSSL_dtls_set_peer(ssl, &client, client_len);
#endif
#if !defined(NO_FILESYSTEM) && !defined(NO_DH) && !defined(NO_ASN)
CyaSSL_SetTmpDH_file(ssl, dhParamFile, WOLF_SSL_FILETYPE_PEM);
CyaSSL_SetTmpDH_file(ssl, dhParamFile, WOLFSSL_FILETYPE_PEM);
#elif !defined(NO_DH)
SetDH(ssl); /* will repick suites with DHE, higher than PSK */
#endif
@@ -288,7 +288,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
do {
err = 0; /* Reset error */
ret = CyaSSL_accept(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = CyaSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -298,7 +298,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#endif
}
} while (err == WC_PENDING_E);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
printf("SSL_accept error = %d, %s\n", err,
CyaSSL_ERR_error_string(err, buffer));
printf("SSL_accept failed\n");
@@ -337,7 +337,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
}
} while (err == WC_PENDING_E);
if (ret <= 0) {
if (err != WOLF_SSL_ERROR_WANT_READ && err != WOLF_SSL_ERROR_ZERO_RETURN){
if (err != WOLFSSL_ERROR_WANT_READ && err != WOLFSSL_ERROR_ZERO_RETURN){
printf("SSL_read echo error %d, %s!\n", err,
CyaSSL_ERR_error_string(err, buffer));
}

6
examples/sctp/sctp-client-dtls.c
View File

@@ -71,11 +71,11 @@ int main()
err_sys("ctx new dtls client failed");
ret = wolfSSL_CTX_dtls_set_sctp(ctx);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
err_sys("set sctp mode failed");
ret = wolfSSL_CTX_load_verify_locations(ctx, cacert, NULL);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
err_sys("ca cert error");
WOLFSSL* ssl = wolfSSL_new(ctx);
@@ -85,7 +85,7 @@ int main()
wolfSSL_set_fd(ssl, sd);
ret = wolfSSL_connect(ssl);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
err_sys("ssl connect failed");
printf("TLS version is %s\n", wolfSSL_get_version(ssl));

12
examples/sctp/sctp-server-dtls.c
View File

@@ -77,15 +77,15 @@ int main()
err_sys("ctx new dtls server failed");
ret = wolfSSL_CTX_dtls_set_sctp(ctx);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
err_sys("set sctp mode failed");
ret = wolfSSL_CTX_use_PrivateKey_file(ctx, key, WOLF_SSL_FILETYPE_PEM);
if (ret != WOLF_SSL_SUCCESS)
ret = wolfSSL_CTX_use_PrivateKey_file(ctx, key, WOLFSSL_FILETYPE_PEM);
if (ret != WOLFSSL_SUCCESS)
err_sys("use private key error");
ret = wolfSSL_CTX_use_certificate_file(ctx, cert, WOLF_SSL_FILETYPE_PEM);
if (ret != WOLF_SSL_SUCCESS)
ret = wolfSSL_CTX_use_certificate_file(ctx, cert, WOLFSSL_FILETYPE_PEM);
if (ret != WOLFSSL_SUCCESS)
err_sys("use cert error");
WOLFSSL* ssl = wolfSSL_new(ctx);
@@ -95,7 +95,7 @@ int main()
wolfSSL_set_fd(ssl, client_sd);
ret = wolfSSL_accept(ssl);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
err_sys("ssl accept failed");
printf("TLS version is %s\n", wolfSSL_get_version(ssl));

108
examples/server/server.c
View File

@@ -132,15 +132,15 @@ static int NonBlockingSSL_Accept(SSL* ssl)
SOCKET_T sockfd = (SOCKET_T)CyaSSL_get_fd(ssl);
int select_ret = 0;
while (ret != WOLF_SSL_SUCCESS && (error == WOLF_SSL_ERROR_WANT_READ ||
error == WOLF_SSL_ERROR_WANT_WRITE ||
while (ret != WOLFSSL_SUCCESS && (error == WOLFSSL_ERROR_WANT_READ ||
error == WOLFSSL_ERROR_WANT_WRITE ||
error == WC_PENDING_E)) {
int currTimeout = 1;
if (error == WOLF_SSL_ERROR_WANT_READ) {
if (error == WOLFSSL_ERROR_WANT_READ) {
/* printf("... server would read block\n"); */
}
else if (error == WOLF_SSL_ERROR_WANT_WRITE) {
else if (error == WOLFSSL_ERROR_WANT_WRITE) {
/* printf("... server would write block\n"); */
}
#ifdef WOLFSSL_ASYNC_CRYPT
@@ -168,16 +168,16 @@ static int NonBlockingSSL_Accept(SSL* ssl)
error = SSL_get_error(ssl, 0);
}
else if (select_ret == TEST_TIMEOUT && !CyaSSL_dtls(ssl)) {
error = WOLF_SSL_ERROR_WANT_READ;
error = WOLFSSL_ERROR_WANT_READ;
}
#ifdef CYASSL_DTLS
else if (select_ret == TEST_TIMEOUT && CyaSSL_dtls(ssl) &&
CyaSSL_dtls_got_timeout(ssl) >= 0) {
error = WOLF_SSL_ERROR_WANT_READ;
error = WOLFSSL_ERROR_WANT_READ;
}
#endif
else {
error = WOLF_SSL_FATAL_ERROR;
error = WOLFSSL_FATAL_ERROR;
}
}
@@ -222,8 +222,8 @@ int ServerEchoData(SSL* ssl, int clientfd, int echoData, int throughput)
}
else
#endif
if (err != WOLF_SSL_ERROR_WANT_READ &&
err != WOLF_SSL_ERROR_ZERO_RETURN) {
if (err != WOLFSSL_ERROR_WANT_READ &&
err != WOLFSSL_ERROR_ZERO_RETURN) {
printf("SSL_read echo error %d\n", err);
err_sys_ex(runWithErrors, "SSL_read failed");
}
@@ -304,7 +304,7 @@ static void ServerRead(WOLFSSL* ssl, char* input, int inputLen)
}
else
#endif
if (err != WOLF_SSL_ERROR_WANT_READ) {
if (err != WOLFSSL_ERROR_WANT_READ) {
printf("SSL_read input error %d, %s\n", err,
ERR_error_string(err, buffer));
err_sys_ex(runWithErrors, "SSL_read failed");
@@ -335,7 +335,7 @@ static void ServerWrite(WOLFSSL* ssl, const char* output, int outputLen)
}
#endif
}
} while (err == WC_PENDING_E || err == WOLF_SSL_ERROR_WANT_WRITE);
} while (err == WC_PENDING_E || err == WOLFSSL_ERROR_WANT_WRITE);
if (ret != outputLen) {
printf("SSL_write msg error %d, %s\n", err,
ERR_error_string(err, buffer));
@@ -918,13 +918,13 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif /* DEBUG_WOLFSSL */
if (wolfSSL_CTX_load_static_memory(&ctx, method, memory, sizeof(memory),0,1)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load static memory and create ctx");
/* load in a buffer for IO */
if (wolfSSL_CTX_load_static_memory(&ctx, NULL, memoryIO, sizeof(memoryIO),
WOLFMEM_IO_POOL_FIXED | WOLFMEM_TRACK_STATS, 1)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load static memory and create ctx");
#else
ctx = SSL_CTX_new(method(NULL));
@@ -940,7 +940,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
if (cipherList && !useDefCipherList) {
if (SSL_CTX_set_cipher_list(ctx, cipherList) != WOLF_SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, cipherList) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 1");
}
@@ -972,7 +972,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if ((!usePsk || usePskPlus) && !useAnon) {
#if !defined(NO_FILESYSTEM)
if (SSL_CTX_use_certificate_chain_file(ctx, ourCert)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load server cert file, check file and run from"
" wolfSSL home dir");
#else
@@ -983,17 +983,17 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#ifndef NO_DH
if (wolfSSL_CTX_SetMinDhKey_Sz(ctx, (word16)minDhKeyBits) != WOLF_SSL_SUCCESS) {
if (wolfSSL_CTX_SetMinDhKey_Sz(ctx, (word16)minDhKeyBits) != WOLFSSL_SUCCESS) {
err_sys_ex(runWithErrors, "Error setting minimum DH key size");
}
#endif
#ifndef NO_RSA
if (wolfSSL_CTX_SetMinRsaKey_Sz(ctx, minRsaKeyBits) != WOLF_SSL_SUCCESS){
if (wolfSSL_CTX_SetMinRsaKey_Sz(ctx, minRsaKeyBits) != WOLFSSL_SUCCESS){
err_sys_ex(runWithErrors, "Error setting minimum RSA key size");
}
#endif
#ifdef HAVE_ECC
if (wolfSSL_CTX_SetMinEccKey_Sz(ctx, minEccKeyBits) != WOLF_SSL_SUCCESS){
if (wolfSSL_CTX_SetMinEccKey_Sz(ctx, minEccKeyBits) != WOLFSSL_SUCCESS){
err_sys_ex(runWithErrors, "Error setting minimum ECC key size");
}
#endif
@@ -1001,7 +1001,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_NTRU
if (useNtruKey) {
if (CyaSSL_CTX_use_NTRUPrivateKey_file(ctx, ourKey)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ntru key file, "
"Please run from wolfSSL home dir");
}
@@ -1009,8 +1009,8 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if !defined(NO_CERTS)
if (!useNtruKey && (!usePsk || usePskPlus) && !useAnon) {
#if !defined(NO_FILESYSTEM)
if (SSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
if (SSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLFSSL_FILETYPE_PEM)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load server private key file, check file and run "
"from wolfSSL home dir");
#else
@@ -1042,7 +1042,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (SSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLF_SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 2");
}
#endif
@@ -1052,7 +1052,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_ANON
CyaSSL_CTX_allow_anon_cipher(ctx);
if (cipherList == NULL || (cipherList && useDefCipherList)) {
if (SSL_CTX_set_cipher_list(ctx, "ADH-AES128-SHA") != WOLF_SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, "ADH-AES128-SHA") != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 4");
}
#endif
@@ -1062,15 +1062,15 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
/* if not using PSK, verify peer with certs
if using PSK Plus then verify peer certs except PSK suites */
if (doCliCertCheck && (usePsk == 0 || usePskPlus) && useAnon == 0) {
SSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER |
((usePskPlus)? WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK :
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0) != WOLF_SSL_SUCCESS)
SSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER |
((usePskPlus)? WOLFSSL_VERIFY_FAIL_EXCEPT_PSK :
WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
#ifdef WOLFSSL_TRUST_PEER_CERT
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
WOLFSSL_FILETYPE_PEM)) != WOLFSSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load trusted peer cert file");
}
}
@@ -1081,7 +1081,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if defined(CYASSL_SNIFFER)
/* don't use EDH, can't sniff tmp keys */
if (cipherList == NULL) {
if (SSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLF_SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 3");
}
#endif
@@ -1089,7 +1089,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_SNI
if (sniHostName)
if (CyaSSL_CTX_UseSNI(ctx, CYASSL_SNI_HOST_NAME, sniHostName,
XSTRLEN(sniHostName)) != WOLF_SSL_SUCCESS)
XSTRLEN(sniHostName)) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "UseSNI failed");
#endif
@@ -1144,7 +1144,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if (doMcast) {
#ifdef WOLFSSL_MULTICAST
wolfSSL_CTX_mcast_set_member_id(ctx, mcastID);
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLF_SSL_SUCCESS)
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLFSSL_SUCCESS)
err_sys("Couldn't set multicast cipher list.");
#endif
}
@@ -1157,7 +1157,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#ifdef WOLFSSL_SEND_HRR_COOKIE
if (hrrCookie && wolfSSL_send_hrr_cookie(ssl, NULL, 0) != WOLF_SSL_SUCCESS) {
if (hrrCookie && wolfSSL_send_hrr_cookie(ssl, NULL, 0) != WOLFSSL_SUCCESS) {
err_sys("unable to set use of cookie with HRR msg");
}
#endif
@@ -1185,7 +1185,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
XMEMSET(sr, 0x5A, sizeof(sr));
if (wolfSSL_set_secret(ssl, 1, pms, sizeof(pms), cr, sr, suite)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys("unable to set mcast secret");
#endif
}
@@ -1197,12 +1197,12 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_CRL_MONITOR
crlFlags = CYASSL_CRL_MONITOR | CYASSL_CRL_START_MON;
#endif
if (CyaSSL_EnableCRL(ssl, 0) != WOLF_SSL_SUCCESS)
if (CyaSSL_EnableCRL(ssl, 0) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to enable CRL");
if (CyaSSL_LoadCRL(ssl, crlPemDir, WOLF_SSL_FILETYPE_PEM, crlFlags)
!= WOLF_SSL_SUCCESS)
if (CyaSSL_LoadCRL(ssl, crlPemDir, WOLFSSL_FILETYPE_PEM, crlFlags)
!= WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load CRL");
if (CyaSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLF_SSL_SUCCESS)
if (CyaSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to set CRL callback url");
#endif
#ifdef HAVE_OCSP
@@ -1218,13 +1218,13 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
|| defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
if (wolfSSL_CTX_EnableOCSPStapling(ctx) != WOLF_SSL_SUCCESS)
if (wolfSSL_CTX_EnableOCSPStapling(ctx) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't enable OCSP Stapling Certificate Manager");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate1-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate1-ca-cert.pem", 0) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate2-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate2-ca-cert.pem", 0) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate3-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate3-ca-cert.pem", 0) != WOLFSSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
#endif
#ifdef HAVE_PK_CALLBACKS
@@ -1241,7 +1241,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
dtlsUDP, dtlsSCTP, serverReadyFile ? 1 : 0, doListen);
doListen = 0; /* Don't listen next time */
if (SSL_set_fd(ssl, clientfd) != WOLF_SSL_SUCCESS) {
if (SSL_set_fd(ssl, clientfd) != WOLFSSL_SUCCESS) {
err_sys_ex(runWithErrors, "error in setting fd");
}
@@ -1273,7 +1273,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if ((usePsk == 0 || usePskPlus) || useAnon == 1 || cipherList != NULL
|| needDH == 1) {
#if !defined(NO_FILESYSTEM) && !defined(NO_DH) && !defined(NO_ASN)
CyaSSL_SetTmpDH_file(ssl, ourDhParam, WOLF_SSL_FILETYPE_PEM);
CyaSSL_SetTmpDH_file(ssl, ourDhParam, WOLFSSL_FILETYPE_PEM);
#elif !defined(NO_DH)
SetDH(ssl); /* repick suites with DHE, higher priority than PSK */
#endif
@@ -1298,7 +1298,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
err = 0; /* reset error */
ret = wolfSSL_read_early_data(ssl, input, sizeof(input)-1,
&len);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -1317,7 +1317,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
do {
err = 0; /* reset error */
ret = SSL_accept(ssl);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@@ -1331,7 +1331,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#else
ret = NonBlockingSSL_Accept(ssl);
#endif
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
printf("SSL_accept error %d, %s\n", err,
ERR_error_string(err, buffer));
@@ -1385,7 +1385,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
word16 protocol_nameSz = 0, listSz = 0;
err = wolfSSL_ALPN_GetProtocol(ssl, &protocol_name, &protocol_nameSz);
if (err == WOLF_SSL_SUCCESS)
if (err == WOLFSSL_SUCCESS)
printf("Sent ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@@ -1394,7 +1394,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
printf("Getting ALPN protocol name failed\n");
err = wolfSSL_ALPN_GetPeerProtocol(ssl, &list, &listSz);
if (err == WOLF_SSL_SUCCESS)
if (err == WOLFSSL_SUCCESS)
printf("List of protocol names sent by Client: %s (%d)\n",
list, listSz);
else
@@ -1407,17 +1407,17 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if !defined(NO_FILESYSTEM) && !defined(NO_CERTS)
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
if (postHandAuth) {
SSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER |
((usePskPlus)? WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK :
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
SSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER |
((usePskPlus)? WOLFSSL_VERIFY_FAIL_EXCEPT_PSK :
WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
}
#ifdef WOLFSSL_TRUST_PEER_CERT
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
WOLFSSL_FILETYPE_PEM)) != WOLFSSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load trusted peer cert file");
}
}
@@ -1471,7 +1471,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if (dtlsUDP == 0) {
ret = SSL_shutdown(ssl);
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)
SSL_shutdown(ssl); /* bidirectional shutdown */
}
/* display collected statistics */

54
src/bio.c
View File

@@ -75,11 +75,11 @@ long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **ptr)
WOLFSSL_ENTER("BIO_get_mem_ptr");
if (bio == NULL || ptr == NULL) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
*ptr = (WOLFSSL_BUF_MEM*)(bio->mem);
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/*** TBD ***/
@@ -99,19 +99,19 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
WOLFSSL_ENTER("wolfSSL_BIO_set_write_buf_size");
if (bio == NULL || bio->type != BIO_BIO || size < 0) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
/* if already in pair then do not change size */
if (bio->pair != NULL) {
WOLFSSL_MSG("WOLFSSL_BIO is paired, free from pair before changing");
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
bio->wrSz = (int)size;
if (bio->wrSz < 0) {
WOLFSSL_MSG("Unexpected negative size value");
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
if (bio->mem != NULL) {
@@ -121,12 +121,12 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
bio->mem = (byte*)XMALLOC(bio->wrSz, bio->heap, DYNAMIC_TYPE_OPENSSL);
if (bio->mem == NULL) {
WOLFSSL_MSG("Memory allocation error");
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
bio->wrIdx = 0;
bio->rdIdx = 0;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
@@ -140,31 +140,31 @@ int wolfSSL_BIO_make_bio_pair(WOLFSSL_BIO *b1, WOLFSSL_BIO *b2)
if (b1 == NULL || b2 == NULL) {
WOLFSSL_LEAVE("wolfSSL_BIO_make_bio_pair", BAD_FUNC_ARG);
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
/* both are expected to be of type BIO and not already paired */
if (b1->type != BIO_BIO || b2->type != BIO_BIO ||
b1->pair != NULL || b2->pair != NULL) {
WOLFSSL_MSG("Expected type BIO and not already paired");
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
/* set default write size if not already set */
if (b1->mem == NULL && wolfSSL_BIO_set_write_buf_size(b1,
WOLFSSL_BIO_SIZE) != WOLF_SSL_SUCCESS) {
return WOLF_SSL_FAILURE;
WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
return WOLFSSL_FAILURE;
}
if (b2->mem == NULL && wolfSSL_BIO_set_write_buf_size(b2,
WOLFSSL_BIO_SIZE) != WOLF_SSL_SUCCESS) {
return WOLF_SSL_FAILURE;
WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
return WOLFSSL_FAILURE;
}
b1->pair = b2;
b2->pair = b1;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
@@ -173,12 +173,12 @@ int wolfSSL_BIO_ctrl_reset_read_request(WOLFSSL_BIO *b)
WOLFSSL_ENTER("wolfSSL_BIO_ctrl_reset_read_request");
if (b == NULL) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
b->readRq = 0;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
@@ -219,7 +219,7 @@ int wolfSSL_BIO_nread(WOLFSSL_BIO *bio, char **buf, int num)
if (bio == NULL || buf == NULL) {
WOLFSSL_MSG("NULL argument passed in");
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
if (bio->pair != NULL) {
@@ -362,17 +362,17 @@ long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c)
if (bio == NULL || fp == NULL) {
WOLFSSL_LEAVE("wolfSSL_BIO_set_fp", BAD_FUNC_ARG);
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
if (bio->type != BIO_FILE) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
bio->close = (byte)c;
bio->file = fp;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
@@ -381,16 +381,16 @@ long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp)
WOLFSSL_ENTER("wolfSSL_BIO_get_fp");
if (bio == NULL || fp == NULL) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
if (bio->type != BIO_FILE) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
*fp = bio->file;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/* overwrites file */
@@ -399,7 +399,7 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
WOLFSSL_ENTER("wolfSSL_BIO_write_filename");
if (bio == NULL || name == NULL) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
if (bio->type == BIO_FILE) {
@@ -409,14 +409,14 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
bio->file = XFOPEN(name, "w");
if (bio->file == NULL) {
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}
bio->close = BIO_CLOSE;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
}

34
src/crl.c
View File

@@ -421,11 +421,11 @@ static int AddCRL(WOLFSSL_CRL* crl, DecodedCRL* dcrl, const byte* buff,
}
/* Load CRL File of type, WOLF_SSL_SUCCESS on ok */
/* Load CRL File of type, WOLFSSL_SUCCESS on ok */
int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
int noVerify)
{
int ret = WOLF_SSL_SUCCESS;
int ret = WOLFSSL_SUCCESS;
const byte* myBuffer = buff; /* if DER ok, otherwise switch */
DerBuffer* der = NULL;
#ifdef WOLFSSL_SMALL_STACK
@@ -439,7 +439,7 @@ int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
if (crl == NULL || buff == NULL || sz == 0)
return BAD_FUNC_ARG;
if (type == WOLF_SSL_FILETYPE_PEM) {
if (type == WOLFSSL_FILETYPE_PEM) {
int eccKey = 0; /* not used */
EncryptedInfo info;
info.ctx = NULL;
@@ -484,7 +484,7 @@ int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
FreeDer(&der);
return ret ? ret : WOLF_SSL_SUCCESS; /* convert 0 to WOLF_SSL_SUCCESS */
return ret ? ret : WOLFSSL_SUCCESS; /* convert 0 to WOLFSSL_SUCCESS */
}
@@ -540,8 +540,8 @@ static int SwapLists(WOLFSSL_CRL* crl)
}
if (crl->monitors[0].path) {
ret = LoadCRL(tmp, crl->monitors[0].path, WOLF_SSL_FILETYPE_PEM, 0);
if (ret != WOLF_SSL_SUCCESS) {
ret = LoadCRL(tmp, crl->monitors[0].path, WOLFSSL_FILETYPE_PEM, 0);
if (ret != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("PEM LoadCRL on dir change failed");
FreeCRL(tmp, 0);
#ifdef WOLFSSL_SMALL_STACK
@@ -552,8 +552,8 @@ static int SwapLists(WOLFSSL_CRL* crl)
}
if (crl->monitors[1].path) {
ret = LoadCRL(tmp, crl->monitors[1].path, WOLF_SSL_FILETYPE_ASN1, 0);
if (ret != WOLF_SSL_SUCCESS) {
ret = LoadCRL(tmp, crl->monitors[1].path, WOLFSSL_FILETYPE_ASN1, 0);
if (ret != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("DER LoadCRL on dir change failed");
FreeCRL(tmp, 0);
#ifdef WOLFSSL_SMALL_STACK
@@ -884,7 +884,7 @@ static void* DoMonitor(void* arg)
/* Start Monitoring the CRL path(s) in a thread */
static int StartMonitorCRL(WOLFSSL_CRL* crl)
{
int ret = WOLF_SSL_SUCCESS;
int ret = WOLFSSL_SUCCESS;
WOLFSSL_ENTER("StartMonitorCRL");
@@ -948,10 +948,10 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
#if !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
/* Load CRL path files of type, WOLF_SSL_SUCCESS on ok */
/* Load CRL path files of type, WOLFSSL_SUCCESS on ok */
int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
{
int ret = WOLF_SSL_SUCCESS;
int ret = WOLFSSL_SUCCESS;
char* name = NULL;
#ifdef WOLFSSL_SMALL_STACK
ReadDirCtx* readCtx = NULL;
@@ -974,7 +974,7 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
ret = wc_ReadDirFirst(readCtx, path, &name);
while (ret == 0 && name) {
int skip = 0;
if (type == WOLF_SSL_FILETYPE_PEM) {
if (type == WOLFSSL_FILETYPE_PEM) {
if (XSTRSTR(name, ".pem") == NULL) {
WOLFSSL_MSG("not .pem file, skipping");
skip = 1;
@@ -990,14 +990,14 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
}
if (!skip && ProcessFile(NULL, name, type, CRL_TYPE, NULL, 0, crl)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
WOLFSSL_MSG("CRL file load failed, continuing");
}
ret = wc_ReadDirNext(readCtx, path, &name);
}
wc_ReadDirClose(readCtx);
ret = WOLF_SSL_SUCCESS; /* load failures not reported, for backwards compat */
ret = WOLFSSL_SUCCESS; /* load failures not reported, for backwards compat */
#ifdef WOLFSSL_SMALL_STACK
XFREE(readCtx, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
@@ -1015,14 +1015,14 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
XSTRNCPY(pathBuf, path, pathLen);
pathBuf[pathLen] = '\0'; /* Null Terminate */
if (type == WOLF_SSL_FILETYPE_PEM) {
if (type == WOLFSSL_FILETYPE_PEM) {
/* free old path before setting a new one */
if (crl->monitors[0].path) {
XFREE(crl->monitors[0].path, crl->heap,
DYNAMIC_TYPE_CRL_MONITOR);
}
crl->monitors[0].path = pathBuf;
crl->monitors[0].type = WOLF_SSL_FILETYPE_PEM;
crl->monitors[0].type = WOLFSSL_FILETYPE_PEM;
} else {
/* free old path before setting a new one */
if (crl->monitors[1].path) {
@@ -1030,7 +1030,7 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
DYNAMIC_TYPE_CRL_MONITOR);
}
crl->monitors[1].path = pathBuf;
crl->monitors[1].type = WOLF_SSL_FILETYPE_ASN1;
crl->monitors[1].type = WOLFSSL_FILETYPE_ASN1;
}
if (monitor & WOLFSSL_CRL_START_MON) {

32
src/internal.c
View File

@@ -1081,7 +1081,7 @@ static int ExportPeerInfo(WOLFSSL* ssl, byte* exp, word32 len, byte ver)
WOLFSSL_MSG("No get peer call back set");
return BAD_FUNC_ARG;
}
if (ssl->ctx->CBGetPeer(ssl, ip, &ipSz, &port, &fam) != WOLF_SSL_SUCCESS) {
if (ssl->ctx->CBGetPeer(ssl, ip, &ipSz, &port, &fam) != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("Get peer callback error");
return SOCKET_ERROR_E;
}
@@ -1136,7 +1136,7 @@ static int ImportPeerInfo(WOLFSSL* ssl, byte* buf, word32 len, byte ver)
WOLFSSL_MSG("No set peer function");
return BAD_FUNC_ARG;
}
if (ssl->ctx->CBSetPeer(ssl, ip, ipSz, port, fam) != WOLF_SSL_SUCCESS) {
if (ssl->ctx->CBSetPeer(ssl, ip, ipSz, port, fam) != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("Error setting peer info");
return SOCKET_ERROR_E;
}
@@ -3901,7 +3901,7 @@ int DhAgree(WOLFSSL* ssl, DhKey* dhKey,
ctx parent factory
writeDup flag indicating this is a write dup only
WOLF_SSL_SUCCESS return value on success */
WOLFSSL_SUCCESS return value on success */
int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
{
byte havePSK = 0;
@@ -4097,7 +4097,7 @@ int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
ssl->readAhead = ctx->readAhead;
#endif
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
int InitHandshakeHashes(WOLFSSL* ssl)
@@ -4410,7 +4410,7 @@ int InitSSL(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
/* Initialize SSL with the appropriate fields from it's ctx */
/* requires valid arrays and suites unless writeDup ing */
if ((ret = SetSSL_CTX(ssl, ctx, writeDup)) != WOLF_SSL_SUCCESS)
if ((ret = SetSSL_CTX(ssl, ctx, writeDup)) != WOLFSSL_SUCCESS)
return ret;
ssl->options.dtls = ssl->version.major == DTLS_MAJOR;
@@ -8205,7 +8205,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
/* already verified above */
ret = AddCA(ssl->ctx->cm, &add, WOLFSSL_CHAIN_CA, 0);
if (ret == 1) {
ret = 0; /* WOLF_SSL_SUCCESS for external */
ret = 0; /* WOLFSSL_SUCCESS for external */
}
}
else if (ret != 0) {
@@ -11428,7 +11428,7 @@ int DoApplicationData(WOLFSSL* ssl, byte* input, word32* inOutIdx)
if (ssl->earlyData) {
if (ssl->earlyDataSz + dataSz > ssl->options.maxEarlyDataSz) {
SendAlert(ssl, alert_fatal, unexpected_message);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->earlyDataSz += dataSz;
}
@@ -13782,7 +13782,7 @@ int SendData(WOLFSSL* ssl, const void* data, int sz)
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
int err;
WOLFSSL_MSG("handshake not complete, trying to finish");
if ( (err = wolfSSL_negotiate(ssl)) != WOLF_SSL_SUCCESS) {
if ( (err = wolfSSL_negotiate(ssl)) != WOLFSSL_SUCCESS) {
/* if async would block return WANT_WRITE */
if (ssl->error == WC_PENDING_E) {
return WOLFSSL_CBIO_ERR_WANT_WRITE;
@@ -13939,7 +13939,7 @@ int ReceiveData(WOLFSSL* ssl, byte* output, int sz, int peek)
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
int err;
WOLFSSL_MSG("Handshake not complete, trying to finish");
if ( (err = wolfSSL_negotiate(ssl)) != WOLF_SSL_SUCCESS) {
if ( (err = wolfSSL_negotiate(ssl)) != WOLFSSL_SUCCESS) {
#ifdef WOLFSSL_ASYNC_CRYPT
/* if async would block return WANT_WRITE */
if (ssl->error == WC_PENDING_E) {
@@ -13956,7 +13956,7 @@ startScr:
int err;
ssl->secure_renegotiation->startScr = 0; /* only start once */
WOLFSSL_MSG("Need to start scr, server requested");
if ( (err = wolfSSL_Rehandshake(ssl)) != WOLF_SSL_SUCCESS)
if ( (err = wolfSSL_Rehandshake(ssl)) != WOLFSSL_SUCCESS)
return err;
}
#endif
@@ -14204,7 +14204,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "peer subject name mismatch";
case WANT_READ :
case WOLF_SSL_ERROR_WANT_READ :
case WOLFSSL_ERROR_WANT_READ :
return "non-blocking socket wants data to be read";
case NOT_READY_ERROR :
@@ -14217,7 +14217,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "record layer version error";
case WANT_WRITE :
case WOLF_SSL_ERROR_WANT_WRITE :
case WOLFSSL_ERROR_WANT_WRITE :
return "non-blocking socket write buffer full";
case BUFFER_ERROR :
@@ -14278,7 +14278,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "cant decode peer key";
case ZERO_RETURN:
case WOLF_SSL_ERROR_ZERO_RETURN:
case WOLFSSL_ERROR_ZERO_RETURN:
return "peer sent close notify alert";
case ECC_CURVETYPE_ERROR:
@@ -16331,7 +16331,7 @@ void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
if (ticket == NULL) return MEMORY_E;
ret = TLSX_UseSessionTicket(&ssl->extensions, ticket, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
idSz = 0;
}
@@ -22605,7 +22605,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
int ret = 0;
ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
}
#endif /* HAVE_SERVER_RENEGOTIATION_INFO */
@@ -23622,7 +23622,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
if (ssl->options.side != WOLFSSL_SERVER_END) {
WOLFSSL_MSG("Client received client keyexchange, attack?");
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
ERROR_OUT(WOLF_SSL_FATAL_ERROR, exit_dcke);
ERROR_OUT(WOLFSSL_FATAL_ERROR, exit_dcke);
}
if (ssl->options.clientState < CLIENT_HELLO_COMPLETE) {

14
src/ocsp.c
View File

@@ -471,11 +471,11 @@ int wolfSSL_OCSP_resp_find_status(WOLFSSL_OCSP_BASICRESP *bs,
WOLFSSL_ASN1_TIME** nextupd)
{
if (bs == NULL || id == NULL)
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
/* Only supporting one certificate status in asn.c. */
if (CompareOcspReqResp(id, bs) != 0)
return WOLF_SSL_FAILURE;
return WOLFSSL_FAILURE;
if (status != NULL)
*status = bs->status->status;
@@ -490,7 +490,7 @@ int wolfSSL_OCSP_resp_find_status(WOLFSSL_OCSP_BASICRESP *bs,
if (revtime != NULL)
*revtime = NULL;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
const char *wolfSSL_OCSP_cert_status_str(long s)
@@ -515,7 +515,7 @@ int wolfSSL_OCSP_check_validity(WOLFSSL_ASN1_TIME* thisupd,
(void)sec;
(void)maxsec;
/* Dates validated in DecodeSingleResponse. */
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
void wolfSSL_OCSP_CERTID_free(WOLFSSL_OCSP_CERTID* certId)
@@ -584,16 +584,16 @@ int wolfSSL_OCSP_basic_verify(WOLFSSL_OCSP_BASICRESP *bs,
WOLF_STACK_OF(WOLFSSL_X509) *certs, WOLFSSL_X509_STORE *st, unsigned long flags)
{
DecodedCert cert;
int ret = WOLF_SSL_SUCCESS;
int ret = WOLFSSL_SUCCESS;
(void)certs;
if (flags & OCSP_NOVERIFY)
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
InitDecodedCert(&cert, bs->cert, bs->certSz, NULL);
if (ParseCertRelative(&cert, CERT_TYPE, VERIFY, st->cm) < 0)
ret = WOLF_SSL_FAILURE;
ret = WOLFSSL_FAILURE;
FreeDecodedCert(&cert);
return ret;

14
src/sniffer.c
View File

@@ -1183,7 +1183,7 @@ static int LoadKeyFile(byte** keyBuf, word32* keyBufSz,
return -1;
}
if (typeKey == WOLF_SSL_FILETYPE_PEM) {
if (typeKey == WOLFSSL_FILETYPE_PEM) {
byte* saveBuf = (byte*)malloc(fileSz);
int saveBufSz = 0;
@@ -1228,8 +1228,8 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
{
SnifferServer* sniffer;
int ret;
int type = (typeKey == FILETYPE_PEM) ? WOLF_SSL_FILETYPE_PEM :
WOLF_SSL_FILETYPE_ASN1;
int type = (typeKey == FILETYPE_PEM) ? WOLFSSL_FILETYPE_PEM :
WOLFSSL_FILETYPE_ASN1;
int isNew = 0;
word32 serverIp;
@@ -1306,7 +1306,7 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
sniffer->ctx, (void*)password);
}
ret = SSL_CTX_use_PrivateKey_file(sniffer->ctx, keyFile, type);
if (ret != WOLF_SSL_SUCCESS) {
if (ret != WOLFSSL_SUCCESS) {
SetError(KEY_FILE_STR, error, NULL, 0);
if (isNew)
FreeSnifferServer(sniffer);
@@ -1825,7 +1825,7 @@ static int ProcessClientHello(const byte* input, int* sslBytes,
*sslBytes + HANDSHAKE_HEADER_SZ + RECORD_HEADER_SZ,
WOLFSSL_SNI_HOST_NAME, name, &nameSz);
if (ret == WOLF_SSL_SUCCESS) {
if (ret == WOLFSSL_SUCCESS) {
NamedKey* namedKey;
if (nameSz >= sizeof(name))
@@ -1838,7 +1838,7 @@ static int ProcessClientHello(const byte* input, int* sslBytes,
XSTRNCMP((char*)name, namedKey->name, nameSz) == 0) {
if (wolfSSL_use_PrivateKey_buffer(session->sslServer,
namedKey->key, namedKey->keySz,
WOLF_SSL_FILETYPE_ASN1) != WOLF_SSL_SUCCESS) {
WOLFSSL_FILETYPE_ASN1) != WOLFSSL_SUCCESS) {
wc_UnLockMutex(&session->context->namedKeysMutex);
SetError(CLIENT_HELLO_LATE_KEY_STR, error, session,
FATAL_ERROR_STATE);
@@ -3596,7 +3596,7 @@ int ssl_GetSessionStats(unsigned int* active, unsigned int* total,
ret = wolfSSL_get_session_stats(active, total, peak, maxSessions);
if (ret == WOLF_SSL_SUCCESS)
if (ret == WOLFSSL_SUCCESS)
return 0;
else {
SetError(BAD_SESSION_STATS, error, NULL, 0);

2022
src/ssl.c
View File

File diff suppressed because it is too large Load Diff

116
src/tls.c
View File

@@ -835,7 +835,7 @@ int wolfSSL_GetHmacType(WOLFSSL* ssl)
#endif
default:
{
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
}
@@ -1173,7 +1173,7 @@ static int TLSX_SetALPN(TLSX** extensions, const void* data, word16 size,
return ret;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/** Parses a buffer of ALPN extensions and set the first one matching
@@ -1207,7 +1207,7 @@ static int TLSX_ALPN_ParseAndSet(WOLFSSL *ssl, byte *input, word16 length,
ssl->alpnSelectArg) == 0) {
WOLFSSL_MSG("ALPN protocol match");
if (TLSX_UseALPN(&ssl->extensions, (char*)out, outLen, 0, ssl->heap)
== WOLF_SSL_SUCCESS) {
== WOLFSSL_SUCCESS) {
if (extension == NULL) {
extension = TLSX_Find(ssl->extensions,
TLSX_APPLICATION_LAYER_PROTOCOL);
@@ -1287,7 +1287,7 @@ static int TLSX_ALPN_ParseAndSet(WOLFSSL *ssl, byte *input, word16 length,
alpn->protocol_name,
(word16)XSTRLEN(alpn->protocol_name),
ssl->heap);
if (r != WOLF_SSL_SUCCESS) {
if (r != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("TLSX_UseALPN failed");
return BUFFER_ERROR;
}
@@ -1337,7 +1337,7 @@ int TLSX_UseALPN(TLSX** extensions, const void* data, word16 size, byte options,
extension->data = (void*)alpn;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/** Get the protocol name set by the server */
@@ -1360,7 +1360,7 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
WOLFSSL_MSG("ALPN extension not found");
*data = NULL;
*dataSz = 0;
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
if (alpn->negotiated != 1) {
@@ -1368,7 +1368,7 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
/* consider as an error */
if (alpn->options & WOLFSSL_ALPN_FAILED_ON_MISMATCH) {
WOLFSSL_MSG("No protocol match with peer -> Failed");
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
/* continue without negotiated protocol */
@@ -1378,13 +1378,13 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
if (alpn->next != NULL) {
WOLFSSL_MSG("Only one protocol name must be accepted");
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
*data = alpn->protocol_name;
*dataSz = (word16)XSTRLEN((char*)*data);
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define ALPN_FREE_ALL TLSX_ALPN_FreeAll
@@ -1641,7 +1641,7 @@ static int TLSX_SNI_Parse(WOLFSSL* ssl, byte* input, word16 length,
int r = TLSX_UseSNI(&ssl->extensions,
type, input + offset, size, ssl->heap);
if (r != WOLF_SSL_SUCCESS)
if (r != WOLFSSL_SUCCESS)
return r; /* throws error. */
if(cacheOnly) {
@@ -1760,7 +1760,7 @@ int TLSX_UseSNI(TLSX** extensions, byte type, const void* data, word16 size,
} while ((sni = sni->next));
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#ifndef NO_WOLFSSL_SERVER
@@ -1935,7 +1935,7 @@ int TLSX_SNI_GetFromBuffer(const byte* clientHello, word32 helloSz,
*inOutSz = min(sniLen, *inOutSz);
XMEMCPY(sni, clientHello + offset, *inOutSz);
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
}
@@ -2001,7 +2001,7 @@ static int TLSX_MFL_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (isRequest) {
int r = TLSX_UseMaxFragment(&ssl->extensions, *input, ssl->heap);
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
if (r != WOLFSSL_SUCCESS) return r; /* throw error */
TLSX_SetResponse(ssl, TLSX_MAX_FRAGMENT_LENGTH);
}
@@ -2033,7 +2033,7 @@ int TLSX_UseMaxFragment(TLSX** extensions, byte mfl, void* heap)
return ret;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
@@ -2069,7 +2069,7 @@ static int TLSX_THM_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (isRequest) {
int r = TLSX_UseTruncatedHMAC(&ssl->extensions, ssl->heap);
if (r != WOLF_SSL_SUCCESS)
if (r != WOLFSSL_SUCCESS)
return r; /* throw error */
TLSX_SetResponse(ssl, TLSX_TRUNCATED_HMAC);
@@ -2091,7 +2091,7 @@ int TLSX_UseTruncatedHMAC(TLSX** extensions, void* heap)
if ((ret = TLSX_Push(extensions, TLSX_TRUNCATED_HMAC, NULL, heap)) != 0)
return ret;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define THM_PARSE TLSX_THM_Parse
@@ -2209,7 +2209,7 @@ static int TLSX_CSR_Parse(WOLFSSL* ssl, byte* input, word16 length,
ret = TLSX_UseCertificateStatusRequest(&ssl->extensions,
csr->status_type, csr->options, ssl->heap,
ssl->devId);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
switch (csr->status_type) {
@@ -2285,7 +2285,7 @@ static int TLSX_CSR_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* accept the first good status_type and return */
ret = TLSX_UseCertificateStatusRequest(&ssl->extensions, status_type,
0, ssl->heap, ssl->devId);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret; /* throw error */
TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST);
@@ -2415,7 +2415,7 @@ int TLSX_UseCertificateStatusRequest(TLSX** extensions, byte status_type,
return ret;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define CSR_FREE_ALL TLSX_CSR_Free
@@ -2573,7 +2573,7 @@ static int TLSX_CSR2_Parse(WOLFSSL* ssl, byte* input, word16 length,
for (; csr2; csr2 = csr2->next) {
ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
csr2->status_type, csr2->options, ssl->heap, ssl->devId);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
switch (csr2->status_type) {
@@ -2672,7 +2672,7 @@ static int TLSX_CSR2_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* accept the first good status_type and return */
ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
status_type, 0, ssl->heap, ssl->devId);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret; /* throw error */
TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST_V2);
@@ -2845,7 +2845,7 @@ int TLSX_UseCertificateStatusRequestV2(TLSX** extensions, byte status_type,
return ret;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define CSR2_FREE_ALL TLSX_CSR2_FreeAll
@@ -2984,7 +2984,7 @@ static int TLSX_EllipticCurve_Parse(WOLFSSL* ssl, byte* input, word16 length,
r = TLSX_UseSupportedCurve(&ssl->extensions, name, ssl->heap);
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
if (r != WOLFSSL_SUCCESS) return r; /* throw error */
}
return 0;
@@ -3320,7 +3320,7 @@ int TLSX_UseSupportedCurve(TLSX** extensions, word16 name, void* heap)
} while ((curve = curve->next));
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define EC_FREE_ALL TLSX_EllipticCurve_FreeAll
@@ -3412,7 +3412,7 @@ static int TLSX_SecureRenegotiation_Parse(WOLFSSL* ssl, byte* input,
TLSX_RENEGOTIATION_INFO) == NULL) {
ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions,
ssl->heap);
if (ret == WOLF_SSL_SUCCESS)
if (ret == WOLFSSL_SUCCESS)
ret = 0;
} else {
@@ -3494,7 +3494,7 @@ int TLSX_UseSecureRenegotiation(TLSX** extensions, void* heap)
return ret;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#ifdef HAVE_SERVER_RENEGOTIATION_INFO
@@ -3512,7 +3512,7 @@ int TLSX_AddEmptyRenegotiationInfo(TLSX** extensions, void* heap)
if (ext)
ext->resp = 1;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#endif /* HAVE_SERVER_RENEGOTIATION_INFO */
@@ -3603,7 +3603,7 @@ static int TLSX_SessionTicket_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (length == 0) {
/* blank ticket */
ret = TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
if (ret == WOLF_SSL_SUCCESS) {
if (ret == WOLFSSL_SUCCESS) {
ret = 0;
TLSX_SetResponse(ssl, TLSX_SESSION_TICKET); /* send blank ticket */
ssl->options.createTicket = 1; /* will send ticket msg */
@@ -3621,7 +3621,7 @@ static int TLSX_SessionTicket_Parse(WOLFSSL* ssl, byte* input, word16 length,
} else if (ret == WOLFSSL_TICKET_RET_CREATE) {
WOLFSSL_MSG("Using existing client ticket, creating new one");
ret = TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
if (ret == WOLF_SSL_SUCCESS) {
if (ret == WOLFSSL_SUCCESS) {
ret = 0;
TLSX_SetResponse(ssl, TLSX_SESSION_TICKET);
/* send blank ticket */
@@ -3685,7 +3685,7 @@ int TLSX_UseSessionTicket(TLSX** extensions, SessionTicket* ticket, void* heap)
!= 0)
return ret;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define WOLF_STK_VALIDATE_REQUEST TLSX_SessionTicket_ValidateRequest
@@ -3999,7 +3999,7 @@ static int TLSX_QSH_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* peer sent an agreed upon scheme */
r = TLSX_UseQSHScheme(&ssl->extensions, name, NULL, 0, ssl->heap);
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
if (r != WOLFSSL_SUCCESS) return r; /* throw error */
numKeys--;
}
@@ -4070,7 +4070,7 @@ static int TLSX_QSH_Parse(WOLFSSL* ssl, byte* input, word16 length,
XFREE(temp, ssl->heap, DYNAMIC_TYPE_TLSX);
}
if (r != WOLF_SSL_SUCCESS) {return r;} /* throw error */
if (r != WOLFSSL_SUCCESS) {return r;} /* throw error */
numKeys--;
}
@@ -4266,7 +4266,7 @@ int TLSX_UseQSHScheme(TLSX** extensions, word16 name, byte* pKey, word16 pkeySz,
} while ((format = format->next));
}
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#define QSH_FREE_ALL TLSX_QSH_FreeAll
@@ -7398,7 +7398,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS743,
public_key, public_key_len, ssl->heap)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
ret = -1;
/* add NTRU 196 */
@@ -7408,7 +7408,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS593,
public_key, public_key_len, ssl->heap)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
ret = -1;
/* add NTRU 128 */
@@ -7418,7 +7418,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS439,
public_key, public_key_len, ssl->heap)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
ret = -1;
}
else if (ssl->sendQSHKeys && ssl->QSH_Key == NULL) {
@@ -7439,7 +7439,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
&public_key_len, qsh->name);
if (TLSX_UseQSHScheme(&ssl->extensions, qsh->name,
public_key, public_key_len,
ssl->heap) != WOLF_SSL_SUCCESS)
ssl->heap) != WOLFSSL_SUCCESS)
ret = -1;
qsh = next;
}
@@ -7455,29 +7455,29 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_SECPR2
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160R2, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160K1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP192R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP192K1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#endif
@@ -7485,60 +7485,60 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP224R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP224K1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP256R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#if defined(HAVE_CURVE25519)
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_X25519, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP256K1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP256R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP384R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP384R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP512R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP521R1, ssl->heap);
if (ret != WOLF_SSL_SUCCESS) return ret;
if (ret != WOLFSSL_SUCCESS) return ret;
#endif
#endif
}
@@ -7567,31 +7567,31 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifdef HAVE_FFDHE_2048
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_2048, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_3072
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_3072, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_4096
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_4096, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_6144
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_6144, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_8192
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_8192, ssl->heap);
if (ret != WOLF_SSL_SUCCESS)
if (ret != WOLFSSL_SUCCESS)
return ret;
#endif
ret = 0;
@@ -7719,7 +7719,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
(void)public_key_len;
(void)ssl;
if (ret == WOLF_SSL_SUCCESS)
if (ret == WOLFSSL_SUCCESS)
ret = 0;
return ret;

108
src/tls13.c
View File

@@ -6385,7 +6385,7 @@ int DoTls13HandShakeMsg(WOLFSSL* ssl, byte* input, word32* inOutIdx,
* Please see note at top of README if you get an error from connect.
*
* ssl The SSL/TLS object.
* returns WOLF_SSL_SUCCESS on successful handshake, WOLF_SSL_FATAL_ERROR when
* returns WOLFSSL_SUCCESS on successful handshake, WOLFSSL_FATAL_ERROR when
* unrecoverable error occurs and 0 otherwise.
* For more error information use wolfSSL_get_error().
*/
@@ -6401,7 +6401,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (ssl->options.side != WOLFSSL_CLIENT_END) {
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
if (ssl->buffers.outputBuffer.length > 0) {
@@ -6421,7 +6421,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
}
else {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
@@ -6431,7 +6431,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
/* Always send client hello first. */
if ((ssl->error = SendTls13ClientHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.connectState = CLIENT_HELLO_SENT;
@@ -6439,7 +6439,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
#ifdef WOLFSSL_EARLY_DATA
if (ssl->earlyData) {
ssl->options.handShakeState = CLIENT_HELLO_COMPLETE;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#endif
FALL_THROUGH;
@@ -6451,7 +6451,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
while (ssl->options.serverState < neededState) {
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
/* if resumption failed, reset needed state. */
if (neededState == SERVER_FINISHED_COMPLETE &&
@@ -6466,7 +6466,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
case HELLO_AGAIN:
if (ssl->options.certOnly)
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
if (!ssl->options.tls1_3)
return wolfSSL_connect(ssl);
@@ -6476,7 +6476,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
/* Try again with different security parameters. */
if ((ssl->error = SendTls13ClientHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
@@ -6494,7 +6494,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
while (ssl->options.serverState < neededState) {
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
/* if resumption failed, reset needed state */
else if (neededState == SERVER_FINISHED_COMPLETE) {
@@ -6513,7 +6513,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (ssl->earlyData) {
if ((ssl->error = SendTls13EndOfEarlyData(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: end_of_early_data");
}
@@ -6529,7 +6529,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13Certificate(ssl);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: certificate");
}
@@ -6546,7 +6546,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13CertificateVerify(ssl);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: certificate verify");
}
@@ -6559,7 +6559,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
case FIRST_REPLY_THIRD:
if ((ssl->error = SendTls13Finished(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: finished");
@@ -6574,17 +6574,17 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (cbret < 0) {
ssl->error = cbret;
WOLFSSL_MSG("HandShake Done Cb don't continue error");
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif /* NO_HANDSHAKE_DONE_CB */
WOLFSSL_LEAVE("wolfSSL_connect_TLSv13()", WOLF_SSL_SUCCESS);
return WOLF_SSL_SUCCESS;
WOLFSSL_LEAVE("wolfSSL_connect_TLSv13()", WOLFSSL_SUCCESS);
return WOLFSSL_SUCCESS;
default:
WOLFSSL_MSG("Unknown connect state ERROR");
return WOLF_SSL_FATAL_ERROR; /* unknown connect state */
return WOLFSSL_FATAL_ERROR; /* unknown connect state */
}
}
@@ -6597,7 +6597,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
* secretSz Size of secret data in bytes.
* Use a value of 0 to indicate use of default size.
* returns BAD_FUNC_ARG when ssl is NULL or not using TLS v1.3, SIDE_ERROR when
* called on a client; WOLF_SSL_SUCCESS on success and otherwise failure.
* called on a client; WOLFSSL_SUCCESS on success and otherwise failure.
*/
int wolfSSL_send_hrr_cookie(WOLFSSL* ssl, const unsigned char* secret,
unsigned int secretSz)
@@ -6652,7 +6652,7 @@ int wolfSSL_send_hrr_cookie(WOLFSSL* ssl, const unsigned char* secret,
ssl->options.sendCookie = 1;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#endif
@@ -6676,7 +6676,7 @@ int wolfSSL_UseKeyShare(WOLFSSL* ssl, word16 group)
if (ret != 0)
return ret;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/* Send no key share entries - use HelloRetryRequest to negotiate shared group.
@@ -6697,7 +6697,7 @@ int wolfSSL_NoKeyShares(WOLFSSL* ssl)
if (ret != 0)
return ret;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/* Do not send a ticket after TLS v1.3 handshake for resumption.
@@ -6771,13 +6771,13 @@ int wolfSSL_no_dhe_psk(WOLFSSL* ssl)
}
/* Update the keys for encryption and decryption.
* If using non-blocking I/O and WOLF_SSL_ERROR_WANT_WRITE is returned then
* If using non-blocking I/O and WOLFSSL_ERROR_WANT_WRITE is returned then
* calling wolfSSL_write() will have the message sent when ready.
*
* ssl The SSL/TLS object.
* returns BAD_FUNC_ARG when ssl is NULL, or not using TLS v1.3,
* WOLF_SSL_ERROR_WANT_WRITE when non-blocking I/O is not ready to write,
* WOLF_SSL_SUCCESS on success and otherwise failure.
* WOLFSSL_ERROR_WANT_WRITE when non-blocking I/O is not ready to write,
* WOLFSSL_SUCCESS on success and otherwise failure.
*/
int wolfSSL_update_keys(WOLFSSL* ssl)
{
@@ -6788,9 +6788,9 @@ int wolfSSL_update_keys(WOLFSSL* ssl)
ret = SendTls13KeyUpdate(ssl);
if (ret == WANT_WRITE)
ret = WOLF_SSL_ERROR_WANT_WRITE;
ret = WOLFSSL_ERROR_WANT_WRITE;
else if (ret == 0)
ret = WOLF_SSL_SUCCESS;
ret = WOLFSSL_SUCCESS;
return ret;
}
@@ -6864,9 +6864,9 @@ int wolfSSL_request_certificate(WOLFSSL* ssl)
ret = SendTls13CertificateRequest(ssl, &certReqCtx->ctx, certReqCtx->len);
if (ret == WANT_WRITE)
ret = WOLF_SSL_ERROR_WANT_WRITE;
ret = WOLFSSL_ERROR_WANT_WRITE;
else if (ret == 0)
ret = WOLF_SSL_SUCCESS;
ret = WOLFSSL_SUCCESS;
return ret;
}
#endif /* !NO_CERTS && WOLFSSL_POST_HANDSHAKE_AUTH */
@@ -6879,7 +6879,7 @@ int wolfSSL_request_certificate(WOLFSSL* ssl)
* Please see note at top of README if you get an error from accept.
*
* ssl The SSL/TLS object.
* returns WOLF_SSL_SUCCESS on successful handshake, WOLF_SSL_FATAL_ERROR when
* returns WOLFSSL_SUCCESS on successful handshake, WOLFSSL_FATAL_ERROR when
* unrecoverable error occurs and 0 otherwise.
* For more error information use wolfSSL_get_error().
*/
@@ -6905,7 +6905,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.side != WOLFSSL_SERVER_END) {
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
#ifndef NO_CERTS
@@ -6918,7 +6918,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
WOLFSSL_MSG("accept error: don't have server cert and key");
ssl->error = NO_PRIVATE_KEY;
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
#endif
@@ -6939,7 +6939,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
}
else {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
@@ -6950,7 +6950,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
while (ssl->options.clientState < CLIENT_HELLO_COMPLETE)
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_CLIENT_HELLO_DONE;
@@ -6961,7 +6961,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.serverState == SERVER_HELLO_RETRY_REQUEST) {
if ((ssl->error = SendTls13HelloRetryRequest(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
ssl->options.acceptState = ACCEPT_HELLO_RETRY_REQUEST_DONE;
@@ -6972,7 +6972,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.serverState == SERVER_HELLO_RETRY_REQUEST) {
if ( (ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
ssl->options.acceptState = ACCEPT_FIRST_REPLY_DONE;
@@ -6982,7 +6982,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case ACCEPT_FIRST_REPLY_DONE :
if ((ssl->error = SendTls13ServerHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.acceptState = SERVER_HELLO_SENT;
WOLFSSL_MSG("accept state SERVER_HELLO_SENT");
@@ -6991,7 +6991,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case SERVER_HELLO_SENT :
if ((ssl->error = SendTls13EncryptedExtensions(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.acceptState = SERVER_EXTENSIONS_SENT;
WOLFSSL_MSG("accept state SERVER_EXTENSIONS_SENT");
@@ -7004,7 +7004,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13CertificateRequest(ssl, NULL, 0);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
}
@@ -7019,7 +7019,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (!ssl->options.resuming && ssl->options.sendVerify) {
if ((ssl->error = SendTls13Certificate(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif
@@ -7032,7 +7032,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (!ssl->options.resuming && ssl->options.sendVerify) {
if ((ssl->error = SendTls13CertificateVerify(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif
@@ -7043,7 +7043,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case CERT_VERIFY_SENT :
if ((ssl->error = SendTls13Finished(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_FINISHED_DONE;
@@ -7051,7 +7051,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
#ifdef WOLFSSL_EARLY_DATA
if (ssl->earlyData) {
ssl->options.handShakeState = SERVER_FINISHED_COMPLETE;
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#endif
FALL_THROUGH;
@@ -7063,7 +7063,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
!ssl->options.noTicketTls13 && ssl->ctx->ticketEncCb != NULL) {
if ((ssl->error = SendTls13NewSessionTicket(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif
@@ -7076,7 +7076,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE)
if ( (ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_SECOND_REPLY_DONE;
@@ -7094,7 +7094,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
!ssl->options.noTicketTls13 && ssl->ctx->ticketEncCb != NULL) {
if ((ssl->error = SendTls13NewSessionTicket(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif /* HAVE_SESSION_TICKET */
@@ -7109,17 +7109,17 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (cbret < 0) {
ssl->error = cbret;
WOLFSSL_MSG("HandShake Done Cb don't continue error");
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif /* NO_HANDSHAKE_DONE_CB */
WOLFSSL_LEAVE("SSL_accept()", WOLF_SSL_SUCCESS);
return WOLF_SSL_SUCCESS;
WOLFSSL_LEAVE("SSL_accept()", WOLFSSL_SUCCESS);
return WOLFSSL_SUCCESS;
default :
WOLFSSL_MSG("Unknown accept state ERROR");
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
}
#endif
@@ -7197,7 +7197,7 @@ int wolfSSL_write_early_data(WOLFSSL* ssl, const void* data, int sz, int* outSz)
ssl->earlyData = 1;
ret = wolfSSL_connect_TLSv13(ssl);
if (ret <= 0)
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
if (ssl->options.handShakeState == CLIENT_HELLO_COMPLETE) {
ret = SendData(ssl, data, sz);
@@ -7208,7 +7208,7 @@ int wolfSSL_write_early_data(WOLFSSL* ssl, const void* data, int sz, int* outSz)
WOLFSSL_LEAVE("SSL_write_early_data()", ret);
if (ret < 0)
ret = WOLF_SSL_FATAL_ERROR;
ret = WOLFSSL_FATAL_ERROR;
return ret;
}
@@ -7241,14 +7241,14 @@ int wolfSSL_read_early_data(WOLFSSL* ssl, void* data, int sz, int* outSz)
ssl->earlyData = 1;
ret = wolfSSL_accept_TLSv13(ssl);
if (ret <= 0)
return WOLF_SSL_FATAL_ERROR;
return WOLFSSL_FATAL_ERROR;
}
if (ssl->options.handShakeState == SERVER_FINISHED_COMPLETE) {
ret = ReceiveData(ssl, (byte*)data, sz, FALSE);
if (ret > 0)
*outSz = ret;
if (ssl->error == ZERO_RETURN)
ssl->error = WOLF_SSL_ERROR_NONE;
ssl->error = WOLFSSL_ERROR_NONE;
}
else
ret = 0;
@@ -7256,7 +7256,7 @@ int wolfSSL_read_early_data(WOLFSSL* ssl, void* data, int sz, int* outSz)
WOLFSSL_LEAVE("wolfSSL_read_early_data()", ret);
if (ret < 0)
ret = WOLF_SSL_FATAL_ERROR;
ret = WOLFSSL_FATAL_ERROR;
return ret;
}
#endif

14
src/wolfio.c
View File

@@ -460,7 +460,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* get peer information stored in ssl struct */
peerSz = sizeof(SOCKADDR_S);
if ((ret = wolfSSL_dtls_get_peer(ssl, (void*)&peer, &peerSz))
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
return ret;
}
@@ -494,7 +494,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
ip[*ipSz - 1] = '\0'; /* make sure has terminator */
*ipSz = (word16)XSTRLEN(ip);
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
/* set the peer information in human readable form (ip, port, family)
@@ -524,7 +524,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* peer sa is free'd in SSL_ResourceFree */
if ((ret = wolfSSL_dtls_set_peer(ssl, (SOCKADDR_IN*)&addr,
sizeof(SOCKADDR_IN)))!= WOLF_SSL_SUCCESS) {
sizeof(SOCKADDR_IN)))!= WOLFSSL_SUCCESS) {
WOLFSSL_MSG("Import DTLS peer info error");
return ret;
}
@@ -541,7 +541,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* peer sa is free'd in SSL_ResourceFree */
if ((ret = wolfSSL_dtls_set_peer(ssl, (SOCKADDR_IN6*)&addr,
sizeof(SOCKADDR_IN6)))!= WOLF_SSL_SUCCESS) {
sizeof(SOCKADDR_IN6)))!= WOLFSSL_SUCCESS) {
WOLFSSL_MSG("Import DTLS peer info error");
return ret;
}
@@ -553,7 +553,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
return BUFFER_E;
}
return WOLF_SSL_SUCCESS;
return WOLFSSL_SUCCESS;
}
#endif /* WOLFSSL_SESSION_EXPORT */
#endif /* WOLFSSL_DTLS */
@@ -1280,7 +1280,7 @@ int wolfIO_HttpProcessResponseCrl(WOLFSSL_CRL* crl, int sfd, byte* httpBuf,
result = wolfIO_HttpProcessResponse(sfd, "application/pkix-crl",
&respBuf, httpBuf, httpBufSz, DYNAMIC_TYPE_CRL, crl->heap);
if (result >= 0) {
result = BufferLoadCRL(crl, respBuf, result, WOLF_SSL_FILETYPE_ASN1, 0);
result = BufferLoadCRL(crl, respBuf, result, WOLFSSL_FILETYPE_ASN1, 0);
}
XFREE(respBuf, crl->heap, DYNAMIC_TYPE_CRL);
@@ -1754,7 +1754,7 @@ int MicriumGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
XMEMSET(&peer, 0, sizeof(peer));
if (wolfSSL_dtls_get_peer(ssl, (void*)&peer,
(unsigned int*)&peerSz) != WOLF_SSL_SUCCESS) {
(unsigned int*)&peerSz) != WOLFSSL_SUCCESS) {
WOLFSSL_MSG("getpeername failed in MicriumGenerateCookie");
return GEN_COOKIE_E;
}

1030
tests/api.c
View File

File diff suppressed because it is too large Load Diff

6
tests/suites.c
View File

@@ -143,13 +143,13 @@ static int IsValidCipherSuite(const char* line, char* suite)
#ifdef HAVE_QSH
if (XSTRNCMP(suite, "QSH", 3) == 0) {
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite + 4)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
return 0;
}
#endif
if (found) {
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == WOLF_SSL_SUCCESS)
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == WOLFSSL_SUCCESS)
valid = 1;
}
@@ -539,7 +539,7 @@ int SuiteTest(void)
#ifdef WOLFSSL_STATIC_MEMORY
if (wolfSSL_CTX_load_static_memory(&cipherSuiteCtx, NULL,
memory, sizeof(memory), 0, 1)
!= WOLF_SSL_SUCCESS) {
!= WOLFSSL_SUCCESS) {
printf("unable to load static memory and create ctx");
args.return_code = EXIT_FAILURE;
goto exit;

184
wolfssl/ssl.h
View File

@@ -1035,117 +1035,117 @@ WOLFSSL_API void wolfSSL_ERR_dump_errors_fp(FILE* fp);
#ifndef NO_OLD_SSL_NAMES
#define SSL_ERROR_NONE WOLF_SSL_ERROR_NONE
#define SSL_FAILURE WOLF_SSL_FAILURE
#define SSL_SUCCESS WOLF_SSL_SUCCESS
#define SSL_SHUTDOWN_NOT_DONE WOLF_WOLF_SSL_SHUTDOWN_NOT_DONE
#define SSL_ERROR_NONE WOLFSSL_ERROR_NONE
#define SSL_FAILURE WOLFSSL_FAILURE
#define SSL_SUCCESS WOLFSSL_SUCCESS
#define SSL_SHUTDOWN_NOT_DONE WOLF_WOLFSSL_SHUTDOWN_NOT_DONE
#define SSL_ALPN_NOT_FOUND WOLF_SSL_ALPN_NOT_FOUND
#define SSL_BAD_CERTTYPE WOLF_SSL_BAD_CERTTYPE
#define SSL_BAD_STAT WOLF_SSL_BAD_STAT
#define SSL_BAD_PATH WOLF_SSL_BAD_PATH
#define SSL_BAD_FILETYPE WOLF_SSL_BAD_FILETYPE
#define SSL_BAD_FILE WOLF_SSL_BAD_FILE
#define SSL_NOT_IMPLEMENTED WOLF_SSL_NOT_IMPLEMENTED
#define SSL_UNKNOWN WOLF_SSL_UNKNOWN
#define SSL_FATAL_ERROR WOLF_SSL_FATAL_ERROR
#define SSL_ALPN_NOT_FOUND WOLFSSL_ALPN_NOT_FOUND
#define SSL_BAD_CERTTYPE WOLFSSL_BAD_CERTTYPE
#define SSL_BAD_STAT WOLFSSL_BAD_STAT
#define SSL_BAD_PATH WOLFSSL_BAD_PATH
#define SSL_BAD_FILETYPE WOLFSSL_BAD_FILETYPE
#define SSL_BAD_FILE WOLFSSL_BAD_FILE
#define SSL_NOT_IMPLEMENTED WOLFSSL_NOT_IMPLEMENTED
#define SSL_UNKNOWN WOLFSSL_UNKNOWN
#define SSL_FATAL_ERROR WOLFSSL_FATAL_ERROR
#define SSL_FILETYPE_ASN1 WOLF_SSL_FILETYPE_ASN1
#define SSL_FILETYPE_PEM WOLF_SSL_FILETYPE_PEM
#define SSL_FILETYPE_DEFAULT WOLF_SSL_FILETYPE_DEFAULT
#define SSL_FILETYPE_RAW WOLF_SSL_FILETYPE_RAW
#define SSL_FILETYPE_ASN1 WOLFSSL_FILETYPE_ASN1
#define SSL_FILETYPE_PEM WOLFSSL_FILETYPE_PEM
#define SSL_FILETYPE_DEFAULT WOLFSSL_FILETYPE_DEFAULT
#define SSL_FILETYPE_RAW WOLFSSL_FILETYPE_RAW
#define SSL_VERIFY_NONE WOLF_SSL_VERIFY_NONE
#define SSL_VERIFY_PEER WOLF_SSL_VERIFY_PEER
#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT
#define SSL_VERIFY_CLIENT_ONCE WOLF_SSL_VERIFY_CLIENT_ONCE
#define SSL_VERIFY_FAIL_EXCEPT_PSK WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK
#define SSL_VERIFY_NONE WOLFSSL_VERIFY_NONE
#define SSL_VERIFY_PEER WOLFSSL_VERIFY_PEER
#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT
#define SSL_VERIFY_CLIENT_ONCE WOLFSSL_VERIFY_CLIENT_ONCE
#define SSL_VERIFY_FAIL_EXCEPT_PSK WOLFSSL_VERIFY_FAIL_EXCEPT_PSK
#define SSL_SESS_CACHE_OFF WOLF_SSL_SESS_CACHE_OFF
#define SSL_SESS_CACHE_CLIENT WOLF_SSL_SESS_CACHE_CLIENT
#define SSL_SESS_CACHE_SERVER WOLF_SSL_SESS_CACHE_SERVER
#define SSL_SESS_CACHE_BOTH WOLF_SSL_SESS_CACHE_BOTH
#define SSL_SESS_CACHE_NO_AUTO_CLEAR WOLF_SSL_SESS_CACHE_NO_AUTO_CLEAR
#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP WOLF_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP
#define SSL_SESS_CACHE_NO_INTERNAL_STORE WOLF_SSL_SESS_CACHE_NO_INTERNAL_STORE
#define SSL_SESS_CACHE_NO_INTERNAL WOLF_SSL_SESS_CACHE_NO_INTERNAL
#define SSL_SESS_CACHE_OFF WOLFSSL_SESS_CACHE_OFF
#define SSL_SESS_CACHE_CLIENT WOLFSSL_SESS_CACHE_CLIENT
#define SSL_SESS_CACHE_SERVER WOLFSSL_SESS_CACHE_SERVER
#define SSL_SESS_CACHE_BOTH WOLFSSL_SESS_CACHE_BOTH
#define SSL_SESS_CACHE_NO_AUTO_CLEAR WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR
#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP
#define SSL_SESS_CACHE_NO_INTERNAL_STORE WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE
#define SSL_SESS_CACHE_NO_INTERNAL WOLFSSL_SESS_CACHE_NO_INTERNAL
#define SSL_ERROR_WANT_READ WOLF_SSL_ERROR_WANT_READ
#define SSL_ERROR_WANT_WRITE WOLF_SSL_ERROR_WANT_WRITE
#define SSL_ERROR_WANT_CONNECT WOLF_SSL_ERROR_WANT_CONNECT
#define SSL_ERROR_WANT_ACCEPT WOLF_SSL_ERROR_WANT_ACCEPT
#define SSL_ERROR_SYSCALL WOLF_SSL_ERROR_SYSCALL
#define SSL_ERROR_WANT_X509_LOOKUP WOLF_SSL_ERROR_WANT_X509_LOOKUP
#define SSL_ERROR_ZERO_RETURN WOLF_SSL_ERROR_ZERO_RETURN
#define SSL_ERROR_SSL WOLF_SSL_ERROR_SSL
#define SSL_ERROR_WANT_READ WOLFSSL_ERROR_WANT_READ
#define SSL_ERROR_WANT_WRITE WOLFSSL_ERROR_WANT_WRITE
#define SSL_ERROR_WANT_CONNECT WOLFSSL_ERROR_WANT_CONNECT
#define SSL_ERROR_WANT_ACCEPT WOLFSSL_ERROR_WANT_ACCEPT
#define SSL_ERROR_SYSCALL WOLFSSL_ERROR_SYSCALL
#define SSL_ERROR_WANT_X509_LOOKUP WOLFSSL_ERROR_WANT_X509_LOOKUP
#define SSL_ERROR_ZERO_RETURN WOLFSSL_ERROR_ZERO_RETURN
#define SSL_ERROR_SSL WOLFSSL_ERROR_SSL
#define SSL_SENT_SHUTDOWN WOLF_SSL_SENT_SHUTDOWN
#define SSL_RECEIVED_SHUTDOWN WOLF_SSL_RECEIVED_SHUTDOWN
#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER WOLF_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
#define SSL_OP_NO_SSLv2 WOLF_SSL_OP_NO_SSLv2
#define SSL_SENT_SHUTDOWN WOLFSSL_SENT_SHUTDOWN
#define SSL_RECEIVED_SHUTDOWN WOLFSSL_RECEIVED_SHUTDOWN
#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER WOLFSSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
#define SSL_OP_NO_SSLv2 WOLFSSL_OP_NO_SSLv2
#define SSL_R_SSL_HANDSHAKE_FAILURE WOLF_SSL_R_SSL_HANDSHAKE_FAILURE
#define SSL_R_TLSV1_ALERT_UNKNOWN_CA WOLF_SSL_R_TLSV1_ALERT_UNKNOWN_CA
#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN WOLF_SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN
#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE WOLF_SSL_R_SSLV3_ALERT_BAD_CERTIFICATE
#define SSL_R_SSL_HANDSHAKE_FAILURE WOLFSSL_R_SSL_HANDSHAKE_FAILURE
#define SSL_R_TLSV1_ALERT_UNKNOWN_CA WOLFSSL_R_TLSV1_ALERT_UNKNOWN_CA
#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN WOLFSSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN
#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE WOLFSSL_R_SSLV3_ALERT_BAD_CERTIFICATE
#define PEM_BUFSIZE WOLF_PEM_BUFSIZE
#endif
enum { /* ssl Constants */
WOLF_SSL_ERROR_NONE = 0, /* for most functions */
WOLF_SSL_FAILURE = 0, /* for some functions */
WOLF_SSL_SUCCESS = 1,
WOLF_SSL_SHUTDOWN_NOT_DONE = 2, /* call wolfSSL_shutdown again to complete */
WOLFSSL_ERROR_NONE = 0, /* for most functions */
WOLFSSL_FAILURE = 0, /* for some functions */
WOLFSSL_SUCCESS = 1,
WOLFSSL_SHUTDOWN_NOT_DONE = 2, /* call wolfSSL_shutdown again to complete */
WOLF_SSL_ALPN_NOT_FOUND = -9,
WOLF_SSL_BAD_CERTTYPE = -8,
WOLF_SSL_BAD_STAT = -7,
WOLF_SSL_BAD_PATH = -6,
WOLF_SSL_BAD_FILETYPE = -5,
WOLF_SSL_BAD_FILE = -4,
WOLF_SSL_NOT_IMPLEMENTED = -3,
WOLF_SSL_UNKNOWN = -2,
WOLF_SSL_FATAL_ERROR = -1,
WOLFSSL_ALPN_NOT_FOUND = -9,
WOLFSSL_BAD_CERTTYPE = -8,
WOLFSSL_BAD_STAT = -7,
WOLFSSL_BAD_PATH = -6,
WOLFSSL_BAD_FILETYPE = -5,
WOLFSSL_BAD_FILE = -4,
WOLFSSL_NOT_IMPLEMENTED = -3,
WOLFSSL_UNKNOWN = -2,
WOLFSSL_FATAL_ERROR = -1,
WOLF_SSL_FILETYPE_ASN1 = 2,
WOLF_SSL_FILETYPE_PEM = 1,
WOLF_SSL_FILETYPE_DEFAULT = 2, /* ASN1 */
WOLF_SSL_FILETYPE_RAW = 3, /* NTRU raw key blob */
WOLFSSL_FILETYPE_ASN1 = 2,
WOLFSSL_FILETYPE_PEM = 1,
WOLFSSL_FILETYPE_DEFAULT = 2, /* ASN1 */
WOLFSSL_FILETYPE_RAW = 3, /* NTRU raw key blob */
WOLF_SSL_VERIFY_NONE = 0,
WOLF_SSL_VERIFY_PEER = 1,
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT = 2,
WOLF_SSL_VERIFY_CLIENT_ONCE = 4,
WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK = 8,
WOLFSSL_VERIFY_NONE = 0,
WOLFSSL_VERIFY_PEER = 1,
WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT = 2,
WOLFSSL_VERIFY_CLIENT_ONCE = 4,
WOLFSSL_VERIFY_FAIL_EXCEPT_PSK = 8,
WOLF_SSL_SESS_CACHE_OFF = 0x0000,
WOLF_SSL_SESS_CACHE_CLIENT = 0x0001,
WOLF_SSL_SESS_CACHE_SERVER = 0x0002,
WOLF_SSL_SESS_CACHE_BOTH = 0x0003,
WOLF_SSL_SESS_CACHE_NO_AUTO_CLEAR = 0x0008,
WOLF_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP = 0x0100,
WOLF_SSL_SESS_CACHE_NO_INTERNAL_STORE = 0x0200,
WOLF_SSL_SESS_CACHE_NO_INTERNAL = 0x0300,
WOLFSSL_SESS_CACHE_OFF = 0x0000,
WOLFSSL_SESS_CACHE_CLIENT = 0x0001,
WOLFSSL_SESS_CACHE_SERVER = 0x0002,
WOLFSSL_SESS_CACHE_BOTH = 0x0003,
WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR = 0x0008,
WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP = 0x0100,
WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE = 0x0200,
WOLFSSL_SESS_CACHE_NO_INTERNAL = 0x0300,
WOLF_SSL_ERROR_WANT_READ = 2,
WOLF_SSL_ERROR_WANT_WRITE = 3,
WOLF_SSL_ERROR_WANT_CONNECT = 7,
WOLF_SSL_ERROR_WANT_ACCEPT = 8,
WOLF_SSL_ERROR_SYSCALL = 5,
WOLF_SSL_ERROR_WANT_X509_LOOKUP = 83,
WOLF_SSL_ERROR_ZERO_RETURN = 6,
WOLF_SSL_ERROR_SSL = 85,
WOLFSSL_ERROR_WANT_READ = 2,
WOLFSSL_ERROR_WANT_WRITE = 3,
WOLFSSL_ERROR_WANT_CONNECT = 7,
WOLFSSL_ERROR_WANT_ACCEPT = 8,
WOLFSSL_ERROR_SYSCALL = 5,
WOLFSSL_ERROR_WANT_X509_LOOKUP = 83,
WOLFSSL_ERROR_ZERO_RETURN = 6,
WOLFSSL_ERROR_SSL = 85,
WOLF_SSL_SENT_SHUTDOWN = 1,
WOLF_SSL_RECEIVED_SHUTDOWN = 2,
WOLF_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER = 4,
WOLF_SSL_OP_NO_SSLv2 = 8,
WOLFSSL_SENT_SHUTDOWN = 1,
WOLFSSL_RECEIVED_SHUTDOWN = 2,
WOLFSSL_MODE_ACCEPT_MOVING_WRITE_BUFFER = 4,
WOLFSSL_OP_NO_SSLv2 = 8,
WOLF_SSL_R_SSL_HANDSHAKE_FAILURE = 101,
WOLF_SSL_R_TLSV1_ALERT_UNKNOWN_CA = 102,
WOLF_SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN = 103,
WOLF_SSL_R_SSLV3_ALERT_BAD_CERTIFICATE = 104,
WOLFSSL_R_SSL_HANDSHAKE_FAILURE = 101,
WOLFSSL_R_TLSV1_ALERT_UNKNOWN_CA = 102,
WOLFSSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN = 103,
WOLFSSL_R_SSLV3_ALERT_BAD_CERTIFICATE = 104,
WOLF_PEM_BUFSIZE = 1024
};

14
wolfssl/test.h
View File

@@ -498,7 +498,7 @@ static INLINE void ShowX509(WOLFSSL_X509* x509, const char* hdr)
printf(" altname = %s\n", altName);
ret = wolfSSL_X509_get_serial_number(x509, serial, &sz);
if (ret == WOLF_SSL_SUCCESS) {
if (ret == WOLFSSL_SUCCESS) {
int i;
int strLen;
char serialMsg[80];
@@ -1168,7 +1168,7 @@ static INLINE unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
static INLINE void load_buffer(WOLFSSL_CTX* ctx, const char* fname, int type)
{
int format = WOLF_SSL_FILETYPE_PEM;
int format = WOLFSSL_FILETYPE_PEM;
byte* buff = NULL;
size_t sz = 0;
@@ -1179,26 +1179,26 @@ static INLINE unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
/* determine format */
if (strstr(fname, ".der"))
format = WOLF_SSL_FILETYPE_ASN1;
format = WOLFSSL_FILETYPE_ASN1;
if (type == WOLFSSL_CA) {
if (wolfSSL_CTX_load_verify_buffer(ctx, buff, (long)sz, format)
!= WOLF_SSL_SUCCESS)
!= WOLFSSL_SUCCESS)
err_sys("can't load buffer ca file");
}
else if (type == WOLFSSL_CERT) {
if (wolfSSL_CTX_use_certificate_buffer(ctx, buff, (long)sz,
format) != WOLF_SSL_SUCCESS)
format) != WOLFSSL_SUCCESS)
err_sys("can't load buffer cert file");
}
else if (type == WOLFSSL_KEY) {
if (wolfSSL_CTX_use_PrivateKey_buffer(ctx, buff, (long)sz,
format) != WOLF_SSL_SUCCESS)
format) != WOLFSSL_SUCCESS)
err_sys("can't load buffer key file");
}
else if (type == WOLFSSL_CERT_CHAIN) {
if (wolfSSL_CTX_use_certificate_chain_buffer_format(ctx, buff,
(long)sz, format) != WOLF_SSL_SUCCESS)
(long)sz, format) != WOLFSSL_SUCCESS)
err_sys("can't load cert chain buffer");
}