Rename SSL_CTX_set_early_cb to SSL_CTX_set_client_hello_cb.

[openssl.git] / test / handshake_helper.c

diff --git a/test/handshake_helper.c b/test/handshake_helper.c
index 67facdc88c7346842f63054cdf959d29863b9bb2..5e5c311cf35c5e45aaeb64e7b542cd234e7decff 100644 (file)
--- a/test/handshake_helper.c
+++ b/test/handshake_helper.c
@@ -16,11 +16,8 @@
 #include <openssl/srp.h>
 #endif
 
 #include <openssl/srp.h>
 #endif
 

-#ifndef OPENSSL_NO_SOCK
-# define USE_SOCKETS
-# include "e_os.h"
-#endif
-
+#include "internal/sockets.h"
+#include "internal/nelem.h"

 #include "handshake_helper.h"
 #include "testutil.h"
 
 #include "handshake_helper.h"
 #include "testutil.h"
 


@@ -140,7 +137,7 @@ static int select_server_ctx(SSL *s, void *arg, int ignore)
     }
 }
 
     }
 }
 

-static int early_select_server_ctx(SSL *s, void *arg, int ignore)
+static int client_hello_select_server_ctx(SSL *s, void *arg, int ignore)

 {
     const char *servername;
     const unsigned char *p;
 {
     const char *servername;
     const unsigned char *p;


@@ -152,11 +149,12 @@ static int early_select_server_ctx(SSL *s, void *arg, int ignore)
      * The server_name extension was given too much extensibility when it
      * was written, so parsing the normal case is a bit complex.
      */
      * The server_name extension was given too much extensibility when it
      * was written, so parsing the normal case is a bit complex.
      */

-    if (!SSL_early_get0_ext(s, TLSEXT_TYPE_server_name, &p, &remaining) ||
+    if (!SSL_client_hello_get0_ext(s, TLSEXT_TYPE_server_name, &p,
+                                   &remaining) ||

         remaining <= 2)
         return 0;
     /* Extract the length of the supplied list of names. */
         remaining <= 2)
         return 0;
     /* Extract the length of the supplied list of names. */

-    len = (*(p++) << 1);
+    len = (*(p++) << 8);

     len += *(p++);
     if (len + 2 != remaining)
         return 0;
     len += *(p++);
     if (len + 2 != remaining)
         return 0;


@@ -171,7 +169,7 @@ static int early_select_server_ctx(SSL *s, void *arg, int ignore)
     /* Now we can finally pull out the byte array with the actual hostname. */
     if (remaining <= 2)
         return 0;
     /* Now we can finally pull out the byte array with the actual hostname. */
     if (remaining <= 2)
         return 0;

-    len = (*(p++) << 1);
+    len = (*(p++) << 8);

     len += *(p++);
     if (len + 2 > remaining)
         return 0;
     len += *(p++);
     if (len + 2 > remaining)
         return 0;


@@ -222,44 +220,44 @@ static int servername_reject_cb(SSL *s, int *ad, void *arg)
     return select_server_ctx(s, arg, 0);
 }
 
     return select_server_ctx(s, arg, 0);
 }
 

-static int early_ignore_cb(SSL *s, int *al, void *arg)
+static int client_hello_ignore_cb(SSL *s, int *al, void *arg)

 {
 {

-    if (!early_select_server_ctx(s, arg, 1)) {
+    if (!client_hello_select_server_ctx(s, arg, 1)) {

         *al = SSL_AD_UNRECOGNIZED_NAME;
         return 0;
     }
     return 1;
 }
 
         *al = SSL_AD_UNRECOGNIZED_NAME;
         return 0;
     }
     return 1;
 }
 

-static int early_reject_cb(SSL *s, int *al, void *arg)
+static int client_hello_reject_cb(SSL *s, int *al, void *arg)

 {
 {

-    if (!early_select_server_ctx(s, arg, 0)) {
+    if (!client_hello_select_server_ctx(s, arg, 0)) {

         *al = SSL_AD_UNRECOGNIZED_NAME;
         return 0;
     }
     return 1;
 }
 
         *al = SSL_AD_UNRECOGNIZED_NAME;
         return 0;
     }
     return 1;
 }
 

