Do not post MG_SIG_CLOSE_CONN if the conn is already closing

tcp_close_tcpip() only closed active TCP PCBs, leaking other types of TCP PCBs
(notably bound only, not yet connected/used).  With time, this led to DoS
situations.

Fix by giving up on the hacky way of searching the LWIP innards for the TCP PCB
needing closing.  The searching was non-comprehensive, hence the problem in
principle, and inherently racy: could close a meanwhile freed & reused PCB.

Pass the pointer to the struct mg_lwip_conn_state of the struct mg_connection
being destroyed to tcp_close_tcpip() instead of the bare PCB pointer, so the PCB
pointer stored within can be used.  Delay unassigning that pointer from the
struct mg_connection until tcp_close_tcpip() finishes, so that
a mg_lwip_tcp_error_cb() meanwhile can clear the PCB pointer stored within.
That ensures no double-closing of the TCP PCB when a concurrent TCP error makes
LWIP close the TCP PCB from the LWIP side.

NB!  At the moment, PCBs can still leak if tcp_close() fails, which is unlikely
but possible as per the API.  Retrying tcp_close() should somehow be
implemented.  For now, at least add logging of tcp_close() failures.

Also: remove the extraneous though benign double-calling of tcp_arg(…, NULL).

h/t @QRPp

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: false

.github/ISSUE_TEMPLATE/issue.md

@@ -1,21 +0,0 @@
----
-name: Issue template
-about: Please fill this issue template for reporting Mongoose issues
-#title: 
-#labels: 
-#assignees: 
----
-
-- My goal is: _describe_
-- My actions were: _describe_
-- My expectation was: _describe_
-- The result I saw: _provide logs or description_
-- My question is: _your question_
-
-# Environment
-
-- mongoose version: _X.Y_
-- Compiler/IDE and SDK: ZZZ version _X.Y_
-- Target hardware/board: _?_
-- Connectivity chip/module: _?_
-- Target RTOS/OS (if applicable): _?_

.github/workflows/cifuzz.yml

@@ -1,36 +0,0 @@
-name: CIFuzz
-on:
-  schedule:
-    - cron: '0 2 * * *' # run at 2 AM UTC
-  # Allow manual runs
-  workflow_dispatch:
-
-jobs:
-  Fuzzing:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^src/' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - name: Build Fuzzers
-      id: build
-      if: ${{ env.GO == 1 }}
-      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
-      with:
-        oss-fuzz-project-name: 'mongoose'
-        dry-run: false
-        language: c++
-    - name: Run Fuzzers
-      if: ${{ env.GO == 1 }}
-      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
-      with:
-        oss-fuzz-project-name: 'mongoose'
-        fuzz-seconds: 600
-        dry-run: false
-        language: c++
-    - name: Upload Crash
-      uses: actions/upload-artifact@v4
-      if: env.GO == 1 && failure() && steps.build.outcome == 'success'
-      with:
-        name: artifacts
-        path: ./out/artifacts

.github/workflows/codeql.yml

@@ -1,32 +0,0 @@
-name: "CodeQL Scanning"
-# https://github.com/github/codeql-action
-
-on:
-  schedule:
-    - cron: '30 23 * * *' # run at 11:30 PM UTC
-  # Allow manual runs
-  workflow_dispatch:
-
-env:
-  IPV6: 0
-jobs:
-  CodeQL-Build:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    permissions:
-      security-events: write
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: cpp
-    - run: |
-        make -C test test CC=gcc ASAN= ASAN_OPTIONS=
-        ./test/setup_ga_network.sh && make -C test mip_test CC=gcc ASAN= ASAN_OPTIONS=
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3

.github/workflows/fuzz.yml

