Sync src with amalgamated versions

Now src contains exactly what's embedded in mongoose.c and .h, nothing more.

Added `tools/amalgam.sh` to aamlgamate both files at once.

There are no functional changes to mongoose.c, .h in this PR, only slight filename changes.

LICENSE

-Copyright (c) 2004-2013 Sergey Lyubka <valenok@gmail.com>
-Copyright (c) 2013-2018 Cesanta Software Limited
+Copyright (c) 2004-2013 Sergey Lyubka
+Copyright (c) 2013-2020 Cesanta Software Limited
 All rights reserved
 
 This software is dual-licensed: you can redistribute it and/or modify

src/CPPLINT.cfg

-exclude_files=sha1\.c

src/common/cs_base64.c

+
+#ifndef EXCLUDE_COMMON
+
+#include "common/cs_base64.h"
+
+#include <string.h>
+
+#include "common/cs_dbg.h"
+
+/* ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ */
+
+#define NUM_UPPERCASES ('Z' - 'A' + 1)
+#define NUM_LETTERS (NUM_UPPERCASES * 2)
+#define NUM_DIGITS ('9' - '0' + 1)
+
+/*
+ * Emit a base64 code char.
+ *
+ * Doesn't use memory, thus it's safe to use to safely dump memory in crashdumps
+ */
+static void cs_base64_emit_code(struct cs_base64_ctx *ctx, int v) {
+  if (v < NUM_UPPERCASES) {
+    ctx->b64_putc(v + 'A', ctx->user_data);
+  } else if (v < (NUM_LETTERS)) {
+    ctx->b64_putc(v - NUM_UPPERCASES + 'a', ctx->user_data);
+  } else if (v < (NUM_LETTERS + NUM_DIGITS)) {
+    ctx->b64_putc(v - NUM_LETTERS + '0', ctx->user_data);
+  } else {
+    ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/',
+                  ctx->user_data);
+  }
+}
+
+static void cs_base64_emit_chunk(struct cs_base64_ctx *ctx) {
+  int a, b, c;
+
+  a = ctx->chunk[0];
+  b = ctx->chunk[1];
+  c = ctx->chunk[2];
+
+  cs_base64_emit_code(ctx, a >> 2);
+  cs_base64_emit_code(ctx, ((a & 3) << 4) | (b >> 4));
+  if (ctx->chunk_size > 1) {
+    cs_base64_emit_code(ctx, (b & 15) << 2 | (c >> 6));
+  }
+  if (ctx->chunk_size > 2) {
+    cs_base64_emit_code(ctx, c & 63);
+  }
+}
+
+void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t b64_putc,
+                    void *user_data) {
+  ctx->chunk_size = 0;
+  ctx->b64_putc = b64_putc;
+  ctx->user_data = user_data;
+}
+
+void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len) {
+  const unsigned char *src = (const unsigned char *) str;
+  size_t i;
+  for (i = 0; i < len; i++) {
+    ctx->chunk[ctx->chunk_size++] = src[i];
+    if (ctx->chunk_size == 3) {
+      cs_base64_emit_chunk(ctx);
+      ctx->chunk_size = 0;
+    }
+  }
+}
+
+void cs_base64_finish(struct cs_base64_ctx *ctx) {
+  if (ctx->chunk_size > 0) {
+    int i;
+    memset(&ctx->chunk[ctx->chunk_size], 0, 3 - ctx->chunk_size);
+    cs_base64_emit_chunk(ctx);
+    for (i = 0; i < (3 - ctx->chunk_size); i++) {
+      ctx->b64_putc('=', ctx->user_data);
+    }
+  }
+}
+
+#define BASE64_ENCODE_BODY                                                \
+  static const char *b64 =                                                \
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; \
+  int i, j, a, b, c;                                                      \
+                                                                          \
+  for (i = j = 0; i < src_len; i += 3) {                                  \
+    a = src[i];                                                           \
+    b = i + 1 >= src_len ? 0 : src[i + 1];                                \
+    c = i + 2 >= src_len ? 0 : src[i + 2];                                \
+                                                                          \
+    BASE64_OUT(b64[a >> 2]);                                              \
+    BASE64_OUT(b64[((a & 3) << 4) | (b >> 4)]);                           \
+    if (i + 1 < src_len) {                                                \
+      BASE64_OUT(b64[(b & 15) << 2 | (c >> 6)]);                          \
+    }                                                                     \
+    if (i + 2 < src_len) {                                                \
+      BASE64_OUT(b64[c & 63]);                                            \
+    }                                                                     \
+  }                                                                       \
+                                                                          \
+  while (j % 4 != 0) {                                                    \
+    BASE64_OUT('=');                                                      \
+  }                                                                       \
+  BASE64_FLUSH()
+
+#define BASE64_OUT(ch) \
+  do {                 \
+    dst[j++] = (ch);   \
+  } while (0)
+
+#define BASE64_FLUSH() \
+  do {                 \
+    dst[j++] = '\0';   \
+  } while (0)
+
+void cs_base64_encode(const unsigned char *src, int src_len, char *dst) {
+  BASE64_ENCODE_BODY;
+}
+
+#undef BASE64_OUT
+#undef BASE64_FLUSH
+
+#if CS_ENABLE_STDIO
+#define BASE64_OUT(ch)      \
+  do {                      \
+    fprintf(f, "%c", (ch)); \
+    j++;                    \
+  } while (0)
+
+#define BASE64_FLUSH()
+
+void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len) {
+  BASE64_ENCODE_BODY;
+}
+
+#undef BASE64_OUT
+#undef BASE64_FLUSH
+#endif /* CS_ENABLE_STDIO */
+
+/* Convert one byte of encoded base64 input stream to 6-bit chunk */
+static unsigned char from_b64(unsigned char ch) {
+  /* Inverse lookup map */
+  static const unsigned char tab[128] = {
+      255, 255, 255, 255,
+      255, 255, 255, 255, /*  0 */
+      255, 255, 255, 255,
+      255, 255, 255, 255, /*  8 */
+      255, 255, 255, 255,
+      255, 255, 255, 255, /*  16 */
+      255, 255, 255, 255,
+      255, 255, 255, 255, /*  24 */
+      255, 255, 255, 255,
+      255, 255, 255, 255, /*  32 */
+      255, 255, 255, 62,
+      255, 255, 255, 63, /*  40 */
+      52,  53,  54,  55,
+      56,  57,  58,  59, /*  48 */
+      60,  61,  255, 255,
+      255, 200, 255, 255, /*  56   '=' is 200, on index 61 */
+      255, 0,   1,   2,
+      3,   4,   5,   6, /*  64 */
+      7,   8,   9,   10,
+      11,  12,  13,  14, /*  72 */
+      15,  16,  17,  18,
+      19,  20,  21,  22, /*  80 */
+      23,  24,  25,  255,
+      255, 255, 255, 255, /*  88 */
+      255, 26,  27,  28,
+      29,  30,  31,  32, /*  96 */
+      33,  34,  35,  36,
+      37,  38,  39,  40, /*  104 */
+      41,  42,  43,  44,
+      45,  46,  47,  48, /*  112 */
+      49,  50,  51,  255,
+      255, 255, 255, 255, /*  120 */
+  };
+  return tab[ch & 127];
+}
+
+int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len) {
+  unsigned char a, b, c, d;
+  int orig_len = len;
+  char *orig_dst = dst;
+  while (len >= 4 && (a = from_b64(s[0])) != 255 &&
+         (b = from_b64(s[1])) != 255 && (c = from_b64(s[2])) != 255 &&
+         (d = from_b64(s[3])) != 255) {
+    s += 4;
+    len -= 4;
+    if (a == 200 || b == 200) break; /* '=' can't be there */
+    *dst++ = a << 2 | b >> 4;
+    if (c == 200) break;
+    *dst++ = b << 4 | c >> 2;
+    if (d == 200) break;
+    *dst++ = c << 6 | d;
+  }
+  *dst = 0;
+  if (dec_len != NULL) *dec_len = (dst - orig_dst);
+  return orig_len - len;
+}
+
+#endif /* EXCLUDE_COMMON */

src/common/cs_base64.h

