ssl: work on anything implementing the socket protocol

In principle this allows core SSL code to be used with e.g., wiznet
or airlift sockets. It might actually be useful with wiznet ethernet devices
(it's probably not with airlift)

Author: jepler

shared-bindings/ssl/SSLContext.c

@@ -200,9 +200,9 @@ STATIC mp_obj_t ssl_sslcontext_wrap_socket(size_t n_args, const mp_obj_t *pos_ar
         mp_raise_ValueError(MP_ERROR_TEXT("Server side context cannot have hostname"));
     }
 
-    socketpool_socket_obj_t *sock = args[ARG_sock].u_obj;
+    mp_obj_t sock_obj = args[ARG_sock].u_obj;
 
-    return common_hal_ssl_sslcontext_wrap_socket(self, sock, server_side, server_hostname);
+    return common_hal_ssl_sslcontext_wrap_socket(self, sock_obj, server_side, server_hostname);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(ssl_sslcontext_wrap_socket_obj, 1, ssl_sslcontext_wrap_socket);
 

shared-bindings/ssl/SSLContext.h

@@ -33,15 +33,14 @@
 #include "common-hal/ssl/SSLContext.h"
 #endif
 
-#include "shared-bindings/socketpool/Socket.h"
 #include "shared-bindings/ssl/SSLSocket.h"
 
 extern const mp_obj_type_t ssl_sslcontext_type;
 
 void common_hal_ssl_sslcontext_construct(ssl_sslcontext_obj_t *self);
 
 ssl_sslsocket_obj_t *common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t *self,
-    socketpool_socket_obj_t *sock, bool server_side, const char *server_hostname);
+    mp_obj_t socket, bool server_side, const char *server_hostname);
 
 void common_hal_ssl_sslcontext_load_verify_locations(ssl_sslcontext_obj_t *self,
     const char *cadata);

shared-bindings/ssl/SSLSocket.c

@@ -73,15 +73,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ssl_sslsocket___exit___obj, 4, 4, ssl
 //|         Returns a tuple of (new_socket, remote_address)"""
 STATIC mp_obj_t ssl_sslsocket_accept(mp_obj_t self_in) {
     ssl_sslsocket_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    uint8_t ip[4];
-    uint32_t port;
-
-    ssl_sslsocket_obj_t *sslsock = common_hal_ssl_sslsocket_accept(self, ip, &port);
-
-    mp_obj_t tuple_contents[2];
-    tuple_contents[0] = MP_OBJ_FROM_PTR(sslsock);
-    tuple_contents[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
-    return mp_obj_new_tuple(2, tuple_contents);
+    return common_hal_ssl_sslsocket_accept(self);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(ssl_sslsocket_accept_obj, ssl_sslsocket_accept);
 
@@ -96,14 +88,7 @@ STATIC mp_obj_t ssl_sslsocket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
     mp_obj_t *addr_items;
     mp_obj_get_array_fixed_n(addr_in, 2, &addr_items);
 
-    size_t hostlen;
-    const char *host = mp_obj_str_get_data(addr_items[0], &hostlen);
-    mp_int_t port = mp_obj_get_int(addr_items[1]);
-    if (port < 0) {
-        mp_raise_ValueError(MP_ERROR_TEXT("port must be >= 0"));
-    }
-
-    size_t error = common_hal_ssl_sslsocket_bind(self, host, hostlen, (uint32_t)port);
+    size_t error = common_hal_ssl_sslsocket_bind(self, addr_in);
     if (error != 0) {
         mp_raise_OSError(error);
     }
@@ -128,18 +113,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(ssl_sslsocket_close_obj, ssl_sslsocket_close);
 //|         ...
 STATIC mp_obj_t ssl_sslsocket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
     ssl_sslsocket_obj_t *self = MP_OBJ_TO_PTR(self_in);
-
-    mp_obj_t *addr_items;
-    mp_obj_get_array_fixed_n(addr_in, 2, &addr_items);
-
-    size_t hostlen;
-    const char *host = mp_obj_str_get_data(addr_items[0], &hostlen);
-    mp_int_t port = mp_obj_get_int(addr_items[1]);
-    if (port < 0) {
-        mp_raise_ValueError(MP_ERROR_TEXT("port must be >= 0"));
-    }
-
-    common_hal_ssl_sslsocket_connect(self, host, hostlen, (uint32_t)port);
+    common_hal_ssl_sslsocket_connect(self, addr_in);
 
     return mp_const_none;
 }

shared-bindings/ssl/SSLSocket.h

@@ -34,10 +34,10 @@
 
 extern const mp_obj_type_t ssl_sslsocket_type;
 
-ssl_sslsocket_obj_t *common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t *self, uint8_t *ip, uint32_t *port);
-size_t common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t *self, const char *host, size_t hostlen, uint32_t port);
+mp_obj_t common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t *self);
+size_t common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t *self, mp_obj_t addr);
 void common_hal_ssl_sslsocket_close(ssl_sslsocket_obj_t *self);
