Merge branch 'master' into ori_master

port/gccollect.c

@@ -0,0 +1,64 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Armink (armink.ztl@gmail.com)
+ *
+ * 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 <stdio.h>
+
+#include "py/mpstate.h"
+#include "py/gc.h"
+
+// If we don't have architecture-specific optimized support,
+// just fall back to setjmp-based implementation.
+
+// If MICROPY_GCREGS_SETJMP was requested explicitly, or if
+// we enabled it as a fallback above.
+#include <setjmp.h>
+
+typedef jmp_buf regs_t;
+
+STATIC void gc_helper_get_regs(regs_t arr) {
+    setjmp(arr);
+}
+
+void gc_collect_regs_and_stack(void) {
+    regs_t regs;
+    gc_helper_get_regs(regs);
+    // GC stack (and regs because we captured them)
+    void **regs_ptr = (void**)(void*)&regs;
+    gc_collect_root(regs_ptr, ((uintptr_t)MP_STATE_THREAD(stack_top) - (uintptr_t)&regs) / sizeof(uintptr_t));
+}
+
+void gc_collect(void) {
+    gc_collect_start();
+    // trace root pointers from any threads
+    gc_collect_regs_and_stack();
+
+#if MICROPY_PY_THREAD
+    //TODO has some problem when multithreading using gc at the same time
+    mp_thread_gc_others();
+#endif
+
+    gc_collect_end();
+    gc_dump_info();
+}

port/genhdr/qstrdefs.generated.h

@@ -664,5 +664,7 @@ QDEF(MP_QSTR_ioctl, (const byte*)"\x78\x05" "ioctl")
 QDEF(MP_QSTR_password, (const byte*)"\x9a\x08" "password")
 QDEF(MP_QSTR_rb, (const byte*)"\xd5\x02" "rb")
 QDEF(MP_QSTR_wb, (const byte*)"\x70\x02" "wb")
+QDEF(MP_QSTR_IP_ADD_MEMBERSHIP, (const byte*)"\x6f\x11" "IP_ADD_MEMBERSHIP")
+QDEF(MP_QSTR_sendall, (const byte*)"\x38\x07" "sendall")
 
 // This file was automatically generated by makeqstrdata.py

port/modusocket.c

@@ -33,7 +33,8 @@
 #include <stdio.h>
 #include <netdb.h>
 #include <sys/socket.h>
-#include <dfs_posix.h>
+#include <fcntl.h>
+#include <sys/select.h>
 
 #include "py/objtuple.h"
 #include "py/objlist.h"
@@ -46,374 +47,388 @@
 #include "lib/netutils/netutils.h"
 #include "modnetwork.h"
 
-/******************************************************************************/
-// socket class
-
-STATIC const mp_obj_type_t socket_type;
+#define SOCKET_POLL_US (100000)
 
-typedef struct _posix_socket_obj_t {
+// socket class
+typedef struct _socket_obj_t {
     mp_obj_base_t base;
     int fd;
-} posix_socket_obj_t;
-
-// constructor socket(family=AF_INET, type=SOCK_STREAM, proto=0)
-STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    uint8_t domain = AF_INET;
-    uint8_t style = SOCK_STREAM;
-    uint8_t proto = 0;
-    int fd = -1;
-    posix_socket_obj_t *s = MP_OBJ_NULL;
-
-    mp_arg_check_num(n_args, n_kw, 0, 4, false);
-
-    if (n_args >= 1) {
-        domain = mp_obj_get_int(args[0]);
-        if (n_args >= 2) {
-            style = mp_obj_get_int(args[1]);
-        }
-    }
+    uint8_t domain;
+    uint8_t type;
+    uint8_t proto;
+    bool peer_closed;
+    unsigned int retries;
+} socket_obj_t;
 
-    fd = socket(domain, style, proto);
+STATIC const mp_obj_type_t socket_type;
 
-    if (fd != -1) {
-        s = m_new_obj_with_finaliser(posix_socket_obj_t);
-        if (s) {
-            s->base.type = (mp_obj_t) &socket_type;
-            s->fd = fd;
-        } else {
-            rt_kprintf("m_new_obj_with_finaliser error.\n");
-            mp_raise_OSError(MP_EAGAIN);
-        }
-    } else {
-        rt_kprintf("Get fd error fd = -1\n");
-        mp_raise_OSError(MP_EAGAIN);
+STATIC void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms);
+
+NORETURN static void exception_from_errno(int _errno) {
+    // Here we need to convert from lwip errno values to MicroPython's standard ones
+    if (_errno == EINPROGRESS) {
+        _errno = MP_EINPROGRESS;
     }
+    mp_raise_OSError(_errno);
+}
 
-    return s;
+static inline void check_for_exceptions(void) {
+    mp_handle_pending();
 }
 
-// method socket.close()
-STATIC mp_obj_t socket_close(mp_obj_t self_in) {
-    posix_socket_obj_t *self = self_in;
+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,
+        .ai_socktype = SOCK_STREAM,
+    };
 
