From 0719c936fb036f0dd3107cd8bd262d80f95c3ca7 Mon Sep 17 00:00:00 2001
From: Paul Sokolovsky <pfalcon@users.sourceforge.net>
Date: Thu, 2 Nov 2017 00:14:11 +0200
Subject: extmod/modussl_axtls: socket_read: Handle EAGAIN.

If SSL_EAGAIN is returned (which is a feature of MicroPython's axTLS fork),
return EAGAIN.

Original axTLS returns SSL_OK both when there's no data to return to user
yet and when the underlying stream returns EAGAIN. That's not distinctive
enough, for example, original module code works well for blocking stream,
but will infinite-loop for non-blocking socket with EAGAIN. But if we fix
non-blocking case, blocking calls to .read() will return few None's initially
(while axTLS progresses thru handshake).

Using SSL_EAGAIN allows to fix non-blocking case without regressing the
blocking one.

Note that this only handles case of non-blocking reads of application data.
Initial handshake and writes still don't support non-blocking mode and must
be done in the blocking way.
---
 extmod/modussl_axtls.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'extmod')

diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 3ad65ebf3..9c5722b12 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -121,6 +121,9 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
                 // EOF
                 return 0;
             }
+            if (r == SSL_EAGAIN) {
+                r = MP_EAGAIN;
+            }
             *errcode = r;
             return MP_STREAM_ERROR;
         }
-- 
cgit v1.2.3


From 1cf6d488b3e6b18b21f13f489ded35a47cf3b37d Mon Sep 17 00:00:00 2001
From: Paul Sokolovsky <pfalcon@users.sourceforge.net>
Date: Thu, 2 Nov 2017 00:16:03 +0200
Subject: extmod/modussl_axtls: Typo fix in comment.

---
 extmod/modussl_axtls.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 9c5722b12..4d8440a89 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -113,7 +113,7 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
         mp_int_t r = ssl_read(o->ssl_sock, &o->buf);
         if (r == SSL_OK) {
             // SSL_OK from ssl_read() means "everything is ok, but there's
-            // not user data yet. So, we just keep reading.
+            // no user data yet". So, we just keep reading.
             continue;
         }
         if (r < 0) {
-- 
cgit v1.2.3


From 7413b3ce3e344a6a916cd55508dfda8f009df598 Mon Sep 17 00:00:00 2001
From: Christopher Cooper <ccooper21@gmail.com>
Date: Fri, 10 Nov 2017 21:57:34 +0000
Subject: extmod/moduhashlib: Enable SHA1 hashing when using "mbedtls" library.

The SHA1 hashing functionality is provided via the "axtls" library's
implementation, and hence is unavailable when the "axtls" library is not being
used.  This change provides the same SHA1 hashing functionality when using the
"mbedtls" library by using its implementation instead.
---
 extmod/moduhashlib.c      | 55 +++++++++++++++++++++++++++++++++++++++++++++++
 ports/unix/mpconfigport.h |  2 +-
 2 files changed, 56 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 3fad69247..6469dcfa3 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -32,10 +32,19 @@
 #if MICROPY_PY_UHASHLIB
 
 #include "crypto-algorithms/sha256.h"
+
 #if MICROPY_PY_UHASHLIB_SHA1
+
+#if MICROPY_SSL_AXTLS
 #include "lib/axtls/crypto/crypto.h"
 #endif
 
+#if MICROPY_SSL_MBEDTLS
+#include "mbedtls/sha1.h"
+#endif
+
+#endif
+
 typedef struct _mp_obj_hash_t {
     mp_obj_base_t base;
     char state[0];
@@ -57,6 +66,7 @@ STATIC mp_obj_t hash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
 #if MICROPY_PY_UHASHLIB_SHA1
 STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg);
 
+#if MICROPY_SSL_AXTLS
 STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(SHA1_CTX));
@@ -69,6 +79,22 @@ STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
 }
 #endif
 
+#if MICROPY_SSL_MBEDTLS
+STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_sha1_context));
+    o->base.type = type;
+    mbedtls_sha1_init((mbedtls_sha1_context*)o->state);
+    mbedtls_sha1_starts((mbedtls_sha1_context*)o->state);
+    if (n_args == 1) {
+        sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
+    }
+    return MP_OBJ_FROM_PTR(o);
+}
+#endif
+
+#endif
+
 STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
@@ -79,6 +105,8 @@ STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
 MP_DEFINE_CONST_FUN_OBJ_2(hash_update_obj, hash_update);
 
 #if MICROPY_PY_UHASHLIB_SHA1
+
+#if MICROPY_SSL_AXTLS
 STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
@@ -86,6 +114,18 @@ STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     SHA1_Update((SHA1_CTX*)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
+#endif
+
+#if MICROPY_SSL_MBEDTLS
+STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
+    mbedtls_sha1_update((mbedtls_sha1_context*)self->state, bufinfo.buf, bufinfo.len);
+    return mp_const_none;
+}
+#endif
+
 MP_DEFINE_CONST_FUN_OBJ_2(sha1_update_obj, sha1_update);
 #endif
 
@@ -99,6 +139,8 @@ STATIC mp_obj_t hash_digest(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(hash_digest_obj, hash_digest);
 
 #if MICROPY_PY_UHASHLIB_SHA1
+
+#if MICROPY_SSL_AXTLS
 STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
@@ -106,6 +148,19 @@ STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
     SHA1_Final((byte*)vstr.buf, (SHA1_CTX*)self->state);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
+#endif
+
+#if MICROPY_SSL_MBEDTLS
+STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    vstr_t vstr;
+    vstr_init_len(&vstr, 20);
+    mbedtls_sha1_finish((mbedtls_sha1_context*)self->state, (byte*)vstr.buf);
+    mbedtls_sha1_free((mbedtls_sha1_context*)self->state);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+#endif
+
 MP_DEFINE_CONST_FUN_OBJ_1(sha1_digest_obj, sha1_digest);
 #endif
 
diff --git a/ports/unix/mpconfigport.h b/ports/unix/mpconfigport.h
index db382e0a7..a3d2bb7db 100644
--- a/ports/unix/mpconfigport.h
+++ b/ports/unix/mpconfigport.h
@@ -121,7 +121,7 @@
 #define MICROPY_PY_UHEAPQ           (1)
 #define MICROPY_PY_UTIMEQ           (1)
 #define MICROPY_PY_UHASHLIB         (1)
-#if MICROPY_PY_USSL && MICROPY_SSL_AXTLS
+#if MICROPY_PY_USSL
 #define MICROPY_PY_UHASHLIB_SHA1    (1)
 #endif
 #define MICROPY_PY_UBINASCII        (1)
-- 
cgit v1.2.3


From 6bc55b657b900dd92ebb8b4a8c393644a30dd7e6 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 16 Nov 2017 13:13:24 +1100
Subject: extmod/vfs: Use existing qstr for forward-slash string object.

---
 extmod/vfs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index 44ad8ffad..105a80a8d 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -261,7 +261,7 @@ mp_obj_t mp_vfs_chdir(mp_obj_t path_in) {
         // subsequent relative paths begin at the root of that VFS.
         for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
             if (vfs->len == 1) {
-                mp_obj_t root = mp_obj_new_str("/", 1, false);
+                mp_obj_t root = MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
                 mp_vfs_proxy_call(vfs, MP_QSTR_chdir, 1, &root);
                 break;
             }
@@ -318,7 +318,7 @@ STATIC mp_obj_t mp_vfs_ilistdir_it_iternext(mp_obj_t self_in) {
         self->cur.vfs = vfs->next;
         if (vfs->len == 1) {
             // vfs is mounted at root dir, delegate to it
-            mp_obj_t root = mp_obj_new_str("/", 1, false);
+            mp_obj_t root = MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
             self->is_iter = true;
             self->cur.iter = mp_vfs_proxy_call(vfs, MP_QSTR_ilistdir, 1, &root);
             return mp_iternext(self->cur.iter);
-- 
cgit v1.2.3


From 4601759bf59e16b860a3f082e9aa4ea78356bf92 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 16 Nov 2017 13:17:51 +1100
Subject: py/objstr: Remove "make_qstr_if_not_already" arg from mp_obj_new_str.

This patch simplifies the str creation API to favour the common case of
creating a str object that is not forced to be interned.  To force
interning of a new str the new mp_obj_new_str_via_qstr function is added,
and should only be used if warranted.

Apart from simplifying the mp_obj_new_str function (and making it have the
same signature as mp_obj_new_bytes), this patch also reduces code size by a
bit (-16 bytes for bare-arm and roughly -40 bytes on the bare-metal archs).
---
 extmod/modujson.c           |  2 +-
 extmod/modwebrepl.c         |  2 +-
 extmod/vfs_fat.c            |  2 +-
 extmod/vfs_fat_misc.c       |  2 +-
 extmod/vfs_reader.c         |  2 +-
 lib/netutils/netutils.c     |  2 +-
 ports/cc3200/mods/modwlan.c | 10 +++++-----
 ports/esp8266/modnetwork.c  |  4 ++--
 ports/esp8266/moduos.c      |  2 +-
 ports/stm32/modnwcc3k.c     |  4 ++--
 ports/unix/coverage.c       |  6 +++---
 ports/unix/main.c           |  6 +++---
 ports/unix/modffi.c         |  2 +-
 ports/unix/modjni.c         |  2 +-
 ports/unix/modos.c          |  4 ++--
 ports/zephyr/modusocket.c   |  2 +-
 py/binary.c                 |  2 +-
 py/builtinhelp.c            |  2 +-
 py/builtinimport.c          |  2 +-
 py/modbuiltins.c            |  4 ++--
 py/modio.c                  |  2 +-
 py/obj.h                    |  3 ++-
 py/objstr.c                 | 36 ++++++++++++++++++------------------
 py/objstrunicode.c          |  4 ++--
 24 files changed, 55 insertions(+), 54 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modujson.c b/extmod/modujson.c
index f14682d26..6eeba4ed6 100644
--- a/extmod/modujson.c
+++ b/extmod/modujson.c
@@ -166,7 +166,7 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
                     goto fail;
                 }
                 S_NEXT(s);
-                next = mp_obj_new_str(vstr.buf, vstr.len, false);
+                next = mp_obj_new_str(vstr.buf, vstr.len);
                 break;
             case '-':
             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': {
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index 3aba5c0f1..42b30f5ea 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -141,7 +141,7 @@ STATIC void handle_op(mp_obj_webrepl_t *self) {
     // Handle operations requiring opened file
 
     mp_obj_t open_args[2] = {
-        mp_obj_new_str(self->hdr.fname, strlen(self->hdr.fname), false),
+        mp_obj_new_str(self->hdr.fname, strlen(self->hdr.fname)),
         MP_OBJ_NEW_QSTR(MP_QSTR_rb)
     };
 
diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 22346bdf1..9942ddeb5 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -197,7 +197,7 @@ STATIC mp_obj_t fat_vfs_getcwd(mp_obj_t vfs_in) {
     if (res != FR_OK) {
         mp_raise_OSError(fresult_to_errno_table[res]);
     }
-    return mp_obj_new_str(buf, strlen(buf), false);
+    return mp_obj_new_str(buf, strlen(buf));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(fat_vfs_getcwd_obj, fat_vfs_getcwd);
 
diff --git a/extmod/vfs_fat_misc.c b/extmod/vfs_fat_misc.c
index 9a26b4a2f..1f90ac14c 100644
--- a/extmod/vfs_fat_misc.c
+++ b/extmod/vfs_fat_misc.c
@@ -57,7 +57,7 @@ STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
         // make 3-tuple with info about this entry
         mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
         if (self->is_str) {
-            t->items[0] = mp_obj_new_str(fn, strlen(fn), false);
+            t->items[0] = mp_obj_new_str(fn, strlen(fn));
         } else {
             t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
         }
diff --git a/extmod/vfs_reader.c b/extmod/vfs_reader.c
index 891098aa1..e1ee45a3c 100644
--- a/extmod/vfs_reader.c
+++ b/extmod/vfs_reader.c
@@ -71,7 +71,7 @@ STATIC void mp_reader_vfs_close(void *data) {
 
 void mp_reader_new_file(mp_reader_t *reader, const char *filename) {
     mp_reader_vfs_t *rf = m_new_obj(mp_reader_vfs_t);
-    mp_obj_t arg = mp_obj_new_str(filename, strlen(filename), false);
+    mp_obj_t arg = mp_obj_new_str(filename, strlen(filename));
     rf->file = mp_vfs_open(1, &arg, (mp_map_t*)&mp_const_empty_map);
     int errcode;
     rf->len = mp_stream_rw(rf->file, rf->buf, sizeof(rf->buf), &errcode, MP_STREAM_RW_READ | MP_STREAM_RW_ONCE);
diff --git a/lib/netutils/netutils.c b/lib/netutils/netutils.c
index 06c3ff9b0..073f46b19 100644
--- a/lib/netutils/netutils.c
+++ b/lib/netutils/netutils.c
@@ -41,7 +41,7 @@ mp_obj_t netutils_format_ipv4_addr(uint8_t *ip, netutils_endian_t endian) {
     } else {
         ip_len = snprintf(ip_str, 16, "%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]);
     }
-    return mp_obj_new_str(ip_str, ip_len, false);
+    return mp_obj_new_str(ip_str, ip_len);
 }
 
 // Takes an array with a raw IP address, and a port, and returns a net-address
diff --git a/ports/cc3200/mods/modwlan.c b/ports/cc3200/mods/modwlan.c
index f9c7111b3..8acc89da3 100644
--- a/ports/cc3200/mods/modwlan.c
+++ b/ports/cc3200/mods/modwlan.c
@@ -885,7 +885,7 @@ STATIC mp_obj_t wlan_scan(mp_obj_t self_in) {
         }
 
         mp_obj_t tuple[5];
-        tuple[0] = mp_obj_new_str((const char *)wlanEntry.ssid, wlanEntry.ssid_len, false);
+        tuple[0] = mp_obj_new_str((const char *)wlanEntry.ssid, wlanEntry.ssid_len);
         tuple[1] = mp_obj_new_bytes((const byte *)wlanEntry.bssid, SL_BSSID_LENGTH);
         // 'normalize' the security type
         if (wlanEntry.sec_type > 2) {
@@ -1075,7 +1075,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wlan_mode_obj, 1, 2, wlan_mode);
 STATIC mp_obj_t wlan_ssid(size_t n_args, const mp_obj_t *args) {
     wlan_obj_t *self = args[0];
     if (n_args == 1) {
-        return mp_obj_new_str((const char *)self->ssid, strlen((const char *)self->ssid), false);
+        return mp_obj_new_str((const char *)self->ssid, strlen((const char *)self->ssid));
     } else {
         size_t len;
         const char *ssid = mp_obj_str_get_data(args[1], &len);
@@ -1095,7 +1095,7 @@ STATIC mp_obj_t wlan_auth(size_t n_args, const mp_obj_t *args) {
         } else {
             mp_obj_t security[2];
             security[0] = mp_obj_new_int(self->auth);
-            security[1] = mp_obj_new_str((const char *)self->key, strlen((const char *)self->key), false);
+            security[1] = mp_obj_new_str((const char *)self->key, strlen((const char *)self->key));
             return mp_obj_new_tuple(2, security);
         }
     } else {
@@ -1199,7 +1199,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
 //    mp_obj_t connections = mp_obj_new_list(0, NULL);
 //
 //    if (wlan_is_connected()) {
-//        device[0] = mp_obj_new_str((const char *)wlan_obj.ssid_o, strlen((const char *)wlan_obj.ssid_o), false);
+//        device[0] = mp_obj_new_str((const char *)wlan_obj.ssid_o, strlen((const char *)wlan_obj.ssid_o));
 //        device[1] = mp_obj_new_bytes((const byte *)wlan_obj.bssid, SL_BSSID_LENGTH);
 //        // add the device to the list
 //        mp_obj_list_append(connections, mp_obj_new_tuple(MP_ARRAY_SIZE(device), device));
@@ -1232,7 +1232,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
 //        if (sl_NetAppGet(SL_NET_APP_DEVICE_CONFIG_ID, NETAPP_SET_GET_DEV_CONF_OPT_DEVICE_URN, &len, (uint8_t *)urn) < 0) {
 //            mp_raise_OSError(MP_EIO);
 //        }
-//        return mp_obj_new_str(urn, (len - 1), false);
+//        return mp_obj_new_str(urn, (len - 1));
 //    }
 //
 //    return mp_const_none;
diff --git a/ports/esp8266/modnetwork.c b/ports/esp8266/modnetwork.c
index b41a11f59..4066c969c 100644
--- a/ports/esp8266/modnetwork.c
+++ b/ports/esp8266/modnetwork.c
@@ -411,7 +411,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
         }
         case QS(MP_QSTR_essid):
             req_if = SOFTAP_IF;
-            val = mp_obj_new_str((char*)cfg.ap.ssid, cfg.ap.ssid_len, false);
+            val = mp_obj_new_str((char*)cfg.ap.ssid, cfg.ap.ssid_len);
             break;
         case QS(MP_QSTR_hidden):
             req_if = SOFTAP_IF;
@@ -428,7 +428,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
         case QS(MP_QSTR_dhcp_hostname): {
             req_if = STATION_IF;
             char* s = wifi_station_get_hostname();
-            val = mp_obj_new_str(s, strlen(s), false);
+            val = mp_obj_new_str(s, strlen(s));
             break;
         }
         default:
diff --git a/ports/esp8266/moduos.c b/ports/esp8266/moduos.c
index d0554096e..93f7aa712 100644
--- a/ports/esp8266/moduos.c
+++ b/ports/esp8266/moduos.c
@@ -60,7 +60,7 @@ STATIC mp_obj_tuple_t os_uname_info_obj = {
 STATIC mp_obj_t os_uname(void) {
     // We must populate the "release" field each time in case it was GC'd since the last call.
     const char *ver = system_get_sdk_version();
-    os_uname_info_obj.items[2] = mp_obj_new_str(ver, strlen(ver), false);
+    os_uname_info_obj.items[2] = mp_obj_new_str(ver, strlen(ver));
     return (mp_obj_t)&os_uname_info_obj;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname);
diff --git a/ports/stm32/modnwcc3k.c b/ports/stm32/modnwcc3k.c
index 8cc0a613d..4f1af7354 100644
--- a/ports/stm32/modnwcc3k.c
+++ b/ports/stm32/modnwcc3k.c
@@ -531,8 +531,8 @@ STATIC mp_obj_t cc3k_ifconfig(mp_obj_t self_in) {
         netutils_format_ipv4_addr(ipconfig.aucDefaultGateway, NETUTILS_LITTLE),
         netutils_format_ipv4_addr(ipconfig.aucDNSServer, NETUTILS_LITTLE),
         netutils_format_ipv4_addr(ipconfig.aucDHCPServer, NETUTILS_LITTLE),
-        mp_obj_new_str(mac_vstr.buf, mac_vstr.len, false),
-        mp_obj_new_str((const char*)ipconfig.uaSSID, strlen((const char*)ipconfig.uaSSID), false),
+        mp_obj_new_str(mac_vstr.buf, mac_vstr.len),
+        mp_obj_new_str((const char*)ipconfig.uaSSID, strlen((const char*)ipconfig.uaSSID)),
     };
     return mp_obj_new_tuple(MP_ARRAY_SIZE(tuple), tuple);
 }
diff --git a/ports/unix/coverage.c b/ports/unix/coverage.c
index 651db0a94..e2896c2dd 100644
--- a/ports/unix/coverage.c
+++ b/ports/unix/coverage.c
@@ -227,7 +227,7 @@ STATIC mp_obj_t extra_coverage(void) {
         mp_printf(&mp_plat_print, "# str\n");
 
         // intern string
-        mp_printf(&mp_plat_print, "%d\n", MP_OBJ_IS_QSTR(mp_obj_str_intern(mp_obj_new_str("intern me", 9, false))));
+        mp_printf(&mp_plat_print, "%d\n", MP_OBJ_IS_QSTR(mp_obj_str_intern(mp_obj_new_str("intern me", 9))));
     }
 
     // mpz
@@ -260,12 +260,12 @@ STATIC mp_obj_t extra_coverage(void) {
         // call mp_call_function_1_protected
         mp_call_function_1_protected(MP_OBJ_FROM_PTR(&mp_builtin_abs_obj), MP_OBJ_NEW_SMALL_INT(1));
         // call mp_call_function_1_protected with invalid args
-        mp_call_function_1_protected(MP_OBJ_FROM_PTR(&mp_builtin_abs_obj), mp_obj_new_str("abc", 3, false));
+        mp_call_function_1_protected(MP_OBJ_FROM_PTR(&mp_builtin_abs_obj), mp_obj_new_str("abc", 3));
 
         // call mp_call_function_2_protected
         mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), MP_OBJ_NEW_SMALL_INT(1), MP_OBJ_NEW_SMALL_INT(1));
         // call mp_call_function_2_protected with invalid args
-        mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), mp_obj_new_str("abc", 3, false), mp_obj_new_str("abc", 3, false));
+        mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), mp_obj_new_str("abc", 3), mp_obj_new_str("abc", 3));
     }
 
     // warning
diff --git a/ports/unix/main.c b/ports/unix/main.c
index e1cd33fc1..25f3e04fb 100644
--- a/ports/unix/main.c
+++ b/ports/unix/main.c
@@ -481,7 +481,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
             vstr_add_strn(&vstr, p + 1, p1 - p - 1);
             path_items[i] = mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
         } else {
-            path_items[i] = MP_OBJ_NEW_QSTR(qstr_from_strn(p, p1 - p));
+            path_items[i] = mp_obj_new_str_via_qstr(p, p1 - p);
         }
         p = p1 + 1;
     }
@@ -537,7 +537,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                     return usage(argv);
                 }
                 mp_obj_t import_args[4];
-                import_args[0] = mp_obj_new_str(argv[a + 1], strlen(argv[a + 1]), false);
+                import_args[0] = mp_obj_new_str(argv[a + 1], strlen(argv[a + 1]));
                 import_args[1] = import_args[2] = mp_const_none;
                 // Ask __import__ to handle imported module specially - set its __name__
                 // to __main__, and also return this leaf module, not top-level package
@@ -603,7 +603,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
 
             // Set base dir of the script as first entry in sys.path
             char *p = strrchr(basedir, '/');
-            path_items[0] = MP_OBJ_NEW_QSTR(qstr_from_strn(basedir, p - basedir));
+            path_items[0] = mp_obj_new_str_via_qstr(basedir, p - basedir);
             free(pathbuf);
 
             set_sys_argv(argv, argc, a);
diff --git a/ports/unix/modffi.c b/ports/unix/modffi.c
index 78adccac1..024f83c14 100644
--- a/ports/unix/modffi.c
+++ b/ports/unix/modffi.c
@@ -144,7 +144,7 @@ STATIC mp_obj_t return_ffi_value(ffi_arg val, char type)
             if (!s) {
                 return mp_const_none;
             }
-            return mp_obj_new_str(s, strlen(s), false);
+            return mp_obj_new_str(s, strlen(s));
         }
         case 'v':
             return mp_const_none;
diff --git a/ports/unix/modjni.c b/ports/unix/modjni.c
index f29c095cf..8ec5ae54d 100644
--- a/ports/unix/modjni.c
+++ b/ports/unix/modjni.c
@@ -337,7 +337,7 @@ STATIC mp_obj_t new_jobject(jobject jo) {
         return mp_const_none;
     } else if (JJ(IsInstanceOf, jo, String_class)) {
         const char *s = JJ(GetStringUTFChars, jo, NULL);
-        mp_obj_t ret = mp_obj_new_str(s, strlen(s), false);
+        mp_obj_t ret = mp_obj_new_str(s, strlen(s));
         JJ(ReleaseStringUTFChars, jo, s);
         return ret;
     } else if (JJ(IsInstanceOf, jo, Class_class)) {
diff --git a/ports/unix/modos.c b/ports/unix/modos.c
index 327116a0a..808d12adb 100644
--- a/ports/unix/modos.c
+++ b/ports/unix/modos.c
@@ -133,7 +133,7 @@ STATIC mp_obj_t mod_os_getenv(mp_obj_t var_in) {
     if (s == NULL) {
         return mp_const_none;
     }
-    return mp_obj_new_str(s, strlen(s), false);
+    return mp_obj_new_str(s, strlen(s));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_getenv_obj, mod_os_getenv);
 
@@ -171,7 +171,7 @@ STATIC mp_obj_t listdir_next(mp_obj_t self_in) {
     }
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
-    t->items[0] = mp_obj_new_str(dirent->d_name, strlen(dirent->d_name), false);
+    t->items[0] = mp_obj_new_str(dirent->d_name, strlen(dirent->d_name));
     #ifdef _DIRENT_HAVE_D_TYPE
     t->items[1] = MP_OBJ_NEW_SMALL_INT(dirent->d_type);
     #else
diff --git a/ports/zephyr/modusocket.c b/ports/zephyr/modusocket.c
index e021c3a44..95414a49b 100644
--- a/ports/zephyr/modusocket.c
+++ b/ports/zephyr/modusocket.c
@@ -91,7 +91,7 @@ STATIC mp_obj_t format_inet_addr(struct sockaddr *addr, mp_obj_t port) {
     net_addr_ntop(addr->sa_family, &sockaddr_in6->sin6_addr, buf, sizeof(buf));
     mp_obj_tuple_t *tuple = mp_obj_new_tuple(addr->sa_family == AF_INET ? 2 : 4, NULL);
 
-    tuple->items[0] = mp_obj_new_str(buf, strlen(buf), false);
+    tuple->items[0] = mp_obj_new_str(buf, strlen(buf));
     // We employ the fact that port offset is the same for IPv4 & IPv6
     // not filled in
     //tuple->items[1] = mp_obj_new_int(ntohs(((struct sockaddr_in*)addr)->sin_port));
diff --git a/py/binary.c b/py/binary.c
index 870a0942b..f509ff010 100644
--- a/py/binary.c
+++ b/py/binary.c
@@ -206,7 +206,7 @@ mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte **ptr) {
         return (mp_obj_t)(mp_uint_t)val;
     } else if (val_type == 'S') {
         const char *s_val = (const char*)(uintptr_t)(mp_uint_t)val;
-        return mp_obj_new_str(s_val, strlen(s_val), false);
+        return mp_obj_new_str(s_val, strlen(s_val));
 #if MICROPY_PY_BUILTINS_FLOAT
     } else if (val_type == 'f') {
         union { uint32_t i; float f; } fpu = {val};
diff --git a/py/builtinhelp.c b/py/builtinhelp.c
index c9992906d..7106f3ced 100644
--- a/py/builtinhelp.c
+++ b/py/builtinhelp.c
@@ -69,7 +69,7 @@ STATIC void mp_help_add_from_names(mp_obj_t list, const char *name) {
     while (*name) {
         size_t l = strlen(name);
         // name should end in '.py' and we strip it off
-        mp_obj_list_append(list, mp_obj_new_str(name, l - 3, false));
+        mp_obj_list_append(list, mp_obj_new_str(name, l - 3));
         name += l + 1;
     }
 }
diff --git a/py/builtinimport.c b/py/builtinimport.c
index 04ce66723..9235e946c 100644
--- a/py/builtinimport.c
+++ b/py/builtinimport.c
@@ -434,7 +434,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
                     DEBUG_printf("%.*s is dir\n", vstr_len(&path), vstr_str(&path));
                     // https://docs.python.org/3/reference/import.html
                     // "Specifically, any module that contains a __path__ attribute is considered a package."
-                    mp_store_attr(module_obj, MP_QSTR___path__, mp_obj_new_str(vstr_str(&path), vstr_len(&path), false));
+                    mp_store_attr(module_obj, MP_QSTR___path__, mp_obj_new_str(vstr_str(&path), vstr_len(&path)));
                     size_t orig_path_len = path.len;
                     vstr_add_char(&path, PATH_SEP_CHAR);
                     vstr_add_str(&path, "__init__.py");
diff --git a/py/modbuiltins.c b/py/modbuiltins.c
index 65c03d523..ebff5f5c0 100644
--- a/py/modbuiltins.c
+++ b/py/modbuiltins.c
@@ -159,12 +159,12 @@ STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) {
     } else {
         mp_raise_ValueError("chr() arg not in range(0x110000)");
     }
-    return mp_obj_new_str(str, len, true);
+    return mp_obj_new_str_via_qstr(str, len);
     #else
     mp_int_t ord = mp_obj_get_int(o_in);
     if (0 <= ord && ord <= 0xff) {
         char str[1] = {ord};
-        return mp_obj_new_str(str, 1, true);
+        return mp_obj_new_str_via_qstr(str, 1);
     } else {
         mp_raise_ValueError("chr() arg not in range(256)");
     }
diff --git a/py/modio.c b/py/modio.c
index 353a00286..828bcec46 100644
--- a/py/modio.c
+++ b/py/modio.c
@@ -176,7 +176,7 @@ STATIC mp_obj_t resource_stream(mp_obj_t package_in, mp_obj_t path_in) {
         return MP_OBJ_FROM_PTR(o);
     }
 
-    mp_obj_t path_out = mp_obj_new_str(path_buf.buf, path_buf.len, false);
+    mp_obj_t path_out = mp_obj_new_str(path_buf.buf, path_buf.len);
     return mp_builtin_open(1, &path_out, (mp_map_t*)&mp_const_empty_map);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(resource_stream_obj, resource_stream);
diff --git a/py/obj.h b/py/obj.h
index 77f0f2298..31c3ce95c 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -637,7 +637,8 @@ mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value);
 mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base);
 mp_obj_t mp_obj_new_int_from_ll(long long val); // this must return a multi-precision integer object (or raise an overflow exception)
 mp_obj_t mp_obj_new_int_from_ull(unsigned long long val); // this must return a multi-precision integer object (or raise an overflow exception)
-mp_obj_t mp_obj_new_str(const char* data, size_t len, bool make_qstr_if_not_already);
+mp_obj_t mp_obj_new_str(const char* data, size_t len);
+mp_obj_t mp_obj_new_str_via_qstr(const char* data, size_t len);
 mp_obj_t mp_obj_new_str_from_vstr(const mp_obj_type_t *type, vstr_t *vstr);
 mp_obj_t mp_obj_new_bytes(const byte* data, size_t len);
 mp_obj_t mp_obj_new_bytearray(size_t n, void *items);
diff --git a/py/objstr.c b/py/objstr.c
index 51da7a418..5c464ba7d 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -176,7 +176,7 @@ mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
                     mp_raise_msg(&mp_type_UnicodeError, NULL);
                 }
                 #endif
