Merge pull request esp8266#10 from esp8266/master

Update

Author: Jason2866

boards.txt

@@ -121,9 +121,9 @@ unsigned long HardwareSerial::testBaudrate()
 
 unsigned long HardwareSerial::detectBaudrate(time_t timeoutMillis)
 {
-    time_t startMillis = millis();
+    esp8266::polledTimeout::oneShotFastMs timeOut(timeoutMillis);
     unsigned long detectedBaudrate;
-    while ((time_t) millis() - startMillis < timeoutMillis) {
+    while (!timeOut) {
         if ((detectedBaudrate = testBaudrate())) {
           break;
         }

cores/esp8266/HardwareSerial.cpp

@@ -45,7 +45,7 @@ size_t Print::write(const uint8_t *buffer, size_t size) {
 
     size_t n = 0;
     while (size--) {
-        size_t ret = write(*buffer++);
+        size_t ret = write(pgm_read_byte(buffer++));
         if (ret == 0) {
             // Write of last byte didn't complete, abort additional processing
             break;

cores/esp8266/Print.cpp

@@ -56,7 +56,7 @@ class Print {
         size_t write(const char *str) {
             if(str == NULL)
                 return 0;
-            return write((const uint8_t *) str, strlen(str));
+            return write((const uint8_t *) str, strlen_P(str));
         }
         virtual size_t write(const uint8_t *buffer, size_t size);
         size_t write(const char *buffer, size_t size) {

cores/esp8266/Print.h

@@ -1,5 +1,4 @@
 #include "Updater.h"
-#include "Arduino.h"
 #include "eboot_command.h"
 #include <esp8266_peri.h>
 
@@ -11,10 +10,10 @@
 #endif
 
 #if ARDUINO_SIGNING
-  #include "../../libraries/ESP8266WiFi/src/BearSSLHelpers.h"
-  static BearSSL::PublicKey signPubKey(signing_pubkey);
-  static BearSSL::HashSHA256 hash;
-  static BearSSL::SigningVerifier sign(&signPubKey);
+namespace esp8266 {
+  extern UpdaterHashClass& updaterSigningHash;
+  extern UpdaterVerifyClass& updaterSigningVerifier;
+}
 #endif
 
 extern "C" {
@@ -39,7 +38,7 @@ UpdaterClass::UpdaterClass()
 , _progress_callback(nullptr)
 {
 #if ARDUINO_SIGNING
-  installSignature(&hash, &sign);
+  installSignature(&esp8266::updaterSigningHash, &esp8266::updaterSigningVerifier);
 #endif
 }
 

cores/esp8266/Updater.cpp

@@ -32,7 +32,7 @@ extern "C" void __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
 extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
 
 
-#ifndef __cpp_exceptions
+#if !defined(__cpp_exceptions) && !defined(NEW_OOM_ABORT)
 void *operator new(size_t size)
 {
     void *ret = malloc(size);
@@ -52,7 +52,7 @@ void *operator new[](size_t size)
     }
     return ret;
 }
-#endif
+#endif // arduino's std::new legacy
 
 void __cxa_pure_virtual(void)
 {

cores/esp8266/abi.cpp

@@ -32,6 +32,37 @@
 
 #define WIFI_HAS_EVENT_CALLBACK
 
+#ifdef __cplusplus
+
+#include <stdlib.h> // malloc()
+#include <stddef.h> // size_t
+
+namespace arduino
+{
+    extern "C++"
+    template <typename T, typename ...TConstructorArgs>
+    T* new0 (size_t n, TConstructorArgs... TconstructorArgs)
+    {
+        // n==0: single allocation, otherwise it is an array
+        size_t offset = n? sizeof(size_t): 0;
+        size_t arraysize = n? n: 1;
+        T* ptr = (T*)malloc(offset + (arraysize * sizeof(T)));
+        if (ptr)
+        {
+            if (n)
+                *(size_t*)(ptr) = n;
+            for (size_t i = 0; i < arraysize; i++)
+                new (ptr + offset + i * sizeof(T)) T(TconstructorArgs...);
+            return ptr + offset;
+        }
+        return nullptr;
+    }
+}
+
+#define arduino_new(Type, ...) arduino::new0<Type>(0, ##__VA_ARGS__)
+#define arduino_newarray(Type, n, ...) arduino::new0<Type>(n, ##__VA_ARGS__)
+
+#endif // __cplusplus
 
 #ifndef __STRINGIFY
 #define __STRINGIFY(a) #a
@@ -61,4 +92,4 @@ inline uint32_t esp_get_cycle_count() {
 }
 #endif // not CORE_MOCK
 
-#endif
+#endif // CORE_ESP8266_FEATURES_H

cores/esp8266/core_esp8266_features.h

@@ -495,7 +495,7 @@ uart_write(uart_t* uart, const char* buf, size_t size)
     size_t ret = size;
     const int uart_nr = uart->uart_nr;
     while (size--)
-        uart_do_write_char(uart_nr, *buf++);
+        uart_do_write_char(uart_nr, pgm_read_byte(buf++));
 
     return ret;
 }

cores/esp8266/uart.cpp

@@ -14,7 +14,7 @@ ESP8266_BASE      = $(ARDUINO_BASE)/hardware/esp8266com/esp8266
 ESP8266_TOOLS     = $(ESP8266_BASE)/tools
 XTENSA_TOOLS_ROOT = $(ESP8266_TOOLS)/xtensa-lx106-elf/bin
 
-PYTHON_BIN        = python
+PYTHON_BIN        = python3
 ESPTOOL_PY_BIN    = $(ESP8266_TOOLS)/esptool.py
 ESPOTA_PY_BIN     = $(ESP8266_TOOLS)/espota.py
 ESPTOOL_BIN       = $(ESP8266_TOOLS)/esptool/esptool.exe

doc/eclipse/makefile.init

@@ -43,7 +43,7 @@ Prerequisites
 
 -  Arduino 1.6.8 (or newer, current working version is 1.8.5)
 -  git
--  Python 2.7 (https://python.org)
+-  Python 3.x (https://python.org)
 -  terminal, console, or command prompt (depending on your OS)
 -  Internet connection
 
@@ -110,7 +110,7 @@ Instructions - Windows 10
    .. code:: bash
 
        cd esp8266/tools
-       python get.py
+       python3 get.py
 
 -  Restart Arduino
 
@@ -184,7 +184,7 @@ Instructions - Other OS
    .. code:: bash
 
        cd esp8266/tools
-       python get.py
+       python3 get.py
 
 -  Restart Arduino
 

doc/installing.rst

@@ -193,7 +193,7 @@ Instructions below show configuration of OTA on NodeMCU 1.0 (ESP-12E Module) boa
    -  esp8266/Arduino platform package 2.0.0 or newer - for instructions
       follow
       https://github.com/esp8266/Arduino#installing-with-boards-manager
-   -  Python 2.7 - https://www.python.org/
+   -  Python 3.x - https://www.python.org/
 
       **Note:** Windows users should select “Add python.exe to Path”
       (see below – this option is not selected by default).

doc/ota_updates/readme.rst

@@ -215,3 +215,75 @@ using FPSTR would become...
         String response2;
         response2 += FPSTR(HTTP);
     }
+
+C++
+----
+
+- About C++ exceptions, ``operator new``, and Exceptions menu option
+  
+  The C++ standard says the following about the ``new`` operator behavior when encountering heap shortage (memory full):
+
+  - has to throw a ``std::bad_alloc`` C++ exception when they are enabled
+
+  - will ``abort()`` otherwise
+  
+  There are several reasons for the first point above, among which are:
+
+  - guarantee that the return of new is never a ``nullptr``
+
+  - guarantee full construction of the top level object plus all member subobjects
+
+  - guarantee that any subobjects partially constructed get destroyed, and in the correct order, if oom is encountered midway through construction
+  
+  When C++ exceptions are disabled, or when using ``new(nothrow)``, the above guarantees can't be upheld, so the second point (``abort()``) above is the only ``std::c++`` viable solution.
+  
+  Historically in Arduino environments, ``new`` is overloaded to simply return the equivalent ``malloc()`` which in turn can return ``nullptr``.
+  
+  This behavior is not C++ standard, and there is good reason for that: there are hidden and very bad side effects. The *class and member constructors are always called, even when memory is full* (``this == nullptr``).
+  In addition, the memory allocation for the top object could succeed, but allocation required for some member object could fail, leaving construction in an undefined state.
+  So the historical behavior of Ardudino's ``new``, when faced with insufficient memory, will lead to bad crashes sooner or later, sometimes unexplainable, generally due to memory corruption even when the returned value is checked and managed.
+  Luckily on esp8266, trying to update RAM near address 0 will immediately raise an hardware exception, unlike on other uC like avr on which that memory can be accessible.
+  
+  As of core 2.6.0, there are 3 options: legacy (default) and two clear cases when ``new`` encounters oom:
+  
+  - ``new`` returns ``nullptr``, with possible bad effects or immediate crash when constructors (called anyway) initialize members (exceptions are disabled in this case)
+
+  - C++ exceptions are disabled: ``new`` calls ``abort()`` and will "cleanly" crash, because there is no way to honor memory allocation or to recover gracefully.
+
+  - C++ exceptions are enabled: ``new`` throws a ``std::bad_alloc`` C++ exception, which can be caught and handled gracefully.
+    This assures correct behavior, including handling of all subobjects, which guarantees stability.
+
+  History: `#6269 <https://github.com/esp8266/Arduino/issues/6269>`__ `#6309 <https://github.com/esp8266/Arduino/pull/6309>`__ `#6312 <https://github.com/esp8266/Arduino/pull/6312>`__
+
+- New optional allocator ``arduino_new``
+
+  A new optional global allocator is introduced with a different semantic:
+
+  - never throws exceptions on oom
+
+  - never calls constructors on oom
+
+  - returns nullptr on oom
+
+  It is similar to arduino ``new`` semantic without side effects
+  (except when parent constructors, or member constructors use ``new``).
+
+  Syntax is slightly different, the following shows the different usages:
+
+  .. code:: cpp
+
+      // with new:
+
+      SomeClass* sc = new SomeClass(arg1, arg2, ...);
+      delete sc;
+
+      SomeClass* scs = new SomeClass[42];
+      delete [] scs;
+
+      // with arduino_new:
+
+      SomeClass* sc = arduino_new(SomeClass, arg1, arg2, ...);
+      delete sc;
+
+      SomeClass* scs = arduino_newarray(SomeClass, 42);
+      delete [] scs;

doc/reference.rst

@@ -13,8 +13,8 @@
 #include <ESP8266HTTPClient.h>
 
 #include <WiFiClientSecureBearSSL.h>
-// Fingerprint for demo URL, expires on June 2, 2019, needs to be updated well before this date
-const uint8_t fingerprint[20] = {0x5A, 0xCF, 0xFE, 0xF0, 0xF1, 0xA6, 0xF4, 0x5F, 0xD2, 0x11, 0x11, 0xC6, 0x1D, 0x2F, 0x0E, 0xBC, 0x39, 0x8D, 0x50, 0xE0};
+// Fingerprint for demo URL, expires on June 2, 2021, needs to be updated well before this date
+const uint8_t fingerprint[20] = {0x40, 0xaf, 0x00, 0x6b, 0xec, 0x90, 0x22, 0x41, 0x8e, 0xa3, 0xad, 0xfa, 0x1a, 0xe8, 0x25, 0x41, 0x1d, 0x1a, 0x54, 0xb3};
 
 ESP8266WiFiMulti WiFiMulti;
 

libraries/ESP8266HTTPClient/examples/BasicHttpsClient/BasicHttpsClient.ino

@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 # This script pulls the list of Mozilla trusted certificate authorities
 # from the web at the "mozurl" below, parses the file to grab the PEM
@@ -7,16 +7,18 @@
 # and use them for your outgoing SSL connections.
 #
 # Script by Earle F. Philhower, III.  Released to the public domain.
-
+from __future__ import print_function
 import csv
 import os
+import sys
 from subprocess import Popen, PIPE, call
-import urllib2
 try:
-    # for Python 2.x
+    from urllib.request import urlopen
+except:
+    from urllib2 import urlopen
+try:
     from StringIO import StringIO
-except ImportError:
-    # for Python 3.x
+except:
     from io import StringIO
 
 # Mozilla's URL for the CSV file with included PEM certs
@@ -25,9 +27,12 @@
 # Load the manes[] and pems[] array from the URL
 names = []
 pems = []
-response = urllib2.urlopen(mozurl)
+response = urlopen(mozurl)
 csvData = response.read()
-csvReader = csv.reader(StringIO(csvData))
+if sys.version_info[0] > 2:
+    csvData = csvData.decode('utf-8')
+csvFile = StringIO(csvData)
+csvReader = csv.reader(csvFile)
 for row in csvReader:
     names.append(row[0]+":"+row[1]+":"+row[2])
     pems.append(row[30])
@@ -46,10 +51,10 @@
 for i in range(0, len(pems)):
     certName = "data/ca_%03d.der" % (idx);
     thisPem = pems[i].replace("'", "")
-    print names[i] + " -> " + certName
+    print(names[i] + " -> " + certName)
     ssl = Popen(['openssl','x509','-inform','PEM','-outform','DER','-out', certName], shell = False, stdin = PIPE)
     pipe = ssl.stdin
-    pipe.write(thisPem)
+    pipe.write(thisPem.encode('utf-8'))
     pipe.close()
     ssl.wait()
     if os.path.exists(certName):