-    if (self->fd >= 0) {
-        closesocket(self->fd);
-        self->fd = -1;
+    mp_obj_t port = portx;
+    if (MP_OBJ_IS_SMALL_INT(port)) {
+        // This is perverse, because lwip_getaddrinfo promptly converts it back to an int, but
+        // that's the API we have to work with ...
+        port = mp_obj_str_binary_op(MP_BINARY_OP_MODULO, mp_obj_new_str_via_qstr("%s", 2), port);
     }
-    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) {
-    posix_socket_obj_t *self = self_in;
-    int _errno;
-    struct sockaddr_in sockaddr;
-    mp_obj_t *items;
+    const char *host_str = mp_obj_str_get_str(host);
+    const char *port_str = mp_obj_str_get_str(port);
 
-    mp_obj_get_array_fixed_n(addr_in, 2, &items);
+    if (host_str[0] == '\0') {
+        // a host of "" is equivalent to the default/all-local IP address
+        host_str = "0.0.0.0";
+    }
 
-    sockaddr.sin_family = AF_INET;
-    sockaddr.sin_port = htons(mp_obj_get_int(items[1]));
+    MP_THREAD_GIL_EXIT();
+    int res = getaddrinfo(host_str, port_str, &hints, resp);
+    MP_THREAD_GIL_ENTER();
 
-    const char *strip = mp_obj_str_get_str(items[0]);
-    inet_aton((char * )strip, (struct in_addr* )&(sockaddr.sin_addr));
-    memset(&(sockaddr.sin_zero), 0, sizeof(sockaddr.sin_zero));
+    return res;
+}
 
-    if ((_errno = bind(self->fd, (struct sockaddr *) &sockaddr, sizeof(struct sockaddr))) < 0) {
-        mp_raise_OSError(_errno);
-    }
+int _socket_getaddrinfo(const mp_obj_t addrtuple, struct addrinfo **resp) {
+    mp_uint_t len = 0;
+    mp_obj_t *elem;
+    mp_obj_get_array(addrtuple, &len, &elem);
+    if (len != 2) return -1;
+    return _socket_getaddrinfo2(elem[0], elem[1], resp);
+}
 