@@ -1,20 +0,0 @@
-name: Fuzz
-on:
-  schedule:
-    - cron: '0 21 * * *' # run at 9 PM UTC
-  # Allow manual runs
-  workflow_dispatch:
-env:
-  CC: clang
-jobs:
-  fuzz:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        target: [fuzz, fuzz_tls]
-    name: ${{ matrix.target }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: make -C test ${{ matrix.target }}

.github/workflows/nightly.yml

@@ -1,579 +0,0 @@
-name: Full build and test
-on:
-  schedule:
-    - cron: '0 22 * * *' # run at 10 PM UTC
-  # Allow manual runs
-  workflow_dispatch:
-env:
-  IPV6: 0
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        cc: [gcc, clang, g++, clang++]
-        target: [test]
-        ssl: ["", BUILTIN, MBEDTLS, OPENSSL, WOLFSSL]
-        select: ["-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0", "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0", "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=1"]
-        exclude:
-        - ssl: MBEDTLS
-          select: "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0"
-        - ssl: MBEDTLS
-          select: "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0"
-        - ssl: OPENSSL
-          select: "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0"
-        - ssl: OPENSSL
-          select: "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0"
-        - ssl: WOLFSSL
-          select: "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0"
-        - ssl: WOLFSSL
-          select: "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0"
-    name: linux ${{ matrix.target }} CC=${{ matrix.cc }} SSL=${{ matrix.ssl }} TFLAGS=${{ matrix.select }}
-    env:
-      CC: ${{ matrix.cc }}
-      SSL: ${{ matrix.ssl }}
-      TFLAGS: ${{ matrix.select }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: sudo apt -y update ; sudo apt -y install libmbedtls-dev libwolfssl-dev && make -C test ${{ matrix.target }}
-  mip:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        cc: [gcc, clang, g++, clang++]
-        target: [mip_test, mip_tap_test]
-        ssl: ["", BUILTIN, MBEDTLS, OPENSSL, WOLFSSL]
-    name: ${{ matrix.target }} CC=${{ matrix.cc }} SSL=${{ matrix.ssl }}
-    env:
-      CC: ${{ matrix.cc }}
-      SSL: ${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if [ "${{ matrix.target }}" == "mip_tap_test" ]; then ./test/setup_ga_network.sh ; fi && sudo apt -y update ; sudo apt -y install libmbedtls-dev libwolfssl-dev && make -C test ${{ matrix.target }} IPV6=0
-  s390:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN]
-    name: S390 SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: sudo apt -y update ; sudo apt -y install binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make -C test s390 SSL=${{ matrix.ssl }}
-  armhf:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN]
-    name: ArmHF SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: sudo apt -y update ; sudo apt -y install binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make -C test armhf SSL=${{ matrix.ssl }}
-  unamalgamated-mg_prefix:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN, MBEDTLS, OPENSSL, WOLFSSL]
-    name: unamalgamated-mg_prefix SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: sudo apt -y update ; sudo apt -y install libmbedtls-dev libwolfssl-dev
-    - run: make -C test unamalgamated && make -C test mg_prefix
-  valgrind:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN, MBEDTLS, OPENSSL, WOLFSSL]
-    name: Valgrind SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: sudo apt -y update ; sudo apt -y install libmbedtls-dev libwolfssl-dev valgrind
-    - run: make -C test valgrind SSL=${{ matrix.ssl }}
-  macos:
-    runs-on: macos-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN, MBEDTLS, OPENSSL, WOLFSSL]
-        select: [-DMG_ENABLE_POLL=0, -DMG_ENABLE_POLL=1]
-        exclude:
-        - ssl: MBEDTLS
-          select: -DMG_ENABLE_POLL=0
-        - ssl: OPENSSL
-          select: -DMG_ENABLE_POLL=0
-        - ssl: WOLFSSL
-          select: -DMG_ENABLE_POLL=0
-    name: macos SSL=${{ matrix.ssl }} TFLAGS=${{ matrix.select }}
-    env:
-      SSL: ${{ matrix.ssl }}
-      TFLAGS: ${{ matrix.select }} -Wno-sign-conversion # Workaround for MbedTLS 3.5.0
-      HOMEBREW_NO_AUTO_UPDATE: 1
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: brew install mbedtls wolfssl # jq openssl already pre-installed
-    - run: make -C test test ASAN_OPTIONS= MBEDTLS=$(echo $(brew --cellar)/mbedtls*/*) OPENSSL=$(echo $(brew --cellar)/openssl*/*) WOLFSSL=$(echo $(brew --cellar)/wolfssl*/*)
-  windows:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1   # no parallel runs, to minimize MQTT errors
-      matrix:
-        target: [vc98, vc17, vc22, mingw, mingw++]
-        ssl: ["", BUILTIN]
-        select: [-DMG_ENABLE_POLL=0, -DMG_ENABLE_POLL=1]
-        exclude:
-        - target: vc98
-          select: -DMG_ENABLE_POLL=1
-    name: windows ${{ matrix.target }} SSL=${{ matrix.ssl }} TFLAGS=${{ matrix.select }}
-    env:
-      SSL: SSL=${{ matrix.ssl }}
-      TFLAGS: ${{ matrix.select }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: make -C test ${{ matrix.target }} 
-  arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN]
-    name: Arm SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test arm SSL=${{ matrix.ssl }}
-  riscv:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN]
-    name: RISC-V SSL=${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test riscv SSL=${{ matrix.ssl }}
-
-  tutorials:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: [-DMG_TLS=MG_TLS_NONE, -DMG_TLS=MG_TLS_BUILTIN]
-    name: tutorials ${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt -y install libpcap-dev
-    - run: make -C test tutorials CFLAGS_EXTRA="${{ matrix.ssl }}"
-    - run: make -C test clean_tutorials
-  tutorials_win:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: [-DMG_TLS=MG_TLS_NONE, -DMG_TLS=MG_TLS_BUILTIN]
-    name: tutorials_win ${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-#    - uses: egor-tensin/setup-mingw@v2
-#      with:
-#        platform: x64
-    - name: test they build
-      run: make -C test tutorials_win CFLAGS_EXTRA="${{ matrix.ssl }}"
-      shell: cmd
-    - name: test they clean
-      run: make -C test clean_tutorials_win
-      shell: cmd
-  tutorials_mac:
-    runs-on: macos-latest
-    env: { HOMEBREW_NO_AUTO_UPDATE: 1 }
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: [-DMG_TLS=MG_TLS_NONE, -DMG_TLS=MG_TLS_BUILTIN]
-    name: tutorials_mac ${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test tutorials_mac CFLAGS_EXTRA="${{ matrix.ssl }}"
-    - run: make -C test clean_tutorials_mac
-
-
-  arduino:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: echo # nothing specific to install or do
-    - run: make -C test/arduino
-    - run: make -C test/arduino cleanall
-
-
-#  wizard_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: esp32/esp32-idf
-#    name: ${{ matrix.example.path }}
-#    env:
-#      GO: 0
-#    steps:
-#      - uses: actions/checkout@v4
-#        with: { fetch-depth: 2 }
-#      - run: echo # nothing specific to install or do
-#          fi
-#      - run: make -C tutorials/${{ matrix.example.path }} build
-
-  wizard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: infineon/xmc47_relax-make-baremetal-builtin
-          - path: infineon/xmc_plt2go_4400-make-baremetal-builtin
-          - path: infineon/xmc72_evk-make-baremetal-builtin
-          - path: nxp/frdm-mcxn947-make-baremetal-builtin
-          - path: nxp/frdm-mcxn947-make-freertos-builtin
-          - path: nxp/rt1020-evk-make-baremetal-builtin
-          - path: nxp/rt1060-evk-make-baremetal-builtin
-          - path: nxp/rt1170-evk-make-baremetal-builtin
-          - path: pico-sdk/pico-w-picosdk-baremetal-builtin
-          - path: pico-sdk/pico-2-w-picosdk-baremetal-builtin
-          - path: pico-sdk/w5500-evb-pico-picosdk-baremetal-builtin
-          - path: pico-sdk/w5500-evb-pico2-picosdk-baremetal-builtin
-          - path: stm32/nucleo-f429zi-make-baremetal-builtin
-          - path: stm32/nucleo-f429zi-make-freertos-builtin
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin
-          - path: stm32/nucleo-f746zg-make-freertos-builtin
-          - path: stm32/nucleo-h563zi-make-baremetal-builtin
-          - path: stm32/nucleo-h563zi-make-freertos-builtin
-          - path: stm32/nucleo-h723zg-make-baremetal-builtin
-          - path: stm32/nucleo-h723zg-make-freertos-builtin
-          - path: stm32/nucleo-h743zi-make-baremetal-builtin
-          - path: stm32/nucleo-h743zi-make-freertos-builtin
-          - path: stm32/stm32h573i-dk-make-baremetal-builtin
-          - path: stm32/stm32h573i-dk-make-freertos-builtin
-          - path: ti/ek-tm4c1294xl-make-baremetal-builtin
-          - path: ti/ek-tm4c1294xl-make-freertos-builtin
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - run: make -C tutorials/${{ matrix.example.path }} build
-
-
-  generic_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: micropython/esp32
-          - path: http/uart-bridge/esp32
-          - path: http/http-client/esp8266/http-client-server
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: echo # nothing specific to install or do
-      - run: make -C tutorials/${{ matrix.example.path }} build
-  
-  generic_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: mqtt/mqtt-client/microchip/same54-xpro
-          - path: nxp/nxp-mimxrt1020-azurertos
-          - path: nxp/nxp-frdmk66f-freertos
-          - path: nxp/nxp-lpcxpresso54s018m-freertos
-          - path: nxp/nxp-mimxrt1020-freertos
-          - path: nxp/nxp-evkbimxrt1050-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1020-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1024-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1060-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1064-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1160-cm7-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1170-cm7-lwip-freertos
-          - path: nxp/nxp-frdmk64f-lwip-freertos
-          - path: nxp/nxp-frdmk66f-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54018-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54608-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54618-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54628-lwip-freertos
-          - path: nxp/nxp-twrk65f180m-lwip-freertos
-          - path: nxp/nxp-twrkv58f220m-lwip-freertos
-          - path: pico-sdk/pico-rmii
-          - path: stm32/nucleo-f429zi-make-baremetal-builtin-rndis
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin-rndis
-          - path: stm32/nucleo-g031-make-baremetal-builtin
-          - path: ti/ti-ek-tm4c1294xl-http-server
-          - path: ti/ek-tm4c1294xl-make-baremetal-builtin-rndis
-    name: ${{ matrix.example.path }}
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - run: make -C tutorials/${{ matrix.example.path }} build
-
-  device_dashboard_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: esp32
-    name: ${{ matrix.example.path }}
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: echo # nothing specific to install or do
-      - run: make -C tutorials/http/device-dashboard/${{ matrix.example.path }} build
-
-
-  device_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", -DMG_TLS=MG_TLS_BUILTIN]
-        example:
-          - path: tutorials/http/device-dashboard/microchip/same54-xpro
-          - path: nxp/rt1020-evk-make-freertos-builtin
-          - path: nxp/rt1060-evk-make-freertos-builtin
-          - path: nxp/rt1170-evk-make-freertos-builtin
-          - path: renesas/ek-ra6m4-make-baremetal-builtin
-          - path: pico-sdk/pico-rndis-dashboard
-          - path: pico-sdk/pico-w-picosdk-freertos-lwip
-          - path: pico-sdk/pico-2-w-picosdk-freertos-lwip
-          - path: stm32/nucleo-f746zg-make-freertos-tcp
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin-cmsis_driver
-    name: ${{ matrix.example.path }} ${{ matrix.ssl }}
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - run: make -C tutorials/${{ matrix.example.path }} build CFLAGS_EXTRA="${{ matrix.ssl }}"
-
-#  mqtt_dashboard_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: 
-#    name: ${{ matrix.example.path }}
-#    steps:
-#      - uses: actions/checkout@v4
-#        with: { fetch-depth: 2 }
-#      - run: echo # nothing specific to install or do
-#      - run: make -C tutorials/${{ matrix.example.path }} build
-      
-  mqtt_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: pico-sdk/pico-rndis-device
-    name: ${{ matrix.example.path }}
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - run: make -C tutorials/${{ matrix.example.path }} build
-      
-#  dual_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: 
-#    name: ${{ matrix.example.path }}
-#    steps:
-#      - uses: actions/checkout@v4
-#        with: { fetch-depth: 2 }
-#      - run: echo # nothing specific to install or do
-#      - run: make -C tutorials/${{ matrix.example.path }} device_dashboard
-#      - run: make -C tutorials/${{ matrix.example.path }} mqtt_dashboard
-
-  cube_examples:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo pip install yq
-      - run: cd test/cube && make
-
-  zephyr_examples:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - run: make -C tutorials/zephyr init REPO=zephyrprojectrtos/ci:v0.26.14 # "no space left on device" with newers
-      - name: minify manifest
-        uses: mikefarah/yq@master
-        with:
-          cmd: yq -i eval '(.manifest.defaults, .manifest.remotes, .manifest.projects[] | select(.name == "cmsis" or .name == "hal_stm32" or .name == "mbedtls" or .name == "mcuboot" or .name == "picolibc" | del(.null) ), .manifest.self) as $i ireduce({};setpath($i | path; $i)) | del(.manifest.projects.[].null) | del(..|select(length==0))' tutorials/zephyr/zephyrproject/zephyr/west.yml
-      - run: make -C tutorials/zephyr update
-      - run: make -C tutorials/zephyr/device-dashboard build
-      - run: make -C tutorials/zephyr/http-client build
-      - run: make -C tutorials/zephyr/http-server build
-      - run: make -C tutorials/zephyr/mqtt-aws-client build
-      - run: make -C tutorials/zephyr/websocket-server build
-
-  test_f7:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/stm32/nucleo-f746zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-f746zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-f746zg-make-freertos-tcp test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - name: Cube
-      run: echo # nothing specific to install or do
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5    
-    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-
-  test_f4:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/stm32/nucleo-f429zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-f429zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - name: Cube
-      run: echo # nothing specific to install or do
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-
-  test_h743:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/stm32/nucleo-h743zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-h743zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-#    - name: Cube
-#      run: echo # nothing specific to install or do
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-h743zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-#    - run: make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-h743zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-
-  test_h723:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/stm32/nucleo-h723zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-h723zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    
-  test_h5:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/stm32/nucleo-h563zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/stm32/nucleo-h563zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_rt1020:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/nxp/rt1020-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/nxp/rt1020-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_rt1060:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/nxp/rt1060-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/nxp/rt1060-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_rt1170:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/nxp/rt1170-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run: make -C tutorials/nxp/rt1170-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_ra6m4:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run: make -C tutorials/renesas/ek-ra6m4-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-#    - run: make -C tutorials/renesas/ek-ra6m4-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_tm4c:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run:  make -C tutorials/ti/ek-tm4c1294xl-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run:  make -C tutorials/ti/ek-tm4c1294xl-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_same54:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run:  make -C tutorials/http/device-dashboard/microchip/same54-xpro test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - run:  make -C tutorials/mqtt/mqtt-client/microchip/same54-xpro test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_pico_w5500:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: SDK
-      run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-    - run:  make -C tutorials/pico-sdk/w5500-evb-pico-picosdk-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-

.github/workflows/quicktest.yml

@@ -1,694 +0,0 @@
-name: Build and test - essentials
-on:
-  push:
-    paths:
-      - "**Makefile"
-      - "**.c"
-      - "**.h"
-env:
-  IPV6: 0
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        cc: [gcc, clang++]
-        target: [test, mip_test]
-        ssl: ["", BUILTIN]
-    name: linux ${{ matrix.target }} CC=${{ matrix.cc }} SSL=${{ matrix.ssl }}
-    env:
-      CC: ${{ matrix.cc }}
-      SSL: ${{ matrix.ssl }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: make -C test ${{ matrix.target }}
-  s390:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: sudo apt -y update ; sudo apt -y install binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make -C test s390
-  armhf:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: sudo apt -y update ; sudo apt -y install binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make -C test armhf
-  unamalgamated-mg_prefix:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: make -C test unamalgamated && make -C test mg_prefix
-  macos:
-    runs-on: macos-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", BUILTIN]
-    name: macos SSL=${{ matrix.ssl }}
-    env:
-      SSL: ${{ matrix.ssl }}
-      #TFLAGS: -DNO_SNTP_CHECK
-      HOMEBREW_NO_AUTO_UPDATE: 1
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run:  make -C test test ASAN_OPTIONS=
-  windows:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        target: [vc98, vc22, mingw++]
-    name: windows ${{ matrix.target }}
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: make -C test ${{ matrix.target }} 
-  arm:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test arm
-  riscv:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test riscv
-
-  tutorials:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test tutorials_essential
-    - run: make -C test clean_tutorials_essential
-  tutorials_win:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v4
-#    - uses: egor-tensin/setup-mingw@v2
-#      with:
-#        platform: x64
-    - name: test they build
-      run: make -C test tutorials_win
-      shell: cmd
-    - name: test they clean
-      run: make -C test clean_tutorials_win
-      shell: cmd
-  tutorials_mac:
-    runs-on: macos-latest
-    env: { HOMEBREW_NO_AUTO_UPDATE: 1 }
-    steps:
-    - uses: actions/checkout@v4
-    - run: make -C test tutorials_mac
-    - run: make -C test clean_tutorials_mac
-
-
-#  wizard_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: esp32/esp32-idf
-#    name: ${{ matrix.example.path }}
-#    env:
-#      GO: 0
-#    steps:
-#      - uses: actions/checkout@v4
-#        with: { fetch-depth: 2 }
-#      - run: |
-#          if ./test/match_changed_files.sh '^src'; then
-#            echo GO=1 >> $GITHUB_ENV
-#            # nothing specific to install or do
-#          fi
-#      - if: ${{ env.GO == 1 }}
-#        run: make -C tutorials/${{ matrix.example.path }} build
-
-  wizard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: infineon/xmc47_relax-make-baremetal-builtin
-          - path: infineon/xmc_plt2go_4400-make-baremetal-builtin
-          - path: infineon/xmc72_evk-make-baremetal-builtin
-          - path: nxp/frdm-mcxn947-make-baremetal-builtin
-          - path: nxp/frdm-mcxn947-make-freertos-builtin
-          - path: nxp/rt1020-evk-make-baremetal-builtin
-          - path: nxp/rt1060-evk-make-baremetal-builtin
-          - path: nxp/rt1170-evk-make-baremetal-builtin
-          - path: pico-sdk/pico-w-picosdk-baremetal-builtin
-          - path: pico-sdk/pico-2-w-picosdk-baremetal-builtin
-          - path: pico-sdk/w5500-evb-pico-picosdk-baremetal-builtin
-          - path: pico-sdk/w5500-evb-pico2-picosdk-baremetal-builtin
-          - path: stm32/nucleo-f429zi-make-baremetal-builtin
-          - path: stm32/nucleo-f429zi-make-freertos-builtin
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin
-          - path: stm32/nucleo-f746zg-make-freertos-builtin
-          - path: stm32/nucleo-h563zi-make-baremetal-builtin
-          - path: stm32/nucleo-h563zi-make-freertos-builtin
-          - path: stm32/nucleo-h723zg-make-baremetal-builtin
-          - path: stm32/nucleo-h723zg-make-freertos-builtin
-          - path: stm32/nucleo-h743zi-make-baremetal-builtin
-          - path: stm32/nucleo-h743zi-make-freertos-builtin
-          - path: stm32/stm32h573i-dk-make-baremetal-builtin
-          - path: stm32/stm32h573i-dk-make-freertos-builtin
-          - path: ti/ek-tm4c1294xl-make-baremetal-builtin
-          - path: ti/ek-tm4c1294xl-make-freertos-builtin
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/${{ matrix.example.path }} build
-
-
-  generic_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: http/uart-bridge/esp32
-          - path: http/http-client/esp8266/http-client-server
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: if ./test/match_changed_files.sh '^src|^tutorials/http/uart-bridge|^tutorials/${{ matrix.example.path }}'; then echo GO=1 >> $GITHUB_ENV ; fi
-      - if: ${{ env.GO == 1 }}
-        run: |
-          # nothing specific to install or do
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/${{ matrix.example.path }} build
-  
-  generic_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: stm32/nucleo-g031-make-baremetal-builtin
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: if ./test/match_changed_files.sh '^src|^tutorials/${{ matrix.example.path }}'; then echo GO=1 >> $GITHUB_ENV ; fi
-      - if: ${{ env.GO == 1 }}
-        run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/${{ matrix.example.path }} build
-
-  device_dashboard_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: esp32
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard'; then
-            echo GO=1 >> $GITHUB_ENV
-            # nothing specific to install or do
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/http/device-dashboard/${{ matrix.example.path }} build
-
-  device_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: http/device-dashboard/microchip/same54-xpro
-          - path: nxp/rt1020-evk-make-freertos-builtin
-          - path: nxp/rt1060-evk-make-freertos-builtin
-          - path: nxp/rt1170-evk-make-freertos-builtin
-          - path: renesas/ek-ra6m4-make-baremetal-builtin
-          - path: pico-sdk/pico-rndis-dashboard
-          - path: pico-sdk/pico-w-picosdk-freertos-lwip
-          - path: pico-sdk/pico-2-w-picosdk-freertos-lwip
-          - path: stm32/nucleo-f746zg-make-freertos-tcp
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin-cmsis_driver
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|^tutorials/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/${{ matrix.example.path }} build
-
-#  mqtt_dashboard_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: 
-#    name: ${{ matrix.example.path }}
-#    env:
-#      GO: 0
-#    steps:
-#      - uses: actions/checkout@v4
-#        with: { fetch-depth: 2 }
-#      - run: |
-#          if ./test/match_changed_files.sh '^src|tutorials/mqtt/mqtt-dashboard/device|^tutorials/${{ matrix.example.path }}'; then
-#            echo GO=1 >> $GITHUB_ENV
-#            # nothing specific to install or do
-#          fi
-#      - if: ${{ env.GO == 1 }}
-#        run: make -C tutorials/${{ matrix.example.path }} build
-      
-  mqtt_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: pico-sdk/pico-rndis-device
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|tutorials/mqtt/mqtt-dashboard/device|^tutorials/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C tutorials/${{ matrix.example.path }} build
-      
-  cube_examples:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v4
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|tutorials/stm32/nucleo-*-cube-*'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo pip install yq
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: cd test/cube && make
-
-  test_f7:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-f7.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    # always run baremetal on core or dashboard or specific example changes; other examples only on specific example changes
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true   # continue so next test has a chance to re-flash and exit from collisions and flash failures
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-f746zg-make-baremetal-builtin'; then
-          make -C tutorials/stm32/nucleo-f746zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f746zg-make-freertos-builtin'; then
-          make -C tutorials/stm32/nucleo-f746zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f746zg-make-freertos-tcp'; then
-          make -C tutorials/stm32/nucleo-f746zg-make-freertos-tcp test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - name: Cube
-      run: |
-        echo GO=0 >> $GITHUB_ENV
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f7.*-cube-'; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f746zg-cube-baremetal-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-#        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f746zg-cube-freertos-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5    
-#        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f746zg-cube-freertos-lwip'; then
-          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f746zg-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-        fi
-
-
-  test_f4:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-f4.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-f429zi-make-baremetal-builtin'; then
-          make -C tutorials/stm32/nucleo-f429zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f429zi-make-freertos-builtin'; then
-          make -C tutorials/stm32/nucleo-f429zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - name: Cube
-      run: |
-        echo GO=0 >> $GITHUB_ENV
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f4.*-cube-'; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f429zi-cube-baremetal-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-#        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f429zi-cube-freertos-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-#        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-f429zi-cube-freertos-lwip'; then
-          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-f429zi-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-        fi
-
-  test_h743:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h74.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h743zi-make-baremetal-builtin'; then
-        make -C tutorials/stm32/nucleo-h743zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h743zi-make-freertos-builtin'; then
-          make -C tutorials/stm32/nucleo-h743zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-#    - name: Cube
-#      run: |
-#        echo GO=0 >> $GITHUB_ENV
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h74.*-cube-'; then
-#          echo GO=1 >> $GITHUB_ENV
-#          # nothing specific to install or do
-#        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h743zi-cube-baremetal-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-h743zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-#        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h743zi-cube-freertos-builtin'; then
-#          make -C test/cube test PROJECTS=../../tutorials/stm32/nucleo-h743zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-#        fi
-
-  test_h723:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h72.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h723zg-make-baremetal-builtin'; then
-          make -C tutorials/stm32/nucleo-h723zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h723zg-make-freertos-builtin'; then
-          make -C tutorials/stm32/nucleo-h723zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    
-  test_h5:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h5.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/stm32/nucleo-h563zi-make-baremetal-builtin'; then
-          make -C tutorials/stm32/nucleo-h563zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/stm32/nucleo-h563zi-make-freertos-builtin'; then
-          make -C tutorials/stm32/nucleo-h563zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_rt1020:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/nxp/rt1020.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/nxp/rt1020-evk-make-baremetal-builtin'; then
-          make -C tutorials/nxp/rt1020-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/nxp/rt1020-evk-make-freertos-builtin'; then
-          make -C tutorials/nxp/rt1020-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_rt1060:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/nxp/rt1060.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/nxp/rt1060-evk-make-baremetal-builtin'; then
-          make -C tutorials/nxp/rt1060-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/nxp/rt1060-evk-make-freertos-builtin'; then
-          make -C tutorials/nxp/rt1060-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_rt1170:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/nxp/rt1170.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/nxp/rt1170-evk-make-baremetal-builtin'; then
-          make -C tutorials/nxp/rt1170-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/nxp/rt1170-evk-make-freertos-builtin'; then
-          make -C tutorials/nxp/rt1170-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_ra6m4:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/renesas/ek-ra6m4.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      continue-on-error: true
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/renesas/ek-ra6m4-make-baremetal-builtin'; then
-          make -C tutorials/renesas/ek-ra6m4-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh 'tutorials/renesas/ek-ra6m4-make-freertos-builtin'; then
-#          make -C tutorials/renesas/ek-ra6m4-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-#        fi
-
-  test_tm4c:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/ti/ek-tm4c.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard|tutorials/ti/ek-tm4c1294xl-make-baremetal-builtin'; then
-          make -C tutorials/ti/ek-tm4c1294xl-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh 'tutorials/ti/ek-tm4c1294xl-make-freertos-builtin'; then
-          make -C tutorials/ti/ek-tm4c1294xl-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_same54:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|tutorials/http/device-dashboard|tutorials/mqtt/mqtt-client" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/http/device-dashboard'; then
-          make -C tutorials/http/device-dashboard/microchip/same54-xpro test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|tutorials/mqtt/mqtt-client'; then
-          make -C tutorials/mqtt/mqtt-client/microchip/same54-xpro test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_pico_w5500:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v4
-      with: { fetch-depth: 2 }
-    - name: SDK
-      run: |
-        if ./test/match_changed_files.sh "^src" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run:  make -C tutorials/pico-sdk/w5500-evb-pico-picosdk-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-

.github/workflows/test.yml

@@ -1,740 +0,0 @@
-name: original workflow, outdated # *** YES, OUTDATED *** kept for hystorical/reference purposes, attachment, etc.
-on:
-  workflow_dispatch:
-env:
-  IPV6: 0
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        cc: [gcc, clang, g++, clang++]
-        target: [test, mip_test]
-        ssl: ["", MBEDTLS, OPENSSL]
-        select: ["-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0", "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0", "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=1"]
-        exclude:
-        - ssl: MBEDTLS
-          select: "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0"
-        - ssl: MBEDTLS
-          select: "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0"
-        - ssl: OPENSSL
-          select: "-DMG_ENABLE_POLL=0 -DMG_ENABLE_EPOLL=0"
-        - ssl: OPENSSL
-          select: "-DMG_ENABLE_POLL=1 -DMG_ENABLE_EPOLL=0"
-    name: linux ${{ matrix.target }} CC=${{ matrix.cc }} SSL=${{ matrix.ssl }} TFLAGS=${{ matrix.select }}
-    env:
-      CC: ${{ matrix.cc }}
-      SSL: ${{ matrix.ssl }}
-      TFLAGS: ${{ matrix.select }}
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: ./test/setup_ga_network.sh && sudo apt -y update ; sudo apt -y install libmbedtls-dev && make ${{ matrix.target }}
-  s390:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: sudo apt -y update ; sudo apt -y install qemu binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make s390
-  armhf:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: sudo apt -y update ; sudo apt -y install qemu binfmt-support qemu-user-static && docker run --rm --privileged multiarch/qemu-user-static --reset -p yes && make armhf
-  linux2:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: sudo apt -y update ; sudo apt -y install libmbedtls-dev valgrind
-    - if: ${{ env.GO == 1 }}
-      run: make unamalgamated && make valgrind && make mg_prefix
-  macos:
-    runs-on: macos-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ssl: ["", MBEDTLS, OPENSSL]
-        select: [-DMG_ENABLE_POLL=0, -DMG_ENABLE_POLL=1]
-        exclude:
-        - ssl: MBEDTLS
-          select: -DMG_ENABLE_POLL=0
-        - ssl: OPENSSL
-          select: -DMG_ENABLE_POLL=0
-    name: macos SSL=${{ matrix.ssl }} TFLAGS=${{ matrix.select }}
-    env:
-      SSL: ${{ matrix.ssl }}
-      TFLAGS: ${{ matrix.select }} -DNO_SNTP_CHECK -Wno-sign-conversion # Workaround for MbedTLS 3.5.0
-      HOMEBREW_NO_AUTO_UPDATE: 1
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: brew install jq mbedtls openssl
-    - if: ${{ env.GO == 1 }}
-      run:  make test ASAN_OPTIONS= MBEDTLS=`echo /usr/local/Cellar/mbedtls*/*` OPENSSL=`echo /usr/local/Cellar/openssl*/*`
-    - if: ${{ env.GO == 1 }}
-      run: make mg_prefix
-  windows:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        target: [vc98, vc17, vc22, mingw, mingw++]
-        select: [-DMG_ENABLE_POLL=0, -DMG_ENABLE_POLL=1]
-        exclude:
-        - target: vc98
-          select: -DMG_ENABLE_POLL=1
-    name: windows ${{ matrix.target }} TFLAGS=${{ matrix.select }}
-    env:
-      TFLAGS: ${{ matrix.select }}
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: if ./test/match_changed_files.sh '^test|^src/.*.[ch]' ; then echo GO=1 >> $GITHUB_ENV ; fi
-    - if: ${{ env.GO == 1 }}
-      run: make ${{ matrix.target }} 
-  arm:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: make arm
-  riscv:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: make riscv
-
-  examples:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: sudo apt -y install libmbedtls-dev libpcap-dev
-    - run: make examples
-    - run: make clean
-  examples_win:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v3
-#    - uses: egor-tensin/setup-mingw@v2
-#      with:
-#        platform: x64
-    - name: test they build
-      run: make examples_win
-      shell: cmd
-    - name: test they clean
-      run: make clean_examples_win
-      shell: cmd
-  examples_mac:
-    runs-on: macos-latest
-    env: { HOMEBREW_NO_AUTO_UPDATE: 1 }
-    steps:
-    - uses: actions/checkout@v3
-    - run: make examples_mac
-    - run: make clean_examples_mac
-
-
-  arduino:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/arduino" ; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/arduino'; then
-          make -C examples/arduino arduino-xiao
-        fi
-#    - if: ${{ env.GO == 1 }}
-#      run: |
-#        if ./test/match_changed_files.sh '^src|examples/arduino'; then
-#          make -C examples/arduino arduino-nano
-#        fi
-    - if: ${{ env.GO == 1 }}
-      run: make -C examples/arduino clean
-
-
-  generic_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: esp32/uart-bridge
-          - path: esp32/micropython
-          - path: esp8266/http-client-server
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: if ./test/match_changed_files.sh '^src|^examples/${{ matrix.example.path }}'; then echo GO=1 >> $GITHUB_ENV ; fi
-      - if: ${{ env.GO == 1 }}
-        run: |
-          # nothing specific to install or do
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/${{ matrix.example.path }} build
-  
-  generic_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: microchip/same54-xpro/mqtt-client
-          - path: infineon/infineon-xmc4700_4800-lwip-rtx-rtos
-          - path: nxp/nxp-mimxrt1020-azurertos
-          - path: nxp/nxp-frdmk66f-freertos
-          - path: nxp/nxp-lpcxpresso54s018m-freertos
-          - path: nxp/nxp-mimxrt1020-freertos
-          - path: nxp/nxp-evkbimxrt1050-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1020-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1024-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1060-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1064-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1160-cm7-lwip-freertos
-          - path: nxp/nxp-evkmimxrt1170-cm7-lwip-freertos
-          - path: nxp/nxp-frdmk64f-lwip-freertos
-          - path: nxp/nxp-frdmk66f-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54018-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54608-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54618-lwip-freertos
-          - path: nxp/nxp-lpcxpresso54628-lwip-freertos
-          - path: nxp/nxp-twrk65f180m-lwip-freertos
-          - path: nxp/nxp-twrkv58f220m-lwip-freertos
-          - path: rp2040/pico-rmii
-          - path: stm32/nucleo-f429zi-make-baremetal-builtin-rndis
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin-rndis
-          - path: stm32/nucleo-g031-make-baremetal-builtin
-          - path: ti/ti-ek-tm4c1294xl-http-server
-          - path: ti/ek-tm4c1294xl-make-baremetal-builtin-rndis
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: if ./test/match_changed_files.sh '^src|^examples/${{ matrix.example.path }}'; then echo GO=1 >> $GITHUB_ENV ; fi
-      - if: ${{ env.GO == 1 }}
-        run: sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/${{ matrix.example.path }} build
-
-  device_dashboard_examples:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: esp32/device-dashboard
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|examples/device-dashboard|^examples/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            # nothing specific to install or do
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/${{ matrix.example.path }} build
-
-  device_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: microchip/same54-xpro/device-dashboard
-          - path: nxp/rt1020-evk-make-baremetal-builtin
-          - path: nxp/rt1020-evk-make-freertos-builtin
-          - path: nxp/rt1060-evk-make-baremetal-builtin
-          - path: nxp/rt1060-evk-make-freertos-builtin
-          - path: rp2040/pico-rndis-dashboard
-          - path: rp2040/pico-w
-          - path: rp2040/pico-w5500
-          - path: stm32/nucleo-f429zi-make-baremetal-builtin
-          - path: stm32/nucleo-f429zi-make-freertos-builtin
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin
-          - path: stm32/nucleo-f746zg-make-freertos-builtin
-          - path: stm32/nucleo-f746zg-make-freertos-tcp
-          - path: stm32/nucleo-f746zg-make-baremetal-builtin-cmsis_driver
-          - path: stm32/nucleo-h563zi-make-baremetal-builtin
-          - path: stm32/nucleo-h563zi-make-freertos-builtin
-          - path: stm32/nucleo-h723zg-make-freertos-builtin
-          - path: stm32/nucleo-h743zi-make-baremetal-builtin
-          - path: stm32/nucleo-h743zi-make-freertos-builtin
-          - path: stm32/stm32h573i-dk-make-baremetal-builtin
-          - path: stm32/stm32h573i-dk-make-freertos-builtin
-          - path: ti/ek-tm4c1294xl-make-baremetal-builtin
-          - path: ti/ek-tm4c1294xl-make-freertos-builtin
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|examples/device-dashboard|^examples/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/${{ matrix.example.path }} build
-
-#  mqtt_dashboard_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: 
-#    name: ${{ matrix.example.path }}
-#    env:
-#      GO: 0
-#    steps:
-#      - uses: actions/checkout@v3
-#        with: { fetch-depth: 2 }
-#      - run: |
-#          if ./test/match_changed_files.sh '^src|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-#            echo GO=1 >> $GITHUB_ENV
-#            # nothing specific to install or do
-#          fi
-#      - if: ${{ env.GO == 1 }}
-#        run: make -C examples/${{ matrix.example.path }} build
-      
-  mqtt_dashboard_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: rp2040/pico-rndis-device
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/${{ matrix.example.path }} build
-      
-#  dual_examples:
-#    runs-on: ubuntu-latest
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        example:
-#          - path: 
-#    name: ${{ matrix.example.path }}
-#    env:
-#      GO: 0
-#    steps:
-#      - uses: actions/checkout@v3
-#        with: { fetch-depth: 2 }
-#      - run: |
-#          if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-#            echo GO=1 >> $GITHUB_ENV
-#            # nothing specific to install or do
-#          fi
-#      - if: ${{ env.GO == 1 }}
-#        run: |
-#          if ./test/match_changed_files.sh '^src|examples/device-dashboard|^examples/${{ matrix.example.path }}'; then
-#            make -C examples/${{ matrix.example.path }} device_dashboard
-#          fi
-#      - if: ${{ env.GO == 1 }}
-#        run: |
-#          if ./test/match_changed_files.sh '^src|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-#            make -C examples/${{ matrix.example.path }} mqtt_dashboard
-#          fi
-
-  dual_examples_arm:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        example:
-          - path: stm32/nucleo-h723zg-make-baremetal-builtin
-    name: ${{ matrix.example.path }}
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: |
-          if ./test/match_changed_files.sh '^src|examples/device-dashboard|^examples/${{ matrix.example.path }}'; then
-            make -C examples/${{ matrix.example.path }} device_dashboard
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: |
-          if ./test/match_changed_files.sh '^src|examples/mqtt-dashboard/device|^examples/${{ matrix.example.path }}'; then
-            make -C examples/${{ matrix.example.path }} mqtt_dashboard
-          fi
-
-  cube_examples:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src|examples/stm32/nucleo-*-cube-*'; then
-            echo GO=1 >> $GITHUB_ENV
-            # nothing specific to install or do
-          fi
-      - if: ${{ env.GO == 1 }}
-        run: cd test/cube && make
-
-  zephyr_examples:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-      - uses: actions/checkout@v3
-        with: { fetch-depth: 2 }
-      - run: |
-          if ./test/match_changed_files.sh '^src/.*.[ch]|^examples/zephyr'; then
-            echo GO=1 >> $GITHUB_ENV
-            sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-            fi
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr init
-      - name: minify manifest
-        if: ${{ env.GO == 1 }}
-        uses: mikefarah/yq@master
-        with:
-          cmd: yq -i eval '(.manifest.defaults, .manifest.remotes, .manifest.projects[] | select(.name == "cmsis" or .name == "hal_stm32" or .name == "mbedtls" or .name == "mcuboot" or .name == "picolibc" | del(.null) ), .manifest.self) as $i ireduce({};setpath($i | path; $i)) | del(.manifest.projects.[].null) | del(..|select(length==0))' examples/zephyr/zephyrproject/zephyr/west.yml
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr update
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr/device-dashboard build
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr/http-client build
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr/http-server build
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr/mqtt-aws-client build
-      - if: ${{ env.GO == 1 }}
-        run: make -C examples/zephyr/websocket-server build
-
-  test_f7:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/stm32/nucleo-f7.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-make-baremetal-builtin'; then
-          make -C examples/stm32/nucleo-f746zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-make-freertos-builtin'; then
-          make -C examples/stm32/nucleo-f746zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-make-freertos-tcp'; then
-          make -C examples/stm32/nucleo-f746zg-make-freertos-tcp test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - name: Cube
-      run: |
-        echo GO=0 >> $GITHUB_ENV
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f7.*-cube-'; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-cube-baremetal-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f746zg-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-cube-freertos-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f746zg-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5    
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f746zg-cube-freertos-lwip'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f746zg-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=5
-        fi
-
-
-  test_f4:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/stm32/nucleo-f4.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f429zi-make-baremetal-builtin'; then
-          make -C examples/stm32/nucleo-f429zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f429zi-make-freertos-builtin'; then
-          make -C examples/stm32/nucleo-f429zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - name: Cube
-      run: |
-        echo GO=0 >> $GITHUB_ENV
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f4.*-cube-'; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f429zi-cube-baremetal-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f429zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f429zi-cube-freertos-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f429zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-f429zi-cube-freertos-lwip'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-f429zi-cube-freertos-lwip VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=2
-        fi
-
-  test_h743:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/stm32/nucleo-h74.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h743zi-make-baremetal-builtin'; then
-        make -C examples/stm32/nucleo-h743zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h743zi-make-freertos-builtin'; then
-          make -C examples/stm32/nucleo-h743zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - name: Cube
-      run: |
-        echo GO=0 >> $GITHUB_ENV
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h74.*-cube-'; then
-          echo GO=1 >> $GITHUB_ENV
-          # nothing specific to install or do
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h743zi-cube-baremetal-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-h743zi-cube-baremetal-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h743zi-cube-freertos-builtin'; then
-          make -C test/cube test PROJECTS=../../examples/stm32/nucleo-h743zi-cube-freertos-builtin VCON_API_KEY=${{secrets.VCON_API_KEY}} DEVICE=6
-        fi
-
-  test_h723:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/stm32/nucleo-h72.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h723zg-make-baremetal-builtin'; then
-          make -C examples/stm32/nucleo-h723zg-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h723zg-make-freertos-builtin'; then
-          make -C examples/stm32/nucleo-h723zg-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    
-  test_h5:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/stm32/nucleo-h5.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h563zi-make-baremetal-builtin'; then
-          make -C examples/stm32/nucleo-h563zi-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/stm32/nucleo-h563zi-make-freertos-builtin'; then
-          make -C examples/stm32/nucleo-h563zi-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_rt1020:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/nxp/rt1020.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        #if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/nxp/rt1020-evk-make-baremetal-builtin'; then
-        if ./test/match_changed_files.sh '^src|examples/nxp/rt1020-evk-make-baremetal-builtin'; then
-          make -C examples/nxp/rt1020-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        #if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/nxp/rt1020-evk-make-freertos-builtin'; then
-        if ./test/match_changed_files.sh '^src|examples/nxp/rt1020-evk-make-freertos-builtin'; then
-          make -C examples/nxp/rt1020-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_rt1060:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 3 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/nxp/rt1060.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/nxp/rt1060-evk-make-baremetal-builtin'; then
-          make -C examples/nxp/rt1060-evk-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-    - if: ${{ env.GO == 1 }}
-      run: |
-        if ./test/match_changed_files.sh '^src|examples/device-dashboard|examples/nxp/rt1060-evk-make-freertos-builtin'; then
-          make -C examples/nxp/rt1060-evk-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-        fi
-
-  test_tm4c:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/ti/ek-tm4c.*-make-" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run:  make -C examples/ti/ek-tm4c1294xl-make-baremetal-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - if: ${{ env.GO == 1 }}
-      run:  make -C examples/ti/ek-tm4c1294xl-make-freertos-builtin test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_same54:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - name: baremetal
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/microchip/same54-xpro" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run:  make -C examples/microchip/same54-xpro/device-dashboard test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-    - if: ${{ env.GO == 1 }}
-      run:  make -C examples/microchip/same54-xpro/mqtt-client test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-
-  test_pico_w5500:
-    runs-on: ubuntu-latest
-    env:
-      GO: 0
-    steps:
-    - uses: actions/checkout@v3
-      with: { fetch-depth: 2 }
-    - name: SDK
-      run: |
-        if ./test/match_changed_files.sh "^src|examples/device-dashboard|examples/rp2040/pico-w5500" ; then
-          echo GO=1 >> $GITHUB_ENV
-          sudo apt -y update && sudo apt -y install gcc-arm-none-eabi
-        fi
-    - if: ${{ env.GO == 1 }}
-      run:  make -C examples/rp2040/pico-w5500 test VCON_API_KEY=${{secrets.VCON_API_KEY}}
-

.mbedignore

@@ -0,0 +1,9 @@
+binary/
+deps/
+docker/
+docs/
+examples/
+platforms/
+src/
+test/
+multilingual/

LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2004-2013 Sergey Lyubka
-Copyright (c) 2013-2025 Cesanta Software Limited
+Copyright (c) 2013-2020 Cesanta Software Limited
 All rights reserved
 
 This software is dual-licensed: you can redistribute it and/or modify
@@ -13,4 +13,4 @@ warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details.
 
 Alternatively, you can license this software under a commercial
-license, as set out in <https://mongoose.ws/licensing/>.
+license, as set out in <https://www.cesanta.com/license>.

README.md

@@ -1,187 +1,12 @@
-# Mongoose - Embedded Web Server / Embedded Network Library
+# Mongoose - Embedded Web Server / Embedded Networking Library
 
-[![License: GPLv2/Commercial](https://img.shields.io/badge/License-GPLv2%20or%20Commercial-green.svg)](https://opensource.org/licenses/gpl-2.0.php)
+![](https://img.shields.io/badge/license-GPL_2-green.svg "License")
-[![Build Status]( https://github.com/cesanta/mongoose/workflows/build/badge.svg)](https://github.com/cesanta/mongoose/actions)
-[![Code Coverage](https://codecov.io/gh/cesanta/mongoose/branch/master/graph/badge.svg)](https://codecov.io/gh/cesanta/mongoose)
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/mongoose.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:mongoose)
-[![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20Mongoose%20Guru-006BFF)](https://gurubase.io/g/mongoose)
 
-Mongoose is a network library for C/C++.  It provides event-driven non-blocking
+This branch is only for use by [Mongoose OS](https://github.com/cesanta/mongoose-os),
-APIs for TCP, UDP, HTTP, WebSocket, MQTT, and other protocols.  It is designed
+for other projects please use the master branch.
-for connecting devices and bringing them online. On the market since 2004, used
-by vast number of open source and commercial products - it even runs on the
-International Space Station!  Mongoose makes embedded network programming fast,
-robust, and easy. Features include:
 
-- Cross-platform:
+# Licensing
-  - works on Linux/UNIX, MacOS, Windows, Android
-  - works on ST, NXP, ESP32, Nordic, TI, Microchip, Infineon, Renesas and other chips
-  - write code once - and it'll work everywhere
-  - ideal for the unification of the network infrastructure code across company
-- Built-in protocols: plain TCP/UDP, SNTP, HTTP, MQTT, Websocket, and other
-- Asynchronous DNS resolver
-- Tiny static and run-time footprint
-- Source code is both ISO C and ISO C++ compliant
-- Easy to integrate: just copy [mongoose.c](https://raw.githubusercontent.com/cesanta/mongoose/master/mongoose.c)
-  and [mongoose.h](https://raw.githubusercontent.com/cesanta/mongoose/master/mongoose.h) files to your source tree
-- Built-in TCP/IP stack with drivers for bare metal or RTOS systems
-   - Available drivers: STM32F, STM32H; NXP RT1xxx; TI TM4C; Microchip SAME54; Wiznet W5500
-   - A complete Web device dashboard on bare metal ST Nucleo boards is only 6 files
-   - For comparison, a CubeIDE generated HTTP example is 400+ files
-- Can run on top of an existing TCP/IP stack with BSD API, e.g. lwIP, Zephyr, Azure, etc
-- Built-in TLS 1.3 ECC stack. Also can use external TLS libraries - mbedTLS, OpenSSL, or other
-- Does not depend on any other software to implement networking
-- Built-in firmware updates for STM32 H5, STM32 H7
 
-See https://mongoose.ws/ for complete documentation, videos, case studies, etc.
+Mongoose is released under Commercial and [GNU GPL v.2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.html) open source licenses.
 
-## Usage Examples
+Commercial Projects: [Contact us for commercial license.](https://www.cesanta.com/contact.html)
-
-Below are quick snippets that should give an idea how simple the API is and
-how easy it is to create applications with it.
-
-Create a simple web server that serves a directory. The behavior of the
-HTTP server is specified by its event handler function:
-
-```c
-#include "mongoose.h"   // To build, run: cc main.c mongoose.c
-
-// HTTP server event handler function
-void ev_handler(struct mg_connection *c, int ev, void *ev_data) {
-  if (ev == MG_EV_HTTP_MSG) {
-    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-    struct mg_http_serve_opts opts = { .root_dir = "./web_root/" };
-    mg_http_serve_dir(c, hm, &opts);
-  }
-}
-
-int main(void) {
-  struct mg_mgr mgr;  // Declare event manager
-  mg_mgr_init(&mgr);  // Initialise event manager
-  mg_http_listen(&mgr, "http://0.0.0.0:8000", ev_handler, NULL);  // Setup listener
-  for (;;) {          // Run an infinite event loop
-    mg_mgr_poll(&mgr, 1000);
-  }
-  return 0;
-}
-```
-
-HTTP server implements a REST API that returns current time. JSON formatting:
-```c
-static void ev_handler(struct mg_connection *c, int ev, void *ev_data) {
-  if (ev == MG_EV_HTTP_MSG) {
-    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-    if (mg_match(hm->uri, mg_str("/api/time/get"), NULL)) {
-      mg_http_reply(c, 200, "", "{%m:%lu}\n", MG_ESC("time"), time(NULL));
-    } else {
-      mg_http_reply(c, 500, "", "{%m:%m}\n", MG_ESC("error"), MG_ESC("Unsupported URI")); 
-    }
-  }
-}
-```
-
-MQTT client that subscribes to a topic `device1/rx` and
-echoes incoming messages to `device1/tx`:
-
-```c
-#include "mongoose.h"
-
-static const char *s_mqtt_url = "mqtt://broker.hivemq.com:1883";
-static struct mg_connection *s_mqtt_conn = NULL;
-
-// MQTT connection event handler function
-static void ev_handler(struct mg_connection *c, int ev, void *ev_data) {
-  if (ev == MG_EV_OPEN) {
-    MG_INFO(("%lu created, connecting to %s ...", c->id, s_mqtt_url));
-  } else if (ev == MG_EV_MQTT_OPEN) {
-    struct mg_mqtt_opts opts = {.qos = 1, .topic = mg_str("device1/rx")};
-    mg_mqtt_sub(c, &opts);
-    MG_INFO(("%lu connected, subscribing to %s", c->id, opts.topic.buf));
-  } else if (ev == MG_EV_MQTT_MSG) {
-    char response[100];
-    struct mg_mqtt_message *mm = (struct mg_mqtt_message *) ev_data;
-    struct mg_mqtt_opts opts = {.qos = 1, .topic = mg_str("device1/tx")};
-    mg_snprintf(response, sizeof(response), "Received [%.*s] / [%.*s]",
-                mm->topic.len, mm->topic.buf, mm->data.len, mm->data.buf);
-    opts.message = mg_str(response);
-    mg_mqtt_pub(c, &opts);
-  } else if (ev == MG_EV_CLOSE) {
-    MG_INFO(("%u closing", c->id));
-    s_mqtt_conn = NULL;
-  }
-}
-
-// Reconnection timer function. If we get disconnected, reconnect again
-static void timer_fn(void *arg) {
-  struct mg_mgr *mgr = (struct mg_mgr *) arg;
-  if (s_mqtt_conn == NULL) {
-    struct mg_mqtt_opts opts = {.clean = true};
-    s_mqtt_conn = mg_mqtt_connect(mgr, s_mqtt_url, &opts, ev_handler, NULL);
-  }
-}
-
-int main() {
-  struct mg_mgr mgr;  // Mongoose event manager. Holds all connections
-  mg_mgr_init(&mgr);  // Initialise event manager
-  mg_timer_add(&mgr, 3000, MG_TIMER_REPEAT | MG_TIMER_RUN_NOW, timer_fn, &mgr);
-  for (;;) {
-    mg_mgr_poll(&mgr, 1000);  // Infinite event loop
-  }
-  return 0;
-}
-```
-
-## Commercial use
-- Mongoose is used by hundreds of businesses, from Fortune500 giants like
-  Siemens, Schneider Electric, Broadcom, Bosch, Google, Samsung, Qualcomm, Caterpillar to the small businesses
-- Used to solve a wide range of business needs, like implementing Web UI
-  interface on devices, RESTful API services, telemetry data exchange, remote
-  control for a product, remote software updates, remote monitoring, and others
-- Deployed to hundreds of millions devices in production environment worldwide
-- See [Case Studies](https://mongoose.ws/case-studies/) from our respected
-  customers like [Schneider Electric](https://mongoose.ws/case-studies/schneider-electric/) (industrial automation), [Broadcom](https://mongoose.ws/case-studies/broadcom/) (semiconductors), [Pilz](https://mongoose.ws/case-studies/pilz/) (industrial automation), and others
-- See [Testimonials](https://mongoose.ws/testimonials/) from engineers that integrated Mongoose in their commercial products
-- We provide [Evaluation and Commercial licensing](https://mongoose.ws/licensing/), [support](https://mongoose.ws/support/), consultancy and [integration
-  services](https://mongoose.ws/integration/) - don't hesitate to [contact us](https://mongoose.ws/contact/)
-
-
-## Security
-
-We take security seriously:
-1. Mongoose repository runs a
-  [continuous integration test powered by GitHub](https://github.com/cesanta/mongoose/actions),
-  which runs through hundreds of unit tests on every commit to the repository.
-  Our [unit tests](https://github.com/cesanta/mongoose/tree/master/test)
-  are built with modern address sanitizer technologies, which help to find
-  security vulnerabilities early
-2. Mongoose repository is integrated into Google's
-  [oss-fuzz continuous fuzzer](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:mongoose)
-  which scans for potential vulnerabilities continuously
-3.  We receive periodic vulnerability reports from the independent security
-  groups like
-  [Cisco Talos](https://www.cisco.com/c/en/us/products/security/talos.html),
-  [Microsoft Security Response Center](https://www.microsoft.com/en-us/msrc),
-  [MITRE Corporation](https://www.mitre.org/),
-  [Compass Security](https://www.compass-security.com/en/) and others.
-  In case of the vulnerability found, we act according to the industry best
-  practice: hold on to the publication, fix the software and notify all our
-  customers that have an appropriate subscription
-4. Some of our customers (for example NASA)
-  have specific security requirements and run independent security audits,
-  of which we get notified and in case of any issue, act similar to (3).
-
-
-## Articles
-
-Technical guides and deep dives into embedded web servers, WebUI integration and embedded networking technologies:
-- [Embedded Web Server: A Comprehensive Guide for Modern Connected Devices](https://mongoose.ws/articles/embedded-web-server-a-comprehensive-guide-for-modern-connected-devices/)
-- [Building Embedded Web Device Dashboards](https://mongoose.ws/articles/building-embedded-web-device-dashboard/)
-- [ESP32 Device Dashboard: A Step-by-Step Guide for Developers](https://mongoose.ws/articles/esp32-device-dashboard/)
-
-
-## Contributions
-
-Contributions are welcome! Please follow the guidelines below:
-
-- Sign [Cesanta CLA](https://cesanta.com/cla.html) and send GitHub pull request
-- Make sure that PRs have only one commit, and deal with one issue only

docs/c-api/intro.md

@@ -0,0 +1,16 @@
+---
+items:
+  - { name: mbuf.h }
+  - { name: mg_net.h }
+  - { name: mg_http.h }
+  - { name: mg_http_server.h }
+  - { name: mg_http_client.h }
+  - { name: mg_dns.h }
+  - { name: mg_dns_server.h }
+  - { name: mg_resolv.h }
+  - { name: mg_mqtt.h }
+  - { name: mg_mqtt_server.h }
+  - { name: mg_coap.h }
+  - { name: mg_util.h }
+  - { name: mg_uri.h }
+---

docs/c-api/mbuf.h/intro.md

@@ -0,0 +1,23 @@
+---
+title: "mbuf.h"
+symbol_kind: "intro"
+decl_name: "mbuf.h"
+items:
+  - { name: mbuf_append.md }
+  - { name: mbuf_append_and_free.md }
+  - { name: mbuf_clear.md }
+  - { name: mbuf_free.md }
+  - { name: mbuf_init.md }
+  - { name: mbuf_insert.md }
+  - { name: mbuf_move.md }
+  - { name: mbuf_remove.md }
+  - { name: mbuf_resize.md }
+  - { name: mbuf_trim.md }
+  - { name: struct_mbuf.md }
+---
+
+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.
+

docs/c-api/mbuf.h/mbuf_append.md

@@ -0,0 +1,12 @@
+---
+title: "mbuf_append()"
+decl_name: "mbuf_append"
+symbol_kind: "func"
+signature: |
+  size_t mbuf_append(struct mbuf *, const void *data, size_t data_size);
+---
+
+Appends data to the Mbuf.
+
+Returns the number of bytes appended or 0 if out of memory. 
+

docs/c-api/mbuf.h/mbuf_append_and_free.md

@@ -0,0 +1,13 @@
+---
+title: "mbuf_append_and_free()"
+decl_name: "mbuf_append_and_free"
+symbol_kind: "func"
+signature: |
+  size_t mbuf_append_and_free(struct mbuf *, 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. 
+

docs/c-api/mbuf.h/mbuf_clear.md

@@ -0,0 +1,10 @@
+---
+title: "mbuf_clear()"
+decl_name: "mbuf_clear"
+symbol_kind: "func"
+signature: |
+  void mbuf_clear(struct mbuf *);
+---
+
+Removes all the data from mbuf (if any). 
+

docs/c-api/mbuf.h/mbuf_free.md

@@ -0,0 +1,10 @@
+---
+title: "mbuf_free()"
+decl_name: "mbuf_free"
+symbol_kind: "func"
+signature: |
+  void mbuf_free(struct mbuf *);
+---
+
+Frees the space allocated for the mbuffer and resets the mbuf structure. 
+

docs/c-api/mbuf.h/mbuf_init.md

@@ -0,0 +1,11 @@
+---
+title: "mbuf_init()"
+decl_name: "mbuf_init"
+symbol_kind: "func"
+signature: |
+  void mbuf_init(struct mbuf *, size_t initial_capacity);
+---
+
+Initialises an Mbuf.
+`initial_capacity` specifies the initial capacity of the mbuf. 
+

docs/c-api/mbuf.h/mbuf_insert.md

@@ -0,0 +1,14 @@
+---
+title: "mbuf_insert()"
+decl_name: "mbuf_insert"
+symbol_kind: "func"
+signature: |
+  size_t mbuf_insert(struct mbuf *, size_t, const void *, size_t);
+---
+
+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. 
+

docs/c-api/mbuf.h/mbuf_move.md

@@ -0,0 +1,10 @@
+---
+title: "mbuf_move()"
+decl_name: "mbuf_move"
+symbol_kind: "func"
+signature: |
+  void mbuf_move(struct mbuf *from, struct mbuf *to);
+---
+
+Moves the state from one mbuf to the other. 
+

docs/c-api/mbuf.h/mbuf_remove.md

@@ -0,0 +1,10 @@
+---
+title: "mbuf_remove()"
+decl_name: "mbuf_remove"
+symbol_kind: "func"
+signature: |
+  void mbuf_remove(struct mbuf *, size_t data_size);
+---
+
+Removes `data_size` bytes from the beginning of the buffer. 
+

docs/c-api/mbuf.h/mbuf_resize.md

@@ -0,0 +1,13 @@
+---
+title: "mbuf_resize()"
+decl_name: "mbuf_resize"
+symbol_kind: "func"
+signature: |
+  void mbuf_resize(struct mbuf *, size_t new_size);
+---
+
+Resizes an Mbuf.
+
+If `new_size` is smaller than buffer's `len`, the
+resize is not performed. 
+

docs/c-api/mbuf.h/mbuf_trim.md

@@ -0,0 +1,10 @@
+---
+title: "mbuf_trim()"
+decl_name: "mbuf_trim"
+symbol_kind: "func"
+signature: |
+  void mbuf_trim(struct mbuf *);
+---
+
+Shrinks an Mbuf by resizing its `size` to `len`. 
+

docs/c-api/mbuf.h/struct_mbuf.md

@@ -0,0 +1,14 @@
+---
+title: "struct mbuf"
+decl_name: "struct mbuf"
+symbol_kind: "struct"
+signature: |
+  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 */
+  };
+---
+
+Memory buffer descriptor 
+

