diff --git a/esp32/frozen/LTE/sqnsupgrade.py b/esp32/frozen/LTE/sqnsupgrade.py index 47a0746a31..8cd0b20b72 100644 --- a/esp32/frozen/LTE/sqnsupgrade.py +++ b/esp32/frozen/LTE/sqnsupgrade.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -VERSION = "1.2.2" +VERSION = "1.2.3" # Copyright (c) 2019, Pycom Limited. # @@ -17,6 +17,7 @@ import sqnstp as stp release = None + try: sysname = os.uname().sysname if 'FiPy' in sysname or 'GPy' in sysname: @@ -50,6 +51,8 @@ def __init__(self): self.__resp_921600 = False self.__serial = None self.__kill_ppp_ok = False + self.__modem_speed = None + self.__speed_detected = False if 'GPy' in self.__sysname: self.__pins = ('P5', 'P98', 'P7', 'P99') @@ -86,7 +89,8 @@ def read_rsp(self, size=None, timeout=-1): else: return b'' - def print_pretty_response(self, rsp, flush=False): + def print_pretty_response(self, rsp, flush=False, prefix=None): + if prefix is not None: self.special_print(prefix, flush=flush, end=' ') lines = rsp.decode('ascii').split('\r\n') for line in lines: if 'OK' not in line and line!='': @@ -222,17 +226,20 @@ def __hangup_modem(self, delay, debug): return False - def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): + def detect_modem_state(self, retry=5, initial_delay=1000, hangup=True, debug=False): count = 0 self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=1) + self.__modem_speed = 921600 self.__serial.read() while count < retry: count += 1 delay = initial_delay * count if debug: print("The current delay is {}".format(delay)) self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=10) + self.__modem_speed = 921600 #if True: - if self.__hangup_modem(initial_delay, debug): + if hangup and self.__hangup_modem(initial_delay, debug): + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -242,6 +249,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): except: pass else: + self.__modem_speed = 921600 self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=1) self.__serial.read() self.__serial.write(b"AT\r\n") @@ -250,6 +258,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): self.__check_resp(resp) if debug: print('Response (AT #3) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -264,6 +273,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): self.__check_resp(resp) if debug: print('Response (AT #4) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -274,12 +284,14 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): pass else: if not self.__resp_921600: + self.__modem_speed = 115200 self.__serial = UART(1, baudrate=115200, pins=self.__pins, timeout_chars=10) self.__serial.write(b"AT\r\n") time.sleep_ms(delay) resp = self.__serial.read() if debug: print('Response (AT #1 @ 115200) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -293,6 +305,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): resp = self.__serial.read() if debug: print('Response (AT #2 @ 115200) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -303,6 +316,14 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): pass return None + def get_imei(self): + self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=10) + self.__serial.write(b"AT+CGSN\r\n") + time.sleep(.5) + imei_val = self.read_rsp(2000) + return self.return_pretty_response(imei_val) + + def __get_power_warning(self): return "<<<=== DO NOT DISCONNECT POWER ===>>>" @@ -317,13 +338,14 @@ def __get_wait_msg(self, load_fff=True): - def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, version_only=False, expected_smod=None, verbose=False, load_fff=False): + def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, info_only=False, expected_smod=None, verbose=False, load_fff=False): self.__wait_msg = False mirror = True if atneg_only else mirror recover = True if atneg_only else load_ffh - resume = True if mirror or recover or atneg_only or version_only else resume + resume = True if mirror or recover or atneg_only or info_only else resume verbose = True if debug else verbose load_fff = False if bootrom and switch_ffh else load_fff + baudrate = self.__modem_speed if self.__speed_detected else baudrate if debug: print('mirror? {} recover? {} resume? {} direct? {} atneg_only? {} bootrom? {} load_fff? {}'.format(mirror, recover, resume, direct, atneg_only, bootrom, load_fff)) abort = True external = False @@ -331,7 +353,7 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f if 'FiPy' in self.__sysname or 'GPy' in self.__sysname: - self.__serial = UART(1, baudrate=115200 if recover else baudrate, pins=self.__pins, timeout_chars=100) + self.__serial = UART(1, baudrate=115200 if recover and not self.__speed_detected else baudrate, pins=self.__pins, timeout_chars=100) self.__serial.read() else: if port is None: @@ -340,15 +362,18 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f external = True br = 115200 if recover and not direct else baudrate if debug: print('Setting baudrate to {}'.format(br)) - self.__serial = serial.Serial(port, br, bytesize=serial.EIGHTBITS, timeout=1 if version_only else 0.1) + self.__serial = serial.Serial(port, br, bytesize=serial.EIGHTBITS, timeout=1 if info_only else 0.1) self.__serial.reset_input_buffer() self.__serial.reset_output_buffer() - if version_only: + if info_only: self.__serial.read() self.__serial.write(b'AT\r\n') self.__serial.write(b'AT\r\n') self.__serial.read() + self.__serial.write(b"AT+CGSN\r\n") + time.sleep(.5) + shimei = self.read_rsp(2000) if verbose: self.__serial.write(b"AT!=\"showver\"\r\n") else: @@ -357,6 +382,8 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f shver = self.read_rsp(2000) if shver is not None: self.print_pretty_response(shver) + if shimei is not None: + self.print_pretty_response(shimei, prefix='\nIMEI:') return True if debug: print('Initial prepartion complete...') @@ -391,9 +418,17 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f if not resume: + # bind to AT channel + self.__serial.write(b"AT+BIND=AT\r\n") + time.sleep(.5) + response = self.read_rsp(size=100) + if debug: print("AT+BIND=AT returned {}".format(response)) + # disable echo self.__serial.write(b"ATE0\r\n") - response = self.read_rsp(size=6) + time.sleep(.5) + response = self.read_rsp(size=100) + if debug: print("ATE0 returned {}".format(response)) self.__serial.read(100) if debug: print('Entering upgrade mode...') @@ -673,14 +708,14 @@ def __check_br(self, br_only=False, verbose=False, debug=False): def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT wakeup...'): if 'FiPy' in self.__sysname or 'GPy' in self.__sysname: - self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=1) + self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=10) MAX_TRY = max_try count = 0 if msg is not None: print(msg) self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=25) if debug: print('{}'.format(response)) while (not b'OK' in response) and (count < MAX_TRY): count = count + 1 @@ -688,7 +723,7 @@ def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT time.sleep(delay) self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=25) if debug: print('{}'.format(response)) if 'FiPy' in sysname or 'GPy' in sysname: self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=100) @@ -699,7 +734,7 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug): count = 0 print('Attempting AT auto-negotiation...') self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=20) if debug: print('{}'.format(response)) while (not b'OK' in response) and (count < MAX_TRY): count = count + 1 @@ -707,7 +742,7 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug): time.sleep(1) self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=20) if debug: print('{}'.format(response)) if b'OK' in response: self.__serial.read() @@ -757,9 +792,9 @@ def uart_mirror(self, color): def success_message(self, port=None, verbose=False, debug=False): print("Your modem has been successfully updated.") print("Here is the current firmware version:\n") - self.show_version(port=port, verbose=verbose, debug=debug) + self.show_info(port=port, verbose=verbose, debug=debug) - def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True): + def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True, load_only=False): success = True if not retry and mfile is not None: if resume or self.__check_br(br_only=True, verbose=verbose, debug=debug): @@ -776,6 +811,8 @@ def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, success = False success = self.__run(file_path=mfile, load_ffh=True, direct=False, baudrate=baudrate, debug=debug, pkgdebug=pkgdebug, verbose=verbose) time.sleep(1) + if load_only: + return True else: success = True else: @@ -818,8 +855,8 @@ def upgrade_uart(self, ffh_mode=False, mfile=None, retry=False, resume=False, co else: print('Unable to upgrade bootrom.') - def show_version(self, port=None, debug=False, verbose=False): - self.__run(port=port, debug=debug, version_only=True, verbose=verbose) + def show_info(self, port=None, debug=False, verbose=False): + self.__run(port=port, debug=debug, info_only=True, verbose=verbose) def upgrade_ext(self, port, ffile, mfile, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True): success = True @@ -847,13 +884,29 @@ def print_welcome(): if 'FiPy' in sysname or 'GPy' in sysname: - def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff=True): + def load(mfile, baudrate=921600, verbose=False, debug=False, hangup=False): + print_welcome() + sqnup = sqnsupgrade() + if sqnup.check_files(mfile, None, debug): + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) + if state is None: + detect_error() + elif state == 0: + sqnup.upgrade(ffile=None, mfile=mfile, baudrate=baudrate, retry=True, resume=False, debug=debug, pkgdebug=False, verbose=verbose, load_fff=False, load_only=True) + elif state == -1: + detect_error() + else: + print('Modem must be in recovery mode!') + reconnect_uart() + + def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff=True, hangup=True): print_welcome() retry = False resume = False sqnup = sqnsupgrade() if sqnup.check_files(ffile, mfile, debug): - state = sqnup.detect_modem_state(debug=debug) + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) if debug: print('Modem state: {}'.format(state)) if state is None: detect_error() @@ -863,19 +916,24 @@ def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff print('Your modem is in recovery mode. Please specify updater.elf file') reconnect_uart() sys.exit(1) - elif state == 4: + elif state == 4 or state == 1: resume = True elif state == -1: detect_error() sqnup.upgrade(ffile=ffile, mfile=mfile, baudrate=baudrate, retry=retry, resume=resume, debug=debug, pkgdebug=False, verbose=verbose, load_fff=load_fff) reconnect_uart() - def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False): + def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False, hangup=True): print_welcome() retry = False resume = False + import pycom + state = None sqnup = sqnsupgrade() - state = sqnup.detect_modem_state(debug=debug) + if verbose: print('Trying to detect modem state...') + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) + if state is None: detect_error() elif state == 0: @@ -888,22 +946,19 @@ def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False) detect_error() sqnup.upgrade_uart(ffh_mode, mfile, retry, resume, color, debug, False, verbose) - def info(verbose=False, debug=False, retry=5): + def info(verbose=False, debug=False, hangup=True): print_welcome() import pycom - count = 0 + state = None sqnup = sqnsupgrade() - while count < retry: - count += 1 - if verbose: print('Trying to detect modem state [{}/{}]'.format(count, retry)) - state = sqnup.detect_modem_state(debug=debug) - if debug: print('State: {} at count: {}'.format(state, count)) - if state is not None: break + if verbose: print('Trying to detect modem state...') + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) if state is not None: if state == 2: print('Your modem is in application mode. Here is the current version:') - sqnup.show_version(verbose=verbose, debug=debug) + sqnup.show_info(verbose=verbose, debug=debug) elif state == 1: print('Your modem is in mTools mode.') elif state == 0: @@ -918,6 +973,15 @@ def info(verbose=False, debug=False, retry=5): print('Cannot determine modem state!') reconnect_uart() + def imei(verbose=False, debug=False, retry=5, hangup=False): + sqnup = sqnsupgrade() + state = sqnup.detect_modem_state(debug=debug, hangup=hangup, retry=retry) + return sqnup.get_imei() if state == 2 else None + + def state(verbose=False, debug=False, retry=5, hangup=False): + sqnup = sqnsupgrade() + return sqnup.detect_modem_state(debug=debug, hangup=hangup, retry=retry) + else: def run(port, ffile, mfile=None, resume=False, debug=False, verbose=False, load_fff=True): print_welcome() @@ -927,4 +991,4 @@ def run(port, ffile, mfile=None, resume=False, debug=False, verbose=False, load_ def version(port, verbose=False, debug=False): sqnup = sqnsupgrade() - sqnup.show_version(port=port, debug=debug, verbose=verbose) + sqnup.show_info(port=port, debug=debug, verbose=verbose) diff --git a/esp32/mods/lwipsocket.c b/esp32/mods/lwipsocket.c index ee009d1345..2a3d7ceff2 100644 --- a/esp32/mods/lwipsocket.c +++ b/esp32/mods/lwipsocket.c @@ -34,6 +34,7 @@ #include "lwip/sockets.h" #include "lwip/dns.h" #include "lwip/netdb.h" +#include "lwipsocket.h" #define WLAN_MAX_RX_SIZE 2048 @@ -156,49 +157,19 @@ int lwipsocket_socket_connect(mod_network_socket_obj_t *s, byte *ip, mp_uint_t p if (ret != 0) { // printf("Connect returned -0x%x\n", -ret); - *_errno = ret; + *_errno = errno; return -1; } // printf("Connected.\n"); if (s->sock_base.is_ssl && (ret == 0)) { - mp_obj_ssl_socket_t *ss = (mp_obj_ssl_socket_t *)s; - - if ((ret = mbedtls_net_set_block(&ss->context_fd)) != 0) { - // printf("failed! net_set_(non)block() returned -0x%x\n", -ret); - *_errno = ret; - return -1; - } - - mbedtls_ssl_set_bio(&ss->ssl, &ss->context_fd, mbedtls_net_send, NULL, mbedtls_net_recv_timeout); - - // printf("Performing the SSL/TLS handshake...\n"); - - while ((ret = mbedtls_ssl_handshake(&ss->ssl)) != 0) - { - if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_TIMEOUT) - { - // printf("mbedtls_ssl_handshake returned -0x%x\n", -ret); - *_errno = ret; - return -1; - } - } - - // printf("Verifying peer X.509 certificate...\n"); - if ((ret = mbedtls_ssl_get_verify_result(&ss->ssl)) != 0) { - /* In real life, we probably want to close connection if ret != 0 */ - // printf("Failed to verify peer certificate!\n"); - *_errno = ret; - return -1; - } else { - // printf("Certificate verified.\n"); - } + ret = lwipsocket_socket_setup_ssl(s, _errno); } s->sock_base.connected = true; - return 0; + return ret; } int lwipsocket_socket_send(mod_network_socket_obj_t *s, const byte *buf, mp_uint_t len, int *_errno) { @@ -393,3 +364,45 @@ int lwipsocket_socket_ioctl (mod_network_socket_obj_t *s, mp_uint_t request, mp_ } return ret; } + +int lwipsocket_socket_setup_ssl(mod_network_socket_obj_t *s, int *_errno) +{ + int ret; + uint32_t count = 0; + mp_obj_ssl_socket_t *ss = (mp_obj_ssl_socket_t *)s; + + if ((ret = mbedtls_net_set_block(&ss->context_fd)) != 0) { + // printf("failed! net_set_(non)block() returned -0x%x\n", -ret); + *_errno = ret; + return -1; + } + + mbedtls_ssl_set_bio(&ss->ssl, &ss->context_fd, mbedtls_net_send, NULL, mbedtls_net_recv_timeout); + + // printf("Performing the SSL/TLS handshake...\n"); + + while ((ret = mbedtls_ssl_handshake(&ss->ssl)) != 0) + { + if ((ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_TIMEOUT ) || count >= ss->read_timeout) + { + // printf("mbedtls_ssl_handshake returned -0x%x\n", -ret); + *_errno = ret; + return -1; + } + if(ret == MBEDTLS_ERR_SSL_TIMEOUT) + { + count++; + } + } + + // printf("Verifying peer X.509 certificate...\n"); + + if ((ret = mbedtls_ssl_get_verify_result(&ss->ssl)) != 0) { + /* In real life, we probably want to close connection if ret != 0 */ + // printf("Failed to verify peer certificate!\n"); + *_errno = ret; + return -1; + } + // printf("Certificate verified.\n"); + return 0; +} diff --git a/esp32/mods/lwipsocket.h b/esp32/mods/lwipsocket.h index d379619003..82d526c8cc 100644 --- a/esp32/mods/lwipsocket.h +++ b/esp32/mods/lwipsocket.h @@ -40,4 +40,6 @@ extern int lwipsocket_socket_settimeout(mod_network_socket_obj_t *s, mp_int_t ti extern int lwipsocket_socket_ioctl (mod_network_socket_obj_t *s, mp_uint_t request, mp_uint_t arg, int *_errno); +extern int lwipsocket_socket_setup_ssl(mod_network_socket_obj_t *s, int *_errno); + #endif // LWIPSOCKET_H_ diff --git a/esp32/mods/machuart.c b/esp32/mods/machuart.c index 9f2a53ba8d..fe6c10222c 100644 --- a/esp32/mods/machuart.c +++ b/esp32/mods/machuart.c @@ -75,6 +75,9 @@ #define UART_TRIGGER_RX_FULL (0x04) #define UART_TRIGGER_TX_DONE (0x08) +#define MACH_UART_CHECK_INIT(self) \ + if(!(self->init)) {nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "UART not Initialized!"));} + /****************************************************************************** DECLARE PRIVATE FUNCTIONS ******************************************************************************/ @@ -93,6 +96,7 @@ struct _mach_uart_obj_t { uint8_t uart_id; uint8_t rx_timeout; uint8_t n_pins; + bool init; }; /****************************************************************************** @@ -269,6 +273,7 @@ STATIC bool uart_rx_wait (mach_uart_obj_t *self) { STATIC void mach_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) if (self->config.baud_rate > 0) { mp_printf(print, "UART(%u, baudrate=%u, bits=", self->uart_id, self->config.baud_rate); switch (self->config.data_bits) { @@ -434,6 +439,9 @@ STATIC mp_obj_t mach_uart_init_helper(mach_uart_obj_t *self, const mp_arg_val_t // configure the rx timeout threshold self->uart_reg->conf1.rx_tout_thrhd = self->rx_timeout & UART_RX_TOUT_THRHD_V; + // Init Done + self->init = true; + return mp_const_none; error: @@ -498,18 +506,22 @@ STATIC mp_obj_t mach_uart_deinit(mp_obj_t self_in) { uart_driver_delete(self->uart_id); } + self->init = false; + return mp_const_none; } STATIC MP_DEFINE_CONST_FUN_OBJ_1(mach_uart_deinit_obj, mach_uart_deinit); STATIC mp_obj_t mach_uart_any(mp_obj_t self_in) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) return mp_obj_new_int(uart_rx_any(self)); } STATIC MP_DEFINE_CONST_FUN_OBJ_1(mach_uart_any_obj, mach_uart_any); STATIC mp_obj_t mach_uart_wait_tx_done(mp_obj_t self_in, mp_obj_t timeout_ms) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) TickType_t timeout_ticks = mp_obj_get_int_truncated(timeout_ms) / portTICK_PERIOD_MS; return uart_wait_tx_done(self->uart_id, timeout_ticks) == ESP_OK ? mp_const_true : mp_const_false; } @@ -517,6 +529,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mach_uart_wait_tx_done_obj, mach_uart_wait_tx_d STATIC mp_obj_t mach_uart_sendbreak(mp_obj_t self_in, mp_obj_t bits) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) pin_obj_t * pin = (pin_obj_t *)((mp_obj_t *)self->pins)[0]; uint32_t isrmask = MICROPY_BEGIN_ATOMIC_SECTION(); @@ -576,6 +589,7 @@ STATIC MP_DEFINE_CONST_DICT(mach_uart_locals_dict, mach_uart_locals_dict_table); STATIC mp_uint_t mach_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) byte *buf = buf_in; // make sure we want at least 1 char @@ -603,6 +617,7 @@ STATIC mp_uint_t mach_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, STATIC mp_uint_t mach_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) const char *buf = buf_in; // write the data @@ -614,6 +629,7 @@ STATIC mp_uint_t mach_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t STATIC mp_uint_t mach_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) { mach_uart_obj_t *self = self_in; + MACH_UART_CHECK_INIT(self) mp_uint_t ret; if (request == MP_IOCTL_POLL) { diff --git a/esp32/mods/modlte.c b/esp32/mods/modlte.c index e420101c73..b54473c073 100644 --- a/esp32/mods/modlte.c +++ b/esp32/mods/modlte.c @@ -1185,5 +1185,6 @@ const mod_network_nic_type_t mod_network_nic_type_lte = { .n_setsockopt = lwipsocket_socket_setsockopt, .n_bind = lwipsocket_socket_bind, .n_ioctl = lwipsocket_socket_ioctl, + .n_setupssl = lwipsocket_socket_setup_ssl, .inf_up = ltepp_is_ppp_conn_up, }; diff --git a/esp32/mods/modnetwork.h b/esp32/mods/modnetwork.h index 511b1017d6..18a559a71a 100644 --- a/esp32/mods/modnetwork.h +++ b/esp32/mods/modnetwork.h @@ -70,6 +70,7 @@ typedef struct _mod_network_nic_type_t { int (*n_setsockopt)(struct _mod_network_socket_obj_t *socket, mp_uint_t level, mp_uint_t opt, const void *optval, mp_uint_t optlen, int *_errno); int (*n_settimeout)(struct _mod_network_socket_obj_t *socket, mp_int_t timeout_ms, int *_errno); int (*n_ioctl)(struct _mod_network_socket_obj_t *socket, mp_uint_t request, mp_uint_t arg, int *_errno); + int (*n_setupssl)(struct _mod_network_socket_obj_t *socket, int *_errno); // Interface status bool (*inf_up)(void); diff --git a/esp32/mods/modusocket.c b/esp32/mods/modusocket.c index 183ec9daa8..8e8a66e4ca 100644 --- a/esp32/mods/modusocket.c +++ b/esp32/mods/modusocket.c @@ -538,6 +538,16 @@ STATIC mp_obj_t socket_makefile(mp_uint_t n_args, const mp_obj_t *args) { } STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 6, socket_makefile); +STATIC mp_obj_t socket_do_handshake(mp_obj_t self_in) { + mod_network_socket_obj_t *self = self_in; + + int _errno; + if (self->sock_base.nic_type->n_setupssl(self, &_errno) != 0) { + nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno))); + } + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_do_handshake_obj, socket_do_handshake); 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 }, @@ -555,6 +565,7 @@ STATIC const mp_map_elem_t socket_locals_dict_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_setblocking), (mp_obj_t)&socket_setblocking_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_makefile), (mp_obj_t)&socket_makefile_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_fileno), (mp_obj_t)&socket_fileno_obj }, + { MP_OBJ_NEW_QSTR(MP_QSTR_do_handshake), (mp_obj_t)&socket_do_handshake_obj }, // stream methods { MP_OBJ_NEW_QSTR(MP_QSTR_read), (mp_obj_t)&mp_stream_read_obj }, @@ -678,7 +689,7 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) { int32_t result = nic_type->n_gethostbyname(host, hlen, out_ip, AF_INET); if (result < 0) { // negate result as it contains the error code which must be positive - nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-result))); + nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(result))); } mp_obj_tuple_t *tuple = mp_obj_new_tuple(5, NULL); tuple->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET); diff --git a/esp32/mods/modussl.c b/esp32/mods/modussl.c index 5bd0f1c57e..427852b3f2 100644 --- a/esp32/mods/modussl.c +++ b/esp32/mods/modussl.c @@ -32,6 +32,7 @@ DEFINE CONSTANTS ******************************************************************************/ #define FILE_READ_SIZE 256 +#define DEFAULT_SSL_READ_TIMEOUT 10 //sec /****************************************************************************** DECLARE PRIVATE FUNCTIONS @@ -143,6 +144,8 @@ static int32_t mod_ssl_setup_socket (mp_obj_ssl_socket_t *ssl_sock, const char * } } + mbedtls_ssl_conf_read_timeout(&ssl_sock->conf, 1000); + ssl_sock->context_fd.fd = ssl_sock->sock_base.u.sd; ssl_sock->sock_base.is_ssl = true; @@ -157,12 +160,17 @@ static int32_t mod_ssl_setup_socket (mp_obj_ssl_socket_t *ssl_sock, const char * mbedtls_ssl_set_bio(&ssl_sock->ssl, &ssl_sock->context_fd, mbedtls_net_send, NULL, mbedtls_net_recv_timeout); // printf("Performing the SSL/TLS handshake...\n"); + int count = 0; while ((ret = mbedtls_ssl_handshake(&ssl_sock->ssl)) != 0) { - if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_TIMEOUT) { - // printf("mbedtls_ssl_handshake returned -0x%x\n", -ret); + if ((ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_TIMEOUT) || count >= ssl_sock->read_timeout) { + //printf("mbedtls_ssl_handshake returned -0x%x\n", -ret); return ret; } + if(ret == MBEDTLS_ERR_SSL_TIMEOUT) + { + count++; + } } // printf("Verifying peer X.509 certificate...\n"); @@ -174,7 +182,6 @@ static int32_t mod_ssl_setup_socket (mp_obj_ssl_socket_t *ssl_sock, const char * // printf("Certificate verified.\n"); } } - mbedtls_ssl_conf_read_timeout(&ssl_sock->conf, 10); return 0; } @@ -224,6 +231,7 @@ STATIC mp_obj_t mod_ssl_wrap_socket(mp_uint_t n_args, const mp_obj_t *pos_args, { MP_QSTR_ssl_version, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, { MP_QSTR_ca_certs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, }; int32_t _error; @@ -258,6 +266,16 @@ STATIC mp_obj_t mod_ssl_wrap_socket(mp_uint_t n_args, const mp_obj_t *pos_args, ssl_sock->base.type = &ssl_socket_type; ssl_sock->o_sock = args[0].u_obj; // this is needed so that the GC doesnt collect the socket + //Read timeout + if(args[8].u_obj == mp_const_none) + { + ssl_sock->read_timeout = DEFAULT_SSL_READ_TIMEOUT; + } + else + { + ssl_sock->read_timeout = mp_obj_get_int(args[8].u_obj); + } + _error = mod_ssl_setup_socket(ssl_sock, host_name, cafile_path, certfile_path, keyfile_path, verify_type, server_side ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT); @@ -284,6 +302,8 @@ STATIC const mp_map_elem_t mp_module_ussl_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_CERT_OPTIONAL), MP_OBJ_NEW_SMALL_INT(MBEDTLS_SSL_VERIFY_OPTIONAL) }, { MP_OBJ_NEW_QSTR(MP_QSTR_CERT_REQUIRED), MP_OBJ_NEW_SMALL_INT(MBEDTLS_SSL_VERIFY_REQUIRED) }, + { MP_OBJ_NEW_QSTR(MP_QSTR_SSL_TIMEOUT), MP_OBJ_NEW_SMALL_INT(MBEDTLS_ERR_SSL_TIMEOUT) }, + // { MP_OBJ_NEW_QSTR(MP_QSTR_PROTOCOL_SSLv3), MP_OBJ_NEW_SMALL_INT(SL_SO_SEC_METHOD_SSLV3) }, // { MP_OBJ_NEW_QSTR(MP_QSTR_PROTOCOL_TLSv1), MP_OBJ_NEW_SMALL_INT(SL_SO_SEC_METHOD_TLSV1) }, // { MP_OBJ_NEW_QSTR(MP_QSTR_PROTOCOL_TLSv1_1), MP_OBJ_NEW_SMALL_INT(SL_SO_SEC_METHOD_TLSV1_1) }, diff --git a/esp32/mods/modussl.h b/esp32/mods/modussl.h index c157cd4dc2..a3063ed2ca 100644 --- a/esp32/mods/modussl.h +++ b/esp32/mods/modussl.h @@ -42,6 +42,7 @@ typedef struct _mp_obj_ssl_socket_t { mbedtls_net_context context_fd; mbedtls_x509_crt own_cert; mbedtls_pk_context pk_key; + uint8_t read_timeout; } mp_obj_ssl_socket_t; #endif /* MODUSSL_H_ */ diff --git a/esp32/mods/modwlan.c b/esp32/mods/modwlan.c index d71063cd09..11e4a5e8d6 100644 --- a/esp32/mods/modwlan.c +++ b/esp32/mods/modwlan.c @@ -1198,6 +1198,7 @@ const mod_network_nic_type_t mod_network_nic_type_wlan = { .n_setsockopt = lwipsocket_socket_setsockopt, .n_settimeout = lwipsocket_socket_settimeout, .n_ioctl = lwipsocket_socket_ioctl, + .n_setupssl = lwipsocket_socket_setup_ssl, .inf_up = wlan_is_inf_up }; diff --git a/esp32/mp_pycom_err.h b/esp32/mp_pycom_err.h new file mode 100644 index 0000000000..d18cfd006a --- /dev/null +++ b/esp32/mp_pycom_err.h @@ -0,0 +1,121 @@ +/* + * mp_pycom_err.h + * + * Created on: 22 Feb 2019 + * Author: iwahdan + */ + +#ifndef ESP32_MP_PYCOM_ERR_H_ +#define ESP32_MP_PYCOM_ERR_H_ + +#include "mbedtls/net_sockets.h" +#include "mbedtls/ssl.h" +#include "lwip/err.h" +#include "lwip/netdb.h" +#include "esp_err.h" + +#define MP_MBEDTLS_ERR_NET_SOCKET_FAILED MBEDTLS_ERR_NET_SOCKET_FAILED +#define MP_MBEDTLS_ERR_NET_CONNECT_FAILED MBEDTLS_ERR_NET_CONNECT_FAILED +#define MP_MBEDTLS_ERR_NET_BIND_FAILED MBEDTLS_ERR_NET_BIND_FAILED +#define MP_MBEDTLS_ERR_NET_LISTEN_FAILED MBEDTLS_ERR_NET_LISTEN_FAILED +#define MP_MBEDTLS_ERR_NET_ACCEPT_FAILED MBEDTLS_ERR_NET_ACCEPT_FAILED +#define MP_MBEDTLS_ERR_NET_RECV_FAILED MBEDTLS_ERR_NET_RECV_FAILED +#define MP_MBEDTLS_ERR_NET_SEND_FAILED MBEDTLS_ERR_NET_SEND_FAILED +#define MP_MBEDTLS_ERR_NET_CONN_RESET MBEDTLS_ERR_NET_CONN_RESET +#define MP_MBEDTLS_ERR_NET_UNKNOWN_HOST MBEDTLS_ERR_NET_UNKNOWN_HOST +#define MP_MBEDTLS_ERR_NET_BUFFER_TOO_SMALL MBEDTLS_ERR_NET_BUFFER_TOO_SMALL +#define MP_MBEDTLS_ERR_NET_INVALID_CONTEXT MBEDTLS_ERR_NET_INVALID_CONTEXT + +#define MP_ERR_MEM ERR_MEM +#define MP_ERR_BUF ERR_BUF +#define MP_ERR_TIMEOUT ERR_TIMEOUT +#define MP_ERR_RTE ERR_RTE +#define MP_ERR_INPROGRESS ERR_INPROGRESS +#define MP_ERR_VAL ERR_VAL +#define MP_ERR_WOULDBLOCK ERR_WOULDBLOCK +#define MP_ERR_USE ERR_USE + +#define MP_ERR_ALREADY ERR_ALREADY +#define MP_ERR_ISCONN ERR_ISCONN +#define MP_ERR_ABRT ERR_ABRT +#define MP_ERR_RST ERR_RST +#define MP_ERR_CLSD ERR_CLSD +#define MP_ERR_CONN ERR_CONN +#define MP_ERR_ARG ERR_ARG +#define MP_ERR_IF ERR_IF + +#define MP_ESP_ERR_NO_MEM ESP_ERR_NO_MEM /*!< Out of memory */ +#define MP_ESP_ERR_INVALID_ARG ESP_ERR_INVALID_ARG /*!< Invalid argument */ +#define MP_ESP_ERR_INVALID_STATE ESP_ERR_INVALID_STATE /*!< Invalid state */ +#define MP_ESP_ERR_INVALID_SIZE ESP_ERR_INVALID_SIZE /*!< Invalid size */ +#define MP_ESP_ERR_NOT_FOUND ESP_ERR_NOT_FOUND /*!< Requested resource not found */ +#define MP_ESP_ERR_NOT_SUPPORTED ESP_ERR_NOT_SUPPORTED /*!< Operation or feature not supported */ +#define MP_ESP_ERR_TIMEOUT ESP_ERR_TIMEOUT /*!< Operation timed out */ +#define MP_ESP_ERR_INVALID_RESPONSE ESP_ERR_INVALID_RESPONSE /*!< Received response was invalid */ +#define MP_ESP_ERR_INVALID_CRC ESP_ERR_INVALID_CRC /*!< CRC or checksum was invalid */ +#define MP_ESP_ERR_INVALID_VERSION ESP_ERR_INVALID_VERSION /*!< Version was invalid */ +#define MP_ESP_ERR_INVALID_MAC ESP_ERR_INVALID_MAC /*!< MAC address was invalid */ + +#define MP_EAI_NONAME EAI_NONAME +#define MP_EAI_SERVICE EAI_SERVICE +#define MP_EAI_FAIL EAI_FAIL +#define MP_EAI_MEMORY EAI_MEMORY +#define MP_EAI_FAMILY EAI_FAMILY +#define MP_HOST_NOT_FOUND HOST_NOT_FOUND +#define MP_NO_DATA NO_DATA +#define MP_NO_RECOVERY NO_RECOVERY +#define MP_TRY_AGAIN TRY_AGAIN + +#define MP_MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE /* < The requested feature is not available. */ +#define MP_MBEDTLS_ERR_SSL_BAD_INPUT_DATA MBEDTLS_ERR_SSL_BAD_INPUT_DATA /* < Bad input parameters to function. */ +#define MP_MBEDTLS_ERR_SSL_INVALID_MAC MBEDTLS_ERR_SSL_INVALID_MAC /* < Verification of the message MAC failed. */ +#define MP_MBEDTLS_ERR_SSL_INVALID_RECORD MBEDTLS_ERR_SSL_INVALID_RECORD /* < An invalid SSL record was received. */ +#define MP_MBEDTLS_ERR_SSL_CONN_EOF MBEDTLS_ERR_SSL_CONN_EOF /* < The connection indicated an EOF. */ +#define MP_MBEDTLS_ERR_SSL_UNKNOWN_CIPHER MBEDTLS_ERR_SSL_UNKNOWN_CIPHER /* < An unknown cipher was received. */ +#define MP_MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN /* < The server has no ciphersuites in common with the client. */ +#define MP_MBEDTLS_ERR_SSL_NO_RNG MBEDTLS_ERR_SSL_NO_RNG /* < No RNG was provided to the SSL module. */ +#define MP_MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE /* < No client certification received from the client, but required by the authentication mode. */ +#define MP_MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE /* < Our own certificate(s) is/are too large to send in an SSL message. */ +#define MP_MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED /* < The own certificate is not set, but needed by the server. */ +#define MP_MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED /* < The own private key or pre-shared key is not set, but needed. */ +#define MP_MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED /* < No CA Chain is set, but required to operate. */ +#define MP_MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE /* < An unexpected message was received from our peer. */ +#define MP_MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE /* < A fatal alert message was received from our peer. */ +#define MP_MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED /* < Verification of our peer failed. */ +#define MP_MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY /* < The peer notified us that the connection is going to be closed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO /* < Processing of the ClientHello handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO /* < Processing of the ServerHello handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE /* < Processing of the Certificate handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST /* < Processing of the CertificateRequest handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE /* < Processing of the ServerKeyExchange handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE /* < Processing of the ServerHelloDone handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE /* < Processing of the ClientKeyExchange handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP /* < Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS /* < Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY /* < Processing of the CertificateVerify handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC /* < Processing of the ChangeCipherSpec handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_FINISHED MBEDTLS_ERR_SSL_BAD_HS_FINISHED /* < Processing of the Finished handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_ALLOC_FAILED MBEDTLS_ERR_SSL_ALLOC_FAILED /* < Memory allocation failed */ +#define MP_MBEDTLS_ERR_SSL_HW_ACCEL_FAILED MBEDTLS_ERR_SSL_HW_ACCEL_FAILED /* < Hardware acceleration function returned with error */ +#define MP_MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH /* < Hardware acceleration function skipped / left alone data */ +#define MP_MBEDTLS_ERR_SSL_COMPRESSION_FAILED MBEDTLS_ERR_SSL_COMPRESSION_FAILED /* < Processing of the compression / decompression failed */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION /* < Handshake protocol not within min/max boundaries */ +#define MP_MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET /* < Processing of the NewSessionTicket handshake message failed. */ +#define MP_MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED /* < Session ticket has expired. */ +#define MP_MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH /* < Public key type mismatch (eg, asked for RSA key exchange and presented EC key) */ +#define MP_MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY /* < Unknown identity received (eg, PSK identity) */ +#define MP_MBEDTLS_ERR_SSL_INTERNAL_ERROR MBEDTLS_ERR_SSL_INTERNAL_ERROR /* < Internal error (eg, unexpected failure in lower-level module) */ +#define MP_MBEDTLS_ERR_SSL_COUNTER_WRAPPING MBEDTLS_ERR_SSL_COUNTER_WRAPPING /* < A counter would wrap (eg, too many messages exchanged). */ +#define MP_MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO /* < Unexpected message at ServerHello in renegotiation. */ +#define MP_MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED /* < DTLS client must retry for hello verification */ +#define MP_MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL /* < A buffer is too small to receive or write a message */ +#define MP_MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE /* < None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages). */ +#define MP_MBEDTLS_ERR_SSL_WANT_READ MBEDTLS_ERR_SSL_WANT_READ /* < No data of requested type currently available on underlying transport. */ +#define MP_MBEDTLS_ERR_SSL_WANT_WRITE MBEDTLS_ERR_SSL_WANT_WRITE /* < Connection requires a write call. */ +#define MP_MBEDTLS_ERR_SSL_TIMEOUT MBEDTLS_ERR_SSL_TIMEOUT /* < The operation timed out. */ +#define MP_MBEDTLS_ERR_SSL_CLIENT_RECONNECT MBEDTLS_ERR_SSL_CLIENT_RECONNECT /* < The client initiated a reconnect from the same port. */ +#define MP_MBEDTLS_ERR_SSL_UNEXPECTED_RECORD MBEDTLS_ERR_SSL_UNEXPECTED_RECORD /* < Record header looks valid but is not expected. */ +#define MP_MBEDTLS_ERR_SSL_NON_FATAL MBEDTLS_ERR_SSL_NON_FATAL /* < The alert message received indicates a non-fatal error. */ +#define MP_MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH /* < Couldn't set the hash for verifying CertificateVerify */ + +#endif /* ESP32_MP_PYCOM_ERR_H_ */ diff --git a/esp32/mpconfigport.h b/esp32/mpconfigport.h index 5ed95fd22d..13f84e06ca 100644 --- a/esp32/mpconfigport.h +++ b/esp32/mpconfigport.h @@ -40,6 +40,7 @@ #define __INCLUDED_MPCONFIGPORT_H #include +#include "mp_pycom_err.h" // options to control how Micro Python is built #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A) @@ -248,6 +249,130 @@ extern const struct _mp_obj_module_t mp_module_uqueue; #define _assert(expr) ((expr) ? (void)0 : __assert_func(__FILE__, __LINE__, __func__, #expr)) +#define ERRNO_LIST \ + X(EPERM) \ + X(ENOENT) \ + X(EIO) \ + X(EBADF) \ + X(EAGAIN) \ + X(ENOMEM) \ + X(EACCES) \ + X(EEXIST) \ + X(ENODEV) \ + X(EISDIR) \ + X(EINVAL) \ + X(EMSGSIZE) \ + X(EOPNOTSUPP) \ + X(EADDRINUSE) \ + X(ENETDOWN) \ + X(ECONNABORTED) \ + X(ECONNRESET) \ + X(ENOBUFS) \ + X(ENOTCONN) \ + X(ETIMEDOUT) \ + X(ECONNREFUSED) \ + X(EHOSTUNREACH) \ + X(EALREADY) \ + X(EINPROGRESS) \ + X(MBEDTLS_ERR_NET_SOCKET_FAILED) \ + X(MBEDTLS_ERR_NET_CONNECT_FAILED) \ + X(MBEDTLS_ERR_NET_BIND_FAILED) \ + X(MBEDTLS_ERR_NET_LISTEN_FAILED) \ + X(MBEDTLS_ERR_NET_ACCEPT_FAILED) \ + X(MBEDTLS_ERR_NET_RECV_FAILED) \ + X(MBEDTLS_ERR_NET_SEND_FAILED) \ + X(MBEDTLS_ERR_NET_CONN_RESET) \ + X(MBEDTLS_ERR_NET_UNKNOWN_HOST) \ + X(MBEDTLS_ERR_NET_BUFFER_TOO_SMALL) \ + X(MBEDTLS_ERR_NET_INVALID_CONTEXT) \ + X(ERR_MEM) \ + X(ERR_BUF) \ + X(ERR_TIMEOUT) \ + X(ERR_RTE) \ + X(ERR_INPROGRESS) \ + X(ERR_VAL) \ + X(ERR_WOULDBLOCK) \ + X(ERR_USE) \ + X(ERR_ALREADY) \ + X(ERR_ISCONN) \ + X(ERR_ABRT) \ + X(ERR_RST) \ + X(ERR_CLSD) \ + X(ERR_CONN) \ + X(ERR_ARG) \ + X(ERR_IF) \ + X(ESP_ERR_NO_MEM) \ + X(ESP_ERR_INVALID_ARG) \ + X(ESP_ERR_INVALID_STATE) \ + X(ESP_ERR_INVALID_SIZE) \ + X(ESP_ERR_NOT_FOUND) \ + X(ESP_ERR_NOT_SUPPORTED) \ + X(ESP_ERR_TIMEOUT) \ + X(ESP_ERR_INVALID_RESPONSE) \ + X(ESP_ERR_INVALID_CRC) \ + X(ESP_ERR_INVALID_VERSION) \ + X(ESP_ERR_INVALID_MAC) \ + X(EAI_NONAME) \ + X(EAI_SERVICE) \ + X(EAI_FAIL) \ + X(EAI_MEMORY) \ + X(EAI_FAMILY) \ + X(HOST_NOT_FOUND) \ + X(NO_DATA) \ + X(NO_RECOVERY) \ + X(TRY_AGAIN) \ + X(MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) \ + X(MBEDTLS_ERR_SSL_BAD_INPUT_DATA) \ + X(MBEDTLS_ERR_SSL_INVALID_MAC) \ + X(MBEDTLS_ERR_SSL_INVALID_RECORD) \ + X(MBEDTLS_ERR_SSL_CONN_EOF) \ + X(MBEDTLS_ERR_SSL_UNKNOWN_CIPHER) \ + X(MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN) \ + X(MBEDTLS_ERR_SSL_NO_RNG) \ + X(MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE) \ + X(MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE) \ + X(MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED) \ + X(MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED) \ + X(MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED) \ + X(MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE) \ + X(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE) \ + X(MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED) \ + X(MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO) \ + X(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) \ + X(MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) \ + X(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) \ + X(MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) \ + X(MBEDTLS_ERR_SSL_BAD_HS_FINISHED) \ + X(MBEDTLS_ERR_SSL_ALLOC_FAILED) \ + X(MBEDTLS_ERR_SSL_HW_ACCEL_FAILED) \ + X(MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH) \ + X(MBEDTLS_ERR_SSL_COMPRESSION_FAILED) \ + X(MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION) \ + X(MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) \ + X(MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED) \ + X(MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH) \ + X(MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY) \ + X(MBEDTLS_ERR_SSL_INTERNAL_ERROR) \ + X(MBEDTLS_ERR_SSL_COUNTER_WRAPPING) \ + X(MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) \ + X(MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) \ + X(MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) \ + X(MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE) \ + X(MBEDTLS_ERR_SSL_WANT_READ) \ + X(MBEDTLS_ERR_SSL_WANT_WRITE) \ + X(MBEDTLS_ERR_SSL_TIMEOUT) \ + X(MBEDTLS_ERR_SSL_CLIENT_RECONNECT) \ + X(MBEDTLS_ERR_SSL_UNEXPECTED_RECORD) \ + X(MBEDTLS_ERR_SSL_NON_FATAL) \ + X(MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH) \ + #include "mpconfigboard.h" #endif // __INCLUDED_MPCONFIGPORT_H diff --git a/esp32/pycom_version.h b/esp32/pycom_version.h index 8dd9a1ec53..78fc77d669 100644 --- a/esp32/pycom_version.h +++ b/esp32/pycom_version.h @@ -10,7 +10,7 @@ #ifndef VERSION_H_ #define VERSION_H_ -#define SW_VERSION_NUMBER "1.18.2.r1" +#define SW_VERSION_NUMBER "1.18.2.r2" #define LORAWAN_VERSION_NUMBER "1.0.2" diff --git a/esp32/qstrdefsport.h b/esp32/qstrdefsport.h index 89c2fe3f08..e0bb517fd3 100644 --- a/esp32/qstrdefsport.h +++ b/esp32/qstrdefsport.h @@ -12,3 +12,101 @@ Q(/) // entries for sys.path Q(/flash) Q(/flash/lib) +Q(MBEDTLS_ERR_NET_SOCKET_FAILED) +Q(MBEDTLS_ERR_NET_CONNECT_FAILED) +Q(MBEDTLS_ERR_NET_BIND_FAILED) +Q(MBEDTLS_ERR_NET_LISTEN_FAILED) +Q(MBEDTLS_ERR_NET_ACCEPT_FAILED) +Q(MBEDTLS_ERR_NET_RECV_FAILED) +Q(MBEDTLS_ERR_NET_SEND_FAILED) +Q(MBEDTLS_ERR_NET_CONN_RESET) +Q(MBEDTLS_ERR_NET_UNKNOWN_HOST) +Q(MBEDTLS_ERR_NET_BUFFER_TOO_SMALL) +Q(MBEDTLS_ERR_NET_INVALID_CONTEXT) +Q(ERR_MEM) +Q(ERR_BUF) +Q(ERR_TIMEOUT) +Q(ERR_RTE) +Q(ERR_INPROGRESS) +Q(ERR_VAL) +Q(ERR_WOULDBLOCK) +Q(ERR_USE) +Q(ERR_ALREADY) +Q(ERR_ISCONN) +Q(ERR_ABRT) +Q(ERR_RST) +Q(ERR_CLSD) +Q(ERR_CONN) +Q(ERR_ARG) +Q(ERR_IF) +Q(ESP_ERR_NO_MEM) +Q(ESP_ERR_INVALID_ARG) +Q(ESP_ERR_INVALID_STATE) +Q(ESP_ERR_INVALID_SIZE) +Q(ESP_ERR_NOT_FOUND) +Q(ESP_ERR_NOT_SUPPORTED) +Q(ESP_ERR_TIMEOUT) +Q(ESP_ERR_INVALID_RESPONSE) +Q(ESP_ERR_INVALID_CRC) +Q(ESP_ERR_INVALID_VERSION) +Q(ESP_ERR_INVALID_MAC) +Q(EAI_NONAME) +Q(EAI_SERVICE) +Q(EAI_FAIL) +Q(EAI_MEMORY) +Q(EAI_FAMILY) +Q(HOST_NOT_FOUND) +Q(NO_DATA) +Q(NO_RECOVERY) +Q(TRY_AGAIN) +Q(MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) +Q(MBEDTLS_ERR_SSL_BAD_INPUT_DATA) +Q(MBEDTLS_ERR_SSL_INVALID_MAC) +Q(MBEDTLS_ERR_SSL_INVALID_RECORD) +Q(MBEDTLS_ERR_SSL_CONN_EOF) +Q(MBEDTLS_ERR_SSL_UNKNOWN_CIPHER) +Q(MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN) +Q(MBEDTLS_ERR_SSL_NO_RNG) +Q(MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE) +Q(MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE) +Q(MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED) +Q(MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED) +Q(MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED) +Q(MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE) +Q(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE) +Q(MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED) +Q(MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) +Q(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO) +Q(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO) +Q(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE) +Q(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) +Q(MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) +Q(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) +Q(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) +Q(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) +Q(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) +Q(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) +Q(MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) +Q(MBEDTLS_ERR_SSL_BAD_HS_FINISHED) +Q(MBEDTLS_ERR_SSL_ALLOC_FAILED) +Q(MBEDTLS_ERR_SSL_HW_ACCEL_FAILED) +Q(MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH) +Q(MBEDTLS_ERR_SSL_COMPRESSION_FAILED) +Q(MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION) +Q(MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) +Q(MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED) +Q(MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH) +Q(MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY) +Q(MBEDTLS_ERR_SSL_INTERNAL_ERROR) +Q(MBEDTLS_ERR_SSL_COUNTER_WRAPPING) +Q(MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) +Q(MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) +Q(MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) +Q(MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE) +Q(MBEDTLS_ERR_SSL_WANT_READ) +Q(MBEDTLS_ERR_SSL_WANT_WRITE) +Q(MBEDTLS_ERR_SSL_TIMEOUT) +Q(MBEDTLS_ERR_SSL_CLIENT_RECONNECT) +Q(MBEDTLS_ERR_SSL_UNEXPECTED_RECORD) +Q(MBEDTLS_ERR_SSL_NON_FATAL) +Q(MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH) diff --git a/py/moduerrno.c b/py/moduerrno.c index bbc127c586..74f1853180 100644 --- a/py/moduerrno.c +++ b/py/moduerrno.c @@ -34,6 +34,7 @@ // This list could be defined per port in mpconfigport.h to tailor it to a // specific port's needs. But for now we have a common list. +#ifndef ERRNO_LIST #define ERRNO_LIST \ X(EPERM) \ X(ENOENT) \ @@ -60,6 +61,7 @@ X(EALREADY) \ X(EINPROGRESS) \ +#endif STATIC const mp_rom_map_elem_t errorcode_table[] = { #define X(e) { MP_ROM_INT(MP_ ## e), MP_ROM_QSTR(MP_QSTR_## e) }, ERRNO_LIST