-                return mp_obj_new_str(bufinfo.buf, bufinfo.len, false);
+                return mp_obj_new_str(bufinfo.buf, bufinfo.len);
             }
     }
 }
@@ -423,7 +423,7 @@ STATIC mp_obj_t bytes_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
         if (MICROPY_PY_BUILTINS_STR_UNICODE || type == &mp_type_bytes) {
             return MP_OBJ_NEW_SMALL_INT(self_data[index_val]);
         } else {
-            return mp_obj_new_str((char*)&self_data[index_val], 1, true);
+            return mp_obj_new_str_via_qstr((char*)&self_data[index_val], 1);
         }
     } else {
         return MP_OBJ_NULL; // op not supported
@@ -1046,7 +1046,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
             } else {
                 const char *lookup;
                 for (lookup = field_name; lookup < field_name_top && *lookup != '.' && *lookup != '['; lookup++);
-                mp_obj_t field_q = mp_obj_new_str(field_name, lookup - field_name, true/*?*/);
+                mp_obj_t field_q = mp_obj_new_str_via_qstr(field_name, lookup - field_name); // should it be via qstr?
                 field_name = lookup;
                 mp_map_elem_t *key_elem = mp_map_lookup(kwargs, field_q, MP_MAP_LOOKUP);
                 if (key_elem == NULL) {
@@ -1413,7 +1413,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                 }
                 ++str;
             }
-            mp_obj_t k_obj = mp_obj_new_str((const char*)key, str - key, true);
+            mp_obj_t k_obj = mp_obj_new_str_via_qstr((const char*)key, str - key);
             arg = mp_obj_dict_get(dict, k_obj);
             str++;
         }
@@ -1992,6 +1992,11 @@ mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte* data, siz
     return MP_OBJ_FROM_PTR(o);
 }
 
+// Create a str using a qstr to store the data; may use existing or new qstr.
+mp_obj_t mp_obj_new_str_via_qstr(const char* data, size_t len) {
+    return MP_OBJ_NEW_QSTR(qstr_from_strn(data, len));
+}
+
 // Create a str/bytes object from the given vstr.  The vstr buffer is resized to
 // the exact length required and then reused for the str/bytes object.  The vstr
 // is cleared and can safely be passed to vstr_free if it was heap allocated.
@@ -2022,25 +2027,20 @@ mp_obj_t mp_obj_new_str_from_vstr(const mp_obj_type_t *type, vstr_t *vstr) {
     return MP_OBJ_FROM_PTR(o);
 }
 
-mp_obj_t mp_obj_new_str(const char* data, size_t len, bool make_qstr_if_not_already) {
-    if (make_qstr_if_not_already) {
-        // use existing, or make a new qstr
-        return MP_OBJ_NEW_QSTR(qstr_from_strn(data, len));
+mp_obj_t mp_obj_new_str(const char* data, size_t len) {
+    qstr q = qstr_find_strn(data, len);
+    if (q != MP_QSTR_NULL) {
+        // qstr with this data already exists
+        return MP_OBJ_NEW_QSTR(q);
     } else {
-        qstr q = qstr_find_strn(data, len);
-        if (q != MP_QSTR_NULL) {
-            // qstr with this data already exists
-            return MP_OBJ_NEW_QSTR(q);
-        } else {
-            // no existing qstr, don't make one
-            return mp_obj_new_str_of_type(&mp_type_str, (const byte*)data, len);
-        }
+        // no existing qstr, don't make one
+        return mp_obj_new_str_of_type(&mp_type_str, (const byte*)data, len);
     }
 }
 
 mp_obj_t mp_obj_str_intern(mp_obj_t str) {
     GET_STR_DATA_LEN(str, data, len);
-    return MP_OBJ_NEW_QSTR(qstr_from_strn((const char*)data, len));
+    return mp_obj_new_str_via_qstr((const char*)data, len);
 }
 
 mp_obj_t mp_obj_new_bytes(const byte* data, size_t len) {
@@ -2138,7 +2138,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
     mp_obj_str8_it_t *self = MP_OBJ_TO_PTR(self_in);
     GET_STR_DATA_LEN(self->str, str, len);
     if (self->cur < len) {
-        mp_obj_t o_out = mp_obj_new_str((const char*)str + self->cur, 1, true);
+        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char*)str + self->cur, 1);
         self->cur += 1;
         return o_out;
     } else {
diff --git a/py/objstrunicode.c b/py/objstrunicode.c
index 29f7695b7..a1f54b8a2 100644
--- a/py/objstrunicode.c
+++ b/py/objstrunicode.c
@@ -216,7 +216,7 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
                 ++len;
             }
         }
-        return mp_obj_new_str((const char*)s, len, true); // This will create a one-character string
+        return mp_obj_new_str_via_qstr((const char*)s, len); // This will create a one-character string
     } else {
         return MP_OBJ_NULL; // op not supported
     }
@@ -291,7 +291,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
     if (self->cur < len) {
         const byte *cur = str + self->cur;
         const byte *end = utf8_next_char(str + self->cur);
-        mp_obj_t o_out = mp_obj_new_str((const char*)cur, end - cur, true);
+        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char*)cur, end - cur);
         self->cur += end - cur;
         return o_out;
     } else {
-- 
cgit v1.2.3


From 12ad64bc554fe33772c492efc55eb9290463048a Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 16 Nov 2017 16:01:47 +1100
Subject: extmod/vfs_fat: Mount FatFS on creation so VFS methods can be used.

It's possible to use the methods (eg ilistdir) of a VFS FatFS object
without it being mounted in the VFS itself.  This previously worked but
only because FatFS was "mounting" the filesystem automatically when any
function (eg f_opendir) was called.  But it didn't work for ports that used
synchronisation objects (_FS_REENTRANT) because they are only initialised
via a call to f_mount.  So, call f_mount explicitly when creating a new
FatFS object so that everything is set up correctly.  Then also provide a
finaliser to do the f_umount call, but only if synchronisation objects are
enabled (since otherwise the f_umount call does nothing).
---
 extmod/vfs_fat.c | 34 ++++++++++++++++++++++++++--------
 extmod/vfs_fat.h |  1 +
 2 files changed, 27 insertions(+), 8 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 9942ddeb5..0076df262 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -69,9 +69,28 @@ STATIC mp_obj_t fat_vfs_make_new(const mp_obj_type_t *type, size_t n_args, size_
         mp_load_method(args[0], MP_QSTR_count, vfs->u.old.count);
     }
 
+    // mount the block device so the VFS methods can be used
+    FRESULT res = f_mount(&vfs->fatfs);
+    if (res == FR_NO_FILESYSTEM) {
+        // don't error out if no filesystem, to let mkfs()/mount() create one if wanted
+        vfs->flags |= FSUSER_NO_FILESYSTEM;
+    } else if (res != FR_OK) {
+        mp_raise_OSError(fresult_to_errno_table[res]);
+    }
+
     return MP_OBJ_FROM_PTR(vfs);
 }
 
+#if _FS_REENTRANT
+STATIC mp_obj_t fat_vfs_del(mp_obj_t self_in) {
+    mp_obj_fat_vfs_t *self = MP_OBJ_TO_PTR(self_in);
+    // f_umount only needs to be called to release the sync object
+    f_umount(&self->fatfs);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(fat_vfs_del_obj, fat_vfs_del);
+#endif
+
 STATIC mp_obj_t fat_vfs_mkfs(mp_obj_t bdev_in) {
     // create new object
     fs_user_mount_t *vfs = MP_OBJ_TO_PTR(fat_vfs_make_new(&mp_fat_vfs_type, 1, 0, &bdev_in));
@@ -291,10 +310,8 @@ STATIC mp_obj_t vfs_fat_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs
         self->writeblocks[0] = MP_OBJ_NULL;
     }
 
-    // mount the block device
-    FRESULT res = f_mount(&self->fatfs);
-
     // check if we need to make the filesystem
+    FRESULT res = (self->flags & FSUSER_NO_FILESYSTEM) ? FR_NO_FILESYSTEM : FR_OK;
     if (res == FR_NO_FILESYSTEM && mp_obj_is_true(mkfs)) {
         uint8_t working_buf[_MAX_SS];
         res = f_mkfs(&self->fatfs, FM_FAT | FM_SFD, 0, working_buf, sizeof(working_buf));
@@ -302,22 +319,23 @@ STATIC mp_obj_t vfs_fat_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs
     if (res != FR_OK) {
         mp_raise_OSError(fresult_to_errno_table[res]);
     }
+    self->flags &= ~FSUSER_NO_FILESYSTEM;
 
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_fat_mount_obj, vfs_fat_mount);
 
 STATIC mp_obj_t vfs_fat_umount(mp_obj_t self_in) {
-    fs_user_mount_t *self = MP_OBJ_TO_PTR(self_in);
-    FRESULT res = f_umount(&self->fatfs);
-    if (res != FR_OK) {
-        mp_raise_OSError(fresult_to_errno_table[res]);
-    }
+    (void)self_in;
+    // keep the FAT filesystem mounted internally so the VFS methods can still be used
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(fat_vfs_umount_obj, vfs_fat_umount);
 
 STATIC const mp_rom_map_elem_t fat_vfs_locals_dict_table[] = {
+    #if _FS_REENTRANT
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&fat_vfs_del_obj) },
+    #endif
     { MP_ROM_QSTR(MP_QSTR_mkfs), MP_ROM_PTR(&fat_vfs_mkfs_obj) },
     { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&fat_vfs_open_obj) },
     { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&fat_vfs_ilistdir_obj) },
diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index 443e4eda8..688452973 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -35,6 +35,7 @@
 #define FSUSER_NATIVE       (0x0001) // readblocks[2]/writeblocks[2] contain native func
 #define FSUSER_FREE_OBJ     (0x0002) // fs_user_mount_t obj should be freed on umount
 #define FSUSER_HAVE_IOCTL   (0x0004) // new protocol with ioctl
+#define FSUSER_NO_FILESYSTEM (0x0008) // the block device has no filesystem on it
 
 typedef struct _fs_user_mount_t {
     mp_obj_base_t base;
-- 
cgit v1.2.3


From 5e34a113eaaf736fb4f703a3ee0892e1705d0a63 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 24 Nov 2017 13:04:24 +1100
Subject: py/runtime: Add MP_BINARY_OP_CONTAINS as reverse of MP_BINARY_OP_IN.

Before this patch MP_BINARY_OP_IN had two meanings: coming from bytecode it
meant that the args needed to be swapped, but coming from within the
runtime meant that the args were already in the correct order.  This lead
to some confusion in the code and comments stating how args were reversed.
It also lead to 2 bugs: 1) containment for a subclass of a native type
didn't work; 2) the expression "{True} in True" would illegally succeed and
return True.  In both of these cases it was because the args to
MP_BINARY_OP_IN ended up being reversed twice.

To fix these things this patch introduces MP_BINARY_OP_CONTAINS which
corresponds exactly to the __contains__ special method, and this is the
operator that built-in types should implement.  MP_BINARY_OP_IN is now only
emitted by the compiler and is converted to MP_BINARY_OP_CONTAINS by
swapping the arguments.
---
 extmod/modbtree.c                    |  2 +-
 py/objarray.c                        |  3 +--
 py/objdict.c                         |  4 ++--
 py/objint_mpz.c                      |  2 +-
 py/objset.c                          |  4 ++--
 py/objstr.c                          |  3 +--
 py/objtype.c                         |  2 +-
 py/opmethods.c                       |  2 +-
 py/runtime.c                         | 42 ++++++++++++++++--------------------
 py/runtime0.h                        |  4 ++++
 tests/micropython/viper_error.py.exp |  2 +-
 11 files changed, 34 insertions(+), 36 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modbtree.c b/extmod/modbtree.c
index 5c1311532..8b7688580 100644
--- a/extmod/modbtree.c
+++ b/extmod/modbtree.c
@@ -282,7 +282,7 @@ STATIC mp_obj_t btree_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
 STATIC mp_obj_t btree_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     mp_obj_btree_t *self = MP_OBJ_TO_PTR(lhs_in);
     switch (op) {
-        case MP_BINARY_OP_IN: {
+        case MP_BINARY_OP_CONTAINS: {
             DBT key, val;
             key.data = (void*)mp_obj_str_get_data(rhs_in, &key.size);
             int res = __bt_get(self->db, &key, &val, 0);
diff --git a/py/objarray.c b/py/objarray.c
index 7003ec9e7..a35539484 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -269,8 +269,7 @@ STATIC mp_obj_t array_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
             return lhs_in;
         }
 
-        case MP_BINARY_OP_IN: {
-            /* NOTE `a in b` is `b.__contains__(a)` */
+        case MP_BINARY_OP_CONTAINS: {
             mp_buffer_info_t lhs_bufinfo;
             mp_buffer_info_t rhs_bufinfo;
 
diff --git a/py/objdict.c b/py/objdict.c
index 1553a83b4..d0f95e41a 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -115,7 +115,7 @@ STATIC mp_obj_t dict_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 STATIC mp_obj_t dict_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     mp_obj_dict_t *o = MP_OBJ_TO_PTR(lhs_in);
     switch (op) {
-        case MP_BINARY_OP_IN: {
+        case MP_BINARY_OP_CONTAINS: {
             mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
             return mp_obj_new_bool(elem != NULL);
         }
@@ -485,7 +485,7 @@ STATIC mp_obj_t dict_view_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t
     if (o->kind != MP_DICT_VIEW_KEYS) {
         return MP_OBJ_NULL; // op not supported
     }
-    if (op != MP_BINARY_OP_IN) {
+    if (op != MP_BINARY_OP_CONTAINS) {
         return MP_OBJ_NULL; // op not supported
     }
     return dict_binary_op(op, o->dict, rhs_in);
diff --git a/py/objint_mpz.c b/py/objint_mpz.c
index 7b5cb0b9d..17e3ee6d2 100644
--- a/py/objint_mpz.c
+++ b/py/objint_mpz.c
@@ -207,7 +207,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
         return mp_obj_new_float(flhs / frhs);
 #endif
 
-    } else if (op >= MP_BINARY_OP_INPLACE_OR) {
+    } else if (op >= MP_BINARY_OP_INPLACE_OR && op < MP_BINARY_OP_CONTAINS) {
         mp_obj_int_t *res = mp_obj_int_new_mpz();
 
         switch (op) {
diff --git a/py/objset.c b/py/objset.c
index 6ed15c791..3e98c30e8 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -461,7 +461,7 @@ STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
     #else
     bool update = true;
     #endif
-    if (op != MP_BINARY_OP_IN && !is_set_or_frozenset(rhs)) {
+    if (op != MP_BINARY_OP_CONTAINS && !is_set_or_frozenset(rhs)) {
         // For all ops except containment the RHS must be a set/frozenset
         return MP_OBJ_NULL;
     }
@@ -507,7 +507,7 @@ STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
             return set_issubset(lhs, rhs);
         case MP_BINARY_OP_MORE_EQUAL:
             return set_issuperset(lhs, rhs);
-        case MP_BINARY_OP_IN: {
+        case MP_BINARY_OP_CONTAINS: {
             mp_obj_set_t *o = MP_OBJ_TO_PTR(lhs);
             mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);
             return mp_obj_new_bool(elem != MP_OBJ_NULL);
diff --git a/py/objstr.c b/py/objstr.c
index 1ff5132d2..b4f15b38d 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -384,8 +384,7 @@ mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
             return mp_obj_new_str_from_vstr(lhs_type, &vstr);
         }
 
-        case MP_BINARY_OP_IN:
-            /* NOTE `a in b` is `b.__contains__(a)` */
+        case MP_BINARY_OP_CONTAINS:
             return mp_obj_new_bool(find_subbytes(lhs_data, lhs_len, rhs_data, rhs_len, 1) != NULL);
 
         //case MP_BINARY_OP_NOT_EQUAL: // This is never passed here
diff --git a/py/objtype.c b/py/objtype.c
index 01d248256..267cae815 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -424,7 +424,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_LESS_EQUAL] = MP_QSTR___le__,
     [MP_BINARY_OP_MORE_EQUAL] = MP_QSTR___ge__,
     // MP_BINARY_OP_NOT_EQUAL, // a != b calls a == b and inverts result
-    [MP_BINARY_OP_IN] = MP_QSTR___contains__,
+    [MP_BINARY_OP_CONTAINS] = MP_QSTR___contains__,
 
     // All inplace methods are optional, and normal methods will be used
     // as a fallback.
diff --git a/py/opmethods.c b/py/opmethods.c
index 31901bb52..247fa5bbc 100644
--- a/py/opmethods.c
+++ b/py/opmethods.c
@@ -47,6 +47,6 @@ MP_DEFINE_CONST_FUN_OBJ_2(mp_op_delitem_obj, op_delitem);
 
 STATIC mp_obj_t op_contains(mp_obj_t lhs_in, mp_obj_t rhs_in) {
     mp_obj_type_t *type = mp_obj_get_type(lhs_in);
-    return type->binary_op(MP_BINARY_OP_IN, lhs_in, rhs_in);
+    return type->binary_op(MP_BINARY_OP_CONTAINS, lhs_in, rhs_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_contains_obj, op_contains);
diff --git a/py/runtime.c b/py/runtime.c
index 08a35c2e6..c7fe39367 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -523,30 +523,12 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
         }
     }
 
-    /* deal with `in`
-     *
-     * NOTE `a in b` is `b.__contains__(a)`, hence why the generic dispatch
-     * needs to go below with swapped arguments
-     */
+    // Convert MP_BINARY_OP_IN to MP_BINARY_OP_CONTAINS with swapped args.
     if (op == MP_BINARY_OP_IN) {
-        mp_obj_type_t *type = mp_obj_get_type(rhs);
-        if (type->binary_op != NULL) {
-            mp_obj_t res = type->binary_op(op, rhs, lhs);
-            if (res != MP_OBJ_NULL) {
-                return res;
-            }
-        }
-
-        // final attempt, walk the iterator (will raise if rhs is not iterable)
-        mp_obj_iter_buf_t iter_buf;
-        mp_obj_t iter = mp_getiter(rhs, &iter_buf);
-        mp_obj_t next;
-        while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
-            if (mp_obj_equal(next, lhs)) {
-                return mp_const_true;
-            }
-        }
-        return mp_const_false;
+        op = MP_BINARY_OP_CONTAINS;
+        mp_obj_t temp = lhs;
+        lhs = rhs;
+        rhs = temp;
     }
 
     // generic binary_op supplied by type
@@ -575,6 +557,20 @@ generic_binary_op:
     }
 #endif
 
+    if (op == MP_BINARY_OP_CONTAINS) {
+        // If type didn't support containment then explicitly walk the iterator.
+        // mp_getiter will raise the appropriate exception if lhs is not iterable.
+        mp_obj_iter_buf_t iter_buf;
+        mp_obj_t iter = mp_getiter(lhs, &iter_buf);
+        mp_obj_t next;
+        while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
+            if (mp_obj_equal(next, rhs)) {
+                return mp_const_true;
+            }
+        }
+        return mp_const_false;
+    }
+
 unsupported_op:
     if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
         mp_raise_TypeError("unsupported type for operator");
diff --git a/py/runtime0.h b/py/runtime0.h
index a72b7feb7..960532d17 100644
--- a/py/runtime0.h
+++ b/py/runtime0.h
@@ -131,6 +131,10 @@ typedef enum {
         #endif
     ,
 
+    // The runtime will convert MP_BINARY_OP_IN to this operator with swapped args.
+    // A type should implement this containment operator instead of MP_BINARY_OP_IN.
+    MP_BINARY_OP_CONTAINS,
+
     MP_BINARY_OP_NUM_RUNTIME,
 
     // These 2 are not supported by the runtime and must be synthesised by the emitter
diff --git a/tests/micropython/viper_error.py.exp b/tests/micropython/viper_error.py.exp
index 96be5a590..a44fb3ff0 100644
--- a/tests/micropython/viper_error.py.exp
+++ b/tests/micropython/viper_error.py.exp
@@ -18,7 +18,7 @@ ViperTypeError('must raise an object',)
 ViperTypeError('unary op __pos__ not implemented',)
 ViperTypeError('unary op __neg__ not implemented',)
 ViperTypeError('unary op __invert__ not implemented',)
-ViperTypeError('binary op __contains__ not implemented',)
+ViperTypeError('binary op  not implemented',)
 NotImplementedError('native yield',)
 NotImplementedError('native yield from',)
 NotImplementedError('conversion to object',)
-- 
cgit v1.2.3


From e511f24ddd62f8157ac137f8e4b87e15e5012d70 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 30 Oct 2017 12:48:14 +1100
Subject: extmod/modussl_axtls: Implement key and cert kw args to wrap_socket.

The key and cert must both be a str/bytes object in DER format.
---
 extmod/modussl_axtls.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'extmod')

diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 4d8440a89..35e3106cd 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -44,6 +44,8 @@ typedef struct _mp_obj_ssl_socket_t {
 } mp_obj_ssl_socket_t;
 
 struct ssl_args {
+    mp_arg_val_t key;
+    mp_arg_val_t cert;
     mp_arg_val_t server_side;
     mp_arg_val_t server_hostname;
 };
@@ -62,10 +64,28 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     o->sock = sock;
 
     uint32_t options = SSL_SERVER_VERIFY_LATER;
+    if (args->key.u_obj != mp_const_none) {
+        options |= SSL_NO_DEFAULT_KEY;
+    }
     if ((o->ssl_ctx = ssl_ctx_new(options, SSL_DEFAULT_CLNT_SESS)) == NULL) {
         mp_raise_OSError(MP_EINVAL);
     }
 
+    if (args->key.u_obj != mp_const_none) {
+        size_t len;
+        const byte *data = (const byte*)mp_obj_str_get_data(args->key.u_obj, &len);
+        int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL);
+        if (res != SSL_OK) {
+            mp_raise_ValueError("invalid key");
+        }
+
+        data = (const byte*)mp_obj_str_get_data(args->cert.u_obj, &len);
+        res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL);
+        if (res != SSL_OK) {
+            mp_raise_ValueError("invalid cert");
+        }
+    }
+
     if (args->server_side.u_bool) {
         o->ssl_sock = ssl_server_new(o->ssl_ctx, (long)sock);
     } else {
@@ -211,6 +231,8 @@ STATIC const mp_obj_type_t ussl_socket_type = {
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // TODO: Implement more args
     static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
         { MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
         { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
     };
-- 
cgit v1.2.3


From 48f6990fbc54ac29b15fa765d431244d1dcb5f21 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 31 Oct 2017 13:50:08 +1100
Subject: extmod/modlwip: Commit TCP out data to lower layers if buffer gets
 full.

Dramatically improves TCP sending throughput because without an explicit
call to tcp_output() the data is only sent to the lower layers via the
lwIP slow timer which (by default) ticks every 500ms.
---
 extmod/modlwip.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index bbb01b5d7..2c194e1bd 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -498,6 +498,11 @@ STATIC mp_uint_t lwip_tcp_send(lwip_socket_obj_t *socket, const byte *buf, mp_ui
 
     err_t err = tcp_write(socket->pcb.tcp, buf, write_len, TCP_WRITE_FLAG_COPY);
 
+    // If the output buffer is getting full then send the data to the lower layers
+    if (err == ERR_OK && tcp_sndbuf(socket->pcb.tcp) < TCP_SND_BUF / 4) {
+        err = tcp_output(socket->pcb.tcp);
+    }
+
     if (err != ERR_OK) {
         *_errno = error_lookup_table[-err];
         return MP_STREAM_ERROR;
-- 
cgit v1.2.3


From 6df7b2f2fee71e231927511d4baf58ff86eb7983 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Sun, 26 Nov 2017 23:38:50 +1100
Subject: extmod/machine_signal: Change VLA to use new scoped allocation API.

---
 extmod/machine_signal.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/machine_signal.c b/extmod/machine_signal.c
index 78d0c3fee..3f9f5af94 100644
--- a/extmod/machine_signal.c
+++ b/extmod/machine_signal.c
@@ -58,7 +58,7 @@ STATIC mp_obj_t signal_make_new(const mp_obj_type_t *type, size_t n_args, size_t
         // If first argument isn't a Pin-like object, we filter out "invert"
         // from keyword arguments and pass them all to the exported Pin
         // constructor to create one.
-        mp_obj_t pin_args[n_args + n_kw * 2];
+        mp_obj_t *pin_args = mp_local_alloc((n_args + n_kw * 2) * sizeof(mp_obj_t));
         memcpy(pin_args, args, n_args * sizeof(mp_obj_t));
         const mp_obj_t *src = args + n_args;
         mp_obj_t *dst = pin_args + n_args;
@@ -88,6 +88,8 @@ STATIC mp_obj_t signal_make_new(const mp_obj_type_t *type, size_t n_args, size_t
         // will just ignore it as set a concrete type. If not, we'd need
         // to expose port's "default" pin type too.
         pin = MICROPY_PY_MACHINE_PIN_MAKE_NEW(NULL, n_args, n_kw, pin_args);
+
+        mp_local_free(pin_args);
     }
     else
     #endif
-- 
cgit v1.2.3


From ab750ee2fb6329eb7b0b06ff44a0d0d152ba32b7 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Sun, 26 Nov 2017 23:39:25 +1100
Subject: extmod/modure: Convert alloca() to use new scoped allocation API.

---
 extmod/modure.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modure.c b/extmod/modure.c
index 78de4706d..d0180881d 100644
--- a/extmod/modure.c
+++ b/extmod/modure.c
@@ -144,7 +144,7 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
     }
 
     mp_obj_t retval = mp_obj_new_list(0, NULL);
-    const char **caps = alloca(caps_num * sizeof(char*));
+    const char **caps = mp_local_alloc(caps_num * sizeof(char*));
     while (true) {
         // cast is a workaround for a bug in msvc: it treats const char** as a const pointer instead of a pointer to pointer to const char
         memset((char**)caps, 0, caps_num * sizeof(char*));
@@ -165,6 +165,7 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
             break;
         }
     }
+    mp_local_free(caps);
 
     mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, subj.end - subj.begin);
     mp_obj_list_append(retval, s);
-- 
cgit v1.2.3


From 7df2ebbfeaf390cc257c56916c5af94c7785469f Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 31 Oct 2017 15:54:15 +1100
Subject: extmod/modussl_mbedtls: Clean up mbedtls state when error during
 setup.

Without this patch, if the SSL handshake fails (eg the connection was lost)
then the mbedtls state (memory) will never be freed.
---
 extmod/modussl_mbedtls.c | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 69a64d2f7..197a0651c 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -141,8 +141,7 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     const byte seed[] = "upy";
     ret = mbedtls_ctr_drbg_seed(&o->ctr_drbg, null_entropy_func/*mbedtls_entropy_func*/, &o->entropy, seed, sizeof(seed));
     if (ret != 0) {
-        printf("ret=%d\n", ret);
-        assert(0);
+        goto cleanup;
     }
 
     ret = mbedtls_ssl_config_defaults(&o->conf,
@@ -150,7 +149,7 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
                     MBEDTLS_SSL_TRANSPORT_STREAM,
                     MBEDTLS_SSL_PRESET_DEFAULT);
     if (ret != 0) {
-        assert(0);
+        goto cleanup;
     }
 
     mbedtls_ssl_conf_authmode(&o->conf, MBEDTLS_SSL_VERIFY_NONE);
@@ -161,14 +160,14 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     ret = mbedtls_ssl_setup(&o->ssl, &o->conf);
     if (ret != 0) {
-        assert(0);
+        goto cleanup;
     }
 
     if (args->server_hostname.u_obj != mp_const_none) {
         const char *sni = mp_obj_str_get_str(args->server_hostname.u_obj);
         ret = mbedtls_ssl_set_hostname(&o->ssl, sni);
         if (ret != 0) {
-            assert(0);
+            goto cleanup;
         }
     }
 
@@ -194,13 +193,27 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     while ((ret = mbedtls_ssl_handshake(&o->ssl)) != 0) {
         if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
-            //assert(0);
             printf("mbedtls_ssl_handshake error: -%x\n", -ret);
-            mp_raise_OSError(MP_EIO);
+            goto cleanup;
         }
     }
 
     return o;
+
+cleanup:
+    mbedtls_pk_free(&o->pkey);
+    mbedtls_x509_crt_free(&o->cert);
+    mbedtls_x509_crt_free(&o->cacert);
+    mbedtls_ssl_free(&o->ssl);
+    mbedtls_ssl_config_free(&o->conf);
+    mbedtls_ctr_drbg_free(&o->ctr_drbg);
+    mbedtls_entropy_free(&o->entropy);
+
+    if (ret == MBEDTLS_ERR_SSL_ALLOC_FAILED) {
+        mp_raise_OSError(MP_ENOMEM);
+    } else {
+        mp_raise_OSError(MP_EIO);
+    }
 }
 
 STATIC mp_obj_t mod_ssl_getpeercert(mp_obj_t o_in, mp_obj_t binary_form) {
-- 
cgit v1.2.3


From 1b223a42bf79640d37567c4f427767ee97d45897 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 13 Dec 2017 22:22:57 +1100
Subject: extmod/modure: Add cast to workaround bug in MSVC.

---
 extmod/modure.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modure.c b/extmod/modure.c
index d0180881d..31c2b9864 100644
--- a/extmod/modure.c
+++ b/extmod/modure.c
@@ -165,7 +165,8 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
             break;
         }
     }
-    mp_local_free(caps);
+    // cast is a workaround for a bug in msvc (see above)
+    mp_local_free((char**)caps);
 
     mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, subj.end - subj.begin);
     mp_obj_list_append(retval, s);
-- 
cgit v1.2.3


From 34247465c34113bb26f6c9582ea31f31b0ea0d1b Mon Sep 17 00:00:00 2001
From: Petr Viktorin <encukou@gmail.com>
Date: Sat, 15 Jul 2017 15:53:47 +0200
Subject: extmod/modframebuf: Add 2-bit color format (GS2_HMSB).

This format is used in 2-color LED matrices and in e-ink displays like
SSD1606.
---
 docs/library/framebuf.rst     |  4 +++
 extmod/modframebuf.c          | 30 +++++++++++++++++++++
 tests/extmod/framebuf2.py     | 62 +++++++++++++++++++++++++++++++++++++++++++
 tests/extmod/framebuf2.py.exp | 57 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 153 insertions(+)
 create mode 100644 tests/extmod/framebuf2.py
 create mode 100644 tests/extmod/framebuf2.py.exp

(limited to 'extmod')

diff --git a/docs/library/framebuf.rst b/docs/library/framebuf.rst
index 74c9f8564..4f0026e38 100644
--- a/docs/library/framebuf.rst
+++ b/docs/library/framebuf.rst
@@ -148,6 +148,10 @@ Constants
 
     Red Green Blue (16-bit, 5+6+5) color format
 
+.. data:: framebuf.GS2_HMSB
+
+    Grayscale (2-bit) color format
+
 .. data:: framebuf.GS4_HMSB
 
     Grayscale (4-bit) color format
diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c
index 20e40d579..f2dc4e858 100644
--- a/extmod/modframebuf.c
+++ b/extmod/modframebuf.c
@@ -54,6 +54,7 @@ typedef struct _mp_framebuf_p_t {
 // constants for formats
 #define FRAMEBUF_MVLSB    (0)
 #define FRAMEBUF_RGB565   (1)
+#define FRAMEBUF_GS2_HMSB (5)
 #define FRAMEBUF_GS4_HMSB (2)
 #define FRAMEBUF_MHLSB    (3)
 #define FRAMEBUF_MHMSB    (4)
@@ -130,6 +131,30 @@ STATIC void rgb565_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, i
     }
 }
 