+
+#ifndef CS_COMMON_CS_BASE64_H_
+#define CS_COMMON_CS_BASE64_H_
+
+#ifndef DISABLE_BASE64
+#define DISABLE_BASE64 0
+#endif
+
+#if !DISABLE_BASE64
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*cs_base64_putc_t)(char, void *);
+
+struct cs_base64_ctx {
+  /* cannot call it putc because it's a macro on some environments */
+  cs_base64_putc_t b64_putc;
+  unsigned char chunk[3];
+  int chunk_size;
+  void *user_data;
+};
+
+void cs_base64_init(struct cs_base64_ctx *ctx, cs_base64_putc_t putc,
+                    void *user_data);
+void cs_base64_update(struct cs_base64_ctx *ctx, const char *str, size_t len);
+void cs_base64_finish(struct cs_base64_ctx *ctx);
+
+void cs_base64_encode(const unsigned char *src, int src_len, char *dst);
+void cs_fprint_base64(FILE *f, const unsigned char *src, int src_len);
+
+/*
+ * Decodes a base64 string `s` length `len` into `dst`.
+ * `dst` must have enough space to hold the result.
+ * `*dec_len` will contain the resulting length of the string in `dst`
+ * while return value will return number of processed bytes in `src`.
+ * Return value == len indicates successful processing of all the data.
+ */
+int cs_base64_decode(const unsigned char *s, int len, char *dst, int *dec_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DISABLE_BASE64 */
+
+#endif /* CS_COMMON_CS_BASE64_H_ */

src/common/cs_dbg.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 "common/cs_dbg.h"
 

src/common/cs_dbg.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
 
 #ifndef CS_COMMON_CS_DBG_H_
 #define CS_COMMON_CS_DBG_H_

src/common/cs_dirent.c

+
+#ifndef EXCLUDE_COMMON
+
+#include "common/mg_mem.h"
+#include "common/cs_dirent.h"
+
+/*
+ * This file contains POSIX opendir/closedir/readdir API implementation
+ * for systems which do not natively support it (e.g. Windows).
+ */
+
+#ifdef _WIN32
+struct win32_dir {
+  DIR d;
+  HANDLE handle;
+  WIN32_FIND_DATAW info;
+  struct dirent result;
+};
+
+DIR *opendir(const char *name) {
+  struct win32_dir *dir = NULL;
+  wchar_t wpath[MAX_PATH];
+  DWORD attrs;
+
+  if (name == NULL) {
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  } else if ((dir = (struct win32_dir *) MG_MALLOC(sizeof(*dir))) == NULL) {
+    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+  } else {
+    to_wchar(name, wpath, ARRAY_SIZE(wpath));
+    attrs = GetFileAttributesW(wpath);
+    if (attrs != 0xFFFFFFFF && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
+      (void) wcscat(wpath, L"\\*");
+      dir->handle = FindFirstFileW(wpath, &dir->info);
+      dir->result.d_name[0] = '\0';
+    } else {
+      MG_FREE(dir);
+      dir = NULL;
+    }
+  }
+
+  return (DIR *) dir;
+}
+
+int closedir(DIR *d) {
+  struct win32_dir *dir = (struct win32_dir *) d;
+  int result = 0;
+
+  if (dir != NULL) {
+    if (dir->handle != INVALID_HANDLE_VALUE)
+      result = FindClose(dir->handle) ? 0 : -1;
+    MG_FREE(dir);
+  } else {
+    result = -1;
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  }
+
+  return result;
+}
+
+struct dirent *readdir(DIR *d) {
+  struct win32_dir *dir = (struct win32_dir *) d;
+  struct dirent *result = NULL;
+
+  if (dir) {
+    memset(&dir->result, 0, sizeof(dir->result));
+    if (dir->handle != INVALID_HANDLE_VALUE) {
+      result = &dir->result;
+      (void) WideCharToMultiByte(CP_UTF8, 0, dir->info.cFileName, -1,
+                                 result->d_name, sizeof(result->d_name), NULL,
+                                 NULL);
+
+      if (!FindNextFileW(dir->handle, &dir->info)) {
+        (void) FindClose(dir->handle);
+        dir->handle = INVALID_HANDLE_VALUE;
+      }
+
+    } else {
+      SetLastError(ERROR_FILE_NOT_FOUND);
+    }
+  } else {
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  }
+
+  return result;
+}
+#endif
+
+#endif /* EXCLUDE_COMMON */
+
+/* ISO C requires a translation unit to contain at least one declaration */
+typedef int cs_dirent_dummy;

src/common/cs_dirent.h

+
+#ifndef CS_COMMON_CS_DIRENT_H_
+#define CS_COMMON_CS_DIRENT_H_
+
+#include <limits.h>
+
+#include "common/platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifdef CS_DEFINE_DIRENT
+typedef struct { int dummy; } DIR;
+
+struct dirent {
+  int d_ino;
+#ifdef _WIN32
+  char d_name[MAX_PATH];
+#else
+  /* TODO(rojer): Use PATH_MAX but make sure it's sane on every platform */
+  char d_name[256];
+#endif
+};
+
+DIR *opendir(const char *dir_name);
+int closedir(DIR *dir);
+struct dirent *readdir(DIR *dir);
+#endif /* CS_DEFINE_DIRENT */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CS_COMMON_CS_DIRENT_H_ */

src/common/cs_endian.h

+
+#ifndef CS_COMMON_CS_ENDIAN_H_
+#define CS_COMMON_CS_ENDIAN_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * clang with std=-c99 uses __LITTLE_ENDIAN, by default
+ * while for ex, RTOS gcc - LITTLE_ENDIAN, by default
+ * it depends on __USE_BSD, but let's have everything
+ */
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#define BYTE_ORDER __BYTE_ORDER
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif /* LITTLE_ENDIAN */
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN __LITTLE_ENDIAN
+#endif /* BIG_ENDIAN */
+#endif /* BYTE_ORDER */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CS_COMMON_CS_ENDIAN_H_ */

src/common/cs_md5.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
 
 #ifndef CS_COMMON_MD5_H_
 #define CS_COMMON_MD5_H_

src/common/cs_sha1.c

+/* Copyright(c) By Steve Reid <steve@edmweb.com> */
+/* 100% Public Domain */
+
+#include "common/cs_sha1.h"
+
+#if !CS_DISABLE_SHA1 && !defined(EXCLUDE_COMMON)
+
+#include "common/cs_endian.h"
+
+#define SHA1HANDSOFF
+#if defined(__sun)
+#include "common/solarisfixes.h"
+#endif
+
+union char64long16 {
+  unsigned char c[64];
+  uint32_t l[16];
+};
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+static uint32_t blk0(union char64long16 *block, int i) {
+/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
+#if BYTE_ORDER == LITTLE_ENDIAN
+  block->l[i] =
+      (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
+#endif
+  return block->l[i];
+}
+
+/* Avoid redefine warning (ARM /usr/include/sys/ucontext.h define R0~R4) */
+#undef blk
+#undef R0
+#undef R1
+#undef R2
+#undef R3
+#undef R4
+
+#define blk(i)                                                               \
+  (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
+                              block->l[(i + 2) & 15] ^ block->l[i & 15],     \
+                          1))
+#define R0(v, w, x, y, z, i)                                          \
+  z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \
+  w = rol(w, 30);
+#define R1(v, w, x, y, z, i)                                  \
+  z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
+  w = rol(w, 30);
+#define R2(v, w, x, y, z, i)                          \
+  z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
+  w = rol(w, 30);
+#define R3(v, w, x, y, z, i)                                        \
+  z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
+  w = rol(w, 30);
+#define R4(v, w, x, y, z, i)                          \
+  z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
+  w = rol(w, 30);
+
+void cs_sha1_transform(uint32_t state[5], const unsigned char buffer[64]) {
+  uint32_t a, b, c, d, e;
+  union char64long16 block[1];
+
+  memcpy(block, buffer, 64);
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  R0(a, b, c, d, e, 0);
+  R0(e, a, b, c, d, 1);
+  R0(d, e, a, b, c, 2);
+  R0(c, d, e, a, b, 3);
+  R0(b, c, d, e, a, 4);
+  R0(a, b, c, d, e, 5);
+  R0(e, a, b, c, d, 6);
+  R0(d, e, a, b, c, 7);
+  R0(c, d, e, a, b, 8);
+  R0(b, c, d, e, a, 9);
+  R0(a, b, c, d, e, 10);
+  R0(e, a, b, c, d, 11);
+  R0(d, e, a, b, c, 12);
+  R0(c, d, e, a, b, 13);
+  R0(b, c, d, e, a, 14);
+  R0(a, b, c, d, e, 15);
+  R1(e, a, b, c, d, 16);
+  R1(d, e, a, b, c, 17);
+  R1(c, d, e, a, b, 18);
+  R1(b, c, d, e, a, 19);
+  R2(a, b, c, d, e, 20);
+  R2(e, a, b, c, d, 21);
+  R2(d, e, a, b, c, 22);
+  R2(c, d, e, a, b, 23);
+  R2(b, c, d, e, a, 24);
+  R2(a, b, c, d, e, 25);
+  R2(e, a, b, c, d, 26);
+  R2(d, e, a, b, c, 27);
+  R2(c, d, e, a, b, 28);
+  R2(b, c, d, e, a, 29);
+  R2(a, b, c, d, e, 30);
+  R2(e, a, b, c, d, 31);
+  R2(d, e, a, b, c, 32);
+  R2(c, d, e, a, b, 33);
+  R2(b, c, d, e, a, 34);
+  R2(a, b, c, d, e, 35);
+  R2(e, a, b, c, d, 36);
+  R2(d, e, a, b, c, 37);
+  R2(c, d, e, a, b, 38);
+  R2(b, c, d, e, a, 39);
+  R3(a, b, c, d, e, 40);
+  R3(e, a, b, c, d, 41);
+  R3(d, e, a, b, c, 42);
+  R3(c, d, e, a, b, 43);
+  R3(b, c, d, e, a, 44);
+  R3(a, b, c, d, e, 45);
+  R3(e, a, b, c, d, 46);
+  R3(d, e, a, b, c, 47);
+  R3(c, d, e, a, b, 48);
+  R3(b, c, d, e, a, 49);
+  R3(a, b, c, d, e, 50);
+  R3(e, a, b, c, d, 51);
+  R3(d, e, a, b, c, 52);
+  R3(c, d, e, a, b, 53);
+  R3(b, c, d, e, a, 54);
+  R3(a, b, c, d, e, 55);
+  R3(e, a, b, c, d, 56);
+  R3(d, e, a, b, c, 57);
+  R3(c, d, e, a, b, 58);
+  R3(b, c, d, e, a, 59);
+  R4(a, b, c, d, e, 60);
+  R4(e, a, b, c, d, 61);
+  R4(d, e, a, b, c, 62);
+  R4(c, d, e, a, b, 63);
+  R4(b, c, d, e, a, 64);
+  R4(a, b, c, d, e, 65);
+  R4(e, a, b, c, d, 66);
+  R4(d, e, a, b, c, 67);
+  R4(c, d, e, a, b, 68);
+  R4(b, c, d, e, a, 69);
+  R4(a, b, c, d, e, 70);
+  R4(e, a, b, c, d, 71);
+  R4(d, e, a, b, c, 72);
+  R4(c, d, e, a, b, 73);
+  R4(b, c, d, e, a, 74);
+  R4(a, b, c, d, e, 75);
+  R4(e, a, b, c, d, 76);
+  R4(d, e, a, b, c, 77);
+  R4(c, d, e, a, b, 78);
+  R4(b, c, d, e, a, 79);
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  /* Erase working structures. The order of operations is important,
+   * used to ensure that compiler doesn't optimize those out. */
+  memset(block, 0, sizeof(block));
+  a = b = c = d = e = 0;
+  (void) a;
+  (void) b;
+  (void) c;
+  (void) d;
+  (void) e;
+}
+
+void cs_sha1_init(cs_sha1_ctx *context) {
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xEFCDAB89;
+  context->state[2] = 0x98BADCFE;
+  context->state[3] = 0x10325476;
+  context->state[4] = 0xC3D2E1F0;
+  context->count[0] = context->count[1] = 0;
+}
+
+void cs_sha1_update(cs_sha1_ctx *context, const unsigned char *data,
+                    uint32_t len) {
+  uint32_t i, j;
+
+  j = context->count[0];
+  if ((context->count[0] += len << 3) < j) context->count[1]++;
+  context->count[1] += (len >> 29);
+  j = (j >> 3) & 63;
+  if ((j + len) > 63) {
+    memcpy(&context->buffer[j], data, (i = 64 - j));
+    cs_sha1_transform(context->state, context->buffer);
+    for (; i + 63 < len; i += 64) {
+      cs_sha1_transform(context->state, &data[i]);
+    }
+    j = 0;
+  } else
+    i = 0;
+  memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *context) {
+  unsigned i;
+  unsigned char finalcount[8], c;
+
+  for (i = 0; i < 8; i++) {
+    finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
+                                      ((3 - (i & 3)) * 8)) &
+                                     255);
+  }
+  c = 0200;
+  cs_sha1_update(context, &c, 1);
+  while ((context->count[0] & 504) != 448) {
+    c = 0000;
+    cs_sha1_update(context, &c, 1);
+  }
+  cs_sha1_update(context, finalcount, 8);
+  for (i = 0; i < 20; i++) {
+    digest[i] =
+        (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+  }
+  memset(context, '\0', sizeof(*context));
+  memset(&finalcount, '\0', sizeof(finalcount));
+}
+
+void cs_hmac_sha1(const unsigned char *key, size_t keylen,
+                  const unsigned char *data, size_t datalen,
+                  unsigned char out[20]) {
+  cs_sha1_ctx ctx;
+  unsigned char buf1[64], buf2[64], tmp_key[20], i;
+
+  if (keylen > sizeof(buf1)) {
+    cs_sha1_init(&ctx);
+    cs_sha1_update(&ctx, key, keylen);
+    cs_sha1_final(tmp_key, &ctx);
+    key = tmp_key;
+    keylen = sizeof(tmp_key);
+  }
+
+  memset(buf1, 0, sizeof(buf1));
+  memset(buf2, 0, sizeof(buf2));
+  memcpy(buf1, key, keylen);
+  memcpy(buf2, key, keylen);
+
+  for (i = 0; i < sizeof(buf1); i++) {
+    buf1[i] ^= 0x36;
+    buf2[i] ^= 0x5c;
+  }
+
+  cs_sha1_init(&ctx);
+  cs_sha1_update(&ctx, buf1, sizeof(buf1));
+  cs_sha1_update(&ctx, data, datalen);
+  cs_sha1_final(out, &ctx);
+
+  cs_sha1_init(&ctx);
+  cs_sha1_update(&ctx, buf2, sizeof(buf2));
+  cs_sha1_update(&ctx, out, 20);
+  cs_sha1_final(out, &ctx);
+}
+
+#endif /* EXCLUDE_COMMON */

src/common/cs_sha1.h

+
+#ifndef CS_COMMON_SHA1_H_
+#define CS_COMMON_SHA1_H_
+
+#ifndef CS_DISABLE_SHA1
+#define CS_DISABLE_SHA1 0
+#endif
+
+#if !CS_DISABLE_SHA1
+
+#include "common/platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef struct {
+  uint32_t state[5];
+  uint32_t count[2];
+  unsigned char buffer[64];
+} cs_sha1_ctx;
+
+void cs_sha1_init(cs_sha1_ctx *);
+void cs_sha1_update(cs_sha1_ctx *, const unsigned char *data, uint32_t len);
+void cs_sha1_final(unsigned char digest[20], cs_sha1_ctx *);
+void cs_hmac_sha1(const unsigned char *key, size_t key_len,
+                  const unsigned char *text, size_t text_len,
+                  unsigned char out[20]);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CS_DISABLE_SHA1 */
+
+#endif /* CS_COMMON_SHA1_H_ */

src/common/cs_time.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 "common/cs_time.h"
 

src/common/cs_time.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
 
 #ifndef CS_COMMON_CS_TIME_H_
 #define CS_COMMON_CS_TIME_H_

src/common/mbuf.c

+
+#ifndef EXCLUDE_COMMON
+
+#include <assert.h>
+#include <string.h>
+#include "common/mbuf.h"
+
+#ifndef MBUF_REALLOC
+#define MBUF_REALLOC realloc
+#endif
+
+#ifndef MBUF_FREE
+#define MBUF_FREE free
+#endif
+
+void mbuf_init(struct mbuf *mbuf, size_t initial_size) WEAK;
+void mbuf_init(struct mbuf *mbuf, size_t initial_size) {
+  mbuf->len = mbuf->size = 0;
+  mbuf->buf = NULL;
+  mbuf_resize(mbuf, initial_size);
+}
+
+void mbuf_free(struct mbuf *mbuf) WEAK;
+void mbuf_free(struct mbuf *mbuf) {
+  if (mbuf->buf != NULL) {
+    MBUF_FREE(mbuf->buf);
+    mbuf_init(mbuf, 0);
+  }
+}
+
+void mbuf_resize(struct mbuf *a, size_t new_size) WEAK;
+void mbuf_resize(struct mbuf *a, size_t new_size) {
+  if (new_size > a->size || (new_size < a->size && new_size >= a->len)) {
+    char *buf = (char *) MBUF_REALLOC(a->buf, new_size);
+    /*
+     * In case realloc fails, there's not much we can do, except keep things as
+     * they are. Note that NULL is a valid return value from realloc when
+     * size == 0, but that is covered too.
+     */
+    if (buf == NULL && new_size != 0) return;
+    a->buf = buf;
+    a->size = new_size;
+  }
+}
+
+void mbuf_trim(struct mbuf *mbuf) WEAK;
+void mbuf_trim(struct mbuf *mbuf) {
+  mbuf_resize(mbuf, mbuf->len);
+}
+
+size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t) WEAK;
+size_t mbuf_insert(struct mbuf *a, size_t off, const void *buf, size_t len) {
+  char *p = NULL;
+
+  assert(a != NULL);
+  assert(a->len <= a->size);
+  assert(off <= a->len);
+
+  /* check overflow */
+  if (~(size_t) 0 - (size_t) a->buf < len) return 0;
+
+  if (a->len + len <= a->size) {
+    memmove(a->buf + off + len, a->buf + off, a->len - off);
+    if (buf != NULL) {
+      memcpy(a->buf + off, buf, len);
+    }
+    a->len += len;
+  } else {
+    size_t min_size = (a->len + len);
+    size_t new_size = (size_t)(min_size * MBUF_SIZE_MULTIPLIER);
+    if (new_size - min_size > MBUF_SIZE_MAX_HEADROOM) {
+      new_size = min_size + MBUF_SIZE_MAX_HEADROOM;
+    }
+    p = (char *) MBUF_REALLOC(a->buf, new_size);
+    if (p == NULL && new_size != min_size) {
+      new_size = min_size;
+      p = (char *) MBUF_REALLOC(a->buf, new_size);
+    }
+    if (p != NULL) {
+      a->buf = p;
+      if (off != a->len) {
+        memmove(a->buf + off + len, a->buf + off, a->len - off);
+      }
+      if (buf != NULL) memcpy(a->buf + off, buf, len);
+      a->len += len;
+      a->size = new_size;
+    } else {
+      len = 0;
+    }
+  }
+
+  return len;
+}
+
+size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) WEAK;
+size_t mbuf_append(struct mbuf *a, const void *buf, size_t len) {
+  return mbuf_insert(a, a->len, buf, len);
+}
+
+size_t mbuf_append_and_free(struct mbuf *a, void *buf, size_t len) WEAK;
+size_t mbuf_append_and_free(struct mbuf *a, void *data, size_t len) {
+  size_t ret;
+  /* Optimization: if the buffer is currently empty,
+   * take over the user-provided buffer. */
+  if (a->len == 0) {
+    if (a->buf != NULL) free(a->buf);
+    a->buf = (char *) data;
+    a->len = a->size = len;
+    return len;
+  }
+  ret = mbuf_insert(a, a->len, data, len);
+  free(data);
+  return ret;
+}
+
+void mbuf_remove(struct mbuf *mb, size_t n) WEAK;
+void mbuf_remove(struct mbuf *mb, size_t n) {
+  if (n > 0 && n <= mb->len) {
+    memmove(mb->buf, mb->buf + n, mb->len - n);
+    mb->len -= n;
+  }
+}
+
+void mbuf_clear(struct mbuf *mb) WEAK;
+void mbuf_clear(struct mbuf *mb) {
+  mb->len = 0;
+}
+
+void mbuf_move(struct mbuf *from, struct mbuf *to) WEAK;
+void mbuf_move(struct mbuf *from, struct mbuf *to) {
+  memcpy(to, from, sizeof(*to));
+  memset(from, 0, sizeof(*from));
+}
+
+#endif /* EXCLUDE_COMMON */

src/common/mbuf.h

+
+/*
+ * Mbufs are mutable/growing memory buffers, like C++ strings.
+ * Mbuf can append data to the end of a buffer or insert data into arbitrary
+ * position in the middle of a buffer. The buffer grows automatically when
+ * needed.
+ */
+
+#ifndef CS_COMMON_MBUF_H_
+#define CS_COMMON_MBUF_H_
+
+#include <stdlib.h>
+#include "common/platform.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifndef MBUF_SIZE_MULTIPLIER
+#define MBUF_SIZE_MULTIPLIER 1.5
+#endif
+
+#ifndef MBUF_SIZE_MAX_HEADROOM
+#ifdef BUFSIZ
+#define MBUF_SIZE_MAX_HEADROOM BUFSIZ
+#else
+#define MBUF_SIZE_MAX_HEADROOM 1024
+#endif
+#endif
+
+/* Memory buffer descriptor */
+struct mbuf {
+  char *buf;   /* Buffer pointer */
+  size_t len;  /* Data length. Data is located between offset 0 and len. */
+  size_t size; /* Buffer size allocated by realloc(1). Must be >= len */
+};
+
+/*
+ * Initialises an Mbuf.
+ * `initial_capacity` specifies the initial capacity of the mbuf.
+ */
+void mbuf_init(struct mbuf *, size_t initial_capacity);
+
+/* Frees the space allocated for the mbuffer and resets the mbuf structure. */
+void mbuf_free(struct mbuf *);
+
+/*
+ * Appends data to the Mbuf.
+ *
+ * Returns the number of bytes appended or 0 if out of memory.
+ */
+size_t mbuf_append(struct mbuf *, const void *data, size_t data_size);
+
+/*
+ * Appends data to the Mbuf and frees it (data must be heap-allocated).
+ *
+ * Returns the number of bytes appended or 0 if out of memory.
+ * data is freed irrespective of return value.
+ */
+size_t mbuf_append_and_free(struct mbuf *, void *data, size_t data_size);
+
+/*
+ * Inserts data at a specified offset in the Mbuf.
+ *
+ * Existing data will be shifted forwards and the buffer will
+ * be grown if necessary.
+ * Returns the number of bytes inserted.
+ */
+size_t mbuf_insert(struct mbuf *, size_t, const void *, size_t);
+
+/* Removes `data_size` bytes from the beginning of the buffer. */
+void mbuf_remove(struct mbuf *, size_t data_size);
+
+/*
+ * Resizes an Mbuf.
+ *
+ * If `new_size` is smaller than buffer's `len`, the
+ * resize is not performed.
+ */
+void mbuf_resize(struct mbuf *, size_t new_size);
+
+/* Moves the state from one mbuf to the other. */
+void mbuf_move(struct mbuf *from, struct mbuf *to);
+
+/* Removes all the data from mbuf (if any). */
+void mbuf_clear(struct mbuf *);
+
+/* Shrinks an Mbuf by resizing its `size` to `len`. */
+void mbuf_trim(struct mbuf *);
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif /* CS_COMMON_MBUF_H_ */