-void common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t *self, const char *host, size_t hostlen, uint32_t port);
+void common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t *self, mp_obj_t addr);
 bool common_hal_ssl_sslsocket_get_closed(ssl_sslsocket_obj_t *self);
 bool common_hal_ssl_sslsocket_get_connected(ssl_sslsocket_obj_t *self);
 bool common_hal_ssl_sslsocket_listen(ssl_sslsocket_obj_t *self, int backlog);

shared-module/ssl/SSLContext.c

@@ -26,7 +26,6 @@
 
 #include "shared-bindings/ssl/SSLContext.h"
 #include "shared-bindings/ssl/SSLSocket.h"
-#include "shared-bindings/socketpool/SocketPool.h"
 
 #include "py/runtime.h"
 #include "py/stream.h"

shared-module/ssl/SSLSocket.c

@@ -27,12 +27,10 @@
  */
 
 #include "shared-bindings/ssl/SSLSocket.h"
-#include "shared-bindings/socketpool/Socket.h"
 #include "shared-bindings/ssl/SSLContext.h"
-#include "shared-bindings/socketpool/SocketPool.h"
-#include "shared-bindings/socketpool/Socket.h"
 
 #include "shared/runtime/interrupt_char.h"
+#include "shared/netutils/netutils.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
 #include "py/objstr.h"
@@ -108,11 +106,72 @@ STATIC NORETURN void mbedtls_raise_error(int err) {
     #endif
 }
 
+STATIC int call_method_errno(size_t n_args, const mp_obj_t *args) {
+    nlr_buf_t nlr;
+    mp_int_t result = -MP_EINVAL;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t obj_result = mp_call_method_n_kw(n_args, 0, args);
+        result = (obj_result == mp_const_none) ? 0 : mp_obj_get_int(obj_result);
+        nlr_pop();
+        return result;
+    } else {
+        mp_obj_t exc = MP_OBJ_FROM_PTR(nlr.ret_val);
+        if (nlr_push(&nlr) == 0) {
+            result = -mp_obj_get_int(mp_load_attr(exc, MP_QSTR_errno));
+            nlr_pop();
+        }
+    }
+    return result;
+}
+
+static int ssl_socket_send(ssl_sslsocket_obj_t *self, const byte *buf, size_t len) {
+    mp_obj_array_t mv;
+    mp_obj_memoryview_init(&mv, 'B', 0, len, (void *)buf);
+
+    self->send_args[2] = MP_OBJ_FROM_PTR(&mv);
+    return call_method_errno(1, self->send_args);
+}
+
+static int ssl_socket_recv_into(ssl_sslsocket_obj_t *self, byte *buf, size_t len) {
+    mp_obj_array_t mv;
+    mp_obj_memoryview_init(&mv, 'B' | MP_OBJ_ARRAY_TYPECODE_FLAG_RW, 0, len, buf);
+
+    self->recv_into_args[2] = MP_OBJ_FROM_PTR(&mv);
+    return call_method_errno(1, self->recv_into_args);
+}
+
+static int ssl_socket_connect(ssl_sslsocket_obj_t *self, mp_obj_t addr_in) {
+    self->connect_args[2] = addr_in;
+    return call_method_errno(1, self->connect_args);
+}
+
+static int ssl_socket_bind(ssl_sslsocket_obj_t *self, mp_obj_t addr_in) {
+    self->bind_args[2] = addr_in;
+    return call_method_errno(1, self->bind_args);
+}
+
+static int ssl_socket_close(ssl_sslsocket_obj_t *self) {
+    return call_method_errno(0, self->close_args);
+}
+
+static int ssl_socket_settimeout(ssl_sslsocket_obj_t *self, mp_int_t timeout_ms) {
+    self->settimeout_args[2] = mp_obj_new_float(timeout_ms * MICROPY_FLOAT_CONST(1e-3));
+    return call_method_errno(1, self->settimeout_args);
+}
+
+static int ssl_socket_listen(ssl_sslsocket_obj_t *self, mp_int_t backlog) {
+    self->listen_args[2] = MP_OBJ_NEW_SMALL_INT(backlog);
+    return call_method_errno(1, self->listen_args);
+}
+
+static mp_obj_t ssl_socket_accept(ssl_sslsocket_obj_t *self) {
+    return mp_call_method_n_kw(0, 0, self->accept_args);
+}
+
 STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