+// Functions for GS2_HMSB format
+
+STATIC void gs2_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
+    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride) >> 2];
+    uint8_t shift = (x & 0x3) << 1;
+    uint8_t mask = 0x3 << shift;
+    uint8_t color = (col & 0x3) << shift;
+    *pixel = color | (*pixel & (~mask));
+}
+
+STATIC uint32_t gs2_hmsb_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
+    uint8_t pixel = ((uint8_t*)fb->buf)[(x + y * fb->stride) >> 2];
+    uint8_t shift = (x & 0x3) << 1;
+    return (pixel >> shift) & 0x3;
+}
+
+STATIC void gs2_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
+    for (int xx=x; xx < x+w; xx++) {
+        for (int yy=y; yy < y+h; yy++) {
+            gs2_hmsb_setpixel(fb, xx, yy, col);
+        }
+    }
+}
+
 // Functions for GS4_HMSB format
 
 STATIC void gs4_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
@@ -184,6 +209,7 @@ STATIC void gs4_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w,
 STATIC mp_framebuf_p_t formats[] = {
     [FRAMEBUF_MVLSB] = {mvlsb_setpixel, mvlsb_getpixel, mvlsb_fill_rect},
     [FRAMEBUF_RGB565] = {rgb565_setpixel, rgb565_getpixel, rgb565_fill_rect},
+    [FRAMEBUF_GS2_HMSB] = {gs2_hmsb_setpixel, gs2_hmsb_getpixel, gs2_hmsb_fill_rect},
     [FRAMEBUF_GS4_HMSB] = {gs4_hmsb_setpixel, gs4_hmsb_getpixel, gs4_hmsb_fill_rect},
     [FRAMEBUF_MHLSB] = {mono_horiz_setpixel, mono_horiz_getpixel, mono_horiz_fill_rect},
     [FRAMEBUF_MHMSB] = {mono_horiz_setpixel, mono_horiz_getpixel, mono_horiz_fill_rect},
@@ -240,6 +266,9 @@ STATIC mp_obj_t framebuf_make_new(const mp_obj_type_t *type, size_t n_args, size
         case FRAMEBUF_MHMSB:
             o->stride = (o->stride + 7) & ~7;
             break;
+        case FRAMEBUF_GS2_HMSB:
+            o->stride = (o->stride + 3) & ~3;
+            break;
         case FRAMEBUF_GS4_HMSB:
             o->stride = (o->stride + 1) & ~1;
             break;
@@ -579,6 +608,7 @@ STATIC const mp_rom_map_elem_t framebuf_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_MVLSB), MP_ROM_INT(FRAMEBUF_MVLSB) },
     { MP_ROM_QSTR(MP_QSTR_MONO_VLSB), MP_ROM_INT(FRAMEBUF_MVLSB) },
     { MP_ROM_QSTR(MP_QSTR_RGB565), MP_ROM_INT(FRAMEBUF_RGB565) },
+    { MP_ROM_QSTR(MP_QSTR_GS2_HMSB), MP_ROM_INT(FRAMEBUF_GS2_HMSB) },
     { MP_ROM_QSTR(MP_QSTR_GS4_HMSB), MP_ROM_INT(FRAMEBUF_GS4_HMSB) },
     { MP_ROM_QSTR(MP_QSTR_MONO_HLSB), MP_ROM_INT(FRAMEBUF_MHLSB) },
     { MP_ROM_QSTR(MP_QSTR_MONO_HMSB), MP_ROM_INT(FRAMEBUF_MHMSB) },
diff --git a/tests/extmod/framebuf2.py b/tests/extmod/framebuf2.py
new file mode 100644
index 000000000..a313170eb
--- /dev/null
+++ b/tests/extmod/framebuf2.py
@@ -0,0 +1,62 @@
+try:
+    import framebuf
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+def printbuf():
+    print("--8<--")
+    for y in range(h):
+        for x in range(w):
+            print('%u' % ((buf[(x + y * w) // 4] >> ((x & 3) << 1)) & 3), end='')
+        print()
+    print("-->8--")
+
+w = 8
+h = 5
+buf = bytearray(w * h // 4)
+fbuf = framebuf.FrameBuffer(buf, w, h, framebuf.GS2_HMSB)
+
+# fill
+fbuf.fill(3)
+printbuf()
+fbuf.fill(0)
+printbuf()
+
+# put pixel
+fbuf.pixel(0, 0, 1)
+fbuf.pixel(3, 0, 2)
+fbuf.pixel(0, 4, 3)
+fbuf.pixel(3, 4, 2)
+printbuf()
+
+# get pixel
+print(fbuf.pixel(0, 4), fbuf.pixel(1, 1))
+
+# scroll
+fbuf.fill(0)
+fbuf.pixel(2, 2, 3)
+printbuf()
+fbuf.scroll(0, 1)
+printbuf()
+fbuf.scroll(1, 0)
+printbuf()
+fbuf.scroll(-1, -2)
+printbuf()
+
+w2 = 2
+h2 = 3
+buf2 = bytearray(w2 * h2 // 4)
+fbuf2 = framebuf.FrameBuffer(buf2, w2, h2, framebuf.GS2_HMSB)
+
+# blit
+fbuf2.fill(0)
+fbuf2.pixel(0, 0, 1)
+fbuf2.pixel(0, 2, 2)
+fbuf2.pixel(1, 0, 1)
+fbuf2.pixel(1, 2, 2)
+fbuf.fill(3)
+fbuf.blit(fbuf2, 3, 3, 0)
+fbuf.blit(fbuf2, -1, -1, 0)
+fbuf.blit(fbuf2, 16, 16, 0)
+printbuf()
diff --git a/tests/extmod/framebuf2.py.exp b/tests/extmod/framebuf2.py.exp
new file mode 100644
index 000000000..c53e518a6
--- /dev/null
+++ b/tests/extmod/framebuf2.py.exp
@@ -0,0 +1,57 @@
+--8<--
+33333333
+33333333
+33333333
+33333333
+33333333
+-->8--
+--8<--
+00000000
+00000000
+00000000
+00000000
+00000000
+-->8--
+--8<--
+10020000
+00000000
+00000000
+00000000
+30020000
+-->8--
+3 0
+--8<--
+00000000
+00000000
+00300000
+00000000
+00000000
+-->8--
+--8<--
+00000000
+00000000
+00000000
+00300000
+00000000
+-->8--
+--8<--
+00000000
+00000000
+00000000
+00030000
+00000000
+-->8--
+--8<--
+00000000
+00300000
+00000000
+00030000
+00000000
+-->8--
+--8<--
+33333333
+23333333
+33333333
+33311333
+33333333
+-->8--
-- 
cgit v1.2.3


From 46b35356e1727365dd5a33fcf3a722fda82c8b08 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 14 Dec 2017 17:36:13 +1100
Subject: extmod/modframebuf: Add 8-bit greyscale format (GS8).

---
 docs/library/framebuf.rst     |  4 ++++
 extmod/modframebuf.c          | 24 ++++++++++++++++++++++++
 tests/extmod/framebuf8.py     | 32 ++++++++++++++++++++++++++++++++
 tests/extmod/framebuf8.py.exp | 15 +++++++++++++++
 4 files changed, 75 insertions(+)
 create mode 100644 tests/extmod/framebuf8.py
 create mode 100644 tests/extmod/framebuf8.py.exp

(limited to 'extmod')

diff --git a/docs/library/framebuf.rst b/docs/library/framebuf.rst
index 4f0026e38..ed4b78ab1 100644
--- a/docs/library/framebuf.rst
+++ b/docs/library/framebuf.rst
@@ -155,3 +155,7 @@ Constants
 .. data:: framebuf.GS4_HMSB
 
     Grayscale (4-bit) color format
+
+.. data:: framebuf.GS8
+
+    Grayscale (8-bit) color format
diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c
index f2dc4e858..a7f6ba905 100644
--- a/extmod/modframebuf.c
+++ b/extmod/modframebuf.c
@@ -56,6 +56,7 @@ typedef struct _mp_framebuf_p_t {
 #define FRAMEBUF_RGB565   (1)
 #define FRAMEBUF_GS2_HMSB (5)
 #define FRAMEBUF_GS4_HMSB (2)
+#define FRAMEBUF_GS8      (6)
 #define FRAMEBUF_MHLSB    (3)
 #define FRAMEBUF_MHMSB    (4)
 
@@ -206,11 +207,31 @@ STATIC void gs4_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w,
     }
 }
 
+// Functions for GS8 format
+
+STATIC void gs8_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
+    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride)];
+    *pixel = col & 0xff;
+}
+
+STATIC uint32_t gs8_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
+    return ((uint8_t*)fb->buf)[(x + y * fb->stride)];
+}
+
+STATIC void gs8_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
+    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride)];
+    while (h--) {
+        memset(pixel, col, w);
+        pixel += fb->stride;
+    }
+}
+
 STATIC mp_framebuf_p_t formats[] = {
     [FRAMEBUF_MVLSB] = {mvlsb_setpixel, mvlsb_getpixel, mvlsb_fill_rect},
     [FRAMEBUF_RGB565] = {rgb565_setpixel, rgb565_getpixel, rgb565_fill_rect},
     [FRAMEBUF_GS2_HMSB] = {gs2_hmsb_setpixel, gs2_hmsb_getpixel, gs2_hmsb_fill_rect},
     [FRAMEBUF_GS4_HMSB] = {gs4_hmsb_setpixel, gs4_hmsb_getpixel, gs4_hmsb_fill_rect},
+    [FRAMEBUF_GS8] = {gs8_setpixel, gs8_getpixel, gs8_fill_rect},
     [FRAMEBUF_MHLSB] = {mono_horiz_setpixel, mono_horiz_getpixel, mono_horiz_fill_rect},
     [FRAMEBUF_MHMSB] = {mono_horiz_setpixel, mono_horiz_getpixel, mono_horiz_fill_rect},
 };
@@ -272,6 +293,8 @@ STATIC mp_obj_t framebuf_make_new(const mp_obj_type_t *type, size_t n_args, size
         case FRAMEBUF_GS4_HMSB:
             o->stride = (o->stride + 1) & ~1;
             break;
+        case FRAMEBUF_GS8:
+            break;
         default:
             mp_raise_ValueError("invalid format");
     }
@@ -610,6 +633,7 @@ STATIC const mp_rom_map_elem_t framebuf_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_RGB565), MP_ROM_INT(FRAMEBUF_RGB565) },
     { MP_ROM_QSTR(MP_QSTR_GS2_HMSB), MP_ROM_INT(FRAMEBUF_GS2_HMSB) },
     { MP_ROM_QSTR(MP_QSTR_GS4_HMSB), MP_ROM_INT(FRAMEBUF_GS4_HMSB) },
+    { MP_ROM_QSTR(MP_QSTR_GS8), MP_ROM_INT(FRAMEBUF_GS8) },
     { MP_ROM_QSTR(MP_QSTR_MONO_HLSB), MP_ROM_INT(FRAMEBUF_MHLSB) },
     { MP_ROM_QSTR(MP_QSTR_MONO_HMSB), MP_ROM_INT(FRAMEBUF_MHMSB) },
 };
diff --git a/tests/extmod/framebuf8.py b/tests/extmod/framebuf8.py
new file mode 100644
index 000000000..b6899aae9
--- /dev/null
+++ b/tests/extmod/framebuf8.py
@@ -0,0 +1,32 @@
+try:
+    import framebuf
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+def printbuf():
+    print("--8<--")
+    for y in range(h):
+        for x in range(w):
+            print('%02x' % buf[(x + y * w)], end='')
+        print()
+    print("-->8--")
+
+w = 8
+h = 5
+buf = bytearray(w * h)
+fbuf = framebuf.FrameBuffer(buf, w, h, framebuf.GS8)
+
+# fill
+fbuf.fill(0x55)
+printbuf()
+
+# put pixel
+fbuf.pixel(0, 0, 0x11)
+fbuf.pixel(w - 1, 0, 0x22)
+fbuf.pixel(0, h - 1, 0x33)
+fbuf.pixel(w - 1, h - 1, 0xff)
+printbuf()
+
+# get pixel
+print(hex(fbuf.pixel(0, h - 1)), hex(fbuf.pixel(1, 1)))
diff --git a/tests/extmod/framebuf8.py.exp b/tests/extmod/framebuf8.py.exp
new file mode 100644
index 000000000..01d8976fe
--- /dev/null
+++ b/tests/extmod/framebuf8.py.exp
@@ -0,0 +1,15 @@
+--8<--
+5555555555555555
+5555555555555555
+5555555555555555
+5555555555555555
+5555555555555555
+-->8--
+--8<--
+1155555555555522
+5555555555555555
+5555555555555555
+5555555555555555
+33555555555555ff
+-->8--
+0x33 0x55
-- 
cgit v1.2.3


From 7642785881550bd71815623c4f93e0516217429c Mon Sep 17 00:00:00 2001
From: Ayke van Laethem <aykevanlaethem@gmail.com>
Date: Tue, 19 Dec 2017 23:47:07 +0100
Subject: extmod/vfs_fat_file: Implement SEEK_CUR for non-zero offset.

CPython doesn't allow SEEK_CUR with non-zero offset for files in text mode,
and uPy inherited this behaviour for both text and binary files.  It makes
sense to provide full support for SEEK_CUR of binary-mode files in uPy, and
to do this in a minimal way means also allowing to use SEEK_CUR with
non-zero offsets on text-mode files.  That seems to be a fair compromise.
---
 extmod/vfs_fat_file.c               | 6 +-----
 tests/extmod/vfs_fat_fileio1.py     | 6 ++----
 tests/extmod/vfs_fat_fileio1.py.exp | 2 +-
 3 files changed, 4 insertions(+), 10 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index 1fcbb253d..6154c8483 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -134,11 +134,7 @@ STATIC mp_uint_t file_obj_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
                 break;
 
             case 1: // SEEK_CUR
-                if (s->offset != 0) {
-                    *errcode = MP_EOPNOTSUPP;
-                    return MP_STREAM_ERROR;
-                }
-                // no-operation
+                f_lseek(&self->fp, f_tell(&self->fp) + s->offset);
                 break;
 
             case 2: // SEEK_END
diff --git a/tests/extmod/vfs_fat_fileio1.py b/tests/extmod/vfs_fat_fileio1.py
index d19df120b..8b9ff92eb 100644
--- a/tests/extmod/vfs_fat_fileio1.py
+++ b/tests/extmod/vfs_fat_fileio1.py
@@ -91,10 +91,8 @@ with open("foo_file.txt") as f2:
 
     f2.seek(0, 1) # SEEK_CUR
     print(f2.read(1))
-    try:
-        f2.seek(1, 1) # SEEK_END
-    except OSError as e:
-        print(e.args[0] == uerrno.EOPNOTSUPP)
+    f2.seek(2, 1) # SEEK_CUR
+    print(f2.read(1))
 
     f2.seek(-2, 2) # SEEK_END
     print(f2.read(1))
diff --git a/tests/extmod/vfs_fat_fileio1.py.exp b/tests/extmod/vfs_fat_fileio1.py.exp
index d777585cf..a66f07605 100644
--- a/tests/extmod/vfs_fat_fileio1.py.exp
+++ b/tests/extmod/vfs_fat_fileio1.py.exp
@@ -7,7 +7,7 @@ hello!world!
 12
 h
 e
-True
+o
 d
 True
 [('foo_dir', 16384, 0)]
-- 
cgit v1.2.3


From d9bca1f7bddad762aac72b0fcbdd84eb22e1c3c1 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 6 Feb 2018 15:35:52 +1100
Subject: extmod/modujson: Implement ujson.dump() function.

---
 extmod/modujson.c          | 11 +++++++++++
 tests/extmod/ujson_dump.py | 18 ++++++++++++++++++
 2 files changed, 29 insertions(+)
 create mode 100644 tests/extmod/ujson_dump.py

(limited to 'extmod')

diff --git a/extmod/modujson.c b/extmod/modujson.c
index 6eeba4ed6..f731d7193 100644
--- a/extmod/modujson.c
+++ b/extmod/modujson.c
@@ -34,6 +34,16 @@
 
 #if MICROPY_PY_UJSON
 
+STATIC mp_obj_t mod_ujson_dump(mp_obj_t obj, mp_obj_t stream) {
+    if (!MP_OBJ_IS_OBJ(stream)) {
+        mp_raise_TypeError(NULL);
+    }
+    mp_print_t print = {MP_OBJ_TO_PTR(stream), mp_stream_write_adaptor};
+    mp_obj_print_helper(&print, obj, PRINT_JSON);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_ujson_dump_obj, mod_ujson_dump);
+
 STATIC mp_obj_t mod_ujson_dumps(mp_obj_t obj) {
     vstr_t vstr;
     mp_print_t print;
@@ -283,6 +293,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_loads_obj, mod_ujson_loads);
 
 STATIC const mp_rom_map_elem_t mp_module_ujson_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ujson) },
+    { MP_ROM_QSTR(MP_QSTR_dump), MP_ROM_PTR(&mod_ujson_dump_obj) },
     { MP_ROM_QSTR(MP_QSTR_dumps), MP_ROM_PTR(&mod_ujson_dumps_obj) },
     { MP_ROM_QSTR(MP_QSTR_load), MP_ROM_PTR(&mod_ujson_load_obj) },
     { MP_ROM_QSTR(MP_QSTR_loads), MP_ROM_PTR(&mod_ujson_loads_obj) },
diff --git a/tests/extmod/ujson_dump.py b/tests/extmod/ujson_dump.py
new file mode 100644
index 000000000..c80e533ed
--- /dev/null
+++ b/tests/extmod/ujson_dump.py
@@ -0,0 +1,18 @@
+try:
+    from uio import StringIO
+    import ujson as json
+except:
+    try:
+        from io import StringIO
+        import json
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+s = StringIO()
+json.dump(False, s)
+print(s.getvalue())
+
+s = StringIO()
+json.dump({"a": (2, [3, None])}, s)
+print(s.getvalue())
-- 
cgit v1.2.3


From ae4a07730af7fe4f62f9f61e8b600e39f557925e Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 23 Feb 2018 17:17:32 +1100
Subject: extmod/vfs_fat: Move ilistdir implementation from misc to main file.

The fat_vfs_ilistdir2() function was only used by fat_vfs_ilistdir_func()
so moving the former into the same file as the latter allows it to be
placed directly into the latter function, thus saving code size.
---
 extmod/vfs_fat.c      | 58 +++++++++++++++++++++++++++++++++++++++++++++++++-
 extmod/vfs_fat.h      |  2 --
 extmod/vfs_fat_misc.c | 59 ---------------------------------------------------
 3 files changed, 57 insertions(+), 62 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 0076df262..58af0a8e8 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -109,6 +109,52 @@ STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(fat_vfs_mkfs_obj, MP_ROM_PTR(&fat_vfs_mk
 
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fatfs_builtin_open_self);
 
+typedef struct _mp_vfs_fat_ilistdir_it_t {
+    mp_obj_base_t base;
+    mp_fun_1_t iternext;
+    bool is_str;
+    FF_DIR dir;
+} mp_vfs_fat_ilistdir_it_t;
+
+STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
+    mp_vfs_fat_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
+
+    for (;;) {
+        FILINFO fno;
+        FRESULT res = f_readdir(&self->dir, &fno);
+        char *fn = fno.fname;
+        if (res != FR_OK || fn[0] == 0) {
+            // stop on error or end of dir
+            break;
+        }
+
+        // Note that FatFS already filters . and .., so we don't need to
+
+        // make 3-tuple with info about this entry
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
+        if (self->is_str) {
+            t->items[0] = mp_obj_new_str(fn, strlen(fn));
+        } else {
+            t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
+        }
+        if (fno.fattrib & AM_DIR) {
+            // dir
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
+        } else {
+            // file
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
+        }
+        t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
+
+        return MP_OBJ_FROM_PTR(t);
+    }
+
+    // ignore error because we may be closing a second time
+    f_closedir(&self->dir);
+
+    return MP_OBJ_STOP_ITERATION;
+}
+
 STATIC mp_obj_t fat_vfs_ilistdir_func(size_t n_args, const mp_obj_t *args) {
     mp_obj_fat_vfs_t *self = MP_OBJ_TO_PTR(args[0]);
     bool is_str_type = true;
@@ -122,7 +168,17 @@ STATIC mp_obj_t fat_vfs_ilistdir_func(size_t n_args, const mp_obj_t *args) {
         path = "";
     }
 
-    return fat_vfs_ilistdir2(self, path, is_str_type);
+    // Create a new iterator object to list the dir
+    mp_vfs_fat_ilistdir_it_t *iter = m_new_obj(mp_vfs_fat_ilistdir_it_t);
+    iter->base.type = &mp_type_polymorph_iter;
+    iter->iternext = mp_vfs_fat_ilistdir_it_iternext;
+    iter->is_str = is_str_type;
+    FRESULT res = f_opendir(&self->fatfs, &iter->dir, path);
+    if (res != FR_OK) {
+        mp_raise_OSError(fresult_to_errno_table[res]);
+    }
+
+    return MP_OBJ_FROM_PTR(iter);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fat_vfs_ilistdir_obj, 1, 2, fat_vfs_ilistdir_func);
 
diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index 688452973..b6a4795bb 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -60,6 +60,4 @@ mp_import_stat_t fat_vfs_import_stat(struct _fs_user_mount_t *vfs, const char *p
 mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode);
 MP_DECLARE_CONST_FUN_OBJ_KW(mp_builtin_open_obj);
 
-mp_obj_t fat_vfs_ilistdir2(struct _fs_user_mount_t *vfs, const char *path, bool is_str_type);
-
 #endif // MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
diff --git a/extmod/vfs_fat_misc.c b/extmod/vfs_fat_misc.c
index 1f90ac14c..d72d9c69c 100644
--- a/extmod/vfs_fat_misc.c
+++ b/extmod/vfs_fat_misc.c
@@ -31,65 +31,6 @@
 #include "py/runtime.h"
 #include "lib/oofatfs/ff.h"
 #include "extmod/vfs_fat.h"
-#include "py/lexer.h"
-
-typedef struct _mp_vfs_fat_ilistdir_it_t {
-    mp_obj_base_t base;
-    mp_fun_1_t iternext;
-    bool is_str;
-    FF_DIR dir;
-} mp_vfs_fat_ilistdir_it_t;
-
-STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
-    mp_vfs_fat_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
-
-    for (;;) {
-        FILINFO fno;
-        FRESULT res = f_readdir(&self->dir, &fno);
-        char *fn = fno.fname;
-        if (res != FR_OK || fn[0] == 0) {
-            // stop on error or end of dir
-            break;
-        }
-
-        // Note that FatFS already filters . and .., so we don't need to
-
-        // make 3-tuple with info about this entry
-        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
-        if (self->is_str) {
-            t->items[0] = mp_obj_new_str(fn, strlen(fn));
-        } else {
-            t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
-        }
-        if (fno.fattrib & AM_DIR) {
-            // dir
-            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
-        } else {
-            // file
-            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
-        }
-        t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
-
-        return MP_OBJ_FROM_PTR(t);
-    }
-
-    // ignore error because we may be closing a second time
-    f_closedir(&self->dir);
-
-    return MP_OBJ_STOP_ITERATION;
-}
-
-mp_obj_t fat_vfs_ilistdir2(fs_user_mount_t *vfs, const char *path, bool is_str_type) {
-    mp_vfs_fat_ilistdir_it_t *iter = m_new_obj(mp_vfs_fat_ilistdir_it_t);
-    iter->base.type = &mp_type_polymorph_iter;
-    iter->iternext = mp_vfs_fat_ilistdir_it_iternext;
-    iter->is_str = is_str_type;
-    FRESULT res = f_opendir(&vfs->fatfs, &iter->dir, path);
-    if (res != FR_OK) {
-        mp_raise_OSError(fresult_to_errno_table[res]);
-    }
-    return MP_OBJ_FROM_PTR(iter);
-}
 
 mp_import_stat_t fat_vfs_import_stat(fs_user_mount_t *vfs, const char *path) {
     FILINFO fno;
-- 
cgit v1.2.3


From 638b860066ddf6a684ce2d573917b3c8a5817ba2 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 23 Feb 2018 17:24:57 +1100
Subject: extmod/vfs_fat: Merge remaining vfs_fat_misc.c code into vfs_fat.c.

The only function left in vfs_fat_misc.c is fat_vfs_import_stat() which
can logically go into vfs_fat.c, allowing to remove vfs_fat_misc.c.
---
 extmod/vfs_fat.c      | 14 ++++++++++++++
 extmod/vfs_fat_misc.c | 49 -------------------------------------------------
 py/py.mk              |  1 -
 3 files changed, 14 insertions(+), 50 deletions(-)
 delete mode 100644 extmod/vfs_fat_misc.c

(limited to 'extmod')

diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 58af0a8e8..e696e0fa8 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -47,6 +47,20 @@
 
 #define mp_obj_fat_vfs_t fs_user_mount_t
 
+mp_import_stat_t fat_vfs_import_stat(fs_user_mount_t *vfs, const char *path) {
+    FILINFO fno;
+    assert(vfs != NULL);
+    FRESULT res = f_stat(&vfs->fatfs, path, &fno);
+    if (res == FR_OK) {
+        if ((fno.fattrib & AM_DIR) != 0) {
+            return MP_IMPORT_STAT_DIR;
+        } else {
+            return MP_IMPORT_STAT_FILE;
+        }
+    }
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
 STATIC mp_obj_t fat_vfs_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
 
diff --git a/extmod/vfs_fat_misc.c b/extmod/vfs_fat_misc.c
deleted file mode 100644
index d72d9c69c..000000000
--- a/extmod/vfs_fat_misc.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2014 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
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "py/mpconfig.h"
-#if MICROPY_VFS_FAT
-
-#include <string.h>
-#include "py/runtime.h"
-#include "lib/oofatfs/ff.h"
-#include "extmod/vfs_fat.h"
-
-mp_import_stat_t fat_vfs_import_stat(fs_user_mount_t *vfs, const char *path) {
-    FILINFO fno;
-    assert(vfs != NULL);
-    FRESULT res = f_stat(&vfs->fatfs, path, &fno);
-    if (res == FR_OK) {
-        if ((fno.fattrib & AM_DIR) != 0) {
-            return MP_IMPORT_STAT_DIR;
-        } else {
-            return MP_IMPORT_STAT_FILE;
-        }
-    }
-    return MP_IMPORT_STAT_NO_EXIST;
-}
-
-#endif // MICROPY_VFS_FAT
diff --git a/py/py.mk b/py/py.mk
index 879c63248..7c4cf82d8 100644
--- a/py/py.mk
+++ b/py/py.mk
@@ -244,7 +244,6 @@ PY_EXTMOD_O_BASENAME = \
 	extmod/vfs_fat.o \
 	extmod/vfs_fat_diskio.o \
 	extmod/vfs_fat_file.o \
-	extmod/vfs_fat_misc.o \
 	extmod/utime_mphal.o \
 	extmod/uos_dupterm.o \
 	lib/embed/abort_.o \
-- 
cgit v1.2.3


From eb570f47a2ec48285fcfab5643301862fa4fe544 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 23 Feb 2018 17:33:26 +1100
Subject: extmod/vfs_fat: Make fat_vfs_open_obj wrapper public, not its
 function.

This patch just moves the definition of the wrapper object fat_vfs_open_obj
to the location of the definition of its function, which matches how it's
done in most other places in the code base.
---
 extmod/vfs_fat.c      | 2 --
 extmod/vfs_fat.h      | 2 +-
 extmod/vfs_fat_file.c | 3 ++-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index e696e0fa8..0177f5129 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -121,8 +121,6 @@ STATIC mp_obj_t fat_vfs_mkfs(mp_obj_t bdev_in) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(fat_vfs_mkfs_fun_obj, fat_vfs_mkfs);
 STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(fat_vfs_mkfs_obj, MP_ROM_PTR(&fat_vfs_mkfs_fun_obj));
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fatfs_builtin_open_self);
-
 typedef struct _mp_vfs_fat_ilistdir_it_t {
     mp_obj_base_t base;
     mp_fun_1_t iternext;
diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index b6a4795bb..14597158f 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -57,7 +57,7 @@ extern const byte fresult_to_errno_table[20];
 extern const mp_obj_type_t mp_fat_vfs_type;
 
 mp_import_stat_t fat_vfs_import_stat(struct _fs_user_mount_t *vfs, const char *path);
-mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode);
+MP_DECLARE_CONST_FUN_OBJ_3(fat_vfs_open_obj);
 MP_DECLARE_CONST_FUN_OBJ_KW(mp_builtin_open_obj);
 
 #endif // MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index 6154c8483..23e5aa10f 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -282,7 +282,7 @@ const mp_obj_type_t mp_type_textio = {
 };
 
 // Factory function for I/O stream classes
-mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode) {
+STATIC mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode) {
     // TODO: analyze buffering args and instantiate appropriate type
     fs_user_mount_t *self = MP_OBJ_TO_PTR(self_in);
     mp_arg_val_t arg_vals[FILE_OPEN_NUM_ARGS];
@@ -291,5 +291,6 @@ mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode)
     arg_vals[2].u_obj = mp_const_none;
     return file_open(self, &mp_type_textio, arg_vals);
 }
+MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fatfs_builtin_open_self);
 
 #endif // MICROPY_VFS && MICROPY_VFS_FAT
-- 
cgit v1.2.3


From 2ad555bc760833aae9991a4e6c893daa790c0c89 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 23 Feb 2018 17:41:47 +1100
Subject: extmod/vfs_fat: Remove declaration of mp_builtin_open_obj.