+STATIC mp_obj_t socket_bind(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    struct addrinfo *res;
+    _socket_getaddrinfo(arg1, &res);
+    int r = bind(self->fd, res->ai_addr, res->ai_addrlen);
+    freeaddrinfo(res);
+    if (r < 0) exception_from_errno(errno);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
 
-// method socket.listen(backlog)
-STATIC mp_obj_t socket_listen(mp_obj_t self_in, mp_obj_t backlog) {
-    posix_socket_obj_t *self = self_in;
-    int _errno;
-
-    if ((_errno = listen(self->fd, mp_obj_get_int(backlog))) < 0) {
-        mp_raise_OSError(_errno);
-    }
-
+STATIC mp_obj_t socket_listen(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    int backlog = mp_obj_get_int(arg1);
+    int r = listen(self->fd, backlog);
+    if (r < 0) exception_from_errno(errno);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
 
-// method socket.accept()
-STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
-    posix_socket_obj_t *self = self_in;
-
-    // create new socket object
-    posix_socket_obj_t *socket2 = m_new_obj_with_finaliser(posix_socket_obj_t);
-    socket2->base.type = (mp_obj_t) &socket_type;
+STATIC mp_obj_t socket_accept(const mp_obj_t arg0) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
 
-    // accept incoming connection
-    int new_client;
-    struct sockaddr_in addr;
-    socklen_t addrlen;
+    struct sockaddr addr;
+    socklen_t addr_len = sizeof(addr);
 
-    if ((new_client = accept(self->fd, (struct sockaddr *) &addr, &addrlen)) < 0) {
-        mp_raise_OSError(new_client);
+    int new_fd = -1;
+    for (int i = 0; i <= self->retries; i++) {
+        MP_THREAD_GIL_EXIT();
+        new_fd = accept(self->fd, &addr, &addr_len);
+        MP_THREAD_GIL_ENTER();
+        if (new_fd >= 0) break;
+//        if (errno != EAGAIN) exception_from_errno(errno);
+        check_for_exceptions();
     }
+    if (new_fd < 0) mp_raise_OSError(MP_ETIMEDOUT);
+
+    // create new socket object
+    socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
+    sock->base.type = self->base.type;
+    sock->fd = new_fd;
+    sock->domain = self->domain;
+    sock->type = self->type;
+    sock->proto = self->proto;
+    sock->peer_closed = false;
+    _socket_settimeout(sock, UINT64_MAX);
 
-    socket2->fd = new_client;
     // make the return value
+    uint8_t *ip = (uint8_t*)&((struct sockaddr_in*)&addr)->sin_addr;
+    mp_uint_t port = ntohs(((struct sockaddr_in*)&addr)->sin_port);
     mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL);
-    client->items[0] = socket2;
+    client->items[0] = sock;
+    client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
 
-    mp_obj_t tuple[2] = {
-        tuple[0] = netutils_format_ipv4_addr((uint8_t *)&addr.sin_addr, NETUTILS_BIG),
-        tuple[1] = mp_obj_new_int(ntohs(addr.sin_port)),
-    };
-
-    client->items[1] = mp_obj_new_tuple(2, tuple);
     return client;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
 
-// method socket.connect(address)
-STATIC mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
-    posix_socket_obj_t *self = self_in;
+STATIC mp_obj_t socket_connect(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    struct addrinfo *res;
+    _socket_getaddrinfo(arg1, &res);
+    MP_THREAD_GIL_EXIT();
+    int r = connect(self->fd, res->ai_addr, res->ai_addrlen);
+    MP_THREAD_GIL_ENTER();
+    freeaddrinfo(res);
+    if (r != 0) {
+        exception_from_errno(errno);
+    }
 
-    int _errno;
-    mp_obj_t *items;
-    struct sockaddr_in sockaddr;
-    mp_obj_get_array_fixed_n(addr_in, 2, &items);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
 
-    sockaddr.sin_family = AF_INET;
-    sockaddr.sin_port = htons(mp_obj_get_int(items[1]));
+STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
+    (void)n_args; // always 4
+    socket_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    int opt = mp_obj_get_int(args[2]);
+
+    switch (opt) {
+        // level: SOL_SOCKET
+        case SO_REUSEADDR: {
+            int val = mp_obj_get_int(args[3]);
+            int ret = setsockopt(self->fd, SOL_SOCKET, opt, &val, sizeof(int));
+            if (ret != 0) {
+                exception_from_errno(errno);
+            }
+            break;
+        }
 
-    const char *strip = mp_obj_str_get_str(items[0]);
-    inet_aton((char * )strip, (struct in_addr* )&(sockaddr.sin_addr));
-    memset(&(sockaddr.sin_zero), 0, sizeof(sockaddr.sin_zero));
+        // level: IPPROTO_IP
+        case IP_ADD_MEMBERSHIP: {
+            mp_buffer_info_t bufinfo;
+            mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
+            if (bufinfo.len != sizeof(ip4_addr_t) * 2) {
+                mp_raise_ValueError(NULL);
+            }
+
+//            // POSIX setsockopt has order: group addr, if addr, lwIP has it vice-versa
+//            err_t err = igmp_joingroup((const ip4_addr_t*)bufinfo.buf + 1, bufinfo.buf);
+//            if (err != ERR_OK) {
+//                mp_raise_OSError(-err);
+//            }
+            break;
+        }
 
-    if ((_errno = connect(self->fd, (struct sockaddr *) &sockaddr, sizeof(struct sockaddr))) < 0) {
-        mp_raise_OSError(_errno);
+        default:
+            mp_printf(&mp_plat_print, "Warning: setsockopt() option not implemented\n");
     }
 
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
 
-// method socket.send(bytes)
-STATIC mp_obj_t socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
-    posix_socket_obj_t *self = self_in;
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
-    int _errno;
+STATIC void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms) {
+    // Rather than waiting for the entire timeout specified, we wait sock->retries times
+    // for SOCKET_POLL_US each, checking for a MicroPython interrupt between timeouts.
+    // with SOCKET_POLL_MS == 100ms, sock->retries allows for timeouts up to 13 years.
+    // if timeout_ms == UINT64_MAX, wait forever.
+    sock->retries = (timeout_ms == UINT64_MAX) ? UINT_MAX : timeout_ms * 1000 / SOCKET_POLL_US;
 
-    _errno = send(self->fd, bufinfo.buf, bufinfo.len, 0);
-    if (_errno == -1) {
-        mp_raise_OSError(_errno);
-    }
-    return mp_obj_new_int_from_uint(_errno);
+    struct timeval timeout = {
+        .tv_sec = 0,
+        .tv_usec = timeout_ms ? SOCKET_POLL_US : 0
+    };
+    setsockopt(sock->fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
+    setsockopt(sock->fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
+    fcntl(sock->fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_send_obj, socket_send);
 
-//socket.write(buf)
-//Write the buffer of bytes to the socket.
-//This function will try to write all data to a socket (no short writes ).
-//This may be not possible with a non-blocking socket though, and returned value will be less than the length of buf.
-//Return value: number of bytes written.
+STATIC mp_obj_t socket_settimeout(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    if (arg1 == mp_const_none) _socket_settimeout(self, UINT64_MAX);
+    else _socket_settimeout(self, mp_obj_get_float(arg1) * 1000L);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
 
-STATIC mp_obj_t socket_write(mp_obj_t self_in, mp_obj_t buf_in) {
-    posix_socket_obj_t *self = self_in;
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
-    int _errno;
+STATIC mp_obj_t socket_setblocking(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    if (mp_obj_is_true(arg1)) _socket_settimeout(self, UINT64_MAX);
+    else _socket_settimeout(self, 0);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
 
-    _errno = send(self->fd, bufinfo.buf, bufinfo.len, 0);
-    if (_errno == -1) {
-        mp_raise_OSError(_errno);
+// XXX this can end up waiting a very long time if the content is dribbled in one character
+// at a time, as the timeout resets each time a recvfrom succeeds ... this is probably not
+// good behaviour.
+STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size,
+    struct sockaddr *from, socklen_t *from_len, int *errcode) {
+    socket_obj_t *sock = MP_OBJ_TO_PTR(self_in);
+
+    // If the peer closed the connection then the lwIP socket API will only return "0" once
+    // from lwip_recvfrom_r and then block on subsequent calls.  To emulate POSIX behaviour,
+    // which continues to return "0" for each call on a closed socket, we set a flag when
+    // the peer closed the socket.
+    if (sock->peer_closed) {
+        return 0;
     }
-    return mp_obj_new_int_from_uint(_errno);
+
+    // XXX Would be nicer to use RTC to handle timeouts
+    for (int i = 0; i <= sock->retries; ++i) {
+        MP_THREAD_GIL_EXIT();
+        int r = recvfrom(sock->fd, buf, size, 0, from, from_len);
+        MP_THREAD_GIL_ENTER();
+        if (r == 0) {
+            sock->peer_closed = true;
+        }
+        if (r >= 0) {
+            return r;
+        }
+//        if (errno != EWOULDBLOCK) {
+//            *errcode = errno;
+//            return MP_STREAM_ERROR;
+//        }
+        check_for_exceptions();
+    }
+
+    *errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
+    return MP_STREAM_ERROR;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_write_obj, socket_write);
 
-// method socket.recv(bufsize)
-STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
-    posix_socket_obj_t *self = self_in;
-    mp_int_t len = mp_obj_get_int(len_in);
+mp_obj_t _socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in,
+        struct sockaddr *from, socklen_t *from_len) {
+    size_t len = mp_obj_get_int(len_in);
     vstr_t vstr;
     vstr_init_len(&vstr, len);
-    int ret;
 
-    ret = recv(self->fd, (byte*)vstr.buf, len, 0);
-    if (ret == -1) {
-        mp_raise_OSError(ret);
-    }
-    if (ret == 0) {
-        return mp_const_empty_bytes;
+    int errcode;
+    mp_uint_t ret = _socket_read_data(self_in, vstr.buf, len, from, from_len, &errcode);
+    if (ret == MP_STREAM_ERROR) {
+        exception_from_errno(errcode);
     }
+
     vstr.len = ret;
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recv_obj, socket_recv);
 
-// method socket.sendto(bytes, address)
-STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in) {
-    posix_socket_obj_t *self = self_in;
-
-    // get the data
-    mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
-
-    mp_obj_t *items;
-    struct sockaddr_in sockaddr;
-    mp_obj_get_array_fixed_n(addr_in, 2, &items);
-    sockaddr.sin_family = AF_INET;
-    sockaddr.sin_port = htons(mp_obj_get_int(items[1]));
-    const char *strip = mp_obj_str_get_str(items[0]);
-    inet_aton((char * )strip, (struct in_addr* )&(sockaddr.sin_addr));
-    memset(&(sockaddr.sin_zero), 0, sizeof(sockaddr.sin_zero));
-
-    mp_int_t ret = sendto(self->fd, bufinfo.buf, bufinfo.len, MSG_DONTWAIT, (struct sockaddr *) &sockaddr,
-            sizeof(struct sockaddr));
-    if (ret == -1) {
-        mp_raise_OSError(ret);
-    }
-
-    return mp_obj_new_int(ret);
+STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
+    return _socket_recvfrom(self_in, len_in, NULL, NULL);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recv_obj, socket_recv);
 
-// method socket.recvfrom(bufsize)
 STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
-    posix_socket_obj_t *self = self_in;
-    vstr_t vstr;
-    vstr_init_len(&vstr, mp_obj_get_int(len_in));
-    byte ip[4];
-    mp_uint_t port;
-    int ret;
-    struct sockaddr_in sockaddr;
-    uint32_t addr_len;
+    struct sockaddr from;
+    socklen_t fromlen = sizeof(from);
 
-    ret = recvfrom(self->fd, vstr.buf, vstr.len, MSG_DONTWAIT, (struct sockaddr *)&sockaddr, &addr_len);
-    if (ret == -1) {
-        mp_raise_OSError(ret);
-    }
     mp_obj_t tuple[2];
-    if (ret == 0) {
-        tuple[0] = mp_const_empty_bytes;
-    } else {
-        vstr.len = ret;
-        tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-    }
+    tuple[0] = _socket_recvfrom(self_in, len_in, &from, &fromlen);
+
+    uint8_t *ip = (uint8_t*)&((struct sockaddr_in*)&from)->sin_addr;
+    mp_uint_t port = ntohs(((struct sockaddr_in*)&from)->sin_port);
     tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
+
     return mp_obj_new_tuple(2, tuple);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
 
-// method socket.setsockopt(level, optname, value)
-STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
-    posix_socket_obj_t *self = args[0];
-
-    mp_int_t level = mp_obj_get_int(args[1]);
-    mp_int_t opt = mp_obj_get_int(args[2]);
-
-    const void *optval;
-    mp_uint_t optlen;
-    mp_int_t val;
-    if (mp_obj_is_integer(args[3])) {
-        val = mp_obj_get_int_truncated(args[3]);
-        optval = &val;
-        optlen = sizeof(val);
-    } else {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
-        optval = bufinfo.buf;
-        optlen = bufinfo.len;
+STATIC int _socket_send(socket_obj_t *sock, const char *data, size_t datalen) {
+    int sentlen = 0;
+    for (int i = 0; i <= sock->retries && sentlen < datalen; i++) {
+        MP_THREAD_GIL_EXIT();
+        int r = send(sock->fd, data + sentlen, datalen - sentlen, 0);
+        MP_THREAD_GIL_ENTER();
+        if (r < 0 && errno != EWOULDBLOCK) exception_from_errno(errno);
+        if (r > 0) sentlen += r;
+        check_for_exceptions();
     }
+    if (sentlen == 0) mp_raise_OSError(MP_ETIMEDOUT);
+    return sentlen;
+}
 
-    int _errno;
-    if ((_errno = setsockopt(self->fd, level, opt, optval, optlen)) < 0) {
-        mp_raise_OSError(_errno);
-    }
+STATIC mp_obj_t socket_send(const mp_obj_t arg0, const mp_obj_t arg1) {
+    socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
+    mp_uint_t datalen;
+    const char *data = mp_obj_str_get_data(arg1, &datalen);
+    int r = _socket_send(sock, data, datalen);
+    return mp_obj_new_int(r);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_send_obj, socket_send);
 
+STATIC mp_obj_t socket_sendall(const mp_obj_t arg0, const mp_obj_t arg1) {
+    // XXX behaviour when nonblocking (see extmod/modlwip.c)
+    // XXX also timeout behaviour.
+    socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
+    int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
+    if (r < bufinfo.len) mp_raise_OSError(MP_ETIMEDOUT);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_sendall_obj, socket_sendall);
 
-int _socket_settimeout(int sock_fd, uint timeout_ms) {
-    struct timeval timeout = {
-        .tv_sec = 0,
-        .tv_usec = timeout_ms
-    };
-    setsockopt(sock_fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
-    setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
-    return fcntl(sock_fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
-}
+STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-// method socket.settimeout(value)
-// timeout=0 means non-blocking
-// timeout=None means blocking
-// otherwise, timeout is in seconds
-STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
-    posix_socket_obj_t *self = self_in;
-    int timeout;
-    int _errno;
-
-    if (timeout_in == mp_const_none) {
-        timeout = -1;
-    } else {
-        #if MICROPY_PY_BUILTINS_FLOAT
-        timeout = 1000 * mp_obj_get_float(timeout_in);
-        #else
-        timeout = 1000 * mp_obj_get_int(timeout_in);
-        #endif
-    }
+    // get the buffer to send
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
 
-    if (timeout < 0) {
-        _errno = _socket_settimeout(self->fd, UINT32_MAX);
-    } else if (timeout > 0) {
-        _errno = _socket_settimeout(self->fd, timeout);
-    } else {
-        _errno = _socket_settimeout(self->fd, 0);
+    // create the destination address
+    struct sockaddr_in to;
+    to.sin_len = sizeof(to);
+    to.sin_family = AF_INET;
+    to.sin_port = htons(netutils_parse_inet_addr(addr_in, (uint8_t*)&to.sin_addr, NETUTILS_BIG));
+
+    // send the data
+    for (int i=0; i<=self->retries; i++) {
+        MP_THREAD_GIL_EXIT();
+        int ret = sendto(self->fd, bufinfo.buf, bufinfo.len, 0, (struct sockaddr*)&to, sizeof(to));
+        MP_THREAD_GIL_ENTER();
+        if (ret > 0) return mp_obj_new_int_from_uint(ret);
+        if (ret == -1 && errno != EWOULDBLOCK) {
+            exception_from_errno(errno);
+        }
+        check_for_exceptions();
     }
+    mp_raise_OSError(MP_ETIMEDOUT);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
 
-    if (_errno < 0) {
-        mp_raise_OSError(_errno);
-    }
-    return mp_const_none;
+STATIC mp_obj_t socket_fileno(const mp_obj_t arg0) {
+    socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
+    return mp_obj_new_int(self->fd);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_fileno_obj, socket_fileno);
 
-// method socket.setblocking(flag)
-STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t blocking) {
-    if (mp_obj_is_true(blocking)) {
-        return socket_settimeout(self_in, mp_const_none);
-    } else {
-        return socket_settimeout(self_in, MP_OBJ_NEW_SMALL_INT(0));
-    }
+STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    return args[0];
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, 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_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) },
-    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socket_connect_obj) },
-    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&socket_send_obj) },
-    { MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&socket_recv_obj) },
-    { MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socket_sendto_obj) },
-    { MP_ROM_QSTR(MP_QSTR_recvfrom), MP_ROM_PTR(&socket_recvfrom_obj) },
-    { MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socket_setsockopt_obj) },
-    { MP_ROM_QSTR(MP_QSTR_settimeout), MP_ROM_PTR(&socket_settimeout_obj) },
-    { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
-    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_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) },
-};
-STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
+STATIC mp_uint_t socket_stream_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
+    return _socket_read_data(self_in, buf, size, NULL, NULL, errcode);
+}
 
-STATIC mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
-    posix_socket_obj_t * socket = self_in;
+STATIC mp_uint_t socket_stream_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    socket_obj_t *sock = self_in;
+    for (int i = 0; i <= sock->retries; i++) {
+        MP_THREAD_GIL_EXIT();
+        int r = send(sock->fd, buf, size, 0);
+        MP_THREAD_GIL_ENTER();
+        if (r > 0) return r;
+        if (r < 0 && errno != EWOULDBLOCK) { *errcode = errno; return MP_STREAM_ERROR; }
+        check_for_exceptions();
+    }
+    *errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
+    return MP_STREAM_ERROR;
+}
+
+STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    socket_obj_t * socket = self_in;
     if (request == MP_STREAM_POLL) {
+
         fd_set rfds; FD_ZERO(&rfds);
         fd_set wfds; FD_ZERO(&wfds);
         fd_set efds; FD_ZERO(&efds);
@@ -422,59 +437,100 @@ STATIC mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg
         if (arg & MP_STREAM_POLL_WR) FD_SET(socket->fd, &wfds);
         if (arg & MP_STREAM_POLL_HUP) FD_SET(socket->fd, &efds);
 
+        MP_THREAD_GIL_EXIT();
         int r = select((socket->fd)+1, &rfds, &wfds, &efds, &timeout);
+        MP_THREAD_GIL_ENTER();
         if (r < 0) {
             *errcode = MP_EIO;
             return MP_STREAM_ERROR;
         }
-        
+
         mp_uint_t ret = 0;
         if (FD_ISSET(socket->fd, &rfds)) ret |= MP_STREAM_POLL_RD;
         if (FD_ISSET(socket->fd, &wfds)) ret |= MP_STREAM_POLL_WR;
-        if (FD_ISSET(socket->fd, &efds)) ret |= MP_STREAM_POLL_HUP;     
+        if (FD_ISSET(socket->fd, &efds)) ret |= MP_STREAM_POLL_HUP;
         return ret;
-    }else{
-        return ioctl(socket->fd, request, (void *) arg);
+    } else if (request == MP_STREAM_CLOSE) {
+        if (socket->fd >= 0) {
+            int ret = closesocket(socket->fd);
+            if (ret != 0) {
+                *errcode = errno;
+                return MP_STREAM_ERROR;
+            }
+            socket->fd = -1;
+        }
+        return 0;
     }
 
     *errcode = MP_EINVAL;
     return MP_STREAM_ERROR;
 }
 
