From 37282f8fc135a16ff36e2afe0de907cbde531ed0 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 13 Oct 2017 20:01:57 +1100
Subject: extmod/uos_dupterm: Update uos.dupterm() and helper funcs to have
 index.

The uos.dupterm() signature and behaviour is updated to reflect the latest
enhancements in the docs.  It has minor backwards incompatibility in that
it no longer accepts zero arguments.

The dupterm_rx helper function is moved from esp8266 to extmod and
generalised to support multiple dupterm slots.

A port can specify multiple slots by defining the MICROPY_PY_OS_DUPTERM
config macro to an integer, being the number of slots it wants to have;
0 means to disable the dupterm feature altogether.

The unix and esp8266 ports are updated to work with the new interface and
are otherwise unchanged with respect to functionality.
---
 extmod/misc.h        |  3 +-
 extmod/uos_dupterm.c | 96 +++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 74 insertions(+), 25 deletions(-)

(limited to 'extmod')

diff --git a/extmod/misc.h b/extmod/misc.h
index 6c13592c7..d6f6d859c 100644
--- a/extmod/misc.h
+++ b/extmod/misc.h
@@ -35,8 +35,9 @@
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_uos_dupterm_obj);
 
 #if MICROPY_PY_OS_DUPTERM
+int mp_uos_dupterm_rx_chr(void);
 void mp_uos_dupterm_tx_strn(const char *str, size_t len);
-void mp_uos_deactivate(const char *msg, mp_obj_t exc);
+void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc);
 #else
 #define mp_uos_dupterm_tx_strn(s, l)
 #endif
diff --git a/extmod/uos_dupterm.c b/extmod/uos_dupterm.c
index 1d6f02dce..d4326d326 100644
--- a/extmod/uos_dupterm.c
+++ b/extmod/uos_dupterm.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2016 Paul Sokolovsky
+ * Copyright (c) 2017 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -31,12 +32,13 @@
 #include "py/objtuple.h"
 #include "py/objarray.h"
 #include "py/stream.h"
+#include "lib/utils/interrupt_char.h"
 
 #if MICROPY_PY_OS_DUPTERM
 