src/common/mg_mem.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
 
 #ifndef CS_COMMON_MG_MEM_H_
 #define CS_COMMON_MG_MEM_H_

src/common/mg_str.c

+
+#include "common/mg_mem.h"
+#include "common/mg_str.h"
+#include "common/platform.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+int mg_ncasecmp(const char *s1, const char *s2, size_t len) WEAK;
+
+struct mg_str mg_mk_str(const char *s) WEAK;
+struct mg_str mg_mk_str(const char *s) {
+  struct mg_str ret = {s, 0};
+  if (s != NULL) ret.len = strlen(s);
+  return ret;
+}
+
+struct mg_str mg_mk_str_n(const char *s, size_t len) WEAK;
+struct mg_str mg_mk_str_n(const char *s, size_t len) {
+  struct mg_str ret = {s, len};
+  return ret;
+}
+
+int mg_vcmp(const struct mg_str *str1, const char *str2) WEAK;
+int mg_vcmp(const struct mg_str *str1, const char *str2) {
+  size_t n2 = strlen(str2), n1 = str1->len;
+  int r = strncmp(str1->p, str2, (n1 < n2) ? n1 : n2);
+  if (r == 0) {
+    return n1 - n2;
+  }
+  return r;
+}
+
+int mg_vcasecmp(const struct mg_str *str1, const char *str2) WEAK;
+int mg_vcasecmp(const struct mg_str *str1, const char *str2) {
+  size_t n2 = strlen(str2), n1 = str1->len;
+  int r = mg_ncasecmp(str1->p, str2, (n1 < n2) ? n1 : n2);
+  if (r == 0) {
+    return n1 - n2;
+  }
+  return r;
+}
+
+static struct mg_str mg_strdup_common(const struct mg_str s,
+                                      int nul_terminate) {
+  struct mg_str r = {NULL, 0};
+  if (s.len > 0 && s.p != NULL) {
+    char *sc = (char *) MG_MALLOC(s.len + (nul_terminate ? 1 : 0));
+    if (sc != NULL) {
+      memcpy(sc, s.p, s.len);
+      if (nul_terminate) sc[s.len] = '\0';
+      r.p = sc;
+      r.len = s.len;
+    }
+  }
+  return r;
+}
+
+struct mg_str mg_strdup(const struct mg_str s) WEAK;
+struct mg_str mg_strdup(const struct mg_str s) {
+  return mg_strdup_common(s, 0 /* NUL-terminate */);
+}
+
+struct mg_str mg_strdup_nul(const struct mg_str s) WEAK;
+struct mg_str mg_strdup_nul(const struct mg_str s) {
+  return mg_strdup_common(s, 1 /* NUL-terminate */);
+}
+
+const char *mg_strchr(const struct mg_str s, int c) WEAK;
+const char *mg_strchr(const struct mg_str s, int c) {
+  size_t i;
+  for (i = 0; i < s.len; i++) {
+    if (s.p[i] == c) return &s.p[i];
+  }
+  return NULL;
+}
+
+int mg_strcmp(const struct mg_str str1, const struct mg_str str2) WEAK;
+int mg_strcmp(const struct mg_str str1, const struct mg_str str2) {
+  size_t i = 0;
+  while (i < str1.len && i < str2.len) {
+    int c1 = str1.p[i];
+    int c2 = str2.p[i];
+    if (c1 < c2) return -1;
+    if (c1 > c2) return 1;
+    i++;
+  }
+  if (i < str1.len) return 1;
+  if (i < str2.len) return -1;
+  return 0;
+}
+
+int mg_strncmp(const struct mg_str, const struct mg_str, size_t n) WEAK;
+int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n) {
+  struct mg_str s1 = str1;
+  struct mg_str s2 = str2;
+
+  if (s1.len > n) {
+    s1.len = n;
+  }
+  if (s2.len > n) {
+    s2.len = n;
+  }
+  return mg_strcmp(s1, s2);
+}
+
+int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2) WEAK;
+int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2) {
+  size_t i = 0;
+  while (i < str1.len && i < str2.len) {
+    int c1 = tolower((int) str1.p[i]);
+    int c2 = tolower((int) str2.p[i]);
+    if (c1 < c2) return -1;
+    if (c1 > c2) return 1;
+    i++;
+  }
+  if (i < str1.len) return 1;
+  if (i < str2.len) return -1;
+  return 0;
+}
+
+void mg_strfree(struct mg_str *s) WEAK;
+void mg_strfree(struct mg_str *s) {
+  char *sp = (char *) s->p;
+  s->p = NULL;
+  s->len = 0;
+  if (sp != NULL) free(sp);
+}
+
+const char *mg_strstr(const struct mg_str haystack,
+                      const struct mg_str needle) WEAK;
+const char *mg_strstr(const struct mg_str haystack,
+                      const struct mg_str needle) {
+  size_t i;
+  if (needle.len > haystack.len) return NULL;
+  for (i = 0; i <= haystack.len - needle.len; i++) {
+    if (memcmp(haystack.p + i, needle.p, needle.len) == 0) {
+      return haystack.p + i;
+    }
+  }
+  return NULL;
+}
+
+struct mg_str mg_strstrip(struct mg_str s) WEAK;
+struct mg_str mg_strstrip(struct mg_str s) {
+  while (s.len > 0 && isspace((int) *s.p)) {
+    s.p++;
+    s.len--;
+  }
+  while (s.len > 0 && isspace((int) *(s.p + s.len - 1))) {
+    s.len--;
+  }
+  return s;
+}
+
+int mg_str_starts_with(struct mg_str s, struct mg_str prefix) WEAK;
+int mg_str_starts_with(struct mg_str s, struct mg_str prefix) {
+  const struct mg_str sp = MG_MK_STR_N(s.p, prefix.len);
+  if (s.len < prefix.len) return 0;
+  return (mg_strcmp(sp, prefix) == 0);
+}

src/common/mg_str.h

+
+#ifndef CS_COMMON_MG_STR_H_
+#define CS_COMMON_MG_STR_H_
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Describes chunk of memory */
+struct mg_str {
+  const char *p; /* Memory chunk pointer */
+  size_t len;    /* Memory chunk length */
+};
+
+/*
+ * Helper function for creating mg_str struct from plain C string.
+ * `NULL` is allowed and becomes `{NULL, 0}`.
+ */
+struct mg_str mg_mk_str(const char *s);
+
+/*
+ * Like `mg_mk_str`, but takes string length explicitly.
+ */
+struct mg_str mg_mk_str_n(const char *s, size_t len);
+
+/* Macro for initializing mg_str. */
+#define MG_MK_STR(str_literal) \
+  { str_literal, sizeof(str_literal) - 1 }
+#define MG_MK_STR_N(str_literal, len) \
+  { str_literal, len }
+#define MG_NULL_STR \
+  { NULL, 0 }
+
+/*
+ * Cross-platform version of `strcmp()` where where first string is
+ * specified by `struct mg_str`.
+ */
+int mg_vcmp(const struct mg_str *str2, const char *str1);
+
+/*
+ * Cross-platform version of `strncasecmp()` where first string is
+ * specified by `struct mg_str`.
+ */
+int mg_vcasecmp(const struct mg_str *str2, const char *str1);
+
+/* Creates a copy of s (heap-allocated). */
+struct mg_str mg_strdup(const struct mg_str s);
+
+/*
+ * Creates a copy of s (heap-allocated).
+ * Resulting string is NUL-terminated (but NUL is not included in len).
+ */
+struct mg_str mg_strdup_nul(const struct mg_str s);
+
+/*
+ * Locates character in a string.
+ */
+const char *mg_strchr(const struct mg_str s, int c);
+
+/*
+ * Compare two `mg_str`s; return value is the same as `strcmp`.
+ */
+int mg_strcmp(const struct mg_str str1, const struct mg_str str2);
+
+/*
+ * Like `mg_strcmp`, but compares at most `n` characters.
+ */
+int mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n);
+
+/*
+ * Compare two `mg_str`s ignoreing case; return value is the same as `strcmp`.
+ */
+int mg_strcasecmp(const struct mg_str str1, const struct mg_str str2);
+
+/*
+ * Free the string (assuming it was heap allocated).
+ */
+void mg_strfree(struct mg_str *s);
+
+/*
+ * Finds the first occurrence of a substring `needle` in the `haystack`.
+ */
+const char *mg_strstr(const struct mg_str haystack, const struct mg_str needle);
+
+/* Strip whitespace at the start and the end of s */
+struct mg_str mg_strstrip(struct mg_str s);
+
+/* Returns 1 if s starts with the given prefix. */
+int mg_str_starts_with(struct mg_str s, struct mg_str prefix);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CS_COMMON_MG_STR_H_ */

src/common/platforms/arm/arm_exc.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 "arm_exc.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "FreeRTOS.h"
-
-#include "common/platform.h"
-
-#include "mgos_core_dump.h"
-#include "mgos_hal.h"
-
-#ifndef MGOS_ENABLE_CORE_DUMP
-#define MGOS_ENABLE_CORE_DUMP 1
-#endif
-
-#if __FPU_PRESENT && !defined(MGOS_BOOT_BUILD)
-static void save_s16_s31(uint32_t *dst) {
-  __asm volatile(
-      "\
-      vmov r1, s16\n str  r1, [%0, 0]\n\
-      vmov r1, s17\n str  r1, [%0, 4]\n\
-      vmov r1, s18\n str  r1, [%0, 8]\n\
-      vmov r1, s19\n str  r1, [%0, 12]\n\
-      vmov r1, s20\n str  r1, [%0, 16]\n\
-      vmov r1, s21\n str  r1, [%0, 20]\n\
-      vmov r1, s22\n str  r1, [%0, 24]\n\
-      vmov r1, s23\n str  r1, [%0, 28]\n\
-      vmov r1, s24\n str  r1, [%0, 32]\n\
-      vmov r1, s25\n str  r1, [%0, 36]\n\
-      vmov r1, s26\n str  r1, [%0, 40]\n\
-      vmov r1, s27\n str  r1, [%0, 44]\n\
-      vmov r1, s28\n str  r1, [%0, 48]\n\
-      vmov r1, s29\n str  r1, [%0, 52]\n\
-      vmov r1, s30\n str  r1, [%0, 56]\n\
-      vmov r1, s31\n str  r1, [%0, 60]\n\
-      "
-      :
-      : "r"(dst)
-      : "r1");
-}
-
-static void print_fpu_regs(const uint32_t *regs, int off, int n) {
-  for (int i = 0, j = off; i < n; i++, j++) {
-    if (j % 4 == 0) mgos_cd_putc('\n');
-    mgos_cd_printf("  S%d: %s0x%08lx", j, (j < 10 ? " " : ""), regs[i]);
-  }
-}
-#endif
-
-static struct arm_gdb_reg_file *s_rf = NULL;
-
-void arm_exc_dump_regs(void) {
-  mgos_cd_write_section(MGOS_CORE_DUMP_SECTION_REGS, s_rf, sizeof(*s_rf));
-}
-
-void arm_exc_handler_bottom(uint8_t isr_no, struct arm_exc_frame *ef,
-                            struct arm_gdb_reg_file *rf) {
-  char buf[8];
-  const char *name;
-#if __MPU_PRESENT
-  MPU->CTRL = 0;  // Disable MPU.
-#endif
-  portDISABLE_INTERRUPTS();
-  s_rf = rf;
-  switch (isr_no) {
-    case 0:
-      name = "ThreadMode";
-      break;
-    case 1:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 13:
-      name = "Reserved";
-      break;
-    case 2:
-      name = "NMI";
-      break;
-    case 3:
-      name = "HardFault";
-      break;
-    case 4:
-      name = "MemManage";
-      break;
-    case 5:
-      name = "BusFault";
-      break;
-    case 6:
-      name = "UsageFault";
-      break;
-    case 11:
-      name = "SVCall";
-      break;
-    case 12:
-      name = "ReservedDebug";
-      break;
-    case 14:
-      name = "PendSV";
-      break;
-    case 15:
-      name = "SysTick";
-      break;
-    default: {
-#ifndef MGOS_BOOT_BUILD
-      sprintf(buf, "IRQ%u", isr_no - 16);
-#endif
-      name = buf;
-    }
-  }
-  mgos_cd_printf("\n\n--- Exception %u (%s) ---\n", isr_no, name);
-  if (rf != NULL) {
-    mgos_cd_printf(
-        "  R%d:  0x%08lx  R%d:  0x%08lx  R%d:  0x%08lx  R%d:  0x%08lx\n", 0,
-        rf->r[0], 1, rf->r[1], 2, rf->r[2], 3, rf->r[3]);
-    mgos_cd_printf(
-        "  R%d:  0x%08lx  R%d:  0x%08lx  R%d:  0x%08lx  R%d:  0x%08lx\n", 4,
-        rf->r[4], 5, rf->r[5], 6, rf->r[6], 7, rf->r[7]);
-    mgos_cd_printf("  R8:  0x%08lx  R9:  0x%08lx  R10: 0x%08lx  R11: 0x%08lx\n",
-                   rf->r[8], rf->r[9], rf->r[10], rf->r[11]);
-    mgos_cd_printf("  R12: 0x%08lx  SP:  0x%08lx   LR: 0x%08lx  PC:  0x%08lx\n",
-                   rf->r[12], rf->sp, rf->lr, rf->pc);
-    mgos_cd_printf("  PSR: 0x%08lx MSP:  0x%08lx  PSP: 0x%08lx\n", rf->xpsr,
-                   rf->msp, rf->psp);
-  }
-#if __FPU_PRESENT
-  memset(rf->d, 0, sizeof(rf->d));
-#if !defined(MGOS_BOOT_BUILD)
-  rf->fpscr = ef->fpscr;
-  memcpy((uint8_t *) rf->d, ef->s, sizeof(ef->s));
-  print_fpu_regs((uint32_t *) rf->d, 0, ARRAY_SIZE(ef->s));
-  save_s16_s31(ef->s);
-  memcpy(((uint8_t *) rf->d) + sizeof(ef->s), ef->s, sizeof(ef->s));
-  print_fpu_regs((uint32_t *) (((uint8_t *) rf->d) + sizeof(ef->s)), 16,
-                 ARRAY_SIZE(ef->s));
-  mgos_cd_putc('\n');
-  mgos_cd_printf("FPSCR: 0x%08lx\n", rf->fpscr);
-#else
-  rf->fpscr = 0;
-#endif
-#endif
-#if MGOS_ENABLE_CORE_DUMP
-  mgos_cd_write();
-#endif
-#ifdef MGOS_HALT_ON_EXCEPTION
-  mgos_cd_printf("Halting\n");
-  while (1) {
-    mgos_wdt_feed();
-  }
-#else
-  mgos_cd_printf("Rebooting\n");
-  mgos_dev_system_restart();
-#endif
-  (void) ef;
-}