-STATIC mp_uint_t stream_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
-    posix_socket_obj_t *self = self_in;
-    int err = recv(self->fd, buf, size, 0);
-    if (err < 0) {
-        *errcode = err;
-        return -1;
-    }
-    return err;
-}
+STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
+    { 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) },
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socket_connect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&socket_send_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sendall), MP_ROM_PTR(&socket_sendall_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socket_sendto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&socket_recv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_recvfrom), MP_ROM_PTR(&socket_recvfrom_obj) },
+    { MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socket_setsockopt_obj) },
+    { MP_ROM_QSTR(MP_QSTR_settimeout), MP_ROM_PTR(&socket_settimeout_obj) },
+    { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
+    { MP_ROM_QSTR(MP_QSTR_makefile), MP_ROM_PTR(&socket_makefile_obj) },
+    { MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&socket_fileno_obj) },
 
-STATIC mp_uint_t steam_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
-    posix_socket_obj_t *self = self_in;
-    int err = send(self->fd, buf, size, 0);
-    if (err < 0) {
-        *errcode = err;
-        return -1;
-    }
-    return err;
-}
+    { 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) },
+};
+STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
 
 STATIC const mp_stream_p_t socket_stream_p = {
-    .read = stream_read,
-    .write = steam_write,
-    .ioctl = socket_ioctl,
-    .is_text = false, };
+    .read = socket_stream_read,
+    .write = socket_stream_write,
+    .ioctl = socket_stream_ioctl
+};
 
 STATIC const mp_obj_type_t socket_type = {
     { &mp_type_type },
     .name = MP_QSTR_socket,
-    .make_new = socket_make_new,
     .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&socket_locals_dict,
+    .locals_dict = (mp_obj_t)&socket_locals_dict,
 };
 