It's declared already in py/builtin.h.
---
 extmod/vfs_fat.h | 1 -
 1 file changed, 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index 14597158f..da56a9077 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -58,6 +58,5 @@ extern const mp_obj_type_t mp_fat_vfs_type;
 
 mp_import_stat_t fat_vfs_import_stat(struct _fs_user_mount_t *vfs, const char *path);
 MP_DECLARE_CONST_FUN_OBJ_3(fat_vfs_open_obj);
-MP_DECLARE_CONST_FUN_OBJ_KW(mp_builtin_open_obj);
 
 #endif // MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
-- 
cgit v1.2.3


From 09be031e047f0e7ba77620c29c5abbdbd5e3d055 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 28 Feb 2018 15:11:20 +1100
Subject: extmod/vfs_fat_diskio: Use a C-stack-allocated bytearray for block
 buf.

This patch eliminates heap allocation in the VFS FAT disk IO layer, when
calling the underlying readblocks/writeblocks methods.  The bytearray
object that is passed to these methods is now allocated on the C stack
rather than the heap (it's only 4 words big).

This means that these methods should not retain a pointer to the buffer
object that is passed in, but this was already a restriction because the
original heap-allocated bytearray had its buffer passed by reference.
---
 extmod/vfs_fat_diskio.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat_diskio.c b/extmod/vfs_fat_diskio.c
index ff23c6b0c..712038f3e 100644
--- a/extmod/vfs_fat_diskio.c
+++ b/extmod/vfs_fat_diskio.c
@@ -36,6 +36,8 @@
 #include "py/mphal.h"
 
 #include "py/runtime.h"
+#include "py/binary.h"
+#include "py/objarray.h"
 #include "lib/oofatfs/ff.h"
 #include "lib/oofatfs/diskio.h"
 #include "extmod/vfs_fat.h"
@@ -126,8 +128,9 @@ DRESULT disk_read (
             return RES_ERROR;
         }
     } else {
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, count * SECSIZE(&vfs->fatfs), buff};
         vfs->readblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
-        vfs->readblocks[3] = mp_obj_new_bytearray_by_ref(count * SECSIZE(&vfs->fatfs), buff);
+        vfs->readblocks[3] = MP_OBJ_FROM_PTR(&ar);
         mp_call_method_n_kw(2, 0, vfs->readblocks);
         // TODO handle error return
     }
@@ -162,8 +165,9 @@ DRESULT disk_write (
             return RES_ERROR;
         }
     } else {
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, count * SECSIZE(&vfs->fatfs), (void*)buff};
         vfs->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
-        vfs->writeblocks[3] = mp_obj_new_bytearray_by_ref(count * SECSIZE(&vfs->fatfs), (void*)buff);
+        vfs->writeblocks[3] = MP_OBJ_FROM_PTR(&ar);
         mp_call_method_n_kw(2, 0, vfs->writeblocks);
         // TODO handle error return
     }
-- 
cgit v1.2.3


From 21d5527edf37ba550316ea0dbac87253c7791bd1 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 2 Mar 2018 19:12:52 +1100
Subject: extmod/machine_spi: Make SPI protocol structure public.

So it can be referenced directly without the need for the uPy object.
---
 extmod/machine_spi.c | 2 +-
 extmod/machine_spi.h | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/machine_spi.c b/extmod/machine_spi.c
index a67d294ba..cfd94fcef 100644
--- a/extmod/machine_spi.c
+++ b/extmod/machine_spi.c
@@ -321,7 +321,7 @@ STATIC void mp_machine_soft_spi_init(mp_obj_base_t *self_in, size_t n_args, cons
     mp_hal_pin_input(self->miso);
 }
 
-STATIC const mp_machine_spi_p_t mp_machine_soft_spi_p = {
+const mp_machine_spi_p_t mp_machine_soft_spi_p = {
     .init = mp_machine_soft_spi_init,
     .deinit = NULL,
     .transfer = mp_machine_soft_spi_transfer,
diff --git a/extmod/machine_spi.h b/extmod/machine_spi.h
index e24e41eb3..3ee1b241f 100644
--- a/extmod/machine_spi.h
+++ b/extmod/machine_spi.h
@@ -46,6 +46,7 @@ typedef struct _mp_machine_soft_spi_obj_t {
     mp_hal_pin_obj_t miso;
 } mp_machine_soft_spi_obj_t;
 
+extern const mp_machine_spi_p_t mp_machine_soft_spi_p;
 extern const mp_obj_type_t mp_machine_soft_spi_type;
 extern const mp_obj_dict_t mp_machine_spi_locals_dict;
 
-- 
cgit v1.2.3


From 58ebeca6a9a172a35b9298a911d450722797c409 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 9 Mar 2018 17:25:58 +1100
Subject: drivers/bus: Pull out software SPI implementation to dedicated
 driver.

This patch takes the software SPI implementation from extmod/machine_spi.c
and moves it to a dedicated file in drivers/bus/softspi.c.  This allows the
SPI driver to be used independently of the uPy runtime, making it a more
general component.
---
 drivers/bus/softspi.c           | 105 ++++++++++++++++++++++++++++++++++++
 drivers/bus/spi.h               |  55 +++++++++++++++++++
 extmod/machine_spi.c            | 114 ++++++++++------------------------------
 extmod/machine_spi.h            |  10 +---
 ports/esp32/Makefile            |   1 +
 ports/esp32/mpconfigport.h      |   4 +-
 ports/esp8266/Makefile          |   1 +
 ports/esp8266/esp8266_common.ld |   1 +
 ports/stm32/Makefile            |   1 +
 ports/stm32/mpconfigport.h      |   4 +-
 ports/stm32/spibdev.c           |   4 +-
 11 files changed, 202 insertions(+), 98 deletions(-)
 create mode 100644 drivers/bus/softspi.c
 create mode 100644 drivers/bus/spi.h

(limited to 'extmod')

diff --git a/drivers/bus/softspi.c b/drivers/bus/softspi.c
new file mode 100644
index 000000000..bc12d89d3
--- /dev/null
+++ b/drivers/bus/softspi.c
@@ -0,0 +1,105 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016-2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "drivers/bus/spi.h"
+
+int mp_soft_spi_ioctl(void *self_in, uint32_t cmd) {
+    mp_soft_spi_obj_t *self = (mp_soft_spi_obj_t*)self_in;
+
+    switch (cmd) {
+        case MP_SPI_IOCTL_INIT:
+            mp_hal_pin_write(self->sck, self->polarity);
+            mp_hal_pin_output(self->sck);
+            mp_hal_pin_output(self->mosi);
+            mp_hal_pin_input(self->miso);
+            break;
+
+        case MP_SPI_IOCTL_DEINIT:
+            break;
+    }
+
+    return 0;
+}
+
+void mp_soft_spi_transfer(void *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
+    mp_soft_spi_obj_t *self = (mp_soft_spi_obj_t*)self_in;
+    uint32_t delay_half = self->delay_half;
+
+    // only MSB transfer is implemented
+
+    // If a port defines MICROPY_HW_SOFTSPI_MIN_DELAY, and the configured
+    // delay_half is equal to this value, then the software SPI implementation
+    // will run as fast as possible, limited only by CPU speed and GPIO time.
+    #ifdef MICROPY_HW_SOFTSPI_MIN_DELAY
+    if (delay_half == MICROPY_HW_SOFTSPI_MIN_DELAY) {
+        for (size_t i = 0; i < len; ++i) {
+            uint8_t data_out = src[i];
+            uint8_t data_in = 0;
+            for (int j = 0; j < 8; ++j, data_out <<= 1) {
+                mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
+                mp_hal_pin_write(self->sck, 1 - self->polarity);
+                data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
+                mp_hal_pin_write(self->sck, self->polarity);
+            }
+            if (dest != NULL) {
+                dest[i] = data_in;
+            }
+        }
+        return;
+    }
+    #endif
+
+    for (size_t i = 0; i < len; ++i) {
+        uint8_t data_out = src[i];
+        uint8_t data_in = 0;
+        for (int j = 0; j < 8; ++j, data_out <<= 1) {
+            mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
+            if (self->phase == 0) {
+                mp_hal_delay_us_fast(delay_half);
+                mp_hal_pin_write(self->sck, 1 - self->polarity);
+            } else {
+                mp_hal_pin_write(self->sck, 1 - self->polarity);
+                mp_hal_delay_us_fast(delay_half);
+            }
+            data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
+            if (self->phase == 0) {
+                mp_hal_delay_us_fast(delay_half);
+                mp_hal_pin_write(self->sck, self->polarity);
+            } else {
+                mp_hal_pin_write(self->sck, self->polarity);
+                mp_hal_delay_us_fast(delay_half);
+            }
+        }
+        if (dest != NULL) {
+            dest[i] = data_in;
+        }
+    }
+}
+
+const mp_spi_proto_t mp_soft_spi_proto = {
+    .ioctl = mp_soft_spi_ioctl,
+    .transfer = mp_soft_spi_transfer,
+};
diff --git a/drivers/bus/spi.h b/drivers/bus/spi.h
new file mode 100644
index 000000000..6d1b9c2f8
--- /dev/null
+++ b/drivers/bus/spi.h
@@ -0,0 +1,55 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016-2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
+#define MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
+
+#include "py/mphal.h"
+
+enum {
+    MP_SPI_IOCTL_INIT,
+    MP_SPI_IOCTL_DEINIT,
+};
+
+typedef struct _mp_spi_proto_t {
+    int (*ioctl)(void *self, uint32_t cmd);
+    void (*transfer)(void *self, size_t len, const uint8_t *src, uint8_t *dest);
+} mp_spi_proto_t;
+
+typedef struct _mp_soft_spi_obj_t {
+    uint32_t delay_half; // microsecond delay for half SCK period
+    uint8_t polarity;
+    uint8_t phase;
+    mp_hal_pin_obj_t sck;
+    mp_hal_pin_obj_t mosi;
+    mp_hal_pin_obj_t miso;
+} mp_soft_spi_obj_t;
+
+extern const mp_spi_proto_t mp_soft_spi_proto;
+
+int mp_soft_spi_ioctl(void *self, uint32_t cmd);
+void mp_soft_spi_transfer(void *self, size_t len, const uint8_t *src, uint8_t *dest);
+
+#endif // MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
diff --git a/extmod/machine_spi.c b/extmod/machine_spi.c
index cfd94fcef..f0c4896c2 100644
--- a/extmod/machine_spi.c
+++ b/extmod/machine_spi.c
@@ -38,61 +38,6 @@
 #define MICROPY_PY_MACHINE_SPI_LSB (1)
 #endif
 
-void mp_machine_soft_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
-    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t*)self_in;
-    uint32_t delay_half = self->delay_half;
-
-    // only MSB transfer is implemented
-
-    // If a port defines MICROPY_PY_MACHINE_SPI_MIN_DELAY, and the configured
-    // delay_half is equal to this value, then the software SPI implementation
-    // will run as fast as possible, limited only by CPU speed and GPIO time.
-    #ifdef MICROPY_PY_MACHINE_SPI_MIN_DELAY
-    if (delay_half == MICROPY_PY_MACHINE_SPI_MIN_DELAY) {
-        for (size_t i = 0; i < len; ++i) {
-            uint8_t data_out = src[i];
-            uint8_t data_in = 0;
-            for (int j = 0; j < 8; ++j, data_out <<= 1) {
-                mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
-                mp_hal_pin_write(self->sck, 1 - self->polarity);
-                data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
-                mp_hal_pin_write(self->sck, self->polarity);
-            }
-            if (dest != NULL) {
-                dest[i] = data_in;
-            }
-        }
-        return;
-    }
-    #endif
-
-    for (size_t i = 0; i < len; ++i) {
-        uint8_t data_out = src[i];
-        uint8_t data_in = 0;
-        for (int j = 0; j < 8; ++j, data_out <<= 1) {
-            mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
-            if (self->phase == 0) {
-                mp_hal_delay_us_fast(delay_half);
-                mp_hal_pin_write(self->sck, 1 - self->polarity);
-            } else {
-                mp_hal_pin_write(self->sck, 1 - self->polarity);
-                mp_hal_delay_us_fast(delay_half);
-            }
-            data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
-            if (self->phase == 0) {
-                mp_hal_delay_us_fast(delay_half);
-                mp_hal_pin_write(self->sck, self->polarity);
-            } else {
-                mp_hal_pin_write(self->sck, self->polarity);
-                mp_hal_delay_us_fast(delay_half);
-            }
-        }
-        if (dest != NULL) {
-            dest[i] = data_in;
-        }
-    }
-}
-
 /******************************************************************************/
 // MicroPython bindings for generic machine.SPI
 
@@ -199,9 +144,9 @@ MP_DEFINE_CONST_DICT(mp_machine_spi_locals_dict, machine_spi_locals_dict_table);
 // Implementation of soft SPI
 
 STATIC uint32_t baudrate_from_delay_half(uint32_t delay_half) {
-    #ifdef MICROPY_PY_MACHINE_SPI_MIN_DELAY
-    if (delay_half == MICROPY_PY_MACHINE_SPI_MIN_DELAY) {
-        return MICROPY_PY_MACHINE_SPI_MAX_BAUDRATE;
+    #ifdef MICROPY_HW_SOFTSPI_MIN_DELAY
+    if (delay_half == MICROPY_HW_SOFTSPI_MIN_DELAY) {
+        return MICROPY_HW_SOFTSPI_MAX_BAUDRATE;
     } else
     #endif
     {
@@ -210,9 +155,9 @@ STATIC uint32_t baudrate_from_delay_half(uint32_t delay_half) {
 }
 
 STATIC uint32_t baudrate_to_delay_half(uint32_t baudrate) {
-    #ifdef MICROPY_PY_MACHINE_SPI_MIN_DELAY
-    if (baudrate >= MICROPY_PY_MACHINE_SPI_MAX_BAUDRATE) {
-        return MICROPY_PY_MACHINE_SPI_MIN_DELAY;
+    #ifdef MICROPY_HW_SOFTSPI_MIN_DELAY
+    if (baudrate >= MICROPY_HW_SOFTSPI_MAX_BAUDRATE) {
+        return MICROPY_HW_SOFTSPI_MIN_DELAY;
     } else
     #endif
     {
@@ -229,8 +174,8 @@ STATIC void mp_machine_soft_spi_print(const mp_print_t *print, mp_obj_t self_in,
     mp_machine_soft_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "SoftSPI(baudrate=%u, polarity=%u, phase=%u,"
         " sck=" MP_HAL_PIN_FMT ", mosi=" MP_HAL_PIN_FMT ", miso=" MP_HAL_PIN_FMT ")",
-        baudrate_from_delay_half(self->delay_half), self->polarity, self->phase,
-        mp_hal_pin_name(self->sck), mp_hal_pin_name(self->mosi), mp_hal_pin_name(self->miso));
+        baudrate_from_delay_half(self->spi.delay_half), self->spi.polarity, self->spi.phase,
+        mp_hal_pin_name(self->spi.sck), mp_hal_pin_name(self->spi.mosi), mp_hal_pin_name(self->spi.miso));
 }
 
 STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
@@ -253,9 +198,9 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
     self->base.type = &mp_machine_soft_spi_type;
 
     // set parameters
-    self->delay_half = baudrate_to_delay_half(args[ARG_baudrate].u_int);
-    self->polarity = args[ARG_polarity].u_int;
-    self->phase = args[ARG_phase].u_int;
+    self->spi.delay_half = baudrate_to_delay_half(args[ARG_baudrate].u_int);
+    self->spi.polarity = args[ARG_polarity].u_int;
+    self->spi.phase = args[ARG_phase].u_int;
     if (args[ARG_bits].u_int != 8) {
         mp_raise_ValueError("bits must be 8");
     }
@@ -267,15 +212,12 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
         || args[ARG_miso].u_obj == MP_OBJ_NULL) {
         mp_raise_ValueError("must specify all of sck/mosi/miso");
     }
-    self->sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
-    self->mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);
-    self->miso = mp_hal_get_pin_obj(args[ARG_miso].u_obj);
+    self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
+    self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);
+    self->spi.miso = mp_hal_get_pin_obj(args[ARG_miso].u_obj);
 
-    // configure pins
-    mp_hal_pin_write(self->sck, self->polarity);
-    mp_hal_pin_output(self->sck);
-    mp_hal_pin_output(self->mosi);
-    mp_hal_pin_input(self->miso);
+    // configure bus
+    mp_soft_spi_ioctl(&self->spi, MP_SPI_IOCTL_INIT);
 
     return MP_OBJ_FROM_PTR(self);
 }
@@ -296,29 +238,31 @@ STATIC void mp_machine_soft_spi_init(mp_obj_base_t *self_in, size_t n_args, cons
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     if (args[ARG_baudrate].u_int != -1) {
-        self->delay_half = baudrate_to_delay_half(args[ARG_baudrate].u_int);
+        self->spi.delay_half = baudrate_to_delay_half(args[ARG_baudrate].u_int);
     }
     if (args[ARG_polarity].u_int != -1) {
-        self->polarity = args[ARG_polarity].u_int;
+        self->spi.polarity = args[ARG_polarity].u_int;
     }
     if (args[ARG_phase].u_int != -1) {
-        self->phase = args[ARG_phase].u_int;
+        self->spi.phase = args[ARG_phase].u_int;
     }
     if (args[ARG_sck].u_obj != MP_OBJ_NULL) {
-        self->sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
+        self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
     }
     if (args[ARG_mosi].u_obj != MP_OBJ_NULL) {
-        self->mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);
+        self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);
     }
     if (args[ARG_miso].u_obj != MP_OBJ_NULL) {
-        self->miso = mp_hal_get_pin_obj(args[ARG_miso].u_obj);
+        self->spi.miso = mp_hal_get_pin_obj(args[ARG_miso].u_obj);
     }
 