-void mp_uos_deactivate(const char *msg, mp_obj_t exc) {
-    mp_obj_t term = MP_STATE_PORT(term_obj);
-    MP_STATE_PORT(term_obj) = NULL;
+void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) {
+    mp_obj_t term = MP_STATE_VM(dupterm_objs[dupterm_idx]);
+    MP_STATE_VM(dupterm_objs[dupterm_idx]) = MP_OBJ_NULL;
     mp_printf(&mp_plat_print, msg);
     if (exc != MP_OBJ_NULL) {
         mp_obj_print_exception(&mp_plat_print, exc);
@@ -44,48 +46,94 @@ void mp_uos_deactivate(const char *msg, mp_obj_t exc) {
     mp_stream_close(term);
 }
 
+int mp_uos_dupterm_rx_chr(void) {
+    for (size_t idx = 0; idx < MICROPY_PY_OS_DUPTERM; ++idx) {
+        if (MP_STATE_VM(dupterm_objs[idx]) == MP_OBJ_NULL) {
+            continue;
+        }
+
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_obj_t readinto_m[3];
+            mp_load_method(MP_STATE_VM(dupterm_objs[idx]), MP_QSTR_readinto, readinto_m);
+            readinto_m[2] = MP_STATE_VM(dupterm_arr_obj);
+            mp_obj_t res = mp_call_method_n_kw(1, 0, readinto_m);
+            if (res == mp_const_none) {
+                nlr_pop();
+            } else if (res == MP_OBJ_NEW_SMALL_INT(0)) {
+                mp_uos_deactivate(idx, "dupterm: EOF received, deactivating\n", MP_OBJ_NULL);
+                nlr_pop();
+            } else {
+                mp_buffer_info_t bufinfo;
+                mp_get_buffer_raise(MP_STATE_VM(dupterm_arr_obj), &bufinfo, MP_BUFFER_READ);
+                nlr_pop();
+                if (*(byte*)bufinfo.buf == mp_interrupt_char) {
+                    // Signal keyboard interrupt to be raised as soon as the VM resumes
+                    mp_keyboard_interrupt();
+                    return -2;
+                }
+                return *(byte*)bufinfo.buf;
+            }
+        } else {
+            mp_uos_deactivate(idx, "dupterm: Exception in read() method, deactivating: ", nlr.ret_val);
+        }
+    }
+
+    // No chars available
+    return -1;
+}
+
 void mp_uos_dupterm_tx_strn(const char *str, size_t len) {
-    if (MP_STATE_PORT(term_obj) != MP_OBJ_NULL) {
+    for (size_t idx = 0; idx < MICROPY_PY_OS_DUPTERM; ++idx) {
+        if (MP_STATE_VM(dupterm_objs[idx]) == MP_OBJ_NULL) {
+            continue;
+        }
         nlr_buf_t nlr;
         if (nlr_push(&nlr) == 0) {
             mp_obj_t write_m[3];
-            mp_load_method(MP_STATE_PORT(term_obj), MP_QSTR_write, write_m);
+            mp_load_method(MP_STATE_VM(dupterm_objs[idx]), MP_QSTR_write, write_m);
 
-            mp_obj_array_t *arr = MP_OBJ_TO_PTR(MP_STATE_PORT(dupterm_arr_obj));
+            mp_obj_array_t *arr = MP_OBJ_TO_PTR(MP_STATE_VM(dupterm_arr_obj));
             void *org_items = arr->items;
             arr->items = (void*)str;
             arr->len = len;
-            write_m[2] = MP_STATE_PORT(dupterm_arr_obj);
+            write_m[2] = MP_STATE_VM(dupterm_arr_obj);
             mp_call_method_n_kw(1, 0, write_m);
-            arr = MP_OBJ_TO_PTR(MP_STATE_PORT(dupterm_arr_obj));
+            arr = MP_OBJ_TO_PTR(MP_STATE_VM(dupterm_arr_obj));
             arr->items = org_items;
             arr->len = 1;
             nlr_pop();
         } else {
-            mp_uos_deactivate("dupterm: Exception in write() method, deactivating: ", nlr.ret_val);
+            mp_uos_deactivate(idx, "dupterm: Exception in write() method, deactivating: ", nlr.ret_val);
         }
     }
 }
 
 STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
-    if (n_args == 0) {
-        if (MP_STATE_PORT(term_obj) == MP_OBJ_NULL) {
-            return mp_const_none;
-        } else {
-            return MP_STATE_PORT(term_obj);
-        }
+    mp_int_t idx = 0;
+    if (n_args == 2) {
+        idx = mp_obj_get_int(args[1]);
+    }
+
+    if (idx < 0 || idx >= MICROPY_PY_OS_DUPTERM) {
+        mp_raise_ValueError("invalid dupterm index");
+    }
+
+    mp_obj_t previous_obj = MP_STATE_VM(dupterm_objs[idx]);
+    if (previous_obj == MP_OBJ_NULL) {
+        previous_obj = mp_const_none;
+    }
+    if (args[0] == mp_const_none) {
+        MP_STATE_VM(dupterm_objs[idx]) = MP_OBJ_NULL;
     } else {
-        if (args[0] == mp_const_none) {
-            MP_STATE_PORT(term_obj) = MP_OBJ_NULL;
-        } else {
-            MP_STATE_PORT(term_obj) = args[0];
-            if (MP_STATE_PORT(dupterm_arr_obj) == MP_OBJ_NULL) {
-                MP_STATE_PORT(dupterm_arr_obj) = mp_obj_new_bytearray(1, "");
-            }
+        MP_STATE_VM(dupterm_objs[idx]) = args[0];
+        if (MP_STATE_VM(dupterm_arr_obj) == MP_OBJ_NULL) {
+            MP_STATE_VM(dupterm_arr_obj) = mp_obj_new_bytearray(1, "");
         }
-        return mp_const_none;
     }
+
+    return previous_obj;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_uos_dupterm_obj, 0, 1, mp_uos_dupterm);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_uos_dupterm_obj, 1, 2, mp_uos_dupterm);
 
 #endif
-- 
cgit v1.2.3


From 9725a654bdfc4ec0b7d6bc6aa3f4365f0825c5f3 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 19 Oct 2017 14:10:17 +1100
Subject: extmod/uos_dupterm: Swallow any errors from dupterm closing the
 stream.

Without this the board will crash when deactivating a stream that doesn't
have a close() method (eg UART) or that raises an exception within the
method (eg user-defined function).
---
 extmod/uos_dupterm.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/uos_dupterm.c b/extmod/uos_dupterm.c
index d4326d326..f77cff577 100644
--- a/extmod/uos_dupterm.c
+++ b/extmod/uos_dupterm.c
@@ -43,7 +43,13 @@ void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) {
     if (exc != MP_OBJ_NULL) {
         mp_obj_print_exception(&mp_plat_print, exc);
     }
-    mp_stream_close(term);
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        mp_stream_close(term);
+        nlr_pop();
+    } else {
+        // Ignore any errors during stream closing
+    }
 }
 
 int mp_uos_dupterm_rx_chr(void) {
@@ -61,8 +67,8 @@ int mp_uos_dupterm_rx_chr(void) {
             if (res == mp_const_none) {
                 nlr_pop();
             } else if (res == MP_OBJ_NEW_SMALL_INT(0)) {
-                mp_uos_deactivate(idx, "dupterm: EOF received, deactivating\n", MP_OBJ_NULL);
                 nlr_pop();
+                mp_uos_deactivate(idx, "dupterm: EOF received, deactivating\n", MP_OBJ_NULL);
             } else {
                 mp_buffer_info_t bufinfo;
                 mp_get_buffer_raise(MP_STATE_VM(dupterm_arr_obj), &bufinfo, MP_BUFFER_READ);
-- 
cgit v1.2.3


From f4059dcc0c5251256a53fcb49f56fdda6e879341 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 24 Oct 2017 22:39:36 +1100
Subject: all: Use NULL instead of "" when calling mp_raise exception helpers.

This is the established way of doing it and reduces code size by a little
bit.
---
 extmod/modlwip.c             | 2 +-
 extmod/modussl_axtls.c       | 2 +-
 extmod/modutimeq.c           | 2 +-
 extmod/modwebrepl.c          | 2 +-
 ports/esp8266/machine_hspi.c | 2 +-
 ports/esp8266/machine_wdt.c  | 2 +-
 ports/unix/modjni.c          | 2 +-
 py/objarray.c                | 2 +-
 py/objlist.c                 | 4 ++--
 9 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index f7e776af9..bbb01b5d7 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1032,7 +1032,7 @@ STATIC mp_obj_t lwip_socket_sendall(mp_obj_t self_in, mp_obj_t buf_in) {
             break;
         }
         case MOD_NETWORK_SOCK_DGRAM:
-            mp_raise_NotImplementedError("");
+            mp_raise_NotImplementedError(NULL);
             break;
     }
 
diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 88a89a23d..719a65cd1 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -152,7 +152,7 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
     // Currently supports only blocking mode
     (void)self_in;
     if (!mp_obj_is_true(flag_in)) {
-        mp_raise_NotImplementedError("");
+        mp_raise_NotImplementedError(NULL);
     }
     return mp_const_none;
 }
diff --git a/extmod/modutimeq.c b/extmod/modutimeq.c
index 94cbd20d2..620e7484b 100644
--- a/extmod/modutimeq.c
+++ b/extmod/modutimeq.c
@@ -146,7 +146,7 @@ STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
     }
     mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref);
     if (!MP_OBJ_IS_TYPE(list_ref, &mp_type_list) || ret->len < 3) {
-        mp_raise_TypeError("");
+        mp_raise_TypeError(NULL);
     }
 
     struct qentry *item = &heap->items[0];
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index 4ff282aac..3aba5c0f1 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -308,7 +308,7 @@ STATIC mp_obj_t webrepl_set_password(mp_obj_t passwd_in) {
     size_t len;
     const char *passwd = mp_obj_str_get_data(passwd_in, &len);
     if (len > sizeof(webrepl_passwd) - 1) {
-        mp_raise_ValueError("");
+        mp_raise_ValueError(NULL);
     }
     strcpy(webrepl_passwd, passwd);
     return mp_const_none;
diff --git a/ports/esp8266/machine_hspi.c b/ports/esp8266/machine_hspi.c
index eaabbab7e..9fd0f4868 100644
--- a/ports/esp8266/machine_hspi.c
+++ b/ports/esp8266/machine_hspi.c
@@ -149,7 +149,7 @@ mp_obj_t machine_hspi_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     // args[0] holds the id of the peripheral
     if (args[0] != MP_OBJ_NEW_SMALL_INT(1)) {
         // FlashROM is on SPI0, so far we don't support its usage
-        mp_raise_ValueError("");
+        mp_raise_ValueError(NULL);
     }
 
     machine_hspi_obj_t *self = m_new_obj(machine_hspi_obj_t);
diff --git a/ports/esp8266/machine_wdt.c b/ports/esp8266/machine_wdt.c
index 04b42782e..4432297fa 100644
--- a/ports/esp8266/machine_wdt.c
+++ b/ports/esp8266/machine_wdt.c
@@ -51,7 +51,7 @@ STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args
     case 0:
         return &wdt_default;
     default:
-        mp_raise_ValueError("");
+        mp_raise_ValueError(NULL);
     }
 }
 