+STATIC mp_obj_t get_socket(size_t n_args, const mp_obj_t *args) {
+    socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
+    sock->base.type = &socket_type;
+    sock->domain = AF_INET;
+    sock->type = SOCK_STREAM;
+    sock->proto = 0;
+    sock->peer_closed = false;
+    if (n_args > 0) {
+        sock->domain = mp_obj_get_int(args[0]);
+        if (n_args > 1) {
+            sock->type = mp_obj_get_int(args[1]);
+            if (n_args > 2) {
+                sock->proto = mp_obj_get_int(args[2]);
+            }
+        }
+    }
+
+    sock->fd = socket(sock->domain, sock->type, sock->proto);
+    if (sock->fd < 0) {
+        exception_from_errno(errno);
+    }
+    _socket_settimeout(sock, UINT64_MAX);
+
+    return MP_OBJ_FROM_PTR(sock);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_socket_obj, 0, 3, get_socket);
+
 /******************************************************************************/
 // usocket module
 // function usocket.getaddrinfo(host, port)
@@ -487,7 +543,9 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(uint n_args, const mp_obj_t *arg) {
     struct addrinfo hint, *res = NULL;
     memset(&hint, 0, sizeof(hint));
 
+    MP_THREAD_GIL_EXIT();
     ret = getaddrinfo(host, NULL, &hint, &res);
+    MP_THREAD_GIL_ENTER();
     if (ret != 0) {
         rt_kprintf("getaddrinfo err: %d '%s'\n", ret, host);
         nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "no available netif"));