docs/c-api/mg_coap.h/intro.md

@@ -0,0 +1,26 @@
+---
+title: "CoAP API reference"
+symbol_kind: "intro"
+decl_name: "mg_coap.h"
+items:
+  - { name: mg_coap_add_option.md }
+  - { name: mg_coap_compose.md }
+  - { name: mg_coap_free_options.md }
+  - { name: mg_coap_parse.md }
+  - { name: mg_coap_send_ack.md }
+  - { name: mg_coap_send_message.md }
+  - { name: mg_set_protocol_coap.md }
+  - { name: struct_mg_coap_message.md }
+  - { name: struct_mg_coap_option.md }
+---
+
+CoAP message format:
+
+```
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+|Ver| T | TKL | Code | Message ID | Token (if any, TKL bytes) ...
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+| Options (if any) ...            |1 1 1 1 1 1 1 1| Payload (if any) ...
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+```
+

docs/c-api/mg_coap.h/mg_coap_add_option.md

@@ -0,0 +1,14 @@
+---
+title: "mg_coap_add_option()"
+decl_name: "mg_coap_add_option"
+symbol_kind: "func"
+signature: |
+  struct mg_coap_option *mg_coap_add_option(struct mg_coap_message *cm,
+                                            uint32_t number, char *value,
+                                            size_t len);
+---
+
+Adds a new option to mg_coap_message structure.
+Returns pointer to the newly created option.
+Note: options must be freed by using mg_coap_free_options 
+