-    mp_obj_t sock = *(mp_obj_t *)ctx;
+    ssl_sslsocket_obj_t *self = (ssl_sslsocket_obj_t *)ctx;
 
-    // mp_uint_t out_sz = sock_stream->write(sock, buf, len, &err);
-    mp_int_t out_sz = socketpool_socket_send(sock, buf, len);
+    mp_int_t out_sz = ssl_socket_send(self, buf, len);
     DEBUG_PRINT("socket_send() -> %d", out_sz);
     if (out_sz < 0) {
         int err = -out_sz;
@@ -128,9 +187,9 @@ STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
 
 // _mbedtls_ssl_recv is called by mbedtls to receive bytes from the underlying socket
 STATIC int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
-    mp_obj_t sock = *(mp_obj_t *)ctx;
+    ssl_sslsocket_obj_t *self = (ssl_sslsocket_obj_t *)ctx;
 
-    mp_int_t out_sz = socketpool_socket_recv_into(sock, buf, len);
+    mp_int_t out_sz = ssl_socket_recv_into(self, buf, len);
     DEBUG_PRINT("socket_recv() -> %d", out_sz);
     if (out_sz < 0) {
         int err = -out_sz;
@@ -155,16 +214,26 @@ static int urandom_adapter(void *unused, unsigned char *buf, size_t n) {
 #endif
 
 ssl_sslsocket_obj_t *common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t *self,
-    socketpool_socket_obj_t *socket, bool server_side, const char *server_hostname) {
+    mp_obj_t socket, bool server_side, const char *server_hostname) {
 
-    if (socket->type != SOCKETPOOL_SOCK_STREAM) {
+    mp_int_t socket_type = mp_obj_get_int(mp_load_attr(socket, MP_QSTR_type));
+    if (socket_type != SOCKETPOOL_SOCK_STREAM) {
         mp_raise_RuntimeError(MP_ERROR_TEXT("Invalid socket for TLS"));
     }
 
     ssl_sslsocket_obj_t *o = m_new_obj_with_finaliser(ssl_sslsocket_obj_t);
     o->base.type = &ssl_sslsocket_type;
     o->ssl_context = self;
-    o->sock = socket;
+    o->sock_obj = socket;
+
+    mp_load_method(socket, MP_QSTR_accept, o->accept_args);
+    mp_load_method(socket, MP_QSTR_bind, o->bind_args);
+    mp_load_method(socket, MP_QSTR_close, o->close_args);
+    mp_load_method(socket, MP_QSTR_connect, o->connect_args);
+    mp_load_method(socket, MP_QSTR_listen, o->listen_args);
+    mp_load_method(socket, MP_QSTR_recv_into, o->recv_into_args);
+    mp_load_method(socket, MP_QSTR_send, o->send_args);
+    mp_load_method(socket, MP_QSTR_settimeout, o->settimeout_args);
 
     mbedtls_ssl_init(&o->ssl);
     mbedtls_ssl_config_init(&o->conf);
@@ -223,7 +292,7 @@ ssl_sslsocket_obj_t *common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t
         }
     }
 
-    mbedtls_ssl_set_bio(&o->ssl, &o->sock, _mbedtls_ssl_send, _mbedtls_ssl_recv, NULL);
+    mbedtls_ssl_set_bio(&o->ssl, o, _mbedtls_ssl_send, _mbedtls_ssl_recv, NULL);
 
     if (self->cert_buf.buf != NULL) {
         #if MBEDTLS_VERSION_MAJOR >= 3
@@ -292,13 +361,13 @@ mp_uint_t common_hal_ssl_sslsocket_send(ssl_sslsocket_obj_t *self, const uint8_t
     mbedtls_raise_error(ret);
 }
 
-size_t common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t *self, const char *host, size_t hostlen, uint32_t port) {
-    return common_hal_socketpool_socket_bind(self->sock, host, hostlen, port);
+size_t common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t *self, mp_obj_t addr_in) {
+    return ssl_socket_bind(self, addr_in);
 }
 
 void common_hal_ssl_sslsocket_close(ssl_sslsocket_obj_t *self) {
     self->closed = true;
-    common_hal_socketpool_socket_close(self->sock);
+    ssl_socket_close(self);
     mbedtls_pk_free(&self->pkey);
     mbedtls_x509_crt_free(&self->cert);
     mbedtls_x509_crt_free(&self->cacert);
@@ -344,8 +413,8 @@ STATIC void do_handshake(ssl_sslsocket_obj_t *self) {
     }
 }
 
-void common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t *self, const char *host, size_t hostlen, uint32_t port) {
-    common_hal_socketpool_socket_connect(self->sock, host, hostlen, port);
+void common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t *self, mp_obj_t addr_in) {
+    ssl_socket_connect(self, addr_in);
     do_handshake(self);
 }
 
@@ -358,16 +427,21 @@ bool common_hal_ssl_sslsocket_get_connected(ssl_sslsocket_obj_t *self) {
 }
 
 bool common_hal_ssl_sslsocket_listen(ssl_sslsocket_obj_t *self, int backlog) {
-    return common_hal_socketpool_socket_listen(self->sock, backlog);
+    return ssl_socket_listen(self, backlog);
 }
 
-ssl_sslsocket_obj_t *common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t *self, uint8_t *ip, uint32_t *port) {
-    socketpool_socket_obj_t *sock = common_hal_socketpool_socket_accept(self->sock, ip, port);
+mp_obj_t common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t *self) {
+    mp_obj_t accepted = ssl_socket_accept(self);
+    mp_obj_t sock = mp_obj_subscr(accepted, MP_OBJ_NEW_SMALL_INT(0), MP_OBJ_SENTINEL);
     ssl_sslsocket_obj_t *sslsock = common_hal_ssl_sslcontext_wrap_socket(self->ssl_context, sock, true, NULL);
     do_handshake(sslsock);
-    return sslsock;
+    mp_obj_t peer = mp_obj_subscr(accepted, MP_OBJ_NEW_SMALL_INT(0), MP_OBJ_SENTINEL);
+    mp_obj_t tuple_contents[2];
+    tuple_contents[0] = MP_OBJ_FROM_PTR(sslsock);
+    tuple_contents[1] = peer;
+    return mp_obj_new_tuple(2, tuple_contents);
 }
 
 void common_hal_ssl_sslsocket_settimeout(ssl_sslsocket_obj_t *self, uint32_t timeout_ms) {
-    common_hal_socketpool_socket_settimeout(self->sock, timeout_ms);
+    ssl_socket_settimeout(self, timeout_ms);
 }

shared-module/ssl/SSLSocket.h

@@ -30,7 +30,6 @@
 #include "py/obj.h"
 
 #include "shared-module/ssl/SSLContext.h"
-#include "common-hal/socketpool/Socket.h"
 
 #include "mbedtls/platform.h"
 #include "mbedtls/ssl.h"
@@ -41,7 +40,7 @@
 
 typedef struct ssl_sslsocket_obj {
     mp_obj_base_t base;
-    socketpool_socket_obj_t *sock;
+    mp_obj_t sock_obj;
     ssl_sslcontext_obj_t *ssl_context;
     mbedtls_entropy_context entropy;
     mbedtls_ctr_drbg_context ctr_drbg;
@@ -51,4 +50,12 @@ typedef struct ssl_sslsocket_obj {
     mbedtls_x509_crt cert;
     mbedtls_pk_context pkey;
     bool closed;
+    mp_obj_t accept_args[2];
+    mp_obj_t bind_args[3];
+    mp_obj_t close_args[2];
+    mp_obj_t connect_args[3];
+    mp_obj_t listen_args[3];
+    mp_obj_t recv_into_args[3];
+    mp_obj_t send_args[3];
+    mp_obj_t settimeout_args[3];
 } ssl_sslsocket_obj_t;