@@ -500,7 +558,7 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(uint n_args, const mp_obj_t *arg) {
     tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
 
     mp_obj_t tuple_addr[2] = {
-            tuple_addr[0] = netutils_format_ipv4_addr(((res->ai_addr->sa_data) + 2), NETUTILS_BIG),
+            tuple_addr[0] = netutils_format_ipv4_addr((uint8_t *)((res->ai_addr->sa_data) + 2), NETUTILS_BIG),
             tuple_addr[1] = mp_obj_new_int(port),
     };
 
@@ -511,38 +569,30 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(uint n_args, const mp_obj_t *arg) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_usocket_getaddrinfo_obj, 2, 6, mod_usocket_getaddrinfo);
 
-STATIC const mp_rom_map_elem_t mp_module_usocket_globals_table[] = {
+STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_usocket) },
 
-    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&socket_type) },
+    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&get_socket_obj) },
     { MP_ROM_QSTR(MP_QSTR_getaddrinfo), MP_ROM_PTR(&mod_usocket_getaddrinfo_obj) },
 
-    // class constants
-    { MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(MOD_NETWORK_AF_INET) },
-    { MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(MOD_NETWORK_AF_INET6) },
-
-    { MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(MOD_NETWORK_SOCK_STREAM) },
-    { MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(MOD_NETWORK_SOCK_DGRAM) },
-    { MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(MOD_NETWORK_SOCK_RAW) },
-    { MP_ROM_QSTR(MP_QSTR_SOL_SOCKET), MP_ROM_INT(SOL_SOCKET) },
-    { MP_ROM_QSTR(MP_QSTR_SO_REUSEADDR), MP_ROM_INT(SO_REUSEADDR) },
-        
-
-    { MP_ROM_QSTR(MP_QSTR_IPPROTO_IP), MP_ROM_INT(IPPROTO_IP) },
-    { MP_ROM_QSTR(MP_QSTR_IPPROTO_ICMP), MP_ROM_INT(IPPROTO_ICMP) },
-    { MP_ROM_QSTR(MP_QSTR_IPPROTO_IPV4), MP_ROM_INT(IPPROTO_IP) },
+    { MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(AF_INET) },
+    { MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(AF_INET6) },
+    { MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(SOCK_STREAM) },
+    { MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(SOCK_DGRAM) },
+    { MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(SOCK_RAW) },
     { MP_ROM_QSTR(MP_QSTR_IPPROTO_TCP), MP_ROM_INT(IPPROTO_TCP) },
     { MP_ROM_QSTR(MP_QSTR_IPPROTO_UDP), MP_ROM_INT(IPPROTO_UDP) },
-    { MP_ROM_QSTR(MP_QSTR_IPPROTO_IPV6), MP_ROM_INT(41) },
-    { MP_ROM_QSTR(MP_QSTR_IPPROTO_RAW), MP_ROM_INT(IPPROTO_RAW) },
-
+    { MP_ROM_QSTR(MP_QSTR_IPPROTO_IP), MP_ROM_INT(IPPROTO_IP) },
+    { MP_ROM_QSTR(MP_QSTR_SOL_SOCKET), MP_ROM_INT(SOL_SOCKET) },
+    { MP_ROM_QSTR(MP_QSTR_SO_REUSEADDR), MP_ROM_INT(SO_REUSEADDR) },
+    { MP_ROM_QSTR(MP_QSTR_IP_ADD_MEMBERSHIP), MP_ROM_INT(IP_ADD_MEMBERSHIP) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(mp_module_usocket_globals, mp_module_usocket_globals_table);
+STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_table);
 
 const mp_obj_module_t mp_module_usocket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_usocket_globals,