-    // configure pins
-    mp_hal_pin_write(self->sck, self->polarity);
-    mp_hal_pin_output(self->sck);
-    mp_hal_pin_output(self->mosi);
-    mp_hal_pin_input(self->miso);
+    // configure bus
+    mp_soft_spi_ioctl(&self->spi, MP_SPI_IOCTL_INIT);
+}
+
+STATIC void mp_machine_soft_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
+    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t*)self_in;
+    mp_soft_spi_transfer(&self->spi, len, src, dest);
 }
 
 const mp_machine_spi_p_t mp_machine_soft_spi_p = {
diff --git a/extmod/machine_spi.h b/extmod/machine_spi.h
index 3ee1b241f..db21e1cd3 100644
--- a/extmod/machine_spi.h
+++ b/extmod/machine_spi.h
@@ -28,6 +28,7 @@
 
 #include "py/obj.h"
 #include "py/mphal.h"
+#include "drivers/bus/spi.h"
 
 // SPI protocol
 typedef struct _mp_machine_spi_p_t {
@@ -38,20 +39,13 @@ typedef struct _mp_machine_spi_p_t {
 
 typedef struct _mp_machine_soft_spi_obj_t {
     mp_obj_base_t base;
-    uint32_t delay_half; // microsecond delay for half SCK period
-    uint8_t polarity;
-    uint8_t phase;
-    mp_hal_pin_obj_t sck;
-    mp_hal_pin_obj_t mosi;
-    mp_hal_pin_obj_t miso;
+    mp_soft_spi_obj_t spi;
 } mp_machine_soft_spi_obj_t;
 
 extern const mp_machine_spi_p_t mp_machine_soft_spi_p;
 extern const mp_obj_type_t mp_machine_soft_spi_type;
 extern const mp_obj_dict_t mp_machine_spi_locals_dict;
 
-void mp_machine_soft_spi_transfer(mp_obj_base_t *self, size_t len, const uint8_t *src, uint8_t *dest);
-
 mp_obj_t mp_machine_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args);
 
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_machine_spi_read_obj);
diff --git a/ports/esp32/Makefile b/ports/esp32/Makefile
index eb0a3be24..d2d6192b5 100644
--- a/ports/esp32/Makefile
+++ b/ports/esp32/Makefile
@@ -195,6 +195,7 @@ LIB_SRC_C += \
 endif
 
 DRIVERS_SRC_C = $(addprefix drivers/,\
+	bus/softspi.c \
 	dht/dht.c \
 	)
 
diff --git a/ports/esp32/mpconfigport.h b/ports/esp32/mpconfigport.h
index bf027f1c5..80594b114 100644
--- a/ports/esp32/mpconfigport.h
+++ b/ports/esp32/mpconfigport.h
@@ -135,8 +135,8 @@
 #define MICROPY_PY_MACHINE_SPI_MSB          (0)
 #define MICROPY_PY_MACHINE_SPI_LSB          (1)
 #define MICROPY_PY_MACHINE_SPI_MAKE_NEW     machine_hw_spi_make_new
-#define MICROPY_PY_MACHINE_SPI_MIN_DELAY    (0)
-#define MICROPY_PY_MACHINE_SPI_MAX_BAUDRATE (ets_get_cpu_frequency() * 1000000 / 200) // roughly
+#define MICROPY_HW_SOFTSPI_MIN_DELAY        (0)
+#define MICROPY_HW_SOFTSPI_MAX_BAUDRATE     (ets_get_cpu_frequency() * 1000000 / 200) // roughly
 #define MICROPY_PY_USSL                     (1)
 #define MICROPY_SSL_MBEDTLS                 (1)
 #define MICROPY_PY_USSL_FINALISER           (1)
diff --git a/ports/esp8266/Makefile b/ports/esp8266/Makefile
index 9d6e502c7..716f18d6a 100644
--- a/ports/esp8266/Makefile
+++ b/ports/esp8266/Makefile
@@ -130,6 +130,7 @@ LIB_SRC_C += \
 endif
 
 DRIVERS_SRC_C = $(addprefix drivers/,\
+	bus/softspi.c \
 	dht/dht.c \
         )
 
diff --git a/ports/esp8266/esp8266_common.ld b/ports/esp8266/esp8266_common.ld
index 08da02869..6b7eba56a 100644
--- a/ports/esp8266/esp8266_common.ld
+++ b/ports/esp8266/esp8266_common.ld
@@ -135,6 +135,7 @@ SECTIONS
         *lib/netutils/*.o*(.literal*, .text*)
         *lib/timeutils/*.o*(.literal*, .text*)
         *lib/utils/*.o*(.literal*, .text*)
+        *drivers/bus/*.o(.literal* .text*)
 
         build/main.o(.literal* .text*)
         *gccollect.o(.literal* .text*)
diff --git a/ports/stm32/Makefile b/ports/stm32/Makefile
index 112093f84..765c55a35 100644
--- a/ports/stm32/Makefile
+++ b/ports/stm32/Makefile
@@ -187,6 +187,7 @@ EXTMOD_SRC_C = $(addprefix extmod/,\
         )
 
 DRIVERS_SRC_C = $(addprefix drivers/,\
+	bus/softspi.c \
 	bus/softqspi.c \
 	memory/spiflash.c \
 	dht/dht.c \
diff --git a/ports/stm32/mpconfigport.h b/ports/stm32/mpconfigport.h
index 35b59cbfd..a0a67e95f 100644
--- a/ports/stm32/mpconfigport.h
+++ b/ports/stm32/mpconfigport.h
@@ -140,8 +140,8 @@
 #define MICROPY_PY_MACHINE_SPI_MSB  (SPI_FIRSTBIT_MSB)
 #define MICROPY_PY_MACHINE_SPI_LSB  (SPI_FIRSTBIT_LSB)
 #define MICROPY_PY_MACHINE_SPI_MAKE_NEW machine_hard_spi_make_new
-#define MICROPY_PY_MACHINE_SPI_MIN_DELAY (0)
-#define MICROPY_PY_MACHINE_SPI_MAX_BAUDRATE (HAL_RCC_GetSysClockFreq() / 48)
+#define MICROPY_HW_SOFTSPI_MIN_DELAY (0)
+#define MICROPY_HW_SOFTSPI_MAX_BAUDRATE (HAL_RCC_GetSysClockFreq() / 48)
 #define MICROPY_PY_FRAMEBUF         (1)
 #ifndef MICROPY_PY_USOCKET
 #define MICROPY_PY_USOCKET          (1)
diff --git a/ports/stm32/spibdev.c b/ports/stm32/spibdev.c
index 3eadb995d..846b29d1f 100644
--- a/ports/stm32/spibdev.c
+++ b/ports/stm32/spibdev.c
@@ -42,12 +42,14 @@ static uint32_t flash_tick_counter_last_write;
 
 STATIC const mp_machine_soft_spi_obj_t spiflash_spi_bus = {
     .base = {&mp_machine_soft_spi_type},
-    .delay_half = MICROPY_PY_MACHINE_SPI_MIN_DELAY,
+    .spi = {
+    .delay_half = MICROPY_HW_SOFTSPI_MIN_DELAY,
     .polarity = 0,
     .phase = 0,
     .sck = &MICROPY_HW_SPIFLASH_SCK,
     .mosi = &MICROPY_HW_SPIFLASH_MOSI,
     .miso = &MICROPY_HW_SPIFLASH_MISO,
+    }
 };
 
 STATIC const mp_spiflash_config_t spiflash_config = {
-- 
cgit v1.2.3


From 4d3a92c67c9b1550eaf07d06ed74de996ee8fa3b Mon Sep 17 00:00:00 2001
From: Tom Collins <tom.collins@digi.com>
Date: Thu, 8 Mar 2018 16:02:26 -0800
Subject: extmod/vfs_fat: Add file size as 4th element of uos.ilistdir tuple.

---
 docs/library/uos.rst                 | 8 ++++++--
 extmod/vfs.c                         | 4 +---
 extmod/vfs_fat.c                     | 5 +++--
 tests/extmod/vfs_fat_fileio1.py.exp  | 2 +-
 tests/extmod/vfs_fat_fileio2.py.exp  | 8 ++++----
 tests/extmod/vfs_fat_oldproto.py.exp | 2 +-
 tests/extmod/vfs_fat_ramdisk.py.exp  | 4 ++--
 7 files changed, 18 insertions(+), 15 deletions(-)

(limited to 'extmod')

diff --git a/docs/library/uos.rst b/docs/library/uos.rst
index 85adb6a4d..27f339bb1 100644
--- a/docs/library/uos.rst
+++ b/docs/library/uos.rst
@@ -43,11 +43,11 @@ Filesystem access
 
 .. function:: ilistdir([dir])
 
-   This function returns an iterator which then yields 3-tuples corresponding to
+   This function returns an iterator which then yields tuples corresponding to
    the entries in the directory that it is listing.  With no argument it lists the
    current directory, otherwise it lists the directory given by *dir*.
 
-   The 3-tuples have the form *(name, type, inode)*:
+   The tuples have the form *(name, type, inode[, size])*:
 
     - *name* is a string (or bytes if *dir* is a bytes object) and is the name of
       the entry;
@@ -55,6 +55,10 @@ Filesystem access
       directories and 0x8000 for regular files;
     - *inode* is an integer corresponding to the inode of the file, and may be 0
       for filesystems that don't have such a notion.
+    - Some platforms may return a 4-tuple that includes the entry's *size*.  For
+      file entries, *size* is an integer representing the size of the file
+      or -1 if unknown.  Its meaning is currently undefined for directory
+      entries.
 
 .. function:: listdir([dir])
 
diff --git a/extmod/vfs.c b/extmod/vfs.c
index 105a80a8d..0585de1c7 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -366,9 +366,7 @@ mp_obj_t mp_vfs_listdir(size_t n_args, const mp_obj_t *args) {
     mp_obj_t dir_list = mp_obj_new_list(0, NULL);
     mp_obj_t next;
     while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
-        mp_obj_t *items;
-        mp_obj_get_array_fixed_n(next, 3, &items);
-        mp_obj_list_append(dir_list, items[0]);
+        mp_obj_list_append(dir_list, mp_obj_subscr(next, MP_OBJ_NEW_SMALL_INT(0), MP_OBJ_SENTINEL));
     }
     return dir_list;
 }
diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 0177f5129..5666a6b0c 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -142,8 +142,8 @@ STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
 
         // Note that FatFS already filters . and .., so we don't need to
 
-        // make 3-tuple with info about this entry
-        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
+        // make 4-tuple with info about this entry
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(4, NULL));
         if (self->is_str) {
             t->items[0] = mp_obj_new_str(fn, strlen(fn));
         } else {
@@ -157,6 +157,7 @@ STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
             t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
         }
         t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
+        t->items[3] = mp_obj_new_int_from_uint(fno.fsize);
 
         return MP_OBJ_FROM_PTR(t);
     }
diff --git a/tests/extmod/vfs_fat_fileio1.py.exp b/tests/extmod/vfs_fat_fileio1.py.exp
index 2d4792aa3..4eb50402c 100644
--- a/tests/extmod/vfs_fat_fileio1.py.exp
+++ b/tests/extmod/vfs_fat_fileio1.py.exp
@@ -10,7 +10,7 @@ e
 o
 d
 True
-[('foo_dir', 16384, 0)]
+[('foo_dir', 16384, 0, 0)]
 MemoryError
 x0
 x1
diff --git a/tests/extmod/vfs_fat_fileio2.py.exp b/tests/extmod/vfs_fat_fileio2.py.exp
index 118dee26b..268405364 100644
--- a/tests/extmod/vfs_fat_fileio2.py.exp
+++ b/tests/extmod/vfs_fat_fileio2.py.exp
@@ -3,9 +3,9 @@ True
 True
 b'data in file'
 True
-[('sub_file.txt', 32768, 0), ('file.txt', 32768, 0)]
-[('foo_dir', 16384, 0), ('moved-to-root.txt', 32768, 0)]
-[('foo_dir', 16384, 0), ('moved-to-root.txt', 32768, 0)]
+[('sub_file.txt', 32768, 0, 11), ('file.txt', 32768, 0, 12)]
+[('foo_dir', 16384, 0, 0), ('moved-to-root.txt', 32768, 0, 12)]
+[('foo_dir', 16384, 0, 0), ('moved-to-root.txt', 32768, 0, 8)]
 new text
-[('moved-to-root.txt', 32768, 0)]
+[('moved-to-root.txt', 32768, 0, 8)]
 ENOSPC: True
diff --git a/tests/extmod/vfs_fat_oldproto.py.exp b/tests/extmod/vfs_fat_oldproto.py.exp
index ab8338cbb..b97468316 100644
--- a/tests/extmod/vfs_fat_oldproto.py.exp
+++ b/tests/extmod/vfs_fat_oldproto.py.exp
@@ -1,3 +1,3 @@
-[('file.txt', 32768, 0)]
+[('file.txt', 32768, 0, 6)]
 hello!
 []
diff --git a/tests/extmod/vfs_fat_ramdisk.py.exp b/tests/extmod/vfs_fat_ramdisk.py.exp
index ccd0f7134..ef6cf1e72 100644
--- a/tests/extmod/vfs_fat_ramdisk.py.exp
+++ b/tests/extmod/vfs_fat_ramdisk.py.exp
@@ -3,7 +3,7 @@ True
 statvfs: (512, 512, 16, 16, 16, 0, 0, 0, 0, 255)
 getcwd: /
 True
-[('foo_file.txt', 32768, 0)]
+[('foo_file.txt', 32768, 0, 6)]
 stat root: (16384, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 stat file: (32768, 0, 0, 0, 0, 0, 6)
 True
@@ -12,5 +12,5 @@ getcwd: /foo_dir
 []
 True
 getcwd: /
-[(b'foo_file.txt', 32768, 0), (b'foo_dir', 16384, 0)]
+[(b'foo_file.txt', 32768, 0, 6), (b'foo_dir', 16384, 0, 0)]
 ENOENT: True
-- 
cgit v1.2.3


From cf31d384f1d2ca09f817f154892eaa6860c10144 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 7 Mar 2018 17:48:53 +1100
Subject: py/stream: Switch stream close operation from method to ioctl.

This patch moves the implementation of stream closure from a dedicated
method to the ioctl of the stream protocol, for each type that implements
closing.  The benefits of this are:

1. Rounds out the stream ioctl function, which already includes flush,
   seek and poll (among other things).

2. Makes calling mp_stream_close() on an object slightly more efficient
   because it now no longer needs to lookup the close method and call it,
   rather it just delegates straight to the ioctl function (if it exists).

3. Reduces code size and allows future types that implement the stream
   protocol to be smaller because they don't need a dedicated close method.

Code size reduction is around 200 bytes smaller for x86 archs and around
30 bytes smaller for the bare-metal archs.
---
 extmod/modlwip.c               | 72 ++++++++++++++++++++----------------------
 extmod/modussl_axtls.c         | 35 ++++++++++++--------
 extmod/modussl_mbedtls.c       | 37 +++++++++++++---------
 extmod/modwebrepl.c            | 21 ++++++++----
 extmod/modwebsocket.c          | 15 ++++-----
 extmod/vfs_fat_file.c          | 30 ++++++++----------
 ports/cc3200/mods/modusocket.c | 15 +++------
 ports/esp32/modsocket.c        | 27 +++++++---------
 ports/stm32/modusocket.c       | 22 ++++++-------
 ports/unix/file.c              | 20 +++++-------
 ports/unix/modusocket.c        | 34 ++++++++++++--------
 ports/zephyr/modusocket.c      | 33 ++++++++++++-------
 py/objstringio.c               | 30 ++++++++----------
 py/stream.c                    | 18 +++++++----
 py/stream.h                    |  3 +-
 15 files changed, 216 insertions(+), 196 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 2c194e1bd..9810089da 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -637,42 +637,6 @@ STATIC mp_obj_t lwip_socket_make_new(const mp_obj_type_t *type, size_t n_args, s
     return socket;
 }
 
-STATIC mp_obj_t lwip_socket_close(mp_obj_t self_in) {
-    lwip_socket_obj_t *socket = self_in;
-    bool socket_is_listener = false;
-
-    if (socket->pcb.tcp == NULL) {
-        return mp_const_none;
-    }
-    switch (socket->type) {
-        case MOD_NETWORK_SOCK_STREAM: {
-            if (socket->pcb.tcp->state == LISTEN) {
-                socket_is_listener = true;
-            }
-            if (tcp_close(socket->pcb.tcp) != ERR_OK) {
-                DEBUG_printf("lwip_close: had to call tcp_abort()\n");
-                tcp_abort(socket->pcb.tcp);
-            }
-            break;
-        }
-        case MOD_NETWORK_SOCK_DGRAM: udp_remove(socket->pcb.udp); break;
-        //case MOD_NETWORK_SOCK_RAW: raw_remove(socket->pcb.raw); break;
-    }
-    socket->pcb.tcp = NULL;
-    socket->state = _ERR_BADF;
-    if (socket->incoming.pbuf != NULL) {
-        if (!socket_is_listener) {
-            pbuf_free(socket->incoming.pbuf);
-        } else {
-            tcp_abort(socket->incoming.connection);
-        }
-        socket->incoming.pbuf = NULL;
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(lwip_socket_close_obj, lwip_socket_close);
-
 STATIC mp_obj_t lwip_socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
     lwip_socket_obj_t *socket = self_in;
 
@@ -1179,6 +1143,38 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             ret |= flags & (MP_STREAM_POLL_RD | MP_STREAM_POLL_WR);
         }
 
+    } else if (request == MP_STREAM_CLOSE) {
+        bool socket_is_listener = false;
+
+        if (socket->pcb.tcp == NULL) {
+            return 0;
+        }
+        switch (socket->type) {
+            case MOD_NETWORK_SOCK_STREAM: {
+                if (socket->pcb.tcp->state == LISTEN) {
+                    socket_is_listener = true;
+                }
+                if (tcp_close(socket->pcb.tcp) != ERR_OK) {
+                    DEBUG_printf("lwip_close: had to call tcp_abort()\n");
+                    tcp_abort(socket->pcb.tcp);
+                }
+                break;
+            }
+            case MOD_NETWORK_SOCK_DGRAM: udp_remove(socket->pcb.udp); break;
+            //case MOD_NETWORK_SOCK_RAW: raw_remove(socket->pcb.raw); break;
+        }
+        socket->pcb.tcp = NULL;
+        socket->state = _ERR_BADF;
+        if (socket->incoming.pbuf != NULL) {
+            if (!socket_is_listener) {
+                pbuf_free(socket->incoming.pbuf);
+            } else {
+                tcp_abort(socket->incoming.connection);
+            }
+            socket->incoming.pbuf = NULL;
+        }
+        ret = 0;
+
     } else {
         *errcode = MP_EINVAL;
         ret = MP_STREAM_ERROR;
@@ -1188,8 +1184,8 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
 }
 
 STATIC const mp_rom_map_elem_t lwip_socket_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&lwip_socket_close_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&lwip_socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&lwip_socket_bind_obj) },
     { MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&lwip_socket_listen_obj) },
     { MP_ROM_QSTR(MP_QSTR_accept), MP_ROM_PTR(&lwip_socket_accept_obj) },
diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 35e3106cd..689d33305 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -175,6 +175,25 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
     return r;
 }
 
+STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(o_in);
+    (void)arg;
+    switch (request) {
+        case MP_STREAM_CLOSE:
+            if (self->ssl_sock != NULL) {
+                ssl_free(self->ssl_sock);
+                ssl_ctx_free(self->ssl_ctx);
+                self->ssl_sock = NULL;
+                mp_stream_close(self->sock);
+            }
+            return 0;
+
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
+}
+
 STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
     // Currently supports only blocking mode
     (void)self_in;
@@ -185,26 +204,13 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
 
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->ssl_sock != NULL) {
-        ssl_free(self->ssl_sock);
-        ssl_ctx_free(self->ssl_ctx);
-        self->ssl_sock = NULL;
-        return mp_stream_close(self->sock);
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
-
 STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { 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) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 #if MICROPY_PY_USSL_FINALISER
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
 #endif
@@ -215,6 +221,7 @@ STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_tab
 STATIC const mp_stream_p_t ussl_socket_stream_p = {
     .read = socket_read,
     .write = socket_write,
+    .ioctl = socket_ioctl,
 };
 
 STATIC const mp_obj_type_t ussl_socket_type = {
diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 197a0651c..bd4b0c725 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -274,20 +274,26 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
 
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(self_in);
-
-    mbedtls_pk_free(&self->pkey);
-    mbedtls_x509_crt_free(&self->cert);
-    mbedtls_x509_crt_free(&self->cacert);
-    mbedtls_ssl_free(&self->ssl);
-    mbedtls_ssl_config_free(&self->conf);
-    mbedtls_ctr_drbg_free(&self->ctr_drbg);
-    mbedtls_entropy_free(&self->entropy);
-
-    return mp_stream_close(self->sock);
+STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(o_in);
+    (void)arg;
+    switch (request) {
+        case MP_STREAM_CLOSE:
+            mbedtls_pk_free(&self->pkey);
+            mbedtls_x509_crt_free(&self->cert);
+            mbedtls_x509_crt_free(&self->cacert);
+            mbedtls_ssl_free(&self->ssl);
+            mbedtls_ssl_config_free(&self->conf);
+            mbedtls_ctr_drbg_free(&self->ctr_drbg);
+            mbedtls_entropy_free(&self->entropy);
+            mp_stream_close(self->sock);
+            return 0;
+
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
 
 STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
@@ -295,9 +301,9 @@ STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { 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) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 #if MICROPY_PY_USSL_FINALISER
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
 #endif
     { MP_ROM_QSTR(MP_QSTR_getpeercert), MP_ROM_PTR(&mod_ssl_getpeercert_obj) },
 };
@@ -307,6 +313,7 @@ STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_tab
 STATIC const mp_stream_p_t ussl_socket_stream_p = {
     .read = socket_read,
     .write = socket_write,
+    .ioctl = socket_ioctl,
 };
 
 STATIC const mp_obj_type_t ussl_socket_type = {
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index 42b30f5ea..983b5a10c 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -297,12 +297,20 @@ STATIC mp_uint_t webrepl_write(mp_obj_t self_in, const void *buf, mp_uint_t size
     return stream_p->write(self->sock, buf, size, errcode);
 }
 
-STATIC mp_obj_t webrepl_close(mp_obj_t self_in) {
-    mp_obj_webrepl_t *self = MP_OBJ_TO_PTR(self_in);
-    // TODO: This is a place to do cleanup
-    return mp_stream_close(self->sock);
+STATIC mp_uint_t webrepl_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_webrepl_t *self = MP_OBJ_TO_PTR(o_in);
+    (void)arg;
+    switch (request) {
+        case MP_STREAM_CLOSE:
+            // TODO: This is a place to do cleanup
+            mp_stream_close(self->sock);
+            return 0;
+
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(webrepl_close_obj, webrepl_close);
 
 STATIC mp_obj_t webrepl_set_password(mp_obj_t passwd_in) {
     size_t len;
@@ -319,13 +327,14 @@ STATIC const mp_rom_map_elem_t webrepl_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&webrepl_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(webrepl_locals_dict, webrepl_locals_dict_table);
 
 STATIC const mp_stream_p_t webrepl_stream_p = {
     .read = webrepl_read,
     .write = webrepl_write,
+    .ioctl = webrepl_ioctl,
 };
 
 STATIC const mp_obj_type_t webrepl_type = {
diff --git a/extmod/modwebsocket.c b/extmod/modwebsocket.c
index a651164b2..5a826ec64 100644
--- a/extmod/modwebsocket.c
+++ b/extmod/modwebsocket.c
@@ -256,6 +256,11 @@ STATIC mp_uint_t websocket_write(mp_obj_t self_in, const void *buf, mp_uint_t si
 STATIC mp_uint_t websocket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     mp_obj_websocket_t *self = MP_OBJ_TO_PTR(self_in);
     switch (request) {
+        case MP_STREAM_CLOSE:
+            // TODO: Send close signaling to the other side, otherwise it's
+            // abrupt close (connection abort).
+            mp_stream_close(self->sock);
+            return 0;
         case MP_STREAM_GET_DATA_OPTS:
             return self->ws_flags & FRAME_OPCODE_MASK;
         case MP_STREAM_SET_DATA_OPTS: {
@@ -269,21 +274,13 @@ STATIC mp_uint_t websocket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t
     }
 }
 
-STATIC mp_obj_t websocket_close(mp_obj_t self_in) {
-    mp_obj_websocket_t *self = MP_OBJ_TO_PTR(self_in);
-    // TODO: Send close signaling to the other side, otherwise it's
-    // abrupt close (connection abort).
-    return mp_stream_close(self->sock);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(websocket_close_obj, websocket_close);
-
 STATIC const mp_rom_map_elem_t websocket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&mp_stream_ioctl_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&websocket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(websocket_locals_dict, websocket_locals_dict_table);
 
diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index 23e5aa10f..cbd013f16 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -103,22 +103,9 @@ STATIC mp_uint_t file_obj_write(mp_obj_t self_in, const void *buf, mp_uint_t siz
 }
 
 
-STATIC mp_obj_t file_obj_close(mp_obj_t self_in) {
-    pyb_file_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    // if fs==NULL then the file is closed and in that case this method is a no-op
-    if (self->fp.obj.fs != NULL) {
-        FRESULT res = f_close(&self->fp);
-        if (res != FR_OK) {
-            mp_raise_OSError(fresult_to_errno_table[res]);
-        }
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(file_obj_close_obj, file_obj_close);
-
 STATIC mp_obj_t file_obj___exit__(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
-    return file_obj_close(args[0]);
+    return mp_stream_close(args[0]);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(file_obj___exit___obj, 4, 4, file_obj___exit__);
 
@@ -153,6 +140,17 @@ STATIC mp_uint_t file_obj_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
         }
         return 0;
 
+    } else if (request == MP_STREAM_CLOSE) {
+        // if fs==NULL then the file is closed and in that case this method is a no-op
+        if (self->fp.obj.fs != NULL) {
+            FRESULT res = f_close(&self->fp);
+            if (res != FR_OK) {
+                *errcode = fresult_to_errno_table[res];
+                return MP_STREAM_ERROR;
+            }
+        }
+        return 0;
+
     } else {
         *errcode = MP_EINVAL;
         return MP_STREAM_ERROR;
@@ -234,10 +232,10 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&file_obj_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
     { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&file_obj_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&file_obj___exit___obj) },
 };
diff --git a/ports/cc3200/mods/modusocket.c b/ports/cc3200/mods/modusocket.c
index f587e765a..286b1fb02 100644
--- a/ports/cc3200/mods/modusocket.c
+++ b/ports/cc3200/mods/modusocket.c
@@ -336,6 +336,9 @@ STATIC int wlan_socket_ioctl (mod_network_socket_obj_t *s, mp_uint_t request, mp
         if (SL_FD_ISSET(sd, &xfds)) {
             ret |= MP_STREAM_POLL_HUP;
         }
+    } else if (request == MP_STREAM_CLOSE) {
+        wlan_socket_close(s);
+        ret = 0;
     } else {
         *_errno = MP_EINVAL;
         ret = MP_STREAM_ERROR;
@@ -466,14 +469,6 @@ STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     return s;
 }
 
-// method socket.close()
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    mod_network_socket_obj_t *self = self_in;
-    wlan_socket_close(self);
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
-
 // method socket.bind(address)
 STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
     mod_network_socket_obj_t *self = self_in;
@@ -704,8 +699,8 @@ STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 6, socket_makefile);
 
 STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___del__),         MP_ROM_PTR(&socket_close_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close),           MP_ROM_PTR(&socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__),         MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close),           MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_bind),            MP_ROM_PTR(&socket_bind_obj) },
     { MP_ROM_QSTR(MP_QSTR_listen),          MP_ROM_PTR(&socket_listen_obj) },
     { MP_ROM_QSTR(MP_QSTR_accept),          MP_ROM_PTR(&socket_accept_obj) },
diff --git a/ports/esp32/modsocket.c b/ports/esp32/modsocket.c
index 31d153964..8b3c28063 100644
--- a/ports/esp32/modsocket.c
+++ b/ports/esp32/modsocket.c
@@ -83,19 +83,6 @@ void check_for_exceptions() {
     }
 }
 
-STATIC mp_obj_t socket_close(const mp_obj_t arg0) {
-    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
-    if (self->fd >= 0) {
-        int ret = lwip_close_r(self->fd);
-        if (ret != 0) {
-            exception_from_errno(errno);
-        }
-        self->fd = -1;
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
-
 static int _socket_getaddrinfo2(const mp_obj_t host, const mp_obj_t portx, struct addrinfo **resp) {
     const struct addrinfo hints = {
         .ai_family = AF_INET,
@@ -450,6 +437,16 @@ STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintpt
         if (FD_ISSET(socket->fd, &wfds)) ret |= MP_STREAM_POLL_WR;
         if (FD_ISSET(socket->fd, &efds)) ret |= MP_STREAM_POLL_HUP;
         return ret;
+    } else if (request == MP_STREAM_CLOSE) {
+        if (socket->fd >= 0) {
+            int ret = lwip_close_r(socket->fd);
+            if (ret != 0) {
+                *errcode = errno;
+                return MP_STREAM_ERROR;
+            }
+            socket->fd = -1;
+        }
+        return 0;
     }
 
     *errcode = MP_EINVAL;
@@ -457,8 +454,8 @@ STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintpt
 }
 
 STATIC const mp_map_elem_t socket_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___del__), (mp_obj_t)&socket_close_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t)&socket_close_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___del__), (mp_obj_t)&mp_stream_close_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t)&mp_stream_close_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_bind), (mp_obj_t)&socket_bind_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_listen), (mp_obj_t)&socket_listen_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_accept), (mp_obj_t)&socket_accept_obj },
diff --git a/ports/stm32/modusocket.c b/ports/stm32/modusocket.c
index 71a237b0d..0c663437e 100644
--- a/ports/stm32/modusocket.c
+++ b/ports/stm32/modusocket.c
@@ -30,6 +30,7 @@
 #include "py/objtuple.h"
 #include "py/objlist.h"
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "py/mperrno.h"
 #include "lib/netutils/netutils.h"
 #include "modnetwork.h"
@@ -79,16 +80,6 @@ STATIC void socket_select_nic(mod_network_socket_obj_t *self, const byte *ip) {
         }
     }
 }
-// method socket.close()
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    mod_network_socket_obj_t *self = self_in;
-    if (self->nic != MP_OBJ_NULL) {
-        self->nic_type->close(self);
-        self->nic = MP_OBJ_NULL;
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
 
 // method socket.bind(address)
 STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
@@ -347,8 +338,8 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t blocking) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
 
 STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&socket_bind_obj) },
     { MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&socket_listen_obj) },
     { MP_ROM_QSTR(MP_QSTR_accept), MP_ROM_PTR(&socket_accept_obj) },
@@ -366,6 +357,13 @@ STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
 
 mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
     mod_network_socket_obj_t *self = self_in;
+    if (request == MP_STREAM_CLOSE) {
+        if (self->nic != MP_OBJ_NULL) {
+            self->nic_type->close(self);
+            self->nic = MP_OBJ_NULL;
+        }
+        return 0;
+    }
     return self->nic_type->ioctl(self, request, arg, errcode);
 }
 
diff --git a/ports/unix/file.c b/ports/unix/file.c
index 84e918082..9bb44c6ab 100644
--- a/ports/unix/file.c
+++ b/ports/unix/file.c
@@ -118,25 +118,21 @@ STATIC mp_uint_t fdfile_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, i
                 return MP_STREAM_ERROR;
             }
             return 0;
+        case MP_STREAM_CLOSE:
+            close(o->fd);
+            #ifdef MICROPY_CPYTHON_COMPAT
+            o->fd = -1;
+            #endif
+            return 0;
         default:
             *errcode = EINVAL;
             return MP_STREAM_ERROR;
     }
 }
 
-STATIC mp_obj_t fdfile_close(mp_obj_t self_in) {
-    mp_obj_fdfile_t *self = MP_OBJ_TO_PTR(self_in);
-    close(self->fd);
-#ifdef MICROPY_CPYTHON_COMPAT
-    self->fd = -1;
-#endif
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(fdfile_close_obj, fdfile_close);
-
 STATIC mp_obj_t fdfile___exit__(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
-    return fdfile_close(args[0]);
+    return mp_stream_close(args[0]);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fdfile___exit___obj, 4, 4, fdfile___exit__);
 
@@ -224,7 +220,7 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
     { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&fdfile_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&fdfile___exit___obj) },
 };
diff --git a/ports/unix/modusocket.c b/ports/unix/modusocket.c
index cfb6a9f5e..ba50e6165 100644
--- a/ports/unix/modusocket.c
+++ b/ports/unix/modusocket.c
@@ -108,19 +108,26 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
     return r;
 }
 
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
-    // There's a POSIX drama regarding return value of close in general,
-    // and EINTR error in particular. See e.g.
-    // http://lwn.net/Articles/576478/
-    // http://austingroupbugs.net/view.php?id=529
-    // The rationale MicroPython follows is that close() just releases
-    // file descriptor. If you're interested to catch I/O errors before
-    // closing fd, fsync() it.
-    close(self->fd);
-    return mp_const_none;
+STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_socket_t *self = MP_OBJ_TO_PTR(o_in);
+    (void)arg;
+    switch (request) {
+        case MP_STREAM_CLOSE:
+            // There's a POSIX drama regarding return value of close in general,
+            // and EINTR error in particular. See e.g.
+            // http://lwn.net/Articles/576478/
+            // http://austingroupbugs.net/view.php?id=529
+            // The rationale MicroPython follows is that close() just releases
+            // file descriptor. If you're interested to catch I/O errors before
+            // closing fd, fsync() it.
+            close(self->fd);
+            return 0;
+
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
+    }
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
 
 STATIC mp_obj_t socket_fileno(mp_obj_t self_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
@@ -359,7 +366,7 @@ STATIC const mp_rom_map_elem_t usocket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socket_sendto_obj) },
     { MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socket_setsockopt_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) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(usocket_locals_dict, usocket_locals_dict_table);
@@ -367,6 +374,7 @@ STATIC MP_DEFINE_CONST_DICT(usocket_locals_dict, usocket_locals_dict_table);
 STATIC const mp_stream_p_t usocket_stream_p = {
     .read = socket_read,
     .write = socket_write,
+    .ioctl = socket_ioctl,
 };
 
 const mp_obj_type_t mp_type_socket = {
diff --git a/ports/zephyr/modusocket.c b/ports/zephyr/modusocket.c
index 95414a49b..84d6fa729 100644
--- a/ports/zephyr/modusocket.c
+++ b/ports/zephyr/modusocket.c
@@ -299,20 +299,31 @@ STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
 
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    socket_obj_t *socket = self_in;
-    if (socket->ctx != -1) {
-        int res = zsock_close(socket->ctx);
-        RAISE_SOCK_ERRNO(res);
-        socket->ctx = -1;
+STATIC mp_uint_t sock_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    socket_obj_t *socket = o_in;
+    (void)arg;
+    switch (request) {
+        case MP_STREAM_CLOSE:
+            if (socket->ctx != -1) {
+                int res = zsock_close(socket->ctx);
+                RAISE_SOCK_ERRNO(res);
+                if (res == -1) {
+                    *errcode = errno;
+                    return MP_STREAM_ERROR;
+                }
+                socket->ctx = -1;
+            }
+            return 0;
+
+        default:
+            *errcode = MP_EINVAL;
+            return MP_STREAM_ERROR;
     }
-    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
 
 STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&socket_bind_obj) },
     { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socket_connect_obj) },
     { MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&socket_listen_obj) },
@@ -332,7 +343,7 @@ STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
 STATIC const mp_stream_p_t socket_stream_p = {
     .read = sock_read,
     .write = sock_write,
-    //.ioctl = sock_ioctl,
+    .ioctl = sock_ioctl,
 };
 
 STATIC const mp_obj_type_t socket_type = {
diff --git a/py/objstringio.c b/py/objstringio.c
index 5c50aa317..b405ee21e 100644
--- a/py/objstringio.c
+++ b/py/objstringio.c
@@ -143,6 +143,17 @@ STATIC mp_uint_t stringio_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
         }
         case MP_STREAM_FLUSH:
             return 0;
+        case MP_STREAM_CLOSE:
+            #if MICROPY_CPYTHON_COMPAT
+            vstr_free(o->vstr);
+            o->vstr = NULL;
+            #else
+            vstr_clear(o->vstr);
+            o->vstr->alloc = 0;
+            o->vstr->len = 0;
+            o->pos = 0;
+            #endif
+            return 0;
         default:
             *errcode = MP_EINVAL;
             return MP_STREAM_ERROR;
@@ -159,24 +170,9 @@ STATIC mp_obj_t stringio_getvalue(mp_obj_t self_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(stringio_getvalue_obj, stringio_getvalue);
 
-STATIC mp_obj_t stringio_close(mp_obj_t self_in) {
-    mp_obj_stringio_t *self = MP_OBJ_TO_PTR(self_in);
-#if MICROPY_CPYTHON_COMPAT
-    vstr_free(self->vstr);
-    self->vstr = NULL;
-#else
-    vstr_clear(self->vstr);
-    self->vstr->alloc = 0;
-    self->vstr->len = 0;
-    self->pos = 0;
-#endif
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(stringio_close_obj, stringio_close);
-
 STATIC mp_obj_t stringio___exit__(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
-    return stringio_close(args[0]);
+    return mp_stream_close(args[0]);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stringio___exit___obj, 4, 4, stringio___exit__);
 
@@ -233,7 +229,7 @@ STATIC const mp_rom_map_elem_t stringio_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&stringio_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_getvalue), MP_ROM_PTR(&stringio_getvalue_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&stringio___exit___obj) },
diff --git a/py/stream.c b/py/stream.c
index 453dee769..f51f634b6 100644
--- a/py/stream.c
+++ b/py/stream.c
@@ -105,13 +105,6 @@ const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) {
     return stream_p;
 }
 
-mp_obj_t mp_stream_close(mp_obj_t stream) {
-    // TODO: Still consider using ioctl for close
-    mp_obj_t dest[2];
-    mp_load_method(stream, MP_QSTR_close, dest);
-    return mp_call_method_n_kw(0, 0, dest);
-}
-
 STATIC mp_obj_t stream_read_generic(size_t n_args, const mp_obj_t *args, byte flags) {
     const mp_stream_p_t *stream_p = mp_get_stream_raise(args[0], MP_STREAM_OP_READ);
 
@@ -434,6 +427,17 @@ mp_obj_t mp_stream_unbuffered_iter(mp_obj_t self) {
     return MP_OBJ_STOP_ITERATION;
 }
 
+mp_obj_t mp_stream_close(mp_obj_t stream) {
+    const mp_stream_p_t *stream_p = mp_get_stream_raise(stream, MP_STREAM_OP_IOCTL);
+    int error;
+    mp_uint_t res = stream_p->ioctl(stream, MP_STREAM_CLOSE, 0, &error);
+    if (res == MP_STREAM_ERROR) {
+        mp_raise_OSError(error);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_close_obj, mp_stream_close);
+
 STATIC mp_obj_t stream_seek(size_t n_args, const mp_obj_t *args) {
     const mp_stream_p_t *stream_p = mp_get_stream_raise(args[0], MP_STREAM_OP_IOCTL);
 
diff --git a/py/stream.h b/py/stream.h
index fbe3d7d85..a7d8d08f1 100644
--- a/py/stream.h
+++ b/py/stream.h
@@ -35,7 +35,7 @@
 #define MP_STREAM_FLUSH (1)
 #define MP_STREAM_SEEK  (2)
 #define MP_STREAM_POLL  (3)
-//#define MP_STREAM_CLOSE       (4)  // Not yet implemented
+#define MP_STREAM_CLOSE         (4)
 #define MP_STREAM_TIMEOUT       (5)  // Get/set timeout (single op)
 #define MP_STREAM_GET_OPTS      (6)  // Get stream options
 #define MP_STREAM_SET_OPTS      (7)  // Set stream options
@@ -69,6 +69,7 @@ MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_unbuffered_readline_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_unbuffered_readlines_obj);
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_write_obj);
 MP_DECLARE_CONST_FUN_OBJ_2(mp_stream_write1_obj);
+MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_close_obj);
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_seek_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_tell_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_flush_obj);
-- 
cgit v1.2.3


From 6a693db71d032518dedc50731376c15bebe6cec9 Mon Sep 17 00:00:00 2001
From: armink <armink.ztl@gmail.com>
Date: Wed, 21 Mar 2018 10:21:29 +0800
Subject: extmod/re1.5: Fix compilecode.c compile problem on IAR tool chain.

The 2nd and 3rd args of the ternary operator are treated like they are in
the same expression and must have similar types.  void is not compatible
with int so that's why the compiler is complaining.
---
 extmod/re1.5/compilecode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/re1.5/compilecode.c b/extmod/re1.5/compilecode.c
index 3267a4190..a685a508a 100644
--- a/extmod/re1.5/compilecode.c
+++ b/extmod/re1.5/compilecode.c
@@ -5,9 +5,9 @@
 #include "re1.5.h"
 
 #define INSERT_CODE(at, num, pc) \
-    ((code ? memmove(code + at + num, code + at, pc - at) : (void)0), pc += num)
+    ((code ? memmove(code + at + num, code + at, pc - at) : 0), pc += num)
 #define REL(at, to) (to - at - 2)
-#define EMIT(at, byte) (code ? (code[at] = byte) : (void)(at))
+#define EMIT(at, byte) (code ? (code[at] = byte) : (at))
 #define PC (prog->bytelen)
 
 static const char *_compilecode(const char *re, ByteProg *prog, int sizecode)
-- 
cgit v1.2.3


From bdff68db9c1f7e35d0600841647cffac4b1d9ef0 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 23 Apr 2018 16:38:20 +1000
Subject: extmod/modlwip: Check if getaddrinfo() constraints are supported or
 not.

In particular don't issue a warning if the passed-in constraints are
actually supported because they are the default values.
---
 extmod/modlwip.c | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 9810089da..b23f53961 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1292,14 +1292,33 @@ STATIC void lwip_getaddrinfo_cb(const char *name, ip_addr_t *ipaddr, void *arg)
 
 // lwip.getaddrinfo
 STATIC mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
-    if (n_args > 2) {
-        mp_warning("getaddrinfo constraints not supported");
-    }
-
     mp_obj_t host_in = args[0], port_in = args[1];
     const char *host = mp_obj_str_get_str(host_in);
     mp_int_t port = mp_obj_get_int(port_in);
 
+    // If constraints were passed then check they are compatible with the supported params
+    if (n_args > 2) {
+        mp_int_t family = mp_obj_get_int(args[2]);
+        mp_int_t type = 0;
+        mp_int_t proto = 0;
+        mp_int_t flags = 0;
+        if (n_args > 3) {
+            type = mp_obj_get_int(args[3]);
+            if (n_args > 4) {
+                proto = mp_obj_get_int(args[4]);
+                if (n_args > 5) {
+                    flags = mp_obj_get_int(args[5]);
+                }
+            }
+        }
+        if (!((family == 0 || family == MOD_NETWORK_AF_INET)
+            && (type == 0 || type == MOD_NETWORK_SOCK_STREAM)
+            && proto == 0
+            && flags == 0)) {
+            mp_warning("unsupported getaddrinfo constraints");
+        }
+    }
+
     getaddrinfo_state_t state;
     state.status = 0;
 
-- 
cgit v1.2.3


From 89b1c4a60cd43697e755b645127387d3b34e6d3f Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 2 May 2018 17:08:48 +1000
Subject: extmod/vfs: Delegate import_stat to vfs.stat to allow generic FS
 import.

---
 extmod/vfs.c | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index 0585de1c7..16f75aba9 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -130,8 +130,26 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
         return fat_vfs_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     }
     #endif
-    // TODO delegate to vfs.stat() method
-    return MP_IMPORT_STAT_NO_EXIST;
+
+    // delegate to vfs.stat() method
+    mp_obj_t path_o = mp_obj_new_str(path_out, strlen(path_out));
+    mp_obj_t stat;
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        stat = mp_vfs_proxy_call(vfs, MP_QSTR_stat, 1, &path_o);
+        nlr_pop();
+    } else {
+        // assume an exception means that the path is not found
+        return MP_IMPORT_STAT_NO_EXIST;
+    }
+    mp_obj_t *items;
+    mp_obj_get_array_fixed_n(stat, 10, &items);
+    mp_int_t st_mode = mp_obj_get_int(items[0]);
+    if (st_mode & MP_S_IFDIR) {
+        return MP_IMPORT_STAT_DIR;
+    } else {
+        return MP_IMPORT_STAT_FILE;
+    }
 }
 
 mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-- 
cgit v1.2.3


From 59361681501cda2aa998fda649929591308aaebb Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 2 May 2018 23:16:22 +1000
Subject: extmod/uzlib: Fix C-language sequencing error with uzlib_get_byte
 calls.

The order of function calls in an arithmetic expression is undefined and so
they must be written out as sequential statements.

Thanks to @dv-extrarius for reporting this issue, see issue #3690.
---
 extmod/uzlib/tinflate.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'extmod')

diff --git a/extmod/uzlib/tinflate.c b/extmod/uzlib/tinflate.c
index 58850eb4a..21558af5b 100644
--- a/extmod/uzlib/tinflate.c
+++ b/extmod/uzlib/tinflate.c
@@ -394,9 +394,11 @@ static int tinf_inflate_uncompressed_block(TINF_DATA *d)
         unsigned int length, invlength;
 
         /* get length */
-        length = uzlib_get_byte(d) + 256 * uzlib_get_byte(d);
+        length = uzlib_get_byte(d);
+        length += 256 * uzlib_get_byte(d);
         /* get one's complement of length */
-        invlength = uzlib_get_byte(d) + 256 * uzlib_get_byte(d);
+        invlength = uzlib_get_byte(d);
+        invlength += 256 * uzlib_get_byte(d);
         /* check length */
         if (length != (~invlength & 0x0000ffff)) return TINF_DATA_ERROR;
 
-- 
cgit v1.2.3


From 318f874cda22567a55bb004434ed0ec891fd7d61 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 4 May 2018 15:15:04 +1000
Subject: extmod/modlwip: In ioctl handle case when socket is in an error
 state.

Using MP_STREAM_POLL_HUP for ERR_RST state follows how *nix handles this
case.
---
 extmod/modlwip.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index b23f53961..3aa023707 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1132,7 +1132,8 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             ret |= MP_STREAM_POLL_RD;
         }
 