docs/c-api/mg_coap.h/mg_coap_compose.md

@@ -0,0 +1,12 @@
+---
+title: "mg_coap_compose()"
+decl_name: "mg_coap_compose"
+symbol_kind: "func"
+signature: |
+  uint32_t mg_coap_compose(struct mg_coap_message *cm, struct mbuf *io);
+---
+
+Composes CoAP message from mg_coap_message structure.
+This is a helper function.
+Return value: see `mg_coap_send_message()` 
+

docs/c-api/mg_coap.h/mg_coap_free_options.md

@@ -0,0 +1,11 @@
+---
+title: "mg_coap_free_options()"
+decl_name: "mg_coap_free_options"
+symbol_kind: "func"
+signature: |
+  void mg_coap_free_options(struct mg_coap_message *cm);
+---
+
+Frees the memory allocated for options.
+If the cm parameter doesn't contain any option it does nothing. 
+

docs/c-api/mg_coap.h/mg_coap_parse.md

@@ -0,0 +1,22 @@
+---
+title: "mg_coap_parse()"
+decl_name: "mg_coap_parse"
+symbol_kind: "func"
+signature: |
+  uint32_t mg_coap_parse(struct mbuf *io, struct mg_coap_message *cm);
+---
+
+Parses CoAP message and fills mg_coap_message and returns cm->flags.
+This is a helper function.
+
+NOTE: usually CoAP works over UDP, so lack of data means format error.
+But, in theory, it is possible to use CoAP over TCP (according to RFC)
+
+The caller has to check results and treat COAP_NOT_ENOUGH_DATA according to
+underlying protocol:
+
+- in case of UDP COAP_NOT_ENOUGH_DATA means COAP_FORMAT_ERROR,
+- in case of TCP client can try to receive more data
+
+Return value: see `mg_coap_send_message()` 
+

