Get rid of SSL_CTX_INTERNAL and SSL_INTERNAL.

These are no longer necessary due to SSL_CTX and SSL now being fully
opaque. Merge SSL_CTX_INTERNAL back into SSL_CTX and SSL_INTERNAL back
into SSL.

Prompted by tb@

1 files changed, 76 insertions, 76 deletions

diff --git a/src/lib/libssl/ssl_pkt.c b/src/lib/libssl/ssl_pkt.c
index d9f5a0d057..8462d03967 100644
--- a/src/lib/libssl/ssl_pkt.c
+++ b/src/lib/libssl/ssl_pkt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_pkt.c,v 1.60 2022/09/11 13:51:25 jsing Exp $ */
+/* $OpenBSD: ssl_pkt.c,v 1.61 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -136,16 +136,16 @@ ssl_force_want_read(SSL *s)
         BIO_clear_retry_flags(bio);
         BIO_set_retry_read(bio);
 
-        s->internal->rwstate = SSL_READING;
+        s->rwstate = SSL_READING;
 }
 
 /*
  * If extend == 0, obtain new n-byte packet; if extend == 1, increase
  * packet by another n bytes.
  * The packet will be in the sub-array of s->s3->rbuf.buf specified
- * by s->internal->packet and s->internal->packet_length.
- * (If s->internal->read_ahead is set, 'max' bytes may be stored in rbuf
- * [plus s->internal->packet_length bytes if extend == 1].)
+ * by s->packet and s->packet_length.
+ * (If s->read_ahead is set, 'max' bytes may be stored in rbuf
+ * [plus s->packet_length bytes if extend == 1].)
  */
 static int
 ssl3_read_n(SSL *s, int n, int max, int extend)
@@ -187,8 +187,8 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
                                 rb->offset = align;
                         }
                 }
-                s->internal->packet = rb->buf + rb->offset;
-                s->internal->packet_length = 0;
+                s->packet = rb->buf + rb->offset;
+                s->packet_length = 0;
                 /* ... now we can act as if 'extend' was set */
         }
 