diff --git a/ports/unix/modjni.c b/ports/unix/modjni.c
index 15b6d9cd7..f29c095cf 100644
--- a/ports/unix/modjni.c
+++ b/ports/unix/modjni.c
@@ -266,7 +266,7 @@ STATIC mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value)
                 return mp_const_none;
             }
         }
-        mp_raise_NotImplementedError("");
+        mp_raise_NotImplementedError(NULL);
     }
 
     if (!JJ(IsInstanceOf, self->obj, List_class)) {
diff --git a/py/objarray.c b/py/objarray.c
index 8a3e7faad..7003ec9e7 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -286,7 +286,7 @@ STATIC mp_obj_t array_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
 
             // Otherwise, can only look for a scalar numeric value in an array
             if (MP_OBJ_IS_INT(rhs_in) || mp_obj_is_float(rhs_in)) {
-                mp_raise_NotImplementedError("");
+                mp_raise_NotImplementedError(NULL);
             }
 
             return mp_const_false;
diff --git a/py/objlist.c b/py/objlist.c
index bc22d9fc3..1a18f937d 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -158,7 +158,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
-                mp_raise_NotImplementedError("");
+                mp_raise_NotImplementedError(NULL);
             }
 
             mp_int_t len_adj = slice.start - slice.stop;