docs/c-api/mg_coap.h/mg_coap_send_ack.md

@@ -0,0 +1,12 @@
+---
+title: "mg_coap_send_ack()"
+decl_name: "mg_coap_send_ack"
+symbol_kind: "func"
+signature: |
+  uint32_t mg_coap_send_ack(struct mg_connection *nc, uint16_t msg_id);
+---
+
+Composes CoAP acknowledgement from `mg_coap_message`
+and sends it into `nc` connection.
+Return value: see `mg_coap_send_message()` 
+

docs/c-api/mg_coap.h/mg_coap_send_message.md

@@ -0,0 +1,19 @@
+---
+title: "mg_coap_send_message()"
+decl_name: "mg_coap_send_message"
+symbol_kind: "func"
+signature: |
+  uint32_t mg_coap_send_message(struct mg_connection *nc,
+                                struct mg_coap_message *cm);
+---
+
+Composes a CoAP message from `mg_coap_message`
+and sends it into `nc` connection.
+Returns 0 on success. On error, it is a bitmask:
+
+- `#define MG_COAP_ERROR 0x10000`
+- `#define MG_COAP_FORMAT_ERROR (MG_COAP_ERROR | 0x20000)`
+- `#define MG_COAP_IGNORE (MG_COAP_ERROR | 0x40000)`
+- `#define MG_COAP_NOT_ENOUGH_DATA (MG_COAP_ERROR | 0x80000)`
+- `#define MG_COAP_NETWORK_ERROR (MG_COAP_ERROR | 0x100000)` 
+

docs/c-api/mg_coap.h/mg_set_protocol_coap.md

@@ -0,0 +1,10 @@
+---
+title: "mg_set_protocol_coap()"
+decl_name: "mg_set_protocol_coap"
+symbol_kind: "func"
+signature: |
+  int mg_set_protocol_coap(struct mg_connection *nc);
+---
+
+Sets CoAP protocol handler - triggers CoAP specific events. 
+

docs/c-api/mg_coap.h/struct_mg_coap_message.md

@@ -0,0 +1,20 @@
+---
+title: "struct mg_coap_message"
+decl_name: "struct mg_coap_message"
+symbol_kind: "struct"
+signature: |
+  struct mg_coap_message {
+    uint32_t flags;
+    uint8_t msg_type;
+    uint8_t code_class;
+    uint8_t code_detail;
+    uint16_t msg_id;
+    struct mg_str token;
+    struct mg_coap_option *options;
+    struct mg_str payload;
+    struct mg_coap_option *optiomg_tail;
+  };
+---
+
+CoAP message. See RFC 7252 for details. 
+

docs/c-api/mg_coap.h/struct_mg_coap_option.md

@@ -0,0 +1,16 @@
+---
+title: "struct mg_coap_option"
+decl_name: "struct mg_coap_option"
+symbol_kind: "struct"
+signature: |
+  struct mg_coap_option {
+    struct mg_coap_option *next;
+    uint32_t number;
+    struct mg_str value;
+  };
+---
+
+CoAP options.
+Use mg_coap_add_option and mg_coap_free_options
+for creation and destruction. 
+

docs/c-api/mg_dns.h/intro.md

@@ -0,0 +1,20 @@
+---
+title: "DNS API reference"
+symbol_kind: "intro"
+decl_name: "mg_dns.h"
+items:
+  - { name: mg_dns_copy_questions.md }
+  - { name: mg_dns_encode_name.md }
+  - { name: mg_dns_encode_record.md }
+  - { name: mg_dns_insert_header.md }
+  - { name: mg_dns_parse_record_data.md }
+  - { name: mg_dns_uncompress_name.md }
+  - { name: mg_parse_dns.md }
+  - { name: mg_send_dns_query.md }
+  - { name: mg_set_protocol_dns.md }
+  - { name: struct_mg_dns_message.md }
+  - { name: struct_mg_dns_resource_record.md }
+---
+
+
+

docs/c-api/mg_dns.h/mg_dns_copy_questions.md

@@ -0,0 +1,15 @@
+---
+title: "mg_dns_copy_questions()"
+decl_name: "mg_dns_copy_questions"
+symbol_kind: "func"
+signature: |
+  int mg_dns_copy_questions(struct mbuf *io, struct mg_dns_message *msg);
+---
+
+Appends already encoded questions from an existing message.
+
+This is useful when generating a DNS reply message which includes
+all question records.
+
+Returns the number of appended bytes. 
+

docs/c-api/mg_dns.h/mg_dns_encode_name.md

@@ -0,0 +1,10 @@
+---
+title: "mg_dns_encode_name()"
+decl_name: "mg_dns_encode_name"
+symbol_kind: "func"
+signature: |
+  int mg_dns_encode_name(struct mbuf *io, const char *name, size_t len);
+---
+
+Encodes a DNS name. 
+

docs/c-api/mg_dns.h/mg_dns_encode_record.md

@@ -0,0 +1,25 @@
+---
+title: "mg_dns_encode_record()"
+decl_name: "mg_dns_encode_record"
+symbol_kind: "func"
+signature: |
+  int mg_dns_encode_record(struct mbuf *io, struct mg_dns_resource_record *rr,
+                           const char *name, size_t nlen, const void *rdata,
+                           size_t rlen);
+---
+
+Encodes and appends a DNS resource record to an IO buffer.
+
+The record metadata is taken from the `rr` parameter, while the name and data
+are taken from the parameters, encoded in the appropriate format depending on
+record type and stored in the IO buffer. The encoded values might contain
+offsets within the IO buffer. It's thus important that the IO buffer doesn't
+get trimmed while a sequence of records are encoded while preparing a DNS
+reply.
+
+This function doesn't update the `name` and `rdata` pointers in the `rr`
+struct because they might be invalidated as soon as the IO buffer grows
+again.
+
+Returns the number of bytes appended or -1 in case of error. 
+

docs/c-api/mg_dns.h/mg_dns_insert_header.md

@@ -0,0 +1,13 @@
+---
+title: "mg_dns_insert_header()"
+decl_name: "mg_dns_insert_header"
+symbol_kind: "func"
+signature: |
+  int mg_dns_insert_header(struct mbuf *io, size_t pos,
+                           struct mg_dns_message *msg);
+---
+
+Inserts a DNS header to an IO buffer.
+
+Returns the number of bytes inserted. 
+

docs/c-api/mg_dns.h/mg_dns_parse_record_data.md

@@ -0,0 +1,20 @@
+---
+title: "mg_dns_parse_record_data()"
+decl_name: "mg_dns_parse_record_data"
+symbol_kind: "func"
+signature: |
+  int mg_dns_parse_record_data(struct mg_dns_message *msg,
+                               struct mg_dns_resource_record *rr, void *data,
+                               size_t data_len);
+---
+
+Parses the record data from a DNS resource record.
+
+ - A:     struct in_addr *ina
+ - AAAA:  struct in6_addr *ina
+ - CNAME: char buffer
+
+Returns -1 on error.
+
+TODO(mkm): MX 
+

docs/c-api/mg_dns.h/mg_dns_uncompress_name.md

@@ -0,0 +1,21 @@
+---
+title: "mg_dns_uncompress_name()"
+decl_name: "mg_dns_uncompress_name"
+symbol_kind: "func"
+signature: |
+  size_t mg_dns_uncompress_name(struct mg_dns_message *msg, struct mg_str *name,
+                                char *dst, int dst_len);
+---
+
+Uncompresses a DNS compressed name.
+
+The containing DNS message is required because of the compressed encoding
+and reference suffixes present elsewhere in the packet.
+
+If the name is less than `dst_len` characters long, the remainder
+of `dst` is terminated with `\0` characters. Otherwise, `dst` is not
+terminated.
+
+If `dst_len` is 0 `dst` can be NULL.
+Returns the uncompressed name length. 
+

docs/c-api/mg_dns.h/mg_parse_dns.md

@@ -0,0 +1,10 @@
+---
+title: "mg_parse_dns()"
+decl_name: "mg_parse_dns"
+symbol_kind: "func"
+signature: |
+  int mg_parse_dns(const char *buf, int len, struct mg_dns_message *msg);
+---
+
+Low-level: parses a DNS response. 
+

docs/c-api/mg_dns.h/mg_send_dns_query.md

@@ -0,0 +1,11 @@
+---
+title: "mg_send_dns_query()"
+decl_name: "mg_send_dns_query"
+symbol_kind: "func"
+signature: |
+  void mg_send_dns_query(struct mg_connection *nc, const char *name,
+                         int query_type);
+---
+
+Sends a DNS query to the remote end. 
+

docs/c-api/mg_dns.h/mg_set_protocol_dns.md