+    .globals = (mp_obj_dict_t*)&mp_module_socket_globals,
 };
 
 #endif  // MICROPY_PY_USOCKET

port/mpthreadport.c

@@ -36,12 +36,21 @@
 
 #if MICROPY_PY_THREAD
 
-#define MP_THREAD_MIN_STACK_SIZE                        (4 * 1024)
+#define MP_THREAD_MIN_STACK_SIZE                        (5 * 1024)
 #define MP_THREAD_DEFAULT_STACK_SIZE                    (MP_THREAD_MIN_STACK_SIZE + 1024)
 #define MP_THREAD_PRIORITY                              (RT_THREAD_PRIORITY_MAX / 2)
 
 typedef struct {
     rt_thread_t thread;
+    /* whether the thread is ready and running */
+    rt_bool_t ready;
+    /* thread Python args, a GC root pointer */
+    void *arg;
+    /* pointer to the stack */
+    void *stack;
+    void *tcb;
+    /* number of words in the stack */
+    size_t stack_len;
     rt_list_t list;
 } mp_thread, *mp_thread_t;
 
@@ -53,16 +62,58 @@ typedef struct {
 // the mutex controls access to the linked list
 STATIC mp_thread_mutex_t thread_mutex;
 STATIC rt_list_t thread_list, mutex_list;
+STATIC mp_thread thread_entry0;
+/* root pointer, handled by mp_thread_gc_others */
+STATIC mp_thread *main_thread;
 
-void mp_thread_init(void) {
+/**
+ * thread port initialization
+ *
+ * @param stack MicroPython main thread stack
+ * @param stack_len MicroPython main thread stack, unit: word
+ */
+void mp_thread_init(void *stack, uint32_t stack_len) {
     mp_thread_set_state(&mp_state_ctx.thread);
 
+    main_thread = &thread_entry0;
+    main_thread->thread = rt_thread_self();
+    main_thread->ready = RT_TRUE;
+    main_thread->arg = NULL;
+    main_thread->stack = stack;
+    main_thread->stack_len = stack_len;
+
     rt_list_init(&thread_list);
     rt_list_init(&mutex_list);
 
+    rt_list_insert_before(&thread_list, &(main_thread->list));
+
     mp_thread_mutex_init(&thread_mutex);
 }
 
+void mp_thread_gc_others(void) {
+    struct rt_list_node *list = &thread_list, *node = NULL;
+    mp_thread_t cur_thread_node = NULL;
+
+    mp_thread_mutex_lock(&thread_mutex, 1);
+
+    for (node = list->next; node != list; node = node->next) {
+        cur_thread_node = rt_list_entry(node, mp_thread, list);
+        gc_collect_root((void **)&cur_thread_node->thread, 1);
+        /* probably not needed */
+        gc_collect_root(&cur_thread_node->arg, 1);
+        if (cur_thread_node->thread == rt_thread_self()) {
+            continue;
+        }
+        if (!cur_thread_node->ready) {
+            continue;
+        }
+        /* probably not needed */
+        gc_collect_root(cur_thread_node->stack, cur_thread_node->stack_len);
+    }
+
+    mp_thread_mutex_unlock(&thread_mutex);
+}
+
 mp_state_thread_t *mp_thread_get_state(void) {
     return (mp_state_thread_t *)(rt_thread_self()->user_data);
 }
@@ -72,6 +123,20 @@ void mp_thread_set_state(void *state) {
 }
 
 void mp_thread_start(void) {
+    struct rt_list_node *list = &thread_list, *node = NULL;
+    mp_thread_t cur_thread_node = NULL;
+
+    mp_thread_mutex_lock(&thread_mutex, 1);
+
+    for (node = list->next; node != list; node = node->next) {
+        cur_thread_node = rt_list_entry(node, mp_thread, list);
+        if (cur_thread_node->thread == rt_thread_self()) {
+            cur_thread_node->ready = RT_TRUE;
+            break;
+        }
+    }
+
+    mp_thread_mutex_unlock(&thread_mutex);
 }
 
 STATIC void *(*ext_thread_entry)(void*) = NULL;
@@ -81,23 +146,7 @@ STATIC void rtthread_entry(void *arg) {
         ext_thread_entry(arg);
     }
 
-    /* remove node on list */
-    {
-        struct rt_list_node *list = &thread_list, *node = NULL;
-        mp_thread_t cur_thread_node = NULL;
-
-        mp_thread_mutex_lock(&thread_mutex, 1);
-
-        for (node = list->next; node != list; node = node->next) {
-            cur_thread_node = rt_list_entry(node, mp_thread, list);
-            if (cur_thread_node->thread == rt_thread_self()) {
-                rt_list_remove(node);
-                break;
-            }
-        }
-
-        mp_thread_mutex_unlock(&thread_mutex);
-    }
+    rt_thread_detach(rt_thread_self());
 }
 
 void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, int priority, char *name) {
@@ -110,20 +159,30 @@ void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, i
         *stack_size = MP_THREAD_MIN_STACK_SIZE; // minimum stack size
     }
 
-    // allocate linked-list node (must be outside thread_mutex lock)
-    mp_thread *node = rt_malloc(sizeof(mp_thread));
+    // allocate TCB, stack and linked-list node (must be outside thread_mutex lock)
+    rt_thread_t th = m_new_obj(struct rt_thread);
+    if (th == NULL) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread TCB"));
+    }
+    uint8_t *stack = m_new(uint8_t, *stack_size);
+    if (stack == NULL) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread stack"));
+    }
+    mp_thread *node = m_new_obj(mp_thread);
     if (node == NULL) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread list node"));
     }