-static int early_nov12_cb(SSL *s, int *al, void *arg)
+static int client_hello_nov12_cb(SSL *s, int *al, void *arg)

 {
     int ret;
     unsigned int v;
     const unsigned char *p;
 
 {
     int ret;
     unsigned int v;
     const unsigned char *p;
 

-    v = SSL_early_get0_legacy_version(s);
+    v = SSL_client_hello_get0_legacy_version(s);

     if (v > TLS1_2_VERSION || v < SSL3_VERSION) {
         *al = SSL_AD_PROTOCOL_VERSION;
         return 0;
     }
     if (v > TLS1_2_VERSION || v < SSL3_VERSION) {
         *al = SSL_AD_PROTOCOL_VERSION;
         return 0;
     }

-    (void)SSL_early_get0_session_id(s, &p);
+    (void)SSL_client_hello_get0_session_id(s, &p);

     if (p == NULL ||
     if (p == NULL ||

-        SSL_early_get0_random(s, &p) == 0 ||
-        SSL_early_get0_ciphers(s, &p) == 0 ||
-        SSL_early_get0_compression_methods(s, &p) == 0) {
+        SSL_client_hello_get0_random(s, &p) == 0 ||
+        SSL_client_hello_get0_ciphers(s, &p) == 0 ||
+        SSL_client_hello_get0_compression_methods(s, &p) == 0) {

         *al = SSL_AD_INTERNAL_ERROR;
         return 0;
     }
         *al = SSL_AD_INTERNAL_ERROR;
         return 0;
     }

-    ret = early_select_server_ctx(s, arg, 0);
+    ret = client_hello_select_server_ctx(s, arg, 0);

     SSL_set_max_proto_version(s, TLS1_1_VERSION);
     if (!ret)
         *al = SSL_AD_UNRECOGNIZED_NAME;
     SSL_set_max_proto_version(s, TLS1_1_VERSION);
     if (!ret)
         *al = SSL_AD_UNRECOGNIZED_NAME;


@@ -492,7 +490,8 @@ static int configure_handshake_ctx(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
 
     /*
      * Link the two contexts for SNI purposes.
 
     /*
      * Link the two contexts for SNI purposes.

-     * Also do early callbacks here, as setting both early and SNI is bad.
+     * Also do ClientHello callbacks here, as setting both ClientHello and SNI
+     * is bad.

      */
     switch (extra->server.servername_callback) {
     case SSL_TEST_SERVERNAME_IGNORE_MISMATCH:
      */
     switch (extra->server.servername_callback) {
     case SSL_TEST_SERVERNAME_IGNORE_MISMATCH:


@@ -505,14 +504,14 @@ static int configure_handshake_ctx(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
         break;
     case SSL_TEST_SERVERNAME_CB_NONE:
         break;
         break;
     case SSL_TEST_SERVERNAME_CB_NONE:
         break;

-    case SSL_TEST_SERVERNAME_EARLY_IGNORE_MISMATCH:
-        SSL_CTX_set_early_cb(server_ctx, early_ignore_cb, server2_ctx);
+    case SSL_TEST_SERVERNAME_CLIENT_HELLO_IGNORE_MISMATCH:
+        SSL_CTX_set_client_hello_cb(server_ctx, client_hello_ignore_cb, server2_ctx);

         break;
         break;

-    case SSL_TEST_SERVERNAME_EARLY_REJECT_MISMATCH:
-        SSL_CTX_set_early_cb(server_ctx, early_reject_cb, server2_ctx);
+    case SSL_TEST_SERVERNAME_CLIENT_HELLO_REJECT_MISMATCH:
+        SSL_CTX_set_client_hello_cb(server_ctx, client_hello_reject_cb, server2_ctx);

         break;
         break;

-    case SSL_TEST_SERVERNAME_EARLY_NO_V12:
-        SSL_CTX_set_early_cb(server_ctx, early_nov12_cb, server2_ctx);
+    case SSL_TEST_SERVERNAME_CLIENT_HELLO_NO_V12:
+        SSL_CTX_set_client_hello_cb(server_ctx, client_hello_nov12_cb, server2_ctx);

     }
 
     if (extra->server.cert_status != SSL_TEST_CERT_STATUS_NONE) {
     }
 
     if (extra->server.cert_status != SSL_TEST_CERT_STATUS_NONE) {


@@ -855,7 +854,7 @@ static void do_reneg_setup_step(const SSL_TEST_CTX *test_ctx, PEER *peer)
         if (!SSL_renegotiate_pending(peer->ssl)) {
             /*
              * If we are the client we will always attempt to resume the
         if (!SSL_renegotiate_pending(peer->ssl)) {
             /*
              * If we are the client we will always attempt to resume the

-             * session. The server may or may not resume dependant on the
+             * session. The server may or may not resume dependent on the

              * setting of SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
              */
             if (SSL_is_server(peer->ssl)) {
              * setting of SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
              */
             if (SSL_is_server(peer->ssl)) {


@@ -1319,6 +1318,8 @@ static HANDSHAKE_RESULT *do_handshake_internal(
     memset(&client_ctx_data, 0, sizeof(client_ctx_data));
     memset(&server, 0, sizeof(server));
     memset(&client, 0, sizeof(client));
     memset(&client_ctx_data, 0, sizeof(client_ctx_data));
     memset(&server, 0, sizeof(server));
     memset(&client, 0, sizeof(client));

+    memset(&server_ex_data, 0, sizeof(server_ex_data));
+    memset(&client_ex_data, 0, sizeof(client_ex_data));

 
     if (!configure_handshake_ctx(server_ctx, server2_ctx, client_ctx,
                                  test_ctx, extra, &server_ctx_data,
 
     if (!configure_handshake_ctx(server_ctx, server2_ctx, client_ctx,
                                  test_ctx, extra, &server_ctx_data,


@@ -1348,9 +1349,6 @@ static HANDSHAKE_RESULT *do_handshake_internal(
             goto err;
     }
 
             goto err;
     }
 

-    memset(&server_ex_data, 0, sizeof(server_ex_data));
-    memset(&client_ex_data, 0, sizeof(client_ex_data));
-

     ret->result = SSL_TEST_INTERNAL_ERROR;
 
     if (test_ctx->use_sctp) {
     ret->result = SSL_TEST_INTERNAL_ERROR;
 
     if (test_ctx->use_sctp) {