src/common/platforms/arm/arm_exc.h

-/*
- * Copyright (c) 2014-2019 Cesanta Software Limited
- * All rights reserved
- *
- * 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 <stdint.h>
-
-struct arm_exc_frame {
-  uint32_t r0;
-  uint32_t r1;
-  uint32_t r2;
-  uint32_t r3;
-  uint32_t r12;
-  uint32_t lr;
-  uint32_t pc;
-  uint32_t xpsr;
-#if __FPU_PRESENT
-  uint32_t s[16];
-  uint32_t fpscr;
-  uint32_t reserved;
-#endif
-} __attribute__((packed));
-
-struct arm_gdb_reg_file {
-  uint32_t r[13];
-  uint32_t sp;
-  uint32_t lr;
-  uint32_t pc;
-  uint32_t xpsr;
-#if __FPU_PRESENT
-  uint64_t d[16];
-  uint32_t fpscr;
-#endif
-  // MSP and PSP are our extension.
-  uint32_t msp;
-  uint32_t psp;
-} __attribute__((packed));
-
-void arm_exc_handler_bottom(uint8_t isr_no, struct arm_exc_frame *ef,
-                            struct arm_gdb_reg_file *rf);
-void arm_exc_dump_regs(void);

src/common/platforms/arm/arm_exc_top.S

-/*
- * Copyright (c) 2014-2017 Cesanta Software Limited
- * All rights reserved
- */
-
-.arch armv7e-m
-.syntax unified
-.thumb
-
-/* These are required to satisfy TI linker. */
-.eabi_attribute Tag_ABI_align_needed, 1
-.eabi_attribute Tag_ABI_align_preserved, 1
-
-.global arm_exc_handler_top
-.global arm_exc_handler_bottom
-
-/*
- * Determines the stack pointer, populates most of the GDB frame 
- * and hands off to the C routine.
- */
-.section .text.arm_exc_handler_top
-.type arm_exc_handler_top, %function
-.align 8
-
-arm_exc_handler_top:
-  tst lr, #4
-  ite eq
-  mrseq r1, msp
-  mrsne r1, psp
-  // r1 -> arm_exc_frame prepared for us by the CPU
-#if __FPU_PRESENT
-  add r0, r1, #104  // sizeof(arm_exc_frame)
-  sub sp, #208      // sizeof(arm_gdb_reg_file)
-#else
-  add r0, r1, #32   // sizeof(arm_exc_frame)
-  sub sp, #76       // sizeof(arm_gdb_reg_file)
-#endif
-  mov r2, sp
-  // r0 -> original sp, r2 -> arm_gdb_reg_file to fill
-  // r3 - scratch
-  ldr r3,  [r1, #0]   // r0
-  str r3,  [r2, #0]
-  ldr r3,  [r1, #4]   // r2
-  str r3,  [r2, #4]
-  ldr r3,  [r1, #8]   // r1
-  str r3,  [r2, #8]
-  ldr r3,  [r1, #12]  // r3
-  str r3,  [r2, #12]
-  str r4,  [r2, #16]  // r4
-  str r5,  [r2, #20]  // r5
-  str r6,  [r2, #24]  // r6
-  str r7,  [r2, #28]  // r7
-  str r8,  [r2, #32]  // r8
-  str r9,  [r2, #36]  // r9
-  str r10, [r2, #40]  // r10
-  str r11, [r2, #44]  // r11
-  ldr r3,  [r1, #16]  // r12
-  str r3,  [r2, #48]
-  str r0,  [r2, #52]  // sp
-  ldr r3,  [r1, #20]  // lr
-  str r3,  [r2, #56]
-  ldr r3,  [r1, #24]  // pc
-  str r3,  [r2, #60]
-  ldr r3,  [r1, #28]  // xpsr
-  str r3,  [r2, #64]
-#if __FPU_PRESENT
-  mrs r3,  msp
-  str r3,  [r2, #200] // msp
-  mrs r3,  psp
-  str r3,  [r2, #204] // psp
-#else
-  mrs r3,  msp
-  str r3,  [r2, #68] // msp
-  mrs r3,  psp
-  str r3,  [r2, #72] // psp
-#endif
-
-  mrs r0, ipsr
-  b arm_exc_handler_bottom
-.size arm_exc_handler_top, . - arm_exc_handler_top

src/common/platforms/arm/arm_nsleep100.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 <math.h>
-
-#include "mgos.h"
-#include "mgos_system.h"
-
-void (*mgos_nsleep100)(uint32_t n);
-uint32_t mgos_nsleep100_loop_count = 0;
-/* Provided by arm_nsleep100_{m4,m7}.S for M4 and M7 respectively. */
-extern void mgos_nsleep100_impl(uint32_t n);
-
-void mgos_nsleep100_cal(void) {
-  uint32_t cpu_freq = mgos_get_cpu_freq();
-  /* # of instruction cycles per 100 ns */
-  mgos_nsleep100_loop_count =
-      roundf((100.0f / 1000000000.0f) / (1.0f / cpu_freq));
-  mgos_nsleep100 = mgos_nsleep100_impl;
-}

src/common/platforms/arm/arm_nsleep100_m3.S

-/*
- * Copyright (c) 2014-2019 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-.arch armv7e-m
-.syntax unified
-.thumb
-
-/* These are required to satisfy TI linker. */
-.eabi_attribute Tag_ABI_align_needed, 1
-.eabi_attribute Tag_ABI_align_preserved, 1
-
-.global mgos_nsleep100_impl
-.global mgos_nsleep100_loop_count
-
-.section .text.IRAM.mgos_nsleep100_impl
-.type mgos_nsleep100_impl, %function
-.align 4
-
-mgos_nsleep100_impl:
-      ldr     r3, =mgos_nsleep100_loop_count
-      ldr     r3, [r3]
-      mul     r0, r3
-      mov     r1, #6
-      udiv    r0, r0, r1
-      cbz     r0, xxx
-lxx:
-      subs    r0, #1
-      bne     lxx
-xxx:
-      bx      lr
-.align 4
-.size mgos_nsleep100_impl, . - mgos_nsleep100_impl

src/common/platforms/arm/arm_nsleep100_m4.S

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-.arch armv7e-m
-.syntax unified
-.thumb
-
-/* These are required to satisfy TI linker. */
-.eabi_attribute Tag_ABI_align_needed, 1
-.eabi_attribute Tag_ABI_align_preserved, 1
-
-.global mgos_nsleep100_impl
-.global mgos_nsleep100_loop_count
-
-#if defined(TARGET_IS_CC3200) || defined(TARGET_IS_CC3220)
-.section .iram.mgos_nsleep100_impl
-#else
-.section .text.IRAM.mgos_nsleep100_impl
-#endif
-.type mgos_nsleep100_impl, %function
-.align 4
-
-mgos_nsleep100_impl:
-      ldr     r3, =mgos_nsleep100_loop_count
-      ldr     r3, [r3]
-      mul     r0, r3
-#if defined(STM32L4)
-      mov     r1, #3
-#else
-      mov     r1, #6
-#endif
-      udiv    r0, r0, r1
-      cbz     r0, mgos_nsleep100_impl_out
-mgos_nsleep100_impl_loop:
-      subs    r0, #1
-      bne     mgos_nsleep100_impl_loop
-mgos_nsleep100_impl_out:
-      bx      lr
-.align 4
-.size mgos_nsleep100_impl, . - mgos_nsleep100_impl

src/common/platforms/arm/arm_nsleep100_m7.S

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-.arch armv7e-m
-.syntax unified
-.thumb
-
-/* These are required to satisfy TI linker. */
-.eabi_attribute Tag_ABI_align_needed, 1
-.eabi_attribute Tag_ABI_align_preserved, 1
-
-.global mgos_nsleep100_impl
-.global mgos_nsleep100_loop_count
-
-.section .text.IRAM.mgos_nsleep100_impl
-.type mgos_nsleep100_impl, %function
-.align 4
-
-mgos_nsleep100_impl:
-      ldr     r3, =mgos_nsleep100_loop_count
-      ldr     r3, [r3]
-      /* Because of speculative fetch, the core loop only takes 1 cycle. */
-      muls    r0, r3
-      cbz     r0, xxx
-lxx:
-      subs    r0, #1
-      bne     lxx
-xxx:
-      bx      lr
-.align 4
-.size mgos_nsleep100_impl, . - mgos_nsleep100_impl

src/common/platforms/cc3200/cc3200.ld

-/*****************************************************************************
-*
-* GCC Linker script for CC3200. Based on TI's example "blinky.ld".
-*
-* Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ 
-* 
-* 
-*  Redistribution and use in source and binary forms, with or without 
-*  modification, are permitted provided that the following conditions 
-*  are met:
-*
-*    Redistributions of source code must retain the above copyright 
-*    notice, this list of conditions and the following disclaimer.
-*
-*    Redistributions in binary form must reproduce the above copyright
-*    notice, this list of conditions and the following disclaimer in the 
-*    documentation and/or other materials provided with the   
-*    distribution.
-*
-*    Neither the name of Texas Instruments Incorporated nor the names of
-*    its contributors may be used to endorse or promote products derived
-*    from this software without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*
-******************************************************************************/
-
-ORG = DEFINED(ORG) ? ORG : 0x20004000;
-RAM_SIZE = DEFINED(RAM_SIZE) ? RAM_SIZE : 0x3C000;
-
-MEMORY
-{
-    /* SRAM size of 240KB for cc3200 ES 1.33 device onward */
-    SRAM (rwx) : ORIGIN = ORG, LENGTH = RAM_SIZE
-}
-
-SECTIONS
-{
-    .text :
-    {
-        _text = .;
-        KEEP(*(.intvecs))
-        *(.text*)
-        *(.rodata*)
-        *(.ARM.extab* .gnu.linkonce.armextab.*)
-        . = ALIGN(8);
-        _etext = .;
-    } > SRAM
-
-    .ARM : {
-    __exidx_start = .;
-      *(.ARM.exidx*)
-      __exidx_end = .;
-    } > SRAM
-
-    __init_data = .;
-
-    .data : AT(__init_data)
-    {
-        _data = .;
-        *(.data*)
-        . = ALIGN (8);
-        _edata = .;
-    } > SRAM
-
-    .bss :
-    {
-        _bss = .;
-        *(.bss*)
-        *(COMMON)
-        _ebss = .;
-    } > SRAM
-
-    .heap :
-    {
-        _heap = .;
-        . = . + (LENGTH(SRAM) - SIZEOF(.text) - SIZEOF(.ARM) - SIZEOF(.data) - SIZEOF(.bss));
-        . = ALIGN(8);
-        _eheap = .;
-
-    } > SRAM
-}

src/common/platforms/cc3200/cc3200_libc.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
 
 #if CS_PLATFORM == CS_P_CC3200
 

src/common/platforms/cc3200/cc3200v1p32.cmd

-//*****************************************************************************
-// cc3200v1p32.cmd
-//
-// CCS linker configuration file for cc3200 ES 1.32.
-//
-// Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ 
-// 
-// 
-//  Redistribution and use in source and binary forms, with or without 
-//  modification, are permitted provided that the following conditions 
-//  are met:
-//
-//    Redistributions of source code must retain the above copyright 
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above copyright
-//    notice, this list of conditions and the following disclaimer in the 
-//    documentation and/or other materials provided with the   
-//    distribution.
-//
-//    Neither the name of Texas Instruments Incorporated nor the names of
-//    its contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-//  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-//  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-//  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-//  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-//*****************************************************************************
-
-
---retain=g_pfnVectors
-
-//*****************************************************************************
-// The following command line options are set as part of the CCS project.  
-// If you are building using the command line, or for some reason want to    
-// define them here, you can uncomment and modify these lines as needed.     
-// If you are using CCS for building, it is probably better to make any such 
-// modifications in your CCS project and leave this file alone.              
-//*****************************************************************************
-
-
-//*****************************************************************************
-// The starting address of the application.  Normally the interrupt vectors  
-// must be located at the beginning of the application.                      
-//*****************************************************************************
-#define RAM_BASE 0x20004000
-
-/* System memory map */
-
-MEMORY
-{
-    /* Application uses internal RAM for program and data */
-    SRAM_CODE (RWX) : origin = 0x20004000, length = 0x2F000
-    SRAM_DATA (RWX) : origin = 0x20033000, length = 0xD000
-}
-
-/* Section allocation in memory */
-
-SECTIONS
-{
-    .intvecs:   > RAM_BASE
-    .init_array : > SRAM_CODE
-    .vtable :   > SRAM_CODE
-    .text   :   > SRAM_CODE
-    .const  :   > SRAM_CODE
-    .cinit  :   > SRAM_CODE
-    .pinit  :   > SRAM_CODE
-    .data   :   > SRAM_DATA
-    .bss    :   > SRAM_DATA
-    .sysmem :   > SRAM_DATA
-    .stack  :   > SRAM_DATA(HIGH)
-}
-

src/common/platforms/cc3200/gcc.mk

-APP_LDFLAGS ?=
-CC_WRAPPER ?=
-GENFILES_LIST ?=
-CC = arm-none-eabi-gcc
-CXX = arm-none-eabi-g++
-AR = arm-none-eabi-ar
-NM = arm-none-eabi-nm
-
-IPATH += $(SDK_PATH)/third_party/FreeRTOS/source/portable/GCC/ARM_CM4
-VPATH += $(SDK_PATH)/third_party/FreeRTOS/source/portable/GCC/ARM_CM4
-
-C_CXX_FLAGS = -mthumb -mcpu=cortex-m4 -ffunction-sections -fdata-sections \
-              -MD -Os -ggdb -Wall -Werror -Dgcc
-CFLAGS += -std=c99 $(C_CXX_FLAGS)
-CXXFLAGS += -std=g++11 $(C_CXX_FLAGS)
-
-AR = arm-none-eabi-ar
-LD = arm-none-eabi-ld
-OBJCOPY = arm-none-eabi-objcopy
-LIBGCC := ${shell ${CC} -mthumb ${CFLAGS} -print-libgcc-file-name}
-LIBC := ${shell ${CC} ${CFLAGS} -print-file-name=libc.a}
-LIBM := ${shell ${CC} ${CFLAGS} -print-file-name=libm.a}
-
-# Disable certain warnings on SDK sources, we have no control over them anyway.
-# We also force-include platform.h which resolves some symbol conflicts
-# between system includes and simplelink.h
-$(SDK_OBJS): CFLAGS += -Wno-missing-braces -Wno-strict-aliasing -Wno-parentheses -Wno-unused-variable -Wno-builtin-macro-redefined
-$(SDK_OBJS): CFLAGS += -include common/platform.h
-
-# cc flags,file
-define cc
-	$(vecho) "GCC   $2"
-	$(Q) $(CC_WRAPPER) $(CC) -c $1 -o $@ $2
-endef
-define cxx
-	$(vecho) "G++   $2"
-	$(Q) $(CC_WRAPPER) $(CXX) -c $1 -o $@ $2
-endef
-
-# ar files
-define ar
-	$(vecho) "AR    $@"
-	$(Q) $(AR) cru $@ $1
-endef
-
-# link script,flags,objs
-define link
-	$(vecho) "LD    $@"
-	$(Q) $(CC_WRAPPER) $(LD) \
-	  --gc-sections -o $@ -T $1 $2 $3 \
-	  $(LIBM) $(LIBC) $(LIBGCC)
-endef

src/common/platforms/cc3200/ti.mk

-IPATH += $(SDK_PATH)/third_party/FreeRTOS/source/portable/CCS/ARM_CM3
-VPATH += $(SDK_PATH)/third_party/FreeRTOS/source/portable/CCS/ARM_CM3
-
-CC_WRAPPER ?=
-CC = $(TOOLCHAIN)/bin/armcl
-AR = $(TOOLCHAIN)/bin/armar
-NM = nm
-GENFILES_LIST ?=
-
-C_CXX_FLAGS = -Dccs -I$(TOOLCHAIN)/include
-TI_C_CXX_FLAGS = -mv7M4 --little_endian --code_state=16 --float_support=vfplib --abi=eabi \
-                 -O4 --opt_for_speed=0 --unaligned_access=on --small_enum \
-                 --gen_func_subsections=on --diag_wrap=off --display_error_number \
-                 --emit_warnings_as_errors
-CFLAGS += --c99 $(TI_C_CXX_FLAGS) $(C_CXX_FLAGS)
-CXXFLAGS += $(TI_C_CXX_FLAGS) $(C_CXX_FLAGS)
-
-# cc flags,file
-define cc
-	$(vecho) "TICC  $2"
-	$(Q) $(CC_WRAPPER) $(CC) -c --preproc_with_compile -ppd=$@.d $1 --output_file=$@ $2
-endef
-define cxx
-	$(vecho) "TICXX $2"
-	$(Q) $(CC_WRAPPER) $(CC) -c --preproc_with_compile -ppd=$@.d $1 --output_file=$@ $2
-endef
-
-# asm flags,file
-define asm
-	$(vecho) "TIASM $2"
-	$(Q) $(CC_WRAPPER) $(CC) -c $1 --output_file=$@ $2
-endef
-
-# ar files
-define ar
-	$(vecho) "TIAR  $@"
-	$(Q) $(AR) qru $@ $1
-endef
-
-# link script,flags,objs
-define link
-	$(vecho) "TILD  $@"
-	$(Q) $(CC_WRAPPER) $(CC) \
-	  -mv7M4 --code_state=16 --float_support=vfplib --abi=eabi --little_endian \
-	  --run_linker \
-	  --generate_dead_funcs_list=$@.garbage.xml \
-	  -i $(TOOLCHAIN)/lib \
-	  --reread_libs --warn_sections --display_error_number \
-	  --unused_section_elimination=on \
-	  -o $@ --map_file=$@.map --xml_link_info=$@.map.xml \
-	  $2 $1 $3
-endef

src/common/platforms/esp/slip.c

-#include "rom_functions.h"
-
-void SLIP_send(uint8_t *pkt, uint32_t size) {
-  send_packet(pkt, size);
-}
-
-uint32_t SLIP_recv(void *pkt, uint32_t max_len) {
-  uint8_t c;
-  uint32_t len = 0;
-  uint8_t *p = (uint8_t *) pkt;
-  do {
-    c = uart_rx_one_char_block();
-  } while (c != '\xc0');
-  while (len < max_len) {
-    c = uart_rx_one_char_block();
-    if (c == '\xc0') return len;
-    if (c == '\xdb') {
-      c = uart_rx_one_char_block();
-      if (c == '\xdc') {
-        c = '\xc0';
-      } else if (c == '\xdd') {
-        c = '\xdb';
-      } else {
-        len = 0;
-        break; /* Bad esc sequence. */
-      }
-    }
-    *p++ = c;
-    len++;
-  }
-  do {
-    c = uart_rx_one_char_block();
-  } while (c != '\xc0');
-  return len;
-}

src/common/platforms/esp/slip.h

-#ifndef CS_COMMON_PLATFORMS_ESP8266_STUBS_SLIP_H_
-#define CS_COMMON_PLATFORMS_ESP8266_STUBS_SLIP_H_
-
-#include <inttypes.h>
-
-void SLIP_send(const void *pkt, uint32_t size);
-uint32_t SLIP_recv(void *pkt, uint32_t max_len);
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_STUBS_SLIP_H_ */

src/common/platforms/esp/stub_flasher.h

-#ifndef CS_COMMON_PLATFORMS_ESP8266_STUBS_STUB_FLASHER_H_
-#define CS_COMMON_PLATFORMS_ESP8266_STUBS_STUB_FLASHER_H_
-
-enum stub_cmd {
-  /*
-   * Write to the SPI flash.
-   *
-   * Args: addr, len, erase; addr and len must be SECTOR_SIZE-aligned.
-   *       If erase != 0, perform erase before writing.
-   * Input: Stream of data to be written, note: no SLIP encapsulation here.
-   * Output: SLIP packets with number of bytes written after every write.
-   *         This can (and should) be used for flow control. Flasher will
-   *         write in 1K chunks but will buffer up to 4K of data
-   *         Use this feedback to keep buffer above 1K but below 4K.
-   *         Final packet will contain MD5 digest of the data written.
-   */
-  CMD_FLASH_WRITE = 1,
-
-  /*
-   * Read from the SPI flash.
-   *
-   * Args: addr, len, block_size; no alignment requirements, block_size <= 4K.
-   * Input: None.
-   * Output: Packets of up to block_size with data. An acknowledgement is
-   *expected
-   *         after every packet, in the form of a packet with total number of
-   *         bytes received so far.
-   *         Last packet is the MD5 digest of the data sent.
-   *
-   * Note: No flow control is performed, it is assumed that the host can cope
-   * with the inbound stream.
-   */
-  CMD_FLASH_READ = 2,
-
-  /*
-   * Compute MD5 digest of the specified flash region.
-   *
-   * Args: addr, len, digest_block_size; no alignment requirements.
-   * Input: None.
-   * Output: If block digests are not enabled (digest_block_size == 0),
-   *         only overall digest is produced.
-   *         Otherwise, there will be a separate digest for each block,
-   *         the remainder (if any) and the overall digest at the end.
-   */
-  CMD_FLASH_DIGEST = 3,
-
-  /*
-   * Read flash chip ID.
-   * This is the JEDEC ID, containinf manufactirer, SPI mode and capacity.
-   *
-   * Args: None.
-   * Input: None.
-   * Output: 32 bit chip id (only 24 bits are meaningful).
-   */
-  CMD_FLASH_READ_CHIP_ID = 4,
-
-  /*
-   * Zap the whole chip at once.
-   *
-   * Args: None.
-   * Input: None.
-   * Output: None.
-   */
-  CMD_FLASH_ERASE_CHIP = 5,
-
-  /*
-   * Boots the firmware from flash.
-   *
-   * Args: None.
-   * Input: None.
-   * Output: None.
-   */
-  CMD_BOOT_FW = 6,
-
-  /*
-   * Reboot the CPU.
-   * Since strapping settings are not reset, this will reboot into whatever mode
-   * got us here, most likely UART loader.
-   *
-   * Args: None.
-   * Input: None.
-   * Output: None.
-   */
-  CMD_REBOOT = 7,
-
-  /*
-   * Echo the arguments back to the host.
-   *
-   * Args: variable.
-   * Input: None.
-   * Output: arguments.
-   */
-  CMD_ECHO = 8,
-
-  /*
-   * Read register value.
-   *
-   * Args: register address.
-   * Input: None.
-   * Output: register value.
-   */
-  CMD_READ_REG = 9,
-
-  /*
-   * Write register value.
-   *
-   * Args: register address, value.
-   * Input: None.
-   * Output: None.
-   */
-  CMD_WRITE_REG = 10,
-};
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_STUBS_STUB_FLASHER_H_ */

src/common/platforms/esp31/rom/.gitattributes

-rom.bin -nodiff

src/common/platforms/esp31/rom/disasm.sh

-#!/bin/bash
-
-xtensa-esp108-elf-gcc -Wl,-N,-Ttext,0x40000000 -nostdlib rom.S -o rom.elf && \
-  xtensa-esp108-elf-objdump -d rom.elf > ESP31B_ROM.txt

src/common/platforms/esp31/rom/notes.c

-/* Just some notes scribbled while disassembling */
-
-/*
- * RTC = 0x60008000
- * RTC+0x18: ??c????? ???????? ???????? ????????
- * RTC+0x34: ???????? ??bbbbbb bbbb???? ??aaaaaa
- */
-int _X_get_rst_cause(void) {
-  int ret;
-  int a = GET_PERI_REG_BITS(RTC_STATE1, 6, 0);
-  if (a == 5) {
-    int b = (RTC_STATE1 >> 12) && 0xfff;
-    if (b != 1) {
-      ret = (b == 8 ? a : 0);
-    } else {
-      ret = 20;
-    }
-  } else {
-    ret = a;
-  }
-  CLEAR_PERI_REG_MASK(RTC_STATE0, RTC_CNTL_SLP_WAKEUP);
-  return ret;
-}
-
-/*
- * RTC = 0x60008000
- * RTC+0x38: ???????? ???????? ???????? ??cccccc
- * RTC+0x74: ???????? ???????? ???????? dddddddd
- * RTC+0x80: ???????? ??????a? ???b???? ????????
- */
-void main(void) {
-  uint32_t rst_cause = _X_get_rst_cause();
-  CLEAR_PERI_REG_MASK(RTC+0x80, BIT(17));     // a
-  SET_PERI_REG_MASK(RTC+0x80, BIT(12));       // b
-  uint32_t boot_mode = GET_PERI_REG_BITS(GPIO_STRAP, 6, 0);  // c
-  if (boot_mode & (BIT(5) | BIT(4)) == (BIT(5) | BIT(4)) || boot_mode == 24 || boot_mode == 26) {
-    CLEAR_PERI_REG_MASK(RTC+0x74, 0xff);
-  }
-  if (boot_mode & (BIT(5) | BIT(4)) == BIT(5)) {
-    CLEAR_PERI_REG_MASK(RTC+0x94, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0x98, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0x9c, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0xa0, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0xa4, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0xa8, BIT(31));
-    CLEAR_PERI_REG_MASK(RTC+0xac, BIT(31));
-  }
-  if (boot_mode & (BIT(5) | BIT(3)) == 0) {
-    // ... 1405
-  }
-  CLEAR_PERI_REG_MASK(RTC+0x74, 0xff);
-  _X_uart_attach();
-  _X_uart_init(0);
-  // GPIO_STRAP ...
-  ets_printf(boot_banner, fw_build, rst_cause, boot_mode);
-  // rst_cause
-  if (rst_cause == 1 || rst_cause == 2) {
-    
-  } else {
-    // ...
-  }
-  ets_printf("%s %u", "ets_main.c", 305);
-  while(1) {}
-}
-
-/*
- * GPIO strap mapping:
- *
- * 0011 1111 1011 0011
- *   || |||| |||| ||||
- *   || |||| |||| |||`- IO5
- *   || |||| |||| ||`-- IO15
- *   || |||| |||| |`--- IO4
- *   || |||| |||| `---- IO2
- *   || |||| |||`------ ?
- *   || |||| ||`------- IO0
- *   || |||| |`-------- IO12
- *   || |||| `--------- ?
- *   || |||`----------- CLK
- *   || ||`------------ ?
- *   || |`------------- SD0
- *   || `-------------- SD1
- *   |`---------------- ? SD2
- *   `----------------- SD3
- */
-
-struct uartdev {
-  uint32_t baud_rate;  // 0
-  uint32_t ud4;
-  uint32_t ud8;
-  uint32_t ud12;
-  uint32_t ud16;
-  uint32_t ud20;
-  uint8_t ud24;
-  uint8_t ud25;
-  uint32_t ud28;
-  uint32_t ud32;
-  uint32_t ud36;
-  uint8_t ud40;
-  uint32_t ud48;
-  uint32_t ud52;
-};
-
-void _X_uart_attach(void) {
-  // zero uartdev
-  uartdev.baud_rate = 115200;
-  _X_xtos_ints_off(1 << ETS_UART_INUM);
-  // INTR_MAP_REG_C
-  // 11111111 11111111 11111100 00011111 &
-  // 00000000 00000000 00000000 10100000 |
-  // PRODPORT_INTR_MAP_13 -> 5 = ETS_UART_INUM
-  // 11111111 11111111 10000011 11111111 &
-  // 00000000 00000000 00010100 11111111 |
-  // PRODPORT_INTR_MAP_14 -> 5 = ETS_UART_INUM
-  _xtos_set_interrupt_handler_arg(ETS_UART_INUM, uart_int_handler, _c_0x3fffdb2c_uart_int_handler_arg);
-}
-
-void _X_uart_init(uint32_t a) {
-  // GPIO_FUNC_IN_SEL3
-  // xx999999 88888877 77776666 66555555
-  // 11111111 11111100 00001111 11111111 = 0xfffc0fff
-  // 00000000 00000000 10010000 00000000 = 0x00009000
-  // GPIO17 func => 9
-  // 00000000 00000010 00000000 00000000
-  uart_div_modify(13000000 / uartdev.baud_rate);
-  // ...
-}
-
-struct _st_0x3fffdc90 {
-};
-
-struct _st_0x3fffdf70 {
-  void *fp1;  // 20
-  void *fp2;  // 24
-  uint32_t d28;
-  uint32_t d32;
-  uint32_t d36;
-  struct _st_0x3fffdc90 *st;  // 44
-} stdf70;
-
-void _X_slc_init_attach(void *fp1, void *fp2, struct _st_0x3fffdc90 *st, uint32_t gpio_mode) {
-  stdf70.fp1 = fp1;
-  stdf70.fp2 = fp2;
-  stdf70.st = st;
-  d28 = d32 = d36 = 0;
-  SET_PERI_REG_MASK(WIFI_RST_EN, PRODPORT_SDIO_RST);
-  CLEAR_PERI_REG_MASK(WIFI_RST_EN, PRODPORT_SDIO_RST);
-  if (gpio_mode == 4) {
-    SET_PERI_REG((READ_PERI_REG(PERIPHS_HINF_BASEADDR+4) & 0xf0000000) | 0x01110013);
-  } else {
-    SET_PERI_REG((READ_PERI_REG(PERIPHS_HINF_BASEADDR+4) & 0xf0000000) | 0x02320017);
-  }
-  SET_PERI_REG(PERIPHS_HINF_BASEADDR, 0x11116666);
-  _X_slc_set_host_io_max_window();
-  ...
-}
-
-#define SLC_TOKEN1 (PERIPHS_SLC_BASEADDR + 0x54)
-#define SLC_BRIDGE_CONF (PERIPHS_SLC_BASEADDR + 0x74)
-
-void _X_slc_set_host_io_max_window(void) {
-  SET_PERI_REG(SLC_BRIDGE_CONF, (READ_PERI_REG(SLC_BRIDGE_CONF) & 0xfffff0c0) | 0x720);
-}

src/common/platforms/esp31/rom/rom.S

-.text
-.org 0
-.globl _start
-
-// xtensa-esp108-elf-gcc -Wl,-N,-Ttext,0x40000000 -nostdlib rom.S -o rom.elf
-
-here = .
-#define PROVIDE(name, addr) name = here + addr - 0x40000000
-
-#include "rom_functions.S"
-
-.text
-
-_start:
-.incbin "rom.bin"
-_end:

src/common/platforms/esp31/rom/rom_functions.S

-// These come from linker script
-
-PROVIDE ( Cache_Read_Disable , 0x4000444c );
-PROVIDE ( Cache_Read_Enable , 0x4000438c );
-
-PROVIDE ( ets_delay_us , 0x40002db4 );
-
-PROVIDE ( bzero , 0x40002a54 );
-
-PROVIDE ( memcmp , 0x400068ec );
-PROVIDE ( memcpy , 0x40006974 );
-PROVIDE ( memmove , 0x40006a6c );
-PROVIDE ( memset , 0x40006be4 );
-
-PROVIDE ( strcmp , 0x40005bb8 );
-PROVIDE ( strcpy , 0x40005cdc );
-PROVIDE ( strlen , 0x40005d6c );
-PROVIDE ( strncmp , 0x40005dd0 );
-PROVIDE ( strncpy , 0x40005e90 );
-PROVIDE ( strstr , 0x40005f6c );
-
-PROVIDE ( ets_install_putc1 , 0x40002774 );
-PROVIDE ( ets_printf , 0x40002804 );
-PROVIDE ( ets_putc , 0x40002b14 );
-
-PROVIDE ( ets_str2macaddr , 0x40002a64 );
-
-PROVIDE ( gpio_output_set , 0x400049d8 );
-PROVIDE ( gpio_output_set_high , 0x400049f8 );
-
-PROVIDE ( ets_get_cpu_frequency , 0x40002de8 );
-PROVIDE ( ets_update_cpu_frequency , 0x40002ddc );
-
-PROVIDE ( lldesc_build_chain , 0x40004c8c );
-
-PROVIDE ( multofup , 0x400068a0 );
-PROVIDE ( roundup2 , 0x40006890 );
-
-PROVIDE (software_reset_cpu , 0x40002998 );
-
-PROVIDE ( SPIEraseSector , 0x40004708 );
-PROVIDE ( SPIRead , 0x40004898 );
-PROVIDE ( SPIWrite , 0x40004738 );
-
-PROVIDE ( uart_div_modify , 0x400034e8 );
-PROVIDE ( uart_tx_one_char , 0x4000362c );
-
-PROVIDE ( __divsi3 , 0x40006888 );
-PROVIDE ( __udivdi3 , 0x40006c30 );
-PROVIDE ( __umoddi3 , 0x40006e64 );
-
-PROVIDE ( _xtos_set_intlevel , 0x40006670 );
-
-// These have been reverse-engineered.
-
-PROVIDE(_XX_Vec40, 0x40000040)
-PROVIDE(_XX_ExcVec50, 0x40000050)
-PROVIDE(_XX_ExcVec80, 0x40000080)
-
-PROVIDE(_XX_Vec400, 0x40000300)
-
-PROVIDE(_WindowOverflowHandler, 0x40000100)
-PROVIDE(_WindowUnderflowHandler, 0x40000140)
-
-PROVIDE(_X_ResetVector, 0x40000500)
-
-PROVIDE(_c_stack, 0x40000700)
-PROVIDE(_c_bss_start, 0x40000708)
-PROVIDE(_c_bss_end, 0x4000070c)
-PROVIDE(_c_0x3fffc210, 0x40000734)
-PROVIDE(_c_0x80000000, 0x40000738)
-PROVIDE(_c_0x40000000, 0x40000760)
-PROVIDE(_c_0x7fffffff, 0x40000780)
-PROVIDE(_c_0x00ff0000, 0x40000798)
-
-PROVIDE(_X_start, 0x400007ac)
-
-PROVIDE(_c_0x3fffd820, 0x40000f50)
-PROVIDE(_X_ets_task, 0x40000f54)
-PROVIDE(_XX_unk0f84, 0x40000f84)
-PROVIDE(_XX_unk0f96, 0x40000f98)
-
-PROVIDE(_c_ets_critical_level, 0x400010a4)
-PROVIDE(_X_ets_enter_critical, 0x400010a8)
-PROVIDE(_X_ets_exit_critical, 0x400010bc)
-PROVIDE(_X_ets_exit_critical_and_wait_int, 0x400010d4)
-PROVIDE(_X_ets_isr_attach, 0x400010e8)  // 3 args
-PROVIDE(_X_ets_isr_mask, 0x400010f8)  // 1 arg
-PROVIDE(_X_ets_isr_unmask, 0x40001104)  // 1 arg
-
-PROVIDE(_c_0x3fffda30, 0x40001110)
-PROVIDE(_XX_set_0x3fffda30_0, 0x40001114)
-PROVIDE(_XX_set_0x3fffda30_4, 0x40001120)
-PROVIDE(_c_0xfffdffff, 0x4000112c)
-PROVIDE(_c_0x60003e00, 0x40001130)
-PROVIDE(_c_0x60008200, 0x40001134)
-PROVIDE(_c_0x60007e00, 0x40001138)
-PROVIDE(_c_0x1000, 0x4000113c)
-PROVIDE(_s_fw_build, 0x40001140)
-PROVIDE(_s_boot_banner, 0x40001144)
-PROVIDE(_s_pct_s_pct_u, 0x40001148)
-PROVIDE(_s_ets_main_c, 0x4000114c)
-PROVIDE(_X_main, 0x4000115c)
-
-PROVIDE(_l_strap_0x0xxx, 0x4000125a)
-PROVIDE(_l_strap_init_uart0, 0x40001269)
-PROVIDE(_l_strap_0x0x00, 0x400012e2)
-PROVIDE(_l_boot, 0x400012ea)
-PROVIDE(_l_rst_cause_345, 0x40001336)
-PROVIDE(_l_rst_cause_12, 0x40001342)
-PROVIDE(_l_strap_NxNxxx, 0x40001405)
-PROVIDE(_l_strap_0010xx, 0x4000144c)
-PROVIDE(_l_strap_001000_0x110x, 0x400014b0)
-PROVIDE(_l_strap_0x0x11_loader, 0x400014c9)  // loader
-PROVIDE(_l_strap_0x0x01, 0x400014d4)
-PROVIDE(_l_strap_0x0x10, 0x400014e6)
-PROVIDE(_c_0xffff8fff, 0x400014f0)
-PROVIDE(_c_0x60008e00, 0x400014f4)
-
-PROVIDE(_s_waiting_for_host, 0x4000152c)
-PROVIDE(_s_mem_banner, 0x40001cdc)
-PROVIDE(_c_stack_sentry, 0x40001ce0)
-PROVIDE(_XX_unk153c, 0x4000153c)
-
-PROVIDE(_c_data_end, 0x40001cd8)
-PROVIDE(_c_data_start, 0x40001ce4)
-PROVIDE(_X_print_mem_banner, 0x40001ce8)
-
-PROVIDE(_s_exc_sp_fmt, 0x40001d0c)
-PROVIDE(_s_exc_sf_dump_fmt, 0x40001d10)
-PROVIDE(_s_exc_regs_fmt, 0x40001d14)
-PROVIDE(_X_exc_handler, 0x40001d18)
-
-PROVIDE(_XX_unk1d90, 0x40001d90)
-
-PROVIDE(_X_ets_memset, 0x40001db4)
-PROVIDE(_X_ets_memcpy, 0x40001dc4)
-PROVIDE(_X_ets_memmove, 0x40001dd4)
-PROVIDE(_X_ets_memcmp, 0x40001de4)
-
-PROVIDE(_st_0x3fffda9c, 0x40002150)  // struct
-
-PROVIDE(_X_ets_uart_putc, 0x4000223c)
-PROVIDE(_X_ets_unk225c, 0x4000225c)
-
-PROVIDE(_c_0x4000223c_ets_uart_putc, 0x40002780)
-PROVIDE(_X_ets_install_uart_printf, 0x40002784)
-PROVIDE(_c_0x400027dc, 0x40002790)
-PROVIDE(_X_ets_install_external_printf, 0x40002794)
-PROVIDE(_X_ets_install_putc2, 0x400027b4)
-PROVIDE(_X_ets_get_printf_buf_remain_len, 0x400027c0)
-PROVIDE(_X_ets_reset_printf_buf_len, 0x400027cc)
-PROVIDE(_X_ets_putc, 0x400027dc)
-
-PROVIDE(_c_0xdfffffff, 0x400028d4)
-PROVIDE(_X_get_rst_cause, 0x400028d8)
-PROVIDE(_XX_unk2948, 0x40002948)
-PROVIDE(_l_2970, 0x40002970)
-PROVIDE(_X_sw_sys_rst, 0x4000297c)
-PROVIDE(_c_0x00400000, 0x400029b4)
-PROVIDE(_c_0xffbfffff, 0x400029b8)
-PROVIDE(_XX_apb_bridge_toggle, 0x400029bc)  // turns RTC_CNTL_APB2RTC_BRIDGE_SEL on and off
-PROVIDE(_X_ets_strcpy, 0x400029ec)
-PROVIDE(_X_ets_strncpy, 0x40002a00)
-PROVIDE(_X_ets_strcmp, 0x40002a10)
-PROVIDE(_X_ets_strncmp, 0x40002a24)
-PROVIDE(_X_ets_strlen, 0x40002a34)
-PROVIDE(_X_ets_strstr, 0x40002a40)
-
-PROVIDE(_st_0x3fffdb10_uartdev, 0x40002e4c)  // some struct - uartdev?
-
-PROVIDE(_c_0x3fffdb00, 0x40002e50)
-PROVIDE(_c_0x3fffdb04, 0x40002f64)
-PROVIDE(_XX_unk2e58, 0x40002e58)
-PROVIDE(_X_UartDwnLdProc, 0x40002f6c)
-PROVIDE(_c_0x00001800, 0x400030ec)
-PROVIDE(_X_FlashDwnLdStartMsgProc, 0x400030f0)
-PROVIDE(_XX_unk313c, 0x4000313c)
-PROVIDE(_XX_unk31bc, 0x400031bc)
-PROVIDE(_XX_unk31e4, 0x400031e4)
-PROVIDE(_XX_unk3210, 0x40003210)
-PROVIDE(_XX_unk3240, 0x40003240)
-PROVIDE(_X_MemDwnLdStopReqMsgProc, 0x4000329c)
-PROVIDE(_X_UartConnectProc, 0x400032c4)
-PROVIDE(_X_UartRegWriteProc, 0x400032d4)
-PROVIDE(_X_UartRegReadProc, 0x40003318)
-
-PROVIDE(_c_115200, 0x4000332c)
-PROVIDE(_c_0x3feffe00, 0x40003330)
-PROVIDE(_c_0xffff83ff, 0x40003334)
-PROVIDE(_c_0x00001400, 0x40003338)
-PROVIDE(_c_0x40003728_uart_int_handler, 0x4000333c)
-PROVIDE(_c_0x3fffdb2c_uart_int_handler_arg, 0x40003340)
-PROVIDE(_X_uart_attach, 0x40003344)
-PROVIDE(_XX_uart_set_unk33c0, 0x400033c0)
-PROVIDE(_c_0x5ffffe00, 0x400033cc)
-PROVIDE(_c_0x0000ffff, 0x400033d0)
-PROVIDE(_c_0x000fffff, 0x40003448)
-PROVIDE(_c_0x00060000, 0x400034e0)
-PROVIDE(_c_0xfff9ffff, 0x400034e4)
-
-PROVIDE(_c_0xfffc0fff, 0x40003520)
-PROVIDE(_c_0x00009000, 0x40003524)
-PROVIDE(_c_0x00020000, 0x40003528)
-PROVIDE(_c_13000000, 0x4000352c)
-PROVIDE(_c_0x08000000, 0x40003530)
-PROVIDE(_X_uart_init, 0x40003534)
-PROVIDE(_l_35f4, 0x400035f4)
-PROVIDE(_X_uart_wait_tx_empty, 0x4000369c)
-
-PROVIDE(_X_uart_int_handler, 0x40003728)
-
-PROVIDE(_X_uart_tx_one_char2, 0x40003664)
-
-PROVIDE(_X_send_packet, 0x400037d4)
-PROVIDE(_X_SendMsg, 0x40003828)
-PROVIDE(_X_recv_packet, 0x4000383c)
-PROVIDE(_X_RcvMsg, 0x40003988)
-PROVIDE(_X_uart_rx_readbuff, 0x400039a0)
-
-PROVIDE(_c_0x60004e00, 0x40003a18)
-PROVIDE(_X_SelectSpiFunction, 0x40003a1c)  // 1 arg - SPI number
-PROVIDE(_c_0x60002e00, 0x40003c78)
-PROVIDE(_X_SPI_chip_erase, 0x40003c7c)
-PROVIDE(_c_0x00ffffff, 0x40003cb4)
-PROVIDE(_c_0x01000000, 0x40003cb8)
-PROVIDE(_XX_unk3cbc, 0x40003cbc)
-PROVIDE(_c_0x00800000, 0x40003d00)
-PROVIDE(_c_0x02000000, 0x40003d4c)
-PROVIDE(_XX_unk3e24, 0x40003e24)
-PROVIDE(_X_SPI_read_status, 0x40003efc)
-PROVIDE(_c_0x90000000, 0x40003f48)
-PROVIDE(_c_0x70000035, 0x40003f4c)
-PROVIDE(_c_0x00040000, 0x40003f50)
-PROVIDE(_XX_unk3f54, 0x40003f54)
-PROVIDE(_c_0x04000000, 0x40003fcc)
-PROVIDE(_XX_unk4010, 0x40004010)
-PROVIDE(_X_SPI_write_enable, 0x400041bc)
-PROVIDE(_X_Wait_SPI_Idle, 0x40004208)
-PROVIDE(_l_4228, 0x40004228)
-PROVIDE(_l_4234, 0x40004234)
-PROVIDE(_XX_unk4238, 0x40004238)
-PROVIDE(_X_SPIFlashModeConfig, 0x400042d8)
-PROVIDE(_X_spi_flash_attach, 0x40004370)  // 2 args: SPI num, ???
-PROVIDE(_X_SPIReadModeConfig, 0x40004538)
-
-PROVIDE(_X_SPIEraseArea, 0x400048b4)
-PROVIDE(_XX_unk4940, 0x40004940)
-
-PROVIDE(_st_0x3fffdc90, 0x40004d80)
-PROVIDE(_XX_unk4d88, 0x40004d88)
-PROVIDE(_XX_unk4f6c, 0x40004f6c)
-PROVIDE(_XX_unk4fc8, 0x40004fc8)
-
-PROVIDE(_c_0xbfffffff, 0x40004c80)
-PROVIDE(_c_0xff000fff, 0x40004c88)
-PROVIDE(_XX_unk4f14, 0x40004f14)
-PROVIDE(_s_no_rds, 0x40005008)
-PROVIDE(_XX_unk500c, 0x4000500c)
-
-PROVIDE(_fp_0x40004f6c, 0x40005164)
-PROVIDE(_fp_0x40004fc8, 0x40005168)
-PROVIDE(_X_sip_init_attach, 0x40005170)  // 1 arg, boot_mode?
-PROVIDE(_XX_unk51ac, 0x400051ac)
-PROVIDE(_c_0x60017e00, 0x40005478)
-PROVIDE(_st_0x3fffdf70, 0x400054a4)
-PROVIDE(_c_0x6000ae00, 0x400054b8)
-PROVIDE(_c_0xf0000000, 0x400054bc)
-PROVIDE(_c_0x02320017, 0x400054c0)
-PROVIDE(_c_0x11116666, 0x400054c4)
-PROVIDE(_c_0x01110013, 0x400054e4)
-PROVIDE(_X_slc_init_attach, 0x400054e8)  // 4 args - fp, fp, st, boot_mode; PRODPORT_SDIO_RST
-PROVIDE(_l_slc_boot_mode_4, 0x40005654)
-PROVIDE(_X_slc_enable, 0x40005678)
-PROVIDE(_X_slc_select_tohost_gpio_mode, 0x400056fc)
-PROVIDE(_X_slc_select_tohost_gpio, 0x40005708)
-PROVIDE(_c_0xff300000, 0x40005730)
-PROVIDE(_XX_unk5734, 0x40005734)
-PROVIDE(_XX_unk57b8, 0x400057b8)
-PROVIDE(_XX_unk57f4, 0x400057f4)
-PROVIDE(_XX_unk5848, 0x40005848)
-
-PROVIDE(_c_0xfffff0c0, 0x40005988)
-PROVIDE(_X_slc_set_host_io_max_window, 0x4000598c)
-PROVIDE(_X_slc_init_credit, 0x400059ac)
-PROVIDE(_X_slc_add_credits, 0x400059c4)
-
-PROVIDE(_X_xtos_set_interrupt_handler_arg, 0x400059d8)
-PROVIDE(_X_xtos_set_interrupt_handler, 0x40005a24)
-PROVIDE(_X_xtos_ints_on, 0x40005a34)
-PROVIDE(_X_xtos_ints_off, 0x40005a58)
-
-PROVIDE(_XX_xtos_exc_unk5a80, 0x40005a80)
-PROVIDE(_XX_xtos_exc_unk5b94, 0x40005b94)

src/common/platforms/esp32/rom/.gitattributes

-rom.bin -nodiff
-rom.elf -nodiff

src/common/platforms/esp32/rom/disasm.sh

-#!/bin/bash
-
-xtensa-esp32-elf-gcc -Wl,-N,-Ttext,0x40000000 -nostdlib rom.S -o rom.elf && \
-  xtensa-esp32-elf-objdump -d rom.elf > ESP32_ROM.txt

src/common/platforms/esp32/rom/rom.S

-.text
-.org 0
-.globl _start
-
-// xtensa-esp32-elf-gcc -Wl,-N,-Ttext,0x40000000 -nostdlib rom.S -o rom.elf
-
-here = .
-#define PROVIDE(name, addr) name = here + addr - 0x40000000
-
-#include "rom_functions.S"
-
-PROVIDE ( _x_unk_40061b88, 0x40061b88 )
-PROVIDE ( _x_unk_spi_400622c0, 0x400622c0 )
-PROVIDE ( _c_3ff000c8, 0x40062df0 )
-PROVIDE ( _c_3ff5b024, 0x40062e0c )
-PROVIDE ( _c_3ff5b000, 0x40062e10 )
-PROVIDE ( _c_3ff5b020, 0x40062e14 )
-PROVIDE ( _c_3ff5b028, 0x40062e18 )
-PROVIDE ( _l_40062e90, 0x40062e90 )
-PROVIDE ( _l_SPI_Prepare_Encrypt_Data_loop, 0x40062e34 )
-PROVIDE ( _l_SPI_Prepare_Encrypt_Data_wait, 0x40062e54 )
-PROVIDE ( _l_SPI_Prepare_Encrypt_Data_out, 0x40062e5e )
-
-.text
-
-_start:
-.incbin "rom.bin"
-_end:

src/common/platforms/esp32/stubs/Makefile

-#
-# Copyright (c) 2015 Cesanta Software Limited
-# All rights reserved
-#
-
-STUB = stub_hello.c
-LIBS =
-PARAMS =
-PORT = /dev/ttyUSB0
-
-BUILD_DIR = .build
-COMMON_STUB_DIR = ../../esp
-STUB_ELF = $(BUILD_DIR)/$(patsubst %.c,%.elf,$(notdir $(STUB)))
-STUB_JSON ?= $(BUILD_DIR)/$(patsubst %.c,%.json,$(notdir $(STUB)))
-SDK = $(shell cat ../../../../fw/platforms/esp32/sdk.version)
-XT_CC = xtensa-esp32-elf-gcc
-
-.PHONY: all clean run wrap
-
-all: $(STUB_ELF)
-
-$(STUB_ELF): $(STUB) $(LIBS)
-	@echo "  CC   $^ -> $@"
-	@[ -d $(BUILD_DIR) ] || mkdir $(BUILD_DIR)
-	@docker run --rm -i -v $(CURDIR)/../../../..:/src $(SDK) //bin/bash -c \
-    "cd /src/common/platforms/esp32/stubs && \
-     $(XT_CC) -std=c99 -Wall -Werror -Os -DESP32 \
-         -mtext-section-literals -mlongcalls -nostdlib -fno-builtin \
-         -I. -I/src/common/platforms/esp \
-         -I/opt/Espressif/esp-idf/components/esp32/include \
-         -I/opt/Espressif/esp-idf/components/soc/esp32/include \
-         -L/opt/Espressif/esp-idf -Wl,-static \
-         -ffunction-sections -Wl,--gc-sections \
-         -Tstub.ld -o $@ $^"
-
-wrap: $(STUB_JSON)
-
-$(STUB_JSON): $(STUB_ELF) $(COMMON_STUB_DIR)/esptool.py
-	@echo "  WRAP $< -> $@"
-	@docker run --rm -i -v $(CURDIR)/../../../..:/src $(SDK) //bin/bash -c \
-    "cd /src/common/platforms/esp32/stubs && \
-     $(COMMON_STUB_DIR)/esptool.py wrap_stub $<" > $@
-
-run: $(STUB_JSON)
-	@echo "  RUN  $< $(PARAMS) -> $(PORT)"
-	@docker run --rm -i --privileged -v $(CURDIR)/../../../..:/src $(SDK) //bin/bash -c \
-    "cd /src/common/platforms/esp32/stubs && \
-     $(COMMON_STUB_DIR)/esptool.py --port $(PORT) run_stub $< $(PARAMS)"
-
-clean:
-	@rm -rf $(BUILD_DIR)

src/common/platforms/esp32/stubs/README.md

-This is a ESP boot loader stub development environment.
-
-Code produced in this environment can be loaded and executed
-in the bootloader environment. Usually it is used to implement
-functionality not found in the bootloader.
-
-Stubs can be executed using the `run_stub` command of the modified esptool.py provided.
-`wrap_stub` produces a JSON represenattion of the stub that can later be reused
-or built into other tools.
-
-Example usage:
-  $ make run STUB=stub_flash_size.c PORT=/dev/ttyUSB0
-  $ make run STUB=stub_md5.c PORT=/dev/ttyUSB0 PARAMS="0x11000 10000 1"

src/common/platforms/esp32/stubs/led.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 "soc/gpio_reg.h"
-
-void led_setup(int io) {
-  if (io < 32) {
-    WRITE_PERI_REG(GPIO_ENABLE_W1TS_REG, 1 << io);
-  } else {
-    WRITE_PERI_REG(GPIO_ENABLE1_W1TS_REG, 1 << (io - 32));
-  }
-}
-
-void led_on(int io) {
-  if (io < 32) {
-    WRITE_PERI_REG(GPIO_OUT_W1TS_REG, 1 << io);
-  } else {
-    WRITE_PERI_REG(GPIO_OUT1_W1TS_REG, 1 << (io - 32));
-  }
-}
-
-void led_off(int io) {
-  if (io < 32) {
-    WRITE_PERI_REG(GPIO_OUT_W1TC_REG, 1 << io);
-  } else {
-    WRITE_PERI_REG(GPIO_OUT1_W1TC_REG, 1 << (io - 32));
-  }
-}
-
-void led_toggle(int io) {
-  if (READ_PERI_REG(GPIO_OUT_REG & (1 << io))) {
-    WRITE_PERI_REG(GPIO_OUT_W1TC_REG, 1 << io);
-  } else {
-    WRITE_PERI_REG(GPIO_OUT_W1TS_REG, 1 << io);
-  }
-}

src/common/platforms/esp32/stubs/led.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#pragma once
-
-void led_setup(int io);
-void led_on(int io);
-void led_off(int io);
-void led_toggle(int io);

src/common/platforms/esp32/stubs/rom_functions.h

-#ifndef CS_COMMON_PLATFORMS_ESP32_STUBS_ROM_FUNCTIONS_H_
-#define CS_COMMON_PLATFORMS_ESP32_STUBS_ROM_FUNCTIONS_H_
-
-#include "rom/ets_sys.h"
-#include "rom/spi_flash.h"
-#include "rom/md5_hash.h"
-#include "rom/uart.h"
-#include "rom/rtc.h"
-
-#endif /* CS_COMMON_PLATFORMS_ESP32_STUBS_ROM_FUNCTIONS_H_ */

src/common/platforms/esp32/stubs/sdkconfig.h

-#define CONFIG_SPI_FLASH_ROM_DRIVER_PATCH 1

src/common/platforms/esp32/stubs/stub.ld

-/*
- * Copyright (c) 2016 Cesanta Software Limited
- * All rights reserved
- */
-
-MEMORY {
-  iram     : org = 0x40090000, len = 0x10000
-  /* DRAM startin at 0x3FFC0000 gets stomped by something before mem_finish
-   * and is thus not suitable for initialized data, but works fine for BSS. */
-  dram_bss : org = 0x3FFC0000, len = 0x10000
-  dram     : org = 0x3FFD0000, len = 0x10000
-}
-
-ENTRY(stub_main)
-
-SECTIONS {
-  .params 0x40090000 : {
-    _params_start = ABSOLUTE(.);
-    *(.params)
-    _params_end = ABSOLUTE(.);
-  } > iram
-
-  .text : ALIGN(4) {
-    _code_start = ABSOLUTE(.);
-    *(.literal)
-    *(.text .text.*)
-  } > iram
-
-  .bss : ALIGN(4) {
-    _bss_start = ABSOLUTE(.);
-    *(.bss)
-    _bss_end = ABSOLUTE(.);
-  } > dram
-
-  .data : ALIGN(4) {
-    _data_start = ABSOLUTE(.);
-    *(.data)
-    *(.rodata .rodata.*)
-  } > dram
-}
-
-INCLUDE "components/esp32/ld/esp32.rom.ld"
-INCLUDE "components/esp32/ld/esp32.rom.spiram_incompatible_fns.ld"
-
-PROVIDE(ets_isr_mask = 0x400067fc);
-PROVIDE(ets_isr_unmask = 0x40006808);
-PROVIDE(MD5Init = 0x4005da7c);
-PROVIDE(MD5Update = 0x4005da9c);
-PROVIDE(MD5Final = 0x4005db1c);
-PROVIDE(esp_rom_spiflash_attach = 0x40062a6c);
-PROVIDE(esp_rom_spiflash_config_clk = 0x40062bc8);

src/common/platforms/esp32/stubs/stub_hello.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 <inttypes.h>
-#include <string.h>
-#include "slip.h"
-
-/* Define the args vector and put it into the ".params" section. */
-uint32_t params[3] __attribute__((section(".params")));
-
-/* Define a function called stub_main. Do not return or reboot.
- * Use send_packet to communicate to the host. */
-
-const char *hello = "Hello";
-
-static char buf[1024];
-extern uint32_t _bss_start, _bss_end;
-
-void stub_main(void) {
-  uint32_t greeting = 0x4941484f;
-  SLIP_send(&greeting, 4);
-  memset(&_bss_start, 0, (&_bss_end - &_bss_start));
-  buf[1] = 123;
-  SLIP_send(hello, 5);
-  while (1) {
-  }
-}

src/common/platforms/esp32/stubs/uart.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 "uart.h"
-
-#include "rom_functions.h"
-
-uint32_t set_baud_rate(uint32_t uart_no, uint32_t old_baud_rate,
-                       uint32_t new_baud_rate) {
-  uint32_t uart_reg = REG_READ(UART_CLKDIV_REG(uart_no));
-  uint32_t uart_div = uart_reg & UART_CLKDIV_M;
-  uint32_t fraction = (uart_reg >> UART_CLKDIV_FRAG_S) & UART_CLKDIV_FRAG_V;
-  uart_div = (uart_div << 4) + fraction;
-  uint32_t master_freq = uart_div * old_baud_rate;
-  uart_div_modify(uart_no, master_freq / new_baud_rate);
-  return uart_div;
-}

src/common/platforms/esp32/stubs/uart.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#ifndef CS_COMMON_PLATFORMS_ESP32_STUBS_UART_H_
-#define CS_COMMON_PLATFORMS_ESP32_STUBS_UART_H_
-
-#include <stdint.h>
-
-uint32_t set_baud_rate(uint32_t uart_no, uint32_t old_baud_rate,
-                       uint32_t new_baud_rate);
-
-#endif /* CS_COMMON_PLATFORMS_ESP32_STUBS_UART_H_ */

src/common/platforms/esp8266/common.mk

-CFLAGS_EXTRA ?=
-
-XTENSA_TOOLS_ROOT ?= /opt/Espressif/crosstool-NG/builds/xtensa-lx106-elf/bin
-SDK_PATH ?= /opt/Espressif/ESP8266_SDK
-ESPTOOL ?= esptool.py
-ESPPORT ?= /dev/ttyACM0
-ESPSPEED ?= 230400
-# For flash = > 16Mbit
-ESPFLASHARGS = --flash_mode dio --flash_size 32m
-
-VERBOSE ?= 0
-
-CC := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-gcc
-CXX := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-g++
-AR := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-ar
-LD := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-gcc
-OBJCOPY := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-objcopy
-NM := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-nm
-CC_WRAPPER ?=
-
-define link
-$(vecho) "LD    $@"
-$(Q) $(CC_WRAPPER) $(LD) $(LIBDIRS) -T$(LD_SCRIPT) $(LDFLAGS) -o $@ \
--Wl,-Map=$@.map -Wl,--start-group $1 -Wl,--end-group
-endef
-
-define compile_params
-$(vecho) "$5    $1"
-$(Q) $(CC_WRAPPER) $3 -MD -MP $(INCDIRS) $4 -c $1 -o $2
-endef
-
-define compile
-$(call compile_params,$<,$@, $(CC), $(CFLAGS),"CC")
-endef
-
-define compile_cxx
-$(call compile_params,$<,$@, $(CXX), $(CXXFLAGS),"CXX")
-endef
-
-# some of these flags works around for gdb 7.5.x stacktrace issue
-# while still allowing -Os to remove padding between data in .rodata
-# section, allowing us to gain about 1k of ram.
-# text section is 4k bigger, but we care more about ram at the moment.
-# TODO(mkm): figure out which flag(s).
-NO_Os_FLAGS= -fno-expensive-optimizations -fno-thread-jumps \
-             -fno-align-functions -fno-align-jumps \
-             -fno-align-loops -fno-align-labels -fno-caller-saves \
-             -fno-crossjumping -fno-cse-follow-jumps -fno-cse-skip-blocks \
-             -fno-delete-null-pointer-checks -fno-devirtualize  \
-             -fno-gcse -fno-gcse-lm -fno-hoist-adjacent-loads \
-             -fno-inline-small-functions -fno-indirect-inlining -fno-partial-inlining \
-             -fno-ipa-cp -fno-ipa-sra -fno-peephole2 -fno-optimize-sibling-calls -fno-optimize-strlen \
-             -fno-reorder-blocks -fno-reorder-blocks-and-partition -fno-reorder-functions \
-             -fno-sched-interblock -fno-sched-spec -fno-rerun-cse-after-loop \
-             -fno-schedule-insns -fno-schedule-insns2 -fno-strict-aliasing -fno-strict-overflow \
-             -fno-tree-builtin-call-dce -fno-tree-switch-conversion -fno-tree-tail-merge \
-             -fno-tree-pre -fno-tree-vrp
-
-C_CXX_FLAGS  = -W -Wall -Werror -Wundef -Wno-comment -Wno-variadic-macros -Wpointer-arith \
-               -Wno-missing-field-initializers \
-               -pipe -Os $(NO_Os_FLAGS) -g3 \
-               -Wl,-EL -fno-inline-functions \
-               -D_XOPEN_SOURCE=500 \
-               -nostdlib -mlongcalls -mtext-section-literals -D__ets__ -DSTATIC=static \
-               -Wno-parentheses \
-               -DIRAM='__attribute__((section(".fast.text")))' \
-               -DICACHE_RAM_ATTR=IRAM \
-               -DNOINSTR='__attribute__((no_instrument_function))' \
-               -DCS_PLATFORM=3 \
-               -ffunction-sections -fdata-sections
-
-CFLAGS = -std=gnu99 $(C_CXX_FLAGS)
-CXXFLAGS = -std=gnu++11 -fno-exceptions $(C_CXX_FLAGS)
-
-# linker flags used to generate the main object file
-LDFLAGS = -nostdlib -Wl,--no-check-sections -u call_user_start \
-          -Wl,-static -Wl,--gc-sections

src/common/platforms/esp8266/esp_crypto.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "mongoose.h"
-
-#ifdef RTOS_SDK
-#include "esp_libc.h"
-#else
-#include "osapi.h"
-#endif
-
-extern int sha1_vector(size_t num_msgs, const uint8_t *msgs[],
-                       const size_t *msg_lens, uint8_t *digest);
-
-extern int md5_vector(size_t num_msgs, const uint8_t *msgs[],
-                      const size_t *msg_lens, uint8_t *digest);
-
-/* For digest auth. */
-void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[],
-                   const size_t *msg_lens, uint8_t *digest) {
-  (void) md5_vector(num_msgs, msgs, msg_lens, digest);
-}
-
-/* For WebSocket handshake. */
-void mg_hash_sha1_v(size_t num_msgs, const uint8_t *msgs[],
-                    const size_t *msg_lens, uint8_t *digest) {
-  (void) sha1_vector(num_msgs, msgs, msg_lens, digest);
-}

src/common/platforms/esp8266/esp_hw_wdt_register.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#ifndef CS_COMMON_PLATFORMS_ESP8266_ESP_HW_WDT_REGISTER_H_
-#define CS_COMMON_PLATFORMS_ESP8266_ESP_HW_WDT_REGISTER_H_
-
-#ifdef RTOS_SDK
-#include <esp_common.h>
-#else
-#include <user_interface.h>
-#endif
-
-#define REG_WDT_BASE 0x60000900
-
-#define WDT_CTL (REG_WDT_BASE + 0x0)
-#define WDT_CTL_ENABLE (BIT(0))
-#define WDT_CTL_STAGE1_NO_RESET (BIT(1))
-#define WDT_CTL_STAGE1_DISABLE (BIT(2))
-#define WDT_CTL_UNK3 (BIT(3))
-#define WDT_CTL_UNK4 (BIT(4))
-#define WDT_CTL_UNK5 (BIT(5))
-
-/* Bits 3, 4, 5 - ???; set to 1 by ROM. */
-
-#define WDT_RELOAD_STAGE0 (REG_WDT_BASE + 0x4)
-#define WDT_RELOAD_STAGE0_V (0xf)
-#define WDT_RELOAD_STAGE0_S (0)
-
-#define WDT_RELOAD_STAGE1 (REG_WDT_BASE + 0x8)
-#define WDT_RELOAD_STAGE1_V (0xf)
-#define WDT_RELOAD_STAGE1_S (0)
-
-#define WDT_COUNT (REG_WDT_BASE + 0xc) /* Counts at CPU_CLK (80 MHz) */
-#define WDT_COUNT_V (0xffffffff)
-#define WDT_COUNT_S (0)
-
-#define WDT_STAGE (REG_WDT_BASE + 0x10)
-#define WDT_STAGE_V (1)
-#define WDT_STAGE_S (0)
-
-#define WDT_RESET (REG_WDT_BASE + 0x14)
-#define WDT_RESET_V (0xff)
-#define WDT_RESET_S (0)
-
-#define WDT_RESET_STAGE (REG_WDT_BASE + 0x18)
-#define WDT_RESET_STAGE_V (0xff)
-#define WDT_RESET_STAGE_S (0)
-
-#define WDT_RESET_VALUE 0x73
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_ESP_HW_WDT_REGISTER_H_ */

src/common/platforms/esp8266/esp_missing_includes.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#ifndef CS_COMMON_PLATFORMS_ESP8266_ESP_MISSING_INCLUDES_H_
-#define CS_COMMON_PLATFORMS_ESP8266_ESP_MISSING_INCLUDES_H_
-
-#include <stdint.h>
-#include <stdlib.h>
-
-void pp_soft_wdt_init(void);
-void pp_soft_wdt_stop(void);
-void pp_soft_wdt_feed(void);
-void pp_soft_wdt_restart(void);
-void system_soft_wdt_stop(void); /* Alias for pp_soft_wdt_stop */
-
-void Cache_Read_Disable(void);
-void Cache_Read_Enable(uint32_t, uint32_t, uint32_t);
-void Cache_Read_Disable_2(void);
-void Cache_Read_Enable_2(void);
-void Cache_Read_Enable_New(void);
-
-int SPIEraseBlock(uint32_t block);
-uint32_t SPIRead(uint32_t addr, void *dst, uint32_t size);
-
-#ifndef RTOS_SDK
-
-#include <ets_sys.h>
-
-/* There are no declarations for these anywhere in the SDK (as of 1.2.0). */
-void ets_isr_mask(unsigned intr);
-void ets_isr_unmask(unsigned intr);
-void system_restart_local(void);
-int os_printf_plus(const char *format, ...);
-
-void ets_wdt_init(void);
-void ets_wdt_enable(uint32_t mode, uint32_t arg1, uint32_t arg2);
-void ets_wdt_disable(void);
-void ets_wdt_restore(uint32_t mode);
-uint32_t ets_wdt_get_mode(void);
-
-void _xtos_l1int_handler(void);
-void _xtos_set_exception_handler();
-void xthal_set_intenable(unsigned);
-
-/* These are present in mem.h but are commented out. */
-void *pvPortMalloc(size_t xWantedSize, const char *file, int line);
-void vPortFree(void *pv, const char *file, int line);
-void *pvPortZalloc(size_t size, const char *file, int line);
-void *pvPortRealloc(void *pv, size_t size, const char *file, int line);
-
-#else /* !RTOS_SDK */
-
-#define BIT(nr) (1UL << (nr))
-void system_soft_wdt_feed(void);
-void system_soft_wdt_restart(void);
-void ets_putc(char c);
-
-#endif /* RTOS_SDK */
-
-void _ResetVector(void);
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_ESP_MISSING_INCLUDES_H_ */

src/common/platforms/esp8266/esp_ssl_krypton.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#ifndef CS_COMMON_PLATFORMS_ESP8266_ESP_SSL_KRYPTON_H_
-#define CS_COMMON_PLATFORMS_ESP8266_ESP_SSL_KRYPTON_H_
-
-#include "krypton/krypton.h"
-
-struct mg_connection;
-
-void mg_lwip_ssl_do_hs(struct mg_connection *nc);
-void mg_lwip_ssl_send(struct mg_connection *nc);
-void mg_lwip_ssl_recv(struct mg_connection *nc);
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_ESP_SSL_KRYPTON_H_ */

src/common/platforms/esp8266/esp_umm_malloc.c

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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 <string.h>
-#include <stdio.h>
-#include "common/umm_malloc/umm_malloc.h"
-#include "esp_umm_malloc.h"
-
-#if ESP_UMM_ENABLE
-
-/*
- * ESP-specific glue for the `umm_malloc`.
- *
- * In SDK (https://github.com/cesanta/esp-open-sdk), there is an archive
- * `sdk/lib/libmain.a` which contains some files, including `mem_manager.o`.
- *
- * The `mem_manager.o` contains all the heap-related functions: `pvPortMalloc`,
- * etc. We have weaken all symbols from `mem_manager.o` by
- * `xtensa-lx106-elf-objcopy` (see exact commands in Dockerfile:
- * `docker/esp8266/Dockerfile-esp8266-build-oss`), and provide our own
- * implementations in this file.
- *
- * ------------------------------------
- *
- * NOTE that not all public functions from `mem_manager.o` need to be replaced:
- * some of them are used only internally:
- *
- * - system_show_malloc()
- * - pvShowMalloc()
- * - prvInsertBlockIntoUsedList()
- * - prvRemoveBlockFromUsedList()
- * - check_memleak_debug_enable()
- * - vPortInitialiseBlocks()
- *
- * So when we replace all the rest (`pvPortMalloc`, etc), we can check with
- * `objdump` that resulting binary (for SJ, it's `fw.out`) doesn't contain
- * any of the "internal" functions.
- *
- * ------------------------------------
- *
- * NOTE that to make linker actually consider implementations in this file,
- * you should explicitly reference some function from it. This is what
- * `esp_umm_init()` is for: it is a dummy no-op function that must be called
- * from somewhere outside.
- *
- * If you don't do this, linker will merely garbage-collect this file, and
- * will use heap implementation from SDK.
- */
-
-void *pvPortMalloc(size_t size, const char *file, unsigned line) {
-  (void) file;
-  (void) line;
-
-  return umm_malloc(size);
-}
-
-void *pvPortCalloc(size_t num, size_t size, const char *file, unsigned line) {
-  (void) file;
-  (void) line;
-
-  return umm_calloc(num, size);
-}
-
-void *pvPortZalloc(size_t size, const char *file, unsigned line) {
-  void *ret;
-
-  (void) file;
-  (void) line;
-
-  ret = umm_malloc(size);
-  if (ret != NULL) memset(ret, 0, size);
-  return ret;
-}
-
-void *pvPortRealloc(void *ptr, size_t size, const char *file, unsigned line) {
-  (void) file;
-  (void) line;
-
-  return umm_realloc(ptr, size);
-}
-
-void vPortFree(void *ptr, const char *file, unsigned line) {
-  (void) file;
-  (void) line;
-
-  umm_free(ptr);
-}
-
-size_t xPortGetFreeHeapSize(void) {
-  return umm_free_heap_size();
-}
-
-size_t xPortWantedSizeAlign(void) {
-  return 4;
-}
-
-void esp_umm_init(void) {
-  /* Nothing to do, see header for details */
-}
-
-void esp_umm_oom_cb(size_t size, size_t blocks_cnt) {
-  fprintf(stderr, "E:M %u (%u blocks)\n", (unsigned int) size,
-          (unsigned int) blocks_cnt);
-}
-
-#endif /* ESP_UMM_ENABLE */

src/common/platforms/esp8266/esp_umm_malloc.h

-/*
- * Copyright (c) 2014-2018 Cesanta Software Limited
- * All rights reserved
- *
- * 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.
- */
-
-#if ESP_UMM_ENABLE
-
-/*
- * This is a no-op dummy function that is merely needed because we have to
- * reference any function from the file `esp_umm_malloc.c`, so that linker
- * won't garbage-collect the whole compilation unit.
- */
-void esp_umm_init(void);
-
-/*
- * Callback that gets called by umm_malloc in case of Out-of-memory error.
- *
- * `size` is the size requested by user, and `block_cnt` is a number of heap
- * blocks that umm_malloc failed to allocate
- */
-void esp_umm_oom_cb(size_t size, size_t blocks_cnt);
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_ESP_UMM_MALLOC_H_ */

src/common/platforms/esp8266/rboot/esptool2/Makefile

-#
-# Makefile for esptool2
-# https://github.com/raburton/esp8266
-#
-
-CFLAGS = -O2 -Wall
-CC = gcc
-LD = gcc
-BUILD_DIR = ../../build
-
-all: $(BUILD_DIR) $(BUILD_DIR)/esptool2
-
-$(BUILD_DIR):
-	@mkdir -p $(BUILD_DIR)
-
-$(BUILD_DIR)/esptool2.o: esptool2.c esptool2.h esptool2_elf.h elf.h
-	@echo "CC $<"
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(BUILD_DIR)/esptool2_elf.o: esptool2_elf.c esptool2.h esptool2_elf.h elf.h
-	@echo "CC $<"
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(BUILD_DIR)/esptool2: $(BUILD_DIR)/esptool2.o $(BUILD_DIR)/esptool2_elf.o
-	@echo "LD $@"
-	$(LD) -o $@ $^

src/common/platforms/esp8266/rboot/esptool2/esptool2.h

-/**********************************************************************************
-*
-*    Copyright (c) 2015 Richard A Burton <richardaburton@gmail.com>
-*
-*    This file is part of esptool2.
-*
-*    esptool2 is free software: you can redistribute it and/or modify
-*    it under the terms of the GNU General Public License as published by
-*    the Free Software Foundation, either version 3 of the License, or
-*    (at your option) any later version.
-*
-*    esptool2 is distributed in the hope that it will be useful,
-*    but WITHOUT ANY WARRANTY; without even the implied warranty of
-*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*    GNU General Public License for more details.
-*
-*    You should have received a copy of the GNU General Public License
-*    along with esptool2.  If not, see <http://www.gnu.org/licenses/>.
-*
-**********************************************************************************/
-
-#ifndef CS_COMMON_PLATFORMS_ESP8266_RBOOT_ESPTOOL2_ESPTOOL2_H_
-#define CS_COMMON_PLATFORMS_ESP8266_RBOOT_ESPTOOL2_ESPTOOL2_H_
-
-#ifdef WIN32
-typedef signed __int8     int8_t;
-typedef signed __int16    int16_t;
-typedef signed __int32    int32_t;
-typedef unsigned __int8   uint8_t;
-typedef unsigned __int16  uint16_t;
-typedef unsigned __int32  uint32_t;
-#else
-#include <stdint.h>
-#endif
-
-#define true 1
-#define false 0
-#define bool char
-
-void debug( const char* format, ... );
-void print( const char* format, ... );
-void error( const char* format, ... );
-
-#endif /* CS_COMMON_PLATFORMS_ESP8266_RBOOT_ESPTOOL2_ESPTOOL2_H_ */

src/common/platforms/esp8266/rboot/esptool2/readme.txt

-Esptool2
-richardaburton@gmail.com
-http://richard.burtons.org/
-
-Esptool2 is a tool for creating rom images for the ESP8266. It is an alternative
-to using the SDK supplied shell script/Makefile/python script combo, which is a
-mess. It was inspired by the windows esptool v0.0.2 by mamalala and found on
-www.esp8266.com but made somewhat simpler in code and usage. It also adds
-support for boot loader v1.2+ rom types, which was the main reason I wrote it.
-
-It was written for my own use and the name was simply to distinguish it for the
-other version on my system. The 2 is not intended to imply it is better than the
-original. The original has since been updated to v0.0.3 which can write to the
-flash, but I currently have no intention to add that to esptool2, it is purely a
-rom creating utility. It has become an integral part of my build process now and
-has added functionality needed for building the rBoot boot loader. Since I have
-released rBoot I needed to release this as well.
-
-Run tool for full usage instructions, or look at the code.