@@ -0,0 +1,19 @@
+---
+title: "mg_set_protocol_dns()"
+decl_name: "mg_set_protocol_dns"
+symbol_kind: "func"
+signature: |
+  void mg_set_protocol_dns(struct mg_connection *nc);
+---
+
+Attaches a built-in DNS event handler to the given listening connection.
+
+The DNS event handler parses the incoming UDP packets, treating them as DNS
+requests. If an incoming packet gets successfully parsed by the DNS event
+handler, a user event handler will receive an `MG_DNS_REQUEST` event, with
+`ev_data` pointing to the parsed `struct mg_dns_message`.
+
+See
+[captive_dns_server](https://github.com/cesanta/mongoose/tree/master/examples/captive_dns_server)
+example on how to handle DNS request and send DNS reply. 
+

docs/c-api/mg_dns.h/struct_mg_dns_message.md

@@ -0,0 +1,18 @@
+---
+title: "struct mg_dns_message"
+decl_name: "struct mg_dns_message"
+symbol_kind: "struct"
+signature: |
+  struct mg_dns_message {
+    struct mg_str pkt; /* packet body */
+    uint16_t flags;
+    uint16_t transaction_id;
+    int num_questions;
+    int num_answers;
+    struct mg_dns_resource_record questions[MG_MAX_DNS_QUESTIONS];
+    struct mg_dns_resource_record answers[MG_MAX_DNS_ANSWERS];
+  };
+---
+
+DNS message (request and response). 
+

docs/c-api/mg_dns.h/struct_mg_dns_resource_record.md

@@ -0,0 +1,17 @@
+---
+title: "struct mg_dns_resource_record"
+decl_name: "struct mg_dns_resource_record"
+symbol_kind: "struct"
+signature: |
+  struct mg_dns_resource_record {
+    struct mg_str name; /* buffer with compressed name */
+    int rtype;
+    int rclass;
+    int ttl;
+    enum mg_dns_resource_record_kind kind;
+    struct mg_str rdata; /* protocol data (can be a compressed name) */
+  };
+---
+
+DNS resource record. 
+

docs/c-api/mg_dns_server.h/intro.md

@@ -0,0 +1,12 @@
+---
+title: "DNS server API reference"
+symbol_kind: "intro"
+decl_name: "mg_dns_server.h"
+items:
+  - { name: mg_dns_create_reply.md }
+  - { name: mg_dns_reply_record.md }
+  - { name: mg_dns_send_reply.md }
+---
+
+Disabled by default; enable with `-DMG_ENABLE_DNS_SERVER`.
+

docs/c-api/mg_dns_server.h/mg_dns_create_reply.md

@@ -0,0 +1,36 @@
+---
+title: "mg_dns_create_reply()"
+decl_name: "mg_dns_create_reply"
+symbol_kind: "func"
+signature: |
+  struct mg_dns_reply mg_dns_create_reply(struct mbuf *io,
+                                          struct mg_dns_message *msg);
+---
+
+Creates a DNS reply.
+
+The reply will be based on an existing query message `msg`.
+The query body will be appended to the output buffer.
+"reply + recursion allowed" will be added to the message flags and the
+message's num_answers will be set to 0.
+
+Answer records can be appended with `mg_dns_send_reply` or by lower
+level function defined in the DNS API.
+
+In order to send a reply use `mg_dns_send_reply`.
+It's possible to use a connection's send buffer as reply buffer,
+and it will work for both UDP and TCP connections.
+
+Example:
+
+```c
+reply = mg_dns_create_reply(&nc->send_mbuf, msg);
+for (i = 0; i < msg->num_questions; i++) {
+  rr = &msg->questions[i];
+  if (rr->rtype == MG_DNS_A_RECORD) {
+    mg_dns_reply_record(&reply, rr, 3600, &dummy_ip_addr, 4);
+  }
+}
+mg_dns_send_reply(nc, &reply);
+``` 
+

docs/c-api/mg_dns_server.h/mg_dns_reply_record.md

@@ -0,0 +1,18 @@
+---
+title: "mg_dns_reply_record()"
+decl_name: "mg_dns_reply_record"
+symbol_kind: "func"
+signature: |
+  int mg_dns_reply_record(struct mg_dns_reply *reply,
+                          struct mg_dns_resource_record *question,
+                          const char *name, int rtype, int ttl, const void *rdata,
+                          size_t rdata_len);
+---
+
+Appends a DNS reply record to the IO buffer and to the DNS message.
+
+The message's num_answers field will be incremented. It's the caller's duty
+to ensure num_answers is properly initialised.
+
+Returns -1 on error. 
+

docs/c-api/mg_dns_server.h/mg_dns_send_reply.md

@@ -0,0 +1,19 @@
+---
+title: "mg_dns_send_reply()"
+decl_name: "mg_dns_send_reply"
+symbol_kind: "func"
+signature: |
+  void mg_dns_send_reply(struct mg_connection *nc, struct mg_dns_reply *r);
+---
+
+Sends a DNS reply through a connection.
+
+The DNS data is stored in an IO buffer pointed by reply structure in `r`.
+This function mutates the content of that buffer in order to ensure that
+the DNS header reflects the size and flags of the message, that might have
+been updated either with `mg_dns_reply_record` or by direct manipulation of
+`r->message`.
+
+Once sent, the IO buffer will be trimmed unless the reply IO buffer
+is the connection's send buffer and the connection is not in UDP mode. 
+

docs/c-api/mg_http.h/intro.md

@@ -0,0 +1,26 @@
+---
+title: "Common API reference"
+symbol_kind: "intro"
+decl_name: "mg_http.h"
+items:
+  - { name: mg_connect_ws.md }
+  - { name: mg_connect_ws_opt.md }
+  - { name: mg_http_is_authorized.md }
+  - { name: mg_http_send_digest_auth_request.md }
+  - { name: mg_printf_websocket_frame.md }
+  - { name: mg_send_websocket_frame.md }
+  - { name: mg_send_websocket_framev.md }
+  - { name: mg_send_websocket_handshake.md }
+  - { name: mg_send_websocket_handshake2.md }
+  - { name: mg_send_websocket_handshake3.md }
+  - { name: mg_send_websocket_handshake3v.md }
+  - { name: mg_set_protocol_http_websocket.md }
+  - { name: mg_url_decode.md }
+  - { name: struct_http_message.md }
+  - { name: struct_mg_http_multipart_part.md }
+  - { name: struct_mg_ssi_call_ctx.md }
+  - { name: struct_websocket_message.md }
+---
+
+
+

docs/c-api/mg_http.h/mg_connect_ws.md

@@ -0,0 +1,29 @@
+---
+title: "mg_connect_ws()"
+decl_name: "mg_connect_ws"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_ws(struct mg_mgr *mgr,
+                                      MG_CB(mg_event_handler_t event_handler,
+                                            void *user_data);
+---
+
+Helper function that creates an outbound WebSocket connection.
+
+`url` is a URL to connect to. It must be properly URL-encoded, e.g. have
+no spaces, etc. By default, `mg_connect_ws()` sends Connection and
+Host headers. `extra_headers` is an extra HTTP header to send, e.g.
+`"User-Agent: my-app\r\n"`.
+If `protocol` is not NULL, then a `Sec-WebSocket-Protocol` header is sent.
+
+Examples:
+
+```c
+  nc1 = mg_connect_ws(mgr, ev_handler_1, "ws://echo.websocket.org", NULL,
+                      NULL);
+  nc2 = mg_connect_ws(mgr, ev_handler_1, "wss://echo.websocket.org", NULL,
+                      NULL);
+  nc3 = mg_connect_ws(mgr, ev_handler_1, "ws://api.cesanta.com",
+                      "clubby.cesanta.com", NULL);
+``` 
+

docs/c-api/mg_http.h/mg_connect_ws_opt.md

@@ -0,0 +1,14 @@
+---
+title: "mg_connect_ws_opt()"
+decl_name: "mg_connect_ws_opt"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_ws_opt(
+      struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data);
+---
+
+Helper function that creates an outbound WebSocket connection
+
+Mostly identical to `mg_connect_ws`, but allows to provide extra parameters
+(for example, SSL parameters) 
+

docs/c-api/mg_http.h/mg_http_is_authorized.md

@@ -0,0 +1,16 @@
+---
+title: "mg_http_is_authorized()"
+decl_name: "mg_http_is_authorized"
+symbol_kind: "func"
+signature: |
+  int mg_http_is_authorized(struct http_message *hm, struct mg_str path,
+                            const char *domain, const char *passwords_file,
+                            int flags);
+---
+
+Checks whether an http request is authorized. `domain` is the authentication
+realm, `passwords_file` is a htdigest file (can be created e.g. with
+`htdigest` utility). If either `domain` or `passwords_file` is NULL, this
+function always returns 1; otherwise checks the authentication in the
+http request and returns 1 only if there is a match; 0 otherwise. 
+

docs/c-api/mg_http.h/mg_http_send_digest_auth_request.md

@@ -0,0 +1,11 @@
+---
+title: "mg_http_send_digest_auth_request()"
+decl_name: "mg_http_send_digest_auth_request"
+symbol_kind: "func"
+signature: |
+  void mg_http_send_digest_auth_request(struct mg_connection *c,
+                                        const char *domain);
+---
+
+Sends 401 Unauthorized response. 
+

docs/c-api/mg_http.h/mg_printf_websocket_frame.md

@@ -0,0 +1,14 @@
+---
+title: "mg_printf_websocket_frame()"
+decl_name: "mg_printf_websocket_frame"
+symbol_kind: "func"
+signature: |
+  void mg_printf_websocket_frame(struct mg_connection *nc, int op_and_flags,
+                                 const char *fmt, ...);
+---
+
+Sends WebSocket frame to the remote end.
+
+Like `mg_send_websocket_frame()`, but allows to create formatted messages
+with `printf()`-like semantics. 
+

docs/c-api/mg_http.h/mg_send_websocket_frame.md

@@ -0,0 +1,26 @@
+---
+title: "mg_send_websocket_frame()"
+decl_name: "mg_send_websocket_frame"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_frame(struct mg_connection *nc, int op_and_flags,
+                               const void *data, size_t data_len);
+---
+
+Send WebSocket frame to the remote end.
+
+`op_and_flags` specifies the frame's type. It's one of:
+
+- WEBSOCKET_OP_CONTINUE
+- WEBSOCKET_OP_TEXT
+- WEBSOCKET_OP_BINARY
+- WEBSOCKET_OP_CLOSE
+- WEBSOCKET_OP_PING
+- WEBSOCKET_OP_PONG
+
+Orred with one of the flags:
+
+- WEBSOCKET_DONT_FIN: Don't set the FIN flag on the frame to be sent.
+
+`data` and `data_len` contain frame data. 
+

docs/c-api/mg_http.h/mg_send_websocket_framev.md

@@ -0,0 +1,12 @@
+---
+title: "mg_send_websocket_framev()"
+decl_name: "mg_send_websocket_framev"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_framev(struct mg_connection *nc, int op_and_flags,
+                                const struct mg_str *strings, int num_strings);
+---
+
+Like `mg_send_websocket_frame()`, but composes a single frame from multiple
+buffers. 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake.md

@@ -0,0 +1,22 @@
+---
+title: "mg_send_websocket_handshake()"
+decl_name: "mg_send_websocket_handshake"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake(struct mg_connection *nc, const char *uri,
+                                   const char *extra_headers);
+---
+
+Send websocket handshake to the server.
+
+`nc` must be a valid connection, connected to a server. `uri` is an URI
+to fetch, extra_headers` is extra HTTP headers to send or `NULL`.
+
+This function is intended to be used by websocket client.
+
+Note that the Host header is mandatory in HTTP/1.1 and must be
+included in `extra_headers`. `mg_send_websocket_handshake2` offers
+a better API for that.
+
+Deprecated in favour of `mg_send_websocket_handshake2` 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake2.md

@@ -0,0 +1,19 @@
+---
+title: "mg_send_websocket_handshake2()"
+decl_name: "mg_send_websocket_handshake2"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path,
+                                    const char *host, const char *protocol,
+                                    const char *extra_headers);
+---
+
+Send websocket handshake to the server.
+
+`nc` must be a valid connection, connected to a server. `uri` is an URI
+to fetch, `host` goes into the `Host` header, `protocol` goes into the
+`Sec-WebSocket-Proto` header (NULL to omit), extra_headers` is extra HTTP
+headers to send or `NULL`.
+
+This function is intended to be used by websocket client. 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake3.md

@@ -0,0 +1,13 @@
+---
+title: "mg_send_websocket_handshake3()"
+decl_name: "mg_send_websocket_handshake3"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path,
+                                    const char *host, const char *protocol,
+                                    const char *extra_headers, const char *user,
+                                    const char *pass);
+---
+
+Like mg_send_websocket_handshake2 but also passes basic auth header 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake3v.md

@@ -0,0 +1,17 @@
+---
+title: "mg_send_websocket_handshake3v()"
+decl_name: "mg_send_websocket_handshake3v"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake3v(struct mg_connection *nc,
+                                     const struct mg_str path,
+                                     const struct mg_str host,
+                                     const struct mg_str protocol,
+                                     const struct mg_str extra_headers,
+                                     const struct mg_str user,
+                                     const struct mg_str pass);
+---
+
+Same as mg_send_websocket_handshake3 but with strings not necessarily
+NUL-temrinated 
+

docs/c-api/mg_http.h/mg_set_protocol_http_websocket.md

@@ -0,0 +1,61 @@
+---
+title: "mg_set_protocol_http_websocket()"
+decl_name: "mg_set_protocol_http_websocket"
+symbol_kind: "func"
+signature: |
+  void mg_set_protocol_http_websocket(struct mg_connection *nc);
+---
+
+Attaches a built-in HTTP event handler to the given connection.
+The user-defined event handler will receive following extra events:
+
+- MG_EV_HTTP_REQUEST: HTTP request has arrived. Parsed HTTP request
+ is passed as
+  `struct http_message` through the handler's `void *ev_data` pointer.
+- MG_EV_HTTP_REPLY: The HTTP reply has arrived. The parsed HTTP reply is
+  passed as `struct http_message` through the handler's `void *ev_data`
+  pointer.
+- MG_EV_HTTP_CHUNK: The HTTP chunked-encoding chunk has arrived.
+  The parsed HTTP reply is passed as `struct http_message` through the
+  handler's `void *ev_data` pointer. `http_message::body` would contain
+  incomplete, reassembled HTTP body.
+  It will grow with every new chunk that arrives, and it can
+  potentially consume a lot of memory. An event handler may process
+  the body as chunks are coming, and signal Mongoose to delete processed
+  body by setting `MG_F_DELETE_CHUNK` in `mg_connection::flags`. When
+  the last zero chunk is received,
+  Mongoose sends `MG_EV_HTTP_REPLY` event with
+  full reassembled body (if handler did not signal to delete chunks) or
+  with empty body (if handler did signal to delete chunks).
+- MG_EV_WEBSOCKET_HANDSHAKE_REQUEST: server has received the WebSocket
+  handshake request. `ev_data` contains parsed HTTP request.
+- MG_EV_WEBSOCKET_HANDSHAKE_DONE: server has completed the WebSocket
+  handshake. `ev_data` is a `struct http_message` containing the
+  client's request (server mode) or server's response (client).
+  In client mode handler can examine `resp_code`, which should be 101.
+- MG_EV_WEBSOCKET_FRAME: new WebSocket frame has arrived. `ev_data` is
+  `struct websocket_message *`
+
+When compiled with MG_ENABLE_HTTP_STREAMING_MULTIPART, Mongoose parses
+multipart requests and splits them into separate events:
+- MG_EV_HTTP_MULTIPART_REQUEST: Start of the request.
+  This event is sent before body is parsed. After this, the user
+  should expect a sequence of PART_BEGIN/DATA/END requests.
+  This is also the last time when headers and other request fields are
+  accessible.
+- MG_EV_HTTP_PART_BEGIN: Start of a part of a multipart message.
+  Argument: mg_http_multipart_part with var_name and file_name set
+  (if present). No data is passed in this message.
+- MG_EV_HTTP_PART_DATA: new portion of data from the multipart message.
+  Argument: mg_http_multipart_part. var_name and file_name are preserved,
+  data is available in mg_http_multipart_part.data.
+- MG_EV_HTTP_PART_END: End of the current part. var_name, file_name are
+  the same, no data in the message. If status is 0, then the part is
+  properly terminated with a boundary, status < 0 means that connection
+  was terminated.
+- MG_EV_HTTP_MULTIPART_REQUEST_END: End of the multipart request.
+  Argument: mg_http_multipart_part, var_name and file_name are NULL,
+  status = 0 means request was properly closed, < 0 means connection
+  was terminated (note: in this case both PART_END and REQUEST_END are
+  delivered). 
+

docs/c-api/mg_http.h/mg_url_decode.md

@@ -0,0 +1,19 @@
+---
+title: "mg_url_decode()"
+decl_name: "mg_url_decode"
+symbol_kind: "func"
+signature: |
+  int mg_url_decode(const char *src, int src_len, char *dst, int dst_len,
+                    int is_form_url_encoded);
+---
+
+Decodes a URL-encoded string.
+
+Source string is specified by (`src`, `src_len`), and destination is
+(`dst`, `dst_len`). If `is_form_url_encoded` is non-zero, then
+`+` character is decoded as a blank space character. This function
+guarantees to NUL-terminate the destination. If destination is too small,
+then the source string is partially decoded and `-1` is returned.
+*Otherwise,
+a length of the decoded string is returned, not counting final NUL. 
+

docs/c-api/mg_http.h/struct_http_message.md

@@ -0,0 +1,42 @@
+---
+title: "struct http_message"
+decl_name: "struct http_message"
+symbol_kind: "struct"
+signature: |
+  struct http_message {
+    struct mg_str message; /* Whole message: request line + headers + body */
+    struct mg_str body;    /* Message body. 0-length for requests with no body */
+  
+    /* HTTP Request line (or HTTP response line) */
+    struct mg_str method; /* "GET" */
+    struct mg_str uri;    /* "/my_file.html" */
+    struct mg_str proto;  /* "HTTP/1.1" -- for both request and response */
+  
+    /* For responses, code and response status message are set */
+    int resp_code;
+    struct mg_str resp_status_msg;
+  
+    /*
+     * Query-string part of the URI. For example, for HTTP request
+     *    GET /foo/bar?param1=val1&param2=val2
+     *    |    uri    |     query_string     |
+     *
+     * Note that question mark character doesn't belong neither to the uri,
+     * nor to the query_string
+     */
+    struct mg_str query_string;
+  
+    /* Headers */
+    struct mg_str header_names[MG_MAX_HTTP_HEADERS];
+    struct mg_str header_values[MG_MAX_HTTP_HEADERS];
+  
+    /*
+     * Value of the Content-Length header if present,
+     * otherwise MG_HTTP_CONTENT_LENGTH_UNKNOWN.
+     */
+    size_t content_length;
+  };
+---
+
+HTTP message 
+

docs/c-api/mg_http.h/struct_mg_http_multipart_part.md

@@ -0,0 +1,24 @@
+---
+title: "struct mg_http_multipart_part"
+decl_name: "struct mg_http_multipart_part"
+symbol_kind: "struct"
+signature: |
+  struct mg_http_multipart_part {
+    const char *file_name;
+    const char *var_name;
+    struct mg_str data;
+    int status; /* <0 on error */
+    void *user_data;
+    /*
+     * User handler can indicate how much of the data was consumed
+     * by setting this variable. By default, it is assumed that all
+     * data has been consumed by the handler.
+     * If not all data was consumed, user's handler will be invoked again later
+     * with the remainder.
+     */
+    size_t num_data_consumed;
+  };
+---
+
+HTTP multipart part 
+

docs/c-api/mg_http.h/struct_mg_ssi_call_ctx.md

@@ -0,0 +1,14 @@
+---
+title: "struct mg_ssi_call_ctx"
+decl_name: "struct mg_ssi_call_ctx"
+symbol_kind: "struct"
+signature: |
+  struct mg_ssi_call_ctx {
+    struct http_message *req; /* The request being processed. */
+    struct mg_str file;       /* Filesystem path of the file being processed. */
+    struct mg_str arg; /* The argument passed to the tag: <!-- call arg -->. */
+  };
+---
+
+SSI call context 
+

docs/c-api/mg_http.h/struct_websocket_message.md

@@ -0,0 +1,14 @@
+---
+title: "struct websocket_message"
+decl_name: "struct websocket_message"
+symbol_kind: "struct"
+signature: |
+  struct websocket_message {
+    unsigned char *data;
+    size_t size;
+    unsigned char flags;
+  };
+---
+
+WebSocket message 
+

docs/c-api/mg_http_client.h/intro.md

@@ -0,0 +1,12 @@
+---
+title: "Client API reference"
+symbol_kind: "intro"
+decl_name: "mg_http_client.h"
+items:
+  - { name: mg_connect_http.md }
+  - { name: mg_connect_http_opt.md }
+  - { name: mg_http_create_digest_auth_header.md }
+---
+
+
+

docs/c-api/mg_http_client.h/mg_connect_http.md

@@ -0,0 +1,33 @@
+---
+title: "mg_connect_http()"
+decl_name: "mg_connect_http"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_http(
+      struct mg_mgr *mgr,
+      MG_CB(mg_event_handler_t event_handler, void *user_data);
+---
+
+Helper function that creates an outbound HTTP connection.
+
+`url` is the URL to fetch. It must be properly URL-encoded, e.g. have
+no spaces, etc. By default, `mg_connect_http()` sends the Connection and
+Host headers. `extra_headers` is an extra HTTP header to send, e.g.
+`"User-Agent: my-app\r\n"`.
+If `post_data` is NULL, then a GET request is created. Otherwise, a POST
+request is created with the specified POST data. Note that if the data being
+posted is a form submission, the `Content-Type` header should be set
+accordingly (see example below).
+
+Examples:
+
+```c
+  nc1 = mg_connect_http(mgr, ev_handler_1, "http://www.google.com", NULL,
+                        NULL);
+  nc2 = mg_connect_http(mgr, ev_handler_1, "https://github.com", NULL, NULL);
+  nc3 = mg_connect_http(
+      mgr, ev_handler_1, "my_server:8000/form_submit/",
+      "Content-Type: application/x-www-form-urlencoded\r\n",
+      "var_1=value_1&var_2=value_2");
+``` 
+

docs/c-api/mg_http_client.h/mg_connect_http_opt.md

@@ -0,0 +1,15 @@
+---
+title: "mg_connect_http_opt()"
+decl_name: "mg_connect_http_opt"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_http_opt(
+      struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data);
+---
+
+Helper function that creates an outbound HTTP connection.
+
+Mostly identical to mg_connect_http, but allows you to provide extra
+*parameters
+(for example, SSL parameters) 
+

docs/c-api/mg_http_client.h/mg_http_create_digest_auth_header.md

@@ -0,0 +1,13 @@
+---
+title: "mg_http_create_digest_auth_header()"
+decl_name: "mg_http_create_digest_auth_header"
+symbol_kind: "func"
+signature: |
+  int mg_http_create_digest_auth_header(char *buf, size_t buf_len,
+                                        const char *method, const char *uri,
+                                        const char *auth_domain, const char *user,
+                                        const char *passwd, const char *nonce);
+---
+
+Creates digest authentication header for a client request. 
+

docs/c-api/mg_http_server.h/intro.md

@@ -0,0 +1,33 @@
+---
+title: "Server API reference"
+symbol_kind: "intro"
+decl_name: "mg_http_server.h"
+items:
+  - { name: mg_check_digest_auth.md }
+  - { name: mg_file_upload_handler.md }
+  - { name: mg_get_http_basic_auth.md }
+  - { name: mg_get_http_header.md }
+  - { name: mg_get_http_var.md }
+  - { name: mg_http_check_digest_auth.md }
+  - { name: mg_http_parse_header.md }
+  - { name: mg_http_parse_header2.md }
+  - { name: mg_http_reverse_proxy.md }
+  - { name: mg_http_send_error.md }
+  - { name: mg_http_send_redirect.md }
+  - { name: mg_http_serve_file.md }
+  - { name: mg_parse_http.md }
+  - { name: mg_parse_http_basic_auth.md }
+  - { name: mg_parse_multipart.md }
+  - { name: mg_printf_html_escape.md }
+  - { name: mg_printf_http_chunk.md }
+  - { name: mg_register_http_endpoint.md }
+  - { name: mg_send_head.md }
+  - { name: mg_send_http_chunk.md }
+  - { name: mg_send_response_line.md }
+  - { name: mg_serve_http.md }
+  - { name: mg_fu_fname_fn.md }
+  - { name: struct_mg_serve_http_opts.md }
+---
+
+
+

docs/c-api/mg_http_server.h/mg_check_digest_auth.md

@@ -0,0 +1,17 @@
+---
+title: "mg_check_digest_auth()"
+decl_name: "mg_check_digest_auth"
+symbol_kind: "func"
+signature: |
+  int mg_check_digest_auth(struct mg_str method, struct mg_str uri,
+                           struct mg_str username, struct mg_str cnonce,
+                           struct mg_str response, struct mg_str qop,
+                           struct mg_str nc, struct mg_str nonce,
+                           struct mg_str auth_domain, FILE *fp);
+---
+
+Authenticates given response params against an opened password file.
+Returns 1 if authenticated, 0 otherwise.
+
+It's used by mg_http_check_digest_auth(). 
+

docs/c-api/mg_http_server.h/mg_file_upload_handler.md

@@ -0,0 +1,41 @@
+---
+title: "mg_file_upload_handler()"
+decl_name: "mg_file_upload_handler"
+symbol_kind: "func"
+signature: |
+  void mg_file_upload_handler(struct mg_connection *nc, int ev, void *ev_data,
+                              mg_fu_fname_fn local_name_fn
+                                  MG_UD_ARG(void *user_data);
+---
+
+File upload handler.
+This handler can be used to implement file uploads with minimum code.
+This handler will process MG_EV_HTTP_PART_* events and store file data into
+a local file.
+`local_name_fn` will be invoked with whatever name was provided by the client
+and will expect the name of the local file to open. A return value of NULL
+will abort file upload (client will get a "403 Forbidden" response). If
+non-null, the returned string must be heap-allocated and will be freed by
+the caller.
+Exception: it is ok to return the same string verbatim.
+
+Example:
+
+```c
+struct mg_str upload_fname(struct mg_connection *nc, struct mg_str fname) {
+  // Just return the same filename. Do not actually do this except in test!
+  // fname is user-controlled and needs to be sanitized.
+  return fname;
+}
+void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
+  switch (ev) {
+    ...
+    case MG_EV_HTTP_PART_BEGIN:
+    case MG_EV_HTTP_PART_DATA:
+    case MG_EV_HTTP_PART_END:
+      mg_file_upload_handler(nc, ev, ev_data, upload_fname);
+      break;
+  }
+}
+``` 
+

docs/c-api/mg_http_server.h/mg_fu_fname_fn.md

@@ -0,0 +1,11 @@
+---
+title: "mg_fu_fname_fn"
+decl_name: "mg_fu_fname_fn"
+symbol_kind: "typedef"
+signature: |
+  typedef struct mg_str (*mg_fu_fname_fn)(struct mg_connection *nc,
+                                          struct mg_str fname);
+---
+
+Callback prototype for `mg_file_upload_handler()`. 
+

docs/c-api/mg_http_server.h/mg_get_http_basic_auth.md

@@ -0,0 +1,14 @@
+---
+title: "mg_get_http_basic_auth()"
+decl_name: "mg_get_http_basic_auth"
+symbol_kind: "func"
+signature: |
+  int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len,
+                             char *pass, size_t pass_len);
+---
+
+Gets and parses the Authorization: Basic header
+Returns -1 if no Authorization header is found, or if
+mg_parse_http_basic_auth
+fails parsing the resulting header. 
+

docs/c-api/mg_http_server.h/mg_get_http_header.md

@@ -0,0 +1,13 @@
+---
+title: "mg_get_http_header()"
+decl_name: "mg_get_http_header"
+symbol_kind: "func"
+signature: |
+  struct mg_str *mg_get_http_header(struct http_message *hm, const char *name);
+---
+
+Searches and returns the header `name` in parsed HTTP message `hm`.
+If header is not found, NULL is returned. Example:
+
+    struct mg_str *host_hdr = mg_get_http_header(hm, "Host"); 
+

docs/c-api/mg_http_server.h/mg_get_http_var.md

@@ -0,0 +1,17 @@
+---
+title: "mg_get_http_var()"
+decl_name: "mg_get_http_var"
+symbol_kind: "func"
+signature: |
+  int mg_get_http_var(const struct mg_str *buf, const char *name, char *dst,
+                      size_t dst_len);
+---
+
+Fetches a HTTP form variable.
+
+Fetches a variable `name` from a `buf` into a buffer specified by `dst`,
+`dst_len`. The destination is always zero-terminated. Returns the length of
+a fetched variable. If not found, 0 is returned. `buf` must be valid
+url-encoded buffer. If destination is too small or an error occured,
+negative number is returned. 
+

docs/c-api/mg_http_server.h/mg_http_check_digest_auth.md

@@ -0,0 +1,12 @@
+---
+title: "mg_http_check_digest_auth()"
+decl_name: "mg_http_check_digest_auth"
+symbol_kind: "func"
+signature: |
+  int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain,
+                                FILE *fp);
+---
+
+Authenticates a HTTP request against an opened password file.
+Returns 1 if authenticated, 0 otherwise. 
+

docs/c-api/mg_http_server.h/mg_http_parse_header.md

@@ -0,0 +1,15 @@
+---
+title: "mg_http_parse_header()"
+decl_name: "mg_http_parse_header"
+symbol_kind: "func"
+signature: |
+  int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf,
+                           size_t buf_size);
+---
+
+DEPRECATED: use mg_http_parse_header2() instead.
+
+Same as mg_http_parse_header2(), but takes buffer as a `char *` (instead of
+`char **`), and thus it cannot allocate a new buffer if the provided one
+is not enough, and just returns 0 in that case. 
+

