Release candidate for mbed-os-5.5.2

CONTRIBUTING.md

@@ -5,7 +5,7 @@ All changes in code base should originate from GitHub Issues and take advantage
 Guidelines from this document are created to help new and existing contributors understand process workflow and align to project rules before pull request is submitted. It explains how a participant should do things like format code, test fixes, and submit patches.
 
 ## Where to get more information?
-You can read more on our [documentation page](https://docs.mbed.com/).
+You can read more on our [documentation page](https://docs.mbed.com/docs/mbed-os-handbook/en/latest/cont/contributing/).
 
 # How to contribute
 We really appreciate your contributions! We are Open Source project and we need your help. We want to keep it as easy as possible to contribute changes that get things working in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.

TESTS/mbedtls/multi/main.cpp

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2013-2016, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <stdio.h>
+#include <string.h>
+#include "mbed.h"
+#include "greentea-client/test_env.h"
+#include "unity/unity.h"
+#include "utest/utest.h"
+
+#include "mbedtls/sha256.h"
+
+
+using namespace utest::v1;
+
+#if defined(MBEDTLS_SHA256_C)
+/* Tests several call to mbedtls_sha256_update function that are not modulo 64 bytes */
+void test_case_sha256_split() {
+  const unsigned char test_buf[] = {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"};
+  // sha256_output_values for 3*abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+  const unsigned char test_sum[] =
+  { 0x50, 0xEA, 0x82, 0x5D, 0x96, 0x84, 0xF4, 0x22,
+    0x9C, 0xA2, 0x9F, 0x1F, 0xEC, 0x51, 0x15, 0x93,
+    0xE2, 0x81, 0xE4, 0x6A, 0x14, 0x0D, 0x81, 0xE0,
+    0x00, 0x5F, 0x8F, 0x68, 0x86, 0x69, 0xA0, 0x6C};
+  unsigned char outsum[32];
+  int i;
+
+  mbedtls_sha256_context ctx;
+  printf("test sha256\n");
+  mbedtls_sha256_init( &ctx );
+  mbedtls_sha256_starts( &ctx, 0);
+  #if 0
+    printf("test not splitted\n");
+    mbedtls_sha256_update( &ctx, test_buf, 168 );
+  #else
+    printf("test splitted into 3 pieces\n");
+    mbedtls_sha256_update( &ctx, test_buf, 2 );
+    mbedtls_sha256_update( &ctx, test_buf+2, 66 );
+    mbedtls_sha256_update( &ctx, test_buf+68, 100 );
+  #endif
+
+    mbedtls_sha256_finish( &ctx, outsum );
+    mbedtls_sha256_free( &ctx );
+
+    printf("\nreceived result : ");
+    for (i=0;i<32;i++) { printf("%02X",outsum[i]);}
+    printf("\nawaited result  : 50EA825D9684F4229CA29F1FEC511593E281E46A140D81E0005F8F688669A06C\n"); // for  abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+
+    printf("\nend of test sha256\n");
+  TEST_ASSERT_EQUAL_UINT8_ARRAY(outsum, test_sum,32);
+}
+
+/* Tests that treating 2 sha256 objects in // does not impact the result */
+void test_case_sha256_multi() {
+    const unsigned char test_buf[] = {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"};
+    const unsigned char test_buf2[] = {"abcdefghijklmnopqrstuvwxyz012345678901234567890123456789"};
+
+    // sha256_output_values for abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+    const unsigned char test_sum1[] =
+    { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
+      0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
+      0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
+      0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 };
+    // sha256_output_values for 3*abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+    const unsigned char test_sum2[] =
+    { 0x50, 0xEA, 0x82, 0x5D, 0x96, 0x84, 0xF4, 0x22,
+      0x9C, 0xA2, 0x9F, 0x1F, 0xEC, 0x51, 0x15, 0x93,
+      0xE2, 0x81, 0xE4, 0x6A, 0x14, 0x0D, 0x81, 0xE0,
+      0x00, 0x5F, 0x8F, 0x68, 0x86, 0x69, 0xA0, 0x6C};
+    // sha256_output_values for abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdefghijklmnopqrstuvwxyz012345678901234567890123456789
+    const unsigned char test_sum3[] =
+    { 0x6D, 0x5D, 0xDB, 0x5F, 0x4A, 0x94, 0xAB, 0x7E,
+      0x5C, 0xF7, 0x9A, 0xD8, 0x3F, 0x58, 0xD3, 0x97,
+      0xFE, 0x79, 0xFB, 0x0D, 0x79, 0xB2, 0x0D, 0x22,
+      0xFF, 0x95, 0x9F, 0x04, 0xA2, 0xE4, 0x6C, 0x68};
+    unsigned char outsum1[32], outsum2[32], outsum3[32];
+    int i;
+
+    mbedtls_sha256_context ctx1;
+    mbedtls_sha256_context ctx2;
+    mbedtls_sha256_context ctx3;
+    printf("test sha256_multi\n");
+    //Init both contexts
+    mbedtls_sha256_init( &ctx1);
+    mbedtls_sha256_init( &ctx2);
+    mbedtls_sha256_init( &ctx3);
+    //Start both contexts
+    mbedtls_sha256_starts( &ctx1, 0);
+    mbedtls_sha256_starts( &ctx2, 0);
+
+    printf("upd ctx1\n");
+    mbedtls_sha256_update( &ctx1, test_buf, 56 );
+    printf("upd ctx2\n");
+    mbedtls_sha256_update( &ctx2, test_buf, 66 );
+    printf("finish ctx1\n");
+    mbedtls_sha256_finish( &ctx1, outsum1 );
+    printf("upd ctx2\n");
+    mbedtls_sha256_update( &ctx2, test_buf+66, 46 );
+    printf("clone ctx2 in ctx3\n");
+    mbedtls_sha256_clone(&ctx3, (const mbedtls_sha256_context *)&ctx2);
+    printf("free ctx1\n");
+    mbedtls_sha256_free( &ctx1 );
+    printf("upd ctx2\n");
+    mbedtls_sha256_update( &ctx2, test_buf+112, 56 );
+    printf("upd ctx3 with different values than ctx2\n");
+    mbedtls_sha256_update( &ctx3, test_buf2, 56 );
+    printf("finish ctx2\n");
+    mbedtls_sha256_finish( &ctx2, outsum2 );
+    printf("finish ctx3\n");
+    mbedtls_sha256_finish( &ctx3, outsum3 );
+    printf("free ctx2\n");
+    mbedtls_sha256_free( &ctx2 );
+    printf("free ctx3\n");
+    mbedtls_sha256_free( &ctx3 );
+
+    printf("\nreceived result ctx1 : ");
+    for (i=0;i<32;i++) { printf("%02X",outsum1[i]);}
+    printf("\nawaited result       : 248D6A61D20638B8E5C026930C3E6039A33CE45964FF216F6ECEDD19DB06C1\n"); // for  abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+    printf("\nreceived result ctx2 : ");
+    for (i=0;i<32;i++) { printf("%02X",outsum2[i]);}
+    printf("\nawaited result       : 50EA825D9684F4229CA29F1FEC511593E281E46A140D81E0005F8F688669A06C\n"); // for  3*abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq
+    printf("\nreceived result ctx3 : ");
+    for (i=0;i<32;i++) { printf("%02X",outsum3[i]);}
+    printf("\nawaited result       : 6D5DDB5F4A94AB7E5CF79AD83F58D397FE79FB0D79B20D22FF959F04A2E46C68\n"); // for 2*abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq+3*0123456789
+    printf("\nend of test sha256\n");
+    TEST_ASSERT_EQUAL_UINT8_ARRAY(outsum1, test_sum1,32);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY(outsum2, test_sum2,32);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY(outsum3, test_sum3,32);
+}
+#endif //MBEDTLS_SHA256_C
+
+utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
+    greentea_case_failure_abort_handler(source, reason);
+    return STATUS_CONTINUE;
+}
+
+Case cases[] = {
+#if defined(MBEDTLS_SHA256_C)
+    Case("Crypto: sha256_split", test_case_sha256_split, greentea_failure_handler),
+    Case("Crypto: sha256_multi", test_case_sha256_multi, greentea_failure_handler),
+#endif
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(10, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main() {
+    Harness::run(specification);
+}

cmsis/TOOLCHAIN_IAR/cmain.S

@@ -46,6 +46,7 @@
         EXTERN  exit
         EXTERN  __iar_dynamic_initialization
         EXTERN mbed_sdk_init
+        EXTERN mbed_main
         EXTERN SystemInit
 
         THUMB
@@ -87,6 +88,10 @@ _call_main:
           FUNCALL __cmain, __iar_argc_argv
         BL      __iar_argc_argv   ; Maybe setup command line
 
+        MOVS    r0,#0             ;  No parameters  
+          FUNCALL __cmain, mbed_main
+        BL      mbed_main
+
           FUNCALL __cmain, main
         BL      main
 _main:

drivers/BusIn.h

@@ -19,6 +19,7 @@
 #include "platform/platform.h"
 #include "drivers/DigitalIn.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
@@ -28,7 +29,7 @@ namespace mbed {
  * @note Synchronization level: Thread safe
  * @ingroup drivers
  */
-class BusIn {
+class BusIn : private NonCopyable<BusIn> {
 
 public:
     /* Group: Configuration Methods */
@@ -115,12 +116,9 @@ class BusIn {
 
     PlatformMutex _mutex;
 
-    /* disallow copy constructor and assignment operators */
 private:
     virtual void lock();
     virtual void unlock();
-    BusIn(const BusIn&);
-    BusIn & operator = (const BusIn&);
 };
 
 } // namespace mbed

drivers/BusInOut.h

@@ -18,6 +18,7 @@
 
 #include "drivers/DigitalInOut.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
@@ -27,7 +28,7 @@ namespace mbed {
  * @note Synchronization level: Thread safe
  * @ingroup drivers
  */
-class BusInOut {
+class BusInOut : private NonCopyable<BusInOut> {
 
 public:
 
@@ -135,11 +136,6 @@ class BusInOut {
     int _nc_mask;
 
     PlatformMutex _mutex;
-
-    /* disallow copy constructor and assignment operators */
-private:
-    BusInOut(const BusInOut&);
-    BusInOut & operator = (const BusInOut&);
 };
 
 } // namespace mbed

drivers/BusOut.h

@@ -18,14 +18,15 @@
 
 #include "drivers/DigitalOut.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
 
 /** A digital output bus, used for setting the state of a collection of pins
  * @ingroup drivers
  */
-class BusOut {
+class BusOut : private NonCopyable<BusOut> {
 
 public:
 
@@ -119,11 +120,6 @@ class BusOut {
     int _nc_mask;
 
     PlatformMutex _mutex;
-
-   /* disallow copy constructor and assignment operators */
-private:
-    BusOut(const BusOut&);
-    BusOut & operator = (const BusOut&);
 };
 
 } // namespace mbed

drivers/CAN.h

@@ -23,6 +23,7 @@
 #include "hal/can_api.h"
 #include "platform/Callback.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
@@ -78,7 +79,7 @@ class CANMessage : public CAN_Message {
 /** A can bus client, used for communicating with can devices
  * @ingroup drivers
  */
-class CAN {
+class CAN : private NonCopyable<CAN> {
 
 public:
     /** Creates an CAN interface connected to specific pins.

drivers/Ethernet.h

@@ -17,6 +17,7 @@
 #define MBED_ETHERNET_H
 
 #include "platform/platform.h"
+#include "platform/NonCopyable.h"
 
 #if defined (DEVICE_ETHERNET) || defined(DOXYGEN_ONLY)
 
@@ -54,7 +55,7 @@ namespace mbed {
  * @endcode
  * @ingroup drivers
  */
-class Ethernet {
+class Ethernet : private NonCopyable<Ethernet> {
 
 public:
 

drivers/FlashIAP.h

@@ -27,6 +27,7 @@
 #include "flash_api.h"
 #include "platform/SingletonPtr.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 
@@ -37,7 +38,7 @@ namespace mbed {
  * @note Synchronization level: Thread safe
  * @ingroup drivers
  */
-class FlashIAP {
+class FlashIAP : private NonCopyable<FlashIAP> {
 public:
     FlashIAP();
     ~FlashIAP();

drivers/I2C.h

@@ -23,6 +23,7 @@
 #include "hal/i2c_api.h"
 #include "platform/SingletonPtr.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 
 #if DEVICE_I2C_ASYNCH
 #include "platform/CThunk.h"
@@ -53,7 +54,7 @@ namespace mbed {
  * @endcode
  * @ingroup drivers
  */
-class I2C {
+class I2C : private NonCopyable<I2C> {
 
 public:
     enum RxStatus {

drivers/InterruptIn.h

@@ -25,6 +25,7 @@
 #include "platform/Callback.h"
 #include "platform/mbed_critical.h"
 #include "platform/mbed_toolchain.h"
+#include "platform/NonCopyable.h"
 
 namespace mbed {
 /** \addtogroup drivers */
@@ -56,7 +57,7 @@ namespace mbed {
  * @endcode
  * @ingroup drivers
  */
-class InterruptIn {
+class InterruptIn : private NonCopyable<InterruptIn> {
 
 public:
 

drivers/InterruptManager.h

@@ -19,6 +19,7 @@
 #include "cmsis.h"
 #include "platform/CallChain.h"
 #include "platform/PlatformMutex.h"
+#include "platform/NonCopyable.h"
 #include <string.h>
 
 namespace mbed {
@@ -53,7 +54,7 @@ namespace mbed {
  * @endcode
  * @ingroup drivers
  */
-class InterruptManager {
+class InterruptManager : private NonCopyable<InterruptManager> {
 public:
     /** Get the instance of InterruptManager Class
      *
@@ -138,12 +139,6 @@ class InterruptManager {
     void lock();
     void unlock();
 
-    // We declare the copy contructor and the assignment operator, but we don't
-    // implement them. This way, if someone tries to copy/assign our instance,
-    // he will get an error at compile time.
-    InterruptManager(const InterruptManager&);
-    InterruptManager& operator =(const InterruptManager&);
-
     template<typename T>
     pFunctionPointer_t add_common(T *tptr, void (T::*mptr)(void), IRQn_Type irq, bool front=false) {
         _mutex.lock();