+    // adjust the stack_size to provide room to recover from hitting the limit
+    *stack_size -= 1024;
+
+    node->ready = RT_FALSE;
+    node->arg = arg;
+    node->stack = stack;
+    node->stack_len = *stack_size / 4;
 
     mp_thread_mutex_lock(&thread_mutex, 1);
 
-    // create thread
-    rt_thread_t th = rt_thread_create(name, rtthread_entry, arg, *stack_size, priority, 0);
-    if (th == NULL) {
-        mp_thread_mutex_unlock(&thread_mutex);
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread"));
-    }
+    rt_thread_init(th, name, rtthread_entry, arg, stack, *stack_size, priority, 0);
 
     // add thread to linked list of all threads
     {
@@ -153,6 +212,27 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
 }
 
 void mp_thread_finish(void) {
+    struct rt_list_node *list = &thread_list, *node = NULL;
+    mp_thread_t cur_thread_node = NULL;
+
+    mp_thread_mutex_lock(&thread_mutex, 1);
+
+    for (node = list->next; node != list; node = node->next) {
+        cur_thread_node = rt_list_entry(node, mp_thread, list);
+        if (cur_thread_node->thread == rt_thread_self()) {
+            cur_thread_node->ready = RT_FALSE;
+            // explicitly release all its memory
+            m_del(rt_thread_t, cur_thread_node->thread, 1);
+            m_del(uint8_t, cur_thread_node->stack, cur_thread_node->stack_len);
+//            m_del(mp_thread, cur_thread_node, 1);
+            rt_list_remove(node);
+            break;
+        }
+    }
+
+    mp_thread_mutex_unlock(&thread_mutex);
+
+    rt_thread_detach(rt_thread_self());
 }
 
 void mp_thread_mutex_init(mp_thread_mutex_t *mutex) {
@@ -198,8 +278,9 @@ void mp_thread_deinit(void) {
 
         for (node = list->next; node != list; node = node->next) {
             cur_thread_node = rt_list_entry(node, mp_thread, list);
-            rt_thread_delete(cur_thread_node->thread);
-            rt_free(cur_thread_node);
+            if (cur_thread_node->thread != main_thread->thread) {
+                rt_thread_detach(cur_thread_node->thread);
+            }
         }
     }
     /* remove all mutex node on list */

port/mpthreadport.h

@@ -31,7 +31,7 @@
 
 typedef struct rt_mutex mp_thread_mutex_t;
 
-void mp_thread_init(void);
+void mp_thread_init(void *stack, uint32_t stack_len);
 void mp_thread_gc_others(void);
 void mp_thread_deinit(void);
 

port/mpy_main.c

@@ -39,6 +39,7 @@
 #include <py/mperrno.h>
 #include <py/stackctrl.h>
 #include <py/frozenmod.h>
+#include <lib/mp-readline/readline.h>
 #include <lib/utils/pyexec.h>
 #include "rtt_getchar.h"
 
@@ -71,12 +72,12 @@ void mpy_main(const char *filename) {
     rtt_getchar_init();
 
 #if MICROPY_PY_THREAD
-    mp_thread_init();
+    mp_thread_init(rt_thread_self()->stack_addr, rt_thread_self()->stack_size / 4);
 #endif
 
     mp_stack_set_top(stack_top);
     // Make MicroPython's stack limit somewhat smaller than full stack available
-	mp_stack_set_limit(FINSH_THREAD_STACK_SIZE - 512);
+	mp_stack_set_limit(FINSH_THREAD_STACK_SIZE - 1024);
 
     #if MICROPY_ENABLE_GC
     heap = rt_malloc(MICROPY_HEAP_SIZE);
@@ -95,6 +96,7 @@ void mpy_main(const char *filename) {
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
     mp_obj_list_append(mp_sys_path, mp_obj_new_str(MICROPY_PY_PATH, strlen(MICROPY_PY_PATH)));
     mp_obj_list_init(mp_sys_argv, 0);
+    readline_init0();
 
     if (filename) {
         pyexec_file(filename);
@@ -141,17 +143,6 @@ void mpy_main(const char *filename) {
     rtt_getchar_deinit();
 }
 
-void gc_collect(void) {
-    // WARNING: This gc_collect implementation doesn't try to get root
-    // pointers from CPU registers, and thus may function incorrectly.
-    void *dummy;
-    gc_collect_start();
-    gc_collect_root(&dummy, ((mp_uint_t)stack_top - (mp_uint_t)&dummy) / sizeof(mp_uint_t));
-
-    gc_collect_end();
-    gc_dump_info();
-}
-
 #if !MICROPY_PY_MODUOS_FILE
 mp_import_stat_t mp_import_stat(const char *path) {
     return MP_IMPORT_STAT_NO_EXIST;

py/stream.c

@@ -32,13 +32,6 @@
 #include "py/stream.h"
 #include "py/runtime.h"
 
-#if MICROPY_STREAMS_NON_BLOCK
-#include <errno.h>
-#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
-#define EWOULDBLOCK 140
-#endif
-#endif
-
 // This file defines generic Python stream read/write methods which
 // dispatch to the underlying stream interface of an object.
 
@@ -105,13 +98,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 +420,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);
 

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);
@@ -106,7 +107,7 @@ int mp_stream_posix_fsync(mp_obj_t stream);
 #endif
 
 #if MICROPY_STREAMS_NON_BLOCK
-#define mp_is_nonblocking_error(errno) ((errno) == EAGAIN || (errno) == EWOULDBLOCK)
+#define mp_is_nonblocking_error(errno) ((errno) == MP_EAGAIN || (errno) == MP_EWOULDBLOCK)
 #else
 #define mp_is_nonblocking_error(errno) (0)
 #endif