docs/c-api/mg_http_server.h/mg_http_parse_header2.md

@@ -0,0 +1,30 @@
+---
+title: "mg_http_parse_header2()"
+decl_name: "mg_http_parse_header2"
+symbol_kind: "func"
+signature: |
+  int mg_http_parse_header2(struct mg_str *hdr, const char *var_name, char **buf,
+                            size_t buf_size);
+---
+
+Parses the HTTP header `hdr`. Finds variable `var_name` and stores its value
+in the buffer `*buf`, `buf_size`. If the buffer size is not enough,
+allocates a buffer of required size and writes it to `*buf`, similar to
+asprintf(). The caller should always check whether the buffer was updated,
+and free it if so.
+
+This function is supposed to parse cookies, authentication headers, etc.
+Example (error handling omitted):
+
+    char user_buf[20];
+    char *user = user_buf;
+    struct mg_str *hdr = mg_get_http_header(hm, "Authorization");
+    mg_http_parse_header2(hdr, "username", &user, sizeof(user_buf));
+    // ... do something useful with user
+    if (user != user_buf) {
+      free(user);
+    }
+
+Returns the length of the variable's value. If variable is not found, 0 is
+returned. 
+

docs/c-api/mg_http_server.h/mg_http_reverse_proxy.md

@@ -0,0 +1,19 @@
+---
+title: "mg_http_reverse_proxy()"
+decl_name: "mg_http_reverse_proxy"
+symbol_kind: "func"
+signature: |
+  void mg_http_reverse_proxy(struct mg_connection *nc,
+                             const struct http_message *hm, struct mg_str mount,
+                             struct mg_str upstream);
+---
+
+Proxies a given request to a given upstream http server. The path prefix
+in `mount` will be stripped of the path requested to the upstream server,
+e.g. if mount is /api and upstream is http://localhost:8001/foo
+then an incoming request to /api/bar will cause a request to
+http://localhost:8001/foo/bar
+
+EXPERIMENTAL API. Please use http_serve_http + url_rewrites if a static
+mapping is good enough. 
+

docs/c-api/mg_http_server.h/mg_http_send_error.md

@@ -0,0 +1,11 @@
+---
+title: "mg_http_send_error()"
+decl_name: "mg_http_send_error"
+symbol_kind: "func"
+signature: |
+  void mg_http_send_error(struct mg_connection *nc, int code, const char *reason);
+---
+
+Sends an error response. If reason is NULL, the message will be inferred
+from the error code (if supported). 
+

docs/c-api/mg_http_server.h/mg_http_send_redirect.md

@@ -0,0 +1,20 @@
+---
+title: "mg_http_send_redirect()"
+decl_name: "mg_http_send_redirect"
+symbol_kind: "func"
+signature: |
+  void mg_http_send_redirect(struct mg_connection *nc, int status_code,
+                             const struct mg_str location,
+                             const struct mg_str extra_headers);
+---
+
+Sends a redirect response.
+`status_code` should be either 301 or 302 and `location` point to the
+new location.
+If `extra_headers` is not empty, then `extra_headers` are also sent
+after the response line. `extra_headers` must NOT end end with new line.
+
+Example:
+
+     mg_http_send_redirect(nc, 302, mg_mk_str("/login"), mg_mk_str(NULL)); 
+

docs/c-api/mg_http_server.h/mg_http_serve_file.md

@@ -0,0 +1,28 @@
+---
+title: "mg_http_serve_file()"
+decl_name: "mg_http_serve_file"
+symbol_kind: "func"
+signature: |
+  void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm,
+                          const char *path, const struct mg_str mime_type,
+                          const struct mg_str extra_headers);
+---
+
+Serves a specific file with a given MIME type and optional extra headers.
+
+Example code snippet:
+
+```c
+static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
+  switch (ev) {
+    case MG_EV_HTTP_REQUEST: {
+      struct http_message *hm = (struct http_message *) ev_data;
+      mg_http_serve_file(nc, hm, "file.txt",
+                         mg_mk_str("text/plain"), mg_mk_str(""));
+      break;
+    }
+    ...
+  }
+}
+``` 
+

docs/c-api/mg_http_server.h/mg_parse_http.md

@@ -0,0 +1,15 @@
+---
+title: "mg_parse_http()"
+decl_name: "mg_parse_http"
+symbol_kind: "func"
+signature: |
+  int mg_parse_http(const char *s, int n, struct http_message *hm, int is_req);
+---
+
+Parses a HTTP message.
+
+`is_req` should be set to 1 if parsing a request, 0 if reply.
+
+Returns the number of bytes parsed. If HTTP message is
+incomplete `0` is returned. On parse error, a negative number is returned. 
+

docs/c-api/mg_http_server.h/mg_parse_http_basic_auth.md

@@ -0,0 +1,13 @@
+---
+title: "mg_parse_http_basic_auth()"
+decl_name: "mg_parse_http_basic_auth"
+symbol_kind: "func"
+signature: |
+  int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len,
+                               char *pass, size_t pass_len);
+---
+
+Parses the Authorization: Basic header
+Returns -1 iif the authorization type is not "Basic" or any other error such
+as incorrectly encoded base64 user password pair. 
+

docs/c-api/mg_http_server.h/mg_parse_multipart.md