@@ -198,7 +198,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             mp_obj_get_array(value, &value_len, &value_items);
             mp_bound_slice_t slice_out;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice_out)) {
-                mp_raise_NotImplementedError("");
+                mp_raise_NotImplementedError(NULL);
             }
             mp_int_t len_adj = value_len - (slice_out.stop - slice_out.start);
             //printf("Len adj: %d\n", len_adj);
-- 
cgit v1.2.3


From c64eb4f8ce20b025bb5762d9ce6e093d15a19dce Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 27 Oct 2017 18:01:25 +1100
Subject: extmod/vfs: Replace VLA in proxy func with small, static sized array.

VLAs can be expensive on stack usage due to stack alignment requirements,
and also the fact that extra local variables are needed to track the
dynamic size of the stack.  So using fixed-size arrays when possible can
help to reduce code size and stack usage.

In this particular case, the maximum value of n_args in the VLA is 2 and so
it's more efficient to just allocate this array with a fixed size.  This
reduces code size by around 30 bytes on Thumb2 and Xtensa archs.  It also
reduces total stack usage of the function: on Thumb2 the usage with VLA is
between 40 and 48 bytes, which is reduced to 32; on Xtensa, VLA usage is
between 64 and 80 bytes, reduced to 32; on x86-64 it's at least 88 bytes
reduced to 80.
---
 extmod/vfs.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index a1cd8d5f6..44ad8ffad 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -38,6 +38,10 @@
 #include "extmod/vfs_fat.h"
 #endif
 
+// For mp_vfs_proxy_call, the maximum number of additional args that can be passed.
+// A fixed maximum size is used to avoid the need for a costly variable array.
+#define PROXY_MAX_ARGS (2)
+
 // path is the path to lookup and *path_out holds the path within the VFS
 // object (starts with / if an absolute path).
 // Returns MP_VFS_ROOT for root dir (and then path_out is undefined) and