-        if (flags & MP_STREAM_POLL_WR && tcp_sndbuf(socket->pcb.tcp) > 0) {
+        // Note: pcb.tcp==NULL if state<0, and in this case we can't call tcp_sndbuf
+        if (flags & MP_STREAM_POLL_WR && socket->pcb.tcp != NULL && tcp_sndbuf(socket->pcb.tcp) > 0) {
             ret |= MP_STREAM_POLL_WR;
         }
 
@@ -1141,6 +1142,13 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             // return EOF, write - error. Without this poll will hang on a
             // socket which was closed by peer.
             ret |= flags & (MP_STREAM_POLL_RD | MP_STREAM_POLL_WR);
+        } else if (socket->state == ERR_RST) {
+            // Socket was reset by peer, a write will return an error
+            ret |= flags & (MP_STREAM_POLL_WR | MP_STREAM_POLL_HUP);
+        } else if (socket->state < 0) {
+            // Socket in some other error state, use catch-all ERR flag
+            // TODO: may need to set other return flags here
+            ret |= flags & MP_STREAM_POLL_ERR;
         }
 
     } else if (request == MP_STREAM_CLOSE) {
-- 
cgit v1.2.3


From 9c2044717c8852105df25746a8a7b873fbfc3609 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 17 May 2018 12:58:34 +1000
Subject: extmod/modlwip: Update to work with lwIP v2.0.

lwIP v2.0.3 has been tested with this lwip module and it works very well.
---
 extmod/modlwip.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 50 insertions(+), 6 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 3aa023707..19766c0c8 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -38,13 +38,18 @@
 #include "lib/netutils/netutils.h"
 
 #include "lwip/init.h"
-#include "lwip/timers.h"
 #include "lwip/tcp.h"
 #include "lwip/udp.h"
 //#include "lwip/raw.h"
 #include "lwip/dns.h"
-#include "lwip/tcp_impl.h"
 #include "lwip/igmp.h"
+#if LWIP_VERSION_MAJOR < 2
+#include "lwip/timers.h"
+#include "lwip/tcp_impl.h"
+#else
+#include "lwip/timeouts.h"
+#include "lwip/priv/tcp_priv.h"
+#endif
 
 #if 0 // print debugging info
 #define DEBUG_printf DEBUG_printf
@@ -171,11 +176,16 @@ STATIC const mp_obj_type_t lwip_slip_type = {
 // Table to convert lwIP err_t codes to socket errno codes, from the lwIP
 // socket API.
 
+// lwIP 2 changed LWIP_VERSION and it can no longer be used in macros,
+// so we define our own equivalent version that can.
+#define LWIP_VERSION_MACRO (LWIP_VERSION_MAJOR << 24 | LWIP_VERSION_MINOR << 16 \
+                            | LWIP_VERSION_REVISION << 8 | LWIP_VERSION_RC)
+
 // Extension to lwIP error codes
 #define _ERR_BADF -16
 // TODO: We just know that change happened somewhere between 1.4.0 and 1.4.1,
 // investigate in more detail.
-#if LWIP_VERSION < 0x01040100
+#if LWIP_VERSION_MACRO < 0x01040100
 static const int error_lookup_table[] = {
     0,                /* ERR_OK          0      No error, everything OK. */
     MP_ENOMEM,        /* ERR_MEM        -1      Out of memory error.     */
@@ -196,7 +206,7 @@ static const int error_lookup_table[] = {
     MP_EALREADY,      /* ERR_ISCONN     -15     Already connected.       */
     MP_EBADF,         /* _ERR_BADF      -16     Closed socket (null pcb) */
 };
-#else
+#elif LWIP_VERSION_MACRO < 0x02000000
 static const int error_lookup_table[] = {
     0,                /* ERR_OK          0      No error, everything OK. */
     MP_ENOMEM,        /* ERR_MEM        -1      Out of memory error.     */
@@ -217,6 +227,30 @@ static const int error_lookup_table[] = {
     -1,               /* ERR_IF         -15     Low-level netif error    */
     MP_EBADF,         /* _ERR_BADF      -16     Closed socket (null pcb) */
 };
+#else
+// Matches lwIP 2.0.3
+#undef _ERR_BADF
+#define _ERR_BADF -17
+static const int error_lookup_table[] = {
+    0,                /* ERR_OK          0      No error, everything OK  */
+    MP_ENOMEM,        /* ERR_MEM        -1      Out of memory error      */
+    MP_ENOBUFS,       /* ERR_BUF        -2      Buffer error             */
+    MP_EWOULDBLOCK,   /* ERR_TIMEOUT    -3      Timeout                  */
+    MP_EHOSTUNREACH,  /* ERR_RTE        -4      Routing problem          */
+    MP_EINPROGRESS,   /* ERR_INPROGRESS -5      Operation in progress    */
+    MP_EINVAL,        /* ERR_VAL        -6      Illegal value            */
+    MP_EWOULDBLOCK,   /* ERR_WOULDBLOCK -7      Operation would block    */
+    MP_EADDRINUSE,    /* ERR_USE        -8      Address in use           */
+    MP_EALREADY,      /* ERR_ALREADY    -9      Already connecting       */
+    MP_EALREADY,      /* ERR_ISCONN     -10     Conn already established */
+    MP_ENOTCONN,      /* ERR_CONN       -11     Not connected            */
+    -1,               /* ERR_IF         -12     Low-level netif error    */
+    MP_ECONNABORTED,  /* ERR_ABRT       -13     Connection aborted       */
+    MP_ECONNRESET,    /* ERR_RST        -14     Connection reset         */
+    MP_ENOTCONN,      /* ERR_CLSD       -15     Connection closed        */
+    MP_EIO,           /* ERR_ARG        -16     Illegal argument.        */
+    MP_EBADF,         /* _ERR_BADF      -17     Closed socket (null pcb) */
+};
 #endif
 
 /*******************************************************************************/
@@ -276,7 +310,12 @@ static inline void exec_user_callback(lwip_socket_obj_t *socket) {
 
 // Callback for incoming UDP packets. We simply stash the packet and the source address,
 // in case we need it for recvfrom.
-STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, u16_t port) {
+#if LWIP_VERSION_MAJOR < 2
+STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, u16_t port)
+#else
+STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
+#endif
+{
     lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
 
     if (socket->incoming.pbuf != NULL) {
@@ -1287,7 +1326,12 @@ typedef struct _getaddrinfo_state_t {
 } getaddrinfo_state_t;
 
 // Callback for incoming DNS requests.
-STATIC void lwip_getaddrinfo_cb(const char *name, ip_addr_t *ipaddr, void *arg) {
+#if LWIP_VERSION_MAJOR < 2
+STATIC void lwip_getaddrinfo_cb(const char *name, ip_addr_t *ipaddr, void *arg)
+#else
+STATIC void lwip_getaddrinfo_cb(const char *name, const ip_addr_t *ipaddr, void *arg)
+#endif
+{
     getaddrinfo_state_t *state = arg;
     if (ipaddr != NULL) {
         state->status = 1;
-- 
cgit v1.2.3


From 1e2a6a84a263e069d7be5f27d73e7fc124413fa5 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 17 May 2018 23:17:36 +1000
Subject: extmod/modlwip: Set POLLHUP flag for sockets that are new.

This matches CPython behaviour on Linux: a socket that is new and not
listening or connected is considered "hung up".

Thanks to @rkojedzinszky for the initial patch, PR #3457.
---
 extmod/modlwip.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 19766c0c8..7c0a20a1b 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -723,6 +723,9 @@ STATIC mp_obj_t lwip_socket_listen(mp_obj_t self_in, mp_obj_t backlog_in) {
     socket->pcb.tcp = new_pcb;
     tcp_accept(new_pcb, _lwip_tcp_accept);
 
+    // Socket is no longer considered "new" for purposes of polling
+    socket->state = STATE_CONNECTING;
+
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(lwip_socket_listen_obj, lwip_socket_listen);
@@ -1176,7 +1179,10 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             ret |= MP_STREAM_POLL_WR;
         }
 
-        if (socket->state == STATE_PEER_CLOSED) {
+        if (socket->state == STATE_NEW) {
+            // New sockets are not connected so set HUP
+            ret |= flags & MP_STREAM_POLL_HUP;
+        } else if (socket->state == STATE_PEER_CLOSED) {
             // Peer-closed socket is both readable and writable: read will
             // return EOF, write - error. Without this poll will hang on a
             // socket which was closed by peer.
-- 
cgit v1.2.3


From 41766ba7e67022d2d15ce78896a730745ea3871f Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 21 May 2018 16:46:30 +1000
Subject: extmod/modlwip: Allow to compile with MICROPY_PY_LWIP disabled.

---
 extmod/modlwip.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 7c0a20a1b..dfb5de9e4 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1409,7 +1409,7 @@ STATIC mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     tuple->items[4] = netutils_format_inet_addr((uint8_t*)&state.ipaddr, port, NETUTILS_BIG);
     return mp_obj_new_list(1, (mp_obj_t*)&tuple);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lwip_getaddrinfo_obj, 2, 6, lwip_getaddrinfo);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lwip_getaddrinfo_obj, 2, 6, lwip_getaddrinfo);
 
 // Debug functions
 
-- 
cgit v1.2.3


From 98b9f0fc9d0fe14c5f13faf2e9b902422919594c Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 31 May 2018 21:47:26 +1000
Subject: extmod/modussl_mbedtls: Populate sock member right away in
 wrap_socket.

Otherwise the "sock" member may have an undefined value if wrap_socket
fails with an exception and exits early, and then if the finaliser runs it
will try to close an invalid stream object.

Fixes issue #3828.
---
 extmod/modussl_mbedtls.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index bd4b0c725..636f45f4e 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -124,6 +124,7 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
 #endif
     o->base.type = &ussl_socket_type;
+    o->sock = sock;
 
     int ret;
     mbedtls_ssl_init(&o->ssl);
@@ -171,7 +172,6 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
         }
     }
 
-    o->sock = sock;
     mbedtls_ssl_set_bio(&o->ssl, &o->sock, _mbedtls_ssl_send, _mbedtls_ssl_recv, NULL);
 
     if (args->key.u_obj != MP_OBJ_NULL) {
-- 
cgit v1.2.3


From ea22406f7661edcce88defb9d20517ec967a5a9f Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Thu, 31 May 2018 21:52:29 +1000
Subject: extmod/modussl_mbedtls: Use mbedtls_entropy_func for CTR-DRBG
 entropy.

If mbedtls_ctr_drbg_seed() is available in the mbedtls bulid then so should
be mbedtls_entropy_func().  Then it's up to the port to configure a valid
entropy source, eg via MBEDTLS_ENTROPY_HARDWARE_ALT.
---
 extmod/modussl_mbedtls.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 636f45f4e..1c9dfd17f 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -73,15 +73,6 @@ STATIC void mbedtls_debug(void *ctx, int level, const char *file, int line, cons
 }
 #endif
 
-// TODO: FIXME!
-STATIC int null_entropy_func(void *data, unsigned char *output, size_t len) {
-    (void)data;
-    (void)output;
-    (void)len;
-    // enjoy random bytes
-    return 0;
-}
-
 STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
     mp_obj_t sock = *(mp_obj_t*)ctx;
 
@@ -140,7 +131,7 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     mbedtls_entropy_init(&o->entropy);
     const byte seed[] = "upy";
-    ret = mbedtls_ctr_drbg_seed(&o->ctr_drbg, null_entropy_func/*mbedtls_entropy_func*/, &o->entropy, seed, sizeof(seed));
+    ret = mbedtls_ctr_drbg_seed(&o->ctr_drbg, mbedtls_entropy_func, &o->entropy, seed, sizeof(seed));
     if (ret != 0) {
         goto cleanup;
     }
-- 
cgit v1.2.3


From 172c23fe5d2efd464433c1d80304b8f3d54e7961 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 6 Jun 2018 11:57:01 +1000
Subject: extmod/vfs: Use u_rom_obj properly in argument structures.

---
 extmod/vfs.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index 16f75aba9..7298edab1 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -155,8 +155,8 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
 mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_readonly, ARG_mkfs };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_false} },
-        { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_false} },
+        { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_false_obj)} },
+        { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_false_obj)} },
     };
 
     // parse args
@@ -264,7 +264,7 @@ mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_vfs_mount_t *vfs = lookup_path((mp_obj_t)args[ARG_file].u_rom_obj, &args[ARG_file].u_obj);
+    mp_vfs_mount_t *vfs = lookup_path(args[ARG_file].u_obj, &args[ARG_file].u_obj);
     return mp_vfs_proxy_call(vfs, MP_QSTR_open, 2, (mp_obj_t*)&args);
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_open_obj, 0, mp_vfs_open);
-- 
cgit v1.2.3


From f35aae366c4fd54a166960f830b4f93608d847cb Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 6 Jun 2018 12:00:23 +1000
Subject: extmod/vfs_fat: Rename FileIO/TextIO types to mp_type_vfs_fat_XXX.