@@ -202,7 +202,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
         /* if there is enough in the buffer from a previous read, take some */
         if (left >= n) {
-                s->internal->packet_length += n;
+                s->packet_length += n;
                 rb->left = left - n;
                 rb->offset += n;
                 return (n);
@@ -210,15 +210,15 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
         /* else we need to read more data */
 
-        len = s->internal->packet_length;
+        len = s->packet_length;
         pkt = rb->buf + align;
         /* Move any available bytes to front of buffer:
          * 'len' bytes already pointed to by 'packet',
          * 'left' extra ones at the end */
-        if (s->internal->packet != pkt)  {
+        if (s->packet != pkt)  {
                 /* len > 0 */
-                memmove(pkt, s->internal->packet, len + left);
-                s->internal->packet = pkt;
+                memmove(pkt, s->packet, len + left);
+                s->packet = pkt;
                 rb->offset = len + align;
         }
 
@@ -228,7 +228,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
                 return -1;
         }
 
-        if (s->internal->read_ahead || SSL_is_dtls(s)) {
+        if (s->read_ahead || SSL_is_dtls(s)) {
                 if (max < n)
                         max = n;
                 if (max > (int)(rb->len - rb->offset))
@@ -245,7 +245,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
                 errno = 0;
                 if (s->rbio != NULL) {
-                        s->internal->rwstate = SSL_READING;
+                        s->rwstate = SSL_READING;
                         i = BIO_read(s->rbio, pkt + len + left, max - left);
                 } else {
                         SSLerror(s, SSL_R_READ_BIO_NOT_SET);
@@ -254,7 +254,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
                 if (i <= 0) {
                         rb->left = left;
-                        if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                        if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                             !SSL_is_dtls(s)) {
                                 if (len + left == 0)
                                         ssl3_release_read_buffer(s);
@@ -277,8 +277,8 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
         /* done reading, now the book-keeping */
         rb->offset += n;
         rb->left = left - n;
-        s->internal->packet_length += n;
-        s->internal->rwstate = SSL_NOTHING;
+        s->packet_length += n;
+        s->rwstate = SSL_NOTHING;
 
         return (n);
 }
@@ -291,8 +291,8 @@ ssl3_packet_read(SSL *s, int plen)
         n = ssl3_read_n(s, plen, s->s3->rbuf.len, 0);
         if (n <= 0)
                 return n;
-        if (s->internal->packet_length < plen)
-                return s->internal->packet_length;
+        if (s->packet_length < plen)
+                return s->packet_length;
 
         return plen;
 }
@@ -302,15 +302,15 @@ ssl3_packet_extend(SSL *s, int plen)
 {
         int rlen, n;
 
-        if (s->internal->packet_length >= plen)
+        if (s->packet_length >= plen)
                 return plen;
-        rlen = plen - s->internal->packet_length;
+        rlen = plen - s->packet_length;
 
         n = ssl3_read_n(s, rlen, rlen, 1);
         if (n <= 0)
                 return n;
-        if (s->internal->packet_length < plen)
-                return s->internal->packet_length;
+        if (s->packet_length < plen)
+                return s->packet_length;
 
         return plen;
 }
@@ -319,9 +319,9 @@ ssl3_packet_extend(SSL *s, int plen)
  * It will return <= 0 if more data is needed, normally due to an error
  * or non-blocking IO.
  * When it finishes, one packet has been decoded and can be found in
- * ssl->s3->internal->rrec.type    - is the type of record
- * ssl->s3->internal->rrec.data,         - data
- * ssl->s3->internal->rrec.length, - number of bytes
+ * ssl->s3->rrec.type    - is the type of record
+ * ssl->s3->rrec.data,   - data
+ * ssl->s3->rrec.length, - number of bytes
  */
 /* used only by ssl3_read_bytes */
 static int
@@ -337,8 +337,8 @@ ssl3_get_record(SSL *s)
 
  again:
         /* check if we have the header */
-        if ((s->internal->rstate != SSL_ST_READ_BODY) ||
-            (s->internal->packet_length < SSL3_RT_HEADER_LENGTH)) {
+        if ((s->rstate != SSL_ST_READ_BODY) ||
+            (s->packet_length < SSL3_RT_HEADER_LENGTH)) {
                 CBS header;
                 uint16_t len, ssl_version;
                 uint8_t type;
@@ -347,16 +347,16 @@ ssl3_get_record(SSL *s)
                 if (n <= 0)
                         return (n);
 
-                s->internal->mac_packet = 1;
-                s->internal->rstate = SSL_ST_READ_BODY;
+                s->mac_packet = 1;
+                s->rstate = SSL_ST_READ_BODY;
 
-                if (s->server && s->internal->first_packet) {
+                if (s->server && s->first_packet) {
                         if ((ret = ssl_server_legacy_first_packet(s)) != 1)
                                 return (ret);
                         ret = -1;
                 }
 
-                CBS_init(&header, s->internal->packet, SSL3_RT_HEADER_LENGTH);
+                CBS_init(&header, s->packet, SSL3_RT_HEADER_LENGTH);
 
                 /* Pull apart the header into the SSL3_RECORD_INTERNAL */
                 if (!CBS_get_u8(&header, &type) ||
@@ -370,9 +370,9 @@ ssl3_get_record(SSL *s)
                 rr->length = len;
 
                 /* Lets check version */
-                if (!s->internal->first_packet && ssl_version != s->version) {
+                if (!s->first_packet && ssl_version != s->version) {
                         if ((s->version & 0xFF00) == (ssl_version & 0xFF00) &&
-                            !tls12_record_layer_write_protected(s->internal->rl)) {
+                            !tls12_record_layer_write_protected(s->rl)) {
                                 /* Send back error using their minor version number :-) */
                                 s->version = ssl_version;
                         }
@@ -399,17 +399,17 @@ ssl3_get_record(SSL *s)
         if (n != SSL3_RT_HEADER_LENGTH + rr->length)
                 return (n);
 
-        s->internal->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
+        s->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
 
         /*
          * A full record has now been read from the wire, which now needs
          * to be processed.
          */
-        tls12_record_layer_set_version(s->internal->rl, s->version);
+        tls12_record_layer_set_version(s->rl, s->version);
 
-        if (!tls12_record_layer_open_record(s->internal->rl, s->internal->packet,
-            s->internal->packet_length, &out, &out_len)) {
-                tls12_record_layer_alert(s->internal->rl, &alert_desc);
+        if (!tls12_record_layer_open_record(s->rl, s->packet,
+            s->packet_length, &out, &out_len)) {
+                tls12_record_layer_alert(s->rl, &alert_desc);
 
                 if (alert_desc == 0)
                         goto err;
@@ -428,7 +428,7 @@ ssl3_get_record(SSL *s)
         rr->off = 0;
 
         /* we have pulled in a full packet so zero things */
-        s->internal->packet_length = 0;
+        s->packet_length = 0;
 
         if (rr->length == 0) {
                 /*
@@ -446,18 +446,18 @@ ssl3_get_record(SSL *s)
                  * insert a single empty record, so we allow ourselves to read
                  * once past a single empty record without forcing want_read.
                  */
-                if (s->internal->empty_record_count++ > SSL_MAX_EMPTY_RECORDS) {
+                if (s->empty_record_count++ > SSL_MAX_EMPTY_RECORDS) {
                         SSLerror(s, SSL_R_PEER_BEHAVING_BADLY);
                         return -1;
                 }
-                if (s->internal->empty_record_count > 1) {
+                if (s->empty_record_count > 1) {
                         ssl_force_want_read(s);
                         return -1;
                 }
                 goto again;
         }
 
-        s->internal->empty_record_count = 0;
+        s->empty_record_count = 0;
 
         return (1);
 
@@ -482,12 +482,12 @@ ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
                 return -1;
         }
 
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
         tot = s->s3->wnum;
         s->s3->wnum = 0;
 
-        if (SSL_in_init(s) && !s->internal->in_handshake) {
-                i = s->internal->handshake_func(s);
+        if (SSL_in_init(s) && !s->in_handshake) {
+                i = s->handshake_func(s);
                 if (i < 0)
                         return (i);
                 if (i == 0) {
@@ -512,7 +512,7 @@ ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
                 }
 
                 if ((i == (int)n) || (type == SSL3_RT_APPLICATION_DATA &&
-                    (s->internal->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
+                    (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
                         /*
                          * Next chunk of data should get another prepended
                          * empty fragment in ciphersuites with known-IV
@@ -573,7 +573,7 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
          */
         version = s->version;
         if (s->s3->hs.state == SSL3_ST_CW_CLNT_HELLO_B &&
-            !s->internal->renegotiate &&
+            !s->renegotiate &&
             s->s3->hs.our_max_tls_version > TLS1_VERSION)
                 version = TLS1_VERSION;
 
@@ -582,7 +582,7 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
          * (see http://www.openssl.org/~bodo/tls-cbc.txt). Note that this
          * is unnecessary for AEAD.
          */
-        if (sess != NULL && tls12_record_layer_write_protected(s->internal->rl)) {
+        if (sess != NULL && tls12_record_layer_write_protected(s->rl)) {
                 if (s->s3->need_empty_fragments &&
                     !s->s3->empty_fragment_done &&
                     type == SSL3_RT_APPLICATION_DATA)
@@ -603,16 +603,16 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
         if (!CBB_init_fixed(&cbb, wb->buf + align, wb->len - align))
                 goto err;
 
-        tls12_record_layer_set_version(s->internal->rl, version);
+        tls12_record_layer_set_version(s->rl, version);
 
         if (need_empty_fragment) {
-                if (!tls12_record_layer_seal_record(s->internal->rl, type,
+                if (!tls12_record_layer_seal_record(s->rl, type,
                     buf, 0, &cbb))
                         goto err;
                 s->s3->empty_fragment_done = 1;
         }
 
-        if (!tls12_record_layer_seal_record(s->internal->rl, type, buf, len, &cbb))
+        if (!tls12_record_layer_seal_record(s->rl, type, buf, len, &cbb))
                 goto err;
 
         if (!CBB_finish(&cbb, NULL, &out_len))
@@ -647,7 +647,7 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
 
         /* XXXX */
         if ((s->s3->wpend_tot > (int)len) || ((s->s3->wpend_buf != buf) &&
-            !(s->internal->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
+            !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
             (s->s3->wpend_type != type)) {
                 SSLerror(s, SSL_R_BAD_WRITE_RETRY);
                 return (-1);
@@ -656,7 +656,7 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
         for (;;) {
                 errno = 0;
                 if (s->wbio != NULL) {
-                        s->internal->rwstate = SSL_WRITING;
+                        s->rwstate = SSL_WRITING;
                         i = BIO_write(s->wbio, (char *)&(wb->buf[wb->offset]),
                             (unsigned int)wb->left);
                 } else {
@@ -666,10 +666,10 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
                 if (i == wb->left) {
                         wb->left = 0;
                         wb->offset += i;
-                        if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                        if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                             !SSL_is_dtls(s))
                                 ssl3_release_write_buffer(s);
-                        s->internal->rwstate = SSL_NOTHING;
+                        s->rwstate = SSL_NOTHING;
                         return (s->s3->wpend_ret);
                 } else if (i <= 0) {
                         /*
@@ -731,7 +731,7 @@ ssl3_read_alert(SSL *s)
         if (alert_level == SSL3_AL_WARNING) {
                 s->s3->warn_alert = alert_descr;
                 if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
-                        s->internal->shutdown |= SSL_RECEIVED_SHUTDOWN;
+                        s->shutdown |= SSL_RECEIVED_SHUTDOWN;
                         return 0;
                 }
                 /* We requested renegotiation and the peer rejected it. */
@@ -742,11 +742,11 @@ ssl3_read_alert(SSL *s)
                         return -1;
                 }
         } else if (alert_level == SSL3_AL_FATAL) {
-                s->internal->rwstate = SSL_NOTHING;
+                s->rwstate = SSL_NOTHING;
                 s->s3->fatal_alert = alert_descr;
                 SSLerror(s, SSL_AD_REASON_OFFSET + alert_descr);
                 ERR_asprintf_error_data("SSL alert number %d", alert_descr);
-                s->internal->shutdown |= SSL_RECEIVED_SHUTDOWN;
+                s->shutdown |= SSL_RECEIVED_SHUTDOWN;
                 SSL_CTX_remove_session(s->ctx, s->session);
                 return 0;
         } else {
@@ -847,7 +847,7 @@ ssl3_read_handshake_unexpected(SSL *s)
         if (s->s3->handshake_fragment_len < sizeof(s->s3->handshake_fragment))
                 return 1;
 
-        if (s->internal->in_handshake) {
+        if (s->in_handshake) {
                 SSLerror(s, ERR_R_INTERNAL_ERROR);
                 return -1;
         }
@@ -937,7 +937,7 @@ ssl3_read_handshake_unexpected(SSL *s)
                         return -1;
                 }
 
-                if ((s->internal->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
+                if ((s->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_NO_RENEGOTIATION);
                         return -1;
@@ -957,8 +957,8 @@ ssl3_read_handshake_unexpected(SSL *s)
                 }
 
                 s->s3->hs.state = SSL_ST_ACCEPT;
-                s->internal->renegotiate = 1;
-                s->internal->new_session = 1;
+                s->renegotiate = 1;
+                s->new_session = 1;
 
         } else {
                 SSLerror(s, SSL_R_UNEXPECTED_MESSAGE);
@@ -966,14 +966,14 @@ ssl3_read_handshake_unexpected(SSL *s)
                 return -1;
         }
 
-        if ((ret = s->internal->handshake_func(s)) < 0)
+        if ((ret = s->handshake_func(s)) < 0)
                 return ret;
         if (ret == 0) {
                 SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
                 return -1;
         }
 
-        if (!(s->internal->mode & SSL_MODE_AUTO_RETRY)) {
+        if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
                 if (s->s3->rbuf.left == 0) {
                         ssl_force_want_read(s);
                         return -1;
@@ -1062,8 +1062,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return n;
         }
 
-        if (SSL_in_init(s) && !s->internal->in_handshake) {
-                if ((ret = s->internal->handshake_func(s)) < 0)
+        if (SSL_in_init(s) && !s->in_handshake) {
+                if ((ret = s->handshake_func(s)) < 0)
                         return ret;
                 if (ret == 0) {
                         SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
@@ -1085,11 +1085,11 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return -1;
         }
 
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
 
         rr = &s->s3->rrec;
 
-        if (rr->length == 0 || s->internal->rstate == SSL_ST_READ_BODY) {
+        if (rr->length == 0 || s->rstate == SSL_ST_READ_BODY) {
                 if ((ret = ssl3_get_record(s)) <= 0)
                         return ret;
         }
@@ -1106,8 +1106,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
          * If the other end has shut down, throw anything we read away (even in
          * 'peek' mode).
          */
-        if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return 0;
         }
@@ -1119,7 +1119,7 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                  * are doing a handshake for the first time.
                  */
                 if (SSL_in_init(s) && type == SSL3_RT_APPLICATION_DATA &&
-                    !tls12_record_layer_read_protected(s->internal->rl)) {
+                    !tls12_record_layer_read_protected(s->rl)) {
                         SSLerror(s, SSL_R_APP_DATA_IN_HANDSHAKE);
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_UNEXPECTED_MESSAGE);
@@ -1140,9 +1140,9 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                         rr->length -= n;
                         rr->off += n;
                         if (rr->length == 0) {
-                                s->internal->rstate = SSL_ST_READ_HEADER;
+                                s->rstate = SSL_ST_READ_HEADER;
                                 rr->off = 0;
-                                if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                                if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                                     s->s3->rbuf.left == 0)
                                         ssl3_release_read_buffer(s);
                         }
@@ -1162,8 +1162,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 goto start;
         }
 
-        if (s->internal->shutdown & SSL_SENT_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_SENT_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return 0;
         }