@@ -97,6 +101,7 @@ STATIC mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
 }
 
 STATIC mp_obj_t mp_vfs_proxy_call(mp_vfs_mount_t *vfs, qstr meth_name, size_t n_args, const mp_obj_t *args) {
+    assert(n_args <= PROXY_MAX_ARGS);
     if (vfs == MP_VFS_NONE) {
         // mount point not found
         mp_raise_OSError(MP_ENODEV);
@@ -105,7 +110,7 @@ STATIC mp_obj_t mp_vfs_proxy_call(mp_vfs_mount_t *vfs, qstr meth_name, size_t n_
         // can't do operation on root dir
         mp_raise_OSError(MP_EPERM);
     }
-    mp_obj_t meth[n_args + 2];
+    mp_obj_t meth[2 + PROXY_MAX_ARGS];
     mp_load_method(vfs->obj, meth_name, meth);
     if (args != NULL) {
         memcpy(meth + 2, args, n_args * sizeof(*args));
-- 
cgit v1.2.3


From 74ec52d85758ad9da7a3abb24257511b22d74964 Mon Sep 17 00:00:00 2001
From: Eric Poulsen <eric@zyxod.com>
Date: Thu, 26 Oct 2017 21:17:35 -0700
Subject: extmod/modussl: Add finaliser support for ussl objects.

Per the comment found here
https://github.com/micropython/micropython-esp32/issues/209#issuecomment-339855157,
this patch adds finaliser code to prevent memory leaks from ussl objects,
which is especially useful when memory for a ussl context is allocated
outside the uPy heap.  This patch is in-line with the finaliser code found
in many modsocket implementations for various ports.

This feature is configured via MICROPY_PY_USSL_FINALISER and is disabled by
default because there may be issues using it when the ussl state *is*
allocated on the uPy heap, rather than externally.
---
 extmod/modussl_axtls.c   | 7 +++++++
 extmod/modussl_mbedtls.c | 7 +++++++
 py/mpconfig.h            | 2 ++
 3 files changed, 16 insertions(+)

(limited to 'extmod')

diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 719a65cd1..3ad65ebf3 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -51,7 +51,11 @@ struct ssl_args {
 STATIC const mp_obj_type_t ussl_socket_type;
 
 STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
+#if MICROPY_PY_USSL_FINALISER
+    mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
+#else
     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
+#endif
     o->base.type = &ussl_socket_type;
     o->buf = NULL;
     o->bytes_left = 0;
@@ -178,6 +182,9 @@ STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&socket_close_obj) },
+#if MICROPY_PY_USSL_FINALISER
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
+#endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_table);
diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index d7316cb4a..59dceb6cf 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -111,7 +111,11 @@ int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
 
 
 STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
+#if MICROPY_PY_USSL_FINALISER
+    mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
+#else
     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
+#endif
     o->base.type = &ussl_socket_type;
 
     int ret;
@@ -272,6 +276,9 @@ STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&socket_close_obj) },
+#if MICROPY_PY_USSL_FINALISER
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
+#endif
     { MP_ROM_QSTR(MP_QSTR_getpeercert), MP_ROM_PTR(&mod_ssl_getpeercert_obj) },
 };
 
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 1694a1360..6a32ea2a6 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -1109,6 +1109,8 @@ typedef double mp_float_t;
 
 #ifndef MICROPY_PY_USSL
 #define MICROPY_PY_USSL (0)
+// Whether to add finaliser code to ussl objects
+#define MICROPY_PY_USSL_FINALISER (0)
 #endif
 
 #ifndef MICROPY_PY_WEBSOCKET
-- 
cgit v1.2.3


From 10b76a9620b7407ffed8366d71f5463496f98838 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 30 Oct 2017 15:41:37 +1100
Subject: extmod/modussl_mbedtls: Allow to compile with unix coverage build.

Fixes a few C warnings.  No functional changes.
---
 extmod/modussl_mbedtls.c | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 59dceb6cf..69a64d2f7 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -65,23 +65,30 @@ struct ssl_args {
 
 STATIC const mp_obj_type_t ussl_socket_type;
 
-void mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str) {
+#ifdef MBEDTLS_DEBUG_C
+STATIC void mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str) {
+    (void)ctx;
+    (void)level;
     printf("DBG:%s:%04d: %s\n", file, line, str);
 }
+#endif
 
 // TODO: FIXME!
-int null_entropy_func(void *data, unsigned char *output, size_t len) {
+STATIC int null_entropy_func(void *data, unsigned char *output, size_t len) {
+    (void)data;
+    (void)output;
+    (void)len;
     // enjoy random bytes
     return 0;
 }
 
-int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
+STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
     mp_obj_t sock = *(mp_obj_t*)ctx;
 
     const mp_stream_p_t *sock_stream = mp_get_stream_raise(sock, MP_STREAM_OP_WRITE);
     int err;
 
-    int out_sz = sock_stream->write(sock, buf, len, &err);
+    mp_uint_t out_sz = sock_stream->write(sock, buf, len, &err);
     if (out_sz == MP_STREAM_ERROR) {
         if (mp_is_nonblocking_error(err)) {
             return MBEDTLS_ERR_SSL_WANT_WRITE;
@@ -92,13 +99,13 @@ int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
     }
 }
 
-int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
+STATIC int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
     mp_obj_t sock = *(mp_obj_t*)ctx;
 
     const mp_stream_p_t *sock_stream = mp_get_stream_raise(sock, MP_STREAM_OP_READ);
     int err;
 
-    int out_sz = sock_stream->read(sock, buf, len, &err);
+    mp_uint_t out_sz = sock_stream->read(sock, buf, len, &err);
     if (out_sz == MP_STREAM_ERROR) {
         if (mp_is_nonblocking_error(err)) {
             return MBEDTLS_ERR_SSL_WANT_READ;
-- 
cgit v1.2.3