So they don't clash with other VFS implementations.
---
 extmod/vfs_fat.h             |  2 ++
 extmod/vfs_fat_file.c        | 16 +++++-----------
 ports/cc3200/mpconfigport.h  |  4 ++--
 ports/esp32/mpconfigport.h   |  4 ++--
 ports/esp8266/mpconfigport.h |  4 ++--
 ports/stm32/mpconfigport.h   |  4 ++--
 6 files changed, 15 insertions(+), 19 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index da56a9077..e0836a555 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -55,6 +55,8 @@ typedef struct _fs_user_mount_t {
 
 extern const byte fresult_to_errno_table[20];
 extern const mp_obj_type_t mp_fat_vfs_type;
+extern const mp_obj_type_t mp_type_vfs_fat_fileio;
+extern const mp_obj_type_t mp_type_vfs_fat_textio;
 
 mp_import_stat_t fat_vfs_import_stat(struct _fs_user_mount_t *vfs, const char *path);
 MP_DECLARE_CONST_FUN_OBJ_3(fat_vfs_open_obj);
diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index cbd013f16..f7b9331b8 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -35,12 +35,6 @@
 #include "lib/oofatfs/ff.h"
 #include "extmod/vfs_fat.h"
 
-#define mp_type_fileio fatfs_type_fileio
-#define mp_type_textio fatfs_type_textio
-
-extern const mp_obj_type_t mp_type_fileio;
-extern const mp_obj_type_t mp_type_textio;
-
 // this table converts from FRESULT to POSIX errno
 const byte fresult_to_errno_table[20] = {
     [FR_OK] = 0,
@@ -189,11 +183,11 @@ STATIC mp_obj_t file_open(fs_user_mount_t *vfs, const mp_obj_type_t *type, mp_ar
                 break;
             #if MICROPY_PY_IO_FILEIO
             case 'b':
-                type = &mp_type_fileio;
+                type = &mp_type_vfs_fat_fileio;
                 break;
             #endif
             case 't':
-                type = &mp_type_textio;
+                type = &mp_type_vfs_fat_textio;
                 break;
         }
     }
@@ -249,7 +243,7 @@ STATIC const mp_stream_p_t fileio_stream_p = {
     .ioctl = file_obj_ioctl,
 };
 
-const mp_obj_type_t mp_type_fileio = {
+const mp_obj_type_t mp_type_vfs_fat_fileio = {
     { &mp_type_type },
     .name = MP_QSTR_FileIO,
     .print = file_obj_print,
@@ -268,7 +262,7 @@ STATIC const mp_stream_p_t textio_stream_p = {
     .is_text = true,
 };
 
-const mp_obj_type_t mp_type_textio = {
+const mp_obj_type_t mp_type_vfs_fat_textio = {
     { &mp_type_type },
     .name = MP_QSTR_TextIOWrapper,
     .print = file_obj_print,
@@ -287,7 +281,7 @@ STATIC mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_
     arg_vals[0].u_obj = path;
     arg_vals[1].u_obj = mode;
     arg_vals[2].u_obj = mp_const_none;
-    return file_open(self, &mp_type_textio, arg_vals);
+    return file_open(self, &mp_type_vfs_fat_textio, arg_vals);
 }
 MP_DEFINE_CONST_FUN_OBJ_3(fat_vfs_open_obj, fatfs_builtin_open_self);
 
diff --git a/ports/cc3200/mpconfigport.h b/ports/cc3200/mpconfigport.h
index 29ae9092b..ee9a226e5 100644
--- a/ports/cc3200/mpconfigport.h
+++ b/ports/cc3200/mpconfigport.h
@@ -131,8 +131,8 @@
     X(ETIMEDOUT) \
 
 // TODO these should be generic, not bound to fatfs
-#define mp_type_fileio fatfs_type_fileio
-#define mp_type_textio fatfs_type_textio
+#define mp_type_fileio mp_type_vfs_fat_fileio
+#define mp_type_textio mp_type_vfs_fat_textio
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
diff --git a/ports/esp32/mpconfigport.h b/ports/esp32/mpconfigport.h
index c7a87e3af..24034ba16 100644
--- a/ports/esp32/mpconfigport.h
+++ b/ports/esp32/mpconfigport.h
@@ -152,8 +152,8 @@
 #define MICROPY_FATFS_RPATH                 (2)
 #define MICROPY_FATFS_MAX_SS                (4096)
 #define MICROPY_FATFS_LFN_CODE_PAGE         (437) /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
-#define mp_type_fileio                      fatfs_type_fileio
-#define mp_type_textio                      fatfs_type_textio
+#define mp_type_fileio                      mp_type_vfs_fat_fileio
+#define mp_type_textio                      mp_type_vfs_fat_textio
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
diff --git a/ports/esp8266/mpconfigport.h b/ports/esp8266/mpconfigport.h
index f29dbe5c0..ff45f86ae 100644
--- a/ports/esp8266/mpconfigport.h
+++ b/ports/esp8266/mpconfigport.h
@@ -141,8 +141,8 @@ typedef uint32_t sys_prot_t; // for modlwip
 void *esp_native_code_commit(void*, size_t);
 #define MP_PLAT_COMMIT_EXEC(buf, len) esp_native_code_commit(buf, len)
 
-#define mp_type_fileio fatfs_type_fileio
-#define mp_type_textio fatfs_type_textio
+#define mp_type_fileio mp_type_vfs_fat_fileio
+#define mp_type_textio mp_type_vfs_fat_textio
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
diff --git a/ports/stm32/mpconfigport.h b/ports/stm32/mpconfigport.h
index 7bd944213..ecb3596ff 100644
--- a/ports/stm32/mpconfigport.h
+++ b/ports/stm32/mpconfigport.h
@@ -161,8 +161,8 @@
 #define MICROPY_FATFS_MULTI_PARTITION  (1)
 
 // TODO these should be generic, not bound to fatfs
-#define mp_type_fileio fatfs_type_fileio
-#define mp_type_textio fatfs_type_textio
+#define mp_type_fileio mp_type_vfs_fat_fileio
+#define mp_type_textio mp_type_vfs_fat_textio
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
-- 
cgit v1.2.3


From 8d82b0edbd38cd6019ec1c55dbc886c9058be7d4 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 6 Jun 2018 13:11:33 +1000
Subject: extmod: Add VfsPosix filesystem component.

This VFS component allows to mount a host POSIX filesystem within the uPy
VFS sub-system.  All traditional POSIX file access then goes through the
VFS, allowing to sandbox a uPy process to a certain sub-dir of the host
system, as well as mount other filesystem types alongside the host
filesystem.
---
 extmod/vfs_posix.c      | 357 ++++++++++++++++++++++++++++++++++++++++++++++++
 extmod/vfs_posix.h      |  41 ++++++
 extmod/vfs_posix_file.c | 261 +++++++++++++++++++++++++++++++++++
 py/mpconfig.h           |   5 +
 py/py.mk                |   2 +
 5 files changed, 666 insertions(+)
 create mode 100644 extmod/vfs_posix.c
 create mode 100644 extmod/vfs_posix.h
 create mode 100644 extmod/vfs_posix_file.c

(limited to 'extmod')

diff --git a/extmod/vfs_posix.c b/extmod/vfs_posix.c
new file mode 100644
index 000000000..0db45a0c1
--- /dev/null
+++ b/extmod/vfs_posix.c
@@ -0,0 +1,357 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017-2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "extmod/vfs.h"
+#include "extmod/vfs_posix.h"
+
+#if MICROPY_VFS_POSIX
+
+#include <string.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+typedef struct _mp_obj_vfs_posix_t {
+    mp_obj_base_t base;
+    vstr_t root;
+    size_t root_len;
+    bool readonly;
+} mp_obj_vfs_posix_t;
+
+STATIC const char *vfs_posix_get_path_str(mp_obj_vfs_posix_t *self, mp_obj_t path) {
+    if (self->root_len == 0) {
+        return mp_obj_str_get_str(path);
+    } else {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, mp_obj_str_get_str(path));
+        return vstr_null_terminated_str(&self->root);
+    }
+}
+
+STATIC mp_obj_t vfs_posix_get_path_obj(mp_obj_vfs_posix_t *self, mp_obj_t path) {
+    if (self->root_len == 0) {
+        return path;
+    } else {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, mp_obj_str_get_str(path));
+        return mp_obj_new_str(self->root.buf, self->root.len);
+    }
+}
+
+STATIC mp_obj_t vfs_posix_fun1_helper(mp_obj_t self_in, mp_obj_t path_in, int (*f)(const char*)) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    int ret = f(vfs_posix_get_path_str(self, path_in));
+    if (ret != 0) {
+        mp_raise_OSError(errno);
+    }
+    return mp_const_none;
+}
+
+mp_import_stat_t mp_vfs_posix_import_stat(mp_obj_vfs_posix_t *self, const char *path) {
+    if (self->root_len != 0) {
+        self->root.len = self->root_len;
+        vstr_add_str(&self->root, path);
+        path = vstr_null_terminated_str(&self->root);
+    }
+    struct stat st;
+    if (stat(path, &st) == 0) {
+        if (S_ISDIR(st.st_mode)) {
+            return MP_IMPORT_STAT_DIR;
+        } else if (S_ISREG(st.st_mode)) {
+            return MP_IMPORT_STAT_FILE;
+        }
+    }
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+STATIC mp_obj_t vfs_posix_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+
+    mp_obj_vfs_posix_t *vfs = m_new_obj(mp_obj_vfs_posix_t);
+    vfs->base.type = type;
+    vstr_init(&vfs->root, 0);
+    if (n_args == 1) {
+        vstr_add_str(&vfs->root, mp_obj_str_get_str(args[0]));
+        vstr_add_char(&vfs->root, '/');
+    }
+    vfs->root_len = vfs->root.len;
+    vfs->readonly = false;
+
+    return MP_OBJ_FROM_PTR(vfs);
+}
+
+STATIC mp_obj_t vfs_posix_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    if (mp_obj_is_true(readonly)) {
+        self->readonly = true;
+    }
+    if (mp_obj_is_true(mkfs)) {
+        mp_raise_OSError(MP_EPERM);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_mount_obj, vfs_posix_mount);
+
+STATIC mp_obj_t vfs_posix_umount(mp_obj_t self_in) {
+    (void)self_in;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_umount_obj, vfs_posix_umount);
+
+STATIC mp_obj_t vfs_posix_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *mode = mp_obj_str_get_str(mode_in);
+    if (self->readonly
+        && (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL || strchr(mode, '+') != NULL)) {
+        mp_raise_OSError(MP_EROFS);
+    }
+    if (!MP_OBJ_IS_SMALL_INT(path_in)) {
+        path_in = vfs_posix_get_path_obj(self, path_in);
+    }
+    return mp_vfs_posix_file_open(&mp_type_textio, path_in, mode_in);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_open_obj, vfs_posix_open);
+
+STATIC mp_obj_t vfs_posix_chdir(mp_obj_t self_in, mp_obj_t path_in) {
+    return vfs_posix_fun1_helper(self_in, path_in, chdir);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_chdir_obj, vfs_posix_chdir);
+
+STATIC mp_obj_t vfs_posix_getcwd(mp_obj_t self_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    char buf[MICROPY_ALLOC_PATH_MAX + 1];
+    const char *ret = getcwd(buf, sizeof(buf));
+    if (ret == NULL) {
+        mp_raise_OSError(errno);
+    }
+    ret += self->root_len;
+    return mp_obj_new_str(ret, strlen(ret));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_getcwd_obj, vfs_posix_getcwd);
+
+typedef struct _vfs_posix_ilistdir_it_t {
+    mp_obj_base_t base;
+    mp_fun_1_t iternext;
+    bool is_str;
+    DIR *dir;
+} vfs_posix_ilistdir_it_t;
+
+STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
+    vfs_posix_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
+
+    if (self->dir == NULL) {
+        return MP_OBJ_STOP_ITERATION;
+    }
+
+    for (;;) {
+        struct dirent *dirent = readdir(self->dir);
+        if (dirent == NULL) {
+            closedir(self->dir);
+            self->dir = NULL;
+            return MP_OBJ_STOP_ITERATION;
+        }
+        const char *fn = dirent->d_name;
+
+        if (fn[0] == '.' && (fn[1] == 0 || fn[1] == '.')) {
+            // skip . and ..
+            continue;
+        }
+
+        // make 3-tuple with info about this entry
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
+
+        if (self->is_str) {
+            t->items[0] = mp_obj_new_str(fn, strlen(fn));
+        } else {
+            t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
+        }
+
+        #ifdef _DIRENT_HAVE_D_TYPE
+        if (dirent->d_type == DT_DIR) {
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
+        } else if (dirent->d_type == DT_REG) {
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
+        } else {
+            t->items[1] = MP_OBJ_NEW_SMALL_INT(dirent->d_type);
+        }
+        #else
+        // DT_UNKNOWN should have 0 value on any reasonable system
+        t->items[1] = MP_OBJ_NEW_SMALL_INT(0);
+        #endif
+        #ifdef _DIRENT_HAVE_D_INO
+        t->items[2] = MP_OBJ_NEW_SMALL_INT(dirent->d_ino);
+        #else
+        t->items[2] = MP_OBJ_NEW_SMALL_INT(0);
+        #endif
+
+        return MP_OBJ_FROM_PTR(t);
+    }
+}
+
+STATIC mp_obj_t vfs_posix_ilistdir(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    vfs_posix_ilistdir_it_t *iter = m_new_obj(vfs_posix_ilistdir_it_t);
+    iter->base.type = &mp_type_polymorph_iter;
+    iter->iternext = vfs_posix_ilistdir_it_iternext;
+    iter->is_str = mp_obj_get_type(path_in) == &mp_type_str;
+    const char *path = vfs_posix_get_path_str(self, path_in);
+    iter->dir = opendir(path);
+    if (iter->dir == NULL) {
+        mp_raise_OSError(errno);
+    }
+    return MP_OBJ_FROM_PTR(iter);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_ilistdir_obj, vfs_posix_ilistdir);
+
+typedef struct _mp_obj_listdir_t {
+    mp_obj_base_t base;
+    mp_fun_1_t iternext;
+    DIR *dir;
+} mp_obj_listdir_t;
+
+STATIC mp_obj_t vfs_posix_mkdir(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    int ret = mkdir(vfs_posix_get_path_str(self, path_in), 0777);
+    if (ret != 0) {
+        mp_raise_OSError(errno);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_mkdir_obj, vfs_posix_mkdir);
+
+STATIC mp_obj_t vfs_posix_remove(mp_obj_t self_in, mp_obj_t path_in) {
+    return vfs_posix_fun1_helper(self_in, path_in, unlink);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_remove_obj, vfs_posix_remove);
+
+STATIC mp_obj_t vfs_posix_rename(mp_obj_t self_in, mp_obj_t old_path_in, mp_obj_t new_path_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    const char *old_path = vfs_posix_get_path_str(self, old_path_in);
+    const char *new_path = vfs_posix_get_path_str(self, new_path_in);
+    int ret = rename(old_path, new_path);
+    if (ret != 0) {
+        mp_raise_OSError(errno);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_rename_obj, vfs_posix_rename);
+
+STATIC mp_obj_t vfs_posix_rmdir(mp_obj_t self_in, mp_obj_t path_in) {
+    return vfs_posix_fun1_helper(self_in, path_in, rmdir);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_rmdir_obj, vfs_posix_rmdir);
+
+STATIC mp_obj_t vfs_posix_stat(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    struct stat sb;
+    int ret = stat(vfs_posix_get_path_str(self, path_in), &sb);
+    if (ret != 0) {
+        mp_raise_OSError(errno);
+    }
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.st_mode);
+    t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.st_ino);
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(sb.st_dev);
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(sb.st_nlink);
+    t->items[4] = MP_OBJ_NEW_SMALL_INT(sb.st_uid);
+    t->items[5] = MP_OBJ_NEW_SMALL_INT(sb.st_gid);
+    t->items[6] = MP_OBJ_NEW_SMALL_INT(sb.st_size);
+    t->items[7] = MP_OBJ_NEW_SMALL_INT(sb.st_atime);
+    t->items[8] = MP_OBJ_NEW_SMALL_INT(sb.st_mtime);
+    t->items[9] = MP_OBJ_NEW_SMALL_INT(sb.st_ctime);
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_stat_obj, vfs_posix_stat);
+
+#ifdef __ANDROID__
+#define USE_STATFS 1
+#endif
+
+#if USE_STATFS
+#include <sys/vfs.h>
+#define STRUCT_STATVFS struct statfs
+#define STATVFS statfs
+#define F_FAVAIL sb.f_ffree
+#define F_NAMEMAX sb.f_namelen
+#define F_FLAG sb.f_flags
+#else
+#include <sys/statvfs.h>
+#define STRUCT_STATVFS struct statvfs
+#define STATVFS statvfs
+#define F_FAVAIL sb.f_favail
+#define F_NAMEMAX sb.f_namemax
+#define F_FLAG sb.f_flag
+#endif
+
+STATIC mp_obj_t vfs_posix_statvfs(mp_obj_t self_in, mp_obj_t path_in) {
+    mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
+    STRUCT_STATVFS sb;
+    const char *path = vfs_posix_get_path_str(self, path_in);
+    int ret = STATVFS(path, &sb);
+    if (ret != 0) {
+        mp_raise_OSError(errno);
+    }
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.f_bsize);
+    t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.f_frsize);
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(sb.f_blocks);
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(sb.f_bfree);
+    t->items[4] = MP_OBJ_NEW_SMALL_INT(sb.f_bavail);
+    t->items[5] = MP_OBJ_NEW_SMALL_INT(sb.f_files);
+    t->items[6] = MP_OBJ_NEW_SMALL_INT(sb.f_ffree);
+    t->items[7] = MP_OBJ_NEW_SMALL_INT(F_FAVAIL);
+    t->items[8] = MP_OBJ_NEW_SMALL_INT(F_FLAG);
+    t->items[9] = MP_OBJ_NEW_SMALL_INT(F_NAMEMAX);
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_statvfs_obj, vfs_posix_statvfs);
+
+STATIC const mp_rom_map_elem_t vfs_posix_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&vfs_posix_mount_obj) },
+    { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&vfs_posix_umount_obj) },
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&vfs_posix_open_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&vfs_posix_chdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&vfs_posix_getcwd_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&vfs_posix_ilistdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&vfs_posix_mkdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&vfs_posix_remove_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&vfs_posix_rename_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&vfs_posix_rmdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&vfs_posix_stat_obj) },
+    { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&vfs_posix_statvfs_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(vfs_posix_locals_dict, vfs_posix_locals_dict_table);
+
+const mp_obj_type_t mp_type_vfs_posix = {
+    { &mp_type_type },
+    .name = MP_QSTR_VfsPosix,
+    .make_new = vfs_posix_make_new,
+    .locals_dict = (mp_obj_dict_t*)&vfs_posix_locals_dict,
+};
+
+#endif // MICROPY_VFS_POSIX
diff --git a/extmod/vfs_posix.h b/extmod/vfs_posix.h
new file mode 100644
index 000000000..35a255ff6
--- /dev/null
+++ b/extmod/vfs_posix.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_EXTMOD_VFS_POSIX_H
+#define MICROPY_INCLUDED_EXTMOD_VFS_POSIX_H
+
+#include "py/lexer.h"
+#include "py/obj.h"
+
+struct _mp_obj_vfs_posix_t;
+
+extern const mp_obj_type_t mp_type_vfs_posix;
+extern const mp_obj_type_t mp_type_vfs_posix_fileio;
+extern const mp_obj_type_t mp_type_vfs_posix_textio;
+
+mp_import_stat_t mp_vfs_posix_import_stat(struct _mp_obj_vfs_posix_t *self, const char *path_in);
+mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in);
+
+#endif // MICROPY_INCLUDED_EXTMOD_VFS_POSIX_H
diff --git a/extmod/vfs_posix_file.c b/extmod/vfs_posix_file.c
new file mode 100644
index 000000000..435ac65cd
--- /dev/null
+++ b/extmod/vfs_posix_file.c
@@ -0,0 +1,261 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "extmod/vfs_posix.h"
+
+#if MICROPY_VFS_POSIX
+
+#include <fcntl.h>
+
+#ifdef _WIN32
+#define fsync _commit
+#endif
+
+typedef struct _mp_obj_vfs_posix_file_t {
+    mp_obj_base_t base;
+    int fd;
+} mp_obj_vfs_posix_file_t;
+
+#ifdef MICROPY_CPYTHON_COMPAT
+STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
+    if (o->fd < 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "I/O operation on closed file"));
+    }
+}
+#else
+#define check_fd_is_open(o)
+#endif
+
+STATIC void vfs_posix_file_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    (void)kind;
+    mp_obj_vfs_posix_file_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "<io.%s %d>", mp_obj_get_type_str(self_in), self->fd);
+}
+
+mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in) {
+    mp_obj_vfs_posix_file_t *o = m_new_obj(mp_obj_vfs_posix_file_t);
+    const char *mode_s = mp_obj_str_get_str(mode_in);
+
+    int mode_rw = 0, mode_x = 0;
+    while (*mode_s) {
+        switch (*mode_s++) {
+            case 'r':
+                mode_rw = O_RDONLY;
+                break;
+            case 'w':
+                mode_rw = O_WRONLY;
+                mode_x = O_CREAT | O_TRUNC;
+                break;
+            case 'a':
+                mode_rw = O_WRONLY;
+                mode_x = O_CREAT | O_APPEND;
+                break;
+            case '+':
+                mode_rw = O_RDWR;
+                break;
+            #if MICROPY_PY_IO_FILEIO
+            // If we don't have io.FileIO, then files are in text mode implicitly
+            case 'b':
+                type = &mp_type_vfs_posix_fileio;
+                break;
+            case 't':
+                type = &mp_type_vfs_posix_textio;
+                break;
+            #endif
+        }
+    }
+
+    o->base.type = type;
+
+    mp_obj_t fid = file_in;
+
+    if (MP_OBJ_IS_SMALL_INT(fid)) {
+        o->fd = MP_OBJ_SMALL_INT_VALUE(fid);
+        return MP_OBJ_FROM_PTR(o);
+    }
+
+    const char *fname = mp_obj_str_get_str(fid);
+    int fd = open(fname, mode_x | mode_rw, 0644);
+    if (fd == -1) {
+        mp_raise_OSError(errno);
+    }
+    o->fd = fd;
+    return MP_OBJ_FROM_PTR(o);
+}
+
+STATIC mp_obj_t vfs_posix_file_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
+    };
+
+    mp_arg_val_t arg_vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, args, MP_ARRAY_SIZE(allowed_args), allowed_args, arg_vals);
+    return mp_vfs_posix_file_open(type, arg_vals[0].u_obj, arg_vals[1].u_obj);
+}
+
+STATIC mp_obj_t vfs_posix_file_fileno(mp_obj_t self_in) {
+    mp_obj_vfs_posix_file_t *self = MP_OBJ_TO_PTR(self_in);
+    check_fd_is_open(self);
+    return MP_OBJ_NEW_SMALL_INT(self->fd);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_file_fileno_obj, vfs_posix_file_fileno);
+
+STATIC mp_obj_t vfs_posix_file___exit__(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    return mp_stream_close(args[0]);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vfs_posix_file___exit___obj, 4, 4, vfs_posix_file___exit__);
+
+STATIC mp_uint_t vfs_posix_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
+    mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
+    check_fd_is_open(o);
+    mp_int_t r = read(o->fd, buf, size);
+    if (r == -1) {
+        *errcode = errno;
+        return MP_STREAM_ERROR;
+    }
+    return r;
+}
+
+STATIC mp_uint_t vfs_posix_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
+    mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
+    check_fd_is_open(o);
+    #if MICROPY_PY_OS_DUPTERM
+    if (o->fd <= STDERR_FILENO) {
+        mp_hal_stdout_tx_strn(buf, size);
+        return size;
+    }
+    #endif
+    mp_int_t r = write(o->fd, buf, size);
+    while (r == -1 && errno == EINTR) {
+        if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
+            mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
+            MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
+            nlr_raise(obj);
+        }
+        r = write(o->fd, buf, size);
+    }
+    if (r == -1) {
+        *errcode = errno;
+        return MP_STREAM_ERROR;
+    }
+    return r;
+}
+
+STATIC mp_uint_t vfs_posix_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
+    check_fd_is_open(o);
+    switch (request) {
+        case MP_STREAM_FLUSH:
+            if (fsync(o->fd) < 0) {
+                *errcode = errno;
+                return MP_STREAM_ERROR;
+            }
+            return 0;
+        case MP_STREAM_SEEK: {
+            struct mp_stream_seek_t *s = (struct mp_stream_seek_t*)arg;
+            off_t off = lseek(o->fd, s->offset, s->whence);
+            if (off == (off_t)-1) {
+                *errcode = errno;
+                return MP_STREAM_ERROR;
+            }
+            s->offset = off;
+            return 0;
+        }
+        case MP_STREAM_CLOSE:
+            close(o->fd);
+            #ifdef MICROPY_CPYTHON_COMPAT
+            o->fd = -1;
+            #endif
+            return 0;
+        default:
+            *errcode = EINVAL;
+            return MP_STREAM_ERROR;
+    }
+}
+
+STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&vfs_posix_file_fileno_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
+    { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&vfs_posix_file___exit___obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
+
+#if MICROPY_PY_IO_FILEIO
+STATIC const mp_stream_p_t fileio_stream_p = {
+    .read = vfs_posix_file_read,
+    .write = vfs_posix_file_write,
+    .ioctl = vfs_posix_file_ioctl,
+};
+
+const mp_obj_type_t mp_type_vfs_posix_fileio = {
+    { &mp_type_type },
+    .name = MP_QSTR_FileIO,
+    .print = vfs_posix_file_print,
+    .make_new = vfs_posix_file_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &fileio_stream_p,
+    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+};
+#endif
+
+STATIC const mp_stream_p_t textio_stream_p = {
+    .read = vfs_posix_file_read,
+    .write = vfs_posix_file_write,
+    .ioctl = vfs_posix_file_ioctl,
+    .is_text = true,
+};
+
+const mp_obj_type_t mp_type_vfs_posix_textio = {
+    { &mp_type_type },
+    .name = MP_QSTR_TextIOWrapper,
+    .print = vfs_posix_file_print,
+    .make_new = vfs_posix_file_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &textio_stream_p,
+    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+};
+
+const mp_obj_vfs_posix_file_t mp_sys_stdin_obj  = {{&mp_type_textio}, STDIN_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stdout_obj = {{&mp_type_textio}, STDOUT_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stderr_obj = {{&mp_type_textio}, STDERR_FILENO};
+
+#endif // MICROPY_VFS_POSIX
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 100e2a981..dc0fc5d40 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -681,6 +681,11 @@ typedef double mp_float_t;
 #define MICROPY_VFS (0)
 #endif
 
+// Support for VFS POSIX component, to mount a POSIX filesystem within VFS
+#ifndef MICROPY_VFS
+#define MICROPY_VFS_POSIX (0)
+#endif
+
 /*****************************************************************************/
 /* Fine control over Python builtins, classes, modules, etc                  */
 
diff --git a/py/py.mk b/py/py.mk
index a91813526..f4b62a88a 100644
--- a/py/py.mk
+++ b/py/py.mk
@@ -241,6 +241,8 @@ PY_EXTMOD_O_BASENAME = \
 	extmod/modframebuf.o \
 	extmod/vfs.o \
 	extmod/vfs_reader.o \
+	extmod/vfs_posix.o \
+	extmod/vfs_posix_file.o \
 	extmod/vfs_fat.o \
 	extmod/vfs_fat_diskio.o \
 	extmod/vfs_fat_file.o \
-- 
cgit v1.2.3


From d4ce57e4e320a717db1a231f2e6c1e92afaafde0 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 6 Jun 2018 13:12:23 +1000
Subject: extmod/vfs: Add fast path for stating VfsPosix filesystem.

---
 extmod/vfs.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index 7298edab1..96d5019b3 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -34,6 +34,9 @@
 
 #if MICROPY_VFS
 
+#if MICROPY_VFS_POSIX
+#include "extmod/vfs_posix.h"
+#endif
 #if MICROPY_VFS_FAT
 #include "extmod/vfs_fat.h"
 #endif
@@ -124,8 +127,14 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
     if (vfs == MP_VFS_NONE || vfs == MP_VFS_ROOT) {
         return MP_IMPORT_STAT_NO_EXIST;
     }
+
+    // Fast paths for known VFS types
+    #if MICROPY_VFS_POSIX
+    if (mp_obj_get_type(vfs->obj) == &mp_type_vfs_posix) {
+        return mp_vfs_posix_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
+    }
+    #endif
     #if MICROPY_VFS_FAT
-    // fast paths for known VFS types
     if (mp_obj_get_type(vfs->obj) == &mp_fat_vfs_type) {
         return fat_vfs_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     }
-- 
cgit v1.2.3


From c117effddd1f9ffd902a9712cf0ae7413696dc66 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 6 Jun 2018 14:24:23 +1000
Subject: extmod/vfs: Introduce a C-level VFS protocol, with fast import_stat.

Following other C-level protocols, this VFS protocol is added to help
abstract away implementation details of the underlying VFS in an efficient
way.  As a starting point, the import_stat function is put into this
protocol so that the VFS sub-system does not need to know about every VFS
implementation in order to do an efficient stat for importing files.

In the future it might be worth adding other functions to this protocol.
---
 extmod/vfs.c       | 17 ++++-------------
 extmod/vfs.h       |  5 +++++
 extmod/vfs_fat.c   |  9 ++++++++-
 extmod/vfs_fat.h   |  1 -
 extmod/vfs_posix.c |  8 +++++++-
 extmod/vfs_posix.h |  3 ---
 6 files changed, 24 insertions(+), 19 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs.c b/extmod/vfs.c
index 96d5019b3..77531b874 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -34,9 +34,6 @@
 
 #if MICROPY_VFS
 
-#if MICROPY_VFS_POSIX
-#include "extmod/vfs_posix.h"
-#endif
 #if MICROPY_VFS_FAT
 #include "extmod/vfs_fat.h"
 #endif
@@ -128,17 +125,11 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
         return MP_IMPORT_STAT_NO_EXIST;
     }
 
-    // Fast paths for known VFS types
-    #if MICROPY_VFS_POSIX
-    if (mp_obj_get_type(vfs->obj) == &mp_type_vfs_posix) {
-        return mp_vfs_posix_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
-    }
-    #endif
-    #if MICROPY_VFS_FAT
-    if (mp_obj_get_type(vfs->obj) == &mp_fat_vfs_type) {
-        return fat_vfs_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
+    // If the mounted object has the VFS protocol, call its import_stat helper
+    const mp_vfs_proto_t *proto = mp_obj_get_type(vfs->obj)->protocol;
+    if (proto != NULL) {
+        return proto->import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     }
-    #endif
 
     // delegate to vfs.stat() method
     mp_obj_t path_o = mp_obj_new_str(path_out, strlen(path_out));
diff --git a/extmod/vfs.h b/extmod/vfs.h
index f2efdbe79..730dea043 100644
--- a/extmod/vfs.h
+++ b/extmod/vfs.h
@@ -45,6 +45,11 @@
 #define BP_IOCTL_SEC_COUNT      (4)
 #define BP_IOCTL_SEC_SIZE       (5)
 
+// At the moment the VFS protocol just has import_stat, but could be extended to other methods
+typedef struct _mp_vfs_proto_t {
+    mp_import_stat_t (*import_stat)(void *self, const char *path);
+} mp_vfs_proto_t;
+
 typedef struct _mp_vfs_mount_t {
     const char *str; // mount point with leading /
     size_t len;
diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 5666a6b0c..4af836b2d 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -47,7 +47,8 @@
 
 #define mp_obj_fat_vfs_t fs_user_mount_t
 
-mp_import_stat_t fat_vfs_import_stat(fs_user_mount_t *vfs, const char *path) {
+STATIC mp_import_stat_t fat_vfs_import_stat(void *vfs_in, const char *path) {
+    fs_user_mount_t *vfs = vfs_in;
     FILINFO fno;
     assert(vfs != NULL);
     FRESULT res = f_stat(&vfs->fatfs, path, &fno);
@@ -421,11 +422,17 @@ STATIC const mp_rom_map_elem_t fat_vfs_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(fat_vfs_locals_dict, fat_vfs_locals_dict_table);
 
+STATIC const mp_vfs_proto_t fat_vfs_proto = {
+    .import_stat = fat_vfs_import_stat,
+};
+
 const mp_obj_type_t mp_fat_vfs_type = {
     { &mp_type_type },
     .name = MP_QSTR_VfsFat,
     .make_new = fat_vfs_make_new,
+    .protocol = &fat_vfs_proto,
     .locals_dict = (mp_obj_dict_t*)&fat_vfs_locals_dict,
+
 };
 
 #endif // MICROPY_VFS_FAT
diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index e0836a555..ba2915386 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -58,7 +58,6 @@ extern const mp_obj_type_t mp_fat_vfs_type;
 extern const mp_obj_type_t mp_type_vfs_fat_fileio;
 extern const mp_obj_type_t mp_type_vfs_fat_textio;
 
-mp_import_stat_t fat_vfs_import_stat(struct _fs_user_mount_t *vfs, const char *path);
 MP_DECLARE_CONST_FUN_OBJ_3(fat_vfs_open_obj);
 
 #endif // MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
diff --git a/extmod/vfs_posix.c b/extmod/vfs_posix.c
index 0db45a0c1..6e3bb2c5b 100644
--- a/extmod/vfs_posix.c
+++ b/extmod/vfs_posix.c
@@ -71,7 +71,8 @@ STATIC mp_obj_t vfs_posix_fun1_helper(mp_obj_t self_in, mp_obj_t path_in, int (*
     return mp_const_none;
 }
 
-mp_import_stat_t mp_vfs_posix_import_stat(mp_obj_vfs_posix_t *self, const char *path) {
+STATIC mp_import_stat_t mp_vfs_posix_import_stat(void *self_in, const char *path) {
+    mp_obj_vfs_posix_t *self = self_in;
     if (self->root_len != 0) {
         self->root.len = self->root_len;
         vstr_add_str(&self->root, path);
@@ -347,10 +348,15 @@ STATIC const mp_rom_map_elem_t vfs_posix_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(vfs_posix_locals_dict, vfs_posix_locals_dict_table);
 
+STATIC const mp_vfs_proto_t vfs_posix_proto = {
+    .import_stat = mp_vfs_posix_import_stat,
+};
+
 const mp_obj_type_t mp_type_vfs_posix = {
     { &mp_type_type },
     .name = MP_QSTR_VfsPosix,
     .make_new = vfs_posix_make_new,
+    .protocol = &vfs_posix_proto,
     .locals_dict = (mp_obj_dict_t*)&vfs_posix_locals_dict,
 };
 
diff --git a/extmod/vfs_posix.h b/extmod/vfs_posix.h
index 35a255ff6..00756b4c9 100644
--- a/extmod/vfs_posix.h
+++ b/extmod/vfs_posix.h
@@ -29,13 +29,10 @@
 #include "py/lexer.h"
 #include "py/obj.h"
 
-struct _mp_obj_vfs_posix_t;
-
 extern const mp_obj_type_t mp_type_vfs_posix;
 extern const mp_obj_type_t mp_type_vfs_posix_fileio;
 extern const mp_obj_type_t mp_type_vfs_posix_textio;
 
-mp_import_stat_t mp_vfs_posix_import_stat(struct _mp_obj_vfs_posix_t *self, const char *path_in);
 mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_obj_t mode_in);
 
 #endif // MICROPY_INCLUDED_EXTMOD_VFS_POSIX_H
-- 
cgit v1.2.3


From b045ebd354b2e1cdb268ec5667d08db15dab747e Mon Sep 17 00:00:00 2001
From: Yonatan Goldschmidt <yon.goldschmidt@gmail.com>
Date: Sat, 9 Jun 2018 02:38:34 +0300
Subject: extmod/moduhashlib: Prefix all Python methods and objects with
 uhashlib.

For consistency with other modules, and to help avoid clashes with the
actual underlying functions that do the hashing (eg
crypto-algorithms/sha256.c:sha256_update).
---
 extmod/moduhashlib.c | 74 ++++++++++++++++++++++++++--------------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 6469dcfa3..ba26e56e5 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -50,44 +50,44 @@ typedef struct _mp_obj_hash_t {
     char state[0];
 } mp_obj_hash_t;
 
-STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg);
+STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg);
 
-STATIC mp_obj_t hash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(CRYAL_SHA256_CTX));
     o->base.type = type;
     sha256_init((CRYAL_SHA256_CTX*)o->state);
     if (n_args == 1) {
-        hash_update(MP_OBJ_FROM_PTR(o), args[0]);
+        uhashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
     return MP_OBJ_FROM_PTR(o);
 }
 
 #if MICROPY_PY_UHASHLIB_SHA1
-STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg);
+STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg);
 
 #if MICROPY_SSL_AXTLS
-STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(SHA1_CTX));
     o->base.type = type;
     SHA1_Init((SHA1_CTX*)o->state);
     if (n_args == 1) {
-        sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
+        uhashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
     return MP_OBJ_FROM_PTR(o);
 }
 #endif
 
 #if MICROPY_SSL_MBEDTLS
-STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_sha1_context));
     o->base.type = type;
     mbedtls_sha1_init((mbedtls_sha1_context*)o->state);
     mbedtls_sha1_starts((mbedtls_sha1_context*)o->state);
     if (n_args == 1) {
-        sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
+        uhashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
     return MP_OBJ_FROM_PTR(o);
 }
@@ -95,19 +95,19 @@ STATIC mp_obj_t sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
 
 #endif
 
-STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
+STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
     sha256_update((CRYAL_SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_2(hash_update_obj, hash_update);
+MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
 
 #if MICROPY_PY_UHASHLIB_SHA1
 
 #if MICROPY_SSL_AXTLS
-STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
+STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
@@ -117,7 +117,7 @@ STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
 #endif
 
 #if MICROPY_SSL_MBEDTLS
-STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
+STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
@@ -126,22 +126,22 @@ STATIC mp_obj_t sha1_update(mp_obj_t self_in, mp_obj_t arg) {
 }
 #endif
 
-MP_DEFINE_CONST_FUN_OBJ_2(sha1_update_obj, sha1_update);
+MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha1_update_obj, uhashlib_sha1_update);
 #endif
 
-STATIC mp_obj_t hash_digest(mp_obj_t self_in) {
+STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
     sha256_final((CRYAL_SHA256_CTX*)self->state, (byte*)vstr.buf);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-MP_DEFINE_CONST_FUN_OBJ_1(hash_digest_obj, hash_digest);
+MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
 
 #if MICROPY_PY_UHASHLIB_SHA1
 
 #if MICROPY_SSL_AXTLS
-STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
+STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, SHA1_SIZE);
@@ -151,7 +151,7 @@ STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
 #endif
 
 #if MICROPY_SSL_MBEDTLS
-STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
+STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, 20);
@@ -161,51 +161,51 @@ STATIC mp_obj_t sha1_digest(mp_obj_t self_in) {
 }
 #endif
 
-MP_DEFINE_CONST_FUN_OBJ_1(sha1_digest_obj, sha1_digest);
+MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha1_digest_obj, uhashlib_sha1_digest);
 #endif
 
-STATIC const mp_rom_map_elem_t hash_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&hash_update_obj) },
-    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&hash_digest_obj) },
+STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha256_update_obj) },
+    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&uhashlib_sha256_digest_obj) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(hash_locals_dict, hash_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(uhashlib_sha256_locals_dict, uhashlib_sha256_locals_dict_table);
 
-STATIC const mp_obj_type_t sha256_type = {
+STATIC const mp_obj_type_t uhashlib_sha256_type = {
     { &mp_type_type },
     .name = MP_QSTR_sha256,
-    .make_new = hash_make_new,
-    .locals_dict = (void*)&hash_locals_dict,
+    .make_new = uhashlib_sha256_make_new,
+    .locals_dict = (void*)&uhashlib_sha256_locals_dict,
 };
 
 #if MICROPY_PY_UHASHLIB_SHA1
-STATIC const mp_rom_map_elem_t sha1_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&sha1_update_obj) },
-    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&sha1_digest_obj) },
+STATIC const mp_rom_map_elem_t uhashlib_sha1_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha1_update_obj) },
+    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&uhashlib_sha1_digest_obj) },
 };
-STATIC MP_DEFINE_CONST_DICT(sha1_locals_dict, sha1_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(uhashlib_sha1_locals_dict, uhashlib_sha1_locals_dict_table);
 
-STATIC const mp_obj_type_t sha1_type = {
+STATIC const mp_obj_type_t uhashlib_sha1_type = {
     { &mp_type_type },
     .name = MP_QSTR_sha1,
-    .make_new = sha1_make_new,
-    .locals_dict = (void*)&sha1_locals_dict,
+    .make_new = uhashlib_sha1_make_new,
+    .locals_dict = (void*)&uhashlib_sha1_locals_dict,
 };
 #endif
 
-STATIC const mp_rom_map_elem_t mp_module_hashlib_globals_table[] = {
+STATIC const mp_rom_map_elem_t mp_module_uhashlib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uhashlib) },
-    { MP_ROM_QSTR(MP_QSTR_sha256), MP_ROM_PTR(&sha256_type) },
+    { MP_ROM_QSTR(MP_QSTR_sha256), MP_ROM_PTR(&uhashlib_sha256_type) },
     #if MICROPY_PY_UHASHLIB_SHA1
-    { MP_ROM_QSTR(MP_QSTR_sha1), MP_ROM_PTR(&sha1_type) },
+    { MP_ROM_QSTR(MP_QSTR_sha1), MP_ROM_PTR(&uhashlib_sha1_type) },
     #endif
 };
 
-STATIC MP_DEFINE_CONST_DICT(mp_module_hashlib_globals, mp_module_hashlib_globals_table);
+STATIC MP_DEFINE_CONST_DICT(mp_module_uhashlib_globals, mp_module_uhashlib_globals_table);
 
 const mp_obj_module_t mp_module_uhashlib = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_hashlib_globals,
+    .globals = (mp_obj_dict_t*)&mp_module_uhashlib_globals,
 };
 
 #include "crypto-algorithms/sha256.c"
-- 
cgit v1.2.3


From 38682d4629c0c87d3a20330dcb10cb4e01e09aed Mon Sep 17 00:00:00 2001
From: Yonatan Goldschmidt <yon.goldschmidt@gmail.com>
Date: Sat, 9 Jun 2018 02:46:08 +0300
Subject: extmod/moduhashlib: Reorder funcs so that they are grouped by hash
 type.

Makes the code much more readable by reducing the number of #ifdefs and
keeping related functions close.
---
 extmod/moduhashlib.c | 116 ++++++++++++++++++++++-----------------------------
 1 file changed, 49 insertions(+), 67 deletions(-)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index ba26e56e5..2eb90ed73 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -63,6 +63,38 @@ STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_arg
     return MP_OBJ_FROM_PTR(o);
 }
 
+STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
+    sha256_update((CRYAL_SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
+
+STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    vstr_t vstr;
+    vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
+    sha256_final((CRYAL_SHA256_CTX*)self->state, (byte*)vstr.buf);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
+
+STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha256_update_obj) },
+    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&uhashlib_sha256_digest_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(uhashlib_sha256_locals_dict, uhashlib_sha256_locals_dict_table);
+
+STATIC const mp_obj_type_t uhashlib_sha256_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_sha256,
+    .make_new = uhashlib_sha256_make_new,
+    .locals_dict = (void*)&uhashlib_sha256_locals_dict,
+};
+
 #if MICROPY_PY_UHASHLIB_SHA1
 STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg);
 
@@ -77,6 +109,22 @@ STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args,
     }
     return MP_OBJ_FROM_PTR(o);
 }
+
+STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
+    SHA1_Update((SHA1_CTX*)self->state, bufinfo.buf, bufinfo.len);
+    return mp_const_none;
+}
+
+STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    vstr_t vstr;
+    vstr_init_len(&vstr, SHA1_SIZE);
+    SHA1_Final((byte*)vstr.buf, (SHA1_CTX*)self->state);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
 #endif
 
 #if MICROPY_SSL_MBEDTLS
@@ -91,32 +139,7 @@ STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args,
     }
     return MP_OBJ_FROM_PTR(o);
 }
-#endif
-
-#endif
-
-STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
-    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    sha256_update((CRYAL_SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
-    return mp_const_none;
-}
-MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
-
-#if MICROPY_PY_UHASHLIB_SHA1
 
-#if MICROPY_SSL_AXTLS
-STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
-    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    SHA1_Update((SHA1_CTX*)self->state, bufinfo.buf, bufinfo.len);
-    return mp_const_none;
-}
-#endif
-
-#if MICROPY_SSL_MBEDTLS
 STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