@@ -0,0 +1,46 @@
+---
+title: "mg_parse_multipart()"
+decl_name: "mg_parse_multipart"
+symbol_kind: "func"
+signature: |
+  size_t mg_parse_multipart(const char *buf, size_t buf_len, char *var_name,
+                            size_t var_name_len, char *file_name,
+                            size_t file_name_len, const char **chunk,
+                            size_t *chunk_len);
+---
+
+Parses the buffer `buf`, `buf_len` that contains multipart form data chunks.
+Stores the chunk name in a `var_name`, `var_name_len` buffer.
+If a chunk is an uploaded file, then `file_name`, `file_name_len` is
+filled with an uploaded file name. `chunk`, `chunk_len`
+points to the chunk data.
+
+Return: number of bytes to skip to the next chunk or 0 if there are
+        no more chunks.
+
+Usage example:
+
+```c
+   static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
+     switch(ev) {
+       case MG_EV_HTTP_REQUEST: {
+         struct http_message *hm = (struct http_message *) ev_data;
+         char var_name[100], file_name[100];
+         const char *chunk;
+         size_t chunk_len, n1, n2;
+
+         n1 = n2 = 0;
+         while ((n2 = mg_parse_multipart(hm->body.p + n1,
+                                         hm->body.len - n1,
+                                         var_name, sizeof(var_name),
+                                         file_name, sizeof(file_name),
+                                         &chunk, &chunk_len)) > 0) {
+           printf("var: %s, file_name: %s, size: %d, chunk: [%.*s]\n",
+                  var_name, file_name, (int) chunk_len,
+                  (int) chunk_len, chunk);
+           n1 += n2;
+         }
+       }
+       break;
+``` 
+

docs/c-api/mg_http_server.h/mg_printf_html_escape.md

@@ -0,0 +1,10 @@
+---
+title: "mg_printf_html_escape()"
+decl_name: "mg_printf_html_escape"
+symbol_kind: "func"
+signature: |
+  void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...);
+---
+
+Sends a printf-formatted HTTP chunk, escaping HTML tags. 
+

docs/c-api/mg_http_server.h/mg_printf_http_chunk.md

@@ -0,0 +1,11 @@
+---
+title: "mg_printf_http_chunk()"
+decl_name: "mg_printf_http_chunk"
+symbol_kind: "func"
+signature: |
+  void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...);
+---
+
+Sends a printf-formatted HTTP chunk.
+Functionality is similar to `mg_send_http_chunk()`. 
+

docs/c-api/mg_http_server.h/mg_register_http_endpoint.md

@@ -0,0 +1,36 @@
+---
+title: "mg_register_http_endpoint()"
+decl_name: "mg_register_http_endpoint"
+symbol_kind: "func"
+signature: |
+  void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path,
+                                 MG_CB(mg_event_handler_t handler,
+                                       void *user_data);
+---
+
+Registers a callback for a specified http endpoint
+Note: if callback is registered it is called instead of the
+callback provided in mg_bind
+
+Example code snippet:
+
+```c
+static void handle_hello1(struct mg_connection *nc, int ev, void *ev_data) {
+  (void) ev; (void) ev_data;
+  mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello1]");
+ nc->flags |= MG_F_SEND_AND_CLOSE;
+}
+
+static void handle_hello2(struct mg_connection *nc, int ev, void *ev_data) {
+ (void) ev; (void) ev_data;
+  mg_printf(nc, "HTTP/1.0 200 OK\r\n\r\n[I am Hello2]");
+ nc->flags |= MG_F_SEND_AND_CLOSE;
+}
+
+void init() {
+  nc = mg_bind(&mgr, local_addr, cb1);
+  mg_register_http_endpoint(nc, "/hello1", handle_hello1);
+  mg_register_http_endpoint(nc, "/hello1/hello2", handle_hello2);
+}
+``` 
+

docs/c-api/mg_http_server.h/mg_send_head.md

@@ -0,0 +1,22 @@
+---
+title: "mg_send_head()"
+decl_name: "mg_send_head"
+symbol_kind: "func"
+signature: |
+  void mg_send_head(struct mg_connection *n, int status_code,
+                    int64_t content_length, const char *extra_headers);
+---
+
+Sends the response line and headers.
+This function sends the response line with the `status_code`, and
+automatically
+sends one header: either "Content-Length" or "Transfer-Encoding".
+If `content_length` is negative, then "Transfer-Encoding: chunked" header
+is sent, otherwise, "Content-Length" header is sent.
+
+NOTE: If `Transfer-Encoding` is `chunked`, then message body must be sent
+using `mg_send_http_chunk()` or `mg_printf_http_chunk()` functions.
+Otherwise, `mg_send()` or `mg_printf()` must be used.
+Extra headers could be set through `extra_headers`. Note `extra_headers`
+must NOT be terminated by a new line. 
+

docs/c-api/mg_http_server.h/mg_send_http_chunk.md

@@ -0,0 +1,25 @@
+---
+title: "mg_send_http_chunk()"
+decl_name: "mg_send_http_chunk"
+symbol_kind: "func"
+signature: |
+  void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len);
+---
+
+Sends buffer `buf` of size `len` to the client using chunked HTTP encoding.
+This function sends the buffer size as hex number + newline first, then
+the buffer itself, then the newline. For example,
+`mg_send_http_chunk(nc, "foo", 3)` will append the `3\r\nfoo\r\n` string
+to the `nc->send_mbuf` output IO buffer.
+
+NOTE: The HTTP header "Transfer-Encoding: chunked" should be sent prior to
+using this function.
+
+NOTE: do not forget to send an empty chunk at the end of the response,
+to tell the client that everything was sent. Example:
+
+```
+  mg_printf_http_chunk(nc, "%s", "my response!");
+  mg_send_http_chunk(nc, "", 0); // Tell the client we're finished
+``` 
+

docs/c-api/mg_http_server.h/mg_send_response_line.md

@@ -0,0 +1,21 @@
+---
+title: "mg_send_response_line()"
+decl_name: "mg_send_response_line"
+symbol_kind: "func"
+signature: |
+  void mg_send_response_line(struct mg_connection *nc, int status_code,
+                             const char *extra_headers);
+---
+
+Sends the response status line.
+If `extra_headers` is not NULL, then `extra_headers` are also sent
+after the response line. `extra_headers` must NOT end end with new line.
+Example:
+
+     mg_send_response_line(nc, 200, "Access-Control-Allow-Origin: *");
+
+Will result in:
+
+     HTTP/1.1 200 OK\r\n
+     Access-Control-Allow-Origin: *\r\n 
+

docs/c-api/mg_http_server.h/mg_serve_http.md

@@ -0,0 +1,28 @@
+---
+title: "mg_serve_http()"
+decl_name: "mg_serve_http"
+symbol_kind: "func"
+signature: |
+  void mg_serve_http(struct mg_connection *nc, struct http_message *hm,
+                     struct mg_serve_http_opts opts);
+---
+
+Serves given HTTP request according to the `options`.
+
+Example code snippet:
+
+```c
+static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
+  struct http_message *hm = (struct http_message *) ev_data;
+  struct mg_serve_http_opts opts = { .document_root = "/var/www" };  // C99
+
+  switch (ev) {
+    case MG_EV_HTTP_REQUEST:
+      mg_serve_http(nc, hm, opts);
+      break;
+    default:
+      break;
+  }
+}
+``` 
+

docs/c-api/mg_http_server.h/struct_mg_serve_http_opts.md

@@ -0,0 +1,165 @@
+---
+title: "struct mg_serve_http_opts"
+decl_name: "struct mg_serve_http_opts"
+symbol_kind: "struct"
+signature: |
+  struct mg_serve_http_opts {
+    /* Path to web root directory */
+    const char *document_root;
+  
+    /* List of index files. Default is "" */
+    const char *index_files;
+  
+    /*
+     * Leave as NULL to disable authentication.
+     * To enable directory protection with authentication, set this to ".htpasswd"
+     * Then, creating ".htpasswd" file in any directory automatically protects
+     * it with digest authentication.
+     * Use `mongoose` web server binary, or `htdigest` Apache utility to
+     * create/manipulate passwords file.
+     * Make sure `auth_domain` is set to a valid domain name.
+     */
+    const char *per_directory_auth_file;
+  
+    /* Authorization domain (domain name of this web server) */
+    const char *auth_domain;
+  
+    /*
+     * Leave as NULL to disable authentication.
+     * Normally, only selected directories in the document root are protected.
+     * If absolutely every access to the web server needs to be authenticated,
+     * regardless of the URI, set this option to the path to the passwords file.
+     * Format of that file is the same as ".htpasswd" file. Make sure that file
+     * is located outside document root to prevent people fetching it.
+     */
+    const char *global_auth_file;
+  
+    /* Set to "no" to disable directory listing. Enabled by default. */
+    const char *enable_directory_listing;
+  
+    /*
+     * SSI files pattern. If not set, "**.shtml$|**.shtm$" is used.
+     *
+     * All files that match ssi_pattern are treated as SSI.
+     *
+     * Server Side Includes (SSI) is a simple interpreted server-side scripting
+     * language which is most commonly used to include the contents of a file
+     * into a web page. It can be useful when it is desirable to include a common
+     * piece of code throughout a website, for example, headers and footers.
+     *
+     * In order for a webpage to recognize an SSI-enabled HTML file, the
+     * filename should end with a special extension, by default the extension
+     * should be either .shtml or .shtm
+     *
+     * Unknown SSI directives are silently ignored by Mongoose. Currently,
+     * the following SSI directives are supported:
+     *    <!--#include FILE_TO_INCLUDE -->
+     *    <!--#exec "COMMAND_TO_EXECUTE" -->
+     *    <!--#call COMMAND -->
+     *
+     * Note that <!--#include ...> directive supports three path
+     *specifications:
+     *
+     * <!--#include virtual="path" -->  Path is relative to web server root
+     * <!--#include abspath="path" -->  Path is absolute or relative to the
+     *                                  web server working dir
+     * <!--#include file="path" -->,    Path is relative to current document
+     * <!--#include "path" -->
+     *
+     * The include directive may be used to include the contents of a file or
+     * the result of running a CGI script.
+     *
+     * The exec directive is used to execute
+     * a command on a server, and show command's output. Example:
+     *
+     * <!--#exec "ls -l" -->
+     *
+     * The call directive is a way to invoke a C handler from the HTML page.
+     * On each occurence of <!--#call COMMAND OPTIONAL_PARAMS> directive,
+     * Mongoose calls a registered event handler with MG_EV_SSI_CALL event,
+     * and event parameter will point to the COMMAND OPTIONAL_PARAMS string.
+     * An event handler can output any text, for example by calling
+     * `mg_printf()`. This is a flexible way of generating a web page on
+     * server side by calling a C event handler. Example:
+     *
+     * <!--#call foo --> ... <!--#call bar -->
+     *
+     * In the event handler:
+     *    case MG_EV_SSI_CALL: {
+     *      const char *param = (const char *) ev_data;
+     *      if (strcmp(param, "foo") == 0) {
+     *        mg_printf(c, "hello from foo");
+     *      } else if (strcmp(param, "bar") == 0) {
+     *        mg_printf(c, "hello from bar");
+     *      }
+     *      break;
+     *    }
+     */
+    const char *ssi_pattern;
+  
+    /* IP ACL. By default, NULL, meaning all IPs are allowed to connect */
+    const char *ip_acl;
+  
+  #if MG_ENABLE_HTTP_URL_REWRITES
+    /* URL rewrites.
+     *
+     * Comma-separated list of `uri_pattern=url_file_or_directory_path` rewrites.
+     * When HTTP request is received, Mongoose constructs a file name from the
+     * requested URI by combining `document_root` and the URI. However, if the
+     * rewrite option is used and `uri_pattern` matches requested URI, then
+     * `document_root` is ignored. Instead, `url_file_or_directory_path` is used,
+     * which should be a full path name or a path relative to the web server's
+     * current working directory. It can also be an URI (http:// or https://)
+     * in which case mongoose will behave as a reverse proxy for that destination.
+     *
+     * Note that `uri_pattern`, as all Mongoose patterns, is a prefix pattern.
+     *
+     * If uri_pattern starts with `@` symbol, then Mongoose compares it with the
+     * HOST header of the request. If they are equal, Mongoose sets document root
+     * to `file_or_directory_path`, implementing virtual hosts support.
+     * Example: `@foo.com=/document/root/for/foo.com`
+     *
+     * If `uri_pattern` starts with `%` symbol, then Mongoose compares it with
+     * the listening port. If they match, then Mongoose issues a 301 redirect.
+     * For example, to redirect all HTTP requests to the
+     * HTTPS port, do `%80=https://my.site.com`. Note that the request URI is
+     * automatically appended to the redirect location.
+     */
+    const char *url_rewrites;
+  #endif
+  
+    /* DAV document root. If NULL, DAV requests are going to fail. */
+    const char *dav_document_root;
+  
+    /*
+     * DAV passwords file. If NULL, DAV requests are going to fail.
+     * If passwords file is set to "-", then DAV auth is disabled.
+     */
+    const char *dav_auth_file;
+  
+    /* Glob pattern for the files to hide. */
+    const char *hidden_file_pattern;
+  
+    /* Set to non-NULL to enable CGI, e.g. **.cgi$|**.php$" */
+    const char *cgi_file_pattern;
+  
+    /* If not NULL, ignore CGI script hashbang and use this interpreter */
+    const char *cgi_interpreter;
+  
+    /*
+     * Comma-separated list of Content-Type overrides for path suffixes, e.g.
+     * ".txt=text/plain; charset=utf-8,.c=text/plain"
+     */
+    const char *custom_mime_types;
+  
+    /*
+     * Extra HTTP headers to add to each server response.
+     * Example: to enable CORS, set this to "Access-Control-Allow-Origin: *".
+     */
+    const char *extra_headers;
+  };
+---
+
+This structure defines how `mg_serve_http()` works.
+Best practice is to set only required settings, and leave the rest as NULL. 
+

docs/c-api/mg_mqtt.h/intro.md

@@ -0,0 +1,29 @@
+---
+title: "MQTT API reference"
+symbol_kind: "intro"
+decl_name: "mg_mqtt.h"
+items:
+  - { name: mg_mqtt_connack.md }
+  - { name: mg_mqtt_disconnect.md }
+  - { name: mg_mqtt_match_topic_expression.md }
+  - { name: mg_mqtt_next_subscribe_topic.md }
+  - { name: mg_mqtt_ping.md }
+  - { name: mg_mqtt_pong.md }
+  - { name: mg_mqtt_puback.md }
+  - { name: mg_mqtt_pubcomp.md }
+  - { name: mg_mqtt_publish.md }
+  - { name: mg_mqtt_pubrec.md }
+  - { name: mg_mqtt_pubrel.md }
+  - { name: mg_mqtt_suback.md }
+  - { name: mg_mqtt_subscribe.md }
+  - { name: mg_mqtt_unsuback.md }
+  - { name: mg_mqtt_unsubscribe.md }
+  - { name: mg_mqtt_vmatch_topic_expression.md }
+  - { name: mg_send_mqtt_handshake.md }
+  - { name: mg_send_mqtt_handshake_opt.md }
+  - { name: mg_set_protocol_mqtt.md }
+  - { name: struct_mg_mqtt_proto_data.md }
+---
+
+
+

docs/c-api/mg_mqtt.h/mg_mqtt_connack.md

@@ -0,0 +1,10 @@
+---
+title: "mg_mqtt_connack()"
+decl_name: "mg_mqtt_connack"
+symbol_kind: "func"
+signature: |
+  void mg_mqtt_connack(struct mg_connection *nc, uint8_t return_code);
+---
+
+Sends a CONNACK command with a given `return_code`. 
+

docs/c-api/mg_mqtt.h/mg_mqtt_disconnect.md

@@ -0,0 +1,10 @@
+---
+title: "mg_mqtt_disconnect()"
+decl_name: "mg_mqtt_disconnect"
+symbol_kind: "func"
+signature: |
+  void mg_mqtt_disconnect(struct mg_connection *nc);
+---
+
+Sends a DISCONNECT command. 
+