@@ -124,33 +147,7 @@ STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mbedtls_sha1_update((mbedtls_sha1_context*)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
-#endif
-
-MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha1_update_obj, uhashlib_sha1_update);
-#endif
-
-STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
-    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
-    vstr_t vstr;
-    vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
-    sha256_final((CRYAL_SHA256_CTX*)self->state, (byte*)vstr.buf);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-}
-MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
-
-#if MICROPY_PY_UHASHLIB_SHA1
-
-#if MICROPY_SSL_AXTLS
-STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
-    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
-    vstr_t vstr;
-    vstr_init_len(&vstr, SHA1_SIZE);
-    SHA1_Final((byte*)vstr.buf, (SHA1_CTX*)self->state);
-    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-}
-#endif
 
-#if MICROPY_SSL_MBEDTLS
 STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
@@ -161,24 +158,9 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
 }
 #endif
 
+MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha1_update_obj, uhashlib_sha1_update);
 MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha1_digest_obj, uhashlib_sha1_digest);
-#endif
 
-STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha256_update_obj) },
-    { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&uhashlib_sha256_digest_obj) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(uhashlib_sha256_locals_dict, uhashlib_sha256_locals_dict_table);
-
-STATIC const mp_obj_type_t uhashlib_sha256_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sha256,
-    .make_new = uhashlib_sha256_make_new,
-    .locals_dict = (void*)&uhashlib_sha256_locals_dict,
-};
-
-#if MICROPY_PY_UHASHLIB_SHA1
 STATIC const mp_rom_map_elem_t uhashlib_sha1_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha1_update_obj) },
     { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&uhashlib_sha1_digest_obj) },
-- 
cgit v1.2.3


From 6630354ffe9f33d2af8154fbac003cb4db0cc348 Mon Sep 17 00:00:00 2001
From: Yonatan Goldschmidt <yon.goldschmidt@gmail.com>
Date: Sat, 9 Jun 2018 02:48:29 +0300
Subject: extmod/moduhashlib: Allow to disable the sha256 class.

Via the config value MICROPY_PY_UHASHLIB_SHA256.  Default to enabled to
keep backwards compatibility.

Also add default value for the sha1 class, to at least document its
existence.
---
 extmod/moduhashlib.c | 8 ++++++++
 py/mpconfig.h        | 8 ++++++++
 2 files changed, 16 insertions(+)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 2eb90ed73..e47bae0a0 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -31,7 +31,9 @@
 
 #if MICROPY_PY_UHASHLIB
 
+#if MICROPY_PY_UHASHLIB_SHA256
 #include "crypto-algorithms/sha256.h"
+#endif
 
 #if MICROPY_PY_UHASHLIB_SHA1
 
@@ -50,6 +52,7 @@ typedef struct _mp_obj_hash_t {
     char state[0];
 } mp_obj_hash_t;
 
+#if MICROPY_PY_UHASHLIB_SHA256
 STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg);
 
 STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -94,6 +97,7 @@ STATIC const mp_obj_type_t uhashlib_sha256_type = {
     .make_new = uhashlib_sha256_make_new,
     .locals_dict = (void*)&uhashlib_sha256_locals_dict,
 };
+#endif
 
 #if MICROPY_PY_UHASHLIB_SHA1
 STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg);
@@ -177,7 +181,9 @@ STATIC const mp_obj_type_t uhashlib_sha1_type = {
 
 STATIC const mp_rom_map_elem_t mp_module_uhashlib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uhashlib) },
+    #if MICROPY_PY_UHASHLIB_SHA256
     { MP_ROM_QSTR(MP_QSTR_sha256), MP_ROM_PTR(&uhashlib_sha256_type) },
+    #endif
     #if MICROPY_PY_UHASHLIB_SHA1
     { MP_ROM_QSTR(MP_QSTR_sha1), MP_ROM_PTR(&uhashlib_sha1_type) },
     #endif
@@ -190,6 +196,8 @@ const mp_obj_module_t mp_module_uhashlib = {
     .globals = (mp_obj_dict_t*)&mp_module_uhashlib_globals,
 };
 
+#if MICROPY_PY_UHASHLIB_SHA256
 #include "crypto-algorithms/sha256.c"
+#endif
 
 #endif //MICROPY_PY_UHASHLIB
diff --git a/py/mpconfig.h b/py/mpconfig.h
index a85b22128..08d100549 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -1155,6 +1155,14 @@ typedef double mp_float_t;
 #define MICROPY_PY_UHASHLIB (0)
 #endif
 
+#ifndef MICROPY_PY_UHASHLIB_SHA1
+#define MICROPY_PY_UHASHLIB_SHA1  (0)
+#endif
+
+#ifndef MICROPY_PY_UHASHLIB_SHA256
+#define MICROPY_PY_UHASHLIB_SHA256 (1)
+#endif
+
 #ifndef MICROPY_PY_UBINASCII
 #define MICROPY_PY_UBINASCII (0)
 #endif
-- 
cgit v1.2.3


From 6963ee90750f0af94cad1a823cf89aec97e0242d Mon Sep 17 00:00:00 2001
From: Yonatan Goldschmidt <yon.goldschmidt@gmail.com>
Date: Sat, 9 Jun 2018 03:00:21 +0300
Subject: extmod/moduhashlib: Allow using the sha256 implementation of mbedTLS.

---
 extmod/moduhashlib.c | 42 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index e47bae0a0..446aa4827 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -32,9 +32,15 @@
 #if MICROPY_PY_UHASHLIB
 
 #if MICROPY_PY_UHASHLIB_SHA256
+
+#if MICROPY_SSL_MBEDTLS
+#include "mbedtls/sha256.h"
+#else
 #include "crypto-algorithms/sha256.h"
 #endif
 
+#endif
+
 #if MICROPY_PY_UHASHLIB_SHA1
 
 #if MICROPY_SSL_AXTLS
@@ -55,6 +61,38 @@ typedef struct _mp_obj_hash_t {
 #if MICROPY_PY_UHASHLIB_SHA256
 STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg);
 
+#if MICROPY_SSL_MBEDTLS
+
+STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_sha256_context));
+    o->base.type = type;
+    mbedtls_sha256_init((mbedtls_sha256_context*)&o->state);
+    mbedtls_sha256_starts((mbedtls_sha256_context*)&o->state, 0);
+    if (n_args == 1) {
+        uhashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
+    }
+    return MP_OBJ_FROM_PTR(o);
+}
+
+STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
+    mbedtls_sha256_update((mbedtls_sha256_context*)&self->state, bufinfo.buf, bufinfo.len);
+    return mp_const_none;
+}
+
+STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
+    vstr_t vstr;
+    vstr_init_len(&vstr, 32);
+    mbedtls_sha256_finish((mbedtls_sha256_context*)&self->state, (unsigned char *)vstr.buf);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+
+#else
+
 STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(CRYAL_SHA256_CTX));
@@ -73,7 +111,6 @@ STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
     sha256_update((CRYAL_SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
 
 STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
@@ -82,6 +119,9 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     sha256_final((CRYAL_SHA256_CTX*)self->state, (byte*)vstr.buf);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
+#endif
+
+MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
 MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
 
 STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
-- 
cgit v1.2.3


From c2fb725e72f041a81b66e82ee4f7eebf55945061 Mon Sep 17 00:00:00 2001
From: Yonatan Goldschmidt <yon.goldschmidt@gmail.com>
Date: Sat, 9 Jun 2018 17:32:27 +0300
Subject: extmod/moduhashlib: Make function objects STATIC.

These are not exported to anyone anyway.
---
 extmod/moduhashlib.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'extmod')

diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 446aa4827..b3feb23bc 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -121,8 +121,8 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
 }
 #endif
 
-MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
-MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha256_update_obj, uhashlib_sha256_update);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha256_digest_obj, uhashlib_sha256_digest);
 
 STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha256_update_obj) },
@@ -202,8 +202,8 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
 }
 #endif
 
-MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha1_update_obj, uhashlib_sha1_update);
-MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha1_digest_obj, uhashlib_sha1_digest);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(uhashlib_sha1_update_obj, uhashlib_sha1_update);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(uhashlib_sha1_digest_obj, uhashlib_sha1_digest);
 
 STATIC const mp_rom_map_elem_t uhashlib_sha1_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&uhashlib_sha1_update_obj) },
-- 
cgit v1.2.3


From 035906419d925bf723dba21f9fbb22ca1c8021f1 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 12 Jun 2018 15:06:11 +1000
Subject: extmod/uos_dupterm: Use native C stream methods on dupterm object.

This patch changes dupterm to call the native C stream methods on the
connected stream objects, instead of calling the Python readinto/write
methods.  This is much more efficient for native stream objects like UART
and webrepl and doesn't require allocating a special dupterm array.

This change is a minor breaking change from the user's perspective because
dupterm no longer accepts pure user stream objects to duplicate on.  But
with the recent addition of uio.IOBase it is possible to still create such
classes just by inheriting from uio.IOBase, for example:

    import uio, uos

    class MyStream(uio.IOBase):
        def write(self, buf):
            # existing write implementation
        def readinto(self, buf):
            # existing readinto implementation

    uos.dupterm(MyStream())
---
 extmod/uos_dupterm.c | 42 ++++++++++++++++--------------------------
 py/mpstate.h         |  1 -
 py/runtime.c         |  1 -
 3 files changed, 16 insertions(+), 28 deletions(-)

(limited to 'extmod')

diff --git a/extmod/uos_dupterm.c b/extmod/uos_dupterm.c
index f77cff577..822d64037 100644
--- a/extmod/uos_dupterm.c
+++ b/extmod/uos_dupterm.c
@@ -60,25 +60,29 @@ int mp_uos_dupterm_rx_chr(void) {
 
         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)) {
+            byte buf[1];
+            int errcode;
+            const mp_stream_p_t *stream_p = mp_get_stream_raise(MP_STATE_VM(dupterm_objs[idx]), MP_STREAM_OP_READ);
+            mp_uint_t out_sz = stream_p->read(MP_STATE_VM(dupterm_objs[idx]), buf, 1, &errcode);
+            if (out_sz == 0) {
                 nlr_pop();
                 mp_uos_deactivate(idx, "dupterm: EOF received, deactivating\n", MP_OBJ_NULL);
+            } else if (out_sz == MP_STREAM_ERROR) {
+                // errcode is valid
+                if (mp_is_nonblocking_error(errcode)) {
+                    nlr_pop();
+                } else {
+                    mp_raise_OSError(errcode);
+                }
             } else {
-                mp_buffer_info_t bufinfo;
-                mp_get_buffer_raise(MP_STATE_VM(dupterm_arr_obj), &bufinfo, MP_BUFFER_READ);
+                // read 1 byte
                 nlr_pop();
-                if (*(byte*)bufinfo.buf == mp_interrupt_char) {
+                if (buf[0] == mp_interrupt_char) {
                     // Signal keyboard interrupt to be raised as soon as the VM resumes
                     mp_keyboard_interrupt();
                     return -2;
                 }
-                return *(byte*)bufinfo.buf;
+                return buf[0];
             }
         } else {
             mp_uos_deactivate(idx, "dupterm: Exception in read() method, deactivating: ", nlr.ret_val);
@@ -96,18 +100,7 @@ void mp_uos_dupterm_tx_strn(const char *str, size_t len) {
         }
         nlr_buf_t nlr;
         if (nlr_push(&nlr) == 0) {
-            mp_obj_t write_m[3];
-            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_VM(dupterm_arr_obj));
-            void *org_items = arr->items;
-            arr->items = (void*)str;
-            arr->len = len;
-            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_VM(dupterm_arr_obj));
-            arr->items = org_items;
-            arr->len = 1;
+            mp_stream_write(MP_STATE_VM(dupterm_objs[idx]), str, len, MP_STREAM_RW_WRITE);
             nlr_pop();
         } else {
             mp_uos_deactivate(idx, "dupterm: Exception in write() method, deactivating: ", nlr.ret_val);
@@ -133,9 +126,6 @@ STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
         MP_STATE_VM(dupterm_objs[idx]) = MP_OBJ_NULL;
     } else {
         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 previous_obj;
diff --git a/py/mpstate.h b/py/mpstate.h
index 199fd2cb6..8c3b710cb 100644
--- a/py/mpstate.h
+++ b/py/mpstate.h
@@ -171,7 +171,6 @@ typedef struct _mp_state_vm_t {
 
     #if MICROPY_PY_OS_DUPTERM
     mp_obj_t dupterm_objs[MICROPY_PY_OS_DUPTERM];
-    mp_obj_t dupterm_arr_obj;
     #endif
 
     #if MICROPY_PY_LWIP_SLIP
diff --git a/py/runtime.c b/py/runtime.c
index 8f1063076..a2dac46a4 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -108,7 +108,6 @@ void mp_init(void) {
     for (size_t i = 0; i < MICROPY_PY_OS_DUPTERM; ++i) {
         MP_STATE_VM(dupterm_objs[i]) = MP_OBJ_NULL;
     }
-    MP_STATE_VM(dupterm_arr_obj) = MP_OBJ_NULL;
     #endif
 
     #if MICROPY_FSUSERMOUNT
-- 
cgit v1.2.3


From d11fb09333ab96ec1b4e9d10d74961caf1172153 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 13 Jun 2018 13:16:21 +1000
Subject: extmod/modussl_axtls: Fix __del__ to point to mp_stream_close_obj.

---
 extmod/modussl_axtls.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'extmod')

diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 689d33305..475d3f0ea 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -212,7 +212,7 @@ STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
 #if MICROPY_PY_USSL_FINALISER
-    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
 #endif
 };
 
-- 
cgit v1.2.3


From 564abb01a5526bd2d981791401e28774c7dcfe4c Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Sat, 16 Jun 2018 18:21:42 +1000
Subject: extmod/vfs_fat_diskio: Factor disk ioctl code to reduce code size.

Functionality is unchanged.
---
 extmod/vfs_fat_diskio.c | 188 +++++++++++++++++-------------------------------
 1 file changed, 66 insertions(+), 122 deletions(-)

(limited to 'extmod')

diff --git a/extmod/vfs_fat_diskio.c b/extmod/vfs_fat_diskio.c
index 712038f3e..fa013d278 100644
--- a/extmod/vfs_fat_diskio.c
+++ b/extmod/vfs_fat_diskio.c
@@ -53,59 +53,6 @@ STATIC fs_user_mount_t *disk_get_device(void *bdev) {
     return (fs_user_mount_t*)bdev;
 }
 
-/*-----------------------------------------------------------------------*/
-/* Initialize a Drive                                                    */
-/*-----------------------------------------------------------------------*/
-
-STATIC
-DSTATUS disk_initialize (
-    bdev_t pdrv              /* Physical drive nmuber (0..) */
-)
-{
-    fs_user_mount_t *vfs = disk_get_device(pdrv);
-    if (vfs == NULL) {
-        return STA_NOINIT;
-    }
-
-    if (vfs->flags & FSUSER_HAVE_IOCTL) {
-        // new protocol with ioctl; call ioctl(INIT, 0)
-        vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(BP_IOCTL_INIT);
-        vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
-        mp_obj_t ret = mp_call_method_n_kw(2, 0, vfs->u.ioctl);
-        if (ret != mp_const_none && MP_OBJ_SMALL_INT_VALUE(ret) != 0) {
-            // error initialising
-            return STA_NOINIT;
-        }
-    }
-
-    if (vfs->writeblocks[0] == MP_OBJ_NULL) {
-        return STA_PROTECT;
-    } else {
-        return 0;
-    }
-}
-
-/*-----------------------------------------------------------------------*/
-/* Get Disk Status                                                       */
-/*-----------------------------------------------------------------------*/
-
-STATIC
-DSTATUS disk_status (
-    bdev_t pdrv      /* Physical drive nmuber (0..) */
-)
-{
-    fs_user_mount_t *vfs = disk_get_device(pdrv);
-    if (vfs == NULL) {
-        return STA_NOINIT;
-    }
-
-    if (vfs->writeblocks[0] == MP_OBJ_NULL) {
-        return STA_PROTECT;
-    } else {
-        return 0;
-    }
-}
-
 /*-----------------------------------------------------------------------*/
 /* Read Sector(s)                                                        */
 /*-----------------------------------------------------------------------*/
@@ -191,54 +138,21 @@ DRESULT disk_ioctl (
         return RES_PARERR;
     }
 
+    // First part: call the relevant method of the underlying block device
+    mp_obj_t ret = mp_const_none;
     if (vfs->flags & FSUSER_HAVE_IOCTL) {
         // new protocol with ioctl
-        switch (cmd) {
-            case CTRL_SYNC:
-                vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(BP_IOCTL_SYNC);
-                vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
-                mp_call_method_n_kw(2, 0, vfs->u.ioctl);
-                return RES_OK;
-
-            case GET_SECTOR_COUNT: {
-                vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(BP_IOCTL_SEC_COUNT);
-                vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
-                mp_obj_t ret = mp_call_method_n_kw(2, 0, vfs->u.ioctl);
-                *((DWORD*)buff) = mp_obj_get_int(ret);
-                return RES_OK;
-            }
-
-            case GET_SECTOR_SIZE: {
-                vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(BP_IOCTL_SEC_SIZE);
-                vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
-                mp_obj_t ret = mp_call_method_n_kw(2, 0, vfs->u.ioctl);
-                if (ret == mp_const_none) {
-                    // Default sector size
-                    *((WORD*)buff) = 512;
-                } else {
-                    *((WORD*)buff) = mp_obj_get_int(ret);
-                }
-                #if _MAX_SS != _MIN_SS
-                // need to store ssize because we use it in disk_read/disk_write
-                vfs->fatfs.ssize = *((WORD*)buff);
-                #endif
-                return RES_OK;
-            }
-
-            case GET_BLOCK_SIZE:
-                *((DWORD*)buff) = 1; // erase block size in units of sector size
-                return RES_OK;
-
-            case IOCTL_INIT:
-                *((DSTATUS*)buff) = disk_initialize(pdrv);
-                return RES_OK;
-
-            case IOCTL_STATUS:
-                *((DSTATUS*)buff) = disk_status(pdrv);
-                return RES_OK;
-
-            default:
-                return RES_PARERR;
+        static const uint8_t op_map[8] = {
+            [CTRL_SYNC] = BP_IOCTL_SYNC,
+            [GET_SECTOR_COUNT] = BP_IOCTL_SEC_COUNT,
+            [GET_SECTOR_SIZE] = BP_IOCTL_SEC_SIZE,
+            [IOCTL_INIT] = BP_IOCTL_INIT,
+        };
+        uint8_t bp_op = op_map[cmd & 7];
+        if (bp_op != 0) {
+            vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(bp_op);
+            vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
+            ret = mp_call_method_n_kw(2, 0, vfs->u.ioctl);
         }
     } else {
         // old protocol with sync and count
@@ -247,37 +161,67 @@ DRESULT disk_ioctl (
                 if (vfs->u.old.sync[0] != MP_OBJ_NULL) {
                     mp_call_method_n_kw(0, 0, vfs->u.old.sync);
                 }
-                return RES_OK;
+                break;
 
-            case GET_SECTOR_COUNT: {
-                mp_obj_t ret = mp_call_method_n_kw(0, 0, vfs->u.old.count);
-                *((DWORD*)buff) = mp_obj_get_int(ret);
-                return RES_OK;
-            }
+            case GET_SECTOR_COUNT:
+                ret = mp_call_method_n_kw(0, 0, vfs->u.old.count);
+                break;
 
             case GET_SECTOR_SIZE:
-                *((WORD*)buff) = 512; // old protocol had fixed sector size
-                #if _MAX_SS != _MIN_SS
-                // need to store ssize because we use it in disk_read/disk_write
-                vfs->fatfs.ssize = 512;
-                #endif
-                return RES_OK;
-
-            case GET_BLOCK_SIZE:
-                *((DWORD*)buff) = 1; // erase block size in units of sector size
-                return RES_OK;
+                // old protocol has fixed sector size of 512 bytes
+                break;
 
             case IOCTL_INIT:
-                *((DSTATUS*)buff) = disk_initialize(pdrv);
-                return RES_OK;
+                // old protocol doesn't have init
+                break;
+        }
+    }
 
-            case IOCTL_STATUS:
-                *((DSTATUS*)buff) = disk_status(pdrv);
-                return RES_OK;
+    // Second part: convert the result for return
+    switch (cmd) {
+        case CTRL_SYNC:
+            return RES_OK;
 
-            default:
-                return RES_PARERR;
+        case GET_SECTOR_COUNT: {
+            *((DWORD*)buff) = mp_obj_get_int(ret);
+            return RES_OK;
         }
+
+        case GET_SECTOR_SIZE: {
+            if (ret == mp_const_none) {
+                // Default sector size
+                *((WORD*)buff) = 512;
+            } else {
+                *((WORD*)buff) = mp_obj_get_int(ret);
+            }
+            #if _MAX_SS != _MIN_SS
+            // need to store ssize because we use it in disk_read/disk_write
+            vfs->fatfs.ssize = *((WORD*)buff);
+            #endif
+            return RES_OK;
+        }
+
+        case GET_BLOCK_SIZE:
+            *((DWORD*)buff) = 1; // erase block size in units of sector size
+            return RES_OK;
+
+        case IOCTL_INIT:
+        case IOCTL_STATUS: {
+            DSTATUS stat;
+            if (ret != mp_const_none && MP_OBJ_SMALL_INT_VALUE(ret) != 0) {
+                // error initialising
+                stat = STA_NOINIT;
+            } else if (vfs->writeblocks[0] == MP_OBJ_NULL) {
+                stat = STA_PROTECT;
+            } else {
+                stat = 0;
+            }
+            *((DSTATUS*)buff) = stat;
+            return RES_OK;
+        }
+
+        default:
+            return RES_PARERR;
     }
 }
 
-- 
cgit v1.2.3


From e8398a58567cc94b866d46721fd06289601f5c8a Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 13 Jun 2018 12:37:49 +1000
Subject: extmod: Update to use new mp_get_stream helper.

With this patch objects are only checked that they have the stream protocol
at the start of their use as a stream, and afterwards the efficient
mp_get_stream() helper is used to extract the stream protocol C methods.
---
 extmod/modujson.c        |  4 +---
 extmod/modussl_mbedtls.c |  7 +++++--
 extmod/moduzlib.c        |  3 ++-
 extmod/modwebrepl.c      | 11 +++++------
 extmod/modwebsocket.c    |  3 ++-
 extmod/uos_dupterm.c     |  3 ++-
 6 files changed, 17 insertions(+), 14 deletions(-)

(limited to 'extmod')

diff --git a/extmod/modujson.c b/extmod/modujson.c
index f731d7193..830b588fd 100644
--- a/extmod/modujson.c
+++ b/extmod/modujson.c
@@ -35,9 +35,7 @@
 #if MICROPY_PY_UJSON
 
 STATIC mp_obj_t mod_ujson_dump(mp_obj_t obj, mp_obj_t stream) {
-    if (!MP_OBJ_IS_OBJ(stream)) {
-        mp_raise_TypeError(NULL);
-    }
+    mp_get_stream_raise(stream, MP_STREAM_OP_WRITE);
     mp_print_t print = {MP_OBJ_TO_PTR(stream), mp_stream_write_adaptor};
     mp_obj_print_helper(&print, obj, PRINT_JSON);
     return mp_const_none;
diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 1c9dfd17f..08807d20b 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -76,7 +76,7 @@ STATIC void mbedtls_debug(void *ctx, int level, const char *file, int line, cons
 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);
+    const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     int err;
 
     mp_uint_t out_sz = sock_stream->write(sock, buf, len, &err);
@@ -93,7 +93,7 @@ STATIC int _mbedtls_ssl_send(void *ctx, const 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);
+    const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     int err;
 
     mp_uint_t out_sz = sock_stream->read(sock, buf, len, &err);
@@ -109,6 +109,9 @@ STATIC 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) {
+    // Verify the socket object has the full stream protocol
+    mp_get_stream_raise(sock, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+
 #if MICROPY_PY_USSL_FINALISER
     mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
 #else
diff --git a/extmod/moduzlib.c b/extmod/moduzlib.c
index e9af07370..940b72805 100644
--- a/extmod/moduzlib.c
+++ b/extmod/moduzlib.c
@@ -53,7 +53,7 @@ STATIC unsigned char read_src_stream(TINF_DATA *data) {
     p -= offsetof(mp_obj_decompio_t, decomp);
     mp_obj_decompio_t *self = (mp_obj_decompio_t*)p;
 
-    const mp_stream_p_t *stream = mp_get_stream_raise(self->src_stream, MP_STREAM_OP_READ);
+    const mp_stream_p_t *stream = mp_get_stream(self->src_stream);
     int err;
     byte c;
     mp_uint_t out_sz = stream->read(self->src_stream, &c, 1, &err);
@@ -68,6 +68,7 @@ STATIC unsigned char read_src_stream(TINF_DATA *data) {
 
 STATIC mp_obj_t decompio_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 2, false);
+    mp_get_stream_raise(args[0], MP_STREAM_OP_READ);
     mp_obj_decompio_t *o = m_new_obj(mp_obj_decompio_t);
     o->base.type = type;
     memset(&o->decomp, 0, sizeof(o->decomp));
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index 983b5a10c..06da210d1 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -76,7 +76,7 @@ STATIC char denied_prompt[] = "\r\nAccess denied\r\n";
 STATIC char webrepl_passwd[10];
 
 STATIC void write_webrepl(mp_obj_t websock, const void *buf, size_t len) {
-    const mp_stream_p_t *sock_stream = mp_get_stream_raise(websock, MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+    const mp_stream_p_t *sock_stream = mp_get_stream(websock);
     int err;
     int old_opts = sock_stream->ioctl(websock, MP_STREAM_SET_DATA_OPTS, FRAME_BIN, &err);
     sock_stream->write(websock, buf, len, &err);
@@ -86,7 +86,7 @@ STATIC void write_webrepl(mp_obj_t websock, const void *buf, size_t len) {
 #define SSTR(s) s, sizeof(s) - 1
 STATIC void write_webrepl_str(mp_obj_t websock, const char *str, int sz) {
     int err;
-    const mp_stream_p_t *sock_stream = mp_get_stream_raise(websock, MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+    const mp_stream_p_t *sock_stream = mp_get_stream(websock);
     sock_stream->write(websock, str, sz, &err);
 }
 
@@ -110,8 +110,7 @@ STATIC mp_obj_t webrepl_make_new(const mp_obj_type_t *type, size_t n_args, size_
 }
 
 STATIC int write_file_chunk(mp_obj_webrepl_t *self) {
-    const mp_stream_p_t *file_stream =
-        mp_get_stream_raise(self->cur_file, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+    const mp_stream_p_t *file_stream = mp_get_stream(self->cur_file);
     byte readbuf[2 + 256];
     int err;
     mp_uint_t out_sz = file_stream->read(self->cur_file, readbuf + 2, sizeof(readbuf) - 2, &err);
@@ -181,7 +180,7 @@ STATIC mp_uint_t _webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
     // We know that os.dupterm always calls with size = 1
     assert(size == 1);
     mp_obj_webrepl_t *self = self_in;
-    const mp_stream_p_t *sock_stream = mp_get_stream_raise(self->sock, MP_STREAM_OP_READ);
+    const mp_stream_p_t *sock_stream = mp_get_stream(self->sock);
     mp_uint_t out_sz = sock_stream->read(self->sock, buf, size, errcode);
     //DEBUG_printf("webrepl: Read %d initial bytes from websocket\n", out_sz);
     if (out_sz == 0 || out_sz == MP_STREAM_ERROR) {
@@ -293,7 +292,7 @@ STATIC mp_uint_t webrepl_write(mp_obj_t self_in, const void *buf, mp_uint_t size
         // Don't forward output until passwd is entered
         return size;
     }
-    const mp_stream_p_t *stream_p = mp_get_stream_raise(self->sock, MP_STREAM_OP_WRITE);
+    const mp_stream_p_t *stream_p = mp_get_stream(self->sock);
     return stream_p->write(self->sock, buf, size, errcode);
 }
 
diff --git a/extmod/modwebsocket.c b/extmod/modwebsocket.c
index 5a826ec64..c556f2b77 100644
--- a/extmod/modwebsocket.c
+++ b/extmod/modwebsocket.c
@@ -59,6 +59,7 @@ STATIC mp_uint_t websocket_write(mp_obj_t self_in, const void *buf, mp_uint_t si
 
 STATIC mp_obj_t websocket_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 2, false);
+    mp_get_stream_raise(args[0], MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
     mp_obj_websocket_t *o = m_new_obj(mp_obj_websocket_t);
     o->base.type = type;
     o->sock = args[0];
@@ -75,7 +76,7 @@ STATIC mp_obj_t websocket_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
 STATIC mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
     mp_obj_websocket_t *self =  MP_OBJ_TO_PTR(self_in);
-    const mp_stream_p_t *stream_p = mp_get_stream_raise(self->sock, MP_STREAM_OP_READ);
+    const mp_stream_p_t *stream_p = mp_get_stream(self->sock);
     while (1) {
         if (self->to_recv != 0) {
             mp_uint_t out_sz = stream_p->read(self->sock, self->buf + self->buf_pos, self->to_recv, errcode);
diff --git a/extmod/uos_dupterm.c b/extmod/uos_dupterm.c
index 822d64037..cc6d97f41 100644
--- a/extmod/uos_dupterm.c
+++ b/extmod/uos_dupterm.c
@@ -62,7 +62,7 @@ int mp_uos_dupterm_rx_chr(void) {
         if (nlr_push(&nlr) == 0) {
             byte buf[1];
             int errcode;
-            const mp_stream_p_t *stream_p = mp_get_stream_raise(MP_STATE_VM(dupterm_objs[idx]), MP_STREAM_OP_READ);
+            const mp_stream_p_t *stream_p = mp_get_stream(MP_STATE_VM(dupterm_objs[idx]));
             mp_uint_t out_sz = stream_p->read(MP_STATE_VM(dupterm_objs[idx]), buf, 1, &errcode);
             if (out_sz == 0) {
                 nlr_pop();
@@ -125,6 +125,7 @@ STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
     if (args[0] == mp_const_none) {
         MP_STATE_VM(dupterm_objs[idx]) = MP_OBJ_NULL;
     } else {
+        mp_get_stream_raise(args[0], MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
         MP_STATE_VM(dupterm_objs[idx]) = args[0];
     }
 
-- 
cgit v1.2.3