diff --git a/.appveyor.yml b/.appveyor.yml
index e496d6344..1254c9c16 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -3,9 +3,9 @@ configuration:
   - Debug
 
 image:
+  - Visual Studio 2022
   - Visual Studio 2019
   - Visual Studio 2015
-  - Visual Studio 2013
 
 platform:
   - x64
@@ -14,15 +14,11 @@ platform:
 build_script:
   - ps: $VSIMG = $Env:APPVEYOR_BUILD_WORKER_IMAGE; $CNFG = $Env:CONFIGURATION
   # use a few differing arguments depending on VS version to exercise different options during builds
-  - ps: if ($VSIMG -match '2019' -and $CNFG -eq "Release") { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS ON -UNIT_TESTS ON }
-  - ps: if ($VSIMG -match '2019' -and $CNFG -eq "Debug")   { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS ON }
-  - ps: if ($VSIMG -match '2015' -and $CNFG -eq "Release") { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS ON -UNIT_TESTS ON }
-  - ps: if ($VSIMG -match '2015' -and $CNFG -eq "Debug")   { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS OFF }
-  - ps: if ($VSIMG -match '2013' -and $CNFG -eq "Release") { .\scripts\build-windows.ps1 -CXX11 OFF -BUILD_APPS ON }
-  - ps: if ($VSIMG -match '2013' -and $CNFG -eq "Debug")   { Exit-AppveyorBuild } # just skip 2013 debug build for speed
+  - ps: if ($CNFG -eq "Release") { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS ON -UNIT_TESTS ON -BONDING ON}
+  - ps: if ($CNFG -eq "Debug") { if ($VSIMG -match '2015') { .\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS OFF } else {.\scripts\build-windows.ps1 -STATIC_LINK_SSL ON -BUILD_APPS ON }}
 
 test_script:
-  - ps: if ( $Env:RUN_UNIT_TESTS ) { cd ./_build; ctest --extra-verbose -C $Env:CONFIGURATION; cd ../ }
+  - ps: if ( $Env:RUN_UNIT_TESTS ) { cd ./_build; ctest -E "TestIPv6.v6_calls_v4" --extra-verbose -C $Env:CONFIGURATION; cd ../ }
   
 after_build:
 - cmd: >-
diff --git a/.github/workflows/abi.yml b/.github/workflows/abi.yml
new file mode 100644
index 000000000..2c05cc06b
--- /dev/null
+++ b/.github/workflows/abi.yml
@@ -0,0 +1,61 @@
+name: ABI checks
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  SRT_BASE: v1.5.0
+
+jobs:
+  build:
+    name: ABI checks
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        path: pull_request
+    - name: configure
+      run: |
+        cd pull_request
+        mkdir _build && cd _build
+        cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_UNITTESTS=ON ../
+    - name: build
+      run: |
+        sudo apt install -y abi-dumper
+        cd pull_request/_build && cmake --build ./
+        make install DESTDIR=./installdir
+        SRT_TAG_VERSION=$(cat version.h |grep SRT_VERSION_MINOR |head -n1 |awk {'print $3'})
+        abi-dumper libsrt.so -o libsrt-pr.dump -public-headers installdir/usr/local/include/srt/ -lver 0
+        SRT_BASE="v1.$SRT_TAG_VERSION.0"
+        echo "SRT_BASE=$SRT_BASE" >> "$GITHUB_ENV"
+    - uses: actions/checkout@v3
+      with:
+        path: tag
+        ref: ${{ env.SRT_BASE }}
+    - name: configure_tag
+      run: |
+        echo $SRT_TAG_VERSION
+        cd tag
+        mkdir _build && cd _build
+        cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_UNITTESTS=ON ../
+    - name: build_tag
+      run: |
+        cd tag      
+        cd _build && cmake --build ./
+        make install DESTDIR=./installdir
+        abi-dumper libsrt.so -o libsrt-tag.dump -public-headers installdir/usr/local/include/srt/ -lver 1
+    - name: abi-check
+      run: |
+         git clone https://github.com/lvc/abi-compliance-checker.git
+         cd abi-compliance-checker && sudo make install && cd ../
+         abi-compliance-checker -l libsrt -old tag/_build/libsrt-tag.dump -new pull_request/_build/libsrt-pr.dump
+         RES=$?
+         if (( $RES != 0 ))
+          then
+            echo "ABI/API Compatibility check failed with value $?"
+            exit $RES
+          fi
diff --git a/.github/workflows/android.yaml b/.github/workflows/android.yaml
new file mode 100644
index 000000000..0af85fda3
--- /dev/null
+++ b/.github/workflows/android.yaml
@@ -0,0 +1,26 @@
+name: Android
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    name: NDK-R23
+    runs-on: ubuntu-20.04
+
+    steps:
+    - name: Setup Android NDK R23
+      uses: nttld/setup-ndk@v1
+      id: setup-ndk
+      with:
+        ndk-version: r23
+        add-to-path: false
+    - uses: actions/checkout@v3
+    - name: build
+      run: |
+        cd ./scripts/build-android/
+        echo ${{ steps.setup-ndk.outputs.ndk-path }}
+        source ./build-android -n ${{ steps.setup-ndk.outputs.ndk-path }}
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 000000000..4a337b6ca
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,43 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master", "experimental/socket-groups" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ cpp ]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Configure
+        run: cmake -DENABLE_HEAVY_LOGGING=1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS=-fpermissive -DENABLE_BONDING=1 .        
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          queries: +security-and-quality
+
+      - name: Build
+        run: |
+          make
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{ matrix.language }}"
diff --git a/.github/workflows/cxx11-macos.yaml b/.github/workflows/cxx11-macos.yaml
index 57cc5af79..e3e6b1f8a 100644
--- a/.github/workflows/cxx11-macos.yaml
+++ b/.github/workflows/cxx11-macos.yaml
@@ -1,4 +1,4 @@
-name: cxx11_win
+name: cxx11
 
 on:
   push:
@@ -8,15 +8,17 @@ on:
 
 jobs:
   build:
-    name: macos-cxx11
+    name: macos
     runs-on: macos-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - name: GoogleTest
+      run: brew install googletest
+    - uses: actions/checkout@v3
     - name: configure
       run: |
         mkdir _build && cd _build
-        cmake ../ -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=OFF -DENABLE_UNITTESTS=ON -DENABLE_EXPERIMENTAL_BONDING=ON
+        cmake ../ -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=OFF -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DUSE_CXX_STD=14
     - name: build
       run: cd _build && cmake --build ./
     - name: test
diff --git a/.github/workflows/cxx11-ubuntu.yaml b/.github/workflows/cxx11-ubuntu.yaml
index 44dd06ce0..918bbcd22 100644
--- a/.github/workflows/cxx11-ubuntu.yaml
+++ b/.github/workflows/cxx11-ubuntu.yaml
@@ -1,23 +1,38 @@
-name: cxx11_win
+name: cxx11
 
 on:
   push:
     branches: [ master ]
   pull_request:
     branches: [ master ]
-
+    types: [opened, synchronize, reopened]
 jobs:
   build:
-    name: ubuntu-cxx11
-    runs-on: ubuntu-18.04
-
+    name: ubuntu
+    runs-on: ubuntu-20.04
+    env:
+      BUILD_WRAPPER_OUT_DIR: sonar-output # Directory where build-wrapper output will be placed
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+    - name: Install sonar-scanner and build-wrapper
+      uses: sonarsource/sonarcloud-github-c-cpp@v2
     - name: configure
       run: |
         mkdir _build && cd _build
-        cmake ../ -DENABLE_STDCXX_SYNC=ON -DENABLE_UNITTESTS=ON -DENABLE_EXPERIMENTAL_BONDING=ON
+        cmake ../ -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=ON -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DENABLE_TESTING=ON -DENABLE_EXAMPLES=ON -DENABLE_CODE_COVERAGE=ON
     - name: build
-      run: cd _build && cmake --build ./
+      run: cd _build && build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build .
     - name: test
-      run: cd _build && ctest --extra-verbose
+      run: |
+        cd _build && ctest --extra-verbose
+    - name: codecov
+      run: |
+        source ./scripts/collect-gcov.sh
+        bash <(curl -s https://codecov.io/bash)
+    - name: Run SonarCloud Scan for C and C++
+      if: ${{ !github.event.pull_request.head.repo.fork }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      # Consult https://docs.sonarcloud.io/advanced-setup/ci-based-analysis/sonarscanner-cli/ for more information and options.
+      run: sonar-scanner --define sonar.cfamily.build-wrapper-output=_build/"${{ env.BUILD_WRAPPER_OUT_DIR }}"
diff --git a/.github/workflows/cxx11-win.yaml b/.github/workflows/cxx11-win.yaml
index cf9dcd871..f1554053d 100644
--- a/.github/workflows/cxx11-win.yaml
+++ b/.github/workflows/cxx11-win.yaml
@@ -1,4 +1,4 @@
-name: cxx11_win
+name: cxx11
 
 on:
   push:
@@ -9,16 +9,16 @@ on:
 jobs:
   build:
 
-    name: windows-cxx11
+    name: windows
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: configure
       run: |
         md _build && cd _build
-        cmake ../ -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=OFF -DENABLE_UNITTESTS=ON -DENABLE_EXPERIMENTAL_BONDING=ON
+        cmake ../ -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=OFF -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DUSE_CXX_STD=c++11
     - name: build
-      run: cd _build && cmake --build ./ --config Release
+      run: cd _build && cmake --build ./ --config Release --verbose
     - name: test
-      run: cd _build && ctest --extra-verbose -C Release
+      run: cd _build && ctest -E "TestIPv6.v6_calls_v4|TestConnectionTimeout.BlockingLoop" --extra-verbose -C Release
diff --git a/.github/workflows/iOS.yaml b/.github/workflows/iOS.yaml
new file mode 100644
index 000000000..0fb11542b
--- /dev/null
+++ b/.github/workflows/iOS.yaml
@@ -0,0 +1,25 @@
+name: iOS
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        cxxstdsync: [OFF, ON]
+
+    name: iOS-cxxsync${{ matrix.cxxstdsync }}
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: configure
+      run: |
+        mkdir _build && cd _build
+        cmake ../ -DENABLE_ENCRYPTION=OFF -DENABLE_STDCXX_SYNC=${{matrix.cxxstdsync}} -DENABLE_UNITTESTS=OFF -DENABLE_BONDING=ON --toolchain scripts/iOS.cmake
+    - name: build
+      run: cd _build && cmake --build ./
diff --git a/.github/workflows/s390x-focal.yaml b/.github/workflows/s390x-focal.yaml
new file mode 100644
index 000000000..f1b6c7508
--- /dev/null
+++ b/.github/workflows/s390x-focal.yaml
@@ -0,0 +1,41 @@
+name: QEMU to run s390x-focal
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  Tests:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Setup multiarch/qemu-user-static
+      run: |
+        docker run --rm --privileged multiarch/qemu-user-static:register --reset
+    - name: ubuntu-core:s390x-focal
+      uses: docker://multiarch/ubuntu-core:s390x-focal
+      with:
+        args: >
+          bash -c
+          "uname -a &&
+          lscpu | grep Endian 
+          "
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: configure
+      uses: docker://multiarch/ubuntu-core:s390x-focal
+      with:
+        args: >
+          bash -c
+          "apt-get -y update &&
+          export DEBIAN_FRONTEND=noninteractive &&
+          export TZ=Etc/UTC && 
+          apt-get -y install tzdata &&
+          uname -a &&
+          lscpu | grep Endian &&
+          apt-get -y install cmake g++ libssl-dev git && 
+          mkdir _build && cd _build &&
+          cmake ../ -DENABLE_ENCRYPTION=ON -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DENABLE_TESTING=ON -DENABLE_EXAMPLES=ON &&
+          cmake --build ./ &&
+          ./test-srt -disable-ipv6"
diff --git a/.gitignore b/.gitignore
index e179ad146..b4e22ff8d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,13 @@ _*/
 # Ignode Visual Studio Code temp folder
 .vs/
 .vscode/
+
+# Ignore vcpkg submodule
+vcpkg/
+
+# LSP
+compile_commands.json
+
+# ignore files generated by clion and cmake
+.idea/
+cmake-build-debug/
diff --git a/.lgtm.yml b/.lgtm.yml
index 5d42eec3e..4df28afb9 100644
--- a/.lgtm.yml
+++ b/.lgtm.yml
@@ -2,4 +2,4 @@ extraction:
   cpp:
     configure:
       command:
-      - cmake . -DENABLE_HEAVY_LOGGING=1 -DENABLE_EXPERIMENTAL_BONDING=1
+      - cmake . -DENABLE_HEAVY_LOGGING=1 -DENABLE_BONDING=1
diff --git a/.travis.yml b/.travis.yml
index 4d27056a6..94d5dac3a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,5 @@
 language: cpp
-dist: trusty
+dist: xenial
 
 addons:
     apt:
@@ -9,12 +9,10 @@ addons:
         - cmake
         - libssl-dev
         - build-essential
-    sonarcloud:
-        organization: "haivision"
-        token:
-            secure: "wJZC0kyyjuf4SZyonZ6p/5Ga9asEqSnKWF9NpRbu6S6ceERO7vbebuSJF5qX3A6ivPuw0TTk5WASOdnvIyfA28FU/D0MWRdH8K7T3w77wdE9EgAEYTUXzdrbzJY18+9pxjljHwWXWALPSGf3MClg4irWrdk1e6uHK+68R39+ZvBGBFpWeeZy/+at9+xwhtAGKBlSHe8zc+3wPxuYdvviLVJ25qbpNmnzkUR0X89G+UBl90raCPSN32EHFdImHZ5DxfEQQJgZFRjzQUY4EW/iYwaMel7jufAq0ClgV4psKujl9Lz8cPqx3WgqRfJyiIthOMTsac7G4zAw8LK2CI0VsssBp0JalLXaumi6vG7o6c3rIwKckzSKccq3pHa7h45praIVVn9s3nq+Q/JGA11FMkKQxdQtmwgFsLhbi6ZxabgsUi5KtWoWY2z6MgpJuROuAjNxZi9XJzUoJs7zSTUtRRW7V8Q2lRiOnknYh25N6TCA5bpyy1EZmRdJErm071YNI9P01gbFz5137FWJFiJzro9TGF0KoHSGiCIdUt3WlMzwr/i/wFLxFBQOZQ2rjTXvhs4hxONxMZV3gzxA1NdLaf9i5Mh6jxVMV+ujaRSV7JmPGzxqiAlpT9cJUhTCYuar9diLLeDrpe7RawEZR8V1xVDQ7yT8ruDNQ78VbSn/sC0="
+        - libmbedtls-dev
+        - gdb
     homebrew:
-        update: true  # TODO: this should be removed once this bug is fixed: https://travis-ci.community/t/macos-build-fails-because-of-homebrew-bundle-unknown-command/7296
+        update: false
         packages:
         - openssl
 
@@ -23,20 +21,22 @@ matrix:
         - os: linux
           env:
           - BUILD_TYPE=Debug
-          - BUILD_OPTS='-DENABLE_CODE_COVERAGE=ON -DENABLE_EXPERIMENTAL_BONDING=ON'
-          - RUN_SONARCUBE=1
-          - RUN_CODECOV=1
+          - BUILD_OPTS='-DENABLE_BONDING=ON -DCMAKE_CXX_FLAGS="-Werror"'
         - env:
           - BUILD_TYPE=Debug
-          - BUILD_OPTS='-DENABLE_LOGGING=OFF -DENABLE_MONOTONIC_CLOCK=ON -DENABLE_EXPERIMENTAL_BONDING=ON'
+          - BUILD_OPTS='-DENABLE_LOGGING=OFF -DUSE_ENCLIB=mbedtls -DENABLE_MONOTONIC_CLOCK=ON -DENABLE_BONDING=ON -DCMAKE_CXX_FLAGS="-Werror"'
         - os: linux
           env: BUILD_TYPE=Release
         - os: osx
-          osx_image: xcode10.2
-          env: BUILD_TYPE=Debug
+          osx_image: xcode11.1
+          env:
+          - BUILD_TYPE=Debug
+          - BUILD_OPTS='-DCMAKE_CXX_FLAGS="-Werror"'
         - os: osx
-          osx_image: xcode10.2
-          env: BUILD_TYPE=Release
+          osx_image: xcode11.1
+          env:
+          - BUILD_TYPE=Release
+          - BUILD_OPTS='-DCMAKE_CXX_FLAGS="-Werror"'
         - os: linux
           compiler: x86_64-w64-mingw32-g++
           addons:
@@ -48,41 +48,38 @@ matrix:
                 - gcc-mingw-w64
                 - g++-mingw-w64-x86-64
           before_script:
-            - git clone -b OpenSSL_1_1_1-stable https://github.com/openssl/openssl.git openssl
+            - git clone -b OpenSSL_1_1_1g https://github.com/openssl/openssl.git openssl
             - cd openssl
             - ./Configure --cross-compile-prefix=x86_64-w64-mingw32- mingw64
             - make
             - cd ..
           env: BUILD_TYPE=Release
+
+         # Power jobs
+        - os: linux
+          arch: ppc64le
+          env:
+          - BUILD_TYPE=Debug
+        - arch: ppc64le
+          env:
+          - BUILD_TYPE=Release
+          - BUILD_OPTS='-DENABLE_MONOTONIC_CLOCK=ON'
 script:
     - if [ "$TRAVIS_COMPILER" == "x86_64-w64-mingw32-g++" ]; then
         export CC="x86_64-w64-mingw32-gcc";
         export CXX="x86_64-w64-mingw32-g++";
-        cmake . -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_OPTS -DENABLE_UNITTESTS="ON" -DUSE_OPENSSL_PC="OFF" -DOPENSSL_ROOT_DIR="$PWD/openssl" -DCMAKE_SYSTEM_NAME="Windows";
+        cmake . -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_OPTS -DENABLE_UNITTESTS="OFF" -DUSE_OPENSSL_PC="OFF" -DOPENSSL_ROOT_DIR="$PWD/openssl" -DCMAKE_SYSTEM_NAME="Windows";
       elif [ "$TRAVIS_OS_NAME" == "linux" ]; then
         cmake . -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_OPTS -DENABLE_UNITTESTS="ON";
       elif [ "$TRAVIS_OS_NAME" == "osx" ]; then
         export PKG_CONFIG_PATH=$(brew --prefix openssl)"/lib/pkgconfig";
         cmake . -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_OPTS -DENABLE_UNITTESTS="ON";
       fi
-    - echo "TRAVIS_REPO_SLUG=$TRAVIS_REPO_SLUG"
-    - echo "TRAVIS_PULL_REQUEST=$TRAVIS_PULL_REQUEST"
-    - if [[ "$TRAVIS_REPO_SLUG" != "Haivision/srt" || "$TRAVIS_PULL_REQUEST" -gt 0 ]]; then
-        export RUN_SONARCUBE=0;
-      fi
-    - echo "RUN_SONARCUBE=$RUN_SONARCUBE"
-    - if (( "$RUN_SONARCUBE" )); then
-        build-wrapper-linux-x86-64 --out-dir bw-output make;
-      else
-        make -j$(nproc);
-      fi
+    - make -j$(nproc);
     - if [ "$TRAVIS_COMPILER" != "x86_64-w64-mingw32-g++" ]; then
-        ./test-srt --gtest_filter="-TestMuxer.IPv4_and_IPv6";
-      fi
-    - source ./scripts/collect-gcov.sh
-    - if (( "$RUN_CODECOV" )); then
-        bash <(curl -s https://codecov.io/bash);
-      fi
-    - if (( "$RUN_SONARCUBE" )); then
-        sonar-scanner -D"sonar.cfamily.gcov.reportPath=.";
+        ulimit -c unlimited;
+        ./test-srt -disable-ipv6;
+        SUCCESS=$?;
+        if [ -f core ]; then gdb -batch ./test-srt -c core -ex bt -ex "info thread" -ex quit; else echo "NO CORE - NO CRY!"; fi;
+        test $SUCCESS == 0;
       fi
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2270ce380..9a2fc63d2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,14 +8,26 @@
 #
 
 cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
-# XXX This can be potentially done in future, but there still exist
-# some dependent project using cmake 2.8 - this can't be done this way.
-#cmake_minimum_required (VERSION 3.0.2 FATAL_ERROR)
-#project(SRT VERSION "1.4.2")
-project(SRT C CXX)
+set (SRT_VERSION 1.5.4)
 
 set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/scripts")
-include(haiUtil)
+include(haiUtil) # needed for set_version_variables
+# CMake version 3.0 introduced the VERSION option of the project() command
+# to specify a project version as well as the name.
+if(${CMAKE_VERSION} VERSION_LESS "3.0.0")
+	project(SRT C CXX)
+	# Sets SRT_VERSION_MAJOR, SRT_VERSION_MINOR, SRT_VERSION_PATCH
+	set_version_variables(SRT_VERSION ${SRT_VERSION})
+else()
+	cmake_policy(SET CMP0048 NEW)
+	# Also sets SRT_VERSION_MAJOR, SRT_VERSION_MINOR, SRT_VERSION_PATCH
+	project(SRT VERSION ${SRT_VERSION} LANGUAGES C CXX)
+endif()
+
+if (NOT ${CMAKE_VERSION} VERSION_LESS "3.28.1")
+	cmake_policy(SET CMP0054 NEW)
+endif ()
+
 include(FindPkgConfig)
 # XXX See 'if (MINGW)' condition below, may need fixing.
 include(FindThreads)
@@ -26,25 +38,19 @@ string(TOLOWER ${CMAKE_SYSTEM_NAME} SYSNAME_LC)
 set_if(DARWIN	   (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 					OR (${CMAKE_SYSTEM_NAME} MATCHES "iOS")
 					OR (${CMAKE_SYSTEM_NAME} MATCHES "tvOS")
-					OR (${CMAKE_SYSTEM_NAME} MATCHES "watchOS"))
+					OR (${CMAKE_SYSTEM_NAME} MATCHES "watchOS")
+					OR (${CMAKE_SYSTEM_NAME} MATCHES "visionOS"))
 set_if(LINUX       ${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 set_if(BSD         ${SYSNAME_LC} MATCHES "bsd$")
 set_if(MICROSOFT   WIN32 AND (NOT MINGW AND NOT CYGWIN))
 set_if(GNU         ${CMAKE_SYSTEM_NAME} MATCHES "GNU")
-set_if(POSIX       LINUX OR DARWIN OR BSD OR (CYGWIN AND CYGWIN_USE_POSIX))
-set_if(SYMLINKABLE LINUX OR DARWIN OR BSD OR CYGWIN OR GNU)
-
-# Not sure what to do in case of compiling by MSVC.
-# This will make installdir in C:\Program Files\SRT then
-# inside "bin" and "lib64" directories. At least this maintains
-# the current status. Shall this be not desired, override values
-# of CMAKE_INSTALL_BINDIR, CMAKE_INSTALL_LIBDIR and CMAKE_INSTALL_INCLUDEDIR.
-if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-	include(GNUInstallDirs)
-endif()
+set_if(ANDROID     ${SYSNAME_LC} MATCHES "android")
+set_if(SUNOS       "${SYSNAME_LC}" MATCHES "sunos")
+set_if(POSIX       LINUX OR DARWIN OR BSD OR SUNOS OR ANDROID OR (CYGWIN AND CYGWIN_USE_POSIX))
+set_if(SYMLINKABLE LINUX OR DARWIN OR BSD OR SUNOS OR CYGWIN OR GNU)
+set_if(NEED_DESTINATION  ${CMAKE_VERSION} VERSION_LESS "3.14.0")
 
-set (SRT_VERSION 1.4.2)
-set_version_variables(SRT_VERSION ${SRT_VERSION})
+include(GNUInstallDirs)
 
 # The CMAKE_BUILD_TYPE seems not to be always set, weird.
 if (NOT DEFINED ENABLE_DEBUG)
@@ -56,15 +62,33 @@ if (NOT DEFINED ENABLE_DEBUG)
 	endif()
 endif()
 
-# Set CMAKE_BUILD_TYPE properly, now that you know
-# that ENABLE_DEBUG is set as it should.
+# XXX This is a kind of workaround - this part to set the build
+# type and associated other flags should not be done for build
+# systems (cmake generators) that generate a multi-configuration
+# build definition. At least it is known that MSVC does it and it
+# sets _DEBUG and NDEBUG flags itself, so this shouldn't be done
+# at all in this case.
+if (NOT MICROSOFT)
+
+	# Set CMAKE_BUILD_TYPE properly, now that you know
+	# that ENABLE_DEBUG is set as it should.
+	if (ENABLE_DEBUG EQUAL 2)
+		set (CMAKE_BUILD_TYPE "RelWithDebInfo")
+		if (ENABLE_ASSERT)
+			# Add _DEBUG macro if explicitly requested, to enable SRT_ASSERT().
+			add_definitions(-D_DEBUG)
+		else()
+			add_definitions(-DNDEBUG)
+		endif()
+	elseif (ENABLE_DEBUG) # 1, ON, YES, TRUE, Y, or any other non-zero number
+		set (CMAKE_BUILD_TYPE "Debug")
 
-if (ENABLE_DEBUG EQUAL 2)
-	set (CMAKE_BUILD_TYPE "RelWithDebInfo")
-elseif (ENABLE_DEBUG) # 1, ON, YES, TRUE, Y, or any other non-zero number
-	set (CMAKE_BUILD_TYPE "Debug")
-else()
-	set (CMAKE_BUILD_TYPE "Release")
+		# Add _DEBUG macro in debug mode only, to enable SRT_ASSERT().
+		add_definitions(-D_DEBUG)
+	else()
+		set (CMAKE_BUILD_TYPE "Release")
+		add_definitions(-DNDEBUG)
+	endif()
 endif()
 
 message(STATUS "BUILD TYPE: ${CMAKE_BUILD_TYPE}")
@@ -87,11 +111,14 @@ endforeach()
 
 # SRT_ENABLE_ECN 1                /* Early Congestion Notification (for source bitrate control) */
 # SRT_DEBUG_TSBPD_OUTJITTER 1     /* Packet Delivery histogram */
-# SRT_DEBUG_TSBPD_DRIFT 1         /* Debug Encoder-Decoder Drift) */
+# SRT_DEBUG_TRACE_DRIFT 1         /* Create a trace log for Encoder-Decoder Clock Drift */
 # SRT_DEBUG_TSBPD_WRAP 1          /* Debug packet timestamp wraparound */
 # SRT_DEBUG_TLPKTDROP_DROPSEQ 1
 # SRT_DEBUG_SNDQ_HIGHRATE 1
+# SRT_DEBUG_BONDING_STATES 1
+# SRT_DEBUG_RTT 1                 /* RTT trace */
 # SRT_MAVG_SAMPLING_RATE 40       /* Max sampling rate */
+# SRT_ENABLE_FREQUENT_LOG_TRACE 0 : set to 1 to enable printing reason for suppressed freq logs
 
 # option defaults
 set(ENABLE_HEAVY_LOGGING_DEFAULT OFF)
@@ -101,12 +128,29 @@ if (ENABLE_DEBUG)
 	set(ENABLE_HEAVY_LOGGING_DEFAULT ON)
 endif()
 
+# Note that the IP_PKTINFO  has a limited portability and may not work on some platforms
+# (Windows, FreeBSD, ...).
+set (ENABLE_PKTINFO_DEFAULT OFF)
+
+set(ENABLE_STDCXX_SYNC_DEFAULT OFF)
+set(ENABLE_MONOTONIC_CLOCK_DEFAULT OFF)
+set(MONOTONIC_CLOCK_LINKLIB "")
+if (MICROSOFT)
+	set(ENABLE_STDCXX_SYNC_DEFAULT ON)
+elseif (POSIX)
+	test_requires_clock_gettime(ENABLE_MONOTONIC_CLOCK_DEFAULT MONOTONIC_CLOCK_LINKLIB)
+endif()
+
 
 # options
 option(CYGWIN_USE_POSIX "Should the POSIX API be used for cygwin. Ignored if the system isn't cygwin." OFF)
-option(ENABLE_CXX11 "Should the c++11 parts (srt-live-transmit) be enabled" ON)
+if (CMAKE_CXX_COMPILER_ID MATCHES "^GNU$" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
+	option(ENABLE_CXX11 "Should the c++11 parts (srt-live-transmit) be enabled" OFF)
+else()
+	option(ENABLE_CXX11 "Should the c++11 parts (srt-live-transmit) be enabled" ON)
+endif()
 option(ENABLE_APPS "Should the Support Applications be Built?" ON)
-option(ENABLE_EXPERIMENTAL_BONDING "Should the EXPERIMENTAL bonding functionality be enabled?" OFF)
+option(ENABLE_BONDING "Should the bonding functionality be enabled?" OFF)
 option(ENABLE_TESTING "Should the Developer Test Applications be Built?" OFF)
 option(ENABLE_PROFILE "Should instrument the code for profiling. Ignored for non-GNU compiler." $ENV{HAI_BUILD_PROFILE})
 option(ENABLE_LOGGING "Should logging be enabled" ON)
@@ -114,20 +158,34 @@ option(ENABLE_HEAVY_LOGGING "Should heavy debug logging be enabled" ${ENABLE_HEA
 option(ENABLE_HAICRYPT_LOGGING "Should logging in haicrypt be enabled" 0)
 option(ENABLE_SHARED "Should libsrt be built as a shared library" ON)
 option(ENABLE_STATIC "Should libsrt be built as a static library" ON)
+option(ENABLE_PKTINFO "Enable using IP_PKTINFO to allow the listener extracting the target IP address from incoming packets" ${ENABLE_PKTINFO_DEFAULT})
 option(ENABLE_RELATIVE_LIBPATH "Should application contain relative library paths, like ../lib" OFF)
 option(ENABLE_GETNAMEINFO "In-logs sockaddr-to-string should do rev-dns" OFF)
 option(ENABLE_UNITTESTS "Enable unit tests" OFF)
 option(ENABLE_ENCRYPTION "Enable encryption in SRT" ON)
+option(ENABLE_AEAD_API_PREVIEW "Enable AEAD API preview in SRT" Off)
+option(ENABLE_MAXREXMITBW "Enable SRTO_MAXREXMITBW (v1.6.0 API preview)" Off)
 option(ENABLE_CXX_DEPS "Extra library dependencies in srt.pc for the CXX libraries useful with C language" ON)
 option(USE_STATIC_LIBSTDCXX "Should use static rather than shared libstdc++" OFF)
 option(ENABLE_INET_PTON "Set to OFF to prevent usage of inet_pton when building against modern SDKs while still requiring compatibility with older Windows versions, such as Windows XP, Windows Server 2003 etc." ON)
 option(ENABLE_CODE_COVERAGE "Enable code coverage reporting" OFF)
-option(ENABLE_MONOTONIC_CLOCK "Enforced clock_gettime with monotonic clock on GC CV /temporary fix for #729/" OFF)
-option(ENABLE_STDCXX_SYNC "Use C++11 chrono and threads for timing instead of pthreads" OFF)
+option(ENABLE_MONOTONIC_CLOCK "Enforced clock_gettime with monotonic clock on GC CV" ${ENABLE_MONOTONIC_CLOCK_DEFAULT})
+option(ENABLE_STDCXX_SYNC "Use C++11 chrono and threads for timing instead of pthreads" ${ENABLE_STDCXX_SYNC_DEFAULT})
 option(USE_OPENSSL_PC "Use pkg-config to find OpenSSL libraries" ON)
+option(OPENSSL_USE_STATIC_LIBS "Link OpenSSL libraries statically." OFF)
 option(USE_BUSY_WAITING "Enable more accurate sending times at a cost of potentially higher CPU load" OFF)
 option(USE_GNUSTL "Get c++ library/headers from the gnustl.pc" OFF)
 option(ENABLE_SOCK_CLOEXEC "Enable setting SOCK_CLOEXEC on a socket" ON)
+option(ENABLE_SHOW_PROJECT_CONFIG "Enable show Project Configuration" OFF)
+
+option(ENABLE_CLANG_TSA "Enable Clang Thread Safety Analysis" OFF)
+
+# NOTE: Use ATOMIC_USE_SRT_SYNC_MUTEX and will override the auto-detection of the
+#  Atomic implemetation in srtcore/atomic.h.
+option(ATOMIC_USE_SRT_SYNC_MUTEX "Use srt::sync::Mutex to Implement Atomics" OFF)
+if (ATOMIC_USE_SRT_SYNC_MUTEX)
+   add_definitions(-DATOMIC_USE_SRT_SYNC_MUTEX=1)
+endif()
 
 set(TARGET_srt "srt" CACHE STRING "The name for the SRT library")
 
@@ -158,6 +216,16 @@ else()
 	message(STATUS "USE_BUSY_WAITING: OFF (default)")
 endif()
 
+# Reduce the frequency of some frequent logs, milliseconds
+set(SRT_LOG_SLOWDOWN_FREQ_MS_DEFAULT 1000) # 1s
+if (NOT DEFINED SRT_LOG_SLOWDOWN_FREQ_MS)
+	if (ENABLE_HEAVY_LOGGING)
+		set(SRT_LOG_SLOWDOWN_FREQ_MS 0) # Just show every log message.
+	else()
+		set(SRT_LOG_SLOWDOWN_FREQ_MS ${SRT_LOG_SLOWDOWN_FREQ_MS_DEFAULT})
+	endif()
+endif()
+
 if ( CYGWIN AND NOT CYGWIN_USE_POSIX )
 	set(WIN32 1)
 	set(CMAKE_LEGACY_CYGWIN_WIN32 1)
@@ -170,13 +238,12 @@ if (NOT USE_ENCLIB)
 		message("NOTE: USE_GNUTLS is deprecated. Use -DUSE_ENCLIB=gnutls instead.")
 		set (USE_ENCLIB gnutls)
 	else()
-		set (USE_ENCLIB openssl)
+		set (USE_ENCLIB openssl-evp)
 	endif()
-
 endif()
 
 set(USE_ENCLIB "${USE_ENCLIB}" CACHE STRING "The crypto library that SRT uses")
-set_property(CACHE USE_ENCLIB PROPERTY STRINGS "openssl" "gnutls" "mbedtls")
+set_property(CACHE USE_ENCLIB PROPERTY STRINGS "openssl" "openssl-evp" "gnutls" "mbedtls" "botan")
 
 # Make sure DLLs and executabes go to the same path regardles of subdirectory
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
@@ -244,7 +311,13 @@ if(WIN32)
 	if(ENABLE_INET_PTON)
 		set(CMAKE_REQUIRED_LIBRARIES ws2_32)
 		check_function_exists(inet_pton HAVE_INET_PTON)
-		add_definitions(-D_WIN32_WINNT=0x0600)
+		try_compile(AT_LEAST_VISTA
+			${CMAKE_BINARY_DIR}
+			"${CMAKE_CURRENT_SOURCE_DIR}/scripts/test_vista.c")
+		if(NOT AT_LEAST_VISTA)
+			# force targeting Vista
+			add_definitions(-D_WIN32_WINNT=0x0600)
+		endif()
 	else()
 		add_definitions(-D_WIN32_WINNT=0x0501)
 	endif()
@@ -255,7 +328,15 @@ if (DEFINED HAVE_INET_PTON)
 	add_definitions(-DHAVE_INET_PTON=1)
 endif()
 
+# Defines HAVE_PTHREAD_GETNAME_* and HAVE_PTHREAD_SETNAME_*
+include(FindPThreadGetSetName)
+FindPThreadGetSetName()
+
 if (ENABLE_MONOTONIC_CLOCK)
+	if (NOT ENABLE_MONOTONIC_CLOCK_DEFAULT)
+		message(FATAL_ERROR "Your platform does not support CLOCK_MONOTONIC. Build with -DENABLE_MONOTONIC_CLOCK=OFF.")
+	endif()
+	set (WITH_EXTRALIBS "${WITH_EXTRALIBS} ${MONOTONIC_CLOCK_LINKLIB}")
 	add_definitions(-DENABLE_MONOTONIC_CLOCK=1)
 endif()
 
@@ -277,18 +358,41 @@ if (ENABLE_ENCRYPTION)
 		link_directories(
 			${SSL_LIBRARY_DIRS}
 		)
-	else() # Common for mbedtls and openssl
-		if ("${USE_ENCLIB}" STREQUAL "mbedtls")
-			add_definitions(-DUSE_MBEDTLS=1)
-			set (SSL_REQUIRED_MODULES "mbedtls mbedcrypto")
-		else()
-			add_definitions(-DUSE_OPENSSL=1)
-			set (SSL_REQUIRED_MODULES "openssl libcrypto")
+	elseif ("${USE_ENCLIB}" STREQUAL "mbedtls")
+		add_definitions(-DUSE_MBEDTLS=1)
+		if ("${SSL_LIBRARY_DIRS}" STREQUAL "")
+			set(MBEDTLS_PREFIX "${CMAKE_PREFIX_PATH}" CACHE PATH "The path of mbedtls")
+			find_package(MbedTLS REQUIRED)
+			set (SSL_INCLUDE_DIRS ${MBEDTLS_INCLUDE_DIR})
+			set (SSL_LIBRARIES  ${MBEDTLS_LIBRARIES})
 		endif()
+		if (WIN32)
+			set (SSL_LIBRARIES ${SSL_LIBRARIES} bcrypt)
+		endif()
+		if ("${SSL_LIBRARIES}" STREQUAL "")
+			set (SSL_LIBRARIES  mbedtls mbedcrypto)
+		endif()
+		message(STATUS "SSL enforced mbedtls: -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
+
+		foreach(LIB ${SSL_LIBRARIES})
+			if(IS_ABSOLUTE ${LIB} AND EXISTS ${LIB})
+				set (SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} ${LIB})
+			else()
+				set(SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} "-l${LIB}")
+			endif()
+		endforeach()
+	elseif ("${USE_ENCLIB}" STREQUAL "openssl-evp")
+		# Openssl-EVP requires CRYSPR2
+		add_definitions(-DUSE_OPENSSL_EVP=1 -DCRYSPR2)
+		set (SSL_REQUIRED_MODULES "openssl libcrypto")
 		# Try using pkg-config method first if enabled,
 		# fall back to find_package method otherwise
 		if (USE_OPENSSL_PC)
 			pkg_check_modules(SSL ${SSL_REQUIRED_MODULES})
+			if (OPENSSL_USE_STATIC_LIBS)
+				# use `pkg-config --static xxx` found libs
+				set(SSL_LIBRARIES ${SSL_STATIC_LIBRARIES})
+			endif()
 		endif()
 		if (SSL_FOUND)
 			# We have some cases when pkg-config is improperly configured
@@ -309,31 +413,105 @@ if (ENABLE_ENCRYPTION)
 			)
 			message(STATUS "SSL via pkg-config: -L ${SSL_LIBRARY_DIRS} -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
 		else()
-			if ("${USE_ENCLIB}" STREQUAL "mbedtls")
-				if ("${SSL_LIBRARY_DIRS}" STREQUAL "")
-					set(MBEDTLS_PREFIX "${CMAKE_PREFIX_PATH}" CACHE PATH "The path of mbedtls")
-					find_package(MbedTLS REQUIRED)
-					set (SSL_INCLUDE_DIRS ${MBEDTLS_INCLUDE_DIR})
-					set (SSL_LIBRARIES  ${MBEDTLS_LIBRARIES})
-				endif()
-				if ("${SSL_LIBRARIES}" STREQUAL "")
-					set (SSL_LIBRARIES  mbedtls mbedcrypto)
-				endif()
-				message(STATUS "SSL enforced mbedtls: -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
-			else()
-				find_package(OpenSSL REQUIRED)
-				set (SSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
-				set (SSL_LIBRARIES ${OPENSSL_LIBRARIES})
-				message(STATUS "SSL via find_package(OpenSSL): -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
+			find_package(OpenSSL REQUIRED)
+			set (SSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
+			set (SSL_LIBRARIES ${OPENSSL_LIBRARIES})
+			message(STATUS "SSL via find_package(OpenSSL): -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
+		endif()
+	elseif ("${USE_ENCLIB}" STREQUAL "botan")
+		add_definitions(-DUSE_BOTAN=1 -DCRYSPR2)
+		set (SSL_REQUIRED_MODULES "botan")
+		find_package(Botan 3.0.0 REQUIRED)
+		botan_generate(
+			botan
+			ffi
+			nist_keywrap
+			aes_armv8
+			aes_ni
+			aes_power8
+			aes_vperm
+			idea_sse2
+			serpent_avx2
+			shacal2_armv8
+			shacal2_avx2
+			shacal2_x86
+			sm4_armv8
+			rdseed
+			sha1_armv8
+			sha1_sse2
+			sha1_x86
+			sha2_32_armv8
+			sha2_32_bmi2
+			sha2_32_x86
+			sha2_64_bmi2
+			sha3_bmi2
+			zfec_sse2
+			zfec_vperm
+			argon2_avx2
+			argon2_ssse3
+			processor_rng
+			chacha_avx2
+			ghash_cpu
+			ghash_vperm
+			simd
+			simd_avx2)
+		target_compile_features("botan" PRIVATE "cxx_std_20")
+		set (SSL_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
+		set (SSL_LIBRARIES "botan")
+	else() # openssl
+		# Openssl (Direct-AES API) can use CRYSPR2
+		add_definitions(-DUSE_OPENSSL=1 -DCRYSPR2)
+			set (SSL_REQUIRED_MODULES "openssl libcrypto")
+		# Try using pkg-config method first if enabled,
+		# fall back to find_package method otherwise
+		if (USE_OPENSSL_PC)
+			pkg_check_modules(SSL ${SSL_REQUIRED_MODULES})
+		endif()
+		if (SSL_FOUND)
+			# We have some cases when pkg-config is improperly configured
+			# When it doesn't ship the -L and -I options, and the CMAKE_PREFIX_PATH
+			# is set (also through `configure`), then we have this problem. If so,
+			# set forcefully the -I and -L contents to prefix/include and
+			# prefix/lib.
+			if ("${SSL_LIBRARY_DIRS}" STREQUAL "")
+			if (NOT "${CMAKE_PREFIX_PATH}" STREQUAL "")
+				message(STATUS "WARNING: pkg-config has incorrect prefix - enforcing target path prefix: ${CMAKE_PREFIX_PATH}")
+				set (SSL_LIBRARY_DIRS ${CMAKE_PREFIX_PATH}/${CMAKE_INSTALL_LIBDIR})
+				set (SSL_INCLUDE_DIRS ${CMAKE_PREFIX_PATH}/include)
 			endif()
+			endif()
+
+			link_directories(
+				${SSL_LIBRARY_DIRS}
+			)
+			message(STATUS "SSL via pkg-config: -L ${SSL_LIBRARY_DIRS} -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
+		else()
+			find_package(OpenSSL REQUIRED)
+			set (SSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
+			set (SSL_LIBRARIES ${OPENSSL_LIBRARIES})
+			message(STATUS "SSL via find_package(OpenSSL): -I ${SSL_INCLUDE_DIRS} -l;${SSL_LIBRARIES}")
 		endif()
+
 	endif()
 
 	add_definitions(-DSRT_ENABLE_ENCRYPTION)
 	message(STATUS "ENCRYPTION: ENABLED, using: ${SSL_REQUIRED_MODULES}")
 	message (STATUS "SSL libraries: ${SSL_LIBRARIES}")
+
+	if (ENABLE_AEAD_API_PREVIEW)
+		if (("${USE_ENCLIB}" STREQUAL "openssl-evp") OR ("${USE_ENCLIB}" STREQUAL "botan"))
+			add_definitions(-DENABLE_AEAD_API_PREVIEW)
+			message(STATUS "ENCRYPTION AEAD API: ENABLED")
+		else()
+			message(FATAL_ERROR "ENABLE_AEAD_API_PREVIEW is only available with USE_ENCLIB=[openssl-evp | botan]!")
+		endif()
+	else()
+		message(STATUS "ENCRYPTION AEAD API: DISABLED")
+	endif()
+
 else()
 	message(STATUS "ENCRYPTION: DISABLED")
+	message(STATUS "ENCRYPTION AEAD API: N/A")
 endif()
 
 if (USE_GNUSTL)
@@ -343,8 +521,15 @@ if (USE_GNUSTL)
 	set (SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} ${GNUSTL_LIBRARIES} ${GNUSTL_LDFLAGS})
 endif()
 
+if (ENABLE_MAXREXMITBW)
+	add_definitions(-DENABLE_MAXREXMITBW)
+	message(STATUS "MAXREXMITBW API: ENABLED")
+else()
+	message(STATUS "MAXREXMITBW API: DISABLED")
+endif()
+
 if (USING_DEFAULT_COMPILER_PREFIX)
-# Detect if the compiler is GNU compatable for flags
+# Detect if the compiler is GNU compatible for flags
 if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Intel|Clang|AppleClang")
 	message(STATUS "COMPILER: ${CMAKE_CXX_COMPILER_ID} (${CMAKE_CXX_COMPILER}) - GNU compat")
 	set(HAVE_COMPILER_GNU_COMPAT 1)
@@ -374,6 +559,29 @@ else() # Compiler altered by WITH_COMPILER_TYPE/PREFIX - can't rely on CMAKE_CXX
 	message(STATUS "COMPILER CHANGED TO: ${COMPILER_TYPE} - forcing C++11 standard for apps")
 endif()
 
+# Check for GCC Atomic Intrinsics and C++11 Atomics.
+# Sets:
+#  HAVE_LIBATOMIC
+#  HAVE_LIBATOMIC_COMPILES
+#  HAVE_LIBATOMIC_COMPILES_STATIC
+#  HAVE_GCCATOMIC_INTRINSICS
+#  HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC
+include(CheckGCCAtomicIntrinsics)
+CheckGCCAtomicIntrinsics()
+#  HAVE_CXX_ATOMIC
+#  HAVE_CXX_ATOMIC_STATIC
+include(CheckCXXAtomic)
+CheckCXXAtomic()
+
+# Check for std::put_time():
+# Sets:
+#  HAVE_CXX_STD_PUT_TIME
+include(CheckCXXStdPutTime)
+CheckCXXStdPutTime()
+if (HAVE_CXX_STD_PUT_TIME)
+	add_definitions(-DHAVE_CXX_STD_PUT_TIME=1)
+endif()
+
 if (DISABLE_CXX11)
 	set (ENABLE_CXX11 0)
 elseif( DEFINED ENABLE_CXX11 )
@@ -409,9 +617,6 @@ if (NOT ENABLE_CXX11)
 	if (ENABLE_STDCXX_SYNC)
 		message(FATAL_ERROR "ENABLE_STDCXX_SYNC is set, but C++11 is disabled by ENABLE_CXX11")
 	endif()
-	if (DEFINED USE_CXX_STD)
-		message(FATAL_ERROR "USE_CXX_STD can be set only when ENABLE_CXX11 is on")
-	endif()
 elseif (ENABLE_STDCXX_SYNC)
 	add_definitions(-DENABLE_STDCXX_SYNC=1)
 	if (DEFINED USE_CXX_STD)
@@ -426,6 +631,7 @@ elseif (ENABLE_STDCXX_SYNC)
 endif()
 
 message(STATUS "STDCXX_SYNC: ${ENABLE_STDCXX_SYNC}")
+message(STATUS "MONOTONIC_CLOCK: ${ENABLE_MONOTONIC_CLOCK}")
 
 if (ENABLE_SOCK_CLOEXEC)
 	add_definitions(-DENABLE_SOCK_CLOEXEC=1)
@@ -455,9 +661,14 @@ if (DEFINED USE_CXX_STD)
 
 			# Set this through independent flags
 			set (USE_CXX_STD_LIB ${STDCXX})
-			set (USE_CXX_STD_APP "")
 			set (FORCE_CXX_STANDARD 1)
-			message(STATUS "C++ STANDARD: library: C++${STDCXX}, but apps still at least C++11")
+			if (NOT ENABLE_APPS)
+				set (USE_CXX_STD_APP ${STDCXX})
+				message(STATUS "C++ STANDARD: library: C++${STDCXX}, apps disabled (examples will follow C++${STDCXX})")
+			else()
+				set (USE_CXX_STD_APP "")
+				message(STATUS "C++ STANDARD: library: C++${STDCXX}, but apps still at least C++11")
+			endif()
 		elseif (FORCE_CXX_STANDARD_GNUONLY)
 			# CMake is too old to handle CMAKE_CXX_STANDARD,
 			# use bare GNU options.
@@ -499,6 +710,9 @@ endif()
 # add extra warning flags for gccish compilers
 if (HAVE_COMPILER_GNU_COMPAT)
 	set (SRT_GCC_WARN "-Wall -Wextra")
+	if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0 AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+		set (SRT_GCC_WARN "${SRT_GCC_WARN} -Wshadow=local")
+	endif()
 else()
 	# cpp debugging on Windows :D
 	#set (SRT_GCC_WARN "/showIncludes")
@@ -512,14 +726,6 @@ if (USE_STATIC_LIBSTDCXX)
 	endif()
 endif()
 
-# We need clock_gettime, but on some systems this is only provided
-# by librt. Check if librt is required.
-if (ENABLE_MONOTONIC_CLOCK AND LINUX)
-	# "requires" - exits on FATAL_ERROR when clock_gettime not available
-	test_requires_clock_gettime(NEED_CLOCK_GETTIME)
-	set (WITH_EXTRALIBS "${WITH_EXTRALIBS} ${NEED_CLOCK_GETTIME}")
-endif()
-
 
 # This options is necessary on some systems; on a cross-ARM compiler it
 # has been detected, for example, that -lrt is necessary for some applications
@@ -571,6 +777,9 @@ elseif(CYGWIN)
 elseif(GNU)
 	add_definitions(-DGNU=1)
 	message(STATUS "DETECTED SYSTEM: GNU;  GNU=1" )
+elseif(SUNOS)
+	add_definitions(-DSUNOS=1)
+	message(STATUS "DETECTED SYSTEM: SunOS|Solaris;  SUNOS=1" )
 else()
 	message(FATAL_ERROR "Unsupported system: ${CMAKE_SYSTEM_NAME}")
 endif()
@@ -610,8 +819,26 @@ if (ENABLE_GETNAMEINFO)
 	list(APPEND SRT_EXTRA_CFLAGS "-DENABLE_GETNAMEINFO=1")
 endif()
 
+if (ENABLE_PKTINFO)
+	if (WIN32 OR BSD)
+		message(FATAL_ERROR "PKTINFO is not implemented on Windows or *BSD.")
+	endif()
+
+	list(APPEND SRT_EXTRA_CFLAGS "-DSRT_ENABLE_PKTINFO=1")
+endif()
+
+
+# ENABLE_EXPERIMENTAL_BONDING is deprecated. Use ENABLE_BONDING. ENABLE_EXPERIMENTAL_BONDING is be removed in v1.6.0.
 if (ENABLE_EXPERIMENTAL_BONDING)
-	list(APPEND SRT_EXTRA_CFLAGS "-DENABLE_EXPERIMENTAL_BONDING=1")
+	message(DEPRECATION "ENABLE_EXPERIMENTAL_BONDING is deprecated. Please use ENABLE_BONDING instead.")
+	set (ENABLE_BONDING ON)
+endif()
+
+if (ENABLE_BONDING)
+	list(APPEND SRT_EXTRA_CFLAGS "-DENABLE_BONDING=1")
+	message(STATUS "ENABLE_BONDING: ON")
+else()
+	message(STATUS "ENABLE_BONDING: OFF")
 endif()
 
 if (ENABLE_THREAD_CHECK)
@@ -622,6 +849,11 @@ if (ENABLE_THREAD_CHECK)
 	)
 endif()
 
+if (ENABLE_CLANG_TSA)
+	list(APPEND SRT_EXTRA_CFLAGS "-Wthread-safety")
+	message(STATUS "Clang TSA: Enabled")
+endif()
+
 if (ENABLE_PROFILE)
 	if (HAVE_COMPILER_GNU_COMPAT)
 		# They are actually cflags, not definitions, but CMake is stupid enough.
@@ -775,14 +1007,17 @@ MafReadDir(srtcore filelist.maf
 	PRIVATE_HEADERS HEADERS_srt_private
 )
 
-message(STATUS "SRT Sources: ${SOURCES_srt}")
-
 # Auto generated version file and add it to the HEADERS_srt list.
 if(DEFINED ENV{APPVEYOR_BUILD_NUMBER})
 	set(SRT_VERSION_BUILD ON)
-	set(APPVEYOR_BUILD_NUMBER_STRING $ENV{APPVEYOR_BUILD_NUMBER})
+	set(CI_BUILD_NUMBER_STRING $ENV{APPVEYOR_BUILD_NUMBER})
 	message(STATUS "AppVeyor build environment detected: Adding build number to version header")
 endif()
+if(DEFINED ENV{TEAMCITY_VERSION})
+	set(SRT_VERSION_BUILD ON)
+	set(CI_BUILD_NUMBER_STRING $ENV{CI_BUILD_COUNTER})
+	message(STATUS "TeamCity build environment detected: Adding build counter to version header")
+endif()
 
 configure_file("srtcore/version.h.in" "version.h" @ONLY)
 
@@ -801,10 +1036,10 @@ macro(srt_set_stdcxx targetname spec)
 	if (NOT "${stdcxxspec}" STREQUAL "")
 		if (FORCE_CXX_STANDARD_GNUONLY)
 			target_compile_options(${targetname} PRIVATE -std=c++${stdcxxspec})
-			#message(STATUS "C++ STD: ${targetname}: forced C++${stdcxxspec} standard - GNU option: -std=c++${stdcxxspec}")
+			message(STATUS "C++ STD: ${targetname}: forced C++${stdcxxspec} standard - GNU option: -std=c++${stdcxxspec}")
 		else()
 			set_target_properties(${targetname} PROPERTIES CXX_STANDARD ${stdcxxspec})
-			#message(STATUS "C++ STD: ${targetname}: forced C++${stdcxxspec} standard - portable way")
+			message(STATUS "C++ STD: ${targetname}: forced C++${stdcxxspec} standard - portable way")
 		endif()
 	else()
 		message(STATUS "APP: ${targetname}: using default C++ standard")
@@ -821,20 +1056,22 @@ if (srt_libspec_shared)
 	# shared libraries need PIC
 	set (CMAKE_POSITION_INDEPENDENT_CODE ON)
 	set_property(TARGET ${TARGET_srt}_shared PROPERTY OUTPUT_NAME ${TARGET_srt})
-	set_target_properties (${TARGET_srt}_shared PROPERTIES VERSION ${SRT_VERSION} SOVERSION ${SRT_VERSION_MAJOR})
+	set_target_properties (${TARGET_srt}_shared PROPERTIES VERSION ${SRT_VERSION} SOVERSION ${SRT_VERSION_MAJOR}.${SRT_VERSION_MINOR})
 	list (APPEND INSTALL_TARGETS ${TARGET_srt}_shared)
 	if (ENABLE_ENCRYPTION)
 		target_link_libraries(${TARGET_srt}_shared PRIVATE ${SSL_LIBRARIES})
 	endif()
 	if (MICROSOFT)
 		target_link_libraries(${TARGET_srt}_shared PRIVATE ws2_32.lib)
-		if (OPENSSL_USE_STATIC_LIBS)			
-			target_link_libraries(${TARGET_srt}_shared PRIVATE crypt32.lib)
-		else()
-			set_target_properties(${TARGET_srt}_shared PROPERTIES LINK_FLAGS "/DELAYLOAD:libeay32.dll")
+		if (NOT (ENABLE_ENCRYPTION AND "${USE_ENCLIB}" STREQUAL "botan"))
+			if (OPENSSL_USE_STATIC_LIBS)
+				target_link_libraries(${TARGET_srt}_shared PRIVATE crypt32.lib)
+			else()
+				set_target_properties(${TARGET_srt}_shared PROPERTIES LINK_FLAGS "/DELAYLOAD:libeay32.dll")
+			endif()
 		endif()
 	elseif (MINGW)
-		target_link_libraries(${TARGET_srt}_shared PRIVATE wsock32.lib ws2_32.lib)
+		target_link_libraries(${TARGET_srt}_shared PRIVATE wsock32 ws2_32)
 	elseif (APPLE)
 		set_property(TARGET ${TARGET_srt}_shared PROPERTY MACOSX_RPATH ON)
 	endif()
@@ -866,7 +1103,7 @@ if (srt_libspec_static)
 	endif()
 	if (MICROSOFT)
 		target_link_libraries(${TARGET_srt}_static PRIVATE ws2_32.lib)
-		if (OPENSSL_USE_STATIC_LIBS)			
+		if (OPENSSL_USE_STATIC_LIBS)
 			target_link_libraries(${TARGET_srt}_static PRIVATE crypt32.lib)
 		endif()
 	elseif (MINGW)
@@ -879,8 +1116,8 @@ endif()
 
 target_include_directories(srt_virtual PRIVATE  ${SSL_INCLUDE_DIRS})
 
-if (MICROSOFT)		
-	if (OPENSSL_USE_STATIC_LIBS)			
+if (MICROSOFT)
+	if (OPENSSL_USE_STATIC_LIBS)
 		set (SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} ws2_32.lib crypt32.lib)
 	else()
 		set (SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} ws2_32.lib)
@@ -913,15 +1150,43 @@ if (ENABLE_SHARED)
 	target_compile_definitions(srt_virtual PUBLIC -DSRT_DYNAMIC)
 endif()
 
+target_compile_definitions(srt_virtual PRIVATE -DSRT_LOG_SLOWDOWN_FREQ_MS=${SRT_LOG_SLOWDOWN_FREQ_MS})
+
+if (ENABLE_ENCRYPTION AND "${USE_ENCLIB}" STREQUAL "botan")
+	add_dependencies(srt_virtual botan)
+endif()
+
 if (srt_libspec_shared)
 	if (MICROSOFT)
 		target_link_libraries(${TARGET_srt}_shared PUBLIC Ws2_32.lib)
-		if (OPENSSL_USE_STATIC_LIBS)			
+		if (OPENSSL_USE_STATIC_LIBS)
 			target_link_libraries(${TARGET_srt}_shared PUBLIC crypt32.lib)
 		endif()
 	endif()
 endif()
 
+# Required by some toolchains when statically linking this library if the
+#  GCC Atomic Intrinsics are being used.
+if (HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC AND HAVE_LIBATOMIC)
+	if (srt_libspec_static)
+		target_link_libraries(${TARGET_srt}_static PUBLIC atomic)
+	endif()
+	if (srt_libspec_shared)
+		target_link_libraries(${TARGET_srt}_shared PUBLIC atomic)
+	endif()
+elseif (HAVE_LIBATOMIC AND HAVE_LIBATOMIC_COMPILES_STATIC)
+	# This is a workaround for ANDROID NDK<17 builds, which need to link
+	#  to libatomic when linking statically to the SRT library.
+	if (srt_libspec_static)
+		target_link_libraries(${TARGET_srt}_static PUBLIC atomic)
+	endif()
+elseif (LINUX AND HAVE_LIBATOMIC AND HAVE_LIBATOMIC_COMPILES)
+	# This is a workaround for some older Linux Toolchains.
+	if (srt_libspec_static)
+		target_link_libraries(${TARGET_srt}_static PUBLIC atomic)
+	endif()
+endif()
+
 # Cygwin installs the *.dll libraries in bin directory and uses PATH.
 
 set (INSTALL_SHARED_DIR ${CMAKE_INSTALL_LIBDIR})
@@ -930,15 +1195,29 @@ if (CYGWIN)
 endif()
 
 message(STATUS "INSTALL DIRS: bin=${CMAKE_INSTALL_BINDIR} lib=${CMAKE_INSTALL_LIBDIR} shlib=${INSTALL_SHARED_DIR} include=${CMAKE_INSTALL_INCLUDEDIR}")
-
-install(TARGETS ${INSTALL_TARGETS}
-		RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-		ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+if (NEED_DESTINATION)
+	if (DEFINED CMAKE_INSTALL_BINDIR AND DEFINED CMAKE_INSTALL_LIBDIR AND NOT INSTALL_SHARED_DIR STREQUAL "")
+		install(TARGETS ${INSTALL_TARGETS}
+			RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+			ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+			LIBRARY DESTINATION ${INSTALL_SHARED_DIR}
+		)
+	else()
+		message(WARNING "No location to install ${INSTALL_TARGETS}")
+	endif()
+elseif (NOT INSTALL_SHARED_DIR STREQUAL "")
+	install(TARGETS ${INSTALL_TARGETS}
 		LIBRARY DESTINATION ${INSTALL_SHARED_DIR}
-)
-install(FILES ${HEADERS_srt} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/srt)
-if (WIN32)
-	install(FILES ${HEADERS_srt_win32} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/srt/win)
+	)
+else()
+	install(TARGETS ${INSTALL_TARGETS})
+endif()
+
+if (DEFINED CMAKE_INSTALL_INCLUDEDIR)
+	install(FILES ${HEADERS_srt} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/srt)
+	if (WIN32)
+		install(FILES ${HEADERS_srt_win32} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/srt/win)
+	endif()
 endif()
 
 # ---
@@ -964,7 +1243,7 @@ endif()
 # obtained by `pkg-config --libs`.
 if(ENABLE_CXX_DEPS)
 	foreach(LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES})
-		if(IS_ABSOLUTE ${LIB} AND EXISTS ${LIB})
+		if((IS_ABSOLUTE ${LIB} AND EXISTS ${LIB}) OR (${LIB} MATCHES "^-l"))
 			set(SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} ${LIB})
 		else()
 			set(SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE} "-l${LIB}")
@@ -974,11 +1253,13 @@ endif()
 
 join_arguments(SRT_LIBS_PRIVATE ${SRT_LIBS_PRIVATE})
 
-# haisrt.pc left temporarily for backward compatibility. To be removed in future!
-configure_file(scripts/srt.pc.in haisrt.pc @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/haisrt.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-configure_file(scripts/srt.pc.in srt.pc @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/srt.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+if (DEFINED CMAKE_INSTALL_LIBDIR)
+	# haisrt.pc left temporarily for backward compatibility. To be removed in future!
+	configure_file(scripts/srt.pc.in haisrt.pc @ONLY)
+	install(FILES ${CMAKE_CURRENT_BINARY_DIR}/haisrt.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+	configure_file(scripts/srt.pc.in srt.pc @ONLY)
+	install(FILES ${CMAKE_CURRENT_BINARY_DIR}/srt.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+endif()
 
 # Applications
 
@@ -996,11 +1277,21 @@ else()
 	message(FATAL_ERROR "Either ENABLE_STATIC or ENABLE_SHARED has to be ON!")
 endif()
 
-macro(srt_add_program name)
+macro(srt_add_program_dont_install name)
 	add_executable(${name} ${ARGN})
 	target_include_directories(${name} PRIVATE apps)
 	target_include_directories(${name} PRIVATE common)
-	install(TARGETS ${name} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endmacro()
+
+macro(srt_add_program name)
+	srt_add_program_dont_install(${name} ${ARGN})
+	if(NOT NEED_DESTINATION)
+		install(TARGETS ${name} RUNTIME)
+	elseif (DEFINED CMAKE_INSTALL_BINDIR)
+		install(TARGETS ${name} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+	else()
+		message(WARNING "No location to install program ${name}")
+	endif()
 endmacro()
 
 macro(srt_make_application name)
@@ -1039,7 +1330,13 @@ endmacro()
 macro(srt_add_application name) # ARGN=sources...
 	srt_add_program(${name} apps/${name}.cpp ${ARGN})
 	srt_make_application(${name})
-	install(TARGETS ${name} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+	if(NOT NEED_DESTINATION)
+		install(TARGETS ${name} RUNTIME)
+	elseif (DEFINED CMAKE_INSTALL_BINDIR)
+		install(TARGETS ${name} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+	else()
+		message(WARNING "No location to install program ${name}")
+	endif()
 endmacro()
 
 ## FIXME: transmitmedia.cpp does not build on OpenBSD
@@ -1086,7 +1383,6 @@ if (ENABLE_APPS)
 		# srt-multiplex temporarily blocked
 		#srt_add_application(srt-multiplex ${VIRTUAL_srtsupport})
 		srt_add_application(srt-tunnel ${VIRTUAL_srtsupport})
-		target_compile_definitions(srt-tunnel PUBLIC -DSRT_ENABLE_VERBOSE_LOCK)
 	endif()
 
 	if (ENABLE_TESTING)
@@ -1103,7 +1399,7 @@ if (ENABLE_APPS)
 			# For testing applications, every application has its exclusive
 			# list of source files in its own Manifest file.
 			MafReadDir(testing ${name}.maf SOURCES SOURCES_app)
-			srt_add_program(${name} ${SOURCES_app})
+			srt_add_program_dont_install(${name} ${SOURCES_app})
 		endmacro()
 
 		srt_add_testprogram(utility-test)
@@ -1124,12 +1420,11 @@ if (ENABLE_APPS)
 
 		srt_add_testprogram(srt-test-relay)
 		srt_make_application(srt-test-relay)
-		target_compile_definitions(srt-test-relay PUBLIC -DSRT_ENABLE_VERBOSE_LOCK)
 
 		srt_add_testprogram(srt-test-multiplex)
 		srt_make_application(srt-test-multiplex)
 
-		if (ENABLE_EXPERIMENTAL_BONDING)
+		if (ENABLE_BONDING)
 			srt_add_testprogram(srt-test-mpbond)
 			srt_make_application(srt-test-mpbond)
 		endif()
@@ -1148,41 +1443,56 @@ if (ENABLE_EXAMPLES)
 	# No examples should need C++11
 	macro(srt_add_example mainsrc)
 		get_filename_component(name ${mainsrc} NAME_WE)
-		srt_add_program(${name} examples/${mainsrc} ${ARGN})
+		srt_add_program_dont_install(${name} examples/${mainsrc} ${ARGN})
+		target_link_libraries(${name} ${srt_link_library} ${DEPENDS_srt})
 	endmacro()
 
-	srt_add_example(sendfile.cpp)
-	srt_make_application(sendfile)
+	srt_add_example(recvlive.cpp)
 
+	srt_add_example(sendfile.cpp)
+		
 	srt_add_example(recvfile.cpp)
-	srt_make_application(recvfile)
 
-	srt_add_example(recvlive.cpp)
-	srt_make_application(recvlive)
+	srt_add_example(sendmsg.cpp)
+		
+	srt_add_example(recvmsg.cpp)
 
 	srt_add_example(test-c-client.c)
-	srt_make_application(test-c-client)
+
+	srt_add_example(example-client-nonblock.c)
 
 	srt_add_example(test-c-server.c)
-	srt_make_application(test-c-server)
 
-if (ENABLE_EXPERIMENTAL_BONDING)
+if (ENABLE_BONDING)
 	srt_add_example(test-c-client-bonding.c)
-	srt_make_application(test-c-client-bonding)
 
 	srt_add_example(test-c-server-bonding.c)
-	srt_make_application(test-c-server-bonding)
 endif()
 
 	srt_add_example(testcapi-connect.c)
-	target_link_libraries(testcapi-connect ${srt_link_library} ${DEPENDS_srt})
 endif()
 
 
 if (ENABLE_UNITTESTS AND ENABLE_CXX11)
+
+	if (${CMAKE_VERSION} VERSION_LESS "3.10.0") 
+		message(STATUS "VERSION < 3.10 -- adding test using the old method")
+		set (USE_OLD_ADD_METHOD 1)
+	else()
+		message(STATUS "VERSION > 3.10 -- using NEW POLICY for in_list operator")
+		cmake_policy(SET CMP0057 NEW) # Support the new IN_LIST operator.
+	endif()
+
+
 	set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 
-	find_package(GTest 1.8)
+	# Version ranges are only supported with CMake 3.19 or later.
+	# Need GTest v1.10 or higher to support GTEST_SKIP.
+	if (${CMAKE_VERSION} VERSION_LESS "3.19.0")
+		find_package(GTest 1.10)
+	else()
+		find_package(GTest 1.10...1.12)
+	endif()
 	if (NOT GTEST_FOUND)
 		message(STATUS "GTEST not found! Fetching from git.")
 		include(googletest)
@@ -1194,12 +1504,11 @@ if (ENABLE_UNITTESTS AND ENABLE_CXX11)
 	endif()
 
 	MafReadDir(test filelist.maf
+		HEADERS SOURCES_unittests
 		SOURCES SOURCES_unittests
 	)
-	
-	message(STATUS "Unit test sources: ${SOURCES_unittests}")
 
-	srt_add_program(test-srt ${SOURCES_unittests})
+	srt_add_program_dont_install(test-srt ${SOURCES_unittests})
 	srt_make_application(test-srt)
 	target_include_directories(test-srt PRIVATE  ${SSL_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS})
 
@@ -1210,19 +1519,28 @@ if (ENABLE_UNITTESTS AND ENABLE_CXX11)
 		${PTHREAD_LIBRARY}
 		)
 
-	add_test(
-		NAME
-			test-srt
-		COMMAND
-			${CMAKE_BINARY_DIR}/test-srt
-	)
+	if (USE_OLD_ADD_METHOD)
+		add_test(
+			NAME	test-srt
+			COMMAND	${CMAKE_BINARY_DIR}/test-srt
+		)
+		#set_tests_properties(test-srt PROPERTIES RUN_SERIAL TRUE)
+	else()
+		set_tests_properties(${tests_srt} PROPERTIES RUN_SERIAL TRUE)
+		gtest_discover_tests(test-srt)
+	endif()
 
 	enable_testing()
-
 endif()
 
 
-install(PROGRAMS scripts/srt-ffplay DESTINATION ${CMAKE_INSTALL_BINDIR})
+if(NOT NEED_DESTINATION)
+	install(PROGRAMS scripts/srt-ffplay TYPE BIN)
+elseif (DEFINED CMAKE_INSTALL_BINDIR)
+	install(PROGRAMS scripts/srt-ffplay DESTINATION ${CMAKE_INSTALL_BINDIR})
+else()
+	message(WARNING "No location to install scripts/srt-ffplay")
+endif()
 
 
 if (DEFINED SRT_EXTRA_APPS_INC)
@@ -1230,3 +1548,8 @@ if (DEFINED SRT_EXTRA_APPS_INC)
 	# No extra variables expected. Just use the variables
 	# already provided and define additional targets.
 endif()
+
+if (ENABLE_SHOW_PROJECT_CONFIG)
+	include(ShowProjectConfig)
+	ShowProjectConfig()
+endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b6f226602..239e25a2c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -21,7 +21,7 @@ Submit a pull request at any time, whether an issue has been created or not. It
 * SRT protocol definitions
 * portability and platform-specific parts
 
-Please follow the [Developer's guide](./docs/DevelopersGuide.md).
+Please follow the [SRT Developer's Guide](docs/dev/developers-guide.md).
 
 ## Code Style
 
diff --git a/README.md b/README.md
index 70bcefbb1..0bf810144 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # Secure Reliable Transport (SRT) Protocol
 
+[About SRT](#what-is-srt) | [Features](#features) | [Getting Started](#getting-started-with-srt) | [Build Instructions](#build-instructions) | [Sample Apps and Tools](#sample-applications-and-tools) | [Contribute](#contributing) | [License](#license) | [Releases](#release-history)
+
 <p align="left">
   <a href="http://srtalliance.org/">
     <img alt="SRT" src="http://www.srtalliance.org/wp-content/uploads/SRT_text_hor_logo_grey.png" width="500"/>
@@ -8,127 +10,209 @@
 
 [![License: MPLv2.0][license-badge]](./LICENSE)
 [![Latest release][release-badge]][github releases]
-[![Debian Badge][debian-badge]][debian-package]  
-[![LGTM Code Quality][lgtm-quality-badge]][lgtm-project]
-[![LGTM Alerts][lgtm-alerts-badge]][lgtm-project]
-[![codecov][codecov-badge]][codecov-project]  
+[![Quality Gate Status][sonarcloud-badge]][sonarcloud-project]
+[![codecov][codecov-badge]][codecov-project]
 [![Build Status Linux and macOS][travis-badge]][travis]
 [![Build Status Windows][appveyor-badge]][appveyor]
 
-## Introduction
+[![Ubuntu 23.04][Ubuntu-badge]][Ubuntu-package]
+[![Fedora 37][fedora-badge]][fedora-package]
+[![Debian][debian-badge]][debian-package]
+[![Homebrew][Homebrew-badge]][Homebrew-package]
+[![Vcpkg][Vcpkg-badge]][Vcpkg-package]
+[![ConanCenter][ConanCenter-badge]][ConanCenter-package]
 
-Secure Reliable Transport (SRT) is an open source transport technology that optimizes streaming performance across unpredictable networks, such as the Internet.
 
-|    |    |
-| --- | --- |
-| **S**ecure | Encrypts video streams |
-| **R**eliable | Recovers from severe packet loss |
-| **T**ransport | Dynamically adapts to changing network conditions |
+## What is SRT?
+
+**Secure Reliable Transport (SRT)** is a transport protocol for ultra low (sub-second) latency live video and audio streaming, as well as for generic bulk data transfer[^1]. SRT is available as an open-source technology with the code on GitHub, a published [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01), and a growing [community of SRT users](https://www.srtalliance.org/).
 
 SRT is applied to contribution and distribution endpoints as part of a video stream workflow to deliver the best quality and lowest latency video at all times.
 
-As audio/video packets are streamed from a source to a destination device, SRT detects and adapts to the real-time network conditions between the two endpoints. SRT helps compensate for jitter and bandwidth fluctuations due to congestion over noisy networks, such as the Internet. Its error recovery mechanism minimizes the packet loss typical of Internet connections. And SRT supports AES encryption for end-to-end security, keeping your streams safe from prying eyes.
+|               |                                                   |
+| ------------- | ------------------------------------------------- |
+| **S**ecure    | Encrypts video streams                            |
+| **R**eliable  | Recovers from severe packet loss                  |
+| **T**ransport | Dynamically adapts to changing network conditions |
+
+In live streaming configurations, the SRT protocol maintains a constant end-to-end latency. This allows the live stream's signal characteristics to be recreated on the receiver side, reducing the need for buffering. As packets are streamed from source to destination, SRT detects and adapts to real-time network conditions between the two endpoints. It helps compensate for jitter and bandwidth fluctuations due to congestion over noisy networks.
+
+[SRT implements AES encryption](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-6) to protect the payload of the media streams, and offers various error recovery mechanisms for minimizing the packet loss that is typical of Internet connections, of which Automatic Repeat reQuest (ARQ) is the primary method. With ARQ, when a receiver detects that a packet is missing it sends an alert to the sender requesting retransmission of this missing packet. [Forward Error Correction (FEC)](./docs/features/packet-filtering-and-fec.md) and [Connection Bonding](./docs/features/bonding-quick-start.md), which adds seamless stream protection and hitless failover, are also supported by the protocol.
+
+<p align="right"><em>To learn more about the protocol subscribe to the <a href="https://medium.com/innovation-labs-blog/tagged/secure-reliable-transport">Innovation Labs Blog</a> on &nbsp;<img alt="slack logo" src="https://upload.wikimedia.org/wikipedia/commons/thumb/0/0d/Medium_%28website%29_logo.svg/500px-Medium_%28website%29_logo.svg.png" width="80"></em></p>
+
+<p align="right"><em>To ask a question <a href="https://slackin-srtalliance.azurewebsites.net">join the conversation</a> in the <b>#development</b> channel on &nbsp;<a href="https://srtalliance.slack.com"><img alt="slack logo" src="https://github.com/stevomatthews/srt/blob/master/docs/images/Slack_RGB2.svg" width="60"></a></em></p>
+
+## Features
+
+> :point_down: Click on the &#9658; button to expand a feature description.
+
+<details>
+  <summary>Pristine Quality and Reliability</summary>
+
+  <p>
+
+  No matter how unreliable your network, SRT can recover from severe packet loss and jitter, ensuring the integrity and quality of your video streams.
+
+  </p>
+</details>
+
+<details>
+  <summary>Low Latency</summary>
+
+  <p>
+
+  SRT’s stream error correction is configurable to accommodate a user’s deployment conditions. Leveraging real-time IP communications development to extend traditional network error recovery practices, SRT delivers media with significantly lower latency than TCP/IP, while offering the speed of UDP transmission with greatly improved reliability.
+
+  </p>
+</details>
+
+<details>
+  <summary>Content Agnostic</summary>
+
+  <p>
+
+  Unlike some other streaming protocols that only support specific video and audio formats, SRT is payload agnostic. Because SRT operates at the network transport level, acting as a wrapper around your content, it can transport any type of video format, codec, resolution, or frame rate.
+
+  </p>
+</details>
+
+<details>
+  <summary>Easy Firewall Traversal with Rendezvous Mode</summary>
+
+  <p>
+
+  The handshaking process used by SRT supports outbound connections without the potential risks and dangers of permanent exterior ports being opened in a firewall, thereby maintaining corporate LAN security policies and minimizing the need for IT intervention.
+
+  </p>
+</details>
+
+<details>
+  <summary><a href="https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-6">AES Encryption</a></summary>
 
-[Join the conversation](https://slackin-srtalliance.azurewebsites.net/) in the `#development` channel on [Slack](https://srtalliance.slack.com).
+  <p>
 
-### Guides
+  Using 128/192/256-bit AES encryption trusted by governments and organizations around the world, SRT ensures that valuable content is protected end-to-end from contribution to distribution so that no unauthorized parties can listen.
 
-* [Why SRT Was Created](docs/why-srt-was-created.md)
-* [SRT Protocol Technical Overview](https://github.com/Haivision/srt/files/2489142/SRT_Protocol_TechnicalOverview_DRAFT_2018-10-17.pdf)
-* SRT Cookbook: [website](https://srtlab.github.io/srt-cookbook), [GitHub](https://github.com/SRTLab/srt-cookbook)
-* SRT RFC: [txt](https://haivision.github.io/srt-rfc/draft-sharabayko-mops-srt.txt), [html](https://haivision.github.io/srt-rfc/draft-sharabayko-mops-srt.html), [GitHub](https://github.com/Haivision/srt-rfc)
-* [Using the `srt-live-transmit` App](docs/srt-live-transmit.md)
-* [Contributing](docs/Contributing.md)
-* [Developer's Guide](docs/DevelopersGuide.md)
-* [SRT Encryption](docs/encryption.md)
-* [API](docs/API.md)
-* [Reporting problems](docs/reporting.md)
+  </p>
+</details>
 
-## Requirements
+<details>
+  <summary><a href="./docs/features/packet-filtering-and-fec.md">Forward Error Correction (FEC) and Packet Filter API</a></summary>
 
-* cmake (as build system)
-* Tcl 8.5 (optional for user-friendly build system)
-* OpenSSL
-* Pthreads (for POSIX systems it's builtin, for Windows there's a library)
+  <p>
 
-For detailed description of the build system and options, please read [BuildOptions.md](docs/BuildOptions.md).
+  [SRT 1.4](https://github.com/Haivision/srt/releases/tag/v1.4.0) sees the introduction of the _packet filter API_. This mechanism allows custom processing to be performed on network packets on the sender side before they are sent, and on the receiver side once received from the network. The API allows users to write their own plugin, thereby extending the SRT protocol's capabilities even further with all kinds of different packet filtering. Users can manipulate the resulting packet filter data in any way, such as for custom encryption, packet inspection, or accessing data before it is sent.
 
-### Build on Linux
+  The first plugin created as an example of what can be achieved with the packet filter API is for Forward Error Correction (FEC) which, in certain use cases, can offer slightly lower latency than Automatic Repeat reQuest (ARQ). This plugin allows three different modes:
 
-Install cmake and openssl-devel (or similar name) package. For pthreads
-there should be -lpthreads linker flag added.
+   - ARQ only – retransmits lost packets,
+   - FEC only – provides the overhead needed for FEC recovery on the receiver side,
+   - FEC and ARQ – retransmits lost packets that FEC fails to recover.
 
-Default installation path prefix of `make install` is `/usr/local`.
+  </p>
+</details>
 
-To define a different installation path prefix, use the `--prefix` option with `configure`
-or [`-DCMAKE_INSTALL_PREFIX`](https://cmake.org/cmake/help/v3.0/variable/CMAKE_INSTALL_PREFIX.html) CMake option.
+<details>
+  <summary><a href="./docs/features/bonding-quick-start.md">Connection Bonding</a></summary>
 
-To uninstall, call `make -n install` to list all the dependencies, and then pass the list to `rm`.
+  <p>
 
-#### Ubuntu 14
+  Similar to SMPTE-2022-7 over managed networks, Connection Bonding adds seamless stream protection and hitless failover to the SRT protocol. This technology relies on more than one IP network path to prevent disruption to live video streams in the event of network congestion or outages, maintaining continuity of service.
 
-```shell
-sudo apt-get update
-sudo apt-get upgrade
-sudo apt-get install tclsh pkg-config cmake libssl-dev build-essential
-./configure
-make
-```
+  This is accomplished using the [socket groups](./docs/features/socket-groups.md) introduced in [SRT v1.5](https://github.com/Haivision/srt/releases/tag/v1.5.0). The general concept of socket groups means having a group that contains multiple sockets, where one operation for sending one data signal is applied to the group. Single sockets inside the group will take over this operation and do what is necessary to deliver the signal to the receiver.
 
-#### CentOS 7
+  Two modes are supported:
 
-```shell
-sudo yum update
-sudo yum install tcl pkgconfig openssl-devel cmake gcc gcc-c++ make automake
-./configure
-make
-```
+  - [Broadcast](./docs/features/socket-groups.md#1-broadcast) - In *Broadcast* mode, data is sent redundantly over all the member links in a group. If one of the links fails or experiences network jitter and/or packet loss, the missing data will be received over another link in the group. Redundant packets are simply discarded at the receiver side.
 
-#### CentOS 6
+  - [Main/Backup](./docs/features/bonding-main-backup.md) - In *Main/Backup* mode, only one (main) link at a time is used for data transmission while other (backup) connections are on standby to ensure the transmission will continue if the main link fails. The goal of Main/Backup mode is to identify a potential link break before it happens, thus providing a time window within which to seamlessly switch to one of the backup links.
 
-```shell
-sudo yum update
-sudo yum install tcl pkgconfig openssl-devel cmake gcc gcc-c++ make automake
-sudo yum install centos-release-scl-rh devtoolset-3-gcc devtoolset-3-gcc-c++
-scl enable devtoolset-3 bash
-./configure --use-static-libstdc++ --with-compiler-prefix=/opt/rh/devtoolset-3/root/usr/bin/
-make
-```
+  </p>
+</details>
 
-### Build on Mac (Darwin, iOS)
+<details>
+  <summary><a href="./docs/features/access-control.md">Access Control (Stream ID)</a></summary>
 
-[Homebrew](https://brew.sh/) supports "srt" formula.
+  <p>
 
-```shell
-brew update
-brew install srt
-```
+  Access Control enables the upstream application to assign a Stream ID to individual SRT streams. By using a unique Stream ID, either automatically generated or customized, the upstream application can send multiple SRT streams to a single IP address and UDP port. The Stream IDs can then be used by a receiver to identify and differentiate between ingest streams, apply user password access methods, and in some cases even apply automation based on the naming of the Stream ID. For example, contribution could be sent to a video production workflow and monitoring to a monitoring service.
 
-If you prefer using a head commit of `master` branch, you should add `--HEAD` option
-to `brew` command.
+  For broadcasters, Stream ID is key to replacing RTMP for ingesting video streams, especially HEVC/H.265 content, into cloud service or CDNs that have a single IP socket (address + port) open for incoming video.
 
-```shell
-brew install --HEAD srt
-```
+  </p>
+</details>
 
-Also, SRT can be built with `cmake` and `make` on Mac.
-Install cmake and openssl with development files from "brew". Note that the
-system version of OpenSSL is inappropriate, although you should be able to
-use any newer version compiled from sources, if you prefer.
+## Getting Started with SRT
 
-```shell
-brew install cmake
-brew install openssl
-export OPENSSL_ROOT_DIR=$(brew --prefix openssl)
-export OPENSSL_LIB_DIR=$(brew --prefix openssl)"/lib"
-export OPENSSL_INCLUDE_DIR=$(brew --prefix openssl)"/include"
-./configure
-make
-```
+|                                                                                                                               |                                                                                      |                                                                                   |
+|:-----------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------:|
+| [The SRT API](./docs#srt-api-documents)                                                                                       | [IETF Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) | [Sample Apps](./docs#sample-applications)                                         |
+| Reference documentation for the SRT library API                                                                               | The SRT Protocol Internet Draft                                                      | Instructions for using test apps (`srt-live-transmit`, `srt-file-transmit`, etc.) |
+| [SRT Technical Overview](https://github.com/Haivision/srt/files/2489142/SRT_Protocol_TechnicalOverview_DRAFT_2018-10-17.pdf)  | [SRT Deployment Guide](https://www.srtalliance.org/srt-deployment-guide/)            | [SRT CookBook](https://srtlab.github.io/srt-cookbook)                             |
+| Early draft technical overview (precursor to the Internet Draft)                                                              | A comprehensive overview of the protocol with deployment guidelines                  | Development notes on the SRT protocol                                             |
+| [Innovation Labs Blog](https://medium.com/innovation-labs-blog/tagged/secure-reliable-transport)                              | [SRTLab YouTube Channel](https://www.youtube.com/channel/UCr35JJ32jKKWIYymR1PTdpA)   | [Slack](https://srtalliance.slack.com)                                            |
+| The blog on Medium with SRT-related technical articles                                                                        | Technical YouTube channel with useful videos                                         | Slack channels to get the latest updates and ask questions <br />[Join SRT Alliance on Slack](https://slackin-srtalliance.azurewebsites.net/) |
 
-### Build on Windows
+### Additional Documentation
+
+- [Why SRT?](./docs/misc/why-srt-was-created.md) - A brief history and rationale for SRT by Marc Cymontkowski.
+- [RTMP vs. SRT: Comparing Latency and Maximum Bandwidth](https://www.haivision.com/resources/white-paper/srt-versus-rtmp/) White Paper.
+- [Documentation on GitHub](./docs#documentation-overview) with SRT API documents, features decsriptions, etc.
+- The SRT Protocol Internet Draft: [Datatracker](https://datatracker.ietf.org/doc/draft-sharabayko-srt/) | [Latest Version](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) | [Latest Working Copy](https://haivision.github.io/srt-rfc/draft-sharabayko-srt.html) | [GitHub Repo](https://github.com/Haivision/srt-rfc)
+
+## Build Instructions
+
+[Linux (Ubuntu/CentOS)](./docs/build/build-linux.md) | [Windows](./docs/build/build-win.md) | [macOS](./docs/build/build-macOS.md) | [iOS](./docs/build/build-iOS.md) | [Android](./docs/build/build-android.md) | [Package Managers](./docs/build/package-managers.md)
+
+### Requirements
+
+* C++03 or above compliant compiler.
+* CMake 2.8.12 or above as a build system.
+* OpenSSL 1.1 to enable encryption, otherwise build with [`-DENABLE_ENCRYPTION=OFF`](./docs/build/build-options.md#enable_encryption).
+* Multithreading is provided by either of the following:
+  * C++11: standard library (`std` by [`-DENABLE_STDCXX_SYNC=ON`](./docs/build/build-options.md#enable_stdcxx_sync) CMake option),
+  * C++03: Pthreads (for POSIX systems it's built in, for Windows there is a ported library).
+* Tcl 8.5 is optional and is used by `./configure` script. Otherwise, use CMake directly.
+
+### Build Options
+
+For detailed descriptions of the build system and options, please read the [SRT Build Options](./docs/build/build-options.md) document.
+
+## Sample Applications and Tools
+
+The current repo provides [sample applications](./apps) and [code examples](./examples) that demonstrate the usage of the SRT library API. Among them are [`srt-live-transmit`](./apps/srt-live-transmit.cpp), [`srt-file-transmit`](./apps/srt-file-transmit.cpp), and other applications. The respective documentation can be found [here](./docs#sample-applications). Note that all samples are provided for instructional purposes, and should not be used in a production environment.
+
+The [`srt-xtransmit`](https://github.com/maxsharabayko/srt-xtransmit) utility is actively used for internal testing and performance evaluation. Among other features it supports dummy payload generation, traffic routings, and connection bonding. Additional details are available in the [`srt-xtransmit`](https://github.com/maxsharabayko/srt-xtransmit) repo itself.
+
+Python tools that might be useful during development are:
+
+- [`srt-stats-plotting`](https://github.com/mbakholdina/srt-stats-plotting) - A script designed to plot graphs based on SRT `.csv` statistics.
+- [`lib-tcpdump-processing`](https://github.com/mbakholdina/lib-tcpdump-processing) - A library designed to process `.pcap(ng)` [tcpdump](https://www.tcpdump.org/) or [Wireshark](https://www.wireshark.org/) trace files and extract SRT packets of interest for further analysis.
+- [`lib-srt-utils`](https://github.com/mbakholdina/lib-srt-utils) - A Python library containing supporting code for running SRT tests based on an experiment configuration.
+
+## Contributing
+
+Anyone is welcome to contribute. If you decide to get involved, please take a moment to review the guidelines:
+
+* [SRT Developer's Guide](docs/dev/developers-guide.md)
+* [Contributing](CONTRIBUTING.md)
+* [Reporting Issues](docs/dev/making-srt-better.md)
+
+For information on contributing to the [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) or to submit issues please go to the following [repo](https://github.com/Haivision/srt-rfc). The repo for contributing in [SRT CookBook](https://srtlab.github.io/srt-cookbook/) can be found [here](https://github.com/SRTLab/srt-cookbook/).
+
+## License
+
+By contributing code to the SRT project, you agree to license your contribution under the [MPLv2.0 License](LICENSE).
+
+## Release History
+
+- [Release notes](https://github.com/Haivision/srt/releases)
+- [SRT versioning](./docs/dev/developers-guide.md#versioning)
+
+
+[^1]: The term “live streaming” refers to continuous data transmission (MPEG-TS or equivalent) with latency management. Live streaming based on segmentation and transmission of files like in the HTTP Live Streaming (HLS) protocol (as described in RFC8216) is not part of this use case. File transmission in either message or buffer mode should be considered in this case. See [Section 7. Best Practices and Configuration Tips for Data Transmission via SRT](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-7) of the Internet Draft for details. Note that SRT is content agnostic, meaning that any type of data can be transmitted via its payload.
 
-Follow the [Windows build instructions](docs/build-win.md).
 
 [appveyor-badge]: https://img.shields.io/appveyor/ci/Haivision/srt/master.svg?label=Windows
 [appveyor]: https://ci.appveyor.com/project/Haivision/srt
@@ -136,9 +220,14 @@ Follow the [Windows build instructions](docs/build-win.md).
 [travis]: https://travis-ci.org/Haivision/srt
 [license-badge]: https://img.shields.io/badge/License-MPLv2.0-blue
 
-[lgtm-alerts-badge]: https://img.shields.io/lgtm/alerts/github/Haivision/srt
-[lgtm-quality-badge]: https://img.shields.io/lgtm/grade/cpp/github/Haivision/srt
-[lgtm-project]: https://lgtm.com/projects/g/Haivision/srt/
+[Vcpkg-package]: https://repology.org/project/srt/versions
+[Vcpkg-badge]: https://repology.org/badge/version-for-repo/vcpkg/srt.svg
+
+[ConanCenter-package]: https://repology.org/project/srt/versions
+[ConanCenter-badge]: https://repology.org/badge/version-for-repo/conancenter/srt.svg
+
+[sonarcloud-project]: https://sonarcloud.io/project/overview?id=srt
+[sonarcloud-badge]: https://sonarcloud.io/api/project_badges/measure?project=srt&metric=alert_status
 
 [codecov-project]: https://codecov.io/gh/haivision/srt
 [codecov-badge]: https://codecov.io/gh/haivision/srt/branch/master/graph/badge.svg
@@ -146,5 +235,14 @@ Follow the [Windows build instructions](docs/build-win.md).
 [github releases]: https://github.com/Haivision/srt/releases
 [release-badge]: https://img.shields.io/github/release/Haivision/srt.svg
 
-[debian-badge]: https://badges.debian.net/badges/debian/testing/libsrt1/version.svg
-[debian-package]: https://packages.debian.org/testing/libsrt1
+[debian-badge]: https://badges.debian.net/badges/debian/testing/libsrt1.5-gnutls/version.svg
+[debian-package]: https://packages.debian.org/testing/libs/libsrt1.5-gnutls
+
+[fedora-package]: https://repology.org/project/srt/versions
+[fedora-badge]: https://repology.org/badge/version-for-repo/fedora_37/srt.svg
+
+[homebrew-package]: https://repology.org/project/srt/versions
+[homebrew-badge]: https://repology.org/badge/version-for-repo/homebrew/srt.svg
+
+[Ubuntu-package]: https://repology.org/project/srt/versions
+[Ubuntu-badge]: https://repology.org/badge/version-for-repo/ubuntu_23_04/srt.svg
diff --git a/apps/apputil.cpp b/apps/apputil.cpp
index ecce703e8..22c31521b 100644
--- a/apps/apputil.cpp
+++ b/apps/apputil.cpp
@@ -16,11 +16,13 @@
 #include <utility>
 #include <memory>
 
+#include "srt.h" // Required for SRT_SYNC_CLOCK_* definitions.
 #include "apputil.hpp"
 #include "netinet_any.h"
 #include "srt_compat.h"
 
 using namespace std;
+using namespace srt;
 
 
 // NOTE: MINGW currently does not include support for inet_pton(). See
@@ -47,9 +49,12 @@ int inet_pton(int af, const char * src, void * dst)
    ZeroMemory(&ss, sizeof(ss));
 
    // work around non-const API
-   strncpy(srcCopy, src, INET6_ADDRSTRLEN + 1);
+#ifdef _MSC_VER
+   strncpy_s(srcCopy, INET6_ADDRSTRLEN + 1, src, _TRUNCATE);
+#else
+   strncpy(srcCopy, src, INET6_ADDRSTRLEN);
    srcCopy[INET6_ADDRSTRLEN] = '\0';
-
+#endif
    if (WSAStringToAddress(
       srcCopy, af, NULL, (struct sockaddr *)&ss, &ssSize) != 0)
    {
@@ -205,7 +210,10 @@ options_t ProcessOptions(char* const* argv, int argc, std::vector<OptionScheme>
             isoption = true;
             // If a[0] isn't NUL - because it is dash - then
             // we can safely check a[1].
-            if (a[1] && isdigit(a[1]))
+            // An expression starting with a dash is not
+            // an option marker if it is a single dash or
+            // a negative number.
+            if (!a[1] || isdigit(a[1]))
                 isoption = false;
         }
 
@@ -248,7 +256,7 @@ options_t ProcessOptions(char* const* argv, int argc, std::vector<OptionScheme>
             }
 
             // Find the key in the scheme. If not found, treat it as ARG_NONE.
-            for (auto s: scheme)
+            for (const auto& s: scheme)
             {
                 if (s.names().count(current_key))
                 {
@@ -349,224 +357,35 @@ string OptionHelpItem(const OptionName& o)
     return out;
 }
 
-// Stats module
-
-class SrtStatsJson : public SrtStatsWriter
-{
-public: 
-    string WriteStats(int sid, const CBytePerfMon& mon) override 
-    { 
-        std::ostringstream output;
-        output << "{";
-        output << "\"sid\":" << sid << ",";
-        output << "\"time\":" << mon.msTimeStamp << ",";
-        output << "\"window\":{";
-        output << "\"flow\":" << mon.pktFlowWindow << ",";
-        output << "\"congestion\":" << mon.pktCongestionWindow << ",";    
-        output << "\"flight\":" << mon.pktFlightSize;    
-        output << "},";
-        output << "\"link\":{";
-        output << "\"rtt\":" << mon.msRTT << ",";
-        output << "\"bandwidth\":" << mon.mbpsBandwidth << ",";
-        output << "\"maxBandwidth\":" << mon.mbpsMaxBW;
-        output << "},";
-        output << "\"send\":{";
-        output << "\"packets\":" << mon.pktSent << ",";
-        output << "\"packetsUnique\":" << mon.pktSentUnique << ",";
-        output << "\"packetsLost\":" << mon.pktSndLoss << ",";
-        output << "\"packetsDropped\":" << mon.pktSndDrop << ",";
-        output << "\"packetsRetransmitted\":" << mon.pktRetrans << ",";
-        output << "\"packetsFilterExtra\":" << mon.pktSndFilterExtra << ",";
-        output << "\"bytes\":" << mon.byteSent << ",";
-        output << "\"bytesUnique\":" << mon.byteSentUnique << ",";
-        output << "\"bytesDropped\":" << mon.byteSndDrop << ",";
-        output << "\"mbitRate\":" << mon.mbpsSendRate;
-        output << "},";
-        output << "\"recv\": {";
-        output << "\"packets\":" << mon.pktRecv << ",";
-        output << "\"packetsUnique\":" << mon.pktRecvUnique << ",";
-        output << "\"packetsLost\":" << mon.pktRcvLoss << ",";
-        output << "\"packetsDropped\":" << mon.pktRcvDrop << ",";
-        output << "\"packetsRetransmitted\":" << mon.pktRcvRetrans << ",";
-        output << "\"packetsBelated\":" << mon.pktRcvBelated << ",";
-        output << "\"packetsFilterExtra\":" << mon.pktRcvFilterExtra << ",";
-        output << "\"packetsFilterSupply\":" << mon.pktRcvFilterSupply << ",";
-        output << "\"packetsFilterLoss\":" << mon.pktRcvFilterLoss << ",";
-        output << "\"bytes\":" << mon.byteRecv << ",";
-        output << "\"bytesUnique\":" << mon.byteRecvUnique << ",";
-        output << "\"bytesLost\":" << mon.byteRcvLoss << ",";
-        output << "\"bytesDropped\":" << mon.byteRcvDrop << ",";
-        output << "\"mbitRate\":" << mon.mbpsRecvRate;
-        output << "}";
-        output << "}" << endl;
-        return output.str();
-    } 
-
-    string WriteBandwidth(double mbpsBandwidth) override 
-    {
-        std::ostringstream output;
-        output << "{\"bandwidth\":" << mbpsBandwidth << '}' << endl;
-        return output.str();
-    }
-};
-
-class SrtStatsCsv : public SrtStatsWriter
-{
-private:
-    bool first_line_printed;
-
-public: 
-    SrtStatsCsv() : first_line_printed(false) {}
-
-    string WriteStats(int sid, const CBytePerfMon& mon) override
-    {
-        // Note: std::put_time is supported only in GCC 5 and higher
-#if !defined(__GNUC__) || defined(__clang__) || (__GNUC__ >= 5)
-#define HAS_PUT_TIME
-#endif
-        std::ostringstream output;
-        if (!first_line_printed)
-        {
-#ifdef HAS_PUT_TIME
-            output << "Timepoint,";
-#endif
-            output << "Time,SocketID,pktFlowWindow,pktCongestionWindow,pktFlightSize,";
-            output << "msRTT,mbpsBandwidth,mbpsMaxBW,pktSent,pktSndLoss,pktSndDrop,";
-            output << "pktRetrans,byteSent,byteSndDrop,mbpsSendRate,usPktSndPeriod,";
-            output << "pktRecv,pktRcvLoss,pktRcvDrop,pktRcvRetrans,pktRcvBelated,";
-            output << "byteRecv,byteRcvLoss,byteRcvDrop,mbpsRecvRate,RCVLATENCYms,";
-            // Filter stats
-            output << "pktSndFilterExtra,pktRcvFilterExtra,pktRcvFilterSupply,pktRcvFilterLoss";
-            output << endl;
-            first_line_printed = true;
-        }
-        int rcv_latency = 0;
-        int int_len     = sizeof rcv_latency;
-        srt_getsockopt(sid, 0, SRTO_RCVLATENCY, &rcv_latency, &int_len);
-
-#ifdef HAS_PUT_TIME
-        // Follows ISO 8601
-        auto print_timestamp = [&output]() {
-            using namespace std;
-            using namespace std::chrono;
-
-            const auto   systime_now = system_clock::now();
-            const time_t time_now    = system_clock::to_time_t(systime_now);
-
-            // SysLocalTime returns zeroed tm_now on failure, which is ok for put_time.
-            const tm tm_now = SysLocalTime(time_now);
-            output << std::put_time(&tm_now, "%FT%T.") << std::setfill('0') << std::setw(6);
-            const auto    since_epoch = systime_now.time_since_epoch();
-            const seconds s           = duration_cast<seconds>(since_epoch);
-            output << duration_cast<microseconds>(since_epoch - s).count();
-            output << std::put_time(&tm_now, "%z");
-            output << ",";
-        };
-
-        print_timestamp();
-#endif // HAS_PUT_TIME
-
-        output << mon.msTimeStamp << ",";
-        output << sid << ",";
-        output << mon.pktFlowWindow << ",";
-        output << mon.pktCongestionWindow << ",";
-        output << mon.pktFlightSize << ",";
-        output << mon.msRTT << ",";
-        output << mon.mbpsBandwidth << ",";
-        output << mon.mbpsMaxBW << ",";
-        output << mon.pktSent << ",";
-        output << mon.pktSndLoss << ",";
-        output << mon.pktSndDrop << ",";
-        output << mon.pktRetrans << ",";
-        output << mon.byteSent << ",";
-        output << mon.byteSndDrop << ",";
-        output << mon.mbpsSendRate << ",";
-        output << mon.usPktSndPeriod << ",";
-        output << mon.pktRecv << ",";
-        output << mon.pktRcvLoss << ",";
-        output << mon.pktRcvDrop << ",";
-        output << mon.pktRcvRetrans << ",";
-        output << mon.pktRcvBelated << ",";
-        output << mon.byteRecv << ",";
-        output << mon.byteRcvLoss << ",";
-        output << mon.byteRcvDrop << ",";
-        output << mon.mbpsRecvRate << ",";
-        output << rcv_latency << ",";
-        // Filter stats
-        output << mon.pktSndFilterExtra << ",";
-        output << mon.pktRcvFilterExtra << ",";
-        output << mon.pktRcvFilterSupply << ",";
-        output << mon.pktRcvFilterLoss; //<< ",";
-        output << endl;
-        return output.str();
-    }
-
-    string WriteBandwidth(double mbpsBandwidth) override
-    {
-        std::ostringstream output;
-        output << "+++/+++SRT BANDWIDTH: " << mbpsBandwidth << endl;
-        return output.str();
-    }
-};
-
-class SrtStatsCols : public SrtStatsWriter
+const char* SRTClockTypeStr()
 {
-public: 
-    string WriteStats(int sid, const CBytePerfMon& mon) override 
-    { 
-        std::ostringstream output;
-        output << "======= SRT STATS: sid=" << sid << endl;
-        output << "PACKETS     SENT: " << setw(11) << mon.pktSent            << "  RECEIVED:   " << setw(11) << mon.pktRecv              << endl;
-        output << "LOST PKT    SENT: " << setw(11) << mon.pktSndLoss         << "  RECEIVED:   " << setw(11) << mon.pktRcvLoss           << endl;
-        output << "REXMIT      SENT: " << setw(11) << mon.pktRetrans         << "  RECEIVED:   " << setw(11) << mon.pktRcvRetrans        << endl;
-        output << "DROP PKT    SENT: " << setw(11) << mon.pktSndDrop         << "  RECEIVED:   " << setw(11) << mon.pktRcvDrop           << endl;
-        output << "FILTER EXTRA  TX: " << setw(11) << mon.pktSndFilterExtra  << "        RX:   " << setw(11) << mon.pktRcvFilterExtra    << endl;
-        output << "FILTER RX  SUPPL: " << setw(11) << mon.pktRcvFilterSupply << "  RX  LOSS:   " << setw(11) << mon.pktRcvFilterLoss     << endl;
-        output << "RATE     SENDING: " << setw(11) << mon.mbpsSendRate       << "  RECEIVING:  " << setw(11) << mon.mbpsRecvRate         << endl;
-        output << "BELATED RECEIVED: " << setw(11) << mon.pktRcvBelated      << "  AVG TIME:   " << setw(11) << mon.pktRcvAvgBelatedTime << endl;
-        output << "REORDER DISTANCE: " << setw(11) << mon.pktReorderDistance << endl;
-        output << "WINDOW      FLOW: " << setw(11) << mon.pktFlowWindow      << "  CONGESTION: " << setw(11) << mon.pktCongestionWindow  << "  FLIGHT: " << setw(11) << mon.pktFlightSize << endl;
-        output << "LINK         RTT: " << setw(9)  << mon.msRTT            << "ms  BANDWIDTH:  " << setw(7)  << mon.mbpsBandwidth    << "Mb/s " << endl;
-        output << "BUFFERLEFT:  SND: " << setw(11) << mon.byteAvailSndBuf    << "  RCV:        " << setw(11) << mon.byteAvailRcvBuf      << endl;
-        return output.str();
-    } 
-
-    string WriteBandwidth(double mbpsBandwidth) override 
-    {
-        std::ostringstream output;
-        output << "+++/+++SRT BANDWIDTH: " << mbpsBandwidth << endl;
-        return output.str();
-    }
-};
+    const int clock_type = srt_clock_type();
 
-shared_ptr<SrtStatsWriter> SrtStatsWriterFactory(SrtStatsPrintFormat printformat)
-{
-    switch (printformat)
+    switch (clock_type)
     {
-    case SRTSTATS_PROFMAT_JSON:
-        return make_shared<SrtStatsJson>();
-    case SRTSTATS_PROFMAT_CSV:
-        return make_shared<SrtStatsCsv>();
-    case SRTSTATS_PROFMAT_2COLS:
-        return make_shared<SrtStatsCols>();
+    case SRT_SYNC_CLOCK_STDCXX_STEADY:
+        return "CXX11_STEADY";
+    case SRT_SYNC_CLOCK_GETTIME_MONOTONIC:
+        return "GETTIME_MONOTONIC";
+    case SRT_SYNC_CLOCK_WINQPC:
+        return "WIN_QPC";
+    case SRT_SYNC_CLOCK_MACH_ABSTIME:
+        return "MACH_ABSTIME";
+    case SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY:
+        return "POSIX_GETTIMEOFDAY";
     default:
         break;
     }
-    return nullptr;
+    
+    return "UNKNOWN VALUE";
 }
 
-SrtStatsPrintFormat ParsePrintFormat(string pf)
+void PrintLibVersion()
 {
-    if (pf == "default")
-        return SRTSTATS_PROFMAT_2COLS;
-
-    if (pf == "json")
-        return SRTSTATS_PROFMAT_JSON;
-
-    if (pf == "csv")
-        return SRTSTATS_PROFMAT_CSV;
-
-    return SRTSTATS_PROFMAT_INVALID;
+    cerr << "Built with SRT Library version: " << SRT_VERSION  << endl;
+    const uint32_t srtver = srt_getversion();
+    const int major = srtver / 0x10000;
+    const int minor = (srtver / 0x100) % 0x100;
+    const int patch = srtver % 0x100;
+    cerr << "SRT Library version: " << major << "." << minor << "." << patch << ", clock type: " << SRTClockTypeStr() << endl;
 }
-
-
diff --git a/apps/apputil.hpp b/apps/apputil.hpp
index 1c8f4a0bb..1a0b158e0 100644
--- a/apps/apputil.hpp
+++ b/apps/apputil.hpp
@@ -19,6 +19,8 @@
 #include <memory>
 
 #include "netinet_any.h"
+#include "utilities.h"
+#include "srt.h"
 
 #if _WIN32
 
@@ -57,23 +59,51 @@ inline void SysCleanupNetwork()
 #include <arpa/inet.h>
 #include <unistd.h>
 
+// Fixes Android build on NDK r16b and earlier.
+#if defined(__ANDROID__) && (__ANDROID__ == 1)
+   #include <android/ndk-version.h>
+   #if !defined(__NDK_MAJOR__) || (__NDK_MAJOR__ <= 16)
+      struct ip_mreq_sourceFIXED {
+        struct in_addr imr_multiaddr;
+        struct in_addr imr_interface;
+        struct in_addr imr_sourceaddr;
+      };
+      #define ip_mreq_source ip_mreq_sourceFIXED
+   #endif
+#endif
+
 // Nothing needs to be done on POSIX; this is a Windows problem.
 inline bool SysInitializeNetwork() {return true;}
 inline void SysCleanupNetwork() {}
 
 #endif
 
-#include "srt.h" // Required for stats module
-
 #ifdef _WIN32
 inline int SysError() { return ::GetLastError(); }
+const int SysAGAIN = WSAEWOULDBLOCK;
 #else
 inline int SysError() { return errno; }
+const int SysAGAIN = EAGAIN;
 #endif
 
-sockaddr_any CreateAddr(const std::string& name, unsigned short port = 0, int pref_family = AF_UNSPEC);
+srt::sockaddr_any CreateAddr(const std::string& name, unsigned short port = 0, int pref_family = AF_UNSPEC);
 std::string Join(const std::vector<std::string>& in, std::string sep);
 
+template <class VarType, class ValType>
+struct OnReturnSetter
+{
+    VarType& var;
+    ValType value;
+
+    OnReturnSetter(VarType& target, ValType v): var(target), value(v) {}
+    ~OnReturnSetter() { var = value; }
+};
+
+template <class VarType, class ValType>
+OnReturnSetter<VarType, ValType> OnReturnSet(VarType& target, ValType v)
+{ return OnReturnSetter<VarType, ValType>(target, v); }
+
+// ---- OPTIONS MODULE
 
 inline bool CheckTrue(const std::vector<std::string>& in)
 {
@@ -181,15 +211,15 @@ struct OptionScheme
     enum Args { ARG_NONE, ARG_ONE, ARG_VAR } type;
 
     OptionScheme(const OptionScheme&) = default;
-	OptionScheme(OptionScheme&& src)
-		: pid(src.pid)
-		, type(src.type)
-	{
-	}
+    OptionScheme(OptionScheme&& src)
+        : pid(src.pid)
+        , type(src.type)
+    {
+    }
 
     OptionScheme(const OptionName& id, Args tp);
 
-	const std::set<std::string>& names();
+    const std::set<std::string>& names() const;
 };
 
 struct OptionName
@@ -234,7 +264,7 @@ struct OptionName
 };
 
 inline OptionScheme::OptionScheme(const OptionName& id, Args tp): pid(&id), type(tp) {}
-inline const std::set<std::string>& OptionScheme::names() { return pid->names; }
+inline const std::set<std::string>& OptionScheme::names() const { return pid->names; }
 
 template <class OutType, class OutValue> inline
 typename OutType::type Option(const options_t&, OutValue deflt=OutValue()) { return deflt; }
@@ -304,27 +334,63 @@ inline bool OptionPresent(const options_t& options, const std::set<std::string>&
 options_t ProcessOptions(char* const* argv, int argc, std::vector<OptionScheme> scheme);
 std::string OptionHelpItem(const OptionName& o);
 
-// Statistics module
+const char* SRTClockTypeStr();
+void PrintLibVersion();
 
-enum SrtStatsPrintFormat
-{
-    SRTSTATS_PROFMAT_INVALID = -1,
-    SRTSTATS_PROFMAT_2COLS = 0,
-    SRTSTATS_PROFMAT_JSON,
-    SRTSTATS_PROFMAT_CSV
-};
 
-SrtStatsPrintFormat ParsePrintFormat(std::string pf);
+namespace srt
+{
 
-class SrtStatsWriter
+struct OptionSetterProxy
 {
-public:
-    virtual std::string WriteStats(int sid, const CBytePerfMon& mon) = 0;
-    virtual std::string WriteBandwidth(double mbpsBandwidth) = 0;
-    virtual ~SrtStatsWriter() { };
-};
+    SRTSOCKET s;
+    int result = -1;
+
+    OptionSetterProxy(SRTSOCKET ss): s(ss) {}
+
+    struct OptionProxy
+    {
+        OptionSetterProxy& parent;
+        SRT_SOCKOPT opt;
+
+#define SPEC(type) \
+        OptionProxy& operator=(const type& val)\
+        {\
+            parent.result = srt_setsockflag(parent.s, opt, &val, sizeof val);\
+            return *this;\
+        }
+
+        SPEC(int32_t);
+        SPEC(int64_t);
+        SPEC(bool);
+#undef SPEC
+
+        template<size_t N>
+        OptionProxy& operator=(const char (&val)[N])
+        {
+            parent.result = srt_setsockflag(parent.s, opt, val, N-1);
+            return *this;
+        }
+
+        OptionProxy& operator=(const std::string& val)
+        {
+            parent.result = srt_setsockflag(parent.s, opt, val.c_str(), val.size());
+            return *this;
+        }
+    };
+
+    OptionProxy operator[](SRT_SOCKOPT opt)
+    {
+        return OptionProxy {*this, opt};
+    }
 
-std::shared_ptr<SrtStatsWriter> SrtStatsWriterFactory(SrtStatsPrintFormat printformat);
+    operator int() { return result; }
+};
 
+inline OptionSetterProxy setopt(SRTSOCKET socket)
+{
+    return OptionSetterProxy(socket);
+}
 
+}
 #endif // INC_SRT_APPCOMMON_H
diff --git a/apps/logsupport.cpp b/apps/logsupport.cpp
index 2acbf64cc..fbd70c47e 100644
--- a/apps/logsupport.cpp
+++ b/apps/logsupport.cpp
@@ -171,4 +171,35 @@ set<srt_logging::LogFA> SrtParseLogFA(string fa, set<string>* punknown)
     return fas;
 }
 
+void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
+{
+    std::ostringstream son, soff;
+
+    for (auto& s: speclist)
+    {
+        string name;
+        bool on = true;
+        if (s[0] == '+')
+            name = s.substr(1);
+        else if (s[0] == '~')
+        {
+            name = s.substr(1);
+            on = false;
+        }
+        else
+            name = s;
+
+        if (on)
+            son << "," << name;
+        else
+            soff << "," << name;
+    }
+
+    const string& sons = son.str();
+    const string& soffs = soff.str();
+
+    w_on = sons.empty() ? string() : sons.substr(1);
+    w_off = soffs.empty() ? string() : soffs.substr(1);
+}
+
 
diff --git a/apps/logsupport.hpp b/apps/logsupport.hpp
index 63e732560..79115d726 100644
--- a/apps/logsupport.hpp
+++ b/apps/logsupport.hpp
@@ -13,11 +13,13 @@
 
 #include <string>
 #include <map>
+#include <vector>
 #include "../srtcore/srt.h"
 #include "../srtcore/logging_api.h"
 
 srt_logging::LogLevel::type SrtParseLogLevel(std::string level);
 std::set<srt_logging::LogFA> SrtParseLogFA(std::string fa, std::set<std::string>* punknown = nullptr);
+void ParseLogFASpec(const std::vector<std::string>& speclist, std::string& w_on, std::string& w_off);
 const std::map<std::string, int> SrtLogFAList();
 
 SRT_API extern std::map<std::string, int> srt_level_names;
diff --git a/apps/socketoptions.cpp b/apps/socketoptions.cpp
index 31825ecb6..68df7291e 100644
--- a/apps/socketoptions.cpp
+++ b/apps/socketoptions.cpp
@@ -102,7 +102,7 @@ SocketOption::Mode SrtConfigurePre(SRTSOCKET socket, string host, map<string, st
 
 
     bool all_clear = true;
-    for (auto o: srt_options)
+    for (const auto &o: srt_options)
     {
         if ( o.binding == SocketOption::PRE && options.count(o.name) )
         {
@@ -124,7 +124,7 @@ void SrtConfigurePost(SRTSOCKET socket, map<string, string> options, vector<stri
     vector<string> dummy;
     vector<string>& fails = failures ? *failures : dummy;
 
-    for (auto o: srt_options)
+    for (const auto &o: srt_options)
     {
         if ( o.binding == SocketOption::POST && options.count(o.name) )
         {
diff --git a/apps/socketoptions.hpp b/apps/socketoptions.hpp
index 6f6305b4c..b8aa67b86 100644
--- a/apps/socketoptions.hpp
+++ b/apps/socketoptions.hpp
@@ -70,7 +70,7 @@ inline int SocketOption::setso<SocketOption::SRT, int>(int socket, int /*ignored
     return srt_setsockopt(socket, 0, SRT_SOCKOPT(sym), data, (int) size);
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 template<>
 inline int SocketOption::setso<SocketOption::SRT, SRT_SOCKOPT_CONFIG*>(SRT_SOCKOPT_CONFIG* obj, int /*ignored*/, int sym, const void* data, size_t size)
 {
@@ -211,7 +211,7 @@ extern const std::map<std::string, int> enummap_transtype;
 namespace {
 const SocketOption srt_options [] {
     { "transtype", 0, SRTO_TRANSTYPE, SocketOption::PRE, SocketOption::ENUM, &enummap_transtype },
-    { "maxbw", 0, SRTO_MAXBW, SocketOption::PRE, SocketOption::INT64, nullptr},
+    { "maxbw", 0, SRTO_MAXBW, SocketOption::POST, SocketOption::INT64, nullptr},
     { "pbkeylen", 0, SRTO_PBKEYLEN, SocketOption::PRE, SocketOption::INT, nullptr},
     { "passphrase", 0, SRTO_PASSPHRASE, SocketOption::PRE, SocketOption::STRING, nullptr},
 
@@ -224,6 +224,7 @@ const SocketOption srt_options [] {
     { "ipttl", 0, SRTO_IPTTL, SocketOption::PRE, SocketOption::INT, nullptr},
     { "iptos", 0, SRTO_IPTOS, SocketOption::PRE, SocketOption::INT, nullptr},
     { "inputbw", 0, SRTO_INPUTBW, SocketOption::POST, SocketOption::INT64, nullptr},
+    { "mininputbw", 0, SRTO_MININPUTBW, SocketOption::POST, SocketOption::INT64, nullptr},
     { "oheadbw", 0, SRTO_OHEADBW, SocketOption::POST, SocketOption::INT, nullptr},
     { "latency", 0, SRTO_LATENCY, SocketOption::PRE, SocketOption::INT, nullptr},
     { "tsbpdmode", 0, SRTO_TSBPDMODE, SocketOption::PRE, SocketOption::BOOL, nullptr},
@@ -232,7 +233,7 @@ const SocketOption srt_options [] {
     { "nakreport", 0, SRTO_NAKREPORT, SocketOption::PRE, SocketOption::BOOL, nullptr},
     { "conntimeo", 0, SRTO_CONNTIMEO, SocketOption::PRE, SocketOption::INT, nullptr},
     { "drifttracer", 0, SRTO_DRIFTTRACER, SocketOption::POST, SocketOption::BOOL, nullptr},
-    { "lossmaxttl", 0, SRTO_LOSSMAXTTL, SocketOption::PRE, SocketOption::INT, nullptr},
+    { "lossmaxttl", 0, SRTO_LOSSMAXTTL, SocketOption::POST, SocketOption::INT, nullptr},
     { "rcvlatency", 0, SRTO_RCVLATENCY, SocketOption::PRE, SocketOption::INT, nullptr},
     { "peerlatency", 0, SRTO_PEERLATENCY, SocketOption::PRE, SocketOption::INT, nullptr},
     { "minversion", 0, SRTO_MINVERSION, SocketOption::PRE, SocketOption::INT, nullptr},
@@ -246,16 +247,20 @@ const SocketOption srt_options [] {
     { "ipv6only", 0, SRTO_IPV6ONLY, SocketOption::PRE, SocketOption::INT, nullptr },
     { "peeridletimeo", 0, SRTO_PEERIDLETIMEO, SocketOption::PRE, SocketOption::INT, nullptr },
     { "packetfilter", 0, SRTO_PACKETFILTER, SocketOption::PRE, SocketOption::STRING, nullptr },
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     { "groupconnect", 0, SRTO_GROUPCONNECT, SocketOption::PRE, SocketOption::INT, nullptr},
+    { "groupminstabletimeo", 0, SRTO_GROUPMINSTABLETIMEO, SocketOption::PRE, SocketOption::INT, nullptr},
 #endif
 #ifdef SRT_ENABLE_BINDTODEVICE
     { "bindtodevice", 0, SRTO_BINDTODEVICE, SocketOption::PRE, SocketOption::STRING, nullptr},
-#endif
-#if ENABLE_EXPERIMENTAL_BONDING
-    { "groupstabtimeo", 0, SRTO_GROUPSTABTIMEO, SocketOption::PRE, SocketOption::INT, nullptr},
 #endif
     { "retransmitalgo", 0, SRTO_RETRANSMITALGO, SocketOption::PRE, SocketOption::INT, nullptr }
+#ifdef ENABLE_AEAD_API_PREVIEW
+    ,{ "cryptomode", 0, SRTO_CRYPTOMODE, SocketOption::PRE, SocketOption::INT, nullptr }
+#endif
+#ifdef ENABLE_MAXREXMITBW
+    ,{ "maxrexmitbw", 0, SRTO_MAXREXMITBW, SocketOption::POST, SocketOption::INT64, nullptr }
+#endif
 };
 }
 
diff --git a/apps/srt-file-transmit.cpp b/apps/srt-file-transmit.cpp
index 521060cb5..327ad6809 100644
--- a/apps/srt-file-transmit.cpp
+++ b/apps/srt-file-transmit.cpp
@@ -52,7 +52,6 @@ void OnINT_ForceExit(int)
     interrupt = true;
 }
 
-
 struct FileTransmitConfig
 {
     unsigned long chunk_size;
@@ -144,12 +143,7 @@ int parse_args(FileTransmitConfig &cfg, int argc, char** argv)
     if (print_help)
     {
         cout << "SRT sample application to transmit files.\n";
-        cerr << "Built with SRT Library version: " << SRT_VERSION << endl;
-        const uint32_t srtver = srt_getversion();
-        const int major = srtver / 0x10000;
-        const int minor = (srtver / 0x100) % 0x100;
-        const int patch = srtver % 0x100;
-        cerr << "SRT Library version: " << major << "." << minor << "." << patch << endl;
+        PrintLibVersion();
         cerr << "Usage: srt-file-transmit [options] <input-uri> <output-uri>\n";
         cerr << "\n";
 
@@ -182,7 +176,7 @@ int parse_args(FileTransmitConfig &cfg, int argc, char** argv)
 
     if (Option<OutBool>(params, false, o_version))
     {
-        cerr << "SRT Library version: " << SRT_VERSION << endl;
+        PrintLibVersion();
         return 2;
     }
 
@@ -321,7 +315,7 @@ bool DoUpload(UriParser& ut, string path, string filename,
                     << tar->GetSRTSocket() << endl;
                 goto exit;
             }
-            UDT::setstreamid(tar->GetSRTSocket(), filename);
+            srt::setstreamid(tar->GetSRTSocket(), filename);
         }
 
         s = tar->GetSRTSocket();
@@ -449,7 +443,7 @@ bool DoUpload(UriParser& ut, string path, string filename,
             }
             Verb() << "Sending buffer still: bytes=" << bytes << " blocks="
                 << blocks;
-            this_thread::sleep_for(chrono::milliseconds(250));
+            srt::sync::this_thread::sleep_for(srt::sync::milliseconds_from(250));
         }
     }
 
@@ -539,7 +533,7 @@ bool DoDownload(UriParser& us, string directory, string filename,
                     cerr << "Failed to add SRT client to poll" << endl;
                     goto exit;
                 }
-                id = UDT::getstreamid(s);
+                id = srt::getstreamid(s);
                 cerr << "Source connected (listener), id ["
                     << id << "]" << endl;
                 connected = true;
@@ -550,14 +544,21 @@ bool DoDownload(UriParser& us, string directory, string filename,
             {
                 if (!connected)
                 {
-                    id = UDT::getstreamid(s);
+                    id = srt::getstreamid(s);
                     cerr << "Source connected (caller), id ["
                         << id << "]" << endl;
                     connected = true;
                 }
             }
             break;
+
+            // No need to do any special action in case of broken.
+            // The app will just try to read and in worst case it will
+            // get an error.
             case SRTS_BROKEN:
+            cerr << "Connection closed, reading buffer remains\n";
+            break;
+
             case SRTS_NONEXIST:
             case SRTS_CLOSED:
             {
@@ -601,7 +602,7 @@ bool DoDownload(UriParser& us, string directory, string filename,
             if (n == 0)
             {
                 result = true;
-                cerr << "Download COMPLETE.";
+                cerr << "Download COMPLETE.\n";
                 break;
             }
 
@@ -707,7 +708,7 @@ int main(int argc, char** argv)
         }
         else
         {
-            UDT::setlogstream(logfile_stream);
+            srt::setlogstream(logfile_stream);
         }
     }
 
diff --git a/apps/srt-live-transmit.cpp b/apps/srt-live-transmit.cpp
index b1ec637e9..0a918e6b0 100644
--- a/apps/srt-live-transmit.cpp
+++ b/apps/srt-live-transmit.cpp
@@ -65,7 +65,7 @@
 #include <thread>
 #include <list>
 
-
+#include "srt_compat.h"
 #include "apputil.hpp"  // CreateAddr
 #include "uriparser.hpp"  // UriParser
 #include "socketoptions.hpp"
@@ -100,8 +100,8 @@ struct AlarmExit: public std::runtime_error
     }
 };
 
-volatile bool int_state = false;
-volatile bool timer_state = false;
+srt::sync::atomic<bool> int_state;
+srt::sync::atomic<bool> timer_state;
 void OnINT_ForceExit(int)
 {
     Verb() << "\n-------- REQUESTED INTERRUPT!\n";
@@ -164,7 +164,6 @@ void PrintOptionHelp(const OptionName& opt_names, const string &value, const str
     cerr << "\t- " << desc << "\n";
 }
 
-
 int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
 {
     const OptionName
@@ -269,12 +268,7 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
         }
 
         cout << "SRT sample application to transmit live streaming.\n";
-        cerr << "Built with SRT Library version: " << SRT_VERSION << endl;
-        const uint32_t srtver = srt_getversion();
-        const int major = srtver / 0x10000;
-        const int minor = (srtver / 0x100) % 0x100;
-        const int patch = srtver % 0x100;
-        cerr << "SRT Library version: " << major << "." << minor << "." << patch << endl;
+        PrintLibVersion();
         cerr << "Usage: srt-live-transmit [options] <input-uri> <output-uri>\n";
         cerr << "\n";
 #ifndef _WIN32
@@ -290,7 +284,7 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
         PrintOptionHelp(o_statsout,  "<filename>", "output stats to file");
         PrintOptionHelp(o_statspf,   "<format=default>", "stats printing format {json, csv, default}");
         PrintOptionHelp(o_statsfull, "", "full counters in stats-report (prints total statistics)");
-        PrintOptionHelp(o_loglevel,  "<level=error>", "log level {fatal,error,info,note,warning}");
+        PrintOptionHelp(o_loglevel,  "<level=warn>", "log level {fatal,error,warn,note,info,debug}");
         PrintOptionHelp(o_logfa,     "<fas>", "log functional area (see '-h logging' for more info)");
         //PrintOptionHelp(o_log_internal, "", "use internal logger");
         PrintOptionHelp(o_logfile, "<filename="">", "write logs to file");
@@ -313,7 +307,7 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
 
     if (print_version)
     {
-        cerr << "SRT Library version: " <<  SRT_VERSION << endl;
+        PrintLibVersion();
         return 2;
     }
 
@@ -335,7 +329,8 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
     cfg.stats_report = Option<OutNumber>(params, o_statsrep);
     cfg.stats_out    = Option<OutString>(params, o_statsout);
     const string pf  = Option<OutString>(params, "default", o_statspf);
-    cfg.stats_pf     = ParsePrintFormat(pf);
+    string pfext;
+    cfg.stats_pf     = ParsePrintFormat(pf, (pfext));
     if (cfg.stats_pf == SRTSTATS_PROFMAT_INVALID)
     {
         cfg.stats_pf = SRTSTATS_PROFMAT_2COLS;
@@ -344,7 +339,7 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
     }
 
     cfg.full_stats   = OptionPresent(params, o_statsfull);
-    cfg.loglevel     = SrtParseLogLevel(Option<OutString>(params, "error", o_loglevel));
+    cfg.loglevel     = SrtParseLogLevel(Option<OutString>(params, "warn", o_loglevel));
     cfg.logfas       = SrtParseLogFA(Option<OutString>(params, "", o_logfa));
     cfg.log_internal = OptionPresent(params, o_log_internal);
     cfg.logfile      = Option<OutString>(params, o_logfile);
@@ -433,7 +428,7 @@ int main(int argc, char** argv)
         }
         else
         {
-            UDT::setlogstream(logfile_stream);
+            srt::setlogstream(logfile_stream);
         }
     }
 
@@ -531,11 +526,13 @@ int main(int argc, char** argv)
                     }
                     break;
                 case UriParser::UDP:
+                case UriParser::RTP:
                     if (srt_epoll_add_ssock(pollid,
                         src->GetSysSocket(), &events))
                     {
-                        cerr << "Failed to add UDP source to poll, "
-                            << src->GetSysSocket() << endl;
+                        cerr << "Failed to add " << src->uri.proto()
+                            << " source to poll, " << src->GetSysSocket()
+                            << endl;
                         return 1;
                     }
                     break;
@@ -857,8 +854,14 @@ int main(int argc, char** argv)
 void TestLogHandler(void* opaque, int level, const char* file, int line, const char* area, const char* message)
 {
     char prefix[100] = "";
-    if ( opaque )
-        strncpy(prefix, (char*)opaque, 99);
+    if ( opaque ) {
+#ifdef _MSC_VER
+        strncpy_s(prefix, sizeof(prefix), (char*)opaque, _TRUNCATE);
+#else
+        strncpy(prefix, (char*)opaque, sizeof(prefix) - 1);
+        prefix[sizeof(prefix) - 1] = '\0';
+#endif
+    }
     time_t now;
     time(&now);
     char buf[1024];
diff --git a/apps/srt-tunnel.cpp b/apps/srt-tunnel.cpp
index 0567b5764..90bd43eae 100644
--- a/apps/srt-tunnel.cpp
+++ b/apps/srt-tunnel.cpp
@@ -27,6 +27,7 @@
 #include <mutex>
 #include <condition_variable>
 
+#include "srt_compat.h"
 #include "apputil.hpp"  // CreateAddr
 #include "uriparser.hpp"  // UriParser
 #include "socketoptions.hpp"
@@ -59,6 +60,7 @@ testmedia.cpp
 */
 
 using namespace std;
+using namespace srt;
 
 const srt_logging::LogFA SRT_LOGFA_APP = 10;
 namespace srt_logging
@@ -94,7 +96,7 @@ class Medium
     bool m_eof = false;
     bool m_broken = false;
 
-    mutex access; // For closing
+    std::mutex access; // For closing
 
     template <class DerivedMedium, class SocketType>
     static Medium* CreateAcceptor(DerivedMedium* self, const sockaddr_any& sa, SocketType sock, size_t chunk)
@@ -223,25 +225,25 @@ class Engine
     Engine(Tunnel* p, Medium* m1, Medium* m2, const std::string& nid)
         :
 #ifdef HAVE_FULL_CXX11
-		media {m1, m2},
+        media {m1, m2},
 #endif
-		parent_tunnel(p), nameid(nid)
+        parent_tunnel(p), nameid(nid)
     {
 #ifndef HAVE_FULL_CXX11
-		// MSVC is not exactly C++11 compliant and complains around
-		// initialization of an array.
-		// Leaving this method of initialization for clarity and
-		// possibly more preferred performance.
-		media[0] = m1;
-		media[1] = m2;
+        // MSVC is not exactly C++11 compliant and complains around
+        // initialization of an array.
+        // Leaving this method of initialization for clarity and
+        // possibly more preferred performance.
+        media[0] = m1;
+        media[1] = m2;
 #endif
     }
 
     void Start()
     {
         Verb() << "START: " << media[DIR_IN]->uri() << " --> " << media[DIR_OUT]->uri();
-        std::string thrn = media[DIR_IN]->id() + ">" + media[DIR_OUT]->id();
-        ThreadName tn(thrn.c_str());
+        const std::string thrn = media[DIR_IN]->id() + ">" + media[DIR_OUT]->id();
+        srt::ThreadName tn(thrn);
 
         thr = thread([this]() { Worker(); });
     }
@@ -286,8 +288,8 @@ class Tunnel
     Tunnelbox* parent_box;
     std::unique_ptr<Medium> med_acp, med_clr;
     Engine acp_to_clr, clr_to_acp;
-    volatile bool running = true;
-    mutex access;
+    srt::sync::atomic<bool> running{true};
+    std::mutex access;
 
 public:
 
@@ -298,7 +300,7 @@ class Tunnel
 
     Tunnel(Tunnelbox* m, std::unique_ptr<Medium>&& acp, std::unique_ptr<Medium>&& clr):
         parent_box(m),
-        med_acp(move(acp)), med_clr(move(clr)),
+        med_acp(std::move(acp)), med_clr(std::move(clr)),
         acp_to_clr(this, med_acp.get(), med_clr.get(), med_acp->id() + ">" + med_clr->id()),
         clr_to_acp(this, med_clr.get(), med_acp.get(), med_clr->id() + ">" + med_acp->id())
     {
@@ -324,7 +326,7 @@ class Tunnel
 
         /*
         {
-            lock_guard<mutex> lk(access);
+            lock_guard<std::mutex> lk(access);
             if (acp_to_clr.stat() == -1 && clr_to_acp.stat() == -1)
             {
                 Verb() << "Tunnel: Both engine decommissioned, will stop the tunnel.";
@@ -438,7 +440,7 @@ class SrtMedium: public Medium
     void CloseSrt()
     {
         Verb() << "Closing SRT socket for " << uri();
-        lock_guard<mutex> lk(access);
+        lock_guard<std::mutex> lk(access);
         if (m_socket == SRT_ERROR)
             return;
         srt_close(m_socket);
@@ -528,7 +530,7 @@ class TcpMedium: public Medium
     void CloseTcp()
     {
         Verb() << "Closing TCP socket for " << uri();
-        lock_guard<mutex> lk(access);
+        lock_guard<std::mutex> lk(access);
         if (m_socket == -1)
             return;
         tcp_close(m_socket);
@@ -648,7 +650,7 @@ void TcpMedium::CreateListener()
 
     sockaddr_any sa = CreateAddr(m_uri.host(), m_uri.portno());
 
-    m_socket = socket(sa.get()->sa_family, SOCK_STREAM, IPPROTO_TCP);
+    m_socket = (int)socket(sa.get()->sa_family, SOCK_STREAM, IPPROTO_TCP);
     ConfigurePre();
 
     int stat = ::bind(m_socket, sa.get(), sa.size());
@@ -693,7 +695,7 @@ unique_ptr<Medium> SrtMedium::Accept()
 unique_ptr<Medium> TcpMedium::Accept()
 {
     sockaddr_any sa;
-    int s = ::accept(m_socket, (sa.get()), (&sa.syslen()));
+    int s = (int)::accept(m_socket, (sa.get()), (&sa.syslen()));
     if (s == -1)
     {
         Error(errno, "accept");
@@ -701,10 +703,10 @@ unique_ptr<Medium> TcpMedium::Accept()
 
     // Configure 1s timeout
     timeval timeout_1s { 1, 0 };
-    int st = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout_1s, sizeof timeout_1s);
+    int st SRT_ATR_UNUSED = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout_1s, sizeof timeout_1s);
     timeval re;
     socklen_t size = sizeof re;
-    int st2 = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*)&re, &size);
+    int st2 SRT_ATR_UNUSED = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*)&re, &size);
 
     LOGP(applog.Debug, "Setting SO_RCVTIMEO to @", m_socket, ": ", st == -1 ? "FAILED" : "SUCCEEDED",
             ", read-back value: ", st2 == -1 ? int64_t(-1) : (int64_t(re.tv_sec)*1000000 + re.tv_usec)/1000, "ms");
@@ -725,7 +727,7 @@ void SrtMedium::CreateCaller()
 
 void TcpMedium::CreateCaller()
 {
-    m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    m_socket = (int)::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     ConfigurePre();
 }
 
@@ -849,7 +851,7 @@ Medium::ReadStatus Medium::Read(bytevector& w_output)
     size_t pred_size = shift + m_chunk;
 
     w_output.resize(pred_size);
-    int st = ReadInternal((w_output.data() + shift), m_chunk);
+    int st = ReadInternal((w_output.data() + shift), (int)m_chunk);
     if (st == -1)
     {
         if (IsErrorAgain())
@@ -883,7 +885,7 @@ Medium::ReadStatus Medium::Read(bytevector& w_output)
 
 void SrtMedium::Write(bytevector& w_buffer)
 {
-    int st = srt_send(m_socket, w_buffer.data(), w_buffer.size());
+    int st = srt_send(m_socket, w_buffer.data(), (int)w_buffer.size());
     if (st == SRT_ERROR)
     {
         Error(UDT::getlasterror(), "srt_send");
@@ -906,7 +908,7 @@ void SrtMedium::Write(bytevector& w_buffer)
 
 void TcpMedium::Write(bytevector& w_buffer)
 {
-    int st = ::send(m_socket, w_buffer.data(), w_buffer.size(), DEF_SEND_FLAG);
+    int st = ::send(m_socket, w_buffer.data(), (int)w_buffer.size(), DEF_SEND_FLAG);
     if (st == -1)
     {
         Error(errno, "send");
@@ -954,23 +956,23 @@ std::unique_ptr<Medium> Medium::Create(const std::string& url, size_t chunk, Med
 struct Tunnelbox
 {
     list<unique_ptr<Tunnel>> tunnels;
-    mutex access;
+    std::mutex access;
     condition_variable decom_ready;
     bool main_running = true;
     thread thr;
 
     void signal_decommission()
     {
-        lock_guard<mutex> lk(access);
+        lock_guard<std::mutex> lk(access);
         decom_ready.notify_one();
     }
 
     void install(std::unique_ptr<Medium>&& acp, std::unique_ptr<Medium>&& clr)
     {
-        lock_guard<mutex> lk(access);
+        lock_guard<std::mutex> lk(access);
         Verb() << "Tunnelbox: Starting tunnel: " << acp->uri() << " <-> " << clr->uri();
 
-        tunnels.emplace_back(new Tunnel(this, move(acp), move(clr)));
+        tunnels.emplace_back(new Tunnel(this, std::move(acp), std::move(clr)));
         // Note: after this instruction, acp and clr are no longer valid!
         auto& it = tunnels.back();
 
@@ -992,7 +994,7 @@ struct Tunnelbox
 
     void CleanupWorker()
     {
-        unique_lock<mutex> lk(access);
+        unique_lock<std::mutex> lk(access);
 
         while (main_running)
         {
@@ -1027,7 +1029,7 @@ void Tunnel::Stop()
     if (!running)
         return; // already stopped
 
-    lock_guard<mutex> lk(access);
+    lock_guard<std::mutex> lk(access);
 
     // Ok, you are the first to make the tunnel
     // not running and inform the tunnelbox.
@@ -1037,7 +1039,7 @@ void Tunnel::Stop()
 
 bool Tunnel::decommission_if_dead(bool forced)
 {
-    lock_guard<mutex> lk(access);
+    lock_guard<std::mutex> lk(access);
     if (running && !forced)
         return false; // working, not to be decommissioned
 
@@ -1115,21 +1117,21 @@ int main( int argc, char** argv )
     string loglevel = Option<OutString>(params, "error", o_loglevel);
     string logfa = Option<OutString>(params, "", o_logfa);
     srt_logging::LogLevel::type lev = SrtParseLogLevel(loglevel);
-    UDT::setloglevel(lev);
+    srt::setloglevel(lev);
     if (logfa == "")
     {
-        UDT::addlogfa(SRT_LOGFA_APP);
+        srt::addlogfa(SRT_LOGFA_APP);
     }
     else
     {
         // Add only selected FAs
         set<string> unknown_fas;
         set<srt_logging::LogFA> fas = SrtParseLogFA(logfa, &unknown_fas);
-        UDT::resetlogfa(fas);
+        srt::resetlogfa(fas);
 
         // The general parser doesn't recognize the "app" FA, we check it here.
         if (unknown_fas.count("app"))
-            UDT::addlogfa(SRT_LOGFA_APP);
+            srt::addlogfa(SRT_LOGFA_APP);
     }
 
     string verbo = Option<OutString>(params, "no", o_verbose);
@@ -1190,7 +1192,7 @@ int main( int argc, char** argv )
             Verb() << "Connected. Establishing pipe.";
 
             // No exception, we are free to pass :)
-            g_tunnels.install(move(accepted), move(caller));
+            g_tunnels.install(std::move(accepted), std::move(caller));
         }
         catch (...)
         {
diff --git a/apps/statswriter.cpp b/apps/statswriter.cpp
new file mode 100644
index 000000000..f1aa343b5
--- /dev/null
+++ b/apps/statswriter.cpp
@@ -0,0 +1,351 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+#include <string>
+#include <chrono>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <utility>
+#include <memory>
+
+#include "statswriter.hpp"
+#include "netinet_any.h"
+#include "srt_compat.h"
+
+
+using namespace std;
+
+
+template <class TYPE>
+inline SrtStatData* make_stat(SrtStatCat cat, const string& name, const string& longname,
+        TYPE CBytePerfMon::*field)
+{
+    return new SrtStatDataType<TYPE>(cat, name, longname, field);
+}
+
+#define STATX(catsuf, sname, lname, field) s.emplace_back(make_stat(SSC_##catsuf, #sname, #lname, &CBytePerfMon:: field))
+#define STAT(catsuf, sname, field) STATX(catsuf, sname, field, field)
+
+vector<unique_ptr<SrtStatData>> g_SrtStatsTable;
+
+struct SrtStatsTableInit
+{
+    SrtStatsTableInit(vector<unique_ptr<SrtStatData>>& s)
+    {
+        STATX(GEN, time, Time, msTimeStamp);
+
+        STAT(WINDOW, flow, pktFlowWindow);
+        STAT(WINDOW, congestion, pktCongestionWindow);
+        STAT(WINDOW, flight, pktFlightSize);
+
+        STAT(LINK, rtt, msRTT);
+        STAT(LINK, bandwidth, mbpsBandwidth);
+        STAT(LINK, maxBandwidth, mbpsMaxBW);
+
+        STAT(SEND, packets, pktSent);
+        STAT(SEND, packetsUnique, pktSentUnique);
+        STAT(SEND, packetsLost, pktSndLoss);
+        STAT(SEND, packetsDropped, pktSndDrop);
+        STAT(SEND, packetsRetransmitted, pktRetrans);
+        STAT(SEND, packetsFilterExtra, pktSndFilterExtra);
+        STAT(SEND, bytes, byteSent);
+        STAT(SEND, bytesUnique, byteSentUnique);
+        STAT(SEND, bytesDropped, byteSndDrop);
+        STAT(SEND, byteAvailBuf, byteAvailSndBuf);
+        STAT(SEND, msBuf, msSndBuf);
+        STAT(SEND, mbitRate, mbpsSendRate);
+        STAT(SEND, sendPeriod, usPktSndPeriod);
+
+        STAT(RECV, packets, pktRecv);
+        STAT(RECV, packetsUnique, pktRecvUnique);
+        STAT(RECV, packetsLost, pktRcvLoss);
+        STAT(RECV, packetsDropped, pktRcvDrop);
+        STAT(RECV, packetsRetransmitted, pktRcvRetrans);
+        STAT(RECV, packetsBelated, pktRcvBelated);
+        STAT(RECV, packetsFilterExtra, pktRcvFilterExtra);
+        STAT(RECV, packetsFilterSupply, pktRcvFilterSupply);
+        STAT(RECV, packetsFilterLoss, pktRcvFilterLoss);
+        STAT(RECV, bytes, byteRecv);
+        STAT(RECV, bytesUnique, byteRecvUnique);
+        STAT(RECV, bytesLost, byteRcvLoss);
+        STAT(RECV, bytesDropped, byteRcvDrop);
+        STAT(RECV, byteAvailBuf, byteAvailRcvBuf);
+        STAT(RECV, msBuf, msRcvBuf);
+        STAT(RECV, mbitRate, mbpsRecvRate);
+        STAT(RECV, msTsbPdDelay, msRcvTsbPdDelay);
+    }
+} g_SrtStatsTableInit (g_SrtStatsTable);
+
+
+#undef STAT
+#undef STATX
+
+string srt_json_cat_names [] = {
+    "",
+    "window",
+    "link",
+    "send",
+    "recv"
+};
+
+#ifdef HAVE_CXX_STD_PUT_TIME
+// Follows ISO 8601
+std::string SrtStatsWriter::print_timestamp()
+{
+    using namespace std;
+    using namespace std::chrono;
+
+    const auto   systime_now = system_clock::now();
+    const time_t time_now    = system_clock::to_time_t(systime_now);
+
+    std::ostringstream output;
+
+    // SysLocalTime returns zeroed tm_now on failure, which is ok for put_time.
+    const tm tm_now = SysLocalTime(time_now);
+    output << std::put_time(&tm_now, "%FT%T.") << std::setfill('0') << std::setw(6);
+    const auto    since_epoch = systime_now.time_since_epoch();
+    const seconds s           = duration_cast<seconds>(since_epoch);
+    output << duration_cast<microseconds>(since_epoch - s).count();
+    output << std::put_time(&tm_now, "%z");
+    return output.str();
+}
+#else
+
+// This is a stub. The error when not defining it would be too
+// misleading, so this stub will work if someone mistakenly adds
+// the item to the output format without checking that HAVE_CXX_STD_PUT_TIME
+string SrtStatsWriter::print_timestamp()
+{ return "<NOT IMPLEMENTED>"; }
+#endif // HAVE_CXX_STD_PUT_TIME
+
+
+class SrtStatsJson : public SrtStatsWriter
+{
+    static string quotekey(const string& name)
+    {
+        if (name == "")
+            return "";
+
+        return R"(")" + name + R"(":)";
+    }
+
+    static string quote(const string& name)
+    {
+        if (name == "")
+            return "";
+
+        return R"(")" + name + R"(")";
+    }
+
+public: 
+    string WriteStats(int sid, const CBytePerfMon& mon) override
+    {
+        std::ostringstream output;
+
+        string pretty_cr, pretty_tab;
+        if (Option("pretty"))
+        {
+            pretty_cr = "\n";
+            pretty_tab = "\t";
+        }
+
+        SrtStatCat cat = SSC_GEN;
+
+        // Do general manually
+        output << quotekey(srt_json_cat_names[cat]) << "{" << pretty_cr;
+
+        // SID is displayed manually
+        output << pretty_tab << quotekey("sid") << sid;
+
+        // Extra Timepoint is also displayed manually
+#ifdef HAVE_CXX_STD_PUT_TIME
+        // NOTE: still assumed SSC_GEN category
+        output << "," << pretty_cr << pretty_tab
+            << quotekey("timepoint") << quote(print_timestamp());
+#endif
+
+        // Now continue with fields as specified in the table
+        for (auto& i: g_SrtStatsTable)
+        {
+            if (i->category == cat)
+            {
+                output << ","; // next item in same cat
+                output << pretty_cr;
+                output << pretty_tab;
+                if (cat != SSC_GEN)
+                    output << pretty_tab;
+            }
+            else
+            {
+                if (cat != SSC_GEN)
+                {
+                    // DO NOT close if general category, just
+                    // enter the depth.
+                    output << pretty_cr << pretty_tab << "}";
+                }
+                cat = i->category;
+                output << ",";
+                output << pretty_cr;
+                if (cat != SSC_GEN)
+                    output << pretty_tab;
+
+                output << quotekey(srt_json_cat_names[cat]) << "{" << pretty_cr << pretty_tab;
+                if (cat != SSC_GEN)
+                    output << pretty_tab;
+            }
+
+            // Print the current field
+            output << quotekey(i->name);
+            i->PrintValue(output, mon);
+        }
+
+        // Close the previous subcategory
+        if (cat != SSC_GEN)
+        {
+            output << pretty_cr << pretty_tab << "}" << pretty_cr;
+        }
+
+        // Close the general category entity
+        output << "}" << pretty_cr << endl;
+
+        return output.str();
+    }
+
+    string WriteBandwidth(double mbpsBandwidth) override
+    {
+        std::ostringstream output;
+        output << "{\"bandwidth\":" << mbpsBandwidth << '}' << endl;
+        return output.str();
+    }
+};
+
+class SrtStatsCsv : public SrtStatsWriter
+{
+private:
+    bool first_line_printed;
+
+public: 
+    SrtStatsCsv() : first_line_printed(false) {}
+
+    string WriteStats(int sid, const CBytePerfMon& mon) override
+    {
+        std::ostringstream output;
+
+        // Header
+        if (!first_line_printed)
+        {
+#ifdef HAVE_CXX_STD_PUT_TIME
+            output << "Timepoint,";
+#endif
+            output << "Time,SocketID";
+
+            for (auto& i: g_SrtStatsTable)
+            {
+                output << "," << i->longname;
+            }
+            output << endl;
+            first_line_printed = true;
+        }
+
+        // Values
+#ifdef HAVE_CXX_STD_PUT_TIME
+        // HDR: Timepoint
+        output << print_timestamp() << ",";
+#endif // HAVE_CXX_STD_PUT_TIME
+
+        // HDR: Time,SocketID
+        output << mon.msTimeStamp << "," << sid;
+
+        // HDR: the loop of all values in g_SrtStatsTable
+        for (auto& i: g_SrtStatsTable)
+        {
+            output << ",";
+            i->PrintValue(output, mon);
+        }
+
+        output << endl;
+        return output.str();
+    }
+
+    string WriteBandwidth(double mbpsBandwidth) override
+    {
+        std::ostringstream output;
+        output << "+++/+++SRT BANDWIDTH: " << mbpsBandwidth << endl;
+        return output.str();
+    }
+};
+
+class SrtStatsCols : public SrtStatsWriter
+{
+public: 
+    string WriteStats(int sid, const CBytePerfMon& mon) override 
+    { 
+        std::ostringstream output;
+        output << "======= SRT STATS: sid=" << sid << endl;
+        output << "PACKETS     SENT: " << setw(11) << mon.pktSent            << "  RECEIVED:   " << setw(11) << mon.pktRecv              << endl;
+        output << "LOST PKT    SENT: " << setw(11) << mon.pktSndLoss         << "  RECEIVED:   " << setw(11) << mon.pktRcvLoss           << endl;
+        output << "REXMIT      SENT: " << setw(11) << mon.pktRetrans         << "  RECEIVED:   " << setw(11) << mon.pktRcvRetrans        << endl;
+        output << "DROP PKT    SENT: " << setw(11) << mon.pktSndDrop         << "  RECEIVED:   " << setw(11) << mon.pktRcvDrop           << endl;
+        output << "FILTER EXTRA  TX: " << setw(11) << mon.pktSndFilterExtra  << "        RX:   " << setw(11) << mon.pktRcvFilterExtra    << endl;
+        output << "FILTER RX  SUPPL: " << setw(11) << mon.pktRcvFilterSupply << "  RX  LOSS:   " << setw(11) << mon.pktRcvFilterLoss     << endl;
+        output << "RATE     SENDING: " << setw(11) << mon.mbpsSendRate       << "  RECEIVING:  " << setw(11) << mon.mbpsRecvRate         << endl;
+        output << "BELATED RECEIVED: " << setw(11) << mon.pktRcvBelated      << "  AVG TIME:   " << setw(11) << mon.pktRcvAvgBelatedTime << endl;
+        output << "REORDER DISTANCE: " << setw(11) << mon.pktReorderDistance << endl;
+        output << "WINDOW      FLOW: " << setw(11) << mon.pktFlowWindow      << "  CONGESTION: " << setw(11) << mon.pktCongestionWindow  << "  FLIGHT: " << setw(11) << mon.pktFlightSize << endl;
+        output << "LINK         RTT: " << setw(9)  << mon.msRTT            << "ms  BANDWIDTH:  " << setw(7)  << mon.mbpsBandwidth    << "Mb/s " << endl;
+        output << "BUFFERLEFT:  SND: " << setw(11) << mon.byteAvailSndBuf    << "  RCV:        " << setw(11) << mon.byteAvailRcvBuf      << endl;
+        return output.str();
+    } 
+
+    string WriteBandwidth(double mbpsBandwidth) override 
+    {
+        std::ostringstream output;
+        output << "+++/+++SRT BANDWIDTH: " << mbpsBandwidth << endl;
+        return output.str();
+    }
+};
+
+shared_ptr<SrtStatsWriter> SrtStatsWriterFactory(SrtStatsPrintFormat printformat)
+{
+    switch (printformat)
+    {
+    case SRTSTATS_PROFMAT_JSON:
+        return make_shared<SrtStatsJson>();
+    case SRTSTATS_PROFMAT_CSV:
+        return make_shared<SrtStatsCsv>();
+    case SRTSTATS_PROFMAT_2COLS:
+        return make_shared<SrtStatsCols>();
+    default:
+        break;
+    }
+    return nullptr;
+}
+
+SrtStatsPrintFormat ParsePrintFormat(string pf, string& w_extras)
+{
+    size_t havecomma = pf.find(',');
+    if (havecomma != string::npos)
+    {
+        w_extras = pf.substr(havecomma+1);
+        pf = pf.substr(0, havecomma);
+    }
+
+    if (pf == "default")
+        return SRTSTATS_PROFMAT_2COLS;
+
+    if (pf == "json")
+        return SRTSTATS_PROFMAT_JSON;
+
+    if (pf == "csv")
+        return SRTSTATS_PROFMAT_CSV;
+
+    return SRTSTATS_PROFMAT_INVALID;
+}
diff --git a/apps/statswriter.hpp b/apps/statswriter.hpp
new file mode 100644
index 000000000..1b4fd4fbc
--- /dev/null
+++ b/apps/statswriter.hpp
@@ -0,0 +1,107 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+
+#ifndef INC_SRT_APPS_STATSWRITER_H
+#define INC_SRT_APPS_STATSWRITER_H
+
+#include <string>
+#include <map>
+#include <vector>
+#include <memory>
+
+#include "srt.h"
+#include "utilities.h"
+
+enum SrtStatsPrintFormat
+{
+    SRTSTATS_PROFMAT_INVALID = -1,
+    SRTSTATS_PROFMAT_2COLS = 0,
+    SRTSTATS_PROFMAT_JSON,
+    SRTSTATS_PROFMAT_CSV
+};
+
+SrtStatsPrintFormat ParsePrintFormat(std::string pf, std::string& w_extras);
+
+enum SrtStatCat
+{
+    SSC_GEN, //< General
+    SSC_WINDOW, // flow/congestion window
+    SSC_LINK, //< Link data
+    SSC_SEND, //< Sending
+    SSC_RECV //< Receiving
+};
+
+struct SrtStatData
+{
+    SrtStatCat category;
+    std::string name;
+    std::string longname;
+
+    SrtStatData(SrtStatCat cat, std::string n, std::string l): category(cat), name(n), longname(l) {}
+    virtual ~SrtStatData() {}
+
+    virtual void PrintValue(std::ostream& str, const CBytePerfMon& mon) = 0;
+};
+
+template <class TYPE>
+struct SrtStatDataType: public SrtStatData
+{
+    typedef TYPE CBytePerfMon::*pfield_t;
+    pfield_t pfield;
+
+    SrtStatDataType(SrtStatCat cat, const std::string& name, const std::string& longname, pfield_t field)
+        : SrtStatData (cat, name, longname), pfield(field)
+    {
+    }
+
+    void PrintValue(std::ostream& str, const CBytePerfMon& mon) override
+    {
+        str << mon.*pfield;
+    }
+};
+
+class SrtStatsWriter
+{
+public:
+    virtual std::string WriteStats(int sid, const CBytePerfMon& mon) = 0;
+    virtual std::string WriteBandwidth(double mbpsBandwidth) = 0;
+    virtual ~SrtStatsWriter() {}
+
+    // Only if HAS_PUT_TIME. Specified in the imp file.
+    std::string print_timestamp();
+
+    void Option(const std::string& key, const std::string& val)
+    {
+        options[key] = val;
+    }
+
+    bool Option(const std::string& key, std::string* rval = nullptr)
+    {
+        const std::string* out = map_getp(options, key);
+        if (!out)
+            return false;
+
+        if (rval)
+            *rval = *out;
+        return true;
+    }
+
+protected:
+    std::map<std::string, std::string> options;
+};
+
+extern std::vector<std::unique_ptr<SrtStatData>> g_SrtStatsTable;
+
+std::shared_ptr<SrtStatsWriter> SrtStatsWriterFactory(SrtStatsPrintFormat printformat);
+
+
+
+#endif
diff --git a/apps/support.maf b/apps/support.maf
index 19ac894b4..e5aa77b8e 100644
--- a/apps/support.maf
+++ b/apps/support.maf
@@ -9,6 +9,7 @@
 
 SOURCES
 apputil.cpp
+statswriter.cpp
 logsupport.cpp
 logsupport_appdefs.cpp
 socketoptions.cpp
diff --git a/apps/transmitbase.hpp b/apps/transmitbase.hpp
index 3b3c7d0b9..bd0af916d 100644
--- a/apps/transmitbase.hpp
+++ b/apps/transmitbase.hpp
@@ -19,11 +19,11 @@
 #include "srt.h"
 #include "uriparser.hpp"
 #include "apputil.hpp"
+#include "statswriter.hpp"
 
 typedef std::vector<char> bytevector;
 extern bool transmit_total_stats;
 extern bool g_stats_are_printed_to_stdout;
-extern volatile bool transmit_throw_on_interrupt;
 extern unsigned long transmit_bw_report;
 extern unsigned long transmit_stats_report;
 extern unsigned long transmit_chunk_size;
@@ -69,8 +69,8 @@ class Source: public Location
         }
     };
 
-    virtual SRTSOCKET GetSRTSocket() const { return SRT_INVALID_SOCK; };
-    virtual int GetSysSocket() const { return -1; };
+    virtual SRTSOCKET GetSRTSocket() const { return SRT_INVALID_SOCK; }
+    virtual int GetSysSocket() const { return -1; }
     virtual bool AcceptNewClient() { return false; }
 };
 
diff --git a/apps/transmitmedia.cpp b/apps/transmitmedia.cpp
index 7ab167c9f..275295173 100644
--- a/apps/transmitmedia.cpp
+++ b/apps/transmitmedia.cpp
@@ -22,9 +22,12 @@
 #if !defined(_WIN32)
 #include <sys/ioctl.h>
 #else
-#include <fcntl.h> 
+#include <fcntl.h>
 #include <io.h>
 #endif
+#if defined(SUNOS)
+#include <sys/filio.h>
+#endif
 
 #include "netinet_any.h"
 #include "apputil.hpp"
@@ -35,6 +38,7 @@
 #include "verbose.hpp"
 
 using namespace std;
+using namespace srt;
 
 bool g_stats_are_printed_to_stdout = false;
 bool transmit_total_stats = false;
@@ -117,6 +121,24 @@ void SrtCommon::InitParameters(string host, map<string,string> par)
         }
     }
 
+    if (par.count("bind"))
+    {
+        string bindspec = par.at("bind");
+        UriParser u (bindspec, UriParser::EXPECT_HOST);
+        if ( u.scheme() != ""
+                || u.path() != ""
+                || !u.parameters().empty()
+                || u.portno() == 0)
+        {
+            Error("Invalid syntax in 'bind' option");
+        }
+
+        if (u.host() != "")
+            par["adapter"] = u.host();
+        par["port"] = u.port();
+        par.erase("bind");
+    }
+
     string adapter;
     if (par.count("adapter"))
     {
@@ -302,7 +324,7 @@ int SrtCommon::ConfigurePost(SRTSOCKET sock)
 
     SrtConfigurePost(sock, m_options);
 
-    for (auto o: srt_options)
+    for (const auto &o: srt_options)
     {
         if ( o.binding == SocketOption::POST && m_options.count(o.name) )
         {
@@ -374,9 +396,9 @@ void SrtCommon::OpenClient(string host, int port)
 {
     PrepareClient();
 
-    if ( m_outgoing_port )
+    if (m_outgoing_port || m_adapter != "")
     {
-        SetupAdapter("", m_outgoing_port);
+        SetupAdapter(m_adapter, m_outgoing_port);
     }
 
     ConnectClient(host, port);
@@ -398,7 +420,7 @@ void SrtCommon::ConnectClient(string host, int port)
 {
 
     sockaddr_any sa = CreateAddr(host, port);
-	sockaddr* psa = sa.get();
+    sockaddr* psa = sa.get();
 
     Verb() << "Connecting to " << host << ":" << port;
 
@@ -624,7 +646,7 @@ void SrtModel::Establish(std::string& w_name)
         if (w_name != "")
         {
             Verb() << "Connect with requesting stream [" << w_name << "]";
-            UDT::setstreamid(m_sock, w_name);
+            srt::setstreamid(m_sock, w_name);
         }
         else
         {
@@ -667,7 +689,7 @@ void SrtModel::Establish(std::string& w_name)
         Verb() << "Accepting a client...";
         AcceptNewClient();
         // This rewrites m_sock with a new SRT socket ("accepted" socket)
-        w_name = UDT::getstreamid(m_sock);
+        w_name = srt::getstreamid(m_sock);
         Verb() << "... GOT CLIENT for stream [" << w_name << "]";
     }
 }
@@ -783,7 +805,7 @@ class UdpCommon
 
     void Setup(string host, int port, map<string,string> attr)
     {
-        m_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        m_sock = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
         if (m_sock == -1)
             Error(SysError(), "UdpCommon::Setup: socket");
 
@@ -826,7 +848,6 @@ class UdpCommon
 
         if (is_multicast)
         {
-            ip_mreq_source mreq_ssm;
             ip_mreq mreq;
             sockaddr_any maddr (AF_INET);
             int opt_name;
@@ -850,6 +871,7 @@ class UdpCommon
             if (attr.count("source"))
             {
 #ifdef IP_ADD_SOURCE_MEMBERSHIP
+                ip_mreq_source mreq_ssm;
                 /* this is an ssm.  we need to use the right struct and opt */
                 opt_name = IP_ADD_SOURCE_MEMBERSHIP;
                 mreq_ssm.imr_multiaddr.s_addr = sadr.sin.sin_addr.s_addr;
@@ -963,6 +985,7 @@ class UdpCommon
 
 class UdpSource: public Source, public UdpCommon
 {
+protected:
     bool eof = true;
 public:
 
@@ -1012,6 +1035,9 @@ class UdpTarget: public Target, public UdpCommon
 public:
     UdpTarget(string host, int port, const map<string,string>& attr )
     {
+        if (host.empty())
+            cerr << "\nWARN Host for UDP target is not provided. Will send to localhost:" << port << ".\n";
+
         Setup(host, port, attr);
         if (adapter != "")
         {
@@ -1057,6 +1083,74 @@ template <> struct Udp<Target> { typedef UdpTarget type; };
 template <class Iface>
 Iface* CreateUdp(const string& host, int port, const map<string,string>& par) { return new typename Udp<Iface>::type (host, port, par); }
 
+class RtpSource: public UdpSource
+{
+    // for now, make no effort to parse the header, just assume it is always
+    // fixed length and either a user-configurable value, or twelve bytes.
+    const int MINIMUM_RTP_HEADER_SIZE = 12;
+    int bytes_to_skip = MINIMUM_RTP_HEADER_SIZE;
+public:
+    RtpSource(string host, int port, const map<string,string>& attr) :
+        UdpSource { host, port, attr }
+        {
+            if (attr.count("rtpheadersize"))
+            {
+                const int header_size = stoi(attr.at("rtpheadersize"), 0, 0);
+                if (header_size < MINIMUM_RTP_HEADER_SIZE)
+                {
+                    cerr << "Invalid RTP header size provided: " << header_size
+                        << ", minimum allowed is " << MINIMUM_RTP_HEADER_SIZE
+                        << endl;
+                    throw invalid_argument("Invalid RTP header size");
+                }
+                bytes_to_skip = header_size;
+            }
+        }
+
+    int Read(size_t chunk, MediaPacket& pkt, ostream & ignored SRT_ATR_UNUSED = cout) override
+    {
+        const int length = UdpSource::Read(chunk, pkt);
+
+        if (length < 1 || !bytes_to_skip)
+        {
+            // something went wrong, or we're not skipping bytes for some
+            // reason, just return the length read via the base method
+            return length;
+        }
+
+        // we got some data and we're supposed to skip some of it
+        // check there's enough bytes for our intended skip
+        if (length < bytes_to_skip)
+        {
+            // something went wrong here
+            cerr << "RTP packet too short (" << length
+                << " bytes) to remove headers (needed "
+                << bytes_to_skip << ")" << endl;
+            throw std::runtime_error("Unexpected RTP packet length");
+        }
+
+        pkt.payload.erase(
+            pkt.payload.begin(),
+            pkt.payload.begin() + bytes_to_skip
+        );
+
+        return length - bytes_to_skip;
+    }
+};
+
+class RtpTarget : public UdpTarget {
+public:
+    RtpTarget(string host, int port, const map<string,string>& attr ) :
+        UdpTarget { host, port, attr } {}
+};
+
+template <class Iface> struct Rtp;
+template <> struct Rtp<Source> { typedef RtpSource type; };
+template <> struct Rtp<Target> { typedef RtpTarget type; };
+
+template <class Iface>
+Iface* CreateRtp(const string& host, int port, const map<string,string>& par) { return new typename Rtp<Iface>::type (host, port, par); }
+
 template<class Base>
 inline bool IsOutput() { return false; }
 
@@ -1116,10 +1210,24 @@ extern unique_ptr<Base> CreateMedium(const string& uri)
         ptr.reset( CreateUdp<Base>(u.host(), iport, u.parameters()) );
         break;
 
+    case UriParser::RTP:
+        if (IsOutput<Base>())
+        {
+            cerr << "RTP not supported as an output\n";
+            throw invalid_argument("Invalid output protocol: RTP");
+        }
+        iport = atoi(u.port().c_str());
+        if ( iport < 1024 )
+        {
+            cerr << "Port value invalid: " << iport << " - must be >=1024\n";
+            throw invalid_argument("Invalid port number");
+        }
+        ptr.reset( CreateRtp<Base>(u.host(), iport, u.parameters()) );
+        break;
     }
 
     if (ptr.get())
-        ptr->uri = move(u);
+        ptr->uri = std::move(u);
 
     return ptr;
 }
diff --git a/apps/transmitmedia.hpp b/apps/transmitmedia.hpp
index 604a8dfba..527f005d9 100644
--- a/apps/transmitmedia.hpp
+++ b/apps/transmitmedia.hpp
@@ -56,7 +56,7 @@ class SrtCommon
     SRTSOCKET Socket() const { return m_sock; }
     SRTSOCKET Listener() const { return m_bindsock; }
 
-    virtual void Close();
+    void Close();
 
 protected:
 
@@ -109,7 +109,6 @@ class SrtSource: public Source, public SrtCommon
 
     bool IsOpen() override { return IsUsable(); }
     bool End() override { return IsBroken(); }
-    void Close() override { return SrtCommon::Close(); }
 
     SRTSOCKET GetSRTSocket() const override
     { 
@@ -137,7 +136,6 @@ class SrtTarget: public Target, public SrtCommon
     int Write(const char* data, size_t size, int64_t src_time, ostream &out_stats = cout) override;
     bool IsOpen() override { return IsUsable(); }
     bool Broken() override { return IsBroken(); }
-    void Close() override { return SrtCommon::Close(); }
 
     size_t Still() override
     {
@@ -181,18 +179,8 @@ class SrtModel: public SrtCommon
     string m_host;
     int m_port = 0;
 
-
     SrtModel(string host, int port, map<string,string> par);
     void Establish(std::string& name);
-
-    void Close()
-    {
-        if (m_sock != SRT_INVALID_SOCK)
-        {
-            srt_close(m_sock);
-            m_sock = SRT_INVALID_SOCK;
-        }
-    }
 };
 
 
diff --git a/apps/uriparser.cpp b/apps/uriparser.cpp
index 4dae60a8b..6b8c80713 100644
--- a/apps/uriparser.cpp
+++ b/apps/uriparser.cpp
@@ -25,24 +25,27 @@
 
 using namespace std;
 
-map<string, UriParser::Type> types;
+map<string, UriParser::Type> g_types;
 
+// Map construction using the initializer list is only available starting from C++11.
+// This dummy structure is used instead.
 struct UriParserInit
 {
     UriParserInit()
     {
-        types["file"] = UriParser::FILE;
-        types["udp"] = UriParser::UDP;
-        types["tcp"] = UriParser::TCP;
-        types["srt"] = UriParser::SRT;
-        types["rtmp"] = UriParser::RTMP;
-        types["http"] = UriParser::HTTP;
-        types["rtp"] = UriParser::RTP;
-        types[""] = UriParser::UNKNOWN;
+        g_types["file"] = UriParser::FILE;
+        g_types["udp"] = UriParser::UDP;
+        g_types["tcp"] = UriParser::TCP;
+        g_types["srt"] = UriParser::SRT;
+        g_types["rtmp"] = UriParser::RTMP;
+        g_types["http"] = UriParser::HTTP;
+        g_types["rtp"] = UriParser::RTP;
+        g_types[""] = UriParser::UNKNOWN;
     }
 } g_uriparser_init;
 
 UriParser::UriParser(const string& strUrl, DefaultExpect exp)
+    : m_uriType(UNKNOWN)
 {
     m_expect = exp;
     Parse(strUrl, exp);
@@ -145,6 +148,41 @@ string UriParser::queryValue(const string& strKey) const
     return m_mapQuery.at(strKey);
 }
 
+// NOTE: handles percent encoded single byte ASCII / Latin-1 characters but not unicode characters and encodings
+
+static string url_decode(const string& str)
+{
+    string ret;
+    size_t prev_idx;
+    size_t idx;
+
+    for (prev_idx = 0; string::npos != (idx = str.find('%', prev_idx)); prev_idx = idx + 3)
+    {
+        char     tmp[3];
+        unsigned hex;
+
+        if (idx + 2 >= str.size()) // bad percent encoding
+            break;
+
+        tmp[0] = str[idx + 1];
+        tmp[1] = str[idx + 2];
+        tmp[2] = '\0';
+
+        if (!isxdigit((unsigned char) tmp[0]) || // bad percent encoding
+            !isxdigit((unsigned char) tmp[1]) ||
+            1 != sscanf(tmp, "%x", &hex)      ||
+            0 == hex)
+            break;
+
+        ret += str.substr(prev_idx, idx - prev_idx);
+        ret += (char) hex;
+    }
+
+    ret += str.substr(prev_idx, str.size() - prev_idx);
+
+    return ret;
+}
+
 void UriParser::Parse(const string& strUrl, DefaultExpect exp)
 {
     int iQueryStart = -1;
@@ -153,7 +191,7 @@ void UriParser::Parse(const string& strUrl, DefaultExpect exp)
     if (idx != string::npos)
     {
         m_host   = strUrl.substr(0, idx);
-        iQueryStart = idx + 1;
+        iQueryStart = (int)(idx + 1);
     }
     else
     {
@@ -196,7 +234,7 @@ void UriParser::Parse(const string& strUrl, DefaultExpect exp)
 
     // Check special things in the HOST entry.
     size_t atp = m_host.find('@');
-    if ( atp != string::npos )
+    if (atp != string::npos)
     {
         string realhost = m_host.substr(atp+1);
         string prehost;
@@ -294,22 +332,22 @@ void UriParser::Parse(const string& strUrl, DefaultExpect exp)
         if (idx != string::npos)
         {
             strQueryPair = strUrl.substr(iQueryStart, idx - iQueryStart);
-            iQueryStart = idx + 1;
+            iQueryStart = (int)(idx + 1);
         }
         else
         {
             strQueryPair = strUrl.substr(iQueryStart, strUrl.size() - iQueryStart);
-            iQueryStart = idx;
+            iQueryStart = (int)idx;
         }
 
         idx = strQueryPair.find("=");
         if (idx != string::npos)
         {
-            m_mapQuery[strQueryPair.substr(0, idx)] = strQueryPair.substr(idx + 1, strQueryPair.size() - (idx + 1));
+            m_mapQuery[url_decode(strQueryPair.substr(0, idx))] = url_decode(strQueryPair.substr(idx + 1, strQueryPair.size() - (idx + 1)));
         }
     }
 
-    if ( m_proto == "file" )
+    if (m_proto == "file")
     {
         if ( m_path.size() > 3 && m_path.substr(0, 3) == "/./" )
             m_path = m_path.substr(3);
@@ -317,14 +355,19 @@ void UriParser::Parse(const string& strUrl, DefaultExpect exp)
 
     // Post-parse fixes
     // Treat empty protocol as a file. In this case, merge the host and path.
-    if ( exp == EXPECT_FILE && m_proto == "" && m_port == "" )
+    if (exp == EXPECT_FILE && m_proto == "" && m_port == "")
     {
         m_proto = "file";
         m_path = m_host + m_path;
         m_host = "";
     }
 
-    m_uriType = types[m_proto]; // default-constructed UNKNOWN will be used if not found (although also inserted)
+    const auto proto_it = g_types.find(m_proto);
+    // Default-constructed UNKNOWN will be used if not found.
+    if (proto_it != g_types.end())
+    {
+        m_uriType = proto_it->second;
+    }
     m_origUri = strUrl;
 }
 
diff --git a/apps/verbose.cpp b/apps/verbose.cpp
index 58cf83fbe..4ea3b47dc 100644
--- a/apps/verbose.cpp
+++ b/apps/verbose.cpp
@@ -9,14 +9,13 @@
  */
 
 #include "verbose.hpp"
+#include "sync.h" // srt::sync
 
 namespace Verbose
 {
     bool on = false;
     std::ostream* cverb = &std::cerr;
-#if SRT_ENABLE_VERBOSE_LOCK
-    std::mutex vlock;
-#endif
+    srt::sync::Mutex vlock;
 
     Log& Log::operator<<(LogNoEol)
     {
@@ -28,19 +27,16 @@ namespace Verbose
         return *this;
     }
 
-#if SRT_ENABLE_VERBOSE_LOCK
     Log& Log::operator<<(LogLock)
     {
         lockline = true;
         return *this;
     }
-#endif
 
     Log::~Log()
     {
         if (on && !noeol)
         {
-#if SRT_ENABLE_VERBOSE_LOCK
             if (lockline)
             {
                 // Lock explicitly, as requested, and wait for the opportunity.
@@ -48,7 +44,7 @@ namespace Verbose
             }
             else if (vlock.try_lock())
             {
-                // Successfully locked, so unlock immediately, locking wasn't requeted.
+                // Successfully locked, so unlock immediately, locking wasn't requested.
                 vlock.unlock();
             }
             else
@@ -62,15 +58,12 @@ namespace Verbose
                 vlock.lock();
                 vlock.unlock();
             }
-#endif
             (*cverb) << std::endl;
-#if SRT_ENABLE_VERBOSE_LOCK
 
             // If lockline is set, the lock was requested and WAS DONE, so unlock.
             // Otherwise locking WAS NOT DONE.
             if (lockline)
                 vlock.unlock();
-#endif
         }
     }
 }
diff --git a/apps/verbose.hpp b/apps/verbose.hpp
index ec0276c12..e3d20732a 100644
--- a/apps/verbose.hpp
+++ b/apps/verbose.hpp
@@ -12,9 +12,7 @@
 #define INC_SRT_VERBOSE_HPP
 
 #include <iostream>
-#if SRT_ENABLE_VERBOSE_LOCK
-#include <mutex>
-#endif
+#include "atomic.h"
 
 namespace Verbose
 {
@@ -23,22 +21,22 @@ extern bool on;
 extern std::ostream* cverb;
 
 struct LogNoEol { LogNoEol() {} };
-#if SRT_ENABLE_VERBOSE_LOCK
 struct LogLock { LogLock() {} };
-#endif
 
 class Log
 {
     bool noeol = false;
-#if SRT_ENABLE_VERBOSE_LOCK
-    bool lockline = false;
-#endif
+    srt::sync::atomic<bool> lockline;
 
     // Disallow creating dynamic objects
-    void* operator new(size_t);
+    void* operator new(size_t) = delete;
 
 public:
 
+    Log() {}
+    Log(const Log& ) {}
+
+
     template <class V>
     Log& operator<<(const V& arg)
     {
@@ -50,9 +48,7 @@ class Log
     }
 
     Log& operator<<(LogNoEol);
-#if SRT_ENABLE_VERBOSE_LOCK
     Log& operator<<(LogLock);
-#endif
     ~Log();
 };
 
@@ -74,15 +70,38 @@ class ErrLog: public Log
     }
 };
 
+// terminal
+inline void Print(Log& ) {}
+
+template <typename Arg1, typename... Args>
+inline void Print(Log& out, Arg1&& arg1, Args&&... args)
+{
+    out << arg1;
+    Print(out, args...);
+}
+
 }
 
 inline Verbose::Log Verb() { return Verbose::Log(); }
 inline Verbose::ErrLog Verror() { return Verbose::ErrLog(); }
 
+template <typename... Args>
+inline void Verb(Args&&... args)
+{
+    Verbose::Log log;
+    Verbose::Print(log, args...);
+}
+
+template <typename... Args>
+inline void Verror(Args&&... args)
+{
+    Verbose::ErrLog log;
+    Verbose::Print(log, args...);
+}
+
+
 // Manipulator tags
 static const Verbose::LogNoEol VerbNoEOL;
-#if SRT_ENABLE_VERBOSE_LOCK
 static const Verbose::LogLock VerbLock;
-#endif
 
 #endif
diff --git a/codecov.yml b/codecov.yml
index f91e5c1fe..2716c7f60 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -6,3 +6,7 @@ coverage:
         threshold: null
     patch: false
     changes: false
+ignore:
+  - "testing"
+  - "apps"
+  - "example"
\ No newline at end of file
diff --git a/configure-data.tcl b/configure-data.tcl
index 66902324a..3510a9645 100644
--- a/configure-data.tcl
+++ b/configure-data.tcl
@@ -25,47 +25,56 @@
 
 # Options processed here internally, not passed to cmake
 set internal_options {
-	with-compiler-prefix=<prefix> "set C/C++ toolchains <prefix>gcc and <prefix>g++"
-	with-compiler-type=<name> "compiler type: gcc(default), cc, others simply add ++ for C++"
-	with-srt-name=<name> "Override srt library name"
-	with-haicrypt-name=<name> "Override haicrypt library name (if compiled separately)"
+    with-compiler-prefix=<prefix> "set C/C++ toolchains <prefix>gcc and <prefix>g++"
+    with-compiler-type=<name> "compiler type: gcc(default), cc, others simply add ++ for C++"
+    with-srt-name=<name> "Override srt library name"
+    with-haicrypt-name=<name> "Override haicrypt library name (if compiled separately)"
+    with-atomic=<spec> "Select implementation for atomics (compiler-intrinsics or sync-mutex)"
 }
 
 # Options that refer directly to variables used in CMakeLists.txt
 set cmake_options {
     cygwin-use-posix "Should the POSIX API be used for cygwin. Ignored if the system isn't cygwin. (default: OFF)"
-    enable-encryption "Should encryption features be enabled (default: ON)"
-    enable-c++11 "Should the c++11 parts (srt-live-transmit) be enabled (default: ON)"
+    enable-c++11 "Should the c++11 parts (srt-live-transmit) be enabled (default: ON, with gcc < 4.7 OFF)"
     enable-apps "Should the Support Applications be Built? (default: ON)"
+    enable-bonding "Enable 'bonding' SRT feature (default: OFF)"
     enable-testing "Should developer testing applications be built (default: OFF)"
-    enable-c++-deps "Extra library dependencies in srt.pc for C language (default: OFF)"
-    enable-heavy-logging "Should heavy debug logging be enabled (default: OFF)"
+    enable-profile "Should instrument the code for profiling. Ignored for non-GNU compiler. (default: OFF)"
     enable-logging "Should logging be enabled (default: ON)"
-    enable-debug=<0,1,2> "Enable debug mode (0=disabled, 1=debug, 2=rel-with-debug)"
+    enable-heavy-logging "Should heavy debug logging be enabled (default: OFF)"
     enable-haicrypt-logging "Should logging in haicrypt be enabled (default: OFF)"
-    enable-inet-pton "Set to OFF to prevent usage of inet_pton when building against modern SDKs (default: ON)"
-    enable-code-coverage "Enable code coverage reporting (default: OFF)"
-    enable-monotonic-clock "Enforced clock_gettime with monotonic clock on GC CV /temporary fix for #729/ (default: OFF)"
-    enable-profile "Should instrument the code for profiling. Ignored for non-GNU compiler. (default: OFF)"
-    enable-relative-libpath "Should applications contain relative library paths, like ../lib (default: OFF)"
+    enable-pktinfo "Should pktinfo reading and using be enabled (POSIX only) (default: OFF)"
     enable-shared "Should libsrt be built as a shared library (default: ON)"
     enable-static "Should libsrt be built as a static library (default: ON)"
-    enable-suflip "Should suflip tool be built (default: OFF)"
+    enable-relative-libpath "Should applications contain relative library paths, like ../lib (default: OFF)"
     enable-getnameinfo "In-logs sockaddr-to-string should do rev-dns (default: OFF)"
-    enable-unittests "Enable unit tests (default: OFF)"
+    enable-unittests "Enable Unit Tests (will download Google UT) (default: OFF)"
+    enable-encryption "Should encryption features be enabled (default: ON)"
+    enable-c++-deps "Extra library dependencies in srt.pc for C language (default: ON)"
+    use-static-libstdc++ "Should use static rather than shared libstdc++ (default: OFF)"
+    enable-inet-pton "Set to OFF to prevent usage of inet_pton when building against modern SDKs (default: ON)"
+    enable-code-coverage "Enable code coverage reporting (default: OFF)"
+    enable-monotonic-clock "Enforced clock_gettime with monotonic clock on GC CV /temporary fix for #729/ (default: OFF)"
     enable-thread-check "Enable #include <threadcheck.h> that implements THREAD_* macros"
-    openssl-crypto-library=<filepath> "Path to a library."
-    openssl-include-dir=<path> "Path to a file."
-    openssl-ssl-library=<filepath> "Path to a library."
-    pkg-config-executable=<filepath> "pkg-config executable"
-    pthread-include-dir=<path> "Path to a file."
-    pthread-library=<filepath> "Path to a library."
+    enable-stdc++-sync "Use standard C++11 chrono/threads instead of pthread wrapper (default: OFF, on Windows: ON)"
+    use-openssl-pc "Use pkg-config to find OpenSSL libraries (default: ON)"
+    openssl-use-static-libs "Link OpenSSL statically (default: OFF)."
     use-busy-waiting "Enable more accurate sending times at a cost of potentially higher CPU load (default: OFF)"
     use-gnustl "Get c++ library/headers from the gnustl.pc"
-    use-enclib "Encryption library to be used: openssl(default), gnutls, mbedtls"
-    use-gnutls "DEPRECATED. Use USE_ENCLIB=openssl|gnutls|mbedtls instead"
-    use-openssl-pc "Use pkg-config to find OpenSSL libraries (default: ON)"
-    use-static-libstdc++ "Should use static rather than shared libstdc++ (default: OFF)"
+    enable-sock-cloexec "Enable setting SOCK_CLOEXEC on a socket (default: ON)"
+    enable-show-project-config "Enables use of ShowProjectConfig() in cmake (default: OFF)"
+    enable-new-rcvbuffer "Enables the new receiver buffer implementation (default: ON)"
+    enable-clang-tsa "Enable Clang's Thread-Safety-Analysis (default: OFF)"
+    atomic-use-srt-sync-mutex "Use mutex to implement atomics (alias: --with-atomic=sync-mutex) (default: OFF)"
+
+    use-enclib "Encryption library to be used: openssl(default), gnutls, mbedtls, botan"
+    enable-debug=<0,1,2> "Enable debug mode (0=disabled, 1=debug, 2=rel-with-debug)"
+    pkg-config-executable=<filepath> "pkg-config executable"
+    openssl-crypto-library=<filepath> "OpenSSL: Path to a libcrypto library."
+    openssl-include-dir=<path> "OpenSSL: Path to includes."
+    openssl-ssl-library=<filepath> "OpenSSL: Path to a libssl library."
+    pthread-include-dir=<path> "PThread: Path to includes"
+    pthread-library=<filepath> "PThread: Path to the pthread library."
 }
 
 set options $internal_options$cmake_options
@@ -162,9 +171,75 @@ proc preprocess {} {
 		set ::haicrypt_name $::optval(--with-haicrypt-name)
 		unset ::optval(--with-haicrypt-name)
 	}
+
+	if { "--with-atomic" in $::optkeys } {
+		switch -- $::optval(--with-atomic) {
+			compiler-intrinsics {
+			}
+
+			sync-mutex {
+				set ::optval(--atomic-use-srt-sync-mutex) 1
+			}
+
+			default {
+				puts "ERROR: --with-atomic option accepts two values: compiler-intrinsics (default) or sync-mutex"
+				exit 1
+			}
+		}
+
+		unset ::optval(--with-atomic)
+	}
 }
 
-proc GetCompilerCommand {} {
+# Added also the Intel compiler names, just in case.
+set compiler_map {
+	cc c++
+	gcc g++
+	icc icpc
+	icx icpx
+}
+
+proc SplitCompilerVersionSuffix {cmd} {
+	# If there's no version suffix, return just $cmd.
+	# Otherwise return a list with cmd cut and version suffix
+
+	set parts [split $cmd -]
+	if {[llength $parts] == 1} {
+		return $cmd
+	}
+
+	set last [lindex $parts end]
+	if {![regexp {[0-9]+.*} $last]} {
+		return $cmd
+	}
+
+	# Got the version
+	if {[llength $parts] == 2} {
+		set first [lindex $parts 0]
+	} else {
+		set first [join [lrange $parts 0 end-1] -]
+	}
+
+	return [list $first -$last]
+}
+
+# This uses 'compiler' in the form of the C compiler
+# command line. For C++ it returns the C++ command line,
+# which is normally the C compiler command with ++.
+proc GetCompilerCmdName {compiler lang} {
+	lassign [SplitCompilerVersionSuffix $compiler] compiler suffix
+	if {$lang == "c++"} {
+		if { [dict exists $::compiler_map $compiler] } {
+			return [dict get $::compiler_map $compiler]$suffix
+		}
+
+		return ${compiler}++${suffix}
+	}
+
+	return $compiler${suffix}
+}
+
+proc GetCompilerCommand { {lang {}} } {
 	# Expect that the compiler was set through:
 	# --with-compiler-prefix
 	# --cmake-c[++]-compiler
@@ -177,21 +252,25 @@ proc GetCompilerCommand {} {
 
 	if { [info exists ::optval(--with-compiler-prefix)] } {
 		set prefix $::optval(--with-compiler-prefix)
-		return ${prefix}$compiler
+		return ${prefix}[GetCompilerCmdName $compiler $lang]
 	} else {
-		return $compiler
+		return [GetCompilerCmdName $compiler $lang]
 	}
 
-	if { [info exists ::optval(--cmake-c-compiler)] } {
-		return $::optval(--cmake-c-compiler)
+	if { $lang != "c++" } {
+		if { [info exists ::optval(--cmake-c-compiler)] } {
+			return $::optval(--cmake-c-compiler)
+		}
 	}
 
-	if { [info exists ::optval(--cmake-c++-compiler)] } {
-		return $::optval(--cmake-c++-compiler)
-	}
+	if { $lang != "c" } {
+		if { [info exists ::optval(--cmake-c++-compiler)] } {
+			return $::optval(--cmake-c++-compiler)
+		}
 
-	if { [info exists ::optval(--cmake-cxx-compiler)] } {
-		return $::optval(--cmake-cxx-compiler)
+		if { [info exists ::optval(--cmake-cxx-compiler)] } {
+			return $::optval(--cmake-cxx-compiler)
+		}
 	}
 
 	puts "NOTE: Cannot obtain compiler, assuming toolchain file will do what's necessary"
@@ -257,6 +336,18 @@ proc postprocess {} {
 		} else {
 			puts "CONFIGURE: default compiler used"
 		}
+
+		# Complete the variables before calling cmake, otherwise it might not work
+
+		if { [info exists ::optval(--with-compiler-type)] } {
+			if { ![info exists ::optval(--cmake-c-compiler)] } {
+				lappend ::cmakeopt "-DCMAKE_C_COMPILER=[GetCompilerCommand c]"
+			}
+
+			if { ![info exists ::optval(--cmake-c++-compiler)] } {
+				lappend ::cmakeopt "-DCMAKE_CXX_COMPILER=[GetCompilerCommand c++]"
+			}
+		}
 	}
 
 	if { $::srt_name != "" } {
@@ -343,8 +434,23 @@ proc postprocess {} {
 		# Otherwise don't set PKG_CONFIG_PATH and we'll see.
 	}
 
-	if { $::HAVE_DARWIN && !$toolchain_changed} {
+	set use_brew 0
+	if { $::HAVE_DARWIN && !$toolchain_changed } {
+		set use_brew 1
+	}
+	if { [info exists ::optval(--use-enclib)] && $::optval(--use-enclib) == "botan"} {
+		set use_brew 0
+	}
 
+	if { $use_brew } {
+		foreach item $::cmakeopt {
+			if { [string first "Android" $item] != -1 } {
+				set use_brew 0
+				break
+			}
+		}
+	}
+	if { $use_brew } {
 		if { $have_gnutls } {
 			# Use gnutls explicitly, as found in brew
 			set er [catch {exec brew info gnutls} res]
diff --git a/docs/API-functions.md b/docs/API-functions.md
deleted file mode 100644
index 0c50c62de..000000000
--- a/docs/API-functions.md
+++ /dev/null
@@ -1,2549 +0,0 @@
-# SRT API Functions
-
-- [**Library Initialization**](#Library-Initialization)
-  * [srt_startup](#srt_startup)
-  * [srt_cleanup](#srt_cleanup)
-- [**Creating and configuring sockets**](#Creating-and-configuring-sockets)
-  * [srt_socket](#srt_socket)
-  * [srt_create_socket](#srt_create_socket)
-  * [srt_bind](#srt_bind)
-  * [srt_bind_acquire](#srt_bind_acquire)
-  * [srt_getsockstate](#srt_getsockstate)
-  * [srt_getsndbuffer](#srt_getsndbuffer)
-  * [srt_close](#srt_close)
-- [**Connecting**](#Connecting)
-  * [srt_listen](#srt_listen)
-  * [srt_accept](#srt_accept)
-  * [srt_accept_bond](#srt_accept_bond)
-  * [srt_listen_callback](#srt_listen_callback)
-  * [srt_connect](#srt_connect)
-  * [srt_connect_bind](#srt_connect_bind)
-  * [srt_connect_debug](#srt_connect_debug)
-  * [srt_rendezvous](#srt_rendezvous)
-  * [srt_connect_callback](#srt_connect_callback)
-- [**Socket group management**](#Socket-group-management)
-  * [SRT_GROUP_TYPE](#SRT_GROUP_TYPE)
-  * [SRT_SOCKGROUPCONFIG](#SRT_SOCKGROUPCONFIG)
-  * [SRT_SOCKGROUPDATA](#SRT_SOCKGROUPDATA)
-  * [SRT_MEMBERSTATUS](#SRT_MEMBERSTATUS)
-  * [srt_create_group](#srt_create_group)
-  * [srt_include](#srt_include)
-  * [srt_exclude](#srt_exclude)
-  * [srt_groupof](#srt_groupof)
-  * [srt_group_data](#srt_group_data)
-  * [srt_connect_group](#srt_connect_group)
-  * [srt_prepare_endpoint](#srt_prepare_endpoint)
-  * [srt_create_config](#srt_create_config)
-  * [srt_delete_config](#srt_delete_config)
-  * [srt_config_add](#srt_config_add)
-- [**Options and properties**](#Options-and-properties)
-  * [srt_getpeername](#srt_getpeername)
-  * [srt_getsockname](#srt_getsockname)
-  * [srt_getsockopt, srt_getsockflag](#srt_getsockopt-srt_getsockflag)
-  * [srt_setsockopt, srt_setsockflag](#srt_setsockopt-srt_setsockflag)
-  * [srt_getversion](#srt_getversion)
-- [**Helper data types for transmission**](#Helper-data-types-for-transmission)
-  * [SRT_MSGCTRL](#SRT_MSGCTRL)
-- [**Transmission**](#Transmission)
-  * [srt_send, srt_sendmsg, srt_sendmsg2](#srt_send-srt_sendmsg-srt_sendmsg2)
-  * [srt_recv, srt_recvmsg, srt_recvmsg2](#srt_recv-srt_recvmsg-srt_recvmsg2)
-  * [srt_sendfile, srt_recvfile](#srt_sendfile-srt_recvfile)
-- [**Diagnostics**](#Diagnostics)
-  * [srt_getlasterror_str](#srt_getlasterror_str)
-  * [srt_getlasterror](#srt_getlasterror)
-  * [srt_strerror](#srt_strerror)
-  * [srt_clearlasterror](#srt_clearlasterror)
-  * [srt_getrejectreason](#srt_getrejectreason)
-  * [srt_rejectreason_str](#srt_rejectreason_str)
-  * [srt_setrejectreason](#srt_setrejectreason)
-  * [Error Codes](#error-codes)
-- [**Performance tracking**](#Performance-tracking)
-  * [srt_bstats, srt_bistats](#srt_bstats-srt_bistats)
-- [**Asynchronous operations (epoll)**](#Asynchronous-operations-epoll)
-  * [srt_epoll_create](#srt_epoll_create)
-  * [srt_epoll_add_usock, srt_epoll_add_ssock, srt_epoll_update_usock, srt_epoll_update_ssock](#srt_epoll_add_usock-srt_epoll_add_ssock-srt_epoll_update_usock-srt_epoll_update_ssock)
-  * [srt_epoll_remove_usock, srt_epoll_remove_ssock](#srt_epoll_remove_usock-srt_epoll_remove_ssock)
-  * [srt_epoll_wait](#srt_epoll_wait)
-  * [srt_epoll_uwait](#srt_epoll_uwait)
-  * [srt_epoll_clear_usocks](#srt_epoll_clear_usocks)
-  * [srt_epoll_set](#srt_epoll_set)
-  * [srt_epoll_release](#srt_epoll_release)
-- [**Logging control**](#Logging-control)
-  * [srt_setloglevel](#srt_setloglevel)
-  * [srt_addlogfa, srt_dellogfa, srt_resetlogfa](#srt_addlogfa-srt_dellogfa-srt_resetlogfa)
-  * [srt_setloghandler](#srt_setloghandler)
-  * [srt_setlogflags](#srt_setlogflags)
-- [**Time Access**](#time-access)
-  * [srt_time_now](#srt_time_now)
-  * [srt_connection_time](#srt_connection_time)
-
-
-## Library initialization
-
-### srt_startup
-```
-int srt_startup(void);
-```
-
-This function shall be called at the start of an application that uses the SRT
-library. It provides all necessary platform-specific initializations, sets up
-global data, and starts the SRT GC thread. If this function isn't explicitly 
-called, it will be called automatically when creating the first socket. However, 
-relying on this behavior is strongly discouraged.
-
-- Returns:
-
-  *  0 = successfully run, or already started
-  *  1 = this is the first startup, but the GC thread is already running
-  * -1 = failed
-
-- Errors:
-
-  * `SRT_ECONNSETUP` (with error code set): Reported when required system
-resource(s) failed to initialize. This is currently used only on Windows to 
-report a failure from `WSAStartup`.
-
-### srt_cleanup
-```
-int srt_cleanup(void);
-```
-
-This function cleans up all global SRT resources and shall be called just before 
-exiting the application that uses the SRT library. This cleanup function will still
-be called from the C++ global destructor, if not called by the application, although
-relying on this behavior is stronly discouraged.
-
-- Returns:
-
-  * 0 (A possibility to return other values is reserved for future use)
-
-**IMPORTANT**: Note that the startup/cleanup calls have an instance counter.
-This means that if you call `srt_startup` multiple times, you need to call the 
-`srt_cleanup` function exactly the same number of times.
-
-## Creating and configuring sockets
-
-### srt_socket
-```
-SRTSOCKET srt_socket(int af, int type, int protocol);
-```
-
-Old and deprecated version of `srt_create_socket`. All arguments are ignored.
-
-**NOTE** changes with respect to UDT version:
-
-* In UDT (and SRT versions before 1.4.2) the `af` parameter was specifying the
-socket family (`AF_INET` or `AF_INET6`). This is now not required; this parameter
-is decided at the call of `srt_conenct` or `srt_bind`.
-
-* In UDT the `type` parameter was used to specify the file or message mode
-using `SOCK_STREAM` or `SOCK_DGRAM` symbols (with the latter being misleading,
-as the message mode has nothing to do with UDP datagrams and it's rather
-similar to the SCTP protocol). In SRT these two modes are available by setting
-`SRTO_TRANSTYPE`. The default is `SRTT_LIVE`. If, however, you set
-`SRTO_TRANSTYPE` to `SRTT_FILE` for file mode, you can then leave the
-`SRTO_MESSAGEAPI` option as false (default), which corresponds to "stream" mode
-(TCP-like), or set it to true, which corresponds to "message" mode (SCTP-like).
-
-
-### srt_create_socket
-```
-SRTSOCKET srt_create_socket();
-```
-
-Creates an SRT socket.
-
-Note that socket IDs always have the `SRTGROUP_MASK` bit clear.
-
-- Returns:
-
-  * a valid socket ID on success
-  * `SRT_INVALID_SOCK` (`-1`) on error
-
-- Errors:
-
-  * `SRT_ENOTBUF`: not enough memory to allocate required resources
-
-**NOTE:** This is probably a design flaw (**BUG?**). Usually underlying system 
-errors are reported by `SRT_ECONNSETUP`.
-
-
-### srt_bind
-```
-int srt_bind(SRTSOCKET u, const struct sockaddr* name, int namelen);
-```
-
-Binds a socket to a local address and port. Binding specifies the local network
-interface and the UDP port number to be used for the socket. When the local 
-address is a form of `INADDR_ANY`, then it's bound to all interfaces. When the 
-port number is 0, then the port number will be system-allocated if necessary.
-
-This call is obligatory for a listening socket before calling `srt_listen`
-and for rendezvous mode before calling `srt_connect`, otherwise it's optional.
-For a listening socket it defines the network interface and the port where the
-listener should expect a call request. In case of rendezvous mode (when the
-socket has set `SRTO_RENDEZVOUS` to true, in this mode both parties connect
-to one another) it defines the network interface and port from which packets
-will be sent to the peer and to which the peer is expected to send packets.
-
-For a connecting socket this call can set up the outgoing port to be used in
-the communication. It is allowed that multiple SRT sockets share one local
-outgoing port, as long as `SRTO_REUSEADDR` is set to *true* (default). Without
-this call the port will be automatically selected by the system.
-
-NOTE: This function cannot be called on socket group. If you need to
-have the group-member socket bound to the specified source address before
-connecting, use `srt_connect_bind` for that purpose.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) on error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket passed as `u` designates no valid socket
-  * `SRT_EINVOP`: Socket already bound
-  * `SRT_ECONNSETUP`: Internal creation of a UDP socket failed 
-  * `SRT_ESOCKFAIL`: Internal configuration of a UDP socket (`bind`, `setsockopt`) failed
-
-### srt_bind_acquire
-
-```
-int srt_bind_acquire(SRTSOCKET u, UDPSOCKET udpsock);
-```
-
-A version of `srt_bind` that acquires a given UDP socket instead of creating one.
-
-### srt_getsockstate
-
-```
-SRT_SOCKSTATUS srt_getsockstate(SRTSOCKET u);
-```
-
-Gets the current status of the socket. Possible states are:
-
-* `SRTS_INIT`: Created, but not bound
-* `SRTS_OPENED`: Created and bound, but not in use yet.
-* `SRTS_LISTENING`: Socket is in listening state
-* `SRTS_CONNECTING`: The connect operation was initiated, but not yet 
-finished. This may also mean that it has timed out; you can only know
-that after getting a socket error report from `srt_epoll_wait`. In blocking
-mode it's not possible because `srt_connect` does not return until the
-socket is connected or failed due to timeout or interrupted call.
-* `SRTS_CONNECTED`: The socket is connected and ready for transmission.
-* `SRTS_BROKEN`: The socket was connected, but the connection was broken
-* `SRTS_CLOSING`: The socket may still be open and active, but closing
-is requested, so no further operations will be accepted (active operations will 
-be completed before closing)
-* `SRTS_CLOSED`: The socket has been closed, but not yet removed by the GC
-thread
-* `SRTS_NONEXIST`: The specified number does not correspond to a valid socket.
-
-### srt_getsndbuffer
-
-```
-int srt_getsndbuffer(SRTSOCKET sock, size_t* blocks, size_t* bytes);
-```
-
-Retrieves information about the sender buffer.
-
-* `sock`: Socket to test
-* `blocks`: Written information about buffer blocks in use
-* `bytes`: Written information about bytes in use
-
-This function can be used for diagnostics. It is especially useful when the 
-socket needs to be closed asynchronously.
-
-### srt_close
-
-```
-int srt_close(SRTSOCKET u);
-```
-
-Closes the socket or group and frees all used resources. Note that underlying
-UDP sockets may be shared between sockets, so these are freed only with the
-last user closed.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-
-## Connecting
-
-### srt_listen
-```
-int srt_listen(SRTSOCKET u, int backlog);
-```
-
-This sets up the listening state on a socket with a backlog setting that 
-defines how many sockets may be allowed to wait until they are accepted 
-(excessive connection requests are rejected in advance).
-
-The following important options may change the behavior of the listener
-socket and the `srt_accept` function:
-
-* `srt_listen_callback` installs a user function that will be called
-before `srt_accept` can happen
-* `SRTO_GROUPCONNECT` option allows the listener socket to accept group
-connections
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0.
-
-- Errors:
-
-  * `SRT_EINVPARAM`: Value of `backlog` is 0 or negative.
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid SRT socket.
-  * `SRT_EUNBOUNDSOCK`: `srt_bind` has not yet been called on that socket.
-  * `SRT_ERDVNOSERV`: `SRTO_RENDEZVOUS` flag is set to true on specified socket.
-  * `SRT_EINVOP`: Internal error (should not happen when `SRT_EUNBOUNDSOCK` is reported).
-  * `SRT_ECONNSOCK`: The socket is already connected.
-  * `SRT_EDUPLISTEN`: The address used in `srt_bind` by this socket is already
-occupied by another listening socket. Binding multiple sockets to one IP address 
-and port is allowed, as long as `SRTO_REUSEADDR` is set to true, but only one of 
-these sockets can be set up as a listener.
-
-### srt_accept
-
-```
-SRTSOCKET srt_accept(SRTSOCKET lsn, struct sockaddr* addr, int* addrlen);
-```
-
-Accepts a pending connection, then creates and returns a new socket or
-group ID that handles this connection. The group and socket can be
-distinguished by checking the `SRTGROUP_MASK` bit on the returned ID.
-
-* `lsn`: the listener socket previously configured by `srt_listen`
-* `addr`: the IP address and port specification for the remote party
-* `addrlen`: INPUT: size of `addr` pointed object. OUTPUT: real size of the
-returned object
-
-**NOTE:** `addr` is allowed to be NULL, in which case it's understood that the
-application is not interested in the address from which the connection originated.
-Otherwise `addr` should specify an object into which the address will be written, 
-and `addrlen` must also specify a variable to contain the object size. Note also
-that in the case of group connection only the initial connection that
-establishes the group connection is returned, together with its address. As
-member connections are added or broken within the group, you can obtain this
-information through `srt_group_data` or the data filled by `srt_sendmsg2` and
-`srt_recvmsg2`.
-
-If the pending connection is a group connection (initiated on the peer side
-by calling the connection function using a group ID, and permitted on the
-listener socket by `SRTO_GROUPCONNECT` flag), then the value returned is a
-group ID. This function then creates a new group, as well as a new socket for
-this very connection, that will be added to the group. Once the group is
-created this way, further connections within the same group, as well as sockets
-for them, will be created in the background. The `SRT_EPOLL_UPDATE` event is
-raised on the `lsn` socket when a new background connection is attached to the
-group, although it's usually for internal use only.
-
-- Returns:
-
-  * On success, a valid SRT socket or group ID to be used for transmission
-  * `SRT_ERROR` (-1) on failure 
-
-- Errors:
-
-  * `SRT_EINVPARAM`: NULL specified as `addrlen`, when `addr` is not NULL
-  * `SRT_EINVSOCK`: `lsn` designates no valid socket ID. 
-  * `SRT_ENOLISTEN`: `lsn` is not set up as a listener (`srt_listen` not called)
-  * `SRT_EASYNCRCV`: No connection reported so far. This error is reported only
-when the `lsn` listener socket was configured as non-blocking for reading
-(`SRTO_RCVSYN` set to false); otherwise the call blocks until a connection
-is reported or an error occurs
-  * `SRT_ESCLOSED`: The `lsn` socket has been closed while the function was
-blocking the call (if `SRTO_RCVSYN` is set to default true). This includes a
-situation when the socket was closed just at the moment when a connection was
-made and the socket got closed during processing
-
-
-### srt_accept_bond
-
-```
-SRTSOCKET srt_accept_bond(const SRTSOCKET listeners[], int nlisteners, int msTimeOut);
-```
-
-Accepts a pending connection, like `srt_accept`, but pending on any of the
-listener sockets passed in the `listeners` array of `nlisteners` size.
-
-* `listeners`: array of listener sockets (all must be setup by `srt_listen`)
-* `nlisteners`: size of the `listeners` array
-* `msTimeOut`: timeout in [ms] or -1 to block forever
-
-This function is for blocking mode only - for non-blocking mode you should
-simply call `srt_accept` on the first listener socket that reports readiness,
-and this function is actually a friendly shortcut that uses waiting on epoll
-and `srt_accept` internally. This function supports an important use case for
-accepting a group connection, for which every member connection is expected to
-be established over a different listener socket.
-
-Note that there's no special set of settings required or rejected for this
-function. The group-member connections for the same group can be established
-over various different listener sockets always when all those listeners are
-hosted by the same application, as the group management is global for the
-application, so a connection reporting in for an already connected group
-gets discovered and the connection will be handled in the background,
-regardless to which listener socket the call was done - as long as the
-connection is accepted according to any additional conditions.
-
-This function has still nothing to do with the groups - you can use it in
-any case when you have one service that accepts connections to multiple
-endpoints. Note also that the settings as to whether listeners should
-accept or reject socket or group connections, should be applied to the
-listener sockets appropriately prior to calling this function.
-
-- Returns:
-
-  * On success, a valid SRT socket or group ID to be used for transmission
-  * `SRT_ERROR` (-1) on failure 
-
-- Errors:
-
-  * `SRT_EINVPARAM`: NULL specified as `listeners` or `nlisteners` < 1
-
-  * `SRT_EINVSOCK`: any socket in `listeners` designates no valid socket ID.
-Can also mean Internal Error when an error occurred while creating an
-accepted socket (**BUG?**)
-
-  * `SRT_ENOLISTEN`: any socket in `listeners` is not set up as a listener
-(`srt_listen` not called, or the listener socket has already been closed)
-
-  * `SRT_EASYNCRCV`: No connection reported on any listener socket as the
-timeout has been reached. This error is only reported when msTimeOut is
-not -1
-
-
-### srt_listen_callback
-
-```
-int srt_listen_callback(SRTSOCKET lsn, srt_listen_callback_fn* hook_fn, void* hook_opaque);
-```
-
-This call installs a callback hook, which will be executed on a socket that is
-automatically created to handle the incoming connection on the listening
-socket (and is about to be returned by `srt_accept`), but before the connection
-has been accepted.
-
-* `lsn`: Listening socket where you want to install the callback hook
-* `hook_fn`: The callback hook function pointer
-* `hook_opaque`: The pointer value that will be passed to the callback function
-
-- Returns:
-
-   * 0, if successful
-   * -1, on error
-
-- Errors:
-
-   * `SRT_EINVPARAM` reported when `hook_fn` is a null pointer
-
-The callback function has the signature as per this type definition:
-```
-typedef int srt_listen_callback_fn(void* opaque, SRTSOCKET ns, int hs_version
-             const struct sockaddr* peeraddr, const char* streamid);
-```
-
-The callback function gets the following parameters passed:
-
-* `opaque`: The pointer passed as `hook_opaque` when registering
-* `ns`: The freshly created socket to handle the incoming connection
-* `hs_version`: The handshake version (usually 5, pre-1.3 versions use 4)
-* `peeraddr`: The address of the incoming connection
-* `streamid`: The value set to `SRTO_STREAMID` option set on the peer side
-
-(Note that versions that use handshake version 4 are incapable of using
-any extensions, such as streamid, however they do support encryption.
-Note also that the SRT version isn't yet extracted, however you can
-prevent too old version connections using `SRTO_MINVERSION` option).
-
-The callback function is given an opportunity to:
-
-* use the passed information (streamid and peer address) to decide
-  what to do with this connection
-* alter any options on the socket, which could not be set properly
-  before on the listening socket to be derived by the accepted socket,
-  and won't be allowed to be altered after the socket is returned by
-  `srt_accept`
-
-Note that the returned socket has already set all derived options from the
-listener socket, as it happens normally, and the moment when this callback is
-called is when the conclusion handshake has been already received from the
-caller party, but not yet interpreted (the streamid field is extracted from it
-prematurely). When you, for example, set a passphrase on the socket at this
-very moment, the Key Material processing will happen against this already set
-passphrase, after the callback function is finished.
-
-The callback function shall return 0, if the connection is to be accepted.
-If you return -1, **or** if the function throws an exception, this will be
-understood as a request to reject the incoming connection - in which case the
-about-to-be-accepted socket will be silently deleted and `srt_accept` will not
-report it. Note that in case of non-blocking mode the epoll bits for read-ready
-on the listener socket will not be set if the connection is rejected, including
-when rejected from this user function.
-
-**IMPORTANT**: This function is called in the receiver worker thread, which
-means that it must do its checks and operations as quickly as possible and keep
-the minimum possible time, as every delay you do in this function will burden
-the processing of the incoming data on the associated UDP socket, which in case
-of a listener socket means the listener socket itself and every socket accepted
-off this listener socket. Avoid any extensive search operations, best cache in
-memory whatever database you have to check against the data received in
-streamid or peeraddr.
-
-
-### srt_connect
-
-```
-int srt_connect(SRTSOCKET u, const struct sockaddr* name, int namelen);
-```
-
-Connects a socket or a group to a remote party with a specified address and port.
-
-* `u`: can be an SRT socket or SRT group, both freshly created and not yet
-  used for any connection, except possibly `srt_bind` on the socket
-* `name`: specification of the remote address and port
-* `namelen`: size of the object passed by `name`
-
-**NOTES:**
-1. The socket used here may be bound from upside (or binding and connection can
-be done in one function, `srt_connect_bind`) so that it uses a predefined
-network interface or local outgoing port. If not, it behaves as if it was
-bound to `INADDR_ANY` (which binds on all interfaces) and port 0 (which
-makes the system assign the port automatically).
-2. When `u` is a group, then this call can be done multiple times, each time
-for another member connection, and a new member SRT socket will be created
-automatically for every call of this function.
-3. If you want to connect a group to multiple links at once and use blocking
-mode, you might want to use `srt_connect_group` instead.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error
-  * 0 in case when used for `u` socket
-  * Socket ID created for connection for `u` group
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-  * `SRT_ERDVUNBOUND`: Socket `u` has set `SRTO_RENDEZVOUS` to true, but `srt_bind`
-hasn't yet been called on it. The `srt_connect` function is also used to connect a
-rendezvous socket, but rendezvous sockets must be explicitly bound to a local
-interface prior to connecting. Non-rendezvous sockets (caller sockets) can be
-left without binding - the call to `srt_connect` will bind them automatically.
-  * `SRT_ECONNSOCK`: Socket `u` is already connected
-  * `SRT_ECONNREJ`: Connection has been rejected
-  * `SRT_ENOSERVER`: Connection has been timed out (see `SRTO_CONNTIMEO`)
-  * `SRT_ESCLOSED`: The socket `u` has been closed while the function was
-blocking the call (if `SRTO_RCVSYN` is set to default true)
-
-When `SRT_ECONNREJ` error is reported, you can get the reason for
-a rejected connection from `srt_getrejectreason`. In non-blocking
-mode (when `SRTO_RCVSYN` is set to false), only `SRT_EINVSOCK`,
-`SRT_ERDVUNBOUND` and `SRT_ECONNSOCK` can be reported. In all other cases
-the function returns immediately with a success, and the only way to obtain
-the connecting status is through the epoll flag with `SRT_EPOLL_ERR`.
-In this case you can also call `srt_getrejectreason` to get the detailed
-reason for the error, including connection timeout (`SRT_REJ_TIMEOUT`).
-
-
-### srt_connect_bind
-
-```
-int srt_connect_bind(SRTSOCKET u, const struct sockaddr* source,
-                     const struct sockaddr* target, int len);
-```
-
-This function does the same as first `srt_bind` then `srt_connect`, if called
-with `u` being a socket. If `u` is a group, then it will execute `srt_bind`
-first on the automatically created socket for the connection.
-
-* `u`: Socket or group to connect
-* `source`: Address to bind `u` to
-* `target`: Address to connect
-* `len`: size of the original structure of `source` and `target`
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error
-  * 0 in case when used for `u` socket
-  * Socket ID created for connection for `u` group
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket passed as `u` designates no valid socket
-  * `SRT_EINVOP`: Socket already bound
-  * `SRT_ECONNSETUP`: Internal creation of a UDP socket failed
-  * `SRT_ESOCKFAIL`: Internal configuration of a UDP socket (`bind`, `setsockopt`) failed
-  * `SRT_ERDVUNBOUND`: Internal error (`srt_connect` should not report it after `srt_bind` was called)
-  * `SRT_ECONNSOCK`: Socket `u` is already connected
-  * `SRT_ECONNREJ`: Connection has been rejected
-
-IMPORTANT: It's not allowed to bind and connect the same socket to two
-different families (that is, both `source` and `target` must be `AF_INET` or
-`AF_INET6`), although you may mix links over IPv4 and IPv6 in one group.
-
-### srt_connect_debug
-
-```
-int srt_connect_debug(SRTSOCKET u, const struct sockaddr* name, int namelen, int forced_isn);
-```
-
-This function is for developers only and can be used for testing. It does the 
-same thing as [`srt_connect`](#srt_connect), with the exception that it allows 
-specifying the Initial Sequence Number for data transmission. Normally this value 
-is generated randomly.
-
-### srt_rendezvous
-```
-int srt_rendezvous(SRTSOCKET u, const struct sockaddr* local_name, int local_namelen,
-        const struct sockaddr* remote_name, int remote_namelen);
-```
-Performs a rendezvous connection. This is a shortcut for doing bind locally,
-setting the `SRTO_RENDEZVOUS` option to true, and doing `srt_connect`. 
-
-* `u`: socket to connect
-* `local_name`: specifies the local network interface and port to bind
-* `remote_name`: specifies the remote party's IP address and port
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket passed as `u` designates no valid socket
-  * `SRT_EINVOP`: Socket already bound
-  * `SRT_ECONNSETUP`: Internal creation of a UDP socket failed
-  * `SRT_ESOCKFAIL`: Internal configuration of a UDP socket (`bind`, `setsockopt`) failed
-  * `SRT_ERDVUNBOUND`: Internal error (`srt_connect` should not report it after `srt_bind` was called)
-  * `SRT_ECONNSOCK`: Socket `u` is already connected
-  * `SRT_ECONNREJ`: Connection has been rejected
-
-IMPORTANT: It's not allowed to perform a rendezvous connection to two
-different families (that is, both `local_name` and `remote_name` must be `AF_INET` or
-`AF_INET6`).
-
-### srt_connect_callback
-```
-int srt_connect_callback(SRTSOCKET u, srt_connect_callback_fn* hook_fn, void* hook_opaque);
-```
-
-This call installs a callback hook, which will be executed on a given `u`
-socket or all member sockets of `u` group, just after the pending connection
-situation in the background has been resolved and the connection has failed.
-Note that this function is not guaranteed to be called if the `u` socket is set
-to blocking mode (`SRTO_RCVSYN` option set to true). It is guaranteed to be
-called when a socket is in non-blocking mode, or when you use a group.
-
-This function is mainly intended to be used with group connections. Note that
-even if you use a group connection in blocking mode, after the group is considered
-connected the member connections still continue in background. Also, when
-some connections are still pending and others have failed, the blocking
-call for `srt_connect_group` will not exit until at least one of them succeeds
-or all fail - in such a case those failures also happen only in the background,
-while the connecting function blocks until all connections are resolved. 
-When all links fail, you will only get a general error code for the group.
-This mechanism allows you to get individual errors for particular member
-connection failures.
-
-You can also use this mechanism as an alternative method for a single-socket
-connection in non-blocking mode to trigger an action when the connection
-process is finished. It is recommended, however, that you use this callback
-only to collect failure information, as the call will happen in one of the
-internal SRT threads.
-
-* `u`: Socket or group that will be used for connecting and for which the hook is installed
-* `hook_fn`: The callback hook function pointer
-* `hook_opaque`: The pointer value that will be passed to the callback function
-
-- Returns:
-
-   * 0, if successful
-   * -1, on error
-
-- Errors:
-
-   * `SRT_EINVPARAM` reported when `hook_fn` is a null pointer
-
-The callback function signature has the following type definition:
-
-```
-typedef void srt_connect_callback_fn(void* opaq, SRTSOCKET ns, int errorcode, const struct sockaddr* peeraddr, int token);
-```
-where:
-
-* `opaq`: The pointer passed as `hook_opaque` when registering
-* `ns`: The socket for which the connection process was resolved
-* `errorcode`: The error code, same as for `srt_connect` for blocking mode
-* `peeraddr`: The target address passed to `srt_connect` call
-* `token`: The token value, if it was used for group connection, otherwise -1
-
-
-## Socket group management
-
-### SRT_GROUP_TYPE
-
-The following group types are collected in an `SRT_GROUP_TYPE` enum:
-
-* `SRT_GTYPE_BROADCAST`: broadcast type, all links are actively used at once
-* `SRT_GTYPE_BACKUP`: backup type, idle links take over connection on disturbance
-* `SRT_GTYPE_BALANCING`: balancing type, share bandwidth usage between links
-
-### SRT_SOCKGROUPCONFIG
-
-This structure is used to define entry points for connections for the
-`srt_connect_group` function:
-
-```
-typedef struct SRT_GroupMemberConfig_
-{
-    SRTSOCKET id;
-    struct sockaddr_storage srcaddr;
-    struct sockaddr_storage peeraddr;
-    int weight;
-    SRT_SOCKOPT_CONFIG* config;
-    int errorcode;
-    int token;
-} SRT_SOCKGROUPCONFIG;
-```
-
-where:
-
-* `id`: member socket ID (filled back as output)
-* `srcaddr`: address to which `id` should be bound
-* `peeraddr`: address to which `id` should be connected
-* `weight`: the weight parameter for the link (group-type dependent)
-* `config`: the configuration object, if used (see [`srt_create_config()`](#srt_create_config))
-* `errorcode`: status of the connecting operation
-* `token`: An integer value unique for every connection, or -1 if unused
-
-The `srt_perpare_endpoint` sets these fields to default values. After that
-you can change the value of `weight` and `config` and `token` fields. The
-`weight` parameter's meaning is dependent on the group type:
-
-* BROADCAST: not used
-* BACKUP: positive value of link priority (the greater, the more preferred)
-* BALANCING: relative expected load on this link for fixed algorithm
-
-In any case, the allowed value ranges for `weight` is between 0 and 32767.
-
-The `config` parameter is used to provide options to be set separately
-on a socket for a particular connection  (see [`srt_create_config()`](#srt_create_config)).
-
-The `token` value is intended to allow the application to more easily identify
-a particular connection. If you don't use it and leave the default value of -1,
-the library will set a unique value for the next connection (a 32-bit unsigned
-number that will overflow by itself; the default value will be skipped).
-The application can also set a unique value by itself and keep the same
-value for the same connection.
-
-
-### SRT_SOCKGROUPDATA
-
-The most important structure for the group member status is `SRT_SOCKGROUPDATA`:
-
-```c++
-typedef struct SRT_SocketGroupData_
-{
-    SRTSOCKET id;
-    struct sockaddr_storage peeraddr;
-    SRT_SOCKSTATUS sockstate;
-    uint16_t weight;
-    SRT_MEMBERSTATUS memberstate;
-    int result;
-    int token;
-} SRT_SOCKGROUPDATA;
-```
-
-where:
-
-* `id`: member socket ID
-* `peeraddr`: address to which `id` should be connected
-* `sockstate`: current connection status (see [`srt_getsockstate`](#srt_getsockstate))
-* `weight`: current weight value set on the link
-* `memberstate`: current state of the member (see below)
-* `result`: result of the operation (if this operation recently updated this structure)
-* `token`: A token value set for that connection (see [`SRT_SOCKGROUPCONFIG`](#srt_sockgroupconfig))
-
-### SRT_MEMBERSTATUS
-
-The enumeration type that defines the state of the member
-connection in the group:
-
-* `SRT_GST_PENDING`: The connection is in progress, so the socket
-is not currently being used for transmission, even potentially,
-and still has a chance to fail and transit into `SRT_GST_BROKEN`
-without turning into `SRT_GST_IDLE`
-
-* `SRT_GST_IDLE`: The connection is established and ready to
-take over transmission, but it's not used for transmission at
-the moment. This state may last for a short moment in case of
-broadcast or balancing groups. In backup groups this state
-defines a backup link that is ready to take over when the
-currently active (running) link gets unstable.
-
-* `SRT_GST_RUNNING`: The connection is established and at least
-one packet has already been sent or received over it.
-
-* `SRT_GST_BROKEN`: The connection was broken. Broken connections
-are not to be revived. Note also that it is only possible to see this
-state if it is read by `srt_sendmsg2` or `srt_recvmsg2` just after
-the link failure has been detected. Otherwise, the broken link simply 
-disappears from the member list.
-
-Note that internally the member state is separate for sending and
-receiving. If the `memberstate` field of `SRT_SOCKGROUPDATA` is
-`SRT_GST_RUNNING`, it means that this is the state in at least one
-direction, while in the other direction it may be `SRT_GST_IDLE`. In all
-other cases the states should be the same in both directions.
-
-States should normally start with `SRT_GST_PENDING` and then
-turn into `SRT_GST_IDLE`. Once a new link is used for sending data, 
-the state becomes `SRT_GST_RUNNING`. 
-In case of `SRT_GTYPE_BACKUP` type group, if a link is in
-`SRT_GST_RUNNING` state, but another link is chosen to remain
-as the only active one, this link will be "silenced" (its state will
-become `SRT_GST_IDLE`).
-
-
-## Functions to be used on groups:
-
-### srt_create_group
-
-```
-SRTSOCKET srt_create_group(SRT_GROUP_TYPE type);
-```
-
-Creates a new group of type `type`. This is typically called on the
-caller side to be next used for connecting to the listener peer side.
-The group ID is of the same domain as socket ID, with the exception that
-the `SRTGROUP_MASK` bit is set on it, unlike for socket ID.
-
-### srt_include
-
-```
-int srt_include(SRTSOCKET socket, SRTSOCKET group);
-```
-
-This function adds a socket to a group. This is only allowed for unmanaged
-groups. No such group type is currently implemented.
-
-### srt_exclude
-
-```
-int srt_exclude(SRTSOCKET socket);
-```
-This function removes a socket from a group to which it currently belongs.
-This is only allowed for unmanaged groups. No such group type is currently
-implemented.
-
-### srt_groupof
-
-```
-SRTSOCKET srt_groupof(SRTSOCKET socket);
-```
-
-Returns the group ID of the socket, or `SRT_INVALID_SOCK` if the socket
-doesn't exist or it's not a member of any group.
-
-### srt_group_data 
-
-```
-int srt_group_data(SRTSOCKET socketgroup, SRT_SOCKGROUPDATA output[], size_t* inoutlen);
-```
-
-* `socketgroup` an existing socket group ID
-* `output` points to an output array
-* `inoutlen` points to a variable that stores the size of the `output` array,
-  and is set to the filled array's size
-
-This function obtains the current member state of the group specified in
-`socketgroup`. The `output` should point to an array large enough to hold
-all the elements. The `inoutlen` should point to a variable initially set
-to the size of the `output` array.
-The current number of members will be written back to `inoutlen`.
-
-If the size of the `output` array is enough for the current number of members,
-the `output` array will be filled with group data and the function will return
-the number of elements filled.
-Otherwise the array will not be filled and `SRT_ERROR` will be returned.
-
-This function can be used to get the group size by setting `output` to `NULL`,
-and providing `socketgroup` and `inoutlen`.
-
-- Returns:
-
-   * the number of data elements filled, on success
-   * -1, on error
-
-- Errors:
-
-   * `SRT_EINVPARAM` reported if `socketgroup` is not an existing group ID
-   * `SRT_ELARGEMSG` reported if `inoutlen` if less than the size of the group
-
-| in:output | in:inoutlen    | returns      | out:output | out:inoutlen | Error |
-|-----------|----------------|--------------|-----------|--------------|--------|
-| NULL      | NULL           | -1           | NULL      | NULL         | `SRT_EINVPARAM` |
-| NULL      | ptr            | 0            | NULL      | group.size() | ✖️ |
-| ptr       | NULL           | -1           | ✖️         | NULL         | `SRT_EINVPARAM` |
-| ptr       | ≥ group.size   | group.size() | group.data | group.size | ✖️ |
-| ptr       | < group.size   | -1           | ✖️         | group.size  | `SRT_ELARGEMSG` |
-
-
-### srt_connect_group
-
-```
-int srt_connect_group(SRTSOCKET group,
-                      SRT_SOCKGROUPCONFIG name [], int arraysize);
-```
-
-This function does almost the same as calling `srt_connect` or `srt_connect_bind`
-(when the source was specified for `srt_prepare_endpoint`) in a loop for every
-item specified in `name` array. However if you did this in blocking mode, the
-first call to `srt_connect` would block until the connection is established,
-whereas this function blocks until any of the specified connections is
-established.
-
-If you set the group nonblocking mode (`SRTO_RCVSYN` option), there's no
-difference, except that the `SRT_SOCKGROUPCONFIG` structure allows you
-to add extra configuration data used by groups. Note also that this function
-accepts only groups, not sockets.
-
-The elements of the `name` array need to be prepared with the use of the
-[`srt_prepare_endpoint`](#srt_prepare_endpoint) function. Note that it is
-**NOT** required that every target address you specify for it is of the same
-family.
-
-Return value and errors in this function are the same as in `srt_connect`,
-although this function reports success when at least one connection has
-succeeded. If none has succeeded, this function reports `SRT_ECONNLOST`
-error. Particular connection states can be obtained from the `name`
-array upon return from the `errorcode` field.
-
-The fields of `SRT_SOCKGROUPCONFIG` structure have the following meaning:
-
-Input:
-
-* `id`: unused, should be -1 (default when created by `srt_prepare_endpoint`)
-* `srcaddr`: address to bind before connecting, if specified (see below for details)
-* `peeraddr`: target address to connect
-* `weight`: weight value to be set on the link
-* `config`: socket options to be set on the socket before connecting
-* `errorcode`: unused, should be `SRT_SUCCESS` (default)
-* `token`: An integer value unique for every connection, or -1 if unused
-
-Output:
-
-* `id`: The socket created for that connection (-1 if failed to create)
-* `srcaddr`: unchanged
-* `peeraddr`: unchanged
-* `weight`: unchanged
-* `config`: unchanged (the object should be manually deleted upon return)
-* `errorcode`: status of connection for that link (`SRT_SUCCESS` if succeeded)
-* `token`: same as in input, or a newly created token value if input was -1
-
-The procedure of connecting for every connection definition specified
-in the `name` array is performed the following way:
-
-1. The socket for this connection is first created
-
-2. Socket options derived from the group are set on that socket.
-
-3. If `config` is not NULL, configuration options stored there are set on that socket.
-
-4. If source address is specified (that is `srcaddr` value is **not**
-default empty, as described in [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG)),
-then the binding operation is being done on the socket (see `srt_bind`).
-
-5. The socket is added to the group as a member.
-
-6. The socket is being connected to the target address, as specified
-in the `peeraddr` field.
-
-During this process there can be errors at any stage. There are two
-possibilities as to what may happen in this case:
-
-1. If creation of a new socket has failed, which may only happen due to
-problems with system resources, then the whole loop is interrupted and no
-further items in the array are processed. All sockets that got created until
-then, and for which the connection attempt has at least successfully started,
-remain group members, although the function will return immediately with an
-error status (that is, without waiting for the first successful connection). If
-your application wants to do any partial recovery from this situation, it can
-only use epoll mechanism to wait for readiness.
-
-2. In any other case, if an error occurs at any stage of the above process, the
-processing is interrupted for this very array item only, the socket used for it
-is immediately closed, and the processing of the next elements continues. In case
-of connection process, it also passes two stages - parameter check and the process
-itself. Failure at the parameter check breaks this process, while if this check
-passed, this item is considered correctly processed, even if the connection
-attempt is going to fail later. If this function is called in the blocking mode,
-it then blocks until at least one connection reports success or if all of them
-fail. Connections that continue in the background after this function exits can
-be then checked status by [`srt_group_data`](#srt_group_data).
-
-As member socket connections are running in the background, for determining 
-if a particular connection has succeeded or failed it is recommended
-to use [`srt_connect_callback`](#srt_connect_callback). In this case the
-`token` callback function parameter will be the same as the `token` value used
-for the particular item in the `name` connection table.
-
-The `token` value doesn't have any limitations except that the -1 value is
-a "trap representation", that is, when set on input it will make the internals
-define a unique value for the `token`. Your application can also set unique values,
-in which case the `token` value will be preserved.
-
-
-### srt_prepare_endpoint
-
-```
-SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src /*nullable*/,
-                                       const struct sockaddr* adr, int namelen);
-```
-
-This function prepares a default `SRT_SOCKGROUPCONFIG` object as an element
-of the array you can prepare for `srt_connect_group` function, filled with
-additional data:
-
-* `src`: address to which the newly created socket should be bound
-* `adr`: address to which the newly created socket should connect
-* `namelen`: size of both `src` and `adr`
-
-The following fields are set by this function:
-
-* `id`: -1 (unused for input)
-* `srcaddr`: default empty (see below) or copied from `src`
-* `peeraddr`: copied from `adr`
-* `weight`: 0
-* `config`: `NULL`
-* `errorcode`: `SRT_SUCCESS`
-
-The default empty `srcaddr` is set the following way:
-
-* `ss_family` set to the same value as `adr->sa_family`
-* empty address (`INADDR_ANY` for IPv4 and `in6addr_any` for IPv6)
-* port number 0
-
-If `src` is not NULL, then `srcaddr` is copied from `src`. Otherwise
-it will remain as default empty.
-
-The `adr` parameter is obligatory. If `src` parameter is not NULL,
-then both `adr` and `src` must have the same value of `sa_family`.
-
-Note though that this function has no possibility of reporting errors - these
-would be reported only by `srt_connect_group`, separately for every individual
-connection, and the status can be obtained from `errorcode` field.
-
-
-### srt_create_config
-
-```
-SRT_SOCKOPT_CONFIG* srt_create_config();
-```
-
-Creates a dynamic object for specifying the socket options. You can
-add options to be set on the socket by `srt_config_add` and then
-mount this object into the `config` field in `SRT_SOCKGROUPCONFIG`
-object for that particular connection. After the object is no
-longer needed, you should delete it using `srt_delete_config`.
-
-Returns:
-
-* The pointer to the created object (memory allocation errors apply)
-
-
-### srt_delete_config
-
-```
-void srt_delete_config(SRT_SOCKOPT_CONFIG* c);
-```
-
-Deletes the configurartion object.
-
-
-### srt_config_add
-
-```
-int srt_config_add(SRT_SOCKOPT_CONFIG* c, SRT_SOCKOPT opt, void* val, int len);
-```
-
-Adds a configuration option to the configuration object.
-Parameters have meanings similar to `srt_setsockflag`. Note
-that not every option is allowed to be set this way. However,
-the option (if allowed) isn't checked if it doesn't
-violate other preconditions. This will be checked when the
-option is being set on the socket, which may fail as a part
-of the connection process done by `srt_connect_group`.
-
-This function should be used when this option must be set
-individually on a socket and differently for particular link.
-If you need to set some option the same way on every socket,
-you should rather set this option on the whole group.
-
-The following options are allowed to be set on the member socket:
-
-* `SRTO_SNDBUF`: Allows for larger sender buffer for slower links
-* `SRTO_RCVBUF`: Allows for larger receiver buffer for longer recovery
-* `SRTO_UDP_RCVBUF`: UDP receiver buffer, if this link has a big flight window
-* `SRTO_UDP_SNDBUF`: UDP sender buffer, if this link has a big flight window
-* `SRTO_SNDDROPDELAY`: When particular link tends to drop too eagerly
-* `SRTO_NAKREPORT`: If you don't want NAKREPORT to work for this link
-* `SRTO_CONNTIMEO`: If you want to give more time to connect on this link
-* `SRTO_LOSSMAXTTL`: If this link tends to suffer from UDP reordering
-* `SRTO_PEERIDLETIMEO`: If you want to be more tolerant for temporary outages
-* `SRTO_GROUPSTABTIMEO`: To set ACK jitter tolerance per individual link
-
-
-Returns: 0 if succeeded, -1 when failed
-
-Errors:
-
-* `SRT_EINVPARAM`: this option is not allowed to be set on a socket
-being a group member
-
-## Options and properties
-
-### srt_getpeername
-```
-int srt_getpeername(SRTSOCKET u, struct sockaddr* name, int* namelen);
-```
-
-Retrieves the remote address to which the socket is connected.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-  * `SRT_ENOCONN`: Socket `u` isn't connected, so there's no remote address to return
-
-### srt_getsockname
-```
-int srt_getsockname(SRTSOCKET u, struct sockaddr* name, int* namelen);
-```
-
-Extracts the address to which the socket was bound. Although you  should know 
-the address(es) that you have used for binding yourself, this function can be 
-useful for extracting the local outgoing port number when it was specified as 0 
-with binding for system autoselection. With this function you can extract the 
-port number after it has been autoselected.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-  * `SRT_ENOCONN`: Socket `u` isn't bound, so there's no local
-address to return (**BUG?** It should rather be `SRT_EUNBOUNDSOCK`)
-
-### srt_getsockopt, srt_getsockflag
-```
-int srt_getsockopt(SRTSOCKET u, int level /*ignored*/, SRT_SOCKOPT opt, void* optval, int* optlen);
-int srt_getsockflag(SRTSOCKET u, SRT_SOCKOPT opt, void* optval, int* optlen);
-```
-
-Gets the value of the given socket option (from a socket or a group). The first
-version (`srt_getsockopt`) respects the BSD socket API convention, although the
-"level" parameter is ignored.  The second version (`srt_getsockflag`) omits the
-"level" parameter completely.
-
-Options correspond to various data types, so you need to know what data type is 
-assigned to a particular option, and to pass a variable of the appropriate data 
-type. Specifications are provided in the `apps/socketoptions.hpp` file at the 
-`srt_options` object declaration.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-  * `SRT_EINVOP`: Option `opt` indicates no valid option
-
-### srt_setsockopt, srt_setsockflag
-
-```
-int srt_setsockopt(SRTSOCKET u, int level /*ignored*/, SRT_SOCKOPT opt, const void* optval, int optlen);
-int srt_setsockflag(SRTSOCKET u, SRT_SOCKOPT opt, const void* optval, int optlen);
-```
-
-Sets a value for a socket option in the socket or group. The first version
-(`srt_setsockopt`) respects the BSD socket API convention, although the "level"
-parameter is ignored. The second version (`srt_setsockflag`) omits the "level"
-parameter completely.
-
-Options correspond to various data types, so you need to know what data type is 
-assigned to a particular option, and to pass a variable of the appropriate data 
-type with the option value to be set.
-
-Please note that some of the options can only be set on sockets or only on
-groups, although most of the options can be set on the groups so that they
-are then derived by the member sockets.
-
-- Returns:
-
-  * `SRT_ERROR` (-1) in case of error, otherwise 0
-
--Errors:
-
-  * `SRT_EINVSOCK`: Socket `u` indicates no valid socket ID
-  * `SRT_EINVOP`: Option `opt` indicates no valid option
-  * Various other errors that may result from problems when setting a specific 
-    option (see option description for details).
-
-### srt_getversion
-
-```
-uint32_t srt_getversion();
-```
-
-Get SRT version value. The version format in hex is 0xXXYYZZ for x.y.z in human readable form, 
-where x = ("%d", (version>>16) & 0xff), etc.
-
-- Returns:
-
-  * srt version as an unsigned 32-bit integer
-
-
-## Helper data types for transmission
-
-### SRT_MSGCTRL
-
-The `SRT_MSGCTRL` structure:
-
-```c++
-typedef struct SRT_MsgCtrl_
-{
-   int flags;            // Left for future
-   int msgttl;           // TTL for a message, default -1 (no TTL limitation)
-   int inorder;          // Whether a message is allowed to supersede partially lost one. Unused in stream and live mode.
-   int boundary;         // 0:mid pkt, 1(01b):end of frame, 2(11b):complete frame, 3(10b): start of frame
-   int64_t srctime;      // source time (microseconds since SRT internal clock epoch)
-   int32_t pktseq;       // sequence number of the first packet in received message (unused for sending)
-   int32_t msgno;        // message number (output value for both sending and receiving)
-   SRT_SOCKGROUPDATA* grpdata; // pointer to group data array
-   size_t grpdata_size;  // size of the group array
-} SRT_MSGCTRL;
-```
-
-The `SRT_MSGCTRL` structure is used in `srt_sendmsg2` and `srt_recvmsg2` calls 
-and specifies some special extra parameters:
-
-- `flags`: [IN, OUT]. RESERVED FOR FUTURE USE (should be 0). This is
-intended to specify some special options controlling the details of how the
-called function should work.
-
-- `msgttl`: [IN]. In **message** and **live mode** only, specifies the TTL for 
-sending messages (in `[ms]`). Not used for receiving messages. If this value
-is not negative, it defines the maximum time up to which this message should
-stay scheduled for sending for the sake of later retransmission. A message
-is always sent for the first time, but the UDP packet carrying it may be
-(also partially) lost, and if so, lacking packets will be retransmitted. If
-the message is not successfully resent before TTL expires, further retransmission
-is given up and the message is discarded.
-
-- `inorder`: [IN]. In **message mode** only, specifies that sent messages should 
-be extracted by the receiver in the order of sending. This can be meaningful if 
-a packet loss has happened, and a particular message must wait for retransmission 
-so that it can be reassembled and then delivered. When this flag is false, the 
-message can be delivered even if there are any previous messages still waiting 
-for completion.
-
-- `boundary`: RESERVED FOR FUTURE USE. Intended to be used in a special mode 
-when you are allowed to send or retrieve a part of the message.
-
-- `srctime`:
-  - [OUT] Receiver only. Specifies the time when the packet was intended to be
-delivered to the receiving application (in microseconds since SRT clock epoch).
-  - [IN] Sender only. Specifies the application-provided timestamp to be asociated
-with the packet. If not provided (specified as 0), the current time of SRT internal clock
-is used.
-  - For details on how to use `srctime` please refer to (Time Access)[#time-access] section.
-
-- `pktseq`: Receiver only. Reports the sequence number for the packet carrying
-out the payload being returned. If the payload is carried out by more than one
-UDP packet, only the sequence of the first one is reported. Note that in
-**live mode** there's always one UDP packet per message.
-
-- `msgno`: Message number that can be sent by both sender and receiver,
-although it is required that this value remain monotonic in subsequent send calls. 
-Normally message numbers start with 1 and increase with every message sent.
-
-- 'grpdata' and 'grpdata_size': Pointer and size of the group array. For single
-socket connections these values should remain NULL and 0 respectively. When you
-call `srt_sendmsg2` or `srt_recvmsg2` function for a group, you should pass an
-array here so that you can retrieve the status of particular member sockets.
-If you pass an array that is too small, your `grpdata_size` field will be rewritten with
-the current number of members, but without filling in the array. For details,
-see (Bonding introduction)[bonding-intro.md] and (Socket Groups)[socket-groups.md]
-documents.
-
-**Helpers for `SRT_MSGCTRL`:**
-
-```
-void srt_msgctrl_init(SRT_MSGCTRL* mctrl);
-const SRT_MSGCTRL srt_msgctrl_default;
-```
-
-Helpers for getting an object of `SRT_MSGCTRL` type ready to use. The first is
-a function that fills the object with default values. The second is a constant
-object and can be used as a source for assignment. Note that you cannot pass 
-this constant object into any of the API functions because they require it to be 
-mutable, as they use some fields to output values.
-
-## Transmission
-
-### srt_send, srt_sendmsg, srt_sendmsg2
-```
-int srt_send(SRTSOCKET u, const char* buf, int len);
-int srt_sendmsg(SRTSOCKET u, const char* buf, int len, int ttl/* = -1*/, int inorder/* = false*/);
-int srt_sendmsg2(SRTSOCKET u, const char* buf, int len, SRT_MSGCTRL *mctrl);
-```
-
-Sends a payload to a remote party over a given socket.
-
-* `u`: Socket used to send. The socket must be connected for this operation.
-* `buf`: Points to the buffer containing the payload to send.
-* `len`: Size of the payload specified in `buf`.
-* `ttl`: Time (in `[ms]`) to wait for a successful delivery. See description of 
-the [`SRT_MSGCTRL::msgttl`](#SRT_MSGCTRL) field.
-* `inorder`: Required to be received in the order of sending. See 
-[`SRT_MSGCTRL::inorder`](#SRT_MSGCTRL).
-* `mctrl`: An object of [`SRT_MSGCTRL`](#SRT_MSGCTRL) type that contains extra 
-parameters, including `ttl` and `inorder`.
-
-The way this function works is determined by the mode set in options, and it has
-specific requirements:
-
-1. In **file/stream mode**, the payload is byte-based. You are not required to
-know the size of the data, although they are only guaranteed to be received
-in the same byte order.
-
-2. In **file/message mode**, the payload that you send using this function is 
-a single message that you intend to be received as a whole. In other words, a 
-single call to this function determines a message's boundaries.
-
-3. In **live mode**, you are only allowed to send up to the length of
-`SRTO_PAYLOADSIZE`, which can't be larger than 1456 bytes (1316 default).
-
-- Returns:
-
-  * Size of the data sent, if successful. Note that in **file/stream mode** the
-returned size may be less than `len`, which means that it didn't send the
-whole contents of the buffer. You would need to call this function again
-with the rest of the buffer next time to send it completely. In both
-**file/message** and **live mode** the successful return is always equal to `len`
-  * In case of error, `SRT_ERROR` (-1)
-
-- Errors:
-
-  * `SRT_ENOCONN`: Socket `u` used when the operation is not connected.
-  * `SRT_ECONNLOST`: Socket `u` used for the operation has lost its connection.
-  * `SRT_EINVALMSGAPI`: Incorrect API usage in **message mode**:
-    * **live mode**: trying to send more bytes at once than `SRTO_PAYLOADSIZE`
-    or wrong source time was provided.
-  * `SRT_EINVALBUFFERAPI`: Incorrect API usage in **stream mode**:
-    * Reserved for future use. The congestion controller object
-      used for this mode doesn't use any restrictions on this call for now,
-      but this may change in future.
-  * `SRT_ELARGEMSG`: Message to be sent can't fit in the sending buffer (that is,
-it exceeds the current total space in the sending buffer in bytes). This means
-that the sender buffer is too small, or the application is trying to send
-a larger message than initially predicted.
-  * `SRT_EASYNCSND`: There's no free space currently in the buffer to schedule
-the payload. This is only reported in non-blocking mode (`SRTO_SNDSYN` set
-to false); in blocking mode the call is blocked until enough free space in
-the sending buffer becomes available.
-  * `SRT_ETIMEOUT`: The condition described above still persists and the timeout
-has passed. This is only reported in blocking mode when `SRTO_SNDTIMEO` is
-set to a value other than -1.
-  * `SRT_EPEERERR`: This is reported only in the case where, as a stream is being 
-  received by a peer, the `srt_recvfile` function encounters an error during a 
-  write operation on a file. This is reported by a `UMSG_PEERERROR` message from 
-  the peer, and the agent sets the appropriate flag internally. This flag 
-  persists up to the moment when the connection is broken or closed.
-
-### srt_recv, srt_recvmsg, srt_recvmsg2
-
-```
-int srt_recv(SRTSOCKET u, char* buf, int len);
-int srt_recvmsg(SRTSOCKET u, char* buf, int len);
-int srt_recvmsg2(SRTSOCKET u, char *buf, int len, SRT_MSGCTRL *mctrl);
-```
-
-Extracts the payload waiting to be received. Note that `srt_recv` and `srt_recvmsg`
-are identical functions, two different names being kept for historical reasons.
-In the UDT predecessor the application was required to use either the `UDT::recv`
-version for **stream mode** and `UDT::recvmsg` for **message mode**. In SRT this
-distinction is resolved internally by the `SRTO_MESSAGEAPI` flag.
-
-* `u`: Socket used to send. The socket must be connected for this operation.
-* `buf`: Points to the buffer to which the payload is copied
-* `len`: Size of the payload specified in `buf`
-* `mctrl`: An object of [`SRT_MSGCTRL`](#SRT_MSGCTRL) type that contains extra 
-parameters
-
-The way this function works is determined by the mode set in options, and it has 
-specific requirements:
-
-1. In **file/stream mode**, as many bytes as possible are retrieved, that is,
-only so many bytes that fit in the buffer and are currently available. Any
-data that is available but not extracted this time will be available next time.
-
-2. In **file/message mode**, exactly one message is retrieved, with the 
-boundaries defined at the moment of sending. If some parts of the messages are 
-already retrieved, but not the whole message, nothing will be received (the 
-function blocks or returns `SRT_EASYNCRCV`). If the message to be returned does 
-not fit in the buffer, nothing will be received and the error is reported.
-
-3. In **live mode**, the function behaves as in **file/message mode**, although 
-the number of bytes retrieved will be at most the size of `SRTO_PAYLOADSIZE`. In 
-this mode, however, with default settings of `SRTO_TSBPDMODE` and `SRTO_TLPKTDROP`, 
-the message will be received only when its time to play has come, and until then 
-it will be kept in the receiver buffer; also, when the time to play has come
-for a message that is next to the currently lost one, it will be delivered
-and the lost one dropped.
-
-- Returns:
-
-  * Size (\>0) of the data received, if successful.
-  * 0, if the connection has been closed
-  * `SRT_ERROR` (-1) when an error occurs 
-
-- Errors:
-
-  * `SRT_ENOCONN`: Socket `u` used for the operation is not connected.
-  * `SRT_ECONNLOST`: Socket `u` used for the operation has lost connection
-(this is reported only if the connection was unexpectedly broken, not
-when it was closed by the foreign host).
-  * `SRT_EINVALMSGAPI`: Incorrect API usage in **message mode**:
-    * **live mode**: size of the buffer is less than `SRTO_PAYLOADSIZE`
-  * `SRT_EINVALBUFFERAPI`: Incorrect API usage in **stream mode**:
-    * Currently not in use. File congestion control used for **stream mode** 
-     does not restrict the parameters. **???**
-  * `SRT_ELARGEMSG`: Message to be sent can't fit in the sending buffer (that is,
-it exceeds the current total space in the sending buffer in bytes). This means
-that the sender buffer is too small, or the application is trying to send
-a larger message than initially intended.
-  * `SRT_EASYNCRCV`: There are no data currently waiting for delivery. This
-happens only in non-blocking mode (when `SRTO_RCVSYN` is set to false). In
-blocking mode the call is blocked until the data are ready. How this is defined,
-depends on the mode:
-   * In **live mode** (with `SRTO_TSBPDMODE` on), at least one packet must
-   be present in the receiver buffer and its time to play be in the past
-   * In **file/message mode**, one full message must be available,
-     * the next one waiting if there are no messages with `inorder` = false, or 
-     possibly the first message ready with `inorder` = false
-   * In **file/stream mode**, it is expected to have at least one byte of data 
-   still not extracted
-   * `SRT_ETIMEOUT`: The readiness condition described above is still not achieved 
-and the timeout has passed. This is only reported in blocking mode when
-`SRTO_RCVTIMEO` is set to a value other than -1.
-
-### srt_sendfile, srt_recvfile
-
-```
-int64_t srt_sendfile(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block);
-int64_t srt_recvfile(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block);
-```
-
-These are functions dedicated to sending and receiving a file. You need to call
-this function just once for the whole file, although you need to know the size of
-the file prior to sending and also define the size of a single block that should
-be internally retrieved and written into a file in a single step. This influences
-only the performance of the internal operations; from the application perspective
-you just have one call that exits only when the transmission is complete.
-
-* `u`: Socket used for transmission. The socket must be connected.
-* `path`: Path to the file that should be read or written.
-* `offset`: Needed to pass or retrieve the offset used to read or write to a file
-* `size`: Size of transfer (file size, if offset is at 0)
-* `block`: Size of the single block to read at once before writing it to a file
-
-The following values are recommended for the `block` parameter:
-
-```
-#define SRT_DEFAULT_SENDFILE_BLOCK 364000
-#define SRT_DEFAULT_RECVFILE_BLOCK 7280000
-```
-
-You need to pass them to the `srt_sendfile` or `srt_recvfile` function if you 
-don't know what value to chose.
-
-- Returns:
-
-  * Size (\>0) of the transmitted data of a file. It may be less than `size`, if 
-  the size was greater than the free space in the buffer, in which case you have 
-  to send rest of the file next time.
-  * -1 in case of error.
-
-- Errors:
-
-  * `SRT_ENOCONN`: Socket `u` used for the operation is not connected.
-  * `SRT_ECONNLOST`: Socket `u` used for the operation has lost its connection.
-  * `SRT_EINVALBUFFERAPI`: When socket has `SRTO_MESSAGEAPI` = true or 
-  `SRTO_TSBPDMODE` = true.
-(**BUG?**: Looxlike MESSAGEAPI isn't checked)
-  * `SRT_EINVRDOFF`: There is a mistake in `offset` or `size` parameters, which 
-  should match the index availability and size of the bytes available since 
-  `offset` index. This is actually reported for `srt_sendfile` when the `seekg` 
-  or `tellg` operations resulted in error.
-  * `SRT_EINVWROFF`: Like above, reported for `srt_recvfile` and `seekp`/`tellp`.
-  * `SRT_ERDPERM`: The read from file operation has failed (`srt_sendfile`).
-  * `SRT_EWRPERM`: The write to file operation has failed (`srt_recvfile`).
-
-## Diagnostics
-
-General notes concerning the "getlasterror" diagnostic functions: when an API
-function ends up with error, this error information is stored in a thread-local
-storage. This means that you'll get the error of the operation that was last
-performed as long as you call this diagnostic function just after the failed
-function has returned. In any other situation the information provided by the
-diagnostic function is undefined.
-
-### srt_getlasterror
-
-```
-int srt_getlasterror(int* errno_loc);
-```
-
-Get the numeric code of the last error. Additionally, in the variable passed as
-`errno_loc` the system error value is returned, or 0 if there was no system error
-associated with the last error. The system error is:
-
-  * On POSIX systems, the value from `errno`
-  * On Windows, the result from `GetLastError()` call
-
-
-### srt_strerror
-```
-const char* srt_strerror(int code, int errnoval);
-```
-
-Returns a string message that represents a given SRT error code and possibly the
-`errno` value, if not 0.
-
-**NOTE:** *This function isn't thread safe. It uses a static variable to hold the
-error description. There's no problem with using it in a multithreaded environment,
-as long as only one thread in the whole application calls this function at the
-moment*
-
-### srt_getlasterror_str
-```
-const char* srt_getlasterror_str(void);
-```
-
-Get the text message for the last error. It's a shortcut to calling first
-`srt_getlasterror` and then passing the returned value into `srt_strerror`.
-Note that, in contradiction to `srt_strerror`, this function is thread safe.
-
-
-### srt_clearlasterror
-
-```
-void srt_clearlasterror(void);
-```
-
-This function clears the last error. After this call, the `srt_getlasterror` will
-report a "successful" code.
-
-### srt_getrejectreason
-
-```
-int srt_getrejectreason(SRTSOCKET sock);
-```
-This function provides a more detailed reason for the failed connection attempt. 
-It shall be called after a connecting function (such as `srt_connect`)
-has returned an error, the code for which is `SRT_ECONNREJ`. If `SRTO_RCVSYN`
-has been set on the socket used for the connection, the function should also be
-called when the `SRT_EPOLL_ERR` event is set for this socket. It returns a
-numeric code, which can be translated into a message by `srt_rejectreason_str`.
-The following codes are currently reported:
-
-#### SRT_REJ_UNKNOWN
-
-A fallback value for cases when there was no connection rejected.
-
-#### SRT_REJ_SYSTEM
-
-One of system function reported a failure. Usually this means some system
-error or lack of system resources to complete the task.
-
-#### SRT_REJ_PEER
-
-The connection has been rejected by peer, but no further details are available.
-This usually means that the peer doesn't support rejection reason reporting.
-
-#### SRT_REJ_RESOURCE
-
-A problem with resource allocation (usually memory).
-
-#### SRT_REJ_ROGUE
-
-The data sent by one party to another cannot be properly interpreted. This
-should not happen during normal usage, unless it's a bug, or some weird
-events are happening on the network.
-
-#### SRT_REJ_BACKLOG
-
-The listener's backlog has exceeded (there are many other callers waiting for
-the opportunity of being connected and wait in the queue, which has reached
-its limit).
-
-#### SRT_REJ_IPE
-
-Internal Program Error. This should not happen during normal usage and it
-usually means a bug in the software (although this can be reported by both
-local and foreign host).
-
-#### SRT_REJ_CLOSE
-
-The listener socket was able to receive your request, but at this moment it
-is being closed. It's likely that your next attempt will result with timeout.
-
-#### SRT_REJ_VERSION
-
-Any party of the connection has set up minimum version that is required for
-that connection, and the other party didn't satisfy this requirement.
-
-#### SRT_REJ_RDVCOOKIE
-
-Rendezvous cookie collision. This normally should never happen, or the
-probability that this will really happen is negligible. However this can
-be also a result of a misconfiguration that you are trying to make a
-rendezvous connection where both parties try to bind to the same IP
-address, or both are local addresses of the same host - in which case
-the sent handshake packets are returning to the same host as if they
-were sent by the peer, who is this party itself. When this happens,
-this reject reason will be reported by every attempt.
-
-#### SRT_REJ_BADSECRET
-
-Both parties have defined a passprhase for connection and they differ.
-
-#### SRT_REJ_UNSECURE
-
-Only one connection party has set up a password. See also
-`SRTO_ENFORCEDENCRYPTION` flag in API.md.
-
-#### SRT_REJ_MESSAGEAPI
-
-The value for `SRTO_MESSAGEAPI` flag is different on both connection
-parties.
-
-#### SRT_REJ_CONGESTION
-
-The `SRTO_CONGESTION` option has been set up differently on both
-connection parties.
-
-#### SRT_REJ_FILTER
-
-The `SRTO_PACKETFILTER` option has been set differently on both connection
-parties.
-
-#### SRT_REJ_GROUP
-
-The group type or some group settings are incompatible for both connection parties. 
-While every connection within a bonding group may have different target addresses, 
-they should all designate the same endpoint and the same SRT application. If this 
-condition isn't satisfied, then the peer will respond with a different peer group 
-ID for the connection that is trying to contact a machine/application that is 
-completely different from the existing connections in the bonding group.
-
-#### SRT_REJ_TIMEOUT
-
-The connection wasn't rejected, but it timed out. This code is always set on
-connection timeout, but this is the only way to get this state in non-blocking
-mode (see `SRTO_RCVSYN`).
-
-There may also be server and user rejection codes,
-as defined by the `SRT_REJC_INTERNAL`, `SRT_REJC_PREDEFINED` and `SRT_REJC_USERDEFINED`
-constants. Note that the number space from the value of `SRT_REJC_PREDEFINED`
-and above is reserved for "predefined codes" (`SRT_REJC_PREDEFINED` value plus
-adopted HTTP codes). Values above `SRT_REJC_USERDEFINED` are freely defined by
-the application.
-
-### srt_rejectreason_str
-
-```
-const char* srt_rejectreason_str(enum SRT_REJECT_REASON id);
-```
-
-Returns a constant string for the reason of the connection rejected,
-as per given code ID. It provides a system-defined message for
-values below `SRT_REJ_E_SIZE`. For other values below
-`SRT_REJC_PREDEFINED` it returns the string for `SRT_REJ_UNKNOWN`.
-For values since `SRT_REJC_PREDEFINED` on, returns
-"Application-defined rejection reason".
-
-The actual messages assigned to the internal rejection codes, that is,
-less than `SRT_REJ_E_SIZE`, can be also obtained from `srt_rejectreason_msg`
-array.
-
-### srt_setrejectreason
-
-```
-int srt_setrejectreason(SRTSOCKET sock, int value);
-```
-
-Sets the rejection code on the socket. This call is only useful in the
-listener callback. The code from `value` set this way will be set as a
-rejection reason for the socket. After the callback rejects
-the connection, the code will be passed back to the caller peer with the
-handshake response.
-
-Note that allowed values for this function begin with `SRT_REJC_PREDEFINED`
-(that is, you cannot set a system rejection code).
-For example, your application can inform the calling side that the resource
-specified under the `r` key in the StreamID string (see `SRTO_STREAMID`)
-is not availble - it then sets the value to `SRT_REJC_PREDEFINED + 404`.
-
-- Returns:
-  * 0 in case of success.
-  * -1 in case of error.
-
-- Errors:
-
-  * `SRT_EINVSOCK`: Socket `sock` is not an ID of a valid socket
-  * `SRT_EINVPARAM`: `value` is less than `SRT_REJC_PREDEFINED`
-
-### Error codes
-
-All functions that return the status via `int` value return -1 (designated as 
-`SRT_ERROR`) always when the call has failed (in case of resource creation
-functions an appropriate symbol is defined, like `SRT_INVALID_SOCK` for
-`SRTSOCKET`). When this happens, the error code can be obtained from the
-`srt_getlasterror` function. The values for the error are collected in an
-`SRT_ERRNO` enum:
-
-#### `SRT_EUNKNOWN`
-
-Internal error when setting the right error code.
-
-#### `SRT_SUCCESS`
-
-The value set when the last error was cleared and no error has occurred since then.
-
-#### `SRT_ECONNSETUP`
-
-General setup error resulting from internal system state.
-
-#### `SRT_ENOSERVER`
-
-Connection timed out while attempting to connect to the remote address. Note
-that when this happens, `srt_getrejectreason` also reports the timeout reason.
-
-#### `SRT_ECONNREJ`
-
-Connection has been rejected. Additional reject reason can be obtained through
-`srt_getrejectreason` (see above).
-
-#### `SRT_ESOCKFAIL`
-
-An error occurred when trying to call a system function on an internally used
-UDP socket. Note that the detailed system error is available in the extra variable
-passed by pointer to `srt_getlasterror`.
-
-#### `SRT_ESECFAIL`
-
-A possible tampering with the handshake packets was detected, or encryption
-request wasn't properly fulfilled.
-
-#### `SRT_ESCLOSED`
-
-A socket that was vital for an operation called in blocking mode
-has been closed during the operation. Please note that this situation is
-handled differently than the system calls for `connect` and `accept`
-functions for TCP, which simply block indefinitely (or until the standard
-timeout) when the key socket was closed during an operation. When this 
-error is reported, it usually means that the socket passed as the first 
-parameter to `srt_connect*` or `srt_accept` is no longer usable.
-
-
-#### `SRT_ECONNFAIL`
-
-General connection failure of unknown details.
-
-#### `SRT_ECONNLOST`
-
-The socket was properly connected, but the connection has been broken.
-This specialzation is reported from the transmission functions.
-
-#### `SRT_ENOCONN`
-
-The socket is not connected. This can be reported also when the
-connection was broken for a function that checks some characteristic
-socket data.
-
-#### `SRT_ERESOURCE`
-
-System or standard library error reported unexpectedly for unknown purpose.
-Usually it means some internal error.
-
-#### `SRT_ETHREAD`
-
-System was unable to spawn a new thread when requried.
-
-#### `SRT_ENOBUF`
-
-System was unable to allocate memory for buffers.
-
-#### `SRT_ESYSOBJ`
-
-System was unable to allocate system specific objects (such as
-sockets, mutexes or condition variables).
-
-#### `SRT_EFILE`
-
-General filesystem error (for functions operating with file transmission).
-
-#### `SRT_EINVRDOFF`
-
-Failure when trying to read from a given position in the file (file could
-be modified while it was read from).
-
-#### `SRT_ERDPERM`
-
-Read permission was denied when trying to read from file.
-
-#### `SRT_EINVWROFF`
-
-Failed to set position in the written file.
-
-#### `SRT_EWRPERM`
-
-Write permission was denied when trying to write to a file.
-
-#### `SRT_EINVOP`
-
-Invalid operation performed for the current state of a socket. This mainly
-concerns performing `srt_bind*` operations on a socket that
-is already bound.  Once a socket has been been bound, it cannot be bound
-again.
-
-#### `SRT_EBOUNDSOCK`
-
-The socket is currently bound and the required operation cannot be
-performed in this state. Usually it's about an option that can only
-be set on the socket before binding (`srt_bind*`). Note that a socket
-that is currently connected is also considered bound.
-
-#### `SRT_ECONNSOCK`
-
-The socket is currently connected and therefore performing the required
-operation is not possible. Usually concerns setting an option that must
-be set before connecting (although it is allowed to be altered after
-binding), or when trying to start a connecting operation (`srt_connect*`)
-while the socket isn't in a state that allows it (only `SRTS_INIT` or
-`SRTS_OPENED` are allowed).
-
-#### `SRT_EINVPARAM`
-
-This error is reported in a variety of situations when call parameters
-for API functions have some requirements defined and these were not
-satisfied. This error should be reported after an initial check of the
-parameters of the call before even performing any operation. This error
-can be easily avoided if you set the values correctly.
-
-#### `SRT_EINVSOCK`
-
-The API function required an ID of an entity (socket or group) and
-it was invalid. Note that some API functions work only with socket or
-only with group, so they would also return this error if inappropriate
-type of entity was passed, even if it was valid.
-
-#### `SRT_EUNBOUNDSOCK`
-
-The operation to be performed on a socket requires that it first be
-explicitly bound (using `srt_bind*` functions). Currently it applies when
-calling `srt_listen`, which cannot work with an implicitly bound socket.
-
-#### `SRT_ENOLISTEN`
-
-The socket passed for the operation is required to be in the listen
-state (`srt_listen` must be called first).
-
-#### `SRT_ERDVNOSERV`
-
-The required operation cannot be performed when the socket is set to
-rendezvous mode (`SRTO_RENDEZVOUS` set to true). Usually applies when
-trying to call `srt_listen` on such a socket.
-
-#### `SRT_ERDVUNBOUND`
-
-An attempt was made to connect to a socket set to rendezvous mode 
-(`SRTO_RENDEZVOUS` set to true) that was not first bound. A
-rendezvous connection requires setting up two addresses and ports
-on both sides of the connection, then setting the local one with `srt_bind`
-and using the remote one with `srt_connect` (or you can simply
-use `srt_rendezvous`). Calling `srt_connect*` on an unbound socket
-(in `SRTS_INIT` state) that is to be bound implicitly is only allowed
-for regular caller sockets (not rendezvous).
-
-#### `SRT_EINVALMSGAPI`
-
-The function was used incorrectly in the message API. This can happen if:
-
-* The parameters specific for the message API in `SRT_MSGCTRL` type parameter
-were incorrectly specified
-
-* The extra parameter check performed by the congestion controller has
-failed
-
-* The socket is a member of a self-managing group, therefore you should
-perform the operation on the group, not on this socket
-
-
-#### `SRT_EINVALBUFFERAPI`
-
-The function was used incorrectly in the stream (buffer) API, that is,
-either the stream-only functions were used with set message API
-(`srt_sendfile`/`srt_recvfile`) or TSBPD mode was used with buffer API
-(`SRTO_TSBPDMODE` set to true) or the congestion controller has failed
-to check call parameters.
-
-#### `SRT_EDUPLISTEN`
-
-The port tried to be bound for listening is already busy. Note that binding
-to the same port is allowed in general (when `SRTO_REUSEADDR` is true on
-every socket that bound it), but only one such socket can be a listener.
-
-#### `SRT_ELARGEMSG`
-
-Size exceeded. This is reported in the following situations:
-
-* Trying to receive a message, but the read-ready message is larger than
-the buffer passed to the receiving function
-
-* Trying to send a message, but the size of this message exceeds the
-size of the preset sender buffer, so it cannot be stored in the sender buffer.
-
-* With getting group data, the array to be filled is too small.
-
-
-#### `SRT_EINVPOLLID`
-
-The epoll ID passed to an epoll function is invalid
-
-#### `SRT_EPOLLEMPTY`
-
-The epoll container currently has no subscribed sockets. This is reported by an
-epoll waiting function that would in this case block forever. This problem
-might be reported both in a situation where you have created a new epoll
-container and didn't subscribe any sockets to it, or you did, but these
-sockets have been closed (including when closed in a separate thread while the
-waiting function was blocking). Note that this situation can be prevented
-by setting the `SRT_EPOLL_ENABLE_EMPTY` flag, which may be useful when
-you use multiple threads and start waiting without subscribed sockets, so that
-you can subscribe them later from another thread.
-
-#### `SRT_EASYNCFAIL`
-
-General asynchronous failure (not in use currently).
-
-
-#### `SRT_EASYNCSND`
-
-Sending operation is not ready to perform. This error is reported
-when trying to perform a sending operation on a socket that is not
-ready for sending, but `SRTO_SNDSYN` was set to false (when true,
-the function would block the call otherwise).
-
-#### `SRT_EASYNCRCV`
-
-Receiving operation is not ready to perform. This error is reported
-when trying to perform a receiving operation or accept a new socket from the
-listener socket, when the socket is not ready for that operation, but
-`SRTO_RCVSYN` was set to false (when true, the function would block
-the call otherwise).
-
-#### `SRT_ETIMEOUT`
-
-The operation timed out. This can happen if you have a timeout
-set by an option (`SRTO_RCVTIMEO` or `SRTO_SNDTIMEO`), or passed
-as an extra argument (`srt_epoll_wait` or `srt_accept_bond`) and
-the function call was blocking, but the required timeout time has passed.
-
-#### `SRT_ECONGEST`
-
-NOTE: This error is used only in an experimental version that requires
-setting the `SRT_ENABLE_ECN` macro at compile time. Otherwise the
-situation described below results in the usual successful report.
-
-This error should be reported by the sending function when, with
-`SRTO_TSBPDMODE` and `SRTO_TLPKTDROP` set to true, some packets were dropped at
-the sender side (see the description of `SRTO_TLPKTDROP` for details). This
-doesn't concern the data that were passed for sending by the sending function
-(these data are placed at the back of the sender buffer, while the dropped
-packets are at the front). In other words, the operation done by the sending
-function is successful, but the application might want to slow down the sending
-rate to avoid congestion.
-
-#### `SRT_EPEERERR`
-
-This error is reported in a situation when the receiver peer is
-writing to a file that the agent is sending. When the peer encounters
-an error when writing the received data to a file, it sends the
-`UMSG_PEERERROR` message back to the sender, and the sender reports
-this error from the API sending function.
-
-
-
-## Performance tracking
-
-General note concerning sequence numbers used in SRT: they are 32-bit "circular
-numbers" with the most significant bit not included. For example 0x7FFFFFFF
-shifted forward by 3 becomes 2. As far as any comparison is concerned, it can
-be thought of as a "distance" which is an integer
-value expressing an offset to be added to one sequence in order to get the
-second one. This distance is only valid as long as the threshold value isn't
-exceeded, so it's stated that all sequence numbers that are anywhere taken into
-account were systematically updated and they are kept in the range between 0
-and half of the maximum 0x7FFFFFFF. Hence the distance counting procedure
-always assumes that the sequence number are in the required range already, so
-for a numbers like 0x7FFFFFF0 and 0x10, for which the "numeric difference"
-would be 0x7FFFFFE0, the "distance" is 0x20.
-
-### srt_bstats, srt_bistats
-```
-// Performance monitor with Byte counters for better bitrate estimation.
-int srt_bstats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear);
-
-// Performance monitor with Byte counters and instantaneous stats instead of moving averages for Snd/Rcvbuffer sizes.
-int srt_bistats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear, int instantaneous);
-```
-
-Reports the current statistics
-
-* `u`: Socket from which to get statistics
-* `perf`: Pointer to an object to be written with the statistics
-* `clear`: 1 if the statistics should be cleared after retrieval
-* `instantaneous`: 1 if the statistics should use instant data, not moving averages
-
-`SRT_TRACEBSTATS` is an alias to `struct CBytePerfMon`. For a complete description
-of the fields please refer to the document [statistics.md](statistics.md).
-
-## Asynchronous operations (epoll)
-
-The epoll system is currently the only method for using multiple sockets in one
-thread with having the blocking operation moved to epoll waiting so that it can
-block on multiple sockets at once. That is, instead of blocking a single reading
-or writing operation, as it's in blocking mode, it blocks until at least one of
-the sockets subscribed for a single waiting call in given operation mode is ready
-to do this operation without blocking. It's usually combined with setting the
-nonblocking mode on a socket, which in SRT is set separately for reading and
-writing (`SRTO_RCVSYN` and `SRTO_SNDSYN` respectively) in order to ensure that
-in case of some internal error in the application (or even possibly a bug in SRT
-that has reported a spurious readiness report) the operation will end up with
-error rather than cause blocking, which would be more dangerous for the application
-in this case (`SRT_EASYNCRCV` and `SRT_EASYNCRCV` respectively).
-
-The epoll system, similar to the one on Linux, relies on `eid` objects managed
-internally in SRT, which can be subscribed to particular sockets and the 
-readiness status of particular operations. The `srt_epoll_wait` function can 
-then be used to block until any readiness status in the whole `eid` is set.
-
-### srt_epoll_create
-```
-int srt_epoll_create(void);
-```
-
-Creates a new epoll container.
-
-- Returns:
-
-  * valid EID on success
-  * -1 on failure
-
-- Errors:
-
-  * `SRT_ECONNSETUP`: System operation failed or not enough space to create a new epoll.
-System error might happen on systems that use a 
-special method for the system part of epoll (`epoll_create()`, `kqueue()`), and therefore associated resources,
-like epoll on Linux.
-
-### srt_epoll_add_usock, srt_epoll_add_ssock, srt_epoll_update_usock, srt_epoll_update_ssock
-
-```
-int srt_epoll_add_usock(int eid, SRTSOCKET u, const int* events);
-int srt_epoll_add_ssock(int eid, SYSSOCKET s, const int* events);
-int srt_epoll_update_usock(int eid, SRTSOCKET u, const int* events);
-int srt_epoll_update_ssock(int eid, SYSSOCKET s, const int* events);
-```
-
-Adds a socket to a container, or updates an existing socket subscription.
-
-The `_usock` suffix refers to a user socket (SRT socket). 
-The `_ssock` suffix refers to a system socket.
-
-The `_add_` functions add new sockets. The `_update_` functions act on a socket 
-that is in the container already and just allow changes in the subscription 
-details. For example, if you have already subscribed a socket with `SRT_EPOLL_OUT` 
-to wait until it's connected, to change it into poll for read-readiness, you use 
-this function on that same socket with a variable set to `SRT_EPOLL_IN`. This 
-will not only change the event type which is polled on the socket, but also 
-remove any readiness status for flags that are no longer set. It is discouraged
-to perform socket removal and adding back (instead of using `_update_`) because
-this way you may miss an event that could happen in a short moment between
-these two calls.
-
-* `eid`: epoll container id
-* `u`: SRT socket
-* `s`: system socket
-* `events`: points to
-  * a variable set to epoll flags (see below) to use only selected events
-  * NULL if you want to subscribe a socket for all events in level-triggered mode
-
-Possible epoll flags are the following:
-
-   * `SRT_EPOLL_IN`: report readiness for reading or incoming connection on a listener socket
-   * `SRT_EPOLL_OUT`: report readiness for writing or a successful connection
-   * `SRT_EPOLL_ERR`: report errors on the socket
-   * `SRT_EPOLL_UPDATE`: an important event has happened that requires attention
-   * `SRT_EPOLL_ET`: the event will be edge-triggered
-
-All flags except `SRT_EPOLL_ET` are event type flags (important for functions
-that expect only event types and not other flags).
-
-The `SRT_EPOLL_IN`, `SRT_EPOLL_OUT` and `SRT_EPOLL_ERR` events are by default
-**level-triggered**. With `SRT_EPOLL_ET` flag they become **edge-triggered**.
-
-The `SRT_EPOLL_UPDATE` flag is always edge-triggered. It designates a
-special event that happens on a group, or on a listener socket that has the
-`SRTO_GROUPCONNECT` flag set to allow group connections. This flag
-is triggered in the following situations:
-
-* for group connections, when a new link has been established for a group that is already 
-connected (that is, has at least one connection established), `SRT_EPOLL_UPDATE` is 
-reported for the listener socket accepting the connection. This is intended for internal 
-use only. An initial connection results in reporting the group connection on that listener. 
-But when the group is already connected, `SRT_EPOLL_UPDATE`  is reported instead.
-
-* when one of group member connection has been broken
-
-Note that at this time the edge-triggered mode is supported only for SRT
-sockets, not for system sockets.
-
-In the **edge-triggered** mode the function will only return socket states that
-have changed since the last call of the waiting function. All events reported
-in particular call of the waiting function will be cleared in the internal
-flags and will not be reported until the internal signaling logic clears this
-state and raises it again.
-
-In the **level-triggered** mode the function will always return the readiness
-state as long as it lasts, until the internal signaling logic clear it.
-
-Note that when you use `SRT_EPOLL_ET` flag in one subscription call, it defines
-edge-triggered mode for all events passed together with it. However, if you
-want to have some events reported as edge-triggered and others as
-level-triggered, you can do two separate subscriptions for the same socket.
-
-**IMPORTANT**: The `srt_epoll_wait` function does not report
-`SRT_EPOLL_UPDATE` events. If you need the ability to get any possible flag,
-you must use `srt_epoll_uwait`. Note that this function doesn't work with
-system file descriptors.
-
-- Returns:
-
-  * 0 if successful, otherwise -1
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-
-**BUG?**: for `add_ssock` the system error results in an empty `CUDTException()`
-call which actually results in `SRT_SUCCESS`. For cases like that the
-`SRT_ECONNSETUP` code is predicted.
-
-### srt_epoll_remove_usock, srt_epoll_remove_ssock
-
-```
-int srt_epoll_remove_usock(int eid, SRTSOCKET u);
-int srt_epoll_remove_ssock(int eid, SYSSOCKET s);
-```
-
-Removes a specified socket from an epoll container and clears all readiness
-states recorded for that socket.
-
-The `_usock` suffix refers to a user socket (SRT socket). 
-The `_ssock` suffix refers to a system socket.
-
-- Returns:
-
-  * 0 if successful, otherwise -1
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-
-### srt_epoll_wait
-```
-int srt_epoll_wait(int eid, SRTSOCKET* readfds, int* rnum, SRTSOCKET* writefds, int* wnum, int64_t msTimeOut,
-                        SYSSOCKET* lrfds, int* lrnum, SYSSOCKET* lwfds, int* lwnum);
-```
-
-Blocks the call until any readiness state occurs in the epoll container.
-
-Readiness can be on a socket in the container for the event type as per
-subscription. Note that in case when particular event was subscribed with
-`SRT_EPOLL_ET` flag, this event, when once reported in this function, will
-be cleared internally.
-
-The first readiness state causes this function to exit, but all ready sockets
-are reported. This function blocks until the timeout specified in `msTimeOut`
-parameter.  If timeout is 0, it exits immediately after checking. If timeout is
--1, it blocks indefinitely until a readiness state occurs.
-
-* `eid`: epoll container
-* `readfds` and `rnum`: A pointer and length of an array to write SRT sockets that are read-ready
-* `writefds` and `wnum`: A pointer and length of an array to write SRT sockets that are write-ready
-* `msTimeOut`: Timeout specified in milliseconds, or special values (0 or -1)
-* `lwfds` and `lwnum`:A pointer and length of an array to write system sockets that are read-ready
-* `lwfds` and `lwnum`:A pointer and length of an array to write system sockets that are write-ready
-
-Note that the following flags are reported:
-
-* `SRT_EPOLL_IN` as read-ready (also a listener socket ready to accept)
-* `SRT_EPOLL_OUT` as write-ready (also a connected socket)
-* `SRT_EPOLL_ERR` as both read-ready and write-ready
-* `SRT_EPOLL_UPDATE` is not reported
-
-There is no space here to report sockets for which it's already known
-that the operation will end up with error (athough such a state is known
-internally). If an error occurred on a socket then that socket is reported in
-both read-ready and write-ready arrays, regardless of what event types it was
-subscribed for. Usually then you subscribe given socket for only read readiness,
-for example (`SRT_EPOLL_IN`), but pass both arrays for read and write readiness.
-This socket will not be reported in the write readiness array even if it's write
-ready (because this isn't what it was subscribed for), but it will be reported
-there, if the next operation on this socket is about to be erroneous. On such
-sockets you can still perform an operation, just you should expect that it will
-always report and error. On the other hand that's the only way to know what kind
-of error has occurred on the socket.
-
-- Returns:
-
-  * The number (\>0) of ready sockets, of whatever kind (if any)
-  * -1 in case of error
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-  * `SRT_ETIMEOUT`: Up to `msTimeOut` no sockets subscribed in `eid` were ready.
-This is reported only if `msTimeOut` was \>=0, otherwise the function waits
-indefinitely.
-
-### srt_epoll_uwait
-```
-int srt_epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
-```
-
-This function blocks a call until any readiness state occurs in the epoll
-container. Unlike `srt_epoll_wait`, it can only be used with `eid` subscribed
-to user sockets (SRT sockets), not system sockets.
-
-This function blocks until the timeout specified in `msTimeOut` parameter. If
-timeout is 0, it exits immediately after checking. If timeout is -1, it blocks
-indefinitely until a readiness state occurs.
-
-* `eid`: epoll container
-* `fdsSet` : A pointer to an array of `SRT_EPOLL_EVENT`
-* `fdsSize` : The size of the fdsSet array
-* `msTimeOut` : Timeout specified in milliseconds, or special values (0 or -1):
-   * 0: Don't wait, return immediately (report any sockets currently ready)
-   * -1: Wait indefinitely.
-
-- Returns:
-
-  * The number of user socket (SRT socket) state changes that have been reported
-in `fdsSet`, if this number isn't greater than `fdsSize`
-
-  * Otherwise the return value is `fdsSize` + 1. This means that there was not
-enough space in the output array to report all events. For events subscribed with
-`SRT_EPOLL_ET` flag only those will be cleared that were reported. Others will
-wait for the next call.
-
-  * If no readiness state was found on any socket and the timeout has passed, 0
-is returned (this is not possible when waiting indefinitely)
-
-  * -1 in case of error
-
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-  * `SRT_EINVPARAM`: One of possible usage errors:
-    * `fdsSize` is < 0
-    * `fdsSize` is > 0 and `fdsSet` is a null pointer
-    * `eid` was subscribed to any system socket
-
-(IMPORTANT: this function reports timeout by returning 0, not by `SRT_ETIMEOUT` error.)
-
-The `SRT_EPOLL_EVENT` structure:
-
-```
-typedef struct SRT_EPOLL_EVENT_
-{
-    SRTSOCKET fd;
-    int       events;
-} SRT_EPOLL_EVENT;
-```
-
-* `fd` : the user socket (SRT socket)
-* `events` : event flags that report readiness of this socket - a combination
-of `SRT_EPOLL_IN`, `SRT_EPOLL_OUT` and `SRT_EPOLL_ERR` - see [srt_epoll_add_usock](#srt_epoll_add_usock)
-for details
-
-Note that when the `SRT_EPOLL_ERR` is set, the underlying socket error
-can't be retrieved with `srt_getlasterror()`. The socket will be automatically
-closed and its state can be verified with a call to `srt_getsockstate`.
-
-### srt_epoll_clear_usocks
-```
-int srt_epoll_clear_usocks(int eid);
-```
-
-This function removes all SRT ("user") socket subscriptions from the epoll
-container identified by `eid`.
-
-- Returns:
-  * 0 on success
-  * -1 in case of error
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-
-### srt_epoll_set
-```
-int32_t srt_epoll_set(int eid, int32_t flags);
-```
-
-This function allows to set or retrieve flags that change the default
-behavior of the epoll functions. All default values for these flags are 0.
-The following flags are available:
-
-* `SRT_EPOLL_ENABLE_EMPTY`: allows the `srt_epoll_wait` and `srt_epoll_uwait`
-functions to be called with the EID not subscribed to any socket. The default
-behavior of these function is to report error in this case.
-
-* `SRT_EPOLL_ENABLE_OUTPUTCHECK`: Forces the `srt_epoll_wait` and `srt_epoll_uwait`
-functions to check if the output array is not empty. For `srt_epoll_wait` it
-is still allowed that either system or user array is empty, as long as EID
-isn't subscribed to this type of socket/fd. `srt_epoll_uwait` only checks if
-the general output array is not empty.
-
-- Parameters:
-
-   * `eid`: the epoll container id
-   * `flags`: a nonzero set of the above flags, or special values:
-      * 0: clear all flags (set all defaults)
-      * -1: do not modify any flags
-
-- Returns:
-
-This function returns the state of the flags at the time before the call,
-or a special value -1 in case when an error occurred.
-
-- Errors:
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-
-
-### srt_epoll_release
-```
-int srt_epoll_release(int eid);
-```
-
-Deletes the epoll container.
-
-- Returns:
-
-  * The number (\>0) of ready sockets, of whatever kind (if any)
-  * -1 in case of error
-
-- Errors:
-
-
-  * `SRT_EINVPOLLID`: `eid` parameter doesn't refer to a valid epoll container
-
-## Logging control
-
-SRT has a widely used system of logs, as this is usually the only way to determine
-how the internals are working, without changing the rules by the act of tracing.
-Logs are split into levels (5 levels out of those defined by syslog are in use)
-and additional filtering is possible on FA (functional area). By default only
-up to the *Note* log level are displayed and from all FAs.
-
-Logging can only be manipulated globally, with no regard to a specific 
-socket. This is because lots of operations in SRT are not dedicated to any 
-particular socket, and some are shared between sockets.
-
-### srt_setloglevel
-
-```
-void srt_setloglevel(int ll);
-```
-
-Sets the minimum severity for logging. A particular log entry is displayed only 
-if it has a severity greater than or equal to the minimum. Setting this value 
-to `LOG_DEBUG` turns on all levels.
-
-The constants for this value are those from `<sys/syslog.h>`
-(for Windows, refer to `common/win/syslog_defs.h`). The only meaningful are:
-
-* `LOG_DEBUG`: Highly detailed and very frequent messages
-* `LOG_NOTICE`: Occasionally displayed information
-* `LOG_WARNING`: Unusual behavior
-* `LOG_ERR`: Abnormal behavior
-* `LOG_CRIT`: Error that makes the current socket unusable
-
-### srt_addlogfa, srt_dellogfa, srt_resetlogfa
-
-```c++
-void srt_addlogfa(int fa);
-void srt_dellogfa(int fa);
-void srt_resetlogfa(const int* fara, size_t fara_size);
-```
-
-A functional area (FA) is an additional filtering mechanism for logging. You can 
-set up logging to display logs only from selected FAs. The list of FAs is
-collected in `srt.h` file, as identified by the `SRT_LOGFA_` prefix. They are not
-enumerated here because they may be changed very often.
-
-
-All FAs are turned on by default, except potentially dangerous ones
-(such as `SRT_LOGFA_HAICRYPT`). The reaons is that they may display either
-some security information that shall remain in the memory only (so, only
-if strictly required for the development), or some duplicated information
-(so you may want to turn this FA on, while turning off the others).
-
-### srt_setloghandler
-
-```c++
-void srt_setloghandler(void* opaque, SRT_LOG_HANDLER_FN* handler);
-typedef void SRT_LOG_HANDLER_FN(void* opaque, int level, const char* file, int line, const char* area, const char* message);
-```
-
-By default logs are printed to standard error stream. This function replaces
-the sending to a stream with a handler function that will receive them.
-
-### srt_setlogflags
-
-```c++
-void srt_setlogflags(int flags);
-```
-
-When you set a log handler with `srt_setloghandler`, you may also want to
-configure which parts of the log information you do not wish to be passed 
-in the log line (the `message` parameter). A user's logging facility may,
-for example, not wish to get the current time or log level marker, as it
-will provide this information on its own.
-
-
-The following flags are available, as collected in `logging_api.h` public header:
-
-- `SRT_LOGF_DISABLE_TIME`: Do not provide the time in the header
-- `SRT_LOGF_DISABLE_THREADNAME`: Do not provide the thread name in the header
-- `SRT_LOGF_DISABLE_SEVERITY`: Do not provide severity information in the header
-- `SRT_LOGF_DISABLE_EOL`: Do not add the end-of-line character to the log line
-
-## Time Access
-
-The following set of functions is intended to retrieve timestamps from the clock used by SRT.
-The sender can pass the timestamp in `MSGCTRL::srctime` of the `srt_sendmsg2(..)`
-function together with the packet being submitted to SRT.
-If the `srctime` value is not provided (the default value of 0 is set), SRT will use internal
-clock and assign the packet submission time as the packet timestamp.
-If the sender wants to explicitly assign a timestamp
-to a certain packet. this timestamp MUST be taken from SRT Time Access functions.
-The time value provided MUST equal or exceed the connection start time (`srt_connection_time(..)`)
-of the SRT socket passed to `srt_sendmsg2(..)`.
-
-The current time value as of the SRT internal clock can be retrieved using the `srt_time_now()` function.
-
-There are two known cases where you might want to use `srctime`:
-
-1. SRT passthrough (for stream gateways).
-You may wish to simply retrieve packets from an SRT source and pass them transparently
-to an SRT output (possibly re-encrypting). In that case, every packet you read
-should preserve the original value of `srctime` as obtained from `srt_recvmsg2`,
-and the original `srctime` for each packet should be then passed to `srt_sendmsg2`.
-This mechanism could be used to avoid jitter resulting from varying differences between
-the time of receiving and sending the same packet.
-
-2. Stable timing source.
-In the case of a live streaming procedure, when spreading packets evenly into the stream,
-you might want to predefine times for every single packet to keep time intervals perfectly equal.
-Or, if you believe that your input signal delivers packets at the exact times that should be
-assigned to them, you might want to preserve these times at the SRT receiving side
-to avoid jitter that may result from varying time differences between the packet arrival
-and the moment when sending it over SRT. In such cases you might do the following:
-
-    - At the packet arrival time, grab the current time at that moment using `srt_time_now()`.
-
-    - When you want a precalculated packet time, use a private relative time counter
-    set at the moment when the connection was made. From the moment when your first packet
-    is ready, start precalculating packet times relative to the connection start time obtained
-    from `srt_connection_time()`. Although you still have to synchronize sending times with these
-    predefined times, by explicitly specifying the source time you avoid the jitter
-    resulting from a lost accuracy due to waiting time and unfortunate thread scheduling.
-
-Note that  `srctime` uses an internally defined clock
-that is intended to be monotonic (the definition depends on the build flags,
-see below). Because of that **the application should not define this time basing
-on values obtained from the system functions for getting the current system time**
-(such as `time`, `ftime` or `gettimeofday`). To avoid problems and
-misunderstanding you should rely exclusively on time values provided by
-`srt_time_now()` and `srt_connection_time()` functions.
-
-The clock used by SRT internal clock, is determined by the following build flags:
-- `ENABLE_MONOTONIC` makes use of `CLOCK_MONOTONIC` with `clock_gettime` function.
-- `ENABLE_STDXXX_SYNC` makes use of `std::chrono::steady_clock`.
-
-The default is currently to use the system clock as internal SRT clock,
-although it's highly recommended to use one of the above monotonic clocks,
-as system clock is vulnerable to time modifications during transmission.
-
-### srt_time_now
-
-```c++
-int64_t srt_time_now();
-```
-
-Get time in microseconds elapsed since epoch using SRT internal clock (steady or monotonic clock).
-
-- Returns:
-  - Current time in microseconds elapsed since epoch of SRT internal clock.
-
-### srt_connection_time
-
-```c++
-int64_t srt_connection_time(SRTSOCKET sock);
-```
-
-Get connection time in microseconds elapsed since epoch using SRT internal clock (steady or monotonic clock).
-The connection time represents the time when SRT socket was open to establish a connection.
-Milliseconds elapsed since connection start time can be determined using [**Performance tracking**](#Performance-tracking)
-functions and `msTimeStamp` value of the `SRT_TRACEBSTATS` (see [statistics.md](statistics.md)).
-
-- Returns:
-  - Connection time in microseconds elapsed since epoch of SRT internal clock.
-  - -1 in case of error
-
-- Errors:
-  - `SRT_EINVSOCK`: Socket `sock` is not an ID of a valid SRT socket
-
-[RETURN TO TOP OF PAGE](#SRT-API-Functions)
diff --git a/docs/API/API-functions.md b/docs/API/API-functions.md
new file mode 100644
index 000000000..74fbc506f
--- /dev/null
+++ b/docs/API/API-functions.md
@@ -0,0 +1,3446 @@
+# SRT API Functions
+
+<h3 id="Library Initialization">Library Initialization</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_startup](#srt_startup)                       | Called at the start of an application that uses the SRT library                                                |
+| [srt_cleanup](#srt_cleanup)                       | Cleans up global SRT resources before exiting an application                                                   |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+
+<h3 id="creating-and-configuring-sockets">Creating and Configuring Sockets</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_socket](#srt_socket)                         | Deprecated                                                                                                     |
+| [srt_create_socket](#srt_create_socket)           | Creates an SRT socket                                                                                          |
+| [srt_bind](#srt_bind)                             | Binds a socket to a local address and port                                                                     |
+| [srt_bind_acquire](#srt_bind_acquire)             | Acquires a given UDP socket instead of creating one                                                            |
+| [srt_getsockstate](#srt_getsockstate)             | Gets the current status of the socket                                                                          |
+| [srt_getsndbuffer](#srt_getsndbuffer)             | Retrieves information about the sender buffer                                                                  |
+| [srt_close](#srt_close)                           | Closes the socket or group and frees all used resources                                                        |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="connecting">Connecting</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_listen](#srt_listen)                         | Sets up the listening state on a socket                                                                        |
+| [srt_accept](#srt_accept)                         | Accepts a connection; creates/returns a new socket or group ID                                                 |
+| [srt_accept_bond](#srt_accept_bond)               | Accepts a connection pending on any sockets passed in the `listeners` array <br/> of `nlisteners` size               |
+| [srt_listen_callback](#srt_listen_callback)       | Installs/executes a callback hook on a socket created to handle the incoming connection <br/> on a listening socket  |
+| [srt_connect](#srt_connect)                       | Connects a socket or a group to a remote party with a specified address and port                               |
+| [srt_connect_bind](#srt_connect_bind)             | Same as [`srt_bind`](#srt_bind) then [`srt_connect`](#srt_connect) if called with socket [`u`](#u)             |
+| [srt_connect_debug](#srt_connect_debug)           | Same as [`srt_connect`](#srt_connect)but allows specifying ISN (developers only)                               |
+| [srt_rendezvous](#srt_rendezvous)                 | Performs a rendezvous connection                                                                               |
+| [srt_connect_callback](#srt_connect_callback)     | Installs/executes a callback hook on socket/group [`u`](#u) after connection resolution/failure                |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="socket-group-management">Socket Group Management</h3>
+
+Since SRT v1.5.0.
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [SRT_GROUP_TYPE](#SRT_GROUP_TYPE)                 | Group types collected in an [`SRT_GROUP_TYPE`](#SRT_GROUP_TYPE) enum                                           |
+| [SRT_SOCKGROUPCONFIG](#SRT_SOCKGROUPCONFIG)       | Structure used to define entry points for connections for [`srt_connect_group`](#srt_connect_group)            |
+| [SRT_SOCKGROUPDATA](#SRT_SOCKGROUPDATA)           | Most important structure for group member status                                                               |
+| [SRT_MEMBERSTATUS](#SRT_MEMBERSTATUS)             | Enumeration type that defines the state of a member connection in the group                                    |
+| [srt_create_group](#srt_create_group)             | Creates a new group of type `type`                                                                             |
+| [srt_groupof](#srt_groupof)                       | Returns the group ID of a socket, or `SRT_INVALID_SOCK`                                                        |
+| [srt_group_data](#srt_group_data)                 | Obtains the current member state of the group specified in `socketgroup`                                       |
+| [srt_connect_group](#srt_connect_group)           | Similar to calling [`srt_connect`](#srt_connect) or [`srt_connect_bind`](#srt_connect_bind) <br/> in a loop for every item in an array. |
+| [srt_prepare_endpoint](#srt_prepare_endpoint)     | Prepares a default [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG) object as an element of <br/> an array for [`srt_connect_group`](#srt_connect_group)   |
+| [srt_create_config](#srt_create_config)           | Creates a dynamic object for specifying socket options                                                         |
+| [srt_delete_config](#srt_delete_config)           | Deletes the configuration object                                                                               |
+| [srt_config_add](#srt_config_add)                 | Adds a configuration option to the configuration object                                                        |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="options-and-properties">Options and Properties</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_getpeername](#srt_getpeername)               | Retrieves the remote address to which the socket is connected                                                  |
+| [srt_getsockname](#srt_getsockname)               | Extracts the address to which the socket was bound                                                             |
+| [srt_getsockopt](#srt_getsockopt)                 | Gets the value of the given socket option (from a socket or a group)                                           |
+| [srt_getsockflag](#srt_getsockflag)               | Gets the value of the given socket option (from a socket or a group)                                           |
+| [srt_setsockopt](#srt_setsockopt)                 | Sets a value for a socket option in the socket or group                                                        |
+| [srt_setsockflag](#srt_setsockflag)               | Sets a value for a socket option in the socket or group                                                        |
+| [srt_getversion](#srt_getversion)                 | Get SRT version value                                                                                          |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="helper-data-types-for-transmission">Helper Data Types for Transmission</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [SRT_MSGCTRL](#SRT_MSGCTRL)                       | Used in [`srt_sendmsg2`](#srt_sendmsg) and [`srt_recvmsg2`](#srt_recvmsg2) calls; <br/> specifies some extra parameters  |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="transmission">Transmission</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_send](#srt_send)                             | Sends a payload to a remote party over a given socket                                                          |
+| [srt_sendmsg](#srt_sendmsg)                       | Sends a payload to a remote party over a given socket                                                          |
+| [srt_sendmsg2](#srt_sendmsg2)                     | Sends a payload to a remote party over a given socket                                                          |
+| [srt_recv](#srt_recv)                             | Extracts the payload waiting to be received                                                                    |
+| [srt_recvmsg](#srt_recvmsg)                       | Extracts the payload waiting to be received                                                                    |
+| [srt_recvmsg2](#srt_recvmsg2)                     | Extracts the payload waiting to be received                                                                    |
+| [srt_sendfile](#srt_sendfile)                     | Function dedicated to sending a file                                                                           |
+| [srt_recvfile](#srt_recvfile)                     | Function dedicated to receiving a file                                                                         |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="performance-tracking">Performance Tracking</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_bstats](#srt_bstats)                         | Reports the current statistics                                                                                 |
+| [srt_bistats](#srt_bistats)                       | Reports the current statistics                                                                                 |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="asynchronous-operations-epoll">Asynchronous Operations (Epoll)</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_epoll_create](#srt_epoll_create)             | Creates a new epoll container                                                                                  |
+| [srt_epoll_add_usock](#srt_epoll_add_usock)       | Adds a user socket to a container, or updates an existing socket subscription                                  |
+| [srt_epoll_add_ssock](#srt_epoll_add_ssock)       | Adds a system socket to a container, or updates an existing socket subscription                                |
+| [srt_epoll_update_usock](#srt_epoll_update_usock) | Adds a user socket to a container, or updates an existing socket subscription                                  |
+| [srt_epoll_update_ssock](#srt_epoll_update_ssock) | Adds a system socket to a container, or updates an existing socket subscription                                |
+| [srt_epoll_remove_usock](#srt_epoll_remove_usock) | Removes a specified user socket from an epoll container; clears all readiness states for that socket           |
+| [srt_epoll_remove_ssock](#srt_epoll_remove_ssock) | Removes a specified system socket from an epoll container; clears all readiness states for that socket         |
+| [srt_epoll_wait](#srt_epoll_wait)                 | Blocks the call until any readiness state occurs in the epoll container                                        |
+| [srt_epoll_uwait](#srt_epoll_uwait)               | Blocks a call until any readiness state occurs in the epoll container                                          |
+| [srt_epoll_clear_usocks](#srt_epoll_clear_usocks) | removes all SRT ("user") socket subscriptions from the epoll container identified by [`eid`](#eid)             |
+| [srt_epoll_set](#srt_epoll_set)                   | Allows setting or retrieving flags that change the default behavior of the epoll functions                     |
+| [srt_epoll_release](#srt_epoll_release)           | Deletes the epoll container                                                                                    |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="logging-control">Logging Control</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_setloglevel](#srt_setloglevel)               | Sets the minimum severity for logging                                                                          |
+| [srt_addlogfa](#srt_addlogfa)                     | Add a functional area (FA), which is an additional filtering mechanism for logging                             |
+| [srt_dellogfa](#srt_dellogfa)                     | Delete a functional area (FA), which is an additional filtering mechanism for logging                          |
+| [srt_resetlogfa](#srt_resetlogfa)                 | Reset a functional area (FA), which is an additional filtering mechanism for logging                           |
+| [srt_setloghandler](#srt_setloghandler)           | Replaces default standard stream for error logging                                                             |
+| [srt_setlogflags](#srt_setlogflags)               | Allows configuring parts of log information that are not to be passed                                          |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="time-access">Time Access</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_time_now](#srt_time_now)                     | Get time in microseconds elapsed since epoch using SRT internal clock <br/> (steady or monotonic clock)              |
+| [srt_connection_time](#srt_connection_time)       | Get connection time in microseconds elapsed since epoch using SRT internal clock <br/> (steady or monotonic clock)   |
+| [srt_clock_type](#srt_clock_type)                 | Get the type of clock used internally by SRT                                                                   |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h3 id="diagnostics">Diagnostics</h3>
+
+| *Function / Structure*                            | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+| [srt_getlasterror](#srt_getlasterror)             | Get the numeric code of the last error                                                                         |
+| [srt_strerror](#srt_strerror)                     | Returns a string message that represents a given SRT error code and possibly <br/> the `errno` value, if not 0 |
+| [srt_getlasterror_str](#srt_getlasterror_str)     | Gets the text message for the last error                                                                       |
+| [srt_clearlasterror](#srt_clearlasterror)         | Clears the last error                                                                                          |
+| [srt_rejectreason_str](#srt_rejectreason_str)     | Returns a constant string for the reason of the connection rejected, as per given code ID                      |
+| [srt_setrejectreason](#srt_setrejectreason)       | Sets the rejection code on the socket                                                                          |
+| [srt_getrejectreason](#srt_getrejectreason)       | Provides a detailed reason for a failed connection attempt                                                     |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+<h4 id="rejection-reasons">Rejection Reasons</h4>
+
+| *Rejection Reason*                           | *Since*   | *Description*                                                                                                  |
+|:-------------------------------------------- |:--------- |:-------------------------------------------------------------------------------------------------------------- |
+| [SRT_REJ_UNKNOWN](#SRT_REJ_UNKNOWN)          | 1.3.4     | A fallback value for cases when there was no connection rejected                                               |
+| [SRT_REJ_SYSTEM](#SRT_REJ_SYSTEM)            | 1.3.4     | A system function reported a failure                                                                           |
+| [SRT_REJ_PEER](#SRT_REJ_PEER)                | 1.3.4     | The connection has been rejected by peer, but no further details are available                                 |
+| [SRT_REJ_RESOURCE](#SRT_REJ_RESOURCE)        | 1.3.4     | A problem with resource allocation (usually memory)                                                            |
+| [SRT_REJ_ROGUE](#SRT_REJ_ROGUE)              | 1.3.4     | The data sent by one party to another cannot be properly interpreted                                           |
+| [SRT_REJ_BACKLOG](#SRT_REJ_BACKLOG)          | 1.3.4     | The listener's backlog has exceeded                                                                            |
+| [SRT_REJ_IPE](#SRT_REJ_IPE)                  | 1.3.4     | Internal Program Error                                                                                         |
+| [SRT_REJ_CLOSE](#SRT_REJ_CLOSE)              | 1.3.4     | The listener socket received a request as it is being closed                                                   |
+| [SRT_REJ_VERSION](#SRT_REJ_VERSION)          | 1.3.4     | A party did not satisfy the minimum version requirement that had been set up for a connection                  |
+| [SRT_REJ_RDVCOOKIE](#SRT_REJ_RDVCOOKIE)      | 1.3.4     | Rendezvous cookie collision                                                                                    |
+| [SRT_REJ_BADSECRET](#SRT_REJ_BADSECRET)      | 1.3.4     | Both parties have defined a passphrase for connection and they differ                                          |
+| [SRT_REJ_UNSECURE](#SRT_REJ_UNSECURE)        | 1.3.4     | Only one connection party has set up a password                                                                |
+| [SRT_REJ_MESSAGEAPI](#SRT_REJ_MESSAGEAPI)    | 1.3.4     | The value for [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) flag is different on both connection parties  |
+| [SRT_REJ_FILTER](#SRT_REJ_FILTER)            | 1.3.4     | The [`SRTO_PACKETFILTER`](API-socket-options.md#SRTO_PACKETFILTER) option has been set differently on both connection parties  |
+| [SRT_REJ_GROUP](#SRT_REJ_GROUP)              | 1.4.2     | The group type or some group settings are incompatible for both connection parties                             |
+| [SRT_REJ_TIMEOUT](#SRT_REJ_TIMEOUT)          | 1.4.2     | The connection wasn't rejected, but it timed out                                                               |
+| [SRT_REJ_CRYPTO](#SRT_REJ_CRYPTO)            | 1.5.2     | The connection was rejected due to an unsupported or mismatching encryption mode                               |
+| <img width=290px height=1px/>                |           |                                                                                                                |
+
+See the full list in [Rejection Reason Codes](./rejection-codes.md).
+
+<h4 id="error-codes">Error Codes</h4>
+
+| *Error Code*                                      | *Description*                                                                                                  |
+|:------------------------------------------------- |:-------------------------------------------------------------------------------------------------------------- |
+[`SRT_EUNKNOWN`](#srt_eunknown)                     | Internal error when setting the right error code                                                               |
+[`SRT_SUCCESS`](#srt_success)                       | The value set when the last error was cleared and no error has occurred since then                             |
+[`SRT_ECONNSETUP`](#srt_econnsetup)                 | General setup error resulting from internal system state                                                       |
+[`SRT_ENOSERVER`](#srt_enoserver)                   | Connection timed out while attempting to connect to the remote address                                         |
+[`SRT_ECONNREJ`](#srt_econnrej)                     | Connection has been rejected                                                                                   |
+[`SRT_ESOCKFAIL`](#srt_esockfail)                   | An error occurred when trying to call a system function on an internally used UDP socket                       |
+[`SRT_ESECFAIL`](#srt_esecfail)                     | A possible tampering with the handshake packets was detected, or encryption request <br/> wasn't properly fulfilled. |
+[`SRT_ESCLOSED`](#srt_esclosed)                     | A socket that was vital for an operation called in blocking mode has been closed <br/> during the operation          |
+[`SRT_ECONNFAIL`](#srt_econnfail)                   | General connection failure of unknown details                                                                  |
+[`SRT_ECONNLOST`](#srt_econnlost)                   | The socket was properly connected, but the connection has been broken                                          |
+[`SRT_ENOCONN`](#srt_enoconn)                       | The socket is not connected                                                                                    |
+[`SRT_ERESOURCE`](#srt_eresource)                   | System or standard library error reported unexpectedly for unknown purpose                                     |
+[`SRT_ETHREAD`](#srt_ethread)                       | System was unable to spawn a new thread when required                                                          |
+[`SRT_ENOBUF`](#srt_enobuf)                         | System was unable to allocate memory for buffers                                                               |
+[`SRT_ESYSOBJ`](#srt_esysobj)                       | System was unable to allocate system specific objects                                                          |
+[`SRT_EFILE`](#srt_efile)                           | General filesystem error (for functions operating with file transmission)                                      |
+[`SRT_EINVRDOFF`](#srt_einvrdoff)                   | Failure when trying to read from a given position in the file                                                  |
+[`SRT_ERDPERM`](#srt_erdperm)                       | Read permission was denied when trying to read from file                                                       |
+[`SRT_EINVWROFF`](#srt_einvwroff)                   | Failed to set position in the written file                                                                     |
+[`SRT_EWRPERM`](#srt_ewrperm)                       | Write permission was denied when trying to write to a file                                                     |
+[`SRT_EINVOP`](#srt_einvop)                         | Invalid operation performed for the current state of a socket                                                  |
+[`SRT_EBOUNDSOCK`](#srt_eboundsock)                 | The socket is currently bound and the required operation cannot be performed in this state                     |
+[`SRT_ECONNSOCK`](#srt_econnsock)                   | The socket is currently connected and therefore performing the required operation is not possible              |
+[`SRT_EINVPARAM`](#srt_einvparam)                   | Call parameters for API functions have some requirements that were not satisfied                               |
+[`SRT_EINVSOCK`](#srt_einvsock)                     | The API function required an ID of an entity (socket or group) and it was invalid                              |
+[`SRT_EUNBOUNDSOCK`](#srt_eunboundsock)             | The operation to be performed on a socket requires that it first be explicitly bound                           |
+[`SRT_ENOLISTEN`](#srt_enolisten)                   | The socket passed for the operation is required to be in the listen state                                      |
+[`SRT_ERDVNOSERV`](#srt_erdvnoserv)                 | The required operation cannot be performed when the socket is set to rendezvous mode                           |
+[`SRT_ERDVUNBOUND`](#srt_erdvunbound)               | An attempt was made to connect to a socket set to rendezvous mode that was not first bound                     |
+[`SRT_EINVALMSGAPI`](#srt_einvalmsgapi)             | The function was used incorrectly in the message API                                                           |
+[`SRT_EINVALBUFFERAPI`](#srt_einvalbufferapi)       | The function was used incorrectly in the stream (buffer) API                                                   |
+[`SRT_EDUPLISTEN`](#srt_eduplisten)                 | The port tried to be bound for listening is already busy                                                       |
+[`SRT_ELARGEMSG`](#srt_elargemsg)                   | Size exceeded                                                                                                  |
+[`SRT_EINVPOLLID`](#srt_einvpollid)                 | The epoll ID passed to an epoll function is invalid                                                            |
+[`SRT_EPOLLEMPTY`](#srt_epollempty)                 | The epoll container currently has no subscribed sockets                                                        |
+[`SRT_EASYNCFAIL`](#srt_easyncfail)                 | General asynchronous failure (not in use currently)                                                            |
+[`SRT_EASYNCSND`](#srt_easyncsnd)                   | Sending operation is not ready to perform                                                                      |
+[`SRT_EASYNCRCV`](#srt_easyncrcv)                   | Receiving operation is not ready to perform                                                                    |
+[`SRT_ETIMEOUT`](#srt_etimeout)                     | The operation timed out                                                                                        |
+[`SRT_ECONGEST`](#srt_econgest)                     | With [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) and [`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP) set to true, <br/> some packets were dropped by sender                    |
+[`SRT_EPEERERR`](#srt_epeererr)                     | Receiver peer is writing to a file that the agent is sending                                                   |
+| <img width=290px height=1px/>                     | <img width=720px height=1px/>                                                                                  |
+
+
+
+## Library Initialization
+
+* [srt_startup](#srt_startup)
+* [srt_cleanup](#srt_cleanup)
+
+
+### srt_startup
+```
+int srt_startup(void);
+```
+
+This function shall be called at the start of an application that uses the SRT
+library. It provides all necessary platform-specific initializations, sets up
+global data, and starts the SRT GC thread. If this function isn't explicitly
+called, it will be called automatically when creating the first socket. However,
+relying on this behavior is strongly discouraged.
+
+|      Returns                  |                                                                 |
+|:----------------------------- |:--------------------------------------------------------------- |
+|         0                     | Successfully run, or already started                            |
+|         1                     | This is the first startup, but the GC thread is already running |
+|        -1                     | Failed                                                          |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                  |                                                                 |
+|:----------------------------- |:--------------------------------------------------------------- |
+| [`SRT_ECONNSETUP`](#srt_econnsetup) | With error code set, reported when required system resource(s) failed to initialize. <br/> This is currently used only on Windows to report a failure from `WSAStartup`. |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_cleanup
+```
+int srt_cleanup(void);
+```
+
+This function cleans up all global SRT resources and shall be called just before
+exiting the application that uses the SRT library. This cleanup function will still
+be called from the C++ global destructor, if not called by the application, although
+relying on this behavior is strongly discouraged.
+
+|      Returns                  |                                                                 |
+|:----------------------------- |:--------------------------------------------------------------- |
+|         0                     | A possibility to return other values is reserved for future use |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+**IMPORTANT**: Note that the startup/cleanup calls have an instance counter.
+This means that if you call [`srt_startup`](#srt_startup) multiple times, you need to call the
+`srt_cleanup` function exactly the same number of times.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Creating and Configuring Sockets
+
+* [srt_socket](#srt_socket)
+* [srt_create_socket](#srt_create_socket)
+* [srt_bind](#srt_bind)
+* [srt_bind_acquire](#srt_bind_acquire)
+* [srt_getsockstate](#srt_getsockstate)
+* [srt_getsndbuffer](#srt_getsndbuffer)
+* [srt_close](#srt_close)
+
+
+### srt_socket
+```
+SRTSOCKET srt_socket(int af, int type, int protocol);
+```
+
+Old and deprecated version of [`srt_create_socket`](#srt_create_socket). All arguments are ignored.
+
+**NOTE** changes with respect to UDT version:
+
+* In UDT (and SRT versions before 1.4.2) the `af` parameter was specifying the
+socket family (`AF_INET` or `AF_INET6`). This is now not required; this parameter
+is decided at the call of [`srt_connect`](#srt_connect) or [`srt_bind`](#srt_bind).
+
+* In UDT the `type` parameter was used to specify the file or message mode
+using `SOCK_STREAM` or `SOCK_DGRAM` symbols (with the latter being misleading,
+as the message mode has nothing to do with UDP datagrams and it's rather
+similar to the SCTP protocol). In SRT these two modes are available by setting
+[`SRTO_TRANSTYPE`](API-socket-options.md#SRTO_TRANSTYPE). The default is `SRTT_LIVE`. If, however, you set
+[`SRTO_TRANSTYPE`](API-socket-options.md#SRTO_TRANSTYPE) to `SRTT_FILE` for file mode, you can then leave the
+[`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) option as false (default), which corresponds to "stream" mode
+(TCP-like), or set it to true, which corresponds to "message" mode (SCTP-like).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_create_socket
+```
+SRTSOCKET srt_create_socket();
+```
+
+Creates an SRT socket.
+
+Note that socket IDs always have the `SRTGROUP_MASK` bit clear.
+
+|       Returns                 |                                                         |
+|:----------------------------- |:------------------------------------------------------- |
+|      Socket ID                | A valid socket ID on success                            |
+| `SRT_INVALID_SOCK`            | (`-1`) on error                                         |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|     Errors                    |                                                              |
+|:----------------------------- |:------------------------------------------------------------ |
+| [`SRT_ENOBUF`](#srt_enobuf)   |  Not enough memory to allocate required resources          . |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+**NOTE:** This is probably a design flaw (:warning: &nbsp; **BUG?**). Usually underlying system
+errors are reported by [`SRT_ECONNSETUP`](#srt_econnsetup).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+
+---
+
+### srt_bind
+```
+int srt_bind(SRTSOCKET u, const struct sockaddr* name, int namelen);
+```
+
+Binds a socket to a local address and port. Binding specifies the local network
+interface and the UDP port number to be used for the socket. When the local
+address is a wildcard (`INADDR_ANY` for IPv4 or `in6addr_any` for IPv6), then
+it's bound to all interfaces.
+
+**IMPORTANT**: When you bind an IPv6 wildcard address, note that the
+`SRTO_IPV6ONLY` option must be set on the socket explicitly to 1 or 0 prior to
+calling this function. See
+[`SRTO_IPV6ONLY`](API-socket-options.md#SRTO_IPV6ONLY) for more details.
+
+Binding is necessary for every socket to be used for communication. If the socket
+is to be used to initiate a connection to a listener socket, which can be done,
+for example, by the [`srt_connect`](#srt_connect) function, the socket is bound
+implicitly to the wildcard address according to the IP family (`INADDR_ANY` for
+`AF_INET` or `in6addr_any` for `AF_INET6`) and port number 0. In all other cases,
+a socket must be bound explicitly by using the functionality of this function first.
+
+When the port number parameter is 0, then the effective port number will be
+system-allocated. To obtain this effective port number you can use
+[`srt_getsockname`](#srt_getsockname).
+
+This call is obligatory for a listening socket before calling [`srt_listen`](#srt_listen)
+and for rendezvous mode before calling [`srt_connect`](#srt_connect); otherwise it's
+optional. For a listening socket it defines the network interface and the port where
+the listener should expect a call request.
+
+In the case of rendezvous mode there are two parties that connect to one another.
+For every party there must be chosen a local binding endpoint (local address and port)
+to which they expect connection from the peer. Let's say, we have a Party 1
+that selects an endpoint A and a Party 2 that selects an endpoint B. In this case the Party 1
+binds the socket to the endpoint A and then connects to the endpoint B, and the Party 2
+the other way around. Both sockets must be set
+[`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) to *true* to make
+this connection possible.
+
+For a connecting socket the call to `srt_bind` is optional, but can be used to set up the
+outgoing port for communication as well as the local interface through which
+it should reach out to the remote endpoint, should that be necessary.
+
+Whether binding is possible depends on some runtime conditions, in particular:
+
+* No socket in the system has been bound to this port ("free binding"), or
+
+* A socket bound to this port is bound to a certain address, and this binding is
+  using a different non-wildcard address ("side binding"), or
+
+* A socket bound to this port is bound to a wildcard address for a different IP
+  version than the version requested for this binding ("side wildcard binding",
+  see also `SRTO_IPV6ONLY` socket option).
+
+It is also possible to bind to the already busy port as long as the existing
+binding ("shared binding") is possessed by an SRT socket created in the same
+application, and:
+
+* Its binding address and UDP-related socket options match the socket to be bound.
+* Its [`SRTO_REUSEADDR`](API-socket-options.md#SRTO_REUSEADDRS) is set to *true* (default).
+
+If none of the free, side and shared binding options is currently possible, this function
+will fail. If the socket blocking the requested endpoint is an SRT
+socket in the current application, it will report the `SRT_EBINDCONFLICT` error,
+while if it was another socket in the system, or the problem was in the system
+in general, it will report `SRT_ESOCKFAIL`. Here is the table that shows possible situations:
+
+| Requested binding   | vs. Existing bindings...     |           |                             |               |               |
+|---------------------|------------------------------|-----------|-----------------------------|---------------|---------------|
+|                     | A.B.C.D                      | 0.0.0.0   | ::X                         | :: / V6ONLY=1 | :: / V6ONLY=0 |
+| 1.2.3.4             | 1.2.3.4 shareable, else free | blocked   | free                        | free          | blocked       |
+| 0.0.0.0             | blocked                      | shareable | free                        | free          | blocked       |
+| 8080::1             | free                         | free      | 8080::1 sharable, else free | blocked       | blocked       |
+| :: / V6ONLY=1       | free                         | free      | blocked                     | sharable      | blocked       |
+| :: / V6ONLY=0       | blocked                      | blocked   | blocked                     | blocked       | sharable      |
+
+Where:
+
+* free: This binding can coexist with the requested binding.
+
+* blocked: This binding conflicts with the requested binding.
+
+* shareable: This binding can be shared with the requested binding if it's compatible.
+
+* (ADDRESS) shareable, else free: this binding is shareable if the existing binding address is
+equal to the requested ADDRESS. Otherwise it's free.
+
+If the binding is shareable, then the operation will succeed if the socket that currently
+occupies the binding has the `SRTO_REUSEADDR` option set to true (default) and all UDP
+settings are the same as in the current socket. Otherwise it will fail. Shared binding means
+sharing the underlying UDP socket and communication queues between SRT sockets. If
+all existing bindings on the same port are "free" then the requested binding will
+allocate a distinct UDP socket for this SRT socket ("side binding").
+
+**NOTE**: This function cannot be called on a socket group. If you need to
+have the group-member socket bound to the specified source address before
+connecting, use [`srt_connect_bind`](#srt_connect_bind) for that purpose
+or set the appropriate source address using
+[`srt_prepare_endpoint`](#srt_prepare_endpoint).
+
+**IMPORTANT information about IPv6**: If you are going to bind to the
+`in6addr_any` IPv6 wildcard address (known as `::`), the `SRTO_IPV6ONLY`
+option must be first set explicitly to 0 or 1, otherwise the binding
+will fail. In all other cases this option is meaningless. See `SRTO_IPV6ONLY`
+option for more information.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) on error, otherwise 0                                |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                             |                                                                      |
+|:---------------------------------------- |:-------------------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)          | Socket passed as [`u`](#u) designates no valid socket                |
+| [`SRT_EINVOP`](#srt_einvop)              | Socket already bound                                                 |
+| [`SRT_EINVPARAM`](#srt_einvparam)        | Invalid `name`/`namelen` or invalid `SRTO_IPV6ONLY` flag in `u`      |
+| [`SRT_ECONNSETUP`](#srt_econnsetup)      | Internal creation of a UDP socket failed                             |
+| [`SRT_ESOCKFAIL`](#srt_esockfail)        | Internal configuration of a UDP socket (`bind`, `setsockopt`) failed |
+| [`SRT_EBINDCONFLICT`](#srt_ebindconflict)| Binding specification conflicts with existing one                    |
+| <img width=240px height=1px/>            | <img width=710px height=1px/>                                        |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_bind_acquire
+
+```
+int srt_bind_acquire(SRTSOCKET u, UDPSOCKET udpsock);
+```
+
+A version of [`srt_bind`](#srt_bind) that acquires a given UDP socket instead of creating one.
+
+The UDP socket being acquired MUST NOT be a [connected socket](https://man7.org/linux/man-pages/man2/connect.2.html)
+(not associated with the socket name of a peer),
+because SRT needs to be able to set the destination address by itself.
+See [#2178](https://github.com/Haivision/srt/issues/2178) for more information.
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getsockstate
+
+```
+SRT_SOCKSTATUS srt_getsockstate(SRTSOCKET u);
+```
+
+Gets the current status of the socket. Possible states are:
+
+|       State                                     | Description                                                       |
+|:----------------------------------------------- |:----------------------------------------------------------------- |
+| <a name="SRTS_INIT">`SRTS_INIT`</a>             | Created, but not bound.                                           |
+| <a name="SRTS_OPENED">`SRTS_OPENED`</a>         | Created and bound, but not in use yet.                            |
+| <a name="SRTS_LISTENING">`SRTS_LISTENING`</a>   | Socket is in listening state.                                     |
+| <a name="SRTS_CONNECTING">`SRTS_CONNECTING`</a> | The connect operation was initiated, but not yet finished. This may also mean that it has timed out; <br/> you can only know that after getting a socket error report from [`srt_epoll_wait`](#srt_epoll_wait). In blocking mode <br/> it's not possible because [`srt_connect`](#srt_connect) does not return until the socket is connected or failed due <br/> to timeout or interrupted call.  |
+| <a name="SRTS_CONNECTED">`SRTS_CONNECTED`</a>   | The socket is connected and ready for transmission.               |
+| <a name="SRTS_BROKEN">`SRTS_BROKEN`</a>         | The socket was connected, but the connection was broken.          |
+| <a name="SRTS_CLOSING">`SRTS_CLOSING`</a>       | The socket may still be open and active, but closing is requested, so no further operations will <br/> be accepted (active operations will be completed before closing) |
+| <a name="SRTS_CLOSED">`SRTS_CLOSED`</a>         | The socket has been closed, but not yet removed by the GC thread. |
+| <a name="SRTS_NONEXIST">`SRTS_NONEXIST`</a>     | The specified number does not correspond to a valid socket.       |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getsndbuffer
+
+```
+int srt_getsndbuffer(SRTSOCKET sock, size_t* blocks, size_t* bytes);
+```
+
+Retrieves information about the sender buffer.
+
+**Arguments**:
+
+* `sock`: Socket to test
+* `blocks`: Written information about buffer blocks in use
+* `bytes`: Written information about bytes in use
+
+This function can be used for diagnostics. It is especially useful when the
+socket needs to be closed asynchronously.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_close
+
+```
+int srt_close(SRTSOCKET u);
+```
+
+Closes the socket or group and frees all used resources. Note that underlying
+UDP sockets may be shared between sockets, so these are freed only with the
+last user closed.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                             |
+
+|       Errors                    |                                                 |
+|:------------------------------- |:----------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock) | Socket [`u`](#u) indicates no valid socket ID   |
+| <img width=240px height=1px/>   | <img width=710px height=1px/>                   |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Connecting
+
+* [srt_listen](#srt_listen)
+* [srt_accept](#srt_accept)
+* [srt_accept_bond](#srt_accept_bond)
+* [srt_listen_callback](#srt_listen_callback)
+* [srt_connect](#srt_connect)
+* [srt_connect_bind](#srt_connect_bind)
+* [srt_connect_debug](#srt_connect_debug)
+* [srt_rendezvous](#srt_rendezvous)
+* [srt_connect_callback](#srt_connect_callback)
+
+### srt_listen
+```
+int srt_listen(SRTSOCKET u, int backlog);
+```
+
+This sets up the listening state on a socket with a backlog setting that
+defines how many sockets may be allowed to wait until they are accepted
+(excessive connection requests are rejected in advance).
+
+The following important options may change the behavior of the listener
+socket and the [`srt_accept`](#srt_accept) function:
+
+* [`srt_listen_callback`](#srt_listen_callback) installs a user function that will
+be called before [`srt_accept`](#srt_accept) can happen
+* [`SRTO_GROUPCONNECT`](API-socket-options.md#SRTO_GROUPCONNECT) option allows
+the listener socket to accept group connections
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0.                       |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                            |                                                                                              |
+|:--------------------------------------- |:-------------------------------------------------------------------------------------------- |
+| [`SRT_EINVPARAM`](#srt_einvparam)       | Value of `backlog` is 0 or negative.                                                         |
+| [`SRT_EINVSOCK`](#srt_einvsock)         | Socket [`u`](#u) indicates no valid SRT socket.                                              |
+| [`SRT_EUNBOUNDSOCK`](#srt_eunboundsock) | [`srt_bind`](#srt_bind) has not yet been called on that socket.                              |
+| [`SRT_ERDVNOSERV`](#srt_erdvnoserv)     | [`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) flag is set to true on specified socket. |
+| [`SRT_EINVOP`](#srt_einvop)             | Internal error (should not happen when [`SRT_EUNBOUNDSOCK`](#srt_eunboundsock) is reported). |
+| [`SRT_ECONNSOCK`](#srt_econnsock)       | The socket is already connected.                                                             |
+| [`SRT_EDUPLISTEN`](#srt_eduplisten)     | The address used in [`srt_bind`](#srt_bind) by this socket is already occupied by another listening socket. <br/> Binding multiple sockets to one IP address and port is allowed, as long as <br/> [`SRTO_REUSEADDR`](API-socket-options.md#SRTO_REUSEADDRS) is set to true, but only one of these sockets can be set up as a listener.  |
+| <img width=240px height=1px/>           | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_accept
+
+```
+SRTSOCKET srt_accept(SRTSOCKET lsn, struct sockaddr* addr, int* addrlen);
+```
+
+Accepts a pending connection, then creates and returns a new socket or
+group ID that handles this connection. The group and socket can be
+distinguished by checking the `SRTGROUP_MASK` bit on the returned ID.
+
+* `lsn`: the listener socket previously configured by [`srt_listen`](#srt_listen)
+* `addr`: the IP address and port specification for the remote party
+* `addrlen`: INPUT: size of `addr` pointed object. OUTPUT: real size of the
+returned object
+
+**NOTE:** `addr` is allowed to be NULL, in which case it's understood that the
+application is not interested in the address from which the connection originated.
+Otherwise `addr` should specify an object into which the address will be written,
+and `addrlen` must also specify a variable to contain the object size. Note also
+that in the case of group connection only the initial connection that
+establishes the group connection is returned, together with its address. As
+member connections are added or broken within the group, you can obtain this
+information through [`srt_group_data`](#srt_group_data) or the data filled by
+[`srt_sendmsg2`](#srt_sendmsg) and [`srt_recvmsg2`](#srt_recvmsg2).
+
+If the `lsn` listener socket is configured for blocking mode
+([`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) set to true, default),
+the call will block until the incoming connection is ready. Otherwise, the
+call always returns immediately. The `SRT_EPOLL_IN` epoll event should be
+checked on the `lsn` socket prior to calling this function in that case.
+
+If the pending connection is a group connection (initiated on the peer side by
+calling the connection function using a group ID, and permitted on the listener
+socket by the [`SRTO_GROUPCONNECT`](API-socket-options.md#SRTO_GROUPCONNECT)
+flag), then the value returned is a group ID. This function then creates a new
+group, as well as a new socket for this connection, that will be added to the
+group. Once the group is created this way, further connections within the same
+group, as well as sockets for them, will be created in the background. The
+[`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE) event is raised on the `lsn` socket when
+a new background connection is attached to the group, although it's usually for
+internal use only.
+
+|      Returns                  |                                                                         |
+|:----------------------------- |:----------------------------------------------------------------------- |
+| socket/group ID               | On success, a valid SRT socket or group ID to be used for transmission. |
+| `SRT_INVALID_SOCK`            | (-1) on failure                                                         |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                      |                                                                         |
+|:--------------------------------- |:----------------------------------------------------------------------- |
+| [`SRT_EINVPARAM`](#srt_einvparam) | NULL specified as `addrlen`, when `addr` is not NULL  |
+| [`SRT_EINVSOCK`](#srt_einvsock)   | `lsn` designates no valid socket ID.                   |
+| [`SRT_ENOLISTEN`](#srt_enolisten) | `lsn` is not set up as a listener ([`srt_listen`](#srt_listen) not called). |
+| [`SRT_EASYNCRCV`](#srt_easyncrcv) | No connection reported so far. This error is reported only in the non-blocking mode |
+| [`SRT_ESCLOSED`](#srt_esclosed)   | The `lsn` socket has been closed while the function was blocking the call. Including when the socket was closed just at the <br/> moment when a connection was made (i.e., the socket got closed during processing)   |
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_accept_bond
+
+```
+SRTSOCKET srt_accept_bond(const SRTSOCKET listeners[], int nlisteners, int msTimeOut);
+```
+
+Accepts a pending connection, like [`srt_accept`](#srt_accept), but pending on any of the
+listener sockets passed in the `listeners` array of `nlisteners` size.
+
+**Arguments**:
+
+* `listeners`: array of listener sockets (all must be setup by [`srt_listen`](#srt_listen))
+* `nlisteners`: size of the `listeners` array
+* `msTimeOut`: timeout in [ms] or -1 to block forever
+
+This function is for blocking mode only - for non-blocking mode you should simply
+call [`srt_accept`](#srt_accept) on the first listener socket that reports readiness,
+and this function is actually a friendly shortcut that uses waiting on epoll and
+[`srt_accept`](#srt_accept) internally. This function supports an important use
+case for accepting a group connection, for which every member connection is expected
+to be established over a different listener socket.
+
+Note that there's no special set of settings required or rejected for this function.
+Group-member connections for the same group can always be established over various
+different listener sockets when all those listeners are hosted by the same application.
+The group management is global for the application, so a connection reporting in for
+an already connected group gets discovered, and the connection will be handled in the
+background. This occurs regardless of which listener socket the call was made to,
+as long as the connection is accepted according to any additional conditions.
+
+This function has nothing to do with the groups. You can use it in any case when
+you have one service that accepts connections to multiple endpoints. Note also
+that the settings as to whether listeners should accept or reject socket or group
+connections should be applied to the listener sockets appropriately prior to
+calling this function.
+
+|      Returns                  |                                                                        |
+|:----------------------------- |:---------------------------------------------------------------------- |
+| SRT socket<br/>group ID       | On success, a valid SRT socket or group ID to be used for transmission |
+| `SRT_INVALID_SOCK`            | (-1) on failure                                                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                      |                                                              |
+|:--------------------------------- |:------------------------------------------------------------ |
+| [`SRT_EINVPARAM`](#srt_einvparam) | NULL specified as `listeners` or `nlisteners` < 1            |
+| [`SRT_EINVSOCK`](#srt_einvsock)   | Any socket in `listeners` designates no valid socket ID. Can also mean *Internal Error* when <br/> an error occurred while creating an accepted socket (:warning: &nbsp; **BUG?**) |
+| [`SRT_ENOLISTEN`](#srt_enolisten) | Any socket in `listeners` is not set up as a listener ([`srt_listen`](#srt_listen) not called, or the listener socket <br/> has already been closed)  |
+| [`SRT_ETIMEOUT`](#srt_etimeout)   | No connection reported on any listener socket as the timeout has been reached. This error is only <br/> reported when `msTimeOut` is not -1  |
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_listen_callback
+
+```
+int srt_listen_callback(SRTSOCKET lsn, srt_listen_callback_fn* hook_fn, void* hook_opaque);
+```
+
+This call installs a callback hook, which will be executed on a socket that is
+automatically created to handle the incoming connection on the listening socket
+(and is about to be returned by [`srt_accept`](#srt_accept)), but before the
+connection has been accepted.
+
+**Arguments**:
+
+* `lsn`: Listening socket where you want to install the callback hook
+* `hook_fn`: The callback hook function pointer (or NULL to remove the callback)
+* `hook_opaque`: The pointer value that will be passed to the callback function
+
+|      Returns                  |                                                            |
+|:----------------------------- |:---------------------------------------------------------- |
+|         0                     | Successful                                                 |
+|        -1                     | Error                                                      |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                      |                                           |
+|:--------------------------------- |:----------------------------------------- |
+| [`SRT_ECONNSOCK`](#srt_econnsock) | It can't be modified in a connected socket|
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+The callback function has the signature as per this type definition:
+```
+typedef int srt_listen_callback_fn(void* opaque, SRTSOCKET ns, int hs_version
+             const struct sockaddr* peeraddr, const char* streamid);
+```
+
+The callback function gets the following parameters passed:
+
+* `opaque`: The pointer passed as `hook_opaque` when registering
+* `ns`: The freshly created socket to handle the incoming connection
+* `hs_version`: The handshake version (usually 5, pre-1.3 versions of SRT use 4)
+* `peeraddr`: The address of the incoming connection
+* `streamid`: The value set to [`SRTO_STREAMID`](API-socket-options.md#SRTO_STREAMID) option set on the peer side
+
+Note that SRT versions that use handshake version 4 are incapable of using
+any extensions, such as `streamid`. However they do support encryption.
+Note also that the SRT version isn't extracted at this point. However you can
+prevent connections with versions that are too old by using the
+[`SRTO_MINVERSION`](API-socket-options.md#SRTO_MINVERSION) option.
+
+The callback function is given an opportunity to:
+
+* use the passed information (`streamid` and peer address) to decide
+  what to do with this connection
+* alter any options on the socket, which could not be set properly
+  beforehand on the listening socket to be derived by the accepted socket,
+  and won't be allowed to be altered after the socket is returned by
+  [`srt_accept`](#srt_accept)
+
+Note that normally the returned socket has already set all derived options from
+the listener socket. The moment when this callback is called is when the conclusion
+handshake has been already received from the caller party, but not yet interpreted
+(the `streamid` field is extracted from it prematurely). When, for example, you set
+a passphrase on the socket at this point, the Key Material processing will happen
+against this passphrase, after the callback function is finished.
+
+The callback function shall return 0, if the connection is to be accepted.
+If you return -1, **or** if the function throws an exception, this will be
+understood as a request to reject the incoming connection. In this case the
+about-to-be-accepted socket will be silently deleted and [`srt_accept`](#srt_accept)
+will not report it. Note that in case of non-blocking mode the epoll bits for
+read-ready on the listener socket will not be set if the connection is rejected,
+including when rejected from this user function.
+
+**IMPORTANT**: This function is called in the receiver worker thread, which
+means that it must do its checks and operations as quickly as possible. Every
+delay you create in this function will burden the processing of the incoming data
+on the associated UDP socket. In the case of a listener socket this means the
+listener socket itself and every socket accepted off this listener socket.
+Avoid any extensive search operations. It is best to cache in memory whatever
+database you have to check against the data received in `streamid` or `peeraddr`.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_connect
+
+```
+int srt_connect(SRTSOCKET u, const struct sockaddr* name, int namelen);
+```
+
+Connects a socket or a group to a remote party with a specified address and port.
+
+**Arguments**:
+
+* [`u`](#u): can be an SRT socket or SRT group, both freshly created and not yet
+  used for any connection, except possibly [`srt_bind`](#srt_bind) on the socket
+* `name`: specification of the remote address and port
+* `namelen`: size of the object passed by `name`
+
+**NOTES:**
+
+1. The socket used here may be [bound by `srt_bind`](#srt_bind) before connecting,
+or binding and connection can be done in one function ([`srt_connect_bind`](#srt_connect_bind)),
+such that it uses a predefined network interface or local outgoing port. This is optional
+in the case of a caller-listener arrangement, but obligatory for a rendezvous arrangement.
+If not used, the binding will be done automatically to `INADDR_ANY` (which binds on all
+interfaces) and port 0 (which makes the system assign the port automatically).
+
+2. This function is used for both connecting to the listening peer in a caller-listener
+arrangement, and calling the peer in rendezvous mode. For the latter, the
+[`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) flag must be set
+to true prior to calling this function, and binding, as described in #1,
+is in this case obligatory (see `SRT_ERDVUNBOUND` below).
+
+3. When [`u`](#u) is a group, then this call can be done multiple times, each time
+for another member connection, and a new member SRT socket will be created
+automatically for every call of this function.
+
+4. If you want to connect a group to multiple links at once and use blocking
+mode, you might want to use [`srt_connect_group`](#srt_connect_group) instead.
+This function also allows you to use additional settings, available only for groups.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|    `SRT_ERROR`                | (-1) in case of error                                     |
+|         0                     | In case when used for [`u`](#u) socket                    |
+|     Socket ID                 | Created for connection for [`u`](#u) group                |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                          |                                                             |
+|:------------------------------------- |:----------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)       | Socket [`u`](#u) indicates no valid socket ID               |
+| [`SRT_ERDVUNBOUND`](#srt_erdvunbound) | Socket [`u`](#u) is in rendezvous mode, but it wasn't bound (see note #2) |
+| [`SRT_ECONNSOCK`](#srt_econnsock)     | Socket [`u`](#u) is already connected                       |
+| [`SRT_ECONNREJ`](#srt_econnrej)       | Connection has been rejected                                |
+| [`SRT_ENOSERVER`](#srt_enoserver)     | Connection has been timed out (see [`SRTO_CONNTIMEO`](API-socket-options.md#SRTO_CONNTIMEO)) |
+| [`SRT_ESCLOSED`](#srt_esclosed)       | The socket [`u`](#u) has been closed while the function was blocking the call   |
+| <img width=240px height=1px/>         | <img width=710px height=1px/>                      |
+
+If the `u` socket is configured for blocking mode (when
+[`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) is set to true, default),
+the call will block until the connection succeeds or fails. The "early" errors
+[`SRT_EINVSOCK`](#srt_einvsock), [`SRT_ERDVUNBOUND`](#srt_erdvunbound) and
+[`SRT_ECONNSOCK`](#srt_econnsock) are reported in both modes immediately. Other
+errors are "late" failures and can only be reported in blocking mode.
+
+In non-blocking mode, a successful connection can be recognized by the
+`SRT_EPOLL_OUT` epoll event flag and a "late" failure by the `SRT_EPOLL_ERR`
+flag. Note that the socket state in the case of a failed connection remains
+`SRTS_CONNECTING` in that case.
+
+In the case of "late" failures you can additionally call
+[`srt_getrejectreason`](#srt_getrejectreason) to get detailed error
+information. Note that in blocking mode only for the `SRT_ECONNREJ` error
+this function may return any additional information. In non-blocking
+mode a detailed "late" failure cannot be distinguished, and therefore it
+can also be obtained from this function.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_connect_bind
+
+```
+int srt_connect_bind(SRTSOCKET u, const struct sockaddr* source,
+                     const struct sockaddr* target, int len);
+```
+
+This function does the same as first [`srt_bind`](#srt_bind) then
+[`srt_connect`](#srt_connect), if called with [`u`](#u) being a socket.
+If [`u`](#u) is a group, then it will execute [`srt_bind`](#srt_bind)
+first on the automatically created socket for the connection.
+
+**Arguments**:
+
+* [`u`](#u): Socket or group to connect
+* `source`: Address to bind [`u`](#u) to
+* `target`: Address to connect
+* `len`: size of the original structure of `source` and `target`
+
+|      Returns                  |                                                          |
+|:----------------------------- |:-------------------------------------------------------- |
+|    `SRT_ERROR`                | (-1) in case of error                                    |
+|         0                     | In case when used for [`u`](#u) socket                   |
+|    Socket ID                  | Created for connection for [`u`](#u) group               |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                            |
+
+|       Errors                             |                                                          |
+|:---------------------------------------- |:-------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)          | Socket passed as [`u`](#u) designates no valid socket    |
+| [`SRT_EINVOP`](#srt_einvop)              | Socket already bound                                     |
+| [`SRT_ECONNSETUP`](#srt_econnsetup)      | Internal creation of a UDP socket failed                 |
+| [`SRT_ESOCKFAIL`](#srt_esockfail)        | Internal configuration of a UDP socket (`bind`, `setsockopt`) failed   |
+| [`SRT_ERDVUNBOUND`](#srt_erdvunbound)    | Internal error ([`srt_connect`](#srt_connect) should not report it after [`srt_bind`](#srt_bind) was called)   |
+| [`SRT_ECONNSOCK`](#srt_econnsock)        | Socket [`u`](#u) is already connected                    |
+| [`SRT_ECONNREJ`](#srt_econnrej)          | Connection has been rejected                             |
+| [`SRT_EBINDCONFLICT`](#srt_ebindconflict)| Binding specification conflicts with existing one        |
+| <img width=240px height=1px/>            | <img width=710px height=1px/>                            |
+
+
+**IMPORTANT**: It's not allowed to bind and connect the same socket to two
+different families (that is, both `source` and `target` must be `AF_INET` or
+`AF_INET6`), although you may mix links over IPv4 and IPv6 in one group.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_connect_debug
+
+```
+int srt_connect_debug(SRTSOCKET u, const struct sockaddr* name, int namelen, int forced_isn);
+```
+
+This function is for developers only and can be used for testing. It does the
+same thing as [`srt_connect`](#srt_connect), with the exception that it allows
+specifying the Initial Sequence Number for data transmission. Normally this value
+is generated randomly.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_rendezvous
+```
+int srt_rendezvous(SRTSOCKET u, const struct sockaddr* local_name, int local_namelen,
+        const struct sockaddr* remote_name, int remote_namelen);
+```
+Performs a rendezvous connection. This is a shortcut for doing bind locally,
+setting the [`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) option
+to true, and doing [`srt_connect`](#srt_connect).
+
+**Arguments**:
+
+* [`u`](#u): socket to connect
+* `local_name`: specifies the local network interface and port to bind
+* `remote_name`: specifies the remote party's IP address and port
+
+|      Returns                  |                                                          |
+|:----------------------------- |:-------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0                       |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                          |                                                          |
+|:------------------------------------- |:-------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)       | Socket passed as [`u`](#u) designates no valid socket    |
+| [`SRT_EINVOP`](#srt_einvop)           | Socket already bound                                     |
+| [`SRT_ECONNSETUP`](#srt_econnsetup)   | Internal creation of a UDP socket failed                 |
+| [`SRT_ESOCKFAIL`](#srt_esockfail)     | Internal configuration of a UDP socket (`bind`, `setsockopt`) failed    |
+| [`SRT_ERDVUNBOUND`](#srt_erdvunbound) | Internal error ([`srt_connect`](#srt_connect) should not report it after [`srt_bind`](#srt_bind) was called)    |
+| [`SRT_ECONNSOCK`](#srt_econnsock)     | Socket [`u`](#u) is already connected                    |
+| [`SRT_ECONNREJ`](#srt_econnrej)       | Connection has been rejected                             |
+| <img width=240px height=1px/>         | <img width=710px height=1px/>                      |
+
+**IMPORTANT**: Establishing a rendezvous connection to two different families is not
+allowed (that is, both `local_name` and `remote_name` must be `AF_INET` or `AF_INET6`).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_connect_callback
+```
+int srt_connect_callback(SRTSOCKET u, srt_connect_callback_fn* hook_fn, void* hook_opaque);
+```
+
+This call installs a callback hook, which will be executed on a given [`u`](#u)
+socket or all member sockets of a [`u`](#u) group, just after a pending connection
+in the background has been resolved and the connection has failed. Note that this
+function is not guaranteed to be called if the [`u`](#u) socket is set to blocking
+mode ([`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) option set to true).
+It is guaranteed to be called when a socket is in non-blocking mode, or when you
+use a group.
+
+This function is mainly intended to be used with group connections. Note that even
+if you use a group connection in blocking mode, after the group is considered
+connected the member connections still continue in background. Also, when some
+connections are still pending and others have failed, the blocking call for
+[`srt_connect_group`](#srt_connect_group) will not exit until at least one of
+them succeeds or all fail - in such a case those failures also happen only in
+the background, while the connecting function blocks until all connections are
+resolved. When all links fail, you will only get a general error code for the
+group. This mechanism allows you to get individual errors for particular member
+connection failures.
+
+**Arguments**:
+
+* [`u`](#u): Socket or group that will be used for connecting and for which the hook is installed
+* `hook_fn`: The callback hook function pointer (or NULL to remove the callback)
+* `hook_opaque`: The pointer value that will be passed to the callback function
+
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Successful                                                |
+|        -1                     | Error                                                     |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                       |                                           |
+|:---------------------------------- |:------------------------------------------|
+| [`SRT_ECONNSOCK`](#srt_econnsock)  | It can't be modified in a connected socket|
+| <img width=240px height=1px/>      | <img width=710px height=1px/>                      |
+
+
+The callback function signature has the following type definition:
+
+```
+typedef void srt_connect_callback_fn(void* opaq, SRTSOCKET ns, int errorcode, const struct sockaddr* peeraddr, int token);
+```
+
+**Arguments**:
+
+* `opaq`: The pointer passed as `hook_opaque` when registering
+* `ns`: The socket for which the connection process was resolved
+* [`errorcode`](#error-codes): The error code, same as for [`srt_connect`](#srt_connect) for blocking mode
+* `peeraddr`: The target address passed to [`srt_connect`](#srt_connect) call
+* `token`: The token value, if it was used for group connection, otherwise -1
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Socket Group Management
+
+  * [SRT_GROUP_TYPE](#SRT_GROUP_TYPE)
+  * [SRT_SOCKGROUPCONFIG](#SRT_SOCKGROUPCONFIG)
+  * [SRT_SOCKGROUPDATA](#SRT_SOCKGROUPDATA)
+  * [SRT_MEMBERSTATUS](#SRT_MEMBERSTATUS)
+
+### SRT_GROUP_TYPE
+
+The following group types are collected in an [`SRT_GROUP_TYPE`](#SRT_GROUP_TYPE) enum:
+
+* `SRT_GTYPE_BROADCAST`: broadcast type, all links are actively used at once;
+* `SRT_GTYPE_BACKUP`: backup type, idle links take over connection on disturbance.
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### SRT_SOCKGROUPCONFIG
+
+This structure is used to define entry points for connections for the
+[`srt_connect_group`](#srt_connect_group) function:
+
+```
+typedef struct SRT_GroupMemberConfig_
+{
+    SRTSOCKET id;
+    struct sockaddr_storage srcaddr;
+    struct sockaddr_storage peeraddr;
+    uint16_t weight;
+    SRT_SOCKOPT_CONFIG* config;
+    int errorcode;
+    int token;
+} SRT_SOCKGROUPCONFIG;
+```
+
+where:
+
+* `id`: member socket ID (filled back as output)
+* `srcaddr`: address to which `id` should be bound
+* `peeraddr`: address to which `id` should be connected
+* `weight`: the weight parameter for the link (group-type dependent)
+* `config`: the configuration object, if used (see [`srt_create_config()`](#srt_create_config))
+* [`errorcode`](#error-codes): status of the connecting operation
+* `token`: An integer value unique for every connection, or -1 if unused
+
+The `srt_prepare_endpoint` sets these fields to default values. After that
+you can change the value of `weight` and `config` and `token` fields. The
+`weight` parameter's meaning is dependent on the group type:
+
+* BROADCAST: not used
+* BACKUP: positive value of link priority (the greater, the more preferred)
+
+In any case, the allowed value for `weight` is between 0 and 32767.
+
+The `config` parameter is used to provide options to be set separately on a socket
+for a particular connection (see [`srt_create_config()`](#srt_create_config)).
+
+The `token` value is intended to allow the application to more easily identify
+a particular connection. If you don't use it and leave the default value of -1,
+the library will set a unique value for the next connection (a 32-bit unsigned
+number that will overflow by itself; the default value will be skipped).
+The application can also set a unique value by itself and keep the same
+value for the same connection.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### SRT_SOCKGROUPDATA
+
+The most important structure for the group member status is [`SRT_SOCKGROUPDATA`](#SRT_SOCKGROUPDATA):
+
+```c++
+typedef struct SRT_SocketGroupData_
+{
+    SRTSOCKET id;
+    struct sockaddr_storage peeraddr;
+    SRT_SOCKSTATUS sockstate;
+    uint16_t weight;
+    SRT_MEMBERSTATUS memberstate;
+    int result;
+    int token;
+} SRT_SOCKGROUPDATA;
+```
+
+where:
+
+* `id`: member socket ID
+* `peeraddr`: address to which `id` should be connected
+* `sockstate`: current connection status (see [`srt_getsockstate`](#srt_getsockstate)
+* `weight`: current weight value set on the link
+* `memberstate`: current state of the member (see below)
+* `result`: result of the operation (if this operation recently updated this structure)
+* `token`: A token value set for that connection (see [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG))
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### SRT_MEMBERSTATUS
+
+The enumeration type that defines the state of a member
+connection in a group:
+
+* `SRT_GST_PENDING`: The connection is in progress, so the socket
+is not currently being used for transmission, even potentially,
+and still has a chance to fail and transit into `SRT_GST_BROKEN`
+without turning into `SRT_GST_IDLE`
+
+* `SRT_GST_IDLE`: The connection is established and ready to
+take over transmission, but it's not used for transmission at
+the moment. This state may last for a short moment in the case of
+broadcast group. In backup group this state
+defines a backup link that is ready to take over when the
+currently active (running) link becomes unstable.
+
+* `SRT_GST_RUNNING`: The connection is established and at least
+one packet has already been sent or received over it.
+
+* `SRT_GST_BROKEN`: The connection was broken. Broken connections are not to be
+revived. Note also that it is only possible to see this state if it is read by
+[`srt_sendmsg2`](#srt_sendmsg) or [`srt_recvmsg2`](#srt_recvmsg2) just after
+the link failure has been detected. Otherwise, the broken link simply
+disappears from the member list.
+
+Note that internally the member state is separate for sending and receiving. If
+the `memberstate` field of [`SRT_SOCKGROUPDATA`](#SRT_SOCKGROUPDATA) is
+`SRT_GST_RUNNING`, it means that this is the state in at least one
+direction, while in the other direction it may be `SRT_GST_IDLE`. In all
+other cases the states should be the same in both directions.
+
+States should normally start with `SRT_GST_PENDING` and then turn into
+`SRT_GST_IDLE`. Once a new link is used for sending data, the state becomes
+`SRT_GST_RUNNING`. In the case of the `SRT_GTYPE_BACKUP` type group, if a link
+is in the `SRT_GST_RUNNING` state, but another link is chosen to remain
+as the only active one, this link will be "silenced" (its state will
+become `SRT_GST_IDLE`).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### Functions to Be Used on Groups
+
+  * [srt_create_group](#srt_create_group)
+  * [srt_groupof](#srt_groupof)
+  * [srt_group_data](#srt_group_data)
+  * [srt_connect_group](#srt_connect_group)
+  * [srt_prepare_endpoint](#srt_prepare_endpoint)
+  * [srt_create_config](#srt_create_config)
+  * [srt_delete_config](#srt_delete_config)
+  * [srt_config_add](#srt_config_add)
+
+#### srt_create_group
+
+```
+SRTSOCKET srt_create_group(SRT_GROUP_TYPE type);
+```
+
+Creates a new group of type `type`. Is typically called on the
+caller side to be next used for connecting to a remote SRT listener.
+The group ID is of the same domain as the socket ID, with the exception that
+the `SRTGROUP_MASK` bit is set on it, unlike for socket ID.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRTSOCKET`                   | Group SRT socket ID.                                      |
+| `SRT_INVALID_SOCK`            | On error or if bonding API is disabled.                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                             |
+
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_groupof
+
+```
+SRTSOCKET srt_groupof(SRTSOCKET member);
+```
+
+Retrieves the group SRT socket ID that corresponds to the member socket ID `member`.
+
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRTSOCKET`                   | Corresponding group SRT socket ID of the member socket.   |
+| `SRT_INVALID_SOCK`            | The socket doesn't exist, it is not a member of any group, or bonding API is disabled. |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                             |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_group_data
+
+```
+int srt_group_data(SRTSOCKET socketgroup, SRT_SOCKGROUPDATA output[], size_t* inoutlen);
+```
+
+**Arguments**:
+
+* `socketgroup` an existing socket group ID
+* `output` points to an output array
+* `inoutlen` points to a variable that stores the size of the `output` array,
+  and is set to the filled array's size
+
+This function obtains the current member state of the group specified in
+`socketgroup`. The `output` should point to an array large enough to hold all
+the elements. The `inoutlen` should point to a variable initially set to the size
+of the `output` array. The current number of members will be written back to `inoutlen`.
+
+If the size of the `output` array is enough for the current number of members,
+the `output` array will be filled with group data and the function will return
+the number of elements filled. Otherwise the array will not be filled and
+`SRT_ERROR` will be returned.
+
+This function can be used to get the group size by setting `output` to `NULL`,
+and providing `socketgroup` and `inoutlen`.
+
+|      Returns                  |                                                    |
+|:----------------------------- |:-------------------------------------------------- |
+|   # of elements               | The number of data elements filled, on success     |
+|         -1                    | Error                                              |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+
+|      Errors                        |                                                           |
+|:---------------------------------- |:--------------------------------------------------------- |
+| [`SRT_EINVPARAM`](#srt_einvparam)  | Reported if `socketgroup` is not an existing group ID. Or if bonding API is disabled. |
+| [`SRT_ELARGEMSG`](#srt_elargemsg)  | Reported if `inoutlen` if less than the size of the group |
+| <img width=240px height=1px/>      | <img width=710px height=1px/>                      |
+
+
+| in:output | in:inoutlen    | returns      | out:output | out:inoutlen | Error                             |
+|:---------:|:--------------:|:------------:|:----------:|:------------:|:---------------------------------:|
+| NULL      | NULL           | -1           | NULL       | NULL         | [`SRT_EINVPARAM`](#srt_einvparam) |
+| NULL      | ptr            | 0            | NULL       | group.size() | ✖️                                |
+| ptr       | NULL           | -1           | ✖️         | NULL         | [`SRT_EINVPARAM`](#srt_einvparam) |
+| ptr       | ≥ group.size   | group.size() | group.data | group.size   | ✖️                                |
+| ptr       | < group.size   | -1           | ✖️         | group.size   | [`SRT_ELARGEMSG`](#srt_elargemsg) |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_connect_group
+
+```
+int srt_connect_group(SRTSOCKET group,
+                      SRT_SOCKGROUPCONFIG name [], int arraysize);
+```
+
+This function does almost the same as calling [`srt_connect`](#srt_connect) or
+[`srt_connect_bind`](#srt_connect_bind) (when the source was specified for
+[`srt_prepare_endpoint`](#srt_prepare_endpoint)) in a loop for every item specified
+in the `name` array. However if blocking mode is being used, the first call to
+[`srt_connect`](#srt_connect) would block until the connection is established,
+whereas this function blocks until any of the specified connections is established.
+
+If the group nonblocking mode is set ([`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN)
+option), there's no difference, except that the [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG)
+structure allows adding extra configuration data used by groups. Note also that
+this function accepts only groups, not sockets.
+
+The elements of the `name` array need to be prepared with the use of the
+[`srt_prepare_endpoint`](#srt_prepare_endpoint) function. Note that it is
+**NOT** required that every target address specified is of the same family.
+
+Return value and errors in this function are the same as in [`srt_connect`](#srt_connect),
+although this function reports success when at least one connection has
+succeeded. If none has succeeded, this function reports an [`SRT_ECONNLOST`](#srt_econnlost)
+error. Particular connection states can be obtained from the `name`
+array upon return from the [`errorcode`](#error-codes) field.
+
+The fields of [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG) structure have the following meaning:
+
+**Input**:
+
+* `id`: unused, should be -1 (default when created by [`srt_prepare_endpoint`](#srt_prepare_endpoint))
+* `srcaddr`: address to bind before connecting, if specified (see below for details)
+* `peeraddr`: target address to connect
+* `weight`: weight value to be set on the link
+* `config`: socket options to be set on the socket before connecting
+* [`errorcode`](#error-codes): unused, should be [`SRT_SUCCESS`](#srt_success) (default)
+* `token`: An integer value unique for every connection, or -1 if unused
+
+**Output**:
+
+* `id`: The socket created for that connection (-1 if failed to create)
+* `srcaddr`: unchanged
+* `peeraddr`: unchanged
+* `weight`: unchanged
+* `config`: unchanged (the object should be manually deleted upon return)
+* [`errorcode`](#error-codes): status of connection for that link ([`SRT_SUCCESS`](#srt_success) if succeeded)
+* `token`: same as in input, or a newly created token value if input was -1
+
+|      Returns                  |                                                    |
+|:----------------------------- |:-------------------------------------------------- |
+|   `SRT_SOCKET`                | The socket ID of the first connected member.       |
+|         -1                    | Error                                              |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+
+|      Errors                        |                                                           |
+|:---------------------------------- |:--------------------------------------------------------- |
+| [`SRT_EINVPARAM`](#srt_einvparam)  | Reported if `socketgroup` is not an existing group ID. Or if bonding API is disabled. |
+| [`SRT_ECONNLOST`](#srt_econnlost)  | Reported if none of member sockets has connected. |
+| <img width=240px height=1px/>      | <img width=710px height=1px/>                      |
+
+The procedure of connecting for every connection definition specified
+in the `name` array is performed the following way:
+
+1. The socket for this connection is first created
+
+2. Socket options derived from the group are set on that socket.
+
+3. If `config` is not NULL, configuration options stored there are set on that socket.
+
+4. If source address is specified (that is `srcaddr` value is **not**
+default empty, as described in [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG),
+then the binding operation is done on the socket (see [`srt_bind`](#srt_bind)).
+
+5. The socket is added to the group as a member.
+
+6. The socket is connected to the target address, as specified
+in the `peeraddr` field.
+
+During this process there can be errors at any stage. There are two
+possibilities as to what may happen in this case:
+
+1. If creation of a new socket has failed, which may only happen due to
+problems with system resources, then the whole loop is interrupted and no
+further items in the array are processed. All sockets that got created until
+then, and for which the connection attempt has at least successfully started,
+remain group members, although the function will return immediately with an
+error status (that is, without waiting for the first successful connection). If
+your application wants to do any partial recovery from this situation, it can
+only use the epoll mechanism to wait for readiness.
+
+2. In any other case, if an error occurs at any stage of the above process, the
+processing is interrupted for this very array item only, the socket used for it
+is immediately closed, and the processing of the next elements continues. In the case
+of a connection process, it also passes two stages - parameter check and the process
+itself. Failure at the parameter check breaks this process, while if the check
+passes, this item is considered correctly processed, even if the connection
+attempt is going to fail later. If this function is called in blocking mode,
+it then blocks until at least one connection reports success, or if all of them
+fail. The status of connections that continue in the background after this function
+exits can then be checked by [`srt_group_data`](#srt_group_data).
+
+As member socket connections are running in the background, for determining
+if a particular connection has succeeded or failed it is recommended
+to use [`srt_connect_callback`](#srt_connect_callback). In this case the
+`token` callback function parameter will be the same as the `token` value used
+for the particular item in the `name` connection table.
+
+The `token` value doesn't have any limitations except that the -1 value is
+a "trap representation", that is, when set on input it will make the internals
+define a unique value for the `token`. Your application can also set unique values,
+in which case the `token` value will be preserved.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_prepare_endpoint
+
+```
+SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src /*nullable*/,
+                                       const struct sockaddr* dst, int namelen);
+```
+
+This function prepares a default [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG) object as an element
+of the array you can prepare for [`srt_connect_group`](#srt_connect_group) function, filled with
+additional data:
+
+**Arguments**:
+
+* `src`: address to which the newly created socket should be bound
+* `dst`: address to which the newly created socket should connect
+* `namelen`: size of both `src` and `dst`
+
+The following fields are set by this function:
+
+* `id`: -1 (unused for input)
+* `srcaddr`: default empty (see below) or copied from `src`
+* `peeraddr`: copied from `dst`
+* `weight`: 0
+* `config`: `NULL`
+* [`errorcode`](#error-codes): [`SRT_SUCCESS`](#srt_success)
+
+The default empty `srcaddr` is set the following way:
+
+* `ss_family` set to the same value as `dst->sa_family`
+* empty address (`INADDR_ANY` for IPv4 and `in6addr_any` for IPv6)
+* port number 0
+
+If `src` is not NULL, then `srcaddr` is copied from `src`. Otherwise
+it will remain as default empty.
+
+The `dst` parameter is obligatory. If `src` parameter is not NULL,
+then both `dst` and `src` must have the same value of `sa_family`.
+
+Note though that this function has no possibility of reporting errors - these
+would be reported only by [`srt_connect_group`](#srt_connect_group), separately
+for every individual connection, and the status can be obtained from
+the [`errorcode`](#error-codes) field.
+
+Note that the `errorcode` field of the `SRT_SOCKGROUPCONFIG` returned would be set to `SRT_EINVOP`
+if the bonding API is disabled (`ENABLE_BONDING=OFF`).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_create_config
+
+```
+SRT_SOCKOPT_CONFIG* srt_create_config();
+```
+
+Creates a dynamic object for specifying the socket options. You can add options
+to be set on the socket by [`srt_config_add`](#srt_config_add) and then mount this
+object into the `config` field in [`SRT_SOCKGROUPCONFIG`](#SRT_SOCKGROUPCONFIG)
+object for that particular connection. After the object is no longer needed, you
+should delete it using [`srt_delete_config`](#srt_delete_config).
+
+|      Returns                  |                                                                    |
+|:----------------------------- |:------------------------------------------------------------------ |
+|      Pointer                  | The pointer to the created object (memory allocation errors apply) |
+|      NULL                     | If bonding API is disabled.                                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_delete_config
+
+```
+void srt_delete_config(SRT_SOCKOPT_CONFIG* c);
+```
+
+Deletes the configuration object.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+#### srt_config_add
+
+```
+int srt_config_add(SRT_SOCKOPT_CONFIG* c, SRT_SOCKOPT opt, void* val, int len);
+```
+
+Adds a configuration option to the configuration object.
+
+Parameters have meanings similar to [`srt_setsockflag`](#srt_setsockflag). Note
+that not every option is allowed to be set this way. However, the option (if allowed)
+isn't checked if it doesn't violate other preconditions. This will be checked when
+the option is being set on the socket, which may fail as a part of the connection
+process done by [`srt_connect_group`](#srt_connect_group).
+
+This function should be used when this option must be set individually on a socket
+and differently for a particular link. If you need to set some option the same way
+on every socket, you should instead set this option on the whole group.
+
+The following options are allowed to be set on the member socket:
+
+* [`SRTO_BINDTODEVICE`](API-socket-options.md#SRTO_BINDTODEVICE): If you want to limit binding for this link (Linux only)
+* [`SRTO_CONNTIMEO`](API-socket-options.md#SRTO_CONNTIMEO): If you want to give more time to connect on this link
+* [`SRTO_GROUPMINSTABLETIMEO`](API-socket-options.md#SRTO_GROUPMINSTABLETIMEO): To set ACK jitter tolerance per individual link
+* [`SRTO_LOSSMAXTTL`](API-socket-options.md#SRTO_LOSSMAXTTL): If this link tends to suffer from UDP reordering
+* [`SRTO_NAKREPORT`](API-socket-options.md#SRTO_NAKREPORT): If you don't want NAKREPORT to work for this link
+* [`SRTO_PEERIDLETIMEO`](API-socket-options.md#SRTO_PEERIDLETIMEO): If you want to be more tolerant for temporary outages
+* [`SRTO_RCVBUF`](API-socket-options.md#SRTO_RCVBUF): Allows for larger receiver buffer for longer recovery
+* [`SRTO_SNDBUF`](API-socket-options.md#SRTO_SNDBUF): Allows for larger sender buffer for slower links
+* [`SRTO_SNDDROPDELAY`](API-socket-options.md#SRTO_SNDDROPDELAY): When particular link tends to drop too eagerly
+* [`SRTO_UDP_RCVBUF`](API-socket-options.md#SRTO_UDP_RCVBUF): UDP receiver buffer, if this link has a big flight window
+* [`SRTO_UDP_SNDBUF`](API-socket-options.md#SRTO_UDP_SNDBUF): UDP sender buffer, if this link has a big flight window
+
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                       |                                                                       |
+|:---------------------------------- |:--------------------------------------------------------------------- |
+| [`SRT_EINVPARAM`](#srt_einvparam)  | This option is not allowed to be set on a socket being a group member. Or if bonding API is disabled. |
+| <img width=240px height=1px/>      | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Options and Properties
+
+* [srt_getpeername](#srt_getpeername)
+* [srt_getsockname](#srt_getsockname)
+* [srt_getsockopt, srt_getsockflag](#srt_getsockopt-srt_getsockflag)
+* [srt_setsockopt, srt_setsockflag](#srt_setsockopt-srt_setsockflag)
+* [srt_getversion](#srt_getversion)
+
+**NOTE**: For more information, see [SRT API Socket Options, Getting and Setting Options](API-socket-options.md#getting-and-setting-options).
+
+### srt_getpeername
+```
+int srt_getpeername(SRTSOCKET u, struct sockaddr* name, int* namelen);
+```
+
+Retrieves the remote address to which the socket is connected.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                    |                                                                          |
+|:------------------------------- |:------------------------------------------------------------------------ |
+| [`SRT_EINVSOCK`](#srt_einvsock) | Socket [`u`](#u) indicates no valid socket ID                            |
+| [`SRT_ENOCONN`](#srt_enoconn)   | Socket [`u`](#u) isn't connected, so there's no remote address to return |
+| <img width=240px height=1px/>   | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getsockname
+```
+int srt_getsockname(SRTSOCKET u, struct sockaddr* name, int* namelen);
+```
+
+Extracts the address to which the socket was bound. Although you should know
+the address(es) that you have used for binding yourself, this function can be
+useful for extracting the local outgoing port number when it was specified as 0
+with binding for system autoselection. With this function you can extract the
+port number after it has been autoselected.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                    |                                                |
+|:------------------------------- |:---------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock) | Socket [`u`](#u) indicates no valid socket ID  |
+| [`SRT_ENOCONN`](#srt_enoconn)   | Socket [`u`](#u) isn't bound, so there's no local address to return <br/>(:warning: &nbsp; **BUG?** It should rather be [`SRT_EUNBOUNDSOCK`](#srt_eunboundsock))        |
+| <img width=240px height=1px/>   | <img width=710px height=1px/>                      |
+
+Example
+
+```c++
+sockaddr_storage name;
+int namelen = sizeof sockaddr_storage;
+int res = srt_getsockname(m_listener_sock, (sockaddr*) &name, &namelen);
+// IPv4: namelen == sockaddr_in.
+// IPv6: namelen == sockaddr_in6.
+if (res < 0) {
+    std::cerr << "Error " << srt_getlasterror_str() << '\n';
+}
+```
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getsockopt
+### srt_getsockflag
+
+```c++
+int srt_getsockopt(SRTSOCKET u, int level /*ignored*/, SRT_SOCKOPT opt, void* optval, int* optlen);
+int srt_getsockflag(SRTSOCKET u, SRT_SOCKOPT opt, void* optval, int* optlen);
+```
+
+Gets the value of the given socket option (from a socket or a group).
+
+The first version ([`srt_getsockopt`](#srt_getsockopt)) follows the BSD socket
+API convention, although the "level" parameter is ignored. The second version
+([`srt_getsockflag`](#srt_getsockflag)) omits the "level" parameter completely.
+
+Options correspond to various data types (see [API-socket-options.md](./API-socket-options.md)).
+A variable `optval` of the appropriate data type has to be passed.
+The integer value of `optlen` should originally contain the size of the `optval` type provided;
+on return, it will be set to the size of the value returned.
+For most options, it will be the size of an integer. Some options, however, use types `bool`, `int64_t`, `C string`, etc.
+(see [API-socket-options.md](./API-socket-options.md#sockopt_types)).
+
+The application is responsible for allocating sufficient memory space as defined and pointed to by `optval`.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                     |                                                |
+|:-------------------------------- |:---------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)  | Socket [`u`](#u) indicates no valid socket ID  |
+| [`SRT_EINVOP`](#srt_einvop)      | Option `opt` indicates no valid option         |
+| <img width=240px height=1px/>    | <img width=710px height=1px/>                  |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+### srt_setsockopt
+### srt_setsockflag
+
+```c++
+int srt_setsockopt(SRTSOCKET u, int level /*ignored*/, SRT_SOCKOPT opt, const void* optval, int optlen);
+int srt_setsockflag(SRTSOCKET u, SRT_SOCKOPT opt, const void* optval, int optlen);
+```
+
+Sets a value for a socket option in the socket or group.
+
+The first version ([`srt_setsockopt`](#srt_setsockopt)) follows the BSD socket
+API convention, although the "level" parameter is ignored. The second version
+([`srt_setsockflag`](#srt_setsockflag)) omits the "level" parameter completely.
+
+Options correspond to various data types, so you need to know what data type is
+assigned to a particular option, and to pass a variable of the appropriate data
+type with the option value to be set.
+
+Please note that some of the options can only be set on sockets or only on
+groups, although most of the options can be set on the groups so that they
+are then derived by the member sockets.
+
+|      Returns                  |                                                 |
+|:----------------------------- |:----------------------------------------------- |
+| `SRT_ERROR`                   | (-1) in case of error, otherwise 0              |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                   |
+
+|       Errors                        |                                               |
+|:----------------------------------- |:--------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)     | Socket [`u`](#u) indicates no valid socket ID |
+| [`SRT_EINVPARAM`](#srt_einvparam)   | Option `opt` indicates no valid option        |
+| [`SRT_EBOUNDSOCK`](#srt_eboundsock) | Tried to set an option with PRE_BIND restriction on a bound socket. |
+| [`SRT_ECONNSOCK`](#srt_econnsock)   | Tried to set an option with PRE_BIND or PRE restriction on a socket in connecting/listening/connected state. |
+| <img width=240px height=1px/>   | <img width=710px height=1px/>                 |
+
+**NOTE*: Various other errors may result from problems when setting a
+specific option (see option description in [API-socket-options.md](./API-socket-options.md) for details).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getversion
+
+```
+uint32_t srt_getversion();
+```
+
+Get SRT version value. The version format in hex is 0xXXYYZZ for x.y.z in human
+readable form, where x = ("%d", (version>>16) & 0xff), etc.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+| SRT Version                   | Unsigned 32-bit integer                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                             |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Helper Data Types for Transmission
+
+* [SRT_MSGCTRL](#SRT_MSGCTRL)
+
+**NOTE:** There might be a difference in terminology used in [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) and current documentation.
+Please consult [Data Transmission Modes](https://tools.ietf.org/html/draft-sharabayko-srt-01#section-4.2)
+and [Best Practices and Configuration Tips for Data Transmission via SRT](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-7)
+sections of the Internet Draft additionally. The current section is going to be reworked accordingly.
+
+### SRT_MSGCTRL
+
+The [`SRT_MSGCTRL`](#SRT_MSGCTRL) structure:
+
+```c++
+typedef struct SRT_MsgCtrl_
+{
+   int flags;                   // Left for future
+   int msgttl;                  // TTL for a message, default -1 (no TTL limitation)
+   int inorder;                 // Whether a message is allowed to supersede a partially lost one. Unused in stream and live mode
+   int boundary;                // 0:mid pkt, 1(01b):end of frame, 2(11b):complete frame, 3(10b): start of frame
+   int64_t srctime;             // Source time, in microseconds since SRT internal clock epoch
+   int32_t pktseq;              // Sequence number of the first packet in received message (unused for sending)
+   int32_t msgno;               // Message number (output value for both sending and receiving)
+   SRT_SOCKGROUPDATA* grpdata;  // Pointer to group data array
+   size_t grpdata_size;         // Size of the group array
+} SRT_MSGCTRL;
+```
+
+The [`SRT_MSGCTRL`](#SRT_MSGCTRL) structure is used in [`srt_sendmsg2`](#srt_sendmsg)
+and [`srt_recvmsg2`](#srt_recvmsg2) calls and specifies some special extra parameters:
+
+- `flags`: [IN, OUT]. RESERVED FOR FUTURE USE (should be 0). This is
+intended to specify some special options controlling the details of how the
+called function should work.
+
+- `msgttl`: [IN]. In **message** and **live mode** only, specifies the TTL for
+sending messages (in `[ms]`). Not used for receiving messages. If this value
+is not negative, it defines the maximum time up to which this message should
+stay scheduled for sending. If TTL has expired, the message sending and further retransmissions are discarded, even
+if it has never been sent so far.
+
+- `inorder`: [IN]. In **message mode** only, specifies that sent messages should
+be extracted by the receiver in the order of sending. This can be meaningful if
+a packet loss has happened, and a particular message must wait for retransmission
+so that it can be reassembled and then delivered. When this flag is false, the
+message can be delivered even if there are any previous messages still waiting
+for completion.
+
+- `boundary`: RESERVED FOR FUTURE USE. Intended to be used in a special mode
+when you are allowed to send or retrieve a part of the message.
+
+- `srctime`:
+  - [OUT] Receiver only. Specifies the time when the packet was intended to be
+delivered to the receiving application (in microseconds since SRT clock epoch).
+  - [IN] Sender only. Specifies the application-provided timestamp to be associated
+with the packet. If not provided (specified as 0), the current time of
+SRT internal clock is used.
+  - For details on how to use `srctime` please refer to the [Time Access](#time-access) section.
+
+- `pktseq`: Receiver only. Reports the sequence number for the packet carrying
+out the payload being returned. If the payload is carried out by more than one
+UDP packet, only the sequence of the first one is reported. Note that in
+**live mode** there's always one UDP packet per message.
+
+- `msgno`: Message number that can be sent by both sender and receiver,
+although it is required that this value remain monotonic in subsequent send calls.
+Normally message numbers start with 1 and increase with every message sent.
+
+- `grpdata` and `grpdata_size`: Pointer and size of the group array. For single
+socket connections these values should remain NULL and 0 respectively. When you
+call [`srt_sendmsg2`](#srt_sendmsg) or [`srt_recvmsg2`](#srt_recvmsg2) function
+for a group, you should pass an array here so that you can retrieve the status of
+particular member sockets. If you pass an array that is too small, your `grpdata_size`
+field will be rewritten with the current number of members, but without filling in
+the array; otherwise both fields are updated to reflect the current connection state
+of the group. For details, see the [SRT Connection Bonding: Quick Start](../features/bonding-intro.md) and
+[SRT Connection Bonding: Socket Groups](../features/socket-groups.md) documents.
+
+**Helpers for [`SRT_MSGCTRL`](#SRT_MSGCTRL):**
+
+```
+void srt_msgctrl_init(SRT_MSGCTRL* mctrl);
+const SRT_MSGCTRL srt_msgctrl_default;
+```
+
+Helpers for getting an object of [`SRT_MSGCTRL`](#SRT_MSGCTRL) type ready to use.
+The first is a function that fills the object with default values. The second is
+a constant object and can be used as a source for assignment. Note that you cannot
+pass this constant object into any of the API functions because they require it
+to be mutable, as they use some fields to output values.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Transmission
+
+* [srt_send, srt_sendmsg, srt_sendmsg2](#srt_send-srt_sendmsg-srt_sendmsg2)
+* [srt_recv, srt_recvmsg, srt_recvmsg2](#srt_recv-srt_recvmsg-srt_recvmsg2)
+* [srt_sendfile, srt_recvfile](#srt_sendfile-srt_recvfile)
+
+**NOTE:** There might be a difference in terminology used in [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) and current documentation.
+Please consult [Data Transmission Modes](https://tools.ietf.org/html/draft-sharabayko-srt-01#section-4.2)
+and [Best Practices and Configuration Tips for Data Transmission via SRT](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-7)
+sections of the Internet Draft additionally. The current section is going to be reworked accordingly.
+
+
+### srt_send
+### srt_sendmsg
+### srt_sendmsg2
+
+```
+int srt_send(SRTSOCKET u, const char* buf, int len);
+int srt_sendmsg(SRTSOCKET u, const char* buf, int len, int ttl/* = -1*/, int inorder/* = false*/);
+int srt_sendmsg2(SRTSOCKET u, const char* buf, int len, SRT_MSGCTRL *mctrl);
+```
+
+Sends a payload to a remote party over a given socket.
+
+**Arguments**:
+
+* [`u`](#u): Socket used to send. The socket must be connected for this operation.
+* `buf`: Points to the buffer containing the payload to send.
+* `len`: Size of the payload specified in `buf`.
+* `ttl`: Time (in `[ms]`) to wait for a successful delivery. See description of
+the [`SRT_MSGCTRL::msgttl`](#SRT_MSGCTRL) field.
+* `inorder`: Required to be received in the order of sending. See
+[`SRT_MSGCTRL::inorder`](#SRT_MSGCTRL).
+* `mctrl`: An object of [`SRT_MSGCTRL`](#SRT_MSGCTRL) type that contains extra
+parameters, including `ttl` and `inorder`.
+
+The way this function works is determined by the mode set in options, and it has
+specific requirements:
+
+1. In **file/stream mode**, the payload is byte-based. You are not required to
+know the size of the data, although they are only guaranteed to be received
+in the same byte order.
+
+2. In **file/message mode**, the payload that you send using this function is
+a single message that you intend to be received as a whole. In other words, a
+single call to this function determines a message's boundaries.
+
+3. In **live mode**, you are only allowed to send up to the length of
+`SRTO_PAYLOADSIZE`, which can't be larger than 1456 bytes (1316 default).
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|       Size                    | Size of the data sent, if successful                      |
+|    `SRT_ERROR`                | In case of error (-1)                                     |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+**NOTE**: Note that in **file/stream mode** the returned size may be less than `len`,
+which means that it didn't send the whole contents of the buffer. You would need to
+call this function again with the rest of the buffer next time to send it completely.
+In both **file/message** and **live mode** the successful return is always equal to `len`.
+
+|       Errors                                  |                                                                                                                     |
+|:--------------------------------------------- |:------------------------------------------------------------------------------------------------------------------- |
+| [`SRT_ENOCONN`](#srt_enoconn)                 | Socket [`u`](#u) used when the operation is not connected.                                                          |
+| [`SRT_ECONNLOST`](#srt_econnlost)             | Socket [`u`](#u) used for the operation has lost its connection.                                                    |
+| [`SRT_EINVALMSGAPI`](#srt_einvalmsgapi)       | Incorrect API usage in **message mode**:<br/>**live mode**: trying to send more bytes at once than `SRTO_PAYLOADSIZE` or wrong source time <br/>was provided. |
+| [`SRT_EINVALBUFFERAPI`](#srt_einvalbufferapi) | Incorrect API usage in **stream mode** (reserved for future use):<br/>The congestion controller object used for this mode doesn't use any restrictions on this call, <br/>but this may change. |
+| [`SRT_ELARGEMSG`](#srt_elargemsg)             | Message to be sent can't fit in the sending buffer (that is, it exceeds the current total space in the <br/>sending buffer in bytes). This means that the sender buffer is too small, or the application is <br/>trying to send a larger message than initially predicted.  |
+| [`SRT_EASYNCSND`](#srt_easyncsnd)             | There's no free space currently in the buffer to schedule the payload. This is only reported in <br/>non-blocking mode ([`SRTO_SNDSYN`](API-socket-options.md#SRTO_SNDSYN) set to false); in blocking mode the call is blocked until <br/>enough free space in the sending buffer becomes available.  |
+| [`SRT_ETIMEOUT`](#srt_etimeout)               | The condition described above still persists and the timeout has passed. This is only reported in <br/>blocking mode when [`SRTO_SNDTIMEO`](API-socket-options.md#SRTO_SNDTIMEO) is set to a value other than -1. |
+| [`SRT_EPEERERR`](#srt_epeererr)               | This is reported only in the case where, as a stream is being received by a peer, the <br/>[`srt_recvfile`](#srt_recvfile) function encounters an error during a write operation on a file. This is reported by <br/>a `UMSG_PEERERROR` message from the peer, and the agent sets the appropriate flag internally. <br/>This flag persists up to the moment when the connection is broken or closed. |
+| <img width=240px height=1px/>                 | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_recv
+### srt_recvmsg
+### srt_recvmsg2
+
+
+```
+int srt_recv(SRTSOCKET u, char* buf, int len);
+int srt_recvmsg(SRTSOCKET u, char* buf, int len);
+int srt_recvmsg2(SRTSOCKET u, char *buf, int len, SRT_MSGCTRL *mctrl);
+```
+
+Extracts the payload waiting to be received. Note that [`srt_recv`](#srt_recv) and
+[`srt_recvmsg`](#srt_recvmsg) are identical functions, two different names being
+kept for historical reasons. In the UDT predecessor the application was required
+to use either the `UDT::recv` version for **stream mode** and `UDT::recvmsg` for
+**message mode**. In SRT this distinction is resolved internally by the
+[`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) flag.
+
+**Arguments**:
+
+* [`u`](#u): Socket used to send. The socket must be connected for this operation.
+* `buf`: Points to the buffer to which the payload is copied.
+* `len`: Size of the payload specified in `buf`.
+* `mctrl`: An object of [`SRT_MSGCTRL`](#SRT_MSGCTRL) type that contains extra
+parameters.
+
+The way this function works is determined by the mode set in options, and it has
+specific requirements:
+
+1. In **file/stream mode**, as many bytes as possible are retrieved, that is,
+only so many bytes that fit in the buffer and are currently available. Any
+data that is available but not extracted this time will be available next time.
+
+2. In **file/message mode**, exactly one message is retrieved, with the
+boundaries defined at the moment of sending. If some parts of the messages are
+already retrieved, but not the whole message, nothing will be received (the
+function blocks or returns [`SRT_EASYNCRCV`](#srt_easyncrcv)). If the message
+to be returned does not fit in the buffer, nothing will be received and
+the error is reported.
+
+3. In **live mode**, the function behaves as in **file/message mode**, although the
+number of bytes retrieved will be at most the maximum payload of one MTU.
+The [`SRTO_PAYLOADSIZE`](API-socket-options.md#SRTO_PAYLOADSIZE) value configured by the sender
+is not negotiated, and not known to the receiver.
+The [`SRTO_PAYLOADSIZE`](API-socket-options.md#SRTO_PAYLOADSIZE) value set on the SRT receiver
+is mainly used for heuristics. However, the receiver is prepared to receive
+the whole MTU as configured with [`SRTO_MSS`](API-socket-options.md#SRTO_MSS).
+In this mode, however, with default settings of [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE)
+and [`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP), the message will be
+received only when its time to play has come, and until then it will be kept in the
+receiver buffer. Also, when the time to play has come for a message that is next to
+the currently lost one, it will be delivered and the lost one dropped.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|       Size                    | Size (\>0) of the data received, if successful.           |
+|         0                     | If the connection has been closed                         |
+|   `SRT_ERROR`                 | (-1) when an error occurs                                 |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                                  |                                                           |
+|:--------------------------------------------- |:--------------------------------------------------------- |
+| [`SRT_ENOCONN`](#srt_enoconn)                 | Socket [`u`](#u) used for the operation is not connected. |
+| [`SRT_ECONNLOST`](#srt_econnlost)             | Socket [`u`](#u) used for the operation has lost connection (this is reported only if the connection <br/> was unexpectedly broken, not when it was closed by the foreign host). |
+| [`SRT_EINVALMSGAPI`](#srt_einvalmsgapi)       | Incorrect API usage in **message mode**:<br/>-- **live mode**: size of the buffer is less than [`SRTO_PAYLOADSIZE`](API-socket-options.md#SRTO_PAYLOADSIZE) |
+| [`SRT_EINVALBUFFERAPI`](#srt_einvalbufferapi) | Incorrect API usage in **stream mode**:<br/>• Currently not in use. File congestion control used for **stream mode** does not restrict <br/> the parameters. :warning: &nbsp; **???**   |
+| [`SRT_ELARGEMSG`](#srt_elargemsg)             | Message to be sent can't fit in the sending buffer (that is, it exceeds the current total space in <br/> the sending buffer in bytes). This means that the sender buffer is too small, or the application <br/> is trying to send a larger message than initially intended.  |
+| [`SRT_EASYNCRCV`](#srt_easyncrcv)             | There are no data currently waiting for delivery. This happens only in non-blocking mode <br/> (when [`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) is set to false). In blocking mode the call is blocked until the data are ready. <br/> How this is defined, depends on the mode:<br/>• In **live mode** (with [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) on), at least one packet must be present in the receiver <br/> buffer and its time to play be in the past<br/>• In **file/message mode**, one full message must be available, the next one waiting if there are no <br/> messages with `inorder` = false, or possibly the first message ready with `inorder` = false<br/>• In **file/stream mode**, it is expected to have at least one byte of data still not extracted  |
+| [`SRT_ETIMEOUT`](#srt_etimeout)               | The readiness condition described above is still not achieved and the timeout has passed. <br/> This is only reported in blocking mode when[`SRTO_RCVTIMEO`](API-socket-options.md#SRTO_RCVTIMEO) is set to a value other than -1. |
+| <img width=240px height=1px/>                 | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_sendfile
+### srt_recvfile
+
+```
+int64_t srt_sendfile(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block);
+int64_t srt_recvfile(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block);
+```
+
+These are functions dedicated to sending and receiving a file. You need to call
+this function just once for the whole file, although you need to know the size of
+the file prior to sending, and also define the size of a single block that should
+be internally retrieved and written into a file in a single step. This influences
+only the performance of the internal operations; from the application perspective
+you just have one call that exits only when the transmission is complete.
+
+**Arguments**:
+
+* [`u`](#u): Socket used for transmission. The socket must be connected.
+* `path`: Path to the file that should be read or written.
+* `offset`: Needed to pass or retrieve the offset used to read or write to a file
+* `size`: Size of transfer (file size, if offset is at 0)
+* `block`: Size of the single block to read at once before writing it to a file
+
+The following values are recommended for the `block` parameter:
+
+```
+#define SRT_DEFAULT_SENDFILE_BLOCK 364000
+#define SRT_DEFAULT_RECVFILE_BLOCK 7280000
+```
+
+You need to pass them to the [`srt_sendfile`](#srt_sendfile) or
+[`srt_recvfile`](#srt_recvfile) function if you don't know what value to chose.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|       Size                    | The size (\>0) of the transmitted data of a file. It may be less than `size`, if the size was greater <br/> than the free space in the buffer, in which case you have to send rest of the file next time.  |
+|        -1                     | in case of error                                          |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                                  |                                                                               |
+|:--------------------------------------------- |:----------------------------------------------------------------------------- |
+| [`SRT_ENOCONN`](#srt_enoconn)                 | Socket [`u`](#u) used for the operation is not connected.                     |
+| [`SRT_ECONNLOST`](#srt_econnlost)             | Socket [`u`](#u) used for the operation has lost its connection.              |
+| [`SRT_EINVALBUFFERAPI`](#srt_einvalbufferapi) | When socket has [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) = true or [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) = true. <br/> (:warning: &nbsp; **BUG?**: Looxlike MESSAGEAPI isn't checked)   |
+| [`SRT_EINVRDOFF`](#srt_einvrdoff)             | There is a mistake in `offset` or `size` parameters, which should match the index availability <br/> and size of the bytes available since `offset` index. This is actually reported for [`srt_sendfile`](#srt_sendfile) <br/> when the `seekg` or `tellg` operations resulted in error.  |
+| [`SRT_EINVWROFF`](#srt_einvwroff)             | Like above, reported for [`srt_recvfile`](#srt_recvfile) and `seekp`/`tellp`. |
+| [`SRT_ERDPERM`](#srt_erdperm)                 | The read from file operation has failed ([`srt_sendfile`](#srt_sendfile)).    |
+| [`SRT_EWRPERM`](#srt_ewrperm)                 | The write to file operation has failed ([`srt_recvfile`](#srt_recvfile)).     |
+| <img width=240px height=1px/>                 | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Performance Tracking
+
+* [srt_bstats, srt_bistats](#srt_bstats-srt_bistats)
+
+**Sequence Numbers:**
+The sequence numbers used in SRT are 32-bit "circular numbers" with the most significant
+bit not included. For example 0x7FFFFFFF shifted forward by 3 becomes 2. As far as
+any comparison is concerned, it can be thought of as a "distance" which is an integer
+value expressing an offset to be added to one sequence number in order to get the
+second one. This distance is only valid as long as the threshold value isn't exceeded,
+so it's understood that all sequence numbers that are anywhere taken into account are
+systematically updated and kept in the range between 0 and half of the maximum 0x7FFFFFFF.
+Hence, the distance counting procedure always assumes that the sequence number are in
+the required range already, so for a numbers like 0x7FFFFFF0 and 0x10, for which the
+"numeric difference" would be 0x7FFFFFE0, the "distance" is 0x20.
+
+
+### srt_bstats
+### srt_bistats
+```
+// Performance monitor with Byte counters for better bitrate estimation.
+int srt_bstats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear);
+
+// Performance monitor with Byte counters and instantaneous stats instead of moving averages for Snd/Rcvbuffer sizes.
+int srt_bistats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear, int instantaneous);
+```
+
+Reports the current statistics
+
+**Arguments**:
+
+* [`u`](#u): Socket from which to get statistics
+* `perf`: Pointer to an object to be written with the statistics
+* `clear`: 1 if the statistics should be cleared after retrieval
+* `instantaneous`: 1 if the statistics should use instant data, not moving averages
+
+`SRT_TRACEBSTATS` is an alias to `struct CBytePerfMon`. For a complete description
+of the fields please refer to [SRT Statistics](statistics.md).
+
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)     | Invalid socket ID provided.
+| [`SRT_ECONNLOST`](#srt_econnlost)   | Connection lost (group socket).
+| [`SRT_ENOCONN`](#srt_enoconn)       | Not connected (group socket).
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Asynchronous Operations (Epoll)
+
+* [srt_epoll_create](#srt_epoll_create)
+* [srt_epoll_add_usock, srt_epoll_add_ssock, srt_epoll_update_usock, srt_epoll_update_ssock](#srt_epoll_add_usock-srt_epoll_add_ssock-srt_epoll_update_usock-srt_epoll_update_ssock)
+* [srt_epoll_remove_usock, srt_epoll_remove_ssock](#srt_epoll_remove_usock-srt_epoll_remove_ssock)
+* [srt_epoll_wait](#srt_epoll_wait)
+* [srt_epoll_uwait](#srt_epoll_uwait)
+* [srt_epoll_clear_usocks](#srt_epoll_clear_usocks)
+* [srt_epoll_set](#srt_epoll_set)
+* [srt_epoll_release](#srt_epoll_release)
+
+The epoll system is currently the only method for using multiple sockets in one
+thread with having the blocking operation moved to epoll waiting so that it can
+block on multiple sockets at once. That is, instead of blocking a single reading
+or writing operation, as it's in blocking mode, it blocks until at least one of
+the sockets subscribed for a single waiting call in given operation mode is ready
+to do this operation without blocking. It's usually combined with setting the
+nonblocking mode on a socket. In SRT this is set separately for reading and
+writing ([`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) and
+[`SRTO_SNDSYN`](API-socket-options.md#SRTO_SNDSYN) respectively). This is
+to ensure that if there is internal error in the application (or even possibly
+a bug in SRT that has reported a spurious readiness report) the operation will end
+up with an error rather than cause blocking, which would be more dangerous for the
+application ([`SRT_EASYNCRCV`](#srt_easyncrcv) and [`SRT_EASYNCSND`](#srt_easyncsnd)
+respectively).
+
+The epoll system, similar to the one on Linux, relies on [`eid`](#eid) objects
+managed internally in SRT, which can be subscribed to particular sockets and the
+readiness status of particular operations. The [`srt_epoll_wait`](#srt_epoll_wait)
+function can then be used to block until any readiness status in the whole
+[`eid`](#eid) is set.
+
+
+### srt_epoll_create
+```
+int srt_epoll_create(void);
+```
+
+Creates a new epoll container.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|     valid EID                 | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                       |
+|:----------------------------------- |:--------------------------------------------------------------------- |
+| [`SRT_ECONNSETUP`](#srt_econnsetup) | System operation failed or not enough space to create a new epoll. System error might happen on <br/> systems that use a special method for the system part of epoll (`epoll_create()`, `kqueue()`), <br/> and therefore associated resources, like epoll on Linux.   |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_add_usock
+### srt_epoll_add_ssock
+### srt_epoll_update_usock
+### srt_epoll_update_ssock
+
+```
+int srt_epoll_add_usock(int eid, SRTSOCKET u, const int* events);
+int srt_epoll_add_ssock(int eid, SYSSOCKET s, const int* events);
+int srt_epoll_update_usock(int eid, SRTSOCKET u, const int* events);
+int srt_epoll_update_ssock(int eid, SYSSOCKET s, const int* events);
+```
+
+Adds a socket to a container, or updates an existing socket subscription.
+
+The `_usock` suffix refers to a user socket (SRT socket).
+The `_ssock` suffix refers to a system socket.
+
+The `_add_` functions add new sockets. The `_update_` functions act on a socket that
+is in the container already and just allow changes in the subscription details. For
+example, if you have already subscribed a socket with [`SRT_EPOLL_OUT`](#SRT_EPOLL_OUT)
+to wait until it's connected, to change it into poll for read-readiness, you use this
+function on that same socket with a variable set to [`SRT_EPOLL_IN`](#SRT_EPOLL_IN).
+This will not only change the event type which is polled on the socket, but also
+remove any readiness status for flags that are no longer set. It is discouraged
+to perform socket removal and adding back (instead of using `_update_`) because
+this way you may miss an event that could happen in the brief moment between
+these two calls.
+
+**Arguments**:
+
+* <a name="eid">`eid`</a>: epoll container id
+* <a name="u">`u`</a>: SRT socket
+* <a name="s">`s`(#s)</a>: system socket
+* <a name="eid">`events`</a>: points to
+  * a variable set to epoll flags (see below) to use only selected events
+  * NULL if you want to subscribe a socket for all events in level-triggered mode
+
+Possible epoll flags are the following:
+
+   * <a name="SRT_EPOLL_IN">`SRT_EPOLL_IN`</a>: report readiness for reading or incoming connection on a listener socket
+   * <a name="SRT_EPOLL_OUT">`SRT_EPOLL_OUT`</a>: report readiness for writing or a successful connection
+   * <a name="SRT_EPOLL_ERR">`SRT_EPOLL_ERR`</a>: report errors on the socket
+   * <a name="SRT_EPOLL_UPDATE">`SRT_EPOLL_UPDATE`</a>: an important event has happened that requires attention
+   * <a name="SRT_EPOLL_ET">`SRT_EPOLL_ET`</a>: the event will be edge-triggered
+
+All flags except [`SRT_EPOLL_ET`](#SRT_EPOLL_ET) are event type flags (important for functions
+that expect only event types and not other flags).
+
+The [`SRT_EPOLL_IN`](#SRT_EPOLL_IN), [`SRT_EPOLL_OUT`](#SRT_EPOLL_OUT) and
+[`SRT_EPOLL_ERR`](#SRT_EPOLL_ERR) events are by default **level-triggered**.
+With [`SRT_EPOLL_ET`](#SRT_EPOLL_ET) flag they become **edge-triggered**.
+
+The [`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE) flag is always edge-triggered. It
+designates a special event that happens on a group, or on a listener socket that
+has the [`SRTO_GROUPCONNECT`](API-socket-options.md#SRTO_GROUPCONNECT) flag
+set to allow group connections. This flag is triggered in the following situations:
+
+* for group connections, when a new link has been established for a group that
+is already connected (that is, has at least one connection established),
+[`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE) is reported for the listener socket
+accepting the connection. This is intended for internal use only. An initial
+connection results in reporting the group connection on that listener. But
+when the group is already connected, [`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE)
+is reported instead.
+
+* when one of a group's member connection has been broken
+
+Note that at this time the edge-triggered mode is supported only for SRT
+sockets, not for system sockets.
+
+In the **edge-triggered** mode the function will only return socket states that
+have changed since the last call of the waiting function. All events reported
+in a particular call of the waiting function will be cleared in the internal
+flags and will not be reported until the internal signalling logic clears this
+state and raises it again.
+
+In the **level-triggered** mode the function will always return the readiness
+state as long as it lasts, until the internal signalling logic clears it.
+
+Note that when you use [`SRT_EPOLL_ET`](#SRT_EPOLL_ET) flag in one subscription
+call, it defines edge-triggered mode for all events passed together with it.
+However, if you want to have some events reported as edge-triggered and others
+as level-triggered, you can do two separate subscriptions for the same socket.
+
+**IMPORTANT**: The [`srt_epoll_wait`](#srt_epoll_wait) function does not report
+[`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE) events. If you need the ability to get
+any possible flag, you must use [`srt_epoll_uwait`](#srt_epoll_uwait). Note that
+this function doesn't work with system file descriptors.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+:warning: &nbsp; **BUG?**: for `add_ssock` the system error results in an empty `CUDTException()`
+call which actually results in [`SRT_SUCCESS`](#srt_success). For cases like that
+the [`SRT_ECONNSETUP`](#srt_econnsetup) code is predicted.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_remove_usock
+### srt_epoll_remove_ssock
+
+```
+int srt_epoll_remove_usock(int eid, SRTSOCKET u);
+int srt_epoll_remove_ssock(int eid, SYSSOCKET s);
+```
+
+Removes a specified socket from an epoll container and clears all readiness
+states recorded for that socket.
+
+The `_usock` suffix refers to a user socket (SRT socket).
+The `_ssock` suffix refers to a system socket.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_wait
+```
+int srt_epoll_wait(int eid, SRTSOCKET* readfds, int* rnum, SRTSOCKET* writefds, int* wnum, int64_t msTimeOut,
+                        SYSSOCKET* lrfds, int* lrnum, SYSSOCKET* lwfds, int* lwnum);
+```
+
+Blocks the call until any readiness state occurs in the epoll container.
+
+Readiness can be on a socket in the container for the event type as per
+subscription. Note that in the case when a particular event was subscribed with
+[`SRT_EPOLL_ET`](#SRT_EPOLL_ET) flag, this event, once reported in this function,
+will be cleared internally.
+
+The first readiness state causes this function to exit, but all ready sockets
+are reported. This function blocks until the timeout specified in the `msTimeOut`
+parameter.  If timeout is 0, it exits immediately after checking. If timeout is
+-1, it blocks indefinitely until a readiness state occurs.
+
+**Arguments**:
+
+* `eid`: epoll container
+* `readfds` and `rnum`: A pointer and length of an array to write SRT sockets that are read-ready
+* `writefds` and `wnum`: A pointer and length of an array to write SRT sockets that are write-ready
+* `msTimeOut`: Timeout specified in milliseconds, or special values (0 or -1)
+* `lwfds` and `lwnum`: A pointer and length of an array to write system sockets that are read-ready
+* `lwfds` and `lwnum`: A pointer and length of an array to write system sockets that are write-ready
+
+Note that the following flags are reported:
+
+* [`SRT_EPOLL_IN`](#SRT_EPOLL_IN) as read-ready (also a listener socket ready to accept)
+* [`SRT_EPOLL_OUT`](#SRT_EPOLL_OUT) as write-ready (also a connected socket)
+* [`SRT_EPOLL_ERR`](#SRT_EPOLL_ERR) as both read-ready and write-ready
+* [`SRT_EPOLL_UPDATE`](#SRT_EPOLL_UPDATE) is not reported
+
+There is no space here to report sockets for which it's already known that the operation
+will end up with error (although such a state is known internally). If an error occurred
+on a socket then that socket is reported in both read-ready and write-ready arrays,
+regardless of what event types it was subscribed for. Usually then you subscribe the
+given socket for only read readiness, for example ([`SRT_EPOLL_IN`](#SRT_EPOLL_IN)),
+but pass both arrays for read and write readiness.This socket will not be reported
+in the write readiness array even if it's write ready (because this isn't what it
+was subscribed for), but it will be reported there, if the next operation on this
+socket is about to be erroneous. On such sockets you can still perform an operation,
+just you should expect that it will always report an error. On the other hand that's
+the only way to know what kind of error has occurred on the socket.
+
+|      Returns                  |                                                              |
+|:----------------------------- |:------------------------------------------------------------ |
+|       Number                  | The number (\>0) of ready sockets, of whatever kind (if any) |
+|         -1                    | Error                                                        |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                     |
+|:----------------------------------- |:------------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container    |
+| [`SRT_ETIMEOUT`](#srt_etimeout)     | Up to `msTimeOut` no sockets subscribed in [`eid`](#eid) were ready. This is reported only if `msTimeOut` <br/> was \>=0, otherwise the function waits indefinitely. |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_uwait
+```
+int srt_epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
+```
+
+This function blocks a call until any readiness state occurs in the epoll container.
+Unlike [`srt_epoll_wait`](#srt_epoll_wait), it can only be used with [`eid`](#eid)
+subscribed to user sockets (SRT sockets), not system sockets.
+
+This function blocks until the timeout specified in `msTimeOut` parameter. If
+timeout is 0, it exits immediately after checking. If timeout is -1, it blocks
+indefinitely until a readiness state occurs.
+
+**Arguments**:
+
+* `eid`: epoll container
+* `fdsSet` : A pointer to an array of `SRT_EPOLL_EVENT`
+* `fdsSize` : The size of the fdsSet array
+* `msTimeOut` : Timeout specified in milliseconds, or special values (0 or -1):
+   * 0: Don't wait, return immediately (report any sockets currently ready)
+   * -1: Wait indefinitely.
+
+|      Returns                  |                                                                                                                                        |
+|:----------------------------- |:-------------------------------------------------------------------------------------------------------------------------------------- |
+|       Number                  | The number of user socket (SRT socket) state changes that have been reported in `fdsSet`, <br/> if this number isn't greater than `fdsSize`  |
+|   `fdsSize` + 1               | This means that there was not enough space in the output array to report all events. <br/> For events subscribed with the [`SRT_EPOLL_ET`](#SRT_EPOLL_ET) flag only those will be cleared that were reported. <br/> Others will wait for the next call.  |
+|         0                     | If no readiness state was found on any socket and the timeout has passed <br/> (this is not possible when waiting indefinitely)              |
+|        -1                     | Error                                                                                                                                  |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| [`SRT_EINVPARAM`](#srt_einvparam)   | One of possible usage errors:<br/>* `fdsSize` is < 0<br/>* `fdsSize` is > 0 and `fdsSet` is a null pointer<br/>* [`eid`](#eid) was subscribed to any system socket  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+**IMPORTANT**: This function reports timeout by returning 0, not by [`SRT_ETIMEOUT`](#srt_etimeout) error.
+
+The `SRT_EPOLL_EVENT` structure:
+
+```
+typedef struct SRT_EPOLL_EVENT_
+{
+    SRTSOCKET fd;
+    int       events;
+} SRT_EPOLL_EVENT;
+```
+
+* `fd`: the user socket (SRT socket)
+* [`events`](#events): event flags that report readiness of this socket - a combination
+of [`SRT_EPOLL_IN`](#SRT_EPOLL_IN), [`SRT_EPOLL_OUT`](#SRT_EPOLL_OUT) and [`SRT_EPOLL_ERR`](#SRT_EPOLL_ERR).
+See [srt_epoll_add_usock](#srt_epoll_add_usock) for details.
+
+Note that when [`SRT_EPOLL_ERR`](#SRT_EPOLL_ERR) is set, the underlying socket error
+can't be retrieved with `srt_getlasterror()`. The socket will be automatically
+closed and its state can be verified with a call to [`srt_getsockstate`](#srt_getsockstate).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_clear_usocks
+```
+int srt_epoll_clear_usocks(int eid);
+```
+
+This function removes all SRT ("user") socket subscriptions from the epoll
+container identified by [`eid`](#eid).
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Success                                                   |
+|        -1                     | Failure                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_set
+```
+int32_t srt_epoll_set(int eid, int32_t flags);
+```
+
+This function allows setting or retrieving flags that change the default
+behavior of the epoll functions. All default values for these flags are 0.
+The following flags are available:
+
+* `SRT_EPOLL_ENABLE_EMPTY`: allows the [`srt_epoll_wait`](#srt_epoll_wait) and
+[`srt_epoll_uwait`](#srt_epoll_uwait) functions to be called with the EID not
+subscribed to any socket. The default behavior of these function is to report
+error in this case.
+
+* `SRT_EPOLL_ENABLE_OUTPUTCHECK`: Forces the [`srt_epoll_wait`](#srt_epoll_wait)
+and [`srt_epoll_uwait`](#srt_epoll_uwait) functions to check if the output array
+is not empty. For [`srt_epoll_wait`](#srt_epoll_wait) it is still allowed that
+either system or user array is empty, as long as EID isn't subscribed to this
+type of socket/fd. [`srt_epoll_uwait`](#srt_epoll_uwait) only checks if
+the general output array is not empty.
+
+**Arguments**:
+
+   * `eid`: the epoll container id
+   * `flags`: a nonzero set of the above flags, or special values:
+      * 0: clear all flags (set all defaults)
+      * -1: do not modify any flags
+
+|      Returns                  |                                                                            |
+|:----------------------------- |:-------------------------------------------------------------------------- |
+|                               | This function returns the state of the flags at the time before the call  |
+|        -1                     | Special value in case when an error occurred                              |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_epoll_release
+```
+int srt_epoll_release(int eid);
+```
+
+Deletes the epoll container.
+
+|      Returns                  |                                                                |
+|:----------------------------- |:-------------------------------------------------------------- |
+|                               | The number (\>0) of ready sockets, of whatever kind (if any)  |
+|        -1                     | Error                                                         |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                        |                                                                   |
+|:----------------------------------- |:----------------------------------------------------------------- |
+| [`SRT_EINVPOLLID`](#srt_einvpollid) | [`eid`](#eid) parameter doesn't refer to a valid epoll container  |
+| <img width=240px height=1px/>       | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+
+
+## Logging Control
+
+* [srt_setloglevel](#srt_setloglevel)
+* [srt_addlogfa, srt_dellogfa, srt_resetlogfa](#srt_addlogfa-srt_dellogfa-srt_resetlogfa)
+* [srt_setloghandler](#srt_setloghandler)
+* [srt_setlogflags](#srt_setlogflags)
+
+SRT has a widely used system of logs, as this is usually the only way to determine
+how the internals are working without changing the rules by the act of tracing.
+Logs are split into levels (5 levels out of those defined by syslog are in use)
+and additional filtering is possible on an FA (functional area). By default only
+entries up to the *Note* log level are displayed and from all FAs.
+
+Logging can only be manipulated globally, with no regard to a specific
+socket. This is because lots of operations in SRT are not dedicated to any
+particular socket, and some are shared between sockets.
+
+### srt_setloglevel
+
+```
+void srt_setloglevel(int ll);
+```
+
+Sets the minimum severity for logging. A particular log entry is displayed only
+if it has a severity greater than or equal to the minimum. Setting this value
+to `LOG_DEBUG` turns on all levels.
+
+The constants for this value are those from `<sys/syslog.h>`
+(for Windows, refer to `common/win/syslog_defs.h`). The only meaningful ones are:
+
+* `LOG_DEBUG`: Highly detailed and very frequent messages
+* `LOG_NOTICE`: Occasionally displayed information
+* `LOG_WARNING`: Unusual behavior
+* `LOG_ERR`: Abnormal behavior
+* `LOG_CRIT`: Error that makes the current socket unusable
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_addlogfa
+### srt_dellogfa
+### srt_resetlogfa
+
+```c++
+void srt_addlogfa(int fa);
+void srt_dellogfa(int fa);
+void srt_resetlogfa(const int* fara, size_t fara_size);
+```
+
+A functional area (FA) is an additional filtering mechanism for logging. You can
+set up logging to display logs only from selected FAs. The list of FAs is
+collected in the `srt.h` file, as identified by the `SRT_LOGFA_` prefix. They are
+not enumerated here because they may be changed very often.
+
+All FAs are turned on by default, except potentially dangerous ones
+(such as `SRT_LOGFA_HAICRYPT`). The reason is that they may display either
+some security information that shall remain in memory only (so, only
+if strictly required for development), or some duplicated information
+(so you may want to turn one FA on, while turning off the others).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_setloghandler
+
+```c++
+void srt_setloghandler(void* opaque, SRT_LOG_HANDLER_FN* handler);
+typedef void SRT_LOG_HANDLER_FN(void* opaque, int level, const char* file, int line, const char* area, const char* message);
+```
+
+By default logs are printed to standard error stream. This function replaces
+the sending to a stream with a handler function that will receive them.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_setlogflags
+
+```c++
+void srt_setlogflags(int flags);
+```
+
+When you set a log handler with [`srt_setloghandler`](#srt_setloghandler), you
+may also want to configure which parts of the log information you do not wish to
+be passed in the log line (the `message` parameter). A user's logging facility may,
+for example, not wish to get the current time or log level marker, as it
+will provide this information on its own.
+
+The following flags are available, as collected in the `logging_api.h` public header:
+
+- `SRT_LOGF_DISABLE_TIME`: Do not provide the time in the header
+- `SRT_LOGF_DISABLE_THREADNAME`: Do not provide the thread name in the header
+- `SRT_LOGF_DISABLE_SEVERITY`: Do not provide severity information in the header
+- `SRT_LOGF_DISABLE_EOL`: Do not add the end-of-line character to the log line
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+## Time Access
+
+* [srt_time_now](#srt_time_now)
+* [srt_connection_time](#srt_connection_time)
+
+The following set of functions is intended to retrieve timestamps from the clock
+used by SRT.
+
+The sender can pass the timestamp in `MSGCTRL::srctime` of the `srt_sendmsg2(..)`
+function together with the packet being submitted to SRT. If the `srctime` value
+is not provided (the default value of 0 is set), SRT will use the internal clock
+and assign packet submission time as the packet timestamp. If the sender wants to
+explicitly assign a timestamp to a certain packet this timestamp MUST be taken
+from SRT Time Access functions. The time value provided MUST equal or exceed the
+connection start time (`srt_connection_time(..)`) of the SRT socket passed
+to `srt_sendmsg2(..)`.
+
+The current time value of the SRT internal clock can be retrieved using
+the `srt_time_now()` function.
+
+There are two known cases where you might want to use `srctime`:
+
+1. SRT passthrough (for stream gateways).
+You may wish to simply retrieve packets from an SRT source and pass them transparently
+to an SRT output (possibly re-encrypting). In that case, every packet you read should
+preserve the original value of `srctime` as obtained from [`srt_recvmsg2`](#srt_recvmsg2),
+and the original `srctime` for each packet should be then passed to [`srt_sendmsg2`](#srt_sendmsg).
+This mechanism could be used to avoid jitter resulting from varying differences between
+the time of receiving and sending the same packet.
+
+2. Stable timing source.
+In the case of a live streaming procedure, when spreading packets evenly into the stream,
+you might want to predefine times for every single packet to keep time intervals perfectly equal.
+Or, if you believe that your input signal delivers packets at the exact times that should be
+assigned to them, you might want to preserve these times at the SRT receiving side
+to avoid jitter that may result from varying time differences between the packet arrival
+and the moment when sending it over SRT. In such cases you might do the following:
+
+    - At the packet arrival time, grab the current time at that moment using `srt_time_now()`.
+
+    - When you want a pre-calculated packet time, use a private relative time counter
+    set at the moment when the connection was made. From the moment when your first packet
+    is ready, start pre-calculating packet times relative to the connection start time obtained
+    from `srt_connection_time()`. Although you still have to synchronize sending times with these
+    predefined times, by explicitly specifying the source time you avoid the jitter
+    resulting from a lost accuracy due to waiting time and unfortunate thread scheduling.
+
+Note that `srctime` uses an internally defined clock that is intended to be monotonic
+(the definition depends on the build flags, see below). Because of that **the application
+should not define this time basing on values obtained from the system functions for getting
+the current system time** (such as `time`, `ftime` or `gettimeofday`). To avoid problems and
+misunderstanding you should rely exclusively on time values provided by the
+`srt_time_now()` and `srt_connection_time()` functions.
+
+The clock used by the SRT internal clock is determined by the following build flags:
+- `ENABLE_MONOTONIC` makes use of `CLOCK_MONOTONIC` with `clock_gettime` function.
+- `ENABLE_STDXXX_SYNC` makes use of `std::chrono::steady_clock`.
+
+The default is currently to use the system clock as the internal SRT clock,
+although it's highly recommended to use one of the above monotonic clocks,
+as system clock is vulnerable to time modifications during transmission.
+
+### srt_time_now
+
+```c++
+int64_t srt_time_now();
+```
+
+Get time in microseconds elapsed since epoch using SRT internal clock (steady or monotonic clock).
+
+|      Returns                  |                                                                          |
+|:----------------------------- |:------------------------------------------------------------------------ |
+|                               | Current time in microseconds elapsed since epoch of SRT internal clock.  |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_connection_time
+
+```c++
+int64_t srt_connection_time(SRTSOCKET sock);
+```
+
+Get connection time in microseconds elapsed since epoch using SRT internal clock
+(steady or monotonic clock). The connection time represents the time when SRT socket
+was open to establish a connection. Milliseconds elapsed since connection start time
+can be determined using [**Performance tracking**](#Performance-tracking) functions
+and `msTimeStamp` value of the `SRT_TRACEBSTATS` (see [SRT Statistics](statistics.md)).
+
+|      Returns                  |                                                                             |
+|:----------------------------- |:--------------------------------------------------------------------------- |
+|                               | Connection time in microseconds elapsed since epoch of SRT internal clock  |
+|        -1                     | Error                                                                       |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                      |                                                            |
+|:--------------------------------- |:---------------------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)   | Socket `sock` is not an ID of a valid SRT socket           |
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_clock_type
+
+```c
+int srt_clock_type(void);
+```
+
+Get the type of clock used internally by SRT to be used only for informational purposes.
+Using any time source except for [`srt_time_now()`](#srt_time_now) and [`srt_connection_time(SRTSOCKET)`](#srt_connection_time)
+to timestamp packets submitted to SRT is not recommended and must be done with awareness and at your own risk.
+
+| Returns | Clock Type                          | Description                                |
+| :------ | :---------------------------------- | :------------------------------------------|
+| 0       | `SRT_SYNC_CLOCK_STDCXX_STEADY`      | C++11 `std::chrono::steady_clock`          |
+| 1       | `SRT_SYNC_CLOCK_GETTIME_MONOTONIC`  | `clock_gettime` with `CLOCK_MONOTONIC`     |
+| 2       | `SRT_SYNC_CLOCK_WINQPC`             | Windows `QueryPerformanceCounter(..)`      |
+| 3       | `SRT_SYNC_CLOCK_MACH_ABSTIME`       | `mach_absolute_time()`                     |
+| 4       | `SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY` | POSIX `gettimeofday(..)`                   |
+| 5       | `SRT_SYNC_CLOCK_AMD64_RDTSC`        | `asm("rdtsc" ..)`                          |
+| 6       | `SRT_SYNC_CLOCK_IA32_RDTSC`         | `asm volatile("rdtsc" ..)`                 |
+| 7       | `SRT_SYNC_CLOCK_IA64_ITC`           | `asm("mov %0=ar.itc" ..)`                  |
+
+|       Errors                      |                                                            |
+|:--------------------------------- |:---------------------------------------------------------- |
+| None                              |                                                            |
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+
+## Diagnostics
+
+* [srt_getlasterror_str](#srt_getlasterror_str)
+* [srt_getlasterror](#srt_getlasterror)
+* [srt_strerror](#srt_strerror)
+* [srt_clearlasterror](#srt_clearlasterror)
+* [srt_getrejectreason](#srt_getrejectreason)
+* [srt_rejectreason_str](#srt_rejectreason_str)
+* [srt_setrejectreason](#srt_setrejectreason)
+
+General notes concerning the `getlasterror` diagnostic functions: when an API
+function ends up with error, this error information is stored in a thread-local
+storage. This means that you'll get the error of the operation that was last
+performed as long as you call this diagnostic function just after the failed
+function has returned. In any other situation the information provided by the
+diagnostic function is undefined.
+
+**NOTE**: There are lists of rejection reasons and error codes at the bottom of this section.
+
+
+### srt_getlasterror
+
+```
+int srt_getlasterror(int* errno_loc);
+```
+
+Get the numeric code of the last error. Additionally, in the variable passed as
+`errno_loc` the system error value is returned, or 0 if there was no system error
+associated with the last error. The system error is:
+
+  * On POSIX systems, the value from `errno`
+  * On Windows, the result from `GetLastError()` call
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_strerror
+```
+const char* srt_strerror(int code, int errnoval);
+```
+
+Returns a string message that represents a given SRT error code and possibly the
+`errno` value, if not 0.
+
+**NOTE:** *This function isn't thread safe. It uses a static variable to hold the
+error description. There's no problem with using it in a multithreaded environment,
+as long as only one thread in the whole application calls this function at the
+moment*
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getlasterror_str
+```
+const char* srt_getlasterror_str(void);
+```
+
+Get the text message for the last error. It's a shortcut to calling first
+`srt_getlasterror` and then passing the returned value into [`srt_strerror`](#srt_strerror).
+Note that, contrary to [`srt_strerror`](#srt_strerror), this function is thread safe.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_clearlasterror
+
+```
+void srt_clearlasterror(void);
+```
+
+This function clears the last error. After this call, `srt_getlasterror` will
+report a "successful" code.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_rejectreason_str
+
+```
+const char* srt_rejectreason_str(enum SRT_REJECT_REASON id);
+```
+
+Returns a constant string for the reason of the connection rejected, as per given
+code ID. It provides a system-defined message for values below `SRT_REJ_E_SIZE`.
+For other values below `SRT_REJC_PREDEFINED` it returns the string for
+[`SRT_REJ_UNKNOWN`](#SRT_REJ_UNKNOWN). For values since `SRT_REJC_PREDEFINED` on,
+returns "Application-defined rejection reason".
+
+The actual messages assigned to the internal rejection codes, that is, less than
+`SRT_REJ_E_SIZE`, can be also obtained from the `srt_rejectreason_msg` array.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_setrejectreason
+
+```
+int srt_setrejectreason(SRTSOCKET sock, int value);
+```
+
+Sets the rejection code on the socket. This call is only useful in the listener
+callback. The code from `value` set this way will be set as a rejection reason
+for the socket. After the callback rejects the connection, the code will be passed
+back to the caller peer with the handshake response.
+
+Note that allowed values for this function begin with `SRT_REJC_PREDEFINED`
+(that is, you cannot set a system rejection code). For example, your application
+can inform the calling side that the resource specified under the `r` key in the
+StreamID string (see [`SRTO_STREAMID`](API-socket-options.md#SRTO_STREAMID))
+is not available - it then sets the value to `SRT_REJC_PREDEFINED + 404`.
+
+|      Returns                  |                                                           |
+|:----------------------------- |:--------------------------------------------------------- |
+|         0                     | Error                                                     |
+|        -1                     | Success                                                   |
+| <img width=240px height=1px/> | <img width=710px height=1px/>                      |
+
+|       Errors                      |                                              |
+|:--------------------------------- |:-------------------------------------------- |
+| [`SRT_EINVSOCK`](#srt_einvsock)   | Socket `sock` is not an ID of a valid socket |
+| [`SRT_EINVPARAM`](#srt_einvparam) | `value` is less than `SRT_REJC_PREDEFINED`   |
+| <img width=240px height=1px/>     | <img width=710px height=1px/>                      |
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### srt_getrejectreason
+
+```
+int srt_getrejectreason(SRTSOCKET sock);
+```
+This function provides a more detailed reason for a failed connection attempt. It
+shall be called after a connecting function (such as [`srt_connect`](#srt_connect))
+has returned an error, the code for which is [`SRT_ECONNREJ`](#srt_econnrej). If
+[`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN) has been set on the socket
+used for the connection, the function should also be called when the
+[`SRT_EPOLL_ERR`](#SRT_EPOLL_ERR) event is set for this socket. It returns
+a numeric code, which can be translated into a message by
+[`srt_rejectreason_str`](#srt_rejectreason_str).
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### Rejection Reasons
+
+
+#### SRT_REJ_UNKNOWN
+
+A fallback value for cases when there was no connection rejected.
+
+
+#### SRT_REJ_SYSTEM
+
+One system function reported a failure. Usually this means some system
+error or lack of system resources to complete the task.
+
+
+#### SRT_REJ_PEER
+
+The connection has been rejected by peer, but no further details are available.
+This usually means that the peer doesn't support rejection reason reporting.
+
+
+#### SRT_REJ_RESOURCE
+
+A problem with resource allocation (usually memory).
+
+
+#### SRT_REJ_ROGUE
+
+The data sent by one party to another cannot be properly interpreted. This
+should not happen during normal usage, unless it's a bug, or some weird
+events are happening on the network.
+
+
+#### SRT_REJ_BACKLOG
+
+The listener's backlog has exceeded its queue limit (there are many other callers
+waiting for the opportunity of being connected and wait in the queue, which has
+reached its limit).
+
+
+#### SRT_REJ_IPE
+
+Internal Program Error. This should not happen during normal usage and it
+usually means a bug in the software (although this can be reported by both
+local and foreign host).
+
+
+#### SRT_REJ_CLOSE
+
+The listener socket was able to receive your request, but at this moment it
+is being closed. It's likely that your next attempt will result in a timeout.
+
+
+#### SRT_REJ_VERSION
+
+One party of the connection has set up a minimum version that is required for
+that connection, but the other party didn't satisfy this requirement.
+
+
+#### SRT_REJ_RDVCOOKIE
+
+Rendezvous cookie collision. This normally should never happen, or the
+probability that it will happen is negligible. However this can also be
+a result of a misconfiguration in that you are trying to make a
+rendezvous connection where both parties try to bind to the same IP
+address, or both are local addresses of the same host. In such a case
+the sent handshake packets are returning to the same host as if they
+were sent by the peer (i.e. a party is sending to itself). When this happens,
+this reject reason will be reported by every attempt.
+
+
+#### SRT_REJ_BADSECRET
+
+Both parties have defined a passphrase for connection, but they differ.
+
+
+#### SRT_REJ_UNSECURE
+
+Only one connection party has set up a password. See also the
+[`SRTO_ENFORCEDENCRYPTION`](API-socket-options.md#SRTO_ENFORCEDENCRYPTION) flag.
+
+
+#### SRT_REJ_MESSAGEAPI
+
+The value of the [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI)
+flag is different on both connection parties.
+
+
+#### SRT_REJ_CONGESTION
+
+The [`SRTO_CONGESTION`](API-socket-options.md#SRTO_CONGESTION)option has
+been set up differently on both connection parties.
+
+
+#### SRT_REJ_FILTER
+
+The [`SRTO_PACKETFILTER`](API-socket-options.md#SRTO_PACKETFILTER) option
+has been set differently on both connection parties.
+
+
+#### SRT_REJ_GROUP
+
+The group type or some group settings are incompatible for both connection parties.
+While every connection within a bonding group may have different target addresses,
+they should all designate the same endpoint and the same SRT application. If this
+condition isn't satisfied, then the peer will respond with a different peer group
+ID for the connection that is trying to contact a machine/application that is
+completely different from the existing connections in the bonding group.
+
+
+#### SRT_REJ_TIMEOUT
+
+The connection wasn't rejected, but it timed out. This code is always set on
+connection timeout, but this is the only way to get this state in non-blocking
+mode (see [`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN)).
+
+There may also be server and user rejection codes, as defined by the
+`SRT_REJC_INTERNAL`, `SRT_REJC_PREDEFINED` and `SRT_REJC_USERDEFINED`
+constants. Note that the number space from the value of `SRT_REJC_PREDEFINED`
+and above is reserved for "predefined codes" (`SRT_REJC_PREDEFINED` value plus
+adopted HTTP codes). Values above `SRT_REJC_USERDEFINED` are freely defined by
+the application.
+
+
+[:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
+
+---
+
+### Error Codes
+
+All functions that return the status via `int` value return -1 (designated as
+`SRT_ERROR`) always when the call has failed (in case of resource creation
+functions an appropriate symbol is defined, like `SRT_INVALID_SOCK` for
+`SRTSOCKET`). When this happens, the error code can be obtained from the
+`srt_getlasterror` function. The values for the error are collected in an
+`SRT_ERRNO` enum:
+
+
+#### SRT_EUNKNOWN
+
+Internal error when setting the right error code.
+
+
+#### SRT_SUCCESS
+
+The value set when the last error was cleared and no error has occurred since then.
+
+
+#### SRT_ECONNSETUP
+
+General setup error resulting from internal system state.
+
+
+#### SRT_ENOSERVER
+
+Connection timed out while attempting to connect to the remote address. Note
+that when this happens, [`srt_getrejectreason`](#srt_getrejectreason) also reports
+the timeout reason.
+
+
+#### SRT_ECONNREJ
+
+Connection has been rejected. Additional reject reason can be obtained through
+[`srt_getrejectreason`](#srt_getrejectreason) (see above).
+
+
+#### SRT_ESOCKFAIL
+
+An error occurred when trying to call a system function on an internally used
+UDP socket. Note that the detailed system error is available in the extra variable
+passed by pointer to `srt_getlasterror`.
+
+
+#### SRT_ESECFAIL
+
+A possible tampering with the handshake packets was detected, or an encryption
+request wasn't properly fulfilled.
+
+
+#### SRT_ESCLOSED
+
+A socket that was vital for an operation called in blocking mode
+has been closed during the operation. Please note that this situation is
+handled differently than the system calls for `connect` and `accept`
+functions for TCP, which simply block indefinitely (or until the standard
+timeout) when the key socket was closed during an operation. When this
+error is reported, it usually means that the socket passed as the first
+parameter to [`srt_connect*`](#srt_connect) or [`srt_accept`](#srt_accept)
+is no longer usable.
+
+
+#### SRT_ECONNFAIL
+
+General connection failure of unknown details.
+
+
+#### SRT_ECONNLOST
+
+The socket was properly connected, but the connection has been broken.
+This specialization is reported from the transmission functions.
+
+
+#### SRT_ENOCONN
+
+The socket is not connected. This can be reported also when the connection was
+broken for a function that checks some characteristic socket data.
+
+
+#### SRT_ERESOURCE
+
+System or standard library error reported unexpectedly for unknown purpose.
+Usually it means some internal error.
+
+
+#### SRT_ETHREAD
+
+System was unable to spawn a new thread when required.
+
+
+#### SRT_ENOBUF
+
+System was unable to allocate memory for buffers.
+
+
+#### SRT_ESYSOBJ
+
+System was unable to allocate system specific objects (such as
+sockets, mutexes or condition variables).
+
+
+#### SRT_EFILE
+
+General filesystem error (for functions operating with file transmission).
+
+
+#### SRT_EINVRDOFF
+
+Failure when trying to read from a given position in the file (file could
+be modified while it was read from).
+
+
+#### SRT_ERDPERM
+
+Read permission was denied when trying to read from file.
+
+
+#### SRT_EINVWROFF
+
+Failed to set position in the written file.
+
+
+#### SRT_EWRPERM
+
+Write permission was denied when trying to write to a file.
+
+
+#### SRT_EINVOP
+
+Invalid operation performed for the current state of a socket. This mainly
+concerns performing `srt_bind*` operations on a socket that is already bound.
+Once a socket has been been bound, it cannot be bound again.
+
+
+#### SRT_EBOUNDSOCK
+
+The socket is currently bound and the required operation cannot be
+performed in this state. Usually it's about an option that can only
+be set on the socket before binding (`srt_bind*`). Note that a socket
+that is currently connected is also considered bound.
+
+
+#### SRT_ECONNSOCK
+
+The socket is currently connected and therefore performing the required operation
+is not possible. Usually concerns setting an option that must be set before
+connecting (although it is allowed to be altered after binding), or when trying
+to start a connecting operation ([`srt_connect*`](#srt_connect)) while the socket
+isn't in a state that allows it (only [`SRTS_INIT`](#SRTS_INIT) or
+[`SRTS_OPENED`](#SRTS_OPENED) are allowed).
+
+
+#### SRT_EINVPARAM
+
+This error is reported in a variety of situations when call parameters
+for API functions have some requirements defined and these were not
+satisfied. This error should be reported after an initial check of the
+parameters of the call before even performing any operation. This error
+can be easily avoided if you set the values correctly.
+
+
+#### SRT_EINVSOCK
+
+The API function required an ID of an entity (socket or group) and
+it was invalid. Note that some API functions work only with socket or
+only with group, so they would also return this error if inappropriate
+type of entity was passed, even if it was valid.
+
+
+#### SRT_EUNBOUNDSOCK
+
+The operation to be performed on a socket requires that it first be explicitly
+bound (using [`srt_bind*`](#srt_bind) functions). Currently it applies when
+calling [`srt_listen`](#srt_listen), which cannot work with an implicitly
+bound socket.
+
+
+#### SRT_ENOLISTEN
+
+The socket passed for the operation is required to be in the listen
+state ([`srt_listen`](#srt_listen) must be called first).
+
+
+#### SRT_ERDVNOSERV
+
+The required operation cannot be performed when the socket is set to rendezvous
+mode ([`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) set to true).
+Usually applies when trying to call [`srt_listen`](#srt_listen) on such a socket.
+
+
+#### SRT_ERDVUNBOUND
+
+An attempt was made to connect to a socket set to rendezvous mode
+([`SRTO_RENDEZVOUS`](API-socket-options.md#SRTO_RENDEZVOUS) set to true)
+that was not first bound. A rendezvous connection requires setting up two addresses
+and ports on both sides of the connection, then setting the local one with
+[`srt_bind`](#srt_bind) and using the remote one with [`srt_connect`](#srt_connect)
+(or you can simply use [`srt_rendezvous`](#srt_rendezvous)). Calling
+[`srt_connect*`](#srt_connect) on an unbound socket (in [`SRTS_INIT`](#SRTS_INIT)
+state) that is to be bound implicitly is only allowed for regular caller sockets
+(not rendezvous).
+
+
+#### SRT_EINVALMSGAPI
+
+The function was used incorrectly in the message API. This can happen if:
+
+* The parameters specific for the message API in [`SRT_MSGCTRL`](#SRT_MSGCTRL)
+type parameter were incorrectly specified.
+
+* The extra parameter check performed by the congestion controller has failed.
+
+* The socket is a member of a self-managing group, therefore you should
+perform the operation on the group, not on this socket.
+
+
+#### SRT_EINVALBUFFERAPI
+
+The function was used incorrectly in the stream (buffer) API, that is, either the
+stream-only functions were used with set message API ([`srt_sendfile`](#srt_sendfile)/[`srt_recvfile`](#srt_recvfile))
+or TSBPD mode was used with buffer API ([`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) set to true)
+or the congestion controller has failed to check call parameters.
+
+
+#### SRT_EDUPLISTEN
+
+The port tried to be bound for listening is already busy. Note that binding to the same port
+is allowed in general (when [`SRTO_REUSEADDR`](API-socket-options.md#SRTO_REUSEADDRS)
+is true on every socket that has bound it), but only one such socket can be a listener.
+
+
+#### SRT_ELARGEMSG
+
+Size exceeded. This is reported in the following situations:
+
+* Trying to receive a message, but the read-ready message is larger than
+the buffer passed to the receiving function.
+
+* Trying to send a message, but the size of this message exceeds the
+size of the preset sender buffer, so it cannot be stored in the sender buffer.
+
+* When getting group data, the array to be filled is too small.
+
+
+#### SRT_EINVPOLLID
+
+The epoll ID passed to an epoll function is invalid.
+
+
+#### SRT_EPOLLEMPTY
+
+The epoll container currently has no subscribed sockets. This is reported by an
+epoll waiting function that would in this case block forever. This problem
+might be reported both in a situation where you have created a new epoll
+container and didn't subscribe any sockets to it, or you did, but these
+sockets have been closed (including when closed in a separate thread while the
+waiting function was blocking). Note that this situation can be prevented
+by setting the `SRT_EPOLL_ENABLE_EMPTY` flag, which may be useful when
+you use multiple threads and start waiting without subscribed sockets, so that
+you can subscribe them later from another thread.
+
+
+#### `SRT_EBINDCONFLICT`
+
+The binding you are attempting to set up a socket with cannot be completed because
+it conflicts with another existing binding. This is because an intersecting binding
+was found that cannot be reused according to the specification in `srt_bind` call.
+
+A binding is considered intersecting if the existing binding has the same port
+and covers at least partially the range as that of the attempted binding. These
+ranges can be split in three groups:
+
+1. An explicitly specified IP address (both IPv4 and IPv6) covers this address only.
+2. An IPv4 wildcard 0.0.0.0 covers all IPv4 addresses (but not IPv6).
+3. An IPv6 wildcard :: covers:
+   * if `SRTO_IPV6ONLY` is true - all IPv6 addresses (but not IPv4)
+   * if `SRTO_IPV6ONLY` is false - all IP addresses.
+
+Example 1:
+
+* Socket 1: bind to IPv4 0.0.0.0
+* Socket 2: bind to IPv6 :: with `SRTO_IPV6ONLY` = true
+* Result: NOT intersecting
+
+Example 2:
+
+* Socket 1: bind to IPv4 1.2.3.4
+* Socket 2: bind to IPv4 0.0.0.0
+* Result: intersecting (and conflicting)
+
+Example 3:
+
+* Socket 1: bind to IPv4 1.2.3.4
+* Socket 2: bind to IPv6 :: with `SRTO_IPV6ONLY` = false
+* Result: intersecting (and conflicting)
+
+If any common range coverage is found between the attempted binding specification
+(in `srt_bind` call) and the found existing binding with the same port number,
+then all of the following conditions must be satisfied between them:
+
+1. The `SRTO_REUSEADDR` must be true (default) in both.
+
+2. The IP address specification (in case of IPv6, also including the value of
+`SRTO_IPV6ONLY` flag) must be exactly identical.
+
+3. The UDP-specific settings must be identical.
+
+If any of these conditions isn't satisfied, the `srt_bind` function results
+in conflict and report this error.
+
+#### SRT_EASYNCFAIL
+
+General asynchronous failure (not in use currently).
+
+
+#### SRT_EASYNCSND
+
+Sending operation is not ready to perform. This error is reported when trying to
+perform a sending operation on a socket that is not ready for sending, but
+[`SRTO_SNDSYN`](API-socket-options.md#SRTO_SNDSYN) was set to false (when
+true, the function would block the call otherwise).
+
+
+#### SRT_EASYNCRCV
+
+Receiving operation is not ready to perform. This error is reported when trying to
+perform a receiving operation or accept a new socket from the listener socket, when
+the socket is not ready for that operation, but [`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN)
+was set to false (when true, the function would block the call otherwise).
+
+
+#### SRT_ETIMEOUT
+
+The operation timed out. This can happen if you have a timeout set by an option
+([`SRTO_RCVTIMEO`](API-socket-options.md#SRTO_RCVTIMEO) or
+[`SRTO_SNDTIMEO`](API-socket-options.md#SRTO_SNDTIMEO)), or passed as an
+extra argument ([`srt_epoll_wait`](#srt_epoll_wait) or [`srt_accept_bond`](#srt_accept_bond))
+and the function call was blocking, but the required timeout time has passed.
+
+
+#### SRT_ECONGEST
+
+**NOTE**: This error is used only in an experimental version that requires
+setting the `SRT_ENABLE_ECN` macro at compile time. Otherwise the situation
+described below results in the usual successful report.
+
+This error should be reported by the sending function when, with
+[`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) and
+[`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP) set to true, some
+packets were dropped at the sender side (see the description of
+[`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP) for details). This
+doesn't concern the data that were passed for sending by the sending function
+(these data are placed at the back of the sender buffer, while the dropped
+packets are at the front). In other words, the operation done by the sending
+function is successful, but the application might want to slow down the sending
+rate to avoid congestion.
+
+
+#### SRT_EPEERERR
+
+This error is reported when a receiver peer is writing to a file that an agent
+is sending. When the peer encounters an error when writing the received data to
+a file, it sends the `UMSG_PEERERROR` message back to the sender, and the sender
+reports this error from the API sending function.
+
+
+[Return to Top of Page](#SRT-API-Functions)
diff --git a/docs/API/API-socket-options.md b/docs/API/API-socket-options.md
new file mode 100644
index 000000000..a06f8556d
--- /dev/null
+++ b/docs/API/API-socket-options.md
@@ -0,0 +1,1727 @@
+# SRT API Socket Options
+
+There is a general method of setting options on a socket in the SRT C API, similar
+to the system `setsockopt/getsockopt` functions.
+
+- [Types Used in Socket Options](#types-used-in-socket-options)
+- [Getting and Setting Options](#getting-and-setting-options)
+- [List of Options](#list-of-options)
+
+## Types Used in Socket Options <a name="sockopt_types"></a>
+
+Possible types of socket options are:
+
+- `int32_t` - a 32-bit integer. On most systems similar to `int`.
+In some cases the value is expressed using an enumeration type
+(see [Enumeration types...](#enumeration_types) section below).
+
+- `int64_t` - a 64-bit integer.
+
+- `bool` - a Boolean type (`<stdbool.h>` for C, or built-in
+for C++). When *setting* an option, passing the value through an `int` type is
+also properly recognized. When *getting* an option, however, the`bool` type
+should be used. It is also possible to pass a variable of `int` type initialized
+with 0 and then comparing the resulting value with 0 (just don't compare
+the result with 1 or `true`).
+
+- `string` - a C string. When *setting* an option, a `const char*` character array pointer
+is expected to be passed in `optval` and the array length in `optlen` **without the terminating NULL character**.
+When *getting*, an array is expected to be passed in `optval` with a
+sufficient size **with an extra space for the terminating NULL character** provided in `optlen`.
+The return value of `optlen` does not count the terminating NULL character.
+
+- `linger` - Linger structure. Used exclusively with `SRTO_LINGER`.
+
+### Enumeration Types Used in Options <a name="enumeration_types"></a>
+
+#### `SRT_TRANSTYPE`
+
+Used by `SRTO_TRANSTYPE` option:
+
+- `SRTT_LIVE`: Live mode.
+- `SRTT_FILE`: File mode.
+
+See [Transmission Types](API.md#transmission-types) for details.
+
+#### `SRT_KM_STATE`
+
+The defined encryption state as performed by the Key Material Exchange, used
+by `SRTO_RCVKMSTATE`, `SRTO_SNDKMSTATE` and `SRTO_KMSTATE` options:
+
+- `SRT_KM_S_UNSECURED` (`0`): no encryption/decryption. If this state is only on
+the receiver, received encrypted packets will be dropped.
+
+- `SRT_KM_S_SECURING`(`1`): pending security (HSv4 only). This is a temporary state
+used only if the connection uses HSv4 and the Key Material Exchange is
+not finished yet. On HSv5 this is not possible because the Key Material
+Exchange for the initial key is done in the handshake.
+
+- `SRT_KM_S_SECURED` (`2`): KM exchange was successful and the data will be sent
+encrypted and will be decrypted by the receiver. This state is only possible on
+both sides in both directions simultaneously. Any unencrypted packet will be dropped by the receiver.
+
+- `SRT_KM_S_NOSECRET` (`3`): If this state is in the sending direction (`SRTO_SNDKMSTATE`),
+then it means that the sending party has set a passphrase, but the peer did not.
+In this case the sending party can receive unencrypted packets from the peer, but
+packets it sends to the peer will be encrypted and the peer will not be able to
+decrypt them. This state is only possible in HSv5.
+
+- `SRT_KM_S_BADSECRET` (`4`): The password is wrong (set differently on each party);
+encrypted payloads won't be decrypted in either direction.
+
+- `SRT_KM_S_BADCRYPTOMODE` (`5`): The crypto mode mode configuration is either not supported
+or mismatches the configuration of the peer.
+
+
+Note that with the default value of `SRTO_ENFORCEDENCRYPTION` option (true),
+the state is equal on both sides in both directions, and it can be only
+`SRT_KM_S_UNSECURED` or `SRT_KM_S_SECURED` (in other cases the connection
+is rejected). Otherwise it may happen that either both sides have different
+passwords and the state is `SRT_KM_S_BADSECRET` in both directions, or only
+one party has set a password, in which case the KM state is as follows:
+
+|                          | `SRTO_RCVKMSTATE`    | `SRTO_SNDKMSTATE`    |
+|--------------------------|----------------------|----------------------|
+| Party with no password:  | `SRT_KM_S_NOSECRET`  | `SRT_KM_S_UNSECURED` |
+| Party with password:     | `SRT_KM_S_UNSECURED` | `SRT_KM_S_NOSECRET`  |
+
+## Getting and Setting Options
+
+Legacy version:
+
+    int srt_getsockopt(SRTSOCKET socket, int level, SRT_SOCKOPT optName, void* optval, int& optlen);
+    int srt_setsockopt(SRTSOCKET socket, int level, SRT_SOCKOPT optName, const void* optval, int optlen);
+
+New version:
+
+    int srt_getsockflag(SRTSOCKET socket, SRT_SOCKOPT optName, void* optval, int& optlen);
+    int srt_setsockflag(SRTSOCKET socket, SRT_SOCKOPT optName, const void* optval, int optlen);
+
+In the legacy version, there's an additional unused `level` parameter. It was
+there in the original UDT API just to mimic the system `setsockopt` function,
+but it's ignored.
+
+Some options require a value of type `bool` while others require type `integer`,
+which is not the same -- they differ in size, and mistaking them may end up
+causing a crash. This must be kept in mind especially in any C wrapper. For
+convenience, the *setting* option function may accept both `int32_t` and `bool`
+types, but this is not so in the case of *getting* an option value.
+
+**UDT project legacy note**: Almost all options from the UDT library are
+derived (there are a few deleted, including some deprecated already in UDT).
+Many new SRT options have been added. All options are available exclusively
+with the `SRTO_` prefix. Old names are provided as alias names in the `udt.h`
+legacy/C++ API file. Note the translation rules:
+
+* `UDT_` prefix from UDT options was changed to the prefix `SRTO_`
+* `UDP_` prefix from UDT options was changed to the prefix `SRTO_UDP_`
+* `SRT_` prefix in older SRT versions was changed to `SRTO_`
+
+The [table below](#list-of-options) provides a complete list of SRT options and
+their characteristics according to the following legend:
+
+1. **Since**: Defines the SRT version when this option was first introduced. If this field
+is empty, it's an option derived from UDT. "Version 0.0.0" is the oldest version
+of SRT ever created and put into use.
+
+2. **Restrict**: Defines restrictions on setting the option. The field is empty if the option
+is not settable (see **Dir** column):
+
+    - `pre-bind`: The option cannot be altered on a socket that is already bound (by calling
+`srt_bind()` or any other function doing this, including automatic binding when trying to
+connect, as well as accepted sockets). In other words, once an SRT socket has transitioned from
+`SRTS_INIT` to `SRTS_OPENED` socket state.
+
+    - `pre`: The option cannot be altered on a socket that is in `SRTS_LISTENING`, `SRTS_CONNECTING`
+or `SRTS_CONNECTED` state. If an option was set on a listener socket, it will be inherited
+by a socket returned by `srt_accept()` (except for `SRTO_STREAMID`).
+
+    - `post`: The option is unrestricted and can be altered at any time, including when the
+socket is connected, as well as on an accepted socket. The setting of this flag on a listening
+socket is usually derived by the accepted socket, but this isn't a rule for all options.
+Note though that there are some unrestricted options that have an important meaning when
+set prior to connecting (different one than for a connected socket).
+
+   **NOTE**: The `pre-bind` characteristic applies exclusively to options that:
+
+   - Change the behavior and functionality of the `srt_bind` call
+   - Concern or set an option on the internally used UDP socket
+   - Concern any kind of resource used by the multiplexer
+
+3. **Type**: The data type of the option (see above).
+
+4. **Units**: Roughly specified unit, if the value defines things like length or time.
+It can also define more precisely what kind of specialization can be used
+when the type is integer:
+
+    - `enum`: the possible values are defined in an enumeration type
+    - `flags`: the integer value is a collection of bit flags
+    - `B/s` - bytes per second.
+
+5. **Default**: The exact default value, if it can be easily specified. A more complicated
+default state of a particular option will be explained in the [description](#option-descriptions)
+(when marked by asterisk). For non-settable options this field is empty.
+
+6. **Range**: If a value of an integer type has a limited range, or only a certain value
+allowed, it will be specified here (otherwise empty). A range value can be
+specified as:
+
+        - `X-... `: specifies only a minimum value
+        - `X-Y,Z `: values between X and Y are allowed, and additionally Z
+
+    - If the value is of `string` type, this field will contain its maximum size
+in square brackets.
+
+    - If the range contains additionally an asterisk, it means that more elaborate
+restrictions on the value apply, as explained in the [description](#option-descriptions).
+
+7. **Dir**: Option direction: W if can be set, R if can be retrieved, RW if both.
+
+8. **Entity**: This describes whether the option can be set on the socket or the group.
+The G and S options may appear together, in which case both possibilities apply.
+The D and I options, mutually exclusive, appear always with G.
+The + marker can only coexist with GS. Possible specifications are:
+
+    - S: This option can be set on a single socket (exclusively, if not GS)
+
+    - G: This option can be set on a group (exclusively, if not GS)
+
+    - D: If set on a group, it will be derived by the member socket
+
+    - I: If set on a group, it will be taken and managed exclusively by the group
+
+    - +: This option is also allowed to be set individually on a group member
+      socket through a configuration object in `SRT_SOCKGROUPCONFIG` prepared by
+      `srt_create_config`. Note that this setting may override the setting derived
+      from the group.
+
+## List of Options
+
+The following table lists SRT API socket options in alphabetical order. Option details are given further below.
+
+| Option Name                                             | Since | Restrict | Type      | Units   | Default           | Range    | Dir |Entity |
+| :------------------------------------------------------ | :---: | :------: | :-------: | :-----: | :---------------: | :------: |:---:|:-----:|
+| [`SRTO_BINDTODEVICE`](#SRTO_BINDTODEVICE)               | 1.4.2 | pre-bind | `string`  |         |                   |          | RW  | GSD+  |
+| [`SRTO_CONGESTION`](#SRTO_CONGESTION)                   | 1.3.0 | pre      | `string`  |         | "live"            | \*       | W   | S     |
+| [`SRTO_CONNTIMEO`](#SRTO_CONNTIMEO)                     | 1.1.2 | pre      | `int32_t` | ms      | 3000              | 0..      | W   | GSD+  |
+| [`SRTO_CRYPTOMODE`](#SRTO_CRYPTOMODE)                   | 1.5.2 | pre      | `int32_t` |     | 0 (Auto)          | [0, 2]   | W   | GSD   |
+| [`SRTO_DRIFTTRACER`](#SRTO_DRIFTTRACER)                 | 1.4.2 | post     | `bool`    |         | true              |          | RW  | GSD   |
+| [`SRTO_ENFORCEDENCRYPTION`](#SRTO_ENFORCEDENCRYPTION)   | 1.3.2 | pre      | `bool`    |         | true              |          | W   | GSD   |
+| [`SRTO_EVENT`](#SRTO_EVENT)                             |       |          | `int32_t` | flags   |                   |          | R   | S     |
+| [`SRTO_FC`](#SRTO_FC)                                   |       | pre      | `int32_t` | pkts    | 25600             | 32..     | RW  | GSD   |
+| [`SRTO_GROUPCONNECT`](#SRTO_GROUPCONNECT)               | 1.5.0 | pre      | `int32_t` |         | 0                 | 0...1    | W   | S     |
+| [`SRTO_GROUPMINSTABLETIMEO`](#SRTO_GROUPMINSTABLETIMEO) | 1.5.0 | pre      | `int32_t` | ms      | 60                | 60-...   | W   | GDI+  |
+| [`SRTO_GROUPTYPE`](#SRTO_GROUPTYPE)                     | 1.5.0 |          | `int32_t` | enum    |                   |          | R   | S     |
+| [`SRTO_INPUTBW`](#SRTO_INPUTBW)                         | 1.0.5 | post     | `int64_t` | B/s     | 0                 | 0..      | RW  | GSD   |
+| [`SRTO_IPTOS`](#SRTO_IPTOS)                             | 1.0.5 | pre-bind | `int32_t` |         | (system)          | 0..255   | RW  | GSD   |
+| [`SRTO_IPTTL`](#SRTO_IPTTL)                             | 1.0.5 | pre-bind | `int32_t` | hops    | (system)          | 1..255   | RW  | GSD   |
+| [`SRTO_IPV6ONLY`](#SRTO_IPV6ONLY)                       | 1.4.0 | pre-bind | `int32_t` |         | (system)          | -1..1    | RW  | GSD   |
+| [`SRTO_ISN`](#SRTO_ISN)                                 | 1.3.0 |          | `int32_t` |         |                   |          | R   | S     |
+| [`SRTO_KMPREANNOUNCE`](#SRTO_KMPREANNOUNCE)             | 1.3.2 | pre      | `int32_t` | pkts    | 0: 2<sup>12</sup> | 0.. \*   | RW  | GSD   |
+| [`SRTO_KMREFRESHRATE`](#SRTO_KMREFRESHRATE)             | 1.3.2 | pre      | `int32_t` | pkts    | 0: 2<sup>24</sup> | 0..      | RW  | GSD   |
+| [`SRTO_KMSTATE`](#SRTO_KMSTATE)                         | 1.0.2 |          | `int32_t` | enum    |                   |          | R   | S     |
+| [`SRTO_LATENCY`](#SRTO_LATENCY)                         | 1.0.2 | pre      | `int32_t` | ms      | 120 \*            | 0..      | RW  | GSD   |
+| [`SRTO_LINGER`](#SRTO_LINGER)                           |       | post     | `linger`  | s       | off \*            | 0..      | RW  | GSD   |
+| [`SRTO_LOSSMAXTTL`](#SRTO_LOSSMAXTTL)                   | 1.2.0 | post     | `int32_t` | packets | 0                 | 0..      | RW  | GSD+  |
+| [`SRTO_MAXBW`](#SRTO_MAXBW)                             |       | post     | `int64_t` | B/s     | -1                | -1..     | RW  | GSD   |
+| [`SRTO_MAXREXMITBW`](#SRTO_MAXREXMITBW)                 | 1.5.3 | post     | `int64_t` | B/s     | -1                | -1..     | RW  | GSD   |
+| [`SRTO_MESSAGEAPI`](#SRTO_MESSAGEAPI)                   | 1.3.0 | pre      | `bool`    |         | true              |          | W   | GSD   |
+| [`SRTO_MININPUTBW`](#SRTO_MININPUTBW)                   | 1.4.3 | post     | `int64_t` | B/s     | 0                 | 0..      | RW  | GSD   |
+| [`SRTO_MINVERSION`](#SRTO_MINVERSION)                   | 1.3.0 | pre      | `int32_t` | version | 0x010000          | \*       | RW  | GSD   |
+| [`SRTO_MSS`](#SRTO_MSS)                                 |       | pre-bind | `int32_t` | bytes   | 1500              | 76..     | RW  | GSD   |
+| [`SRTO_NAKREPORT`](#SRTO_NAKREPORT)                     | 1.1.0 | pre      | `bool`    |         |  \*               |          | RW  | GSD+  |
+| [`SRTO_OHEADBW`](#SRTO_OHEADBW)                         | 1.0.5 | post     | `int32_t` | %       | 25                | 5..100   | RW  | GSD   |
+| [`SRTO_PACKETFILTER`](#SRTO_PACKETFILTER)               | 1.4.0 | pre      | `string`  |         | ""                | [512]    | RW  | GSD   |
+| [`SRTO_PASSPHRASE`](#SRTO_PASSPHRASE)                   | 0.0.0 | pre      | `string`  |         | ""                | [10..80] | W   | GSD   |
+| [`SRTO_PAYLOADSIZE`](#SRTO_PAYLOADSIZE)                 | 1.3.0 | pre      | `int32_t` | bytes   | \*                | 0.. \*   | W   | GSD   |
+| [`SRTO_PBKEYLEN`](#SRTO_PBKEYLEN)                       | 0.0.0 | pre      | `int32_t` | bytes   | 0                 | \*       | RW  | GSD   |
+| [`SRTO_PEERIDLETIMEO`](#SRTO_PEERIDLETIMEO)             | 1.3.3 | pre      | `int32_t` | ms      | 5000              | 0..      | RW  | GSD+  |
+| [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY)                 | 1.3.0 | pre      | `int32_t` | ms      | 0                 | 0..      | RW  | GSD   |
+| [`SRTO_PEERVERSION`](#SRTO_PEERVERSION)                 | 1.1.0 |          | `int32_t` | *       |                   |          | R   | GS    |
+| [`SRTO_RCVBUF`](#SRTO_RCVBUF)                           |       | pre-bind | `int32_t` | bytes   | 8192 payloads     | \*       | RW  | GSD+  |
+| [`SRTO_RCVDATA`](#SRTO_RCVDATA)                         |       |          | `int32_t` | pkts    |                   |          | R   | S     |
+| [`SRTO_RCVKMSTATE`](#SRTO_RCVKMSTATE)                   | 1.2.0 |          | `int32_t` | enum    |                   |          | R   | S     |
+| [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY)                   | 1.3.0 | pre      | `int32_t` | msec    | \*                | 0..      | RW  | GSD   |
+| [`SRTO_RCVSYN`](#SRTO_RCVSYN)                           |       | post     | `bool`    |         | true              |          | RW  | GSI   |
+| [`SRTO_RCVTIMEO`](#SRTO_RCVTIMEO)                       |       | post     | `int32_t` | ms      | -1                | -1, 0..  | RW  | GSI   |
+| [`SRTO_RENDEZVOUS`](#SRTO_RENDEZVOUS)                   |       | pre      | `bool`    |         | false             |          | RW  | S     |
+| [`SRTO_RETRANSMITALGO`](#SRTO_RETRANSMITALGO)           | 1.4.2 | pre      | `int32_t` |         | 1                 | [0, 1]   | RW  | GSD   |
+| [`SRTO_REUSEADDR`](#SRTO_REUSEADDR)                     |       | pre-bind | `bool`    |         | true              |          | RW  | GSD   |
+| [`SRTO_SENDER`](#SRTO_SENDER)                           | 1.0.4 | pre      | `bool`    |         | false             |          | W   | S     |
+| [`SRTO_SNDBUF`](#SRTO_SNDBUF)                           |       | pre-bind | `int32_t` | bytes   | 8192 payloads     | \*       | RW  | GSD+  |
+| [`SRTO_SNDDATA`](#SRTO_SNDDATA)                         |       |          | `int32_t` | pkts    |                   |          | R   | S     |
+| [`SRTO_SNDDROPDELAY`](#SRTO_SNDDROPDELAY)               | 1.3.2 | post     | `int32_t` | ms      | \*                | -1..     | W   | GSD+  |
+| [`SRTO_SNDKMSTATE`](#SRTO_SNDKMSTATE)                   | 1.2.0 |          | `int32_t` | enum    |                   |          | R   | S     |
+| [`SRTO_SNDSYN`](#SRTO_SNDSYN)                           |       | post     | `bool`    |         | true              |          | RW  | GSI   |
+| [`SRTO_SNDTIMEO`](#SRTO_SNDTIMEO)                       |       | post     | `int32_t` | ms      | -1                | -1..     | RW  | GSI   |
+| [`SRTO_STATE`](#SRTO_STATE)                             |       |          | `int32_t` | enum    |                   |          | R   | S     |
+| [`SRTO_STREAMID`](#SRTO_STREAMID)                       | 1.3.0 | pre      | `string`  |         | ""                | [512]    | RW  | GSD   |
+| [`SRTO_TLPKTDROP`](#SRTO_TLPKTDROP)                     | 1.0.6 | pre      | `bool`    |         | \*                |          | RW  | GSD   |
+| [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)                     | 1.3.0 | pre      | `int32_t` | enum    |`SRTT_LIVE`        | \*       | W   | S     |
+| [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)                     | 0.0.0 | pre      | `bool`    |         | \*                |          | W   | S     |
+| [`SRTO_UDP_RCVBUF`](#SRTO_UDP_RCVBUF)                   |       | pre-bind | `int32_t` | bytes   | 8192 payloads     | \*       | RW  | GSD+  |
+| [`SRTO_UDP_SNDBUF`](#SRTO_UDP_SNDBUF)                   |       | pre-bind | `int32_t` | bytes   | 65536             | \*       | RW  | GSD+  |
+| [`SRTO_VERSION`](#SRTO_VERSION)                         | 1.1.0 |          | `int32_t` |         |                   |          | R   | S     |
+
+### Option Descriptions
+
+#### SRTO_BINDTODEVICE
+
+| OptName               | Since | Restrict | Type     | Units  | Default  | Range  | Dir |Entity|
+| --------------------- | ----- | -------- | -------- | ------ | -------- | ------ |-----|------|
+| `SRTO_BINDTODEVICE`   | 1.4.2 | pre-bind | `string` |        |          |        | RW  | GSD+ |
+
+Refers to the `SO_BINDTODEVICE` system socket option for `SOL_SOCKET` level.
+This effectively limits the packets received by this socket to only those
+that are targeted to that device. The device is specified by name passed as
+string. The setting becomes effective after binding the socket (including
+default-binding when connecting).
+
+NOTE: This option is only available on Linux and available there by default.
+On all other platforms setting this option will always fail.
+
+NOTE: With the default system configuration, this option is only available
+for a process that runs as root. Otherwise the function that applies the setting
+(`srt_bind`, `srt_connect` etc.) will fail.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_CONGESTION
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_CONGESTION` | 1.3.0 | pre      | `string`   |         | "live"    | *      | W   | S      |
+
+The type of congestion controller used for the transmission for that socket.
+
+Its type must be exactly the same on both connecting parties, otherwise the
+connection is rejected - **however** you may also change the value of this
+option for the accepted socket in the listener callback (see `srt_listen_callback`)
+if an appropriate instruction was given in the Stream ID.
+
+Currently supported congestion controllers are designated as "live" and "file",
+which correspond to the Live and File modes.
+
+Note that it is not recommended to change this option manually, but you should
+rather change the whole set of options using the [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE) option.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_CONNTIMEO
+
+| OptName            | Since | Restrict |   Type    | Units  | Default  | Range  | Dir | Entity |
+| ------------------ | ----- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_CONNTIMEO`   | 1.1.2 | pre      | `int32_t` | msec   | 3000     | 0..    | W   | GSD+   |
+
+Connect timeout. This option applies to the caller and rendezvous connection
+modes. For the rendezvous mode (see `SRTO_RENDEZVOUS`) the effective connection timeout
+will be 10 times the value set with `SRTO_CONNTIMEO`.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_CRYPTOMODE
+
+| OptName            | Since     | Restrict |   Type    | Units  | Default  | Range  | Dir | Entity |
+| ------------------ | --------- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_CRYPTOMODE`  | 1.5.2     | pre      | `int32_t` |        | 0 (Auto) | [0, 2] | RW  | GSD   |
+
+The encryption mode to be used if the [`SRTO_PASSPHRASE`](#SRTO_PASSPHRASE) is set.
+
+The feature is a part of the AEAD Preview API of SRT v1.5.2, and is disabled by default.
+To enable use [`ENABLE_AEAD_API_PREVIEW`](../build/build-options.md#enable_aead_api_preview) build option.
+
+Crypto modes:
+
+- `0`: SRT listener accepts any mode from the caller. SRT Caller or SRT Rendezvous effectively negotiate AES-CTR (1).
+- `1`: regular AES-CTR (without message integrity authentication).
+- `2`: AES-GCM mode with message integrity authentication (AEAD).
+
+The AES-GCM mode (2) is only allowed if TSBPD is enabled ([`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)).
+Auto (0) is equivalent to AES-CTR (1) in Rendezvous and for a Caller.
+
+Once a connection is established, reading `SRTO_CRYPTOMODE` shows the negotiated crypto mode:
+AES-CTR (1) or AES-GCM (2).
+
+When [Listener callback](./API-functions.md##srt_listen_callback) is used, the value of
+`SRTO_CRYPTOMODE` read on the new SRT socket to be accepted is not yet the
+negotiated one. It is the value to be negotiated, and is inherited from the listener SRT socket.
+If a specific behavior for each individual connection request is desired based on
+[the user ID or anything else](../features/access-control.md),
+the intended behavior can be achieved by setting the `SRTO_CRYPTOMODE` on the new SRT socket to a specific value.
+
+For example, let's say the initial value set on the listener socket is Auto (0). The listener callback is called,
+signalling the new connection request. The user ID is extracted, and the server wants to force AES-GCM only
+for the connection from this specific user. In this case AES-GCM (2) can be set on the new socket.
+
+There is no way to check the crypto mode being requested by the SRT caller at this point.
+
+| Caller      | Listener    | Negotiated  | | Rdv In-tor  | Rdv Res-der | Negotiated  |
+| ----------- | ----------- | ----------- |-| ----------- | ----------- | ----------- |
+| 0 (auto)    | 0 (auto)    | AES-CTR (1) | | 0 (auto)    | 0 (auto)    | AES-CTR (1) |
+| 0 (auto)    | AES-CTR (1) | AES-CTR (1) | | 0 (auto)    | AES-CTR (1) | AES-CTR (1) |
+| 0 (auto)    | AES-GCM (2) | reject      | | 0 (auto)    | AES-GCM (2) | reject      |
+| AES-CTR (1) | 0 (auto)    | AES-CTR (1) | | AES-CTR (1) | 0 (auto)    | AES-CTR (1) |
+| AES-CTR (1) | AES-CTR (1) | AES-CTR (1) | | AES-CTR (1) | AES-CTR (1) | AES-CTR (1) |
+| AES-CTR (1) | AES-GCM (2) | reject      | | AES-CTR (1) | AES-GCM (2) | reject      |
+| AES-GCM (2) | 0 (auto)    | AES-GCM (2) | | AES-GCM (2) | 0 (auto)    | reject      |
+| AES-GCM (2) | AES-CTR (1) | reject      | | AES-GCM (2) | AES-CTR (1) | reject      |
+| AES-GCM (2) | AES-GCM (2) | AES-GCM (2) | | AES-GCM (2) | AES-GCM (2) | AES-GCM (2) |
+
+* Rdv - Rendezvous; In-tor - initiator; Res-der - responder.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_DRIFTTRACER
+
+| OptName           | Since | Restrict | Type      | Units  | Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_DRIFTTRACER`| 1.4.2 | post    | `bool`    |        | true     |        | RW  | GSD    |
+
+Enables or disables time drift tracer (receiver).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_ENFORCEDENCRYPTION
+
+| OptName                    | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_ENFORCEDENCRYPTION`  | 1.3.2 | pre      | `bool`     |         | true      |        | W   | GSD    |
+
+This option enforces that both connection parties have the same passphrase
+set, or both do not set the passphrase, otherwise the connection is rejected.
+
+When this option is set to FALSE **on both connection parties**, the
+connection is allowed even if the passphrase differs on both parties,
+or it was set only on one party. Note that the party that has set a passphrase
+is still allowed to send data over the network. However, the receiver will not
+be able to decrypt that data and will not deliver it to the application. The
+party that has set no passphrase can send (unencrypted) data that will be
+successfully received by its peer.
+
+This option can be used in some specific situations when the user knows
+both parties of the connection, so there's no possible situation of a rogue
+sender and can be useful in situations where it is important to know whether a
+connection is possible. The inability to decrypt an incoming transmission can
+be then reported as a different kind of problem.
+
+**IMPORTANT**: There is unusual and unobvious behavior when this flag is TRUE
+on the caller and FALSE on the listener, and the passphrase was mismatched. On
+the listener side the connection will be established and broken right after,
+resulting in a short-lived "spurious" connection report on the listener socket.
+This way, a socket will be available for retrieval from an `srt_accept` call
+for a very short time, after which it will be removed from the listener backlog
+just as if no connection attempt was made at all. If the application is fast
+enough to react on an incoming connection, it will retrieve it, only to learn
+that it is already broken. This also makes possible a scenario where
+`SRT_EPOLL_IN` is reported on a listener socket, but then an `srt_accept` call
+reports an `SRT_EASYNCRCV` error. How fast the connection gets broken depends
+on the network parameters -- in particular, whether the `UMSG_SHUTDOWN` message
+sent by the caller is delivered (which takes one RTT in this case) or missed
+during the interval from its creation up to the connection timeout (default = 5
+seconds). It is therefore strongly recommended that you only set this flag to
+FALSE on the listener when you are able to ensure that it is also set to FALSE
+on the caller side.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_EVENT
+
+| OptName           | Since | Restrict | Type      | Units  | Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_EVENT`      |       |          | `int32_t` | flags  |          |        | R   | S      |
+
+Returns bit flags set according to the current active events on the socket.
+
+Possible values are those defined in `SRT_EPOLL_OPT` enum (a combination of
+`SRT_EPOLL_IN`, `SRT_EPOLL_OUT` and `SRT_EPOLL_ERR`).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_FC
+
+| OptName           | Since | Restrict | Type      | Units  | Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_FC`         |       | pre      | `int32_t` | pkts   | 25600    | 32..   | RW  | GSD    |
+
+Flow Control limits the maximum number of packets "in flight" - payload (data) packets that were sent
+but reception is not yet acknowledged with an ACK control packet.
+It also includes data packets already received, but that can't be acknowledged due to loss of preceding data packet(s).
+In other words, if a data packet with sequence number `A` was lost, then acknowledgement of the following `SRTO_FC` packets
+is blocked until packet `A` is either successfully retransmitted or dropped by the
+[Too-Late Packet Drop mechanism](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00#section-4.6).
+Thus the sender will have  `SRTO_FC` packets in flight, and will not be allowed to send further data packets.
+Therefore, when establishing the value of `SRTO_FC`, it is recommend taking into consideration possible delays due to packet loss and retransmission.
+
+There is a restriction that the receiver buffer size ([SRTO_RCVBUF](#SRTO_RCVBUF)) must not be greater than `SRTO_FC`
+([#700](https://github.com/Haivision/srt/issues/700)).
+Therefore, it is recommended to set the value of `SRTO_FC` first, and then the value of `SRTO_RCVBUF`.
+
+The default flow control window size is 25600 packets. It is approximately:
+- 270 Mbits of payload in the default live streaming configuration with an SRT payload size of 1316 bytes;
+- 300 Mbits of payload with an SRT payload size of 1456 bytes.
+
+The minimum number of packets in flight should be (assuming max payload size):
+`FCmin = bps / 8 × RTTsec / (MSS - 44)`,
+where
+- `bps` - is the payload bitrate of the stream in bits per second;
+- `RTTsec` - RTT of the network connection in seconds;
+- `MSS` - Maximum segment size (aka MTU), see [SRTO_MSS](#SRTO_MSS);
+- 44 - size of headers (20 bytes IPv4 + 8 bytes of UDP + 16 bytes of SRT packet header).
+
+To avoid blocking the sending of further packets in case of packet loss, the recommended flow control window is
+`FC = bps / 8 × (RTTsec + latency_sec) / (MSS - 44)`,
+where `latency_sec` is the receiver buffering delay ([SRTO_RCVLATENCY](#SRTO_RCVLATENCY)) **in seconds**.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_GROUPCONNECT
+
+| OptName              | Since | Restrict | Type      | Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | --------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_GROUPCONNECT`  | 1.5.0 | pre      | `int32_t` |        | 0        | 0...1  | W   | S      |
+
+When this flag is set to 1 on a listener socket, it allows this socket to
+accept group connections. When set to the default 0, group connections will be
+rejected. Keep in mind that if the `SRTO_GROUPCONNECT` flag is set to 1 (i.e.
+group connections are allowed) `srt_accept` may return a socket **or** a group
+ID. A call to `srt_accept` on a listener socket that has group connections
+allowed must take this into consideration. It's up to the caller of this
+function to make this distinction and to take appropriate action depending on
+the type of entity returned.
+
+When this flag is set to 1 on an accepted socket that is passed to the
+listener callback handler, it means that this socket is created for a group
+connection and it will become a member of a group. Note that in this case
+only the first connection within the group will result in reporting from
+`srt_accept` (further connections are handled in the background), and this
+function will return the group, not this socket ID.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_GROUPMINSTABLETIMEO
+
+| OptName                    | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| -------------------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_GROUPMINSTABLETIMEO` | 1.5.0 | pre      | `int32_t`  | ms     | 60       | 60-... | W   | GDI+   |
+
+The option is used for groups of type `SRT_GTYPE_BACKUP`. It defines the **minimum** value of the stability
+timeout for all active member sockets in a group.
+The actual timeout value is determined in runtime based on the RTT estimate of an individual member socket.
+If there is no response from the peer for the calculated timeout,
+the member is considered unstable, triggering activation of an idle backup member.
+
+The smaller the value is, the earlier a backup member might be activated to prepare transition to that path.
+However, it may also lead to spurious activations of backup paths.
+The higher the value is, the later the backup link would be activated. All unacknowledged payload packets
+have to be retransmitted through the backup path. If they don't reach the receiver in time, they would be dropped.
+Therefore, an appropriate adjustment of the SRT buffering delay
+(`SRTO_PEERLATENCY` on sender, `SRTO_RCVLATENCY` on receiver) should also be considered.
+
+Normally the receiver should send an ACK back to the sender every 10 ms. In the case of congestion,
+in the live streaming configuration of SRT a loss report is expected to be sent every RTT/2.
+The network jitter and increase of RTT on the public internet causes
+these intervals to be stretched.
+The default minimum value of 60 ms is selected as a general fit for most of the use cases.
+
+Please refer to the [SRT Connection Bonding: Main/Backup](../features/bonding-main-backup.md) document for more details.
+
+Note that the value of this option is not allowed to exceed the value of
+`SRTO_PEERIDLETIMEO`, which determines the timeout to actually break an idle (irresponsive) connection.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_GROUPTYPE
+
+| OptName              | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_GROUPTYPE`     | 1.5.0 |          | `int32_t`  | enum   |          |        | R   | S      |
+
+This option is read-only and it is intended to be called inside the listener
+callback handler (see `srt_listen_callback`). Possible values are defined in
+the `SRT_GROUP_TYPE` enumeration type.
+
+This option returns the group type that is declared in the incoming connection.
+If the incoming connection is not going to make a group-member connection, then
+the value returned is `SRT_GTYPE_UNDEFINED`. If this option is read in any other
+context than inside the listener callback handler, the value is undefined.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_INPUTBW
+
+| OptName          | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ---------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_INPUTBW`   | 1.0.5 | post     | `int64_t`  | B/s    | 0        | 0..    | RW  | GSD    |
+
+This option is effective only if [`SRTO_MAXBW`](#SRTO_MAXBW) is set to 0 (relative). It
+controls the maximum bandwidth together with [`SRTO_OHEADBW`](#SRTO_OHEADBW) option according
+to the formula: `MAXBW = INPUTBW * (100 + OHEADBW) / 100`. When this option
+is set to 0 (automatic) then the real INPUTBW value will be estimated from
+the rate of the input (cases when the application calls the `srt_send*`
+function) during transmission. The minimum allowed estimate value is restricted
+by [`SRTO_MININPUTBW`](#SRTO_MININPUTBW), meaning `INPUTBW = MAX(INPUTBW_ESTIMATE; MININPUTBW)`.
+
+*Recommended: set this option to the anticipated bitrate of your live stream
+and keep the default 25% value for `SRTO_OHEADBW`*.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MININPUTBW
+
+| OptName           | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_MININPUTBW` | 1.4.3 | post     | `int64_t`  | B/s    | 0        | 0..    | RW  | GSD    |
+
+This option is effective only if both `SRTO_MAXBW` and `SRTO_INPUTBW` are set to 0.
+It controls the minimum allowed value of the input bitrate estimate.
+
+See [`SRTO_INPUTBW`](#SRTO_INPUTBW).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_IPTOS
+
+| OptName          | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ---------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_IPTOS`     | 1.0.5 | pre-bind | `int32_t`  |        | (system) | 0..255 | RW  | GSD    |
+
+IPv4 Type of Service (see `IP_TOS` option for IP) or IPv6 Traffic Class (see `IPV6_TCLASS`
+of IPv6) depending on socket address family. Applies to sender only.
+
+When *getting*, the returned value is the user preset for non-connected sockets
+and the actual value for connected sockets.
+
+*Sender*: user configurable, default: `0xB8`.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_IPTTL
+
+| OptName          | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ---------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_IPTTL`     | 1.0.5 | pre-bind | `int32_t`  | hops   | (system) | 1..255 | RW  | GSD    |
+
+IPv4 Time To Live (see `IP_TTL` option for IP) or IPv6 unicast hops (see
+`IPV6_UNICAST_HOPS` for IPv6) depending on socket address family. Applies to sender only.
+
+When *getting*, the returned value is the user preset for non-connected sockets
+and the actual value for connected sockets.
+
+*Sender*: user configurable, default: 64
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_IPV6ONLY
+
+| OptName          | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ---------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_IPV6ONLY`  | 1.4.0 | pre-bind | `int32_t`  |        | (system) | -1..1  | RW  | GSD    |
+
+Set system socket option level `IPPROTO_IPV6` named `IPV6_V6ONLY`. This is meaningful
+only when the socket is going to be bound to the IPv6 wildcard address `in6addr_any`
+(known also as `::`). If you bind to a wildcard address, you have the following
+possibilities:
+
+* IPv4 only: bind to an IPv4 wildcard address
+* IPv6 only: bind to an IPv6 wildcard address and set this option to 1
+* IPv4 and IPv6: bind to an IPv6 wildcard address and set this option to 0
+
+This option's default value is -1 because it is not possible to determine the default
+value on the current platform, and if you bind to an IPv6 wildcard address, this value
+is required prior to binding. When you bind implicitly by calling `srt_connect` on the
+socket, this isn't a problem -- binding will be done using the system-default value and then
+extracted afterwards. But if you want to bind explicitly using `srt_bind`, this
+option must be set explicitly to 0 or 1 because this information is vital for
+determining any potential bind conflicts with other sockets.
+
+Possible values are:
+
+* -1: (default) use system-default value (can be used when not binding to IPv6 wildcard `::`)
+* 0: The binding to `in6addr_any` will bind to both IPv6 and IPv4 wildcard address
+* 1: The binding to `in6addr_any` will bind only to IPv6 and not IPv4 wildcard address
+
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_ISN
+
+| OptName          | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| ---------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_ISN`       | 1.3.0 |          | `int32_t`  |        |          |        | R   | S      |
+
+The value of the ISN (Initial Sequence Number), which is the first sequence
+number put on the first UDP packets sent that are carrying an SRT data payload.
+
+*This value is useful for developers of some more complicated methods of flow
+control, possibly with multiple SRT sockets at a time. It is not intended to be
+used in any regular development.*
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_KMPREANNOUNCE
+
+| OptName               | Since | Restrict | Type       | Units  | Default           | Range  | Dir | Entity |
+| --------------------- | ----- | -------- | ---------- | ------ | ----------------- | ------ | --- | ------ |
+| `SRTO_KMPREANNOUNCE`  | 1.3.2 | pre      | `int32_t`  | pkts   | 0: 2<sup>12</sup> | 0.. *  | RW  | GSD    |
+
+The interval (defined in packets) between when a new Stream Encrypting Key
+(SEK) is sent and when switchover occurs. This value also applies to the
+subsequent interval between when switchover occurs and when the old SEK is
+decommissioned.
+
+At `SRTO_KMPREANNOUNCE` packets before switchover the new key is sent
+(repeatedly, if necessary, until it is confirmed by the receiver).
+
+At the switchover point (see `SRTO_KMREFRESHRATE`), the sender starts
+encrypting and sending packets using the new key. The old key persists in case
+it is needed to decrypt packets that were in the flight window, or
+retransmitted packets.
+
+The old key is decommissioned at `SRTO_KMPREANNOUNCE` packets after switchover.
+
+**The allowed range** for this value is between 1 and half of the current value of
+`SRTO_KMREFRESHRATE`. The minimum value should never be less than the flight
+window [`SRTO_FC`](#SRTO_FC) (i.e. the number of packets that have already left the sender but have
+not yet arrived at the receiver).
+
+The value of `SRTO_KMPREANNOUNCE must not exceed `(SRTO_KMREFRESHRATE - 1) / 2`.
+
+**Default value:** `0` - corresponds to 4096 packets (2<sup>12</sup> or 0x1000).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_KMREFRESHRATE
+
+| OptName               | Since | Restrict | Type       | Units  | Default          | Range  | Dir | Entity |
+| --------------------- | ----- | -------- | ---------- | ------ | ---------------- | ------ | --- | ------ |
+| `SRTO_KMREFRESHRATE`  | 1.3.2 | pre      | `int32_t`  | pkts   | 0: 2<sup>24</sup>| 0..    | RW  | GSD    |
+
+The number of packets to be transmitted after which the Stream Encryption Key
+(SEK), used to encrypt packets, will be switched to the new one. Note that
+the old and new keys live in parallel for a certain period of time (see
+`SRTO_KMPREANNOUNCE`) before and after the switchover.
+
+Having a preannounce period before switchover ensures the new SEK is installed
+at the receiver before the first packet encrypted with the new SEK is received.
+The old key remains active after switchover in order to decrypt packets that
+might still be in flight, or packets that have to be retransmitted.
+
+**Default value:** `0` - corresponds to 16777216 packets (2<sup>24</sup> or 0x1000000).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_KMSTATE
+
+| OptName               | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| --------------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_KMSTATE`        | 1.0.2 |          | `int32_t`  | enum   |          |        | R   | S      |
+
+Keying Material state. This is a legacy option that is equivalent to
+`SRTO_SNDKMSTATE`, if the socket has set `SRTO_SENDER` to true, and
+`SRTO_RCVKMSTATE` otherwise. This option is then equal to `SRTO_RCVKMSTATE`
+always if your application disregards possible cooperation with a peer older
+than 1.3.0, but then with the default value of `SRTO_ENFORCEDENCRYPTION` the
+value returned by both options is always the same. See [`SRT_KM_STATE`](#srt_km_state)
+for more details.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_LATENCY
+
+| OptName               | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| --------------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_LATENCY`        | 1.0.2 | pre      | `int32_t`  | ms     | 120 *    | 0..    | RW  | GSD    |
+
+This option sets both [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY) and [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY)
+to the same value specified. Note that the default value for `SRTO_RCVLATENCY` is modified by the
+[`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE) option.
+
+Prior to SRT version 1.3.0 `SRTO_LATENCY` was the only option to set the latency.
+However it is effectively equivalent to setting `SRTO_PEERLATENCY` in the sending direction
+(see [`SRTO_SENDER`](#SRTO_SENDER)), and `SRTO_RCVLATENCY` in the receiving direction.
+SRT version 1.3.0 and higher support bidirectional transmission, so that each side can
+be sender and receiver at the same time, and `SRTO_SENDER` became redundant.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_LINGER
+
+| OptName              | Since | Restrict | Type       | Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------ | -------- | ------ | --- | ------ |
+| `SRTO_LINGER`        |       | pre      | `linger`   | s      | off \*   | 0..    | RW  | GSD    |
+
+SRT socket linger time on close (similar to [SO\_LINGER](http://man7.org/linux/man-pages/man7/socket.7.html)).
+The defulat value in [the live streaming configuration](./API.md#transmission-types) is OFF. In this type of workflow there is no point for wait for all the data
+to be delivered after a connection is closed.
+The default value in [the file transfer configuration](./API.md#transmission-types) is 180 s.
+
+
+*SRT recommended value*: off (0).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_LOSSMAXTTL
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_LOSSMAXTTL`    | 1.2.0 | post     | `int32_t`  | packets | 0        | 0..    | RW  | GSD+   |
+
+The value up to which the *Reorder Tolerance* may grow. The *Reorder Tolerance*
+is the number of packets that must follow the experienced "gap" in sequence numbers
+of incoming packets so that the loss report is sent (in the hope that the gap is due
+to packet reordering rather than because of loss). The value of *Reorder Tolerance*
+starts from 0 and is set to a greater value when packet reordering is detected
+This happens when a "belated" packet, with sequence number older than the latest
+received, has been received, but without retransmission flag. When this is detected
+the *Reorder Tolerance* is set to the value of the interval between latest sequence
+and this packet's sequence, but not more than the value set by `SRTO_LOSSMAXTTL`.
+By default this value is set to 0, which means that this mechanism is off.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MAXBW
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_MAXBW`         | 1.0.5 | post     | `int64_t`  | B/s     | -1       | -1..   | RW  | GSD    |
+
+Maximum send bandwidth:
+
+- `-1`: infinite (the limit in Live Mode is 1 Gbps);
+- `0`: relative to input rate (see [`SRTO_INPUTBW`](#SRTO_INPUTBW));
+- `>0`: absolute limit in B/s.
+
+**NOTE**: This option has a default value of -1, regardless of the mode.
+For live streams it is typically recommended to set the value 0 here and rely
+on `SRTO_INPUTBW` and `SRTO_OHEADBW` options. However, if you want to do so,
+you should make sure that your stream has a fairly constant bitrate, or that
+changes are not abrupt, as high bitrate changes may work against the
+measurement. SRT cannot ensure that this is always the case for a live stream,
+therefore the default -1 remains even in live mode.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MAXREXMITBW
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_MAXREXMITBW`   | 1.5.3 | post     | `int64_t`  | B/s     | -1       | -1..   | RW  | GSD    |
+
+Maximum BW limit for retransmissions:
+
+- `-1`: unlimited;
+- `0`: do not allow retransmissions.
+- `>0`: BW usage limit in Bytes/sec for packet retransmissions (including 16 bytes of SRT header).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MESSAGEAPI
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_MESSAGEAPI`    | 1.3.0 | pre      | `bool`     |         | true     |        | W   | GSD    |
+
+When set, this socket uses the Message API[\*], otherwise it uses the
+Stream API. Note that in live mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE) option) only the
+Message API is available. In File mode you can chose to use one of two modes
+(note that the default for this option is changed with `SRTO_TRANSTYPE`
+option):
+
+- **Stream API** (default for file mode): In this mode you may send
+as many data as you wish with one sending instruction, or even use dedicated
+functions that operate directly on a file. The internal facility will take care
+of any speed and congestion control. When receiving, you can also receive as
+many data as desired. The data not extracted will be waiting for the next call.
+There is no boundary between data portions in Stream mode.
+
+- **Message API**: In this mode your single sending instruction passes exactly
+one piece of data that has boundaries (a message). Contrary to Live mode,
+this message may span multiple UDP packets, and the only size limitation
+is that it shall fit as a whole in the sending buffer. The receiver shall use
+as large a buffer as necessary to receive the message, otherwise reassembling
+and delivering the message might not be possible. When the message is not
+complete (not all packets received or there was a packet loss) it will not be
+copied to the application's buffer. Messages that are sent later, but were
+earlier reassembled by the receiver, will be delivered once ready, if the
+`inorder` flag was set to false.
+See [`srt_sendmsg`](API.md#sending-and-receiving).
+
+As a comparison to the standard system protocols, the Stream API does
+transmission similar to TCP, whereas the Message API functions like the
+SCTP protocol.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MINVERSION
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_MINVERSION`    | 1.3.0 | pre      | `int32_t`  | version | 0x010000 | *      | RW  | GSD    |
+
+The minimum SRT version that is required from the peer. A connection to a
+peer that does not satisfy the minimum version requirement will be rejected.
+See [`SRTO_VERSION`](#SRTO_VERSION) for the version format.
+
+The default value is 0x010000 (SRT v1.0.0).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_MSS
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_MSS`           |       | pre-bind | `int32_t`  | bytes   | 1500     | 76..   | RW  | GSD    |
+
+Maximum Segment Size. Used for buffer allocation and rate calculation using
+packet counter assuming fully filled packets. Each party can set its own MSS
+value independently. During a handshake the parties exchange MSS values, and
+the lowest is used.
+
+*Generally on the internet MSS is 1500 by default. This is the maximum
+size of a UDP packet and can be only decreased, unless you have some unusual
+dedicated network settings. MSS is not to be confused with the size of the UDP
+payload or SRT payload - this size is the size of the IP packet, including the
+UDP and SRT headers*
+
+THe value of `SRTO_MSS` must not exceed `SRTO_UDP_SNDBUF` or `SRTO_UDP_RCVBUF`.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_NAKREPORT
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_NAKREPORT`     | 1.1.0 | pre      | `bool`     |         |  *       |        | RW  | GSD+   |
+
+When set to true, every report for a detected loss will be repeated when the
+timeout for the expected retransmission of this loss has expired and the
+missing packet still wasn't recovered, or wasn't conditionally dropped (see
+[`SRTO_TLPKTDROP`](#SRTO_TLPKTDROP)).
+
+The default is true for Live mode, and false for File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_OHEADBW
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_OHEADBW`       | 1.0.5 | post     | `int32_t`  | %       | 25       | 5..100 | RW  | GSD    |
+
+Recovery bandwidth overhead above input rate (see [`SRTO_INPUTBW`](#SRTO_INPUTBW)),
+in percentage of the input rate. It is effective only if `SRTO_MAXBW` is set to 0.
+
+*Sender*: user configurable, default: 25%.
+
+Recommendations:
+
+- Overhead is intended to give you extra bandwidth for the case when a packet
+has taken part of the bandwidth, but then was lost and has to be retransmitted.
+Therefore the effective maximum bandwidth should be appropriately higher than
+your stream's bitrate so that there's some room for retransmission, but still
+limited so that the retransmitted packets don't cause the bandwidth usage to
+skyrocket when larger groups of packets are lost
+
+- Don't configure it too low and avoid 0 in the case when you have the
+`SRTO_INPUTBW` option set to 0 (automatic). Otherwise your stream will choke
+and break quickly at any rise in packet loss.
+
+- ***To do: set-only; get should be supported.***
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PACKETFILTER
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PACKETFILTER`  | 1.4.0 | pre      | `string`   |         |  ""      | [512]  | RW  | GSD    |
+
+Set up the packet filter. The string must match appropriate syntax for packet
+filter setup. Note also that:
+
+* The configuration is case-sentitive (e.g. "FEC,Cols:20" is not valid).
+* Setting this option will fail if you use an unknown filter type.
+
+An empty value for this option means that for this connection the filter isn't
+required, but it will accept any filter settings if provided by the peer. If
+this option is changed by both parties simultaneously, the result will be a
+configuration integrating parameters from both parties, that is:
+
+* parameters provided by both parties are accepted, if they are identical
+* parameters that are set only on one side will have the value defined by that side
+* parameters not set in either side will be set as default
+
+The connection will be rejected with `SRT_REJ_FILTER` code in the following cases:
+
+* both sides define a different packet filter type
+* for the same key two different values were provided by both sides
+* mandatory parameters weren't provided by either side
+
+In case of the built-in `fec` filter, the mandatory parameter is `cols`, all
+others have their default values. For example, the configuration specified
+as `fec,cols:10` is `fec,cols:10,rows:1,arq:onreq,layout:even`. See how to
+configure the FEC filter in [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md#configuring-the-fec-filter).
+
+Below in the table are examples for the built-in `fec` filter. Note that the
+negotiated config need not have parameters in the given order.
+
+Cases when negotiation succeeds:
+
+| Peer A               | Peer B              | Negotiated Config
+|----------------------|---------------------|------------------------------------------------------
+| (no filter)          | (no filter)         |
+| fec,cols:10          | fec                 | fec,cols:10,rows:1,arq:onreq,layout:even
+| fec,cols:10          | fec,cols:10,rows:20 | fec,cols:10,rows:20,arq:onreq,layout:even
+| fec,layout:staircase | fec,cols:10         | fec,cols:10,rows:1,arq:onreq,layout:staircase
+
+In these cases the configuration is rejected with SRT_REJ_FILTER code:
+
+| Peer A                | Peer B              | Error reason
+|-----------------------|---------------------|--------------------------
+| fec                   | (no filter)         | missing `cols` parameter
+| fec,rows:20,arq:never | fec,layout:even     | missing `cols` parameter
+| fec,cols:20           | fec,cols:10         | `cols` parameter value conflict
+| fec,cols:20,rows:20   | fec,cols:20,rows:10 | `rows` parameter value conflict
+
+In general it is recommended that one party defines the full configuration,
+while the other keeps this value empty.
+
+Reading this option after the connection is established will return the full
+configuration that has been agreed upon by both parties (including default
+values).
+
+For details, see [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PASSPHRASE
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PASSPHRASE`    | 0.0.0 | pre      | `string`   |         | ""       |[10..80]| W   | GSD    |
+
+Sets the passphrase for encryption. This enables encryption on this party (or
+disables it, if an empty passphrase is passed). The password must be minimum
+10 and maximum 79 characters long.
+
+The passphrase is the shared secret between the sender and the receiver. It is
+used to generate the Key Encrypting Key using [PBKDF2](http://en.wikipedia.org/wiki/PBKDF2)
+(Password-Based Key Derivation Function 2).
+
+When a socket with configured passphrase is being connected, the peer must
+have the same password set, or the connection is rejected. This behavior can be
+changed by [`SRTO_ENFORCEDENCRYPTION`](#SRTO_ENFORCEDENCRYPTION).
+
+Note that since the introduction of bidirectional support, there's only one
+initial encryption key to encrypt the stream (new keys after refreshing will be
+updated independently), and there's no distinction between "service party that
+defines the password" and "client party that is required to set matching
+password" - both parties are equivalent, and in order to have a working
+encrypted connection, they have to simply set the same passphrase.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PAYLOADSIZE
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PAYLOADSIZE`   | 1.3.0 | pre      | `int32_t`  | bytes   | \*       | 0.. \* | W   | GSD    |
+
+Sets the maximum declared size of a single call to sending function in Live
+mode. When set to 0, there's no limit for a single sending call.
+
+For Live mode: Default value is 1316, but can be increased up to 1456. Note that
+with the `SRTO_PACKETFILTER` option additional header space is usually required,
+which decreases the maximum possible value for `SRTO_PAYLOADSIZE`.
+
+For File mode: Default value is 0 and it's recommended not to be changed.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PBKEYLEN
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PBKEYLEN`      | 0.0.0 | pre      | `int32_t`  | bytes   | 0        | *      | RW  | GSD    |
+
+Encryption key length.
+
+Possible values:
+
+- 0 =`PBKEYLEN` (default value)
+- 16 = AES-128 (effective value)
+- 24 = AES-192
+- 32 = AES-256
+
+The use is slightly different in 1.2.0 (HSv4), and since 1.3.0 (HSv5):
+
+- **HSv4**: This is set on the sender and enables encryption, if not 0. The receiver
+shall not set it and will agree on the length as defined by the sender. Being a
+sender is defined by the `SRTO_SENDER` socket option set to true; otherwise the
+party is a receiver.
+
+- **HSv5**: The "default value" for `PBKEYLEN` is 0, which means that the
+`PBKEYLEN` won't be advertised. The "effective value" for `PBKEYLEN` is 16, but
+this applies only when neither party has set the value explicitly (i.e. when
+both are initially at the default value of 0). If any party *has* set an
+explicit value (16, 24, 32) it will be advertised in the handshake. If the other
+party remains at the default 0, it will accept the peer's value. The situation
+where both parties set a value should be treated carefully. Actually there are
+three intended methods of defining it, and all other uses are considered
+undefined behavior:
+
+  - **Unidirectional**: the sender shall set `PBKEYLEN` and the receiver shall
+  not alter the default value 0. The effective `PBKEYLEN` will be the one set
+  on the sender. The receiver need not know the sender's `PBKEYLEN`, just the
+  passphrase, `PBKEYLEN` will be correctly passed.
+
+  - **Bidirectional in Caller-Listener arrangement**: it is recommended to use
+  a rule whereby you will be setting the `PBKEYLEN` exclusively either on the
+  Listener (the service defines the encryption rules strictly) or on the Caller
+  (the service allows all clients to freely decide about encryption, or the
+  server uses more elaborate rules for encryption).
+
+  - **Bidirectional in Rendezvous mode**: In Rendezvous mode it is assumed that the settings (including `PBKEYLEN`) are known at both ends.
+  as it is with Listener mode, so both parties should set the same passphrase and the same key length,
+  or both should leave the `SRTO_PBKEYLEN` option unchanged (which results in default 16).
+
+  - **Unwanted behavior cases**: if both parties set `PBKEYLEN` and the value
+  on both sides is different, this is considered a conflict. It is resolved by
+  the Initiator party, which takes its own value, if the `SRTO_SENDER`
+  option is set to true. Otherwise, it takes the value from the Responder party. The
+  assignment of Initiator-Responder roles matches the Caller-Listener layout.
+  In the case of Rendezvous this assignment depends on the result of
+  the cookie comparison.  **It is highly recommended to never allow this to
+  happen**, as this may result in having one party's setting of length = 32 be
+  overridden by the other party's setting of length = 16.
+
+| Initiator     |             | Responder     |             | Result  |
+|---------------|-------------|---------------|-------------|---------|
+| SRTO_PBKEYLEN | SRTO_SENDER | SRTO_PBKEYLEN | SRTO_SENDER |         |
+|  0            | any         |  0            | any         | AES-128 |
+|  0            | any         | AES-128       | any         | AES-128 |
+|  0            | any         | AES-192       | any         | AES-192 |
+|  0            | any         | AES-256       | any         | AES-256 |
+| AES-128       | any         |  0            | any         | AES-128 |
+| AES-128       | any         | AES-128       | any         | AES-128 |
+| AES-128       | 0           | AES-192       | any         | AES-192 |
+| AES-128       | 0           | AES-256       | any         | AES-256 |
+| AES-128       | 1           | AES-192       | any         | AES-128 |
+| AES-128       | 1           | AES-256       | any         | AES-128 |
+| AES-192       | any         |  0            | any         | AES-192 |
+| AES-192       | 0           | AES-128       | any         | AES-128 |
+| AES-192       | any         | AES-192       | any         | AES-192 |
+| AES-192       | 0           | AES-256       | any         | AES-256 |
+| AES-192       | 1           | AES-128       | any         | AES-192 |
+| AES-192       | 1           | AES-256       | any         | AES-192 |
+| AES-256       | any         |  0            | any         | AES-256 |
+| AES-256       | 0           | AES-128       | any         | AES-128 |
+| AES-256       | 0           | AES-192       | any         | AES-192 |
+| AES-256       | any         | AES-256       | any         | AES-256 |
+| AES-256       | 1           | AES-128       | any         | AES-256 |
+| AES-256       | 1           | AES-192       | any         | AES-256 |
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PEERIDLETIMEO
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PEERIDLETIMEO` | 1.3.3 | pre      | `int32_t`  | ms      | 5000     | 0..    | RW  | GSD+   |
+
+The maximum time in `[ms]` to wait until another packet is received from a peer
+since the last such packet reception. If this time is passed, the connection is
+considered broken on timeout.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PEERLATENCY
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PEERLATENCY`   | 1.3.0 | pre      | `int32_t`  | ms      | 0        | 0..    | RW  | GSD    |
+
+The latency value (as described in [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY)) provided by the sender
+side as a minimum value for the receiver.
+
+This value is only significant when [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE) is enabled.
+
+Reading the value of the option on an unconnected socket reports the configured value.
+Reading the value on a connected socket reports the effective receiver buffering latency of the peer.
+
+**The `SRTO_PEERLATENCY` option in versions prior to 1.3.0 is only available as**
+[`SRTO_LATENCY`](#SRTO_LATENCY).
+
+See also [`SRTO_LATENCY`](#SRTO_LATENCY).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_PEERVERSION
+
+| OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
+| `SRTO_PEERVERSION`   | 1.1.0 |          | `int32_t`  | *       |          |        | R   | GS     |
+
+SRT version used by the peer. The value 0 is returned if not connected, SRT
+handshake not yet performed (HSv4 only), or if peer is not SRT.
+See [`SRTO_VERSION`](#SRTO_VERSION) for the version format.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVBUF
+
+| OptName              | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVBUF`        |       | pre-bind | `int32_t`  | bytes   | 8192 bufs  | *      | RW  | GSD+   |
+
+Receive Buffer Size, in bytes. Note, however, that the internal setting of this
+value is in the number of buffers, each one of size equal to SRT payload size,
+which is the value of `SRTO_MSS` decreased by UDP and SRT header sizes (28 and 16).
+The value set here will be effectively aligned to the multiple of payload size.
+
+- **Minimum value**: 32 buffers (46592 with default value of `SRTO_MSS`).
+
+- **Maximum value**: [`SRTO_FC`](#SRTO_FC) number of buffers (receiver buffer must not be greater
+than the Flight Flag size).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVDATA
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVDATA`    |       |          | `int32_t`  | pkts    |            |        | R   | S      |
+
+Size of the available data in the receive buffer.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVKMSTATE
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVKMSTATE` | 1.2.0 |          | `int32_t`  | enum    |            |        | R   | S      |
+
+KM state on the agent side when it's a receiver.
+
+Values defined in enum [`SRT_KM_STATE`](#srt_km_state).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVLATENCY
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVLATENCY` | 1.3.0 | pre      | `int32_t`  | ms      | *          | 0..    | RW  | GSD    |
+
+The latency value in the receiving direction of the socket.
+This value is only significant when [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE) is enabled.
+
+**Default value**: 120 ms in Live mode, 0 in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
+
+The latency value defines the **minimum** receiver buffering delay before delivering an SRT data packet
+from a receiving SRT socket to a receiving application.
+
+The actual value of the receiver buffering delay `Ln` (the negotiated latency) used on a connection
+is determined by the negotiation in the connection establishment (handshake exchange) phase as the maximum of the
+`SRTO_RCVLATENCY` value and the value of [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY) set by the peer.
+
+The general idea for the latency mechanism is to keep the time distance between two consecutive
+received packets the same as the time when these same packets were scheduled for sending by the
+sender application (or per the time explicitly declared when sending - see
+[`srt_sendmsg2`](API-functions.md#srt_sendmsg2) for details). This keeps any packets that have arrived
+earlier than their delivery time in the receiver buffer until their delivery time comes. This should
+compensate for any jitter in the network and provides an extra delay needed for a packet retransmission.
+
+For detailed information on how the latency setting influences the actual packet delivery time and
+how this time is defined, refer to the [latency documentation](../features/latency.md).
+
+Reading the `SRTO_RCVLATENCY` value on a socket after the connection is established provides the actual (negotiated)
+latency value `Ln`.
+
+The receiver's buffer must be large enough to store the `L` segment of the stream,
+i.e. `L × Bitrate` bytes. Refer to [`SRTO_RCVBUF`](#SRTO_RCVBUF).
+
+The sender's buffer must be large enough to store a packet up until it is either delivered (and acknowledged)
+or dropped by the sender due to it becoming too late to be delivered.
+In other words, `D × Bitrate` bytes, where `D` is the sender's drop delay value configured with [`SRTO_SNDDROPDELAY`](#SRTO_SNDDROPDELAY).
+
+Buffering of data packets on the receiving side makes it possible to recover from packet losses using the ARQ
+(Automatic Repeat Request) technique, and to deal with varying RTT times (network jitter) in the network, providing
+a (close to) **constant end-to-end latency of the transmission**.
+
+See also [`SRTO_LATENCY`](#SRTO_LATENCY).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVSYN
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVSYN`     |       | post     | `bool`     |         | true       |        | RW  | GSI    |
+
+When true, sets blocking mode on reading function when it's not ready to
+perform the operation. When false ("non-blocking mode"), the reading function
+will in this case report error `SRT_EASYNCRCV` and return immediately. Details
+depend on the tested entity:
+
+On a connected socket or group this applies to a receiving function
+(`srt_recv` and others) and a situation when there are no data available for
+reading. The readiness state for this operation can be tested by checking the
+`SRT_EPOLL_IN` flag on the aforementioned socket or group.
+
+On a freshly created socket or group that is about to be connected to a peer
+listener this applies to any `srt_connect` call (and derived), which in
+"non-blocking mode" always returns immediately. The connected state for that
+socket or group can be tested by checking the `SRT_EPOLL_OUT` flag. Note
+that a socket that failed to connect doesn't change the `SRTS_CONNECTING`
+state and can be found out only by testing the `SRT_EPOLL_ERR` flag.
+
+On a listener socket this applies to `srt_accept` call. The readiness state
+for this operation can be tested by checking the `SRT_EPOLL_IN` flag on
+this listener socket. This flag is also derived from the listener socket
+by the accepted socket or group, although the meaning of this flag is
+effectively different.
+
+Note that when this flag is set only on a group, it applies to a
+specific receiving operation being done on that group (i.e. it is not
+derived from the socket of which the group is a member).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RCVTIMEO
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RCVTIMEO`   |       | post     | `int32_t`  | ms      | -1         | -1, 0..| RW  | GSI    |
+
+Limits the time up to which the receiving operation will block (see
+[`SRTO_RCVSYN`](#SRTO_RCVSYN) for details), such that when this time is exceeded,
+it will behave as if in "non-blocking mode". The -1 value means no time limit.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RENDEZVOUS
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_RENDEZVOUS` |       | pre      | `bool`     |         | false      |        | RW  | S      |
+
+Use Rendezvous connection mode (both sides must set this and both must use the
+procedure of `srt_bind` and then `srt_connect` (or `srt_rendezvous`) to one another.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_RETRANSMITALGO
+
+| OptName               | Since | Restrict | Type      | Units  | Default | Range  | Dir | Entity |
+| --------------------- | ----- | -------- | --------- | ------ | ------- | ------ | --- | ------ |
+| `SRTO_RETRANSMITALGO` | 1.4.2 | pre      | `int32_t` |        | 1       | [0, 1] | RW  | GSD    |
+
+An SRT sender option to choose between two retransmission algorithms:
+
+- 0 - aggressive retransmission algorithm (default until SRT v1.4.4), and
+- 1 - efficient retransmission algorithm (introduced in SRT v1.4.2; default since SRT v1.4.4).
+
+The aggressive retransmission algorithm causes the SRT sender to schedule a packet for retransmission each time it receives a negative acknowledgement (NAK). On a network characterized by low packet loss levels and link capacity high enough to accommodate extra retransmission overhead, this algorithm increases the chances of recovering from packet loss with a minimum delay, and may better suit end-to-end latency constraints.
+
+The new efficient algorithm optimizes the bandwidth usage by producing fewer retransmissions per lost packet. It takes SRT statistics into account to determine if a retransmitted packet is still in flight and could reach the receiver in time, so that some of the NAK reports are ignored by the sender. This algorithm better fits general use cases, as well as cases where channel bandwidth is limited.
+
+To learn more about the algorithms, read ["Improving SRT Retransmissions — Experiments with Simulated Live Streaming (Part 1)"](https://medium.com/innovation-labs-blog/improving-srt-retransmissions-experiments-with-simulated-live-streaming-part-1-7d192483bba4) article.
+
+NOTE: This option is effective only on the sending side. It influences the decision
+as to whether a particular reported lost packet should be retransmitted at a
+certain time or not.
+
+NOTE: The efficient retransmission algorithm can only be used when a receiver sends
+Periodic NAK reports. See [SRTO_NAKREPORT](#SRTO_NAKREPORT).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_REUSEADDR
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_REUSEADDR`  |       | pre-bind | `bool`     |         | true       |        | RW  | GSD    |
+
+When true, allows the SRT socket to use the binding address used already by
+another SRT socket in the same application. Note that SRT socket uses an
+intermediate object called Multiplexer to access the underlying UDP sockets,
+so multiple SRT sockets may share one UDP socket, and the packets received by this
+UDP socket will be correctly dispatched to the SRT socket to which they are
+currently destined. This has some similarities to the `SO_REUSEADDR` system socket
+option, although it's only used inside SRT.
+
+*TODO: This option weirdly only allows the socket used in **bind()** to use the
+local address that another socket is already using, but not to disallow another
+socket in the same application to use the binding address that the current
+socket is already using. What it actually changes is that when given an address in
+**bind()** is already used by another socket, this option will make the binding
+fail instead of adding the socket to the shared group of that socket that
+already has bound this address - but it will not disallow another socket to reuse
+its address.*
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SENDER
+
+| OptName           | Since | Restrict | Type       |  Units  |   Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | ---------- | ------ | --- | ------ |
+| `SRTO_SENDER`     | 1.0.4 | pre      | `bool`     |         | false      |        | W   | S      |
+
+Set sender side. The side that sets this flag is expected to be a sender. This
+flag is only required when communicating with a receiver that uses SRT version
+less than 1.3.0 (and hence *HSv4* handshake), in which case if not set properly,
+the TSBPD mode (see [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)) or encryption will not
+work. Setting `SRTO_MINVERSION` to 1.3.0 is therefore recommended.
+
+This flag in versions above 1.3.0 also influences the conflict resolution for
+`SRTO_PBKEYLEN` in the case where this flag is forcefully set on both connection
+parties simultaneously.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDBUF
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDBUF`     |       | pre-bind | `int32_t`  | bytes   |8192 bufs  | *      | RW  | GSD+   |
+
+Sender Buffer Size. See [`SRTO_RCVBUF`](#SRTO_RCVBUF) for more information.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDDATA
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDDATA`    |       |          | `int32_t`  | pkts    |           |        | R   | S      |
+
+Size of the unacknowledged data in send buffer.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDDROPDELAY
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDDROPDELAY`  | 1.3.2 | post     | `int32_t`  | ms      | *         | -1..   | W   | GSD+   |
+
+Sets an extra delay before `TLPKTDROP` is triggered on the data sender.
+This delay is added to the default drop delay time interval value. Keep in mind
+that the longer the delay, the more probable it becomes that packets would be
+retransmitted uselessly because they will be dropped by the receiver anyway.
+
+`TLPKTDROP` discards packets reported as lost if it is already too late to send
+them (the receiver would discard them even if received). The delay before the
+`TLPKTDROP` mechanism is triggered consists of the SRT latency (`SRTO_PEERLATENCY`),
+plus `SRTO_SNDDROPDELAY`, plus `2 * interval between sending ACKs` (where the
+default `interval between sending ACKs` is 10 milliseconds).
+The minimum delay is `1000 + 2 * interval between sending ACKs` milliseconds.
+
+**Special value -1**: Do not drop packets on the sender at all (retransmit them
+always when requested).
+
+**Default:** 0 in Live mode, -1 in File mode.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDKMSTATE
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDKMSTATE`    | 1.2.0 |          | `int32_t`  |  enum   |           |        | R   | S      |
+
+Peer KM state on receiver side for `SRTO_KMSTATE`
+
+Values defined in enum [`SRT_KM_STATE`](#srt_km_state).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDSYN
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDSYN`        |       | post     | `bool`     |         | true      |        | RW  | GSI    |
+
+When true, sets blocking mode on writing function when it's not ready to
+perform the operation. When false ("non-blocking mode"), the writing function
+will in this case report error `SRT_EASYNCSND` and return immediately.
+
+On a connected socket or group this applies to a sending function
+(`srt_send` and others) and a situation when there's no free space in
+the sender buffer, caused by inability to send all the scheduled data over
+the network. Readiness for this operation can be tested by checking the
+`SRT_EPOLL_OUT` flag.
+
+On a freshly created socket or group it will have no effect until the socket
+enters a connected state.
+
+On a listener socket it will be derived by the accepted socket or group,
+but will have no effect on the listener socket itself.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_SNDTIMEO
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_SNDTIMEO`      |       | post     | `int32_t`  | ms      | -1        | -1..   | RW  | GSI    |
+
+limit the time up to which the sending operation will block (see
+`SRTO_SNDSYN` for details), so when this time is exceeded, it will behave as
+if in "non-blocking mode". The -1 value means no time limit.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_STATE
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_STATE`         |       |          | `int32_t`  |  enum   |           |        | R   | S      |
+
+Returns the current socket state, same as `srt_getsockstate`.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_STREAMID
+
+| OptName              | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| -------------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_STREAMID`      | 1.3.0 | pre      | `string`   |         | ""        | [512]  | RW  | GSD    |
+
+- A string that can be set on the socket prior to connecting. The listener side
+will be able to retrieve this stream ID from the socket that is returned from
+`srt_accept` (for a connected socket with that stream ID). You usually use SET
+on the socket used for `srt_connect`, and GET on the socket retrieved from
+`srt_accept`. This string can be used completely free-form. However, it's highly
+recommended to follow the [SRT Access Control (Stream ID) Guidlines](../features/access-control.md).
+
+- As this uses internally the `std::string` type, there are additional functions
+for it in the legacy/C++ API (udt.h): `srt::setstreamid` and `srt::getstreamid`.
+
+- This option is not useful for a Rendezvous connection, since one side would
+override the value from the other side resulting in an arbitrary winner. Also
+in this connection both peers are known to one another and both have equivalent
+roles in the connection.
+
+- **IMPORTANT**: This option is not derived by the accepted socket from the listener
+socket, and setting it on a listener socket (see `srt_listen` function) doesn't
+influence anything.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_TLPKTDROP
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_TLPKTDROP`  | 1.0.6 | pre      | `bool`     |         | *         |        | RW  | GSD    |
+
+Too-late Packet Drop. When enabled on receiver, it skips missing packets that
+have not been delivered in time and delivers the subsequent packets to the
+application when their time-to-play has come. It also sends a fake ACK to the
+sender. When enabled on sender and enabled on the receiving peer, sender drops
+the older packets that have no chance to be delivered in time. It is automatically
+enabled in sender if receiver supports it.
+
+**Default:** true in Live mode, false in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE))
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_TRANSTYPE
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_TRANSTYPE`  | 1.3.0 | pre      | `int32_t`  |  enum   |`SRTT_LIVE`| \*     | W   | S      |
+
+Sets the transmission type for the socket, in particular, setting this option
+sets multiple other parameters to their default values as required for a
+particular transmission type. This sets the following options to their defaults
+in particular mode:
+
+* [`SRTO_CONGESTION`](#SRTO_CONGESTION)
+* [`SRTO_MESSAGEAPI`](#SRTO_MESSAGEAPI)
+* [`SRTO_NAKREPORT`](#SRTO_NAKREPORT)
+* [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY), also set as [`SRTO_LATENCY`](#SRTO_LATENCY)
+* [`SRTO_TLPKTDROP`](#SRTO_TLPKTDROP)
+* [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)
+
+
+
+Values defined by enum [`SRT_TRANSTYPE`](#SRT_TRANSTYPE).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_TSBPDMODE
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_TSBPDMODE`  | 0.0.0 | pre      | `bool`     |         | \*        |        | W   | S      |
+
+When true, use Timestamp-based Packet Delivery mode. In this mode the
+packet's time is assigned at the sending time (or allowed to be predefined),
+transmitted in the packet's header, and then restored on the receiver side so that
+the time intervals between consecutive packets are preserved when delivering to
+the application.
+
+**Default:** true in Live mode, false in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_UDP_RCVBUF
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_UDP_RCVBUF` |       | pre-bind | `int32_t`  | bytes   | 8192 bufs | *      | RW  | GSD+   |
+
+UDP Socket Receive Buffer Size. Configured in bytes, maintained in packets
+based on MSS value. Receive buffer must not be greater than FC size.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_UDP_SNDBUF
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_UDP_SNDBUF` |       | pre-bind | `int32_t`  | bytes   | 65536     | *      | RW  | GSD+   |
+
+UDP Socket Send Buffer Size. Configured in bytes, maintained in packets based
+on `SRTO_MSS` value.
+
+[Return to list](#list-of-options)
+
+---
+
+#### SRTO_VERSION
+
+| OptName           | Since | Restrict | Type       |  Units  |  Default  | Range  | Dir | Entity |
+| ----------------- | ----- | -------- | ---------- | ------- | --------- | ------ | --- | ------ |
+| `SRTO_VERSION`    | 1.1.0 |          | `int32_t`  |         |           |        | R   | S      |
+
+Local SRT version. This is the highest local version supported if not
+connected, or the highest version supported by the peer if connected.
+
+The version format in hex is `0x00XXYYZZ` for x.y.z in human readable form.
+For example, version 1.4.2 is encoded as `0x010402`.
+
+[Return to list](#list-of-options)
+
+---
diff --git a/docs/API.md b/docs/API/API.md
similarity index 59%
rename from docs/API.md
rename to docs/API/API.md
index 182ecc41a..3bd303830 100644
--- a/docs/API.md
+++ b/docs/API/API.md
@@ -1,116 +1,94 @@
 # SRT API
 
-The SRT C API (defined in `srt.h` file) is largely based in design on the legacy 
-UDT API, with some important changes. The `udt.h` file contains the legacy UDT API 
-plus some minor optional functions that require the C++ standard library to be used. 
-There are a few optional C++ API functions stored there, as there is no real C++ API 
+The SRT C API (defined in `srt.h` file) is largely based in design on the legacy
+UDT API, with some important changes. The `udt.h` file contains the legacy UDT API
+plus some minor optional functions that require the C++ standard library to be used.
+There are a few optional C++ API functions stored there, as there is no real C++ API
 for SRT. These functions may be useful in certain situations.
 
-There are some example applications so that you can see how the API is being used, 
-including `srt-live-transmit` and `srt-file-transmit`. All SRT related material is contained 
-in `transmitmedia.*` files in the `apps` directory 
-which is used by all applications. See `SrtSource::Read` and `SrtTarget::Write` 
+There are some example applications so that you can see how the API is being used,
+including `srt-live-transmit` and `srt-file-transmit`. All SRT related material is contained
+in `transmitmedia.*` files in the `apps` directory
+which is used by all applications. See `SrtSource::Read` and `SrtTarget::Write`
 as examples of how data are read and written in SRT.
 
-  - [Setup and teardown](#setup-and-teardown)
-  - [Creating and destroying a socket](#creating-and-destroying-a-socket)
-    - [Synopsis](#synopsis)
-    - [Usage](#usage)
-    - [Important Remarks](#important-remarks)
-  - [Binding and connecting](#binding-and-connecting)
-    - [Synopsis](#synopsis)
-    - [SRT Usage - listener (server)](#srt-usage---listener-server)
-    - [SRT Usage - rendezvous](#srt-usage---rendezvous)
-  - [Sending and Receiving](#sending-and-receiving)
-    - [Synopsis](#synopsis)
-    - [Usage](#usage)
-    - [Transmission types available in SRT](#transmission-types-available-in-srt)
-  - [Blocking and Non-blocking Mode](#blocking-and-non-blocking-mode)
-  - [EPoll (Non-blocking Mode Events)](#epoll-non-blocking-mode-events))
-    - [Synopsis](#synopsis)
-    - [SRT Usage](#srt-usage)
-    - [Transmission types](#transmission-types)
-      - [Terminology](#terminology)
-    - [Transmission method: Live](#transmission-method-live)
-    - [Transmission method: Buffer](#transmission-method-buffer)
-    - [Transmission method: Message](#transmission-method-message)
-
-
-**NOTE**: The socket option descriptions originally contained in this document 
-have been moved to [APISocketOptions.md](https://github.com/Haivision/srt/blob/master/docs/APISocketOptions.md) 
-
-
-Setup and teardown
-==================
+- [Setup and Teardown](#setup-and-teardown)
+- [Creating and Destroying a Socket](#creating-and-destroying-a-socket)
+- [Binding and Connecting](#binding-and-connecting)
+- [Sending and Receiving](#sending-and-receiving)
+- [Blocking and Non-blocking Modes](#blocking-and-non-blocking-modes)
+  - [EPoll (Non-blocking Mode Events)](#epoll-non-blocking-mode-events)
+- [Transmission Types](#transmission-types)
+  - [Transmission Method: Live](#transmission-method-live)
+  - [Transmission Method: Buffer](#transmission-method-buffer)
+  - [Transmission Method: Message](#transmission-method-message)
+
+## Setup and Teardown
 
 Before any part of the SRT C API can be used, the user should call the `srt_startup()`
 function. Likewise, before the application exits, the `srt_cleanup()` function
-should be called. Note that one of the things the startup function does is to create 
+should be called. Note that one of the things the startup function does is to create
 a new thread, so choose the point of execution for these functions carefully.
 
-Creating and destroying a socket
-================================
+## Creating and Destroying a Socket
 
-To do anything with SRT, you first have to create an SRT socket. The term "socket" 
-in this case is used because of its logical similarity to system-wide sockets. 
-An SRT socket is not directly related to system sockets, but like a system socket 
+To do anything with SRT, you first have to create an SRT socket. The term "socket"
+in this case is used because of its logical similarity to system-wide sockets.
+An SRT socket is not directly related to system sockets, but like a system socket
 it is used to define a point of communication.
 
-Synopsis
---------
-
-    SRTSOCKET srt_socket(int af, int, int);
-    int srt_close(SRTSOCKET s);
+### Synopsis
 
-The `srt_socket` function is based on the legacy UDT API except
-the first parameter. The other two are ignored.
+```c++
+SRTSOCKET srt_create_socket();
+int srt_close(SRTSOCKET s);
+```
 
 Note that `SRTSOCKET` is just an alias for `int`; this is a legacy naming convention
 from UDT, which is here only for clarity.
 
-Usage
------
+### Usage
 
-    sock = srt_socket(AF_INET, SOCK_DGRAM, 0);
+```c++
+sock = srt_create_socket();
+```
 
 This creates a socket, which can next be configured and then used for communication.
 
-    srt_close(sock);
+```c++
+srt_close(sock);
+```
 
 This closes the socket and frees all its resources. Note that the true life of the
 socket does not end exactly after this function exits - some details are being
-finished in a separate "SRT GC" thread. Still, at least all shared system resources 
+finished in a separate "SRT GC" thread. Still, at least all shared system resources
 (such as listener port) should be released after this function exits.
 
+### Important Remarks
 
-Important Remarks
------------------
-
-1. Please note that the use of SRT with `AF_INET6` has not been fully tested; 
-use at your own risk.
-2. SRT uses the system UDP protocol as an underlying communication layer, and so 
-it uses also UDP sockets. The underlying communication layer is used only 
-instrumentally, and SRT manages UDP sockets as its own system resource as it 
-pleases - so in some cases it may be reasonable for multiple SRT sockets to share 
+1. SRT uses the system UDP protocol as an underlying communication layer, and so
+it uses also UDP sockets. The underlying communication layer is used only
+instrumentally, and SRT manages UDP sockets as its own system resource as it
+pleases - so in some cases it may be reasonable for multiple SRT sockets to share
 one UDP socket, or for one SRT socket to use multiple UDP sockets.
-3. The term "port" used in SRT is occasionally identical to the term "UDP
-port". However SRT offers more flexibility than UDP (or TCP, the more logical 
-similarity) because it manages ports as its own resources. For example, one port 
-may be shared between various services.
 
+2. The term "port" used in SRT is occasionally identical to the term "UDP
+port". However SRT offers more flexibility than UDP (or TCP, the more logical
+similarity) because it manages ports as its own resources. For example, one port
+may be shared between various services.
 
-Binding and connecting
-======================
+## Binding and Connecting
 
-Connections are established using the same philosophy as TCP, using functions 
-with names and signatures similar to the BSD Socket API. What is new here is 
+Connections are established using the same philosophy as TCP, using functions
+with names and signatures similar to the BSD Socket API. What is new here is
 the _rendezvous_ mode.
 
-Synopsis
---------
+### Synopsis
 
-    int srt_bind(SRTSOCKET u, const struct sockaddr* name, int namelen);
-    int srt_bind_peerof(SRTSOCKET u, UDPSOCKET udpsock);
+```c++
+int srt_bind(SRTSOCKET u, const struct sockaddr* name, int namelen);
+int srt_bind_acquire(SRTSOCKET u, UDPSOCKET udpsock);
+```
 
 This function sets up the "sockname" for the socket, that is, the local IP address
 of the network device (use `INADDR_ANY` for using any device) and port. Note that
@@ -118,24 +96,30 @@ this can be done on both listening and connecting sockets; for the latter it wil
 define the outgoing port. If you don't set up the outgoing port by calling this
 function (or use port number 0), a unique port number will be selected automatically.
 
-The `*_peerof` version simply copies the bound address setting from an existing 
-UDP socket.
+The `*_acquire` version simply takes over the given UDP socket and copies the
+bound address setting from it.
 
-    int srt_listen(SRTSOCKET u, int backlog);
+```c++
+int srt_listen(SRTSOCKET u, int backlog);
+```
 
 This sets the backlog (maximum allowed simultaneously pending connections) and
 puts the socket into a listening state -- that is, incoming connections will be
 accepted in the call `srt_accept`.
 
-    SRTSOCKET srt_accept(SRTSOCKET u, struct sockaddr* addr, int* addrlen);
+```c++
+SRTSOCKET srt_accept(SRTSOCKET u, struct sockaddr* addr, int* addrlen);
+```
 
 This function accepts the incoming connection (the peer should do
 `srt_connect`) and returns a socket that is exclusively bound to an opposite
 socket at the peer. The peer's address is returned in the `addr`
 argument.
 
-    int srt_connect(SRTSOCKET u, const struct sockaddr* name, int namelen);
-    int srt_connect_debug(SRTSOCKET u, const struct sockaddr* name, int namelen, int forced_isn);
+```c++
+int srt_connect(SRTSOCKET u, const struct sockaddr* name, int namelen);
+int srt_connect_debug(SRTSOCKET u, const struct sockaddr* name, int namelen, int forced_isn);
+```
 
 This function initiates the connection of a given socket with its peer's counterpart
 (the peer gets the new socket for this connection from `srt_accept`). The
@@ -143,8 +127,10 @@ address for connection is passed in 'name'. The `connect_debug` version allows
 for enforcing the ISN (initial sequence number); this is used only for
 debugging or unusual experiments.
 
-    int srt_rendezvous(SRTSOCKET u, const struct sockaddr* local_name, int local_namelen,
-        const struct sockaddr* remote_name, int remote_namelen);
+```c++
+int srt_rendezvous(SRTSOCKET u, const struct sockaddr* local_name, int local_namelen,
+    const struct sockaddr* remote_name, int remote_namelen);
+```
 
 A convenience function that combines the calls to bind, setting the `SRTO_RENDEZVOUS` flag,
 and connecting to the rendezvous counterpart. For simplest usage, the `local_name` should
@@ -153,52 +139,61 @@ and `remote_name` must use the same port. The peer to which this is going to con
 should call the same function, with appropriate local and remote addresses. A rendezvous
 connection means that both parties connect to one another simultaneously.
 
+**IMPORTANT**: The connection may fail, but the socket that was used for connecting
+is not automatically closed and it's also not in broken state (broken state can be
+only if a socket was first successfully connected and then broken). When using blocking
+mode, the connection failure will result in reporting an error from this function call.
+In non-blocking mode the connection failure is designated by the `SRT_EPOLL_ERR` flag
+set for this socket in the epoll container. After that failure you can read an extra
+information from the socket using `srt_getrejectreason` function, and then you should
+close the socket.
+
+### Listener (Server) Example
+
+```c++
+sockaddr_in sa = { ... }; // set local listening port and possibly interface's IP
+int st = srt_bind(sock, (sockaddr*)&sa, sizeof sa);
+srt_listen(sock, 5);
+while ( !finish ) {
+    int sa_len = sizeof sa;
+    newsocket = srt_accept(sock, (sockaddr*)&sa, &sa_len);
+    HandleNewClient(newsocket, sa);
+}
+```
 
+### Caller (Client) Example
 
-SRT Usage - listener (server)
------------------------------
-
-        sockaddr_in sa = { ... }; // set local listening port and possibly interface's IP
-        int st = srt_bind(sock, (sockaddr*)&sa, sizeof sa);
-        srt_listen(sock, 5);
-        while ( !finish ) {
-           int sa_len = sizeof sa;
-           newsocket = srt_accept(sock, (sockaddr*)&sa, &sa_len);
-           HandleNewClient(newsocket, sa);
-        }
-
-SRT Usage - caller (client)
----------------------------
-
-        sockaddr_in sa = { ... }; // set target IP and port
-
-        int st = srt_connect(sock, (sockaddr*)&sa, sizeof sa);
-        HandleConnection(sock);
+```c++
+sockaddr_in sa = { ... }; // set target IP and port
 
+int st = srt_connect(sock, (sockaddr*)&sa, sizeof sa);
+HandleConnection(sock);
+```
 
-SRT Usage - rendezvous
-----------------------
+### Rendezvous Example
 
-        sockaddr_in lsa = { ... }; // set local listening IP/port
-        sockaddr_in rsa = { ... }; // set remote IP/port
+```c++
+sockaddr_in lsa = { ... }; // set local listening IP/port
+sockaddr_in rsa = { ... }; // set remote IP/port
 
-        srt_setsockopt(m_sock, 0, SRTO_RENDEZVOUS, &yes, sizeof yes);
-        int stb = srt_bind(sock, (sockaddr*)&lsa, sizeof lsa);
-        int stc = srt_connect(sock, (sockaddr*)&rsa, sizeof rsa);
-        HandleConnection(sock);
+srt_setsockopt(m_sock, 0, SRTO_RENDEZVOUS, &yes, sizeof yes);
+int stb = srt_bind(sock, (sockaddr*)&lsa, sizeof lsa);
+int stc = srt_connect(sock, (sockaddr*)&rsa, sizeof rsa);
+HandleConnection(sock);
+```
 
 or simpler
 
-        sockaddr_in lsa = { ... }; // set local listening IP/port
-        sockaddr_in rsa = { ... }; // set remote IP/port
-
-        int stc = srt_rendezvous(sock, (sockaddr*)&lsa, sizeof lsa,
-                                       (sockaddr*)&rsa, sizeof rsa);
-        HandleConnection(sock);
+```c++
+sockaddr_in lsa = { ... }; // set local listening IP/port
+sockaddr_in rsa = { ... }; // set remote IP/port
 
+int stc = srt_rendezvous(sock, (sockaddr*)&lsa, sizeof lsa,
+                                (sockaddr*)&rsa, sizeof rsa);
+HandleConnection(sock);
+```
 
-Sending and Receiving
-=====================
+## Sending and Receiving
 
 The SRT API for sending and receiving is split into three categories: *simple*,
 *rich*, and *for files only*.
@@ -210,103 +205,100 @@ and `write` functions.
 The **rich API** includes the `srt_sendmsg` and `srt_recvmsg` functions. Actually
 `srt_recvmsg` is provided for convenience and backward compatibility, as it is
 identical to `srt_recv`. The `srt_sendmsg` receives more parameters, specifically
-for messages. The `srt_sendmsg2` and `srt_recvmsg2` functions receive the socket, 
-buffer, and the `SRT_MSGCTRL` object, which is an input-output object specifying 
+for messages. The `srt_sendmsg2` and `srt_recvmsg2` functions receive the socket,
+buffer, and the `SRT_MSGCTRL` object, which is an input-output object specifying
 extra data for the operation.
 
 Functions with the `msg2` suffix use the `SRT_MSGCTRL` object, and have the
 following interpretation (except `flags` and `boundary` which are reserved for
 future use and should be 0):
 
-* `srt_sendmsg2`:
-    * `msgttl`: [IN] maximum time (in ms) to wait for successful delivery (-1: indefinitely)
-    * `inorder`: [IN] if false, the later sent message is allowed to be delivered earlier
-    * `srctime`: [IN] timestamp to be used for sending (0 if current time)
-    * `pktseq`: unused
-    * `msgno`: [OUT] message number assigned to the currently sent message
-
-* `srt_recvmsg2`
-    * `msgttl`:  unused
-    * `inorder`: unused
-    * `srctime`: [OUT] timestamp set for this dataset when sending
-    * `pktseq`: [OUT] packet sequence number (first packet from the message, if it spans multiple UDP packets)
-    * `msgno`: [OUT] message number assigned to the currently received message
-
-Please note that the `msgttl` and `inorder` arguments and fields in `SRT_MSGCTRL` 
-are meaningful only when you use the message API in file mode (this will be explained 
-later). In live mode, which is the SRT default, packets are always delivered when 
-the time comes (always in order), where you don't want a packet to be dropped 
+- `srt_sendmsg2`:
+  - `msgttl`: [IN] maximum time (in ms) to wait for successful delivery (-1: indefinitely)
+  - `inorder`: [IN] if false, the later sent message is allowed to be delivered earlier
+  - `srctime`: [IN] timestamp to be used for sending (0 if current time)
+  - `pktseq`: unused
+  - `msgno`: [OUT] message number assigned to the currently sent message
+
+- `srt_recvmsg2`
+  - `msgttl`:  unused
+  - `inorder`: unused
+  - `srctime`: [OUT] timestamp set for this dataset when sending
+  - `pktseq`: [OUT] packet sequence number (first packet from the message, if it spans multiple UDP packets)
+  - `msgno`: [OUT] message number assigned to the currently received message
+
+Please note that the `msgttl` and `inorder` arguments and fields in `SRT_MSGCTRL`
+are meaningful only when you use the message API in file mode (this will be explained
+later). In live mode, which is the SRT default, packets are always delivered when
+the time comes (always in order), where you don't want a packet to be dropped
 before sending (so -1 should be passed here).
 
 The `srctime` parameter is an SRT addition for applications (i.e. gateways)
-forwarding SRT streams. It permits pulling and pushing of the sender's original 
-time stamp, converted to local time and drift adjusted. The `srctime` parameter 
-is the number of usec (since epoch) in local SRT clock time. If the connection 
-is not between SRT peers or if **Timestamp-Based Packet Delivery mode (TSBPDMODE)** 
-is not enabled (see [APISocketOptions.md](https://github.com/Haivision/srt/blob/master/docs/APISocketOptions.md)), 
-the extracted `srctime` will be 0. Passing `srctime = 0` in `sendmsg` is like using 
-the API without `srctime` and the local send time will be used (if TSBPDMODE is 
+forwarding SRT streams. It permits pulling and pushing of the sender's original
+time stamp, converted to local time and drift adjusted. The `srctime` parameter
+is the number of usec (since epoch) in local SRT clock time. If the connection
+is not between SRT peers or if **Timestamp-Based Packet Delivery mode (TSBPDMODE)**
+is not enabled (see [SRT API Socket Options](API-socket-options.md)),
+the extracted `srctime` will be 0. Passing `srctime = 0` in `sendmsg` is like using
+the API without `srctime` and the local send time will be used (if TSBPDMODE is
 enabled and receiver supports it).
 
+### Synopsis
 
-Synopsis
---------
+```c++
+int srt_send(SRTSOCKET s, const char* buf, int len);
+int srt_sendmsg(SRTSOCKET s, const char* buf, int len, int msgttl, bool inorder, uint64_t srctime);
+int srt_sendmsg2(SRTSOCKET s, const char* buf, int len, SRT_MSGCTRL* msgctrl);
 
-    int srt_send(SRTSOCKET s, const char* buf, int len);
-    int srt_sendmsg(SRTSOCKET s, const char* buf, int len, int msgttl, bool inorder, uint64_t srctime);
-    int srt_sendmsg2(SRTSOCKET s, const char* buf, int len, SRT_MSGCTRL* msgctrl);
-
-    int srt_recv(SRTSOCKET s, char* buf, int len);
-    int srt_recvmsg(SRTSOCKET s, char* buf, int len);
-    int srt_recvmsg2(SRTSOCKET s, char* buf, int len, SRT_MSGCTRL* msgctrl);
+int srt_recv(SRTSOCKET s, char* buf, int len);
+int srt_recvmsg(SRTSOCKET s, char* buf, int len);
+int srt_recvmsg2(SRTSOCKET s, char* buf, int len, SRT_MSGCTRL* msgctrl);
+```
 
-Usage
------
+### Usage
 
 Sending a payload:
 
-    nb = srt_sendmsg(u, buf, nb, -1, true);
-
-    nb = srt_send(u, buf, nb);
+```c++
+nb = srt_sendmsg(u, buf, nb, -1, true);
 
-    SRT_MSGCTRL mc = srt_msgctrl_default;
-    nb = srt_sendmsg2(u, buf, nb, &mc);
+nb = srt_send(u, buf, nb);
 
+SRT_MSGCTRL mc = srt_msgctrl_default;
+nb = srt_sendmsg2(u, buf, nb, &mc);
+```
 
 Receiving a payload:
 
-    nb = srt_recvmsg(u, buf, nb);
-    nb = srt_recv(u, buf, nb);
-
-    SRT_MSGCTRL mc = srt_msgctrl_default;
-    nb = srt_recvmsg2(u, buf, nb, &mc);
+```c++
+nb = srt_recvmsg(u, buf, nb);
+nb = srt_recv(u, buf, nb);
 
+SRT_MSGCTRL mc = srt_msgctrl_default;
+nb = srt_recvmsg2(u, buf, nb, &mc);
+```
 
-Transmission types available in SRT
------------------------------------
+### Transmission Types Available in SRT
 
-Mode settings determine how the sender and receiver functions work. The main 
-[socket options](APISocketOptions.md) 
-that control it are:
+Mode settings determine how the sender and receiver functions work. The main
+SRT [socket options](API-socket-options.md) that control it are:
 
-* `SRTO_TRANSTYPE`. Sets several parameters in accordance with the selected
+- `SRTO_TRANSTYPE`. Sets several parameters in accordance with the selected
 mode:
-    * `SRTT_LIVE` (default) the Live mode (for live stream transmissions)
-    * `SRTT_FILE` the File mode (for "no time controlled" fastest data transmission)
-* `SRTO_MESSAGEAPI`
-    * true: (default in Live mode): use Message API
-    * false: (default in File mode): use Buffer API
+  - `SRTT_LIVE` (default) the Live mode (for live stream transmissions)
+  - `SRTT_FILE` the File mode (for "no time controlled" fastest data transmission)
+- `SRTO_MESSAGEAPI`
+  - true: (default in Live mode): use Message API
+  - false: (default in File mode): use Buffer API
 
 See [Transmission types](#transmission-types) below.
 
+## Blocking and Non-blocking Modes
 
-Blocking and Non-blocking Mode
-==============================
-
-SRT functions can also work in blocking and non-blocking mode, for which
+SRT functions can also work in blocking and non-blocking modes, for which
 there are two separate options for sending and receiving: `SRTO_SNDSYN` and
 `SRTO_RCVSYN`. When blocking mode is used, a function will not exit until
-the availability condition is satisfied. In non-blocking mode the function 
+the availability condition is satisfied. In non-blocking mode the function
 always exits immediately, and in case of lack of resource availability, it
 returns an error with an appropriate code. The use of non-blocking mode usually
 requires using some polling mechanism, which in SRT is **EPoll**.
@@ -316,28 +308,25 @@ and receiving. For example, `SNDSYN` defines blocking for `srt_connect` and
 `RCVSYN` defines blocking for `srt_accept`. The `SNDSYN` also makes `srt_close`
 exit only after the sending buffer is completely empty.
 
-
-EPoll (Non-blocking Mode Events)
-================================
+### EPoll (Non-blocking Mode Events)
 
 EPoll is a mechanism to track the events happening on the sockets, both "system
 sockets" (see `SYSSOCKET` type) and SRT Sockets. Note that `SYSSOCKET` is also
 an alias for `int`, used only for clarity.
 
+#### Synopsis
 
-Synopsis
---------
-
-    int srt_epoll_update_usock(int eid, SRTSOCKET u, const int* events = NULL);
-    int srt_epoll_update_ssock(int eid, SYSSOCKET s, const int* events = NULL);
-    int srt_epoll_wait(int eid, SRTSOCKET* readfds, int* rnum, SRTSOCKET* writefds, int* wnum,
-                        int64_t msTimeOut,
-                        SYSSOCKET* lrfds, int* lrnum, SYSSOCKET* lwfds, int* lwnum);
-    int srt_epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
-    int srt_epoll_clear_usocks(int eid);
+```c++
+int srt_epoll_update_usock(int eid, SRTSOCKET u, const int* events = NULL);
+int srt_epoll_update_ssock(int eid, SYSSOCKET s, const int* events = NULL);
+int srt_epoll_wait(int eid, SRTSOCKET* readfds, int* rnum, SRTSOCKET* writefds, int* wnum,
+                    int64_t msTimeOut,
+                    SYSSOCKET* lrfds, int* lrnum, SYSSOCKET* lwfds, int* lwnum);
+int srt_epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
+int srt_epoll_clear_usocks(int eid);
+```
 
-SRT Usage
----------
+#### Usage
 
 SRT socket being a user level concept, the system epoll (or other select)
 cannot be used to handle SRT non-blocking mode events. Instead, SRT provides a
@@ -367,22 +356,24 @@ is raised on any of the subscribed sockets. This function will exit as
 soon as at least one event is detected or a timeout occurs. The timeout is
 specified in `[ms]`, with two special values:
 
- -  0: check and report immediately (don't wait)
- - -1: wait indefinitely (not interruptible, even by a system signal)
+-  0: check and report immediately (don't wait)
+- -1: wait indefinitely (not interruptible, even by a system signal)
 
 There are some differences in the synopsis between these two:
 
-1. `srt_epoll_wait`: Both system and SRT sockets can be subscribed. This
+#### `srt_epoll_wait`
+
+Both system and SRT sockets can be subscribed. This
 function reports events on both socket types according to subscriptions, in
 these arrays:
 
-    - `readfds` and `lrfds`: subscribed for `IN` and `ERR`
-    - `writefds` and `lwfds`: subscribed for `OUT` and `ERR`
+- `readfds` and `lrfds`: subscribed for `IN` and `ERR`
+- `writefds` and `lwfds`: subscribed for `OUT` and `ERR`
 
 where:
 
-    - `readfds` and `writefds` report SRT sockets ("user" socket)
-    - `lrfds` and `lwfds` report system sockets
+- `readfds` and `writefds` report SRT sockets ("user" socket)
+- `lrfds` and `lwfds` report system sockets
 
 **NOTE**: this function provides no straightforward possibility to report
 sockets with an error. If you want to distinguish a report of readiness
@@ -393,8 +384,8 @@ in the array in the direction for which the socket wasn't subscribed. For
 example, when an SRT socket is subscribed for `SRT_EPOLL_OUT | SRT_EPOLL_ERR`,
 its presence in `readfds` means that an error is reported for it.
 This need not be a big problem, because when an error is reported on
-a socket, making it appear as if it were ready for an operation, then when that 
-operation occurs it will simply result in an error. You can use this as an 
+a socket, making it appear as if it were ready for an operation, then when that
+operation occurs it will simply result in an error. You can use this as an
 alternative error check method.
 
 This function also reports an error of type `SRT_ETIMEOUT` when no socket is
@@ -407,13 +398,14 @@ when system sockets are involved, is also 10ms. The return time from a poll
 function can only be quicker when there is an event raised on one of the active
 SRT sockets.
 
+#### `srt_epoll_uwait`
 
-2. `srt_epoll_uwait`: In this function only the SRT sockets can be subscribed
+In this function only the SRT sockets can be subscribed
 (it reports error if you pass an epoll id that is subscribed to system sockets).
 This function waits for the first event on subscribed SRT sockets and reports all
 events collected at that moment in an array with the following structure:
 
-```
+```c++
 typedef struct SRT_EPOLL_EVENT_
 {
     SRTSOCKET fd;
@@ -433,112 +425,112 @@ the epoll container.
 The SRT EPoll system does not supports all features of Linux epoll. For
 example, it only supports level-triggered events for system sockets.
 
+## Transmission Types
 
-Transmission types
-------------------
+**NOTE:** There might be a difference in terminology used in [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) and current documentation.
+Please consult [Data Transmission Modes](https://tools.ietf.org/html/draft-sharabayko-srt-01#section-4.2)
+and [Best Practices and Configuration Tips for Data Transmission via SRT](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-7)
+sections of the Internet Draft additionally. The current section is going to be reworked accordingly.
 
-SRT was originally intended to be used for Live Streaming and therefore its main 
+SRT was originally intended to be used for Live Streaming and therefore its main
 and default transmission type is "live". However, SRT supports the modes that
 the original UDT library supported, that is, *file* and *message* transmission.
 
-There are two general modes: **Live** and **File** transmission. Inside File 
-transmission mode, there are also two possibilities: **Buffer API** and 
-**Message API**. The Live mode uses Message API. However it doesn't exactly match 
-the description of the Message API because it uses a maximum single sending buffer 
+There are two general modes: **Live** and **File** transmission. Inside File
+transmission mode, there are also two possibilities: **Buffer API** and
+**Message API**. The Live mode uses Message API. However it doesn't exactly match
+the description of the Message API because it uses a maximum single sending buffer
 up to the size that fits in one UDP packet.
 
 There are two options to set a particular type:
 
-* `SRTO_TRANSTYPE`: uses the enum value with `SRTT_LIVE` for live mode
-   and `SRTT_FILE` for file mode. This option actually changes several parameters 
-   to their default values for that mode. After this is done, additional parameters, 
+- `SRTO_TRANSTYPE`: uses the enum value with `SRTT_LIVE` for live mode
+   and `SRTT_FILE` for file mode. This option actually changes several parameters
+   to their default values for that mode. After this is done, additional parameters,
    including those that are set here, can be further changed.
-* `SRTO_MESSAGEAPI`: This sets the Message API (true) or Buffer API (false)
+
+- `SRTO_MESSAGEAPI`: This sets the Message API (true) or Buffer API (false)
 
 This makes possible a total of three data transmission methods:
 
-* [Live](#transmission-method-live)
-* [Buffer](#transmission-method-buffer)
-* [Message](#transmission-method-message)
+- [Live](#transmission-method-live)
+- [Buffer](#transmission-method-buffer)
+- [Message](#transmission-method-message)
 
 ### Terminology
 
 The following terms are used in the description of transmission types:
 
 **HANGUP / RESUME**: These terms have different meanings depending on the blocking
-state. They describe how a particular function behaves when performing an operation 
+state. They describe how a particular function behaves when performing an operation
 requires a specific readiness condition to be satisfied.
 
-In blocking mode HANGUP means that the function blocks until a condition is 
-satisfied. RESUME means that the condition is satisfied and the function performs 
+In blocking mode HANGUP means that the function blocks until a condition is
+satisfied. RESUME means that the condition is satisfied and the function performs
 the required operation.
 
-In non-blocking mode the only difference is that HANGUP, instead of blocking, makes 
+In non-blocking mode the only difference is that HANGUP, instead of blocking, makes
 the function exit immediately with an appropriate error code (such as SRT_EASYNC*,
-SRT_ETIMEOUT or SRT_ECONGEST) explaining why the function is not ready to perform 
-the operation. Refer to the error descriptions in [API-funtions.md](API-funtions.md) 
+SRT_ETIMEOUT or SRT_ECONGEST) explaining why the function is not ready to perform
+the operation. Refer to the error descriptions in [API-functions.md](API-functions.md)
 for details.
 
 The following types of operations are involved:
 
 1. Reading data: `srt_recv`, `srt_recvmsg`, `srt_recvmsg2`, `srt_recvfile`.
-
-The function HANGS UP if there are no available data to read, and RESUMES when 
-readable data become available (`SRT_EPOLL_IN` flag set in epoll). Use `SRTO_RCVSYN` 
-to control blocking mode here.
+  The function HANGS UP if there are no available data to read, and RESUMES when
+  readable data become available (`SRT_EPOLL_IN` flag set in epoll). Use `SRTO_RCVSYN`
+  to control blocking mode here.
 
 2. Writing data: `srt_send`, `srt_sendmsg`, `srt_sendmsg2`, `srt_sendfile`.
-
-The function HANGS UP if the sender buffer becomes full and unable to store
-any additional data, and RESUMES if the data scheduled for sending have been
-removed from the sender buffer (after being sent and acknowledged) and there
-is enough free space in the sender buffer to store data (`SRT_EPOLL_OUT` flag
-set in epoll). Use `SRTO_SNDSYN` to control blocking mode here.
+  The function HANGS UP if the sender buffer becomes full and unable to store
+  any additional data, and RESUMES if the data scheduled for sending have been
+  removed from the sender buffer (after being sent and acknowledged) and there
+  is enough free space in the sender buffer to store data (`SRT_EPOLL_OUT` flag
+  set in epoll). Use `SRTO_SNDSYN` to control blocking mode here.
 
 3. Accepting an incoming connection: `srt_accept`
-
-The function HANGS UP if there are no new connections reporting in, and
-RESUMES when a new connection has been processed and a new socket or group
-has been created to handle it. Note that this function requires the listener
-socket to get the connection (the flag `SRTO_RCVSYN` set on
-the listener socket controls the blocking mode for this operation). Note also
-that the blocking mode for a similar `srt_accept_bond` function is controlled
-exclusively by its timeout parameter because it can work with multiple listener
-sockets, potentially with different settings.
+  The function HANGS UP if there are no new connections reporting in, and
+  RESUMES when a new connection has been processed and a new socket or group
+  has been created to handle it. Note that this function requires the listener
+  socket to get the connection (the flag `SRTO_RCVSYN` set on
+  the listener socket controls the blocking mode for this operation). Note also
+  that the blocking mode for a similar `srt_accept_bond` function is controlled
+  exclusively by its timeout parameter because it can work with multiple listener
+  sockets, potentially with different settings.
 
 4. Connecting: `srt_connect` and its derivatives
-
-The function HANGS UP in the beginning, and RESUMES when the socket used for
-connecting is either ready to perform transmission operations or has failed to
-connect. It behaves a little differently in non-blocking mode -- the function 
-should be called only once, and it simply returns a success result as a "HANGUP". 
-Calling it again with the same socket would be an error. Calling it with a group 
-would start a completely new connection. It is only possible to determine whether 
-an operation has finished ("has RESUMED") from epoll flags. The socket, when 
-successfully connected, would have `SRT_EPOLL_OUT` set, that is, becomes ready 
-to send data, and `SRT_EPOLL_ERR` when it failed to connect.
-
-**BLIND / FAST / LATE REXMIT**: BLIND REXMIT is a situation where packets that 
-were sent are still not acknowledged, either in the expected time frame, or when 
-another ACK has come for the same number, but no packets have been reported as 
-lost, or at least not for all still unacknowledged packets. The congestion control 
-class is responsible for the algorithm for taking care of this situation, which is 
+  The function HANGS UP in the beginning, and RESUMES when the socket used for
+  connecting is either ready to perform transmission operations or has failed to
+  connect. It behaves a little differently in non-blocking mode -- the function
+  should be called only once, and it simply returns a success result as a "HANGUP".
+  Calling it again with the same socket would be an error. Calling it with a group
+  would start a completely new connection. It is only possible to determine whether
+  an operation has finished ("has RESUMED") from epoll flags. The socket, when
+  successfully connected, would have `SRT_EPOLL_OUT` set, that is, becomes ready
+  to send data, and `SRT_EPOLL_ERR` when it failed to connect.
+
+**BLIND / FAST / LATE REXMIT**: BLIND REXMIT is a situation where packets that
+were sent are still not acknowledged, either in the expected time frame, or when
+another ACK has come for the same number, but no packets have been reported as
+lost, or at least not for all still unacknowledged packets. The congestion control
+class is responsible for the algorithm for taking care of this situation, which is
 either `FASTREXMIT` or `LATEREXMIT`. This will be explained below.
 
+### Transmission Method: Live
 
-Transmission method: Live
--------------------------
+Setting `SRTO_TRANSTYPE` to `SRTT_LIVE` sets the following [socket options](API-socket-options.md):
 
-Setting `SRTO_TRANSTYPE` to `SRTT_LIVE` sets the following [parameters](APISocketOptions.md):
-
-* `SRTO_TSBPDMODE` = true
-* `SRTO_RCVLATENCY` = 120
-* `SRTO_PEERLATENCY` = 0
-* `SRTO_TLPKTDROP` = true
-* `SRTO_MESSAGEAPI` = true
-* `SRTO_NAKREPORT` = true
-* `SRTO_PAYLOADSIZE` = 1316
-* `SRTO_CONGESTION` = "live"
+- [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) = true
+- [`SRTO_RCVLATENCY`](API-socket-options.md#SRTO_RCVLATENCY) = 120
+- [`SRTO_PEERLATENCY`](API-socket-options.md#SRTO_PEERLATENCY) = 0
+- [`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP) = true
+- [`SRTO_LINGER`](API-socket-options.md#SRTO_LINGER) = 0
+- [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) = true
+- [`SRTO_NAKREPORT`](API-socket-options.md#SRTO_NAKREPORT) = true
+- [`SRTO_RETRANSMITALGO`](API-socket-options.md#SRTO_RETRANSMITALGO) = 1
+- [`SRTO_PAYLOADSIZE`](API-socket-options.md#SRTO_PAYLOADSIZE) = 1316
+- [`SRTO_CONGESTION`](API-socket-options.md#SRTO_CONGESTION) = "live"
 
 In this mode, every call to a sending function is allowed to send only
 so much data, as declared by `SRTO_PAYLOADSIZE`, whose value is still
@@ -553,71 +545,75 @@ the time comes for the packet to "play").
 
 This mode uses the `LiveCC` congestion control class, which puts only a slight
 limitation on the bandwidth, if needed (i.e. by adding extra time if the interval
-between two consecutive packets would otherwise be too short for the defined speed 
-limit). Note that it is not intended to work with "virtually infinite" ingest 
-speeds (such as, for example, reading directly from a file). Therefore the 
-application is not allowed to stream data with maximum speed -- it must take care 
+between two consecutive packets would otherwise be too short for the defined speed
+limit). Note that it is not intended to work with "virtually infinite" ingest
+speeds (such as, for example, reading directly from a file). Therefore the
+application is not allowed to stream data with maximum speed -- it must take care
 that the speed of data being sent is in rhythm with timestamps in the live stream.
 Otherwise the behavior is undefined and might be surprisingly disappointing.
 
 The reading function will always return only a payload that was
 sent, and it will HANGUP until the time to play has come for this
 packet (if TSBPD mode is on) or when it is available without gaps of
-lost packets (if TSBPD mode is off - see [`SRTO_TSBPDMODE`](APISocketOptions.md#SRTO_TSBPDMODE)).
+lost packets (if TSBPD mode is off - see [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE)).
 
 You may wish to tweak some of the parameters below:
 
-* `SRTO_TSBPDMODE`: You can turn off controlled latency if your application uses 
+- `SRTO_TSBPDMODE`: You can turn off controlled latency if your application uses
 its own method of latency control.
 
-* `SRTO_RCVLATENCY`: You can increase the latency time, if this is
+- `SRTO_RCVLATENCY`: You can increase the latency time, if this is
 too short. Setting a shorter latency than the default is strongly
 discouraged, although in some very specific and dedicated networks
 this may still be reasonable. Note that `SRTO_PEERLATENCY` is an option
 for the sending party, which is the minimum possible value for a receiver.
 
-* `SRTO_TLPKTDROP`: When true (default), this will drop the packets
+- `SRTO_TLPKTDROP`: When true (default), this will drop the packets
 that haven't been retransmitted on time, that is, before the next packet
-that is already received becomes ready to play. You can turn this off to always 
+that is already received becomes ready to play. You can turn this off to always
 ensure a clean delivery. However, a lost packet can simply pause a
 delivery for some longer, potentially undefined time, and cause even
 worse tearing for the player. Setting higher latency will help much more in
 the case when TLPKTDROP causes packet drops too often.
 
-* `SRTO_NAKREPORT`: Turns on repeated sending of loss reports, when the lost
+- `SRTO_NAKREPORT`: Turns on repeated sending of loss reports, when the lost
 packet was not recovered quickly enough, which raises suspicions that the
 loss report itself was lost. Without it, the loss report will be always reported
 just once and never repeated again, and then the lost payload packet will
 be probably dropped by the TLPKTDROP mechanism.
 
-* `SRTO_PAYLOADSIZE`: Default value is for MPEG TS. If you are going
-to use SRT to send any different kind of payload, such as, for example, 
+- `SRTO_RETRANSMITALGO`: Given the receiver sends periodic NAK reports,
+the sender can reduce the retransmission overhead by not retransmitting a loss
+more often than once per RTT (value 1).
+
+- `SRTO_PAYLOADSIZE`: Default value is for MPEG TS. If you are going
+to use SRT to send any different kind of payload, such as, for example,
 wrapping a live stream in very small frames, then you can use a bigger
 maximum frame size, though not greater than 1456 bytes.
 
-Parameters from the modified for transmission type list, not mentioned in the 
+Parameters from the modified for transmission type list, not mentioned in the
 list above, are crucial for Live mode and shall not be changed.
 
-The BLIND REXMIT situation is resolved using the FASTREXMIT algorithm by LiveCC: 
-sending non-acknowledged packets blindly on the premise that the receiver lingers 
-too long before acknowledging them. This mechanism isn't used (i.e. the BLIND REXMIT 
-situation isn't handled at all) when `SRTO_NAKREPORT` is set by the peer -- the 
+The BLIND REXMIT situation is resolved using the FASTREXMIT algorithm by LiveCC:
+sending non-acknowledged packets blindly on the premise that the receiver lingers
+too long before acknowledging them. This mechanism isn't used (i.e. the BLIND REXMIT
+situation isn't handled at all) when `SRTO_NAKREPORT` is set by the peer -- the
 NAKREPORT method is considered so effective that FASTREXMIT isn't necessary.
 
+### Transmission Method: Buffer
 
-Transmission method: Buffer
----------------------------
-
-Setting `SRTO_TRANSTYPE` to `SRTT_FILE` sets the following [parameters](APISocketOptions.md):
+Setting `SRTO_TRANSTYPE` to `SRTT_FILE` sets the following [socket options](API-socket-options.md):
 
-* `SRTO_TSBPDMODE` = false
-* `SRTO_RCVLATENCY` = 0
-* `SRTO_PEERLATENCY` = 0
-* `SRTO_TLPKTDROP` = false
-* `SRTO_MESSAGEAPI` = false
-* `SRTO_NAKREPORT` = false
-* `SRTO_PAYLOADSIZE` = 0
-* `SRTO_CONGESTION` = "file"
+- [`SRTO_TSBPDMODE`](API-socket-options.md#SRTO_TSBPDMODE) = false
+- [`SRTO_RCVLATENCY`](API-socket-options.md#SRTO_RCVLATENCY) = 0
+- [`SRTO_PEERLATENCY`](API-socket-options.md#SRTO_PEERLATENCY) = 0
+- [`SRTO_TLPKTDROP`](API-socket-options.md#SRTO_TLPKTDROP) = false
+- [`SRTO_LINGER`](API-socket-options.md#SRTO_LINGER) = 180 s
+- [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) = false
+- [`SRTO_NAKREPORT`](API-socket-options.md#SRTO_NAKREPORT) = false
+- [`SRTO_RETRANSMITALGO`](API-socket-options.md#SRTO_RETRANSMITALGO) = 0
+- [`SRTO_PAYLOADSIZE`](API-socket-options.md#SRTO_PAYLOADSIZE) = 0
+- [`SRTO_CONGESTION`](API-socket-options.md#SRTO_CONGESTION) = "file"
 
 In this mode, calling a sending function is allowed to potentially send
 virtually any size of data. The sending function will HANGUP only if the
@@ -631,16 +627,16 @@ From the receiving function there will be retrieved as many data as the minimum
 of the passed buffer size and available data; data still available and not
 retrieved by this call will be available for retrieval in the next call.
 
-There is also a dedicated pair of functions that can only be used in this mode: 
-`srt_sendfile` and `srt_recvfile`. These functions can be used to transmit the 
+There is also a dedicated pair of functions that can only be used in this mode:
+`srt_sendfile` and `srt_recvfile`. These functions can be used to transmit the
 whole file, or a fragment of it, based on the offset and size.
 
-This mode uses the `FileCC` congestion control class, which is a direct copy of 
+This mode uses the `FileCC` congestion control class, which is a direct copy of
 UDT's `CUDTCC` congestion control class, adjusted to the needs of SRT's
 congestion control framework. This class generally sends the data with maximum
 speed in the beginning, until the flight window is full, and then keeps the
 speed at the edge of the flight window, only slowing down in the case where
-packet loss was detected. The bandwidth usage can be directly limited by the 
+packet loss was detected. The bandwidth usage can be directly limited by the
 `SRTO_MAXBW` option.
 
 The BLIND REXMIT situation is resolved in FileCC using the LATEREXMIT
@@ -649,71 +645,67 @@ loss list is empty and the flight window is full, all packets since the last
 ACK are sent again (that's more or less the TCP behavior, but in contrast to
 TCP, this is done as a very low probability fallback).
 
-Most of the parameters described above have `false` or `0` values as they usually 
-designate features used in Live mode. None are used with File mode. The only option 
-that makes sense to modify after the `SRTT_FILE` type was set is `SRTO_MESSAGEAPI`, 
+Most of the parameters described above have `false` or `0` values as they usually
+designate features used in Live mode. None are used with File mode. The only option
+that makes sense to modify after the `SRTT_FILE` type was set is `SRTO_MESSAGEAPI`,
 which is described below.
 
-
-Transmission method: Message
-----------------------------
+### Transmission Method: Message
 
 Setting `SRTO_TRANSTYPE` to `SRTT_FILE` and then setting `SRTO_MESSAGEAPI` to
 `true` implies usage of the Message transmission method. Parameters are set as
-described above for the Buffer method, with the exception of `SRTO_MESSAGEAPI`. 
+described above for the Buffer method, with the exception of `SRTO_MESSAGEAPI`.
 The "file" congestion controller is also used in this mode. It differs from the
 Buffer method, however, in terms of the rules concerning sending and receiving.
 
 **HISTORICAL INFO**: The library on which SRT was based (UDT) somewhat misleadingly
-used the terms `STREAM` and `DGRAM`, and used the system symbols `SOCK_STREAM` and 
-`SOCK_DGRAM` in the socket creation function. A "datagram" in the UDT terminology 
-has nothing to do with the "datagram" term in networking terminology, where its 
-size is limited to as much it can fit in one MTU. In UDT it is actually a message, 
-which may span multiple UDP packets and has clearly defined boundaries. It's rather 
-similar to the **SCTP** protocol. Also, in UDP the API functions were strictly bound 
+used the terms `STREAM` and `DGRAM`, and used the system symbols `SOCK_STREAM` and
+`SOCK_DGRAM` in the socket creation function. A "datagram" in the UDT terminology
+has nothing to do with the "datagram" term in networking terminology, where its
+size is limited to as much it can fit in one MTU. In UDT it is actually a message,
+which may span multiple UDP packets and has clearly defined boundaries. It's rather
+similar to the **SCTP** protocol. Also, in UDP the API functions were strictly bound
 to `DGRAM` or `STREAM` mode: `UDT::send/UDT::recv` were only for `STREAM` and
-`UDT::sendmsg/UDT::recvmsg` only for `DGRAM`. In SRT this is changed: all functions 
-can be used in all modes, except `srt_sendfile/srt_recvfile`, and how the functions 
+`UDT::sendmsg/UDT::recvmsg` only for `DGRAM`. In SRT this is changed: all functions
+can be used in all modes, except `srt_sendfile/srt_recvfile`, and how the functions
 actually work is controlled by the `SRTO_MESSAGEAPI` flag.
 
-In message mode, every sending function sends **exactly** as much data as it is 
-passed in a single sending function call. The receiver also receives not less than 
-**exactly** the number of bytes that was sent (although every message may have a 
+In message mode, every sending function sends **exactly** as much data as it is
+passed in a single sending function call. The receiver also receives not less than
+**exactly** the number of bytes that was sent (although every message may have a
 different size). Every message may also have extra parameters:
 
-  - **TTL** defines how much time (in ms) the message should wait in the sending 
-  buffer for the opportunity to be picked up by the sender thread and sent over 
-  the network; otherwise it is dropped. Note that this TTL only applies to packets that 
-  have been lost and should be retransmitted.
-
-  - **INORDER**, when true, means the messages must be read by the receiver in 
-  exactly the same order in which they were sent. In the situation where a message 
-  suffers a packet loss, this prevents any subsequent messages from achieving 
-  completion status prior to recovery of the preceding message.
-
-The sending function will HANGUP when the free space in the sending buffer does 
-not exactly fit the whole message, and it will only RESUME if the free space in 
-the sending buffer grows up to this size. The call to the sending function also 
-returns with an error when the size of the message exceeds the total size of the 
-buffer (this can be modified by the `SRTO_SNDBUF` option). In other words, it is 
-not designed to send just a part of the message -- either the whole message is 
+- **TTL** defines how much time (in ms) the message should wait in the sending
+buffer for the opportunity to be picked up by the sender thread and sent over
+the network; otherwise it is dropped. Note that this TTL only applies to packets that
+have been lost and should be retransmitted.
+
+- **INORDER**, when true, means the messages must be read by the receiver in
+exactly the same order in which they were sent. In the situation where a message
+suffers a packet loss, this prevents any subsequent messages from achieving
+completion status prior to recovery of the preceding message.
+
+The sending function will HANGUP when the free space in the sending buffer does
+not exactly fit the whole message, and it will only RESUME if the free space in
+the sending buffer grows up to this size. The call to the sending function also
+returns with an error when the size of the message exceeds the total size of the
+buffer (this can be modified by the `SRTO_SNDBUF` option). In other words, it is
+not designed to send just a part of the message -- either the whole message is
 sent, or nothing at all.
 
-The receiving function will HANGUP until the whole message is available for reading; 
-if the message spans multiple UDP packets, then the function RESUMES only when 
-every single packet from the message has been received, including recovered packets, 
-if any. When the INORDER flag is set to false and parts of multiple messages are 
-currently available, the first message that is complete (possibly recovered) is 
-returned. Otherwise the function does a HANGUP until the next message is complete. 
-The call to the receiving function is rejected if the buffer size is too small 
+The receiving function will HANGUP until the whole message is available for reading;
+if the message spans multiple UDP packets, then the function RESUMES only when
+every single packet from the message has been received, including recovered packets,
+if any. When the INORDER flag is set to false and parts of multiple messages are
+currently available, the first message that is complete (possibly recovered) is
+returned. Otherwise the function does a HANGUP until the next message is complete.
+The call to the receiving function is rejected if the buffer size is too small
 for a single message to fit in it.
 
-Note that you can use any of the sending and receiving functions for sending and 
-receiving messages, except `sendfile/recvfile`, which are dedicated exclusively 
-for Buffer API. 
-
-For more information, see [APISocketOptions.md](APISocketOptions.md) 
+Note that you can use any of the sending and receiving functions for sending and
+receiving messages, except `sendfile/recvfile`, which are dedicated exclusively
+for Buffer API.
 
+For more information, see [SRT API Socket Options](API-socket-options.md).
 
-[Return to top](#srt-api)
- 
+[Return to Top of Page](#srt-api)
diff --git a/docs/API/configuration-guidelines.md b/docs/API/configuration-guidelines.md
new file mode 100644
index 000000000..76565331b
--- /dev/null
+++ b/docs/API/configuration-guidelines.md
@@ -0,0 +1,115 @@
+# Configuration Guidelines
+
+## Receiver Buffer Size
+
+The receiver buffer can be configured with the [`SRTO_RCVBUF`](./API-socket-options.md#SRTO_RCVBUF) socket option.
+Buffer size in bytes is expected to be passed in the `optval` argument of the `srt_setsockopt(..)` function.
+However, internally the value will be converted into the number of packets stored in the receiver buffer.
+
+The allowed value of `SRTO_RCVBUF` is also limited by the value of the flow control window size [`SRTO_FC`](./API-socket-options.md#SRTO_FC) socket option.
+See issue [#700](https://github.com/Haivision/srt/issues/700).
+
+The default flow control window size is 25600 packets. It is approximately:
+
+- **270 Mbits** of payload in the default live streaming configuration with an SRT payload size of **1316 bytes**;
+- **300 Mbits** of payload in the default file transfer configuration with an SRT payload size of **1456 bytes**.
+
+The default receiver buffer size is 8192 packets. It is approximately:
+- **86 Mbits** of payload with the effective SRT payload size of **1316 bytes**.
+
+### Setting Receiver Buffer Size
+
+When the `SRTO_RCVBUF` option value is set using the `srt_setsockopt(..)` function,
+the provided size in bytes is internally converted to the corresponding size in packets.
+The size of a cell for a single packet in the buffer is defined by the
+`SRTO_MSS` option, which is 1500 by default.  This value, decreased by 28 in
+the case of IPv4 (20 bytes for the IPv4 header and 8 bytes for the UDP header), gives 1472
+bytes per packet to be allocated. The actual memory occupied by the receiver
+buffer will be a multiple of that value. For the default 8192 packets it
+will be 11776 kB (11.5 MB).
+
+Note that every cell has 16 bytes for the SRT header. The remaining space
+is for the payload.
+
+As already mentioned, the maximum allowed size of the receiver buffer is limited by the value of `SRTO_FC`.
+
+The following function returns the configured buffer size in packets depending on the SRTO_RCVBUF, SRTO_MSS and SRTO_FC values set:
+
+```c++
+int getRbufSizePkts(int SRTO_RCVBUF, int SRTO_MSS, int SRTO_FC)
+{
+    // UDP/IPv4 header size is assumed to be 28 bytes
+    // 20 bytes IPv4 + 8 bytes of UDP
+    const int UDP_IPv4_HDR= 28;
+    const int pkts = (rbuf_size / (SRTO_MSS - UDP_IPv4_HDR));
+
+    return min(pkts, SRTO_FC);
+}
+```
+
+If the value of `SRTO_RCVBUF` in packets exceeds `SRTO_FC`, then it is silently set to the value in bytes corresponding to `SRTO_FC`.
+Therefore, to set higher values of `SRTO_RCVBUF` the value of `SRTO_FC` must be increased first.
+
+### Calculating Target Size in Packets
+
+The minimum size of the receiver buffer in packets can be calculated as follows:
+
+`pktsRBufSize = bps / 8 × (RTTsec + latency_sec) / bytePayloadSize`
+
+where
+
+- `bps` is the payload bitrate of the stream in bits per second;
+- `RTTsec` is the RTT of the network connection in seconds;
+
+- `bytePayloadSize` is the expected size of the payload of the SRT data packet.
+
+If the whole remainder of the MTU is expected to be used, payload size is calculated as follows:
+
+`bytePayloadSize = MSS - UDP_IPv4_HDR - SRT_HDR`
+
+where
+
+- `MSS`: Maximum Segment Size (size of the MTU); see `SRTO_MSS` (default: 1500)
+- `UDP_IPv4_HDR`: 20 bytes for IPv4 + 8 bytes for UDP
+- `SRT_HDR`: 16 bytes of SRT header (belonging to the user space)
+
+### Calculating Target Size to Set
+
+To determine the value to pass in `srt_setsockopt(..)` with `SRTO_RCVBUF`
+the size in packets `pktsRBufSize` must be converted to the size in bytes
+assuming the internal conversion of the `srt_setsockopt(..)` function.
+
+The target size of the payload stored by the receiver buffer would be:
+
+`SRTO_RCVBUF = pktsRBufSize × (SRTO_MSS - UDPHDR_SIZE)`
+
+where
+
+- `UDPHDR_SIZE` = 28 (20 bytes IPv4, 8 bytes of UDP)
+- `SRTO_MSS` is the corresponding socket option value at the moment of setting `SRTO_RCVBUF`.
+
+
+### Summing Up
+
+
+```c++
+auto CalculateTargetRBufSize(int msRTT, int bpsRate, int bytesPayloadSize, int msLatency, int SRTO_MSS)
+{
+    const int UDPHDR_SIZE = 28;
+    const long long targetPayloadBytes = static_cast<long long>(msLatency + msRTT / 2) * bpsRate / 1000 / 8;
+    const long long targetNumPackets   = targetPayloadBytes / bytesPayloadSize;
+    const long long targetSizeValue    = targetNumPackets * (SRTO_MSS - UDPHDR_SIZE);
+    return {targetNumPackets, targetSizeValue};
+}
+
+// Configuring
+
+const auto [fc, rcvbuf] = CalculateTargetRBufSize(msRTT, bpsRate, bytesPayloadSize, SRTO_RCVLATENCY, SRTO_MSS);
+
+int optval = fc;
+int optlen = sizeof optval;
+srt_setsockopt(sock, 0, SRTO_FC, (void*) &optval, optlen);
+
+optval = rcvbuf;
+srt_setsockopt(sock, 0, SRTO_RCVBUF, (void*) &optval, optlen);
+```
diff --git a/docs/API/rejection-codes.md b/docs/API/rejection-codes.md
new file mode 100644
index 000000000..0b8418b5f
--- /dev/null
+++ b/docs/API/rejection-codes.md
@@ -0,0 +1,473 @@
+# SRT Rejection Codes
+
+This document provides an overview of the rejection (error) codes used by and supported within SRT and SRT-based applications. For information on other types of error codes refer to the [API Socket Options](./docs/API/API-socket-options.md) document.
+
+[:arrow_down: &nbsp; Jump to list of rejection codes](#api-function-rejection-codes)
+
+
+## Summary of Rejection Codes
+
+Rejection codes are used in the SRT API, and are transferred on the wire as a part of a Handshake packet (refer to the `Handshake Type` field of the [Handshake](./docs/features/handshake.md) packet).
+The rejection codes are divided into several ranges:
+
+  - SRT internal
+  - Predefined application level codes
+  - User defined (custom) codes
+
+In the SRT API these ranges are marked with the following constants (preprocessor definitions):
+
+  - `SRT_REJC_INTERNAL` = 0
+  - `SRT_REJC_PREDEFINED` = 1000
+  - `SRT_REJC_USERDEFINED` = 2000
+  
+When transferred on the wire, the API value is incremented by 1000 to become the `Handshake Type` field value. In the following sections the values of rejection reason codes are given in accordance with the API values.
+
+
+### SRT Internal Rejection Codes
+
+Defined in [**srt.h**](srtcore/srt.h), these codes provide the reason why a connection is rejected by SRT. They cover the reserved range 0 - 999 (below `SRT_REJC_PREDEFINED`). These codes cannot be used by applications to report a rejection reason.
+
+Naming: `SRT_REJ_*`
+
+  - `SRT_REJ_UNKNOWN` = 0
+  - `SRT_REJ_SYSTEM` = 1
+  - ...
+  - `SRT_REJ_CRYPTO` = 17
+See [the list below](#api-function-rejection-codes) for details.
+
+### Extended Rejection Codes
+
+As defined in [**access_control.h**](srtcore/access_control.h), these are standard server error codes including those adopted from HTTP. They provide the reason why an application rejects a connection. The value is expected to be set by an application via the listener callback if it wants to reject an incoming connection request. These codes cover the reserved range 1000 - 1999 (`SRT_REJC_PREDEFINED` - `SRT_REJC_USERDEFINED`).
+
+
+Subranges (1000 + value):
+
+  - **0 - 99**: Reserved for unique SRT-specific codes (unused by HTTP)
+  - **100 - 399**: Info, Success, and Redirection in HTTP (unused by SRT)
+  - **400 - 599**: Client and server errors in HTTP (adopted by SRT)
+
+Naming: `SRT_REJX_*`
+
+Example:
+
+  - `SRT_REJX_KEY_NOTSUP` (1001): The key used in the StreamID keyed string is not supported by the service.
+  - `SRT_REJX_BAD_REQUEST` (1400)
+  - ...
+
+### User Defined Rejection Codes
+
+These codes can be freely defined by an application. They can be custom codes, not adopted by other vendors. For example, `2005: “Makito license expired”`. They cover the reserved range 2000 - 2999 (higher than `SRT_REJC_USERDEFINED`).
+
+
+## API Function Rejection Codes
+
+SRT's API function rejection codes refer to system-level error conditions caused by SRT-specific settings or operating conditions. They are uninfluenced by application-related events, and applications are not permitted to use or simulate these codes.
+
+The table below lists the rejection codes as defined in [**srt.h**](srtcore/srt.h) (click the *Rejection Reason* link to view a complete description).
+
+| *Code* | *Rejection Reason*                                 | *Since* | *Description*                                                                                                  |
+|:------:|:-------------------------------------------------- |:-------:|:-------------------------------------------------------------------------------------------------------------- |
+|    0   | [SRT_REJ_UNKNOWN](#SRT_REJ_UNKNOWN)                | 1.3.4   | Fallback value for cases where connection is not rejected.                                                     |
+|    1   | [SRT_REJ_SYSTEM](#SRT_REJ_SYSTEM)                  | 1.3.4   | System function reported a failure.                                                                            |
+|    2   | [SRT_REJ_PEER](#SRT_REJ_PEER)                      | 1.3.4   | Connection rejected by peer, with no additional details.                                                       |
+|    3   | [SRT_REJ_RESOURCE](#SRT_REJ_RESOURCE)              | 1.3.4   | Problem with resource allocation (usually memory).                                                             |
+|    4   | [SRT_REJ_ROGUE](#SRT_REJ_ROGUE)                    | 1.3.4   | Data sent by one party cannot be interpreted.                                                                  |
+|    5   | [SRT_REJ_BACKLOG](#SRT_REJ_BACKLOG)                | 1.3.4   | Listener's backlog has been exceeded.                                                                          |
+|    6   | [SRT_REJ_IPE](#SRT_REJ_IPE)                        | 1.3.4   | Internal Program Error.                                                                                        |
+|    7   | [SRT_REJ_CLOSE](#SRT_REJ_CLOSE)                    | 1.3.4   | Listener socket received a request as it is being closed.                                                      |
+|    8   | [SRT_REJ_VERSION](#SRT_REJ_VERSION)                | 1.3.4   | Minimum version requirement for a connection not satisfied by one party.                                       |
+|    9   | [SRT_REJ_RDVCOOKIE](#SRT_REJ_RDVCOOKIE)            | 1.3.4   | Rendezvous cookie collision.                                                                                   |
+|   10   | [SRT_REJ_BADSECRET](#SRT_REJ_BADSECRET)            | 1.3.4   | Both parties have defined connection passphrases that differ.                                                  |
+|   11   | [SRT_REJ_UNSECURE](#SRT_REJ_UNSECURE)              | 1.3.4   | Only one party has set up a connection password.                                                               |
+|   12   | [SRT_REJ_MESSAGEAPI](#SRT_REJ_MESSAGEAPI)          | 1.3.4   | [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) flag is different on both connection parties.       |
+|   13   | [SRT_REJ_CONGESTION](#SRT_REJ_CONGESTION)          | 1.3.4   | Incompatible congestion-controller type.                                                                       |
+|   14   | [SRT_REJ_FILTER](#SRT_REJ_FILTER)                  | 1.3.4   | [`SRTO_PACKETFILTER`](API-socket-options.md#SRTO_PACKETFILTER) option is different on both connection parties. |
+|   15   | [SRT_REJ_GROUP](#SRT_REJ_GROUP)                    | 1.4.2   | Group type or group settings are incompatible between connection parties.                                      |
+|   16   | [SRT_REJ_TIMEOUT](#SRT_REJ_TIMEOUT)                | 1.4.2   | Connection not rejected, but timed out.                                                                        |
+|   17   | [SRT_REJ_CRYPTO](#SRT_REJ_CRYPTO)                  | 1.5.2   | Connection rejected due to unsupported or mismatching encryption mode.                                         |
+|        | <img width=250px height=1px/>                      |         |                                                                                                                |
+
+
+## Access Control Rejection Codes
+
+SRT's access control rejection codes are intended for use by applications to forcefully reject connections in SRT listener callbacks. They are intended only as a guide to promote standardization. If they are used in an application, a description of their specific implementation should be published (the descriptions in this documentation are not definitive).
+
+The table below lists the rejection codes as defined in [**access_control.h**](srtcore/access_control.h) (click the *Rejection Reason* link to view a complete description).
+
+| *Code* | *Rejection Reason*                                | *Since* | *Description*                                                                                                  |
+|:------:|:------------------------------------------------- |:-------:|:-------------------------------------------------------------------------------------------------------------- |
+| 1000   | [SRT_REJX_FALLBACK](#SRT_REJX_FALLBACK)           | 1.4.2   | Callback handler has interrupted an incoming connection.                                                       |
+| 1001   | [SRT_REJX_KEY_NOTSUP](#SRT_REJX_KEY_NOTSUP)       | 1.4.2   | Key specified in StreamID string not supported by application.                                                 |
+| 1002   | [SRT_REJX_FILEPATH](#SRT_REJX_FILEPATH)           | 1.4.2   | Resource type designates file where path has wrong syntax or is not found.                                     |
+| 1003   | [SRT_REJX_HOSTNOTFOUND](#SRT_REJX_HOSTNOTFOUND)   | 1.4.2   | The host specified in the `h` key cannot be identified.                                                        | 
+| 1400   | [SRT_REJX_BAD_REQUEST](#SRT_REJX_BAD_REQUEST)     | 1.4.2   | General syntax error.                                                                                          |
+| 1401   | [SRT_REJX_UNAUTHORIZED](#SRT_REJX_UNAUTHORIZED)   | 1.4.2   | Authentication failed; client unauthorized to access the resource.                                             |
+| 1402   | [SRT_REJX_OVERLOAD](#SRT_REJX_OVERLOAD)           | 1.4.2   | Server load too heavy to process request, or credit limit exceeded.                                            |
+| 1403   | [SRT_REJX_FORBIDDEN](#SRT_REJX_FORBIDDEN)         | 1.4.2   | Access denied to the resource for any reason.                                                                  |
+| 1404   | [SRT_REJX_NOTFOUND](#SRT_REJX_NOTFOUND)           | 1.4.2   | Resource specified by `r` and `h` keys cannot be found.                                                        |
+| 1405   | [SRT_REJX_BAD_MODE](#SRT_REJX_BAD_MODE)           | 1.4.2   | Mode specified in the `m` key in StreamID is not supported for this request.                                   |
+| 1406   | [SRT_REJX_UNACCEPTABLE](#SRT_REJX_UNACCEPTABLE)   | 1.4.2   | Unavailable parameters in `StreamID`, or `m=publish` data format not supported.                                |
+| 1409   | [SRT_REJX_CONFLICT](#SRT_REJX_CONFLICT)           | 1.4.2   | Resource specified by `r` and `h` keys is locked for modification.                                             | 
+| 1415   | [SRT_REJX_NOTSUP_MEDIA](#SRT_REJX_NOTSUP_MEDIA)   | 1.4.2   | Media type  not supported by the application.                                                                  |
+| 1423   | [SRT_REJX_LOCKED](#SRT_REJX_LOCKED)               | 1.4.2   | Resource is locked against any access.                                                                         |
+| 1424   | [SRT_REJX_FAILED_DEPEND](#SRT_REJX_FAILED_DEPEND) | 1.4.2   | Dependent entity for the request is not present.                                                               |
+| 1500   | [SRT_REJX_ISE](#SRT_REJX_ISE)                     | 1.4.2   | Internal server error.                                                                                         |
+| 1501   | [SRT_REJX_UNIMPLEMENTED](#SRT_REJX_UNIMPLEMENTED) | 1.4.2   | Request not supported by current version of the service.                                                       |
+| 1502   | [SRT_REJX_GW](#SRT_REJX_GW)                       | 1.4.2   | Target endpoint rejected connection from gateway server                                                        |
+| 1503   | [SRT_REJX_DOWN](#SRT_REJX_DOWN)                   | 1.4.2   | Service is down for maintenance.                                                                               |
+| 1505   | [SRT_REJX_VERSION](#SRT_REJX_VERSION)             | 1.4.2   | SRT application version not supported.                                                                             |
+| 1507   | [SRT_REJX_NOROOM](#SRT_REJX_NOROOM)               | 1.4.2   | Data stream cannot be archived due to lack of storage space.                                                   |
+|        | <img width=250px height=1px/>                     |         |                                                                                                                |
+
+
+**NOTE**: SRT rejection codes follow this prefix convention:
+
+  - `SRT_REJ`: standard rejection codes from SRT API functions (0 - 99)
+  - `SRT_REJC`: mark the border values between ranges.
+  - `SRT_REJX`: extended rejection codes (code values above 1000).above)?*
+
+
+## API Function Rejection Reasons
+
+
+#### SRT_REJ_UNKNOWN
+
+A fallback value for cases when there was no connection rejected.
+
+
+#### SRT_REJ_SYSTEM
+
+One system function reported a failure. Usually this means some system
+error or lack of system resources to complete the task.
+
+  
+#### SRT_REJ_PEER
+
+The connection has been rejected by the peer, but no further details are available.
+This usually means that the peer doesn't support rejection reason reporting.
+
+  
+#### SRT_REJ_RESOURCE
+
+A problem with resource allocation (usually memory).
+
+  
+#### SRT_REJ_ROGUE
+
+The data sent by one party to another cannot be properly interpreted. This
+should not happen during normal usage, unless it's a bug, or some weird
+events are happening on the network.
+
+  
+#### SRT_REJ_BACKLOG
+
+The listener's backlog has exceeded its queue limit (there are many other callers 
+waiting for the opportunity to be connected and the "wait queue" has 
+reached its limit).
+
+  
+#### SRT_REJ_IPE
+
+Internal Program Error. This should not happen during normal usage. It
+usually indicates a bug in the software (although this can be reported by both
+local and foreign hosts).
+
+  
+#### SRT_REJ_CLOSE
+
+The listener socket was able to receive the request, but is currently
+being closed. It's likely that the next request will result in a timeout.
+
+  
+#### SRT_REJ_VERSION
+
+One party in the connection has set up a minimum version that is required for
+that connection, but the other party doesn't satisfy this requirement.
+
+  
+#### SRT_REJ_RDVCOOKIE
+
+Rendezvous cookie collision. Normally, the probability that this will happen is 
+negligible. However, it *can* result from a misconfiguration when, in attempting 
+to make a rendezvous connection, both parties try to bind to the same IP address, 
+or both are local addresses of the same host. In such a case the sent handshake 
+packets are returned to the same host as if they were sent by the peer (i.e. a 
+party is sending to itself). In such situations, this reject reason will be 
+reported for every attempt.
+
+  
+#### SRT_REJ_BADSECRET
+
+Both parties have defined a passphrase for a connection, but they differ.
+
+  
+#### SRT_REJ_UNSECURE
+
+Only one connection party has set up a password. See also the 
+[`SRTO_ENFORCEDENCRYPTION`](API-socket-options.md#SRTO_ENFORCEDENCRYPTION) flag.
+
+  
+#### SRT_REJ_MESSAGEAPI
+
+The value of the [`SRTO_MESSAGEAPI`](API-socket-options.md#SRTO_MESSAGEAPI) 
+flag is different on both parties in a connection.
+
+  
+#### SRT_REJ_CONGESTION
+
+The [`SRTO_CONGESTION`](API-socket-options.md#SRTO_CONGESTION)option has 
+been set up differently on both parties in a connection.
+
+  
+#### SRT_REJ_FILTER
+
+The [`SRTO_PACKETFILTER`](API-socket-options.md#SRTO_PACKETFILTER) option 
+has been set differently on both parties in a connection.
+
+  
+#### SRT_REJ_GROUP
+
+The group type or some group settings are incompatible between connection parties. 
+While every connection within a bonding group may have different target addresses, 
+they should all designate the same endpoint and the same SRT application. If this 
+condition isn't satisfied, then the peer will respond with a different peer group 
+ID for the connection that is trying to contact a machine/application that is 
+completely different from the existing connections in the bonding group.
+
+  
+#### SRT_REJ_TIMEOUT
+
+The connection wasn't rejected, but it timed out. This code is always sent on
+a connection timeout, but this is the only way to get this state in non-blocking
+mode (see [`SRTO_RCVSYN`](API-socket-options.md#SRTO_RCVSYN)).
+
+There may also be server and user rejection codes, as defined by the 
+`SRT_REJC_INTERNAL`, `SRT_REJC_PREDEFINED`, and `SRT_REJC_USERDEFINED`
+constants. Note that the number space from the value of `SRT_REJC_PREDEFINED`
+and above is reserved for "predefined codes" (`SRT_REJC_PREDEFINED` value plus
+adopted HTTP codes). Values above `SRT_REJC_USERDEFINED` are freely defined by
+the application.
+
+#### SRT_REJ_CRYPTO
+
+The connection was rejected due to a mismatch in crypto modes. See `SRTO_CRYPTOMODE`.
+
+[:arrow_up: &nbsp; Back to top](#srt-rejection-codes)
+
+
+## Access Control Rejection Reasons
+
+An SRT listener callback handler can decide to reject an  incoming connection. 
+Under normal circumstances, the rejection code is predefined as `SRT_REJ_RESOURCE`. 
+The handler can, however, set its own rejection code. There are two numbered spaces 
+intended for this purpose (as the range below `SRT_REJC_PREDEFINED` is reserved 
+for internal codes):
+
+- `SRT_REJC_PREDEFINED` and above: These are predefined errors. Errors from this 
+range (that is, below `SRT_REJC_USERDEFINED`) have their definitions provided in
+the `access_control.h` public header file. The intention is that applications
+using these codes understand the situations they describe in a standard way.
+
+- `SRT_REJC_USERDEFINED` and above: These are errors that are freely defined by 
+the application. Codes from this range can be only understood if each application 
+knows the code definitions of the other. These codes should be used only after 
+making sure that the applications at either end of a connection understand them.
+
+The intention here is for the predefined codes to be consistent with the HTTP
+standard codes. Such code can be set by using the [`srt_setrejectreason`](docs/api/api-functions.md#srt-setrejectreason) function.
+
+The SRT-specific codes are:
+
+#### SRT_REJX_FALLBACK
+
+This code should be set by the callback handler in the beginning in case
+the application needs to be informed that the callback handler
+actually has interpreted the incoming connection, but hasn't set a
+more appropriate code describing the situation.
+
+#### SRT_REJX_KEY_NOTSUP
+
+Indicates there was a key specified in the StreamID string that this application
+doesn't support. Note that it's not obligatory for the application to
+react this way - it may chose to ignore unknown keys completely, or
+to have some keys in the ignore list (which it won't interpret, but tolerate)
+while rejecting any others. It is also up to the application
+to decide to return this specific error, or more generally report
+the syntax error with `SRT_REJX_BAD_REQUEST`.
+
+#### SRT_REJX_FILEPATH
+
+The resource type designates a file, and the path either has the wrong syntax
+or is not found. In the case where `t=file`, the path should be specified under
+the `r` key, and the file specified there must be able to be saved this way.
+It's up to the application to decide how to treat this path, how to parse it,
+and what this path specifically means. For the `r` key, the application should
+at least handle the single filename, and have storage space available to save
+it (provided a file of the same name does not already exist there).  The
+application should decide whether and how to handle all other situations (like
+directory path, special markers in the path to be interpreted by the
+application, etc.), or to report this error.
+
+#### SRT_REJX_HOSTNOTFOUND
+
+The host specified in the `h` key cannot be identified. The `h` key is
+generally for a situation when you have multiple DNS names for a host,
+so an application may want to extract the name from the URI and set it
+to the `h` key so that the application can distinguish the request also by
+the target host name. The application may, however, limit the number of
+recognized services by host name to some predefined names and not
+handle the others, even if this is properly resolved by DNS. In this
+case it should report this error.
+
+The other error codes are HTTP codes adapted for SRT:
+
+#### SRT_REJX_BAD_REQUEST
+
+General syntax error. This can be reported in any case when parsing
+the StreamID contents failed, or it cannot be properly interpreted.
+
+#### SRT_REJX_UNAUTHORIZED
+
+Authentication failed, which makes the client unauthorized to access the
+resource. This error, however, confirms that the syntax is correct and
+the resource has been properly identified. Note that this cannot be
+reported when you use a simple user-password authentication
+method because in this case the password is verified only after the
+listener callback handler accepts the connection. This error is rather
+intended to be reported in the case of `t=auth` when the authentication
+process has generated some valid session ID, but then the session
+connection has specified a resource that is not within the frames
+of that authentication.
+
+#### SRT_REJX_OVERLOAD
+
+The server is too heavily loaded to process the request, or the credit limit
+for accessing the service and the resource has been exceeded.
+In HTTP the description mentions payment for a service, but
+it is also used by some services for general "credit" management
+for a client. In SRT it should be used when the service is doing
+any kind of credit management to limit access to selected clients
+that "have" enough credit, even if the credit is something the client
+can recharge itself, or that can be granted depending on available
+service resources.
+
+#### SRT_REJX_FORBIDDEN
+
+Access denied to the resource for any reason. This error is
+independent of an authorization or authentication error (as reported
+by `SRT_REJX_UNAUTHORIZED`). The application can decide which
+is more appropriate. This error is usually intended for
+a resource that should only be accessed after a successful
+authorization over a separate auth-only connection, where the query
+in StreamID has correctly specified the resource identity and mode,
+but the session ID (in the `s` key) is either (a) not specified, or 
+(b) specifies a valid session, but the authorization region for this
+session does not include the specified resource.
+
+#### SRT_REJX_NOTFOUND
+
+The resource specified in the `r` key (in combination with the `h` key)
+is not found at this time. This error should be only reported if the
+information about resource accessibility is allowed to be publicly
+visible. Otherwise, the application might report authorization
+errors.
+
+#### SRT_REJX_BAD_MODE
+
+The mode specified in the `m` key in StreamID is not supported for this request.
+This may apply to read-only or write-only resources, as well when interactive
+(bidirectional) access is not valid for a resource.
+
+#### SRT_REJX_UNACCEPTABLE
+
+Applies when the parameters specified in StreamID cannot be satisfied for the
+requested resource, or when `m=publish` but the data format is not acceptable.
+This is a general error reporting an unsupported format for data that appears to
+be wrong when sending, or a restriction on the data format (as specified in the
+details of the resource specification) such that it cannot be provided
+when receiving.
+
+#### SRT_REJX_CONFLICT
+
+The resource being accessed (as specified by `r` and `h` keys) is locked for
+modification. This error should only be reported for `m=publish` when the
+resource being accessed is read-only because another client (not necessarily
+connected through SRT):
+
+- is currently publishing into this resource
+- has reserved this resource ID for publishing
+
+Note that this error should be reported when there is no other reason for
+having a problem accessing the resource.
+
+#### SRT_REJX_NOTSUP_MEDIA
+
+The media type is not supported by the application. The media type is
+specified in the `t` key. The currently standard types are
+`stream`, `file` and `auth`. An application may extend this list, and
+is not obliged to support all of the standard types.
+
+#### SRT_REJX_LOCKED
+
+The resource being accessed is locked against any access. This is similar to
+`SRT_REJX_CONFLICT`, but in this case the resource is locked for reading
+and writing. This is for when the resource should be shown as existing and
+available to the client, but access is temporarily blocked.
+
+#### SRT_REJX_FAILED_DEPEND
+
+The dependent entity for the request is not present. In this case the
+dependent entity is the session, which should be specified in the `s`
+key. This means that the specified session ID is nonexistent, or it
+has already expired.
+
+#### SRT_REJX_ISE
+
+Internal server error. This is for a general case when a request has
+been correctly verified, with no related problems found, but an
+unexpected error occurs after the processing of the request has started.
+
+#### SRT_REJX_UNIMPLEMENTED
+
+The request was correctly recognized, but the current software version
+of the service (be it SRT or any other software component) doesn't
+support it. This should be reported for a case where some features to
+be specified in the StreamID request are supposed to be supported in a
+predictable future, but the current version of the server does not
+support it, or the support for this feature in this version has been
+temporarily blocked. This shouldn't be reported for existing features that are
+being deprecated, or older features that are no longer supported
+(for this case the general `SRT_REJX_BAD_REQUEST` is more appropriate).
+
+#### SRT_REJX_GW
+
+The server acts as a gateway and the target endpoint rejected the
+connection. The reason the connection was rejected is unspecified.
+The gateway cannot forward the original rejection code from the
+target endpoint because this would suggest the error was on the
+gateway itself. Use this error with some other mechanism to report
+the original target error, if possible.
+
+#### SRT_REJX_DOWN
+
+The service is down for maintenance. This can only be reported
+when the service has been temporarily replaced by a stub that is only
+reporting this error, while the real service is down for maintenance.
+
+#### SRT_REJX_VERSION
+
+Application version not supported. This can refer to an application feature
+that is unsupported (possibly from an older SRT version), or to a feature
+that is no longer supported because of backward compatibility requirements.
+
+#### SRT_REJX_NOROOM
+
+The data stream cannot be archived due to a lack of storage space. This is
+reported when a request to send a file or a live stream to be archived is
+unsuccessful. Note that the length of a file transmission is usually
+pre-declared, so this error can be reported early. It can also be reported when
+the stream is of undefined length, and there is no more storage space
+available.
+
+
+[:arrow_up: &nbsp; Back to top](#srt-rejection-codes)
diff --git a/docs/statistics.md b/docs/API/statistics.md
similarity index 88%
rename from docs/statistics.md
rename to docs/API/statistics.md
index 62a37bcbf..bc34ecca8 100644
--- a/docs/statistics.md
+++ b/docs/API/statistics.md
@@ -23,7 +23,7 @@ The following API functions can be used to retrieve statistics on an SRT socket:
 * `int srt_bstats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear)`
 * `int srt_bistats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear, int instantaneous)`
 
-Refer to the documentation of the [API functions](API-functions.md) for usage instructions.
+Refer to the documentation of the [SRT API Functions](API-functions.md) for usage instructions.
 
 ### Summary Table
 
@@ -32,7 +32,7 @@ The table below provides a summary of SRT socket statistics: name, type, unit of
 There are three types of statistics:
 
 - **Accumulated:** the statistic is accumulated since the time an SRT socket has been created (after the successful call to `srt_connect(...)` or `srt_bind(...)` function), e.g., [pktSentTotal](#pktSentTotal), etc.,
-- **Interval-based:** the statistic is accumulated during a specified time interval (e.g., 100 milliseconds if SRT statistics is collected each 100 milliseconds) from the time an SRT socket has been created, e.g., [pktSent](#pktSent), etc. The value of the statistic can be reset by calling the `srt_bstats(..., int clear)` function with `clear = 1`, 
+- **Interval-based:** the statistic is accumulated during a specified time interval (e.g., 100 milliseconds if SRT statistics is collected each 100 milliseconds) from the time an SRT socket has been created, e.g., [pktSent](#pktSent), etc. The value of the statistic can be reset by calling the `srt_bstats(..., int clear)` function with `clear = 1`,
 - **Instantaneous:** the statistic is obtained at the moment the `srt_bistats()` function is called, e.g., [msRTT](#msRTT), etc.
 
 See sections [Accumulated Statistics](#accumulated-statistics), [Interval-Based Statistics](#interval-based-statistics), and [Instantaneous Statistics](#instantaneous-statistics) for a detailed description of each statistic.
@@ -134,19 +134,19 @@ The time elapsed, in milliseconds, since the SRT socket has been created (after
 
 The total number of sent DATA packets, including retransmitted packets ([pktRetransTotal](#pktRetransTotal)). Available for sender.
 
-If the `SRTO_PACKETFILTER` socket option is enabled (refer to [API.md](API.md)), this statistic counts sent packet filter control packets ([pktSndFilterExtraTotal](#pktSndFilterExtraTotal)) as well. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is enabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic counts sent packet filter control packets ([pktSndFilterExtraTotal](#pktSndFilterExtraTotal)) as well. Introduced in SRT v1.4.0.
 
 #### pktRecvTotal
 
 The total number of received DATA packets, including retransmitted packets ([pktRcvRetransTotal](#pktRcvRetransTotal)). Available for receiver.
 
-If the `SRTO_PACKETFILTER` socket option is enabled (refer to [API.md](API.md)), this statistic counts received packet filter control packets ([pktRcvFilterExtraTotal](#pktRcvFilterExtraTotal)) as well. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is enabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic counts received packet filter control packets ([pktRcvFilterExtraTotal](#pktRcvFilterExtraTotal)) as well. Introduced in SRT v1.4.0.
 
-#### pktSentUniqueTotal 
+#### pktSentUniqueTotal
 
-The total number of *unique* DATA packets sent by the SRT sender. Available for sender. 
+The total number of *unique* DATA packets sent by the SRT sender. Available for sender.
 
-This value contains only *unique* *original* DATA packets. Retransmitted DATA packets ([pktRetransTotal](#pktRetransTotal)) are not taken into account. If the `SRTO_PACKETFILTER` socket option is enabled (refer to [API.md](https://cac-word-edit.officeapps.live.com/we/API.md)), packet filter control packets ([pktSndFilterExtraTotal](#pktSndFilterExtraTotal)) are also not taken into account.
+This value contains only *unique* *original* DATA packets. Retransmitted DATA packets ([pktRetransTotal](#pktRetransTotal)) are not taken into account. If the `SRTO_PACKETFILTER` socket option is enabled (refer to [SRT API Socket Options](API-socket-options.md)), packet filter control packets ([pktSndFilterExtraTotal](#pktSndFilterExtraTotal)) are also not taken into account.
 
 This value corresponds to the number of original DATA packets sent by the SRT sender. It counts every packet sent over the network for the first time, and can be calculated as follows: `pktSentUniqueTotal = pktSentTotal – pktRetransTotal`, or by `pktSentUniqueTotal = pktSentTotal – pktRetransTotal - pktSndFilterExtraTotal` if the  `SRTO_PACKETFILTER` socket option is enabled. The original DATA packets are sent only once.
 
@@ -154,21 +154,21 @@ This value corresponds to the number of original DATA packets sent by the SRT se
 
 The total number of *unique* original, retransmitted or recovered by the packet filter DATA packets *received in time*, *decrypted without errors* and, as a result, scheduled for delivery to the upstream application by the SRT receiver. Available for receiver.
 
-Unique means "first arrived" DATA packets. There is no difference whether a packet is original or, in case of loss, retransmitted or recovered by the packet filter. Whichever packet comes first is taken into account. 
+Unique means "first arrived" DATA packets. There is no difference whether a packet is original or, in case of loss, retransmitted or recovered by the packet filter. Whichever packet comes first is taken into account.
 
 This statistic doesn't count
 
-- duplicate packets (retransmitted or sent several times by defective hardware/software), 
+- duplicate packets (retransmitted or sent several times by defective hardware/software),
 - arrived too late packets (retransmitted or original packets arrived out of order) that were already dropped by the TLPKTDROP mechanism (see [pktRcvDropTotal](#pktRcvDropTotal) statistic),
 - arrived in time packets, but decrypted with errors (see [pktRcvUndecryptTotal](#pktRcvUndecryptTotal) statistic), and, as a result, dropped by the TLPKTDROP mechanism (see [pktRcvDropTotal](#pktRcvDropTotal) statistic).
 
-DATA packets recovered by the packet filter ([pktRcvFilterSupplyTotal](#pktRcvFilterSupplyTotal)) are taken into account if the `SRTO_PACKETFILTER` socket option is enabled (refer to [API.md](API.md)). Do not mix up with the control packets received by the packet filter ([pktRcvFilterExtraTotal](#pktRcvFilterExtraTotal)).
+DATA packets recovered by the packet filter ([pktRcvFilterSupplyTotal](#pktRcvFilterSupplyTotal)) are taken into account if the `SRTO_PACKETFILTER` socket option is enabled (refer to [SRT API Socket Options](API-socket-options.md)). Do not mix up with the control packets received by the packet filter ([pktRcvFilterExtraTotal](#pktRcvFilterExtraTotal)).
 
 #### pktSndLossTotal
 
 The total number of data packets considered or reported as lost at the sender side. Does not correspond to the packets detected as lost at the receiver side. Available for sender.
 
-A packet is considered lost in two cases: 
+A packet is considered lost in two cases:
 1. Sender receives a loss report from a receiver,
 2. Sender initiates retransmission after not receiving an ACK packet for a certain timeout. Refer to `FASTREXMIT` and `LATEREXMIT` algorithms.
 
@@ -222,55 +222,59 @@ The total accumulated time in microseconds, during which the SRT sender has some
 
 #### pktSndDropTotal
 
-The total number of _dropped_ by the SRT sender DATA packets that have no chance to be delivered in time (refer to [TLPKTDROP](https://github.com/Haivision/srt-rfc/blob/master/draft-sharabayko-mops-srt.md#too-late-packet-drop-too-late-packet-drop) mechanism). Available for sender.
+The total number of _dropped_ by the SRT sender DATA packets that have no chance to be delivered in time (refer to [Too-Late Packet Drop](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-4.6) mechanism). Available for sender.
 
-Packets may be dropped conditionally when both `SRTO_TSBPDMODE` and `SRTO_TLPKTDROP` socket options are enabled, refer to [API.md](API.md).
+Packets may be dropped conditionally when both `SRTO_TSBPDMODE` and `SRTO_TLPKTDROP` socket options are enabled, refer to [SRT API Socket Options](API-socket-options.md).
 
-The delay before TLPKTDROP mechanism is triggered is calculated as follows 
+The delay before TLPKTDROP mechanism is triggered is calculated as follows
 `SRTO_PEERLATENCY + SRTO_SNDDROPDELAY + 2 * interval between sending ACKs`,
-where `SRTO_PEERLATENCY` is the configured SRT latency, `SRTO_SNDDROPDELAY` adds an extra to `SRTO_PEERLATENCY` delay, the default `interval between sending ACKs` is 10 milliseconds. The minimum delay is `1000 + 2 * interval between sending ACKs` milliseconds. Refer to `SRTO_PEERLATENCY`, `SRTO_SNDDROPDELAY` socket options in [API.md](API.md).
+where `SRTO_PEERLATENCY` is the configured SRT latency, `SRTO_SNDDROPDELAY` adds an extra to `SRTO_PEERLATENCY` delay, the default `interval between sending ACKs` is 10 milliseconds. The minimum delay is `1000 + 2 * interval between sending ACKs` milliseconds. Refer to `SRTO_PEERLATENCY`, `SRTO_SNDDROPDELAY` socket options in [SRT API Socket Options](API-socket-options.md).
 
 #### pktRcvDropTotal
 
-The total number of _dropped_ by the SRT receiver and, as a result, not delivered to the upstream application DATA packets (refer to [TLPKTDROP](https://github.com/Haivision/srt-rfc/blob/master/draft-sharabayko-mops-srt.md#too-late-packet-drop-too-late-packet-drop) mechanism). Available for receiver.
+The total number of _dropped_ by the SRT receiver and, as a result, not delivered to the upstream application DATA packets (refer to [Too-Late Packet Drop](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-4.6) mechanism). Available for receiver.
 
 This statistic counts
+
+- not arrived packets including those signalled for dropping by the sender, that were dropped in favor of the subsequent existing packets,
 - arrived too late packets (retransmitted or original packets arrived out of order),
 - arrived in time packets, but decrypted with errors (see also [pktRcvUndecryptTotal](#pktRcvUndecryptTotal) statistic).
 
-Packets may be dropped conditionally when both `SRTO_TSBPDMODE` and `SRTO_TLPKTDROP` socket options are enabled, refer to [API.md](API.md).
+Packets may be dropped conditionally when both `SRTO_TSBPDMODE` and `SRTO_TLPKTDROP` socket options are enabled, refer to [SRT API Socket Options](API-socket-options.md).
 
 #### pktRcvUndecryptTotal
 
 The total number of packets that failed to be decrypted at the receiver side. Available for receiver.
+The statistic also counts unencrypted packets that were expected to be uncrypted on a secured connection (see [SRTO_KM_S_SECURED](API-socket-options.md#srt_km_state))
+and hence dropped as not encrypted (undecrypted).
 
 #### pktSndFilterExtraTotal
 
-The total number of packet filter control packets generated by the packet filter (refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md)). Available for sender.
+The total number of packet filter control packets generated by the packet filter (refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md)). Available for sender.
 
 Packet filter control packets contain only control information necessary for the packet filter. The type of these packets is DATA.
 
-If the `SRTO_PACKETFILTER` socket option is disabled (refer to [API.md](API.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is disabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
 
 #### pktRcvFilterExtraTotal
 
-The total number of packet filter control packets received by the packet filter (refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md)). Available for receiver.
+The total number of packet filter control packets received by the packet filter (refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md)). Available for receiver.
 
 Packet filter control packets contain only control information necessary for the packet filter. The type of these packets is DATA.
 
-If the `SRTO_PACKETFILTER` socket option is disabled (refer to [API.md](API.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is disabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
 
 #### pktRcvFilterSupplyTotal
 
-The total number of lost DATA packets recovered by the packet filter at the receiver side (e.g., FEC rebuilt packets; refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md)). Available for receiver.
+The total number of lost DATA packets recovered by the packet filter at the receiver side (e.g., FEC rebuilt packets; refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md)). Available for receiver.
 
-If the `SRTO_PACKETFILTER` socket option is disabled (refer to [API.md](API.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is disabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
 
 #### pktRcvFilterLossTotal
 
-The total number of lost DATA packets **not** recovered by the packet filter at the receiver side (refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md)). Available for receiver.
+The total number of lost DATA packets **not** recovered by the packet filter at the receiver side (refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md)). Available for receiver.
 
-If the `SRTO_PACKETFILTER` socket option is disabled (refer to [API.md](API.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
+If the `SRTO_PACKETFILTER` socket option is disabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic is equal to 0. Introduced in SRT v1.4.0.
 
 #### byteSentTotal
 
@@ -363,25 +367,25 @@ Same as [pktRecvNAKTotal](#pktRecvNAKTotal), but for a specified interval.
 
 Same as [pktSndFilterExtraTotal](#pktSndFilterExtraTotal), but for a specified interval.
 
-Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md).
+Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md).
 
 #### pktRcvFilterExtra
 
 Same as [pktRcvFilterExtraTotal](#pktRcvFilterExtraTotal), but for a specified interval.
 
-Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md).
+Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md).
 
 #### pktRcvFilterSupply
 
 Same as [pktRcvFilterSupplyTotal](#pktRcvFilterSupplyTotal), but for a specified interval.
 
-Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md).
+Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md).
 
 #### pktRcvFilterLoss
 
 Same as [pktRcvFilterLossTotal](#pktRcvFilterLossTotal), but for a specified interval.
 
-Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](packet-filtering-and-fec.md).
+Introduced in v1.4.0. Refer to [SRT Packet Filtering & FEC](../features/packet-filtering-and-fec.md).
 
 #### mbpsSendRate
 
@@ -408,9 +412,9 @@ The number of packets received but IGNORED due to having arrived too late.
 
 Makes sense only if TSBPD and TLPKTDROP are enabled.
 
-An offset between sequence numbers of the newly arrived DATA packet and latest 
+An offset between sequence numbers of the newly arrived DATA packet and latest
 acknowledged DATA packet is calculated.
-If the offset is negative, the packet is considered late, meaning that it was 
+If the offset is negative, the packet is considered late, meaning that it was
 either already acknowledged or dropped by TSBPD as too late to be delivered.
 
 Retransmitted packets can also be considered late.
@@ -468,7 +472,7 @@ Same as [byteRcvUndecryptTotal](#byteRcvUndecryptTotal), but for a specified int
 
 #### usPktSndPeriod
 
-Current minimum time interval between which consecutive packets are sent, in 
+Current minimum time interval between which consecutive packets are sent, in
 microseconds. Sender only.
 
 Note that several sockets sharing one outgoing port use the same sending queue.
@@ -477,8 +481,8 @@ be placed in the same sending queue, which may affect the send timing.
 
 `usPktSndPeriod` is the minimum time (sending period) that must be kept
 between two packets sent consecutively over the link used by an SRT socket.
-It is not the EXACT time interval between two consecutive packets. In the case where the time spent by an 
-application between sending two consecutive packets exceeds `usPktSndPeriod`, the next 
+It is not the EXACT time interval between two consecutive packets. In the case where the time spent by an
+application between sending two consecutive packets exceeds `usPktSndPeriod`, the next
 packet will be sent faster, or even immediately, to preserve the average sending rate.
 
 **Note**: Does not apply to probing packets.
@@ -520,8 +524,8 @@ The number of packets in flight. Sender only.
 
 `pktFlightSize <= pktFlowWindow` and `pktFlightSize <= pktCongestionWindow`
 
-This is the distance 
-between the packet sequence number that was last reported by an ACK message and 
+This is the distance
+between the packet sequence number that was last reported by an ACK message and
 the sequence number of the latest packet sent (at the moment when the statistics
 are being read).
 
@@ -539,21 +543,10 @@ at that moment.
 
 #### msRTT
 
-Calculated Round trip time (RTT), in milliseconds. Sender and Receiver. \
-The value is calculated by the receiver based on the incoming ACKACK control packets
-(used by sender to acknowledge ACKs from receiver).
-
-The RTT (Round-Trip time) is the sum of two STT (Single-Trip time) 
-values, one from agent to peer, and one from peer to agent. Note that **the 
-measurement method is different than in TCP**. SRT measures only the "reverse
-RTT", that is, the time measured at the receiver between sending a `UMSG_ACK`
-message until receiving the sender's `UMSG_ACKACK` response message (with the
-same journal). This happens to be a little different from the "forward RTT"
-measured in TCP, which is the time between sending a data packet of a particular 
-sequence number and receiving `UMSG_ACK` with a sequence number that is later 
-by 1. Forward RTT isn't being measured or reported in SRT, although some
-research works have shown that these values, even though they should be the same,
-happen to differ; "reverse RTT" seems to be more optimistic.
+Smoothed round-trip time (SRTT), an exponentially-weighted moving average (EWMA) of an endpoint's RTT samples, in milliseconds.
+Available both for sender and receiver.
+
+See [Section 4.10. Round-Trip Time Estimation](https://tools.ietf.org/html/draft-sharabayko-srt-01#section-4.10) of the [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) and [[RFC6298] Paxson, V., Allman, M., Chu, J., and M. Sargent, "Computing TCP's Retransmission Timer"](https://datatracker.ietf.org/doc/html/rfc6298) for more details.
 
 #### mbpsBandwidth
 
@@ -571,8 +564,8 @@ The receiver then sends back a running average calculation to the sender with an
 
 The available space in the sender's buffer, in bytes. Sender only.
 
-This value decreases with data scheduled for sending by the application, and increases 
-with every ACK received from the receiver, after the packets are sent over 
+This value decreases with data scheduled for sending by the application, and increases
+with every ACK received from the receiver, after the packets are sent over
 the UDP link.
 
 #### byteAvailRcvBuf
@@ -586,13 +579,13 @@ from the sender over the UDP link.
 #### mbpsMaxBW
 
 Transmission bandwidth limit, in Mbps. Sender only.
-Usually this is the setting from 
-the `SRTO_MAXBW` option, which may include the value 0 (unlimited). Under certain 
-conditions a nonzero value might be be provided by a congestion 
-control module, although none of the built-in congestion control modules 
+Usually this is the setting from
+the `SRTO_MAXBW` option, which may include the value 0 (unlimited). Under certain
+conditions a nonzero value might be be provided by a congestion
+control module, although none of the built-in congestion control modules
 currently use it.
 
-Refer to `SRTO_MAXBW` and `SRTO_INPUTBW` in [API.md](API.md).
+Refer to `SRTO_MAXBW` and `SRTO_INPUTBW` in [SRT API Socket Options](API-socket-options.md).
 
 #### byteMSS
 
@@ -602,11 +595,11 @@ Should not exceed the size of the maximum transmission unit (MTU), in bytes. Sen
 The default size of the UDP packet used for transport,
 including all possible headers (Ethernet, IP and UDP), is 1500 bytes.
 
-Refer to `SRTO_MSS` in [API.md](API.md).
+Refer to `SRTO_MSS` in [SRT API Socket Options](API-socket-options.md).
 
 #### pktSndBuf
 
-The number of packets in the sender's buffer that are already 
+The number of packets in the sender's buffer that are already
 scheduled for sending or even possibly sent, but not yet acknowledged.
 Sender only.
 
@@ -638,7 +631,7 @@ The current state is returned if `srt_bistats(...)` is called with `instantaneou
 #### msSndTsbPdDelay
 
 Timestamp-based Packet Delivery Delay value of the peer.
-If `SRTO_TSBPDMODE` is on (default for **live mode**), it 
+If `SRTO_TSBPDMODE` is on (default for **live mode**), it
 returns the value of `SRTO_PEERLATENCY`, otherwise 0.
 The sender reports the TSBPD delay value of the receiver.
 The receiver reports the TSBPD delay of the sender.
@@ -666,7 +659,7 @@ The timespan (msec) of acknowledged packets in the receiver's buffer. Receiver s
 
 If TSBPD mode is enabled (defualt for **live mode**),
 a packet can be acknowledged, but not yet ready to play.
-This range includes all packets regardless of whether 
+This range includes all packets regardless of whether
 they are ready to play or not.
 
 A moving average value is reported when the value is retrieved by calling
@@ -719,20 +712,15 @@ The packet with sequence number 9 is reported lost.
 
 #### pktRcvAvgBelatedTime
 
-Accumulated difference between the current time and the time-to-play of a packet 
+Accumulated difference between the current time and the time-to-play of a packet
 that is received late.
 
 
 ## SRT Group Statistics
 
-SRT group statistics are implemented for SRT Connection Bonding feature and available since SRT v1.5.0. Check the following documentation and code examples for details:
+SRT group statistics are implemented for [SRT Connection Bonding](../features/bonding-quick-start.md) feature and available since SRT v1.5.0.
 
-- [Introduction in SRT Connection Bonding feature](https://github.com/Haivision/srt/blob/master/docs/bonding-intro.md),
-- [The concept of socket groups](https://github.com/Haivision/srt/blob/master/docs/socket-groups.md). Here you will also find the information regarding `srt-test-live`  application for testing Connection Bonding,
-- Check also [API](https://github.com/Haivision/srt/blob/master/docs/API.md) and [API functions](https://github.com/Haivision/srt/blob/master/docs/API-functions.md) documentation for Connection Bonding related updates,
-- Code examples: simple [client](https://github.com/Haivision/srt/blob/master/examples/test-c-client-bonding.c) and [server](https://github.com/Haivision/srt/blob/master/examples/test-c-server-bonding.c) implementation.
-
-`srt_bistats(SRTSOCKET u, ...)`  function can be used with a socket group ID as a first argument to get statistics for a group. Most values of the `SRT_TRACEBSTATS` will be filled with zeros except for the fields listed in [Summary Table](#group-summary-table) below. Refer to the documentation of the [API functions](API-functions.md) for usage instructions.
+The `srt_bistats(SRTSOCKET u, ...)` function can be used with a socket group ID as the first argument to get statistics for a group. `SRT_TRACEBSTATS` values will mostly be zeros, except for the fields listed in the [Summary Table](#group-summary-table) below. Refer to the [SRT API Functions](../API/API-functions.md#socket-group-management) documentation for usage instructions.
 
 ### Summary Table <a name="group-summary-table"></a>
 
@@ -758,7 +746,7 @@ The table below provides a summary of SRT group statistics: name, type, unit of
 
 #### msTimeStamp <a name="group-msTimeStamp"></a>
 
-The time elapsed, in milliseconds, since the time ("connection" time) when the initial group connection has been initiated (the time when the first connection in the group has been made and therefore made the group connected). This "connection" time will be then set in this statistic in every next socket that will become a member of the group as the new connections are established. A new connection to an already connected group doesn’t change the value of "connection" time. Available both for sender and receiver. 
+The time elapsed, in milliseconds, since the time ("connection" time) when the initial group connection has been initiated (the time when the first connection in the group has been made and therefore made the group connected). This "connection" time will be then set in this statistic in every next socket that will become a member of the group as the new connections are established. A new connection to an already connected group doesn’t change the value of "connection" time. Available both for sender and receiver.
 
 #### pktSentUniqueTotal <a name="group-pktSentUniqueTotal"></a>
 
@@ -768,7 +756,7 @@ This value counts every *original* DATA packet sent over the network for the fir
 
 This statistic does not count retransmitted DATA packets that are individual per socket connection within the group. See the corresponding [pktRetransTotal](#pktRetransTotal) socket statistic.
 
-If the `SRTO_PACKETFILTER` socket option is enabled (refer to [API.md](API.md)), this statistic does not count packet filter control packets that are individual per socket connection within the group. See the corresponding [pktSndFilterExtraTotal](#pktSndFilterExtraTotal) socket statistic.
+If the `SRTO_PACKETFILTER` socket option is enabled (refer to [SRT API Socket Options](API-socket-options.md)), this statistic does not count packet filter control packets that are individual per socket connection within the group. See the corresponding [pktSndFilterExtraTotal](#pktSndFilterExtraTotal) socket statistic.
 
 #### pktRecvUniqueTotal <a name="group-pktRecvUniqueTotal"></a>
 
@@ -835,5 +823,5 @@ The ratio of unrecovered by the socket group packets `Dropped Packets Ratio` can
 
 ```
 Dropped Packets Ratio = pktRcvDropTotal / pktSentUniqueTotal; in case both sender and receiver statistics is available
-Dropped Packets Ratio = pktRcvDropTotal / (pktRecvUniqueTotal + pktRcvDropTotal); in case receiver only statistics is available 
-```
\ No newline at end of file
+Dropped Packets Ratio = pktRcvDropTotal / (pktRecvUniqueTotal + pktRcvDropTotal); in case receiver only statistics is available
+```
diff --git a/docs/APISocketOptions.md b/docs/APISocketOptions.md
deleted file mode 100644
index 82da159cf..000000000
--- a/docs/APISocketOptions.md
+++ /dev/null
@@ -1,1466 +0,0 @@
-# SRT Socket Options
-
-There is a general method of setting options on a socket in the SRT C API, similar
-to the system `setsockopt/getsockopt` functions.
-
-**NOTE**: This document replaces the socket option description originally
-in [api.md](https://github.com/Haivision/srt/blob/master/docs/API.md)
-
-**Sections:**
-
-- [Types used in socket options](#types-used-in-socket-options)
-- [Getting and setting options](#getting-and-setting-options)
-- [List of options](#list-of-options)
-
-## Types used in socket options
-
-Possible types of socket options are:
-
-- `int32_t` - This type can usually be treated as an `int` equivalent since it 
-does not change size on 64-bit systems. For clarity, options use this fixed size 
-integer. In some cases the value is expressed using an enumeration type (see below).
-
-- `int64_t` - Some options need the parameter specified as 64-bit integer
-
-- `bool` - Requires the use of a boolean type (`<stdbool.h>` for C, or built-in
-for C++). When *setting* an option, passing the value through an `int` type is
-also properly recognized. When *getting* an option, however, you should use the
-`bool` type, although you can risk passing a variable of `int` type initialized
-with 0 and then checking if the resulting value is equal to 0 (just don't compare
-the result with 1).
-
-- `string` - When *setting* an option, pass the character array pointer as value
-and the string length as length. When *getting*, pass an array of sufficient size
-(as specified in the size variable). Every option with this type that can be
-read should specify the maximum length of that array.
-
-- `linger` - Linger structure. Used exclusively with `SRTO_LINGER`.
-
-### Enumeration types used in options
-
-#### `SRT_TRANSTYPE`
-
-Used by `SRTO_TRANSTYPE` option:
-
-- `SRTT_LIVE`: Live mode.
-- `SRTT_FILE`: File mode.
-
-See [Transmission types](./API.md#transmission-types) for details.
-
-#### `SRT_KM_STATE`
-
-The defined encryption state as performed by the Key Material Exchange, used
-by `SRTO_RCVKMSTATE`, `SRTO_SNDKMSTATE` and `SRTO_KMSTATE` options:
-
-- `SRT_KM_S_UNSECURED`: no encryption/decryption. If this state is only on
-the receiver, received encrypted packets will be dropped.
-
-- `SRT_KM_S_SECURING`: pending security (HSv4 only). This is a temporary state
-used only if the connection uses HSv4 and the Key Material Exchange is
-not finished yet. On HSv5 this is not possible because the Key Material
-Exchange for the initial key is done in the handshake.
-
-- `SRT_KM_S_SECURED`: KM exchange was successful and the data will be sent
-encrypted and will be decrypted by the receiver. This state is only possible on
-both sides in both directions simultaneously.
-
-- `SRT_KM_S_NOSECRET`: If this state is in the sending direction (`SRTO_SNDKMSTATE`), 
-then it means that the sending party has set a passphrase, but the peer did not. 
-In this case the sending party can receive unencrypted packets from the peer, but 
-packets it sends to the peer will be encrypted and the peer will not be able to 
-decrypt them. This state is only possible in HSv5.
-
-- `SRT_KM_S_BADSECRET`: The password is wrong (set differently on each party);
-encrypted payloads won't be decrypted in either direction.
-
-Note that with the default value of `SRTO_ENFORCEDENCRYPTION` option (true),
-the state is equal on both sides in both directions, and it can be only
-`SRT_KM_S_UNSECURED` or `SRT_KM_S_SECURED` (in other cases the connection
-is rejected). Otherwise it may happen that either both sides have different
-passwords and the state is `SRT_KM_S_BADSECRET` in both directions, or only
-one party has set a password, in which case the KM state is as follows:
-
-|                          | `SRTO_RCVKMSTATE`    | `SRTO_SNDKMSTATE`    |
-|--------------------------|----------------------|----------------------|
-| Party with no password:  | `SRT_KM_S_NOSECRET`  | `SRT_KM_S_UNSECURED` |
-| Party with password:     | `SRT_KM_S_UNSECURED` | `SRT_KM_S_NOSECRET`  |
-
-## Getting and setting options
-
-Legacy version:
-
-    int srt_getsockopt(SRTSOCKET socket, int level, SRT_SOCKOPT optName, void* optval, int& optlen);
-    int srt_setsockopt(SRTSOCKET socket, int level, SRT_SOCKOPT optName, const void* optval, int optlen);
-
-New version:
-
-    int srt_getsockflag(SRTSOCKET socket, SRT_SOCKOPT optName, void* optval, int& optlen);
-    int srt_setsockflag(SRTSOCKET socket, SRT_SOCKOPT optName, const void* optval, int optlen);
-
-In the legacy version, there's an additional unused `level` parameter. It was 
-there in the original UDT API just to mimic the system `setsockopt` function, 
-but it's ignored.
-
-Some options require a value of type `bool` while others require type `integer`,
-which is not the same -- they differ in size, and mistaking them may end up
-causing a crash. This must be kept in mind especially in any C wrapper. For
-convenience, the *setting* option function may accept both `int32_t` and `bool`
-types, but this is not so in the case of *getting* an option value.
-
-**UDT project legacy note**: Almost all options from the UDT library are
-derived (there are a few deleted, including some deprecated already in UDT).
-Many new SRT options have been added. All options are available exclusively
-with the `SRTO_` prefix. Old names are provided as alias names in the `udt.h`
-legacy/C++ API file. Note the translation rules:
-
-* `UDT_` prefix from UDT options was changed to the prefix `SRTO_`
-* `UDP_` prefix from UDT options was changed to the prefix `SRTO_UDP_`
-* `SRT_` prefix in older SRT versions was changed to `SRTO_`
-
-The [table below](#list-of-options) provides a complete list of SRT options and 
-their characteristics according to the following legend:
-
-1. **Since**: Defines the SRT version when this option was first introduced. If this field
-is empty, it's an option derived from UDT. "Version 0.0.0" is the oldest version
-of SRT ever created and put into use.
-
-2. **Binding**: Defines limitation on setting the option. The field is empty if the option
-is not settable (see **Dir** column):
-
-    - `pre`: A connecting socket (both as caller and rendezvous) must be set
-prior to calling `srt_connect()` or `srt_bind()` and never changed thereafter.
-A listener socket should be set to "listening" and it will be
-derived by every socket returned by `srt_accept()`.
-
-    - `post`: This flag can be changed any time, including after the socket is
-connected (as well as on an accepted socket). Setting this flag on a listening 
-socket is effective only on that socket itself. Note though that there are some
-post-bound options that have important meaning when set prior to connecting.
-
-3. **Type**: The data type of the option (see above).
-
-4. **Units**: Roughly specified unit, if the value defines things like length or time.
-It can also define more precisely what kind of specialization can be used
-when the type is integer:
-
-    - `enum`: the possible values are defined in an enumeration type
-    - `flags`: the integer value is a collection of bit flags
-    - `B/s` - bytes per second.
-
-5. **Default**: The exact default value, if it can be easily specified. A more complicated
-default state of a particular option will be explained in the [description](#option-descriptions)
-(when marked by asterisk). For non-settable options this field is empty.
-
-6. **Range**: If a value of an integer type has a limited range, or only a certain value
-allowed, it will be specified here (otherwise empty). A range value can be
-specified as:
-
-        - `X-... `: specifies only a minimum value
-        - `X-Y,Z `: values between X and Y are allowed, and additionally Z
-
-    - If the value is of `string` type, this field will contain its maximum size
-in square brackets.
-
-    - If the range contains additionally an asterisk, it means that more elaborate
-restrictions on the value apply, as explained in the [description](#option-descriptions).
-
-7. **Dir**: Option direction: W if can be set, R if can be retrieved, RW if both.
-
-8. **Entity**: This describes whether the option can be set on the socket or the group.
-The G and S options may appear together, in which case both possibilities apply.
-The D and I options, mutually exclusive, appear always with G. 
-The + marker can only coexist with GS. Possible specifications are:
-
-    - S: This option can be set on a single socket (exclusively, if not GS)
-
-    - G: This option can be set on a group (exclusively, if not GS)
-
-    - D: If set on a group, it will be derived by the member socket
-
-    - I: If set on a group, it will be taken and managed exclusively by the group
-
-    - +: This option is also allowed to be set individually on a group member
-      socket through a configuration object in `SRT_SOCKGROUPCONFIG` prepared by
-      `srt_create_config`. Note that this setting may override the setting derived
-      from the group.
-
-## List of options
-
-The following table lists SRT socket options in alphabetical order. Option details are given further below.
-
-| Option Name                                            | Since | Binding | Type      | Units   | Default       | Range    | Dir |Entity |
-| :----------------------------------------------------- | :---: | :-----: | :-------: | :-----: | :-----------: | :------: |:---:|:-----:|
-| [`SRTO_BINDTODEVICE`](#SRTO_BINDTODEVICE)              | 1.4.2 | pre     | `string`  |         |               |          | RW  | GSD+  |
-| [`SRTO_CONGESTION`](#SRTO_CONGESTION)                  | 1.3.0 | pre     | `string`  |         | "live"        | *        | W   | S     |
-| [`SRTO_CONNTIMEO`](#SRTO_CONNTIMEO)                    | 1.1.2 | pre     | `int32_t` | ms      | 3000          | 0..      | W   | GSD+  |
-| [`SRTO_DRIFTTRACER`](#SRTO_DRIFTTRACER)                | 1.4.2 | post    | `bool`    |         | true          |          | RW  | GSD   |
-| [`SRTO_ENFORCEDENCRYPTION`](#SRTO_ENFORCEDENCRYPTION)  | 1.3.2 | pre     | `bool`    |         | true          |          | W   | GSD   |
-| [`SRTO_EVENT`](#SRTO_EVENT)                            |       |         | `int32_t` | flags   |               |          | R   | S     |
-| [`SRTO_FC`](#SRTO_FC)                                  |       | pre     | `int32_t` | pkts    | 25600         | 32..     | RW  | GSD   |
-| [`SRTO_GROUPCONNECT`](#SRTO_GROUPCONNECT)              | 1.5.0 | pre     | `int32_t` |         | 0             | 0...1    | W   | S     |
-| [`SRTO_GROUPSTABTIMEO`](#SRTO_GROUPSTABTIMEO)          | 1.5.0 | pre     | `int32_t` | ms      | 80            | 10-...   | W   | GSD+  |
-| [`SRTO_GROUPTYPE`](#SRTO_GROUPTYPE)                    | 1.5.0 | pre     | `int32_t` | enum    |               |          | R   | S     |
-| [`SRTO_INPUTBW`](#SRTO_INPUTBW)                        | 1.0.5 | post    | `int64_t` | B/s     | 0             | 0..      | RW  | GSD   |
-| [`SRTO_IPTOS`](#SRTO_IPTOS)                            | 1.0.5 | pre     | `int32_t` |         | (system)      | 0..255   | RW  | GSD   |
-| [`SRTO_IPTTL`](#SRTO_IPTTL)                            | 1.0.5 | pre     | `int32_t` | hops    | (system)      | 1..255   | RW  | GSD   |
-| [`SRTO_IPV6ONLY`](#SRTO_IPV6ONLY)                      | 1.4.0 | pre     | `int32_t` |         | (system)      | -1..1    | RW  | GSD   |
-| [`SRTO_ISN`](#SRTO_ISN)                                | 1.3.0 |         | `int32_t` |         |               |          | R   | S     |
-| [`SRTO_KMPREANNOUNCE`](#SRTO_KMPREANNOUNCE)            | 1.3.2 | pre     | `int32_t` | pkts    | 0x1000        | 0.. *    | RW  | GSD   |
-| [`SRTO_KMREFRESHRATE`](#SRTO_KMREFRESHRATE)            | 1.3.2 | pre     | `int32_t` | pkts    | 0x1000000     | 0..      | RW  | GSD   |
-| [`SRTO_KMSTATE`](#SRTO_KMSTATE)                        | 1.0.2 |         | `int32_t` | enum    |               |          | R   | S     |
-| [`SRTO_LATENCY`](#SRTO_LATENCY)                        | 1.0.2 | pre     | `int32_t` | ms      | 120 *         | 0..      | RW  | GSD   |
-| [`SRTO_LINGER`](#SRTO_LINGER)                          |       | pre     | `linger`  | s       | on, 180       | 0..      | RW  | GSD   |
-| [`SRTO_LOSSMAXTTL`](#SRTO_LOSSMAXTTL)                  | 1.2.0 | pre     | `int32_t` | packets | 0             | 0..      | RW  | GSD+  |
-| [`SRTO_MAXBW`](#SRTO_MAXBW)                            | 1.0.5 | pre     | `int64_t` | B/s     | -1            | -1..     | RW  | GSD   |
-| [`SRTO_MESSAGEAPI`](#SRTO_MESSAGEAPI)                  | 1.3.0 | pre     | `bool`    |         | true          |          | W   | GSD   |
-| [`SRTO_MINVERSION`](#SRTO_MINVERSION)                  | 1.3.0 | pre     | `int32_t` | version | 0             | *        | W   | GSD   |
-| [`SRTO_MSS`](#SRTO_MSS)                                |       | pre     | `int32_t` | bytes   | 1500          | 76..     | RW  | GSD   |
-| [`SRTO_NAKREPORT`](#SRTO_NAKREPORT)                    | 1.1.0 | pre     | `bool`    |         |  *            |          | RW  | GSD+  |
-| [`SRTO_OHEADBW`](#SRTO_OHEADBW)                        | 1.0.5 | post    | `int32_t` | %       | 25            | 5..100   | RW  | GSD   |
-| [`SRTO_PACKETFILTER`](#SRTO_PACKETFILTER)              | 1.4.0 | pre     | `string`  |         | ""            | [512]    | W   | GSD   |
-| [`SRTO_PASSPHRASE`](#SRTO_PASSPHRASE)                  | 0.0.0 | pre     | `string`  |         | ""            | [10..79] | W   | GSD   |
-| [`SRTO_PAYLOADSIZE`](#SRTO_PAYLOADSIZE)                | 1.3.0 | pre     | `int32_t` | bytes   | \*            | \*       | W   | GSD   |
-| [`SRTO_PBKEYLEN`](#SRTO_PBKEYLEN)                      | 0.0.0 | pre     | `int32_t` | bytes   | 0             | *        | RW  | GSD   |
-| [`SRTO_PEERIDLETIMEO`](#SRTO_PEERIDLETIMEO)            | 1.3.3 | pre     | `int32_t` | ms      | 5000          | 0..      | RW  | GSD+  |
-| [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY)                | 1.3.0 | pre     | `int32_t` | ms      | 0             | 0..      | RW  | GSD   |
-| [`SRTO_PEERVERSION`](#SRTO_PEERVERSION)                | 1.1.0 |         | `int32_t` | *       |               |          | R   | GS    |
-| [`SRTO_RCVBUF`](#SRTO_RCVBUF)                          |       | pre     | `int32_t` | bytes   | 8192 payloads | *        | RW  | GSD+  |
-| [`SRTO_RCVDATA`](#SRTO_RCVDATA)                        |       |         | `int32_t` | pkts    |               |          | R   | S     |
-| [`SRTO_RCVKMSTATE`](#SRTO_RCVKMSTATE)                  | 1.2.0 |         | `int32_t` | enum    |               |          | R   | S     |
-| [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY)                  | 1.3.0 | pre     | `int32_t` | msec    | *             | 0..      | RW  | GSD   |
-| [`SRTO_RCVSYN`](#SRTO_RCVSYN)                          |       | post    | `bool`    |         | true          |          | RW  | GSI   |
-| [`SRTO_RCVTIMEO`](#SRTO_RCVTIMEO)                      |       | post    | `int32_t` | ms      | -1            | -1, 0..  | RW  | GSI   |
-| [`SRTO_RENDEZVOUS`](#SRTO_RENDEZVOUS)                  |       | pre     | `bool`    |         | false         |          | RW  | S     |
-| [`SRTO_RETRANSMITALGO`](#SRTO_RETRANSMITALGO)          | 1.4.2 | pre     | `int32_t` |         | 0             | [0, 1]   | RW  | GSD   |
-| [`SRTO_REUSEADDR`](#SRTO_REUSEADDR)                    |       | pre     | `bool`    |         | true          |          | RW  | GSD   |
-| [`SRTO_SENDER`](#SRTO_SENDER)                          | 1.0.4 | pre     | `bool`    |         | false         |          | W   | S     |
-| [`SRTO_SNDBUF`](#SRTO_SNDBUF)                          |       | pre     | `int32_t` | bytes   | 8192 payloads | *        | RW  | GSD+  |
-| [`SRTO_SNDDATA`](#SRTO_SNDDATA)                        |       |         | `int32_t` | pkts    |               |          | R   | S     |
-| [`SRTO_SNDDROPDELAY`](#SRTO_SNDDROPDELAY)              | 1.3.2 | pre     | `int32_t` | ms      | *             | -1..     | W   | GSD+  |
-| [`SRTO_SNDKMSTATE`](#SRTO_SNDKMSTATE)                  | 1.2.0 | post    | `int32_t` | enum    |               |          | R   | S     |
-| [`SRTO_SNDSYN`](#SRTO_SNDSYN)                          |       | post    | `bool`    |         | true          |          | RW  | GSI   |
-| [`SRTO_SNDTIMEO`](#SRTO_SNDTIMEO)                      |       | post    | `int32_t` | ms      | -1            | -1..     | RW  | GSI   |
-| [`SRTO_STATE`](#SRTO_STATE)                            |       |         | `int32_t` | enum    |               |          | R   | S     |
-| [`SRTO_STREAMID`](#SRTO_STREAMID)                      | 1.3.0 | pre     | `string`  |         | ""            | [512]    | RW  | GSD   |
-| [`SRTO_TLPKTDROP`](#SRTO_TLPKTDROP)                    | 1.0.6 | pre     | `bool`    |         | *             |          | RW  | GSD   |
-| [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)                    | 1.3.0 | pre     | `int32_t` | enum    |`SRTT_LIVE`    | *        | W   | S     |
-| [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)                    | 0.0.0 | pre     | `bool`    |         | *             |          | W   | S     |
-| [`SRTO_UDP_RCVBUF`](#SRTO_UDP_RCVBUF)                  |       | pre     | `int32_t` | bytes   | 8192 payloads | *        | RW  | GSD+  |
-| [`SRTO_UDP_SNDBUF`](#SRTO_UDP_SNDBUF)                  |       | pre     | `int32_t` | bytes   | 65536         | *        | RW  | GSD+  |
-| [`SRTO_VERSION`](#SRTO_VERSION)                        | 1.1.0 |         | `int32_t` |         |               |          | R   | S     |
-
-### Option Descriptions
-
-#### SRTO_BINDTODEVICE
-
-| OptName               | Since | Binding | Type     | Units  | Default  | Range  | Dir |Entity|
-| --------------------- | ----- | ------- | -------- | ------ | -------- | ------ |-----|------|
-| `SRTO_BINDTODEVICE`   | 1.4.2 | pre     | `string` |        |          |        | RW  | GSD+ |
-
-Refers to the `SO_BINDTODEVICE` system socket option for `SOL_SOCKET` level.
-This effectively limits the packets received by this socket to only those
-that are targeted to that device. The device is specified by name passed as
-string. The setting becomes effective after binding the socket (including
-default-binding when connecting).
-
-NOTE: This option is only available on Linux and available there by default.
-On all other platforms setting this option will always fail.
-
-NOTE: With the default system configuration, this option is only available
-for a process that runs as root. Otherwise the function that applies the setting
-(`srt_bind`, `srt_connect` etc.) will fail.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_CONGESTION
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_CONGESTION` | 1.3.0 | pre     | `string`   |         | "live"    | *      | W   | S      |
-
-The type of congestion controller used for the transmission for that socket.
-
-Its type must be exactly the same on both connecting parties, otherwise the
-connection is rejected - **however** you may also change the value of this
-option for the accepted socket in the listener callback (see `srt_listen_callback`)
-if an appropriate instruction was given in the Stream ID.
-
-Currently supported congestion controllers are designated as "live" and "file"
-
-Note that it is not recommended to change this option manually, but you should
-rather change the whole set of options using the [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE) option.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_CONNTIMEO
-
-| OptName            | Since | Binding |   Type    | Units  | Default  | Range  | Dir | Entity |
-| ------------------ | ----- | ------- | --------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_CONNTIMEO`   | 1.1.2 | pre     | `int32_t` | msec   | 3000     | 0..    | W   | GSD+   |
-
-Connect timeout. This option applies to the caller and rendezvous connection
-modes. For the rendezvous mode (see `SRTO_RENDEZVOUS`) the effective connection timeout
-will be 10 times the value set with `SRTO_CONNTIMEO`.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_DRIFTTRACER
-
-| OptName           | Since | Binding | Type      | Units  | Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | --------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_DRIFTTRACER`| 1.4.2 | post    | `bool`    |        | true     |        | RW  | GSD    |
-
-Enables or disables time drift tracer (receiver).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_ENFORCEDENCRYPTION
-
-| OptName                    | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_ENFORCEDENCRYPTION`  | 1.3.2 | pre     | `bool`     |         | true      |        | W   | GSD    |
-
-This option enforces that both connection parties have the same passphrase
-set, or both do not set the passphrase, otherwise the connection is rejected.
-
-When this option is set to FALSE **on both connection parties**, the
-connection is allowed even if the passphrase differs on both parties,
-or it was set only on one party. Note that the party that has set a passphrase
-is still allowed to send data over the network. However, the receiver will not
-be able to decrypt that data and will not deliver it to the application. The
-party that has set no passphrase can send (unencrypted) data that will be
-successfully received by its peer.
-
-This option can be used in some specific situations when the user knows
-both parties of the connection, so there's no possible situation of a rogue
-sender and can be useful in situations where it is important to know whether a
-connection is possible. The inability to decrypt an incoming transmission can
-be then reported as a different kind of problem.
-
-**IMPORTANT**: There is unusual and unobvious behavior when this flag is TRUE
-on the caller and FALSE on the listener, and the passphrase was mismatched. On
-the listener side the connection will be established and broken right after,
-resulting in a short-lived "spurious" connection report on the listener socket.
-This way, a socket will be available for retrieval from an `srt_accept` call
-for a very short time, after which it will be removed from the listener backlog
-just as if no connection attempt was made at all. If the application is fast
-enough to react on an incoming connection, it will retrieve it, only to learn
-that it is already broken. This also makes possible a scenario where
-`SRT_EPOLL_IN` is reported on a listener socket, but then an `srt_accept` call
-reports an `SRT_EASYNCRCV` error. How fast the connection gets broken depends
-on the network parameters -- in particular, whether the `UMSG_SHUTDOWN` message
-sent by the caller is delivered (which takes one RTT in this case) or missed
-during the interval from its creation up to the connection timeout (default = 5
-seconds). It is therefore strongly recommended that you only set this flag to
-FALSE on the listener when you are able to ensure that it is also set to FALSE
-on the caller side.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_EVENT
-
-| OptName           | Since | Binding | Type      | Units  | Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | --------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_EVENT`      |       |         | `int32_t` | flags  |          |        | R   | S      |
-
-Returns bit flags set according to the current active events on the socket.
-
-Possible values are those defined in `SRT_EPOLL_OPT` enum (a combination of
-`SRT_EPOLL_IN`, `SRT_EPOLL_OUT` and `SRT_EPOLL_ERR`).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_FC
-
-| OptName           | Since | Binding | Type      | Units  | Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | --------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_FC`         |       | pre     | `int32_t` | pkts   | 25600    | 32..   | RW  | GSD    |
-
-Flight Flag Size (maximum number of bytes that can be sent without
-being acknowledged)
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_GROUPCONNECT
-
-| OptName              | Since | Binding | Type      | Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | --------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_GROUPCONNECT`  | 1.5.0 | pre     | `int32_t` |        | 0        | 0...1  | W   | S      |
-
-When this flag is set to 1 on a listener socket, it allows this socket to
-accept group connections. When set to the default 0, group connections will be
-rejected. Keep in mind that if the `SRTO_GROUPCONNECT` flag is set to 1 (i.e.
-group connections are allowed) `srt_accept` may return a socket **or** a group
-ID. A call to `srt_accept` on a listener socket that has group connections
-allowed must take this into consideration. It's up to the caller of this
-function to make this distinction and to take appropriate action depending on
-the type of entity returned.
-
-When this flag is set to 1 on an accepted socket that is passed to the
-listener callback handler, it means that this socket is created for a group
-connection and it will become a member of a group. Note that in this case
-only the first connection within the group will result in reporting from
-`srt_accept` (further connections are handled in the background), and this
-function will return the group, not this socket ID.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_GROUPSTABTIMEO
-
-| OptName               | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_GROUPSTABTIMEO` | 1.5.0 | pre     | `int32_t`  | ms     | 80       | 10-... | W   | GSD+   |
-
-This setting is used for groups of type `SRT_GTYPE_BACKUP`. It defines the stability
-timeout, which is the maximum interval between two consecutive packets retrieved from
-the peer on the currently active link. These two packets can be of any type,
-but this setting usually refers to control packets while the agent is a sender.
-Idle links exchange only keepalive messages once per second, so they do not
-count. Note that this option is meaningless on sockets that are not members of
-the Backup-type group.
-
-This value should be set with a thoroughly selected balance and correspond to
-the maximum stretched response time between two consecutive ACK messages. By default
-ACK messages are sent every 10ms (so this interval is not dependent on the network
-latency), and so should be the interval between two consecutive received ACK
-messages. Note, however, that the network jitter on the public internet causes
-these intervals to be stretched, even to multiples of that interval. Both large
-and small values of this option have consequences:
-
-Large values of this option prevent overreaction on highly stretched response
-times, but introduce a latency penalty - the latency must be greater
-than this value (otherwise switching to another link won't preserve
-smooth signal sending). Large values will also contribute to higher packet
-bursts sent at the moment when an idle link is activated.
-
-Smaller values of this option respect low latency requirements very
-well, but may cause overreaction on even slightly stretched response times. This is
-unwanted, as a link switch should ideally happen only when the currently active
-link is really broken, as every link switch costs extra overhead (it counts
-for 100% for a time of one ACK interval).
-
-Note that the value of this option is not allowed to exceed the value of
-`SRTO_PEERIDLETIMEO`. Usually it is only meaningful if you change the latter
-option, as the default value of it is way above any sensible value of
-`SRTO_GROUPSTABTIMEO`.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_GROUPTYPE
-
-| OptName              | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_GROUPTYPE`     | 1.5.0 | pre     | `int32_t`  | enum   |          |        | R   | S      |
-
-This option is read-only and it is intended to be called inside the listener
-callback handler (see `srt_listen_callback`). Possible values are defined in
-the `SRT_GROUP_TYPE` enumeration type.
-
-This option returns the group type that is declared in the incoming connection.
-If the incoming connection is not going to make a group-member connection, then
-the value returned is `SRT_GTYPE_UNDEFINED`. If this option is read in any other
-context than inside the listener callback handler, the value is undefined.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_INPUTBW
-
-| OptName          | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| ---------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_INPUTBW`   | 1.0.5 | post    | `int64_t`  | B/s    | 0        | 0..    | RW  | GSD    |
-
-This option is effective only if `SRTO_MAXBW` is set to 0 (relative). It
-controls the maximum bandwidth together with `SRTO_OHEADBW` option according
-to the formula: `MAXBW = INPUTBW * (100 + OHEADBW) / 100`. When this option
-is set to 0 (automatic) then the real INPUTBW value will be estimated from
-the rate of the input (cases when the application calls the `srt_send*`
-function) during transmission.
-
-*Recommended: set this option to the anticipated bitrate of your live stream
-and keep the default 25% value for `SRTO_OHEADBW`*.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_IPTOS
-
-| OptName          | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| ---------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_IPTOS`     | 1.0.5 | pre     | `int32_t`  |        | (system) | 0..255 | RW  | GSD    |
-
-IPv4 Type of Service (see `IP_TOS` option for IP) or IPv6 Traffic Class (see `IPV6_TCLASS`
-of IPv6) depending on socket address family. Applies to sender only.
-
-When *getting*, the returned value is the user preset for non-connected sockets
-and the actual value for connected sockets.
-
-*Sender*: user configurable, default: `0xB8`.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_IPTTL
-
-| OptName          | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| ---------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_IPTTL`     | 1.0.5 | pre     | `int32_t`  | hops   | (system) | 1..255 | RW  | GSD    |
-
-IPv4 Time To Live (see `IP_TTL` option for IP) or IPv6 unicast hops (see
-`IPV6_UNICAST_HOPS` for IPv6) depending on socket address family. Applies to sender only.
-
-When *getting*, the returned value is the user preset for non-connected sockets
-and the actual value for connected sockets.
-
-*Sender*: user configurable, default: 64
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_IPV6ONLY
-
-| OptName          | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| ---------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_IPV6ONLY`  | 1.4.0 | pre     | `int32_t`  |        | (system) | -1..1  | RW  | GSD    |
-
-Set system socket flag `IPV6_V6ONLY`. When set to 0 a listening socket binding an
-IPv6 address accepts also IPv4 clients (their addresses will be formatted as
-IPv4-mapped IPv6 addresses). By default (-1) this option is not set and the
-platform default value is used.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_ISN
-
-| OptName          | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| ---------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_ISN`       | 1.3.0 |         | `int32_t`  |        |          |        | R   | S      |
-
-The value of the ISN (Initial Sequence Number), which is the first sequence
-number put on the first UDP packets sent that are carrying an SRT data payload.
-
-*This value is useful for developers of some more complicated methods of flow
-control, possibly with multiple SRT sockets at a time. It is not intended to be
-used in any regular development.*
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_KMPREANNOUNCE
-
-| OptName               | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_KMPREANNOUNCE`  | 1.3.2 | pre     | `int32_t`  | pkts   | 0x1000   | 0.. *  | RW  | GSD    |
-
-The interval (defined in packets) between when a new Stream Encrypting Key
-(SEK) is sent and when switchover occurs. This value also applies to the
-subsequent interval between when switchover occurs and when the old SEK is
-decommissioned.
-
-At `SRTO_KMPREANNOUNCE` packets before switchover the new key is sent
-(repeatedly, if necessary, until it is confirmed by the receiver).
-
-At the switchover point (see `SRTO_KMREFRESHRATE`), the sender starts
-encrypting and sending packets using the new key. The old key persists in case
-it is needed to decrypt packets that were in the flight window, or
-retransmitted packets.
-
-The old key is decommissioned at `SRTO_KMPREANNOUNCE` packets after switchover.
-
-The allowed range for this value is between 1 and half of the current value of
-`SRTO_KMREFRESHRATE`. The minimum value should never be less than the flight
-window (i.e. the number of packets that have already left the sender but have
-not yet arrived at the receiver).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_KMREFRESHRATE
-
-| OptName               | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_KMREFRESHRATE`  | 1.3.2 | pre     | `int32_t`  | pkts   | 0x1000000| 0..    | RW  | GSD    |
-
-The number of packets to be transmitted after which the Stream Encryption Key
-(SEK), used to encrypt packets, will be switched to the new one. Note that
-the old and new keys live in parallel for a certain period of time (see
-`SRTO_KMPREANNOUNCE`) before and after the switchover.
-
-Having a preannounce period before switchover ensures the new SEK is installed
-at the receiver before the first packet encrypted with the new SEK is received.
-The old key remains active after switchover in order to decrypt packets that
-might still be in flight, or packets that have to be retransmitted.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_KMSTATE
-
-| OptName               | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_KMSTATE`        | 1.0.2 |         | `int32_t`  | enum   |          |        | R   | S      |
-
-Keying Material state. This is a legacy option that is equivalent to
-`SRTO_SNDKMSTATE`, if the socket has set `SRTO_SENDER` to true, and
-`SRTO_RCVKMSTATE` otherwise. This option is then equal to `SRTO_RCVKMSTATE`
-always if your application disregards possible cooperation with a peer older
-than 1.3.0, but then with the default value of `SRTO_ENFORCEDENCRYPTION` the
-value returned by both options is always the same. See [`SRT_KM_STATE`](#2-srt_km_state)
-for more details.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_LATENCY
-
-| OptName               | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_LATENCY`        | 1.0.2 | pre     | `int32_t`  | ms     | 120 *    | 0..    | RW  | GSD    |
-
-This option sets both [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY) and [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY)
-to the same value specified.
-
-Prior to SRT version 1.3.0 `SRTO_LATENCY` was the only option to set the latency.
-However it is effectively equivalent to setting `SRTO_PEERLATENCY` in the sending direction
-(see [`SRTO_SENDER`](#SRTO_SENDER)), and `SRTO_RCVLATENCY` in the receiving direction.
-SRT version 1.3.0 and higher support bidirectional transmission, so that each side can
-be sender and receiver at the same time, and `SRTO_SENDER` became redundant.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_LINGER
-
-| OptName              | Since | Binding | Type       | Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------ | -------- | ------ | --- | ------ |
-| `SRTO_LINGER`        |       | pre     | `linger`   | s      | on, 180  | 0..    | RW  | GSD    |
-
-Linger time on close (see [SO\_LINGER](http://man7.org/linux/man-pages/man7/socket.7.html)).
-
-*SRT recommended value*: off (0).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_LOSSMAXTTL
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_LOSSMAXTTL`    | 1.2.0 | pre     | `int32_t`  | packets | 0        | 0..    | RW  | GSD+   |
-
-The value up to which the *Reorder Tolerance* may grow. The *Reorder Tolerance*
-is the number of packets that must follow the experienced "gap" in sequence numbers
-of incoming packets so that the loss report is sent (in the hope that the gap is due
-to packet reordering rather than because of loss). The value of *Reorder Tolerance*
-starts from 0 and is set to a greater value when packet reordering is detected
-This happens when a "belated" packet, with sequence number older than the latest
-received, has been received, but without retransmission flag. When this is detected
-the *Reorder Tolerance* is set to the value of the interval between latest sequence
-and this packet's sequence, but not more than the value set by `SRTO_LOSSMAXTTL`.
-By default this value is set to 0, which means that this mechanism is off.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_MAXBW
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_MAXBW`         | 1.0.5 | pre     | `int64_t`  | B/s     | -1       | -1..   | RW  | GSD    |
-
-Maximum send bandwidth:
-
-- `-1`: infinite (the limit in Live Mode is 1 Gbps);
-- `0`: relative to input rate (see [`SRTO_INPUTBW`](#SRTO_INPUTBW));
-- `>0`: absolute limit in B/s.
-
-**NOTE**: This option has a default value of -1, regardless of the mode.
-For live streams it is typically recommended to set the value 0 here and rely
-on `SRTO_INPUTBW` and `SRTO_OHEADBW` options. However, if you want to do so,
-you should make sure that your stream has a fairly constant bitrate, or that
-changes are not abrupt, as high bitrate changes may work against the
-measurement. SRT cannot ensure that this is always the case for a live stream,
-therefore the default -1 remains even in live mode.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_MESSAGEAPI
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_MESSAGEAPI`    | 1.3.0 | pre     | `bool`     |         | true     |        | W   | GSD    |
-
-When set, this socket uses the Message API[\*], otherwise it uses the
-Stream API. Note that in live mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE) option) only the
-Message API is available. In File mode you can chose to use one of two modes
-(note that the default for this option is changed with `SRTO_TRANSTYPE`
-option):
-
-- **Stream API** (default for file mode): In this mode you may send
-as many data as you wish with one sending instruction, or even use dedicated
-functions that operate directly on a file. The internal facility will take care
-of any speed and congestion control. When receiving, you can also receive as
-many data as desired. The data not extracted will be waiting for the next call.
-There is no boundary between data portions in Stream mode.
-  
-- **Message API**: In this mode your single sending instruction passes exactly
-one piece of data that has boundaries (a message). Contrary to Live mode,
-this message may span multiple UDP packets, and the only size limitation
-is that it shall fit as a whole in the sending buffer. The receiver shall use
-as large a buffer as necessary to receive the message, otherwise reassembling
-and delivering the message might not be possible. When the message is not
-complete (not all packets received or there was a packet loss) it will not be
-copied to the application's buffer. Messages that are sent later, but were
-earlier reassembled by the receiver, will be delivered once ready, if the
-`inorder` flag was set to false.
-See [`srt_sendmsg`](https://github.com/Haivision/srt/blob/master/docs/API.md#sending-and-receiving)).
-  
-As a comparison to the standard system protocols, the Stream API does
-transmission similar to TCP, whereas the Message API functions like the
-SCTP protocol.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_MINVERSION
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_MINVERSION`    | 1.3.0 | pre     | `int32_t`  | version | 0        | *      | W   | GSD    |
-
-The minimum SRT version that is required from the peer. A connection to a
-peer that does not satisfy the minimum version requirement will be rejected.
-See [`SRTO_VERSION`](#SRTO_VERSION) for the version format.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_MSS
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_MSS`           |       | pre     | `int32_t`  | bytes   | 1500     | 76..   | RW  | GSD    |
-
-Maximum Segment Size. Used for buffer allocation and rate calculation using
-packet counter assuming fully filled packets. Each party can set its own MSS
-value independently. During a handshake the parties exchange MSS values, and
-the lowest is used.
-
-*Generally on the internet MSS is 1500 by default. This is the maximum
-size of a UDP packet and can be only decreased, unless you have some unusual
-dedicated network settings. MSS is not to be confused with the size of the UDP
-payload or SRT payload - this size is the size of the IP packet, including the
-UDP and SRT headers*
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_NAKREPORT
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_NAKREPORT`     | 1.1.0 | pre     | `bool`     |         |  *       |        | RW  | GSD+   |
-
-When set to true, every report for a detected loss will be repeated when the
-timeout for the expected retransmission of this loss has expired and the
-missing packet still wasn't recovered, or wasn't conditionally dropped (see
-[`SRTO_TLPKTDROP`](#SRTO_TLPKTDROP)).
-
-The default is true for Live mode, and false for File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_OHEADBW
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_OHEADBW`       | 1.0.5 | post    | `int32_t`  | %       | 25       | 5..100 | RW  | GSD    |
-
-Recovery bandwidth overhead above input rate (see [`SRTO_INPUTBW`](#SRTO_INPUTBW)),
-in percentage of the input rate. It is effective only if `SRTO_MAXBW` is set to 0.
-
-*Sender*: user configurable, default: 25%.
-
-Recommendations:
-
-- Overhead is intended to give you extra bandwidth for the case when a packet
-has taken part of the bandwidth, but then was lost and has to be retransmitted.
-Therefore the effective maximum bandwidth should be appropriately higher than
-your stream's bitrate so that there's some room for retransmission, but still
-limited so that the retransmitted packets don't cause the bandwidth usage to
-skyrocket when larger groups of packets are lost
-
-- Don't configure it too low and avoid 0 in the case when you have the
-`SRTO_INPUTBW` option set to 0 (automatic). Otherwise your stream will choke
-and break quickly at any rise in packet loss.
-
-- ***To do: set-only; get should be supported.***
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PACKETFILTER
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PACKETFILTER`  | 1.4.0 | pre     | `string`   |         |  ""      | [512]  | W   | GSD    |
-
-Set up the packet filter. The string must match appropriate syntax for packet
-filter setup.
-
-As there can only be one configuration for both parties, it is recommended that
-one party defines the full configuration while the other only defines the matching
-packet filter type (for example, one sets `fec,cols:10,rows:-5,layout:staircase`
-and the other just `fec`). Both parties can also set this option to the same value.
-The packet filter function will attempt to merge configuration definitions, but if
-the options specified are in conflict, the connection will be rejected.
-
-For details, see [Packet Filtering & FEC](packet-filtering-and-fec.md).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PASSPHRASE
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PASSPHRASE`    | 0.0.0 | pre     | `string`   |         | ""       |[10..79]| W   | GSD    |
-
-Sets the passphrase for encryption. This enables encryption on this party (or
-disables it, if an empty passphrase is passed).
-
-The passphrase is the shared secret between the sender and the receiver. It is
-used to generate the Key Encrypting Key using [PBKDF2](http://en.wikipedia.org/wiki/PBKDF2)
-(Password-Based Key Derivation Function 2). It is used on the receiver only if
-the received data is encrypted.
-
-Note that since the introduction of bidirectional support, there's only one
-initial SEK to encrypt the stream (new keys after refreshing will be updated
-independently), and there's no distinction between "service party that defines
-the password" and "client party that is required to set matching password" - both
-parties are equivalent, and in order to have a working encrypted connection, they
-have to simply set the same passphrase. Otherwise the connection is rejected by
-default (see also [`SRTO_ENFORCEDENCRYPTION`](#SRTO_ENFORCEDENCRYPTION)).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PAYLOADSIZE
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PAYLOADSIZE`   | 1.3.0 | pre     | `int32_t`  | bytes   | \*       | \*     | W   | GSD    |
-
-Sets the maximum declared size of a single call to sending function in Live
-mode. When set to 0, there's no limit for a single sending call.
-
-For Live mode: Default value is 1316, but can be increased up to 1456. Note that
-with the `SRTO_PACKETFILTER` option additional header space is usually required,
-which decreases the maximum possible value for `SRTO_PAYLOADSIZE`.
-
-For File mode: Default value is 0 and it's recommended not to be changed.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PBKEYLEN
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PBKEYLEN`      | 0.0.0 | pre     | `int32_t`  | bytes   | 0        | *      | RW  | GSD    |
-
-Sender encryption key length.
-
-Possible values:
-
-- 0 =`PBKEYLEN` (default value)
-- 16 = AES-128 (effective value)
-- 24 = AES-192
-- 32 = AES-256
-
-The use is slightly different in 1.2.0 (HSv4), and since 1.3.0 (HSv5):
-
-- **HSv4**: This is set on the sender and enables encryption, if not 0. The receiver
-shall not set it and will agree on the length as defined by the sender.
-
-- **HSv5**: The "default value" for `PBKEYLEN` is 0, which means that the
-`PBKEYLEN` won't be advertised. The "effective value" for `PBKEYLEN` is 16, but
-this applies only when neither party has set the value explicitly (i.e. when
-both are initially at the default value of 0). If any party *has* set an
-explicit value (16, 24, 32) it will be advertised in the handshake. If the other
-party remains at the default 0, it will accept the peer's value. The situation
-where both parties set a value should be treated carefully. Actually there are
-three intended methods of defining it, and all other uses are considered
-undefined behavior:
-  
-  - **Unidirectional**: the sender shall set `PBKEYLEN` and the receiver shall
-  not alter the default value 0. The effective `PBKEYLEN` will be the one set
-  on the sender. The receiver need not know the sender's `PBKEYLEN`, just the
-  passphrase, `PBKEYLEN` will be correctly passed.
-
-  - **Bidirectional in Caller-Listener arrangement**: it is recommended to use
-  a rule whereby you will be setting the `PBKEYLEN` exclusively either on the
-  Listener or on the Caller. The value set on the Listener will win, if set on
-  both parties.
-
-  - **Bidirectional in Rendezvous arrangement**: you have to know the passphrases
-  for both parties, as well as `PBKEYLEN`. Set `PBKEYLEN` to the same value on
-  both parties (or leave the default value on both parties, which will
-  result in 16)
-
-  - **Unwanted behavior cases**: if both parties set `PBKEYLEN` and the value
-  on both sides is different, the effective `PBKEYLEN` will be the one that is
-  set on the Responder party, which may also override the `PBKEYLEN` 32 set by
-  the sender to value 16 if such value was used by the receiver. The Responder
-  party is the Listener in a Caller-Listener arrangement. In Rendezvous it's a
-  matter of luck which party becomes the Responder.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PEERIDLETIMEO
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PEERIDLETIMEO` | 1.3.3 | pre     | `int32_t`  | ms      | 5000     | 0..    | RW  | GSD+   |
-
-The maximum time in `[ms]` to wait until another packet is received from a peer
-since the last such packet reception. If this time is passed, the connection is
-considered broken on timeout.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PEERLATENCY
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PEERLATENCY`   | 1.3.0 | pre     | `int32_t`  | ms      | 0        | 0..    | RW  | GSD    |
-
-The latency value (as described in [`SRTO_RCVLATENCY`](#SRTO_RCVLATENCY)) provided by the sender
-side as a minimum value for the receiver.
-
-Reading the value of the option on an unconnected socket reports the configured value.
-Reading the value on a connected socket reports the effective receiver buffering latency of the peer.
-
-**The `SRTO_PEERLATENCY` option in versions prior to 1.3.0 is only available as**
-[`SRTO_LATENCY`](#SRTO_LATENCY).
-
-See also [`SRTO_LATENCY`](#SRTO_LATENCY).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_PEERVERSION
-
-| OptName              | Since | Binding | Type       |  Units  | Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_PEERVERSION`   | 1.1.0 |         | `int32_t`  | *       |          |        | R   | GS     |
-
-SRT version used by the peer. The value 0 is returned if not connected, SRT
-handshake not yet performed (HSv4 only), or if peer is not SRT.
-See [`SRTO_VERSION`](#SRTO_VERSION) for the version format.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVBUF
-
-| OptName              | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVBUF`        |       | pre     | `int32_t`  | bytes   | 8192 bufs  | *      | RW  | GSD+   |
-
-Receive Buffer Size, in bytes. Note, however, that the internal setting of this
-value is in the number of buffers, each one of size equal to SRT payload size,
-which is the value of `SRTO_MSS` decreased by UDP and SRT header sizes (28 and 16).
-The value set here will be effectively aligned to the multiple of payload size.
-
-- **Minimum value**: 32 buffers (46592 with default value of `SRTO_MSS`).
-
-- **Maximum value**: [`SRTO_FC`](#SRTO_FC) number of buffers (receiver buffer must not be greater
-than the Flight Flag size).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVDATA
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVDATA`    |       |         | `int32_t`  | pkts    |            |        | R   | S      |
-
-Size of the available data in the receive buffer.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVKMSTATE
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVKMSTATE` | 1.2.0 |         | `int32_t`  | enum    |            |        | R   | S      |
-
-KM state on the agent side when it's a receiver.
-
-Values defined in enum [`SRT_KM_STATE`](#srt_km_state).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVLATENCY
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVLATENCY` | 1.3.0 | pre     | `int32_t`  | ms      | *          | 0..    | RW  | GSD    |
-
-The latency value in the receiving direction of the socket.
-This value is only significant when [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE) is enabled.
-
-**Default value**: 120 ms (depicted as 0) in Live mode, 0 in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
-
-The latency value defines the **minimum** receiver buffering delay before delivering an SRT data packet
-from a receiving SRT socket to a receiving application. The provided value is used in the connection establishment (handshake exchange) stage
-to fix the end-to-end latency of the transmission. The effective end-to-end latency `L` will be fixed
-as the network transmission time of the final handshake packet (~1/2 RTT) plus the **negotiated** latency value `Ln`.
-Data packets will stay in the receiver buffer for at least `L` microseconds since the timestamp of the
-packet, independent of the actual network transmission times (RTT variations) of these packets.
-
-The actual value of the receiver buffering delay `Ln` (the negotiated latency) used on a connection
-is determined by the negotiation in the connection establishment (handshake exchange) phase as the maximum of the
-`SRTO_RCVLATENCY` value and the value of [`SRTO_PEERLATENCY`](#SRTO_PEERLATENCY) set by the peer.
-
-Reading the `SRTO_RCVLATENCY` value on a socket after the connection is established provides the actual (negotiated)
-latency value `Ln`.
-
-The receiver's buffer must be large enough to store the `L` segment of the stream,
-i.e. `L × Bitrate` bytes. Refer to [`SRTO_RCVBUF`](#SRTO_RCVBUF).
-
-The sender's buffer must be large enough to store a packet up until it is either delivered (and acknowledged)
-or dropped by the sender due to it becoming too late to be delivered.
-In other words, `D × Bitrate` bytes, where `D` is the sender's drop delay value configured with [`SRTO_SNDDROPDELAY`](#SRTO_SNDDROPDELAY).
-
-Buffering of data packets on the receiving side makes it possible to recover from packet losses using the ARQ
-(Automatic Repeat Request) technique, and to deal with varying RTT times (network jitter) in the network, providing
-a (close to) **constant end-to-end latency of the transmission**.
-
-See also [`SRTO_LATENCY`](#SRTO_LATENCY).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVSYN
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVSYN`     |       | post    | `bool`     |         | true       |        | RW  | GSI    |
-
-When true, sets blocking mode on reading function when it's not ready to
-perform the operation. When false ("non-blocking mode"), the reading function
-will in this case report error `SRT_EASYNCRCV` and return immediately. Details
-depend on the tested entity:
-
-On a connected socket or group this applies to a receiving function
-(`srt_recv` and others) and a situation when there are no data available for
-reading. The readiness state for this operation can be tested by checking the
-`SRT_EPOLL_IN` flag on the aforementioned socket or group.
-
-On a freshly created socket or group that is about to be connected to a peer
-listener this applies to any `srt_connect` call (and derived), which in
-"non-blocking mode" always returns immediately. The connected state for that
-socket or group can be tested by checking the `SRT_EPOLL_OUT` flag. Note
-that a socket that failed to connect doesn't change the `SRTS_CONNECTING`
-state and can be found out only by testing the `SRT_EPOLL_ERR` flag.
-
-On a listener socket this applies to `srt_accept` call. The readiness state
-for this operation can be tested by checking the `SRT_EPOLL_IN` flag on
-this listener socket. This flag is also derived from the listener socket
-by the accepted socket or group, although the meaning of this flag is
-effectively different.
-
-Note that when this flag is set only on a group, it applies to a
-specific receiving operation being done on that group (i.e. it is not
-derived from the socket of which the group is a member).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RCVTIMEO
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RCVTIMEO`   |       | post    | `int32_t`  | ms      | -1         | -1, 0..| RW  | GSI    |
-
-Limits the time up to which the receiving operation will block (see
-[`SRTO_RCVSYN`](#SRTO_RCVSYN) for details), such that when this time is exceeded,
-it will behave as if in "non-blocking mode". The -1 value means no time limit.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RENDEZVOUS
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_RENDEZVOUS` |       | pre     | `bool`     |         | false      |        | RW  | S      |
-
-Use Rendezvous connection mode (both sides must set this and both must use the
-procedure of `srt_bind` and then `srt_connect` (or `srt_rendezvous`) to one another.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_RETRANSMITALGO
-
-| OptName               | Since | Binding | Type      | Units  | Default | Range  | Dir | Entity |
-| --------------------- | ----- | ------- | --------- | ------ | ------- | ------ | --- | ------ |
-| `SRTO_RETRANSMITALGO` | 1.4.2 | pre     | `int32_t` |        | 0       | [0, 1] | RW  | GSD    |
-
-Retransmission algorithm to use (SENDER option):
-
-- 0 - Default (retransmit on every loss report).
-- 1 - Reduced retransmissions (not more often than once per RTT); reduced
-  bandwidth consumption.
-
-This option is effective only on the sending side. It influences the decision
-as to whether a particular reported lost packet should be retransmitted at a
-certain time or not.
-
-The reduced retransmission algorithm (`SRTO_RETRANSMITALGO=1`) is only operational when receiver sends
-Periodic NAK reports. See [SRTO_NAKREPORT](#SRTO_NAKREPORT).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_REUSEADDR
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_REUSEADDR`  |       | pre     | `bool`     |         | true       |        | RW  | GSD    |
-
-When true, allows the SRT socket to use the binding address used already by
-another SRT socket in the same application. Note that SRT socket uses an
-intermediate object called Multiplexer to access the underlying UDP sockets,
-so multiple SRT sockets may share one UDP socket, and the packets received by this
-UDP socket will be correctly dispatched to the SRT socket to which they are
-currently destined. This has some similarities to the `SO_REUSEADDR` system socket
-option, although it's only used inside SRT.
-
-*TODO: This option weirdly only allows the socket used in **bind()** to use the
-local address that another socket is already using, but not to disallow another
-socket in the same application to use the binding address that the current
-socket is already using. What it actually changes is that when given an address in
-**bind()** is already used by another socket, this option will make the binding
-fail instead of adding the socket to the shared group of that socket that
-already has bound this address - but it will not disallow another socket to reuse
-its address.*
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SENDER
-
-| OptName           | Since | Binding | Type       |  Units  |   Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | ---------- | ------ | --- | ------ |
-| `SRTO_SENDER`     | 1.0.4 | pre     | `bool`     |         | false      |        | W   | S      |
-
-Set sender side. The side that sets this flag is expected to be a sender. This
-flag is only required when communicating with a receiver that uses SRT version
-less than 1.3.0 (and hence *HSv4* handshake), in which case if not set properly,
-the TSBPD mode (see [`SRTO_TSBPDMODE`](#SRTO_TSBPDMODE)) or encryption will not
-work. Setting `SRTO_MINVERSION` to 1.3.0 is therefore recommended.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDBUF
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDBUF`     |       | pre     | `int32_t`  | bytes   |8192 bufs  | *      | RW  | GSD+   |
-
-Sender Buffer Size. See [`SRTO_RCVBUF`](#SRTO_RCVBUF) for more information.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDDATA
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDDATA`    |       |         | `int32_t`  | pkts    |           |        | R   | S      |
-
-Size of the unacknowledged data in send buffer.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDDROPDELAY
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDDROPDELAY`  | 1.3.2 | pre     | `int32_t`  | ms      | *         | -1..   | W   | GSD+   |
-
-Sets an extra delay before `TLPKTDROP` is triggered on the data sender.
-This delay is added to the default drop delay time interval value. Keep in mind
-that the longer the delay, the more probable it becomes that packets would be
-retransmitted uselessly because they will be dropped by the receiver anyway.
-
-`TLPKTDROP` discards packets reported as lost if it is already too late to send
-them (the receiver would discard them even if received). The delay before the
-`TLPKTDROP` mechanism is triggered consists of the SRT latency (`SRTO_PEERLATENCY`),
-plus `SRTO_SNDDROPDELAY`, plus `2 * interval between sending ACKs` (where the
-default `interval between sending ACKs` is 10 milliseconds).
-The minimum delay is `1000 + 2 * interval between sending ACKs` milliseconds.
-
-**Special value -1**: Do not drop packets on the sender at all (retransmit them
-always when requested).
-
-**Default:** 0 in Live mode, -1 in File mode.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDKMSTATE
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDKMSTATE`    | 1.2.0 | post    | `int32_t`  |  enum   |           |        | R   | S      |
-
-Peer KM state on receiver side for `SRTO_KMSTATE`
-
-Values defined in enum [`SRT_KM_STATE`](#srt_km_state).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDSYN
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDSYN`        |       | post    | `bool`     |         | true      |        | RW  | GSI    |
-
-When true, sets blocking mode on writing function when it's not ready to
-perform the operation. When false ("non-blocking mode"), the writing function
-will in this case report error `SRT_EASYNCSND` and return immediately.
-
-On a connected socket or group this applies to a sending function
-(`srt_send` and others) and a situation when there's no free space in
-the sender buffer, caused by inability to send all the scheduled data over
-the network. Readiness for this operation can be tested by checking the
-`SRT_EPOLL_OUT` flag.
-
-On a freshly created socket or group it will have no effect until the socket
-enters a connected state.
-
-On a listener socket it will be derived by the accepted socket or group,
-but will have no effect on the listener socket itself.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_SNDTIMEO
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_SNDTIMEO`      |       | post    | `int32_t`  | ms      | -1        | -1..   | RW  | GSI    |
-
-limit the time up to which the sending operation will block (see
-`SRTO_SNDSYN` for details), so when this time is exceeded, it will behave as
-if in "non-blocking mode". The -1 value means no time limit.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_STATE
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_STATE`         |       |         | `int32_t`  |  enum   |           |        | R   | S      |
-
-Returns the current socket state, same as `srt_getsockstate`.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_STREAMID
-
-| OptName              | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| -------------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_STREAMID`      | 1.3.0 | pre     | `string`   |         | ""        | [512]  | RW  | GSD    |
-
-- A string that can be set on the socket prior to connecting. The listener side 
-will be able to retrieve this stream ID from the socket that is returned from 
-`srt_accept` (for a connected socket with that stream ID). You usually use SET 
-on the socket used for `srt_connect`, and GET on the socket retrieved from 
-`srt_accept`. This string can be used completely free-form. However, it's highly 
-recommended to follow the [SRT Access Control guidlines](AccessControl.md).
-
-- As this uses internally the `std::string` type, there are additional functions
-for it in the legacy/C++ API (udt.h): `srt::setstreamid` and `srt::getstreamid`.
-
-- This option is not useful for a Rendezvous connection, since one side would
-override the value from the other side resulting in an arbitrary winner. Also
-in this connection both peers are known to one another and both have equivalent 
-roles in the connection.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_TLPKTDROP
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_TLPKTDROP`  | 1.0.6 | pre     | `bool`     |         | *         |        | RW  | GSD    |
-
-Too-late Packet Drop. When enabled on receiver, it skips missing packets that
-have not been delivered in time and delivers the subsequent packets to the
-application when their time-to-play has come. It also sends a fake ACK to the
-sender. When enabled on sender and enabled on the receiving peer, sender drops
-the older packets that have no chance to be delivered in time. It is automatically
-enabled in sender if receiver supports it.
-
-**Default:** true in Live mode, false in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE))
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_TRANSTYPE
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_TRANSTYPE`  | 1.3.0 | pre     | `int32_t`  |  enum   |`SRTT_LIVE`| \*     | W   | S      |
-
-Sets the transmission type for the socket, in particular, setting this option
-sets multiple other parameters to their default values as required for a
-particular transmission type.
-
-Values defined by enum `SRT_TRANSTYPE` (see above for possible values)
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_TSBPDMODE
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_TSBPDMODE`  | 0.0.0 | pre     | `bool`     |         | \*        |        | W   | S      |
-
-When true, use Timestamp-based Packet Delivery mode. In this mode the
-packet's time is assigned at the sending time (or allowed to be predefined),
-transmitted in the packet's header, and then restored on the receiver side so that
-the time intervals between consecutive packets are preserved when delivering to
-the application.
-
-**Default:** true in Live mode, false in File mode (see [`SRTO_TRANSTYPE`](#SRTO_TRANSTYPE)).
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_UDP_RCVBUF
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_UDP_RCVBUF` |       | pre     | `int32_t`  | bytes   | 8192 bufs | *      | RW  | GSD+   |
-
-UDP Socket Receive Buffer Size. Configured in bytes, maintained in packets
-based on MSS value. Receive buffer must not be greater than FC size.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_UDP_SNDBUF
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_UDP_SNDBUF` |       | pre     | `int32_t`  | bytes   | 65536     | *      | RW  | GSD+   |
-
-UDP Socket Send Buffer Size. Configured in bytes, maintained in packets based
-on `SRTO_MSS` value.
-
-[Return to list](#list-of-options)
-
----
-
-#### SRTO_VERSION
-
-| OptName           | Since | Binding | Type       |  Units  |  Default  | Range  | Dir | Entity |
-| ----------------- | ----- | ------- | ---------- | ------- | --------- | ------ | --- | ------ |
-| `SRTO_VERSION`    | 1.1.0 |         | `int32_t`  |         |           |        | R   | S      |
-
-Local SRT version. This is the highest local version supported if not
-connected, or the highest version supported by the peer if connected.
-
-The version format in hex is `0x00XXYYZZ` for x.y.z in human readable form.
-For example, version 1.4.2 is encoded as `0x010402`.
-
-[Return to list](#list-of-options)
-
----
diff --git a/docs/AccessControl.md b/docs/AccessControl.md
deleted file mode 100644
index df35e662c..000000000
--- a/docs/AccessControl.md
+++ /dev/null
@@ -1,431 +0,0 @@
-# SRT Access Control Guidelines
-
-## Motivation
-
-One type of information that can be interchanged when a connection is being
-established in SRT is "Stream ID", which can be used in a caller-listener
-connection layout. This is a string of maximum 512 characters set on the caller
-side. It can be retrieved at the listener side on the newly accepted socket
-through a socket option (see `SRTO_STREAMID` in [API.md](API.md)).
-
-As of SRT version 1.3.3 a callback can be registered on the listener socket for
-an application to make decisions on incoming caller connections. This callback,
-among others, is provided with the value of Stream ID from the incoming
-connection. Based on this information, the application can accept or reject the
-connection, select the desired data stream, or set an appropriate passphrase for
-the connection.
-
-## Purpose
-
-The Stream ID value can be used as free-form, but there is a recommended
-convention so that all SRT users speak the same language. The intent of the
-convention is to:
-
-- promote readability and consistency among free-form names
-- interpret some typical data in the key-value style
-
-In short,
-
-1. `SRTO_STREAMID` is designed for a caller (client) to be able to identify itself, and state what it wants.
-2. `srt_listen_callback(...)` function is used by a listener (server) to check what a caller (client) has provided in `SRTO_STREAMID` **before** the connection is established.
-For example, the listener (server) can check if it knows the user and set the corresponding passphrase for a connection to be accepted.
-3. Even if `srt_listen_callback(...)` accepts the connection, SRT will still have one more step to check the PASSPHRASE, and reject on mismatch.
-If a correct passphrase is not provided by the client (caller), the request from caller will be rejected by SRT library (not application or programmer).
-
-**Note!** `srt_listen_callback(...)` can't check the passphrase directly for security reasons. 
-The only way to make the app check the passphrase is to set the passphrase on the socket by using the `SRTO_PASSPHRASE` option. This lets SRT to reject connection on mismatch.
-
-## Character Encoding
-
-The Stream ID uses UTF-8 encoding.
-
-## General Syntax
-
-This recommended syntax starts with the characters known as an executable
-specification in POSIX: `#!`.
-
-The next two characters are:
-
-- `:` - this marks the YAML format, the only one currently used
-- The content format, which is either:
-  - `:` - the comma-separated keys with no nesting
-  - `{` - like above, but nesting is allowed and must end with `}`
-
-(Nesting means that you can have multiple level brace-enclosed parts inside.)
-
-The form of the key-value pair is:
-
-```js
-key1=value1,key2=value2...
-```
-
-## Standard Keys
-
-Beside the general syntax, there are several top-level keys treated as standard
-keys. All single letter key definitions, including those not listed in this section,
-are reserved for future use. Users can additionally use custom key definitions
-with `user_*` or `companyname_*` prefixes, where `user` and `companyname` are
-to be replaced with an actual user or company name.
-
-The existing key values must not be extended, and must not differ from those described in this section.
-
-The following keys are standard:
-
-- `u`: **User Name**, or authorization name, that is expected to control which
-password should be used for the connection. The application should interpret
-it to distinguish which user should be used by the listener party to set up the
-password.
-- `r`: **Resource Name** identifies the name of the resource and facilitates
-selection should the listener party be able to serve multiple resources.
-- `h`: **Host Name** identifies the hostname of the resource. For example,
-to request a stream with the URI `somehost.com/videos/querry.php?vid=366` the
-`hostname` field should have `somehost.com`, and the resource name can have
-`videos/querry.php?vid=366` or simply `366`. Note that this is still a key to be
-specified explicitly. Support tools that apply simplifications and URI extraction
-are expected to insert only the host portion of the URI here.
-- `s`: **Session ID** is a temporary resource identifier negotiated with
-the server, used just for verification. This is a one-shot identifier, invalidated
-after the first use. The expected usage is when details for the resource and
-authorization are negotiated over a separate connection first, and then the
-session ID is used here alone.
-- `t`: **Type** specifies the purpose of the connection. Several standard
-types are defined, but users may extend the use:
-  - `stream` (default, if not specified): for exchanging the user-specified
-  payload for an application-defined purpose
-  - `file`: for transmitting a file, where `r` is the filename
-  - `auth`: for exchanging sensible data. The `r` value states its purpose.
-  No specific possible values for that are known so far (FUTURE USE]
-- `m`: **Mode** expected for this connection:
-  - `request` (default): the caller wants to receive the stream
-  - `publish`: the caller wants to send the stream data
-  - `bidirectional`:  bidirectional data exchange is expected
-
-Note that `m` is not required in the case where you don't use `streamid` to
-distinguish authorization or resources, and your caller is expected to send the
-data. This is only for cases where the listener can handle various purposes of the
-connection and is therefore required to know what the caller is attempting to do.
-
-Examples:
-
-```js
-#!::u=admin,r=bluesbrothers1_hi
-```
-
-This specifies the username and the resource name of the stream to be served
-to the caller.
-
-```js
-#!::u=johnny,t=file,m=publish,r=results.csv
-```
-
-This specifies that the file is expected to be transmitted from the caller to
-the listener and its name is `results.csv`.
-
-### Rejection codes
-
-The listener callback handler is also able to decide about rejecting the
-incoming connection. In a normal situation, the rejection code is predefined
-as `SRT_REJ_RESOURCE`. The handler can, however, set its own rejection
-code. There are two number spaces intended for this purpose (as the range
-below `SRT_REJC_PREDEFINED` is reserved for internal codes):
-
-- `SRT_REJC_PREDEFINED` and above: predefined errors. Errors from this range
-(that is, below `SRT_REJC_USERDEFINED`) have their definitions provided in
-the `access_control.h` public header file. The intention is that applications
-using these codes understand the situation described by these codes standard
-way.
-
-- `SRT_REJC_USERDEFINED` and above: to be freely defined by the application.
-Codes from this range can be only understood if each application knows the
-code definitions of the other. These codes should be used only after making
-sure that both applications understood them.
-
-The intention for the predefined codes is to be consistent with the HTTP
-standard codes. Therefore the following sub-ranges are used:
-
-- 0 - 99: Reserved for unique SRT-specific codes (unused by HTTP)
-- 100 - 399: Info, Success and Redirection in HTTP, unused in SRT
-- 400 - 599: Client and server errors in HTTP, adopted by SRT
-- 600 - 999: unused in SRT
-
-Such a code can be set by using the `srt_setrejectreason` function.
-
-The SRT-specific codes are:
-
-#### SRT_REJX_FALLBACK
-
-This code should be set by the callback handler in the beginning in case
-the application needs to be informed that the callback handler
-actually has interpreted the incoming connection, but hasn't set a
-more appropriate code describing the situation.
-
-#### SRT_REJX_KEY_NOTSUP
-
-Indicates there was a key specified in the StreamID string that this application
-doesn't support. Note that it's not obligatory for the application to
-react this way - it may chose to ignore unknown keys completely, or
-to have some keys in the ignore list (which it won't interpret, but tolerate)
-while rejecting any others. It is also up to the application
-to decide to return this specific error, or more generally report
-the syntax error with `SRT_REJX_BAD_REQUEST`.
-
-#### SRT_REJX_FILEPATH
-
-The resource type designates a file, and the path either has the wrong syntax
-or is not found. In the case where `t=file`, the path should be specified under
-the `r` key, and the file specified there must be able to be saved this way.
-It's up to the application to decide how to treat this path, how to parse it,
-and what this path specifically means. For the `r` key, the application should
-at least handle the single filename, and have storage space available to save
-it (provided a file of the same name does not already exist there).  The
-application should decide whether and how to handle all other situations (like
-directory path, special markers in the path to be interpreted by the
-application, etc.), or to report this error.
-
-#### SRT_REJX_HOSTNOTFOUND
-
-The host specified in the `h` key cannot be identified. The `h` key is
-generally for a situation when you have multiple DNS names for a host,
-so an application may want to extract the name from the URI and set it
-to `h` key so that the application can distinguish the request also by
-the target host name. The application may however limit the number of
-recognized services by host name to some predefined names and not
-handle the others, even if this is properly resolved by DNS. In this
-case it should report this error.
-
-The other error codes are HTTP codes adopted for SRT:
-
-#### SRT_REJX_BAD_REQUEST
-
-General syntax error. This can be reported in any case when parsing
-the StreamID contents failed, or it cannot be properly interpreted.
-
-#### SRT_REJX_UNAUTHORIZED
-
-Authentication failed, which makes the client unauthorized to access the
-resource. This error, however, confirms that the syntax is correct and
-the resource has been properly identified. Note that this cannot be
-reported when you use a simple user-password authentication
-method because in this case the password is verified only after the
-listener callback handler accepts the connection. This error is rather
-intended to be reported in case of `t=auth` when the authentication
-process has generated some valid session ID, but then the session
-connection has specified a resource that is not within the frames
-of that authentication.
-
-#### SRT_REJX_OVERLOAD
-
-The server is too heavily loaded to process your request, or you
-have exceeded credits for accessing the service and the resource.
-In HTTP the description mentions payment for a service, but
-it is also used by some services for general "credit" management
-for a client. In SRT it should be used when your service is doing
-any kind of credit management to limit access to selected clients
-that "have" enough credit, even if the credit is something the client
-can recharge itself, or that can be granted depending on available
-service resources.
-
-#### SRT_REJX_FORBIDDEN
-
-Access denied to the resource for any reason. This error is
-independent of an authorization or authentication error (as reported
-by `SRT_REJX_UNAUTHORIZED`). The application can decide which
-is more appropriate. This error is usually intended for
-a resource that should only be accessed after a successful
-authorization over a separate auth-only connection, where the query
-in StreamID has correctly specified the resource identity and mode,
-but the session ID (in the `s` key) is either (a) not specified, or (b) does
-specify a valid session, but the authorization region for this
-session does not embrace the specified resource.
-
-#### SRT_REJX_NOTFOUND
-
-The resource specified in the `r` key (in combination with the `h` key)
-is not found at this time. This error should be only reported if the
-information about resource accessibility is allowed to be publicly
-visible. Otherwise the application might report authorization
-errors.
-
-#### SRT_REJX_BAD_MODE
-
-The mode specified in the `m` key in StreamID is not supported for this request.
-This may apply to read-only or write-only resources, as well for when interactive
-(bidirectional) access is not valid for a resource.
-
-#### SRT_REJX_UNACCEPTABLE
-
-Applies when the parameters specified in SocketID cannot be satisfied for the
-requested resource, or when `m=publish` but the data format is not acceptable.
-This is a general error reporting an unsupported format for data that appears to 
-be wrong when sending, or a restriction on the data format (as specified in the 
-details of the resource specification) such that it cannot be provided 
-when receiving.
-
-#### SRT_REJX_CONFLICT
-
-The resource being accessed (as specified by `r` and `h` keys) is locked for
-modification. This error should only be reported for `m=publish` when the
-resource being accessed is read-only because another client (not necessarily
-connected through SRT):
-
-- is currently publishing into this resource
-- has reserved this resource ID for publishing
-
-Note that this error should be reported when there is no other reason for
-having a problem accessing the resource.
-
-#### SRT_REJX_NOTSUP_MEDIA
-
-The media type is not supported by the application. The media type is
-specified in the `t` key. The currently standard types are
-`stream`, `file` and `auth`. An application may extend this list, and
-is not obliged to support all of the standard types.
-
-#### SRT_REJX_LOCKED
-
-The resource being accessed is locked against any access. This is similar to
-`SRT_REJX_CONFLICT`, but in this case the resource is locked for reading 
-and writing. This is for when the resource should be shown as existing and 
-available to the client, but access is temporarily blocked.
-
-#### SRT_REJX_FAILED_DEPEND
-
-The dependent entity for the request is not present. In this case the
-dependent entity is the session, which should be specified in the `s`
-key. This means that the specified session ID is nonexistent or it
-has already expired.
-
-#### SRT_REJX_ISE
-
-Internal server error. This is for a general case when a request has
-been correctly verified, with no related problems found, but an
-unexpected error occurs after the processing of the request has started.
-
-#### SRT_REJX_UNIMPLEMENTED
-
-The request was correctly recognized, but the current software version
-of the service (be it SRT or any other software component) doesn't
-support it. This should be reported for a case, when some features to
-be specified in the StreamID request are supposed to be supported in a
-predictable future, but the current version of the server does not
-support it, or the support for this feature in this version has been
-temporarily blocked. This shouldn't be reported for existing features that are
-being deprecated, or older features that are no longer supported
-(for this case the general `SRT_REJX_BAD_REQUEST` is more appropriate).
-
-#### SRT_REJX_GW
-
-The server acts as a gateway and the target endpoint rejected the
-connection. The reason the connection was rejected is unspecified.
-The gateway cannot forward the original rejection code from the
-target endpoint because this would suggest the error was on the
-gateway itself. Use this error with some other mechanism to report
-the original target error, if possible.
-
-#### SRT_REJX_DOWN
-
-The service is down for maintenance. This can only be reported
-when the service has been temporarily replaced by a stub that is only
-reporting this error, while the real service is down for maintenance.
-
-#### SRT_REJX_VERSION
-
-Application version not supported. This can refer to an application feature
-that is unsupported (possibly from an older SRT version), or to a feature
-that is no longer supported because of backward compatibility requirements.
-
-#### SRT_REJX_NOROOM
-
-The data stream cannot be archived due to a lack of storage space. This is
-reported when a request to send a file or a live stream to be archived is
-unsuccessful. Note that the length of a file transmission is usually
-pre-declared, so this error can be reported early. It can also be reported when
-the stream is of undefined length, and there is no more storage space
-available.
-
-## Example
-
-An example of Stream ID functionality and the listener callback can be
-found under `tests/test_listen_callback.cpp`.
-
-A listener can register a callback to be called in the middle of accepting a
-new socket connection:
-
-```c++
-srt_listen(server_sock, 5);
-srt_listen_callback(server_sock, &SrtTestListenCallback, NULL);
-```
-
-A callback function has to be implemented by the upstream application. In the
-example below, the function tries to interpret the Stream ID value first according
-to the Access Control guidelines and to extract the username from the `u` key.
-Otherwise it falls back to a free-form specified username. Depending on the user,
-it sets the appropriate password for the expected connection so that it can be
-rejected if the password isn't correct. If the user isn't found in the
-database (`passwd` map) the function itself rejects the connection. Note that
-this can be done by both returning -1 and by throwing an exception.
-
-```c++
-int SrtTestListenCallback(void* opaq, SRTSOCKET ns, int hsversion,
-    const struct sockaddr* peeraddr, const char* streamid)
-{
-    using namespace std;
-
-    // opaq is used to pass some further chained callbacks
-
-    // To reject a connection attempt, return -1.
-
-    static const map<string, string> passwd {
-        {"admin", "thelocalmanager"},
-        {"user", "verylongpassword"}
-    };
-
-    // Try the "standard interpretation" with username at key u
-    string username;
-
-    static const char stdhdr [] = "#!::";
-    uint32_t* pattern = (uint32_t*)stdhdr;
-    bool found = -1;
-
-    // Extract a username from the StreamID:
-    if (strlen(streamid) > 4 && *(uint32_t*)streamid == *pattern)
-    {
-        vector<string> items;
-        Split(streamid+4, ',', back_inserter(items));
-        for (auto& i: items)
-        {
-            vector<string> kv;
-            Split(i, '=', back_inserter(kv));
-            if (kv.size() == 2 && kv[0] == "u")
-            {
-                username = kv[1];
-                found = true;
-            }
-        }
-
-        if (!found)
-        {
-            cerr << "TEST: USER NOT FOUND, returning false.\n";
-            return -1;
-        }
-    }
-    else
-    {
-        // By default the whole streamid is username
-        username = streamid;
-    }
-
-    // When the username of the client is known, the passphrase can be set
-    // on the socket being accepted (SRTSOCKET ns).
-    // The remaining part of the SRT handshaking process will check the
-    // passphrase of the client and accept or reject the connection.
-
-    // When not found, it will throw an exception
-    cerr << "TEST: Accessing user '" << username << "', might throw if not found\n";
-    string exp_pw = passwd.at(username);
-
-    cerr << "TEST: Setting password '" << exp_pw << "' as per user '" << username << "'\n";
-    srt_setsockflag(ns, SRTO_PASSPHRASE, exp_pw.c_str(), exp_pw.size());
-    return 0;
-}
-```
diff --git a/docs/Android/Compiling.md b/docs/Android/Compiling.md
deleted file mode 100644
index fbfe8893c..000000000
--- a/docs/Android/Compiling.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Establishing a Build Environment
-## Installing the Android NDK
-The Android NDK is required to build native modules for Android.
-Consider installing the latest version of cmake. The higher version of cmake the better. As of writing the current version of CMake is 3.18.4
-You can download Cmake from the following website:
-[https://cmake.org/download](https://cmake.org/download/)
-
-Download the NDK r19 or newer archive from the following site:
-[Download the Android NDK on developer.android.com](https://developer.android.com/ndk/downloads/index.html)
-To install the Android NDK, simply expand the archive in the folder where you want to install it.
-## OpenSSL
-Google removed openssl from Android 7+. You must build openssl libs by yourself.
-# Configure the NDK path
-Edit the ```mkall``` script to configure NDK path. Set the ```NDK``` to the directory where the NDK is installed.
-# Build SRT for Android
-Run ```/bin/bash mkall > build.log``` script. Libraries will be installed to ```./target-architecture/lib```.
-# Export SRT libraries
-Run ```/bin/bash packjni``` to generate ```jniLibs``` archive for Android Studio.
diff --git a/docs/Android/mkall b/docs/Android/mkall
deleted file mode 100755
index dbfe386a3..000000000
--- a/docs/Android/mkall
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/bin/bash
-
-NDK=/opt/android-ndk-r19c
-
-openssl_ver=1.1.1h
-#srt_version=1.4.2
-#srt_branch=dev
-
-API_LEVEL=28
-# Determine the path of the executing script
-BASE_DIR=$(readlink -f $0 | xargs dirname)
-
-#wget -N https://www.openssl.org/source/openssl-$openssl_ver.tar.gz
-
-if [ ! -d $BASE_DIR/srt ]; then
- git clone https://github.com/Haivision/srt srt
-# git -C $BASE_DIR/srt checkout v${srt_version}
-# git -C $BASE_DIR/srt checkout -b $srt_branch origin/$srt_branch
-fi
-
-# Clang, binutils, the sysroot, and other toolchain pieces are all installed to $NDK/toolchains/llvm/prebuilt/<host-tag>
-toolchain=$NDK/toolchains/llvm/prebuilt/linux-x86_64
-
-# Cross-compiler tool prefix
-declare -A target_hosts
-target_hosts=(
- [armeabi]=arm-linux-androideabi
- [arm]=arm-linux-androideabi
- [arm64]=aarch64-linux-android
- [x86]=i686-linux-android
- [x86_64]=x86_64-linux-android
-)
-
-# Cross-compiler prefix for -clang and -clang++ has api version
-declare -A target_api
-target_api=(
- [armeabi]=armv5te-linux-androideabi16
- [arm]=armv7a-linux-androideabi16
- [arm64]=aarch64-linux-android21
- [x86]=i686-linux-android16
- [x86_64]=x86_64-linux-android21
-)
-
-declare -A sysroots
-sysroots=(
- [armeabi]=$BASE_DIR/armeabi
- [arm]=$BASE_DIR/armeabi-v7a
- [arm64]=$BASE_DIR/arm64-v8a
- [x86]=$BASE_DIR/x86
- [x86_64]=$BASE_DIR/x86_64
-)
-
-declare -A archabi
-archabi=(
- [armeabi]=armeabi
- [arm]=armeabi-v7a
- [arm64]=arm64-v8a
- [x86]=x86
- [x86_64]=x86_64
-)
-
-$BASE_DIR/mkssl -n $NDK -o $openssl_ver -a $API_LEVEL
-
-for arch in armeabi arm arm64 x86 x86_64; do
- #rm -rf $BASE_DIR/openssl-$openssl_ver
- #tar xf $BASE_DIR/openssl-$openssl_ver.tar.gz
- #$BASE_DIR/mkssl -t $toolchain -h ${target_hosts[$arch]} -a ${target_api[$arch]} -s $BASE_DIR/openssl-$openssl_ver -i ${sysroots[$arch]}
-
- git -C $BASE_DIR/srt clean -fd
- $BASE_DIR/mksrt -t $toolchain -h ${target_hosts[$arch]} -a ${target_api[$arch]} -s $BASE_DIR/srt -i ${sysroots[$arch]} -b ${archabi[$arch]} -n  $NDK -l $API_LEVEL 
-done
diff --git a/docs/Android/mksrt b/docs/Android/mksrt
deleted file mode 100755
index 4d45755a4..000000000
--- a/docs/Android/mksrt
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash
-
-source prepare_build
-
-./configure --use-openssl-pc=OFF --CMAKE_PREFIX_PATH=$install_dir --CMAKE_INSTALL_PREFIX=$install_dir --CMAKE_SYSTEM_NAME=Android --CMAKE_SYSTEM_VERSION=$api_lev  --CMAKE_ANDROID_NDK=$NDK_HOME --CMAKE_ANDROID_ARCH_ABI=$arch_abi
-make
-make install
diff --git a/docs/Android/mkssl b/docs/Android/mkssl
deleted file mode 100755
index 726e4bb05..000000000
--- a/docs/Android/mkssl
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/bin/sh
-
-while getopts n:o:a: option
-do
- case "${option}"
- in
- n) ndk_home=${OPTARG};;
- o) ssl_ver=${OPTARG};;
- a) api_lev=${OPTARG};;
- *) twentytwo=${OPTARG};;
- esac
-done
-
-
-ANDROID_NDK=$ndk_home
-OPENSSL_VERSION=$ssl_ver
-
-API_LEVEL=$api_lev
-
-BUILD_DIR=/tmp/openssl_android_build
-OUT_DIR=$(pwd)
-
-BUILD_TARGETS="armeabi armeabi-v7a arm64-v8a x86 x86_64"
-
-if [ ! -d openssl-${OPENSSL_VERSION} ]
-then
-    if [ ! -f openssl-${OPENSSL_VERSION}.tar.gz ]
-    then
-        wget https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz || exit 128
-    fi
-    tar xzf openssl-${OPENSSL_VERSION}.tar.gz || exit 128
-fi
-
-cd openssl-${OPENSSL_VERSION} || exit 128
-
-
-##### Prepare Files #####
-sed -i 's/.*-mandroid.*//' Configurations/15-android.conf
-patch -p1 -N <<EOP
---- old/Configurations/unix-Makefile.tmpl   2018-09-11 14:48:19.000000000 +0200
-+++ new/Configurations/unix-Makefile.tmpl   2018-10-18 09:06:27.282007245 +0200
-@@ -43,12 +43,17 @@
-      # will return the name from shlib(\$libname) with any SO version number
-      # removed.  On some systems, they may therefore return the exact same
-      # string.
--     sub shlib {
-+     sub shlib_simple {
-          my \$lib = shift;
-          return () if \$disabled{shared} || \$lib =~ /\\.a$/;
--         return \$unified_info{sharednames}->{\$lib}. \$shlibvariant. '\$(SHLIB_EXT)';
-+
-+         if (windowsdll()) {
-+             return \$lib . '\$(SHLIB_EXT_IMPORT)';
-+         }
-+         return \$lib .  '\$(SHLIB_EXT_SIMPLE)';
-      }
--     sub shlib_simple {
-+     
-+   sub shlib {
-          my \$lib = shift;
-          return () if \$disabled{shared} || \$lib =~ /\\.a$/;
-
-EOP
-
-##### remove output-directory #####
-#rm -rf $OUT_DIR
-
-##### export ndk directory. Required by openssl-build-scripts #####
-export ANDROID_NDK
-
-##### build-function #####
-build_the_thing() {
-    TOOLCHAIN=$ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64
-    export PATH=$TOOLCHAIN/$TRIBLE/bin:$TOOLCHAIN/bin:"$PATH"
-echo $PATH
-    make clean
-    #./Configure $SSL_TARGET $OPTIONS -fuse-ld="$TOOLCHAIN/$TRIBLE/bin/ld" "-gcc-toolchain $TOOLCHAIN" && \
-    ./Configure $SSL_TARGET $OPTIONS -fuse-ld="$TOOLCHAIN/$TRIBLE/bin/ld" && \
-    make && \
-    make install DESTDIR=$DESTDIR || exit 128
-}
-
-##### set variables according to build-tagret #####
-for build_target in $BUILD_TARGETS
-do
-    case $build_target in
-    armeabi)
-        TRIBLE="arm-linux-androideabi"
-        TC_NAME="arm-linux-androideabi-4.9"
-        #OPTIONS="--target=armv5te-linux-androideabi -mthumb -fPIC -latomic -D__ANDROID_API__=$API_LEVEL"
-        OPTIONS="--target=armv5te-linux-androideabi -mthumb -fPIC -latomic -D__ANDROID_API__=$API_LEVEL"
-        DESTDIR="$BUILD_DIR/armeabi"
-        SSL_TARGET="android-arm"
-    ;;
-    armeabi-v7a)
-        TRIBLE="arm-linux-androideabi"
-        TC_NAME="arm-linux-androideabi-4.9"
-        OPTIONS="--target=armv7a-linux-androideabi -Wl,--fix-cortex-a8 -fPIC -D__ANDROID_API__=$API_LEVEL"
-        DESTDIR="$BUILD_DIR/armeabi-v7a"
-        SSL_TARGET="android-arm"
-    ;;
-    x86)
-        TRIBLE="i686-linux-android"
-        TC_NAME="x86-4.9"
-        OPTIONS="-fPIC -D__ANDROID_API__=${API_LEVEL}"
-        DESTDIR="$BUILD_DIR/x86"
-        SSL_TARGET="android-x86"
-    ;;
-    x86_64)
-        TRIBLE="x86_64-linux-android"
-        TC_NAME="x86_64-4.9"
-        OPTIONS="-fPIC -D__ANDROID_API__=${API_LEVEL}"
-        DESTDIR="$BUILD_DIR/x86_64"
-        SSL_TARGET="android-x86_64"
-    ;;
-    arm64-v8a)
-        TRIBLE="aarch64-linux-android"
-        TC_NAME="aarch64-linux-android-4.9"
-        OPTIONS="-fPIC -D__ANDROID_API__=${API_LEVEL}"
-        DESTDIR="$BUILD_DIR/arm64-v8a"
-        SSL_TARGET="android-arm64"
-    ;;
-    esac
-
-    rm -rf $DESTDIR
-    build_the_thing
-#### copy libraries and includes to output-directory #####
-    mkdir -p $OUT_DIR/$build_target/include
-    cp -R $DESTDIR/usr/local/include/* $OUT_DIR/$build_target/include
-    cp -R $DESTDIR/usr/local/ssl/* $OUT_DIR/$build_target/
-    mkdir -p $OUT_DIR/$build_target/lib
-    cp -R $DESTDIR/usr/local/lib/*.so $OUT_DIR/$build_target/lib
-    cp -R $DESTDIR/usr/local/lib/*.a $OUT_DIR/$build_target/lib
-done
-
-echo Success
diff --git a/docs/Android/packjni b/docs/Android/packjni
deleted file mode 100755
index 80e19ac80..000000000
--- a/docs/Android/packjni
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-
-BASE_DIR=$(readlink -f $0 | xargs dirname)
-
-declare -A sysroots
-sysroots=(
- [armeabi]=$BASE_DIR/armeabi
- [arm]=$BASE_DIR/armeabi-v7a
- [arm64]=$BASE_DIR/arm64-v8a
- [x86]=$BASE_DIR/x86
- [x86_64]=$BASE_DIR/x86_64
-)
-
-srt_version=1.4.2
-jni_dir=$BASE_DIR/jniLibs
-
-declare -A jnilibs
-jnilibs=(
- [armeabi=$jni_dir/armeabi
- [arm]=$jni_dir/armeabi-v7a
- [arm64]=$jni_dir/arm64-v8a
- [x86]=$jni_dir/x86
- [x86_64]=$jni_dir/x86_64
-)
-
-jni_dir=$BASE_DIR/jniLibs
-
-# Android < 6.0 has an issue with loading versioned libraries
-# The issue is because of library so-name libsrt.so.1
-
-for arch in armeabi arm arm64 x86 x86_64; do
- mkdir -p ${jnilibs[$arch]}
- cp ${sysroots[$arch]}/lib/libsrt.so ${jnilibs[$arch]}/libsrt.so
- /usr/local/bin/patchelf --set-soname libsrt.so ${jnilibs[$arch]}/libsrt.so
- objdump -p ${jnilibs[$arch]}/libsrt.so | grep libsrt.so 
-done
-
-zip -r libsrt_$(date +%Y-%m-%d).zip jniLibs
diff --git a/docs/Android/prepare_build b/docs/Android/prepare_build
deleted file mode 100644
index c0b2cd987..000000000
--- a/docs/Android/prepare_build
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-
-while getopts t:h:a:s:i:b:n:l: option
-do
- case "${option}"
- in
- t) toolchain_dir=${OPTARG};;
- h) target_host=${OPTARG};;
- a) target_host_api=${OPTARG};;
- s) src_dir=${OPTARG};;
- i) install_dir=$OPTARG;;
- b) arch_abi=${OPTARG};;
- n) NDK_HOME=${OPTARG};;
- l) api_lev=${OPTARG};;
- *) twentytwo=${OPTARG};;
- esac
-done
-
-# Add toolchain to the search path.
-export PATH=$PATH:$toolchain_dir/bin
-
-# Tell configure what tools to use.
-export AR=$target_host-ar
-export AS=$target_host-as
-export LD=$target_host-ld
-export STRIP=$target_host-strip
-
-# Tell configure which android api to use.
-export CC=$target_host_api-clang
-export CXX=$target_host_api-clang++
-
-# Tell configure what flags Android requires.
-export CFLAGS="-fPIE -fPIC"
-export LDFLAGS="-pie"
-
-cd $src_dir
diff --git a/docs/BuildOptions.md b/docs/BuildOptions.md
deleted file mode 100644
index 2e1ec0b12..000000000
--- a/docs/BuildOptions.md
+++ /dev/null
@@ -1,399 +0,0 @@
-# Build System
-
-The main build system for SRT is provided by the `cmake` tool, which can be 
-used directly. There's also a wrapper script named `configure` (requires Tcl 
-interpreter) that can make operating with the options easier.
-
-
-## Portability
-
-The `cmake` build system was tested on the following platforms:
-
- - Linux (various flavors)
- - macOS (see this [separate document](build_iOS.md))
- - Windows with MinGW
- - Windows with Microsoft Visual Studio (see this [separate document](build-win.md))
- - Android (see this [separate document](Android/Compiling.md))
- - Cygwin (only for testing)
-
-The `configure` script wasn't tested on Windows (other than on Cygwin).
-
-
-## The `configure` Script
-
-This script is similar in design to the Autotools' `configure` script, and
-so usually handles `--long-options`, possibly with values. It handles
-two kinds of options:
-
-* special options to be resolved inside the script and that may do some
-advanced checks; this should later turn into a set of specific `cmake`
-variable declarations
-
-* options that are directly translated to `cmake` variables. 
-
-The direct translate option always does a simple transformation:
-
-* all letters uppercase
-* dash into underscore
-* plus into X
-* when no value is supplied, it defaults to 1
-
-For example, `--enable-c++11` turns into `-DENABLE_CXX11=1` when passed
-to `cmake`.
-
-Additionally, if you specify `--disable-<X>`, the `configure` script
-will automatically turn it into an associated `--enable-<X>` option,
- passing `0` as its value. For example, `--disable-encryption` will
-be translated for `cmake` into `-DENABLE_ENCRYPTION=0`.
-
-### Build Options
-
-All options below are presented using the `configure` convention. They can all
-be used in `cmake` with the appropriate format changes.
-
-
-**`--cygwin-use-posix`** (default:OFF)
-
-When ON, compile on Cygwin using POSIX API (otherwise it will use MinGW environment).
-
-
-**`--enable-apps`** (default: ON)
-
-Enables compiling user applications.
-
-
-**`--enable-code-coverage`** (default: OFF)
-
-Enable instrumentation for code coverage. Note that this is only available
-on platforms with GNU-compatible compiler.
-
-
-**`--enable-c++-deps`** (default: OFF)
-
-The `pkg-confg` file (`srt.pc`) will be generated with the `libstdc++` library 
-as a dependency. This may be required in some cases where you have an application 
-written in C which therefore won't link against `libstdc++` by default.
-
-**`--enable-c++11`** (default: ON)
-
-Enable compiling in C++11 mode for those parts that may require it.
-Parts that don't require it will still be compiled in C++03 mode,
-although which parts are affected may change in future.
-
-If this option is turned OFF, it affects building a project in two ways:
-
-* an alternative C++03 implementation can be used, if available
-* otherwise the component that requires it will be disabled
-
-Parts that currently require C++11 and have no alternative implementation
-are:
-
-* unit tests
-* user and testing applications (such as `srt-live-transmit`)
-* some of the example applications
-
-It should be possible to compile the SRT library without C++11 support. However, 
-this alternative C++03 implementation may be unsupported on certain platforms.
-
-
-**`--enable-debug=<0,1,2>`**
-
-This option allows control through the `CMAKE_BUILD_TYPE` variable:
-
-* 0 (default): `Release` (highly optimized, no debug info)
-* 1: `Debug` (not optimized, full debug info)
-* 2: `RelWithDebInfo` (highly optimized, but with debug info)
-
-Please note that when the value is other than 0, the
-`--enable-heavy-logging` option is also turned ON by default.
-
-
-**`--enable-encryption`** (default: ON)
-
-Encryption feature enabled, which involves dependency on an external encryption
-library (default: openssl). If you disable encryption, the library will be unable
-to set encryption options. It will be compatible with a peer that has
-encryption enabled, but just won't use encryption for the connection.
-
-
-**`--enable-getnameinfo`** (default: OFF)
-
-Enables the use of `getnameinfo` using options that allow using reverse DNS to
-resolve an internal IP address into a readable internet domain name, so that it 
-can be shown nicely in the log file. This option is turned OFF by default 
-because it may have an impact on general performance. It is recommended only for
-development when testing on a local network.
-
-
-**`--enable-haicrypt-logging`** (default: OFF)
-
-Enables logging in the *haicrypt* module, which serves as a connector to
-an encryption library. Logging here might be seen as unsafe, therefore this 
-option is turned OFF by default.
-
-
-**`--enable-heavy-logging`** (default: OFF in release mode)
-
-This option enables the logging instructions in the code, which are considered
-heavy as they occur often and cover many detailed aspects of library behavior.
-Turning this option ON will allow you to use the `debug` level of logging and get 
-detailed information as to what happens inside the library. Note, however, that 
-this may influence processing by changing times, using less preferred thread 
-switching layouts, and generally worsen the functionality and performance of 
-the library. For these reasons this option is turned OFF by default.
-
-
-**`--enable-inet-pton`** (default: ON)
-
-Enables usage of `inet_pton` function by the applications, which should be used
-to resolve the network endpoint name into an IP address. This may be not
-availabe on some version of Windows, in which case you can turn this OFF.
-When this option is OFF, however, IP addresses cannot be resolved by name,
-as the `inet_pton` function gets a poor-man's simple replacement that can
-only resolve numeric IPv4 addresses.
-
-
-**`--enable-logging`** (default: ON)
-
-Enables logging. When you turn this option OFF, the library will not report
-any runtime information through the logging system, including errors.
-This option may be useful if you suspect the logging system of
-impairing performance.
-
-
-**`--enable-monotonic-clock`** (default: OFF)
-
-This option enforces the use of `clock_gettime` to get the current
-time, instead of `gettimeofday`. This function forces the use of a monotonic
-clock that is independent of the currently set time in the system.
-The condition variables (CV), for which the `*_timedwait()` functions are used
-with time specification based on the time obtained from `clock_gettime`
-must be appropriately configured. For now, this is only done for the
-GarbageCollector controlling CV, not every CV used in SRT. The consequence
-of enabling this option, however, may be portability issues resulting from
-the fact that `clock_gettime` function may be unavailable in some SDKs or that an
-extra `-lrt` option is sometimes required (this requirement will be autodetected).
-
-The problem is based on the fact that POSIX functions that use timeout
-specification (all of `*_timedwait`) expect the absolute time value.
-A relative timeout value can be then only specified by adding it to
-the current time, which can be specified as either system or monotonic
-clock (as configured in the resources used in the operation).
-However the current time of the monotonic clock can only be obtained by
-the `clock_gettime` function.
-
-**NOTE:** *This is a temporary fix for Issue #729* where the library could get 
-stuck if the system clock is modified during an SRT transmission. This option 
-will be removed when the problem is fixed globally.
-
-
-**`--enable-stdcxx-sync`** (default: OFF)
-
-This option enables the standard C++ `thread` and `chrono` libraries (available since C++11)
-to be used by SRT instead of the `pthreads`.
-
-
-**`--enable-profile`** (default: OFF)
-
-Enables code instrumentation for profiling.
-
-This is available only for GNU-compatible compilers.
-
-
-**`--enable-relative-libpath`** (default: OFF)
-
-Enables adding a relative path to a library. This allows applications to be
-linked against a shared SRT library by reaching out to a sibling `../lib`
-directory, provided that the library and applications are installed in POSIX/GNU
-style directories. This might be useful when installing SRT and applications
-in a directory, in which the library subdirectory is not explicitly defined
-among the global library paths. Consider, for example, this application and its 
-required library:
-
-* `/opt/srt/bin/srt-live-transmit`
-* `/opt/srt/lib64/libsrt.so`
-
-By using the `--enable-relative-libpath` option, the `srt-live-transmit` 
-application has a relative library path defined inside as `../lib64`. A dynamic 
-linker will find the required `libsrt.so` file by this path: `../lib64/libsrt.so`. 
-This way the dynamic linkage will work even if `/opt/srt/lib64` path isn't added 
-to the system paths in `/etc/ld.so.conf` or in the `LD_LIBRARY_PATH` environment 
-variable.
-
-This option is OFF by default because of reports that it may cause problems in
-case of default installation.
-
-
-**`--enable-shared`** and **`--enable-static`** (default for both: ON)
-
-Enables building SRT as a shared and/or static library, as required for your 
-application. In practice, you would only disable one or the other
-(e.g. by `--disable-shared`). Note that you can't disable both at once.
-
-
-**`--enable-testing`** (default: OFF)
-
-Enables compiling of developer testing applications.
-
-
-**`--enable-thread-check`** (default: OFF)
-
-Enables `#include <threadcheck.h>`, which implements `THREAD_*` macros" to 
-support better thread debugging. Included to support an existing project.
-
-
-**`--enable-unittests`** (default: OFF)
-
-When ON, this option enables unit tests, possibly with the download 
-and installation of the Google test library in the build directory. The tests 
-will be run as part of the build process. This is intended for developers only.
-
-
-**`--openssl-crypto-library=<filepath>`**
-
-Configure the path to an OpenSSL Crypto library.
-
-
-**`--openssl-include-dir=<path>`**
-
-Configure the path to include files for an OpenSSL library.
-
-
-**`--openssl-ssl-library=<filepath>`**
-
-Configure the path to an OpenSSL SSL library.
-
-
-**`--pkg-config-executable=<filepath>`**
-
-Configure the path to the `pkg-config` tool.
-
-
-**`--prefix=<path>`**
-
-This is an alias to the `--cmake-install-prefix` variable that establishes the
-root directory for installation, inside of which a GNU/POSIX compatible
-directory layout will be used. As on all known build systems, this defaults to
-`/usr/local` on GNU/POSIX compatible systems, with lower level GNU/POSIX
-directories created inside: `/usr/local/bin`,`/usr/local/lib`, etc.
-
-
-**`--pthread-include-dir=<path>`**
-
-Configure the path to include files for a pthread library. Note that this
-is useful only on Windows. On Linux and macOS this path should be available in 
-the system.
-
-
-**`--pthread-library=<filepath>`**
-
-Configure the path to a pthread library.
-
-
-**`--use-busy-waiting`** (default: OFF)
-
-Enable more accurate sending times at the cost of potentially higher CPU load.
-
-This option will cause more empty loop running, which may cause more CPU usage. 
-Keep in mind, however, that when processing high bitrate streams the share of
-empty loop runs will decrease as the bitrate increases. This way higher CPU
-usage would still be productive, while without system-supported waiting this
-option may increase the likelihood of switching to the right thread at the time
-when it is expected to be revived.
-
-**`--use-c++-std=<standard>`**
-
-
-
-**`--use-gnustl`**
-
-Use `pkg-config` with the `gnustl` package name to extract the header and 
-library path for the C++ standard library (instead of using the compiler
-built-in one).
-
-
-**`--use-enclib=<name>`**
-
-Encryption library to be used. Possible options for `<name>`:
-
-* openssl (default)
-* gnutls (with nettle)
-* mbedtls
-
-
-**`--use-openssl-pc`** (default: ON)
-
-Use `pkg-config` to find OpenSSL libraries. You can turn this OFF to force 
-`cmake` to find OpenSSL by its own preferred method.
-
-
-**`--use-static-libstdc++`** (default: OFF)
-
-Enforces linking the SRT library against the static libstdc++ library. This may
-be useful if you are using SRT library in an environment where it would by
-default link against the wrong version of the C++ standard library, or when the
-library in the version used by the compiler is not available as shared.
-
-
-**`--with-compiler-prefix=<prefix>`**
-
-Sets C/C++ toolchains as `<prefix><c-compiler>` and `<prefix><c++-compiler>`.
-
-This option will override the default compiler autodetected by `cmake`.
-It is handled inside `cmake`. It sets the variables `CMAKE_C_COMPILER` and
-`CMAKE_CXX_COMPILER`. The values for the above `<c-compiler>` and
-`<c++-compiler>` are controlled by the `--with-compiler-type` option.
-When this option is not supplied, a system-default compiler will be
-used, that is:
-
-* On Mac OS (Darwin): clang
-* On other POSIX systems: gcc
-* On other systems: obtained from `CMAKE_C_COMPILER` variable
-
-Instead of `--with-compiler-prefix` you can use `--cmake-c-compiler`
-and `--cmake-c++-compiler` options. This can be thought of as a
-shortcut, useful when you have a long path to the compiler command.
-
-NOTE: The prefix is meant to simply precede the compiler type as pure
-prefix, so if your prefix is a full path to the compiler, it must include
-the terminal path separator character, as this can be also used as a
-prefix for a platform-specific cross compiler. For example, if the path
-to the C compiler is: `/opt/arm-tc/bin/arm-linux-gnu-gcc-7.4`, then
-you should specify `--with-compiler-prefix=/opt/arm-tc/bin/arm-linux-gnu-`
-and `--with-compiler-type=gcc-7.4`.
-
-**`--with-compiler-type=<name>`**
-
-Sets the compiler type to be used as `<c-compiler>` and `<c++-compiler>`
-respectively:
-
-* gcc (default): gcc and g++
-* cc: cc and c++
-* others: use `<name>` as C compiler and `<name>++` as C++ compiler
-
-This should be the exact command used as a C compiler, possibly with
-version suffix, e.g. `clang-1.7.0`. If this option is used together
-with `--with-compiler-prefix`, its prefix will be added in front.
-
-**`--with-extralibs=<library-list>`**
-
-This is an option required for unusual situations when a platform-specific
-workaround is needed and some extra libraries must be passed explicitly
-for linkage. The argument is a space-separated list of linker options
-or library names.
-
-There are some known sitautions where it may be necessary:
-
-1. Some older Linux systems do not ship `clock_gettime` functions by
-default in their libc, and need an extra librt. If you are using POSIX
-monotonic clocks (see `--enable-monotonic-clock`), this might be required
-to add `-lrd` through this option. Although this situation is tried to
-be autodetected and this option added automatically, it might sometimes fail.
-
-2. On some systems (found so far on OpenSuSE), if you use C++11 sync
-(see `--enable-stdc++-sync`), the gcc compiler relies on gthreads, which
-relies on pthreads, and happens to define inline source functions in
-the header that refers to `pthread_create`, the compiler however doesn't
-link against pthreads by default. To work this around, add `-pthreads`
-using this option.
-
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 000000000..8c07ee515
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,77 @@
+# Documentation Overview
+
+## SRT API Documents
+
+| Document Title                                              | Folder                        | File Name                                                      | Description                                          |
+| :---------------------------------------------------------- | :---------------------------- | :------------------------------------------------------------- | :--------------------------------------------------- |
+| [SRT API](API/API.md)                                       | [API](API/)                   | [API.md](API/API.md)                                           | Detailed description of the SRT C API.               |
+| [SRT API Functions](API/API-functions.md)                   | [API](API/)                   | [API-functions.md](API/API-functions.md)                       | Reference document for SRT API functions.            |
+| [SRT API Socket Options](API/API-socket-options.md)         | [API](API/)                   | [API-socket-options.md](API/API-socket-options.md)             | Instructions and list of socket options for SRT API. |
+| [SRT Rejection Codes](API/rejections-codes.md)              | [API](API/)                   | [rejection-codes.md](API/rejection-codes.md)                   | The list of SRT rejections codes. |
+| [SRT Statistics](API/statistics.md)                         | [API](API/)                   | [statistics.md](API/statistics.md)                             | How to use SRT socket and socket group statistics.   |
+| [Configuration Guidelines](API/configuration-guidelines.md) | [API](API/)                   | [configuration-guidelines.md](API/configuration-guidelines.md) | How to configure SRT buffers.                        |
+| <img width=200px height=1px/>                               | <img width=100px height=1px/> | <img width=200px height=1px/>                                  | <img width=500px height=1px/>                        |
+
+## Build Instructions
+
+| Document Title                                                | Folder                        | File Name                                        | Description                                                             |
+| :------------------------------------------------------------ | :---------------------------- | :----------------------------------------------- | :---------------------------------------------------------------------- |
+| [SRT Build Options](build/build-options.md)                   | [build](build/)               | [build-options.md](build/build-options.md)       | Description of CMake build system, configure script, and build options. |
+| [Building SRT on Linux (Ubuntu/CentOS)](build/build-linux.md) | [build](build/)               | [build-linux.md](build/build-linux.md)           | Build instructions for Linux (Ubuntu/CentOS).                           |
+| [Building SRT on Windows](build/build-win.md)                 | [build](build/)               | [build-win.md](build/build-win.md)               | Build instructions for Windows.                                         |
+| [Building SRT on macOS](build/build-macOS.md)                 | [build](build/)               | [build-macOS.md](build/build-macOS.md)           | Build instructions for macOS.                                           |
+| [Building SRT on iOS](build/build-iOS.md)                     | [build](build/)               | [build-iOS.md](build/build-iOS.md)               | Build instructions for iOS.                                             |
+| [Building SRT on Android](build/build-android.md)             | [build](build/)               | [build-android.md](build/build-android.md)       | Build instructions for Android.                                         |
+| [Package Managers](build/package-managers.md)                 | [build](build/)               | [package-managers.md](build/package-managers.md) | Package managers supporting SRT library.                                |
+| <img width=200px height=1px/>                                 | <img width=100px height=1px/> | <img width=200px height=1px/>                    | <img width=500px height=1px/>                                           |
+
+## Development Documents
+
+| Document Title                                   | Folder                        | File Name                                        | Description                                                                            |
+| :----------------------------------------------- | :---------------------------- | :----------------------------------------------- | :------------------------------------------------------------------------------------- |
+| [SRT Developer's Guide](dev/developers-guide.md) | [dev](dev/)                   | [developers-guide.md](dev/developers-guide.md)   | Development setup, project structure, coding rules,<br />submitting issues & PRs, etc. |
+| [Low Level Info](dev/low-level-info.md)          | [dev](dev/)                   | [low-level-info.md](dev/low-level-info.md)       | Low level information for the SRT project (only<br />mutex locking).                   |
+| [Making SRT Better](dev/making-srt-better.md)    | [dev](dev/)                   | [making-srt-better.md](dev/making-srt-better.md) | Guidelines for problem reporting, collecting debug logs<br />and pcaps.                |
+| <img width=200px height=1px/>                    | <img width=100px height=1px/> | <img width=200px height=1px/>                    | <img width=500px height=1px/>                                                          |
+
+## Features
+
+| Document Title                                               |            Folder             | File Name                                                    | Description                                                  |
+| :----------------------------------------------------------- | :---------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| [SRT Access Control<br /> (Stream ID) Guidelines](features/access-control.md) |     [features](features/)     | [access-control.md](features/access-control.md)              | Access Control (Stream ID) guidelines.                       |
+| [SRT Connection Bonding: Quick Start](features/bonding-quick-start.md) | [features](features/) | [bonding-quick-start.md](features/bonding-quick-start.md) | SRT Connection Bonding Quick Start. |
+| [SRT Connection Bonding: Introduction](features/bonding-intro.md)          |     [features](features/)     | [bonding-intro.md](features/bonding-intro.md)                | Introduction to Connection Bonding. Description<br />of group (bonded) connections. |
+| [SRT Connection Bonding: Socket Groups](features/socket-groups.md)               |     [features](features/)     | [socket-groups.md](features/socket-groups.md)                | Description of socket groups in SRT (Connection<br />Bonding). Here you will also find information<br />regarding the `srt-test-live` application for testing<br />Connection Bonding. |
+| [SRT Connection Bonding: Main/Backup][main-backup]           |     [features](features/)     | [bonding-main-backup.md][main-backup]                        | Main/Backup mode description.                          |
+| [SRT Encryption](features/encryption.md)                     |     [features](features/)     | [encryption.md](features/encryption.md)                      | Description of SRT encryption mechanism. This<br />document might be outdated, please consult<br />[Section 6. Encryption][srt-internet-draft-sec-6] of the [Internet Draft][srt-internet-draft] additionally. |
+| [SRT Handshake](features/handshake.md)                       |     [features](features/)     | [handshake.md](features/handshake.md)                        | Description of SRT handshake mechanism. This<br />document might be outdated, please consult<br />[Section 3.2.1 Handshake][srt-internet-draft-sec-3-2-1] and<br />[Section 4.3 Handshake Messages](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-4.3) of the<br />[Internet Draft][srt-internet-draft] additionally. |
+| [Live Streaming <br /> Guidelines](features/live-streaming.md) |   [features](features/)     | [live-streaming.md](features/live-streaming.md)              | Guidelines for live streaming with SRT. See also<br />best practices and configuration tips in<br />[Section 7.1 Live Streaming](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-7.1) of the [Internet Draft][srt-internet-draft]. |
+| [SRT Packet <br /> Filtering & FEC][packet-filter]           |     [features](features/)     | [packet-filtering-and-fec.md][packet-filter]                 | Description of SRT packet filtering mechanism,<br />including FEC. |
+| <img width=200px height=1px/>                                | <img width=100px height=1px/> | <img width=200px height=1px/>                                | <img width=500px height=1px/>                                |
+
+## Sample Applications
+
+| Document Title                                                         |            Folder     | File Name                                           | Description                                                   |
+| :--------------------------------------------------------------------- | :-------------------- | :-------------------------------------------------- | :------------------------------------------------------------ |
+| [Using the<br /> `srt-live-transmit` App](apps/srt-live-transmit.md)   | [apps](apps/)         | [srt-live-transmit.md](apps/srt-live-transmit.md)   | A sample application to transmit a live stream from<br />source medium (UDP/SRT/`stdin`) to the target medium<br />(UDP/SRT/`stdout`). |
+| [Using the<br /> `srt-file-transmit` App](apps/srt-file-transmit.md)   | [apps](apps/)         | [srt-file-transmit.md](apps/srt-file-transmit.md)   | A sample application to transmit a file over SRT              |
+| [Using the<br /> `srt-tunnel` App](apps/srt-tunnel.md)                 | [apps](apps/)         | [srt-tunnel.md](apps/srt-tunnel.md)                 | A sample application to set up an SRT tunnel for TCP traffic. |
+| [Using the<br /> `srt-test-multiplex` App](apps/srt-test-multiplex.md) | [apps](apps/)         | [srt-test-multiplex.md](apps/srt-test-multiplex.md) | Testing application that allows to send multiple streams over one UDP link. |
+| [Using the<br /> `srt-test-relay` App](apps/srt-test-relay.md)         | [apps](apps/)         | [srt-test-relay.md](apps/srt-test-relay.md)         | Testing application for bidirectional stream sending over one connection.   |
+| <img width=200px height=1px/>                                  | <img width=100px height=1px/> | <img width=200px height=1px/>                       | <img width=500px height=1px/>                                      |
+
+## Miscellaneous
+
+| Document Title                                     |            Folder             | File Name                                             | Description                                                  |
+| :------------------------------------------------- | :---------------------------- | :---------------------------------------------------- | :----------------------------------------------------------- |
+| [Why SRT Was Created](misc/why-srt-was-created.md) |         [misc](misc/)         | [why-srt-was-created.md](misc/why-srt-was-created.md) | Background and history of SRT. See also<br />[Section 1. Introduction][srt-internet-draft-sec-1] of the [Internet Draft][srt-internet-draft]. |
+| <img width=200px height=1px/>                      | <img width=100px height=1px/> | <img width=200px height=1px/>                         | <img width=500px height=1px/>                                |
+
+
+[srt-internet-draft]: https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01
+[srt-internet-draft-sec-1]: https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-1
+[srt-internet-draft-sec-3-2-1]: https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-3.2.1
+[srt-internet-draft-sec-6]: https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-6
+
+[main-backup]: features/bonding-main-backup.md
+[packet-filter]: features/packet-filtering-and-fec.md
diff --git a/docs/SRT-Multiplex.md b/docs/SRT-Multiplex.md
deleted file mode 100644
index 80dbd0411..000000000
--- a/docs/SRT-Multiplex.md
+++ /dev/null
@@ -1,98 +0,0 @@
-## srt-multiplex
-
-**srt-multiplex** (formerly called "SIPLEX") is a sample program that can send 
-multiple streams in one direction. This tool demonstrates two SRT features:
- - the ability to use a single UDP link (a source and destination pair 
- specified by IP address and port) for multiple SRT connections
- - the use of the `streamid` socket option to identify multiplexed resources
-
-NOTE: due to changes in the common code that can't be properly handled in the
-current form of srt-multiplex, this application is temporarily blocked. Instead
-the `srt-test-multiplex` application was added with the same functionality,
-although it's recommended for testing purposes only.
-
-#### Usage
-
-`srt-multiplex <SRT-URI> -i <INPUT-URI1>[id] <INPUT-URI2>[id]...`
-
-  - Multiplexes data from one or more input URIs to transmit as an SRT stream. 
-  The application reads multiple streams (INPUT URIs), each using a separate SRT 
-  connection. All of the traffic from these connections is sent through the 
-  same UDP link.
-
-`srt-multiplex <SRT-URI> -o <OUTPUT-URI1>[id] <OUTPUT-URI2>[id]...`
-
-  - Transmits data from a multiplexed SRT stream to the specified output URI(s).
-
-An `<SRT URI>` can be identified as input or output using the **-i** or **-o** 
-options. When `-i` is specified, the URIs provided are used as input, and will 
-be output over the `<SRT URI>` socket. The reverse is true for any output URIs 
-specified by `-o`.
-
-Separate connections will be created for every specified URI, although all will 
-be using the same UDP link. When SRT is in caller mode, the SRT socket created 
-for transmitting data for a given URI will be set to the `streamid` socket option 
-from this URI's `id` parameter. When SRT is in listener mode, the `streamid` 
-option will already be set on the accepted socket, and will be matched with a 
-URI that has the same value in its `id` parameter.
-
-This `streamid` is the SRT socket option (`SRTO_STREAMID` in the API). The idea 
-is that it can be set on a socket used for connecting. When a listener is 
-getting an accepted socket for that connection, the `streamid` socket option 
-can be read from it, with the result that it will be the same as was set on 
-the caller side.
-
-So, in caller mode, for every stream media URI (input or output) there will be
-a separate SRT socket created. This socket will have its `socketid` option 
-set to the value that is given by user as the `id` parameter attached to a 
-particular URI. In listener mode this happens in the opposite direction — the 
-value of the `streamid` option is extracted from the accepted socket, and then 
-matched against all ids specified with the stream media URIs:
-```
-URI1?id=a --> s1(streamid=a).connect(remhost:2000)
-URI2?id=b --> s2(streamid=b).connect(remhost:2000)
-URI3?id=c --> s3(streamid=c).connect(remhost:2000)
-```
-And on the listener side:
-```
-(remhost:2000) -> accept --> s(SRT socket) --> in URI array find such that uri.id == s.streamid
-```
-
-#### Examples
-
-  - **Sender:**  
-    - `srt-multiplex srt://remhost:2000 -i udp://:5000?id=low udp://:6000?id=high`
-  - **Receiver:**
-    - `srt-multiplex srt://:2000 -o output-high.ts?id=high output-low.ts?id=low`
-
-In this example a Sender is created which will connect to `remhost` port 2000 
-using multiple SRT sockets, all of which will be using the same outgoing port. 
-Here the outgoing port is automatically selected when connecting. Subsequent 
-sockets will reuse that port. Alternatively you can enforce the outgoing port 
-using the `port` parameter with the `<SRT URI>`.
-
-  - **Sender:**  
-    - `srt-multiplex srt://remhost:2000?port=5555 ...`
-
-A separate connection is made for every input resource. An appropriate resource 
-ID will be set to each socket assigned to that resource according to the `id` 
-parameter.
-```
-           +--                                                   --+
-           |   id=1                                         id=1   |
-           |  ------                                      -------  |
-           |         \               ----->              /         |
-           |   id=2   \  ----------------------------   /   id=2   |
-port=5555 -|  --------- (   multiplexed UDP stream   ) ----------  |- port=2000
-           |          /  ----------------------------   \          |
-           |   id=3  /                                   \  id=3   |
-           |  ------                                       ------  |
-           +--                                                   --+
-```
-When a socket is accepted on the listener side (the Receiver in this example), 
-srt-multiplex will search for the resource ID among the registered resources 
-(input/output URIs) and set an ID that matches the one on the caller side. If 
-the resource is not found, the connection is closed immediately. 
-
-The srt-multiplex program works the same way for connections initiated by a 
-caller or a listener.
diff --git a/docs/apps/srt-file-transmit.md b/docs/apps/srt-file-transmit.md
new file mode 100644
index 000000000..2bf3b1115
--- /dev/null
+++ b/docs/apps/srt-file-transmit.md
@@ -0,0 +1,55 @@
+# srt-file-transmit
+
+The `srt-file-transmit` tool is a tool for transmitting files over SRT.
+
+You need:
+
+ - a file to transmit
+ - a destination to store it into
+ - this application run on both sides, one sending, one receiving
+
+## Introduction
+
+The `srt-file-transmit` application will transmit your file over the SRT connection,
+the application on the other side will receive it and store to the desired location.
+Both caller-listener and rendezvous arrangement of the connection are possible
+and in whatever direction.
+
+The `streamid` socket option will be used to pass the filename to the other side
+so that it is either written with this name or matched with the filename internally.
+
+The application the will be sending a file should use the file path as source and
+SRT URI as a destination, and vice versa for receiving.
+
+## Caller mode
+
+If you use sender in caller mode, then the caller SRT URI destination should be
+specified, and the "root name" from the file path will be set to `streamid`.
+This will allow the listener to use it when writing.
+
+If a receiver is used as a caller, then the destination filepath's rootname
+will be also passed as `streamid` so that the listener receiver can pick up the
+file by name.
+
+In caller mode you must specify the full filename path of the received or sent
+file.
+
+## Listener mode
+
+If you use sender in listener mode, then you start it with specifying either the
+full filename path, or only the directory where the file is located; in the latter
+case the filename will be tried from the `streamid` option extracted from the
+connected socket (as set by the other side's caller). If the full filename was
+specified, it must match the rootname extraced from this option, or otherwise
+transmission will not be done.
+
+If you use receiver in listener mode, then you start it with specifying either
+the full filename path, or just the directory. In the latter case the root name
+will be extracted from `streamid` socket option, and this one will be transmitted.
+
+## Usage
+
+```
+srt-file-transmit [options] <input-uri> <output-uri>
+```
+
diff --git a/docs/srt-live-transmit.md b/docs/apps/srt-live-transmit.md
similarity index 78%
rename from docs/srt-live-transmit.md
rename to docs/apps/srt-live-transmit.md
index ec29a2f1c..48741df23 100644
--- a/docs/srt-live-transmit.md
+++ b/docs/apps/srt-live-transmit.md
@@ -17,6 +17,7 @@ The following medium types are handled by `srt-live-transmit`:
 
 - SRT - use SRT for reading or writing, in listener, caller or rendezvous mode, with possibly additional parameters
 - UDP - read or write the given UDP address (also multicast)
+- RTP - read RTP from the given address (also multicast)
 - Local file - read or store the stream into the file
 - Process's pipeline - use the process's `stdin` and `stdout` standard streams
 
@@ -62,6 +63,16 @@ You should see the stream connect in `srt-live-transmit`.
 Now you can test in VLC (make sure you're using the latest version!) - just go to file -> open network stream and enter
 `srt://127.0.0.1:4201` and you should see bars and tone right away.
 
+Or you can test using ffplay or ffprobe to inspect the stream:
+
+```shell
+ffplay srt://127.0.0.1:4201
+```
+-or-
+```shell
+ffprobe srt://127.0.0.1:4201
+```
+
 If you're having trouble, make sure this works, then add complexity one step at a time (multicast, push vs listen, etc.).
 
 ## URI Syntax
@@ -76,6 +87,7 @@ The applications supports the following schemes:
 
 - `file` - for file or standard input and output
 - `udp` - UDP output (unicast and multicast)
+- `rtp` - RTP input (unicast and multicast)
 - `srt` - SRT connection
 
 Note that this application doesn't support file as a medium, but this
@@ -107,6 +119,16 @@ The specification and meaning of the fields in the URI depend on the mode.
 The **PORT** part is always mandatory and it designates either the port number
 for the target host or the port number to be bound to read from.
 
+The following options are available through URI parameters:
+
+- **iptos**: sets the `IP_TOS` socket option
+- **ttl**: sets the `IP_TTL` or `IP_MULTICAST_TTL` option, depending on mode
+- **mcloop**: sets the `IP_MULTICAST_LOOP` option (multicast mode only)
+- **rcvbuf**: sets the `SO_RCVBUF` socket option
+- **sndbuf**: sets the `SO_SNDBUF` socket option
+- **adapter**: sets the local binding address
+- **source**: uses `IP_ADD_SOURCE_MEMBERSHIP`, see below for details
+
 For sending to unicast:
 
 ```yaml
@@ -163,6 +185,25 @@ instead of `IP_ADD_MEMBERSHIP` and the value is set to `imr_sourceaddr` field.
 Explanations for the symbols and terms used above can be found in POSIX
 manual pages, like `ip(7)` and on Microsoft docs pages under `IPPROTO_IP`.
 
+### Medium: RTP
+
+RTP is supported for input only.
+
+All URI parameters described in the [Medium: UDP](#medium-udp) section above
+also apply to RTP. A further RTP-specific option is available as an URI
+parameter:
+
+- **rtpheadersize**: sets the number of bytes to drop from the beginning of
+each received packet. Defaults to 12 if not provided. Minimum value is 12.
+
+A length of **rtpheadersize** bytes will always be dropped. If you wish to pass
+the entire packet, including RTP header, to the output medium, you should
+instead specify UDP as the input medium.
+
+> NOTE: No effort is made in the initial implementation to attempt to parse
+the RTP headers in any way eg for validation, reordering, extracting timing,
+length detection of checking.
+
 ### Medium: SRT
 
 Most important about SRT is that it can be either input or output and in
@@ -173,7 +214,7 @@ options that can be set through the parameters.
 SRT can be connected using one of three connection modes:
 
 - **caller**: the "agent" (this application) sends the connection request to
-  the peer, which must be **listener**, and this way it initiates the
+the peer, which must be **listener**, and this way it initiates the
 connection.
 
 - **listener**: the "agent" waits to be contacted by any peer **caller**.
@@ -182,50 +223,74 @@ does not use this ability; after the first connection, it no longer
 accepts new connections.
 
 - **rendezvous**: A one-to-one only connection where both parties are
-  equivalent and both connect to one another simultaneously. Whoever happened
-to start first (or succeeded to punch through the firewall) is meant to have
+equivalent and both attempt to initiate a connection simultaneously. Whichever party happens
+to start first (or succeeds in punching through the firewall first) is considered to have
 initiated the connection.
 
 This mode can be specified explicitly using the **mode** parameter. When it's
-not specified, then it is "deduced" the following way:
+not specified, then it is derived based on the *host* part in the URI and
+the presence of the **adapter** parameter:
 
-- `srt://:1234` - the *port* is specified (1234), but *host* is empty. This assumes **listener** mode.
-- `srt://remote.host.com:1234` - both *host* and *port* are specified. This assumes **caller** mode.
+* Listener mode: if you leave the *host* part empty (**adapter** may be specified):
+   - `srt://:1234`
+* Caller mode: if you specify *host* part, but not **adapter** parameter:
+   - `srt://remote.host.com:1234`
+* Rendezvous mode: if you specify *host* AND **adapter** parameter:
+   - `srt://remote.host.com:1234&adapter=my.remote.addr`
 
-When the `mode` parameter is specified explicitly, then the interpretation of the `host` part is the following:
+Sometimes the required parameter specification results in a different mode
+than desired; in this case you should specify the mode explicitly.
 
-- For caller, it's always the destination host address. If this is empty, it is
-resolved to 0.0.0.0, which usually should mean connecting to the local host
+The interpretation of the *host* and *port* parts is the following:
 
-- For listener, it defines the IP address of the local device on which the
-socket should listen, e.g.:
+- In **LISTENER** mode:
+   - *host* part: the local IP address to bind (default: 0.0.0.0 - "all devices")
+   - *port* part: the local port to bind (mandatory)
+   - **adapter** parameter: alternative for *host* part, e.g.:
 
 ```yaml
 srt://10.10.10.100:5001?mode=listener
 ```
 
-An alternative method to specify this IP address is the `adapter` parameter:
+or
 
 ```yaml
 srt://:5001?adapter=10.10.10.100
 ```
 
-The **rendezvous** mode is not deduced and it has to be specified
-explicitly. Note also special cases of the **host** and **port** parts
-specified in the URI:
-
-- **CALLER**: the *host* and *port* parts are mandatory and specify the remote host and port to be contacted.
-  - The **port** parameter can be used to enforce the local outgoing port (**not to be confused** with remote port!).
-  - The **adapter** parameter is not used.
-- **LISTENER**: the *port* part is mandatory and it specifies the local listening port.
-  - The **adapter** parameter can be used to specify the adapter.
-  - The *host* part, if specified, can be also used to set the adapter - although in this case **mode=listener** must be set explicitly.
-  - The **port** parameter is not used.
-- **RENDEZVOUS**: the *host* and *port* parts are mandatory.
-  - The *host* part specifies the remote host to contact.
-  - The *port* part specifies **both local and remote port**. Note that the local port is this way both listening port and outgoing port.
-  - The **adapter** parameter can be used to specify the adapter.
-  - The **port** parameter can be used to specify the local port to bind to.
+- In **CALLER** mode:
+   - *host* part: remote IP address to connect to (mandatory)
+   - *port* part: remote port to connect to (mandatory)
+   - **port** parameter: the local port to bind (default: 0 - "system autoselection")
+   - **adapter** parameter: the local IP address to bind (default: 0.0.0.0 - "system selected device")
+   - **bind** parameter: a shortcut to set adapter or port by specifying ADAPTER:PORT
+
+```yaml
+srt://remote.host.com:5001
+```
+
+```yaml
+srt://remote.host.com:5001?adapter=local1&port=4001&mode=caller
+```
+
+- In **RENDEZVOUS** mode: same as **CALLER** except that the local
+port, if not specified by the **port** parameter, defaults to the
+value of the remote port (specified in the *port* part in the URI).
+
+```yaml
+srt://remote.host.com:5001?mode=rendezvous
+```
+(uses `remote.host.com` port 5001 for a remote host and the default
+network device for routing to this host; the connection from the peer is
+expected on that device and port 5001)
+
+
+```yaml
+srt://remote.host.com:5001?port=4001&adapter=local1
+```
+(uses `remote.host.com` port 5001 for a remote host and the peer
+is expected to connect to `local1` address and port 4001)
+
 
 **IMPORTANT** information about IPv6.
 
@@ -238,16 +303,18 @@ the following restrictions:
 2. In listener mode, if you leave the host empty, the socket is bound to
 `INADDR_ANY` for IPv4 only. If you want to make it listen on IPv6, you need to
 specify the host as `::`.
-NOTE: Don't use square brackets syntax in the adapter specification, 
-as in this case only the host is expected.
-
-3. If you want to listen for connections from both IPv4 and IPv6, mind the
-`ipv6only` option. The default value for this option is system default (see
-system manual for `IPV6_V6ONLY` socket option); if unsure, you might want to
-enforce `ipv6only=0` in order to be able to accept both IPv4 and IPv6
-connections in the same listener.
-
-4. In rendezvous mode you may only interconnect both parties using IPv4, 
+NOTE: Don't use square brackets syntax in the **adapter** parameter
+specification, as in this case only the host is expected.
+
+3. If you bind to an IPv6 wildcard address (with listener mode, or when using the `bind`
+option), setting the `ipv6only` option to 0 or 1 is obligatory, as it is a part
+of the binding definition. If you set it to 1, the binding will apply only to
+IPv6 local addresses, and if you set it to 0, it will apply to both IPv4 and
+IPv6 local addresses. See the
+[`SRTO_IPV6ONLY`](../API/API-socket-options.md#SRTO_IPV6ONLY) option
+description for details.
+
+4. In rendezvous mode you may only interconnect both parties using IPv4,
 or both using IPv6. Unlike listener mode, if you want to leave the socket
 default-bound (you don't specify `adapter`), the socket will be bound with the
 same IP version as the target address. If you do specify `adapter`,
@@ -259,9 +326,8 @@ Examples:
 
 * `srt://[::]:5000` defines caller mode (!) with IPv6.
 
-* `srt://[::]:5000?mode=listener` defines listener mode with IPv6. If the
-    default value for `IPV6_V6ONLY` system socket option is 0, it will accept
-    also IPv4 connections.
+* `srt://[::]:5000?mode=listener&ipv6only=1` defines listener mode with IPv6.
+    Only connections from IPv6 callers will be accepted.
 
 * `srt://192.168.0.5:5000?mode=rendezvous` will make a rendezvous connection
     with local address `INADDR_ANY` (IPv4) and port 5000 to a destination with
@@ -271,32 +337,34 @@ Examples:
     connection with local address `inaddr6_any` (IPv6) and port 4000 to a
     destination with port 5000.
 
-* `srt://[::1]:5000?adapter=127.0.0.1&mode=rendezvous` - this URI is invalid
-    (different IP versions for binding and target address)
+* `srt://[::1]:5000?adapter=127.0.0.1` - this URI is invalid
+    (different IP versions for binding and target address in rendezvous mode)
 
-Some parameters handled for SRT medium are specific, all others are socket options. The following parameters are handled special way by `srt-live-transmit`:
+Some parameters handled for SRT medium are specific, all others are socket options. The following parameters are handled in a special way by `srt-live-transmit`:
 
 - **mode**: enforce caller, listener or rendezvous mode
-- **port**: enforce the **outgoing** port (the port number that will be set in the UDP packet as a source port when sent from this host). This can be used only in **caller mode**.
+- **port**: enforce the **outgoing** port (the port number that will be set in the UDP packet as a source port when sent from this host). Not used in **listener** mode.
 - **blocking**: sets the `SRTO_RCVSYN` for input medium or `SRTO_SNDSYN` for output medium
 - **timeout**: sets `SRTO_RCVTIMEO` for input medium or `SRTO_SNDTIMEO` for output medium
-- **adapter**: sets the adapter for listening in *listener* or *rendezvous* mode
+- **adapter**: sets the local IP address to bind
 
-All other parameters are SRT socket options. The following have the following value types:
+All other parameters are SRT socket options. The Values column uses the
+following type specification:
 
 - `bool`. Possible values: `yes`/`no`, `on`/`off`, `true`/`false`, `1`/`0`.
-- `bytes` positive integer [1; INT32_MAX].
+- `bytes` positive integer `[1; INT32_MAX]`.
 - `ms` - positive integer value of milliseconds.
 
 | URI param            | Values           | SRT Option                | Description |
 | -------------------- | ---------------- | ------------------------- | ----------- |
 | `congestion`         | {`live`, `file`} | `SRTO_CONGESTION`         | Type of congestion control. |
 | `conntimeo`          | `ms`             | `SRTO_CONNTIMEO`          | Connection timeout. |
+| `cryptomode`         | 0..2             | `SRTO_CRYPTOMODE`         | Cryptographic mode. |
 | `drifttracer`        | `bool`           | `SRTO_DRIFTTRACER`        | Enable drift tracer. |
 | `enforcedencryption` | `bool`           | `SRTO_ENFORCEDENCRYPTION` | Reject connection if parties set different passphrase. |
 | `fc`                 | `bytes`          | `SRTO_FC`                 | Flow control window size. |
 | `groupconnect`       | {`0`, `1`}       | `SRTO_GROUPCONNECT`       | Accept group connections. |
-| `groupstabtimeo`     | `ms`             | `SRTO_GROUPSTABTIMEO`     | Group stability timeout. |
+| `groupminstabletimeo`| 60.. `ms`        | `SRTO_GROUPMINSTABLETIMEO`| Group minimum stability timeout. |
 | `inputbw`            | `bytes`          | `SRTO_INPUTBW`            | Input bandwidth. |
 | `iptos`              | 0..255           | `SRTO_IPTOS`              | IP socket type of service |
 | `ipttl`              | 1..255           | `SRTO_IPTTL`              | Defines IP socket "time to live" option. |
@@ -307,13 +375,14 @@ All other parameters are SRT socket options. The following have the following va
 | `linger`             | 0..              | `SRTO_LINGER`             | Link linger value |
 | `lossmaxttl`         | 0..              | `SRTO_LOSSMAXTTL`         | Packet reorder tolerance. |
 | `maxbw`              | 0..              | `SRTO_MAXBW`              | Bandwidth limit in bytes |
+| `mininputbw`         | 0..              | `SRTO_MININPUTBW`         | Minimum allowed estimate of `SRTO_INPUTBW` |
 | `messageapi`         | `bool`           | `SRTO_MESSAGEAPI`         | Enable SRT message mode. |
 | `minversion`         | maj.min.rev      | `SRTO_MINVERSION`         | Minimum SRT library version of a peer. |
 | `mss`                | 76..             | `SRTO_MSS`                | MTU size |
 | `nakreport`          | `bool`           | `SRTO_NAKREPORT`          | Enables/disables periodic NAK reports |
 | `oheadbw`            | 5..100           | `SRTO_OHEADBW`            | limits bandwidth overhead, percents |
 | `packetfilter`       | `string`         | `SRTO_PACKETFILTER`       | Set up the packet filter. |
-| `passphrase`         | `string`         | `SRTO_PASSPHRASE`         | Password for the encrypted transmission. |
+| `passphrase`         | `string`         | `SRTO_PASSPHRASE`         | Password for the encrypted transmission. (must be 10 to 79 characters) |
 | `payloadsize`        | 0..              | `SRTO_PAYLOADSIZE`        | Maximum payload size. |
 | `pbkeylen`           | {16, 24, 32}     | `SRTO_PBKEYLEN`           | Crypto key length in bytes. |
 | `peeridletimeo`      | `ms`             | `SRTO_PEERIDLETIMEO`      | Peer idle timeout. |
@@ -358,7 +427,7 @@ but this space must be part of the parameter and not extracted by a
 shell (using **"** **"** quotes or backslash).
 
 - **-timeout, -t, -to** - Sets the timeout for any activity from any medium (in seconds). Default is 0 for infinite (that is, turn this mechanism off). The mechanism is such that the SIGALRM is set up to be called after the given time and it's reset after every reading succeeded. When the alarm expires due to no reading activity in defined time, it will break the application. **Notes:**
-  - The alarm is set up after the reading loop has started, **not when the application has started**. That is, a caller will still wait the standard timeout to connect, and a listener may wait infinitely until some peer connects; only after the connection is established is the alarm counting started. 
+  - The alarm is set up after the reading loop has started, **not when the application has started**. That is, a caller will still wait the standard timeout to connect, and a listener may wait infinitely until some peer connects; only after the connection is established is the alarm counting started.
   - **The timeout mechanism doesn't work on Windows at all.** It behaves as if the timeout was set to **-1** and it's not modifiable.
 - **-timeout-mode, -tm** - Timeout mode used. Default is 0 - timeout will happen after the specified time. Mode 1 cancels the timeout if the connection was established.
 - **-st, -srctime, -sourcetime** - Enable source time passthrough. Default: disabled. It is recommended to build SRT with monotonic (`-DENABLE_MONOTONIC_CLOCK=ON`) or C++ 11 steady (`-DENABLE_STDCXX_SYNC=ON`) clock to use this feature.
@@ -366,9 +435,9 @@ shell (using **"** **"** quotes or backslash).
 - **-chunk, -c** - use given size of the buffer. The default size is 1456 bytes, which is the maximum payload size for a single SRT packet.
 - **-verbose, -v** - Display additional information on the standard output. Note that it's not allowed to be combined with output specified as **file://con**.
 - **-statsout** - SRT statistics output: filename. Without this option specified, the statistics will be printed to the standard output.
-- **-pf**, **-statspf** - SRT statistics print format. Values: json, csv, default.
+- **-pf**, **-statspf** - SRT statistics print format. Values: json, csv, default. After a comma, options can be specified (e.g. "json,pretty").
 - **-s**, **-stats**, **-stats-report-frequency** - The frequency of SRT statistics collection, based on the number of packets.
-- **-loglevel** - lowest logging level for SRT, one of: *fatal, error, warning, note, debug* (default: *error*)
+- **-loglevel** - lowest logging level for SRT, one of: *fatal, error, warn, note, debug* (default: *warn*)
 - **-logfa, -lfa** - selected FAs in SRT to be logged (default: all are enabled). See the list of FAs running `-help:logging`.
 - **-logfile:logs.txt** - Output of logs is written to file logs.txt instead of being printed to `stderr`.
 - **-help, -h** - Show help.
@@ -401,7 +470,7 @@ The dedicated research showed that at high and bursty data rates (~60 Mbps)
 the `epoll_wait(udp_socket)` is not fast enough to signal about the possibility
 of reading from a socket. It results in losing data when the input bitrate is very high (above 20 Mbps).
 
-PR [#1152](https://github.com/Haivision/srt/pull/1152) (v1.5.0 and above) adds the possibility
+PR [#1152](https://github.com/Haivision/srt/pull/1152) (SRT v1.4.2 and above) adds the possibility
 of setting the buffer size of the UDP socket in `srt-live-transmit`.
 Having a bigger buffer of UDP socket to store incoming data, `srt-live-transmit` handles higher bitrates.
 
diff --git a/docs/apps/srt-test-multiplex.md b/docs/apps/srt-test-multiplex.md
new file mode 100644
index 000000000..1b3d724dd
--- /dev/null
+++ b/docs/apps/srt-test-multiplex.md
@@ -0,0 +1,99 @@
+# srt-test-multiplex
+
+**srt-test-multiplex** (formerly called "SIPLEX") is a sample program that can
+send multiple streams in one direction. This tool demonstrates two SRT features:
+ - the ability to use a single UDP link (a source and destination pair
+ specified by IP address and port) for multiple SRT connections
+ - the use of the `streamid` socket option to identify multiplexed resources
+
+NOTE: To make this application compiled, you need the `-DENABLE_TESTING=1`
+cmake option.
+
+Note also that this application is intended for demonstration only. It can
+simply exit with error message in case of wrong usage or broken connection.
+
+
+## Usage
+
+`srt-test-multiplex <SRT-URI> -i <INPUT-URI1>[id1] <INPUT-URI2>[id2]...`
+
+  - Reads all given input streams and sends them each one over a separate
+  SRT connection, all using the same remote address and source port (hence
+  using the same UDP link).
+
+`srt-test-multiplex <SRT-URI> -o <OUTPUT-URI1>[id] <OUTPUT-URI2>[id]...`
+
+  - Transmits data from a multiplexed SRT stream to the specified output URI(s).
+
+An `<SRT URI>` can be identified as input or output using the **-i** or **-o**
+options. When `-i` is specified, the URIs provided are used as input, and will
+be output over the `<SRT URI>` socket. The reverse is true for any output URIs
+specified by `-o`.
+
+If SRT-URI is caller mode, then for every declared input or output medium a
+separate connection will be made, each one using the same source port (if
+specified, the same will be used for all connections, otherwise the first one
+will be automatically selected and then reused for all next ones) and with the
+`streamid` socket option set to the value extracted from the medium's
+`id` specified parameter:
+```
+URI1?id=a --> s1(streamid=a).connect(remhost:2000)
+URI2?id=b --> s2(streamid=b).connect(remhost:2000)
+URI3?id=c --> s3(streamid=c).connect(remhost:2000)
+```
+
+If SRT-URI is listener mode, then it will extract the value from `streamid`
+socket option and every accepted connection will be matched against the `id`
+parameter of the specified input or output medium.
+```
+(remhost:2000) -> accept --> s(SRT socket) --> in URI array find such that uri.id == s.streamid
+```
+
+Note that the rendezvous mode is not supported because you cannot make
+multiple connections over the same UDP link in rendezvous mode.
+
+This `streamid` is the SRT socket option (`SRTO_STREAMID` in the API). The idea
+is that it can be set on a socket used for connecting. When a listener is
+getting an accepted socket for that connection, the `streamid` socket option
+can be read from it, with the result that it will be the same as was set on
+the caller side.
+
+
+## Examples
+
+  - **Sender:**
+    - `srt-test-multiplex srt://remhost:2000 -i udp://:5000?id=low udp://:6000?id=high`
+  - **Receiver:**
+    - `srt-test-multiplex srt://:2000 -o output-high.ts?id=high output-low.ts?id=low`
+
+In this example a Sender is created which will connect to `remhost` port 2000
+using multiple SRT sockets, all of which will be using the same outgoing port.
+Here the outgoing port is automatically selected when connecting. Subsequent
+sockets will reuse that port. Alternatively you can enforce the outgoing port
+using the `port` parameter with the `<SRT URI>`.
+
+  - **Sender:**
+    - `srt-test-multiplex srt://remhost:2000?port=5555 ...`
+
+A separate connection is made for every input resource. An appropriate resource
+ID will be set to each socket assigned to that resource according to the `id`
+parameter.
+```
+           +--                                                   --+
+           |   id=1                                         id=1   |
+           |  ------                                      -------  |
+           |         \               ----->              /         |
+           |   id=2   \  ----------------------------   /   id=2   |
+port=5555 -|  --------- (   multiplexed UDP stream   ) ----------  |- port=2000
+           |          /  ----------------------------   \          |
+           |   id=3  /                                   \  id=3   |
+           |  ------                                       ------  |
+           +--                                                   --+
+```
+When a socket is accepted on the listener side (the Receiver in this example),
+srt-test-multiplex will search for the resource ID among the registered resources
+(input/output URIs) and set an ID that matches the one on the caller side. If
+the resource is not found, the connection is closed immediately.
+
+The srt-test-multiplex program works the same way for connections initiated by a
+caller or a listener.
diff --git a/docs/apps/srt-test-relay.md b/docs/apps/srt-test-relay.md
new file mode 100644
index 000000000..85789b6db
--- /dev/null
+++ b/docs/apps/srt-test-relay.md
@@ -0,0 +1,34 @@
+# srt-test-relay
+
+**srt-test-relay** is a sample program that can utilize SRT connection for
+bidirectional traffic. Hence beside the SRT connection you can specify both
+input and output media to and from which the traffic will be flipped.
+
+Effectively the specified input will be sent through the SRT connection as
+output, and the input read from the SRT connection will be redirected to
+the given output media.
+
+NOTE: To make this application compiled, you need the `-DENABLE_TESTING=1`
+cmake option.
+
+Note also that this application is intended for demonstration only. It can
+simply exit with error message in case of wrong usage or broken connection.
+
+## Usage
+
+`srt-test-relay <SRT-URI> -i <INPUT URI> -o <OUTPUT URI>`
+
+Establish a connection, send to it the stream received from INPUT URI and
+write the data read from the SRT connection to OUTPUT URI.
+
+`srt-test-relay <SRT-URI> -e -o <OUTPUT URI> <OUTPUT URI2>`
+
+Establish a connection, read the data from the SRT connection, and write
+them back over the SRT connection, and additionally write them as well
+to OUTPUT URI and OUTPUT URI2.
+
+Note that you can also control the single portion of data to be sent
+at once by one sending call by `-c` option and you can use both live
+and file mode for the connection (the latter should be simply enforced
+by `transtype` socket option).
+
diff --git a/docs/srt-tunnel.md b/docs/apps/srt-tunnel.md
similarity index 95%
rename from docs/srt-tunnel.md
rename to docs/apps/srt-tunnel.md
index b38c80038..c664173bf 100644
--- a/docs/srt-tunnel.md
+++ b/docs/apps/srt-tunnel.md
@@ -1,8 +1,7 @@
-SRT Tunnel
-==========
+# srt-tunnel
 
-Purpose
--------
+
+## Purpose
 
 SRT Tunnel is a typical tunnelling application, that is, it simply passes the
 transmission from a given endpoint to another endpoint in both directions.
@@ -22,8 +21,7 @@ longer distance, leaving TCP close to the caller and listener locations:
   --> <Tunnel: SRT->TCP> --> <TCP server>
 ```
 
-Usage
------
+## Usage
 
 The `srt-tunnel` command line accepts two argument, beside the options:
 * Listener: the URI at which this tunnel should await connections
diff --git a/docs/build/build-android.md b/docs/build/build-android.md
new file mode 100644
index 000000000..7c13c9404
--- /dev/null
+++ b/docs/build/build-android.md
@@ -0,0 +1,18 @@
+# Building SRT on Android
+
+**NOTE:** The scripts have been moved to [scripts/build-android](../../scripts/build-android/) folder.
+
+## Install the NDK and CMake
+
+The Android NDK is required to build native modules for Android.
+[Install and configure the NDK](https://developer.android.com/studio/projects/install-ndk)
+
+Consider installing the latest version of cmake. The higher version of cmake the better. As of writing the current version of CMake is 3.18.4
+You can download Cmake from the following website:
+[https://cmake.org/download](https://cmake.org/download/)
+
+## Build SRT for Android
+
+Run ```./build-android -n /path/to/ndk```. E.g. ```./build-android -n /home/username/Android/Sdk/ndk/21.4.7075529```
+
+[Include prebuilt native libraries](https://developer.android.com/studio/projects/gradle-external-native-builds#jniLibs) from ```prebuilt``` folder into Android Studio project.
diff --git a/docs/build_iOS.md b/docs/build/build-iOS.md
similarity index 90%
rename from docs/build_iOS.md
rename to docs/build/build-iOS.md
index 1ab7ac75a..a1fd48ba9 100644
--- a/docs/build_iOS.md
+++ b/docs/build/build-iOS.md
@@ -1,7 +1,7 @@
-# Building SRT for iOS
+# Building SRT on iOS
 
 ## Prerequisites
-* Xcode should be installed. Check in terminal whether `xcode-select -p` points to **/Applications/Xcode.app/Contents/Developer** 
+* Xcode should be installed. Check in terminal whether `xcode-select -p` points to **/Applications/Xcode.app/Contents/Developer**
 * Install Homebrew according to instructions on [https://brew.sh/](https://brew.sh/)
 * Install CMake and pkg-config with Homebrew:
 ```
@@ -15,7 +15,7 @@ There is [OpenSSL for iPhone](https://github.com/x2on/OpenSSL-for-iPhone) projec
 ./build-libssl.sh --archs="arm64"
 ```
 
-Results (both libraries and headers) will be placed in bin/&lt;SDK_VERSION&gt;-&lt;ARCH&gt;.sdk directory (for example, *bin/iPhoneOS11.2-arm64.sdk*). We assume you set **IOS_OPENSSL** variable to this path (e.g. `export IOS_OPENSSL="/Users/johndoe/sources/OpenSSL-for-iPhone/bin/iPhoneOS11.2-arm64.sdk"`). 
+Results (both libraries and headers) will be placed in bin/&lt;SDK_VERSION&gt;-&lt;ARCH&gt;.sdk directory (for example, *bin/iPhoneOS11.2-arm64.sdk*). We assume you set **IOS_OPENSSL** variable to this path (e.g. `export IOS_OPENSSL="/Users/johndoe/sources/OpenSSL-for-iPhone/bin/iPhoneOS11.2-arm64.sdk"`).
 
 ## Building SRT code
 Now you can build SRT providing path to OpenSSL library and toolchain file for iOS
@@ -27,10 +27,10 @@ make
 
 Optionally you may add following iOS-specifc settings to configure:
 
-* `--ios-disable-bitcode=1` - disable embedding bitcode to library. 
-* `--ios-arch=armv7|armv7s|arm64` - specify if you want to build for specific architecture (arm64 by default) 
-* `--ios-platform=OS|SIMULATOR|SIMULATOR64` - specify for build simulator code 
-* `--cmake-ios-developer-root=&lt;path&gt;`- specify path for platform directory; {XCODE_ROOT}/Platforms/iPhoneOS.platform/Developer by default 
+* `--ios-disable-bitcode=1` - disable embedding bitcode to library.
+* `--ios-arch=armv7|armv7s|arm64` - specify if you want to build for specific architecture (arm64 by default)
+* `--ios-platform=OS|SIMULATOR|SIMULATOR64` - specify for build simulator code
+* `--cmake-ios-developer-root=&lt;path&gt;`- specify path for platform directory; {XCODE_ROOT}/Platforms/iPhoneOS.platform/Developer by default
 * `--cmake-ios-sdk-root=<path>` - by default searches for latest SDK version within {CMAKE_IOS_DEVELOPER_ROOT}/SDKs, set if you want to use another SDK version
 
 Note that resulting .dylib file has install path @executable_path/Frameworks/libsrt.1.dylib, so if you need to place it in some other place with your application, you may change it with *install_name_tool* command: ``install_name_tool -id "<install_path>" <library_file>``, for example ``install_name_tool -id "@executable_path/Frameworks/libsrt.1.3.0.dylib" libsrt.1.3.0.dylib``
@@ -40,5 +40,5 @@ In Xcode project settings in General tab, add libsrt to **Linked Frameworks and
 
 Click plus sign in **Embedded binaries** section and choose Frameworks/libsrt.1.dylib
 
-In **Build settings** tab find **Header Search Paths** setting  
-and add paths to SRT library sources (you should add srt, srt/common and srt/common directories). 
+In **Build settings** tab find **Header Search Paths** setting
+and add paths to SRT library sources (you should add srt, srt/common and srt/common directories).
diff --git a/docs/build/build-linux.md b/docs/build/build-linux.md
new file mode 100644
index 000000000..678e96615
--- /dev/null
+++ b/docs/build/build-linux.md
@@ -0,0 +1,44 @@
+# Building SRT on Linux
+
+Install `cmake` and `openssl-devel` (or equivalent) packages. For `pthreads`, add
+the `-lpthreads` linker flag.
+
+Default installation path prefix of `make install` is `/usr/local`.
+
+To define a different installation path prefix, use the `--prefix` option with `configure`
+or the [`-DCMAKE_INSTALL_PREFIX`](https://cmake.org/cmake/help/v3.0/variable/CMAKE_INSTALL_PREFIX.html) CMake option.
+
+To uninstall, call `make -n install` to list all the dependencies, and then pass the list to `rm`.
+
+Here is a link to a demo showing how CMake can be used to build SRT:
+[Quickstart: Running SRT and FFmpeg on Ubuntu](https://www.youtube.com/watch?v=XOtUOVhussc&t=5s).
+
+## Ubuntu 14
+
+```shell
+sudo apt-get update
+sudo apt-get upgrade
+sudo apt-get install tclsh pkg-config cmake libssl-dev build-essential
+./configure
+make
+```
+
+## CentOS 7
+
+```shell
+sudo yum update
+sudo yum install tcl pkgconfig openssl-devel cmake gcc gcc-c++ make automake
+./configure
+make
+```
+
+## CentOS 6
+
+```shell
+sudo yum update
+sudo yum install tcl pkgconfig openssl-devel cmake gcc gcc-c++ make automake
+sudo yum install centos-release-scl-rh devtoolset-3-gcc devtoolset-3-gcc-c++
+scl enable devtoolset-3 bash
+./configure --use-static-libstdc++ --with-compiler-prefix=/opt/rh/devtoolset-3/root/usr/bin/
+make
+```
diff --git a/docs/build/build-macOS.md b/docs/build/build-macOS.md
new file mode 100644
index 000000000..b14a56197
--- /dev/null
+++ b/docs/build/build-macOS.md
@@ -0,0 +1,32 @@
+# Building SRT on macOS
+
+[Homebrew](https://brew.sh/) supports the [`srt`](https://formulae.brew.sh/formula/srt) formula.
+
+```shell
+brew update
+brew install srt
+```
+
+If you prefer using a head commit of `master` branch, add the `--HEAD` option
+to `brew` command.
+
+```shell
+brew install --HEAD srt
+```
+
+Install [CMake](https://cmake.org/) and OpenSSL with development files from `brew`. It is recommended to install the latest version of OpenSSL from the `brew` system rather than relying on the version that is presently installed in the system.
+
+```shell
+brew install cmake
+brew install openssl
+```
+
+SRT can be now built with `cmake` or `make` on Mac.
+
+```shell
+export OPENSSL_ROOT_DIR=$(brew --prefix openssl)
+export OPENSSL_LIB_DIR=$(brew --prefix openssl)"/lib"
+export OPENSSL_INCLUDE_DIR=$(brew --prefix openssl)"/include"
+./configure
+make
+```
diff --git a/docs/build/build-options.md b/docs/build/build-options.md
new file mode 100644
index 000000000..529bd5cd7
--- /dev/null
+++ b/docs/build/build-options.md
@@ -0,0 +1,722 @@
+# Build System
+
+The SRT build system uses [`CMake`](https://cmake.org/) 2.8.12 or above.
+
+A wrapper script named [`configure`](https://github.com/Haivision/srt/blob/master/configure)
+is also available. The `configure` script can simplify the build process, such as
+by trying to automatically detect the OpenSSL path in a system. Note that you must
+have the Tcl interpreter installed to use this script.
+
+
+Here is a link to a demo showing how CMake can be used to build SRT:
+[Quickstart: Running SRT and FFmpeg on Ubuntu](https://www.youtube.com/watch?v=XOtUOVhussc&t=5s).
+
+
+Additional information on building for Windows is available in the
+[Building SRT for Windows](https://github.com/Haivision/srt/blob/master/docs/build/build-win.md)
+document and in the [SRT CookBook](https://srtlab.github.io/srt-cookbook/getting-started/build-on-windows/).
+
+
+## List of Build Options
+
+The following table lists available build options in alphabetical order.
+Option details are given further below.
+
+
+| Option Name                                                  | Since | Type      | Default    | Short Description                                                                                                                                    |
+| :----------------------------------------------------------- | :---: | :-------: | :--------: | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`CMAKE_INSTALL_PREFIX`](#cmake_install_prefix)              | 1.3.0 | `STRING`  | OFF        | Standard CMake variable that establishes the root directory for installation, inside of which a GNU/POSIX compatible directory layout will be used.  |
+| [`CYGWIN_USE_POSIX`](#cygwin_use_posix)                      | 1.2.0 | `BOOL`    | OFF        | Determines when to compile on Cygwin using POSIX API.                                                                                                |
+| [`ENABLE_APPS`](#enable_apps)                                | 1.3.3 | `BOOL`    | ON         | Enables compiling sample applications (`srt-live-transmit`, etc.).                                                                                   |
+| [`ENABLE_BONDING`](#enable_bonding)                          | 1.5.0 | `BOOL`    | OFF        | Enables the [Connection Bonding](../features/bonding-quick-start.md) feature.                                                                        |
+| [`ENABLE_CXX_DEPS`](#enable_cxx_deps)                        | 1.3.2 | `BOOL`    | OFF        | The `pkg-confg` file (`srt.pc`) will be generated with the `libstdc++` library as a dependency.                                                      |
+| [`ENABLE_CXX11`](#enable_cxx11)                              | 1.2.0 | `BOOL`    | ON         | Enable compiling in C++11 mode for those parts that may require it. Default: ON except for GCC<4.7                                                   |
+| [`ENABLE_CODE_COVERAGE`](#enable_code_coverage)              | 1.4.0 | `BOOL`    | OFF        | Enables instrumentation for code coverage.                                                                                                           |
+| [`ENABLE_DEBUG`](#enable_debug)                              | 1.2.0 | `INT`     | ON         | Allows release/debug control through the `CMAKE_BUILD_TYPE` variable.                                                                                |
+| [`ENABLE_ENCRYPTION`](#enable_encryption)                    | 1.3.3 | `BOOL`    | ON         | Enables encryption feature, with dependency on an external encryption library.                                                                       |
+| [`ENABLE_AEAD_API_PREVIEW`](#enable_aead_api_preview)        | 1.5.2 | `BOOL`    | OFF        | Enables AEAD preview API (encryption with integrity check).                                                                                          |
+| [`ENABLE_MAXREXMITBW`](#enable_maxrexmitbw)                  | 1.5.3 | `BOOL`    | OFF        | Enables SRTO_MAXREXMITBW (v1.6.0 API).                                                                                                               |
+| [`ENABLE_GETNAMEINFO`](#enable_getnameinfo)                  | 1.3.0 | `BOOL`    | OFF        | Enables the use of `getnameinfo` to allow using reverse DNS to resolve an internal IP address into a readable internet domain name.                  |
+| [`ENABLE_HAICRYPT_LOGGING`](#enable_haicrypt_logging)        | 1.3.1 | `BOOL`    | OFF        | Enables logging in the *haicrypt* module, which serves as a connector to an encryption library.                                                      |
+| [`ENABLE_HEAVY_LOGGING`](#enable_heavy_logging)              | 1.3.0 | `BOOL`    | OFF        | Enables heavy logging instructions in the code that occur often and cover many detailed aspects of library behavior. Default: OFF in release mode.   |
+| [`ENABLE_INET_PTON`](#enable_inet_pton)                      | 1.3.2 | `BOOL`    | ON         | Enables usage of the `inet_pton` function used to resolve the network endpoint name into an IP address.                                              |
+| [`ENABLE_LOGGING`](#enable_logging)                          | 1.2.0 | `BOOL`    | ON         | Enables normal logging, including errors.                                                                                                            |
+| [`ENABLE_MONOTONIC_CLOCK`](#enable_monotonic_clock)          | 1.4.0 | `BOOL`    | ON\*       | Enforces the use of `clock_gettime` with a monotonic clock that is independent of the currently set time in the system.                              |
+| [`ENABLE_PROFILE`](#enable_profile)                          | 1.2.0 | `BOOL`    | OFF        | Enables code instrumentation for profiling (only for GNU-compatible compilers).                                                                      |
+| [`ENABLE_RELATIVE_LIBPATH`](#enable_relative_libpath)        | 1.3.2 | `BOOL`    | OFF        | Enables adding a relative path to a library for linking against a shared SRT library by reaching out to a sibling directory.                         |
+| [`ENABLE_SHARED`](#enable_shared--enable_static)             | 1.2.0 | `BOOL`    | ON         | Enables building SRT as a shared library.                                                                                                            |
+| [`ENABLE_SHOW_PROJECT_CONFIG`](#enable_show_project_config)  | 1.5.0 | `BOOL`    | OFF        | When ON, the project configuration is displayed at the end of the CMake Configuration Step.                                                          |
+| [`ENABLE_STATIC`](#enable_shared--enable_static)             | 1.3.0 | `BOOL`    | ON         | Enables building SRT as a static library.                                                                                                            |
+| [`ENABLE_STDCXX_SYNC`](#enable_stdcxx_sync)                  | 1.4.2 | `BOOL`    | ON\*       | Enables the standard C++11 `thread` and `chrono` libraries to be used by SRT instead of the `pthreads`.                                              |
+| [`ENABLE_PKTINFO`](#enable_pktinfo)                          | 1.5.2 | `BOOL`    | OFF\*      | Enables using `IP_PKTINFO` to allow the listener extracting the target IP address from incoming packets                                              |
+| [`ENABLE_TESTING`](#enable_testing)                          | 1.3.0 | `BOOL`    | OFF        | Enables compiling of developer testing applications (`srt-test-live`, etc.).                                                                         |
+| [`ENABLE_THREAD_CHECK`](#enable_thread_check)                | 1.3.0 | `BOOL`    | OFF        | Enables `#include <threadcheck.h>`, which implements `THREAD_*` macros" to  support better thread debugging.                                         |
+| [`ENABLE_UNITTESTS`](#enable_unittests)                      | 1.3.2 | `BOOL`    | OFF        | Enables building unit tests.                                                                                                                         |
+| [`OPENSSL_CRYPTO_LIBRARY`](#openssl_crypto_library)          | 1.3.0 | `STRING`  | OFF        | Configures the path to an OpenSSL crypto library.                                                                                                    |
+| [`OPENSSL_INCLUDE_DIR`](#openssl_include_dir)                | 1.3.0 | `STRING`  | OFF        | Configures the path to include files for an OpenSSL library.                                                                                         |
+| [`OPENSSL_SSL_LIBRARY`](#openssl_ssl_library)                | 1.3.0 | `STRING`  | OFF        | Configures the path to an OpenSSL SSL library.                                                                                                       |
+| [`PKG_CONFIG_EXECUTABLE`](#pkg_config_executable)            | 1.3.0 | `BOOL`    | OFF        | Configures the path to the `pkg-config` tool.                                                                                                        |
+| [`PTHREAD_INCLUDE_DIR`](#pthread_include_dir)                | 1.3.0 | `STRING`  | OFF        | Configures the path to include files for a `pthread` library.                                                                                        |
+| [`PTHREAD_LIBRARY`](#pthread_library)                        | 1.3.0 | `STRING`  | OFF        | Configures the path to a `pthread` library.                                                                                                          |
+| [`SRT_LOG_SLOWDOWN_FREQ_MS`](#SRT_LOG_SLOWDOWN_FREQ_MS)      | 1.5.2 | `INT`     | 1000\*     | Reduce the frequency of some frequent logs, milliseconds.                                                                                            |
+| [`USE_BUSY_WAITING`](#use_busy_waiting)                      | 1.3.3 | `BOOL`    | OFF        | Enables more accurate sending times at the cost of potentially higher CPU load.                                                                      |
+| [`USE_CXX_STD`](#use_cxx_std)                                | 1.4.2 | `STRING`  | OFF        | Enforces using a particular C++ standard (11, 14, 17, etc.) when compiling.                                                                          |
+| [`USE_ENCLIB`](#use_enclib)                                  | 1.3.3 | `STRING`  | openssl    | Encryption library to be used (`openssl`, `openssl-evp` (since 1.5.1), `gnutls`, `mbedtls`, `botan` (since 1.6.0)).                                                         |
+| [`USE_GNUSTL`](#use_gnustl)                                  | 1.3.4 | `BOOL`    | OFF        | Use `pkg-config` with the `gnustl` package name to extract the header and library path for the C++ standard library.                                 |
+| [`USE_OPENSSL_PC`](#use_openssl_pc)                          | 1.3.0 | `BOOL`    | ON         | Use `pkg-config` to find OpenSSL libraries.                                                                                                          |
+| [`OPENSSL_USE_STATIC_LIBS`](#openssl_use_static_libs)        | 1.5.0 | `BOOL`    | OFF        | Link OpenSSL statically.                                                                                                                             |
+| [`USE_STATIC_LIBSTDCXX`](#use_static_libstdcxx)              | 1.2.0 | `BOOL`    | OFF        | Enforces linking the SRT library against the static `libstdc++` library.                                                                             |
+| [`WITH_COMPILER_PREFIX`](#with_compiler_prefix)              | 1.3.0 | `STRING`  | OFF        | Sets C/C++ toolchains as `<prefix><c-compiler>` and `<prefix><c++-compiler>`, overriding the default compiler.                                       |
+| [`WITH_COMPILER_TYPE`](#with_compiler_type)                  | 1.3.0 | `STRING`  | OFF        | Sets the compiler type to be used (values: gcc, cc, clang, etc.).                                                                                    |
+| [`WITH_EXTRALIBS`](#with_extralibs)                          | 1.3.0 | `STRING`  | OFF        | Option required for unusual situations when a platform-specific workaround is needed and some extra libraries must be passed explicitly for linkage. |
+| [`WITH_SRT_NAME`](#with_srt_name)                            | 1.3.0 | `STRING`  | OFF        | Configure the SRT library name adding a custom `<prefix>`.                                                                                           |
+| <img width=425px height=1px/>                                |       |           |            |                                                                                                                                                      |
+
+
+\* See the option description for more details.
+
+## Using CMake
+
+If you choose to use CMake directly for the build configuration stage, you must
+specify option values in the CMake format:
+
+`-D<OPTION>=<VALUE>`
+
+For more information please refer to the [official CMake documentation](https://cmake.org/documentation/).
+
+The following example shows how to disable the inclusion of sample SRT applications
+(such as `srt-live-transmit`) in the build configuration, where `./` specifies
+the relative path to the main `CMakeLists.txt` file located in the root folder
+of the SRT project.
+
+In this example CMake is run from the root SRT directory:
+
+```cmake
+cmake ./ -DENABLE_APPS=OFF
+```
+
+
+SRT build options known to CMake are listed in the
+[CMakeLists.txt](https://github.com/Haivision/srt/blob/master/CMakeLists.txt) file as:
+
+`option(<name> <description> <default value>)`.
+
+For example:
+
+`option(CYGWIN_USE_POSIX "Should the POSIX API be used for cygwin. Ignored if the system isn't cygwin." OFF)
+`
+With CMake you would specify this option as:
+
+`cmake -DCYGWIN_USE_POSIX=ON` or `cmake -DCYGWIN_USE_POSIX=OFF`
+
+where “-D” is the CMake command to set a build variable to a certain value.
+
+
+
+## Using the Configure Script
+
+This script is similar in design to the
+[Autotools](https://www.gnu.org/software/automake/manual/html_node/Autotools-Introduction.html)
+`configure` script, and so accepts `--long-options`, with or without values. It
+handles two kinds of options:
+
+* options that are directly translated to `cmake` variables.
+
+* special options to be resolved inside the script that may do some
+advanced checks; these should later be converted into a set of specific `cmake`
+variable declarations
+
+The directly translated options always undergo a simple transformation:
+
+* all letters are converted to uppercase
+* dashes are converted to underscores
+* plus (+) symbols are converted to X
+* when no value is supplied, a default value of 1 is applied
+
+To set the `CYGWIN_USE_POSIX` option using the configure script you would call
+
+`configure --cygwin-use-posix`
+
+which is transformed by the script into `-DCYGWIN-USE-POSIX` and then passed
+to `cmake` to enable POSIX (set to ON). To disable the option (set to OFF) using
+the configure script you would call
+
+`configure –-disable-cygwin-use-posix`
+
+In another example, to enable compiling in C++11 mode with the CMake command
+`ENABLE-C++11` using the configure script you would call
+
+`configure --enable-c++11`
+
+which is transformed by the script into `-DENABLE_CXX11=1` and then passed
+to `cmake`.
+
+Additionally, if you specify `--disable-<X>`, the `configure` script
+will automatically turn it into an associated `--enable-<X>` option,
+ passing `0` as its value. For example, `--disable-encryption` will
+be translated for `cmake` into `-DENABLE_ENCRYPTION=0`.
+
+
+## Build Options
+
+The CMake options available for building SRT are listed below, along with the
+equivalent `configure` format.
+
+
+#### CMAKE_INSTALL_PREFIX
+**`--cmake-install-prefix=<path>`**
+
+Used to configure an alias to the `--cmake-install-prefix` variable that
+establishes the root directory for installation, inside of which a GNU/POSIX
+compatible directory layout will be used. As on all known build systems, this
+defaults to `/usr/local` on GNU/POSIX compatible systems, with lower level
+GNU/POSIX directories created inside: `/usr/local/bin`,`/usr/local/lib`, etc.
+
+
+#### CYGWIN_USE_POSIX
+**`--cygwin-use-posix`** (default:OFF)
+
+Set to ON to compile SRT on Cygwin using the POSIX API (otherwise it will use
+MinGW environment).
+
+
+#### ENABLE_APPS
+**`--enable-apps`** (default: ON)
+
+Enables compiling user applications.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### ENABLE_BONDING
+**`--enable-bonding`** (default: OFF)
+
+Enables the [Connection Bonding](../features/bonding-quick-start.md) feature.
+
+Similar to SMPTE-2022-7 over managed networks, Connection Bonding adds seamless stream protection and hitless failover to the SRT protocol. This technology relies on more than one IP network path to prevent disruption to live video streams in the event of network congestion or outages, maintaining continuity of service.
+
+This is accomplished using the [socket groups](../features/socket-groups.md) introduced in [SRT v1.5](https://github.com/Haivision/srt/releases/tag/v1.5.0). The general concept of socket groups means having a group that contains multiple sockets, where one operation for sending one data signal is applied to the group. Single sockets inside the group will take over this operation and do what is necessary to deliver the signal to the receiver.
+
+Two modes are supported:
+
+- [Broadcast](../features/socket-groups.md#1-broadcast) - In *Broadcast* mode, data is sent redundantly over all the member links in a group. If one of the links fails or experiences network jitter and/or packet loss, the missing data will be received over another link in the group. Redundant packets are simply discarded at the receiver side.
+
+- [Main/Backup](../features/bonding-main-backup.md) - In *Main/Backup* mode, only one (main) link at a time is used for data transmission while other (backup) connections are on standby to ensure the transmission will continue if the main link fails. The goal of Main/Backup mode is to identify a potential link break before it happens, thus providing a time window within which to seamlessly switch to one of the backup links.
+
+With the Connection Bonding feature disabled, [bonding API functions](../API/API-functions.md#socket-group-management) are present, but return an error.
+
+
+#### ENABLE_CXX_DEPS
+**`--enable-c++-deps`** (default: OFF)
+
+When ON, the `pkg-confg` file (`srt.pc`) will be generated with the `libstdc++`
+library as a dependency. This may be required in some cases where you have an
+application written in C which therefore won't link against `libstdc++` by default.
+
+
+#### ENABLE_CXX11
+**`--enable-c++11`** (default: ON except for GCC<4.7)
+
+When ON, enables compiling in C++11 mode for those components that may require it.
+Components that don't require it will still be compiled in C++03 mode,
+although which components are affected may change in future.
+
+If this option is turned OFF, it affects building a project in two ways:
+
+* an alternative C++03 implementation can be used, if available
+* otherwise the component that requires it will be disabled
+
+Components that currently require C++11 and have no alternative implementation
+are:
+
+* unit tests
+* user and testing applications (such as `srt-live-transmit`)
+* some of the example applications
+
+It should be possible to compile the SRT library without C++11 support. However,
+any alternative C++03 implementation may be unsupported on certain platforms.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### ENABLE_CODE_COVERAGE
+**`--enable-code-coverage`** (default: OFF)
+
+When ON, enables instrumentation for code coverage. Note that this is only available
+on platforms with a GNU-compatible compiler.
+
+
+#### ENABLE_DEBUG
+**`--enable-debug=<0,1,2>`**
+
+This option allows control through the `CMAKE_BUILD_TYPE` variable:
+
+* 0 (default): `Release` (highly optimized, no debug info)
+* 1: `Debug` (not optimized, full debug info)
+* 2: `RelWithDebInfo` (highly optimized, but with debug info)
+
+Please note that when the value is other than 0, the
+[`--enable-heavy-logging`](#enable-heavy-logging) option is also turned ON by default.
+
+
+#### ENABLE_ENCRYPTION
+**`--enable-encryption`** (default: ON)
+
+When ON, the encryption feature is enabled. This involves a dependency on an
+external encryption library (default: [openssl](https://github.com/openssl/openssl)).
+If you disable encryption, the library will be unable to set encryption options.
+It will be compatible with a peer that has encryption enabled, but just won't
+use encryption for the connection.
+
+
+#### ENABLE_AEAD_API_PREVIEW
+**`--enable-aead-api-preview`** (default: OFF)
+
+When ON, the AEAD API is enabled. The `ENABLE_ENCRYPTION` must be enabled as well.
+The AEAD functionality is only available if either OpenSSL EVP or Botan is selected
+as the crypto provider:
+build option `-DUSE_ENCLIB=[openssl-evp | botan]`.
+
+The AEAD API is to be official in SRT v1.6.0.
+
+#### ENABLE_MAXREXMITBW
+**`--enable-maxrexmitbw`** (default: OFF)
+
+When ON, the `SRTO_MAXREXMITBW` is enabled (to become official in SRT v1.6.0).
+
+
+#### ENABLE_GETNAMEINFO
+**`--enable-getnameinfo`** (default: OFF)
+
+When ON, enables the use of `getnameinfo` with options that allow using reverse
+DNS to resolve an internal IP address into a readable internet domain name, so
+that it can be shown nicely in the log file. This option is turned OFF by default
+because it may have an impact on general performance. It is recommended only for
+development when testing on a local network.
+
+
+#### ENABLE_HAICRYPT_LOGGING
+**`--enable-haicrypt-logging`** (default: OFF)
+
+When ON, enables logging in the *haicrypt* module, which serves as a connector to
+an encryption library. Logging here might be seen as unsafe, therefore this
+option is turned OFF by default.
+
+The log corresponds to the `HAICRYPT` functional area.
+Enabling `HAICRYPT` logging in the build does not enable the `HAICRYPT` functional area
+in the logging configuration.
+
+Please use the
+[`srt_addlogfa(SRT_LOGFA_HAICRYPT)`](../API/API-functions.md#srt_addlogfa)
+to enable `HAICRYPT` logging via the SRT API.
+To enable the logging in `srt-live-transmit` use `--logfa haicrypt`
+in combination with the required `--loglevel`.
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### ENABLE_HEAVY_LOGGING
+**`--enable-heavy-logging`** (default: OFF in release mode)
+
+When ON, this option enables logging instructions in the code, which are considered
+heavy as they occur often and cover many detailed aspects of library behavior.
+Turning this option ON will allow you to use the `debug` level of logging and get
+detailed information as to what happens inside the library. Note, however, that
+this may influence processing by changing timings, use less preferred thread
+switching layouts, and generally worsen the functionality and performance of
+the library. For these reasons this option is turned OFF by default.
+
+
+#### ENABLE_INET_PTON
+**`--enable-inet-pton`** (default: ON)
+
+When ON, enables usage of the `inet_pton` function by applications, which should
+be used to resolve the network endpoint name into an IP address. This may not be
+available in some versions of Microsoft Windows, in which case you can change the
+setting to OFF. When this option is OFF, however, IP addresses cannot be resolved
+by name, as the `inet_pton` function gets a poor-man's simple replacement that can
+only resolve numeric IPv4 addresses.
+
+
+#### ENABLE_LOGGING
+**`--enable-logging`** (default: ON)
+
+When ON, enables logging. When you turn this option OFF, the library will not
+report any runtime information, including errors, through the logging system. This
+option may be useful if you suspect the logging system of impairing performance.
+
+
+#### ENABLE_MONOTONIC_CLOCK
+**`--enable-monotonic-clock`** (default: OFF)
+
+**NOTE**: The library can get stuck if the system clock is used instead of
+monotonic or C++11 steady. Since v1.4.4 `ENABLE_MONOTONIC_CLOCK` is enabled by
+default on POSIX-type systems if support for CLOCK_MONOTONIC is detected.
+On Windows `ENABLE_STDCXX_SYNC` is enabled by default. It is highly recommended
+to use either of those (`ENABLE_STDCXX_SYNC` excludes `ENABLE_MONOTONIC_CLOCK`).
+
+When ON, this option enforces the use of `clock_gettime` to get the current
+time, instead of `gettimeofday`. This function forces the use of a monotonic
+clock that is independent of the currently set time in the system.
+The condition variables (CV), for which the `*_timedwait()` functions are used
+with time specification based on the time obtained from `clock_gettime`,
+must be appropriately configured. For now, this is only done for the
+garbage collector controlling CV, not every CV used in SRT. The consequence
+of enabling this option, however, may be portability issues resulting from
+the fact that the `clock_gettime` function may be unavailable in some SDKs, or
+that an extra `-lrt` option is sometimes required (this requirement will be
+autodetected).
+
+The problem is based on the fact that POSIX functions that use timeout
+specification (all of `*_timedwait`) expect the absolute time value.
+A relative timeout value can be then only specified by adding it to
+the current time, which can be specified using either the system or monotonic
+clock (as configured in the resources used in the operation).
+However the current time of the monotonic clock can only be obtained by
+the `clock_gettime` function.
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### ENABLE_PROFILE
+**`--enable-profile`** (default: OFF)
+
+When ON, enables code instrumentation for profiling (only available for
+GNU-compatible compilers).
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### ENABLE_RELATIVE_LIBPATH
+**`--enable-relative-libpath`** (default: OFF)
+
+When ON, enables adding a relative path to a library. This allows applications to
+be linked against a shared SRT library by reaching out to a sibling `../lib`
+directory, provided that the library and applications are installed in POSIX/GNU
+style directories. This might be useful when installing SRT and applications
+in a directory in which the library subdirectory is not explicitly defined
+among the global library paths. Consider, for example, this application and its
+required library:
+
+* `/opt/srt/bin/srt-live-transmit`
+* `/opt/srt/lib64/libsrt.so`
+
+By using the `--enable-relative-libpath` option, the `srt-live-transmit`
+application has a relative library path defined inside as `../lib64`. A dynamic
+linker will find the required `libsrt.so` file by this path: `../lib64/libsrt.so`.
+This way the dynamic linkage will work even if the `/opt/srt/lib64` path isn't added
+to the system paths in `/etc/ld.so.conf` or in the `LD_LIBRARY_PATH` environment
+variable.
+
+This option is OFF by default because of reports that it may cause problems with
+default installations.
+
+
+#### ENABLE_SHARED | ENABLE_STATIC
+**`--enable-shared`** and **`--enable-static`** (default for both: ON)
+
+When ON, enables building SRT as a shared and/or static library, as required for
+your application. In practice, you would only disable one or the other
+(e.g. by `--disable-shared`). Note that you can't disable both at once.
+
+
+#### ENABLE_SHOW_PROJECT_CONFIG
+**`--enable-show-project-config`** (default:OFF)
+
+When ON, the project configuration is displayed at the end of the CMake
+configuration step of the build process.
+
+
+#### ENABLE_STDCXX_SYNC
+**`--enable-stdcxx-sync`** (default: OFF)
+
+**NOTE**: The library can get stuck if the system clock is used instead of
+monotonic or C++11 steady. Since v1.4.4 `ENABLE_STDCXX_SYNC`is enabled by
+default on Windows. On POSIX-type systems, an alternative `ENABLE_MONOTONIC_CLOCK` option is enabled by default if support for CLOCK_MONOTONIC is detected. It is highly recommended
+to use either of those (`ENABLE_STDCXX_SYNC` excludes `ENABLE_MONOTONIC_CLOCK`).
+
+When ON, this option enables the standard C++ `thread` and `chrono` libraries
+(available since C++11) to be used by SRT instead of the `pthreads` libraries.
+
+#### ENABLE_PKTINFO
+**`--enable-pktinfo`** (default: OFF)
+
+This allows the use of the `IP_PKTINFO` control message to extract the true target IP
+address from the incoming UDP packets to a listener bound to "any" address. The "any"
+address is defined in IPv4 as 0.0.0.0 (`INADDR_ANY`) and in IPv6 as :: (`in6addr_any`).
+Applications usually implement it by clearing the `sockaddr*` structure and only setting
+the port number. This true address can then be used to override the source IP address
+when sending packets to the peer. This solves the problem where routing rules
+in an agent's host send a packet using a different source IP address than the  target
+IP address in the UDP packet from the peer. The peer will reject such a packet as a
+suspected man-in-the-middle (MITM) attempt, leading to a connection failure.
+
+This problem has been observed where an agent's host has at least
+two IP addresses that share the same broadcast prefix, and it is being contacted
+by a peer using an address other than the first one. For example:
+
+The host has set the following local IP addresses:
+
+  (1) 192.168.10.5 - routing to 192.168.10.1
+  (2) 10.10.5.10 - routing to 10.10.5.1
+  (3) 10.10.5.20 - routing to 10.10.5.1
+
+For all of them the netmask is 255.255.255.0, which means that the second
+and third IP addresses share the same broadcast prefix (10.10.5.0).
+The problem occurs when an agent running on this host is contacted
+by a peer using the address 10.10.5.20.
+
+In such a case the source address set in the UDP packet being sent will
+always be the first of these addresses (10.10.5.10), which will be different
+from the one from which the packet is actually being sent (10.10.5.20).
+The peer will then reject such a packet because its source address is different.
+
+This problem occurs only with listener sockets bound to "any" address - when it
+is bound to a specific IP address, this will be always set as source address
+for outgoing packets.
+
+By enabling this feature SRT mitigates the problem by first reading the real
+target IP address from the incoming handshake packet, and then forcing this
+specific address to be set in the source address field of every UDP packet sent
+from this socket. This behavior is also consistent with TCP.
+
+Note that this feature is available only on certain platforms. Notably the BSD
+systems are known to not provide this feature and the current implementation
+doesn't support this feature on Windows systems.
+
+
+#### ENABLE_TESTING
+**`--enable-testing`** (default: OFF)
+
+When ON, enables compiling of developer testing applications.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+
+#### ENABLE_THREAD_CHECK
+**`--enable-thread-check`** (default: OFF)
+
+When ON, enables `#include <threadcheck.h>`, which implements `THREAD_*` macros
+to support better thread debugging. Included to support an existing project.
+
+
+#### ENABLE_UNITTESTS
+**`--enable-unittests`** (default: OFF)
+
+When ON, this option enables unit tests, possibly with the download
+and installation of the Google test library in the build directory. The tests
+will be run as part of the build process. This is intended for developers only.
+
+
+#### OPENSSL_CRYPTO_LIBRARY
+**`--openssl-crypto-library=<filepath>`**
+
+Used to configure the path to an OpenSSL crypto library. Ignored when encryption
+is disabled (ENABLE_ENCRYPTION = OFF). See [`USE_ENCLIB`](#use_enclib) for the list of supported libraries.
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### OPENSSL_INCLUDE_DIR
+**`--openssl-include-dir=<path>`**
+
+Used to configure the path to include files for an OpenSSL library.
+
+
+#### OPENSSL_SSL_LIBRARY
+**`--openssl-ssl-library=<filepath>`**
+
+Used to configure the path to an OpenSSL SSL library.
+
+
+#### PKG_CONFIG_EXECUTABLE
+**`--pkg-config-executable=<filepath>`**
+
+Used to configure the path to the `pkg-config` tool.
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### PTHREAD_INCLUDE_DIR
+**`--pthread-include-dir=<path>`**
+
+Used to configure the path to include files for a `pthread` library. Note that
+this is useful only on Windows. On Linux and macOS this path should be available
+in the system.
+
+
+#### PTHREAD_LIBRARY
+**`--pthread-library=<filepath>`**
+
+Used to configure the path to a `pthread` library.
+
+
+#### SRT_LOG_SLOWDOWN_FREQ_MS
+**`--srt-log-slowdown-freq-ms=<ms>`** (DEFAULT 1000 ms; or 0 ms if `ENABLE_HEAVY_LOGGING`)
+
+Reduce the frequency of some frequent logs, milliseconds.
+
+- Decryption failure warning message (`SRT_LOGFA_QUE_RECV`).
+
+
+#### USE_BUSY_WAITING
+**`--use-busy-waiting`** (default: OFF)
+
+When ON, enables more accurate sending times at the cost of potentially higher
+CPU load.
+
+This option will cause more empty loop running, which may cause more CPU usage.
+Keep in mind, however, that when processing high bitrate streams the share of
+empty loop runs will decrease as the bitrate increases. This way higher CPU
+usage would still be productive, while without system-supported waiting this
+option may increase the likelihood of switching to the right thread at the time
+when it is expected to be revived.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### USE_CXX_STD
+**`--use-c++-std=<standard>`**
+
+Enforces using a particular C++ standard when compiling. When using this option
+remember that:
+
+* Allowed values are: 98, 03, 11, 14, 17 and 20
+* If you use 98/03 and `--enable-apps`, apps will be still using C++11
+* This option is only supported on GNU and Clang compilers (will be ignored on others).
+
+
+#### USE_ENCLIB
+**`--use-enclib=<name>`**
+
+Encryption library to be used. Possible options for `<name>`:
+
+* openssl-evp (default)
+* openssl 
+* gnutls (with nettle)
+* mbedtls
+* botan
+
+
+#### USE_GNUSTL
+**`--use-gnustl`**
+
+Use `pkg-config` with the `gnustl` package name to extract the header and
+library path for the C++ standard library (instead of using the compiler
+built-in one).
+
+
+#### USE_OPENSSL_PC
+**`--use-openssl-pc`** (default: ON)
+
+When ON, uses `pkg-config` to find OpenSSL libraries. You can turn this OFF to
+force `cmake` to find OpenSSL by its own preferred method.
+
+### OPENSSL_USE_STATIC_LIBS
+**`--openssl-use-static-libs`** (default: OFF)
+
+When ON, OpenSSL libraries are linked statically.
+When `pkg-config`(`-DUSE_OPENSSL_PC=ON`) is used, static OpenSSL libraries are listed in `SSL_STATIC_LIBRARIES`. See `<prefix>_STATIC` in [CMake's FindPkgConfig](https://cmake.org/cmake/help/latest/module/FindPkgConfig.html).
+On Windows additionally links `crypt32.lib`.
+
+#### USE_STATIC_LIBSTDCXX
+**`--use-static-libstdc++`** (default: OFF)
+
+When ON, enforces linking the SRT library against the static `libstdc++` library.
+This may be useful if you are using SRT library in an environment where it would
+by default link against the wrong version of the C++ standard library, or when
+the library in the version used by the compiler is not available as shared.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### WITH_COMPILER_PREFIX
+**`--with-compiler-prefix=<prefix>`**
+
+Sets C/C++ toolchains as `<prefix><c-compiler>` and `<prefix><c++-compiler>`.
+
+This option will override the default compiler autodetected by `cmake`.
+It is handled inside `cmake`. It sets the variables `CMAKE_C_COMPILER` and
+`CMAKE_CXX_COMPILER`. The values for the above `<c-compiler>` and `<c++-compiler>`
+are controlled by the [`--with-compiler-type`](#with-compiler-type) option.
+When this option is not supplied, one of the following system-default compilers
+will be used:
+
+* On Mac OS (Darwin): clang
+* On other POSIX systems: gcc
+* On other systems: compiler obtained from the `CMAKE_C_COMPILER` variable
+
+Instead of `--with-compiler-prefix` you can use [`--cmake-c-compiler`](#cmake-c-compiler)
+and [`--cmake-c++-compiler`](#cmake-c++-compiler) options. This can be thought of
+as a shortcut, useful when you have a long path to the compiler command.
+
+NOTE: The specified prefix is meant to simply precede the compiler type. If your
+prefix is a full path to the compiler, it must include the terminal path
+separator character, as this can also be used as a prefix for a platform-specific
+cross compiler. For example, if the path to the C compiler is:
+
+`/opt/arm-tc/bin/arm-linux-gnu-gcc-7.4`,
+
+then you should specify:
+
+`--with-compiler-prefix=/opt/arm-tc/bin/arm-linux-gnu-`
+and `--with-compiler-type=gcc-7.4`.
+
+
+#### WITH_COMPILER_TYPE
+**`--with-compiler-type=<name>`**
+
+Sets the compiler type to be used as `<c-compiler>` and `<c++-compiler>`
+respectively:
+
+* gcc (default): gcc and g++
+* cc: cc and c++
+* others: use `<name>` as C compiler and `<name>++` as C++ compiler
+
+This should be the exact command used when specifying a C compiler, possibly
+with version suffix, e.g. `clang-1.7.0`. If this option is used together
+with `--with-compiler-prefix`, its prefix will be added in front.
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
+
+
+#### WITH_EXTRALIBS
+**`--with-extralibs=<library-list>`**
+
+This is an option for unusual situations where a platform-specific
+workaround is needed, and some extra libraries must be passed explicitly
+for linkage. The argument is a space-separated list of linker options
+or library names.
+
+There are some known situations where it may be necessary:
+
+1. Some older Linux systems do not ship `clock_gettime` functions by
+default in their `libc`, and need an extra `librt`. If you are using POSIX
+monotonic clocks (see [`--enable-monotonic-clock`](#enable-monotonic-clock)), it
+might be required to add `-lrd` through this option. Although this situation is
+usually autodetected (and the option added automatically), it does sometimes fail.
+
+2. On some systems (e.g. OpenSuSE), if you use C++11 sync
+(see [`--enable-stdc++-sync`](#enable-stdc++-sync)), the gcc compiler relies on
+`gthreads`, which relies on `pthreads`, and happens to define inline source
+functions in the header that refer to `pthread_create`. The compiler, however,
+doesn't link against `pthreads` by default. To work around this, add `-pthreads`
+using this option.
+
+
+#### WITH_SRT_NAME
+**`--with-srt-name=<prefix>`**
+
+Overrides the SRT library name, adding a custom `<prefix>`
+
+
+
+[:arrow_up: &nbsp; Back to List of Build Options](#list-of-build-options)
diff --git a/docs/build-win.md b/docs/build/build-win.md
similarity index 89%
rename from docs/build-win.md
rename to docs/build/build-win.md
index f3c3c1b3c..e8a1e6351 100644
--- a/docs/build-win.md
+++ b/docs/build/build-win.md
@@ -1,20 +1,20 @@
-# SRT Build Instructions
+# Building SRT on Windows
 
 <!-- TOC -->
 
 - [1. Prerequisites](#1-prerequisites)
   - [1.1. Build Tool Dependencies](#11-build-tool-dependencies)
   - [1.2. External Library Dependencies](#12-external-library-dependencies)
-    - [1.2.1. Cryptographic Library](#121-Cryptographic-library)
+    - [1.2.1. Cryptographic Library](#121-cryptographic-library)
     - [1.2.2. Threading Library](#122-threading-library)
   - [1.3. Package Managers](#13-package-managers)
     - [1.3.1. VCpkg Packet Manager (optional)](#131-vcpkg-packet-manager-optional)
     - [1.3.2. NuGet Manager (optional)](#132-nuget-manager-optional)
 - [2. Preparing Dependencies](#2-preparing-dependencies)
-  - [2.1. Cryptographic Library](#21-Cryptographic-library)
+  - [2.1. Cryptographic Library](#21-cryptographic-library)
     - [2.1.1. Install OpenSSL](#211-install-openssl)
       - [2.1.1.1. Using vcpkg](#2111-using-vcpkg)
-      - [2.1.1.2. Using Installer](#2112-using-installer)
+      - [2.1.1.2. Using Installer](#2112-using-installer-windows)
       - [2.1.1.3. Build from Sources](#2113-build-from-sources)
     - [2.1.2. Install MbedTLS](#212-install-mbedtls)
     - [2.1.3. Install LibreSSL](#213-install-libressl)
@@ -23,11 +23,11 @@
     - [2.2.2. Building PThreads](#222-building-pthreads)
       - [2.2.2.1. Using vcpkg](#2221-using-vcpkg)
       - [2.2.2.2. Using NuGet](#2222-using-nuget)
-      - [2.2.2.3. Build pthreads4w from Sources](#2114-build-pthreads4w-from-sources)
-      - [2.2.2.4. Build pthread-win32 from Sources](#2114-build-pthread-win32-from-sources)
+      - [2.2.2.3. Build pthreads4w from Sources](#2223-build-pthreads4w-from-sources)
+      - [2.2.2.4. Build pthread-win32 from Sources](#2224-build-pthread-win32-from-sources)
 - [3. Building SRT](#3-building-srt)
   - [3.1. Cloning the Source Code](#31-cloning-the-source-code)
-  - [3.2. Generate Build Files](#32-generating-build-files)
+  - [3.2. Generate Build Files](#32-generate-build-files)
   - [3.3. Build SRT](#33-build-srt)
 
 <!-- /TOC -->
@@ -54,7 +54,7 @@ only unencrypted mode can be used.
 With the enabled SRT encryption,
 one of the following Crypto libraries is required:
 
-- `OpenSSL` (default)
+- `OpenSSL` (**default**)
 - `LibreSSL`
 - `MbedTLS`
 
@@ -62,17 +62,22 @@ one of the following Crypto libraries is required:
 
 SRT as of v1.4.2 supports two threading libraries:
 
-- `pthreads` (default)
-- Standard C++ thread library available in C++11 (recommended for Windows)
+- Standard C++ thread library available in C++11 (**default on Windows**)
+- `pthreads` (not recommended on Windows)
 
 The `pthreads` library is provided out-of-the-box on all POSIX-based systems.
 On Windows it can be provided as a 3rd party library (see below).
-However the C++ standard thread library is recommended to be used on Windows.
+However, using pthread wrapper on Windows comes with limitations, e.g. converting time from POSIX-based to Windows-based might loose precision, monotonic clock implementation eventually uses wall clock, etc.
+**The C++11 standard thread library is recommended to be used on Windows.**
 
 ### 1.3. Package Managers
 
 #### 1.3.1. VCpkg Packet Manager (optional)
 
+Can be used to:
+- build OpenSSL library (dependency of SRT).
+- build pthreads library (dependency of SRT).
+
 [vcpkg](https://github.com/microsoft/vcpkg) is a C++ library manager for Windows, Linux and MacOS.
 Consider its [prerequisites](https://github.com/microsoft/vcpkg/blob/master/README.md#quick-start) before proceeding.
 
@@ -146,7 +151,7 @@ CMake will be able to find openssl given the following option is provided:
 ##### 2.1.1.2. Using Installer (Windows)
 
 The 64-bit OpenSSL package for Windows can be downloaded using
-the following link: [Win64OpenSSL_Light-1_1_1c](http://slproweb.com/download/Win64OpenSSL_Light-1_1_1c.exe).
+the following link: [Win64OpenSSL-3_0_5](https://slproweb.com/download/Win64OpenSSL-3_0_5.exe).
 
 **Note!** The last letter or version number may change and older versions may become no longer available. In that case find the appropriate installer here: [Win32OpenSSL](http://slproweb.com/products/Win32OpenSSL.html).
 
@@ -181,8 +186,8 @@ to specify the directory that will contain the LibreSSL headers and libraries.
 
 SRT can use one of these two threading libraries:
 
-- C++11 threads (SRT v1.4.2 and above) - recommended for Windows
-- `pthreads` (default)
+- C++11 threads (SRT v1.4.2 and above) - recommended, default since SRT v1.4.4;
+- `pthreads` (not recommended on Windows).
 
 #### 2.2.1. Using C++11 Threading
 
@@ -193,6 +198,8 @@ Otherwise the external PThreads for Windows wrapper library is required.
 
 #### 2.2.2. Building PThreads
 
+It is not recommended to use `pthreads` port on Windows. Consider using [C++11 instead](#221-using-c11-threading),
+
 ##### 2.2.2.1. Using vcpkg
 
 **Note!** The `vcpkg` working directory is referenced as `VCPKG_ROOT`.
diff --git a/docs/build/package-managers.md b/docs/build/package-managers.md
new file mode 100644
index 000000000..bcd6cea21
--- /dev/null
+++ b/docs/build/package-managers.md
@@ -0,0 +1,35 @@
+# Package Managers
+
+<a href="https://repology.org/project/srt/versions">
+    <img src="https://repology.org/badge/vertical-allrepos/srt.svg" alt="Packaging status" align="right">
+</a>
+
+The SRT library can be installed with the help of the following package managers:
+
+- [Vcpkg](https://github.com/Microsoft/vcpkg)
+
+  The SRT library package name is `libsrt`. For example, to install the library on Unix systems, run:
+
+  ```
+  ./vcpkg install libsrt
+  ```
+
+  The `libsrt` port in `vcpkg` is kept up to date by Microsoft team members and community contributors. If the SRT version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the `vcpkg` repository.
+
+- [Homebrew](https://brew.sh/)
+
+  The `Homebrew` formula is [`srt`](https://formulae.brew.sh/formula/srt). See also ["Building SRT on macOS"](./build-macOS.md).
+
+  ```
+  brew install srt
+  ```
+
+- [Apt](https://ubuntu.com/server/docs/package-management)
+
+  ```
+  sudo apt install libsrt
+  ```
+
+- [Conan](https://conan.io/)
+
+  The SRT library package name is [`srt`](https://conan.io/center/srt).
diff --git a/docs/DevelopersGuide.md b/docs/dev/developers-guide.md
similarity index 72%
rename from docs/DevelopersGuide.md
rename to docs/dev/developers-guide.md
index 3114f4f9e..3b0e1c7b6 100644
--- a/docs/DevelopersGuide.md
+++ b/docs/dev/developers-guide.md
@@ -5,6 +5,7 @@
   * [Forking SRT on GitHub](#forking-srt-on-github)
   * [Building SRT](#building-srt)
 * [Project Structure](#project-structure)
+* [Versioning](#versioning)
 * [Coding Rules](#coding-rules)
 * [Submitting an Issue](#submitting-an-issue)
 * [Submitting a Pull Request](#submitting-a-pull-request)
@@ -66,28 +67,52 @@ cmake .. -DENABLE_UNITTESTS=ON
 cmake --build ./
 ```
 
-**Note.** If you're using Windows, please refer to [Windows Build Instructions](./build-win.md).
+**Note.** If you are using Windows, please refer to [Building SRT for Windows](../build/build-win.md) instructions.
 
-**Note.** Please see the following document for the build options: [BuildOptions.md](./BuildOptions.md).
+**Note.** Please see the following document for the build options: [SRT Build Options](../build/build-options.md).
 To see the full list of make options run `cmake .. -LAH` from the `_build` folder.
 
 **Note.** There is an alternative `configure` script provided. It is **NOT** an alternative Autotools build, but a convenience script.
 It processes the usual format of `--long-options` and calls `cmake` with appropriate options in the end. This script is dependent on "tcl" package.
-Please see the following document for `configure` usage: [BuildOptions.md](./BuildOptions.md).
+Please see the following document for `configure` usage: [SRT Build Options](../build/build-options.md).
 
 The build output is in the `_build` directory. The following applications can be found there.
 
-* `srt-live-transmit` — A sample application to transmit a live stream from source medium (UDP/SRT/`stdin`)
-to the target medium (UDP/SRT/`stdout`). See [srt-live-transmit.md](./srt-live-transmit.md) for more info.
-* `srt-file-transmit` — A sample application to transmit files with SRT.
-* `srt-tunnel` — A sample application to set up an SRT tunnel for TCP traffic. See [srt-tunnel.md](./srt-tunnel.md) for more info.
+* `srt-live-transmit` - A sample application to transmit a live stream from source medium (UDP/SRT/`stdin`)
+to the target medium (UDP/SRT/`stdout`). See [Using the `srt-live-transmit` App](../apps/srt-live-transmit.md) for more info.
+* `srt-file-transmit` - A sample application to transmit files with SRT.
+* `srt-tunnel` - A sample application to set up an SRT tunnel for TCP traffic. See [Using the `srt-tunnel` App](../apps/srt-tunnel.md) for more info.
 * `tests-srt` - unit testing application.
 
+## Language standard requirements
+
+The following conventions for the language standard are used in this project:
+
+1. The SRT library requires C++03 (also known as C++98) standard.
+2. The examples (to be enabled in cmake by `-DENABLE_EXAMPLES=1`) require either C++03 or C89 standard.
+3. The following require C++11 standard:
+   * demo applications
+   * testing applications (to be enabled in cmake by `-DENABLE_TESTING=1`)
+   * unit tests (to be enabled in cmake by `-DENABLE_UNITTESTS=1`)
+
+Note that C++11 standard will be enforced if you have enabled applications
+and haven't specified the C++ standard explicitly. When you have an old compiler
+that does not support C++11 and you want to compile as many parts as possible,
+the simplest way is to use the following options (in cmake):
+
+```
+-DENABLE_APPS=0 -DUSE_CXX_STD=03 -DENABLE_EXAMPLES=1
+```
+
+Note also that there are several other options that, when enabled, may require
+that the SRT library be compiled using C++11 standard (`-DENABLE_STDCXX_SYNC=1`
+for example).
+
 ## Project Structure
 
 The SRT installation has the following folders:
 
-* apps - the folder contains [srt-live-transmit](./srt-live-transmit.md), `srt-file-transmit` and `srt-tunnel` sample applications.
+* apps - the folder contains [srt-live-transmit](../apps/srt-live-transmit.md), `srt-file-transmit` and [srt-tunnel](../apps/srt-tunnel.md) sample applications.
 * *common - holds some platform-dependent code.
 * *docs - contains all the documentation in the GitHub Markdown format.
 * *examples - example applications (use `-DENABLE_EXAMPLES=ON` CMake build option to include in the build)
@@ -97,6 +122,31 @@ The SRT installation has the following folders:
 * *test - unit tests for the library.
 * *testing - the folder contains applications used during development: `srt-test-live`, `srt-test-file`, etc. Use `-DENABLE_TESTING=ON` to include in the build.
 
+## Versioning
+
+The SRT library is versioned as `major.minor.patch`, e.g. v1.4.3.
+Due to legacy reasons SRT library version also defines SRT protocol version, announced in the dedicated field of the handshake packet (see the Handshake section of the [SRT Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-3.2.1).
+
+The patch version upgrade usually means improvements and/or bug fixes, that do not affect SRT [API/ABI compatibility](https://community.kde.org/Policies/Binary_Compatibility_Issues_With_C++) and do not significantly change the library behavior. Thus, an application can relatively safely update onto the next SRT patch release.
+
+Any minor version upgrade means SRT might be no longer **fully** compliant with the OLD API/ABI and/or old behavior or contains notable changes in the source code.
+A certain amount of care should be taken considering the upgrade to the new minor release. A proper testing should be done, and the review of changes listed in the release notes.
+
+By default the SRT library `SO`/`DYLIB` name is suffixed with `major.minor` version (starting from SRT v1.4.3):
+- `libsrt.so.1.4`-> `libsrt.so.1.4.3`.
+- `libsrt.so.1.4`-> `libsrt.so.1.4.4`
+- `libsrt.so.1.5`-> `libsrt.so.1.5.0`
+- ...
+
+This way upgrading the app with dynamic SRT linking to the latest patch release is quite easy, while upgrading to the new minor release must happen with awareness and thus might require rebuilding certain modules of the solution.
+
+All SRT versions prior to SRT v1.4.3 had a single `SO`/`DYLIB` name `libsrt.so.1`, while ABI incompatibility could be broken. Thus it was not safe to perform wide deployment of different SRT library versions with the same ABI version:
+- `libsrt.so.1`-> `libsrt.so.1.4.2`.
+- `libsrt.so.1`-> `libsrt.so.1.3.4`
+- `libsrt.so.1`-> `libsrt.so.1.3.0`
+- ...
+
+
 ## Coding Rules
 
 TBD.
@@ -137,7 +187,7 @@ The format of the commit message is `[<tag>] <Message>`, where possible commits
 ## Generated files
 
 Please note *before modifying any files* that some of them are generated. This is
-indicated after the file header, or in any section of a file that needs to be replaced by 
+indicated after the file header, or in any section of a file that needs to be replaced by
 generated code if related changes are added. The following sections require attention:
 
 ### Logging functional areas
diff --git a/docs/LowLevelInfo.md b/docs/dev/low-level-info.md
similarity index 71%
rename from docs/LowLevelInfo.md
rename to docs/dev/low-level-info.md
index b3793dbf5..a2074df7c 100644
--- a/docs/LowLevelInfo.md
+++ b/docs/dev/low-level-info.md
@@ -2,9 +2,9 @@
 
 ## Introduction
 
-This documnent will contain loose information for various topis referring to
-the SRT source code describing some cross-source analysis that would be
-unobvious for a source code reviewer. It's not a complete documentation of
+This document contains information on various topics related to
+the SRT source code, including descriptions of some cross-source analysis that would
+not be obvious for a source code reviewer. It's not a complete documentation of
 anything, rather a collection of various kind of information retrieved during
 development and even reverse engineering.
 
@@ -95,7 +95,7 @@ mutexes for which the locking order must be preserved.
         - CUDTGroup::m_GroupLock  || CSndUList::m_ListLock(T)
 
      - CUDT::m_ConnectionLock
-          
+
               - CRendezvousQueue::m_RIDVectorLock
 
  - CUDT::m_SendLock
@@ -106,10 +106,64 @@ mutexes for which the locking order must be preserved.
 
  - CUDT::m_RecvAckLock || CUDT::m_SendBlockLock
 ------------------
+```
 
-ANALYSIS ON: m_ConnectionLock
+ANALYSIS ON: `m_ConnectionLock`
+
+**NOTE**: There is a potential of reporting a deadlock due to lock
+inversion between `CRcvQueue::m_LSLock` and `CUDT::m_ConnectionLock`.
+This is false.
+
+According to the below description, you need to know which objects
+exactly are taken into account. The CRcvQueue object is an underlying
+object of CMultiplexer, which is shared between sockets, and also it
+is definitely shared between the listener socket and the accepted
+socket spawn out of it. We have then two scenarios here that seem
+to be in conflict:
+
+1. Setting a new listener on the multiplexer by calling `srt_listen()`
+or removing the listener from the multiplexer by calling `srt_close()`
+on the listener socket. This calls `CUDT::setListenState`, which is done under
+a lock for `m_ConnectionLock` of the socket that is being set up as listener.
+Then inside the CRcvQueue::setListener it locks `m_LSLock`.
+
+
+2. Processing the new connection from the incoming connection request
+processed in `CUDT::processConnectRequest`. It is called under the lock
+of `m_LSLock`. Then inside it calls `CUDT::open` and `CUDT::acceptAndRespond`
+that lock `m_ConnectionLock`.
+
+However, the methods that potentially lock `m_ConnectionLock` are
+called for the sake of the **newly created socket** that is about to
+be reported as the accepted one from `srt_accept()`, **not the listener
+socket**.
+
+That said, a potential situation when these two things could be in collision, as
+theoretically these mutexes are in two different objects and the accepted
+socket shares always the listener with the listening socket, then just as well
+if `srt_listen()` is called on an accepted socket (which will always fail and
+makes no sense, but still it must be somehow recognized and rejected by the
+internals), it will go through the sequence of first `m_ConnectionLock` and
+then `m_LSLock`, while for the same object the order was that the `m_LSLock`
+was locked before its creation in response to the connection handler and
+then `m_ConnectionLock` was applied for it.
+
+These two situations, however, cannot occur simultaneously. This is because
+those activities that occur during the connection processing that apply
+`m_ConnectionLock` under a lock of `m_LSLock` are performed during the time
+when the socket is just created and is still under processing for connection.
+A potential of calling `srt_listen()`, just as well as `srt_close()` on it,
+or even breaking it, will be only possible when this activity is finished
+and no more locks are applied on `m_ConnectionLock`.
+
+A theoretical potential exists if you try to call `srt_listen()` on a
+potentially accepted socket in the listener callback. The result will
+only be such that this function call will hang up due to inability to
+lock `m_LSLock`.
 
 
+```
+
 -- CUDT::startConnect flow
 
 CUDTUnited::connectIn -- > [LOCKED s->m_ControlLock]
@@ -227,13 +281,12 @@ CRcvQueue::worker_ProcessConnectionRequest
          CEPoll::update_events
 }
 
--- CUDT::bstats: TRT-LOCKED m_ConnectionLock 
+-- CUDT::bstats: TRT-LOCKED m_ConnectionLock
 
 -- CUDT::packData
 
 CSndQueue::worker
  CSndUList::pop -- > [LOCKED m_ListLock]
-     CUDT::packData 
+     CUDT::packData
 
 ```
-
diff --git a/docs/reporting.md b/docs/dev/making-srt-better.md
similarity index 99%
rename from docs/reporting.md
rename to docs/dev/making-srt-better.md
index 6cf6d4e58..42d7dcb1a 100644
--- a/docs/reporting.md
+++ b/docs/dev/making-srt-better.md
@@ -7,7 +7,7 @@ any other software of this kind, it isn't perfect. In many cases, "best effort"
 is all you can count on.
 
 That being said, it can always be made better. And so we warmly welcome
-everyone who can contribute improvements to SRT. 
+everyone who can contribute improvements to SRT.
 
 We encourage you to read the following guidelines, which are based on the
 experiences of previous contributors and are intended to make it easier for you
diff --git a/docs/features/access-control.md b/docs/features/access-control.md
new file mode 100644
index 000000000..6375802b2
--- /dev/null
+++ b/docs/features/access-control.md
@@ -0,0 +1,244 @@
+# SRT Access Control (Stream ID) Guidelines
+
+## Motivation
+
+One type of information that an SRT caller can share with an SRT listener during a connection negotiation
+is the "Stream ID". This is a string of maximum 512 characters set on the caller
+side. It can be retrieved at the listener side on the newly accepted socket
+through a socket option (see `SRTO_STREAMID` in [SRT API Socket Options](../API/API-socket-options.md)).
+**Only caller-listener connections are supported.**
+
+As of SRT version 1.3.3 a callback can be registered on the listener socket for
+an application to make decisions on incoming caller connections. This callback,
+among others, is provided with the value of Stream ID from the incoming
+connection. Based on this information, the application can accept or reject the
+connection, select the desired data stream, or set an appropriate passphrase for
+the connection.
+
+## Purpose
+
+There are two target use-cases of the Stream ID:
+- identify the file name of a stream that is about to be sent (simple use case);
+- identify a user, the purpose of the connection (receive or send), the resources, and more (advanced use case).
+
+The Stream ID can be provided as free-form value, especially when targeting the simple use case.
+However, there is a recommended convention so that all SRT users speak the same language.
+The intent of the convention is to:
+
+- promote readability and consistency among free-form names
+- interpret some typical data in the key-value style
+
+In short,
+
+1. `SRTO_STREAMID` is designed for a caller (client) to be able to identify itself, and to state its intent (send/receive, live/file, etc.).
+2. `srt_listen_callback(...)` function is used by a listener (server) to check what a caller (client) has provided in `SRTO_STREAMID` **before** the connection is established.
+For example, the listener (server) can check if it knows the user and set the corresponding passphrase for a connection to be accepted.
+3. Even if `srt_listen_callback(...)` accepts the connection, SRT will still have one more step to check the PASSPHRASE, and reject on mismatch.
+If a correct passphrase is not provided by the client (caller), the request from caller will be rejected by SRT library (not application or programmer).
+
+**Note!** `srt_listen_callback(...)` can't check the passphrase directly for security reasons.
+The only way to make the app check the passphrase is to set the passphrase on the socket by using the `SRTO_PASSPHRASE` option. This lets SRT to reject connection on mismatch.
+
+## Character Encoding
+
+The Stream ID uses UTF-8 encoding.
+
+## General Syntax
+
+The recommended syntax starts with the characters known as an executable specification in POSIX: `#!`.
+
+The next character defines the format used for the following key-value pair syntax.
+At the moment, there is only one supported syntax identified by `:` and described below.
+
+Everything that comes after a syntax identifier is further referenced as the content of the Stream ID.
+
+The content starts with a `:` or `{` character identifying its format:
+
+- `:` : comma-separated key-value pairs with no nesting,
+- `{` : a nested block with one or several key-value pairs that must end with a `}` character. Nesting means that multiple level brace-enclosed parts are allowed.
+
+The form of the key-value pair is
+
+~~~
+key1=value1,key2=value2,...
+~~~
+
+## Standard Keys
+
+Beside the general syntax, there are several top-level keys treated as standard
+keys. All single letter key definitions, including those not listed in this section,
+are reserved for future use. Users can additionally use custom key definitions
+with `user_*` or `companyname_*` prefixes, where `user` and `companyname` are
+to be replaced with an actual user or company name.
+
+The existing key values must not be extended, and must not differ from those described in this section.
+
+The following keys are standard:
+
+- `u`: **User Name**, or authorization name, that is expected to control which
+password should be used for the connection. The application should interpret
+it to distinguish which user should be used by the listener party to set up the
+password.
+- `r`: **Resource Name** identifies the name of the resource and facilitates
+selection should the listener party be able to serve multiple resources.
+- `h`: **Host Name** identifies the hostname of the resource. For example,
+to request a stream with the URI `somehost.com/videos/querry.php?vid=366` the
+`hostname` field should have `somehost.com`, and the resource name can have
+`videos/querry.php?vid=366` or simply `366`. Note that this is still a key to be
+specified explicitly. Support tools that apply simplifications and URI extraction
+are expected to insert only the host portion of the URI here.
+- `s`: **Session ID** is a temporary resource identifier negotiated with
+the server, used just for verification. This is a one-shot identifier, invalidated
+after the first use. The expected usage is when details for the resource and
+authorization are negotiated over a separate connection first, and then the
+session ID is used here alone.
+- `t`: **Type** specifies the purpose of the connection. Several standard
+types are defined, but users may extend the use:
+  - `stream` (default, if not specified): for exchanging the user-specified
+  payload for an application-defined purpose
+  - `file`: for transmitting a file, where `r` is the filename
+  - `auth`: for exchanging sensible data. The `r` value states its purpose.
+  No specific possible values for that are known so far (FUTURE USE]
+- `m`: **Mode** expected for this connection:
+  - `request` (default): the caller wants to receive the stream
+  - `publish`: the caller wants to send the stream data
+  - `bidirectional`:  bidirectional data exchange is expected
+
+Note that `m` is not required in the case where you don't use `streamid` to
+distinguish authorization or resources, and your caller is expected to send the
+data. This is only for cases where the listener can handle various purposes of the
+connection and is therefore required to know what the caller is attempting to do.
+
+Examples:
+
+```js
+#!::u=admin,r=bluesbrothers1_hi
+```
+
+This specifies the username and the resource name of the stream to be served
+to the caller.
+
+```js
+#!::u=johnny,t=file,m=publish,r=results.csv
+```
+
+This specifies that the file is expected to be transmitted from the caller to
+the listener and its name is `results.csv`.
+
+### Rejection Codes
+
+The listener callback handler is also able to decide about rejecting the
+incoming connection. In a normal situation, the rejection code is predefined
+as `SRT_REJ_RESOURCE`. The handler can, however, set its own rejection
+code. There are two number spaces intended for this purpose (as the range
+below `SRT_REJC_PREDEFINED` is reserved for internal codes):
+
+- `SRT_REJC_PREDEFINED` and above: predefined errors. Errors from this range
+(that is, below `SRT_REJC_USERDEFINED`) have their definitions provided in
+the `access_control.h` public header file. The intention is that applications
+using these codes understand the situation described by these codes standard
+way.
+
+- `SRT_REJC_USERDEFINED` and above: to be freely defined by the application.
+Codes from this range can be only understood if each application knows the
+code definitions of the other. These codes should be used only after making
+sure that both applications understood them.
+
+The intention for the predefined codes is to be consistent with the HTTP
+standard codes. Therefore the following sub-ranges are used:
+
+- 0 - 99: Reserved for unique SRT-specific codes (unused by HTTP)
+- 100 - 399: Info, Success and Redirection in HTTP, unused in SRT
+- 400 - 599: Client and server errors in HTTP, adopted by SRT
+- 600 - 999: unused in SRT
+
+Such a code can be set by using the `srt_setrejectreason` function.
+
+See the list of rejection codes in the [Rejection Codes](../API/rejection-codes.md) document.
+
+## Example
+
+An example of Stream ID functionality and the listener callback can be
+found under `tests/test_listen_callback.cpp`.
+
+A listener can register a callback to be called in the middle of accepting a
+new socket connection:
+
+```c++
+srt_listen(server_sock, 5);
+srt_listen_callback(server_sock, &SrtTestListenCallback, NULL);
+```
+
+A callback function has to be implemented by the upstream application. In the
+example below, the function tries to interpret the Stream ID value first according
+to the Access Control guidelines and to extract the username from the `u` key.
+Otherwise it falls back to a free-form specified username. Depending on the user,
+it sets the appropriate password for the expected connection so that it can be
+rejected if the password isn't correct. If the user isn't found in the
+database (`passwd` map) the function itself rejects the connection. Note that
+this can be done by both returning -1 and by throwing an exception.
+
+```c++
+int SrtTestListenCallback(void* opaq, SRTSOCKET ns, int hsversion,
+    const struct sockaddr* peeraddr, const char* streamid)
+{
+    using namespace std;
+
+    // opaq is used to pass some further chained callbacks
+
+    // To reject a connection attempt, return -1.
+
+    static const map<string, string> passwd {
+        {"admin", "thelocalmanager"},
+        {"user", "verylongpassword"}
+    };
+
+    // Try the "standard interpretation" with username at key u
+    string username;
+
+    static const char stdhdr [] = "#!::";
+    uint32_t* pattern = (uint32_t*)stdhdr;
+    bool found = -1;
+
+    // Extract a username from the StreamID:
+    if (strlen(streamid) > 4 && *(uint32_t*)streamid == *pattern)
+    {
+        vector<string> items;
+        Split(streamid+4, ',', back_inserter(items));
+        for (auto& i: items)
+        {
+            vector<string> kv;
+            Split(i, '=', back_inserter(kv));
+            if (kv.size() == 2 && kv[0] == "u")
+            {
+                username = kv[1];
+                found = true;
+            }
+        }
+
+        if (!found)
+        {
+            cerr << "TEST: USER NOT FOUND, returning false.\n";
+            return -1;
+        }
+    }
+    else
+    {
+        // By default the whole streamid is username
+        username = streamid;
+    }
+
+    // When the username of the client is known, the passphrase can be set
+    // on the socket being accepted (SRTSOCKET ns).
+    // The remaining part of the SRT handshaking process will check the
+    // passphrase of the client and accept or reject the connection.
+
+    // When not found, it will throw an exception
+    cerr << "TEST: Accessing user '" << username << "', might throw if not found\n";
+    string exp_pw = passwd.at(username);
+
+    cerr << "TEST: Setting password '" << exp_pw << "' as per user '" << username << "'\n";
+    srt_setsockflag(ns, SRTO_PASSPHRASE, exp_pw.c_str(), exp_pw.size());
+    return 0;
+}
+```
diff --git a/docs/bonding-intro.md b/docs/features/bonding-intro.md
similarity index 97%
rename from docs/bonding-intro.md
rename to docs/features/bonding-intro.md
index 578d644cd..d455afb57 100644
--- a/docs/bonding-intro.md
+++ b/docs/features/bonding-intro.md
@@ -1,5 +1,6 @@
-# What are groups ?
+# SRT Connection Bonding: Introduction
 
+## What are Groups ?
 
 A Group is an entity that binds multiple sockets, and is required to
 establish a "bonded connection". Groups can be used in the same way as
@@ -21,15 +22,14 @@ How the links are utilized within a group depends on the group type. The
 simplest type, broadcast, utilizes all links at once to send the same data.
 
 To learn more about socket groups and their abilities, please read the
-[detailed document](socket-groups.md).
-
-# Reminder: Using sockets for establishing a connection
+[SRT Socket Groups](socket-groups.md) document.
 
+## Reminder: Using Sockets for Establishing a Connection
 
 Before we begin, let's review first how to establish a connection for a
 single socket.
 
-## Important changes
+### Important changes
 
 Keep in mind these important changes to SRT:
 
@@ -45,8 +45,7 @@ or file mode. E.g. all 3 functions: `srt_send`, `srt_sendmsg` and
 `srt_sendmsg2` can be used for sending data in any mode - all depends on what
 your application needs.
 
-
-## Socket connection
+### Socket Connection
 
 Let's review quickly how to establish a socket connection in the
 caller-listener arrangement.
@@ -98,8 +97,7 @@ int size = srt_recvmsg2(connsock, packetdata.data(), packetdata.size(), &mc);
 packetdata.resize(size);
 ```
 
-
-# Group (bonded) connection
+## Group (Bonded) Connection
 
 Except for several details, most of the API used for sockets can be used for
 groups. Groups also have numeric identifiers, just like sockets, which
@@ -209,8 +207,7 @@ the same way as above for the sockets.
 There's one additional thing to be covered here: just how much
 should the application be involved with socket groups?
 
-
-# Controlling the member connections
+## Controlling Member Connections
 
 The object of type `SRT_MSGCTRL` is used to exchange some extra information with
 `srt_sendmsg2` and `srt_recvmsg2`. Of particular interest in this case are two fields:
diff --git a/docs/features/bonding-main-backup.md b/docs/features/bonding-main-backup.md
new file mode 100644
index 000000000..b56df7851
--- /dev/null
+++ b/docs/features/bonding-main-backup.md
@@ -0,0 +1,248 @@
+# SRT Connection Bonding: Main/Backup
+
+I. [Introduction](#i-introduction)
+II. [Mode Overview](#ii-mode-overview)
+III. [Sender Logic](#iii-sender-logic)
+IV. [Sending Algorithm](#iV-sending-algorithm)
+
+## I. Introduction
+
+*SRT Main/Backup Switching* mode saves contribution bandwidth by using only one (main) link at a time, while keeping a stream alive if the main link gets broken.
+
+This feature is useful for broadcasting where the traffic costs for a main link are relatively low, and the main link is reasonably reliable. To make sure a transmission doesn’t fail, one or several backup connections are on stand-by. These backup connections ensure reliability, but the traffic costs may be high. To save costs, the backup links are only activated when the main link fails or doesn’t achieve the required throughput.
+
+The goal of SRT's main/backup bonding mode is to identify a potential link break before it happens, thus providing a time window within which to seamlessly switch to one of the backup links.
+
+## II. Mode Overview
+
+### Mode Constraints
+
+The **main constraints** of the main/backup switching mode are:
+
+- **only one active link at a time**, except when switching to one of the backup links or to a link with a higher weight;
+- **seamless switching** to one of the backup links ideally happens without packet drops, but dropping packets for a certain period of time is acceptable during the switch under certain circumstances (e.g. severe conditions).
+
+Transmission happens over the main link until it is considered broken or is presumably about to become broken.
+
+### Sensitivity Levels
+
+The only sensitivity level implemented at the moment is a **pre-emptive switch** to a backup path from an unstable main path before it breaks. The goal is to predict an upcoming link breakage before it happens, and to be ready to switch to an activated backup link while losing as few packets as possible.
+
+An additional sensitivity level (**handover switch**) may be added in the future for cases where low latency and packet loss is not critical. The switch would take place once the link is actually broken, without trying to predict it thereby reducing processing overhead. Since the main path in this case is already broken, there would be a delay associated with activating the backup path resulting in a discontinuity in streaming (data loss during the switch).
+
+### Mode Limitations
+
+Detecting a potential link break and switching to a backup link requires time. If the activation of the backup link happens within the `SRTO_PEERLATENCY` interval, there is a good chance that not a single packet will be lost. Therefore, one of the limitations (or usage guidelines) is to set `SRTO_PEERLATENCY ≥ 3×RTT`.
+
+The logic of the main/backup sending algorithm is triggered each time an application submits new payload (calls `srt_sendmsg2(..)`). This imposes two limitations:
+
+- it is better to submit new packets no later than every 50 or 60 ms to trigger the logic with enough frequency (the bitrate should be > 180 kbps);
+- file transmission logic does not fit well with this algorithm, and is not supported.
+
+## III. Sender Logic
+
+###  Member Link State
+
+In addition to an individual SRT socket state (e.g. `SRTS_CONNECTED`, `SRTS_BROKEN`, etc.; see [srt_getsockstate(..)](./../API/API-functions.md#srt_getsockstate)), a socket member of a group has a member status (see [SRT_MEMBERSTATUS](./../API/API-functions.md#SRT_MEMBERSTATUS)). The top level member status [SRT_MEMBERSTATUS](./../API/API-functions.md#SRT_MEMBERSTATUS) is visible from the SRT API. However, `SRT_GST_RUNNING` member status can have sub-statuses used by the group sending algorithm.
+
+Member link status can be:
+
+1. **SRT_GST_PENDING**. The link is visible, but the connection hasn't been established yet. The link cannot be used for data transmission yet.
+2. **SRT_GST_IDLE** (**stand by**). The link is connected and ready for data transmission, but it is not activated for actual payload transmission. KEEPALIVE control packets are being exchanged once per second.
+3. **SRT_GST_RUNNING** (**active**). The link is being used for payload transmission.
+   1. **Fresh-Activated**. A link was freshly (newly) activated, and it is too early to qualify it as either stable or unstable.
+   2. **Stable**. Active link is considered stable.
+   3. **Unstable**. Active link is considered unstable, e.g. response time has exceeded some threshold.
+   4. **Unstable-Wary**. A link was identified as unstable (e.g. no response longer than some threshold) until a new response makes it potentially stable again.
+4. **SRT_GST_BROKEN**. The link has just been detected to be broken. It is about to be closed and removed from the group.
+
+### Member State Transition
+
+The initial state for group sender logic to operate on a member is once the member socket is connected and transitions to **SRT_GST_IDLE**.
+
+| Event \ State                                                    | => q0 (GST_IDLE)                   | q1 (Fresh-Activated)             | q2 (Stable)                      | q3 (Unstable)                  | q4 (Wary)  | q5 =>(Broken) |
+| ---------------------------------------------------------------- | ---------------------------------- | -------------------------------- | -------------------------------- | ------------------------------ | ---------- | ------------- |
+| Last response < LST*                                             | x                                  | q1                               | q2                               | **q4** (`m_tsWarySince` = now) | x          | x             |
+| Last response >= LST*                                            | x                                  | **q3** (`tsUnstableSince` = now) | **q3** (`tsUnstableSince` = now) | x                              | **q3**     | x             |
+| `tsUnstableSince`!= 0 and (now - `tsUnstableSince`> PEERIDLETMO) | x                                  | x                                | x                                | **q5**                         | **q5**     | x             |
+| Probing period is over                                           | x                                  | q2 / `tsFreshActivation` = 0     | x                                | x                              | **q2**     | x             |
+| Activate (group decision)                                        | **q1** (`tsFreshActivation` = now) | x                                | x                                | x                              | x          | x             |
+| Silence (group decision)                                         | x                                  | :question:                       | **q0**                           | x                              | :question: | x             |
+| Close/break (external event)                                     | **q5**                             | **q5**                           | **q5**                           | **q5**                         | **q5**     | x             |
+
+Member activation happens according to conditions described in the [Member Activation](#member-activation) section. Upon activation a member transitions to the **q1** (**SRT_GST_RUNNING**: **Fresh-Activated**) state.
+
+A member in the **q1** (**SRT_GST_RUNNING**: **Fresh-Activated**) state can either become  **q2** (**SRT_GST_RUNNING**: **Stable**) or **q3** (**SRT_GST_RUNNING**: **Unstable**).
+
+Conditions to qualify a member as unstable are described in the [Qualifying Member Unstable](#qualifying-member-unstable) section. If the conditions are met, the member is transitioned into the **q3** (**SRT_GST_RUNNING**: **Unstable**) state.
+
+An **Unstable** member (**q3** (**SRT_GST_RUNNING**: **Unstable**) or **q4** (**SRT_GST_RUNNING**: **Unstable-Wary**)) **either**:
+
+- transition back to the **q2** (**SRT_GST_RUNNING**: **Stable**) state through the **q4** (**SRT_GST_RUNNING**: **Unstable-Wary**) state;
+- transition to the **q0** (**SRT_GST_IDLE**) state (be silenced); or
+- transition to the **q5** (**SRT_GST_BROKEN**) state (be closed and removed from the group).
+
+A member in the **q5** (**SRT_GST_BROKEN**) state will eventually be closed and removed from the group.
+
+### Member Ordering by Priority <a href="#send-member-ordering"></a>
+
+When comparing two members, one is ordered before the other depending on which of the following ordering conditions applies (in the order of priority).
+
+1. Higher weight (highest priority)
+2. By backup state (if equal weight):
+   1. **SRT_GST_RUNNING**: **Stable**
+   2. **SRT_GST_RUNNING**: **Fresh-Activated**
+   3. **SRT_GST_RUNNING**: **Unstable-Wary**
+   4. **SRT_GST_RUNNING**: **Unstable**
+   5. **SRT_GST_BROKEN**
+   6. **SRT_GST_IDLE** (**stand by**)
+   7. **SRT_GST_PENDING**
+3. By the Socket ID (lower value first).
+
+For example, an unstable member with a higher weight is ordered before a stable member with lower weight.
+
+**Potential Improvement**: Order by connection start time (older connection comes first) before comparing socket IDs.
+
+### Member Activation
+
+*Member activation* means transitioning an idle (stand by) member with status **SRT_GST_IDLE** to a **SRT_GST_RUNNING**: **Fresh-Activated** state. The time it takes to activate a member is saved as `tsFreshActivation = CurrentTime`.
+
+Activation is needed if one of the following is true:
+
+1. There are no **SRT_GST_RUNNING**: **Stable** or **SRT_GST_RUNNING**: **Fresh-Activated** members.
+2. The weight of one of the idle members is higher than the maximum weight of **SRT_GST_RUNNING** links.
+
+An idle link to be activated is taken from the top of the list of idle links, sorted according to [member ordering priority](#send-member-ordering).
+
+A member remains in the  **SRT_GST_RUNNING**: **Fresh-Activated** state while `CurrentTime - tsFreshActivation > ProbingPeriod`, i.e. for the whole probing period:
+
+ `ProbingPeriod = ILST + 50ms`
+
+Here **Initial Link Stability Timeout** `ILST = max(LSTmin; SRTO_PEERLATENCY)`,
+
+- `LSTmin = 60ms` ;
+- `SRTO_PEERLATENCY` is the corresponding socket option value on a connected socket.
+
+### Qualifying a Member as Unstable
+
+A member in the active (**SRT_GST_RUNNING**) state can be transitioned to the **q3** (**SRT_GST_RUNNING**: **Unstable**) state (become unstable) for any of the reasons described below.
+
+#### Unstable due to response timeout
+
+A member link is considered unstable if the time elapsed since the last response from a peer (`LastRspTime`) exceeds the link stability timeout:
+
+`CurrentTime - LastRspTime > LST`
+
+where
+
+- `CurrentTime` is the time when the next data packet **is submitted to a group** for sending;
+- `LastRspTime` is the time when the latest response (*ACK, loss report (NAK), periodic NAK report, KEEP_ALIVE message, or DATA packet in case of bidirectional transmission*) was received from the SRT receiver by the SRT sender for a member in the **SRT_GST_RUNNING**: **Fresh-Activated** state  `LastRspTime ≥ tsFreshActivation`;
+- `LST`  (Link Stability Timeout) is a dynamic value for stability timeout calculated based on the group `SRT Latency` and RTT estimate on a link. This value is calculated individually for each active (**SRT_GST_RUNNING**) link.
+
+The link stability timeout for an active (**SRT_GST_RUNNING**)  member (**except** for **SRT_GST_RUNNING**: **Fresh-Activated**) is calculated with each data packet submission (on `srt_sendmsg2(..)`).
+
+For a member in  **SRT_GST_RUNNING**: **Fresh-Activated** state `LST = ILST` (see [Member Activation](#member-activation)).
+
+For active  (**SRT_GST_RUNNING**) members in states **different** from **SRT_GST_RUNNING**: **Fresh-Activated** `LST` is calculated as follows:
+
+`LST = 2 * SRTT + 4 * RTTVar,` and `LSTmin ≤ LST ≤ SRTO_PEERLATENCY`,
+
+where
+
+- `LSTmin = 60ms`;
+- `SRTO_PEERLATENCY` is the corresponding socket option value on a connected socket;
+- `SRTT` and `RTTVar` are smoothed RTT and RTT variances calculated on an individual socket member in runtime as described in the SRT RFT [Round Trip Time Estimation](https://tools.ietf.org/html/draft-sharabayko-srt-00#section-4.10) section.
+
+#### Unstable due to sending failure
+
+If sending a packet (`srt_sendmsg2(..)`) over a member SRT socket has failed with error `SRT_EASYNCSND`, the member is qualified as **q3** (**SRT_GST_RUNNING**: **Unstable**).
+
+This error indicates that there was not enough free space in the sender's buffer to accept this data packet for sending. It should not happen under normal conditions and if buffers are configured correctly this kind of error indicates some possible congestion on a path.
+
+#### Unstable due to sender-side packet drops
+
+If a member has dropped a packet (see [Too-Late Packet Drop](https://tools.ietf.org/html/draft-sharabayko-srt-01#section-4.6) section of the Internet Draft) **since the previous submission of a data packet** for sending (previous call to `srt_sendmsg2(..)`), it transitions to the **q3** (**SRT_GST_RUNNING**: **Unstable**) state.
+
+#### Unstable due to receiver-side packet drops (TBD)
+
+**IMPORTANT: For the time being, the main backup algorithm does not react to lost packets or packets dropped by the receiver.** Note that an SRT sender does not know the drop rate on the receiver's side. A receiver acknowledges packets it drops. PR [#1889](https://github.com/Haivision/srt/pull/1889) extends ACK packets to include the total number of packets dropped by the receiver.
+
+### Qualifying a Member as Broken
+
+#### Broken due to peer idle timeout
+
+Similar to a single SRT connection, a member SRT socket is considered broken if there has been no response from a peer for a certain time, defined by the [SRTO_PEERIDLETIMEO](./../APISocketOptions.md#SRTO_PEERIDLETIMEO) socket option (5 seconds by default). A broken socket will be closed by the SRT library. It is also removed from a group.
+
+#### Broken due to remaining unstable for too long
+
+The only additional condition to break an SRT connection from a group is if a member remains **unstable** for too long. A group can request a socket member to break its connection if the time elapsed since the socket has become unstable (`tsUnstableSince`) exceeds the timeout defined by the [SRTO_PEERIDLETIMEO](./../APISocketOptions.md#SRTO_PEERIDLETIMEO) socket option:
+
+`CurrentTime - tsUnstableSince > SRTO_PEERIDLETIMEO`.
+
+### Qualifying a Member as Stable
+
+Only a member SRT socket in the active (**SRT_GST_RUNNING**) state can be qualified as stable.
+
+#### Freshly-activated becomes stable
+
+A freshly activated member SRT socket (**SRT_GST_RUNNING**: **Fresh-Activated**) is qualified as stable (**SRT_GST_RUNNING**: **Stable**) once the probing period `ProbingPeriod` is over (unless it has already been qualified as unstable). The probing period is defined in the [Member Activation](#member-activation) section.
+
+#### Unstable becomes stable
+
+If there is no longer a reason to qualify a member as unstable (see [Qualifying a Member as Unstable](#qualifying-a-member-as-unstable)) it can transition to the stable state. A member in the **q3** (**SRT_GST_RUNNING**: **Unstable**) state transitions immediately to the **q4** (**SRT_GST_RUNNING**: **Unstable-Wary**) state. The time of the transition event is saved as `tsWarySince = CurrentTime`.
+
+If a member remains in the **q4** (**SRT_GST_RUNNING**: **Unstable-Wary**) state for `4 × SRTO_PEERLATENCY`, it can transition to the **SRT_GST_RUNNING**: **Stable** state.
+
+*Note that if a member becomes unstable **q3** (**SRT_GST_RUNNING**: **Unstable**) again, the `tsWarySince` time will be reset on the next transition to the **Unstable-Wary** state.*
+
+### Silencing an Active Member
+
+There must be only one stable (**SRT_GST_RUNNING**: **Stable**) member SRT socket active in a group. There may be several active unstable or fresh activated sockets in a group. However, if more than one member is qualified as stable, only one must remain active.
+
+In order to select a stable member to remain active the [Member Ordering by Priority](#send-member-ordering) is applied. All active members ordered after the first stable member are silenced. All active members ordered before the first stable member in the list, including the stable member, remain active.
+
+## IV. Sending Algorithm
+
+The group sending workflow is triggered by a submission of the following data packet via the `srt_sendmsg(..)` SRT API function. The following steps apply in order.
+
+### 1. Qualify Member States
+
+Before sending a packet, all member links are qualified according to the states described above.
+
+### 2. Sending the Same Packet over Active Links
+
+The same data packet is sent (duplicated) over all members qualified as active (**SRT_GST_RUNNING**).
+
+**If sending fails, the link is re-qualified as unstable** as described in the [Unstable by Sending Failure](#unstable-by-sending-failure) section.
+
+### 3. Save the Packet Being Sent to the Group SND Buffer
+
+The group has a separate buffer for packets being sent and to be acknowledged. If a member socket gets broken, those packets can be resent over a freshly-activated backup member.
+
+### 4. Check if Backup Link Activation is Needed
+
+See the [Member Activation](#member-activation) section.
+
+### 5. [IF] Activate Idle Link
+
+If a member is activated, all buffered packets (see step 3) are submitted to this SRT member socket. If sending fails (see the [Unstable by Sending Failure](#unstable-by-sending-failure) section), another member is activated by following the logic described in the [Member Activation](#member-activation) section.
+
+### 6. Check Pending and Broken Sockets
+
+Check if there are pending sockets that failed to connect, and should be removed from the group.
+
+Check if there are broken sockets to be removed from the group.
+
+Check if there are member socket unstable for too long that should be requested to transition to the `broken` state.
+
+### 7. Wait for Sending Success
+
+There may be a situation where no sending has succeeded, but there are active members.
+
+If the group is in non-blocking operation mode, the group returns `SRT_EASYNCSND` error.
+
+If the group is in blocking operation mode, sending over active members is retried until the sending timeout [`SRTO_SNDTIMEO`](./../API/API-socket-options.md#SRTO_SNDTIMEO) is reached (`SRT_EASYNCSND` error is returned), or at least one member successfully accepts a data packet for sending.
+
+### 8. Silence Redundant Members
+
+The rules described in the [Silencing an Active Member](#silencing-an-active-member) section are applied in this step.
diff --git a/docs/features/bonding-quick-start.md b/docs/features/bonding-quick-start.md
new file mode 100644
index 000000000..22b30cfe6
--- /dev/null
+++ b/docs/features/bonding-quick-start.md
@@ -0,0 +1,139 @@
+# SRT Connection Bonding: Quick Start
+
+## 1. Introduction
+
+Similar to SMPTE-2022-7 over managed networks, Connection Bonding adds seamless stream protection and hitless failover to the SRT protocol. This technology relies on more than one IP network path to prevent disruption to live video streams in the event of network congestion or outages, maintaining continuity of service.
+
+This is accomplished using the [socket groups](./socket-groups.md) introduced in [SRT v1.5](https://github.com/Haivision/srt/releases/tag/v1.5.0). The general concept of socket groups means having a group that contains multiple sockets, where one operation for sending one data signal is applied to the group. Single sockets inside the group will take over this operation and do what is necessary to deliver the signal to the receiver.
+
+Two modes are supported:
+
+- [Broadcast](./socket-groups.md#1-broadcast) - In *Broadcast* mode, data is sent redundantly over all the member links in a group. If one of the links fails or experiences network jitter and/or packet loss, the missing data will be received over another link in the group. Redundant packets are simply discarded at the receiver side.
+
+- [Main/Backup](./bonding-main-backup.md) - In *Main/Backup* mode, only one (main) link at a time is used for data transmission while other (backup) connections are on standby to ensure the transmission will continue if the main link fails. The goal of Main/Backup mode is to identify a potential link break before it happens, thus providing a time window within which to seamlessly switch to one of the backup links.
+
+While this feature remains disabled by default, you can use the [`ENABLE_BONDING=ON`](../build/build-options.md#enable_bonding) build option to activate it.
+
+## 2. Additional Documentation and Code Examples
+
+- [SRT Connection Bonding: Introduction](./bonding-intro.md) - Introduction to Connection Bonding. Description of group (bonded) connections.
+- [SRT Connection Bonding: Socket Groups](./socket-groups.md) - Description of socket groups in SRT. Here you will also find information regarding the `srt-test-live` application for testing Connection Bonding.
+- [SRT Connection Bonding: Main/Backup](./bonding-main-backup.md) - Main/Backup mode description.
+- Refer also to the [SRT API](../API/API.md) and [SRT API Functions](../API/API-functions.md#socket-group-management) documentation for updates related to bonding.
+- Code examples: simple [client](../../examples/test-c-client-bonding.c) and [server](../../examples/test-c-server-bonding.c) implementation.
+
+## 3. Quick Start Guidelines
+
+### 3.1. Transition to a Bonded Connection
+
+For the end-user of the SRT library, operations on a group of bonded sockets should be very much like on a single SRT socket. It is important that the application needs to check regularly for broken sockets in a group and to reconnect broken links. Refer to the [SRT API Functions](../API/API-functions.md#socket-group-management) document to learn what functions can be used with a socket group.
+
+**On the listener side (pseudocode):**
+
+* Create a socket: `sock_id = srt_create_socket()`,
+* `srt_bind(sock_id, ..)` to an interface (as usual for a listener socket),
+* `srt_setsockflag(sock_id, SRTO_GROUPCONNECT, &yes /*int yes = 1*/, sizeof yes)` (by allowing group connections your app confirms being group aware),
+* Listen for incoming connections: `srt_listen(sock_id, ...)` (as usual),
+* Accept a bonded connection with `accepted_group_id = srt_accept(sock_id, ...)`. This will return the ID of the accepted socket group once the first socket group member establishes a connection.
+
+Note that the connection might be still single, so to make sure this is a group you need to check `id & SRTGROUP_MASK`.
+
+Note also that you get the activation on `srt_accept` (epoll readiness, or unblock and return) when the first connection in the group is established. Then, as long as at least one member connection is still alive, every next connection is handled in the background.
+
+**On the caller side (pseudocode):**
+
+* Create a socket group: `sockgroup_id = srt_create_group(SRT_GTYPE_BROADCAST)`,
+* For every single endpoint:
+    * Connect to the endpoint with `srt_connect(sockgroup_id, address, ...)`
+
+NOTE: For groups it is recommended to use the multi-connecting function `srt_connect_group`. This also allows you to configure additional data for each group member.
+
+**Sending through a group of SRT sockets:**
+
+* Send data through a group of sockets by calling `srt_sendmsg2(group_id, ...)`.
+* Pass the group ID that was created by `srt_create_group()` on the caller side, or obtained through `srt_accept()` on the listener side.
+
+**Receiving from the group of SRT sockets:**
+
+Read data from a group of sockets by calling `srt_recvmsg2(group_id)`, passing the group ID instead of the socket ID.
+Here `group_id = accepted_group_id` for the listener, and `group_id = sockgroup_id` for the caller.
+
+**Extra data to be passed for sending or receiving**
+
+The `srt_sendmsg2` and `srt_recvmsg2` functions require an object of type `SRT_MSGCTRL` to provide and retrieve extra data for the operation. In this case it should also provide an array of `SRT_SOCKGROUPDATA` type and its size in the `grpdata` and `grpdata_size` fields respectively. On the output `SRT_SOCKGROUPDATA` will be filled with the current state of every member of the group.
+
+### 3.2. Adding Multiple Listeners to a Bonded Group
+
+A bonded connection is only useful when each individual connection is made over a different network interface (any common route/path between the interfaces nullifies the advantages of bonding). Therefore, a listener must be available for connection over the right interface. There are two ways to achieve this:
+
+* Make the listener listen on every network interface (use the `INADDR_ANY` wildcard).
+* Make multiple listeners, each one bound to a different network interface.
+
+In the second case, all you have to do is to configure multiple listener sockets. The one that gets the first member connection will report the group ID from the `srt_accept` call. All others will be handled in the background, regardless of which listener socket they were reported from. For a blocking mode in addition to `srt_accept`, which cannot handle multiple listeners, there's a convenience function available — `srt_accept_bond` can be provided with multiple sockets and returns the first accepted socket that reports on any of the given listener sockets. In non-blocking mode you can still use `srt_accept_bond` to identify which socket is ready.
+
+**Use Case.** Create multiple listeners bound to their own IP and port (NIC), but capable of accepting connections within the same bonding group.
+
+Usage example:
+
+```c++
+vector<SRTSOCKET> listeners;
+
+for (int i = 0; i < 2; ++i)
+{
+    SRTSOCKET s = srt_create_socket();
+    const int gcon = 1;
+    srt_setsockflag(s, SRTO_GROUPCONNECT, &gcon, sizeof gcon);
+    srt_bind(s, (sockaddr*)&(sa[i]), sizeof (sa[i]));
+    srt_listen(s, 5);	listeners.push_back(s);
+}
+SRTSOCKET conngrp = srt_accept_bond(listeners.data(), listeners.size(), -1 /* msTimeOut */);
+```
+
+### 3.3. Getting Group Statistics and Status
+
+The `srt_bistats(SRTSOCKET u, ...)` function can be used with a socket group ID as the first argument to get statistics for a group. `SRT_TRACEBSTATS` values will mostly be zeros, except for the fields listed in the [SRT Group Statistics Summary Table](../API/statistics.md#srt-group-statistics). Refer to the [SRT API Functions](../API/API-functions.md#socket-group-management) documentation for usage instructions.
+
+The number of socket members in a group can be determined by calling `srt_group_data()`. The code below retrieves the number of sockets in a group.
+
+```c++
+SRTSOCKET groupid = srt_create_group(SRT_GTYPE_BROADCAST);
+int group_size = 0;
+srt_group_data(groupid, NULL, &group_size);
+```
+
+To get information (status) on every member of the group at any time, you can use this function:
+
+```c++
+SRT_SOCKGROUPDATA output[group_size];
+srt_group_data(groupid, output, &group_size);
+```
+
+Now `output[i]` contains information on the `i`-th socket. For details, see the [SRT_GROUP_DATA](../API/API-functions.md#srt_sockgroupdata) structure with [`SRT_MEMBER_STATUS`](../API/API-functions.md#srt_memberstatus) per socket.
+
+Note that broken member connections are automatically removed from the group and are no longer members. If you have your own array of endpoint definitions, you should keep it in your application and update it as necessary with the results reported by this function.
+
+## 4. FAQ
+
+### 4.1. _Does rendezvous mode support network bonding?_
+
+No.
+
+### 4.2. _What kinds of statistics for a bonded connection are available?_
+
+Every individual connection is a group of sockets that can be enumerated with `srt_group_data(SRTSOCKET groupid, SRT_SOCKGROUPDATA*, size_t* len)`. Statistics can then be retrieved for every socket in the group. See [Section 3.3. Getting Group Statistics and Status](#33-getting-group-statistics-and-status).
+
+### 4.3. _Is it possible to receive several streams on one listener in the bonded mode?_
+
+Yes, the same as it is with sockets. The listener socket's role is only to handle the connections, so when it's allowed to handle group connections, it can handle single sockets and various different groups as well.
+
+### 4.4. _How are link priorities set in backup mode?_
+
+Priorities can be set only by the caller with the `srt_connect_group(...)` function that accepts a list of `SRT_SOCKGROUPDATA` (prepared by the `srt_prepare_endpoint` function). This structure has the `weight` value for each connection. In backup mode a higher weight corresponds to a higher priority.
+
+### 4.5. _Is it possible to bind a specific NIC to the destination IP address for a particular bonded caller?_
+
+Yes. When you use a single connecting call for every member, you can use `srt_connect_bind`, which allows you to specify the binding address for this connection. When you use `srt_connect_group`, you should specify this source address as a parameter of the `srt_prepare_endpoint` call.
+
+### 4.6. _Is it possible to specify a socket option for a particular bonded caller?_
+
+Yes – if you use the `srt_connect_group` for connecting, you can mount an option container object created by `srt_create_config()` into the `config` field of `SRT_SOCKGROUPCONFIG` structure, after being prepared by `srt_prepare_endpoint`. Options can be added by `srt_config_add()`. When you no longer need the connection table (having used it for `srt_connect_group`) it must be deleted using `srt_delete_config()`. Note that not every option is allowed to be set this way, so you should still check the status of `srt_config_add()`.
diff --git a/docs/encryption.md b/docs/features/encryption.md
similarity index 95%
rename from docs/encryption.md
rename to docs/features/encryption.md
index 614a11303..60e38dc15 100644
--- a/docs/encryption.md
+++ b/docs/features/encryption.md
@@ -1,7 +1,11 @@
-# Introduction
+# SRT Encryption
+
+**NOTE:** This document might be outdated, please consult [Section 6. Encryption](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00#section-6) of the [SRT RFC](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00) additionally.
+
 This document describes an encryption mechanism that protects the payload of SRT streams. Despite using standard cryptographic algorithms, the mechanism is unique and does not interoperate with any known third party stream encryption method.
 
-### Terminology
+## Terminology
+
 | Term | Description |
 |------|-------------|
 | AEAD | Authenticated Encryption with Associated Data |
@@ -53,7 +57,8 @@ This document describes an encryption mechanism that protects the payload of SRT
 | TU | Transmission Unit |
 | UDP | User Datagram Protocol |
 
-### References
+## References
+
 * [ANSX9.102] Accredited Standards Committee, Wrapping of Keys and Associated Data, ANS X9.102, not for free document.
 * [FIPS 140-2] Security Requirements for Cryptographic Modules, NIST, [FIPS PUB 140-2](https://csrc.nist.gov/csrc/media/publications/fips/140/2/final/documents/fips1402.pdf), May 2001.
 * [FIPS 140-3] Security Requirements for Cryptographic Modules, NIST, [FIPS PUB 140-3](https://csrc.nist.gov/publications/detail/fips/140/3/archive/2009-12-11), December 2009.
@@ -71,7 +76,8 @@ This document describes an encryption mechanism that protects the payload of SRT
 * [RFC6070] PBKDF2 Test Vectors
 * [SRTP-EKT] Encrypted Key Transport for Secure RTP, D. McGrew, F. Andreasen, D. Wing, K. Fisher, [draft-ietf-avt-srtp-ekt-02](https://tools.ietf.org/html/draft-ietf-avt-srtp-ekt-02), March 2011.
 
-### Operators
+## Operators
+
 | Operator | Setting |
 |----------|---------|
 | a \|\| b | Concatenation |
@@ -84,7 +90,8 @@ This document describes an encryption mechanism that protects the payload of SRT
 | PRNG(n) | Pseudo Random Number Generator (n bits) |
 | PBKDF2(p,s,i,l) | Password-based Key Derivation Function (PKCS #5)<br> p: password, s: salt, i: iterations, l: key length |
 
-# Overview
+## Overview
+
 AES in counter mode (AES-CTR) is used with a short lived key to encrypt the media stream. This cipher is suitable for random access of a continuous stream, content protection (used by HDCP 2.0), and strong confidentiality when the counter is managed properly.
 
 The short lived key is randomly generated by the sender and transmitted within the stream (KM Tx Period), wrapped with another longer-term key, the Key Encrypting Key (KEK). For connection-oriented transport such as SRT, there is no need to periodically transmit the short lived key since no party can join the stream at any time.
@@ -95,48 +102,49 @@ A pre-shared password used with a password-based key derivation mechanism is pro
 
 The short lived key, hereafter called the Stream Encrypting Key (SEK), is regenerated for cryptographic reasons when enough packets have been encrypted with it (KM Refresh Rate). To ensure seamless rekeying, the next key to use is transmitted in advance to receivers (KM Pre-Announce) so they can switch keys without disruption when rekeying occurs. KM Refresh Rate and KM Pre-Announce are system parameters that can be configurable options if shorter time than the cryptographic limit is required (for example to limit the material obtained from a compromised SEK).
 
-## Definitions
+### Definitions
+
 This section defines the elements of the SRT encryption mechanism. Figure 1 shows the encryption of arbitrary SRT payload.
 
 ![Figure 1][figure1] Figure 1
 
-### Ciphers (AES-CTR)
+#### Ciphers (AES-CTR)
 The payload is encrypted with a cipher in counter mode (AES-CTR). The counter mode is one of the only cipher mode suitable for continuous stream encryption that permits decryption from any point, without access to start of the stream (random access), and for the same reason tolerates packet lost. The Electronic Code Book (ECB) mode also has these characteristics but does not provide serious confidentiality and is not recommended in cryptography.
 
-### Media Stream message (MSmsg)
+#### Media Stream message (MSmsg)
 The Media Stream message is formed from the SRT media stream (data) packets with some elements of the SRT header used for the cryptography. SRT header already carries a 32-bit packet sequence that is used for the cipher’s counter (ctr) and 2 bits are stolen from the header’s message number (then reduced to 27-bits) for the encryption key (odd/even) indicator.
 
-### Keying Material
+#### Keying Material
 For each stream, the sender generates a Stream Encrypting Key (SEK) and a Salt (not shown in Figure 1). For the initial implementation and for most envisioned scenarios where no separate authentication algorithm is used for message integrity, the SEK is used directly to encrypt the media stream. The Initial Vector (IV) for the counter is derived from the Salt only. In other scenarios, the SEK can be used along with the Salt as a key generating material to produce distinct encryption, authentication, and salt keys.
 
-### Stream Encrypting Key (SEK)
+#### Stream Encrypting Key (SEK)
 The Stream Encrypting Key (SEK) is pseudo-random and different for each stream. It must be 128, 192, or 256 bits long for the AES-CTR ciphers. It is non-persistent and relatively short lived. In a typical scenario the SEK is expected to last, cryptographically, around 37 days for a 31-bit counter (2<sup>31</sup> packets / 667 packets/second).
 
 The SEK is regenerated every time a stream starts. It must be discarded before 2<sup>31</sup> packets are encrypted (31-bit packet index) and replaced seamlessly using an odd/even key mechanism described further. SRT is conservative and regenerates the SEK key every 2<sup>25</sup> packets (~6 hours in the above scenario of a 667 packets per second stream). Reusing an IV (often called nonce) with the same key on different clear text is a known catastrophic issue of counter mode ciphers. By regenerating the SEK each time a stream starts we remove the need for fancier management of the IV to ensure uniqueness.
 
-### Initialization Vector (IV)
+#### Initialization Vector (IV)
 The IV (also named nonce in the AES-CTR context) is a 112 bit random number. For the initial implementation and for most envisioned scenarios where no separate authentication algorithm is used for message integrity (Auth=0), the IV is derived from the salt only.
 
 IV = MSB(112, Salt)	; Most significant 112 bits of the salt.
 
-### Counter (ctr)
+#### Counter (ctr)
 The counter for AES-CTR is the size of the cipher’s block, i.e. 128 bits. It is made of a block counter in the least significant 16 bits, counting blocks of a packet, and a 32 bits packet index in the next 32 bits. The upper 112 bits are XORed with the IV to produce a unique counter for each crypto block.
 
 ![Figure 2][figure2] Figure 2
 
 The block counter (bctr) is incremented for each cipher block while producing the key stream. The packet index is incremented for each packet submitted to the cipher. The IV is derived from the Salt provided with the Keying Material.
 
-### Keying Material message (KMmsg)
+#### Keying Material message (KMmsg)
 The SEK and a Salt are transported in-stream, in a Keying Material message (KMmsg), implemented as a SRT custom control packet, wrapped with a longer term Key Encrypting Key (KEK) using AES key wrap [RFC3394]. There are possibilities for an eventual key wrapper with integrity such as AESKW [ANSX9.102] or AES-SIV [RFC5297].
 
 Transmitting a key in-band is not original to this specification. It is used in DVB MPEG-TS where the stream encrypting key is transmitted in an Entitlement Control Message (ECM). It is also proposed in an IETF draft for SRTP for Encrypted Key Transport [SRTP-EKT].
 
 The connection-oriented SRT KM ctrl packet is transmitted at the start of the connection, before any data packet. In most case, if the control packet is not lost, the receiver is able to decrypt from the first packet. Otherwise, the initial packets are dropped (or stored for later decryption) until the KM control packet is received. The SRT ctrl packet is retransmitted until acknowledged by the receiver.
 
-### Odd/Even Stream Encrypting Key (oSEK/eSEK)
+#### Odd/Even Stream Encrypting Key (oSEK/eSEK)
 To ensure seamless rekeying for cryptographic (counter exhausted) or access control reasons, a two-key mechanism, similar to the one used with DVB systems is used. The two keys are identified as the odd key and the even key (oSEK/eSEK). Basically, an odd/even flag in the SRT data header tells which key is in use. The next key to use is transmitted in advance (KM Pre-Announce) to the receivers in a SRT ctrl packet. When rekeying occurs, the SRT data header odd/even flag flips and the receiver already have the new key in hand to continue decrypting the stream without missing a packet.
 
-### Key Encrypting Key (KEK)
+#### Key Encrypting Key (KEK)
 The KEK is used by the sender to wrap the SEK and by the receiver to unwrap it and then decrypt the stream. The KEK must be at least the size of the key it protects, the SEK. The KEK is derived from a shared secret, a pre-shared password by default.
 
 The KEK is derived with the PBKDF2 [PCKS5] derivation function with the stream Salt and the shared secret for input. Each stream then uses a unique KEK to encrypt its Keying Material. A compromised KEK does not compromise other streams protected with the same shared secret (but a compromised shared secret compromises all streams protected with KEK derived from it). Late derivation of the KEK using stream Salt also permits to generate a KEK of the proper size, based on the size of the key it protects.
diff --git a/docs/handshake.md b/docs/features/handshake.md
similarity index 92%
rename from docs/handshake.md
rename to docs/features/handshake.md
index 5c16d07e7..f8ce9b525 100644
--- a/docs/handshake.md
+++ b/docs/features/handshake.md
@@ -1,8 +1,10 @@
 # SRT Handshake
 
-Published: 2018-06-28  
+Published: 2018-06-28
 Last updated: 2018-06-28
 
+**NOTE:** This document might be outdated, please consult [Section 3.2.1 Handshake](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01#section-3.2.1) and [Section 4.3 Handshake Messages](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00#section-4.3) of the [Internet Draft](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-01) additionally.
+
 **Contents**
 
 - [Overview](#overview)
@@ -53,9 +55,9 @@ Just like its predecessor UDT, SRT supports two connection configurations:
 
 As SRT development has evolved, two handshaking mechanisms have emerged:
 
-1. the **legacy UDT handshake**, with the "SRT" part of the handshake implemented 
-as extended control messages; this is the only mechanism in SRT versions 1.2 and 
-lower, and is known as **HSv4** (where the number 4 refers to the last UDT 
+1. the **legacy UDT handshake**, with the "SRT" part of the handshake implemented
+as extended control messages; this is the only mechanism in SRT versions 1.2 and
+lower, and is known as **HSv4** (where the number 4 refers to the last UDT
 version)
 2. the new **integrated handshake**, known as **HSv5**, where all the required
 information concerning the connection is interchanged completely in the
@@ -75,7 +77,7 @@ option is an integer with the version encoded in hex. For example:
 **IMPORTANT:** Your SRT application must do either of these two things:
 
 - Be *HSv4* compatible. In this case it must:
-   - **NOT** use any new features in 1.3.0 or higher (such as bidirectional 
+   - **NOT** use any new features in 1.3.0 or higher (such as bidirectional
    transmission or Stream ID)
    - **ALWAYS** set `SRTO_SENDER` to true on the sender side
 - Require *HSv5*. If so, it must prevent connections to any older
@@ -83,7 +85,7 @@ versions of SRT by setting the minimum version 1.3.0 as shown above.
 
 ## Short Introduction to SRT Packet Structure
 
-Every UDP packet carrying SRT traffic contains an SRT header (immediately after 
+Every UDP packet carrying SRT traffic contains an SRT header (immediately after
 the UDP header). In all versions, the SRT header contains four major 32-bit fields:
 
  - `PH_SEQNO`
@@ -91,11 +93,11 @@ the UDP header). In all versions, the SRT header contains four major 32-bit fiel
  - `PH_TIMESTAMP`
  - `PH_ID`
 
-Their interpretation depends on the type of packet, of which there are two: 
-*control packets* and *data packets*, defined by the first bit in the `PH_SEQNO` 
-field. 
+Their interpretation depends on the type of packet, of which there are two:
+*control packets* and *data packets*, defined by the first bit in the `PH_SEQNO`
+field.
 
-Here, for example, is a representation of an SRT 1.3.0 **data packet header** 
+Here, for example, is a representation of an SRT 1.3.0 **data packet header**
 (where the "packet type" bit = 0):
 
 
@@ -114,7 +116,7 @@ Here, for example, is a representation of an SRT 1.3.0 **data packet header**
 ```
 **NOTE:** Packet diagrams in this document are in network bit order.
 
-While a complete description of a data packet is out of scope for this document, 
+While a complete description of a data packet is out of scope for this document,
 here is a description of some other header fields unique to SRT:
 
 - **FF** = (2 bits) Position of packet in message, where:
@@ -123,20 +125,20 @@ here is a description of some other header fields unique to SRT:
   - 01b = last
   - 11b = single
 
-- **O** = (1 bit) Indicates whether the message should be delivered in order (1) 
-or not (0). In File/Message mode (original UDT with UDT_DGRAM) when this bit is 
-clear then a message that is sent later (but reassembled before an earlier message 
-which may be incomplete due to packet loss) is allowed to be delivered immediately, 
-without waiting for the earlier message to be completed. This is not used in Live 
-mode because there's a completely different function used for data extraction 
+- **O** = (1 bit) Indicates whether the message should be delivered in order (1)
+or not (0). In File/Message mode (original UDT with UDT_DGRAM) when this bit is
+clear then a message that is sent later (but reassembled before an earlier message
+which may be incomplete due to packet loss) is allowed to be delivered immediately,
+without waiting for the earlier message to be completed. This is not used in Live
+mode because there's a completely different function used for data extraction
 when TSBPD mode is on.
 
 - **KK** = (2 bits) Indicates whether or not data is encrypted:
   - 00b: not encrypted
-  - 01b: encrypted with even key 
+  - 01b: encrypted with even key
   - 10b: encrypted with odd key
 
-- **R** = (1 bit) Retransmitted packet. This flag is clear (0) when a packet is 
+- **R** = (1 bit) Retransmitted packet. This flag is clear (0) when a packet is
 transmitted the very first time, and is set (1) if the packet is retransmitted.
 
 In **Data** packets, the third and fourth fields are interpreted as follows:
@@ -144,11 +146,11 @@ In **Data** packets, the third and fourth fields are interpreted as follows:
 - `PH_TIMESTAMP`: Usually the time when a packet was sent, although the real
 interpretation may vary depending on the type, and it's not important for the
 handshake
-- `PH_ID`: The **Destination Socket ID** to which a packet should be dispatched, 
+- `PH_ID`: The **Destination Socket ID** to which a packet should be dispatched,
  although it may have the special value 0 when the packet is a connection request
 
-Additional details for Data packets will be discussed in the sections below 
-covering **extension flags**. 
+Additional details for Data packets will be discussed in the sections below
+covering **extension flags**.
 
 An SRT control packet header ("packet type" bit = 1) has the following structure:
 
@@ -166,7 +168,7 @@ An SRT control packet header ("packet type" bit = 1) has the following structure
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ```
 
-For **Control** packets the first two fields are interpreted respectively (using 
+For **Control** packets the first two fields are interpreted respectively (using
 network bit order) as:
 
  - `PH_SEQNO`:
@@ -178,19 +180,19 @@ network bit order) as:
 
 The type subfields (in the `PH_SEQNO` field) are used in two ways:
 
-1. The **Message Type** (`SEQNO_MSGTYPE`) is one of the values enumerated as 
-`UDTMessageType`, except `UMSG_EXT`. In this case, the type is determined by 
-this value only, and the **Message Extended Type** (`SEQNO_EXTTYPE`) value should 
+1. The **Message Type** (`SEQNO_MSGTYPE`) is one of the values enumerated as
+`UDTMessageType`, except `UMSG_EXT`. In this case, the type is determined by
+this value only, and the **Message Extended Type** (`SEQNO_EXTTYPE`) value should
 always be 0.
-2. The **Message Type** is `UMSG_EXT`. In this case the actual message type is 
+2. The **Message Type** is `UMSG_EXT`. In this case the actual message type is
 contained in the **Message Extended Type**.
 
-The **Extended Message** mechanism is theoretically open for further extensions. 
-SRT uses some of them for its own purposes. This will be referred to later in the 
+The **Extended Message** mechanism is theoretically open for further extensions.
+SRT uses some of them for its own purposes. This will be referred to later in the
 section on the **[SRT Extended Handshake](#the-srt-extended-handshake)**.
 
-The `Additional Data` field (`PH_MSGNO`) is used in some control messages as 
-extra space for data. Its interpretation depends on the particular message type. 
+The `Additional Data` field (`PH_MSGNO`) is used in some control messages as
+extra space for data. Its interpretation depends on the particular message type.
 Handshake messages don't use it.
 
 [Return to top of page](#srt-handshake)
@@ -198,7 +200,7 @@ Handshake messages don't use it.
 
 ## Handshake Structure
 
-The handshake portion of a control packet, which comes immediately after the UDT 
+The handshake portion of a control packet, which comes immediately after the UDT
 header and SRT header, consists of the following 32-bit fields in order:
 
 | Field             | Description                                                                                                                                             |
@@ -213,7 +215,7 @@ header and SRT header, consists of the following 32-bit fields in order:
 | `Cookie`          | Cookie used for various processing (see below)                                                                                                          |
 | `PeerIP`          | Placeholder for the sender's IPv4 or IPv6 IP address, consisting of four 32-bit fields                                                                  |
 
-Here is a representation of the HSv4 handshake structure (which follows immediately 
+Here is a representation of the HSv4 handshake structure (which follows immediately
 after the SRT control packet header):
 
 ```
@@ -242,9 +244,9 @@ after the SRT control packet header):
    |                                                               |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ```
-And here is the equivalent portion of the HSv5 handshake structure (to simplify 
-the comparison here, the extended portion of the HSv5 handshake structure is not 
-shown. See the [**"UDT Legacy" and "SRT Extended" Handshakes**](#the-udt-legacy-and-srt-extended-handshakes) 
+And here is the equivalent portion of the HSv5 handshake structure (to simplify
+the comparison here, the extended portion of the HSv5 handshake structure is not
+shown. See the [**"UDT Legacy" and "SRT Extended" Handshakes**](#the-udt-legacy-and-srt-extended-handshakes)
 section for details):
 
 ```
@@ -283,10 +285,10 @@ as the UDT handshake.
 2. The required SRT data interchange is done **after the connection is established**
 using **SRT Extended Message** with the following Extended Types:
 
-    - `SRT_CMD_HSREQ`/`SRT_CMD_HSRSP`, which exchange special SRT flags as well 
+    - `SRT_CMD_HSREQ`/`SRT_CMD_HSRSP`, which exchange special SRT flags as well
     as a latency value
-	- `SRT_CMD_KMREQ`/`SRT_CMD_KMRSP` (optional), which exchange the wrapped 
-	stream encryption key used with encryption (`KMRSP` is used only for 
+	- `SRT_CMD_KMREQ`/`SRT_CMD_KMRSP` (optional), which exchange the wrapped
+	stream encryption key used with encryption (`KMRSP` is used only for
 	confirmation or error reporting)
 
 **IMPORTANT:** There are two rules in the UDT code that continue to apply to SRT
@@ -310,9 +312,9 @@ message:
 - `Type` = `UDT_DGRAM`
 
 The version recognition relies on the fact that the **Listener** returns a
-version of 5 (or potentially higher) if it is capable, but the **Caller** must 
-set the `Version` to 4 to make sure that the Listener copies this value, which 
-is how an HSv4 client is recognized. This allows SRT to handle the following 
+version of 5 (or potentially higher) if it is capable, but the **Caller** must
+set the `Version` to 4 to make sure that the Listener copies this value, which
+is how an HSv4 client is recognized. This allows SRT to handle the following
 combinations:
 
 1. **HSv5 Caller vs. HSv4 Listener:** The Listener returns version 4 to the Caller,
@@ -331,12 +333,12 @@ rules.
 With **Rendezvous** there's no problem because both sides try to
 connect to one another, so there's no copying of the handshake data. Each
 side crafts its own handshake individually. If the value of the `Version`
-field is 5 from the very beginning, and if there are any extension flags set in 
-the `Type` field (see note below), the rules of HSv5 apply. But if one party is 
+field is 5 from the very beginning, and if there are any extension flags set in
+the `Type` field (see note below), the rules of HSv5 apply. But if one party is
 using version 4, the handshake continues as HSv4.
 
-**NOTE**: Previously, the `Type` field contained only the extension flags, but 
-now it also contains the encryption flag. So for HSv5 rules to apply the 
+**NOTE**: Previously, the `Type` field contained only the extension flags, but
+now it also contains the encryption flag. So for HSv5 rules to apply the
 extension flag needs to be expressly set.
 
 [Return to top of page](#srt-handshake)
@@ -346,19 +348,19 @@ extension flag needs to be expressly set.
 
 ### UDT Legacy Handshake
 
-The first versions of SRT did not change anything in the UDT handshake mechanisms, 
-which are identified as *HSv4*. Here the connection process is the same as it was 
-in UDT, and any extended SRT handshake operations are done after the HSv4 handshake 
+The first versions of SRT did not change anything in the UDT handshake mechanisms,
+which are identified as *HSv4*. Here the connection process is the same as it was
+in UDT, and any extended SRT handshake operations are done after the HSv4 handshake
 is established.
 
 The HSv5 handshake was first introduced in SRT version 1.3.0. It includes all
-the extended SRT handshake operations in the overall handshake process (known as 
-"integrated handshake"), which means that these data are considered exchanged and 
+the extended SRT handshake operations in the overall handshake process (known as
+"integrated handshake"), which means that these data are considered exchanged and
 agreed upon at the moment when the connection is established.
 
 ### Initiator and Responder
 
-The addition of a new handshake mechanism necessitates the introduction of two 
+The addition of a new handshake mechanism necessitates the introduction of two
 new roles: "Initiator" and "Responder":
 
 
@@ -382,11 +384,11 @@ For an *HSv4* handshake the assignments are simple:
 
 - **Initiator** is the sender, which is the party that has set the `SRTO_SENDER`
 socket option to *true*.
-- **Responder** is the receiver, which is the party that has set `SRTO_SENDER` 
+- **Responder** is the receiver, which is the party that has set `SRTO_SENDER`
 to *false* (default).
 
-Note that these roles are independent of the connection mode 
-(Caller/Listener/Rendezvous), and that the behavior is undefined if `SRTO_SENDER` 
+Note that these roles are independent of the connection mode
+(Caller/Listener/Rendezvous), and that the behavior is undefined if `SRTO_SENDER`
 has the same value on both parties.
 
 For an **HSv5** handshake, the roles are dependent of the connection mode:
@@ -394,10 +396,10 @@ For an **HSv5** handshake, the roles are dependent of the connection mode:
 - For Caller-Listener connections:
    - the Caller is the **Initiator**
    - the Listener is the **Responder**
-   
+
 - For Rendezvous connections:
    - The **Initiator** and **Responder** roles are assigned based on the initial
-data interchange during the handshake 
+data interchange during the handshake
 (see [**The Rendezvous Handshake**](#the-rendezvous-handshake) below)
 
 Note that if the handshake can be done as HSv5, the connection is always
@@ -408,7 +410,7 @@ considered bidirectional and the `SRTO_SENDER` flag is unused.
 
 ### The Request Type Field
 
-The `ReqType` field in the **Handshake Structure** (see [above](#handshake-structure)) 
+The `ReqType` field in the **Handshake Structure** (see [above](#handshake-structure))
 indicates the handshake message type.
 
 **Caller-Listener Request Types:**
@@ -424,7 +426,7 @@ indicates the handshake message type.
 2. After receiving the above message from the peer: `URQ_CONCLUSION`
 3. After receiving the above message from the peer: `URQ_AGREEMENT`.
 
-Note that the **Rendezvous** process is different in HSv4 and HSv5, as the latter 
+Note that the **Rendezvous** process is different in HSv4 and HSv5, as the latter
 is based on a state machine.
 
 In case when the connection process has failed when the party was about to
@@ -438,21 +440,21 @@ reason (see `SRT_REJECT_REASON` in `srt.h`).
 
 ### The Type Field
 
-There are two possible interpretations of the `Type` field. The first is the 
-legacy UDT "socket type", of which there are two: `UDT_STREAM` and `UDT_DGRAM` 
+There are two possible interpretations of the `Type` field. The first is the
+legacy UDT "socket type", of which there are two: `UDT_STREAM` and `UDT_DGRAM`
 (in SRT only `UDT_DGRAM` is allowed). This legacy interpretation is applied in
 the following circumstances:
  - in an `URQ_INDUCTION` message sent initially by the Caller
- - in an `URQ_INDUCTION` message sent back by the HSv4 Listener 
+ - in an `URQ_INDUCTION` message sent back by the HSv4 Listener
  - in an `URQ_CONCLUSION` message, if the other party was detected as HSv4
- 
-For more information on Induction and Conclusion see the 
+
+For more information on Induction and Conclusion see the
 [Caller-Listener Handshake](#the-caller-listener-handshake) section below.
 
-UDT interpreted the `Type` field as either a **Stream** or **Message** type, 
-and rejected the connection if the parties each used a different type. Since SRT 
-only uses the **Message** type, HSv5 uses only the `UDT_DGRAM` value for this field 
-in cases where the message is going to be sent to an HSv4 party (which follows 
+UDT interpreted the `Type` field as either a **Stream** or **Message** type,
+and rejected the connection if the parties each used a different type. Since SRT
+only uses the **Message** type, HSv5 uses only the `UDT_DGRAM` value for this field
+in cases where the message is going to be sent to an HSv4 party (which follows
 the UDT interpretation).
 
 In all other cases `Type` follows the HSv5 interpretation and consists of the
@@ -467,7 +469,7 @@ of extension flags (with the `HS_EXT_` prefix)
 `SrtHSRequest::SRT_MAGIC_CODE` (0x4A17)
  - in all other cases it should be 0.
 
-The **encryption flags** currently occupy only 3 out of 16 bits, which are used 
+The **encryption flags** currently occupy only 3 out of 16 bits, which are used
 to advertise a value for `PBKEYLEN` (packet based key length). This value is taken
 from the `SRTO_PBKEYLEN` option, divided by 8, giving possible values of:
  - 2 (AES-128)
@@ -477,18 +479,18 @@ from the `SRTO_PBKEYLEN` option, divided by 8, giving possible values of:
 
 The `PBKEYLEN` advertisement is required due to the fact that while the Sender
 should decide the `PBKEYLEN`, in HSv5 the Sender might be the Responder. Therefore
-`PBKEYLEN` is advertised to the Initiator so that it gets this value before it 
+`PBKEYLEN` is advertised to the Initiator so that it gets this value before it
 starts creating the SEK on its side, to be then sent to the Responder.
 
-**REMINDER:** Initiator and Responder roles are assigned differently in HSv4 
-and HSv5. See the **[Initiator and Responder](#initiator-and-responder)** 
+**REMINDER:** Initiator and Responder roles are assigned differently in HSv4
+and HSv5. See the **[Initiator and Responder](#initiator-and-responder)**
 section above.
 
-The specification of `PBKEYLEN` is decided by the Sender. When the transmission 
-is bidirectional, this value must be agreed upon at the outset because when both 
-are set, the Responder wins. For Caller-Listener connections it is reasonable to 
-set this value on the Listener only. In the case of Rendezvous the only reasonable 
-approach is to decide upon the correct value from the different sources and to 
+The specification of `PBKEYLEN` is decided by the Sender. When the transmission
+is bidirectional, this value must be agreed upon at the outset because when both
+are set, the Responder wins. For Caller-Listener connections it is reasonable to
+set this value on the Listener only. In the case of Rendezvous the only reasonable
+approach is to decide upon the correct value from the different sources and to
 set it on both parties (note that **AES-128** is the default).
 
 [Return to top of page](#srt-handshake)
@@ -498,13 +500,13 @@ set it on both parties (note that **AES-128** is the default).
 
 This section describes the handshaking process where a Listener is
 waiting for an incoming packet on a bound UDP port, which should be an SRT
-handshake command (`UMSG_HANDSHAKE`) from a Caller. The process has two phases: 
+handshake command (`UMSG_HANDSHAKE`) from a Caller. The process has two phases:
 *induction* and *conclusion*.
 
 
 ### The Induction Phase
 
-The Caller begins by sending an "induction" message, which contains the following 
+The Caller begins by sending an "induction" message, which contains the following
 (significant) fields:
 
 - **Version:** must always be 4
@@ -516,29 +518,29 @@ The Caller begins by sending an "induction" message, which contains the followin
 The **Destination Socket ID** (in the SRT header) in this message is 0, which is
 interpreted as a connection request.
 
-**NOTE:** This phase serves only to set a cookie on the Listener so that it 
-doesn't allocate resources, thus mitigating a potential DOS attack that might be 
+**NOTE:** This phase serves only to set a cookie on the Listener so that it
+doesn't allocate resources, thus mitigating a potential DOS attack that might be
 perpetrated by flooding the Listener with handshake commands.
 
 An **HSv4** Listener responds with **exactly the same values**, except:
 
 - **ID:** Socket ID of the HSv4 Listener
-- **SYN Cookie:** a cookie that is crafted based on host, port and current time 
+- **SYN Cookie:** a cookie that is crafted based on host, port and current time
 with 1 minute accuracy
 
 An **HSv5** Listener responds with the following:
 
 - **Version:** 5
-- **Type:** 
-  - Extension Field (lower 16 bits): `SrtHSRequest::SRT_MAGIC_CODE` 
+- **Type:**
+  - Extension Field (lower 16 bits): `SrtHSRequest::SRT_MAGIC_CODE`
   - Encryption Field (upper 16 bits): Advertised `PBKEYLEN`
 - **ReqType:** (UDT Connection Type) `URQ_INDUCTION`
 - **ID:** Socket ID of the HSv5 Listener
-- **SYN Cookie:** a cookie that is crafted based on host, port and current time 
+- **SYN Cookie:** a cookie that is crafted based on host, port and current time
 with 1 minute accuracy
 
 **NOTE:** The HSv5 Listener still doesn't know the version of the Caller, and it
-responds with the same set of values regardless of whether the Caller is 
+responds with the same set of values regardless of whether the Caller is
 version 4 or 5.
 
 The important differences between HSv4 and HSv5 in this respect are:
@@ -551,13 +553,13 @@ passed to the next phase. It does interpret these fields, but only in the
 2. The **HSv5** party does interpret the values in `Version` and `Type`. If it
 receives the value 5 in `Version`, it understands that it comes from an HSv5
 party, so it knows that it should prepare the proper HSv5 messages in the next
-phase.  It also checks the following in the `Type` field: 
+phase.  It also checks the following in the `Type` field:
 
-	- whether the lower 16-bit field (extension flags) contains the magic 
-value (see the **[Type Field](#the-type-field)** section above); otherwise the 
-connection is rejected. This is a contingency for the case where someone who, 
-in attempting to extend UDT independently, increases the `Version` value to 5 
-and tries to test it against SRT. 
+	- whether the lower 16-bit field (extension flags) contains the magic
+value (see the **[Type Field](#the-type-field)** section above); otherwise the
+connection is rejected. This is a contingency for the case where someone who,
+in attempting to extend UDT independently, increases the `Version` value to 5
+and tries to test it against SRT.
 
     - whether the upper 16-bit field (encryption flags) contain a non-zero
 value, which is interpreted as an advertised `PBKEYLEN` (in which case it is
@@ -581,13 +583,13 @@ its `URQ_INDUCTION` response:
 - **ID:** Socket ID of the Caller
 - **Cookie:** the cookie previously received in the induction phase
 
-If an HSv5 Caller receives a confirmation from a Listener that it can use the 
+If an HSv5 Caller receives a confirmation from a Listener that it can use the
 version 5 handshake, it fills in the following values:
 
 - **Version:** 5
 - **Type:** appropriate Extension Flags and Encryption Flags (see below)
 - **ReqType:** `URQ_CONCLUSION`
-- **ID:** Socket ID of the Caller 
+- **ID:** Socket ID of the Caller
 - **Cookie:** the cookie previously received in the induction phase
 
 The Destination Socket ID (in the SRT header, `PH_ID` field) in this message is the
@@ -600,15 +602,15 @@ The **Type** field contains:
 - **Extension Flags:** The `HS_EXT_` prefixed flags defined in `CHandShake` - see the
   **[SRT Extended Handshake](#the-srt-extended-handshake)** section below.
 
-The Listener responds with the same values shown above, without the cookie (which 
-isn't needed here), as well as the extensions for HSv5 (which will probably be 
+The Listener responds with the same values shown above, without the cookie (which
+isn't needed here), as well as the extensions for HSv5 (which will probably be
 exactly the same).
 
-**IMPORTANT:** There isn't any "negotiation" here. If the values passed in the 
-handshake are in any way not acceptable by the other side, the connection will 
-be rejected. The only case when the Listener can have precedence over the Caller 
-is the advertised `PBKEYLEN` in the `Encryption Flags` field in `Type` field. 
-The value for latency is always agreed to be the greater of those reported 
+**IMPORTANT:** There isn't any "negotiation" here. If the values passed in the
+handshake are in any way not acceptable by the other side, the connection will
+be rejected. The only case when the Listener can have precedence over the Caller
+is the advertised `PBKEYLEN` in the `Encryption Flags` field in `Type` field.
+The value for latency is always agreed to be the greater of those reported
 by each party.
 
 [Return to top of page](#srt-handshake)
@@ -616,24 +618,24 @@ by each party.
 
 ## The Rendezvous Handshake
 
-When two parties attempt to connect in **Rendezvous** mode, they are considered 
-to be  equivalent: Both are connecting, but neither is listening, and they expect 
-to be  contacted (over the same port number for both parties) specifically by 
-the same party with which they are trying to connect. Therefore, it's perfectly 
-safe to assume that, at  some point, each party will have agreed upon the 
-connection, and that no induction-conclusion phase split is required. Even so, 
+When two parties attempt to connect in **Rendezvous** mode, they are considered
+to be  equivalent: Both are connecting, but neither is listening, and they expect
+to be  contacted (over the same port number for both parties) specifically by
+the same party with which they are trying to connect. Therefore, it's perfectly
+safe to assume that, at  some point, each party will have agreed upon the
+connection, and that no induction-conclusion phase split is required. Even so,
 the Rendezvous handshake process is more complicated.
 
-The basics of a Rendezvous handshake are the same in HSv4 and HSv5 - the 
+The basics of a Rendezvous handshake are the same in HSv4 and HSv5 - the
 description of the HSv4 process is a good introduction for HSv5. However, HSv5
-has more data to exchange and more conditions to be taken into account. 
+has more data to exchange and more conditions to be taken into account.
 
 [Return to top of page](#srt-handshake)
 
 
 ### HSv4 Rendezvous Process
 
-Initially, each party sends an SRT control message of type `UMSG_HANDSHAKE` to 
+Initially, each party sends an SRT control message of type `UMSG_HANDSHAKE` to
 the other, with the following fields:
 
 - **Version:** 4 (HSv4 only)
@@ -654,16 +656,16 @@ sending this message:
 - **ID:** Socket ID of the party sending this message
 - **Cookie:** 0
 
-At this point, they are considered to be connected. When either party receives 
+At this point, they are considered to be connected. When either party receives
 this message from its peer again, it sends another message with the `ReqType`
 field set as `URQ_AGREEMENT`. This is a formal conclusion to the handshake
 process, required to inform the peer that it can stop sending conclusion
 messages (note that this is UDP, so neither party can assume that the message
 has reached its peer).
 
-With HSv4 there's no debate about who is the Initiator and who is the Responder 
-because this transaction is unidirectional, so the party that has set the 
-`SRTO_SENDER` flag is the Initiator and the other is Responder (as is usual 
+With HSv4 there's no debate about who is the Initiator and who is the Responder
+because this transaction is unidirectional, so the party that has set the
+`SRTO_SENDER` flag is the Initiator and the other is Responder (as is usual
 with HSv4).
 
 [Return to top of page](#srt-handshake)
@@ -671,47 +673,66 @@ with HSv4).
 
 ### HSv5 Rendezvous Process
 
-The HSv5 Rendezvous process introduces a state machine, and therefore is slightly 
-different from HSv4, although it is still based on the same message request types. 
-Both parties start with `URQ_WAVEAHAND` and use a `Version` value of 5. The 
-version recognition is easy - the HSv4 client does not look at the `Version` value, 
+The HSv5 Rendezvous process introduces a state machine, and therefore is slightly
+different from HSv4, although it is still based on the same message request types.
+Both parties start with `URQ_WAVEAHAND` and use a `Version` value of 5. The
+version recognition is easy - the HSv4 client does not look at the `Version` value,
 whereas HSv5 clients can quickly recognize the version from the `Version` field.
 The parties only continue with the HSv5 Rendezvous process when `Version` = 5
 for both. Otherwise the process continues exclusively according to *HSv4* rules.
 
-With HSv5 Rendezvous, both parties create a cookie for a process called a 
-"cookie contest". This is necessary for the assignment of Initiator and Responder 
-roles. Each party generates a cookie value (a 32-bit number) based on the host, 
+With HSv5 Rendezvous, both parties create a cookie for a process called a
+"cookie contest". This is necessary for the assignment of Initiator and Responder
+roles. Each party generates a cookie value (a 32-bit number) based on the host,
 port, and current time with 1 minute accuracy. This value is scrambled using
 an MD5 sum calculation. The cookie values are then compared with one another.
 
 Since you can't have two sockets on the same machine bound to the same device
 and port and operating independently, it's virtually impossible that the
-parties will generate identical cookies. However, this situation may occur if an 
-application tries to "connect to itself" - that is, either connects to a local 
-IP address, when the socket is bound to INADDR_ANY, or to the same IP address to 
-which the socket was bound. If the cookies are identical (for any reason), the 
-connection will not be made until new, unique cookies are generated (after a 
-delay of up to one minute). In the case of an application "connecting to itself", 
+parties will generate identical cookies. However, this situation may occur if an
+application tries to "connect to itself" - that is, either connects to a local
+IP address, when the socket is bound to INADDR_ANY, or to the same IP address to
+which the socket was bound. If the cookies are identical (for any reason), the
+connection will not be made until new, unique cookies are generated (after a
+delay of up to one minute). In the case of an application "connecting to itself",
 the cookies will always be identical, and so the connection will never be made.
 
-When one party's cookie value is greater than its peer's, it wins the cookie 
+```c++
+// Here m_ConnReq.m_iCookie is a local cookie value sent in connection request to the peer.
+// m_ConnRes.m_iCookie is a cookie value sent by the peer in its connection request.
+const int64_t contest = int64_t(m_ConnReq.m_iCookie) - int64_t(m_ConnRes.m_iCookie);
+
+if ((contest & 0xFFFFFFFF) == 0)
+{
+    return HSD_DRAW;
+}
+
+if (contest & 0x80000000)
+{
+    return HSD_RESPONDER;
+}
+
+return HSD_INITIATOR;
+```
+
+When one party's cookie value is greater than its peer's (based on 32-bit subtraction of both
+with potential overflow), it wins the cookie
 contest and becomes Initiator (the other party becomes the Responder).
 
 At this point there are two "handshake flows" possible (at least theoretically):
-*serial*  and *parallel*. 
+*serial*  and *parallel*.
 
 #### Serial Handshake Flow
 
 In the **serial** handshake flow, one party is always first, and the other follows.
 That is, while both parties are repeatedly sending `URQ_WAVEAHAND` messages, at
-some point one party - let's say Alice - will find she has received a 
-`URQ_WAVEAHAND` message before she can send her next one, so she sends a 
-`URQ_CONCLUSION` message in response. Meantime, Bob (Alice's peer) has missed 
-her `URQ_WAVEAHAND` messages, and so Alice's `URQ_CONCLUSION` is the first message 
+some point one party - let's say Alice - will find she has received a
+`URQ_WAVEAHAND` message before she can send her next one, so she sends a
+`URQ_CONCLUSION` message in response. Meantime, Bob (Alice's peer) has missed
+her `URQ_WAVEAHAND` messages, and so Alice's `URQ_CONCLUSION` is the first message
 Bob has received from her.
 
-This process can be described easily as a series of exchanges between the first 
+This process can be described easily as a series of exchanges between the first
 and following parties (Alice and Bob, respectively):
 
 1. Initially, both parties are in the *waving* state. Alice sends a handshake
@@ -722,17 +743,17 @@ message to Bob:
 	- **ID:** Alice's socket ID
 	- **Cookie:** Created based on host/port and current time
 
-Keep in mind that while Alice doesn't yet know if she is sending this message to 
-an HSv4 or HSv5 peer, the values from these fields would not be interpreted by 
+Keep in mind that while Alice doesn't yet know if she is sending this message to
+an HSv4 or HSv5 peer, the values from these fields would not be interpreted by
 an HSv4 peer when the **ReqType** is `URQ_WAVEAHAND`.
 
-2. Bob receives Alice's `URQ_WAVEAHAND` message, switches to the *attention* 
-state. Since Bob now knows Alice's cookie, he performs a "cookie contest" 
-(compares both cookie values). If Bob's cookie is greater than Alice's, he will 
+2. Bob receives Alice's `URQ_WAVEAHAND` message, switches to the *attention*
+state. Since Bob now knows Alice's cookie, he performs a "cookie contest"
+(compares both cookie values). If Bob's cookie is greater than Alice's, he will
 become the **Initiator**. Otherwise, he will become the **Responder**.
 
-**IMPORTANT**: The resolution of the [Handshake Role](#initiator-and-responder) 
-(Initiator or Responder) is essential to further processing. 
+**IMPORTANT**: The resolution of the [Handshake Role](#initiator-and-responder)
+(Initiator or Responder) is essential to further processing.
 
 Then Bob responds:
 
@@ -740,14 +761,14 @@ Then Bob responds:
 - **Type:**
    - *Extension field:* appropriate flags if Initiator, otherwise 0
    - *Encryption field:* advertised `PBKEYLEN`
-- **ReqType:** `URQ_CONCLUSION`    
+- **ReqType:** `URQ_CONCLUSION`
 
 **NOTE:** If Bob is the Initiator and encryption is on, he will use either his
 own `PBKEYLEN` or the one received from Alice (if she has advertised
 `PBKEYLEN`).
-	
-3. Alice receives Bob's `URQ_CONCLUSION` message. While at this point she also 
-performs the "cookie contest", the outcome will be the same. She switches to the 
+
+3. Alice receives Bob's `URQ_CONCLUSION` message. While at this point she also
+performs the "cookie contest", the outcome will be the same. She switches to the
 *fine* state, and sends:
 
 	- **Version:** 5
@@ -761,33 +782,33 @@ previous message from the Responder containing an advertised `PBKEYLEN` in the
 encryption flags field (in the `Type` field), it will be used as the key length
 for key generation sent next in the `SRT_CMD_KMREQ` block.
 
-4. Bob receives Alice's `URQ_CONCLUSION` message, and then does one of the 
+4. Bob receives Alice's `URQ_CONCLUSION` message, and then does one of the
 following (depending on Bob's role):
 
 	- If Bob is the Initiator (Alice's message contains `SRT_CMD_HSRSP`), he:
 		- switches to the *connected* state
-		- sends Alice a message with `ReqType` = `URQ_AGREEMENT`, but containing 
+		- sends Alice a message with `ReqType` = `URQ_AGREEMENT`, but containing
 		  no SRT extensions (*Extension flags* in `Type` should be 0)
-		  
+
 	- If Bob is the Responder (Alice's message contains `SRT_CMD_HSREQ`), he:
 		- switches to *initiated* state
 		- sends Alice a message with ReqType = `URQ_CONCLUSION` that also contains
 		  extensions with `SRT_CMD_HSRSP`
-        - awaits a confirmation from Alice that she is also connected (preferably 
+        - awaits a confirmation from Alice that she is also connected (preferably
           by `URQ_AGREEMENT` message)
 
-5. Alice receives the above message, enters into the *connected* state, and 
+5. Alice receives the above message, enters into the *connected* state, and
 then does one of the following (depending on Alice's role):
 
-    - If Alice is the Initiator (received `URQ_CONCLUSION` with `SRT_CMD_HSRSP`), 
-    she sends Bob a message with `ReqType` = `URQ_AGREEMENT`. 
+    - If Alice is the Initiator (received `URQ_CONCLUSION` with `SRT_CMD_HSRSP`),
+    she sends Bob a message with `ReqType` = `URQ_AGREEMENT`.
 
-    - If Alice is the Responder, the received message has `ReqType` = `URQ_AGREEMENT` 
-    and in response she does nothing. 
+    - If Alice is the Responder, the received message has `ReqType` = `URQ_AGREEMENT`
+    and in response she does nothing.
 
-6. At this point, if Bob was Initiator, he is connected already. If he was a 
+6. At this point, if Bob was Initiator, he is connected already. If he was a
 Responder, he should receive the above `URQ_AGREEMENT` message, after which he
-switches to the *connected* state. In the case where the UDP packet with the 
+switches to the *connected* state. In the case where the UDP packet with the
 agreement message gets lost, Bob will still enter the *connected* state once
 he receives anything else from Alice. If Bob is going to send, however, he
 has to continue sending the same `URQ_CONCLUSION` until he gets the confirmation
@@ -800,23 +821,23 @@ from Alice.
 
 The serial handshake flow described above happens in almost every case.
 
-There is, however, a very rare (but still possible) **parallel** flow that only 
-occurs if the messages with `URQ_WAVEAHAND` are sent and received by both peers 
+There is, however, a very rare (but still possible) **parallel** flow that only
+occurs if the messages with `URQ_WAVEAHAND` are sent and received by both peers
 at precisely the same time. This *might* happen in one of these situations:
 
-- if both Alice and Bob start sending `URQ_WAVEAHAND` messages perfectly 
-simultaneously,  
-or 
-- if Bob starts later but sends his `URQ_WAVEAHAND` message during the 
+- if both Alice and Bob start sending `URQ_WAVEAHAND` messages perfectly
+simultaneously,
+or
+- if Bob starts later but sends his `URQ_WAVEAHAND` message during the
 gap between the moment when Alice had earlier sent her message,
-and the moment when that message is received (that is, if each party receives the 
-message from its peer immediately after having sent its own),  
+and the moment when that message is received (that is, if each party receives the
+message from its peer immediately after having sent its own),
 or
-- if, at the beginning of `srt_connect`, Alice receives the first message from 
-Bob exactly during the very short gap between the time Alice is adding a socket 
+- if, at the beginning of `srt_connect`, Alice receives the first message from
+Bob exactly during the very short gap between the time Alice is adding a socket
 to the connector list and when she sends her first `URQ_WAVEAHAND` message
 
-The resulting flow is very much like Bob's behaviour in the serial handshake flow, 
+The resulting flow is very much like Bob's behaviour in the serial handshake flow,
 but for both parties. Alice and Bob will go through the same state transitions:
 
     Waving -> Attention -> Initiated -> Connected
@@ -826,31 +847,31 @@ roles. It is important to understand that, in contrast to serial flows,
 which are mostly based on request-response cycles, here everything
 happens completely asynchronously: the state switches upon reception
 of a particular handshake message with appropriate contents (the
-Initiator must attach the `HSREQ` extension, and Responder must attach the 
-`HSRSP` extension). 
+Initiator must attach the `HSREQ` extension, and Responder must attach the
+`HSRSP` extension).
 
 Here's how the parallel handshake flow works, based on roles:
 
 **Initiator:**
 
 1. `Waving`
-   - Receives `URQ_WAVEAHAND` message 
+   - Receives `URQ_WAVEAHAND` message
    - Switches to `Attention`
    - Sends `URQ_CONCLUSION` + `HSREQ`
 2. `Attention`
    - Receives `URQ_CONCLUSION` message, which:
      - contains no extensions:
        - switches to `Initiated`, still sends `URQ_CONCLUSION` + `HSREQ`
-     - contains `HSRSP` extension: 
+     - contains `HSRSP` extension:
        - switches to `Connected`, sends `URQ_AGREEMENT`
 3. `Initiated`
    - Receives `URQ_CONCLUSION` message, which:
-     - Contains no extensions: 
+     - Contains no extensions:
        - REMAINS IN THIS STATE, still sends `URQ_CONCLUSION` + `HSREQ`
-     - contains `HSRSP` extension: 
+     - contains `HSRSP` extension:
        - switches to `Connected`, sends `URQ_AGREEMENT`
 4. `Connected`
-   - May receive `URQ_CONCLUSION` and respond with `URQ_AGREEMENT`, but normally 
+   - May receive `URQ_CONCLUSION` and respond with `URQ_AGREEMENT`, but normally
 by now it should already have received payload packets.
 
 **Responder:**
@@ -860,53 +881,53 @@ by now it should already have received payload packets.
    - Switches to `Attention`
    - Sends `URQ_CONCLUSION` message (with no extensions)
 2. `Attention`
-   - Receives `URQ_CONCLUSION` message with `HSREQ`  
-     **NOTE:** This message might contain no extensions, in which case the party 
-     shall simply send the empty `URQ_CONCLUSION` message, as before, and remain 
-     in this state. 
+   - Receives `URQ_CONCLUSION` message with `HSREQ`
+     **NOTE:** This message might contain no extensions, in which case the party
+     shall simply send the empty `URQ_CONCLUSION` message, as before, and remain
+     in this state.
    - Switches to `Initiated` and sends `URQ_CONCLUSION` message with `HSRSP`
 3. `Initiated`
    - Receives:
-     - `URQ_CONCLUSION` message with `HSREQ` 
+     - `URQ_CONCLUSION` message with `HSREQ`
        - responds with `URQ_CONCLUSION` with `HSRSP` and remains in this state
-     - `URQ_AGREEMENT` message 
+     - `URQ_AGREEMENT` message
        - responds with `URQ_AGREEMENT` and switches to `Connected`
-     - Payload packet 
+     - Payload packet
        - responds with `URQ_AGREEMENT` and switches to `Connected`
 4. `Connected`
     - Is not expecting to receive any handshake messages anymore. The
-`URQ_AGREEMENT` message is always sent only once or per every final 
+`URQ_AGREEMENT` message is always sent only once or per every final
 `URQ_CONCLUSION`message.
 
 Note that any of these packets may be missing, and the sending party will
 never become aware. The missing packet problem is resolved this way:
 
-1. If the Responder misses the `URQ_CONCLUSION` + `HSREQ` message, it simply 
-continues sending empty `URQ_CONCLUSION` messages. Only upon reception of 
+1. If the Responder misses the `URQ_CONCLUSION` + `HSREQ` message, it simply
+continues sending empty `URQ_CONCLUSION` messages. Only upon reception of
 `URQ_CONCLUSION` + `HSREQ` does it respond with `URQ_CONCLUSION` + `HSRSP`.
 
-2. If the Initiator misses the `URQ_CONCLUSION` + `HSRSP` response from the 
-Responder, it continues sending `URQ_CONCLUSION` + `HSREQ`. The Responder must 
-always respond with `URQ_CONCLUSION` + `HSRSP` when the Initiator sends 
+2. If the Initiator misses the `URQ_CONCLUSION` + `HSRSP` response from the
+Responder, it continues sending `URQ_CONCLUSION` + `HSREQ`. The Responder must
+always respond with `URQ_CONCLUSION` + `HSRSP` when the Initiator sends
 `URQ_CONCLUSION` + `HSREQ`, even if it has already received and interpreted it.
 
 3. When the Initiator switches to the `Connected` state it responds with a
-`URQ_AGREEMENT` message, which may be missed by the Responder. Nonetheless, the 
-Initiator may start sending data packets because it considers itself connected 
-- it doesn't know that the Responder has not yet switched to the `Connected` state. 
+`URQ_AGREEMENT` message, which may be missed by the Responder. Nonetheless, the
+Initiator may start sending data packets because it considers itself connected
+- it doesn't know that the Responder has not yet switched to the `Connected` state.
 Therefore it is exceptionally allowed that when the Responder is in the `Initiated`
-state and receives a data packet (or any control packet that is normally sent only 
+state and receives a data packet (or any control packet that is normally sent only
 between connected parties) over this connection, it may switch to the `Connected`
 state just as if it had received a `URQ_AGREEMENT` message.
 
-4. If the the Initiator is already switched to the `Connected` state it will not 
-bother the Responder with any more handshake messages. But the Responder may be 
-completely unaware of that (having missed the `URQ_AGREEMENT` message from the 
-Initiator). Therefore it doesn't exit the connecting state (still blocks on 
-`srt_connect` or doesn't signal connection readiness), which means that it 
-continues sending `URQ_CONCLUSION` + `HSRSP` messages until it receives any 
-packet that will make it switch to the `Connected` state (normally 
-`URQ_AGREEMENT`). Only then does it exit the connecting state and the 
+4. If the the Initiator is already switched to the `Connected` state it will not
+bother the Responder with any more handshake messages. But the Responder may be
+completely unaware of that (having missed the `URQ_AGREEMENT` message from the
+Initiator). Therefore it doesn't exit the connecting state (still blocks on
+`srt_connect` or doesn't signal connection readiness), which means that it
+continues sending `URQ_CONCLUSION` + `HSRSP` messages until it receives any
+packet that will make it switch to the `Connected` state (normally
+`URQ_AGREEMENT`). Only then does it exit the connecting state and the
 application can start transmission.
 
 [Return to top of page](#srt-handshake)
@@ -915,7 +936,7 @@ application can start transmission.
 ### Rendezvous Between Different Versions
 
 When one of the parties in a handshake supports HSv5 and the other only
-HSv4, the handshake is conducted according to the rules described in the 
+HSv4, the handshake is conducted according to the rules described in the
 **[HSv4 Rendezvous Process](#hsv4-rendezvous-process)** section above.
 
 Note, though, that in the first phase the `URQ_WAVEAHAND` request type sent
@@ -933,10 +954,10 @@ conclusion handshake message according to the rules of HSv4.
 ### HSv4 Extended Handshake Process
 
 The HSv4 extended handshake process starts **after the connection is considered
-established**. Whatever problems may occur after this point *will only affect 
+established**. Whatever problems may occur after this point *will only affect
 data transmission*.
 
-Here is a representation of the HSv4 extended handshake packet structure 
+Here is a representation of the HSv4 extended handshake packet structure
 (including the first four 32-bit segments of the SRT header):
 
 ```
@@ -961,12 +982,12 @@ Here is a representation of the HSv4 extended handshake packet structure
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ```
 
-The HSv4 extended handshake is performed with the use of the [aforementioned](#overview) 
+The HSv4 extended handshake is performed with the use of the [aforementioned](#overview)
 "SRT Extended Messages", using control messages with major type `UMSG_EXT`.
 
-Note that these command messages, although sent over an established connection, 
-are still simply UDP packets. As such they are subject to all the problematic 
-UDP protocol phenomena, such as packet loss (packet recovery applies exclusively 
+Note that these command messages, although sent over an established connection,
+are still simply UDP packets. As such they are subject to all the problematic
+UDP protocol phenomena, such as packet loss (packet recovery applies exclusively
 to the payload packets). Therefore messages are sent "stubbornly" (with a
 slight delay between subsequent retries) until the peer responds, with some
 maximum number of retries before giving up. It's very important to understand
@@ -977,16 +998,16 @@ command message is sent, followed by the first data packet, and the rest of the
 transmission continues without having the extended SRT handshake yet agreed
 upon.
 
-This means that the initial few data packets might be sent without having the 
+This means that the initial few data packets might be sent without having the
 appropriate SRT settings already working, which may raise two concerns:
 
-- *There is a delay in the application of latency to received packets* - At first, 
-packets are being delivered immediately. It is only when the `SRT_CMD_HSREQ` 
-message is processed that latency is applied to the received packets. The 
+- *There is a delay in the application of latency to received packets* - At first,
+packets are being delivered immediately. It is only when the `SRT_CMD_HSREQ`
+message is processed that latency is applied to the received packets. The
 time stamp based packet delivery mechanism (TSBPD) isn't working until then.
 
-- *There is a delay in the application of encryption (if used) to received 
-packets* - Packets can't be decrypted until the `SRT_CMD_KMREQ` is processed and 
+- *There is a delay in the application of encryption (if used) to received
+packets* - Packets can't be decrypted until the `SRT_CMD_KMREQ` is processed and
 the keys installed. The data packets are still encrypted, but the receiver can't
 decrypt them and will drop them.
 
@@ -1088,8 +1109,8 @@ option). There might be also other extensions placed after HSREQ and KMREQ.
 
 Every extension block has the following structure:
 
-(1) a 16-bit command symbol  
-(2) 16-bit block size (number of 32-bit words following this field)  
+(1) a 16-bit command symbol
+(2) 16-bit block size (number of 32-bit words following this field)
 (3) a number of 32-bit fields, as specified in (2) above
 
 What is contained in a block depends on the extension command code.
@@ -1113,8 +1134,8 @@ error).
 4. Each side declares a transmission type that is not compatible with the
 other. This will be described further, along with other new HSv5 features;
 the HSv4 client supports only and exclusively one transmission type, which
-is *Live*. This is indicated in the `Type` field in the HSv4 handshake, which 
-must be equal to `UDT_DGRAM` (2), and in the HSv5 by the extra *Smoother* 
+is *Live*. This is indicated in the `Type` field in the HSv4 handshake, which
+must be equal to `UDT_DGRAM` (2), and in the HSv5 by the extra *Smoother*
 block declaration (see below). In any case, when there's no *Smoother*
 declared, *Live* is assumed. Otherwise the Smoother type must be exactly
 the same on both sides.
@@ -1160,24 +1181,24 @@ The `SRT_CMD_HSREQ` message contains three 32-bit fields designated as:
 
 The flags (`SRT Flags` field) are the following bits, in order:
 
-(0) `SRT_OPT_TSBPDSND`: The party will be sending in TSBPD (Time Stamp Based 
+(0) `SRT_OPT_TSBPDSND`: The party will be sending in TSBPD (Time Stamp Based
 Packet Delivery) mode.
 
 This is used by the Sender party to specify that it will use TSBPD mode.
-The Responder should respond with its setting for TSBPD reception; if it isn't 
-using TSBPD for reception, it responds with its reception TSBPD flag not set. 
+The Responder should respond with its setting for TSBPD reception; if it isn't
+using TSBPD for reception, it responds with its reception TSBPD flag not set.
 In HSv4, this is only used by the Initiator.
 
 (1) `SRT_OPT_TSBPDRCV`: The party expects to receive in TSBPD mode.
 
 This is used by a party to specify that it expects to receive in TSBPD mode.
 The Responder should respond to this setting with TSBPD sending
-mode (HSv5 only) and set the sending TSBPD flag appropriately. In HSv4 this is 
+mode (HSv5 only) and set the sending TSBPD flag appropriately. In HSv4 this is
 only used by the Responder party.
 
 (2) `SRT_OPT_HAICRYPT`: The party includes `haicrypt` (legacy flag).
 
-This **special legacy compatibility flag** should be always set. See below 
+This **special legacy compatibility flag** should be always set. See below
 for more details.
 
 (3) `SRT_OPT_TLPKTDROP`: The party will do TLPKTDROP.
@@ -1196,7 +1217,7 @@ message when the sender seems to linger with retransmission).
 
 (5) `SRT_OPT_REXMITFLG`: The party uses the REXMIT flag.
 
-This **special legacy compatibility flag** should be always set. See below 
+This **special legacy compatibility flag** should be always set. See below
 for more details.
 
 (6) `SRT_OPT_STREAM`: The party uses stream type transmission.
@@ -1208,7 +1229,7 @@ to the fact that HSv4 supports Live mode only.
 
 **Special Legacy Compatibility Flags**
 
-The `SRT_OPT_HAICRYPT` and `SRT_OPT_REXMITFLG` fields define special cases for 
+The `SRT_OPT_HAICRYPT` and `SRT_OPT_REXMITFLG` fields define special cases for
 the interpretation of the contents in the SRT header for payload packets.
 
 The SRT header contains an unusual field designated as `PH_MSGNO`,
@@ -1221,8 +1242,8 @@ more by stealing bits from the Message Number subfield:
 this field contains a value that declares whether the payload is
 encrypted and with which key.
 
-2. **Retransmission** flag (1 bit). Controlled by `SRT_OPT_REXMITFLG`, this flag 
-is 0 when a packet is sent the first time, and 1 when it is retransmitted (i.e. 
+2. **Retransmission** flag (1 bit). Controlled by `SRT_OPT_REXMITFLG`, this flag
+is 0 when a packet is sent the first time, and 1 when it is retransmitted (i.e.
 requested in a loss report). When the incoming packet is late (one with a
 sequence number older than the newest received so far), this flag allows the
 Receiver to distinguish between a retransmitted packet and a reordered packet.
@@ -1230,27 +1251,27 @@ This is used by the "reorder tolerance" feature described in the API
 documentation under `SRTO_LOSSMAXTTL` socket option.
 
 As of version 1.2.0 both these fields are in use, and therefore both these
-flags must always be set. In theory, there might still exist some SRT versions 
-older than 1.2.0 where these flags are not used, and these extra bits remain 
+flags must always be set. In theory, there might still exist some SRT versions
+older than 1.2.0 where these flags are not used, and these extra bits remain
 part of the "Message Number" subfield.
 
-In practice there are no versions around that do not use encryption bits, 
-although there might be some old SRT versions still in use that do not include 
-the Retransmission field, which was introduced in version 1.2.0. In practice 
-both these flags must be set in the version that has them defined. They might 
-be reused in future for something else, once all versions below 1.2.0 are 
+In practice there are no versions around that do not use encryption bits,
+although there might be some old SRT versions still in use that do not include
+the Retransmission field, which was introduced in version 1.2.0. In practice
+both these flags must be set in the version that has them defined. They might
+be reused in future for something else, once all versions below 1.2.0 are
 decommissioned, but the default is for them to be set.
 
 The `SRT_HS_LATENCY` field defines Sender/Receiver latency.
 
 It is split into two 16-bit parts. The usage differs in HSv4 and HSv5.
 
-In **HSv4** only the lower part (bits 16 - 31) is used. The upper part (bits 0 - 15) 
+In **HSv4** only the lower part (bits 16 - 31) is used. The upper part (bits 0 - 15)
 is always 0. The interpretation of this field is as follows:
  - Receiver party: Receiver latency
  - Sender party: Sender latency
 
-In **HSv5** both 16-bit parts of the field are used, and interpreted 
+In **HSv5** both 16-bit parts of the field are used, and interpreted
 as follows::
  - Upper 16 bits (0 - 15): Receiver latency
  - Lower 16 bits (16 - 31): Sender latency
@@ -1263,16 +1284,16 @@ Receiver to use.
 2. **Receiver latency** is the (minimum) value that the Receiver
 wishes to apply to the stream that it will be receiving.
 
-Once these values are exchanged via the extended handshake, an **effective 
-latency** is established, which is always the maximum of the two. Note that 
-latency is defined in a specified direction. In HSv5, a connection is 
+Once these values are exchanged via the extended handshake, an **effective
+latency** is established, which is always the maximum of the two. Note that
+latency is defined in a specified direction. In HSv5, a connection is
 bidirectional, and a separate latency is defined for each direction.
 
 The Initiator sends an `HSREQ` message, which declares the values on its side.
-The Responder calculates the maximum values between what it receives in the 
+The Responder calculates the maximum values between what it receives in the
 `HSREQ`and its own values, then sends an `HSRSP` with the effective latencies.
 
-Here is an example of an **HSv5 bidirectional transmission** between Alice and 
+Here is an example of an **HSv5 bidirectional transmission** between Alice and
 Bob, where Alice is Initiator:
 
 1. Alice and Bob set the following latency values:
@@ -1300,8 +1321,8 @@ We now have the **effective latency** values:
    - For transmissions from Alice to Bob: 300ms
    - For transmissions from Bob to Alice: 550ms
 
-Here is an example of an *HSv4* exchange, which is simpler because there's only 
-one direction. We'll refer to Alice to Bob again to be consistent with the 
+Here is an example of an *HSv4* exchange, which is simpler because there's only
+one direction. We'll refer to Alice to Bob again to be consistent with the
 Initiator/Responder roles in the HSv5 example:
 
 1. Alice sets `SRTO_LATENCY` to 250 ms
@@ -1321,9 +1342,9 @@ Note that the `SRTO_LATENCY` option in HSv5 sets both `SRTO_RCVLATENCY` and
 is an alias to `SRTO_RCVLATENCY`.
 
 Why is the Sender latency updated to the effective latency for that direction?
-Because the `TLPKTDROP` mechanism, which is used by default in Live mode, may 
-cause the Sender to decide to stop retransmitting packets that are known to be 
-too late to retransmit. This latency value is one of the factors taken into 
+Because the `TLPKTDROP` mechanism, which is used by default in Live mode, may
+cause the Sender to decide to stop retransmitting packets that are known to be
+too late to retransmit. This latency value is one of the factors taken into
 account to calculate the time threshold for `TLPKTDROP`.
 
 [Return to top of page](#srt-handshake)
@@ -1333,7 +1354,7 @@ account to calculate the time threshold for `TLPKTDROP`.
 
 `KMREQ` and `KMRSP` contain the KMX (key material exchange) message used for
 encryption. The most important part of this message is the
-AES-wrapped key (see the [Encryption documentation](encryption.md) for
+AES-wrapped key (see [SRT Encryption](encryption.md) for
 details). If the encryption process on the Responder side was successful,
 the response contains the same message for confirmation. Otherwise it's
 one single 32-bit value that contains the value of `SRT_KMSTATE` type,
@@ -1348,7 +1369,7 @@ that the Responder will not be able to decrypt data sent by the Initiator,
 but the Responder can still send unencrypted data to the Initiator.
 
 - If the Initiator did not declare encryption, but the Responder did, then
-the Responder will attach `SRT_CMD_KMRSP` (despite the fact that the Initiator 
+the Responder will attach `SRT_CMD_KMRSP` (despite the fact that the Initiator
 did not send `SRT_CMD_KMREQ`) with `SRT_KM_S_UNSECURED` status. The
 Responder won't be able to send data to the Initiator (more precisely,
 it will send scrambled data, not able to be decrypted), but the Initiator
@@ -1368,7 +1389,7 @@ case it resolves to `SRTO_SNDKMSTATE`.
 The values retrieved from these options depend on the result of the KMX
 process:
 
-1. If only one party declares encryption, the KM state will be one of 
+1. If only one party declares encryption, the KM state will be one of
 the following:
 
    - For the party that declares no encryption:
@@ -1380,16 +1401,16 @@ the following:
    - For the party that declares encryption:
      - `RCVKMSTATE: UNSECURED`
      - `SNDKMSTATE: NOSECRET`
-     - Result: This party can receive unencrypted payloads from its peer, and 
-     will be able to send encrypted payloads to the peer, but the peer won't 
+     - Result: This party can receive unencrypted payloads from its peer, and
+     will be able to send encrypted payloads to the peer, but the peer won't
      decrypt them.
 
-2. If both declare encryption, but they have different passwords, then both 
-states are `SRT_KM_S_BADSECRET`. In such a situation both sides may send payloads, 
+2. If both declare encryption, but they have different passwords, then both
+states are `SRT_KM_S_BADSECRET`. In such a situation both sides may send payloads,
 but the other party won't decrypt them.
 
-3. If both declare encryption and the password is the same on both sides, then 
-both states are `SRT_KM_S_SECURED`. The transmission will be correctly performed 
+3. If both declare encryption and the password is the same on both sides, then
+both states are `SRT_KM_S_SECURED`. The transmission will be correctly performed
 with encryption in both directions.
 
 Note that due to the introduction of the bidirectional feature in HSv5 (and
@@ -1404,7 +1425,7 @@ The SEK and SALT values are random-generated.
 
 This is the general process of Security Association done for the
 "forward direction", that is, when done by the Sender. However, as there's
-only one KMX process in the handshake, in HSv5 this must also initialize 
+only one KMX process in the handshake, in HSv5 this must also initialize
 the crypto in the opposite direction. This is accomplished by **"reverse KMX"**:
 
 1. The Initiator initializes its Sender Crypto (TXC), like above, and then
@@ -1415,34 +1436,34 @@ the crypto in the opposite direction. This is accomplished by **"reverse KMX"**:
 Crypto, that is, by extracting the SEK and SALT from the Receiver Crypto
 and using them to initialize the Sender Crypto (clone the keys).
 
-This way the Sender (being a Responder) has the Sender Crypto initialized in a 
+This way the Sender (being a Responder) has the Sender Crypto initialized in a
 manner very similar to that of the Initiator. The only difference is that the SEK
 and SALT parameters in the crypto:
  - are random-generated on the Initiator side
  - are extracted (on the Responder side) from the Receiver Crypto, which was
 configured by the incoming KMX message
 
-The extra operations defined as "reverse KMX" happen exclusively in the HSv5 
+The extra operations defined as "reverse KMX" happen exclusively in the HSv5
 handshake.
 
-The encryption key (SEK) is normally configured to be refreshed after a 
-predefined number of packets has been sent. To ensure the "soft handoff" 
+The encryption key (SEK) is normally configured to be refreshed after a
+predefined number of packets has been sent. To ensure the "soft handoff"
 to the new key, this process consists of three activities performed in order:
 
 1. Pre-announcing of the key (SEK is sent by Sender to Receiver)
 2. Switching the key (at some point packets are encrypted with the new key)
 3. Decommissioning the key (removing the old, unused key)
 
-Pre-announcing is done using an SRT Extended Message with the `SRT_CMD_KMREQ` 
-extended type, where only the "forward KMX" part is done. When the transmission 
-is bidirectional, the key refreshing process happens completely independently 
-for each direction, and it's always initiated by the sending side, independently 
-of Initiator and Responder roles (actually, these roles are significant only up 
+Pre-announcing is done using an SRT Extended Message with the `SRT_CMD_KMREQ`
+extended type, where only the "forward KMX" part is done. When the transmission
+is bidirectional, the key refreshing process happens completely independently
+for each direction, and it's always initiated by the sending side, independently
+of Initiator and Responder roles (actually, these roles are significant only up
 to the moment when the connection is considered established).
 
-The decision as to when exactly to perform particular activities belonging to 
+The decision as to when exactly to perform particular activities belonging to
 the key refreshing process is made when the **number of sent packets** exceeds
-a certain value (up to the moment of the connection or previous refresh), which 
+a certain value (up to the moment of the connection or previous refresh), which
 is controlled by the `SRTO_KMREFRESHRATE` and `SRTO_KMPREANNOUNCE` options:
 
 1. Pre-announce: when # of sent packets > `SRTO_KMREFRESHRATE - SRTO_KMPREANNOUNCE`
@@ -1453,7 +1474,7 @@ In other words, `SRTO_KMREFRESHRATE` is the exact number of transmitted packets
 for which a key switch happens. The Pre-announce happens `SRTO_KMPREANNOUNCE`
 packets earlier, and Decommission happens `SRTO_KMPREANNOUNCE` packets later.
 The `SRTO_KMPREANNOUNCE` value serves as an intermediate delay to make sure
-that from the moment of switching the keys the new key is deployed on the 
+that from the moment of switching the keys the new key is deployed on the
 Receiver, and that the old key is not decommissioned until the last
 packet encrypted with that key is received.
 
@@ -1473,12 +1494,12 @@ generated) key is used.
 state) is decommissioned on both the Sender and Receiver sides. The place
 for the key remains open for future key refreshing.
 
-**NOTE** The handlers for `KMREQ` and `KMRSP` are the same for handling the 
-request coming through an SRT Extended Message and through the handshake 
-extension blocks, except that in case of the SRT Extended Message only one 
-direction (forward KMX) is updated. HSv4 relies only on these messages, so 
-there's no difference between initial and refreshed KM exchange. In HSv5 the 
-initial KM exchange is done within the handshake in both directions, and then 
+**NOTE** The handlers for `KMREQ` and `KMRSP` are the same for handling the
+request coming through an SRT Extended Message and through the handshake
+extension blocks, except that in case of the SRT Extended Message only one
+direction (forward KMX) is updated. HSv4 relies only on these messages, so
+there's no difference between initial and refreshed KM exchange. In HSv5 the
+initial KM exchange is done within the handshake in both directions, and then
 the key refresh process is started by the Sender and it updates the key for one
 direction only.
 
@@ -1509,8 +1530,8 @@ This extension is optional and when not present the "live" Congestion Controller
 is assumed. For an HSv4 party, which doesn't support this feature, it is always
 the case.
 
-The "file" type reintroduces the old UDT features for stream transmission 
-(together with the `SRT_OPT_STREAM` flag) and messages that can span multiple UDP 
+The "file" type reintroduces the old UDT features for stream transmission
+(together with the `SRT_OPT_STREAM` flag) and messages that can span multiple UDP
 packets. The Congestion Controller controls the way the transmission is
 handled, how various transmission settings are applied, and how to handle any
 special phenomena that happen during transmission.
@@ -1540,8 +1561,4 @@ application should set it on a Caller socket using the `SRTO_STREAMID` option.
 Upon connection, the accepted socket on the Listener side will have exactly the
 same value set, and it can be retrieved using the same option. For more details
 about the prospective use of this option, please refer to the
-[API description document](API.md) and [SRT Access Control guidelines](AccessControl.md).
-
-
-[Return to top of page](#srt-handshake)
-
+[SRT API Socket Options](../API/API-socket-options.md) and [SRT Access Control (Stream ID) Guidlines](access-control.md).
diff --git a/docs/images/block-aligned-5rx10c.png b/docs/features/images/block-aligned-5rx10c.png
similarity index 100%
rename from docs/images/block-aligned-5rx10c.png
rename to docs/features/images/block-aligned-5rx10c.png
diff --git a/docs/images/block-aligned.png b/docs/features/images/block-aligned.png
similarity index 100%
rename from docs/images/block-aligned.png
rename to docs/features/images/block-aligned.png
diff --git a/docs/images/non-block-aligned-5rx10c-deleted-packets.png b/docs/features/images/non-block-aligned-5rx10c-deleted-packets.png
similarity index 100%
rename from docs/images/non-block-aligned-5rx10c-deleted-packets.png
rename to docs/features/images/non-block-aligned-5rx10c-deleted-packets.png
diff --git a/docs/images/non-block-aligned-5rx10c.png b/docs/features/images/non-block-aligned-5rx10c.png
similarity index 100%
rename from docs/images/non-block-aligned-5rx10c.png
rename to docs/features/images/non-block-aligned-5rx10c.png
diff --git a/docs/images/non-block-aligned.png b/docs/features/images/non-block-aligned.png
similarity index 100%
rename from docs/images/non-block-aligned.png
rename to docs/features/images/non-block-aligned.png
diff --git a/docs/images/packet-filter-mechanism.png b/docs/features/images/packet-filter-mechanism.png
similarity index 100%
rename from docs/images/packet-filter-mechanism.png
rename to docs/features/images/packet-filter-mechanism.png
diff --git a/docs/images/rebuild-missing-sequence.png b/docs/features/images/rebuild-missing-sequence.png
similarity index 100%
rename from docs/images/rebuild-missing-sequence.png
rename to docs/features/images/rebuild-missing-sequence.png
diff --git a/docs/images/srt-encryption-1.png b/docs/features/images/srt-encryption-1.png
similarity index 100%
rename from docs/images/srt-encryption-1.png
rename to docs/features/images/srt-encryption-1.png
diff --git a/docs/images/srt-encryption-2.png b/docs/features/images/srt-encryption-2.png
similarity index 100%
rename from docs/images/srt-encryption-2.png
rename to docs/features/images/srt-encryption-2.png
diff --git a/docs/images/staircase-pattern-5rx10c.png b/docs/features/images/staircase-pattern-5rx10c.png
similarity index 100%
rename from docs/images/staircase-pattern-5rx10c.png
rename to docs/features/images/staircase-pattern-5rx10c.png
diff --git a/docs/features/latency.md b/docs/features/latency.md
new file mode 100644
index 000000000..d287ac030
--- /dev/null
+++ b/docs/features/latency.md
@@ -0,0 +1,219 @@
+## General statement about latency
+
+In the live streaming there are many things happening between the 
+camera's lens and the screen of the video player, all of which contribute 
+to a delay that is generally referred to as "latency". This overall latency 
+includes the time it takes for the camera frame grabber device to pass 
+frames to the encoder, encoding, multiplexing, **sending over the network**, 
+splitting, decoding and then finally displaying. 
+
+In SRT, however, "latency" is defined as only the delay introduced by **sending 
+over the network**. It's the time between the moment when the `srt_sendmsg2` 
+function is called at the sender side up to the moment when the `srt_recvmsg2` 
+function is called at the receiver side. This SRT latency is the actual time difference 
+between these two events.
+
+
+## The goal of the latency (TSBPD) mechanism
+
+SRT employs a TimeStamp Based Packet Delivery (TSBPD) mechanism 
+with strict goal of keeping the time interval between two consecutive packets 
+on the receiver side identical to what they were at the sender side. This 
+requires introducing an extra delay that should define when exactly the packet 
+can be retrieved by the receiver application -- if the packet arrives early, it must
+wait in the receiver buffer until the delivery time. This time for a packet N
+is roughly defined as:
+
+```
+PTS[N] = ETS[N] + LATENCY(option)
+```
+
+where `ETS[N]` is the time when the packet would arrive, if all delays
+from the network and the processing software on both sides are identical
+to what they were for the very first received data packet. This means that
+for the very first packet `ETS[0]` is equal to this packet's arrival time.
+For every following packet the delivery time interval should be equal to the
+that packet's declared scheduling time interval.
+
+
+## SRT's approach to packet arrival time
+
+SRT provides two socket options `SRTO_PEERLATENCY` and `SRTO_RCVLATENCY`.
+While they have "latency" in their names, they do *not* define the true time
+interval between the `srt_sendmsg2` and `srt_recvmsg2` calls for the same
+packet. They are only used to add an extra delay (at the receiver side) to
+the time when the packet "should" arrive (ETS). This extra delay is used to
+compensate for two things:
+
+* an extra network delay (that is, if the packet arrived later than it
+"should have arrived"), or
+
+* a packet retransmission.
+
+Note that many of the values included in these formulas are not controllable and 
+some cannot be measured directly. In many cases there are measured values 
+that are sums of other values, but the component values can't be extracted. 
+
+There are two values that we can obtain at the receiver side:
+
+* ATS: actual arrival time, which is the time when the UDP packet
+has been extracted through the `recvmsg` system call.
+
+* TS: time recorded in the packet header, set on the sender side and extracted
+from the packet at the receiver side
+
+Note that the timestamp in the packet's header is 32-bit, which gives
+it more or less 2.5 minutes to roll over. Therefore timestamp
+rollover is tracked and a segment increase is performed in order to keep an
+eye on the overall actual time. For the needs of the formula definitions
+it must be stated that TS is the true difference between the connection
+start time and the time when the sending time has been declared when
+the sender application is calling any of the `srt_send*` functions
+(see [`srt_sendmsg2`](../API/API-functions.md#srt_sendmsg2) for details).
+
+
+## SRT latency components
+
+To understand the latency components we need also other definitions:
+
+* **ETS** (Expected Time Stamp): The packet's expected arrival time, when it
+"should" arrive according to its timestamp
+
+* **PTS** (Presentation Time Stamp): The packet's play time, when SRT gives the packet
+to the `srt_recvmsg2` call (that is, it sets up the IN flag in epoll
+and resumes the blocked function call, if it was in blocking mode).
+
+* **STS** (Sender Time Stamp): The time when the packet was
+scheduled for sending at the sender side (if you don't use the
+declared time, by default it's the monotonic time used when this
+function is called).
+
+* **RTS** (Receiver Time Stamp): The same as STS, but calculated at the receiver side. The
+only way to extract it is by using some initial statements.
+
+The "true latency" for a particular packet in SRT can be simply defined as:
+
+* `TD = PTS - STS`
+
+Note that this is a stable definition (independent of the packet),
+but this value is not really controllable. So let's define the PTS
+for a packet `x`:
+
+* `PTS[x] = ETS[x] + LATENCY + DRIFT`
+
+where `LATENCY` is the negotiated latency value (out of the
+`SRTO_RCVLATENCY` on the agent and `SRTO_PEERLATENCY` on the peer)
+and DRIFT will be described later (for simplification you can
+state it's initially 0).
+
+These components undergo the following formula:
+
+* `ETS[x] = start_time + TS[x]`
+
+Note that it's not possible to simply define a "true" latency based on STS
+because the sender and receiver are two different machines that can only
+see one another through the network. Their clocks are separate,
+and can even run at different or changing speeds, and the only
+visible phenomena happen when packets arrive at the receiver machine. 
+However, the formula above does allow us to define the start time because
+we state the following for the very first data packet:
+
+* `ETS[0] = ATS[0]`
+
+This means that from this formula we can define the start time:
+
+* `start_time = ATS[0] - TS[0]`
+
+Therefore we can state that if we have two identical clocks on
+both machines with identical time bases and speeds, then:
+
+* `ATS[x] = program_delay[x] + network_delay[x] + STS[x]`
+
+Note that two machines communicating over a network do not typically have a
+common clock base. Therefore, although this formula is correct, it involves
+components that can neither be measured nor captured at the receiver side.
+
+This formula for ATS doesn't apply to the real latency, which is based strictly 
+on ETS. But you can apply this formula for the very first arriving packet, 
+because in this case they are equal: `ATS[0] = ETS[0]`.
+
+Therefore this formula is true for the very first packet:
+
+* `ETS[0] = prg_delay[0] + net_delay[0] + STS[0]`
+
+We know also that the TS set on the sender side is:
+
+* `TS[x] = STS[x] - snd_connect_time`
+
+Taking both formulas for ETS together:
+
+* `ETS[x] = start_time + TS[x] = prg_delay[0] + net_delay[0] + snd_connect_time + TS[x]`
+
+we have then:
+
+* `start_time = prg_delay[0] + net_delay[0] + snd_connect_time`
+
+**IMPORTANT**: `start_time` is not the time of arrival of the first packet,
+but that time taken backwards by using the delay already recorded in TS. As TS should
+represent the delay towards `snd_connect_time`, `start_time` should be simply the same
+as `snd_connect_time`, just on the receiver side, and so shifted by the
+first packet's delays of `prg_delay` and `net_delay`.
+
+So, as we have the start time defined, the above formulas:
+
+* `ETS[x] = start_time + TS[x]`
+* `PTS[x] = ETS[x] + LATENCY + DRIFT`
+
+now define the packet delivery time as:
+
+* `PTS[x] = start_time + TS[x] + LATENCY + DRIFT`
+
+and after replacing the start time we have:
+
+* `PTS[x] = prg_delay[0] + net_delay[0] + snd_connect_time + TS[x] + LATENCY + DRIFT`
+
+and from the TS formula we get STS, so we replace it:
+
+* `PTS[x] = prg_delay[0] + net_delay[0] + STS[x] + LATENCY + DRIFT`
+
+We can now get the true network latency in SRT by moving STS to the other side:
+
+* `PTS[x] - STS[x] = prg_delay[0] + net_delay[0] + LATENCY + DRIFT`
+
+
+## The DRIFT
+
+The DRIFT is a measure of the variance over time of the base time. 
+To simplify the calculations above, DRIFT is considered to be 0,
+which is the initial state. In time, however, it changes based on the
+value of the Arrival Time Deviation:
+
+* `ATD[x] = ATS[x] - ETS[x]`
+
+The drift is then calculated as:
+
+* `DRIFT[x] = average(ATD[x-N] ... ATD[x])`
+
+The value of the drift is tracked over an appropriate number of samples. If
+it exceeds a threshold value, the drift value is applied to modify the
+base time. However, as you can see from the formula for ATD, the drift is
+simply taken from the actual time when the packet arrived, and the time
+when it would have arrived if the `prg_delay` and `net_delay` values were
+exactly the same as for the very first packet. ATD then represents the
+changes in these values. There can be two main factors that could result
+in having this value as non-zero:
+
+1. A phenomenon has been observed in several types of networks where
+the very first packet arrives quickly, but as subsequent data packets
+come in regularly, the network delay slightly increases and then remains fixed
+for a long time at this increased value. This phenomenon can be
+mitigated by having a reliable value for RTT. Once the increase is observed 
+a special factor could be applied to decrease the positive value
+of the drift. This isn't currently implemented. This phenomenon also
+isn't observed in every network, especially those covering longer distances.
+
+2. The clock speed on both machines (sender and receiver) isn't exactly the same, 
+which means that if you decipher the ETS basing on the TS, over time it may result
+in values that even precede the STS (suggesting a negative network delay) or that 
+have an enormous delay (with ATS exceeding PTS). This is actually the main reason 
+for tracking the drift.
diff --git a/docs/live-streaming.md b/docs/features/live-streaming.md
similarity index 81%
rename from docs/live-streaming.md
rename to docs/features/live-streaming.md
index 1ee552cc2..434f4c2aa 100644
--- a/docs/live-streaming.md
+++ b/docs/features/live-streaming.md
@@ -1,66 +1,63 @@
 
-Live streaming with SRT - guidelines
-====================================
+## Live Streaming with SRT - Guidelines
+
+**NOTE:** See also best practices and configuration tips in [Section 7.1 Live Streaming](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00#section-7.1) of the [SRT RFC](https://datatracker.ietf.org/doc/html/draft-sharabayko-srt-00).
 
 SRT is primarily created for live streaming. Before you use it, you must keep
 in mind that Live Streaming is a process with its own rules, of which SRT
 fulfills only and exclusively the transmission part. The Live Streaming process
 consists of more parts.
 
-
-Transmitting MPEG TS binary protocol over SRT
-=============================================
+## Transmitting MPEG TS binary protocol over SRT
 
 MPEG-TS is the most important protocol commonly sent over internet using
-SRT, and the main reason for initiating this project. 
+SRT, and the main reason for initiating this project.
 
-MPEG-TS consists of single units of 188 bytes. Multiplying `188*7` we get 1316, which 
-is the maximum product of 188 that is less than 1500 (`188*8=1504`), which is the 
-standard MTU size in Ethernet. The headers for the IP and UDP protocols occupy 28 bytes 
-of a standard MTU, leaving 1472 bytes, and SRT occupies next 16 bytes for its own header, 
-which leaves a maximum payload size of 1456 bytes. A 1316-byte cell is a good single 
+MPEG-TS consists of single units of 188 bytes. Multiplying `188*7` we get 1316, which
+is the maximum product of 188 that is less than 1500 (`188*8=1504`), which is the
+standard MTU size in Ethernet. The headers for the IP and UDP protocols occupy 28 bytes
+of a standard MTU, leaving 1472 bytes, and SRT occupies next 16 bytes for its own header,
+which leaves a maximum payload size of 1456 bytes. A 1316-byte cell is a good single
 transport unit size for SRT, and it is also often used when sending MPEG-TS over UDP.
 
-Note that SRT isn't limited to MPEG-TS -- it can be applied to any "live streaming" data 
-transmission (as long as you use Live mode, which is the SRT default mode). You can use 
-any other suitable data format, and any intermediate protocol on top of MPEG-TS with 
+Note that SRT isn't limited to MPEG-TS -- it can be applied to any "live streaming" data
+transmission (as long as you use Live mode, which is the SRT default mode). You can use
+any other suitable data format, and any intermediate protocol on top of MPEG-TS with
 an extra header (this is an option that people often try with RTP) - note that
 1316 is the default maximum payload size, which can be changed using the
 `SRTO_PAYLOADSIZE` option to no more than 1456).
 
 However, the transmission must still satisfy the Live Streaming Requirements.
 
-
-Live Streaming Requirements
-===========================
+## Live Streaming Requirements
 
 The MPEG-TS stream, as a good example, consists of Frames. Each
 Frame is a portion of data assigned to a particular stream (usually you have
-multipe streams interleaved, at least video and audio). The video stream always has 
+multipe streams interleaved, at least video and audio). The video stream always has
 its playing speed expressed in fps (frames per second) units. This
 value maps to a duration for one video frame. So, for example, 60 fps means that
-one video frame should be "displayed" for a duration of 1/60 of a second. You can 
-extract from the stream one video frame and several "audio frames", that is, single units 
-that are part of the audio stream that cover the same time range as the video frame. 
-Every such unit in the stream has its own *timestamp*, which can be used to synchronize 
+one video frame should be "displayed" for a duration of 1/60 of a second. You can
+extract from the stream one video frame and several "audio frames", that is, single units
+that are part of the audio stream that cover the same time range as the video frame.
+Every such unit in the stream has its own *timestamp*, which can be used to synchronize
 the reading and displaying of the data.
 
 Now, imagine the very first video frame in the
 stream, which is called an "I-frame". This frame is just a compressed picture, and it
-needs no additional information to decode it into a displayable pixmap. Several 
-transport units (of 1316 bytes) are needed to transmit the I-frame over the network. 
-The audio frames for the period of time corresponding to this video frame 
-should also fit into this "duration". So, you will need to send several units of 
-1316 bytes to transmit all these data over a network. But you usually spend much less 
-time to transmit than the actual "duration" (1/60s in our example). This doesn't mean, 
-however, that you should send the video and audio data as fast as possible and then 
-simply "sleep" for the remaining time! It means that you should split the whole 
-1/60 second **evenly** across all single 1316-byte units. There is a "unit duration" for 
-every single 1316-byte unit, so you send the unit, and then "sleep" **after 
-every unit**, if sending (as usually happens) has taken less time than the exact time 
+needs no additional information to decode it into a displayable pixmap. Several
+transport units (of 1316 bytes) are needed to transmit the I-frame over the network.
+The audio frames for the period of time corresponding to this video frame
+should also fit into this "duration". So, you will need to send several units of
+1316 bytes to transmit all these data over a network. But you usually spend much less
+time to transmit than the actual "duration" (1/60s in our example). This doesn't mean,
+however, that you should send the video and audio data as fast as possible and then
+simply "sleep" for the remaining time! It means that you should split the whole
+1/60 second **evenly** across all single 1316-byte units. There is a "unit duration" for
+every single 1316-byte unit, so you send the unit, and then "sleep" **after
+every unit**, if sending (as usually happens) has taken less time than the exact time
 predicted to be spent by sending this unit.
 
-Should sending that whole "I-Frame with corresponding audio" take **exactly** 1/60s? 
+Should sending that whole "I-Frame with corresponding audio" take **exactly** 1/60s?
 No, not exactly -- there may be some slight time differences, for two reasons:
 
 1. Sending over a network has only average time predictability. Unusual and
@@ -72,63 +69,61 @@ time based on the timestamps in the stream.
 
 2. Not all frames are I-Frames. Most of the frames sent in the video stream are
 "difference frames" (P or B frames), which can only be decoded if all preceding (or even
-succeeding) frames are already received. As you can guess, difference frames are much 
-shorter than I-Frames, so there is much less data in a whole "frame package" to 
-transport, even though these frames still cover the same time period ("duration"). 
-
-Taking the above into consideration, you can understand that the most important factor 
-in synchronizing the streaming data is to make sure that the entire I-Frame is 
-transported at a specified time, and that every subsequent frame is received at more 
-or less the same time as the I-Frame, plus one duration period. There is only a slight 
-time tolerance, which results from size differences. 
-
-What must be absolutely adhered to, however, is that the interval between the first 
-network unit transporting the first portion of one I-frame and the same unit for the 
+succeeding) frames are already received. As you can guess, difference frames are much
+shorter than I-Frames, so there is much less data in a whole "frame package" to
+transport, even though these frames still cover the same time period ("duration").
+
+Taking the above into consideration, you can understand that the most important factor
+in synchronizing the streaming data is to make sure that the entire I-Frame is
+transported at a specified time, and that every subsequent frame is received at more
+or less the same time as the I-Frame, plus one duration period. There is only a slight
+time tolerance, which results from size differences.
+
+What must be absolutely adhered to, however, is that the interval between the first
+network unit transporting the first portion of one I-frame and the same unit for the
 next I-frame must correspond to the interval between these same I-frames as given
 by their timestamps.
 
 In other words, there is some slight buffering at the receiving side, but the
-requirement for a live stream is that data must be transmitted with exactly the same 
-**average** speed as they are output by a video player. More precisely, the data must 
+requirement for a live stream is that data must be transmitted with exactly the same
+**average** speed as they are output by a video player. More precisely, the data must
 be produced at exactly the same speed as they will be consumed by the video player.
 
+## Live Streaming Process
 
-Live Streaming Process
-======================
-
-Now that you know how Live Streaming turns a bunch of MPEG-TS encoded video and audio 
-frames into a network live stream, let's complete the definition of live streaming 
+Now that you know how Live Streaming turns a bunch of MPEG-TS encoded video and audio
+frames into a network live stream, let's complete the definition of live streaming
 by describing transport over the network using SRT.
 
 The source side should be a real live stream, such as for example:
 
 - a file read by an application that can generate a live stream
-- a frame grabber or other device that is capturing data at constant rates, and then 
+- a frame grabber or other device that is capturing data at constant rates, and then
 passing them to a live encoder
 - a live network encoder sending a live stream over UDP
 - a camera that uses some simple encoding method, like MJPEG
 
-`ffmpeg` is an example of an application that can generate a live stream from a file. 
+`ffmpeg` is an example of an application that can generate a live stream from a file.
 Note the following:
 
 - The `-re` option is required for making a live stream from a file
 - The `pkt_size=1316` parameter should be added to the UDP output URI, if you make
 ffmpeg output to UDP
 
-As we described above, you must first split the data into individual cells that can fit 
-into one UDP packet. This entails defining time intervals between these cells so that 
-they are in synch with the timestamps in the transport stream. 
+As we described above, you must first split the data into individual cells that can fit
+into one UDP packet. This entails defining time intervals between these cells so that
+they are in synch with the timestamps in the transport stream.
 
-If you have a device that is capable of grabbing individual frames, it will usually 
+If you have a device that is capable of grabbing individual frames, it will usually
 capture only one video frame and the corresponding audio at a time, which must be split
-into single network units with appropriate time intervals between them. This can only 
-be done by an application with explicit knowledge of the type of stream and how to 
+into single network units with appropriate time intervals between them. This can only
+be done by an application with explicit knowledge of the type of stream and how to
 transform it into time-divided single network transport units.
 
 The `srt-live-transmit` application, or any other application that uses SRT for
 reading, should always read data in 1316-byte segments (network transport units) and
 feed each such unit into the call to an appropriate `srt_send*` function. The
-important part of this process is that these 1316-byte units appear at precise times 
+important part of this process is that these 1316-byte units appear at precise times
 so that SRT can replay them with the identical time interval
 between them on the receiving side.
 
@@ -140,7 +135,7 @@ unexpected transmission delays for a UDP packet, as well as allowing extra time
 for the case where a packet is lost and has to be retransmitted. Every UDP
 packet carrying an SRT packet has a timestamp, which is grabbed at the time
 when the packet is passed to SRT for sending. Using that timestamp the
-appropriate delay is applied before delivering to the output. This ensures that the 
-time intervals between two consecutive packets at the delivery application are identical 
-to the intervals between these same packets at the moment they were passed to SRT 
+appropriate delay is applied before delivering to the output. This ensures that the
+time intervals between two consecutive packets at the delivery application are identical
+to the intervals between these same packets at the moment they were passed to SRT
 for streaming.
diff --git a/docs/packet-filtering-and-fec.md b/docs/features/packet-filtering-and-fec.md
similarity index 87%
rename from docs/packet-filtering-and-fec.md
rename to docs/features/packet-filtering-and-fec.md
index acb12405d..b596a26f4 100644
--- a/docs/packet-filtering-and-fec.md
+++ b/docs/features/packet-filtering-and-fec.md
@@ -21,12 +21,12 @@ SRT Packet Filtering & FEC
 
 # Introduction
 
-SRT has a general-purpose mechanism for injecting extra processing instructions 
-at the beginning and/or end of a transmission. This mechanism, based on packet 
-filtering, was originally created as a means to implement Forward Error 
-Correction (FEC) in SRT, but can be extended for other uses. 
+SRT has a general-purpose mechanism for injecting extra processing instructions
+at the beginning and/or end of a transmission. This mechanism, based on packet
+filtering, was originally created as a means to implement Forward Error
+Correction (FEC) in SRT, but can be extended for other uses.
 
-As of SRT version 1.4 there is one built-in filter ("fec") installed, but more 
+As of SRT version 1.4 there is one built-in filter ("fec") installed, but more
 can be added.
 
 # Configuration
@@ -40,33 +40,34 @@ general syntax:
 ```
 <filter-type>,<key>:<value>[,...]
 ```
-The parts of this syntax are separated by commas. The first part is the name of 
-the filter. This is followed by one or more key:value pairs, the interpretation 
-of which depends on the filter type.
+The parts of this syntax are separated by commas. The first part is the name of
+the filter. This is followed by one or more key:value pairs, the interpretation
+of which depends on the filter type. Note that all keys and values are
+case-sensitive.
 
 You can try this out using the `SRTO_PACKETFILTER` option, or the
 `packetfilter` parameter in an SRT URI in the applications.
 
 The packet filter framework is open for extensions so that users may register
-their own filters. SRT provides also one builtin filter named "fec". This
+their own filters. SRT provides also one built-in filter named "fec". This
 filter implements the FEC mechanism, as described in SMPTE 2022-1-2007.
 
-![SRT packet filter mechanism](/docs/images/packet-filter-mechanism.png)
+![SRT packet filter mechanism](images/packet-filter-mechanism.png)
 
-On the input side, filtering occurs at the moment when a packet is extracted 
+On the input side, filtering occurs at the moment when a packet is extracted
 from the send buffer. A filter may then do two things:
 
-* alter the packet before inserting it into the SRT channel (the builtin "fec"
+* alter the packet before inserting it into the SRT channel (the built-in "fec"
   filter doesn't do it, though)
 
 * insert another packet (such as an FEC control packet) into the channel ahead
   of the next waiting packet from the send buffer.
 
-On the receiving side a packet is first reviewed by the filter, and then 
-potentially passed to the receive buffer. In the case of FEC, the output of the 
+On the receiving side a packet is first reviewed by the filter, and then
+potentially passed to the receive buffer. In the case of FEC, the output of the
 filter may be:
 
-* nothing (this happens when an FEC control packet is received but does not 
+* nothing (this happens when an FEC control packet is received but does not
   trigger rebuilding)
 
 * one or more packets (when together with a newly received packet the FEC
@@ -77,12 +78,12 @@ filter may be:
 To use the FEC filter, set `<filter-type>` in your configuration to `fec`.
 Then add the appropriate key:value pairs based on the following parameters:
 
-* **cols**: The number of columns in your FEC matrix (which is the equivalent of 
-the size of each row). This parameter is obligatory and must be a positive 
+* **cols**: The number of columns in your FEC matrix (which is the equivalent of
+the size of each row). This parameter is obligatory and must be a positive
 number >=2.
 
-* **rows**: The number of rows in your FEC matrix (which is the equivalent of 
-the size of each column). This parameter is optional and defaults to 1. If the 
+* **rows**: The number of rows in your FEC matrix (which is the equivalent of
+the size of each column). This parameter is optional and defaults to 1. If the
 value is >=2, this corresponds to the exact number of rows. Beside this, two
 other special cases are allowed:
 
@@ -95,30 +96,30 @@ a number of columns in one series)
 
 * **layout**: The format of the FEC matrix. The possible values are:
 
-    * **even**: block aligned (default) - columns are arranged in a solid matrix; 
+    * **even**: block aligned (default) - columns are arranged in a solid matrix;
     the first sequence numbers (SNbase) are all contained in one row:
 
-    ![Block-aligned Example](/docs/images/block-aligned.png)
+    ![Block-aligned Example](images/block-aligned.png)
 
-    * **staircase**: non-block aligned - column starting points are staggered; 
+    * **staircase**: non-block aligned - column starting points are staggered;
     the first sequence numbers (SNbase) have an offset equivalent to R+1:
 
-    ![Non-block-aligned Example](/docs/images/non-block-aligned.png)
+    ![Non-block-aligned Example](images/non-block-aligned.png)
 
 
-* **arq**: Optional use of the Automatic Repeat Request (ARQ) protocol. The 
+* **arq**: Optional use of the Automatic Repeat Request (ARQ) protocol. The
 possible values are:
 
-    * **always**: ARQ is done in parallel with FEC (a loss is always reported 
+    * **always**: ARQ is done in parallel with FEC (a loss is always reported
     immediately once detected in SRT).
 
-    * **onreq**: ARQ is allowed, but a loss is only reported when FEC fails to 
-    rebuild, at the moment when an incoming packet has a sequence number that 
-    exceeds the last in one of the column groups; such a packet, if still lacking 
+    * **onreq**: ARQ is allowed, but a loss is only reported when FEC fails to
+    rebuild, at the moment when an incoming packet has a sequence number that
+    exceeds the last in one of the column groups; such a packet, if still lacking
     at that moment, is considered no longer recoverable by FEC.
 
-    * **never**: ARQ is not done at all. Packets not recovered by FEC undergo 
-    TLPKTDROP, just like those that fail ARQ recovery in a conventional SRT 
+    * **never**: ARQ is not done at all. Packets not recovered by FEC undergo
+    TLPKTDROP, just like those that fail ARQ recovery in a conventional SRT
     exchange.
 
 For example, this is how it should be used in the URI:
@@ -129,21 +130,21 @@ srt://recv.com:5000?latency=500&packetfilter=fec,cols:10,rows:5
 As there can only be one configuration for both parties, it is recommended that one party
 defines the full configuration while the other only defines the matching packet filter type
 (for example, the sender sets `fec,cols:10,rows:-5,layout:staircase` and the receiver sets
-just `fec`). Both parties can also set this option to the same value. The packet filter function 
+just `fec`). Both parties can also set this option to the same value. The packet filter function
 will attempt to merge configuration definitions, but if the options specified are in
 conflict, the connection will be rejected.
 
 ## **The motivation for staircase arrangement**
 
-Normally, FEC is done using a solid (block aligned) matrix. Packet sequences are 
-arranged in a two-dimensional array of R rows and C columns. With SRT, the 
-problem is that the FEC control packets are only transmitted when the last row 
+Normally, FEC is done using a solid (block aligned) matrix. Packet sequences are
+arranged in a two-dimensional array of R rows and C columns. With SRT, the
+problem is that the FEC control packets are only transmitted when the last row
 is retransmitted.
 
-Let's imagine 10 columns and 5 rows starting from sequence 500. The rows begin 
-with sequences numbers 500, 510, 520, 530 and 540 (where 540 is the start of the 
-last row). Here is a representation of a series of packets transmitted starting 
-from around the middle of the second-to-last row up until the end of the last 
+Let's imagine 10 columns and 5 rows starting from sequence 500. The rows begin
+with sequences numbers 500, 510, 520, 530 and 540 (where 540 is the start of the
+last row). Here is a representation of a series of packets transmitted starting
+from around the middle of the second-to-last row up until the end of the last
 row (H = horizontal position; V = vertical position):
 ```
 ...
@@ -198,21 +199,21 @@ row (H = horizontal position; V = vertical position):
 
 <FEC/V:549>  -> column FEC packet for the last column
 ```
-Given a constant bitrate at the input, there's a certain bandwidth normally used 
-by the regularly transmitted data packets. But when the last row in a series is 
-transmitted, the transmission will use twice the normal bandwidth because of all 
+Given a constant bitrate at the input, there's a certain bandwidth normally used
+by the regularly transmitted data packets. But when the last row in a series is
+transmitted, the transmission will use twice the normal bandwidth because of all
 the column FEC packets.
 
 There are three methods for mitigating this:
 
 1. *Limit the bandwidth in SRT using* `SRTO_MAXBW`.
 
-    This means that packets will not be transmitted as fast as the FEC mechanism 
-requires, and will add extra delay to the transmission of regular packets. 
-Normally, this shouldn't matter much, as there's already a very high minimum 
-latency you must configure with FEC. This is based on the size of the matrix 
-(50 in the above example), multiplied by the bitrate, divided by a 
-bytes-per-packet factor. But if you use FEC and ARQ together, delaying a packet 
+    This means that packets will not be transmitted as fast as the FEC mechanism
+requires, and will add extra delay to the transmission of regular packets.
+Normally, this shouldn't matter much, as there's already a very high minimum
+latency you must configure with FEC. This is based on the size of the matrix
+(50 in the above example), multiplied by the bitrate, divided by a
+bytes-per-packet factor. But if you use FEC and ARQ together, delaying a packet
 at the sender side may challenge the response time for retransmission.
 
 2. *Delay sending the FEC control packet itself.*  **-> A concept, NOT IMPLEMENTED**
@@ -227,16 +228,16 @@ in a group and the control packet by a factor based on twice the matrix size
 	While in a simple (block aligned) matrix, the packet sequence numbers at
 the start of each column increment by 1, in a staircase (non-block aligned)
 matrix arrangement, the packet sequence numbers at the start of each column
-increment by R+1, where R is the row size. 
+increment by R+1, where R is the row size.
 
-Let's again imagine a matrix of 10 columns and 5 rows starting from sequence 500. 
-The rows begin with sequences numbers 500, 510, 520, 530 and 540. But the columns 
-begin in staggered fashion, separated by an interval of R+1. The colours represent 
-consecutive FEC groups (note the "staircase" pattern): 
+Let's again imagine a matrix of 10 columns and 5 rows starting from sequence 500.
+The rows begin with sequences numbers 500, 510, 520, 530 and 540. But the columns
+begin in staggered fashion, separated by an interval of R+1. The colours represent
+consecutive FEC groups (note the "staircase" pattern):
 
-![5R x 10C Staircase Pattern](/docs/images/staircase-pattern-5rx10c.png)
+![5R x 10C Staircase Pattern](images/staircase-pattern-5rx10c.png)
 
-Here is a representation of a series of packets transmitted starting from 
+Here is a representation of a series of packets transmitted starting from
 packet 537 (H = horizontal position; V = vertical position):
 ```
 ...
@@ -285,17 +286,17 @@ packet 537 (H = horizontal position; V = vertical position):
 
 ...
 ```
-Unlike with the block-aligned arrangement, the transmission of the FEC packets 
+Unlike with the block-aligned arrangement, the transmission of the FEC packets
 is well spaced, thus avoiding spikes in the use of available bandwidth.
 
-Note that with the staircase arrangement, the initial packets sent when a 
-connection is established will not be covered by an FEC group. But it is 
-generally not a problem when packets are lost in the first 2 seconds of a 
-transmission. If needed, even this can be mitigated by adding a series of unused 
+Note that with the staircase arrangement, the initial packets sent when a
+connection is established will not be covered by an FEC group. But it is
+generally not a problem when packets are lost in the first 2 seconds of a
+transmission. If needed, even this can be mitigated by adding a series of unused
 groups to the FEC matrix before the transmission starts (a concept potentially
 to be implemented).
 
-Another advantage of the staircase arrangement is that it increases the 
+Another advantage of the staircase arrangement is that it increases the
 probability of recovering a long sequence of a lost packets in a case when
 consecutive lost packets in a row will belong to different column groups. In
 the example below, it is likely that the entire missing sequence from 572 to
@@ -303,7 +304,7 @@ the example below, it is likely that the entire missing sequence from 572 to
 groups (once these are rebuilt, it becomes possible to rebuild packets 572 and
 582 via row FEC):
 
-![Rebuild Missing Sequence](/docs/images/rebuild-missing-sequence.png)
+![Rebuild Missing Sequence](images/rebuild-missing-sequence.png)
 
 Although in a case of even arrangement you still may have a good luck of
 having a long loss exactly at the border of two column series, the staircase
@@ -313,10 +314,10 @@ be successfully recovered.
 
 # The Built-in FEC Filter
 
-The built-in FEC filter implements the standard XOR-based FEC protection 
-operation. It qualifies packets into groups (see [Layout](#heading=h.wkpnk3l9ni7i) 
-option). For every group, an FEC control packet is generated that can be used to 
-rebuild a packet that was lost. 
+The built-in FEC filter implements the standard XOR-based FEC protection
+operation. It qualifies packets into groups (see [Layout](#heading=h.wkpnk3l9ni7i)
+option). For every group, an FEC control packet is generated that can be used to
+rebuild a packet that was lost.
 
 The built-in FEC filter allows for the following possible configurations:
 
@@ -326,14 +327,14 @@ The built-in FEC filter allows for the following possible configurations:
 
 * **columns and rows**
 
-A row is a series of consecutive packets from a base sequence number up to a 
+A row is a series of consecutive packets from a base sequence number up to a
 number (N) of packets, with N being equal to the size of the row (R).
 
-A column is a series of packets that starts at a base sequence number, with 
-subsequent packets in the column group separated over an interval N (which is 
+A column is a series of packets that starts at a base sequence number, with
+subsequent packets in the column group separated over an interval N (which is
 also the size of the row).
 
-It's important to note that the size of a row (R) is equal to the number of 
+It's important to note that the size of a row (R) is equal to the number of
 columns, and the size of a column (C) is equal to the number of rows.
 
 ## Sending
@@ -347,7 +348,7 @@ a protection operation is performed are:
 * content length
 * contents - padded with zeros up to payloadSize()
 
-For the timestamp recovery, the header field TIMESTAMP is reused. For all others 
+For the timestamp recovery, the header field TIMESTAMP is reused. For all others
 there are extra fields in the payload space of the SRT packet:
 
 * 8 bits: group index (for rows this is -1)
@@ -362,8 +363,8 @@ then be returned at the next call to `packControlPacket`. This function checks i
 the FEC control packet is ready for extraction, first for the row group, then
 for the column group, and provides it if it is ready.
 
-An FEC control packet is distinguished from a regular data packet by having its 
-message number equal to 0. This value isn't normally used in SRT (message numbers 
+An FEC control packet is distinguished from a regular data packet by having its
+message number equal to 0. This value isn't normally used in SRT (message numbers
 start from 1, increment to a maximum, and then roll back to 1).
 
 Figure 1 - SRT data packet structure
@@ -406,16 +407,16 @@ Figure 2 - FEC control packet structure
 ```
 ## Receiving
 
-The receiver must first determine whether the packet is a regular data packet or 
-an FEC control packet. 
+The receiver must first determine whether the packet is a regular data packet or
+an FEC control packet.
 
-If the `getMsgSeq()` function returns 0 (signifying the packet is an FEC control 
-packet), then the first byte from the FEC header in that packet is extracted to 
-determine if this corresponds to a column FEC (contains the column number) or 
+If the `getMsgSeq()` function returns 0 (signifying the packet is an FEC control
+packet), then the first byte from the FEC header in that packet is extracted to
+determine if this corresponds to a column FEC (contains the column number) or
 row FEC (contains -1).
 
-If the `getMsgSeq()` function identifies a regular packet, then the packet is 
-inserted into the horizontal and vertical position of the FEC group to which it 
+If the `getMsgSeq()` function identifies a regular packet, then the packet is
+inserted into the horizontal and vertical position of the FEC group to which it
 belongs by performing the XOR operation with the current contents of the recovery
 buffer and increasing the packets' count (the number of currently processed
 packets in the FEC group buffer). Note that at the receiver there is only one
@@ -424,8 +425,8 @@ on which the XOR protection operation has been performed and added to that
 group's recovery buffer. This operation is done as well on the FEC control
 packet, although this is marked by a separate flag.
 
-The FEC control packet is inserted into the group to which it is destined (its 
-sequence number is the last sequence in the group). Once you have a state where 
+The FEC control packet is inserted into the group to which it is destined (its
+sequence number is the last sequence in the group). Once you have a state where
 the group buffer contains the result of the XOR operation of the FEC control
 packet and N-1 data packets from this group (with N being the size of the
 group), the group is rebuild-ready, and the contents of a missing packet can be
@@ -436,12 +437,12 @@ bit flag for its sequence number. The sequence number of the missing packet is
 therefore determined by examining this flag for all these sequence numbers to
 find out which one is missing. The packet is then rebuilt by:
 
-* setting default values in the header (socket ID for the connection, message 
+* setting default values in the header (socket ID for the connection, message
 number 1)
 
 * setting the sequence number to the number found for the missing packet
 
-* setting the flags directly from the corresponding contents of the FEC group 
+* setting the flags directly from the corresponding contents of the FEC group
 buffer (Flag Recovery from the FEC header);  the retransmission flag is always
 set
 
@@ -453,18 +454,18 @@ Recovery
 * setting the payload contents from the corresponding contents of Data Recovery,
 up to the payload size as read above
 
-If both columns and rows are used, the rebuilding happens recursively - that is, 
-after a packet is rebuilt its contents are also XORed to the row or column in 
-the FEC group to which it simultaneously belongs, and then that row or column is 
-checked again.That may trigger the rebuilding of another packet, which in turn 
+If both columns and rows are used, the rebuilding happens recursively - that is,
+after a packet is rebuilt its contents are also XORed to the row or column in
+the FEC group to which it simultaneously belongs, and then that row or column is
+checked again.That may trigger the rebuilding of another packet, which in turn
 causes a new column or row to be checked, and so on.
 
-The rebuilt packets are stored in the provided array so that they can be picked 
+The rebuilt packets are stored in the provided array so that they can be picked
 up by SRT to insert them all into the receiver buffer.
 
 ## FEC Packet Header
 
-In SRT, FEC control packets have an extra header so that all the recovery 
+In SRT, FEC control packets have an extra header so that all the recovery
 information can be contained. This is the breakdown of the FEC control packet:
 ```
    0                   1                   2                   3
@@ -483,49 +484,49 @@ information can be contained. This is the breakdown of the FEC control packet:
    |                    Payload Recovery...                        | Data
 
 ```
-This is much like a regular data packet in SRT, except that there's an extra 32-bit 
-special FEC header with additional information, and also many of the fields in the 
+This is much like a regular data packet in SRT, except that there's an extra 32-bit
+special FEC header with additional information, and also many of the fields in the
 SRT header are used for a different purpose:
 
-- **Packet Sequence Number:** Contains the sequence number of the last packet in 
+- **Packet Sequence Number:** Contains the sequence number of the last packet in
 the FEC group to which this FEC control packet is assigned.
 
-- **FF (Packet position flag):** 11b (solo). FEC is currently used only in Live 
+- **FF (Packet position flag):** 11b (solo). FEC is currently used only in Live
 mode, where this is the only value that applies.
 
-- **O (Deliver in order flag):** This flag is taken from the first data packet 
-during sending and kept this way for all FEC packets, without checking other 
-data packets. It's assumed that in Live mode all packets have this flag set 
+- **O (Deliver in order flag):** This flag is taken from the first data packet
+during sending and kept this way for all FEC packets, without checking other
+data packets. It's assumed that in Live mode all packets have this flag set
 the same way.
 
-- **KK (Encryption flag):** 00b (unencrypted). The encryption specification doesn't 
-apply to FEC control packets because the protection operation is being performed 
+- **KK (Encryption flag):** 00b (unencrypted). The encryption specification doesn't
+apply to FEC control packets because the protection operation is being performed
 on the contents, whether they have been encrypted or not.
 
-- **R (Retransmission flag):** 1 (set). An FEC control packet is marked as a 
+- **R (Retransmission flag):** 1 (set). An FEC control packet is marked as a
 retransmission to prevent it from being treated as a reordered packet.
 
 - **Message Number:** 0 (a special value identifying an FEC control packet)
 
 - **Time Stamp:** Contains the timestamp recovery (XOR)
 
-- **Destination Socket ID:** Same as in regular SRT packets, as required to 
+- **Destination Socket ID:** Same as in regular SRT packets, as required to
 dispatch the packet to the correct socket.
 
-- **Group Index:** Contains the column number, if it's for a column group, or -1, 
-if it is for a row group. The only functional purpose of this field is to know 
+- **Group Index:** Contains the column number, if it's for a column group, or -1,
+if it is for a row group. The only functional purpose of this field is to know
 whether this FEC control packet is for a row group or for a column group.
 
-- **Flag recovery:** Contains the recovery bits to recover the flags preceding the 
-Message Number field. Currently applies only to the **KK** flags, because 
+- **Flag recovery:** Contains the recovery bits to recover the flags preceding the
+Message Number field. Currently applies only to the **KK** flags, because
 encrypted packets may have KK set to 01 or 10 for the same transmission.
 
 - **Length recovery:** 16-bit field containing the XOR of the packet length.
 
-- **Payload recovery:** Contains the XOR-ed value of all payloads from packets in 
+- **Payload recovery:** Contains the XOR-ed value of all payloads from packets in
 the group, each one padded with zeros before the operation up to `payloadSize()`.
 
-For reference, here is the FEC header for transmission over RTP according 
+For reference, here is the FEC header for transmission over RTP according
 to RFC 2733:
 ```
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -536,225 +537,225 @@ to RFC 2733:
    |                          TS recovery                          |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ```
-- **SNBase:** Minimum sequence number of the packets associated to the FEC packet, 
-and where 16 bit sequence numbers are sufficient, this parameter shall contain 
-the entire sequence number. For transport protocols with longer sequence numbers 
+- **SNBase:** Minimum sequence number of the packets associated to the FEC packet,
+and where 16 bit sequence numbers are sufficient, this parameter shall contain
+the entire sequence number. For transport protocols with longer sequence numbers
 this field shall contain the least significant 16 bits of the sequence number.
 
-- **Length Recovery:** This field should be used to determine the length of any 
+- **Length Recovery:** This field should be used to determine the length of any
 media packets associated with the FEC packet.
 
-- **PT recovery:** This field should be used to determine the Payload Type of any 
+- **PT recovery:** This field should be used to determine the Payload Type of any
 media packets associated with the FEC packet.
 
-- **TS recovery:** This field should be used to recover the timestamp of any media 
+- **TS recovery:** This field should be used to recover the timestamp of any media
 packets associated with the FEC packet.
 
 These fields have equivalents in the FEC control packet in SRT:
 
-- **SNBase** (both low bits and ext bits): This is equivalent to 
-the **Packet Sequence Number** (which is already 32-bit) since the sequence 
+- **SNBase** (both low bits and ext bits): This is equivalent to
+the **Packet Sequence Number** (which is already 32-bit) since the sequence
 numbers used for FEC in SRT are just the existing sequence numbers.
 
-- **Length recovery:** There's a similar **Length recovery** field in the extra 
+- **Length recovery:** There's a similar **Length recovery** field in the extra
 FEC header.
 
-- **PT recovery:** This field is specific to RTP, but is similar to 
+- **PT recovery:** This field is specific to RTP, but is similar to
 the **Flag recovery** field.
 
-- **TS recovery:** In SRT FEC the timestamp recovery is stored in the 
+- **TS recovery:** In SRT FEC the timestamp recovery is stored in the
 SRT header's **Timestamp** field (being Time Stamp Recovery in this case)
 
-- **Index, Offset:** Some similarities can be found in the **Group index** field. 
-However its purpose is mainly to distinguish row and column groups. The index 
+- **Index, Offset:** Some similarities can be found in the **Group index** field.
+However its purpose is mainly to distinguish row and column groups. The index
 itself is only for prospective sanity checks.
 
 ## Cooperation with retransmission
 
-The ARQ level is a value that decides how the packet filtering should cooperate 
+The ARQ level is a value that decides how the packet filtering should cooperate
 with retransmission. Possible values are:
 
-- **NEVER**: Do not do retransmission at all. This means that packets are always 
+- **NEVER**: Do not do retransmission at all. This means that packets are always
 ACK-ed up to the last sequence that is received, and all losses are ignored.
 
-- **ALWAYS**: Do normal retransmission - that is, the retransmission request is 
-sent immediately upon loss detection, possibly in parallel with FEC rebuilding. 
-This might be useful for networks with high bandwidth capacity that happen to 
-be very unstable; working with both FEC and ARQ on the same edge increases the 
-probability that whatever can't be restored by one system will be restored by 
+- **ALWAYS**: Do normal retransmission - that is, the retransmission request is
+sent immediately upon loss detection, possibly in parallel with FEC rebuilding.
+This might be useful for networks with high bandwidth capacity that happen to
+be very unstable; working with both FEC and ARQ on the same edge increases the
+probability that whatever can't be restored by one system will be restored by
 the other as fast as possible. However, both ARQ and FEC overheads will apply.
 
-- **ONREQ**: Lost packets are recorded by SRT, but the loss report is not sent 
-unless a sequence is reported in `loss_seqs` (see "Receiving" in the **Packet Filter 
-Framework** section for details on how packets that are not recoverable by FEC 
-are reported). Note that in this case the lost packets will be reported with a 
-delay. At very low latency there is very little time to recover by ARQ in 
-general, and with the added delay incurred by using this option there is even 
+- **ONREQ**: Lost packets are recorded by SRT, but the loss report is not sent
+unless a sequence is reported in `loss_seqs` (see "Receiving" in the **Packet Filter
+Framework** section for details on how packets that are not recoverable by FEC
+are reported). Note that in this case the lost packets will be reported with a
+delay. At very low latency there is very little time to recover by ARQ in
+general, and with the added delay incurred by using this option there is even
 less, to the point where it may always be too late to retransmit.
 
-Note that in ALWAYS and NEVER modes the filter should not return anything 
+Note that in ALWAYS and NEVER modes the filter should not return anything
 in `loss_seqs`.
 
-It's very important that the latency is properly set. The FEC mechanism may 
-rebuild a packet, but it's delivery will be delayed by the time it takes for 
-enough packets to be accumulated in the corresponding group to trigger the 
-rebuild. The minimum value for the delay due to rebuilding is based on the 
+It's very important that the latency is properly set. The FEC mechanism may
+rebuild a packet, but it's delivery will be delayed by the time it takes for
+enough packets to be accumulated in the corresponding group to trigger the
+rebuild. The minimum value for the delay due to rebuilding is based on the
 number of packets:
 ```
-N = (R * (C-1)) + 2 
+N = (R * (C-1)) + 2
 ```
-(where R = row size, and C = column size). 
+(where R = row size, and C = column size).
 
-The SRT latency should be set such that, given the current bitrate, it is at 
-least equal to the time it takes to send the N packets in an FEC group, and even 
-this minimum should be increased by an extra safety margin. If this condition 
+The SRT latency should be set such that, given the current bitrate, it is at
+least equal to the time it takes to send the N packets in an FEC group, and even
+this minimum should be increased by an extra safety margin. If this condition
 isn't met, the TLPKTDROP mechanism may drop packets even if they can be rebuilt.
 
-The standard recommended minimum ARQ latency for SRT is estimated as 4 * RTT. 
-If you choose to use FEC in cooperation with ARQ with the **ALWAYS** level, your 
-latency penalty should be the maximum of the standard ARQ latency and the FEC 
-latency (which usually means that only the FEC latency penalty should apply). 
-If you use the **ONREQ** level, your latency penalty should be the sum of 
+The standard recommended minimum ARQ latency for SRT is estimated as 4 * RTT.
+If you choose to use FEC in cooperation with ARQ with the **ALWAYS** level, your
+latency penalty should be the maximum of the standard ARQ latency and the FEC
+latency (which usually means that only the FEC latency penalty should apply).
+If you use the **ONREQ** level, your latency penalty should be the sum of
 these two.
 
-With the ONREQ setting, the built-in FEC filter collects the sequence numbers 
-of all packets that are lost and no longer recoverable. This is recognized by 
-the fact that a packet has come with a sequence number that is past the last 
-sequence number for a particular group. All groups for which this packet is 
-"in the future" are dismissed, that is, the irrecoverable packets are reported 
-at this call and the dismissed flag is set so that it's not reported again. 
+With the ONREQ setting, the built-in FEC filter collects the sequence numbers
+of all packets that are lost and no longer recoverable. This is recognized by
+the fact that a packet has come with a sequence number that is past the last
+sequence number for a particular group. All groups for which this packet is
+"in the future" are dismissed, that is, the irrecoverable packets are reported
+at this call and the dismissed flag is set so that it's not reported again.
 Note that this group isn't physically deleted at this time.
 
 ## FEC Group Dismissal and Deletion
 
-At some point, row and column groups are dismissed, which means that they are 
-no longer of use. Missing packets are reported as irrecoverable, and the group 
-is marked dismissed (so that this happens only once). This happens upon arrival 
-of a packet with a sequence number that is higher than that of the last sequence 
+At some point, row and column groups are dismissed, which means that they are
+no longer of use. Missing packets are reported as irrecoverable, and the group
+is marked dismissed (so that this happens only once). This happens upon arrival
+of a packet with a sequence number that is higher than that of the last sequence
 number in the group.
 
-Dismissed FEC groups (and objects representing them) are deleted when no longer 
-needed. This happens when the whole series of groups is already in the past 
+Dismissed FEC groups (and objects representing them) are deleted when no longer
+needed. This happens when the whole series of groups is already in the past
 relative to the incoming packet.
 
-Column and row groups are arranged in series, where the earliest active series 
-is 0, the next is 1, and so on. When series 0 is deleted, series 1 becomes the 
-new series 0. A column or row group is always deleted with the entire series 
+Column and row groups are arranged in series, where the earliest active series
+is 0, the next is 1, and so on. When series 0 is deleted, series 1 becomes the
+new series 0. A column or row group is always deleted with the entire series
 to which it belongs (never by itself).
 
-For block-aligned (even) FEC arrangements, a series is easily defined as all 
-column and row groups that fit in a given size of matrix. All groups are deleted 
-by deleting the entire matrix. In the figure below, with a matrix size of 5 rows 
-by 10 columns, the green region of column and row groups (series 0) is deleted 
+For block-aligned (even) FEC arrangements, a series is easily defined as all
+column and row groups that fit in a given size of matrix. All groups are deleted
+by deleting the entire matrix. In the figure below, with a matrix size of 5 rows
+by 10 columns, the green region of column and row groups (series 0) is deleted
 once a packet (#550 or later)  from the red region (series 1) arrives.
 
-![Block Aligned 5R x 10C](/docs/images/block-aligned-5rx10c.png)
+![Block Aligned 5R x 10C](images/block-aligned-5rx10c.png)
 
 
-For non block-aligned (staircase) FEC arrangements, a series has a more complex 
-definition, and the trigger for deletion comes later (and may therefore use more 
-memory for FEC groups than an even arrangement). Let's look at a specific example. 
-In the figure below (also a matrix size of 5 rows by 10 columns), we can define 
-packet #500 as base0 - the very first sequence number in a group that is still 
+For non block-aligned (staircase) FEC arrangements, a series has a more complex
+definition, and the trigger for deletion comes later (and may therefore use more
+memory for FEC groups than an even arrangement). Let's look at a specific example.
+In the figure below (also a matrix size of 5 rows by 10 columns), we can define
+packet #500 as base0 - the very first sequence number in a group that is still
 active. Red then represents series 0, blue series 1, and white series 2:
 
-![Non-block Aligned 5R x 10C](/docs/images/non-block-aligned-5rx10c.png)
+![Non-block Aligned 5R x 10C](images/non-block-aligned-5rx10c.png)
 
 
-In a staircase arrangement, the minimum distance between base0 and the first 
-incoming packet that might trigger deletion is two times the size of the matrix 
-(an arbitrary value chosen for the sake of simplicity and to provide a small 
-margin of safety; it doesn't impact the functionality because deletion is 
+In a staircase arrangement, the minimum distance between base0 and the first
+incoming packet that might trigger deletion is two times the size of the matrix
+(an arbitrary value chosen for the sake of simplicity and to provide a small
+margin of safety; it doesn't impact the functionality because deletion is
 independent of dismissal, except for the fact that the latter must happen first).
-For example, deletion of the column and row groups in series 0 (the red region) 
-will be triggered by reception of packet #600 (or greater, because packets can 
-be lost). 
-
-Once the trigger packet arrives, all column groups belonging to series 0 (red) 
-are deleted, as well as all rows that begin with packets from the base0 column 
-group - that is, all rows whose first packet falls in the sequence from #500 to 
-#540. In the figure below, deletion of series 0 corresponds to columns with a 
+For example, deletion of the column and row groups in series 0 (the red region)
+will be triggered by reception of packet #600 (or greater, because packets can
+be lost).
+
+Once the trigger packet arrives, all column groups belonging to series 0 (red)
+are deleted, as well as all rows that begin with packets from the base0 column
+group - that is, all rows whose first packet falls in the sequence from #500 to
+#540. In the figure below, deletion of series 0 corresponds to columns with a
 red background and rows with a red border:
 
-![Non-block Aligned 5R x 10C Deleted Packets](/docs/images/non-block-aligned-5rx10c-deleted-packets.png)
+![Non-block Aligned 5R x 10C Deleted Packets](images/non-block-aligned-5rx10c-deleted-packets.png)
 
 
-After the red series 0 is deleted, packet #550 becomes the new base0, packets in 
-the column from #550 to #559 define the new first row group, and the blue packets 
+After the red series 0 is deleted, packet #550 becomes the new base0, packets in
+the column from #550 to #559 define the new first row group, and the blue packets
 become series 0.
 
-When column groups are in the staircase arrangement, the penalty for loss 
-detection (encountered with the ONREQ level) shall be always counted as the size 
-of the matrix (a product of both group sizes). A certain number of packets must 
-be received after the packet that caused a loss detection in order for the FEC 
-facility to report it as lost and not recoverable. In other words, the FEC 
-penalty is the number of packets between the lost packet and the first packet 
-that triggered sending a loss report for that lost packet. The FEC mechanism 
+When column groups are in the staircase arrangement, the penalty for loss
+detection (encountered with the ONREQ level) shall be always counted as the size
+of the matrix (a product of both group sizes). A certain number of packets must
+be received after the packet that caused a loss detection in order for the FEC
+facility to report it as lost and not recoverable. In other words, the FEC
+penalty is the number of packets between the lost packet and the first packet
+that triggered sending a loss report for that lost packet. The FEC mechanism
 always waits for the moment when the lost packet is declared irrecoverable.
 
 # Packet Filter Framework
 
-The built-in FEC facility is connected with SRT through a mechanism called 
-"packet filtering". This mechanism relies on the following checkpoints which 
+The built-in FEC facility is connected with SRT through a mechanism called
+"packet filtering". This mechanism relies on the following checkpoints which
 allow for packet filter injection:
 
 * Sending:
 
-    * a filter is first asked if it is ready to deliver a control packet; if so 
-    it is expected to deliver it, and this packet is sent instead of a data 
+    * a filter is first asked if it is ready to deliver a control packet; if so
+    it is expected to deliver it, and this packet is sent instead of a data
     packet waiting in the sender buffer
 
-    * when a new packet in the sender buffer is about to be sent over the network, 
+    * when a new packet in the sender buffer is about to be sent over the network,
     it's first passed to the filter
 
 * Receiving:
 
     * Every packet received from the network is passed to a filter, which can:
 
-        * pass it through 
+        * pass it through
 
         * provide extra packets
 
-The built-in FEC filter doesn't use all capabilities of Packet Filtering, 
+The built-in FEC filter doesn't use all capabilities of Packet Filtering,
 in particular:
 
 * a packet may be altered prior to sending; FEC only reads the data.
 
-* a receiver does allow packet passthrough; it must process each packet and put 
-all results into a provisional buffer(\*). Note that the FEC filter does allow 
-passthrough for regular data packets, but traps all FEC control packets and 
+* a receiver does allow packet passthrough; it must process each packet and put
+all results into a provisional buffer(\*). Note that the FEC filter does allow
+passthrough for regular data packets, but traps all FEC control packets and
 provides rebuilt packets.
 
     (\*)
 *This provisional buffer is the socket's receiver buffer that is passed to the
 packet filter framework to accommodate packets coming out of the packet filter
-(see the *provided* constructor parameter in the __Construction__ section 
+(see the *provided* constructor parameter in the __Construction__ section
 below).*
 
-The sending and receiving mechanism of packet filtering is defined in one class. 
-SRT is generally bidirectional, so both directions must be covered in a single 
+The sending and receiving mechanism of packet filtering is defined in one class.
+SRT is generally bidirectional, so both directions must be covered in a single
 mechanism.
 
-A user-defined packet filter should be a class derived from `SrtPacketFilterBase` 
+A user-defined packet filter should be a class derived from `SrtPacketFilterBase`
 class, and it should override several virtual methods, as specified below.
 
 ## Basic types
 
 The basic packet structures are:
 
-* `CPacket` is an internal SRT class, that is, it gives you access to the exact 
+* `CPacket` is an internal SRT class, that is, it gives you access to the exact
 packet to be used in the operation.
 
-* `SrtPacket` is a special intermediate class, which has a static definition and 
-is used as an intermediate space to be copied to the `CPacket` structure when 
-needed, automatically. This is required for cases when SRT is doing some specific 
-memory management. The packet filter framework cannot reuse the same memory 
-management for keeping the packets in the receiver buffer, or have access to it. 
-Therefore a filter should provide packets using appropriate methods, and SRT 
-internals will take care of copying it to the receiver buffer. This is why the 
-`CPacket` structure cannot be used for that purpose. 
+* `SrtPacket` is a special intermediate class, which has a static definition and
+is used as an intermediate space to be copied to the `CPacket` structure when
+needed, automatically. This is required for cases when SRT is doing some specific
+memory management. The packet filter framework cannot reuse the same memory
+management for keeping the packets in the receiver buffer, or have access to it.
+Therefore a filter should provide packets using appropriate methods, and SRT
+internals will take care of copying it to the receiver buffer. This is why the
+`CPacket` structure cannot be used for that purpose.
 
-Both classes - while characterized by completely independent contents and 
+Both classes - while characterized by completely independent contents and
 methods - implement a common C++ concept consisting of the following methods:
 
 * `char* data();`
@@ -763,16 +764,16 @@ methods - implement a common C++ concept consisting of the following methods:
 
 * `size_t size();`
 
-    * Returns the size of the contents in the buffer. Note that this is not the 
+    * Returns the size of the contents in the buffer. Note that this is not the
     size of the buffer itself.
 
 * `uint32_t header(SrtPktHeaderFields field);`
 
-    * This accesses the header. The field type specifies the field index in the 
-    header. Note that if a function gives you writable access to `CPacket`, you 
-    can modify the payload, but you can't modify the header. With `SrtPacket` you 
-    are free to modify any contents, but to access the header you should use the 
-    `SrtPacket::hdr` field, which is the array to be indexed by values of 
+    * This accesses the header. The field type specifies the field index in the
+    header. Note that if a function gives you writable access to `CPacket`, you
+    can modify the payload, but you can't modify the header. With `SrtPacket` you
+    are free to modify any contents, but to access the header you should use the
+    `SrtPacket::hdr` field, which is the array to be indexed by values of
     `SrtPktHeaderFields` type.
 
 ## Construction
@@ -781,82 +782,82 @@ The constructor of the packet filter class should have the following signature:
 ```
 MyFilter(const SrtFilterInitializer &init, std::vector<SrtPacket>& provided, const string &confstr);
 ```
-Here `MyFilter` is the example filter class derived from `SrtPacketFilterBase`. The 
+Here `MyFilter` is the example filter class derived from `SrtPacketFilterBase`. The
 following parameters are required:
 
 * `init`
 
-    * This should be passed to the constructor of `SrtPacketFilterBase`. It will 
-    provide you with the basic data you will need when creating a packet at the 
+    * This should be passed to the constructor of `SrtPacketFilterBase`. It will
+    provide you with the basic data you will need when creating a packet at the
     receiver.
 
 * `provided`
 
-    * This is the provisional buffer where you have to store packets that your 
-    filter will generate as extra packets (in the case of FEC, this is where the 
+    * This is the provisional buffer where you have to store packets that your
+    filter will generate as extra packets (in the case of FEC, this is where the
     rebuilt packets will be supplied).
 
 * `confstr`
 
-    * This is a configuration string. You should parse it using `ParseFilterConfig` 
-    so that you can use it for your purposes. Note that this configuration string 
-    is still parsed by this function internally in SRT, so the official syntax 
+    * This is a configuration string. You should parse it using `ParseFilterConfig`
+    so that you can use it for your purposes. Note that this configuration string
+    is still parsed by this function internally in SRT, so the official syntax
     must be preserved.
 
-The base class will provide you with important data from the socket through the 
+The base class will provide you with important data from the socket through the
 following methods:
 
 * `socketID()`
 
-    * The socket ID that you should write into the ID header field on the receiver 
+    * The socket ID that you should write into the ID header field on the receiver
 
 * `sndISN()` and `rcvISN()`
 
-    * It returns the very first sequence number in a particular direction (FEC 
-    uses it to initialize the base sequence numbers for FEC groups). 
+    * It returns the very first sequence number in a particular direction (FEC
+    uses it to initialize the base sequence numbers for FEC groups).
 
 * `payloadSize()`
 
-    * The maximum size of a single packet. This determines how large a content 
-    payload should be used for the FEC control packet. The FEC control packet's 
-    payload recovery field must be of the maximum size of any packet, and any 
+    * The maximum size of a single packet. This determines how large a content
+    payload should be used for the FEC control packet. The FEC control packet's
+    payload recovery field must be of the maximum size of any packet, and any
     shorter packets being protected must be padded with zeros up to this size.
 
 The following virtual methods (to be overridden) are not direction related:
 
 * `size_t extraSize()` [REQUIRED]
 
-    * Should return the size of the extra header that your filter will use, in 
-    the count of 32-bit data. The current FEC implementation returns 4 here, 
-    which is the size of the extra header in FEC control packets. Your 
-    implementation may use some extra header in regular packets as well, so 
-    this should be taken into account here. This is required 
-    for checking if the `SRTO_PAYLOADSIZE` socket option is properly set (it 
-    puts an extra limitation on the value for this option beside the overall 
+    * Should return the size of the extra header that your filter will use, in
+    the count of 32-bit data. The current FEC implementation returns 4 here,
+    which is the size of the extra header in FEC control packets. Your
+    implementation may use some extra header in regular packets as well, so
+    this should be taken into account here. This is required
+    for checking if the `SRTO_PAYLOADSIZE` socket option is properly set (it
+    puts an extra limitation on the value for this option beside the overall
     maximum of 1456 bytes).
 
 * `SRT_ARQLevel arqLevel()` [OPTIONAL; default implementation returns the value extracted earlier from the configuration string under the `arq` key]
-    * Should return the ARQ level in the case where you want it to be specified 
-    differently than the default (for example, if you don't want it to be 
+    * Should return the ARQ level in the case where you want it to be specified
+    differently than the default (for example, if you don't want it to be
     configurable in your implementation).
 
 
 
 ## Sending
 
-Sending in SRT is driven by a congestion control mechanism that determines when 
-a socket is ready to send data at the currently defined speed. There is a 
-function called at the precise moment when a socket should provide a packet to 
+Sending in SRT is driven by a congestion control mechanism that determines when
+a socket is ready to send data at the currently defined speed. There is a
+function called at the precise moment when a socket should provide a packet to
 be sent over the UDP link.
 
-There are currently three packet providers. When one provides a packet, the 
-provision is done and the others will have to wait until the next opportunity. 
+There are currently three packet providers. When one provides a packet, the
+provision is done and the others will have to wait until the next opportunity.
 The providers are checked in a specific order:
 
-- **Case #1**: A packet required for retransmission. This is based on the sender 
+- **Case #1**: A packet required for retransmission. This is based on the sender
 loss list, updated from `UMSG_LOSSREPORT` messages.
 
-- **Case #2**: If a Packet Filter is installed, the filter's control packet, if 
+- **Case #2**: If a Packet Filter is installed, the filter's control packet, if
 one is ready.
 
 - **Case #3**: The next waiting data packet.
@@ -865,34 +866,34 @@ For Case #3, this function is called on the filter (if it is installed):
 ```
 void feedSource(CPacket& pkt);
 ```
-This function is called at the moment when a packet (already submitted by the 
-`srt_sendmsg` call) is picked up from the sender buffer and is going to be sent. 
-Note that this packet is bound to a buffer representing the input, and its size 
-is set to the maximum possible (see **NOTE** below). Since this packet is 
-allowed to be altered, data can also be extended up to this size. Note that if 
-such a packet is altered, it will stay in this form in the sender buffer and be 
+This function is called at the moment when a packet (already submitted by the
+`srt_sendmsg` call) is picked up from the sender buffer and is going to be sent.
+Note that this packet is bound to a buffer representing the input, and its size
+is set to the maximum possible (see **NOTE** below). Since this packet is
+allowed to be altered, data can also be extended up to this size. Note that if
+such a packet is altered, it will stay in this form in the sender buffer and be
 retransmitted, if needed.
 
-The current FEC filter implementation uses this function only to collect the 
+The current FEC filter implementation uses this function only to collect the
 contents of the packet to be XORed into an FEC group buffer.
 
 For Case #2, a filter control packet is provided by this function:
 ```
 bool packControlPacket(SrtPacket& packet, int32_t seq);
 ```
-If the function returns *true*, it means that it has supplied the packet. The 
-function should return *false* when there is no such packet ready, in which event 
+If the function returns *true*, it means that it has supplied the packet. The
+function should return *false* when there is no such packet ready, in which event
 Case #3 (new data packet) will be attempted.
 
-**NOTE**: If *true*, the contents of the filter control packet are to be written 
-in a special packet buffer, from which the contents will be copied to the target 
+**NOTE**: If *true*, the contents of the filter control packet are to be written
+in a special packet buffer, from which the contents will be copied to the target
 packet. This buffer is already the maximum possible size of a single packet in SRT.
 
-Special control packets are distinguished from regular data packets by the 
-Message Number (MSGNO) field. For control packets the Message Number is always 0, 
-while regular data packets have Message Numbers from 1 up to a maximum (after 
-which they roll back to 1). For that reason, you are free to store special 
-values in TIMESTAMP and SEQNO fields, but the MSGNO and ID fields must be left 
+Special control packets are distinguished from regular data packets by the
+Message Number (MSGNO) field. For control packets the Message Number is always 0,
+while regular data packets have Message Numbers from 1 up to a maximum (after
+which they roll back to 1). For that reason, you are free to store special
+values in TIMESTAMP and SEQNO fields, but the MSGNO and ID fields must be left
 alone (they will be overwritten anyway).
 
 ## Receiving
@@ -901,33 +902,33 @@ There is just one function for receiving:
 ```
 bool receive(const CPacket& pkt, loss_seqs_t& loss_seqs);
 ```
-This function is called for any data packet received on a socket. It is 
-understood that this is a data packet, the rest is up to the receive() function. 
-
-A packet received here must not be altered. However, you can decide whether a 
-given packet should be passed through, or dismissed, based on the return value. 
-Returning *true* means that the received packet should be passed on to the 
-receiver buffer; otherwise it is discarded. If you have some special contents 
-in a packet that you want removed, simply recreate the packet, then discard the 
+This function is called for any data packet received on a socket. It is
+understood that this is a data packet, the rest is up to the receive() function.
+
+A packet received here must not be altered. However, you can decide whether a
+given packet should be passed through, or dismissed, based on the return value.
+Returning *true* means that the received packet should be passed on to the
+receiver buffer; otherwise it is discarded. If you have some special contents
+in a packet that you want removed, simply recreate the packet, then discard the
 original.
 
-If you want to inject a packet from a filter (such as an FEC-rebuilt packet), 
-you store it in a provisional buffer (the reference to which you received in 
-the constructor). This method can also be used when you want to replace a packet. 
-The order in which packets are stored in this array doesn't matter, because they 
+If you want to inject a packet from a filter (such as an FEC-rebuilt packet),
+you store it in a provisional buffer (the reference to which you received in
+the constructor). This method can also be used when you want to replace a packet.
+The order in which packets are stored in this array doesn't matter, because they
 will be sorted by sequence number order before they are returned to SRT.
 
 Here are some additional considerations related to the `receive()` function:
 
-1. It's up to you to distinguish regular data packets and filter control packets 
-by checking the message number. It is important to use the `CPacket::getMsgSeq` 
-function for that purpose because this extracts the right part of the MSGNO field 
-from the header - `pkt.header` (`SRT_PH_MSGNO`) will return just the field, which 
+1. It's up to you to distinguish regular data packets and filter control packets
+by checking the message number. It is important to use the `CPacket::getMsgSeq`
+function for that purpose because this extracts the right part of the MSGNO field
+from the header - `pkt.header` (`SRT_PH_MSGNO`) will return just the field, which
 contains extra flags.
 
-2. If you use an extra header for every packet, be sure that you can recognize 
+2. If you use an extra header for every packet, be sure that you can recognize
 it correctly as you have created it.
 
-3. When creating (reconstructing) a packet, you have to correctly set the 
-sequence number, the ID field (get the value from `socketID()`), timestamp, and 
+3. When creating (reconstructing) a packet, you have to correctly set the
+sequence number, the ID field (get the value from `socketID()`), timestamp, and
 the encryption flags (other flags are not important, they are set as default).
diff --git a/docs/socket-groups.md b/docs/features/socket-groups.md
similarity index 94%
rename from docs/socket-groups.md
rename to docs/features/socket-groups.md
index 415dc9ff3..cef0ee98e 100644
--- a/docs/socket-groups.md
+++ b/docs/features/socket-groups.md
@@ -1,4 +1,6 @@
-# Abstract
+# SRT Connection Bonding: Socket Groups
+
+## Introduction
 
 The general concept of the socket groups means that a separate entity,
 parallel to a socket, is provided, and the operation done on a group
@@ -9,34 +11,33 @@ The groups types generally split into two categories:
 
 1. Bonding groups.
 
-This group category is meant to utilize multiple connections in order
-to have a group-wise connection. How particular links are then utilized
-to make a group-wise sending, depends on the particular group type. Within
-this category we have the following group types:
+   This group category is meant to utilize multiple connections in order
+   to have a group-wise connection. How particular links are then utilized
+   to make a group-wise sending, depends on the particular group type. Within
+   this category we have the following group types:
 
-   - Broadcast: send the stream over all links simultaneously
-   - Backup: use one link, but be prepared for a quick switch if broken
-   - Balancing: utilize all links, but one payload is sent only over one link
+    - Broadcast: send the stream over all links simultaneously,
+    - Main/Backup: use one link, but be prepared for a quick switch if broken,
+    - Balancing: utilize all links, but one payload is sent only over one link (**UNDER DEVELOPMENT!**).
 
-Bonding category groups predict that a group is mirrored on the peer network
-node, so all particular links connect to the endpoint that always resolves to
-the same target application. Just possibly every link uses a different network
-path.
+   Bonding category groups predict that a group is mirrored on the peer network
+   node, so all particular links connect to the endpoint that always resolves to
+   the same target application. Just possibly every link uses a different network
+   path.
 
 2. Dispatch groups.
 
-This category contains currently only one Multicast type (**CONCEPT!**).
-
-Multicast group has a behavior dependent on the connection side and it is
-predicted to be only used in case when the listener side is a stream sender
-with possibly multiple callers being stream receivers. It utilizes the UDP
-multicast feature in order to send payloads, while the control communication
-is still sent over the unicast link.
+   This category contains currently only one Multicast type (**CONCEPT! NOT IMPLEMENTED!**).
 
-Details for the group types:
+   Multicast group has a behavior dependent on the connection side and it is
+   predicted to be only used in case when the listener side is a stream sender
+   with possibly multiple callers being stream receivers. It utilizes the UDP
+   multicast feature in order to send payloads, while the control communication
+   is still sent over the unicast link.
 
+## Details for the Group Types
 
-## 1. Broadcast
+### 1. Broadcast
 
 This is the simplest bonding group type. The payload sent for a group will be
 then sent over every single link in the group simultaneously. On the reception
@@ -52,8 +53,7 @@ A drawback of this method is that it always utilizes the full capacity of all
 links in the group, whereas only one link at a time delivers any useful data.
 Every next link in this group gives then another 100% overhead.
 
-
-## 2. Backup
+### 2. Main/Backup
 
 This solution is more complicated and more challenging for the settings,
 and in contradiction to Broadcast group, it costs some penalties.
@@ -139,13 +139,12 @@ withstand the initial high burst of packets, while then the bitrate will
 become stable - but still, some extra latency might be needed to compensate
 any quite probable packet loss that may occur during this process.
 
-
-## 3. Balancing
+### 3. Balancing (**UNDER DEVELOPMENT!**)
 
 The idea of balancing means that there are multiple network links used for
 carrying out the same transmission, however a single input signal should
 distribute the incoming packets between the links so that one link can
-leverage the bandwith burden of the other. Note that this group is not
+leverage the bandwidth burden of the other. Note that this group is not
 directly used as protection - it is normally intended to work with a
 condition that a single link out of all links in the group would not be
 able to withstand the bitrate of the signal. In order to utilize a
@@ -185,8 +184,7 @@ the cost of sending by assigning so much of a share of the signal
 bitrte as it is represented by the share of the link in the sum of
 all maximum bandwidth values from every link.
 
-
-## 4. Multicast (NOT IMPLEMENTED - a concept)
+### 4. Multicast (**CONCEPT! NOT IMPLEMENTED!**)
 
 This group - unlike all others - is not intended to send one signal
 between two network nodes over multiple links, but rather a method of
@@ -303,12 +301,11 @@ The listener side will then send payload packets to the IGMP group,
 however all control packets will be still sent the same way as before,
 that is, over a direct connection.
 
-
-# Socket groups in SRT
+## Socket Groups in SRT
 
 The general idea of groups is that there can be multiple sockets belonging
 to a group, and various operations, normally done on single sockets, can
-be simply done on a group. How an operation done on a group is then 
+be simply done on a group. How an operation done on a group is then
 implemented by doing operations on sockets, depends on the group type and
 the operation itself.
 
@@ -322,10 +319,10 @@ For groups you simply use the same operations as for single socket - it will
 be internally dispatched appropriate way, depending on what kind of entity
 was used. For example, when you send a payload, it will be effectively sent:
 
-- For Broadcast group, over all sockets
-- For Backup group, over all currently active links
-- For Balancing group, over a currently selected link
-- For Multicast group, over an extra socket to the multicast group
+- For Broadcast group, over all sockets,
+- For Main/Backup group, over all currently active links,
+- For Balancing group, over a currently selected link,
+- For Multicast group, over an extra socket to the multicast group.
 
 Similarly, the reading operation will read over all links and due to
 synchronized sequence numbers use them to decide the payload order: when
@@ -337,7 +334,7 @@ packet received over another link will be still earlier ready to play.
 
 The difference in reading between groups is that:
 
-- For Broadcast and Backup groups, sequence numbers are synchronized and
+- For Broadcast and Main/Backup groups, sequence numbers are synchronized and
 used to sort packets out
 
 - For Balancing group, message numbers are used to sort packets out
@@ -352,8 +349,7 @@ multicast link must have the target defined as the group ID so that all data in
 the header look exactly the same way depite being intended to be received by
 various different network nodes.
 
-
-# How to prepare connection for bonded links
+## How to Prepare Connection for Bonded Links
 
 In the listener-caller setup, you have to take care of the side separately.
 
@@ -364,7 +360,7 @@ handshake extension information concerning socket groups.
 The listener socket must have `SRTO_GROUPCONNECT` flag set. There are two
 reasons as to why it is required:
 
-1.  This flag **allows** the socket to accept bonded connections. Without this
+1. This flag **allows** the socket to accept bonded connections. Without this
 flag the connection that attempts to be bonded will be rejected.
 
 2. When `srt_accept` function is being called on a listener socket that has
@@ -390,8 +386,7 @@ to you.
 
 On the caller the matter is a little bit more complicated.
 
-
-# Connect bonded
+## Connect Bonded
 
 At first, please remember that the official function to create a socket is now
 `srt_create_socket` and it gets no arguments. All previous functions to create
@@ -472,8 +467,7 @@ procedure is done on the newly created socket for that connection (and that's
 the only way how you can define the outgoing port for a socket that belongs
 to a managed group).
 
-
-# Maintaining link activity
+## Maintaining Link Activity
 
 A link can get broken, and the only thing that the library does about it is
 make you aware of it. The bonding group, as managed, will simply delete the
@@ -515,9 +509,7 @@ result returned by `srt_group_data` - that is, sockets found broken during
 the operation will be only present if you review the array that was filled
 by `srt_sendmsg2` or `srt_recvmsg2`.
 
-
-
-# Writing data to a bonded link
+## Writing Data to a Bonded Link
 
 This is very simple. Call the sending function (recommended is `srt_sendmsg2`)
 to send the data, passing group ID in the place of socket ID. By recognizing
@@ -541,8 +533,7 @@ on particular link - and in this group type packets are distributed
 throughout the link and never go in the order of scheduling on one link.
 Therefore this group uses message numbers for ordering.
 
-
-# Reading data from a bonded link
+## Reading Data from a Bonded Link
 
 This is also simple from the user's perspective. Simply call the reading
 function, such as `srt_recvmsg2`, passing the group ID instead of socket
@@ -554,8 +545,7 @@ group reading facility will take care that you get your payload in the right
 order and at the time to play, and the redundant payloads retrieved over
 different links simultaneously will be discarded.
 
-
-# Checking the status
+## Checking the Status
 
 If you call `srt_sendmsg2` or `srt_recvmsg2`, you'll get the status of every
 socket in the group in a part of the `SRT_MSGCTRL` structure, where you should
@@ -588,7 +578,7 @@ on the socket group type:
 1. Broadcast: the data are being sent over all links anyway, so it doesn't make
 much difference except that the broken socket must be taken care of.
 
-2. Backup: usually when a socket is broken, there has been a disturbance
+2. Main/Backup: usually when a socket is broken, there has been a disturbance
 notified much earlier and therefore another link already active. The bonding
 group is allowed to keep as many active links as required for at least one
 link to remain stable. A broken socket is then simply a possible resolution for
@@ -624,8 +614,7 @@ the state of "idle", and will be deleted before it could be used.
 And finally, a group can be closed. In this case, it internally closes first
 all sockets that are members of this group, then the group itself is deleted.
 
-
-# Application support
+## Application Support
 
 Currently only the `srt-test-live` application is supporting a syntax for
 socket groups.
@@ -697,7 +686,7 @@ set the `groupconnect` option (here let's say you get the source signal
 from a device that streams to this machine to port 5555):
 
 ```
-./srt-test-live udp://:5555 srt://:5000?groupconnect=true
+./srt-test-live udp://:5555 srt://:5000?groupconnect=1
 ```
 
 At the caller side you can also use some group-member specific options.
@@ -723,5 +712,3 @@ when this link is back online.
 The stability timeout can be configured through `groupstabtimeo` option.
 Note that with increased stability timeout, the necessary latency penalty
 grows as well.
-
-
diff --git a/docs/gstreamer.md b/docs/gstreamer.md
deleted file mode 100644
index f02086e5f..000000000
--- a/docs/gstreamer.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Using SRT with GStreamer
-
-Starting from ver. 1.14 GStreamer supports SRT (see the [v.1.14 release notes](https://gstreamer.freedesktop.org/releases/1.14/)).
-See the SRT plugin for GStreamer on [git](https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/tree/master/ext/srt).
-
-
-## Using GStreamer and SRT to set up a screensharing
-
-Based on the description in [#7](https://github.com/Haivision/srt/issues/7). Note that the commands are likely to change slightly for gstreamer 1.16 (see this [issue](https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/874#note_106395)).
-
-If you don't want to build GSteamer, SRT, and all the plugins from source or don't have a distribution that has 1.14 readily available, you can use [`nix`](https://nixos.org/nix/) to reproduce what is shown further.
-
-Simply install `nix`; then use the command bellow to open a shell where the following commands work.
-
-```
-NIX_PATH=nixpkgs=https://github.com/nh2/nixpkgs/archive/a94ff5f6aaa.tar.gz nix-shell -p gst_all_1.gstreamer \
--p gst_all_1.gst-plugins-good -p gst_all_1.gst-plugins-base -p gst_all_1.gst-plugins-bad \
--p gst_all_1.gst-plugins-ugly -p gst_all_1.gst-libav
-```
-
-### Sender server
-
-Set up a sender server that will grab a source raw video from a desktop or a webcam, encode it with x.264 (H.264/AVC) encoder, pack it in `MPEG-TS` ([more info about live streaming](live-streaming.md)). Then pipe it into the SRT sink that sends it over the network to the receiver client. The streaming URI should looks like `uri=srt://<ip>:<port>`. In the examples below the streaming is sent to port 888 on a localhost by specifying `uri=srt://0.0.0.0:8888`.
-
-
-##### For screensharing (Linux with X Display)
-
-The `ximagesrc` GStreamer plugin can be used to capture X Display and create raw RGB video.
-Refer to `ximagesrc` [RM](https://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-plugins-good-plugins-ximagesrc.html) for configuration options.
-
-```
-/usr/bin/time gst-launch-1.0 ximagesrc startx=0 show-pointer=true use-damage=0 ! videoconvert \
-! x264enc bitrate=32000 tune=zerolatency speed-preset=veryfast byte-stream=true threads=1 key-int-max=15 \
-intra-refresh=true ! video/x-h264, profile=baseline, framerate=30/1 ! mpegtsmux \
-! srtserversink uri=srt://0.0.0.0:8888/ latency=100
-```
-
-##### For webcam images
-
-The `v4l2src` GStreamer plugin can be used to capture video from v4l2 devices, like webcams and TV cards. 
-Refer to `v4l2src` [RM](https://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-plugins-good-plugins-v4l2src.html) for further information.
-
-```
-/usr/bin/time gst-launch-1.0 v4l2src ! videoconvert ! x264enc bitrate=8000 tune=zerolatency speed-preset=superfast \
-byte-stream=true threads=1 key-int-max=15 intra-refresh=true ! video/x-h264, profile=baseline ! mpegtsmux \
-! srtserversink uri=srt://0.0.0.0:8888/ latency=100
-```
-
-##### Notes
-
-* The `decodebin` can also be used to configure settings automatically. Using explicit pipeline elements here make it possible to tune the settings when needed.
-* A use of `time` helps to determine when the thread is capped at 100%, while the the `thread=1` parameter makes the encoding use only one thread. Remove `threads=1` to allow multiple cores, or cjange the  `speed-preset` to reduce CPU load.
-* The `timeout` setting can be tuned. A recommended timeout is 2x-2.5x of the expected roundtrip time.
-* The password functionality works as well, but only if a password is `>= 10` characters long; otherwise it's completely ignored. See [this bug](https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/694#note_106616) of GStreamer.
-
-### Receiver client
-
-A client connection over SRT to the server with URI `srt://127.0.0.1:8888` (localhost) or a remote server is set up. URI syntax is `srt://<ip>:<port>`. Then MPEG-TS demuxer and video decoder is used to get a decompressed video, that goes to a playback plugin `autovideosink`.  Note that multiple clients can connect to the server started earlier.
-
-`gst-launch-1.0 srtclientsrc uri=srt://127.0.0.1:8888 ! tsdemux ! h264parse ! video/x-h264 ! avdec_h264 ! autovideosink sync=false`
-
-This works over both the internet and localhost.
diff --git a/docs/images/SRT_History_Good_Signal.png b/docs/misc/images/srt-history-good-signal.png
similarity index 100%
rename from docs/images/SRT_History_Good_Signal.png
rename to docs/misc/images/srt-history-good-signal.png
diff --git a/docs/images/SRT_Transmission_Bad_Signal.png b/docs/misc/images/srt-transmission-bad-signal.png
similarity index 100%
rename from docs/images/SRT_Transmission_Bad_Signal.png
rename to docs/misc/images/srt-transmission-bad-signal.png
diff --git a/docs/why-srt-was-created.md b/docs/misc/why-srt-was-created.md
similarity index 97%
rename from docs/why-srt-was-created.md
rename to docs/misc/why-srt-was-created.md
index 0d3e35e23..cc694e5df 100644
--- a/docs/why-srt-was-created.md
+++ b/docs/misc/why-srt-was-created.md
@@ -15,14 +15,14 @@ Having had a history with UDT for data transmission, I remembered its packet los
 We started testing sending low latency live streams back and forth between Germany and Montreal and it worked! However, we didn't get the latency down to a level we had hoped to achieve. The problem we faced turned out to be timing related (as always in media ...).
 
 What happened was this:
-![Bad Signal](images/SRT_Transmission_Bad_Signal.png)
+![Bad Signal](images/srt-transmission-bad-signal.png)
 
 The characteristics of the original stream on the source network got completely changed by the transmission over the public internet. The reasons are delay, jitter, packet loss and its recovery on the dirty network. The signal on the receiver side had completely different characteristics, which led to problems with decoding, as the audio and video decoders didn't get the packets at the expected times. This can be handled by buffering, but that's not what you want in low latency setups.
 
 The solution was to come up with a mechanism that recreates the signal characteristics on the receiver side. That way we were able to dramatically reduce the buffering. This functionality is part of the SRT protocol itself, so once the data comes out of the SRT protocol on the receiver side, the stream characteristics have been properly recovered.
 
 The result is a happy decoder:
-![Good Signal](images/SRT_History_Good_Signal.png)
+![Good Signal](images/srt-history-good-signal.png)
 
 We publicly showed SRT (Secure Reliable Transport) the first time at IBC 2013, where we were the only ones to show an HEVC encoded live stream, camera to glass, from a hotel suite outside the exhibition directly onto the show floor, using the network provided by the RAI. Everybody who has been at such a show before knows how bad these networks can get. And the network was bad. So bad that we expected the whole demo to fall apart, having pulled the first trial version of SRT directly from the labs. The excitement was huge, when we realized that the transmission still worked fine!
 
diff --git a/examples/example-client-nonblock.c b/examples/example-client-nonblock.c
new file mode 100644
index 000000000..bbaeb0c44
--- /dev/null
+++ b/examples/example-client-nonblock.c
@@ -0,0 +1,165 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; If not, see <http://www.gnu.org/licenses/>
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#define usleep(x) Sleep(x / 1000)
+#else
+#include <unistd.h>
+#endif
+
+#include "srt.h"
+
+int main(int argc, char** argv)
+{
+    int ss, st;
+    struct sockaddr_in sa;
+    const int no = 0;
+    const char message [] = "This message should be sent to the other side";
+
+    if (argc != 3) {
+      fprintf(stderr, "Usage: %s <host> <port>\n", argv[0]);
+      return 1;
+    }
+
+    printf("SRT startup\n");
+    srt_startup();
+
+    printf("Creating SRT socket\n");
+    ss = srt_create_socket();
+    if (ss == SRT_ERROR)
+    {
+        fprintf(stderr, "srt_socket: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    printf("Creating remote address\n");
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(atoi(argv[2]));
+    if (inet_pton(AF_INET, argv[1], &sa.sin_addr) != 1)
+    {
+        return 1;
+    }
+
+    int epollid = srt_epoll_create();
+    if (epollid == -1)
+    {
+        fprintf(stderr, "srt_epoll_create: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    printf("srt setsockflag\n");
+    if (SRT_ERROR == srt_setsockflag(ss, SRTO_RCVSYN, &no, sizeof no)
+        || SRT_ERROR == srt_setsockflag(ss, SRTO_SNDSYN, &no, sizeof no))
+    {
+        fprintf(stderr, "SRTO_SNDSYN or SRTO_RCVSYN: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    // When a caller is connected, a write-readiness event is triggered.
+    int modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
+    if (SRT_ERROR == srt_epoll_add_usock(epollid, ss, &modes))
+    {
+        fprintf(stderr, "srt_epoll_add_usock: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    printf("srt connect\n");
+    st = srt_connect(ss, (struct sockaddr*)&sa, sizeof sa);
+    if (st == SRT_ERROR)
+    {
+        fprintf(stderr, "srt_connect: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    // We had subscribed for write-readiness or error.
+    // Write readiness comes in wready array,
+    // error is notified via rready in this case.
+    int       rlen = 1;
+    SRTSOCKET rready;
+    int       wlen = 1;
+    SRTSOCKET wready;
+    if (srt_epoll_wait(epollid, &rready, &rlen, &wready, &wlen, -1, 0, 0, 0, 0) != -1)
+    {
+        SRT_SOCKSTATUS state = srt_getsockstate(ss);
+        if (state != SRTS_CONNECTED || rlen > 0) // rlen > 0 - an error notification
+        {
+            fprintf(stderr, "srt_epoll_wait: reject reason %s\n", srt_rejectreason_str(srt_getrejectreason(rready)));
+            return 1;
+        }
+
+        if (wlen != 1 || wready != ss)
+        {
+            fprintf(stderr, "srt_epoll_wait: wlen %d, wready %d, socket %d\n", wlen, wready, ss);
+            return 1;
+        }
+    }
+    else
+    {
+        fprintf(stderr, "srt_connect: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    
+    int i;
+    for (i = 0; i < 100; i++)
+    {
+        rready = SRT_INVALID_SOCK;
+        rlen   = 1;
+        wready = SRT_INVALID_SOCK;
+        wlen   = 1;
+
+        // As we have subscribed only for write-readiness or error events,
+        // but have not subscribed for read-readiness,
+        // through readfds we are notified about an error.
+        int timeout_ms = 5000; // ms
+        int res = srt_epoll_wait(epollid, &rready, &rlen, &wready, &wlen, timeout_ms, 0, 0, 0, 0);
+        if (res == SRT_ERROR || rlen > 0)
+        {
+            fprintf(stderr, "srt_epoll_wait: %s\n", srt_getlasterror_str());
+            return 1;
+        }
+
+        printf("srt sendmsg2 #%d >> %s\n", i, message);
+        st = srt_sendmsg2(ss, message, sizeof message, NULL);
+        if (st == SRT_ERROR)
+        {
+            fprintf(stderr, "srt_sendmsg: %s\n", srt_getlasterror_str());
+            return 1;
+        }
+
+        usleep(1000);   // 1 ms
+    }
+
+    // Let's wait a bit so that all packets reach destination
+    usleep(100000);   // 100 ms
+
+    // In live mode the connection will be closed even if some packets were not yet acknowledged.
+    printf("srt close\n");
+    st = srt_close(ss);
+    if (st == SRT_ERROR)
+    {
+        fprintf(stderr, "srt_close: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+
+    printf("srt cleanup\n");
+    srt_cleanup();
+    return 0;
+}
diff --git a/examples/recvfile.cpp b/examples/recvfile.cpp
index f732d131e..7f75cd856 100644
--- a/examples/recvfile.cpp
+++ b/examples/recvfile.cpp
@@ -21,7 +21,7 @@ int main(int argc, char* argv[])
       return -1;
    }
 
-   // use this function to initialize the UDT library
+   // Use this function to initialize the UDT library
    srt_startup();
 
    srt_setloglevel(srt_logging::LogLevel::debug);
@@ -46,7 +46,7 @@ int main(int argc, char* argv[])
       return -1;
    }
 
-   // connect to the server, implicit bind
+   // Connect to the server, implicit bind.
    if (SRT_ERROR == srt_connect(fhandle, peer->ai_addr, peer->ai_addrlen))
    {
       cout << "connect: " << srt_getlasterror_str() << endl;
@@ -55,8 +55,7 @@ int main(int argc, char* argv[])
 
    freeaddrinfo(peer);
 
-
-   // send name information of the requested file
+   // Send name information of the requested file.
    int len = strlen(argv[3]);
 
    if (SRT_ERROR == srt_send(fhandle, (char*)&len, sizeof(int)))
@@ -71,7 +70,7 @@ int main(int argc, char* argv[])
       return -1;
    }
 
-   // get size information
+   // Get size information.
    int64_t size;
 
    if (SRT_ERROR == srt_recv(fhandle, (char*)&size, sizeof(int64_t)))
@@ -86,8 +85,7 @@ int main(int argc, char* argv[])
       return -1;
    }
 
-   // receive the file
-   //fstream ofs(argv[4], ios::out | ios::binary | ios::trunc);
+   // Receive the file.
    int64_t recvsize; 
    int64_t offset = 0;
 
@@ -108,9 +106,7 @@ int main(int argc, char* argv[])
 
    srt_close(fhandle);
 
-   //ofs.close();
-
-   // use this function to release the UDT library
+   // Signal to the SRT library to clean up all allocated sockets and resources.
    srt_cleanup();
 
    return 0;
diff --git a/examples/recvlive.cpp b/examples/recvlive.cpp
index b2a026d03..e14420a66 100644
--- a/examples/recvlive.cpp
+++ b/examples/recvlive.cpp
@@ -53,16 +53,6 @@ int main(int argc, char* argv[])
       return 0;
    }
 
-   // SRT requires that third argument is always SOCK_DGRAM. The Stream API is set by an option,
-   // although there's also lots of other options to be set, for which there's a convenience option,
-   // SRTO_TRANSTYPE.
-   // SRT_TRANSTYPE tt = SRTT_LIVE;
-   // if (SRT_ERROR == srt_setsockopt(sfd, 0, SRTO_TRANSTYPE, &tt, sizeof tt))
-   // {
-   //    cout << "srt_setsockopt: " << srt_getlasterror_str() << endl;
-   //    return 0;
-   // }
-
    bool no = false;
    if (SRT_ERROR == srt_setsockopt(sfd, 0, SRTO_RCVSYN, &no, sizeof no))
    {
@@ -157,7 +147,7 @@ int main(int argc, char* argv[])
                         clientservice, sizeof(clientservice), NI_NUMERICHOST|NI_NUMERICSERV);
             cout << "new connection: " << clienthost << ":" << clientservice << endl;
 
-            int events = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+            events = SRT_EPOLL_IN | SRT_EPOLL_ERR;
             if (SRT_ERROR == srt_epoll_add_usock(epid, fhandle, &events))
             {
                cout << "srt_epoll_add_usock: " << srt_getlasterror_str() << endl;
diff --git a/examples/recvmsg.cpp b/examples/recvmsg.cpp
new file mode 100644
index 000000000..008eb3928
--- /dev/null
+++ b/examples/recvmsg.cpp
@@ -0,0 +1,215 @@
+#ifndef WIN32
+   #include <cstdlib>
+   #include <netdb.h>
+#else
+   #include <winsock2.h>
+   #include <ws2tcpip.h>
+#endif
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cstring>
+#include <cassert>
+
+#include <srt.h>
+#include <netinet_any.h>
+
+using namespace std;
+
+string ShowChar(char in)
+{
+    if (in >= 32 && in < 127)
+        return string(1, in);
+
+    ostringstream os;
+    os << "<" << hex << uppercase << int(in) << ">";
+    return os.str();
+}
+
+string CreateFilename(string fmt, int ord)
+{
+    ostringstream os;
+
+    size_t pos = fmt.find('%');
+    if (pos == string::npos)
+        os << fmt << ord << ".out";
+    else
+    {
+        os << fmt.substr(0, pos) << ord << fmt.substr(pos+1);
+    }
+    return os.str();
+}
+
+int main(int argc, char* argv[])
+{
+   string service("9000");
+   if (argc > 1)
+      service = argv[1];
+
+   if (service == "--help")
+   {
+      cout << "usage: recvmsg [server_port] [filepattern]" << endl;
+      return 0;
+   }
+
+   addrinfo hints;
+   addrinfo* res;
+
+   memset(&hints, 0, sizeof(struct addrinfo));
+   hints.ai_flags = AI_PASSIVE;
+   hints.ai_family = AF_INET;
+   hints.ai_socktype = SOCK_DGRAM;
+
+   if (0 != getaddrinfo(NULL, service.c_str(), &hints, &res))
+   {
+      cout << "illegal port number or port is busy.\n" << endl;
+      return 1;
+   }
+
+   string outfileform;
+   if (argc > 2)
+   {
+       outfileform = argv[2];
+   }
+
+   // use this function to initialize the UDT library
+   srt_startup();
+
+   srt_setloglevel(srt_logging::LogLevel::debug);
+
+   SRTSOCKET sfd = srt_create_socket();
+   if (SRT_INVALID_SOCK == sfd)
+   {
+      cout << "srt_socket: " << srt_getlasterror_str() << endl;
+      return 1;
+   }
+
+   int file_mode = SRTT_FILE;
+   if (SRT_ERROR == srt_setsockflag(sfd, SRTO_TRANSTYPE, &file_mode, sizeof file_mode))
+   {
+      cout << "srt_setsockopt: " << srt_getlasterror_str() << endl;
+      return 1;
+   }
+
+   bool message_mode = true;
+   if (SRT_ERROR == srt_setsockflag(sfd, SRTO_MESSAGEAPI, &message_mode, sizeof message_mode))
+   {
+      cout << "srt_setsockopt: " << srt_getlasterror_str() << endl;
+      return 1;
+   }
+
+   if (SRT_ERROR == srt_bind(sfd, res->ai_addr, res->ai_addrlen))
+   {
+      cout << "srt_bind: " << srt_getlasterror_str() << endl;
+      return 0;
+   }
+
+   freeaddrinfo(res);
+
+   cout << "server is ready at port: " << service << endl;
+
+   if (SRT_ERROR == srt_listen(sfd, 10))
+   {
+      cout << "srt_listen: " << srt_getlasterror_str() << endl;
+      return 1;
+   }
+
+   char data[4096];
+
+   srt::sockaddr_any remote;
+
+   int afd = srt_accept(sfd, remote.get(), &remote.len);
+
+   if (afd == SRT_INVALID_SOCK)
+   {
+       cout << "srt_accept: " << srt_getlasterror_str() << endl;
+       return 1;
+   }
+
+   cout << "Connection from " << remote.str() << " established\n";
+
+   bool save_to_files = true;
+
+   if (outfileform != "")
+       save_to_files = true;
+
+    int ordinal = 1;
+
+   // the event loop
+   while (true)
+   {
+       SRT_SOCKSTATUS status = srt_getsockstate(afd);
+       if ((status == SRTS_BROKEN) ||
+               (status == SRTS_NONEXIST) ||
+               (status == SRTS_CLOSED))
+       {
+           cout << "source disconnected. status=" << status << endl;
+           srt_close(afd);
+           break;
+       }
+
+       int ret = srt_recvmsg(afd, data, sizeof(data));
+       if (ret == SRT_ERROR)
+       {
+           cout << "srt_recvmsg: " << srt_getlasterror_str() << endl;
+           break;
+       }
+       if (ret == 0)
+       {
+           cout << "EOT\n";
+           break;
+       }
+
+       if (ret < 5)
+       {
+           cout << "WRONG MESSAGE SYNTAX\n";
+           break;
+       }
+
+       if (save_to_files)
+       {
+           string fname = CreateFilename(outfileform, ordinal++);
+           ofstream ofile(fname);
+
+           if (!ofile.good())
+           {
+               cout << "ERROR: can't create file: " << fname << " - skipping message\n";
+               continue;
+           }
+
+           ofile.write(data, ret);
+           ofile.close();
+           cout << "Written " << ret << " bytes of message to " << fname << endl;
+       }
+       else
+       {
+           union
+           {
+               char chars[4];
+               int32_t intval;
+           } first4;
+
+           copy(data, data + 4, first4.chars);
+
+           cout << "[" << ret << "B " << ntohl(first4.intval) << "] ";
+           for (int i = 4; i < ret; ++i)
+               cout << ShowChar(data[i]);
+           cout << endl;
+       }
+   }
+
+   srt_close(afd);
+   srt_close(sfd);
+
+   // use this function to release the UDT library
+   srt_cleanup();
+
+   return 0;
+}
+
+// Local Variables:
+// c-file-style: "ellemtel"
+// c-basic-offset: 3
+// compile-command: "g++ -Wall -O2 -std=c++11 -I.. -I../srtcore -o recvlive recvlive.cpp -L.. -lsrt -lpthread -L/usr/local/opt/openssl/lib -lssl -lcrypto"
+// End:
diff --git a/examples/sendfile.cpp b/examples/sendfile.cpp
index e9b871255..ddaa06407 100644
--- a/examples/sendfile.cpp
+++ b/examples/sendfile.cpp
@@ -21,18 +21,15 @@ DWORD WINAPI sendfile(LPVOID);
 
 int main(int argc, char* argv[])
 {
-   //usage: sendfile [server_port]
    if ((2 < argc) || ((2 == argc) && (0 == atoi(argv[1]))))
    {
       cout << "usage: sendfile [server_port]" << endl;
       return 0;
    }
 
-   // use this function to initialize the UDT library
+   // Initialize the SRT library.
    srt_startup();
 
-   srt_setloglevel(srt_logging::LogLevel::debug);
-
    addrinfo hints;
    addrinfo* res;
 
@@ -66,9 +63,6 @@ int main(int argc, char* argv[])
    srt_setsockopt(serv, 0, SRTO_MSS, &mss, sizeof(int));
 #endif
 
-   //int64_t maxbw = 5000000;
-   //srt_setsockopt(serv, 0, SRTO_MAXBW, &maxbw, sizeof maxbw);
-
    if (SRT_ERROR == srt_bind(serv, res->ai_addr, res->ai_addrlen))
    {
       cout << "bind: " << srt_getlasterror_str() << endl;
@@ -78,7 +72,6 @@ int main(int argc, char* argv[])
    freeaddrinfo(res);
 
    cout << "server is ready at port: " << service << endl;
-
    srt_listen(serv, 10);
 
    sockaddr_storage clientaddr;
@@ -86,6 +79,7 @@ int main(int argc, char* argv[])
 
    SRTSOCKET fhandle;
 
+   // Accept multiple client connections.
    while (true)
    {
       if (SRT_INVALID_SOCK == (fhandle = srt_accept(serv, (sockaddr*)&clientaddr, &addrlen)))
@@ -99,18 +93,18 @@ int main(int argc, char* argv[])
       getnameinfo((sockaddr *)&clientaddr, addrlen, clienthost, sizeof(clienthost), clientservice, sizeof(clientservice), NI_NUMERICHOST|NI_NUMERICSERV);
       cout << "new connection: " << clienthost << ":" << clientservice << endl;
 
-      #ifndef _WIN32
-         pthread_t filethread;
-         pthread_create(&filethread, NULL, sendfile, new SRTSOCKET(fhandle));
-         pthread_detach(filethread);
-      #else
-         CreateThread(NULL, 0, sendfile, new SRTSOCKET(fhandle), 0, NULL);
-      #endif
+#ifndef _WIN32
+      pthread_t filethread;
+      pthread_create(&filethread, NULL, sendfile, new SRTSOCKET(fhandle));
+      pthread_detach(filethread);
+#else
+      CreateThread(NULL, 0, sendfile, new SRTSOCKET(fhandle), 0, NULL);
+#endif
    }
 
    srt_close(serv);
 
-   // use this function to release the UDT library
+   // Signal to the SRT library to clean up all allocated sockets and resources.
    srt_cleanup();
 
    return 0;
@@ -125,7 +119,7 @@ DWORD WINAPI sendfile(LPVOID usocket)
    SRTSOCKET fhandle = *(SRTSOCKET*)usocket;
    delete (SRTSOCKET*)usocket;
 
-   // aquiring file name information from client
+   // Acquiring file name information from client.
    char file[1024];
    int len;
 
@@ -142,15 +136,13 @@ DWORD WINAPI sendfile(LPVOID usocket)
    }
    file[len] = '\0';
 
-   // open the file (only to check the size)
+   // Open the file only to know its size.
    fstream ifs(file, ios::in | ios::binary);
-
    ifs.seekg(0, ios::end);
-   int64_t size = ifs.tellg();
-   //ifs.seekg(0, ios::beg);
+   const int64_t size = ifs.tellg();
    ifs.close();
 
-   // send file size information
+   // Send file size.
    if (SRT_ERROR == srt_send(fhandle, (char*)&size, sizeof(int64_t)))
    {
       cout << "send: " << srt_getlasterror_str() << endl;
@@ -160,7 +152,7 @@ DWORD WINAPI sendfile(LPVOID usocket)
    SRT_TRACEBSTATS trace;
    srt_bstats(fhandle, &trace, true);
 
-   // send the file
+   // Send the file itself.
    int64_t offset = 0;
    if (SRT_ERROR == srt_sendfile(fhandle, file, &offset, size, SRT_DEFAULT_SENDFILE_BLOCK))
    {
@@ -170,13 +162,11 @@ DWORD WINAPI sendfile(LPVOID usocket)
 
    srt_bstats(fhandle, &trace, true);
    cout << "speed = " << trace.mbpsSendRate << "Mbits/sec" << endl;
-   int losspercent = 100*trace.pktSndLossTotal/trace.pktSent;
-   cout << "loss = " << trace.pktSndLossTotal << "pkt (" << losspercent << "%)\n";
+   const int64_t losspercent = 100 * trace.pktSndLossTotal / trace.pktSent;
+   cout << "network loss = " << trace.pktSndLossTotal << "pkts (" << losspercent << "%)\n";
 
    srt_close(fhandle);
 
-   //ifs.close();
-
    #ifndef _WIN32
       return NULL;
    #else
diff --git a/examples/sendmsg.cpp b/examples/sendmsg.cpp
new file mode 100644
index 000000000..af551849b
--- /dev/null
+++ b/examples/sendmsg.cpp
@@ -0,0 +1,210 @@
+#ifndef _WIN32
+   #include <arpa/inet.h>
+   #include <netdb.h>
+#else
+   #include <winsock2.h>
+   #include <ws2tcpip.h>
+#endif
+#include <fstream>
+#include <iostream>
+#include <cstdlib>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <iterator>
+#include <algorithm>
+#include <srt.h>
+
+using namespace std;
+
+string ShowChar(char in)
+{
+    if (in >= 32 && in < 127)
+        return string(1, in);
+
+    ostringstream os;
+    os << "<" << hex << uppercase << int(in) << ">";
+    return os.str();
+}
+
+int main(int argc, char* argv[])
+{
+   if ((argc != 4) || (0 == atoi(argv[2])))
+   {
+      cout << "usage: sendmsg server_ip server_port source_filename" << endl;
+      return -1;
+   }
+
+   // Use this function to initialize the UDT library
+   srt_startup();
+
+   srt_setloglevel(srt_logging::LogLevel::debug);
+
+   struct addrinfo hints, *peer;
+
+   memset(&hints, 0, sizeof(struct addrinfo));
+   hints.ai_flags = AI_PASSIVE;
+   hints.ai_family = AF_INET;
+   hints.ai_socktype = SOCK_DGRAM;
+
+   SRTSOCKET fhandle = srt_create_socket();
+   // SRT requires that third argument is always SOCK_DGRAM. The Stream API is set by an option,
+   // although there's also lots of other options to be set, for which there's a convenience option,
+   // SRTO_TRANSTYPE.
+   SRT_TRANSTYPE tt = SRTT_FILE;
+   srt_setsockopt(fhandle, 0, SRTO_TRANSTYPE, &tt, sizeof tt);
+
+   bool message_mode = true;
+   srt_setsockopt(fhandle, 0, SRTO_MESSAGEAPI, &message_mode, sizeof message_mode);
+
+   if (0 != getaddrinfo(argv[1], argv[2], &hints, &peer))
+   {
+      cout << "incorrect server/peer address. " << argv[1] << ":" << argv[2] << endl;
+      return -1;
+   }
+
+   // Connect to the server, implicit bind.
+   if (SRT_ERROR == srt_connect(fhandle, peer->ai_addr, peer->ai_addrlen))
+   {
+       int rej = srt_getrejectreason(fhandle);
+       cout << "connect: " << srt_getlasterror_str() << ":" << srt_rejectreason_str(rej) << endl;
+       return -1;
+   }
+
+   freeaddrinfo(peer);
+
+   string source_fname = argv[3];
+
+   bool use_filelist = false;
+   if (source_fname[0] == '+')
+   {
+       use_filelist = true;
+       source_fname = source_fname.substr(1);
+   }
+
+   istream* pin;
+   ifstream fin;
+   if (source_fname == "-")
+   {
+       pin = &cin;
+   }
+   else
+   {
+       fin.open(source_fname.c_str());
+       pin = &fin;
+   }
+
+   // The syntax is:
+   //
+   // 1. If the first character is +, it's followed by TTL in milliseconds.
+   // 2. Otherwise the first number is the ID, followed by a space, to be filled in first 4 bytes.
+   // 3. Rest of the characters, up to the end of line, should be put into a solid block and sent at once.
+
+   int status = 0;
+
+   int ordinal = 1;
+   int lpos = 0;
+
+   for (;;)
+   {
+       string line;
+       int32_t id = 0;
+       int ttl = -1;
+
+       getline(*pin, (line));
+       if (pin->eof())
+           break;
+
+       // Interpret
+       if (line.size() < 2)
+           continue;
+
+       if (use_filelist)
+       {
+           // The line should contain [+TTL] FILENAME
+           char fname[1024] = "";
+           if (line[0] == '+')
+           {
+               int nparsed = sscanf(line.c_str(), "+%d %n%1000s", &ttl, &lpos, fname);
+               if (nparsed != 2)
+               {
+                   cout << "ERROR: syntax error in input (" << nparsed << " parsed pos=" << lpos << ")\n";
+                   status = SRT_ERROR;
+                   break;
+               }
+               line = fname;
+           }
+
+           ifstream ifile (line);
+
+           id = ordinal;
+           ++ordinal;
+
+           if (!ifile.good())
+           {
+               cout << "ERROR: file '" << line << "' cannot be read, skipping\n";
+               continue;
+           }
+
+           line = string(istreambuf_iterator<char>(ifile), istreambuf_iterator<char>());
+       }
+       else
+       {
+           int lpos2 = 0;
+
+           int nparsed = 0;
+           if (line[0] == '+')
+           {
+               nparsed = sscanf(line.c_str(), "+%d %d %n%*s", &ttl, &id, &lpos2);
+               if (nparsed != 2)
+               {
+                   cout << "ERROR: syntax error in input (" << nparsed << " parsed pos=" << lpos2 << ")\n";
+                   status = SRT_ERROR;
+                   break;
+               }
+           }
+           else
+           {
+               nparsed = sscanf(line.c_str(), "%d %n%*s", &id, &lpos2);
+               if (nparsed != 1)
+               {
+                   cout << "ERROR: syntax error in input (" << nparsed << " parsed pos=" << lpos2 << ")\n";
+                   status = SRT_ERROR;
+                   break;
+               }
+           }
+       }
+
+       union
+       {
+           char chars[4];
+           int32_t intval;
+       } first4;
+       first4.intval = htonl(id);
+
+       vector<char> input;
+       copy(first4.chars, first4.chars+4, back_inserter(input));
+       copy(line.begin() + lpos, line.end(), back_inserter(input));
+
+       // CHECK CODE
+       // cout << "WILL SEND: TTL=" << ttl << " ";
+       // transform(input.begin(), input.end(),
+       //         ostream_iterator<string>(cout), ShowChar);
+       // cout << endl;
+
+       int nsnd = srt_sendmsg(fhandle, &input[0], input.size(), ttl, false);
+       if (nsnd == SRT_ERROR)
+       {
+           cout << "SRT ERROR: " << srt_getlasterror_str() << endl;
+               status = SRT_ERROR;
+           break;
+       }
+   }
+
+   srt_close(fhandle);
+
+   // Signal to the SRT library to clean up all allocated sockets and resources.
+   srt_cleanup();
+
+   return status;
+}
diff --git a/examples/test-c-client-bonding.c b/examples/test-c-client-bonding.c
index f35c01cee..e9cfb72f0 100644
--- a/examples/test-c-client-bonding.c
+++ b/examples/test-c-client-bonding.c
@@ -40,6 +40,43 @@ struct
 
 #define SIZE(array) (sizeof array/sizeof(array[0]))
 
+// Note that in this example application there's a socket
+// used first to connect to the service and then it will be
+// used for writing. Therefore the same function will be used
+// for waiting for the socket to be connected and then to wait
+// for write-ready on the socket used for transmission. For a
+// model of waiting for read-ready see test-c-server-bonding.c file.
+int WaitForWriteReady(int eid, SRTSOCKET ss)
+{
+    int ready_err[2];
+    int ready_err_len = 2;
+    int ready_out[2];
+    int ready_out_len = 2;
+
+    int st = srt_epoll_wait(eid, ready_err, &ready_err_len, ready_out, &ready_out_len, -1,
+            0, 0, 0, 0);
+
+    // Note: with indefinite wait time we can either have a connection reported
+    // or possibly error. Also srt_epoll_wait never returns 0 - at least the number
+    // of ready connections is reported or -1 is returned for error, including timeout.
+    if (st < 1)
+    {
+        fprintf(stderr, "srt_epoll_wait: %s\n", srt_getlasterror_str());
+        return 0;
+    }
+
+    // Check if this was reported as error-ready, in which case it doesn't
+    // matter if read-ready.
+    if (ready_err[0] == ss)
+    {
+        int reason = srt_getrejectreason(ss);
+        fprintf(stderr, "srt_epoll_wait: socket @%d reported error reason=%d: %s\n", ss, reason, srt_rejectreason_str(reason));
+        return 0;
+    }
+
+    return 1;
+}
+
 int main(int argc, char** argv)
 {
     int ss, st;
@@ -62,18 +99,34 @@ int main(int argc, char** argv)
             break;
         }
 
-    printf("srt startup\n");
-    srt_startup();
-
+    int is_nonblocking = 0;
     size_t nmemb = argc - 2;
-    if (nmemb % 2)
+    if (nmemb < 2)
     {
-        fprintf(stderr, "Usage error: after <type>, <host> <port> pairs are expected.\n");
+        fprintf(stderr, "Usage error: no members specified\n");
         return 1;
     }
 
+    if (nmemb % 2)
+    {
+        // Last argument is then optionset
+        --nmemb;
+        const char* opt = argv[argc-1];
+        if (strchr(opt, 'n'))
+            is_nonblocking = 1;
+    }
+
     nmemb /= 2;
 
+    printf("srt startup\n");
+    srt_startup();
+
+    // Declare all variables before any destructive goto.
+    // In C++ such a code that jumps over initialization would be illegal,
+    // in C it causes an uninitialized value to be used.
+    int eid = -1;
+    int write_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
+    SRT_SOCKGROUPDATA* grpdata = NULL;
     SRT_SOCKGROUPCONFIG* grpconfig = calloc(nmemb, sizeof (SRT_SOCKGROUPCONFIG));
 
     printf("srt group\n");
@@ -81,7 +134,7 @@ int main(int argc, char** argv)
     if (ss == SRT_ERROR)
     {
         fprintf(stderr, "srt_create_group: %s\n", srt_getlasterror_str());
-        return 1;
+        goto end;
     }
 
     const int B = 2;
@@ -94,12 +147,21 @@ int main(int argc, char** argv)
         sa.sin_port = htons(atoi(argv[B + 2*i + 1]));
         if (inet_pton(AF_INET, argv[B + 2*i], &sa.sin_addr) != 1)
         {
-            return 1;
+            fprintf(stderr, "inet_pton: can't resolve address: %s\n", argv[B + 2*i]);
+            goto end;
         }
 
         grpconfig[i] = srt_prepare_endpoint(NULL, (struct sockaddr*)&sa, sizeof sa);
     }
 
+    if (is_nonblocking)
+    {
+        int blockingmode = 0;
+        srt_setsockflag(ss, SRTO_RCVSYN, &blockingmode, sizeof (blockingmode));
+        eid = srt_epoll_create();
+        srt_epoll_add_usock(eid, ss, &write_modes);
+    }
+
     printf("srt connect (group)\n");
 
     // Note: this function unblocks at the moment when at least one connection
@@ -109,7 +171,28 @@ int main(int argc, char** argv)
     if (st == SRT_ERROR)
     {
         fprintf(stderr, "srt_connect: %s\n", srt_getlasterror_str());
-        return 1;
+        goto end;
+    }
+
+    // In non-blocking mode the srt_connect function returns immediately
+    // and displays only errors of the initial usage, not runtime errors.
+    // These could be reported by epoll.
+    if (is_nonblocking)
+    {
+        // WRITE-ready means connected
+
+        printf("srt wait for socket reporting connection success\n");
+        if (!WaitForWriteReady(eid, ss))
+            goto end;
+    }
+
+    // In non-blocking mode now is the time to possibly change the epoll.
+    // As this socket will be used for writing, it is in the right mode already.
+    // Just set the right flag, as for non-blocking connect it needs RCVSYN.
+    if (is_nonblocking)
+    {
+        int blockingmode = 0;
+        srt_setsockflag(ss, SRTO_SNDSYN, &blockingmode, sizeof (blockingmode));
     }
 
     // Important: Normally you need that at least one link is ready for
@@ -123,7 +206,7 @@ int main(int argc, char** argv)
     printf("sleeping 1s to make it probable all links are established\n");
     sleep(1);
 
-    SRT_SOCKGROUPDATA* grpdata = calloc(nmemb, sizeof (SRT_SOCKGROUPDATA));
+    grpdata = calloc(nmemb, sizeof (SRT_SOCKGROUPDATA));
 
     for (i = 0; i < 100; i++)
     {
@@ -133,11 +216,18 @@ int main(int argc, char** argv)
         mc.grpdata = grpdata;
         mc.grpdata_size = nmemb; // Set maximum known
 
+        if (is_nonblocking)
+        {
+            // Block in epoll as srt_recvmsg2 will not block.
+            if (!WaitForWriteReady(eid, ss))
+                goto end;
+        }
+
         st = srt_sendmsg2(ss, message, sizeof message, &mc);
         if (st == SRT_ERROR)
         {
             fprintf(stderr, "srt_sendmsg: %s\n", srt_getlasterror_str());
-            return 1;
+            goto end;
         }
 
         // Perform the group check. This can be used to recognize broken connections
@@ -162,7 +252,11 @@ int main(int argc, char** argv)
         usleep(1000);   // 1 ms
     }
 
-
+end:
+    if (eid != -1)
+    {
+        srt_epoll_release(eid);
+    }
     printf("srt close\n");
     st = srt_close(ss);
     if (st == SRT_ERROR)
@@ -174,6 +268,7 @@ int main(int argc, char** argv)
     free(grpdata);
     free(grpconfig);
 
+//cleanup:
     printf("srt cleanup\n");
     srt_cleanup();
     return 0;
diff --git a/examples/test-c-client.c b/examples/test-c-client.c
index 5134585ef..71f6d30e4 100644
--- a/examples/test-c-client.c
+++ b/examples/test-c-client.c
@@ -59,7 +59,11 @@ int main(int argc, char** argv)
     }
 
     printf("srt setsockflag\n");
-    srt_setsockflag(ss, SRTO_SENDER, &yes, sizeof yes);
+    if (SRT_ERROR == srt_setsockflag(ss, SRTO_SENDER, &yes, sizeof yes))
+    {
+        fprintf(stderr, "srt_setsockflag: %s\n", srt_getlasterror_str());
+        return 1;
+    }
 
     // Test deprecated
     //srt_setsockflag(ss, SRTO_STRICTENC, &yes, sizeof yes);
@@ -87,6 +91,7 @@ int main(int argc, char** argv)
     }
 
 
+    sleep(1); // 1 second to give it enough time to receive all messages
     printf("srt close\n");
     st = srt_close(ss);
     if (st == SRT_ERROR)
diff --git a/examples/test-c-server-bonding.c b/examples/test-c-server-bonding.c
index 60748df12..76d05f50e 100644
--- a/examples/test-c-server-bonding.c
+++ b/examples/test-c-server-bonding.c
@@ -22,6 +22,49 @@
 
 #include "srt.h"
 
+// Note that in this example application there's a listening
+// socket, off which then a transmission socket is accepted,
+// then this socket will be used for reading. Therefore the same
+// function will be used for waiting for the listener to get the
+// accepted socket ready and then to wait for read-readiness on
+// the transmission socket. For a model of waiting for write-ready
+// see test-c-client-bonding.c file.
+int WaitForReadReady(int eid, SRTSOCKET ss)
+{
+    int ready_in[2];
+    int ready_in_len = 2;
+    int ready_err[2];
+    int ready_err_len = 2;
+
+    int st = srt_epoll_wait(eid, ready_in, &ready_in_len, ready_err, &ready_err_len, -1,
+            0, 0, 0, 0);
+
+    // Note: with indefinite wait time we can either have a connection reported
+    // or possibly error. Also srt_epoll_wait never returns 0 - at least the number
+    // of ready connections is reported or -1 is returned for error, including timeout.
+    if (st < 1)
+    {
+        fprintf(stderr, "srt_epoll_wait: %s\n", srt_getlasterror_str());
+        return 0;
+    }
+
+    // Check if this was reported as error-ready, in which case it doesn't
+    // matter if read-ready.
+    if (ready_err[0] == ss)
+    {
+        fprintf(stderr, "srt_epoll_wait: socket @%d reported error\n", ss);
+        return 0;
+    }
+
+    if (ready_in[0] != ss)
+    {
+        fprintf(stderr, "srt_epoll_wait: socket @%d not reported ready\n", ss);
+        return 0;
+    }
+
+    return 1;
+}
+
 int main(int argc, char** argv)
 {
     int globstatus = 0;
@@ -32,9 +75,10 @@ int main(int argc, char** argv)
     struct sockaddr_storage their_addr;
     SRT_SOCKGROUPDATA* grpdata = NULL;
 
-    if (argc != 3) {
-      fprintf(stderr, "Usage: %s <host> <port>\n", argv[0]);
-      return 1;
+    if (argc < 3 || argc > 4)
+    {
+        fprintf(stderr, "Usage: %s <host> <port> [options]\n", argv[0]);
+        return 1;
     }
 
     printf("srt startup\n");
@@ -51,6 +95,19 @@ int main(int argc, char** argv)
     }
     // Now that the socket is created, jump to 'end' on error.
 
+    // Check options
+    int is_nonblocking = 0;
+    SRTSOCKET their_fd = SRT_INVALID_SOCK; // declared early because of gotos
+    int eid = -1;
+    int lsn_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+    int read_modes = lsn_modes;
+    if (argc > 3)
+    {
+        const char* opt = argv[3];
+        if (strchr(opt, 'n'))
+            is_nonblocking = 1;
+    }
+
     printf("srt bind address\n");
     if (0 == strcmp(argv[1], "0"))
     {
@@ -77,6 +134,14 @@ int main(int argc, char** argv)
         goto end;
     }
 
+    if (is_nonblocking)
+    {
+        int blockingmode = 0;
+        srt_setsockflag(ss, SRTO_RCVSYN, &blockingmode, sizeof (blockingmode));
+        eid = srt_epoll_create();
+        srt_epoll_add_usock(eid, ss, &lsn_modes);
+    }
+
     printf("srt listen\n");
 
     // We set here 10, just for a case. Every unit in this number
@@ -91,6 +156,7 @@ int main(int argc, char** argv)
         goto end;
     }
 
+
     // In this example, there will be prepared an array of 10 items.
     // The listener, however, doesn't know how many member connections
     // one bonded connection will contain, so a real application should be
@@ -98,15 +164,50 @@ int main(int argc, char** argv)
     const size_t N = 10;
     grpdata = calloc(N, sizeof (SRT_SOCKGROUPDATA));
 
+    // In non-blocking mode you can't call srt_accept immediately.
+    // You must first wait for readiness on the listener socket.
+    if (is_nonblocking)
+    {
+        printf("srt wait for listener socket reporting in a new connection\n");
+        if (!WaitForReadReady(eid, ss))
+            goto end;
+    }
+
     printf("srt accept\n");
     int addr_size = sizeof their_addr;
-    SRTSOCKET their_fd = srt_accept(ss, (struct sockaddr *)&their_addr, &addr_size);
+    their_fd = srt_accept(ss, (struct sockaddr *)&their_addr, &addr_size);
+
+    if (their_fd == -1)
+    {
+        fprintf(stderr, "srt_accept: %s\n", srt_getlasterror_str());
+        goto end;
+    }
+
+    printf("accepted socket: @%d\n", their_fd);
 
     // You never know if `srt_accept` is going to give you a socket or a group.
     // You have to check it on your own. The SRTO_GROUPCONNECT flag doesn't disallow
     // single socket connections.
     int isgroup = their_fd & SRTGROUP_MASK;
 
+    if (!isgroup)
+    {
+        fprintf(stderr, "srt_accept: Accepted @%d is not a group???\n", their_fd);
+        goto end;
+    }
+
+    if (is_nonblocking)
+    {
+        // NOTE: The SRTO_RCVSYN = false flag will be derived from
+        // the listener socket and we are going to read, so it matches
+        // the need. In case when you'd like to write to the accepted
+        // socket, you'd have to set also SRTO_SNDSYN = false.
+        srt_epoll_add_usock(eid, their_fd, &read_modes);
+
+        // The listener socket is no longer important.
+        srt_epoll_remove_usock(eid, ss);
+    }
+
     // Still, use the same procedure for receiving, no matter if
     // this is a bonded or single connection.
     int i;
@@ -117,6 +218,14 @@ int main(int argc, char** argv)
         SRT_MSGCTRL mc = srt_msgctrl_default;
         mc.grpdata = grpdata;
         mc.grpdata_size = N;
+
+        if (is_nonblocking)
+        {
+            // Block in epoll as srt_recvmsg2 will not block.
+            if (!WaitForReadReady(eid, their_fd))
+                goto end;
+        }
+
         st = srt_recvmsg2(their_fd, msg, sizeof msg, &mc);
         if (st == SRT_ERROR)
         {
@@ -146,8 +255,18 @@ int main(int argc, char** argv)
     }
 
 end:
+    if (eid != -1)
+    {
+        srt_epoll_release(eid);
+    }
     free(grpdata);
     printf("srt close\n");
+    st = srt_close(their_fd); // just for a case; broken socket should be wiped out anyway
+    if (st == SRT_ERROR)
+    {
+        fprintf(stderr, "srt_close: %s\n", srt_getlasterror_str());
+        // But not matter, we're finishing here.
+    }
     st = srt_close(ss);
     if (st == SRT_ERROR)
     {
diff --git a/examples/test-c-server.c b/examples/test-c-server.c
index d1480b0b1..f7faf6fba 100644
--- a/examples/test-c-server.c
+++ b/examples/test-c-server.c
@@ -54,7 +54,11 @@ int main(int argc, char** argv)
     }
 
     printf("srt setsockflag\n");
-    srt_setsockflag(ss, SRTO_RCVSYN, &yes, sizeof yes);
+    if (SRT_ERROR == srt_setsockflag(ss, SRTO_RCVSYN, &yes, sizeof yes))
+    {
+        fprintf(stderr, "srt_setsockflag: %s\n", srt_getlasterror_str());
+        return 1;
+    }
 
     printf("srt bind\n");
     st = srt_bind(ss, (struct sockaddr*)&sa, sizeof sa);
@@ -75,6 +79,11 @@ int main(int argc, char** argv)
     printf("srt accept\n");
     int addr_size = sizeof their_addr;
     int their_fd = srt_accept(ss, (struct sockaddr *)&their_addr, &addr_size);
+    if (their_fd == SRT_INVALID_SOCK)
+    {
+        fprintf(stderr, "srt_accept: %s\n", srt_getlasterror_str());
+        return 1;
+    }
 
     int i;
     for (i = 0; i < 100; i++)
diff --git a/haicrypt/cryspr-botan.c b/haicrypt/cryspr-botan.c
new file mode 100644
index 000000000..341811e82
--- /dev/null
+++ b/haicrypt/cryspr-botan.c
@@ -0,0 +1,380 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2019 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+
+   2023-03-28 (oviano)
+        Botan CRYSPR/4SRT (CRYypto Service PRovider for SRT)
+*****************************************************************************/
+
+#include "hcrypt.h"
+
+#include <string.h>
+
+typedef struct tag_crysprBotanTLS_AES_cb {
+    CRYSPR_cb       ccb;            /* CRYSPR control block */
+#ifdef CRYSPR2
+    CRYSPR_AESCTX   aes_kek_buf;	/* Key Encrypting Key (KEK) */
+    CRYSPR_AESCTX   aes_sek_buf[2]; /* even/odd Stream Encrypting Key (SEK) */
+#endif
+} crysprBotan_cb;
+
+
+static const char* get_key_wrap_algo(size_t kek_len)
+{
+    switch (kek_len)
+    {
+    case 16:
+        return "AES-128";
+    case 24:
+        return "AES-192";
+    case 32:
+        return "AES-256";
+    }
+    
+    return NULL;
+}
+
+int crysprBotan_Prng(unsigned char *rn, int len)
+{
+    if (botan_system_rng_get(rn, len) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int crysprBotan_AES_SetKey(
+        int cipher_type,            /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR] */
+        bool bEncrypt,              /* true:encrypt key, false:decrypt key*/
+        const unsigned char *kstr,  /* key string */
+        size_t kstr_len,            /* kstr length in  bytes (16, 24, or 32 bytes, for AES128, AES192, or AES256) */
+        CRYSPR_AESCTX *aes_key)     /* Cryptolib Specific AES key context */
+{
+    if (!(cipher_type == HCRYPT_CTX_MODE_AESCTR || cipher_type == HCRYPT_CTX_MODE_AESGCM)) {
+        return -1;
+    }
+    if (!(kstr_len == 16 || kstr_len == 24 || kstr_len == 32)) {
+        return -1;
+    }
+
+    const char* algo = NULL;
+    if (cipher_type == HCRYPT_CTX_MODE_AESCTR) {
+        if (kstr_len == 16) {
+            algo = "CTR(AES-128)";
+        }
+        else if (kstr_len == 24) {
+            algo = "CTR(AES-192)";
+        }
+        else/* if (kstr_len == 32)*/ {
+            algo = "CTR(AES-256)";
+        }
+    } else if (cipher_type == HCRYPT_CTX_MODE_AESGCM) {
+        if (kstr_len == 16) {
+            algo = "AES-128/GCM";
+        }
+        else if (kstr_len == 24) {
+            algo = "AES-192/GCM";
+        }
+        else/* if (kstr_len == 32)*/ {
+            algo = "AES-256/GCM";
+        }
+    }
+
+    if (botan_cipher_init(
+        &aes_key->cipher,
+        algo,
+        bEncrypt ? BOTAN_CIPHER_INIT_FLAG_ENCRYPT : BOTAN_CIPHER_INIT_FLAG_DECRYPT) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    if (botan_cipher_set_key(
+        aes_key->cipher,
+        kstr,
+        kstr_len) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    memcpy(aes_key->kstr, kstr, kstr_len);
+    aes_key->kstr_len = kstr_len;
+
+    return 0;
+}
+
+int crysprBotan_AES_CtrCipher(
+    bool bEncrypt,                  /* true:encrypt, false:decrypt */
+    CRYSPR_AESCTX *aes_key,         /* CryptoLib AES context */
+    unsigned char *iv,              /* iv */
+    const unsigned char *indata,    /* src */
+    size_t inlen,                   /* src length */
+    unsigned char *out_txt)         /* dest buffer[inlen] */
+{
+    (void)bEncrypt;
+
+    if (botan_cipher_start(
+        aes_key->cipher,
+        iv,
+        16) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    size_t out_written = 0;
+    size_t in_consumed = 0;
+    if (botan_cipher_update(
+        aes_key->cipher,
+        BOTAN_CIPHER_UPDATE_FLAG_FINAL,
+        out_txt,
+        inlen,
+        &out_written,
+        indata,
+        inlen,
+        &in_consumed) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+    if (in_consumed != inlen || out_written != inlen) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int crysprBotan_AES_GCMCipher(
+    bool bEncrypt,                  /* true:encrypt, false:decrypt */
+    CRYSPR_AESCTX* aes_key,         /* CryptoLib AES context */
+    unsigned char* iv,              /* iv */
+    const unsigned char* aad,       /* associated data */
+    size_t aadlen,                  /* associated data length */
+    const unsigned char* indata,    /* src */
+    size_t inlen,                   /* src length */
+    unsigned char* out_txt,         /* dest buffer[inlen] */
+    unsigned char* out_tag)         /* dest auth tag */
+{
+    if (botan_cipher_set_associated_data(
+        aes_key->cipher,
+        aad,
+        aadlen) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    if (botan_cipher_start(
+        aes_key->cipher,
+        iv,
+        16) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    size_t out_written = 0;
+    size_t in_consumed = 0;
+    if (!bEncrypt) {
+        if (botan_cipher_update(
+            aes_key->cipher,
+            BOTAN_CIPHER_UPDATE_FLAG_FINAL,
+            out_txt,
+            inlen,
+            &out_written,
+            indata,
+            inlen + HAICRYPT_AUTHTAG_MAX,
+            &in_consumed) != BOTAN_FFI_SUCCESS) {
+            return -1;
+        }
+        if (out_written != inlen) {
+            return -1;
+        }
+    } else {
+        if (botan_cipher_update(
+            aes_key->cipher,
+            BOTAN_CIPHER_UPDATE_FLAG_FINAL,
+            out_txt,
+            inlen + HAICRYPT_AUTHTAG_MAX,
+            &out_written,
+            indata,
+            inlen,
+            &in_consumed) != BOTAN_FFI_SUCCESS) {
+            return -1;
+        }
+        if (in_consumed != inlen) {
+            return -1;
+        }
+        memcpy(out_tag, out_txt + inlen, HAICRYPT_AUTHTAG_MAX);
+    }
+
+    return 0;
+}
+
+static CRYSPR_cb *crysprBotan_Open(CRYSPR_methods *cryspr, size_t max_len)
+{
+    crysprBotan_cb *aes_data;
+
+    aes_data = (crysprBotan_cb *)crysprHelper_Open(cryspr, sizeof(crysprBotan_cb), max_len);
+    if (!aes_data) {
+        return NULL;
+    }
+
+    CRYSPR_cb *cryspr_cb = &aes_data->ccb;
+
+#ifdef CRYSPR2
+    cryspr_cb->aes_kek = &aes_data->aes_kek_buf;        // key encrypting key
+    cryspr_cb->aes_sek[0] = &aes_data->aes_sek_buf[0];  // stream encrypting key
+    cryspr_cb->aes_sek[1] = &aes_data->aes_sek_buf[1];  // stream encrypting key
+#endif
+    cryspr_cb->aes_kek->cipher = NULL;
+    cryspr_cb->aes_sek[0]->cipher = NULL;
+    cryspr_cb->aes_sek[1]->cipher = NULL;
+
+    return cryspr_cb;
+}
+
+static int crysprBotan_Close(CRYSPR_cb *cryspr_cb)
+{
+    if (cryspr_cb->aes_kek->cipher) {
+        botan_cipher_destroy(cryspr_cb->aes_kek->cipher);
+        cryspr_cb->aes_kek->cipher = NULL;
+    }
+    if (cryspr_cb->aes_sek[0]->cipher) {
+        botan_cipher_destroy(cryspr_cb->aes_sek[0]->cipher);
+        cryspr_cb->aes_sek[0]->cipher = NULL;
+    }
+    if (cryspr_cb->aes_sek[1]->cipher) {
+        botan_cipher_destroy(cryspr_cb->aes_sek[1]->cipher);
+        cryspr_cb->aes_sek[1]->cipher = NULL;
+    }
+
+    return crysprHelper_Close(cryspr_cb);
+}
+
+int crysprBotan_KmPbkdf2(
+    CRYSPR_cb *cryspr_cb,
+    char *passwd,           /* passphrase */
+    size_t passwd_len,      /* passphrase len */
+    unsigned char *salt,    /* salt */
+    size_t salt_len,        /* salt_len */
+    int itr,                /* iterations */
+    size_t key_len,         /* key_len */
+    unsigned char *out)     /* derived key buffer[key_len]*/
+{
+    (void)cryspr_cb;
+
+    if (botan_pwdhash(
+        "PBKDF2(SHA-1)",
+        itr,
+        0,
+        0,
+        out,
+        key_len,
+        passwd,
+        passwd_len,
+        salt,
+        salt_len) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int crysprBotan_KmSetKey(CRYSPR_cb *cryspr_cb, bool bWrap, const unsigned char *kek, size_t kek_len)
+{
+    return crysprBotan_AES_SetKey(
+        HCRYPT_CTX_MODE_AESCTR,
+        bWrap,
+        kek,
+        kek_len,
+        CRYSPR_GETKEK(cryspr_cb));
+}
+
+int crysprBotan_KmWrap(CRYSPR_cb *cryspr_cb,
+		unsigned char *wrap,
+		const unsigned char *sek,
+        unsigned int seklen)
+{
+    CRYSPR_AESCTX *aes_key = CRYSPR_GETKEK(cryspr_cb); // key encrypting key
+
+    size_t wraplen = seklen + HAICRYPT_WRAPKEY_SIGN_SZ;
+    int ret;
+    if ((ret = botan_nist_kw_enc(
+        get_key_wrap_algo(aes_key->kstr_len),
+        0,
+        sek,
+        seklen,
+        aes_key->kstr,
+        aes_key->kstr_len,
+        wrap,
+        &wraplen)) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    if (seklen + HAICRYPT_WRAPKEY_SIGN_SZ != wraplen) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int crysprBotan_KmUnwrap(
+        CRYSPR_cb *cryspr_cb,
+		unsigned char *sek,
+		const unsigned char *wrap,
+        unsigned int wraplen)
+{
+    CRYSPR_AESCTX *aes_key = CRYSPR_GETKEK(cryspr_cb); // key encrypting key
+
+    size_t seklen = wraplen - HAICRYPT_WRAPKEY_SIGN_SZ;
+    if (botan_nist_kw_dec(
+        get_key_wrap_algo(aes_key->kstr_len),
+        0,
+        wrap,
+        wraplen,
+        aes_key->kstr,
+        aes_key->kstr_len,
+        sek,
+        &seklen) != BOTAN_FFI_SUCCESS) {
+        return -1;
+    }
+
+    if (wraplen - HAICRYPT_WRAPKEY_SIGN_SZ != seklen) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static CRYSPR_methods crysprBotan_methods;
+
+CRYSPR_methods *crysprBotan(void)
+{
+    if (crysprBotan_methods.open) {
+        return &crysprBotan_methods;
+    }
+
+    crysprInit(&crysprBotan_methods);
+
+    /* CryptoLib Primitive API */
+    crysprBotan_methods.prng            = crysprBotan_Prng;
+    crysprBotan_methods.aes_set_key     = crysprBotan_AES_SetKey;
+    crysprBotan_methods.aes_ctr_cipher  = crysprBotan_AES_CtrCipher;
+    crysprBotan_methods.aes_gcm_cipher  = crysprBotan_AES_GCMCipher;
+
+    //--Crypto Session (Top API)
+    crysprBotan_methods.open            = crysprBotan_Open;
+    crysprBotan_methods.close           = crysprBotan_Close;
+
+    //--Keying material (km) encryption
+    crysprBotan_methods.km_pbkdf2       = crysprBotan_KmPbkdf2;
+    crysprBotan_methods.km_setkey       = crysprBotan_KmSetKey;
+    crysprBotan_methods.km_wrap         = crysprBotan_KmWrap;
+    crysprBotan_methods.km_unwrap       = crysprBotan_KmUnwrap;
+
+    return &crysprBotan_methods;
+}
+
+
+
diff --git a/haicrypt/cryspr-botan.h b/haicrypt/cryspr-botan.h
new file mode 100644
index 000000000..704d29695
--- /dev/null
+++ b/haicrypt/cryspr-botan.h
@@ -0,0 +1,59 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2019 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+
+   2019-06-27 (jdube)
+        Botan CRYSPR/4SRT (CRYypto Service PRovider for SRT)
+
+*****************************************************************************/
+
+#ifndef CRYSPR_BOTAN_H
+#define CRYSPR_BOTAN_H
+
+#include <botan/ffi.h>
+
+typedef struct botan_aes_context
+{
+    botan_cipher_t cipher;
+    unsigned char kstr[32];
+    size_t kstr_len;
+} botan_aes_context;
+
+/* Define CRYSPR_HAS_AESCTR to 1 if this CRYSPR has AES CTR cipher mode.
+*/
+#define CRYSPR_HAS_AESCTR 1
+
+/* Define CRYSPR_HAS_AESGCM to 1 if this CRYSPR has AES GCM cipher mode.
+*/
+#define CRYSPR_HAS_AESGCM 1
+
+/* Define CRYSPR_HAS_AESKWRAP to 1 if this CRYSPR has AES Key Wrap.
+*/
+#define CRYSPR_HAS_AESKWRAP 1
+
+/* Define CRYSPR_HAS_PBKDF2 to 1 if this CRYSPR has SHA1-HMAC Password-based Key Derivaion Function 2.
+*/
+#define CRYSPR_HAS_PBKDF2 1
+
+/*
+#define CRYSPR_AESCTX to the CRYSPR specifix AES key context object.
+This type reserves room in the CRYPSPR control block for Haicrypt KEK and SEK
+It is set from the keystring through CRYSPR_methods.aes_set_key and passed
+to CRYSPR_methods.aes_XXX.
+*/
+typedef botan_aes_context CRYSPR_AESCTX;   /* CRYpto Service PRovider AES key context */
+
+struct tag_CRYSPR_methods *crysprBotan(void);
+
+#endif /* CRYSPR_BOTAN_H */
+
diff --git a/haicrypt/cryspr-config.h b/haicrypt/cryspr-config.h
index e90377884..d1b9e8137 100644
--- a/haicrypt/cryspr-config.h
+++ b/haicrypt/cryspr-config.h
@@ -8,14 +8,26 @@
 #if defined(USE_OPENSSL)
 #include "cryspr-openssl.h"
 #define cryspr4SRT()  crysprOpenSSL()
+#define CRYSPR_IMPL_DESC "OpenSSL-AES"
+#elif defined(USE_OPENSSL_EVP)
+#include "cryspr-openssl-evp.h"
+#define cryspr4SRT()  crysprOpenSSL_EVP()
+#define CRYSPR_IMPL_DESC "OpenSSL-EVP"
 #elif defined(USE_GNUTLS)
 #include "cryspr-gnutls.h"
 #define cryspr4SRT()  crysprGnuTLS()
+#define CRYSPR_IMPL_DESC "GnuTLS"
 #elif defined(USE_MBEDTLS)
 #include "cryspr-mbedtls.h"
 #define cryspr4SRT() crysprMbedtls()
+#define CRYSPR_IMPL_DESC "MbedTLS"
+#elif defined(USE_BOTAN)
+#include "cryspr-botan.h"
+#define cryspr4SRT() crysprBotan()
+#define CRYSPR_IMPL_DESC "Botan"
 #else
 #error Cryspr implementation not selected. Please define USE_* + OPENSSL/GNUTLS/MBEDTLS.
+#define CRYSPR_IMPL_DESC "No Cipher"
 #endif
 
 
diff --git a/haicrypt/cryspr-gnutls.c b/haicrypt/cryspr-gnutls.c
index 217a70e8a..95eaf2856 100644
--- a/haicrypt/cryspr-gnutls.c
+++ b/haicrypt/cryspr-gnutls.c
@@ -13,6 +13,8 @@
 written by
    Haivision Systems Inc.
 
+   2022-05-19 (jdube)
+        CRYSPR2 adaptation
    2019-06-27 (jdube)
         GnuTLS/Nettle CRYSPR/4SRT (CRYypto Service PRovider for SRT)
 *****************************************************************************/
@@ -24,6 +26,10 @@ written by
 typedef struct tag_crysprGnuTLS_AES_cb {
         CRYSPR_cb       ccb;        /* CRYSPR control block */
         /* Add other cryptolib specific data here */
+#ifdef CRYSPR2
+        CRYSPR_AESCTX   aes_kek_buf;		/* Key Encrypting Key (KEK) */
+        CRYSPR_AESCTX   aes_sek_buf[2];		/* even/odd Stream Encrypting Key (SEK) */
+#endif
 } crysprGnuTLS_cb;
 
 
@@ -33,11 +39,14 @@ int crysprGnuTLS_Prng(unsigned char *rn, int len)
 }
 
 int crysprGnuTLS_AES_SetKey(
+    int cipher_type,            /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR] */
     bool bEncrypt,              /* true:encrypt key, false:decrypt key*/
     const unsigned char *kstr,  /* key string */
     size_t kstr_len,            /* kstr length in  bytes (16, 24, or 32 bytes (for AES128,AES192, or AES256) */
     CRYSPR_AESCTX *aes_key)     /* Cryptolib Specific AES key context */
 {
+    (void)cipher_type;
+
     if (bEncrypt) {        /* Encrypt key */
         if (!(kstr_len == 16 || kstr_len == 24 || kstr_len == 32)) {
             HCRYPT_LOG(LOG_ERR, "%s", "AES_set_encrypt_key(kek) bad length\n");
@@ -114,6 +123,31 @@ int crysprGnuTLS_AES_CtrCipher( /* AES-CTR128 Encryption */
     return 0;
 }
 
+#ifdef CRYSPR2
+static CRYSPR_cb *crysprGnuTLS_Open(CRYSPR_methods *cryspr, size_t max_len)
+{
+    crysprGnuTLS_cb *aes_data;
+    CRYSPR_cb *cryspr_cb;
+
+    aes_data = (crysprGnuTLS_cb *)crysprHelper_Open(cryspr, sizeof(crysprGnuTLS_cb), max_len);
+    if (NULL == aes_data) {
+        HCRYPT_LOG(LOG_ERR, "crysprHelper_Open(%p, %zd, %zd) failed\n", cryspr, sizeof(crysprGnuTLS_cb), max_len);
+        return(NULL);
+    }
+
+    aes_data->ccb.aes_kek = &aes_data->aes_kek_buf; //key encrypting key
+    aes_data->ccb.aes_sek[0] = &aes_data->aes_sek_buf[0]; //stream encrypting key
+    aes_data->ccb.aes_sek[1] = &aes_data->aes_sek_buf[1]; //stream encrypting key
+
+    return(&aes_data->ccb);
+}
+
+static int crysprGnuTLS_Close(CRYSPR_cb *cryspr_cb)
+{
+    return(crysprHelper_Close(cryspr_cb));
+}
+#endif /* CRYSPR2 */
+
 #ifdef CRYSPR_HAS_PBKDF2
 /*
 * Password-based Key Derivation Function
@@ -157,8 +191,13 @@ CRYSPR_methods *crysprGnuTLS(void)
     #endif
 
     //--Crypto Session (Top API)
+    #ifdef CRYSPR2
+        crysprGnuTLS_methods.open     = crysprGnuTLS_Open;
+        crysprGnuTLS_methods.close    = crysprGnuTLS_Close;
+    #else /* CRYSPR2 */
     //  crysprGnuTLS_methods.open     =
     //  crysprGnuTLS_methods.close    =
+    #endif /* CRYSPR2 */
     //--Keying material (km) encryption
 #if CRYSPR_HAS_PBKDF2
     	crysprGnuTLS_methods.km_pbkdf2  = crysprGnuTLS_KmPbkdf2;
diff --git a/haicrypt/cryspr-mbedtls.c b/haicrypt/cryspr-mbedtls.c
index c10727a0a..a961cca61 100644
--- a/haicrypt/cryspr-mbedtls.c
+++ b/haicrypt/cryspr-mbedtls.c
@@ -13,8 +13,10 @@
 written by
    Haivision Systems Inc.
 
+   2022-05-19 (jdube)
+        CRYSPR2 adaptation
    2019-06-27 (jdube)
-        GnuTLS/Nettle CRYSPR/4SRT (CRYypto Service PRovider for SRT)
+        MBedTLS CRYSPR/4SRT (CRYypto Service PRovider for SRT)
 *****************************************************************************/
 
 #include "hcrypt.h"
@@ -29,11 +31,14 @@ written by
 // Static members of cryspr::mbedtls class.
 static mbedtls_ctr_drbg_context crysprMbedtls_ctr_drbg;
 static mbedtls_entropy_context crysprMbedtls_entropy;
-static mbedtls_md_context_t crysprMbedtls_mdctx;
 
-typedef struct tag_crysprGnuTLS_AES_cb {
+typedef struct tag_crysprMBedTLS_AES_cb {
         CRYSPR_cb       ccb;        /* CRYSPR control block */
         /* Add other cryptolib specific data here */
+#ifdef CRYSPR2
+        CRYSPR_AESCTX   aes_kek_buf;		/* Key Encrypting Key (KEK) */
+        CRYSPR_AESCTX   aes_sek_buf[2];		/* even/odd Stream Encrypting Key (SEK) */
+#endif
 } crysprMbedtls_cb;
 
 
@@ -49,25 +54,30 @@ int crysprMbedtls_Prng(unsigned char *rn, int len)
 }
 
 int crysprMbedtls_AES_SetKey(
+        int cipher_type,            /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR] */
         bool bEncrypt,              /* true:encrypt key, false:decrypt key*/
         const unsigned char *kstr,  /* key string */
         size_t kstr_len,            /* kstr length in  bytes (16, 24, or 32 bytes, for AES128,AES192, or AES256) */
         CRYSPR_AESCTX *aes_key)     /* Cryptolib Specific AES key context */
 {
+    (void)cipher_type;
+
     if (!(kstr_len == 16 || kstr_len == 24 || kstr_len == 32)) {
         HCRYPT_LOG(LOG_ERR, "%s", "AES_set_encrypt_key(kek) bad length\n");
         return -1;
     }
 
     int ret;
-
+#ifdef CRYSPR2
+    (void)cipher_type;
+#endif
     // mbedtls uses the "bits" convention (128, 192, 254), just like openssl.
     // kstr_len is in "bytes" convention (16, 24, 32).
 
     if (bEncrypt) {        /* Encrypt key */
-        ret = mbedtls_aes_setkey_enc(aes_key, kstr, kstr_len*8);
+        ret = mbedtls_aes_setkey_enc(aes_key, kstr, (unsigned int)kstr_len*8);
     } else {               /* Decrypt key */
-        ret = mbedtls_aes_setkey_dec(aes_key, kstr, kstr_len*8);
+        ret = mbedtls_aes_setkey_dec(aes_key, kstr, (unsigned int)kstr_len*8);
     }
 
     return ret == 0 ? 0 : -1;
@@ -81,8 +91,8 @@ int crysprMbedtls_AES_EcbCipher( /* AES Electronic Codebook cipher*/
     unsigned char *out_txt,     /* dst (cipher text) */
     size_t *outlen)             /* dst len */
 {
-    int nblk = inlen/CRYSPR_AESBLKSZ;
-    int nmore = inlen%CRYSPR_AESBLKSZ;
+    int nblk = (int)(inlen/CRYSPR_AESBLKSZ);
+    int nmore = (int)(inlen%CRYSPR_AESBLKSZ);
     int i;
 
     if (bEncrypt) {
@@ -146,6 +156,30 @@ int crysprMbedtls_AES_CtrCipher( /* AES-CTR128 Encryption */
     return 0;
 }
 
+#ifdef CRYSPR2
+static CRYSPR_cb *crysprMbedtls_Open(CRYSPR_methods *cryspr, size_t max_len)
+{
+    crysprMbedtls_cb *aes_data;
+
+    aes_data = (crysprMbedtls_cb *)crysprHelper_Open(cryspr, sizeof(crysprMbedtls_cb), max_len);
+    if (NULL == aes_data) {
+        HCRYPT_LOG(LOG_ERR, "crysprHelper_Open(%p, %zd, %zd) failed\n", cryspr, sizeof(crysprMbedtls_cb), max_len);
+        return(NULL);
+    }
+
+    aes_data->ccb.aes_kek = &aes_data->aes_kek_buf; //key encrypting key
+    aes_data->ccb.aes_sek[0] = &aes_data->aes_sek_buf[0]; //stream encrypting key
+    aes_data->ccb.aes_sek[1] = &aes_data->aes_sek_buf[1]; //stream encrypting key
+
+    return(&aes_data->ccb);
+}
+
+static int crysprMbedtls_Close(CRYSPR_cb *cryspr_cb)
+{
+    return(crysprHelper_Close(cryspr_cb));
+}
+#endif /* CRYSPR2 */
+
 /*
 * Password-based Key Derivation Function
 */
@@ -161,9 +195,29 @@ int crysprMbedtls_KmPbkdf2(
 {
     (void)cryspr_cb;
 
-    int ret = mbedtls_pkcs5_pbkdf2_hmac(&crysprMbedtls_mdctx,
+    const mbedtls_md_info_t* ifo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
+    if ( ifo == NULL ) {
+        // XXX report error, log?
+        return -1;
+    }
+
+    mbedtls_md_context_t mdctx;
+    mbedtls_md_init(&mdctx);
+
+    const int yes_use_hmac = 1;
+    int ret;
+    if ( (ret = mbedtls_md_setup(&mdctx, ifo, yes_use_hmac)) != 0 ) {
+        mbedtls_md_free(&mdctx);
+
+        // XXX report error, log?
+        return ret;
+    }
+
+    ret = mbedtls_pkcs5_pbkdf2_hmac(&mdctx,
             (unsigned char*)passwd, passwd_len, salt, salt_len,
-            itr, key_len, out);
+            itr, (uint32_t)key_len, out);
+
+    mbedtls_md_free(&mdctx);
 
     if (ret == 0)
         return 0;
@@ -196,8 +250,13 @@ CRYSPR_methods *crysprMbedtls(void)
 #endif
 
     //--Crypto Session (Top API)
+#ifdef CRYSPR2
+        crysprMbedtls_methods.open     = crysprMbedtls_Open;
+        crysprMbedtls_methods.close    = crysprMbedtls_Close;
+#else
     //  crysprMbedtls_methods.open     =
     //  crysprMbedtls_methods.close    =
+#endif
     //--Keying material (km) encryption
     crysprMbedtls_methods.km_pbkdf2  = crysprMbedtls_KmPbkdf2;
     //	crysprMbedtls_methods.km_setkey  =
@@ -220,14 +279,6 @@ CRYSPR_methods *crysprMbedtls(void)
         return NULL;
     }
 
-    // Ok, mbedtls with all flexibility you couldn't make it more complicated.
-
-    mbedtls_md_init(&crysprMbedtls_mdctx);
-    const mbedtls_md_info_t* ifo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
-    const int yes_use_hmac = 1;
-    mbedtls_md_setup(&crysprMbedtls_mdctx, ifo, yes_use_hmac);
-
-
     return(&crysprMbedtls_methods);
 }
 
diff --git a/haicrypt/cryspr-mbedtls.h b/haicrypt/cryspr-mbedtls.h
index aa10da874..f62b32e48 100644
--- a/haicrypt/cryspr-mbedtls.h
+++ b/haicrypt/cryspr-mbedtls.h
@@ -13,12 +13,12 @@ written by
    Haivision Systems Inc.
 
    2019-06-27 (jdube)
-        GnuTLS/Nettle CRYSPR/4SRT (CRYypto Service PRovider for SRT)
+        MBedTLS CRYSPR/4SRT (CRYypto Service PRovider for SRT)
 
 *****************************************************************************/
 
-#ifndef CRYSPR_GNUTLS_H
-#define CRYSPR_GNUTLS_H
+#ifndef CRYSPR_MBEDTLS_H
+#define CRYSPR_MBEDTLS_H
 
 #include <mbedtls/ctr_drbg.h>
 #include <mbedtls/aes.h>
@@ -52,12 +52,12 @@ written by
 /*
 #define CRYSPR_AESCTX to the CRYSPR specifix AES key context object.
 This type reserves room in the CRYPSPR control block for Haicrypt KEK and SEK
-It is set from hte keystring through CRYSPR_methods.aes_set_key and passed
+It is set from the keystring through CRYSPR_methods.aes_set_key and passed
 to CRYSPR_methods.aes_XXX.
 */
-typedef struct mbedtls_aes_context CRYSPR_AESCTX;   /* CRYpto Service PRovider AES key context */
+typedef mbedtls_aes_context CRYSPR_AESCTX;   /* CRYpto Service PRovider AES key context */
 
 struct tag_CRYSPR_methods *crysprMbedtls(void);
 
-#endif /* CRYSPR_GNUTLS_H */
+#endif /* CRYSPR_MBEDTLS_H */
 
diff --git a/haicrypt/cryspr-openssl-evp.c b/haicrypt/cryspr-openssl-evp.c
new file mode 100644
index 000000000..3e87e9a5e
--- /dev/null
+++ b/haicrypt/cryspr-openssl-evp.c
@@ -0,0 +1,417 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2019 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+
+   2022-05-19 (jdube)
+        OpenSSL EVP CRYSPR/4SRT (CRYypto Service PRovider for SRT).
+*****************************************************************************/
+
+#include "hcrypt.h"
+
+#include <string.h>
+
+typedef struct tag_crysprOpenSSL_EVP_cb
+{
+    CRYSPR_cb ccb;
+    /* Add cryptolib specific data here */
+} crysprOpenSSL_EVP_cb;
+
+int crysprOpenSSL_EVP_Prng(unsigned char* rn, int len)
+{
+    return (RAND_bytes(rn, len) <= 0 ? -1 : 0);
+}
+
+const EVP_CIPHER* (*Xcipher_fnptr)(void) = EVP_aes_128_ecb;
+
+const EVP_CIPHER* (*_crysprOpenSSL_EVP_cipher_fnptr[][3])(void) = {
+    {NULL, NULL, NULL}, // HCRYPT_CTX_MODE_CLRTXT
+    {EVP_aes_128_ecb, EVP_aes_192_ecb, EVP_aes_256_ecb}, // HCRYPT_CTX_MODE_AESECB
+    {EVP_aes_128_ctr, EVP_aes_192_ctr, EVP_aes_256_ctr}, // HCRYPT_CTX_MODE_AESCTR
+    {NULL, NULL, NULL}, // HCRYPT_CTX_MODE_AESCBC
+    {EVP_aes_128_gcm, EVP_aes_192_gcm, EVP_aes_256_gcm}, // HCRYPT_CTX_MODE_AESGCM
+};
+
+int crysprOpenSSL_EVP_AES_SetKey(
+    int                  cipher_type, /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR] */
+    bool                 bEncrypt,    /* true Enxcrypt key, false: decrypt */
+    const unsigned char* kstr,        /* key sttring*/
+    size_t               kstr_len,    /* kstr len in  bytes (16, 24, or 32 bytes (for AES128, AES192, or AES256) */
+    CRYSPR_AESCTX*       aes_key)           /* CRYpto Service PRovider AES Key context */
+{
+    const EVP_CIPHER* cipher  = NULL;
+    int               idxKlen = (int)((kstr_len / 8) - 2); /* key_len index in cipher_fnptr array in [0,1,2] range */
+
+    switch (cipher_type)
+    {
+    case HCRYPT_CTX_MODE_CLRTXT:
+        return 0;
+    case HCRYPT_CTX_MODE_AESECB:
+        break;
+    case HCRYPT_CTX_MODE_AESCTR:
+#if !CRYSPR_HAS_AESCTR
+        /* internal implementation of AES-CTR using crypto lib's AES-ECB */
+        cipher_type = HCRYPT_CTX_MODE_AESECB;
+#endif
+        break;
+    case HCRYPT_CTX_MODE_AESGCM:
+        break;
+    default:
+        HCRYPT_LOG(LOG_ERR,
+                   "invalid cipher type (%d). Expected: [%d..%d]\n",
+                   cipher_type,
+                   HCRYPT_CTX_MODE_AESECB,
+                   HCRYPT_CTX_MODE_AESCTR);
+        return (-1);
+    }
+    switch (kstr_len)
+    {
+    case 128 / 8:
+    case 192 / 8:
+    case 256 / 8:
+        break;
+    default:
+        HCRYPT_LOG(LOG_ERR, "invalid key length (%d). Expected: 16, 24, 32\n", (int)kstr_len);
+        return -1;
+    }
+    cipher = _crysprOpenSSL_EVP_cipher_fnptr[cipher_type][idxKlen]();
+
+    if (bEncrypt)
+    { /* Encrypt key */
+        if (!EVP_EncryptInit_ex(aes_key, cipher, NULL, kstr, NULL))
+        {
+            HCRYPT_LOG(LOG_ERR, "%s", "EVP_CipherInit_ex(kek) failed\n");
+            return (-1);
+        }
+    }
+    else
+    { /* Decrypt key */
+        if (!EVP_DecryptInit_ex(aes_key, cipher, NULL, kstr, NULL))
+        {
+            HCRYPT_LOG(LOG_ERR, "%s", "EVP_CipherInit_ex(kek) failed\n");
+            return (-1);
+        }
+    }
+    return (0);
+}
+
+static CRYSPR_cb* crysprOpenSSL_EVP_Open(CRYSPR_methods* cryspr, size_t max_len)
+{
+    CRYSPR_cb* cryspr_cb = crysprHelper_Open(cryspr, sizeof(*cryspr_cb), max_len);
+    if (NULL == cryspr_cb)
+    {
+        HCRYPT_LOG(LOG_ERR, "crysprFallback_Open(%p, %zd) failed\n", cryspr, max_len);
+        return (NULL);
+    }
+
+    cryspr_cb->aes_kek = EVP_CIPHER_CTX_new();
+
+    cryspr_cb->aes_sek[0] = EVP_CIPHER_CTX_new();
+
+    cryspr_cb->aes_sek[1] = EVP_CIPHER_CTX_new();
+
+    return (cryspr_cb);
+}
+
+static int crysprOpenSSL_EVP_Close(CRYSPR_cb* cryspr_cb)
+{
+    if (NULL != cryspr_cb)
+    {
+        EVP_CIPHER_CTX_free(cryspr_cb->aes_sek[0]);
+        EVP_CIPHER_CTX_free(cryspr_cb->aes_sek[1]);
+        EVP_CIPHER_CTX_free(cryspr_cb->aes_kek);
+    }
+    return (crysprHelper_Close(cryspr_cb));
+}
+
+#if !(CRYSPR_HAS_AESCTR && CRYSPR_HAS_AESKWRAP)
+
+int crysprOpenSSL_EVP_AES_EcbCipher(bool                 bEncrypt, /* true:encrypt, false:decrypt */
+                                    CRYSPR_AESCTX*       aes_key,  /* CRYpto Service PRovider AES Key context */
+                                    const unsigned char* indata, /* src (clear text if encrypt, cipher text otherwise)*/
+                                    size_t               inlen,  /* indata length */
+                                    unsigned char* out_txt, /* dst (cipher text if encrypt, clear text otherwise) */
+                                    size_t*        outlen_p)       /* in/out dst len */
+{
+    int    nmore  = inlen % CRYSPR_AESBLKSZ; /* bytes in last incomplete block */
+    int    nblk   = (int)(inlen / CRYSPR_AESBLKSZ + (nmore ? 1 : 0)); /* blocks including incomplete */
+    size_t outsiz = (outlen_p ? *outlen_p : 0);
+    int    c_len = 0, f_len = 0;
+
+    (void)bEncrypt; // not needed, alreadydefined in context
+
+    if (outsiz % CRYSPR_AESBLKSZ)
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EcbCipher() no room for PKCS7 padding");
+        return (-1); /* output buf size must be a multiple of AES block size (16) */
+    }
+    if ((outsiz > 16) && ((int)outsiz < (nblk * CRYSPR_AESBLKSZ)))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EcbCipher() no room for PKCS7 padding");
+        return (-1); /* output buf size must have room for PKCS7 padding */
+    }
+    /* allows reusing of 'e' for multiple encryption cycles */
+    if (!EVP_CipherInit_ex(aes_key, NULL, NULL, NULL, NULL, bEncrypt))
+    {
+        HCRYPT_LOG(LOG_ERR, "EVP_CipherInit_ex(%p,NULL,...,-1) failed\n", aes_key);
+        return -1;
+    }
+    if (!EVP_CIPHER_CTX_set_padding(aes_key, 0))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CIPHER_CTX_set_padding(%p) failed", aes_key);
+        return -1;
+    }
+
+    /* update ciphertext, c_len is filled with the length of ciphertext generated,
+     * cryptoPtr->cipher_in_len is the size of plain/cipher text in bytes
+     */
+    if (!EVP_CipherUpdate(aes_key, out_txt, &c_len, indata, (int)inlen))
+    {
+        HCRYPT_LOG(LOG_ERR, "EVP_CipherUpdate(%p, out, %d, in, %d) failed\n", aes_key, c_len, inlen);
+        return -1;
+    }
+
+    /* update ciphertext with the final remaining bytes */
+    /* Useless with pre-padding */
+    f_len = 0;
+    if (0 == EVP_CipherFinal_ex(aes_key, &out_txt[c_len], &f_len))
+    {
+#if ENABLE_HAICRYPT_LOGGING
+        char szErrBuf[256];
+        HCRYPT_LOG(LOG_ERR,
+                   "EVP_CipherFinal_ex(ctx,&out[%d],%d)) failed: %s\n",
+                   c_len,
+                   f_len,
+                   ERR_error_string(ERR_get_error(), szErrBuf));
+#endif /*ENABLE_HAICRYPT_LOGGING*/
+        return -1;
+    }
+    if (outlen_p != NULL) *outlen_p = nblk * CRYSPR_AESBLKSZ;
+    return 0;
+}
+#endif /* !(CRYSPR_HAS_AESCTR && CRYSPR_HAS_AESKWRAP) */
+
+int crysprOpenSSL_EVP_AES_CtrCipher(bool                 bEncrypt, /* true:encrypt, false:decrypt */
+                                    CRYSPR_AESCTX*       aes_key,  /* CRYpto Service PRovider AES Key context */
+                                    unsigned char*       iv,       /* iv */
+                                    const unsigned char* indata,   /* src */
+                                    size_t               inlen,    /* length */
+                                    unsigned char*       out_txt)        /* dest */
+
+{
+    int c_len, f_len;
+
+    (void)bEncrypt;
+
+    /* allows reusing of 'e' for multiple encryption cycles */
+    if (!EVP_CipherInit_ex(aes_key, NULL, NULL, NULL, iv, -1))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CipherInit_ex() failed");
+        return -1;
+    }
+    if (!EVP_CIPHER_CTX_set_padding(aes_key, 0))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CIPHER_CTX_set_padding() failed");
+        return -1;
+    }
+
+    /* update ciphertext, c_len is filled with the length of ciphertext generated,
+     * cryptoPtr->cipher_in_len is the size of plain/cipher text in bytes
+     */
+    if (!EVP_CipherUpdate(aes_key, out_txt, &c_len, indata, (int)inlen))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CipherUpdate() failed");
+        return -1;
+    }
+
+    /* update ciphertext with the final remaining bytes */
+    /* Useless with pre-padding */
+    f_len = 0;
+    if (0 == EVP_CipherFinal_ex(aes_key, &out_txt[c_len], &f_len))
+    {
+#if ENABLE_HAICRYPT_LOGGING
+        char szErrBuf[256];
+        HCRYPT_LOG(LOG_ERR,
+                   "EVP_CipherFinal_ex(ctx,&out[%d],%d)) failed: %s\n",
+                   c_len,
+                   f_len,
+                   ERR_error_string(ERR_get_error(), szErrBuf));
+#endif /*ENABLE_HAICRYPT_LOGGING*/
+        return -1;
+    }
+    return 0;
+}
+
+int crysprOpenSSL_EVP_AES_GCMCipher(bool                 bEncrypt, /* true:encrypt, false:decrypt */
+                                    CRYSPR_AESCTX*       aes_key,  /* CRYpto Service PRovider AES Key context */
+                                    unsigned char*       iv,       /* iv */
+                                    const unsigned char* aad,      /* associated data */
+                                    size_t               aadlen,
+                                    const unsigned char* indata,   /* src */
+                                    size_t               inlen,    /* length */
+                                    unsigned char*       out_txt,
+                                    unsigned char*       out_tag)  /* auth tag */
+{
+    int c_len, f_len;
+
+    /* allows reusing of 'e' for multiple encryption cycles */
+    if (!EVP_CipherInit_ex(aes_key, NULL, NULL, NULL, iv, -1))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CipherInit_ex() failed");
+        return -1;
+    }
+    if (!EVP_CIPHER_CTX_set_padding(aes_key, 0))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CIPHER_CTX_set_padding() failed");
+        return -1;
+    }
+
+    /*
+     * Provide any AAD data. This can be called zero or more times as
+     * required
+     */
+    if (1 != EVP_CipherUpdate(aes_key, NULL, &c_len, aad, (int) aadlen))
+    {
+        ERR_print_errors_fp(stderr);
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_EncryptUpdate failed");
+        return -1;
+    }
+
+    /* update ciphertext, c_len is filled with the length of ciphertext generated,
+     * cryptoPtr->cipher_in_len is the size of plain/cipher text in bytes
+     */
+    if (!EVP_CipherUpdate(aes_key, out_txt, &c_len, indata, (int) inlen))
+    {
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CipherUpdate() failed");
+        return -1;
+    }
+
+    if (!bEncrypt && !EVP_CIPHER_CTX_ctrl(aes_key, EVP_CTRL_GCM_SET_TAG, HAICRYPT_AUTHTAG_MAX, out_tag)) {
+        ERR_print_errors_fp(stderr);
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_EncryptUpdate failed");
+        return -1;
+    }
+
+    /* update ciphertext with the final remaining bytes */
+    /* Useless with pre-padding */
+    f_len = 0;
+    if (0 == EVP_CipherFinal_ex(aes_key, &out_txt[c_len], &f_len))
+    {
+#if ENABLE_HAICRYPT_LOGGING
+        char szErrBuf[256];
+        HCRYPT_LOG(LOG_ERR,
+                   "EVP_CipherFinal_ex(ctx,&out[%d],%d)) failed: %s\n",
+                   c_len,
+                   f_len,
+                   ERR_error_string(ERR_get_error(), szErrBuf));
+#endif /*ENABLE_HAICRYPT_LOGGING*/
+        return -1;
+    }
+
+    /* Get the tag if we are encrypting */
+    if (bEncrypt && !EVP_CIPHER_CTX_ctrl(aes_key, EVP_CTRL_GCM_GET_TAG, HAICRYPT_AUTHTAG_MAX, out_tag))
+    {
+        ERR_print_errors_fp(stderr);
+        HCRYPT_LOG(LOG_ERR, "%s\n", "EVP_CIPHER_CTX_ctrl(EVP_CTRL_GCM_GET_TAG) failed");
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Password-based Key Derivation Function
+ */
+int crysprOpenSSL_EVP_KmPbkdf2(CRYSPR_cb*     cryspr_cb,
+                               char*          passwd,     /* passphrase */
+                               size_t         passwd_len, /* passphrase len */
+                               unsigned char* salt,       /* salt */
+                               size_t         salt_len,   /* salt_len */
+                               int            itr,        /* iterations */
+                               size_t         key_len,    /* key_len */
+                               unsigned char* out)        /* derived key */
+{
+    (void)cryspr_cb;
+    int rc = PKCS5_PBKDF2_HMAC_SHA1(passwd, (int)passwd_len, salt, (int)salt_len, itr, (int)key_len, out);
+    return (rc == 1 ? 0 : -1);
+}
+
+#if CRYSPR_HAS_AESKWRAP
+int crysprOpenSSL_EVP_KmWrap(CRYSPR_cb* cryspr_cb, unsigned char* wrap, const unsigned char* sek, unsigned int seklen)
+{
+    crysprOpenSSL_EVP_cb* aes_data = (crysprOpenSSL_EVP_cb*)cryspr_cb;
+    EVP_CIPHER_CTX*       kek      = CRYSPR_GETKEK(cryspr_cb); // key encrypting key
+
+    return (((seklen + HAICRYPT_WRAPKEY_SIGN_SZ) == (unsigned int)AES_wrap_key(kek, NULL, wrap, sek, seklen)) ? 0 : -1);
+}
+
+int crysprOpenSSL_EVP_KmUnwrap(CRYSPR_cb*           cryspr_cb,
+                               unsigned char*       sek, // Stream encrypting key
+                               const unsigned char* wrap,
+                               unsigned int         wraplen)
+{
+    crysprOpenSSL_EVP_cb* aes_data = (crysprOpenSSL_EVP_cb*)cryspr_cb;
+    EVP_CIPHER_CTX*       kek      = CRYSPR_GETKEK(cryspr_cb); // key encrypting key
+
+    return (((wraplen - HAICRYPT_WRAPKEY_SIGN_SZ) == (unsigned int)AES_unwrap_key(kek, NULL, sek, wrap, wraplen)) ? 0
+                                                                                                                  : -1);
+}
+#endif /*CRYSPR_HAS_AESKWRAP*/
+
+static CRYSPR_methods crysprOpenSSL_EVP_methods;
+
+CRYSPR_methods* crysprOpenSSL_EVP(void)
+{
+    if (NULL == crysprOpenSSL_EVP_methods.open)
+    {
+        crysprInit(&crysprOpenSSL_EVP_methods); // Default/fallback methods
+
+        crysprOpenSSL_EVP_methods.prng = crysprOpenSSL_EVP_Prng;
+        //--CryptoLib Primitive API-----------------------------------------------
+        crysprOpenSSL_EVP_methods.aes_set_key = crysprOpenSSL_EVP_AES_SetKey;
+#if CRYSPR_HAS_AESCTR
+        crysprOpenSSL_EVP_methods.aes_ctr_cipher = crysprOpenSSL_EVP_AES_CtrCipher;
+#endif
+        crysprOpenSSL_EVP_methods.aes_gcm_cipher = crysprOpenSSL_EVP_AES_GCMCipher;
+#if !(CRYSPR_HAS_AESCTR && CRYSPR_HAS_AESKWRAP)
+        /* AES-ECB only required if cryspr has no AES-CTR and no AES KeyWrap */
+        /* OpenSSL has both AESCTR and AESKWRP and the AESECB wrapper is only used
+           to test the falback methods */
+        crysprOpenSSL_EVP_methods.aes_ecb_cipher = crysprOpenSSL_EVP_AES_EcbCipher;
+#endif
+#if !CRYSPR_HAS_PBKDF2
+        crysprOpenSSL_EVP_methods.sha1_msg_digest = NULL; // Required to use eventual default/fallback KmPbkdf2
+#endif
+
+        //--Crypto Session API-----------------------------------------
+        crysprOpenSSL_EVP_methods.open  = crysprOpenSSL_EVP_Open;
+        crysprOpenSSL_EVP_methods.close = crysprOpenSSL_EVP_Close;
+        //--Keying material (km) encryption
+
+#if CRYSPR_HAS_PBKDF2
+        crysprOpenSSL_EVP_methods.km_pbkdf2 = crysprOpenSSL_EVP_KmPbkdf2;
+#else
+#error There is no default/fallback method for PBKDF2
+#endif
+        //	crysprOpenSSL_EVP_methods.km_setkey  =
+#if CRYSPR_HAS_AESKWRAP
+        crysprOpenSSL_EVP_methods.km_wrap   = crysprOpenSSL_EVP_KmWrap;
+        crysprOpenSSL_EVP_methods.km_unwrap = crysprOpenSSL_EVP_KmUnwrap;
+#endif
+
+        //--Media stream (ms) encryption
+        //  crysprOpenSSL_EVP_methods.ms_setkey  =
+        //	crysprOpenSSL_EVP_methods.ms_encrypt =
+        //	crysprOpenSSL_EVP_methods.ms_decrypt =
+    }
+    return (&crysprOpenSSL_EVP_methods);
+}
diff --git a/haicrypt/cryspr-openssl-evp.h b/haicrypt/cryspr-openssl-evp.h
new file mode 100644
index 000000000..a1fb0b925
--- /dev/null
+++ b/haicrypt/cryspr-openssl-evp.h
@@ -0,0 +1,67 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2019 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+
+   2022-05-19 (jdube)
+        OpenSSL EVP AES CRYSPR/4SRT (CRYypto Service PRovider for SRT).
+*****************************************************************************/
+
+#ifndef CRYSPR_OPENSSL_H
+#define CRYSPR_OPENSSL_H
+
+#include <openssl/evp.h> /* PKCS5_xxx() */
+#include <openssl/aes.h> /* AES_xxx() */
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(OPENSSL_IS_BORINGSSL))
+#include <openssl/modes.h> /* CRYPTO_xxx() */
+#endif
+#include <openssl/rand.h>
+#include <openssl/err.h>
+#include <openssl/opensslv.h> /* OPENSSL_VERSION_NUMBER */
+
+/* Define CRYSPR_HAS_AESCTR to 1 if this CRYSPR has AESCTR cipher mode
+   if not set it 0 to use enable CTR cipher mode implementation using ECB cipher mode
+   and provide the aes_ecb_cipher method.
+*/
+#define CRYSPR_HAS_AESCTR 1
+
+/* Define CRYSPR_HAS_AESGCM to 1 if this CRYSPR has AES GCM cipher mode. OpenSSL EVP supports GCM.
+*/
+#define CRYSPR_HAS_AESGCM 1
+
+/* Define CRYSPR_HAS_AESKWRAP to 1 if this CRYSPR has AES Key Wrap
+   if not set to 0 to enable default/fallback crysprFallback_AES_WrapKey/crysprFallback_AES_UnwrapKey methods
+   and provide the aes_ecb_cipher method  .
+*/
+#if 1 // Force internal AES-WRAP (using AES-ECB) until implemented with EVP (OPENSSL_VERSION_NUMBER < 0x00xxxxxxL)
+#define CRYSPR_HAS_AESKWRAP 0
+#else
+#define CRYSPR_HAS_AESKWRAP 1
+#endif
+
+/* Define CRYSPR_HAS_PBKDF2 to 1 if this CRYSPR has SHA1-HMAC Password-based Key Derivaion Function 2
+   if not set to 0 to enable not-yet-implemented/fallback crysprFallback.km_pbkdf2 method
+   and provide the sha1_msg_digest method.
+*/
+#define CRYSPR_HAS_PBKDF2 1 /* Define to 1 if CRYSPR has Password-based Key Derivaion Function 2 */
+
+/*
+#define CRYSPR_AESCTX to the CRYSPR specifix AES key context object.
+This type reserves room in the CRYPSPR control block for Haicrypt KEK and SEK
+It is set from hte keystring through CRYSPR_methods.aes_set_key and passed
+to CRYSPR_methods.aes_*.
+*/
+typedef EVP_CIPHER_CTX CRYSPR_AESCTX; /* CRYpto Service PRovider AES key context */
+
+struct tag_CRYSPR_methods* crysprOpenSSL_EVP(void);
+
+#endif /* CRYSPR_OPENSSL_H */
diff --git a/haicrypt/cryspr-openssl.c b/haicrypt/cryspr-openssl.c
index a5d50ac65..87eb535ec 100644
--- a/haicrypt/cryspr-openssl.c
+++ b/haicrypt/cryspr-openssl.c
@@ -13,18 +13,23 @@
 written by
    Haivision Systems Inc.
 
+   2022-05-19 (jdube)
+        CRYSPR2 adaptation
    2019-06-26 (jdube)
-        OpenSSL CRYSPR/4SRT (CRYypto Service PRovider for SRT).
+        OpenSSL Direct AES CRYSPR/4SRT (CRYypto Service PRovider for SRT).
 *****************************************************************************/
 
 #include "hcrypt.h"
 
 #include <string.h>
 
-
 typedef struct tag_crysprOpenSSL_AES_cb {
-        CRYSPR_cb       ccb;
-        /* Add cryptolib specific data here */
+    CRYSPR_cb       ccb;
+    /* Add cryptolib specific data here */
+#ifdef CRYSPR2
+    CRYSPR_AESCTX   aes_kek_buf;		/* Key Encrypting Key (KEK) */
+    CRYSPR_AESCTX   aes_sek_buf[2];		/* even/odd Stream Encrypting Key (SEK) */
+#endif
 } crysprOpenSSL_cb;
 
 
@@ -34,18 +39,21 @@ int crysprOpenSSL_Prng(unsigned char *rn, int len)
 }
 
 int crysprOpenSSL_AES_SetKey(
+    int cipher_type,            /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR] */
     bool bEncrypt,              /* true Enxcrypt key, false: decrypt */
     const unsigned char *kstr,  /* key sttring*/
     size_t kstr_len,            /* kstr len in  bytes (16, 24, or 32 bytes (for AES128,AES192, or AES256) */
     CRYSPR_AESCTX *aes_key)     /* CRYpto Service PRovider AES Key context */
 {
+    (void)cipher_type;
+
     if (bEncrypt) {        /* Encrypt key */
-        if (AES_set_encrypt_key(kstr, kstr_len * 8, aes_key)) {
+        if (AES_set_encrypt_key(kstr, (int)(kstr_len * 8), aes_key)) {
             HCRYPT_LOG(LOG_ERR, "%s", "AES_set_encrypt_key(kek) failed\n");
             return(-1);
         }
     } else {               /* Decrypt key */
-        if (AES_set_decrypt_key(kstr, kstr_len * 8, aes_key)) {
+        if (AES_set_decrypt_key(kstr, (int)(kstr_len * 8), aes_key)) {
             HCRYPT_LOG(LOG_ERR, "%s", "AES_set_decrypt_key(kek) failed\n");
             return(-1);
         }
@@ -123,7 +131,24 @@ int crysprOpenSSL_AES_CtrCipher(
 #endif
     return 0;
 }
+#ifdef CRYSPR2
+static CRYSPR_cb *crysprOpenSSL_Open(CRYSPR_methods *cryspr, size_t max_len)
+{
+    crysprOpenSSL_cb *aes_data;
+
+    aes_data = (crysprOpenSSL_cb *)crysprHelper_Open(cryspr, sizeof(crysprOpenSSL_cb), max_len);
+    if (NULL == aes_data) {
+        HCRYPT_LOG(LOG_ERR, "crysprHelper_Open(%p, %zd, %zd) failed\n", cryspr, sizeof(crysprOpenSSL_cb), max_len);
+        return(NULL);
+    }
+
+    aes_data->ccb.aes_kek = &aes_data->aes_kek_buf; //key encrypting key
+    aes_data->ccb.aes_sek[0] = &aes_data->aes_sek_buf[0]; //stream encrypting key
+    aes_data->ccb.aes_sek[1] = &aes_data->aes_sek_buf[1]; //stream encrypting key
 
+    return(&aes_data->ccb);
+}
+#endif /* CRYSPR2 */
 /*
 * Password-based Key Derivation Function
 */
@@ -138,7 +163,7 @@ int crysprOpenSSL_KmPbkdf2(
     unsigned char *out)     /* derived key */
 {
     (void)cryspr_cb;
-    int rc = PKCS5_PBKDF2_HMAC_SHA1(passwd,passwd_len,salt,salt_len,itr,key_len,out);
+    int rc = PKCS5_PBKDF2_HMAC_SHA1(passwd,(int)passwd_len,salt,(int)salt_len,itr,(int)key_len,out);
     return(rc == 1? 0 : -1);
 }
 
@@ -148,8 +173,7 @@ int crysprOpenSSL_KmWrap(CRYSPR_cb *cryspr_cb,
 		const unsigned char *sek,
         unsigned int seklen)
 {
-    crysprOpenSSL_cb *aes_data = (crysprOpenSSL_cb *)cryspr_cb;
-    AES_KEY *kek = &aes_data->ccb.aes_kek; //key encrypting key
+    AES_KEY *kek = CRYSPR_GETKEK(cryspr_cb); //key encrypting key
 
     return(((seklen + HAICRYPT_WRAPKEY_SIGN_SZ) == (unsigned int)AES_wrap_key(kek, NULL, wrap, sek, seklen)) ? 0 : -1);
 }
@@ -160,8 +184,7 @@ int crysprOpenSSL_KmUnwrap(
 		const unsigned char *wrap,
         unsigned int wraplen)
 {
-    crysprOpenSSL_cb *aes_data = (crysprOpenSSL_cb *)cryspr_cb;
-    AES_KEY *kek = &aes_data->ccb.aes_kek; //key encrypting key
+    AES_KEY *kek = CRYSPR_GETKEK(cryspr_cb); //key encrypting key
 
     return(((wraplen - HAICRYPT_WRAPKEY_SIGN_SZ) == (unsigned int)AES_unwrap_key(kek, NULL, sek, wrap, wraplen)) ? 0 : -1);
 }
@@ -192,7 +215,11 @@ CRYSPR_methods *crysprOpenSSL(void)
     #endif
 
     //--Crypto Session API-----------------------------------------
+#ifdef CRYSPR2
+        crysprOpenSSL_methods.open     = crysprOpenSSL_Open;
+#else
     //  crysprOpenSSL_methods.open     =
+#endif
     //  crysprOpenSSL_methods.close    =
     //--Keying material (km) encryption
 
diff --git a/haicrypt/cryspr.c b/haicrypt/cryspr.c
index 522d27cfe..a078aad73 100644
--- a/haicrypt/cryspr.c
+++ b/haicrypt/cryspr.c
@@ -14,9 +14,13 @@ written by
    Haivision Systems Inc.
 
    2019-06-28 (jdube)
-        CRYSPR/4SRT Initial implementation.
+		CRYSPR/4SRT Initial implementation.
 *****************************************************************************/
 
+#ifndef _WIN32
+#include <arpa/inet.h>  /* htonl */
+#endif
+
 #include "hcrypt.h"
 #include "cryspr.h"
 
@@ -25,109 +29,135 @@ written by
 
 int crysprStub_Prng(unsigned char *rn, int len)
 {
-    (void)rn;
-    (void)len;
-    return(0);
+	(void)rn;
+	(void)len;
+	return(0);
 }
 
 int crysprStub_AES_SetKey(
-    bool bEncrypt,              /* true Enxcrypt key, false: decrypt */
-    const unsigned char *kstr,  /* key sttring*/
-    size_t kstr_len,            /* kstr len in  bytes (16, 24, or 32 bytes (for AES128,AES192, or AES256) */
-    CRYSPR_AESCTX *aes_key)     /* Cryptolib Specific AES key context */
+	int cipher_type,            /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR|AESGDM] */
+	bool bEncrypt,              /* true Enxcrypt key, false: decrypt */
+	const unsigned char *kstr,  /* key sttring*/
+	size_t kstr_len,            /* kstr len in  bytes (16, 24, or 32 bytes (for AES128,AES192, or AES256) */
+	CRYSPR_AESCTX *aes_key)     /* Cryptolib Specific AES key context */
 {
-    (void)bEncrypt;
-    (void)kstr;
-    (void)kstr_len;
-    (void)aes_key;
+	(void)cipher_type;
+	(void)bEncrypt;
+	(void)kstr;
+	(void)kstr_len;
+	(void)aes_key;
 
-    return(0);
+	return(0);
 }
 
 int crysprStub_AES_EcbCipher(
-    bool bEncrypt,              /* true:encrypt, false:decrypt */
-    CRYSPR_AESCTX *aes_key,     /* AES context */
-    const unsigned char *indata,/* src (clear text)*/
-    size_t inlen,               /* length */
-    unsigned char *out_txt,     /* dst (cipher text) */
-    size_t *outlen)             /* dst len */
+	bool bEncrypt,              /* true:encrypt, false:decrypt */
+	CRYSPR_AESCTX *aes_key,     /* AES context */
+	const unsigned char *indata,/* src (clear text)*/
+	size_t inlen,               /* length */
+	unsigned char *out_txt,     /* dst (cipher text) */
+	size_t *outlen)             /* dst len */
 {
-    (void)bEncrypt;
-    (void)aes_key;
-    (void)indata;
-    (void)inlen;
-    (void)out_txt;
-    (void)outlen;
-
-    return -1;
+	(void)bEncrypt;
+	(void)aes_key;
+	(void)indata;
+	(void)inlen;
+	(void)out_txt;
+	(void)outlen;
+
+	return -1;
 }
 
 int crysprStub_AES_CtrCipher(
-    bool bEncrypt,              /* true:encrypt, false:decrypt */
-    CRYSPR_AESCTX *aes_key,     /* AES context */
-    unsigned char *iv,          /* iv */
-    const unsigned char *indata,/* src */
-    size_t inlen,               /* length */
-    unsigned char *out_txt)     /* dest */
+	bool bEncrypt,              /* true:encrypt, false:decrypt */
+	CRYSPR_AESCTX *aes_key,     /* AES context */
+	unsigned char *iv,          /* iv */
+	const unsigned char *indata,/* src */
+	size_t inlen,               /* length */
+	unsigned char *out_txt)     /* dest */
 {
-    (void)bEncrypt;
-    (void)aes_key;
-    (void)iv;
-    (void)indata;
-    (void)inlen;
-    (void)out_txt;
-
-    return(-1);
+	(void)bEncrypt;
+	(void)aes_key;
+	(void)iv;
+	(void)indata;
+	(void)inlen;
+	(void)out_txt;
+
+	return(-1);
+}
+
+int crysprStub_AES_GCMCipher(
+	bool bEncrypt,              /* true:encrypt, false:decrypt */
+	CRYSPR_AESCTX *aes_key,     /* AES context */
+	unsigned char *iv,          /* iv */
+	const unsigned char *aad,   /* associated data */
+	size_t aadlen,
+	const unsigned char * indata,
+	size_t inlen,
+	unsigned char *out_txt,
+	unsigned char* out_tag)
+{
+	(void)bEncrypt;
+	(void)aes_key;
+	(void)iv;
+	(void)aad;
+	(void)aadlen;
+	(void)indata;
+	(void)inlen;
+	(void)out_txt;
+	(void)out_tag;
+
+	return(-1);
 }
 
 unsigned char *crysprStub_SHA1_MsgDigest(
-    const unsigned char *m, /* in: message */
-    size_t m_len,           /* message length */
-    unsigned char *md)      /* out: message digest buffer *160 bytes */
+	const unsigned char *m, /* in: message */
+	size_t m_len,           /* message length */
+	unsigned char *md)      /* out: message digest buffer *160 bytes */
 {
-    (void)m;
-    (void)m_len;
-    (void)md;
+	(void)m;
+	(void)m_len;
+	(void)md;
 
-    return(NULL);//return md;
+	return(NULL);//return md;
 }
 
 /*
 * Password-based Key Derivation Function
 */
 int crysprStub_KmPbkdf2(
-    CRYSPR_cb *cryspr_cb,
-    char *passwd,           /* passphrase */
-    size_t passwd_len,      /* passphrase len */
-    unsigned char *salt,    /* salt */
-    size_t salt_len,        /* salt_len */
-    int itr,                /* iterations */
-    size_t key_len,         /* key_len */
-    unsigned char *out)     /* derived key */
+	CRYSPR_cb *cryspr_cb,
+	char *passwd,           /* passphrase */
+	size_t passwd_len,      /* passphrase len */
+	unsigned char *salt,    /* salt */
+	size_t salt_len,        /* salt_len */
+	int itr,                /* iterations */
+	size_t key_len,         /* key_len */
+	unsigned char *out)     /* derived key */
 {
-    (void)cryspr_cb;
-    (void)passwd;
-    (void)passwd_len;
-    (void)salt;
-    (void)salt_len;
-    (void)itr;
-    (void)key_len;
-    (void)out;
-
-    /* >>Todo:
-     * develop PBKDF2 using SHA1 primitive cryspr_cb->cryspr->sha1_msg_digest() for cryptolibs not providing it
-     */
-    return(-1);
+	(void)cryspr_cb;
+	(void)passwd;
+	(void)passwd_len;
+	(void)salt;
+	(void)salt_len;
+	(void)itr;
+	(void)key_len;
+	(void)out;
+
+	/* >>Todo:
+	 * develop PBKDF2 using SHA1 primitive cryspr_cb->cryspr->sha1_msg_digest() for cryptolibs not providing it
+	 */
+	return(-1);
 }
 
 static int crysprFallback_KmSetKey(CRYSPR_cb *cryspr_cb, bool bWrap, const unsigned char *kek, size_t kek_len)
 {
-	CRYSPR_AESCTX *aes_kek = &cryspr_cb->aes_kek;
+	CRYSPR_AESCTX *aes_kek = CRYSPR_GETKEK(cryspr_cb);
 
-    if (cryspr_cb->cryspr->aes_set_key(bWrap, kek, kek_len, aes_kek)) {
-        HCRYPT_LOG(LOG_ERR, "AES_set_%s_key(kek) failed\n", bWrap? "encrypt": "decrypt");
-        return(-1);
-    }
+	if (cryspr_cb->cryspr->aes_set_key(HCRYPT_CTX_MODE_AESECB, bWrap, kek, kek_len, aes_kek)) {
+		HCRYPT_LOG(LOG_ERR, "aes_set_%s_key(kek) failed\n", bWrap? "encrypt": "decrypt");
+		return(-1);
+	}
 	return(0);
 }
 
@@ -142,7 +172,7 @@ static const unsigned char default_iv[] = {
 int crysprFallback_AES_WrapKey(CRYSPR_cb *cryspr_cb,
 		unsigned char *out,
 		const unsigned char *in,
-        unsigned int inlen)
+		unsigned int inlen)
 {
 	unsigned char *A, B[16], *R;
 	const unsigned char *iv = default_iv;
@@ -163,7 +193,9 @@ int crysprFallback_AES_WrapKey(CRYSPR_cb *cryspr_cb,
 			memcpy(B + 8, R, 8);
 			{
 				size_t outlen = 16;
-				cryspr_cb->cryspr->aes_ecb_cipher(true, &cryspr_cb->aes_kek, B, 16, B, &outlen);
+				CRYSPR_AESCTX *aes_kek = CRYSPR_GETKEK(cryspr_cb);
+
+				cryspr_cb->cryspr->aes_ecb_cipher(true, aes_kek, B, 16, B, &outlen);
 			}
 			A[7] ^= (unsigned char)(t & 0xff);
 			if (t > 0xff)	
@@ -176,13 +208,13 @@ int crysprFallback_AES_WrapKey(CRYSPR_cb *cryspr_cb,
 		}
 	}
 	memcpy(out, A, 8);
-    return 0;
+	return 0;
 }
 
 int crysprFallback_AES_UnwrapKey(CRYSPR_cb *cryspr_cb,
 		unsigned char *out,
 		const unsigned char *in,
-        unsigned int inlen)
+		unsigned int inlen)
 {
 	unsigned char *A, B[16], *R;
 	const unsigned char *iv = default_iv;
@@ -211,7 +243,9 @@ int crysprFallback_AES_UnwrapKey(CRYSPR_cb *cryspr_cb,
 			memcpy(B + 8, R, 8);
 			{
 				size_t outlen = 16;
-				cryspr_cb->cryspr->aes_ecb_cipher(false, &cryspr_cb->aes_kek, B, 16, B, &outlen);
+				CRYSPR_AESCTX *aes_kek = CRYSPR_GETKEK(cryspr_cb);
+
+				cryspr_cb->cryspr->aes_ecb_cipher(false, aes_kek, B, 16, B, &outlen);
 			}
 			memcpy(R, B + 8, 8);
 		}
@@ -219,9 +253,9 @@ int crysprFallback_AES_UnwrapKey(CRYSPR_cb *cryspr_cb,
 	if (memcmp(A, iv, 8))
 	{
 		memset(out, 0, inlen);
-        return -1;
+		return -1;
 	}
-    return 0;
+	return 0;
 }
 
 static unsigned char *_crysprFallback_GetOutbuf(CRYSPR_cb *cryspr_cb, size_t pfx_len, size_t out_len)
@@ -237,20 +271,23 @@ static unsigned char *_crysprFallback_GetOutbuf(CRYSPR_cb *cryspr_cb, size_t pfx
 	return(out_buf);
 }
 
-static CRYSPR_cb *crysprFallback_Open(CRYSPR_methods *cryspr, size_t max_len)
+CRYSPR_cb *crysprHelper_Open(CRYSPR_methods *cryspr, size_t cb_len, size_t max_len)
 {
 	CRYSPR_cb *cryspr_cb;
 	unsigned char *membuf;
 	size_t memsiz, padded_len = hcryptMsg_PaddedLen(max_len, 128/8);
 
-	HCRYPT_LOG(LOG_DEBUG, "%s", "Using OpenSSL AES\n");
-
-	memsiz = sizeof(*cryspr_cb) + (CRYSPR_OUTMSGMAX * padded_len);
+	if(cb_len < sizeof(*cryspr_cb)) {
+		HCRYPT_LOG(LOG_ERR, "crysprHelper_Open() cb_len too small (%zd < %zd)n",
+				   cb_len, sizeof(*cryspr_cb));
+		return(NULL);
+	}
+	memsiz = cb_len + (CRYSPR_OUTMSGMAX * padded_len);
 #if !CRYSPR_HAS_AESCTR
 	memsiz += HCRYPT_CTR_STREAM_SZ;
 #endif /* !CRYSPR_HAS_AESCTR */
 
-	cryspr_cb = malloc(memsiz);
+	cryspr_cb = calloc(1, memsiz);
 	if (NULL == cryspr_cb) {
 		HCRYPT_LOG(LOG_ERR, "malloc(%zd) failed\n", memsiz);
 		return(NULL);
@@ -258,6 +295,9 @@ static CRYSPR_cb *crysprFallback_Open(CRYSPR_methods *cryspr, size_t max_len)
 	membuf = (unsigned char *)cryspr_cb;
 	membuf += sizeof(*cryspr_cb);
 
+	/*reserve cryspr's private data that caller will initialize */
+	membuf += (cb_len-sizeof(CRYSPR_cb));
+
 #if !CRYSPR_HAS_AESCTR
 	cryspr_cb->ctr_stream = membuf;
 	membuf += HCRYPT_CTR_STREAM_SZ;
@@ -275,24 +315,42 @@ static CRYSPR_cb *crysprFallback_Open(CRYSPR_methods *cryspr, size_t max_len)
 	return(cryspr_cb);
 }
 
-static int crysprFallback_Close(CRYSPR_cb *cryspr_cb)
+int crysprHelper_Close(CRYSPR_cb *cryspr_cb)
 {
 	free(cryspr_cb);
 	return(0);
 }
 
+static CRYSPR_cb *crysprFallback_Open(CRYSPR_methods *cryspr, size_t max_len)
+{
+	CRYSPR_cb *cryspr_cb;
+
+	cryspr_cb = crysprHelper_Open(cryspr, sizeof(CRYSPR_cb), max_len);
+	return(cryspr_cb);
+}
+
+static int crysprFallback_Close(CRYSPR_cb *cryspr_cb)
+{
+	return(crysprHelper_Close(cryspr_cb));
+}
+
 static int crysprFallback_MsSetKey(CRYSPR_cb *cryspr_cb, hcrypt_Ctx *ctx, const unsigned char *key, size_t key_len)
 {
-	CRYSPR_AESCTX *aes_sek = &cryspr_cb->aes_sek[hcryptCtx_GetKeyIndex(ctx)]; /* Ctx tells if it's for odd or even key */
+	CRYSPR_AESCTX *aes_sek = CRYSPR_GETSEK(cryspr_cb, hcryptCtx_GetKeyIndex(ctx)); /* Ctx tells if it's for odd or even key */
 
-	if ((ctx->flags & HCRYPT_CTX_F_ENCRYPT)        /* Encrypt key */
+	if (ctx->mode == HCRYPT_CTX_MODE_AESGCM) {   /* AES GCM mode */
+		if (cryspr_cb->cryspr->aes_set_key(HCRYPT_CTX_MODE_AESGCM, (ctx->flags & HCRYPT_CTX_F_ENCRYPT) != 0, key, key_len, aes_sek)) {
+			HCRYPT_LOG(LOG_ERR, "%s", "CRYSPR->set_encrypt_key(sek) failed\n");
+			return(-1);
+		}
+	} else if ((ctx->flags & HCRYPT_CTX_F_ENCRYPT)        /* Encrypt key */
 	||  (ctx->mode == HCRYPT_CTX_MODE_AESCTR)) {   /* CTR mode decrypts using encryption methods */
-		if (cryspr_cb->cryspr->aes_set_key(true, key, key_len, aes_sek)) {
+		if (cryspr_cb->cryspr->aes_set_key(HCRYPT_CTX_MODE_AESCTR, true, key, key_len, aes_sek)) {
 			HCRYPT_LOG(LOG_ERR, "%s", "CRYSPR->set_encrypt_key(sek) failed\n");
 			return(-1);
 		}
 	} else {                                       /* Decrypt key */
-		if (cryspr_cb->cryspr->aes_set_key(false, key, key_len, aes_sek)) {
+		if (cryspr_cb->cryspr->aes_set_key(HCRYPT_CTX_MODE_AESCTR, false, key, key_len, aes_sek)) {
 			HCRYPT_LOG(LOG_ERR, "%s", "CRYSPR->set_decrypt_key(sek) failed\n");
 			return(-1);
 		}
@@ -370,71 +428,67 @@ static int crysprFallback_MsEncrypt(
 	 * to reserve room for unencrypted message header in output buffer
 	 */
 	pfx_len = ctx->msg_info->pfx_len;
+	/* Extra 16 bytes are needed for an authentication tag in GCM. */
+	const int aux_len = (ctx->mode == HCRYPT_CTX_MODE_AESGCM) ? HAICRYPT_AUTHTAG_MAX : 0;
 
-	/* Get buffer room from the internal circular output buffer */
-	out_msg = _crysprFallback_GetOutbuf(cryspr_cb, pfx_len, in_data[0].len);
+	/* Auth tag produced by AES GCM. */
+	unsigned char tag[HAICRYPT_AUTHTAG_MAX];
+	/* Additional authenticated data used by AES-GCM. */
+	unsigned char aad[HAICRYPT_AAD_MAX];
 
-	if (NULL != out_msg) {
-		switch(ctx->mode) {
-			case HCRYPT_CTX_MODE_AESCTR: /* Counter mode */
+	/*
+	 * Get buffer room from the internal circular output buffer.
+	 * Reserve additional 16 bytes for auth tag in AES GCM mode when needed.
+	 */
+	out_msg = _crysprFallback_GetOutbuf(cryspr_cb, pfx_len, in_data[0].len + aux_len);
+	if (NULL == out_msg) {
+		/* input data too big */
+		return(-1);
+	}
+
+	switch(ctx->mode) {
+		case HCRYPT_CTX_MODE_AESCTR: /* Counter mode */
+		case HCRYPT_CTX_MODE_AESGCM:
+		{
+			/* Get current key (odd|even) from context */
+			CRYSPR_AESCTX *aes_key = CRYSPR_GETSEK(cryspr_cb, hcryptCtx_GetKeyIndex(ctx)); /* Ctx tells if it's for odd or even key */
+
+			unsigned char iv[CRYSPR_AESBLKSZ];
+
+			/* Get input packet index (in network order) */
+			hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
+
+			if (ctx->mode == HCRYPT_CTX_MODE_AESGCM)
 			{
-#if CRYSPR_HAS_AESCTR
-				/* Get current key (odd|even) from context */
-				CRYSPR_AESCTX *aes_key = &cryspr_cb->aes_sek[hcryptCtx_GetKeyIndex(ctx)];
-				unsigned char iv[CRYSPR_AESBLKSZ];
+				const bool old_aead = ctx->use_gcm_153; // SRT v1.5.2 to v1.5.3.
+				if (old_aead)
+				{
+					hcrypt_SetCtrIV((unsigned char*)&pki, ctx->salt, iv);
+					memcpy(aad, in_data[0].pfx, sizeof(aad));
+				}
+				else
+				{
+					hcrypt_SetGcmIV((unsigned char*)&pki, ctx->salt, iv);
 
-				/* Get input packet index (in network order) */
-				hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
+					for (size_t i = 0; i < sizeof(aad) / 4; ++i)
+						*((uint32_t*)aad + i) = htonl(*((uint32_t*)in_data[0].pfx + i));
+				}
 
-				/*
-				 * Compute the Initial Vector
-				 * IV (128-bit):
-				 *    0   1   2   3   4   5  6   7   8   9   10  11  12  13  14  15
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                   0s                  |      pki      |  ctr  |
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *                            XOR
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                         nonce                         +
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *
-				 * pki    (32-bit): packet index
-				 * ctr    (16-bit): block counter
-				 * nonce (112-bit): number used once (salt)
-				 */
+				const int iret = cryspr_cb->cryspr->aes_gcm_cipher(true, aes_key, iv, aad, sizeof(aad), in_data[0].payload, in_data[0].len,
+						&out_msg[pfx_len], tag);
+				if (iret) {
+					return(iret);
+				}
+			}
+			else {
 				hcrypt_SetCtrIV((unsigned char *)&pki, ctx->salt, iv);
-
+#if CRYSPR_HAS_AESCTR
 				cryspr_cb->cryspr->aes_ctr_cipher(true, aes_key, iv, in_data[0].payload, in_data[0].len,
 						&out_msg[pfx_len]);
 #else /*CRYSPR_HAS_AESCTR*/
-				/* Get current key (odd|even) from context */
-				CRYSPR_AESCTX *aes_key = &cryspr_cb->aes_sek[hcryptCtx_GetKeyIndex(ctx)];
-				unsigned char iv[CRYSPR_AESBLKSZ];
-				int iret = 0;
-
-				/* Get input packet index (in network order) */
-				hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
-
-				/*
-				 * Compute the Initial Vector
-				 * IV (128-bit):
-				 *    0   1   2   3   4   5  6   7   8   9   10  11  12  13  14  15
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                   0s                  |      pki      |  ctr  |
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *                            XOR
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                         nonce                         +
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *
-				 * pki    (32-bit): packet index
-				 * ctr    (16-bit): block counter
-				 * nonce (112-bit): number used once (salt)
-				 */
-				hcrypt_SetCtrIV((unsigned char *)&pki, ctx->salt, iv);
 
 				/* Create CtrStream. May be longer than in_len (next cryspr block size boundary) */
-				iret = _crysprFallback_AES_SetCtrStream(cryspr_cb, ctx, in_data[0].len, iv);
+				int iret = _crysprFallback_AES_SetCtrStream(cryspr_cb, ctx, in_data[0].len, iv);
 				if (iret) {
 					return(iret);
 				}
@@ -450,59 +504,29 @@ static int crysprFallback_MsEncrypt(
 					return(iret);
 				}
 #endif/*CRYSPR_HAS_AESCTR*/
-				/* Prepend packet prefix (clear text) in output buffer */
-				memcpy(out_msg, in_data[0].pfx, pfx_len);
-				/* CTR mode output length is same as input, no padding */
-				out_len = in_data[0].len;
-				break;
 			}
-			case HCRYPT_CTX_MODE_CLRTXT:    /* Clear text mode (transparent mode for tests) */
-				memcpy(&out_msg[pfx_len], in_data[0].payload, in_data[0].len);
-				memcpy(out_msg, in_data[0].pfx, pfx_len);
-				out_len = in_data[0].len;
-				break;
-			default:
-				/* Unsupported cipher mode */
-				return(-1);
+			/* Prepend packet prefix (clear text) in output buffer */
+			memcpy(out_msg, in_data[0].pfx, pfx_len);
+			/* CTR mode output length is same as input, no padding */
+			out_len = in_data[0].len;
+			if (ctx->mode == HCRYPT_CTX_MODE_AESGCM)
+			{
+				memcpy(out_msg + pfx_len + out_len, tag, sizeof(tag));
+				out_len += sizeof(tag);
+			}
+			break;
 		}
-	} else {
-		/* input data too big */
-		return(-1);
+		case HCRYPT_CTX_MODE_CLRTXT:    /* Clear text mode (transparent mode for tests) */
+			memcpy(&out_msg[pfx_len], in_data[0].payload, in_data[0].len);
+			memcpy(out_msg, in_data[0].pfx, pfx_len);
+			out_len = in_data[0].len;
+			break;
+		default:
+			/* Unsupported cipher mode */
+			return(-1);
 	}
 
-	if (out_len > 0) {
-		/* Encrypted messages have been produced */
-		if (NULL == out_p) {
-			/*
-			 * Application did not provided output buffer,
-			 * so copy encrypted message back in input buffer
-			 */
-			memcpy(in_data[0].pfx, out_msg, pfx_len);
-#if !CRYSPR_HAS_AESCTR
-			if (ctx->mode == HCRYPT_CTX_MODE_AESCTR) {
-				/* XOR KeyStream with input text directly in input buffer */
-				hcrypt_XorStream(in_data[0].payload, &out_msg[pfx_len], out_len);
-			}else{
-				/* Copy output data back in input buffer */
-				memcpy(in_data[0].payload, &out_msg[pfx_len], out_len);
-			}
-#else /* CRYSPR_HAS_AESCTR */
-			/* Copy output data back in input buffer */
-			memcpy(in_data[0].payload, &out_msg[pfx_len], out_len);
-#endif /* CRYSPR_HAS_AESCTR */
-		} else {
-			/* Copy header in output buffer if needed */
-			if (pfx_len > 0) memcpy(out_msg, in_data[0].pfx, pfx_len);
-#if !CRYSPR_HAS_AESCTR
-			if (ctx->mode == HCRYPT_CTX_MODE_AESCTR) {
-				hcrypt_XorStream(&out_msg[pfx_len], in_data[0].payload, out_len);
-			}
-#endif /* CRYSPR_HAS_AESCTR */
-			out_p[0] = out_msg;
-			out_len_p[0] = pfx_len + out_len;
-			*nbout_p = 1;
-		}
-	} else {
+	if (out_len <= 0) {
 		/*
 		 * Nothing out
 		 * This is not an error for implementations using deferred/async processing
@@ -512,6 +536,43 @@ static int crysprFallback_MsEncrypt(
 		if (nbout_p != NULL) *nbout_p = 0;
 		return(-1);
 	}
+
+	/* Encrypted messages have been produced */
+	if (NULL == out_p) {
+		/*
+			* Application did not provided output buffer,
+			* so copy encrypted message back in input buffer
+			*/
+		memcpy(in_data[0].pfx, out_msg, pfx_len);
+#if !CRYSPR_HAS_AESCTR
+		if (ctx->mode == HCRYPT_CTX_MODE_AESCTR) {
+			/* XOR KeyStream with input text directly in input buffer */
+			hcrypt_XorStream(in_data[0].payload, &out_msg[pfx_len], out_len);
+		}else{
+			/* Copy output data back in input buffer */
+			memcpy(in_data[0].payload, &out_msg[pfx_len], out_len);
+		}
+#else /* CRYSPR_HAS_AESCTR */
+			/* Copy output data back in input buffer */
+			memcpy(in_data[0].payload, &out_msg[pfx_len], out_len);
+			if (ctx->mode == HCRYPT_CTX_MODE_AESGCM) {
+				// Encoding produced more payload (auth tag).
+				return (int)out_len;
+			}
+#endif /* CRYSPR_HAS_AESCTR */
+	} else {
+		/* Copy header in output buffer if needed */
+		if (pfx_len > 0) memcpy(out_msg, in_data[0].pfx, pfx_len);
+#if !CRYSPR_HAS_AESCTR
+		if (ctx->mode == HCRYPT_CTX_MODE_AESCTR) {
+			hcrypt_XorStream(&out_msg[pfx_len], in_data[0].payload, out_len);
+		}
+#endif /* CRYSPR_HAS_AESCTR */
+		out_p[0] = out_msg;
+		out_len_p[0] = pfx_len + out_len;
+		*nbout_p = 1;
+	}
+
 	return(0);
 }
 
@@ -532,81 +593,89 @@ static int crysprFallback_MsDecrypt(CRYSPR_cb *cryspr_cb, hcrypt_Ctx *ctx,
 	if (NULL != out_txt) {
 		switch(ctx->mode) {
 			case HCRYPT_CTX_MODE_AESCTR:
+			case HCRYPT_CTX_MODE_AESGCM:
 			{
-#if CRYSPR_HAS_AESCTR
 				/* Get current key (odd|even) from context */
-				CRYSPR_AESCTX *aes_key = &cryspr_cb->aes_sek[hcryptCtx_GetKeyIndex(ctx)];
+				CRYSPR_AESCTX *aes_key = CRYSPR_GETSEK(cryspr_cb, hcryptCtx_GetKeyIndex(ctx));
 				unsigned char iv[CRYSPR_AESBLKSZ];
 
 				/* Get input packet index (in network order) */
 				hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
 
-				/*
-				 * Compute the Initial Vector
-				 * IV (128-bit):
-				 *    0   1   2   3   4   5  6   7   8   9   10  11  12  13  14  15
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                   0s                  |      pki      |  ctr  |
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *                            XOR
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                         nonce                         +
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *
-				 * pki    (32-bit): packet index
-				 * ctr    (16-bit): block counter
-				 * nonce (112-bit): number used once (salt)
-				 */
-				hcrypt_SetCtrIV((unsigned char *)&pki, ctx->salt, iv);
-
-				cryspr_cb->cryspr->aes_ctr_cipher(false, aes_key, iv, in_data[0].payload, in_data[0].len,
+				if (ctx->mode == HCRYPT_CTX_MODE_AESGCM)
+				{
+					/* Additional authenticated data used by AES-GCM. */
+					unsigned char aad[HAICRYPT_AAD_MAX];
+					const bool old_aead = ctx->use_gcm_153; // SRT v1.5.2 to v1.5.3.
+					if (old_aead)
+					{
+						hcrypt_SetCtrIV((unsigned char*)&pki, ctx->salt, iv);
+						memcpy(aad, in_data[0].pfx, sizeof(aad));
+					}
+					else
+					{
+						hcrypt_SetGcmIV((unsigned char*)&pki, ctx->salt, iv);
+
+						for (size_t i = 0; i < sizeof(aad) / 4; ++i)
+							*((uint32_t*)aad + i) = htonl(*((uint32_t*)in_data[0].pfx + i));
+					}
+
+					unsigned char* tag = in_data[0].payload + in_data[0].len - HAICRYPT_AUTHTAG_MAX;
+					int liret = cryspr_cb->cryspr->aes_gcm_cipher(false, aes_key, iv, aad, sizeof(aad), in_data[0].payload, in_data[0].len - HAICRYPT_AUTHTAG_MAX,
+						out_txt, tag);
+					if (liret) {
+						return(liret);
+					}
+					out_len = in_data[0].len - HAICRYPT_AUTHTAG_MAX;
+				}
+				else {
+					hcrypt_SetCtrIV((unsigned char*)&pki, ctx->salt, iv);
+#if CRYSPR_HAS_AESCTR
+					cryspr_cb->cryspr->aes_ctr_cipher(false, aes_key, iv, in_data[0].payload, in_data[0].len,
 						out_txt);
-				out_len = in_data[0].len;
+					out_len = in_data[0].len;
 #else  /*CRYSPR_HAS_AESCTR*/
-				/* Get current key (odd|even) from context */
-				CRYSPR_AESCTX *aes_key = &cryspr_cb->aes_sek[hcryptCtx_GetKeyIndex(ctx)];
-				unsigned char iv[CRYSPR_AESBLKSZ];
-				int iret = 0;
 
-				/* Get input packet index (in network order) */
-				hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
-
-				/*
-				 * Compute the Initial Vector
-				 * IV (128-bit):
-				 *    0   1   2   3   4   5  6   7   8   9   10  11  12  13  14  15
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                   0s                  |      pki      |  ctr  |
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *                            XOR
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 * |                         nonce                         +
-				 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-				 *
-				 * pki    (32-bit): packet index
-				 * ctr    (16-bit): block counter
-				 * nonce (112-bit): number used once (salt)
-				 */
-				hcrypt_SetCtrIV((unsigned char *)&pki, ctx->salt, iv);
-
-				/* Create CtrStream. May be longer than in_len (next cipher block size boundary) */
-				iret = _crysprFallback_AES_SetCtrStream(cryspr_cb, ctx, in_data[0].len, iv);
-				if (iret) {
-					return(iret);
-				}
-				/* Reserve output buffer for cryspr */
-				out_txt = _crysprFallback_GetOutbuf(cryspr_cb, 0, cryspr_cb->ctr_stream_len);
-
-				/* Create KeyStream (encrypt CtrStream) */
-				iret = cryspr_cb->cryspr->aes_ecb_cipher(true, aes_key,
+					/* Get input packet index (in network order) */
+					hcrypt_Pki pki = hcryptMsg_GetPki(ctx->msg_info, in_data[0].pfx, 1);
+
+					/*
+					 * Compute the Initial Vector
+					 * IV (128-bit):
+					 *    0   1   2   3   4   5  6   7   8   9   10  11  12  13  14  15
+					 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+					 * |                   0s                  |      pki      |  ctr  |
+					 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+					 *                            XOR
+					 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+					 * |                         nonce                         +
+					 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+					 *
+					 * pki    (32-bit): packet index
+					 * ctr    (16-bit): block counter
+					 * nonce (112-bit): number used once (salt)
+					 */
+					hcrypt_SetCtrIV((unsigned char*)&pki, ctx->salt, iv);
+
+					/* Create CtrStream. May be longer than in_len (next cipher block size boundary) */
+					int liret = _crysprFallback_AES_SetCtrStream(cryspr_cb, ctx, in_data[0].len, iv);
+					if (liret) {
+						return(liret);
+					}
+					/* Reserve output buffer for cryspr */
+					out_txt = _crysprFallback_GetOutbuf(cryspr_cb, 0, cryspr_cb->ctr_stream_len);
+
+					/* Create KeyStream (encrypt CtrStream) */
+					liret = cryspr_cb->cryspr->aes_ecb_cipher(true, aes_key,
 						cryspr_cb->ctr_stream, cryspr_cb->ctr_stream_len,
 						out_txt, &out_len);
-				if (iret) {
-					HCRYPT_LOG(LOG_ERR, "%s", "crysprNatural_AES_ecb_cipher(encrypt failed\n");
-					return(iret);
-				}
+					if (liret) {
+						HCRYPT_LOG(LOG_ERR, "%s", "crysprNatural_AES_ecb_cipher(encrypt failed\n");
+						return(liret);
+					}
 
 #endif /*CRYSPR_HAS_AESCTR*/
+				}
 				break;
 			}
 			case HCRYPT_CTX_MODE_CLRTXT:
@@ -637,6 +706,7 @@ static int crysprFallback_MsDecrypt(CRYSPR_cb *cryspr_cb, hcrypt_Ctx *ctx,
 #else /* CRYSPR_HAS_AESCTR */
 			/* Copy output data back in input buffer */
 			memcpy(in_data[0].payload, out_txt, out_len);
+			in_data->len = out_len;
 #endif /* CRYSPR_HAS_AESCTR */
 		} else {
 			/* Copy header in output buffer if needed */
@@ -682,9 +752,9 @@ CRYSPR_methods *crysprInit(CRYSPR_methods *cryspr)
 	cryspr->aes_set_key     = crysprStub_AES_SetKey;
 	cryspr->aes_ecb_cipher  = crysprStub_AES_EcbCipher;
 	cryspr->aes_ctr_cipher  = crysprStub_AES_CtrCipher;
+	cryspr->aes_gcm_cipher  = crysprStub_AES_GCMCipher;
 	cryspr->sha1_msg_digest = crysprStub_SHA1_MsgDigest;
 
-
 	/* Crypto Session API */
 	cryspr->open       = crysprFallback_Open;
 	cryspr->close      = crysprFallback_Close;
@@ -703,5 +773,5 @@ CRYSPR_methods *crysprInit(CRYSPR_methods *cryspr)
 
 HaiCrypt_Cryspr HaiCryptCryspr_Get_Instance(void)
 {
-    return((HaiCrypt_Cryspr)cryspr4SRT());
+	return((HaiCrypt_Cryspr)cryspr4SRT());
 }
diff --git a/haicrypt/cryspr.h b/haicrypt/cryspr.h
index 45a300fef..42426f422 100644
--- a/haicrypt/cryspr.h
+++ b/haicrypt/cryspr.h
@@ -39,24 +39,33 @@ extern "C" {
 #include "cryspr-config.h"
 
 typedef struct tag_CRYSPR_cb {
-	CRYSPR_AESCTX   aes_kek;		/* Key Encrypting Key (KEK) */
-	CRYSPR_AESCTX   aes_sek[2];		/* even/odd Stream Encrypting Key (SEK) */
-
-	struct tag_CRYSPR_methods *cryspr;
+#ifdef CRYSPR2
+    CRYSPR_AESCTX  *aes_kek;		/* Key Encrypting Key (KEK) */
+    CRYSPR_AESCTX  *aes_sek[2];		/* even/odd Stream Encrypting Key (SEK) */
+#define CRYSPR_GETKEK(cb)       ((cb)->aes_kek)
+#define CRYSPR_GETSEK(cb,kk)    ((cb)->aes_sek[kk])
+#else /*CRYSPR2*/
+    CRYSPR_AESCTX   aes_kek;		/* Key Encrypting Key (KEK) */
+    CRYSPR_AESCTX   aes_sek[2];		/* even/odd Stream Encrypting Key (SEK) */
+#define CRYSPR_GETKEK(cb)       (&((cb)->aes_kek))
+#define CRYSPR_GETSEK(cb,kk)    (&((cb)->aes_sek[kk]))
+#endif /*CRYSPR2*/
+
+    struct tag_CRYSPR_methods *cryspr;
 
 #if !CRYSPR_HAS_AESCTR
                                         /* Reserve room to build the counter stream ourself */
 #define HCRYPT_CTR_BLK_SZ       CRYSPR_AESBLKSZ
 #define HCRYPT_CTR_STREAM_SZ	2048
-	unsigned char * ctr_stream;
-	size_t          ctr_stream_len; /* Content size */
-	size_t          ctr_stream_siz; /* Allocated length */
+    unsigned char * ctr_stream;
+    size_t          ctr_stream_len; /* Content size */
+    size_t          ctr_stream_siz; /* Allocated length */
 #endif /* !CRYSPR_HAS_AESCTR */
 
 #define	CRYSPR_OUTMSGMAX		6
-	uint8_t *       outbuf; 		/* output circle buffer */
-	size_t          outbuf_ofs;		/* write offset in circle buffer */
-	size_t          outbuf_siz;		/* circle buffer size */
+    uint8_t *       outbuf; 		/* output circle buffer */
+    size_t          outbuf_ofs;		/* write offset in circle buffer */
+    size_t          outbuf_siz;		/* circle buffer size */
 } CRYSPR_cb;
 
 typedef struct tag_CRYSPR_methods {
@@ -69,6 +78,7 @@ typedef struct tag_CRYSPR_methods {
             int rn_len);
 
         int (*aes_set_key)(
+            int cipher_type,        /* One of HCRYPT_CTX_MODE_[CLRTXT|AESECB|AESCTR|AESGDM] */
             bool bEncrypt,          /* true Enxcrypt key, false: decrypt */
             const unsigned char *kstr,/* key string*/
             size_t kstr_len,        /* kstr len in  bytes (16, 24, or 32 bytes (for AES128,AES192, or AES256) */
@@ -90,6 +100,17 @@ typedef struct tag_CRYSPR_methods {
             size_t inlen,           /* src length */
             unsigned char *out_txt);/* dest */
 
+        int (*aes_gcm_cipher)(
+            bool bEncrypt,          /* true:encrypt false:decrypt (don't care with CTR) */
+            CRYSPR_AESCTX* aes_key, /* ctx */
+            unsigned char* iv,      /* iv */
+            const unsigned char* aad, /* associated data */
+            size_t aadlen,
+            const unsigned char* indata,  /* src (clear text) */
+            size_t inlen,           /* src length */
+            unsigned char* out_txt, /* dest */
+            unsigned char* out_tag);
+
         unsigned char *(*sha1_msg_digest)(
             const unsigned char *m, /* in: message */
             size_t m_len,           /* message length */
@@ -194,6 +215,9 @@ typedef struct tag_CRYSPR_methods {
 
 } CRYSPR_methods;
 
+CRYSPR_cb  *crysprHelper_Open(CRYSPR_methods *cryspr, size_t cb_len, size_t max_len);
+int         crysprHelper_Close(CRYSPR_cb *cryspr_cb);
+
 CRYSPR_methods *crysprInit(CRYSPR_methods *cryspr);
 
 #ifdef __cplusplus
diff --git a/haicrypt/filelist-botan.maf b/haicrypt/filelist-botan.maf
new file mode 100644
index 000000000..33b89119e
--- /dev/null
+++ b/haicrypt/filelist-botan.maf
@@ -0,0 +1,24 @@
+# HaiCrypt library contents
+
+PUBLIC HEADERS
+haicrypt.h
+hcrypt_ctx.h
+hcrypt_msg.h
+
+PRIVATE HEADERS
+hcrypt.h
+cryspr.h
+cryspr-botan.h
+haicrypt_log.h
+
+SOURCES
+cryspr.c
+cryspr-botan.c
+hcrypt.c
+hcrypt_ctx_rx.c
+hcrypt_ctx_tx.c
+hcrypt_rx.c
+hcrypt_sa.c
+hcrypt_tx.c
+hcrypt_xpt_srt.c
+haicrypt_log.cpp
diff --git a/haicrypt/filelist-openssl-evp.maf b/haicrypt/filelist-openssl-evp.maf
new file mode 100644
index 000000000..9548dc796
--- /dev/null
+++ b/haicrypt/filelist-openssl-evp.maf
@@ -0,0 +1,24 @@
+# HaiCrypt library contents
+
+PUBLIC HEADERS
+haicrypt.h
+hcrypt_ctx.h
+hcrypt_msg.h
+
+PRIVATE HEADERS
+hcrypt.h
+cryspr.h
+cryspr-openssl-evp.h
+haicrypt_log.h
+
+SOURCES
+cryspr.c
+cryspr-openssl-evp.c
+hcrypt.c
+hcrypt_ctx_rx.c
+hcrypt_ctx_tx.c
+hcrypt_rx.c
+hcrypt_sa.c
+hcrypt_tx.c
+hcrypt_xpt_srt.c
+haicrypt_log.cpp
diff --git a/haicrypt/haicrypt.h b/haicrypt/haicrypt.h
index 04eb18b76..da0ad3493 100644
--- a/haicrypt/haicrypt.h
+++ b/haicrypt/haicrypt.h
@@ -36,7 +36,8 @@ HaiCrypt_Cryspr HaiCryptCryspr_Get_Instance (void);     /* Return a default crys
 #define HAICRYPT_PWD_MAX_SZ         80  /* MAX password (for Password-based Key Derivation) */
 #define HAICRYPT_KEY_MAX_SZ         32  /* MAX key */
 #define HAICRYPT_SECRET_MAX_SZ      (HAICRYPT_PWD_MAX_SZ > HAICRYPT_KEY_MAX_SZ ? HAICRYPT_PWD_MAX_SZ : HAICRYPT_KEY_MAX_SZ)
-
+#define	HAICRYPT_AUTHTAG_MAX        16  /* maximum length of the auth tag (e.g. GCM) */
+#define	HAICRYPT_AAD_MAX            16  /* maximum length of the additional authenticated data (GCM mode) */
 
 #define HAICRYPT_SALT_SZ            16
 
@@ -60,6 +61,7 @@ typedef struct {
 #define HAICRYPT_CFG_F_TX       0x01        /* !TX -> RX */
 #define HAICRYPT_CFG_F_CRYPTO   0x02        /* Perform crypto Tx:Encrypt Rx:Decrypt */
 #define HAICRYPT_CFG_F_FEC      0x04        /* Do Forward Error Correction */
+#define HAICRYPT_CFG_F_GCM      0x08        /* Use AES-GCM */
         unsigned        flags;
 
         HaiCrypt_Secret secret;             /* Security Association */
@@ -95,6 +97,7 @@ typedef struct hcrypt_Session_str* HaiCrypt_Handle;
 int  HaiCrypt_SetLogLevel(int level, int logfa);
 
 int  HaiCrypt_Create(const HaiCrypt_Cfg *cfg, HaiCrypt_Handle *phhc);
+int  HaiCrypt_UpdateGcm153(HaiCrypt_Handle hhc, unsigned use_gcm_153);
 int  HaiCrypt_Clone(HaiCrypt_Handle hhcSrc, HaiCrypt_CryptoDir tx, HaiCrypt_Handle *phhc);
 int  HaiCrypt_Close(HaiCrypt_Handle hhc);
 int  HaiCrypt_Tx_GetBuf(HaiCrypt_Handle hhc, size_t data_len, unsigned char **in_p);
@@ -108,10 +111,15 @@ int  HaiCrypt_Tx_ManageKeys(HaiCrypt_Handle hhc, void *out_p[], size_t out_len_p
 int  HaiCrypt_Tx_Data(HaiCrypt_Handle hhc, unsigned char *pfx, unsigned char *data, size_t data_len);
 int  HaiCrypt_Rx_Data(HaiCrypt_Handle hhc, unsigned char *pfx, unsigned char *data, size_t data_len);
 
+/// @brief Check if the crypto service provider supports AES GCM.
+/// @return returns 1 if AES GCM is supported, 0 otherwise.
+int  HaiCrypt_IsAESGCM_Supported(void);
+
 /* Status values */
 
 #define HAICRYPT_ERROR -1
 #define HAICRYPT_ERROR_WRONG_SECRET -2
+#define HAICRYPT_ERROR_CIPHER -3
 #define HAICRYPT_OK 0
 
 
diff --git a/haicrypt/haicrypt_log.cpp b/haicrypt/haicrypt_log.cpp
index e09f1aeff..773507196 100644
--- a/haicrypt/haicrypt_log.cpp
+++ b/haicrypt/haicrypt_log.cpp
@@ -10,6 +10,8 @@
 
 #if ENABLE_HAICRYPT_LOGGING
 
+#include "haicrypt_log.h"
+
 #include "hcrypt.h"
 #include "haicrypt.h"
 #include "../srtcore/srt.h"
@@ -42,10 +44,10 @@ int HaiCrypt_SetLogLevel(int level, int logfa)
 #define HAICRYPT_DEFINE_LOG_DISPATCHER(LOGLEVEL, dispatcher) \
     int HaiCrypt_LogF_##LOGLEVEL ( const char* file, int line, const char* function, const char* format, ...) \
 { \
-    va_list ap; \
-    va_start(ap, format); \
     srt_logging::LogDispatcher& lg = hclog.dispatcher; \
     if (!lg.CheckEnabled()) return -1; \
+    va_list ap; \
+    va_start(ap, format); \
     lg().setloc(file, line, function).vform(format, ap); \
     va_end(ap); \
     return 0; \
@@ -97,12 +99,7 @@ void HaiCrypt_DumpConfig(const HaiCrypt_Cfg* cfg)
     LOGC(hclog.Debug, log << "CFG DUMP: flags=" << cfg_flags.str()
             << " xport=" << (cfg->xport == HAICRYPT_XPT_SRT ? "SRT" : "INVALID")
             << " cipher="
-            << (cfg->cipher == HaiCryptCipher_OpenSSL_EVP_CTR() ? "OSSL-EVP-CTR":
-                cfg->cipher == HaiCryptCipher_OpenSSL_AES() ? "OSSL-AES":
-                // This below is used as the only one when Nettle is used. When OpenSSL
-                // is used, one of the above will trigger, and the one below will then never trigger.
-                cfg->cipher == HaiCryptCipher_Get_Instance() ? "Nettle-AES":
-                "UNKNOWN")
+            << CRYSPR_IMPL_DESC
             << " key_len=" << cfg->key_len << " data_max_len=" << cfg->data_max_len);
 
 
diff --git a/haicrypt/haicrypt_log.h b/haicrypt/haicrypt_log.h
index 9655f722b..d788316bf 100644
--- a/haicrypt/haicrypt_log.h
+++ b/haicrypt/haicrypt_log.h
@@ -21,7 +21,7 @@ HAICRYPT_DECLARE_LOG_DISPATCHER(LOG_EMERG);
 
 #define HCRYPT_LOG_INIT()
 #define HCRYPT_LOG_EXIT()
-#define HCRYPT_LOG(lvl, fmt, ...) HaiCrypt_LogF_##lvl (__FILE__, __LINE__, __FUNCTION__, fmt, __VA_ARGS__)
+#define HCRYPT_LOG(lvl, ...) HaiCrypt_LogF_##lvl (__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
 
 #if ENABLE_HAICRYPT_LOGGING == 2
 #define HCRYPT_DEV 1
diff --git a/haicrypt/hcrypt.c b/haicrypt/hcrypt.c
index a94bd9af7..a2b81d832 100644
--- a/haicrypt/hcrypt.c
+++ b/haicrypt/hcrypt.c
@@ -156,7 +156,7 @@ int HaiCrypt_Create(const HaiCrypt_Cfg *cfg, HaiCrypt_Handle *phhc)
                 ||  hcryptCtx_Tx_Init(crypto, &crypto->ctx_pair[1], cfg)) {
             free(crypto);
             return(-1);
-        }			
+        }
         /* Generate keys for first (default) context */
         if (hcryptCtx_Tx_Rekey(crypto, &crypto->ctx_pair[0])) {
             free(crypto);
@@ -178,6 +178,18 @@ int HaiCrypt_Create(const HaiCrypt_Cfg *cfg, HaiCrypt_Handle *phhc)
     return(0);
 }
 
+int HaiCrypt_UpdateGcm153(HaiCrypt_Handle hhc, unsigned use_gcm_153)
+{
+    ASSERT(hhc != NULL);
+    hcrypt_Session* crypto = hhc;
+    if (!crypto)
+        return (-1);
+
+    crypto->ctx_pair[0].use_gcm_153 = use_gcm_153;
+    crypto->ctx_pair[1].use_gcm_153 = use_gcm_153;
+    return (0);
+}
+
 int HaiCrypt_ExtractConfig(HaiCrypt_Handle hhcSrc, HaiCrypt_Cfg* pcfg)
 {
     hcrypt_Session *crypto = (hcrypt_Session *)hhcSrc;
@@ -196,6 +208,9 @@ int HaiCrypt_ExtractConfig(HaiCrypt_Handle hhcSrc, HaiCrypt_Cfg* pcfg)
     pcfg->flags = HAICRYPT_CFG_F_CRYPTO;
     if ((ctx->flags & HCRYPT_CTX_F_ENCRYPT) == HCRYPT_CTX_F_ENCRYPT)
         pcfg->flags |= HAICRYPT_CFG_F_TX;
+   
+    if (ctx->mode == HCRYPT_CTX_MODE_AESGCM)
+        pcfg->flags |= HAICRYPT_CFG_F_GCM;
 
     /* Set this explicitly - this use of this library is SRT only. */
     pcfg->xport = HAICRYPT_XPT_SRT;
@@ -237,7 +252,8 @@ int HaiCrypt_Clone(HaiCrypt_Handle hhcSrc, HaiCrypt_CryptoDir tx, HaiCrypt_Handl
 
     if (tx) {
         HaiCrypt_Cfg crypto_config;
-        HaiCrypt_ExtractConfig(hhcSrc, &crypto_config);
+        if (-1 == HaiCrypt_ExtractConfig(hhcSrc, &crypto_config))
+            return -1;
 
         /*
          * Just invert the direction written in flags and use the
@@ -303,8 +319,7 @@ int HaiCrypt_Clone(HaiCrypt_Handle hhcSrc, HaiCrypt_CryptoDir tx, HaiCrypt_Handl
             return(-1);
         }
 
-
-        /* Configure contexts */
+        /* Configure contexts. Note that GCM mode has been already copied from the source context. */
         if (hcryptCtx_Rx_Init(cryptoClone, &cryptoClone->ctx_pair[0], NULL)
                 ||  hcryptCtx_Rx_Init(cryptoClone, &cryptoClone->ctx_pair[1], NULL)) {
             free(cryptoClone);
@@ -317,6 +332,7 @@ int HaiCrypt_Clone(HaiCrypt_Handle hhcSrc, HaiCrypt_CryptoDir tx, HaiCrypt_Handl
         cryptoClone->ctx_pair[1].flags &= ~HCRYPT_CTX_F_ENCRYPT;
         memset(cryptoClone->ctx_pair[0].salt, 0, sizeof(cryptoClone->ctx_pair[0].salt));
         cryptoClone->ctx_pair[0].salt_len = 0;
+        cryptoClone->ctx = &cryptoClone->ctx_pair[0];
     }
 
     *phhc = (void *)cryptoClone;
@@ -336,3 +352,12 @@ int HaiCrypt_Close(HaiCrypt_Handle hhc)
     HCRYPT_LOG_EXIT();
     return rc;
 }
+
+int  HaiCrypt_IsAESGCM_Supported(void)
+{
+#if CRYSPR_HAS_AESGCM
+    return 1;
+#else
+    return 0;
+#endif
+}
diff --git a/haicrypt/hcrypt.h b/haicrypt/hcrypt.h
index c4fbf87f9..e28a29777 100644
--- a/haicrypt/hcrypt.h
+++ b/haicrypt/hcrypt.h
@@ -32,10 +32,6 @@ written by
 #ifdef _WIN32
    #include <winsock2.h>
    #include <ws2tcpip.h>
-   #if defined(_MSC_VER)
-      #pragma warning(disable:4267)
-      #pragma warning(disable:4018)
-   #endif
 #else
    #include <sys/time.h>
 #endif
@@ -139,6 +135,25 @@ typedef struct hcrypt_Session_str {
             hcrypt_XorStream(&(iv)[0], (nonce), 112/8); \
         } while(0)
 
+/* HaiCrypt-TP GCM mode IV (96-bit) - SRT 1.5.4:
+ *    0   1   2   3   4   5  6   7   8   9   10  11 
+ * +---+---+---+---+---+---+---+---+---+---+---+---+
+ * |                   0s          |      pki      |
+ * +---+---+---+---+---+---+---+---+---+---+---+---+
+ *                         XOR                   
+ * +---+---+---+---+---+---+---+---+---+---+---+---+
+ * |                      nonce                    +
+ * +---+---+---+---+---+---+---+---+---+---+---+---+
+ *
+ * pki   (32-bit): packet index
+ * nonce (96-bit): number used once (salt)
+ */
+#define hcrypt_SetGcmIV(pki, nonce, iv) do { \
+            memset(&(iv)[0], 0, 96/8); \
+            memcpy(&(iv)[8], (pki), HCRYPT_PKI_SZ); \
+            hcrypt_XorStream(&(iv)[0], (nonce), 96/8); \
+        } while(0)
+
 #define hcrypt_XorStream(dst, strm, len) do { \
             int __XORSTREAMi; \
             for (__XORSTREAMi = 0 \
@@ -163,7 +178,18 @@ int hcryptCtx_Tx_AsmKM(hcrypt_Session *crypto, hcrypt_Ctx *ctx, unsigned char *a
 int hcryptCtx_Tx_ManageKM(hcrypt_Session *crypto);
 int hcryptCtx_Tx_InjectKM(hcrypt_Session *crypto, void *out_p[], size_t out_len_p[], int maxout);
 
+/// @brief Initialize receiving crypto context.
+/// @param crypto library instance handle.
+/// @param ctx additional crypto context.
+/// @param cfg crypto configuration.
+/// @return -1 on error, 0 otherwise.
 int hcryptCtx_Rx_Init(hcrypt_Session *crypto, hcrypt_Ctx *ctx, const HaiCrypt_Cfg *cfg);
+
+/// @brief Parse an incoming message related to cryptography module.
+/// @param crypto library instance handle.
+/// @param msg a message to parse.
+/// @param msg_len length of the message in bytes.
+/// @return 0 on success; -3 on cipher mode mismatch; -2 on unmatched shared secret; -1 on other failures.
 int hcryptCtx_Rx_ParseKM(hcrypt_Session *crypto, unsigned char *msg, size_t msg_len);
 
 #endif /* HCRYPT_H */
diff --git a/haicrypt/hcrypt_ctx.h b/haicrypt/hcrypt_ctx.h
index 9c60c0854..0d962c430 100644
--- a/haicrypt/hcrypt_ctx.h
+++ b/haicrypt/hcrypt_ctx.h
@@ -45,7 +45,7 @@ typedef struct {
 typedef struct tag_hcrypt_Ctx {
         struct tag_hcrypt_Ctx * alt;    /* Alternative ctx (even/odd) */
 
-#define HCRYPT_CTX_F_MSG        0x00FF  /* Aligned wiht message header flags */		
+#define HCRYPT_CTX_F_MSG        0x00FF  /* Aligned with message header flags */
 #define HCRYPT_CTX_F_eSEK       HCRYPT_MSG_F_eSEK
 #define HCRYPT_CTX_F_oSEK       HCRYPT_MSG_F_oSEK
 #define HCRYPT_CTX_F_xSEK       HCRYPT_MSG_F_xSEK
@@ -68,7 +68,9 @@ typedef struct tag_hcrypt_Ctx {
 #define HCRYPT_CTX_MODE_AESECB  1   /* Electronic Code Book mode */
 #define HCRYPT_CTX_MODE_AESCTR  2   /* Counter mode */
 #define HCRYPT_CTX_MODE_AESCBC  3   /* Cipher-block chaining mode */
+#define HCRYPT_CTX_MODE_AESGCM  4   /* AES GCM authenticated encryption */
         unsigned         mode;
+        bool             use_gcm_153; /* AES-GCM compatibility mode (SRT v1.5.3 and earlier) */
 
         struct {
             size_t       key_len;
diff --git a/haicrypt/hcrypt_ctx_rx.c b/haicrypt/hcrypt_ctx_rx.c
index 9bd8a8e63..2b67490d3 100644
--- a/haicrypt/hcrypt_ctx_rx.c
+++ b/haicrypt/hcrypt_ctx_rx.c
@@ -14,9 +14,9 @@ written by
    Haivision Systems Inc.
 
    2011-06-23 (jdube)
-        HaiCrypt initial implementation.
+		HaiCrypt initial implementation.
    2014-03-11 (jdube)
-        Adaptation for SRT.
+		Adaptation for SRT.
 *****************************************************************************/
 
 #include <string.h>				/* memcpy */
@@ -24,16 +24,18 @@ written by
 
 int hcryptCtx_Rx_Init(hcrypt_Session *crypto, hcrypt_Ctx *ctx, const HaiCrypt_Cfg *cfg)
 {
-    ctx->mode = HCRYPT_CTX_MODE_AESCTR;
-    ctx->status = HCRYPT_CTX_S_INIT;
-
-    ctx->msg_info = crypto->msg_info;
+	if (cfg) {
+		ctx->mode = (cfg->flags & HAICRYPT_CFG_F_GCM) ? HCRYPT_CTX_MODE_AESGCM : HCRYPT_CTX_MODE_AESCTR;
+	}
+	ctx->status = HCRYPT_CTX_S_INIT;
+	ctx->msg_info = crypto->msg_info;
+	ctx->use_gcm_153 = false; // Default initialization.
 
-    if (cfg && hcryptCtx_SetSecret(crypto, ctx, &cfg->secret)) {
-        return(-1);
-    }
-    ctx->status = HCRYPT_CTX_S_SARDY;
-    return(0);
+	if (cfg && hcryptCtx_SetSecret(crypto, ctx, &cfg->secret)) {
+		return(-1);
+	}
+	ctx->status = HCRYPT_CTX_S_SARDY;
+	return(0);
 }
 
 int hcryptCtx_Rx_Rekey(hcrypt_Session *crypto, hcrypt_Ctx *ctx, unsigned char *sek, size_t sek_len)
@@ -98,9 +100,31 @@ int hcryptCtx_Rx_ParseKM(hcrypt_Session *crypto, unsigned char *km_msg, size_t m
 		}
 
 		/* Check options support  */
-		if ((HCRYPT_CIPHER_AES_CTR != km_msg[HCRYPT_MSG_KM_OFS_CIPHER])
-		||  (HCRYPT_AUTH_NONE != km_msg[HCRYPT_MSG_KM_OFS_AUTH])) {
-			HCRYPT_LOG(LOG_WARNING, "%s", "KMmsg unsupported option\n");
+		if (HCRYPT_CIPHER_AES_CTR != km_msg[HCRYPT_MSG_KM_OFS_CIPHER]
+			&& HCRYPT_CIPHER_AES_GCM != km_msg[HCRYPT_MSG_KM_OFS_CIPHER])
+		{
+			HCRYPT_LOG(LOG_WARNING, "%s", "KMmsg unsupported cipher\n");
+			return(-1);
+		}
+
+#if !CRYSPR_HAS_AESGCM
+		/* Only OpenSSL EVP crypto provider allows the use of GCM.Add this condition. Reject if GCM is not supported by the CRYSPR. */
+		if (HCRYPT_CIPHER_AES_GCM == km_msg[HCRYPT_MSG_KM_OFS_CIPHER])
+		{
+			HCRYPT_LOG(LOG_WARNING, "%s", "KMmsg unsupported GCM cipher\n");
+			return(-1);
+		}
+#endif
+
+		if (HCRYPT_CIPHER_AES_GCM == km_msg[HCRYPT_MSG_KM_OFS_CIPHER]
+			&& HCRYPT_AUTH_AES_GCM != km_msg[HCRYPT_MSG_KM_OFS_AUTH]) {
+			HCRYPT_LOG(LOG_WARNING, "%s", "KMmsg GCM auth method was expected.\n");
+			return(-1);
+		}
+
+		if (HCRYPT_CIPHER_AES_CTR == km_msg[HCRYPT_MSG_KM_OFS_CIPHER]
+			&& HCRYPT_AUTH_NONE != km_msg[HCRYPT_MSG_KM_OFS_AUTH]) {
+			HCRYPT_LOG(LOG_WARNING, "%s", "KMmsg unsupported auth method\n");
 			return(-1);
 		}
 
@@ -144,6 +168,13 @@ int hcryptCtx_Rx_ParseKM(hcrypt_Session *crypto, unsigned char *km_msg, size_t m
 		do_pbkdf = 1; /* Impact on password derived kek */
 	}
 
+	/* Check cipher mode */
+	if (ctx->mode != km_msg[HCRYPT_MSG_KM_OFS_CIPHER])
+	{
+		HCRYPT_LOG(LOG_WARNING, "%s", "cipher mode mismatch\n");
+		return(-3);
+	}
+
 	/* 
 	 * Regenerate KEK if it is password derived
 	 * and Salt or SEK length changed
@@ -159,7 +190,7 @@ int hcryptCtx_Rx_ParseKM(hcrypt_Session *crypto, unsigned char *km_msg, size_t m
 	/* Unwrap SEK(s) and set in context */
 	if (0 > crypto->cryspr->km_unwrap(crypto->cryspr_cb, seks,
 		&km_msg[HCRYPT_MSG_KM_OFS_SALT + salt_len], 
-		(sek_cnt * sek_len) + HAICRYPT_WRAPKEY_SIGN_SZ)) {
+		(unsigned int)((sek_cnt * sek_len) + HAICRYPT_WRAPKEY_SIGN_SZ))) {
 		HCRYPT_LOG(LOG_WARNING, "%s", "unwrap key failed\n");
 		return(-2); //Report unmatched shared secret
 	}
@@ -184,7 +215,6 @@ int hcryptCtx_Rx_ParseKM(hcrypt_Session *crypto, unsigned char *km_msg, size_t m
 		alt->salt_len = salt_len;
 
 		if (kek_len) { /* New or changed KEK */
-//			memcpy(&alt->aes_kek, &ctx->aes_kek, sizeof(alt->aes_kek));
 			alt->status = HCRYPT_CTX_S_SARDY;
 		}
 
diff --git a/haicrypt/hcrypt_ctx_tx.c b/haicrypt/hcrypt_ctx_tx.c
index e518f5138..e66c9497b 100644
--- a/haicrypt/hcrypt_ctx_tx.c
+++ b/haicrypt/hcrypt_ctx_tx.c
@@ -14,18 +14,18 @@ written by
    Haivision Systems Inc.
 
    2011-06-23 (jdube)
-        HaiCrypt initial implementation.
+		HaiCrypt initial implementation.
    2014-03-11 (jdube)
-        Adaptation for SRT.
+		Adaptation for SRT.
 *****************************************************************************/
 
 #include <string.h>		/* memcpy */
 #ifdef _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    #include <win/wintime.h>
+	#include <winsock2.h>
+	#include <ws2tcpip.h>
+	#include <win/wintime.h>
 #else
-    #include <sys/time.h>
+	#include <sys/time.h>
 #endif
 #include "hcrypt.h"
 
@@ -33,9 +33,9 @@ int hcryptCtx_Tx_Init(hcrypt_Session *crypto, hcrypt_Ctx *ctx, const HaiCrypt_Cf
 {
 	ctx->cfg.key_len = cfg->key_len;
 
-	ctx->mode = HCRYPT_CTX_MODE_AESCTR;
+	ctx->mode = (cfg->flags & HAICRYPT_CFG_F_GCM) ? HCRYPT_CTX_MODE_AESGCM : HCRYPT_CTX_MODE_AESCTR;
 	ctx->status = HCRYPT_CTX_S_INIT;
-
+	ctx->use_gcm_153 = false; // Default initialization.
 	ctx->msg_info = crypto->msg_info;
 
 	if (hcryptCtx_SetSecret(crypto, ctx, &cfg->secret)) {
@@ -52,14 +52,14 @@ int hcryptCtx_Tx_Rekey(hcrypt_Session *crypto, hcrypt_Ctx *ctx)
 
 	/* Generate Salt */
 	ctx->salt_len = HAICRYPT_SALT_SZ;
-	if (0 > (iret = crypto->cryspr->prng(ctx->salt, ctx->salt_len))) {
+	if (0 > (iret = crypto->cryspr->prng(ctx->salt, (int)ctx->salt_len))) {
 		HCRYPT_LOG(LOG_ERR, "PRNG(salt[%zd]) failed\n", ctx->salt_len);
 		return(iret);
 	}
 
 	/* Generate SEK */
 	ctx->sek_len = ctx->cfg.key_len;
-	if (0 > (iret = crypto->cryspr->prng(ctx->sek, ctx->sek_len))) {
+	if (0 > (iret = crypto->cryspr->prng(ctx->sek, (int)ctx->sek_len))) {
 		HCRYPT_LOG(LOG_ERR, "PRNG(sek[%zd] failed\n", ctx->sek_len);
 		return(iret);
 	}
@@ -184,7 +184,6 @@ int hcryptCtx_Tx_Refresh(hcrypt_Session *crypto)
 	ASSERT(HCRYPT_CTX_S_SARDY <= new_ctx->status);
 
 	/* Keep same KEK, configuration, and salt */
-//	memcpy(&new_ctx->aes_kek, &ctx->aes_kek, sizeof(new_ctx->aes_kek));
 	memcpy(&new_ctx->cfg, &ctx->cfg, sizeof(new_ctx->cfg));
 
 	new_ctx->salt_len = ctx->salt_len;
@@ -195,7 +194,7 @@ int hcryptCtx_Tx_Refresh(hcrypt_Session *crypto)
 
 	HCRYPT_LOG(LOG_DEBUG, "refresh/generate SEK. salt_len=%d sek_len=%d\n", (int)new_ctx->salt_len, (int)new_ctx->sek_len);
 
-	if (0 > crypto->cryspr->prng(new_ctx->sek, new_ctx->sek_len)) {
+	if (0 > crypto->cryspr->prng(new_ctx->sek, (int)new_ctx->sek_len)) {
 		HCRYPT_LOG(LOG_ERR, "PRNG(sek[%zd] failed\n", new_ctx->sek_len);
 		return(-1);
 	}
@@ -299,9 +298,9 @@ int hcryptCtx_Tx_AsmKM(hcrypt_Session *crypto, hcrypt_Ctx *ctx, unsigned char *a
 		2 == sek_cnt ? HCRYPT_MSG_F_xSEK : (ctx->flags & HCRYPT_MSG_F_xSEK));
 
 	/* crypto->KMmsg_cache[4..7]: KEKI=0 */
-	km_msg[HCRYPT_MSG_KM_OFS_CIPHER] = HCRYPT_CIPHER_AES_CTR;
-	km_msg[HCRYPT_MSG_KM_OFS_AUTH] = HCRYPT_AUTH_NONE;
-	km_msg[HCRYPT_MSG_KM_OFS_SE] = crypto->se;
+	km_msg[HCRYPT_MSG_KM_OFS_CIPHER] = (ctx->mode == HCRYPT_CTX_MODE_AESGCM) ? HCRYPT_CIPHER_AES_GCM : HCRYPT_CIPHER_AES_CTR;
+	km_msg[HCRYPT_MSG_KM_OFS_AUTH] = (ctx->mode == HCRYPT_CTX_MODE_AESGCM) ? HCRYPT_AUTH_AES_GCM : HCRYPT_AUTH_NONE;
+	km_msg[HCRYPT_MSG_KM_OFS_SE] = (char) crypto->se;
 	hcryptMsg_KM_SetSaltLen(km_msg, ctx->salt_len);
 	hcryptMsg_KM_SetSekLen(km_msg, ctx->sek_len);
 
@@ -322,7 +321,7 @@ int hcryptCtx_Tx_AsmKM(hcrypt_Session *crypto, hcrypt_Ctx *ctx, unsigned char *a
 	}
 	if (0 > crypto->cryspr->km_wrap(crypto->cryspr_cb,
 		&km_msg[HCRYPT_MSG_KM_OFS_SALT + ctx->salt_len],
-		seks, sek_cnt * ctx->sek_len)) {
+		seks, (unsigned int)(sek_cnt * ctx->sek_len))) {
 
 		HCRYPT_LOG(LOG_ERR, "%s", "wrap key failed\n");
 		return(-1);
@@ -360,7 +359,7 @@ int hcryptCtx_Tx_ManageKM(hcrypt_Session *crypto)
 		 * prepare next SEK for announcement
 		 */
 		hcryptCtx_Tx_Refresh(crypto);
-
+		
 		HCRYPT_LOG(LOG_INFO, "KM[%d] Pre-announced\n",
 			(ctx->alt->flags & HCRYPT_CTX_F_xSEK)/2);
 
diff --git a/haicrypt/hcrypt_msg.h b/haicrypt/hcrypt_msg.h
index a915c2fa0..33a9522f9 100644
--- a/haicrypt/hcrypt_msg.h
+++ b/haicrypt/hcrypt_msg.h
@@ -122,8 +122,10 @@ typedef struct {
 #define HCRYPT_CIPHER_AES_ECB   1
 #define HCRYPT_CIPHER_AES_CTR   2
 #define HCRYPT_CIPHER_AES_CBC   3
+#define HCRYPT_CIPHER_AES_GCM   4
 
 #define HCRYPT_AUTH_NONE        0
+#define HCRYPT_AUTH_AES_GCM     1
 
 #define HCRYPT_SE_TSUDP         1
         hcrypt_MsgInfo *        hcryptMsg_STA_MsgInfo(void);
@@ -148,8 +150,8 @@ typedef struct {
 #define hcryptMsg_KM_GetSaltLen(msg)    (size_t)((msg)[HCRYPT_MSG_KM_OFS_SLEN] * 4)
 #define hcryptMsg_KM_GetSekLen(msg)     (size_t)((msg)[HCRYPT_MSG_KM_OFS_KLEN] * 4)
 
-#define hcryptMsg_KM_SetSaltLen(msg,len)do {(msg)[HCRYPT_MSG_KM_OFS_SLEN] = (len)/4;} while(0)
-#define hcryptMsg_KM_SetSekLen(msg,len) do {(msg)[HCRYPT_MSG_KM_OFS_KLEN] = (len)/4;} while(0)
+#define hcryptMsg_KM_SetSaltLen(msg,len)do {(msg)[HCRYPT_MSG_KM_OFS_SLEN] = (unsigned char)(len)/4;} while(0)
+#define hcryptMsg_KM_SetSekLen(msg,len) do {(msg)[HCRYPT_MSG_KM_OFS_KLEN] = (unsigned char)(len)/4;} while(0)
 
 
 #endif /* HCRYPT_MSG_H */
diff --git a/haicrypt/hcrypt_rx.c b/haicrypt/hcrypt_rx.c
index e77c73b35..68cb396f8 100644
--- a/haicrypt/hcrypt_rx.c
+++ b/haicrypt/hcrypt_rx.c
@@ -53,7 +53,7 @@ int HaiCrypt_Rx_Data(HaiCrypt_Handle hhc,
 		if (0 > (nb = crypto->cryspr->ms_decrypt(crypto->cryspr_cb, ctx, &indata, 1, NULL, NULL, NULL))) {
 			HCRYPT_LOG(LOG_ERR, "%s", "ms_decrypt failed\n");
 		} else {
-			nb = indata.len;
+			nb = (int)indata.len;
 		}
 	} else { /* No key received yet */
 		nb = 0;
@@ -124,9 +124,6 @@ int HaiCrypt_Rx_Process(HaiCrypt_Handle hhc,
 		||  (0 != memcmp(ctx->KMmsg_cache, in_msg, in_len))) { /* or different */
 
 			nbout = hcryptCtx_Rx_ParseKM(crypto, in_msg, in_len);
-			//-2: unmatched shared secret
-			//-1: other failures
-			//0: success
 		} else {
 			nbout = 0;
 		}
diff --git a/haicrypt/hcrypt_sa.c b/haicrypt/hcrypt_sa.c
index 995334d81..6884c76b1 100644
--- a/haicrypt/hcrypt_sa.c
+++ b/haicrypt/hcrypt_sa.c
@@ -37,7 +37,7 @@ int hcryptCtx_SetSecret(hcrypt_Session *crypto, hcrypt_Ctx *ctx, const HaiCrypt_
 		ctx->cfg.pwd_len = 0;
 		/* KEK: Key Encrypting Key */
 		if (0 > (iret = crypto->cryspr->km_setkey(crypto->cryspr_cb,
-							  (HCRYPT_CTX_F_ENCRYPT & ctx->flags ? true : false),
+							  ((HCRYPT_CTX_F_ENCRYPT & ctx->flags) ? true : false),
 							  secret->str, secret->len))) {
 			HCRYPT_LOG(LOG_ERR, "km_setkey(pdkek[%zd]) failed (rc=%d)\n", secret->len, iret);
 			return(-1);
@@ -87,7 +87,7 @@ int hcryptCtx_GenSecret(hcrypt_Session *crypto, hcrypt_Ctx *ctx)
 	HCRYPT_PRINTKEY(kek, kek_len, "kek");
 	
 	/* KEK: Key Encrypting Key */
-	if (0 > (iret = crypto->cryspr->km_setkey(crypto->cryspr_cb, (HCRYPT_CTX_F_ENCRYPT & ctx->flags ? true : false), kek, kek_len))) {
+	if (0 > (iret = crypto->cryspr->km_setkey(crypto->cryspr_cb, ((HCRYPT_CTX_F_ENCRYPT & ctx->flags) ? true : false), kek, kek_len))) {
 		HCRYPT_LOG(LOG_ERR, "km_setkey(pdkek[%zd]) failed (rc=%d)\n", kek_len, iret);
 		return(-1);
 	}
diff --git a/haicrypt/hcrypt_tx.c b/haicrypt/hcrypt_tx.c
index 85fc798cb..3472c625b 100644
--- a/haicrypt/hcrypt_tx.c
+++ b/haicrypt/hcrypt_tx.c
@@ -14,20 +14,20 @@ written by
    Haivision Systems Inc.
 
    2011-06-23 (jdube)
-        HaiCrypt initial implementation.
+		HaiCrypt initial implementation.
    2014-03-11 (jdube)
-        Adaptation for SRT.
+		Adaptation for SRT.
 *****************************************************************************/
 
 #include <sys/types.h>
 #include <stdlib.h>     /* NULL */
 #include <string.h>     /* memcpy */
 #ifdef _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    #include <stdint.h>
+	#include <winsock2.h>
+	#include <ws2tcpip.h>
+	#include <stdint.h>
 #else
-    #include <arpa/inet.h>  /* htonl */
+	#include <arpa/inet.h>  /* htonl */
 #endif
 #include "hcrypt.h"
 
@@ -52,29 +52,28 @@ int HaiCrypt_Tx_GetBuf(HaiCrypt_Handle hhc, size_t data_len, unsigned char **in_
 	return(crypto->msg_info->pfx_len);
 }
 
-int HaiCrypt_Tx_ManageKeys(HaiCrypt_Handle hhc, void *out_p[], size_t out_len_p[], int maxout) 
+int HaiCrypt_Tx_ManageKeys(HaiCrypt_Handle hhc, void *out_p[], size_t out_len_p[], int maxout)
 {
 	hcrypt_Session *crypto = (hcrypt_Session *)hhc;
-	hcrypt_Ctx *ctx = crypto->ctx;
 	int nbout = 0;
 
 	if ((NULL == crypto)
-	||  (NULL == ctx)
+	||  (NULL == crypto->ctx)
 	||  (NULL == out_p)
 	||  (NULL == out_len_p)) {
-		HCRYPT_LOG(LOG_ERR, "ManageKeys: invalid params: crypto=%p crypto->ctx=%p\n", crypto, ctx);
+		HCRYPT_LOG(LOG_ERR, "ManageKeys: invalid params: crypto=%p out_p=%p out_len_p=%p\n",
+				crypto, out_p, out_len_p);
 		return(-1);
 	}
 
 	/* Manage Key Material (refresh, announce, decommission) */
 	hcryptCtx_Tx_ManageKM(crypto);
 
-	ctx = crypto->ctx;
-	if (NULL == ctx) {
-		HCRYPT_LOG(LOG_ERR, "%s", "crypto context not defined\n");
+	if (NULL == crypto->ctx) {
+		HCRYPT_LOG(LOG_ERR, "%s", "crypto context NULL after ManageKM call\n");
 		return(-1);
 	}
-	ASSERT(ctx->status == HCRYPT_CTX_S_ACTIVE);
+	ASSERT(crypto->ctx->status == HCRYPT_CTX_S_ACTIVE);
 
 	nbout = hcryptCtx_Tx_InjectKM(crypto, out_p, out_len_p, maxout);
 	return(nbout);
@@ -83,30 +82,35 @@ int HaiCrypt_Tx_ManageKeys(HaiCrypt_Handle hhc, void *out_p[], size_t out_len_p[
 int HaiCrypt_Tx_GetKeyFlags(HaiCrypt_Handle hhc)
 {
 	hcrypt_Session *crypto = (hcrypt_Session *)hhc;
-	hcrypt_Ctx *ctx = crypto->ctx;
+	hcrypt_Ctx *ctx = NULL;
 
 	if ((NULL == crypto)
-	||  (NULL == ctx)){
+	||  (NULL == (ctx = crypto->ctx))) {
 		HCRYPT_LOG(LOG_ERR, "GetKeyFlags: invalid params: crypto=%p crypto->ctx=%p\n", crypto, ctx);
 		return(-1);
 	}
-	return(hcryptCtx_GetKeyFlags(ctx));
+	return(hcryptCtx_GetKeyFlags(crypto->ctx));
 }
 
-int HaiCrypt_Tx_Data(HaiCrypt_Handle hhc, 
-	unsigned char *in_pfx, unsigned char *in_data, size_t in_len) 
+int HaiCrypt_Tx_Data(HaiCrypt_Handle hhc,
+	unsigned char *in_pfx, unsigned char *in_data, size_t in_len)
 {
 	hcrypt_Session *crypto = (hcrypt_Session *)hhc;
-	hcrypt_Ctx *ctx = crypto->ctx;
+	hcrypt_Ctx *ctx = NULL;
 	int nbout = 0;
 
 	if ((NULL == crypto)
-	||  (NULL == ctx)){
+	||  (NULL == (ctx = crypto->ctx))) {
 		HCRYPT_LOG(LOG_ERR, "Tx_Data: invalid params: crypto=%p crypto->ctx=%p\n", crypto, ctx);
 		return(-1);
 	}
 	/* Get/Set packet index */
-	ctx->msg_info->indexMsg(in_pfx, ctx->MSpfx_cache); 
+	ctx->msg_info->indexMsg(in_pfx, ctx->MSpfx_cache);
+
+	if (hcryptMsg_GetKeyIndex(ctx->msg_info, in_pfx) != hcryptCtx_GetKeyIndex(ctx))
+	{
+		HCRYPT_LOG(LOG_ERR, "Tx_Data: Key mismatch!");
+	}
 
 	/* Encrypt */
 	{
@@ -125,16 +129,16 @@ int HaiCrypt_Tx_Data(HaiCrypt_Handle hhc,
 	return(nbout);
 }
 
-int HaiCrypt_Tx_Process(HaiCrypt_Handle hhc, 
-	unsigned char *in_msg, size_t in_len, 
+int HaiCrypt_Tx_Process(HaiCrypt_Handle hhc,
+	unsigned char *in_msg, size_t in_len,
 	void *out_p[], size_t out_len_p[], int maxout)
 {
 	hcrypt_Session *crypto = (hcrypt_Session *)hhc;
-	hcrypt_Ctx *ctx = crypto->ctx;
+	hcrypt_Ctx *ctx = NULL;
 	int nb, nbout = 0;
 
 	if ((NULL == crypto)
-	||  (NULL == ctx)
+	||  (NULL == (ctx = crypto->ctx))
 	||  (NULL == out_p)
 	||  (NULL == out_len_p)) {
 		HCRYPT_LOG(LOG_ERR, "Tx_Process: invalid params: crypto=%p crypto->ctx=%p\n", crypto, ctx);
@@ -144,11 +148,6 @@ int HaiCrypt_Tx_Process(HaiCrypt_Handle hhc,
 	/* Manage Key Material (refresh, announce, decommission) */
 	hcryptCtx_Tx_ManageKM(crypto);
 
-	ctx = crypto->ctx;
-	if (NULL == ctx) {
-		HCRYPT_LOG(LOG_ERR, "%s", "crypto context not defined\n");
-		return(-1);
-	}
 	ASSERT(ctx->status == HCRYPT_CTX_S_ACTIVE);
 
 	nbout += hcryptCtx_Tx_InjectKM(crypto, out_p, out_len_p, maxout);
diff --git a/scripts/CheckCXXAtomic.cmake b/scripts/CheckCXXAtomic.cmake
new file mode 100644
index 000000000..d3a3b9e71
--- /dev/null
+++ b/scripts/CheckCXXAtomic.cmake
@@ -0,0 +1,62 @@
+#
+# SRT - Secure, Reliable, Transport
+# Copyright (c) 2021 Haivision Systems Inc.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+# Check for c++11 std::atomic.
+#
+# Sets:
+#     HAVE_CXX_ATOMIC
+#     HAVE_CXX_ATOMIC_STATIC
+
+include(CheckCXXSourceCompiles)
+include(CheckLibraryExists)
+
+function(CheckCXXAtomic)
+
+   unset(HAVE_CXX_ATOMIC CACHE)
+   unset(HAVE_CXX_ATOMIC_STATIC CACHE)
+
+   unset(CMAKE_REQUIRED_FLAGS)
+   unset(CMAKE_REQUIRED_LIBRARIES)
+   unset(CMAKE_REQUIRED_LINK_OPTIONS)
+
+   set(CheckCXXAtomic_CODE
+      "
+      #include<cstdint>
+      #include<atomic>
+      int main(void)
+      {
+         std::atomic<std::ptrdiff_t> x(0);
+         std::atomic<std::intmax_t> y(0);
+         return x + y;
+      }
+      ")
+
+   set(CMAKE_REQUIRED_FLAGS "-std=c++11")
+
+   check_cxx_source_compiles(
+      "${CheckCXXAtomic_CODE}"
+      HAVE_CXX_ATOMIC)
+
+   if(HAVE_CXX_ATOMIC)
+      # CMAKE_REQUIRED_LINK_OPTIONS was introduced in CMake 3.14.
+      if(CMAKE_VERSION VERSION_LESS "3.14")
+         set(CMAKE_REQUIRED_LINK_OPTIONS "-static")
+      else()
+         set(CMAKE_REQUIRED_FLAGS "-std=c++11 -static")
+      endif()
+      check_cxx_source_compiles(
+         "${CheckCXXAtomic_CODE}"
+         HAVE_CXX_ATOMIC_STATIC)
+   endif()
+
+   unset(CMAKE_REQUIRED_FLAGS)
+   unset(CMAKE_REQUIRED_LIBRARIES)
+   unset(CMAKE_REQUIRED_LINK_OPTIONS)
+
+endfunction(CheckCXXAtomic)
diff --git a/scripts/CheckCXXStdPutTime.cmake b/scripts/CheckCXXStdPutTime.cmake
new file mode 100644
index 000000000..7f15ae09f
--- /dev/null
+++ b/scripts/CheckCXXStdPutTime.cmake
@@ -0,0 +1,57 @@
+#
+# SRT - Secure, Reliable, Transport Copyright (c) 2022 Haivision Systems Inc.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# v. 2.0. If a copy of the MPL was not distributed with this file, You can
+# obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+# Check for C++11 std::put_time().
+#
+# Sets:
+#   HAVE_CXX_STD_PUT_TIME
+
+include(CheckCSourceCompiles)
+
+function(CheckCXXStdPutTime)
+
+   unset(HAVE_CXX_STD_PUT_TIME CACHE)
+
+   set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) # CMake 3.6
+
+   unset(CMAKE_REQUIRED_FLAGS)
+   unset(CMAKE_REQUIRED_LIBRARIES)
+   unset(CMAKE_REQUIRED_LINK_OPTIONS)
+
+   set(CheckCXXStdPutTime_CODE
+      "
+      #include <iostream>
+      #include <iomanip>
+      #include <ctime>
+      int main(void)
+      {
+         const int result = 0;
+         std::time_t t = std::time(nullptr);
+         std::tm tm = *std::localtime(&t);
+         std::cout
+            << std::put_time(&tm, \"%FT%T\")
+            << std::setfill('0')
+            << std::setw(6)
+            << std::endl;
+         return result;
+      }
+      "
+   )
+
+   # NOTE: Should we set -std or use the current compiler configuration.
+   #     It seems that the top level build does not track the compiler
+   #     in a consistent manner. So Maybe we need this?
+   set(CMAKE_REQUIRED_FLAGS "-std=c++11")
+
+   # Check that the compiler can build the std::put_time() example:
+   message(STATUS "Checking for C++ 'std::put_time()':")
+   check_cxx_source_compiles(
+      "${CheckCXXStdPutTime_CODE}"
+      HAVE_CXX_STD_PUT_TIME)
+
+endfunction(CheckCXXStdPutTime)
diff --git a/scripts/CheckGCCAtomicIntrinsics.cmake b/scripts/CheckGCCAtomicIntrinsics.cmake
new file mode 100644
index 000000000..7952dd750
--- /dev/null
+++ b/scripts/CheckGCCAtomicIntrinsics.cmake
@@ -0,0 +1,113 @@
+#
+# SRT - Secure, Reliable, Transport Copyright (c) 2021 Haivision Systems Inc.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# v. 2.0. If a copy of the MPL was not distributed with this file, You can
+# obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+# Check for GCC Atomic Intrinsics and whether libatomic is required.
+#
+# Sets:
+#	HAVE_LIBATOMIC
+#	HAVE_LIBATOMIC_COMPILES
+#	HAVE_LIBATOMIC_COMPILES_STATIC
+#	HAVE_GCCATOMIC_INTRINSICS
+#	HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC
+#
+# See
+#	https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
+#	https://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync
+
+include(CheckCSourceCompiles)
+include(CheckLibraryExists)
+
+function(CheckGCCAtomicIntrinsics)
+
+	unset(HAVE_LIBATOMIC CACHE)
+	unset(HAVE_LIBATOMIC_COMPILES CACHE)
+	unset(HAVE_LIBATOMIC_COMPILES_STATIC CACHE)
+	unset(HAVE_GCCATOMIC_INTRINSICS CACHE)
+	unset(HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC CACHE)
+
+	set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) # CMake 3.6
+
+	unset(CMAKE_REQUIRED_FLAGS)
+	unset(CMAKE_REQUIRED_LIBRARIES)
+	unset(CMAKE_REQUIRED_LINK_OPTIONS)
+
+	# Check for existence of libatomic and whether this symbol is present.
+	check_library_exists(atomic __atomic_fetch_add_8 "" HAVE_LIBATOMIC)
+
+	set(CheckLibAtomicCompiles_CODE
+		"
+		int main(void)
+		{
+			const int result = 0;
+			return result;
+		}
+	")
+
+	set(CMAKE_REQUIRED_LIBRARIES "atomic")
+
+	# Check that the compiler can build a simple application and link with
+	# libatomic.
+	check_c_source_compiles("${CheckLibAtomicCompiles_CODE}"
+							HAVE_LIBATOMIC_COMPILES)
+	if(NOT HAVE_LIBATOMIC_COMPILES)
+		set(HAVE_LIBATOMIC
+			0
+			CACHE INTERNAL "" FORCE)
+	endif()
+	if(HAVE_LIBATOMIC AND HAVE_LIBATOMIC_COMPILES)
+		# CMAKE_REQUIRED_LINK_OPTIONS was introduced in CMake 3.14.
+		if(CMAKE_VERSION VERSION_LESS "3.14")
+			set(CMAKE_REQUIRED_LINK_OPTIONS "-static")
+		else()
+			set(CMAKE_REQUIRED_FLAGS "-static")
+	endif()
+	# Check that the compiler can build a simple application and statically link
+	# with libatomic.
+	check_c_source_compiles("${CheckLibAtomicCompiles_CODE}"
+							HAVE_LIBATOMIC_COMPILES_STATIC)
+	else()
+		set(HAVE_LIBATOMIC_COMPILES_STATIC
+			0
+			CACHE INTERNAL "" FORCE)
+	endif()
+
+	unset(CMAKE_REQUIRED_FLAGS)
+	unset(CMAKE_REQUIRED_LIBRARIES)
+	unset(CMAKE_REQUIRED_LINK_OPTIONS)
+
+	set(CheckGCCAtomicIntrinsics_CODE
+		"
+		#include<stddef.h>
+		#include<stdint.h>
+		int main(void)
+		{
+			ptrdiff_t x = 0;
+			intmax_t y = 0;
+			__atomic_add_fetch(&x, 1, __ATOMIC_SEQ_CST);
+			__atomic_add_fetch(&y, 1, __ATOMIC_SEQ_CST);
+			return __atomic_sub_fetch(&x, 1, __ATOMIC_SEQ_CST)
+				+ __atomic_sub_fetch(&y, 1, __ATOMIC_SEQ_CST);
+		}
+	")
+
+	set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) # CMake 3.6
+	check_c_source_compiles("${CheckGCCAtomicIntrinsics_CODE}"
+							HAVE_GCCATOMIC_INTRINSICS)
+
+	if(NOT HAVE_GCCATOMIC_INTRINSICS AND HAVE_LIBATOMIC)
+		set(CMAKE_REQUIRED_LIBRARIES "atomic")
+		check_c_source_compiles("${CheckGCCAtomicIntrinsics_CODE}"
+							HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC)
+		if(HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC)
+			set(HAVE_GCCATOMIC_INTRINSICS
+				1
+				CACHE INTERNAL "" FORCE)
+		endif()
+	endif()
+
+endfunction(CheckGCCAtomicIntrinsics)
diff --git a/scripts/FindBotan.cmake b/scripts/FindBotan.cmake
new file mode 100644
index 000000000..01930170c
--- /dev/null
+++ b/scripts/FindBotan.cmake
@@ -0,0 +1,142 @@
+## This script was taken from https://github.com/Tectu/botan-cmake and modified slightly for SRT integration.
+##
+## This module will automagically download the tarball of the specified Botan version and invoke the configure.py
+## python script to generate the amalgamation files (botan_all.cpp and botan_all.h).
+##
+## Usage:
+##   find_package(
+##       Botan 3.0.0
+##       COMPONENTS
+##           system_rng
+##           argon2
+##           sha3
+##       REQUIRED
+##    )
+##
+##    target_link_libraries(
+##        MyTarget
+##        PRIVATE
+##            botan
+##    )
+##
+
+cmake_minimum_required(VERSION 3.19)
+include(FetchContent)
+
+# Find python
+find_package(
+    Python
+    COMPONENTS
+        Interpreter
+    REQUIRED
+)
+
+# Assemble version string
+set(Botan_VERSION_STRING ${Botan_FIND_VERSION_MAJOR}.${Botan_FIND_VERSION_MINOR}.${Botan_FIND_VERSION_PATCH})
+
+# Assemble download URL
+set(DOWNLOAD_URL https://github.com/randombit/botan/archive/refs/tags/${Botan_VERSION_STRING}.tar.gz)
+
+# Just do a dummy download to see whether we can download the tarball
+file(
+    DOWNLOAD
+    ${DOWNLOAD_URL}
+    STATUS download_status
+)
+if (NOT download_status EQUAL 0)
+    message(FATAL_ERROR "Could not download Botan tarball (status = ${download_status}): ${DOWNLOAD_URL}")
+endif()
+
+# Download the tarball
+FetchContent_Declare(
+    botan_upstream
+    URL ${DOWNLOAD_URL}
+    DOWNLOAD_EXTRACT_TIMESTAMP true
+)
+FetchContent_MakeAvailable(botan_upstream)
+
+# Heavy lifting by cmake
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Botan DEFAULT_MSG Botan_VERSION_STRING)
+
+## Function to generate a target named 'TARGET_NAME' with specific Botan modules enabled.
+function(botan_generate TARGET_NAME MODULES)
+    # The last N arguments are considered to be the modules list.
+    # Here, we collect those in a list and join them with a comma separator ready to be passed to the configure.py script.
+    foreach(module_index RANGE 1 ${ARGC}-2)
+        list(APPEND modules_list ${ARGV${module_index}})
+    endforeach()
+    list(JOIN modules_list "," ENABLE_MODULES_LIST)
+
+    # Determine botan compiler ID (--cc parameter of configure.py)
+    set(BOTAN_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
+    string(TOLOWER ${BOTAN_COMPILER_ID} BOTAN_COMPILER_ID)
+    if (BOTAN_COMPILER_ID STREQUAL "gnu")
+        set(BOTAN_COMPILER_ID "gcc")
+    endif()
+
+    # Run the configure.py script
+    add_custom_command(
+        OUTPUT botan_all.cpp botan_all.h
+        COMMENT "Generating Botan amalgamation files botan_all.cpp and botan_all.h"
+        COMMAND ${Python_EXECUTABLE}
+            ${botan_upstream_SOURCE_DIR}/configure.py
+            --quiet
+            --cc-bin=${CMAKE_CXX_COMPILER}
+            --cc=${BOTAN_COMPILER_ID}
+            --disable-cc-tests
+            --os=${BOTAN_OS}
+            --cpu=${BOTAN_CPU}
+            --disable-shared
+            --amalgamation
+            --with-build-dir=botan
+            --minimized-build
+            --enable-modules=${ENABLE_MODULES_LIST}
+    )
+
+    # Create target
+    set(TARGET ${TARGET_NAME})
+    add_library(${TARGET} STATIC)
+    target_sources(
+        ${TARGET}
+        PUBLIC
+            ${CMAKE_CURRENT_BINARY_DIR}/botan_all.h
+        PRIVATE
+            ${CMAKE_CURRENT_BINARY_DIR}/botan_all.cpp
+    )
+    target_include_directories(
+        ${TARGET}
+        INTERFACE
+            ${CMAKE_CURRENT_BINARY_DIR}
+    )
+    set_target_properties(
+        ${TARGET}
+        PROPERTIES
+            POSITION_INDEPENDENT_CODE ON
+    )
+
+    add_custom_command(
+        TARGET ${TARGET_NAME}
+        COMMENT "Copying build.h file"
+        COMMAND ${CMAKE_COMMAND} -E copy    
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/build/build.h"        
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/build.h"    
+    )
+
+    add_custom_command(
+        TARGET ${TARGET_NAME}
+        COMMENT "Copying compiler.h file"
+        COMMAND ${CMAKE_COMMAND} -E copy    
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/build/include/botan/compiler.h"        
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/compiler.h"    
+    )
+
+    add_custom_command(
+        TARGET ${TARGET_NAME}
+        COMMENT "Copying ffi.h file"
+        COMMAND ${CMAKE_COMMAND} -E copy    
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/build/include/botan/ffi.h"        
+        "${CMAKE_CURRENT_BINARY_DIR}/botan/ffi.h"    
+    )
+
+endfunction()
diff --git a/scripts/FindMbedTLS.cmake b/scripts/FindMbedTLS.cmake
index 7dca6e47e..662255622 100644
--- a/scripts/FindMbedTLS.cmake
+++ b/scripts/FindMbedTLS.cmake
@@ -111,5 +111,5 @@ endif()
 
 # Now we've accounted for the 3-vs-1 library case:
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libmbedtls DEFAULT_MSG MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
+find_package_handle_standard_args(MbedTLS DEFAULT_MSG MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
 mark_as_advanced(MBEDTLS_INCLUDE_DIR MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
diff --git a/scripts/FindPThreadGetSetName.cmake b/scripts/FindPThreadGetSetName.cmake
new file mode 100644
index 000000000..65685e1eb
--- /dev/null
+++ b/scripts/FindPThreadGetSetName.cmake
@@ -0,0 +1,73 @@
+#
+# SRT - Secure, Reliable, Transport
+# Copyright (c) 2021 Haivision Systems Inc.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+# Check for pthread_getname_np(3) and pthread_setname_np(3)
+#    used in srtcore/threadname.h.
+#
+# Some BSD distros need to include <pthread_np.h> for pthread_getname_np().
+#
+# TODO: Some BSD distros have pthread_get_name_np() and pthread_set_name_np()
+#     instead of pthread_getname_np() and pthread_setname_np().
+#
+# Sets:
+#     HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H
+#     HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H
+#     HAVE_PTHREAD_GETNAME_NP
+#     HAVE_PTHREAD_SETNAME_NP
+# Sets as appropriate:
+#     add_definitions(-DHAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H=1)
+#     add_definitions(-DHAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H=1)
+#     add_definitions(-DHAVE_PTHREAD_GETNAME_NP=1)
+#     add_definitions(-DHAVE_PTHREAD_SETNAME_NP=1)
+
+include(CheckSymbolExists)
+
+function(FindPThreadGetSetName)
+
+   unset(HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H CACHE)
+   unset(HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H CACHE)
+   unset(HAVE_PTHREAD_GETNAME_NP CACHE)
+   unset(HAVE_PTHREAD_SETNAME_NP CACHE)
+
+   set(CMAKE_REQUIRED_DEFINITIONS
+      -D_GNU_SOURCE -D_DARWIN_C_SOURCE -D_POSIX_SOURCE=1)
+   set(CMAKE_REQUIRED_FLAGS "-pthread")
+
+   message(STATUS "Checking for pthread_(g/s)etname_np in 'pthread_np.h':")
+   check_symbol_exists(
+      pthread_getname_np "pthread_np.h" HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H)
+   if (HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H)
+      add_definitions(-DHAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H=1)
+   endif()
+   check_symbol_exists(
+      pthread_setname_np "pthread_np.h" HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H)
+   if (HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H)
+      add_definitions(-DHAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H=1)
+   endif()
+
+   message(STATUS "Checking for pthread_(g/s)etname_np in 'pthread.h':")
+   check_symbol_exists(pthread_getname_np "pthread.h" HAVE_PTHREAD_GETNAME_NP)
+   if (HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H)
+      set(HAVE_PTHREAD_GETNAME_NP 1 CACHE INTERNAL "" FORCE)
+   endif()
+   check_symbol_exists(pthread_setname_np "pthread.h" HAVE_PTHREAD_SETNAME_NP)
+   if (HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H)
+      set(HAVE_PTHREAD_SETNAME_NP 1 CACHE INTERNAL "" FORCE)
+   endif()
+   if (HAVE_PTHREAD_GETNAME_NP)
+      add_definitions(-DHAVE_PTHREAD_GETNAME_NP=1)
+   endif()
+   if (HAVE_PTHREAD_SETNAME_NP)
+      add_definitions(-DHAVE_PTHREAD_SETNAME_NP=1)
+   endif()
+
+   unset(CMAKE_REQUIRED_DEFINITIONS)
+   unset(CMAKE_REQUIRED_FLAGS)
+
+endfunction(FindPThreadGetSetName)
diff --git a/scripts/ShowProjectConfig.cmake b/scripts/ShowProjectConfig.cmake
new file mode 100644
index 000000000..108dde5db
--- /dev/null
+++ b/scripts/ShowProjectConfig.cmake
@@ -0,0 +1,192 @@
+#
+# SRT - Secure, Reliable, Transport Copyright (c) 2021 Haivision Systems Inc.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# v. 2.0. If a copy of the MPL was not distributed with this file, You can
+# obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+function(ShowProjectConfig)
+
+   set(__ssl_configuration)
+   if (SSL_FOUND OR SSL_LIBRARIES)
+      set(__ssl_configuration
+      "    SSL Configuration:
+      SSL_FOUND=${SSL_FOUND}
+      SSL_INCLUDE_DIRS=${SSL_INCLUDE_DIRS}
+      SSL_LIBRARIES=${SSL_LIBRARIES}
+      SSL_VERSION=${SSL_VERSION}\n")
+   endif()
+
+   set(static_property_link_libraries)
+   if (srt_libspec_static)
+      get_target_property(
+         static_property_link_libraries
+         ${TARGET_srt}_static
+         LINK_LIBRARIES)
+   endif()
+   set(shared_property_link_libraries)
+   if (srt_libspec_shared)
+      get_target_property(
+         shared_property_link_libraries
+         ${TARGET_srt}_shared
+         LINK_LIBRARIES)
+   endif()
+
+   # See https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html#id13
+   set(__more_tc1_config)
+   if (CMAKE_CROSSCOMPILING)
+      set(__more_tc1_config
+         "    CMAKE_SYSROOT: ${CMAKE_SYSROOT}\n")
+   endif()
+
+   # See https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html#id13
+   set(__more_tc2_config)
+   if (APPLE)
+      set(__more_tc2_config
+    "    CMAKE_INSTALL_NAME_TOOL: ${CMAKE_INSTALL_NAME_TOOL}
+    CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT}
+    CMAKE_OSX_ARCHITECTURES: ${CMAKE_OSX_ARCHITECTURES}
+    CMAKE_OSX_DEPLOYMENT_TARGET: ${CMAKE_OSX_DEPLOYMENT_TARGET}
+    CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT}\n")
+   elseif (ANDROID)
+      set(__more_tc2_config
+    "    CMAKE_ANDROID_NDK: ${CMAKE_ANDROID_NDK}
+    CMAKE_ANDROID_STANDALONE_TOOLCHAIN: ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}
+    CMAKE_ANDROID_API: ${CMAKE_ANDROID_API}
+    CMAKE_ANDROID_ARCH_ABI: ${CMAKE_ANDROID_ARCH_ABI}
+    CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION: ${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
+    CMAKE_ANDROID_STL_TYPE: ${CMAKE_ANDROID_STL_TYPE}\n")
+   endif()
+
+   message(STATUS
+      "\n"
+      "========================================================================\n"
+      "= Project Configuration:\n"
+      "========================================================================\n"
+      "  SRT Version:\n"
+      "    SRT_VERSION: ${SRT_VERSION}\n"
+      "    SRT_VERSION_BUILD: ${SRT_VERSION_BUILD}\n"
+      "  CMake Configuration:\n"
+      "    CMAKE_VERSION: ${CMAKE_VERSION}\n"
+      "    CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}\n"
+      "    CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}\n"
+      "  Target Configuration:\n"
+      "    CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}\n"
+      "    CMAKE_SYSTEM_VERSION: ${CMAKE_SYSTEM_VERSION}\n"
+      "    CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}\n"
+      "    CMAKE_SIZEOF_VOID_P: ${CMAKE_SIZEOF_VOID_P}\n"
+      "    DARWIN: ${DARWIN}\n"
+      "    LINUX: ${LINUX}\n"
+      "    BSD: ${BSD}\n"
+      "    MICROSOFT: ${MICROSOFT}\n"
+      "    GNU: ${GNU}\n"
+      "    ANDROID: ${ANDROID}\n"
+      "    SUNOS: ${SUNOS}\n"
+      "    POSIX: ${POSIX}\n"
+      "    SYMLINKABLE: ${SYMLINKABLE}\n"
+      "    APPLE: ${APPLE}\n"
+      "    UNIX: ${UNIX}\n"
+      "    WIN32: ${WIN32}\n"
+      "    MINGW: ${MINGW}\n"
+      "    CYGWIN: ${CYGWIN}\n"
+      "    CYGWIN_USE_POSIX: ${CYGWIN_USE_POSIX}\n"
+      "  Toolchain Configuration:\n"
+      "    CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}\n"
+      "    CMAKE_CROSSCOMPILING: ${CMAKE_CROSSCOMPILING}\n"
+      "${__more_tc1_config}"
+      "    CMAKE_C_COMPILER_ID: ${CMAKE_C_COMPILER_ID}\n"
+      "    CMAKE_C_COMPILER_VERSION: ${CMAKE_C_COMPILER_VERSION}\n"
+      "    CMAKE_C_COMPILER: ${CMAKE_C_COMPILER}\n"
+      "    CMAKE_C_FLAGS: '${CMAKE_C_FLAGS}'\n"
+      "    CMAKE_C_COMPILE_FEATURES: ${CMAKE_C_COMPILE_FEATURES}\n"
+      "    CMAKE_C_STANDARD: ${CMAKE_CXX_STANDARD}\n"
+      "    CMAKE_CXX_COMPILER_ID: ${CMAKE_CXX_COMPILER_ID}\n"
+      "    CMAKE_CXX_COMPILER_VERSION: ${CMAKE_CXX_COMPILER_VERSION}\n"
+      "    CMAKE_CXX_COMPILER: ${CMAKE_CXX_COMPILER}\n"
+      "    CMAKE_CXX_FLAGS: '${CMAKE_CXX_FLAGS}'\n"
+      "    CMAKE_CXX_COMPILE_FEATURES: ${CMAKE_CXX_COMPILE_FEATURES}\n"
+      "    CMAKE_CXX_STANDARD: ${CMAKE_CXX_STANDARD}\n"
+      "    CMAKE_LINKER: ${CMAKE_LINKER}\n"
+      #"    CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}\n"
+      #"    CMAKE_EXE_LINKER_FLAGS_INIT: ${CMAKE_EXE_LINKER_FLAGS_INIT}\n"
+      #"    CMAKE_MODULE_LINKER_FLAGS: ${CMAKE_MODULE_LINKER_FLAGS}\n"
+      #"    CMAKE_MODULE_LINKER_FLAGS_INIT: ${CMAKE_MODULE_LINKER_FLAGS_INIT}\n"
+      #"    CMAKE_SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}\n"
+      #"    CMAKE_SHARED_LINKER_FLAGS_INIT: ${CMAKE_SHARED_LINKER_FLAGS_INIT}\n"
+      #"    CMAKE_STATIC_LINKER_FLAGS: ${CMAKE_STATIC_LINKER_FLAGS}\n"
+      #"    CMAKE_STATIC_LINKER_FLAGS_INIT: ${CMAKE_STATIC_LINKER_FLAGS_INIT}\n"
+      "    CMAKE_NM: ${CMAKE_NM}\n"
+      "    CMAKE_AR: ${CMAKE_AR}\n"
+      "    CMAKE_RANLIB: ${CMAKE_RANLIB}\n"
+      "${__more_tc2_config}"
+      "    HAVE_COMPILER_GNU_COMPAT: ${HAVE_COMPILER_GNU_COMPAT}\n"
+      "    CMAKE_THREAD_LIBS: ${CMAKE_THREAD_LIBS}\n"
+      "    CMAKE_THREAD_LIBS_INIT: ${CMAKE_THREAD_LIBS_INIT}\n"
+      "    ENABLE_THREAD_CHECK: ${ENABLE_THREAD_CHECK}\n"
+      "    USE_CXX_STD_APP: ${USE_CXX_STD_APP}\n"
+      "    USE_CXX_STD_LIB: ${USE_CXX_STD_LIB}\n"
+      "    STDCXX: ${STDCXX}\n"
+      "    USE_CXX_STD: ${USE_CXX_STD}\n"
+      "    HAVE_CLOCK_GETTIME_IN: ${HAVE_CLOCK_GETTIME_IN}\n"
+      "    HAVE_CLOCK_GETTIME_LIBRT: ${HAVE_CLOCK_GETTIME_LIBRT}\n"
+      "    HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H: ${HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H}\n"
+      "    HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H: ${HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H}\n"
+      "    HAVE_PTHREAD_GETNAME_NP: ${HAVE_PTHREAD_GETNAME_NP}\n"
+      "    HAVE_PTHREAD_SETNAME_NP: ${HAVE_PTHREAD_SETNAME_NP}\n"
+      "    HAVE_LIBATOMIC: ${HAVE_LIBATOMIC}\n"
+      "    HAVE_LIBATOMIC_COMPILES: ${HAVE_LIBATOMIC_COMPILES}\n"
+      "    HAVE_LIBATOMIC_COMPILES_STATIC: ${HAVE_LIBATOMIC_COMPILES_STATIC}\n"
+      "    HAVE_GCCATOMIC_INTRINSICS: ${HAVE_GCCATOMIC_INTRINSICS}\n"
+      "    HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC: ${HAVE_GCCATOMIC_INTRINSICS_REQUIRES_LIBATOMIC}\n"
+      "    HAVE_CXX_ATOMIC: ${HAVE_CXX_ATOMIC}\n"
+      "    HAVE_CXX_ATOMIC_STATIC: ${HAVE_CXX_ATOMIC_STATIC}\n"
+      "    HAVE_CXX_STD_PUT_TIME: ${HAVE_CXX_STD_PUT_TIME}\n"
+      "  Project Configuration:\n"
+      "    ENABLE_DEBUG: ${ENABLE_DEBUG}\n"
+      "    ENABLE_CXX11: ${ENABLE_CXX11}\n"
+      "    ENABLE_APPS: ${ENABLE_APPS}\n"
+      "    ENABLE_EXAMPLES: ${ENABLE_EXAMPLES}\n"
+      "    ENABLE_BONDING: ${ENABLE_BONDING}\n"
+      "    ENABLE_TESTING: ${ENABLE_TESTING}\n"
+      "    ENABLE_PROFILE: ${ENABLE_PROFILE}\n"
+      "    ENABLE_LOGGING: ${ENABLE_LOGGING}\n"
+      "    ENABLE_HEAVY_LOGGING: ${ENABLE_HEAVY_LOGGING}\n"
+      "    ENABLE_HAICRYPT_LOGGING: ${ENABLE_HAICRYPT_LOGGING}\n"
+      "    ENABLE_SHARED: ${ENABLE_SHARED}\n"
+      "    ENABLE_STATIC: ${ENABLE_STATIC}\n"
+      "    ENABLE_RELATIVE_LIBPATH: ${ENABLE_RELATIVE_LIBPATH}\n"
+      "    ENABLE_GETNAMEINFO: ${ENABLE_GETNAMEINFO}\n"
+      "    ENABLE_UNITTESTS: ${ENABLE_UNITTESTS}\n"
+      "    ENABLE_ENCRYPTION: ${ENABLE_ENCRYPTION}\n"
+      "    ENABLE_CXX_DEPS: ${ENABLE_CXX_DEPS}\n"
+      "    USE_STATIC_LIBSTDCXX: ${USE_STATIC_LIBSTDCXX}\n"
+      "    ENABLE_INET_PTON: ${ENABLE_INET_PTON}\n"
+      "    ENABLE_CODE_COVERAGE: ${ENABLE_CODE_COVERAGE}\n"
+      "    ENABLE_MONOTONIC_CLOCK: ${ENABLE_MONOTONIC_CLOCK}\n"
+      "    ENABLE_STDCXX_SYNC: ${ENABLE_STDCXX_SYNC}\n"
+      "    USE_OPENSSL_PC: ${USE_OPENSSL_PC}\n"
+      "    OPENSSL_USE_STATIC_LIBS: ${OPENSSL_USE_STATIC_LIBS}\n"
+      "    USE_BUSY_WAITING: ${USE_BUSY_WAITING}\n"
+      "    USE_GNUSTL: ${USE_GNUSTL}\n"
+      "    ENABLE_SOCK_CLOEXEC: ${ENABLE_SOCK_CLOEXEC}\n"
+      "    ENABLE_SHOW_PROJECT_CONFIG: ${ENABLE_SHOW_PROJECT_CONFIG}\n"
+      "    ENABLE_CLANG_TSA: ${ENABLE_CLANG_TSA}\n"
+      "    ATOMIC_USE_SRT_SYNC_MUTEX: ${ATOMIC_USE_SRT_SYNC_MUTEX}\n"
+      "  Constructed Configuration:\n"
+      "    DISABLE_CXX11: ${DISABLE_CXX11}\n"
+      "    HAVE_INET_PTON: ${HAVE_INET_PTON}\n"
+      "    PTHREAD_LIBRARY: ${PTHREAD_LIBRARY}\n"
+      "    USE_ENCLIB: ${USE_ENCLIB}\n"
+      "${__ssl_configuration}"
+      "    TARGET_srt: ${TARGET_srt}\n"
+      "    srt_libspec_static: ${srt_libspec_static}\n"
+      "    srt_libspec_shared: ${srt_libspec_shared}\n"
+      "    SRT_LIBS_PRIVATE: ${SRT_LIBS_PRIVATE}\n"
+      "    Target Link Libraries:\n"
+      "      Static: ${static_property_link_libraries}\n"
+      "      Shared: ${shared_property_link_libraries}\n"
+      "========================================================================\n"
+   )
+
+endfunction(ShowProjectConfig)
diff --git a/scripts/build-android/README.md b/scripts/build-android/README.md
new file mode 100644
index 000000000..85277f2a6
--- /dev/null
+++ b/scripts/build-android/README.md
@@ -0,0 +1,3 @@
+## Scripts for building SRT for Android
+
+See [Building SRT for Android](../../docs/build/build-android.md) for the instructions.
diff --git a/scripts/build-android/build-android b/scripts/build-android/build-android
new file mode 100755
index 000000000..99438d7f8
--- /dev/null
+++ b/scripts/build-android/build-android
@@ -0,0 +1,108 @@
+#!/bin/sh
+
+echo_help()
+{
+  echo "Usage: $0 [options...]"
+  echo "    -n    NDK root path for the build"
+  echo "    -a    Target API level"
+  echo "    -t    Space-separated list of target architectures"
+  echo "          Android supports the following architectures: armeabi-v7a arm64-v8a x86 x86_64"
+  echo "    -e    Encryption library to be used. Possible options: openssl (default) mbedtls botan"
+  echo "    -o    OpenSSL version. E.g. 1.1.1l"
+  echo "    -m    Mbed TLS version. E.g. v2.26.0"
+  echo
+  echo "Example: ./build-android -n /home/username/Android/Sdk/ndk/23.0.7599858 -a 28 -t \"arm64-v8a x86_64\""
+  echo
+}
+
+# Init optional command line vars
+NDK_ROOT=""
+API_LEVEL=28
+BUILD_TARGETS="armeabi-v7a arm64-v8a x86 x86_64"
+OPENSSL_VERSION=1.1.1l
+ENC_LIB=openssl
+MBEDTLS_VERSION=v2.26.0
+
+while getopts n:a:t:o:s:e:m: option
+do
+ case "${option}"
+ in
+ n) NDK_ROOT=${OPTARG};;
+ a) API_LEVEL=${OPTARG};;
+ t) BUILD_TARGETS=${OPTARG};;
+ o) OPENSSL_VERSION=${OPTARG};;
+ s) SRT_VERSION=${OPTARG};;
+ e) ENC_LIB=${OPTARG};;
+ m) MBEDTLS_VERSION=${OPTARG};;
+ *) twentytwo=${OPTARG};;
+ esac
+done
+
+echo_help
+
+if [ -z "$NDK_ROOT" ] ; then
+ echo "NDK directory not set."
+ exit 128
+else
+ if [ ! -d "$NDK_ROOT" ]; then
+  echo "NDK directory does not exist: $NDK_ROOT"
+  exit 128
+ fi
+fi
+
+SCRIPT_DIR=$(pwd)
+HOST_TAG='unknown'
+unamestr=$(uname -s)
+if [ "$unamestr" = 'Linux' ]; then
+ HOST_TAG='linux-x86_64'
+elif [ "$unamestr" = 'Darwin' ]; then
+ HOST_TAG='darwin-x86_64'
+fi
+
+# Write files relative to current location
+BASE_DIR=$(pwd)
+case "${BASE_DIR}" in
+  *\ * )
+    echo "Your path contains whitespaces, which is not supported by 'make install'."
+    exit 128
+  ;;
+esac
+cd "${BASE_DIR}"
+
+if [ $ENC_LIB = 'openssl' ]; then
+ echo "Building OpenSSL $OPENSSL_VERSION"
+ $SCRIPT_DIR/mkssl -n $NDK_ROOT -a $API_LEVEL -t "$BUILD_TARGETS" -o $OPENSSL_VERSION -d $BASE_DIR -h $HOST_TAG
+elif [ $ENC_LIB = 'mbedtls' ]; then
+ if [ ! -d $BASE_DIR/mbedtls ]; then
+  git clone https://github.com/ARMmbed/mbedtls mbedtls
+  if [ ! -z "$MBEDTLS_VERSION" ]; then
+   git -C $BASE_DIR/mbedtls checkout $MBEDTLS_VERSION
+  fi
+ fi
+elif [ $ENC_LIB = 'botan' ]; then
+ echo "Using Botan for encryption."
+else
+ echo "Unknown encryption library. Possible options: openssl mbedtls"
+ exit 128
+fi
+
+# Build working copy of srt repository
+REPO_DIR="../.."
+
+for build_target in $BUILD_TARGETS; do
+ LIB_DIR=$BASE_DIR/$build_target/lib
+ JNI_DIR=$BASE_DIR/prebuilt/$build_target
+
+ mkdir -p $JNI_DIR
+
+ if [ $ENC_LIB = 'mbedtls' ]; then
+  $SCRIPT_DIR/mkmbedtls -n $NDK_ROOT -a $API_LEVEL -t $build_target -s $BASE_DIR/mbedtls -i $BASE_DIR/$build_target
+  cp $LIB_DIR/libmbedcrypto.so $JNI_DIR/libmbedcrypto.so
+  cp $LIB_DIR/libmbedtls.so $JNI_DIR/libmbedtls.so
+  cp $LIB_DIR/libmbedx509.so $JNI_DIR/libmbedx509.so
+ fi
+
+ git -C $REPO_DIR clean -fd -e scripts
+ $SCRIPT_DIR/mksrt -n $NDK_ROOT -a $API_LEVEL -t $build_target -e $ENC_LIB -s $REPO_DIR -i $BASE_DIR/$build_target
+ cp $LIB_DIR/libsrt.so $JNI_DIR/libsrt.so
+done
diff --git a/scripts/build-android/mkmbedtls b/scripts/build-android/mkmbedtls
new file mode 100755
index 000000000..176154184
--- /dev/null
+++ b/scripts/build-android/mkmbedtls
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+while getopts s:i:t:n:a: option
+do
+ case "${option}"
+ in
+ s) SRC_DIR=${OPTARG};;
+ i) INSTALL_DIR=${OPTARG};;
+ t) ARCH_ABI=${OPTARG};;
+ n) NDK_ROOT=${OPTARG};;
+ a) API_LEVEL=${OPTARG};;
+ *) twentytwo=${OPTARG};;
+ esac
+done
+
+
+BUILD_DIR=/tmp/mbedtls_android_build
+rm -rf $BUILD_DIR
+mkdir $BUILD_DIR
+cd $BUILD_DIR
+cmake -DENABLE_TESTING=Off -DUSE_SHARED_MBEDTLS_LIBRARY=On \
+-DCMAKE_PREFIX_PATH=$INSTALL_DIR -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR -DCMAKE_ANDROID_NDK=$NDK_ROOT \
+-DCMAKE_SYSTEM_NAME=Android -DCMAKE_SYSTEM_VERSION=$API_LEVEL -DCMAKE_ANDROID_ARCH_ABI=$ARCH_ABI \
+-DCMAKE_C_FLAGS="-fPIC" -DCMAKE_SHARED_LINKER_FLAGS="-Wl,--build-id" \
+-DCMAKE_BUILD_TYPE=RelWithDebInfo $SRC_DIR
+cmake --build .
+cmake --install .
diff --git a/scripts/build-android/mksrt b/scripts/build-android/mksrt
new file mode 100755
index 000000000..d30f01bb5
--- /dev/null
+++ b/scripts/build-android/mksrt
@@ -0,0 +1,47 @@
+#!/bin/sh
+
+while getopts s:i:t:n:a:e: option
+do
+ case "${option}"
+ in
+ s) SRC_DIR=${OPTARG};;
+ i) INSTALL_DIR=${OPTARG};;
+ t) ARCH_ABI=${OPTARG};;
+ n) NDK_ROOT=${OPTARG};;
+ a) API_LEVEL=${OPTARG};;
+ e) ENC_LIB=${OPTARG};;
+ *) twentytwo=${OPTARG};;
+ esac
+done
+
+if [ $ARCH_ABI = "armeabi-v7a" ]; then
+    BOTAN_CONFIGURE_CPU=armv7
+    BOTAN_CXX_FLAGS=""
+elif [ $ARCH_ABI = "arm64-v8a" ]; then
+    BOTAN_CONFIGURE_CPU=arm64
+    BOTAN_CXX_FLAGS="-march=armv8-a+crypto"
+elif [ $ARCH_ABI = "x86" ]; then
+    BOTAN_CONFIGURE_CPU=x86
+    BOTAN_CXX_FLAGS=""
+elif [ $ARCH_ABI = "x86_64" ]; then
+    BOTAN_CONFIGURE_CPU=x86_64
+    BOTAN_CXX_FLAGS=""
+fi
+
+cd $SRC_DIR
+./configure --use-enclib=$ENC_LIB \
+--use-openssl-pc=OFF \
+--OPENSSL_INCLUDE_DIR=$INSTALL_DIR/include \
+--OPENSSL_CRYPTO_LIBRARY=$INSTALL_DIR/lib/libcrypto.a --OPENSSL_SSL_LIBRARY=$INSTALL_DIR/lib/libssl.a \
+--STATIC_MBEDTLS=FALSE \
+--MBEDTLS_INCLUDE_DIR=$INSTALL_DIR/include --MBEDTLS_INCLUDE_DIRS=$INSTALL_DIR/include \
+--MBEDTLS_LIBRARIES=$INSTALL_DIR/lib/libmbedtls.so \
+--BOTAN_OS=android \
+--BOTAN_CPU=$BOTAN_CONFIGURE_CPU \
+--CMAKE_PREFIX_PATH=$INSTALL_DIR --CMAKE_INSTALL_PREFIX=$INSTALL_DIR --CMAKE_ANDROID_NDK=$NDK_ROOT \
+--CMAKE_SYSTEM_NAME=Android --CMAKE_SYSTEM_VERSION=$API_LEVEL --CMAKE_ANDROID_ARCH_ABI=$ARCH_ABI \
+--CMAKE_C_FLAGS="-fPIC" --CMAKE_CXX_FLAGS=$BOTAN_CXX_FLAGS --CMAKE_SHARED_LINKER_FLAGS="-Wl,--build-id" \
+--enable-c++11 --enable-stdcxx-sync \
+--enable-debug=2 --enable-logging=0 --enable-heavy-logging=0 --enable-apps=0
+make
+make install
diff --git a/scripts/build-android/mkssl b/scripts/build-android/mkssl
new file mode 100755
index 000000000..22a4421f0
--- /dev/null
+++ b/scripts/build-android/mkssl
@@ -0,0 +1,85 @@
+#!/bin/sh
+
+while getopts n:o:a:t:d:h: option
+do
+ case "${option}"
+ in
+ n) ANDROID_NDK=${OPTARG};;
+ o) OPENSSL_VERSION=${OPTARG};;
+ a) API_LEVEL=${OPTARG};;
+ t) BUILD_TARGETS=${OPTARG};;
+ d) OUT_DIR=${OPTARG};;
+ h) HOST_TAG=${OPTARG};;
+ *) twentytwo=${OPTARG};;
+ esac
+done
+
+
+BUILD_DIR=/tmp/openssl_android_build
+
+if [ ! -d openssl-${OPENSSL_VERSION} ]
+then
+    if [ ! -f openssl-${OPENSSL_VERSION}.tar.gz ]
+    then
+        wget https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz || exit 128
+    fi
+    tar xzf openssl-${OPENSSL_VERSION}.tar.gz || exit 128
+fi
+
+cd openssl-${OPENSSL_VERSION} || exit 128
+
+
+##### export ndk directory. Required by openssl-build-scripts #####
+case ${OPENSSL_VERSION} in
+    1.1.1*)
+        export ANDROID_NDK_HOME=$ANDROID_NDK
+    ;;
+    *)
+        export ANDROID_NDK_ROOT=$ANDROID_NDK
+    ;;
+esac
+
+export PATH=$ANDROID_NDK/toolchains/llvm/prebuilt/$HOST_TAG/bin:$PATH
+
+##### build-function #####
+build_the_thing() {
+    make clean
+    ./Configure $SSL_TARGET -D__ANDROID_API__=$API_LEVEL && \
+    make SHLIB_EXT=.so && \
+    make install SHLIB_EXT=.so DESTDIR=$DESTDIR || exit 128
+}
+
+##### set variables according to build-tagret #####
+for build_target in $BUILD_TARGETS
+do
+    case $build_target in
+    armeabi-v7a)
+        DESTDIR="$BUILD_DIR/armeabi-v7a"
+        SSL_TARGET="android-arm"
+    ;;
+    x86)
+        DESTDIR="$BUILD_DIR/x86"
+        SSL_TARGET="android-x86"
+    ;;
+    x86_64)
+        DESTDIR="$BUILD_DIR/x86_64"
+        SSL_TARGET="android-x86_64"
+    ;;
+    arm64-v8a)
+        DESTDIR="$BUILD_DIR/arm64-v8a"
+        SSL_TARGET="android-arm64"
+    ;;
+    esac
+
+    rm -rf $DESTDIR
+    build_the_thing
+#### copy libraries and includes to output-directory #####
+    mkdir -p $OUT_DIR/$build_target/include
+    cp -R $DESTDIR/usr/local/include/* $OUT_DIR/$build_target/include
+    cp -R $DESTDIR/usr/local/ssl/* $OUT_DIR/$build_target/
+    mkdir -p $OUT_DIR/$build_target/lib
+    cp -R $DESTDIR/usr/local/lib/*.so $OUT_DIR/$build_target/lib
+    cp -R $DESTDIR/usr/local/lib/*.a $OUT_DIR/$build_target/lib
+done
+
+echo Success
diff --git a/scripts/build-windows.ps1 b/scripts/build-windows.ps1
index c651a77a9..66586158e 100644
--- a/scripts/build-windows.ps1
+++ b/scripts/build-windows.ps1
@@ -1,171 +1,235 @@
-################################################################################
-# Windows SRT Build Script
-#============================
-# Usable on a Windows PC with Powershell and Visual studio, 
-# or called by CI systems like AppVeyor
-#
-# By default produces a VS2019 64-bit Release binary using C++11 threads, without
-# encryption or unit tests enabled, but including test apps.
-# Before enabling any encryption options, please install OpenSSL (or customize)
-################################################################################
-
-param (
-    [Parameter()][String]$VS_VERSION = "2019",
-    [Parameter()][String]$CONFIGURATION = "Release",
-    [Parameter()][String]$DEVENV_PLATFORM = "x64",
-    [Parameter()][String]$ENABLE_ENCRYPTION = "OFF",
-    [Parameter()][String]$STATIC_LINK_SSL = "OFF",
-    [Parameter()][String]$CXX11 = "ON",
-    [Parameter()][String]$BUILD_APPS = "ON",
-    [Parameter()][String]$UNIT_TESTS = "OFF"
-)
-
-# cmake can be optionally installed (useful when running interactively on a developer station).
-# The URL for automatic download is defined later in the script, but it should be possible to just vary the 
-# specific version set below and the URL should be stable enough to still work - you have been warned.
-$cmakeVersion = "3.17.3"
-
-# make all errors trigger a script stop, rather than just carry on
-$ErrorActionPreference = "Stop"
-
-$projectRoot = Join-Path $PSScriptRoot "/.." -Resolve
-
-# if running within AppVeyor, use environment variables to set params instead of passed-in values
-if ( $Env:APPVEYOR ) { 
-    if ( $Env:PLATFORM -eq 'x86' ) { $DEVENV_PLATFORM = 'Win32' } else { $DEVENV_PLATFORM = 'x64' }
-    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2019' ) { $VS_VERSION='2019' }
-    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2015' ) { $VS_VERSION='2015' }
-    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2013' ) { $VS_VERSION='2013' }
-
-    #if not statically linking OpenSSL, set flag to gather the specific openssl package from the build server into package
-    if ( $STATIC_LINK_SSL -eq 'OFF' ) { $Env:GATHER_SSL_INTO_PACKAGE = $true }
-
-    #if unit tests are on, set flag to actually execute ctest step
-    if ( $UNIT_TESTS -eq 'ON' ) { $Env:RUN_UNIT_TESTS = $true }
-    
-    $CONFIGURATION = $Env:CONFIGURATION
-
-    #appveyor has many openssl installations - place the latest one in the default location unless VS2013
-    if( $VS_VERSION -ne '2013' ) {
-        Remove-Item -Path "C:\OpenSSL-Win32" -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
-        Remove-Item -Path "C:\OpenSSL-Win64" -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
-        Copy-Item -Path "C:\OpenSSL-v111-Win32" "C:\OpenSSL-Win32" -Recurse | Out-Null
-        Copy-Item -Path "C:\OpenSSL-v111-Win64" "C:\OpenSSL-Win64" -Recurse | Out-Null
-    }
-}
-
-# persist VS_VERSION so it can be used in an artifact name later
-$Env:VS_VERSION = $VS_VERSION
-
-# select the appropriate cmake generator string given the environment
-if ( $VS_VERSION -eq '2019' ) { $CMAKE_GENERATOR = 'Visual Studio 16 2019'; $MSBUILDVER = "16.0"; }
-if ( $VS_VERSION -eq '2015' -and $DEVENV_PLATFORM -eq 'Win32' ) { $CMAKE_GENERATOR = 'Visual Studio 14 2015'; $MSBUILDVER = "14.0"; }
-if ( $VS_VERSION -eq '2015' -and $DEVENV_PLATFORM -eq 'x64' ) { $CMAKE_GENERATOR = 'Visual Studio 14 2015 Win64'; $MSBUILDVER = "14.0"; }
-if ( $VS_VERSION -eq '2013' -and $DEVENV_PLATFORM -eq 'Win32' ) { $CMAKE_GENERATOR = 'Visual Studio 12 2013'; $MSBUILDVER = "12.0"; }
-if ( $VS_VERSION -eq '2013' -and $DEVENV_PLATFORM -eq 'x64' ) { $CMAKE_GENERATOR = 'Visual Studio 12 2013 Win64'; $MSBUILDVER = "12.0"; }
-
-# clear any previous build and create & enter the build directory
-$buildDir = Join-Path "$projectRoot" "_build"
-Write-Output "Creating (or cleaning if already existing) the folder $buildDir for project files and outputs"
-Remove-Item -Path $buildDir -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
-New-Item -ItemType Directory -Path $buildDir -ErrorAction SilentlyContinue | Out-Null
-Push-Location $buildDir
-
-# check cmake is installed
-if ( $null -eq (Get-Command "cmake.exe" -ErrorAction SilentlyContinue) ) { 
-    $installCmake = Read-Host "Unable to find cmake in your PATH - would you like to download and install automatically? [yes/no]"
-   
-    if ( $installCmake -eq "y" -or $installCmake -eq "yes" ) {
-        # download cmake and run MSI for user
-        $client = New-Object System.Net.WebClient        
-        $tempDownloadFile = New-TemporaryFile
-        
-        $cmakeUrl = "https://github.com/Kitware/CMake/releases/download/v$cmakeVersion/cmake-$cmakeVersion-win64-x64.msi"
-        $cmakeMsiFile = "$tempDownloadFile.cmake-$cmakeVersion-win64-x64.msi"
-        Write-Output "Downloading cmake from $cmakeUrl (temporary file location $cmakeMsiFile)"
-        Write-Output "Note: select the option to add cmake to path for this script to operate"
-        $client.DownloadFile("$cmakeUrl", "$cmakeMsiFile")
-        Start-Process $cmakeMsiFile -Wait
-        Remove-Item $cmakeMsiFile
-        Write-Output "Cmake should have installed, this script will now exit because of path updates - please now re-run this script"
-        exit
-    }
-    else{
-        Write-Output "Quitting because cmake is required"     
-        exit
-    }
-}
-
-if ( $CXX11 -eq "OFF" ) {
-    # get pthreads (this is legacy, and is only availble in nuget for VS2015 and VS2013)
-    if ( $VS_VERSION -gt 2015 ) { 
-        Write-Output "Pthreads is not recommended for use beyond VS2015 and is not supported by this build script - aborting build"
-        exit
-    }
-    if ( $DEVENV_PLATFORM -eq 'Win32' ) { 
-        nuget install cinegy.pthreads-win32-$VS_VERSION -version 2.9.1.24 -OutputDirectory ../_packages
-    }
-    else {        
-        nuget install cinegy.pthreads-win64-$VS_VERSION -version 2.9.1.24 -OutputDirectory ../_packages
-    }
-}
-
-if ( $STATIC_LINK_SSL -eq "ON" ) {
-    if ( $ENABLE_ENCRYPTION -eq "OFF" ) {
-        # requesting a static link implicitly requires encryption support
-        Write-Output "Static linking to OpenSSL requested, will force encryption feature ON"
-        $ENABLE_ENCRYPTION = "ON"
-    }
-}
-
-# build the cmake command flags from arguments
-$cmakeFlags = "-DCMAKE_BUILD_TYPE=$CONFIGURATION " + 
-                "-DENABLE_STDCXX_SYNC=$CXX11 " + 
-                "-DENABLE_APPS=$BUILD_APPS " + 
-                "-DENABLE_ENCRYPTION=$ENABLE_ENCRYPTION " +
-                "-DOPENSSL_USE_STATIC_LIBS=$STATIC_LINK_SSL " + 
-                "-DENABLE_UNITTESTS=$UNIT_TESTS"
-
-# cmake uses a flag for architecture from vs2019, so add that as a suffix
-if ( $VS_VERSION -eq '2019' ) {    
-    $cmakeFlags += " -A `"$DEVENV_PLATFORM`""
-}
-
-# fire cmake to build project files
-$execVar = "cmake ../ -G`"$CMAKE_GENERATOR`" $cmakeFlags"
-Write-Output $execVar
-Invoke-Expression "& $execVar"
-
-# check build ran OK, exit if cmake failed
-if( $LASTEXITCODE -ne 0 ) {
-    return $LASTEXITCODE
-}
-
-# run the set-version-metadata script to inject build numbers into appveyors console and the resulting DLL
-. $PSScriptRoot/set-version-metadata.ps1
-
-# look for msbuild
-$msBuildPath = Get-Command "msbuild.exe" -ErrorAction SilentlyContinue
-if ( $null -eq $msBuildPath ) { 
-    # no mbsuild in the path, so try to locate with 'vswhere'
-    $vsWherePath = Get-Command "vswhere.exe" -ErrorAction SilentlyContinue
-    if ( $null -eq $vsWherePath ) { 
-        # no vswhere in the path, so check the Microsoft published location (true since VS2017 Update 2)
-        $vsWherePath = Get-Command "${Env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -ErrorAction SilentlyContinue
-        if ( $null -eq $vsWherePath ) {
-            Write-Output "Cannot find vswhere (used to locate msbuild). Please install VS2017 update 2 (or later) or add vswhere to your path and try again"
-            exit
-        }
-    }    
-    $msBuildPath = & $vsWherePath -version $MSBUILDVER -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe | select-object -first 1
-}
-
-& $msBuildPath SRT.sln /p:Configuration=$CONFIGURATION /p:Platform=$DEVENV_PLATFORM
-
-# return to the directory previously occupied before running the script
-Pop-Location
-
-# if msbuild returned non-zero, throw to cause failure in CI
-if( $LASTEXITCODE -ne 0 ) {
-    throw
-}
+################################################################################
+# Windows SRT Build Script
+#============================
+# Usable on a Windows PC with Powershell and Visual studio, 
+# or called by CI systems like AppVeyor
+#
+# By default produces a VS2019 64-bit Release binary using C++11 threads, without
+# encryption or unit tests enabled, but including test apps.
+# Before enabling any encryption options, install OpenSSL or set VCKPG flag to build
+################################################################################
+
+param (
+    [Parameter()][String]$VS_VERSION = "2022",
+    [Parameter()][String]$CONFIGURATION = "Release",
+    [Parameter()][String]$DEVENV_PLATFORM = "x64",
+    [Parameter()][String]$ENABLE_ENCRYPTION = "OFF",
+    [Parameter()][String]$STATIC_LINK_SSL = "OFF",
+    [Parameter()][String]$CXX11 = "ON",
+    [Parameter()][String]$BUILD_APPS = "ON",
+    [Parameter()][String]$UNIT_TESTS = "OFF",
+    [Parameter()][String]$BUILD_DIR = "_build",
+    [Parameter()][String]$VCPKG_OPENSSL = "OFF",
+    [Parameter()][String]$BONDING = "OFF"
+)
+
+# cmake can be optionally installed (useful when running interactively on a developer station).
+# The URL for automatic download is defined later in the script, but it should be possible to just vary the 
+# specific version set below and the URL should be stable enough to still work - you have been warned.
+$cmakeVersion = "3.23.2"
+
+# make all errors trigger a script stop, rather than just carry on
+$ErrorActionPreference = "Stop"
+
+$projectRoot = Join-Path $PSScriptRoot "/.." -Resolve
+
+# if running within AppVeyor, use environment variables to set params instead of passed-in values
+if ( $Env:APPVEYOR ) { 
+    if ( $Env:PLATFORM -eq 'x86' ) { $DEVENV_PLATFORM = 'Win32' } else { $DEVENV_PLATFORM = 'x64' }
+    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2022' ) { $VS_VERSION='2022' }
+    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2019' ) { $VS_VERSION='2019' }
+    if ( $Env:APPVEYOR_BUILD_WORKER_IMAGE -eq 'Visual Studio 2015' ) { $VS_VERSION='2015' }
+
+    #if not statically linking OpenSSL, set flag to gather the specific openssl package from the build server into package
+    if ( $STATIC_LINK_SSL -eq 'OFF' ) { $Env:GATHER_SSL_INTO_PACKAGE = $true }
+
+    #if unit tests are on, set flag to actually execute ctest step
+    if ( $UNIT_TESTS -eq 'ON' ) { $Env:RUN_UNIT_TESTS = $true }
+    
+    $CONFIGURATION = $Env:CONFIGURATION
+
+    #appveyor has many openssl installations - place the latest one in the default location unless VS2013
+    Remove-Item -Path "C:\OpenSSL-Win32" -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
+    Remove-Item -Path "C:\OpenSSL-Win64" -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
+    Copy-Item -Path "C:\OpenSSL-v111-Win32" "C:\OpenSSL-Win32" -Recurse | Out-Null
+    Copy-Item -Path "C:\OpenSSL-v111-Win64" "C:\OpenSSL-Win64" -Recurse | Out-Null
+}
+
+# persist VS_VERSION so it can be used in an artifact name later
+$Env:VS_VERSION = $VS_VERSION
+
+# select the appropriate cmake generator string given the environment
+if ( $VS_VERSION -eq '2022' ) { $CMAKE_GENERATOR = 'Visual Studio 17 2022'; $MSBUILDVER = "17.10"; }
+if ( $VS_VERSION -eq '2019' ) { $CMAKE_GENERATOR = 'Visual Studio 16 2019'; $MSBUILDVER = "16.0"; }
+if ( $VS_VERSION -eq '2015' -and $DEVENV_PLATFORM -eq 'Win32' ) { $CMAKE_GENERATOR = 'Visual Studio 14 2015'; $MSBUILDVER = "14.0"; }
+if ( $VS_VERSION -eq '2015' -and $DEVENV_PLATFORM -eq 'x64' ) { $CMAKE_GENERATOR = 'Visual Studio 14 2015 Win64'; $MSBUILDVER = "14.0"; }
+
+# clear any previous build and create & enter the build directory
+$buildDir = Join-Path "$projectRoot" "$BUILD_DIR"
+Write-Output "Creating (or cleaning if already existing) the folder $buildDir for project files and outputs"
+Remove-Item -Path $buildDir -Recurse -Force -ErrorAction SilentlyContinue | Out-Null
+New-Item -ItemType Directory -Path $buildDir -ErrorAction SilentlyContinue | Out-Null
+Push-Location $buildDir
+
+# check cmake is installed
+if ( $null -eq (Get-Command "cmake.exe" -ErrorAction SilentlyContinue) ) { 
+    $installCmake = Read-Host "Unable to find cmake in your PATH - would you like to download and install automatically? [yes/no]"
+   
+    if ( $installCmake -eq "y" -or $installCmake -eq "yes" ) {
+        # download cmake and run MSI for user
+        $client = New-Object System.Net.WebClient        
+        $tempDownloadFile = New-TemporaryFile
+        
+        $cmakeUrl = "https://github.com/Kitware/CMake/releases/download/v$cmakeVersion/cmake-$cmakeVersion-win64-x64.msi"
+        $cmakeMsiFile = "$tempDownloadFile.cmake-$cmakeVersion-win64-x64.msi"
+        Write-Output "Downloading cmake from $cmakeUrl (temporary file location $cmakeMsiFile)"
+        Write-Output "Note: select the option to add cmake to path for this script to operate"
+        $client.DownloadFile("$cmakeUrl", "$cmakeMsiFile")
+        Start-Process $cmakeMsiFile -Wait
+        Remove-Item $cmakeMsiFile
+        Write-Output "Cmake should have installed, this script will now exit because of path updates - please now re-run this script"
+        throw
+    }
+    else{
+        Write-Output "Quitting because cmake is required"     
+        throw
+    }
+}
+
+# get pthreads from nuget if CXX11 is not enabled
+if ( $CXX11 -eq "OFF" ) {
+    # get pthreads (this is legacy, and is only available in nuget for VS2015 and VS2013)
+    if ( $VS_VERSION -gt 2015 ) { 
+        Write-Output "Pthreads is not recommended for use beyond VS2015 and is not supported by this build script - aborting build"
+        throw
+    }
+    if ( $DEVENV_PLATFORM -eq 'Win32' ) { 
+        nuget install cinegy.pthreads-win32-$VS_VERSION -version 2.9.1.24 -OutputDirectory ../_packages
+    }
+    else {        
+        nuget install cinegy.pthreads-win64-$VS_VERSION -version 2.9.1.24 -OutputDirectory ../_packages
+    }
+}
+
+# check to see if static SSL linking was requested, and enable encryption if not already ON
+if ( $STATIC_LINK_SSL -eq "ON" ) {
+    if ( $ENABLE_ENCRYPTION -eq "OFF" ) {
+        # requesting a static link implicitly requires encryption support
+        Write-Output "Static linking to OpenSSL requested, will force encryption feature ON"
+        $ENABLE_ENCRYPTION = "ON"
+    }
+}
+
+# check to see if VCPKG is marked to provide OpenSSL, and enable encryption if not already ON
+if ( $VCPKG_OPENSSL -eq "ON" ) {
+    if ( $ENABLE_ENCRYPTION -eq "OFF" ) {
+        # requesting VCPKG to provide OpenSSL requires encryption support
+        Write-Output "VCPKG compilation of OpenSSL requested, will force encryption feature ON"
+        $ENABLE_ENCRYPTION = "ON"
+    }
+}
+
+# build the cmake command flags from arguments
+$cmakeFlags = "-DCMAKE_BUILD_TYPE=$CONFIGURATION " + 
+                "-DENABLE_STDCXX_SYNC=$CXX11 " + 
+                "-DENABLE_APPS=$BUILD_APPS " + 
+                "-DENABLE_ENCRYPTION=$ENABLE_ENCRYPTION " +
+                "-DENABLE_BONDING=$BONDING " +
+                "-DENABLE_UNITTESTS=$UNIT_TESTS"
+
+# if VCPKG is flagged to provide OpenSSL, checkout VCPKG and install package
+if ( $VCPKG_OPENSSL -eq 'ON' ) {    
+    Push-Location $projectRoot
+    Write-Output "Cloning VCPKG into: $(Get-Location)"
+    if (Test-Path -Path ".\vcpkg") {
+        Set-Location .\vcpkg
+        git pull
+    } else {
+        git clone https://github.com/microsoft/vcpkg
+        Set-Location .\vcpkg
+    }
+
+    .\bootstrap-vcpkg.bat
+
+    if($DEVENV_PLATFORM -EQ "x64"){
+        if($STATIC_LINK_SSL -EQ "ON"){
+            .\vcpkg install openssl:x64-windows-static
+            $cmakeFlags += " -DVCPKG_TARGET_TRIPLET=x64-windows-static"
+        }
+        else{
+            .\vcpkg install openssl:x64-windows
+        }        
+    }
+    else{        
+        if($STATIC_LINK_SSL -EQ "ON"){
+            .\vcpkg install openssl:x86-windows-static
+            $cmakeFlags += " -DVCPKG_TARGET_TRIPLET=x86-windows-static"
+        }
+        else{
+            .\vcpkg install openssl:x86-windows
+        }
+    }
+    
+    .\vcpkg integrate install
+    Pop-Location
+    $cmakeFlags += " -DCMAKE_TOOLCHAIN_FILE=$projectRoot\vcpkg\scripts\buildsystems\vcpkg.cmake"
+}
+else {    
+    $cmakeFlags += " -DOPENSSL_USE_STATIC_LIBS=$STATIC_LINK_SSL "
+}
+
+# cmake uses a flag for architecture from vs2019, so add that as a suffix
+if ( $VS_VERSION -ge '2019' ) {    
+    $cmakeFlags += " -A `"$DEVENV_PLATFORM`""
+}
+
+# fire cmake to build project files
+$execVar = "cmake ../ -G`"$CMAKE_GENERATOR`" $cmakeFlags"
+Write-Output $execVar
+
+# Reset reaction to Continue for cmake as it sometimes tends to print
+# things on stderr, which is understood by PowerShell as error. The
+# exit code from cmake will be checked anyway.
+$ErrorActionPreference = "Continue"
+Invoke-Expression "& $execVar"
+
+# check build ran OK, exit if cmake failed
+if( $LASTEXITCODE -ne 0 ) {
+    Write-Output "Non-zero exit code from cmake: $LASTEXITCODE"
+    throw
+}
+
+$ErrorActionPreference = "Stop"
+
+# run the set-version-metadata script to inject build numbers into appveyors console and the resulting DLL
+. $PSScriptRoot/set-version-metadata.ps1
+
+# look for msbuild
+$msBuildPath = Get-Command "msbuild.exe" -ErrorAction SilentlyContinue
+if ( $null -eq $msBuildPath ) { 
+    # no mbsuild in the path, so try to locate with 'vswhere'
+    $vsWherePath = Get-Command "vswhere.exe" -ErrorAction SilentlyContinue
+    if ( $null -eq $vsWherePath ) { 
+        # no vswhere in the path, so check the Microsoft published location (true since VS2017 Update 2)
+        $vsWherePath = Get-Command "${Env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -ErrorAction SilentlyContinue
+        if ( $null -eq $vsWherePath ) {
+            Write-Output "Cannot find vswhere (used to locate msbuild). Please install VS2017 update 2 (or later) or add vswhere to your path and try again"
+            throw
+        }
+    }    
+    $msBuildPath = & $vsWherePath -products * -version $MSBUILDVER -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe | select-object -first 1
+	if ( $null -eq $msBuildPath ) { 
+		Write-Output "vswhere.exe cannot find msbuild for the specified Visual Studio version - please check the installation"
+		throw
+	}
+}
+
+& $msBuildPath SRT.sln -m /p:Configuration=$CONFIGURATION /p:Platform=$DEVENV_PLATFORM
+
+# return to the directory previously occupied before running the script
+Pop-Location
+
+# if msbuild returned non-zero, throw to cause failure in CI
+if( $LASTEXITCODE -ne 0 ) {
+    throw
+}
diff --git a/scripts/changelog/README.md b/scripts/changelog/README.md
deleted file mode 100644
index 22d5d0be3..000000000
--- a/scripts/changelog/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Changelog
-
-Script designed to create changelog out of `.csv` SRT git log. The output `changelog.md` is generated in the root folder.
-
-In order to generate git log file since the previous release (e.g., v1.4.0), use the following command:
-
-```
-git log --pretty=format:"%h|%s|%an|%ae" v1.4.0...HEAD^ > commits.csv
-```
-
-## Requirements
-
-* python 3.6+
-
-To install python libraries use:
-```
-pip install -r requirements.txt
-```
diff --git a/scripts/generate-error-types.tcl b/scripts/generate-error-types.tcl
new file mode 100755
index 000000000..e4d29c623
--- /dev/null
+++ b/scripts/generate-error-types.tcl
@@ -0,0 +1,251 @@
+#!/usr/bin/tclsh
+#*
+#* SRT - Secure, Reliable, Transport
+#* Copyright (c) 2020 Haivision Systems Inc.
+#* 
+#* This Source Code Form is subject to the terms of the Mozilla Public
+#* License, v. 2.0. If a copy of the MPL was not distributed with this
+#* file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#* 
+#*/
+#
+#*****************************************************************************
+#written by
+#  Haivision Systems Inc.
+#*****************************************************************************
+
+set code_major {
+    UNKNOWN    -1
+    SUCCESS     0
+    SETUP       1
+    CONNECTION  2
+    SYSTEMRES   3
+    FILESYSTEM  4
+    NOTSUP      5
+    AGAIN       6
+    PEERERROR   7
+}
+
+set code_minor {
+    NONE             0
+    TIMEOUT          1
+    REJECTED         2
+    NORES            3
+    SECURITY         4
+    CLOSED           5
+
+    
+    CONNLOST         1
+    NOCONN           2
+    
+    THREAD           1
+    MEMORY           2
+    OBJECT           3
+    
+    SEEKGFAIL        1
+    READFAIL         2
+    SEEKPFAIL        3
+    WRITEFAIL        4
+    
+    ISBOUND          1
+    ISCONNECTED      2
+    INVAL            3
+    SIDINVAL         4
+    ISUNBOUND        5
+    NOLISTEN         6
+    ISRENDEZVOUS     7
+    ISRENDUNBOUND    8
+    INVALMSGAPI      9
+    INVALBUFFERAPI  10
+    BUSY            11
+    XSIZE           12
+    EIDINVAL        13
+    EEMPTY          14
+    BUSYPORT        15
+    
+    WRAVAIL          1
+    RDAVAIL          2
+    XMTIMEOUT        3
+    CONGESTION       4
+}
+
+
+set errortypes {
+
+    SUCCESS "Success" {
+        NONE      ""
+    }
+
+    SETUP "Connection setup failure" {
+        NONE      ""
+        TIMEOUT   "connection timed out"
+        REJECTED  "connection rejected"
+        NORES     "unable to create/configure SRT socket"
+        SECURITY  "aborted for security reasons"
+        CLOSED    "socket closed during operation"
+    }
+
+    CONNECTION "" {
+        NONE     ""
+        CONNLOST "Connection was broken"
+        NOCONN   "Connection does not exist"
+    }
+
+    SYSTEMRES "System resource failure" {
+        NONE   ""
+        THREAD "unable to create new threads"
+        MEMORY "unable to allocate buffers"
+        OBJECT "unable to allocate a system object"
+    }
+
+    FILESYSTEM "File system failure" {
+        NONE      ""
+        SEEKGFAIL "cannot seek read position"
+        READFAIL  "failure in read"
+        SEEKPFAIL "cannot seek write position"
+        WRITEFAIL "failure in write"
+    }
+
+    NOTSUP "Operation not supported" {
+        NONE           ""
+        ISBOUND        "Cannot do this operation on a BOUND socket"
+        ISCONNECTED    "Cannot do this operation on a CONNECTED socket"
+        INVAL          "Bad parameters"
+        SIDINVAL       "Invalid socket ID"
+        ISUNBOUND      "Cannot do this operation on an UNBOUND socket"
+        NOLISTEN       "Socket is not in listening state"
+        ISRENDEZVOUS   "Listen/accept is not supported in rendezvous connection setup"
+        ISRENDUNBOUND  "Cannot call connect on UNBOUND socket in rendezvous connection setup"
+        INVALMSGAPI    "Incorrect use of Message API (sendmsg/recvmsg)."
+        INVALBUFFERAPI "Incorrect use of Buffer API (send/recv) or File API (sendfile/recvfile)."
+        BUSY           "Another socket is already listening on the same port"
+        XSIZE          "Message is too large to send (it must be less than the SRT send buffer size)"
+        EIDINVAL       "Invalid epoll ID"
+        EEMPTY         "All sockets removed from epoll, waiting would deadlock"
+        BUSYPORT       "Another socket is bound to that port and is not reusable for requested settings"
+    }
+
+    AGAIN "Non-blocking call failure" {
+        NONE       ""
+        WRAVAIL    "no buffer available for sending"
+        RDAVAIL    "no data available for reading"
+        XMTIMEOUT  "transmission timed out"
+        CONGESTION "early congestion notification"        
+    }
+
+    PEERERROR "The peer side has signaled an error" {
+        NONE ""
+    }
+
+}
+
+set main_array_item {
+const char** strerror_array_major [] = {
+$minor_array_list
+};
+}
+
+set major_size_item {
+const size_t strerror_array_sizes [] = {
+$minor_array_sizes
+};
+}
+
+set minor_array_item {
+const char* strerror_msgs_$majorlc [] = {
+$minor_message_items
+};
+}
+
+set strerror_function {
+const char* strerror_get_message(size_t major, size_t minor)
+{
+    static const char* const undefined = "UNDEFINED ERROR";
+
+    // Extract the major array
+    if (major >= sizeof(strerror_array_major)/sizeof(const char**))
+    {
+        return undefined;
+    }
+
+    const char** array = strerror_array_major[major];
+    size_t size = strerror_array_sizes[major];
+
+    if (minor >= size)
+    {
+        return undefined;
+    }
+
+    return array[minor];
+}
+
+}
+
+set globalheader {
+ /*
+  WARNING: Generated from ../scripts/generate-error-types.tcl
+
+  DO NOT MODIFY.
+
+  Copyright applies as per the generator script.
+ */
+
+#include <cstddef>
+
+}
+
+proc Generate:imp {} {
+
+    puts $::globalheader
+
+    puts "namespace srt\n\{"
+
+    # Generate major array
+    set majitem 0
+    set minor_array_sizes ""
+    foreach {mt mm cont} $::errortypes {
+
+        puts "// MJ_$mt '$mm'"
+
+        # Generate minor array
+        set majorlc [string tolower $mt]
+        set minor_message_items ""
+        set minitem 0
+        foreach {mnt mnm} $cont {
+            if {$mm == ""} {
+                set msg $mnm
+            } elseif {$mnm == ""} {
+                set msg $mm
+            } else {
+                set msg "$mm: $mnm"
+            }
+            append minor_message_items "    \"$msg\", // MN_$mnt = $minitem\n"
+            incr minitem
+        }
+        append minor_message_items "    \"\""
+        puts [subst -nobackslashes -nocommands $::minor_array_item]
+
+        append minor_array_list "    strerror_msgs_$majorlc, // MJ_$mt = $majitem\n"
+        #append minor_array_sizes "    [expr {$minitem}],\n"
+        append minor_array_sizes "    SRT_ARRAY_SIZE(strerror_msgs_$majorlc) - 1,\n"
+        incr majitem
+    }
+    append minor_array_list "    NULL"
+    append minor_array_sizes "    0"
+
+    puts [subst -nobackslashes -nocommands $::main_array_item]
+    puts {#define SRT_ARRAY_SIZE(ARR) sizeof(ARR) / sizeof(ARR[0])}
+    puts [subst -nobackslashes -nocommands $::major_size_item]
+
+    puts $::strerror_function
+
+    puts "\} // namespace srt"
+}
+
+
+set defmode imp
+if {[lindex $argv 0] != ""} {
+    set defmode [lindex $argv 0]
+}
+
+Generate:$defmode
diff --git a/scripts/googletest-download.cmake b/scripts/googletest-download.cmake
index 55f2c5a55..7469f4f7b 100644
--- a/scripts/googletest-download.cmake
+++ b/scripts/googletest-download.cmake
@@ -11,7 +11,7 @@ ExternalProject_Add(
 	BINARY_DIR "@GOOGLETEST_DOWNLOAD_ROOT@/googletest-build"
 	GIT_REPOSITORY
 	https://github.com/google/googletest.git
-	GIT_TAG release-1.8.1
+	GIT_TAG release-1.10.0
 	CONFIGURE_COMMAND ""
 	BUILD_COMMAND ""
 	INSTALL_COMMAND ""
diff --git a/scripts/haiUtil.cmake b/scripts/haiUtil.cmake
index e161f1e5b..222661989 100644
--- a/scripts/haiUtil.cmake
+++ b/scripts/haiUtil.cmake
@@ -12,11 +12,11 @@ include(CheckCXXSourceCompiles)
 # Useful for combinging paths
 
 function(adddirname prefix lst out_lst)
-        set(output)
-        foreach(item ${lst})
-                list(APPEND output "${prefix}/${item}")
-        endforeach()
-        set(${out_lst} ${${out_lst}} ${output} PARENT_SCOPE)
+	set(output)
+	foreach(item ${lst})
+		list(APPEND output "${prefix}/${item}")
+	endforeach()
+	set(${out_lst} ${${out_lst}} ${output} PARENT_SCOPE)
 endfunction()
 
 # Splits a version formed as "major.minor.patch" recorded in variable 'prefix'
@@ -32,11 +32,11 @@ ENDMACRO(set_version_variables)
 # Sets given variable to 1, if the condition that follows it is satisfied.
 # Otherwise set it to 0.
 MACRO(set_if varname)
-   IF(${ARGN})
-     SET(${varname} 1)
-   ELSE(${ARGN})
-     SET(${varname} 0)
-   ENDIF(${ARGN})
+	IF(${ARGN})
+		SET(${varname} 1)
+	ELSE(${ARGN})
+		SET(${varname} 0)
+	ENDIF(${ARGN})
 ENDMACRO(set_if)
 
 FUNCTION(join_arguments outvar)
@@ -80,11 +80,11 @@ MACRO(MafReadDir directory maffile)
 	configure_file(${directory}/${maffile} dummy_${maffile}.cmake.out)
 	file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/dummy_${maffile}.cmake.out)
 
-    #message("DEBUG: MAF FILE CONTENTS: ${MAFREAD_CONTENTS}")
-    #message("DEBUG: PASSED VARIABLES:")
-    #foreach(DEBUG_VAR ${MAFREAD_TAGS})
-    #	message("DEBUG: ${DEBUG_VAR}=${MAFREAD_VAR_${DEBUG_VAR}}")
-    #endforeach()
+	#message("DEBUG: MAF FILE CONTENTS: ${MAFREAD_CONTENTS}")
+	#message("DEBUG: PASSED VARIABLES:")
+	#foreach(DEBUG_VAR ${MAFREAD_TAGS})
+	#	message("DEBUG: ${DEBUG_VAR}=${MAFREAD_VAR_${DEBUG_VAR}}")
+	#endforeach()
 
 	# The unnamed section becomes SOURCES
 	set (MAFREAD_VARIABLE ${MAFREAD_VAR_SOURCES})
@@ -186,15 +186,15 @@ MACRO(MafReadDir directory maffile)
 	ENDFOREACH()
 	
 	# Final debug report
-    #set (ALL_VARS "")
-    #message("DEBUG: extracted variables:")
-    #foreach(DEBUG_VAR ${MAFREAD_TAGS})
-    #	list(APPEND ALL_VARS ${MAFREAD_VAR_${DEBUG_VAR}})
-    #endforeach()
-    #list(REMOVE_DUPLICATES ALL_VARS)
-    #foreach(DEBUG_VAR ${ALL_VARS})
-    #	message("DEBUG: --> ${DEBUG_VAR} = ${${DEBUG_VAR}}")
-    #endforeach()
+	#set (ALL_VARS "")
+	#message("DEBUG: extracted variables:")
+	#foreach(DEBUG_VAR ${MAFREAD_TAGS})
+	#	list(APPEND ALL_VARS ${MAFREAD_VAR_${DEBUG_VAR}})
+	#endforeach()
+	#list(REMOVE_DUPLICATES ALL_VARS)
+	#foreach(DEBUG_VAR ${ALL_VARS})
+	#	message("DEBUG: --> ${DEBUG_VAR} = ${${DEBUG_VAR}}")
+	#endforeach()
 ENDMACRO(MafReadDir)
 
 # NOTE: This is historical only. Not in use.
@@ -214,9 +214,9 @@ MACRO(GetMafHeaders directory outvar)
 ENDMACRO(GetMafHeaders)
 
 function (getVarsWith _prefix _varResult)
-    get_cmake_property(_vars VARIABLES)
-    string (REGEX MATCHALL "(^|;)${_prefix}[A-Za-z0-9_]*" _matchedVars "${_vars}")
-    set (${_varResult} ${_matchedVars} PARENT_SCOPE)
+	get_cmake_property(_vars VARIABLES)
+	string (REGEX MATCHALL "(^|;)${_prefix}[A-Za-z0-9_]*" _matchedVars "${_vars}")
+	set (${_varResult} ${_matchedVars} PARENT_SCOPE)
 endfunction()
 
 function (check_testcode_compiles testcode libraries _successful)
@@ -228,15 +228,18 @@ function (check_testcode_compiles testcode libraries _successful)
 	set (CMAKE_REQUIRED_LIBRARIES ${save_required_libraries})
 endfunction()
 
-function (test_requires_clock_gettime _result)
+function (test_requires_clock_gettime _enable _linklib)
 	# This function tests if clock_gettime can be used
 	# - at all
 	# - with or without librt
 
 	# Result will be:
-	# rt (if librt required)
-	# "" (if no extra libraries required)
-	# -- killed by FATAL_ERROR if clock_gettime is not available
+	# - CLOCK_MONOTONIC is available, link with librt:
+	#   _enable = ON; _linklib = "-lrt".
+	# - CLOCK_MONOTONIC is available, link without librt:
+	#   _enable = ON; _linklib = "".
+	# - CLOCK_MONOTONIC is not available:
+	#   _enable = OFF; _linklib = "-".
 
 	set (code "
 		#include <time.h>
@@ -249,19 +252,23 @@ function (test_requires_clock_gettime _result)
 
 	check_testcode_compiles(${code} "" HAVE_CLOCK_GETTIME_IN)
 	if (HAVE_CLOCK_GETTIME_IN)
-		message(STATUS "Checked clock_gettime(): no extra libs needed")
-		set (${_result} "" PARENT_SCOPE)
+		message(STATUS "CLOCK_MONOTONIC: available, no extra libs needed")
+		set (${_enable}  ON PARENT_SCOPE)
+		set (${_linklib} "" PARENT_SCOPE)
 		return()
 	endif()
 
 	check_testcode_compiles(${code} "rt" HAVE_CLOCK_GETTIME_LIBRT)
 	if (HAVE_CLOCK_GETTIME_LIBRT)
-		message(STATUS "Checked clock_gettime(): requires -lrt")
-		set (${_result} "-lrt" PARENT_SCOPE)
+		message(STATUS "CLOCK_MONOTONIC: available, requires -lrt")
+		set (${_enable}  ON PARENT_SCOPE)
+		set (${_linklib} "-lrt" PARENT_SCOPE)
 		return()
 	endif()
 
-	message(FATAL_ERROR "clock_gettime() is not available on this system")
+	set (${_enable}  OFF PARENT_SCOPE)
+	set (${_linklib} "-" PARENT_SCOPE)
+	message(STATUS "CLOCK_MONOTONIC: not available on this system")
 endfunction()
 
 function (parse_compiler_type wct _type _suffix)
diff --git a/scripts/iOS.cmake b/scripts/iOS.cmake
index 73544a29b..1f2a04b50 100644
--- a/scripts/iOS.cmake
+++ b/scripts/iOS.cmake
@@ -35,7 +35,8 @@ set (CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING "Force unset of the deployment
 # Determine the cmake host system version so we know where to find the iOS SDKs
 find_program (CMAKE_UNAME uname /bin /usr/bin /usr/local/bin)
 if (CMAKE_UNAME)
-	exec_program(uname ARGS -r OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION)
+	execute_process(COMMAND uname -r
+			OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION)
 	string (REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1" DARWIN_MAJOR_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
 endif (CMAKE_UNAME)
 
@@ -119,7 +120,9 @@ endif (${IOS_PLATFORM} STREQUAL OS)
 
 # Setup iOS developer location unless specified manually with CMAKE_IOS_DEVELOPER_ROOT
 if (NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
-	exec_program(/usr/bin/xcode-select ARGS -print-path OUTPUT_VARIABLE CMAKE_XCODE_DEVELOPER_DIR)
+	execute_process(COMMAND /usr/bin/xcode-select -print-path
+			OUTPUT_VARIABLE CMAKE_XCODE_DEVELOPER_DIR)
+	string(STRIP "${CMAKE_XCODE_DEVELOPER_DIR}" CMAKE_XCODE_DEVELOPER_DIR) # FIXED: remove new line character, otherwise it complain no iOS SDK's found in default search path
 	set (CMAKE_IOS_DEVELOPER_ROOT "${CMAKE_XCODE_DEVELOPER_DIR}/Platforms/${IOS_PLATFORM_LOCATION}/Developer")
 endif (NOT DEFINED CMAKE_IOS_DEVELOPER_ROOT)
 set (CMAKE_IOS_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT} CACHE PATH "Location of iOS Platform")
@@ -151,10 +154,10 @@ if (NOT DEFINED IOS_ARCH)
 		set (IOS_ARCH x86_64)
 	endif (${IOS_PLATFORM} STREQUAL OS)
 endif(NOT DEFINED IOS_ARCH)
-set (CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE string  "Build architecture for iOS")
+set (CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE STRING "Build architecture for iOS")
 
 # Set the find root to the iOS developer roots and to user defined paths
-set (CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE string  "iOS find search path root")
+set (CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_IOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE STRING "iOS find search path root")
 
 # default to searching for frameworks first
 set (CMAKE_FIND_FRAMEWORK FIRST)
@@ -166,8 +169,8 @@ set (CMAKE_SYSTEM_FRAMEWORK_PATH
 	${CMAKE_IOS_SDK_ROOT}/Developer/Library/Frameworks
 )
 
-# only search the iOS sdks, not the remainder of the host filesystem
-set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+# only search the iOS sdks, not the remainder of the host filesystem (except for programs, so that we can still find Python if needed)
+set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
 set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
diff --git a/scripts/release-notes/README.md b/scripts/release-notes/README.md
new file mode 100644
index 000000000..d34b07bfa
--- /dev/null
+++ b/scripts/release-notes/README.md
@@ -0,0 +1,27 @@
+# Script Description
+
+Script designed to generate release notes template with main sections, contributors list, and detailed changelog out of `.csv` SRT git log file. The output `release-notes.md` file is generated in the root folder.
+
+In order to obtain the git log file since the previous release (e.g., v1.4.0), use the following command:
+
+```shell
+git log --pretty=format:"%h|%s|%an|%ae" v1.4.0...HEAD > commits.csv
+```
+
+Use the produced `commits.csv` file as an input to the script:
+
+```shell
+python scripts/release-notes/generate_release_notes.py commits.csv
+```
+
+The script produces `release-notes.md` as an output.
+
+
+## Requirements
+
+* Python 3.6+
+
+To install Python libraries use:
+```shell
+pip install -r requirements.txt
+```
diff --git a/scripts/changelog/changelog.py b/scripts/release-notes/generate_release_notes.py
similarity index 66%
rename from scripts/changelog/changelog.py
rename to scripts/release-notes/generate_release_notes.py
index fe41d5878..2392b4348 100644
--- a/scripts/changelog/changelog.py
+++ b/scripts/release-notes/generate_release_notes.py
@@ -47,22 +47,42 @@ def write_into_changelog(df, f):
     type=click.Path(exists=True)
 )
 def main(git_log):
-    """ Script designed to create changelog out of .csv SRT git log """
-
+    """
+    Script designed to generate release notes template with main sections,
+    contributors list, and detailed changelog out of .csv SRT git log file.
+    """
     df = pd.read_csv(git_log, sep = '|', names = ['commit', 'message', 'author', 'email'])
     df['area'] = df['message'].apply(define_area)
     df['message'] = df['message'].apply(delete_prefix)
 
-    core = df[df['area']=='core']
-    tests = df[df['area']=='tests']
-    build = df[df['area']=='build']
-    apps = df[df['area']=='apps']
-    docs = df[df['area']=='docs']
+    # Split commits by areas
+    core = df[df['area']==Area.core.value]
+    tests = df[df['area']==Area.tests.value]
+    build = df[df['area']==Area.build.value]
+    apps = df[df['area']==Area.apps.value]
+    docs = df[df['area']==Area.docs.value]
     other = df[df['area'].isna()]
 
-    with open('changelog.md', 'w') as f:
+    # Define individual contributors
+    contributors = df.groupby(['author', 'email'])
+    contributors = list(contributors.groups.keys())
+
+    with open('release-notes.md', 'w') as f:
         f.write('# Release Notes\n')
 
+        f.write('\n## API / ABI / Integration Changes\n')
+        f.write('\n**API/ABI version: 1.x.**\n')
+
+        f.write('\n## New Features and Improvements\n')
+        f.write('\n## Important Bug Fixes\n')
+        f.write('\n## Build\n')
+        f.write('\n## Documentation\n')
+
+        f.write('\n## Contributors\n')
+        for name, email in contributors:
+            f.write(f'\n{name} <{email}>')
+        f.write('\n')
+
         f.write('\n## Changelog\n')
         f.write('\n<details><summary>Click to expand/collapse</summary>')
         f.write('\n<p>')
diff --git a/scripts/changelog/requirements.txt b/scripts/release-notes/requirements.txt
similarity index 100%
rename from scripts/changelog/requirements.txt
rename to scripts/release-notes/requirements.txt
diff --git a/scripts/set-version-metadata.ps1 b/scripts/set-version-metadata.ps1
index cd36cc37d..050838e5e 100644
--- a/scripts/set-version-metadata.ps1
+++ b/scripts/set-version-metadata.ps1
@@ -27,6 +27,15 @@ if($Env:APPVEYOR){
 	Update-AppveyorBuild -Version "$majorVer.$minorVer.$patchVer.$buildNum"
 	$FileDescriptionBranchCommitValue = "$Env:APPVEYOR_REPO_NAME - $($Env:APPVEYOR_REPO_BRANCH) ($($Env:APPVEYOR_REPO_COMMIT.substring(0,8)))"
 }
+if($Env:TEAMCITY_VERSION){
+	#make TeamCity update with this new version number
+	Write-Output "##teamcity[buildNumber '$majorVer.$minorVer.$patchVer.$buildNum']"
+	Write-Output "##teamcity[setParameter name='MajorVersion' value='$majorVer']"
+	Write-Output "##teamcity[setParameter name='MinorVersion' value='$minorVer']"
+	Write-Output "##teamcity[setParameter name='PatchVersion' value='$patchVer']"
+	Write-Output "##teamcity[setParameter name='BuildVersion' value='$buildNum']"
+	$FileDescriptionBranchCommitValue = "$majorVer.$minorVer.$patchVer.$buildNum - ($($Env:BUILD_VCS_NUMBER.substring(0,8)))"
+}
 
 #find C++ resource files and update file description with branch / commit details
 $FileDescriptionStringRegex = '(\bVALUE\s+\"FileDescription\"\s*\,\s*\")([^\"]*\\\")*[^\"]*(\")'
diff --git a/scripts/srt-dev.lua b/scripts/srt-dev.lua
index 92b5fca1a..a90ac487d 100644
--- a/scripts/srt-dev.lua
+++ b/scripts/srt-dev.lua
@@ -115,7 +115,7 @@ fields.tsbpd_delay = ProtoField.uint16("srt_dev.tsbpd_delay", "TsbPd Delay", bas
 fields.rcv_tsbpd_delay = ProtoField.uint16("srt_dev.rcv_tsbpd_delay", "Receiver TsbPd Delay", base.DEC)
 fields.snd_tsbpd_delay = ProtoField.uint16("srt_dev.snd_tsbpd_delay", "Sender TsbPd Delay", base.DEC)
 
--- V adn PT status flag
+-- V and PT status flag
 local V_state_select = {
 	[1] = "Initial version"
 }
@@ -252,7 +252,7 @@ function srt_dev.dissector (tvb, pinfo, tree)
 					offset = offset + 4
 					
 					if UDT_version == 4 then
-						-- UDT version is 4, packet is diffrent from UDT version 5
+						-- UDT version is 4, packet is different from UDT version 5
 						-- Handle sock type
 						local sock_type = tvb(offset, 4):uint()
 						if sock_type == 1 then
diff --git a/scripts/test_vista.c b/scripts/test_vista.c
new file mode 100644
index 000000000..833a4d373
--- /dev/null
+++ b/scripts/test_vista.c
@@ -0,0 +1,10 @@
+/* Copyright © 2023 Steve Lhomme */
+/* SPDX-License-Identifier: ISC */
+#include <windows.h>
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600 /* _WIN32_WINNT_VISTA */
+#error NOPE
+#endif
+int main(void)
+{
+    return 0;
+}
diff --git a/scripts/visionOS.cmake b/scripts/visionOS.cmake
new file mode 100644
index 000000000..0f0f60b69
--- /dev/null
+++ b/scripts/visionOS.cmake
@@ -0,0 +1,171 @@
+# This file is based off of the Platform/Darwin.cmake and Platform/UnixPaths.cmake
+# files which are included with CMake 2.8.4
+# It has been altered for VISIONOS development
+
+# Options:
+#
+# VISION_PLATFORM = OS (default) or SIMULATOR or SIMULATOR64
+#   This decides if SDKS will be selected from the XROS.platform or XRSimulator.platform folders
+#   OS - the default, used to build for Vision Pro physical device, which have an arm arch.
+#   SIMULATOR - used to build for the Simulator platforms, which have an x86 arch.
+#
+# VISIONOS_ARCH = arm64 (default for OS), x86_64 (addiitonal support for SIMULATOR64)
+#
+# CMAKE_VISIONOS_DEVELOPER_ROOT = automatic(default) or /path/to/platform/Developer folder
+#   By default this location is automatcially chosen based on the VISIONOS_PLATFORM value above.
+#   If set manually, it will override the default location and force the user of a particular Developer Platform
+#
+# CMAKE_VISIONOS_SDK_ROOT = automatic(default) or /path/to/platform/Developer/SDKs/SDK folder
+#   By default this location is automatcially chosen based on the CMAKE_VISIONOS_DEVELOPER_ROOT value.
+#   In this case it will always be the most up-to-date SDK found in the CMAKE_VISIONOS_DEVELOPER_ROOT path.
+#   If set manually, this will force the use of a specific SDK version
+#
+
+# Standard settings
+set (CMAKE_SYSTEM_NAME Darwin)
+set (CMAKE_SYSTEM_VERSION 1)
+set (UNIX True)
+set (APPLE True)
+set (VISIONOS True)
+
+# Required as of cmake 2.8.10
+set (CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING "Force unset of the deployment target for visionOs" FORCE)
+
+# Determine the cmake host system version so we know where to find the visionOS SDKs
+find_program (CMAKE_UNAME uname /bin /usr/bin /usr/local/bin)
+if (CMAKE_UNAME)
+	execute_process(COMMAND uname -r
+			OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION)
+	string (REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1" DARWIN_MAJOR_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
+endif (CMAKE_UNAME)
+
+
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+set(CMAKE_AR ar CACHE FILEPATH "" FORCE)
+
+set (CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
+set (CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
+set (CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
+set (CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
+
+if (CMAKE_BUILD_TYPE STREQUAL "Debug" OR ENABLE_DEBUG)
+	set(VISIONOS_DEBUG_OPTIONS "-glldb -gmodules")
+else()
+	set(VISIONOS_DEBUG_OPTIONS "-fvisibility=hidden -fvisibility-inlines-hidden")
+endif()	
+
+set (CMAKE_C_FLAGS_INIT "${VISIONOS_DEBUG_OPTIONS} ${EMBED_OPTIONS}")
+set (CMAKE_CXX_FLAGS_INIT "${VISIONOS_DEBUG_OPTIONS} ${EMBED_OPTIONS}")
+
+set (CMAKE_C_LINK_FLAGS "-Wl,-search_paths_first ${EMBED_OPTIONS} ${CMAKE_C_LINK_FLAGS}")
+set (CMAKE_CXX_LINK_FLAGS "-Wl,-search_paths_first ${EMBED_OPTIONS} ${CMAKE_CXX_LINK_FLAGS}")
+
+
+set (CMAKE_PLATFORM_HAS_INSTALLNAME 1)
+set (CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib")
+set (CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle")
+set (CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
+set (CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
+set (CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
+
+# Specify install_name_tool and pkg-config since it outside of SDK path and therefore can't be found by CMake
+if (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+	find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool)
+endif (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+
+if (NOT DEFINED PKG_CONFIG_EXECUTABLE)
+	find_program(PKG_CONFIG_EXECUTABLE NAMES pkg-config)
+	if (DEFINED PKG_CONFIG_EXECUTABLE)
+		execute_process(COMMAND pkg-config --version OUTPUT_VARIABLE PKG_CONFIG_VERSION_STRING)
+	endif(DEFINED PKG_CONFIG_EXECUTABLE)
+endif(NOT DEFINED PKG_CONFIG_EXECUTABLE) 
+
+
+# fffio Specify path to install shared library on device
+set (CMAKE_INSTALL_NAME_DIR  "@executable_path/Frameworks")
+set (CMAKE_BUILD_WITH_INSTALL_NAME_DIR TRUE)
+
+# Setup visionOS platform unless specified manually with VISIONOS_PLATFORM
+if (NOT DEFINED VISIONOS_PLATFORM)
+	set (VISIONOS_PLATFORM "OS")
+endif (NOT DEFINED VISIONOS_PLATFORM)
+set (VISIONOS_PLATFORM ${VISIONOS_PLATFORM} CACHE STRING "Type of visionOS Platform")
+
+# Check the platform selection and setup for developer root
+if (${VISIONOS_PLATFORM} STREQUAL OS)
+	set (VISIONOS_PLATFORM_LOCATION "XROS.platform")
+
+	# This causes the installers to properly locate the output libraries
+	set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-xros")
+elseif (${VISIONOS_PLATFORM} STREQUAL SIMULATOR)
+    set (SIMULATOR true)
+	set (VISIONOS_PLATFORM_LOCATION "XRSimulator.platform")
+
+	# This causes the installers to properly locate the output libraries
+	set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-xrsimulator")
+elseif (${VISIONOS_PLATFORM} STREQUAL SIMULATOR64)
+    set (SIMULATOR true)
+	set (VISIONOS_PLATFORM_LOCATION "XRSimulator.platform")
+
+	# This causes the installers to properly locate the output libraries
+	set (CMAKE_XCODE_EFFECTIVE_PLATFORMS "-xrsimulator")
+else (${VISIONOS_PLATFORM} STREQUAL OS)
+	message (FATAL_ERROR "Unsupported VISIONOS_PLATFORM value selected. Please choose OS or SIMULATOR")
+endif (${VISIONOS_PLATFORM} STREQUAL OS)
+
+# Setup visionOS developer location unless specified manually with CMAKE_VISIONOS_DEVELOPER_ROOT
+if (NOT DEFINED CMAKE_VISIONOS_DEVELOPER_ROOT)
+	execute_process(COMMAND /usr/bin/xcode-select -print-path
+			OUTPUT_VARIABLE CMAKE_XCODE_DEVELOPER_DIR)
+	string(STRIP "${CMAKE_XCODE_DEVELOPER_DIR}" CMAKE_XCODE_DEVELOPER_DIR) # FIXED: remove new line character, otherwise it complain no visionOS SDK's found in default search path
+	set (CMAKE_VISIONOS_DEVELOPER_ROOT "${CMAKE_XCODE_DEVELOPER_DIR}/Platforms/${VISIONOS_PLATFORM_LOCATION}/Developer")
+endif (NOT DEFINED CMAKE_VISIONOS_DEVELOPER_ROOT)
+set (CMAKE_VISIONOS_DEVELOPER_ROOT ${CMAKE_VISIONOS_DEVELOPER_ROOT} CACHE PATH "Location of visionOS Platform")
+
+# Find and use the most recent visionOS sdk unless specified manually with CMAKE_VISIONOS_SDK_ROOT
+if (NOT DEFINED CMAKE_VISIONOS_SDK_ROOT)
+	file (GLOB _CMAKE_VISIONOS_SDKS "${CMAKE_VISIONOS_DEVELOPER_ROOT}/SDKs/*")
+	if (_CMAKE_VISIONOS_SDKS) 
+		list (SORT _CMAKE_VISIONOS_SDKS)
+		list (REVERSE _CMAKE_VISIONOS_SDKS)
+		list (GET _CMAKE_VISIONOS_SDKS 0 CMAKE_VISIONOS_SDK_ROOT)
+	else (_CMAKE_VISIONOS_SDKS)
+		message (FATAL_ERROR "No visionOS SDK's found in default search path ${CMAKE_VISIONOS_DEVELOPER_ROOT}. Manually set CMAKE_VISIONOS_SDK_ROOT or install the visionOS SDK.")
+	endif (_CMAKE_VISIONOS_SDKS)
+	message (STATUS "Toolchain using default visionOS SDK: ${CMAKE_VISIONOS_SDK_ROOT}")
+endif (NOT DEFINED CMAKE_VISIONOS_SDK_ROOT)
+set (CMAKE_VISIONOS_SDK_ROOT ${CMAKE_VISIONOS_SDK_ROOT} CACHE PATH "Location of the selected visionOS SDK")
+
+# Set the sysroot default to the most recent SDK
+set (CMAKE_OSX_SYSROOT ${CMAKE_VISIONOS_SDK_ROOT} CACHE PATH "Sysroot used for visionOS support")
+
+# set the architecture for visionOS 
+if (NOT DEFINED VISIONOS_ARCH)
+	if (${VISIONOS_PLATFORM} STREQUAL OS)
+		set (VISIONOS_ARCH arm64)
+	elseif (${VISIONOS_PLATFORM} STREQUAL SIMULATOR)
+		set (VISIONOS_ARCH arm64)
+	elseif (${VISIONOS_PLATFORM} STREQUAL SIMULATOR64)
+		set (VISIONOS_ARCH x86_64)
+	endif (${VISIONOS_PLATFORM} STREQUAL OS)
+endif(NOT DEFINED VISIONOS_ARCH)
+set (CMAKE_OSX_ARCHITECTURES ${VISIONOS_ARCH} CACHE STRING "Build architecture for visionOS")
+
+# Set the find root to the visionOS developer roots and to user defined paths
+set (CMAKE_FIND_ROOT_PATH ${CMAKE_VISIONOS_DEVELOPER_ROOT} ${CMAKE_VISIONOS_SDK_ROOT} ${CMAKE_PREFIX_PATH} CACHE STRING "visionOS find search path root")
+
+# default to searching for frameworks first
+set (CMAKE_FIND_FRAMEWORK FIRST)
+
+# set up the default search directories for frameworks
+set (CMAKE_SYSTEM_FRAMEWORK_PATH
+	${CMAKE_VISIONOS_SDK_ROOT}/System/Library/Frameworks
+	${CMAKE_VISIONOS_SDK_ROOT}/System/Library/PrivateFrameworks
+	${CMAKE_VISIONOS_SDK_ROOT}/Developer/Library/Frameworks
+)
+
+# only search the visionOS sdks, not the remainder of the host filesystem (except for programs, so that we can still find Python if needed)
+set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
+set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
diff --git a/scripts/win-installer/.gitignore b/scripts/win-installer/.gitignore
new file mode 100644
index 000000000..ed44eef33
--- /dev/null
+++ b/scripts/win-installer/.gitignore
@@ -0,0 +1,10 @@
+tmp
+installers
+*.exe
+*~
+~*
+.#*
+*.bak
+*.autosave
+.DS_Store
+._*
diff --git a/scripts/win-installer/README.md b/scripts/win-installer/README.md
new file mode 100644
index 000000000..ff54df258
--- /dev/null
+++ b/scripts/win-installer/README.md
@@ -0,0 +1,123 @@
+# SRT Static Libraries Installer for Windows
+
+This directory contains scripts to build a binary installer for
+libsrt on Windows systems for Visual Studio applications using SRT.
+
+## SRT developer: Building the libsrt installer
+
+### Prerequisites
+
+These first two steps need to be executed once only.
+
+- Prerequisite 1: Install OpenSSL for Windows, both 64 and 32 bits.
+  This can be done automatically by running the PowerShell script `install-openssl.ps1`.
+
+- Prerequisite 2: Install NSIS, the NullSoft Installation Scripting system.
+  This can be done automatically by running the PowerShell script `install-nsis.ps1`.
+
+### Building the libsrt installer
+
+To build the libsrt installer, simply run the PowerShell script `build-win-installer.ps1`.
+Running it without parameters, for instance launching it from the Windows Explorer, is
+sufficient to build the installer.
+
+Optional parameters:
+
+- `-Version name` :
+  Use the specified string as version number for libsrt. By default, if the
+  current commit has a tag, use that tag (initial "v" removed, for instance
+  `1.4.3`). Otherwise, the defaut version is a detailed version number (most
+  recent version, number of commits since then, short commit SHA, for instance
+  `1.4.3-32-g22cc924`). Use that option if necessary to specify some other
+  non-standard form of version string.
+  
+- `-NoPause` :
+  Do not wait for the user to press `<enter>` at end of execution. By default,
+  execute a `pause` instruction at the end of execution, which is useful
+  when the script was launched from Windows Explorer. Use that option when the
+  script is invoked from another PowerShell script.
+
+The installer is then available in the directory `installers`.
+
+The name of the installer is `libsrt-VERS.exe` where `VERS` is the SRT version number
+(see the `-Version` option).
+
+The installer shall then be published as a release asset in the `srt` repository
+on GitHub, either as `libsrt-VERS.exe` or `libsrt-VERS-win-installer.zip`.
+In the latter case, the archive shall contain `libsrt-VERS.exe`.
+
+## SRT user: Using the libsrt installer
+
+### Installing the SRT libraries
+
+To install the SRT libraries, simply run the `libsrt-VERS.exe` installer which is
+available in the [SRT release area](https://github.com/Haivision/srt/releases).
+
+After installing the libsrt binaries, an environment variable named `LIBSRT` is
+defined with the installation root (typically `C:\Program Files (x86)\libsrt`).
+
+If there is a need for automation, in a CI/CD pipeline for instance, the download
+of the latest `libsrt-VERS.exe` and its installation can be automated using the
+sample PowerShell script `install-libsrt.ps1` which is available in this directory.
+This script may be freely copied in the user's build environment.
+
+When run without parameters (for instance from the Windows explorer), this
+script downloads and installs the latest version of libsrt.
+
+Optional parameters:
+
+- `-Destination path` :
+  Specify a local directory where the libsrt package will be downloaded.
+  By default, use the `tmp` subdirectory from this script's directory.
+
+- `-ForceDownload` :
+  Force a download even if the package is already downloaded in the
+  destination path. Note that the latest version is always checked.
+  If a older package is already present but a newer one is available
+  online, the newer one is always downloaded, even without this option.
+
+- `-GitHubActions` :
+  When used in a GitHub Actions workflow, make sure that the `LIBSRT`
+  environment variable is propagated to subsequent jobs. In your GitHub
+  workflow, in the initial setup phase, use 
+  `script-dir\install-libsrt.ps1 -GitHubActions -NoPause`.
+
+- `-NoInstall` :
+  Do not install the package, only download it. By default, libsrt is installed.
+
+- `-NoPause` :
+  Do not wait for the user to press `<enter>` at end of execution. By default,
+  execute a `pause` instruction at the end of execution, which is useful
+  when the script was launched from Windows Explorer. Use that option when the
+  script is invoked from another PowerShell script.
+
+### Building Windows applications with libsrt
+
+In the SRT installation root directory (specified in environment variable `LIBSRT`),
+there is a Visual Studio property file named `libsrt.props`. Simply reference this
+property file in your Visual Studio project to use libsrt.
+
+You can also do that manually by editing the application project file (the XML
+file named with a `.vcxproj` extension). Add the following line just before
+the end of the file:
+
+~~~
+<Import Project="$(LIBSRT)\libsrt.props"/>
+~~~
+
+With this setup, just compile your application normally, either using the
+Visual Studio IDE or the MSBuild command line tool.
+
+## Files reference
+
+This directory contains the following files:
+
+| File name               | Usage
+| ----------------------- | -----
+| build-win-installer.ps1 | PowerShell script to build the libsrt installer.
+| install-libsrt.ps1      | Sample PowerShell script to automatically install libsrt (for user's projects).
+| install-openssl.ps1     | PowerShell script to install OpenSSL (prerequisite to build the installer).
+| install-nsis.ps1        | PowerShell script to install NSIS (prerequisite to build the installer).
+| libsrt.nsi              | NSIS installation script (used to build the installer).
+| libsrt.props            | Visual Studio property files to use libsrt (embedded in the installer).
+| README.md               | This text file.
diff --git a/scripts/win-installer/build-win-installer.ps1 b/scripts/win-installer/build-win-installer.ps1
new file mode 100644
index 000000000..4265edf8e
--- /dev/null
+++ b/scripts/win-installer/build-win-installer.ps1
@@ -0,0 +1,227 @@
+#-----------------------------------------------------------------------------
+#
+#  SRT - Secure, Reliable, Transport
+#  Copyright (c) 2021, Thierry Lelegard
+# 
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+#-----------------------------------------------------------------------------
+
+<#
+ .SYNOPSIS
+
+  Build the SRT static libraries installer for Windows.
+
+ .PARAMETER Version
+
+  Use the specified string as version number from libsrt. By default, if
+  the current commit has a tag, use that tag (initial 'v' removed). Otherwise,
+  the defaut version is a detailed version number (most recent version, number
+  of commits since then, short commit SHA).
+
+ .PARAMETER NoPause
+
+  Do not wait for the user to press <enter> at end of execution. By default,
+  execute a "pause" instruction at the end of execution, which is useful
+  when the script was run from Windows Explorer.
+
+#>
+[CmdletBinding()]
+param(
+    [string]$Version = "",
+    [switch]$NoPause = $false
+)
+Write-Output "Building the SRT static libraries installer for Windows"
+
+# Directory containing this script:
+$ScriptDir = $PSScriptRoot
+
+# The root of the srt repository is two levels up.
+$RepoDir = (Split-Path -Parent (Split-Path -Parent $ScriptDir))
+
+# Output directory for final installers:
+$OutDir = "$ScriptDir\installers"
+
+# Temporary directory for build operations:
+$TmpDir = "$ScriptDir\tmp"
+
+
+#-----------------------------------------------------------------------------
+# A function to exit this script with optional error message, using -NoPause
+#-----------------------------------------------------------------------------
+
+function Exit-Script([string]$Message = "")
+{
+    $Code = 0
+    if ($Message -ne "") {
+        Write-Output "ERROR: $Message"
+        $Code = 1
+    }
+    if (-not $NoPause) {
+        pause
+    }
+    exit $Code
+}
+
+
+#-----------------------------------------------------------------------------
+# Build SRT version strings
+#-----------------------------------------------------------------------------
+
+# By default, let git format a decent version number.
+if (-not $Version) {
+    $Version = (git describe --tags ) -replace '-g','-'
+}
+$Version = $Version -replace '^v',''
+
+# Split version string in pieces and make sure to get at least four elements.
+$VField = ($Version -split "[-\. ]") + @("0", "0", "0", "0") | Select-String -Pattern '^\d*$'
+$VersionInfo = "$($VField[0]).$($VField[1]).$($VField[2]).$($VField[3])"
+
+Write-Output "SRT version: $Version"
+Write-Output "Windows version info: $VersionInfo"
+
+
+#-----------------------------------------------------------------------------
+# Initialization phase, verify prerequisites
+#-----------------------------------------------------------------------------
+
+# Locate OpenSSL root from local installation.
+$SslRoot = @{
+    "x64" = "C:\Program Files\OpenSSL-Win64";
+    "Win32" = "C:\Program Files (x86)\OpenSSL-Win32"
+}
+
+# Verify OpenSSL directories.
+$Missing = 0
+foreach ($file in @($SslRoot["x64"], $SslRoot["Win32"])) {
+    if (-not (Test-Path $file)) {
+        Write-Output "**** Missing $file"
+        $Missing = $Missing + 1
+    }
+}
+if ($Missing -gt 0) {
+    Exit-Script "Missing $Missing OpenSSL files, use install-openssl.ps1 to install OpenSSL"
+}
+
+# Locate MSBuild and CMake, regardless of Visual Studio version.
+Write-Output "Searching MSBuild ..."
+$MSRoots = @("C:\Program Files*\MSBuild", "C:\Program Files*\Microsoft Visual Studio", "C:\Program Files*\CMake*")
+$MSBuild = Get-ChildItem -Recurse -Path $MSRoots -Include MSBuild.exe -ErrorAction Ignore |
+    ForEach-Object { (Get-Command $_).FileVersionInfo } |
+    Sort-Object -Unique -Property FileVersion |
+    ForEach-Object { $_.FileName} |
+    Select-Object -Last 1
+if (-not $MSBuild) {
+    Exit-Script "MSBuild not found"
+}
+
+Write-Output "Searching CMake ..."
+$CMake = Get-ChildItem -Recurse -Path $MSRoots -Include cmake.exe -ErrorAction Ignore |
+    ForEach-Object { (Get-Command $_).FileVersionInfo } |
+    Sort-Object -Unique -Property FileVersion |
+    ForEach-Object { $_.FileName} |
+    Select-Object -Last 1
+if (-not $CMake) {
+    Exit-Script "CMake not found, check option 'C++ CMake tools for Windows' in Visual Studio installer"
+}
+
+# Locate NSIS, the Nullsoft Scriptable Installation System.
+Write-Output "Searching NSIS ..."
+$NSIS = Get-Item "C:\Program Files*\NSIS\makensis.exe" | ForEach-Object { $_.FullName} | Select-Object -Last 1
+if (-not $NSIS) {
+    Exit-Script "NSIS not found, use install-nsis.ps1 to install NSIS"
+}
+
+Write-Output "MSBuild: $MSBuild"
+Write-Output "CMake: $CMake"
+Write-Output "NSIS: $NSIS"
+
+# Create the directories for builds when necessary.
+[void](New-Item -Path $TmpDir -ItemType Directory -Force)
+[void](New-Item -Path $OutDir -ItemType Directory -Force)
+
+
+#-----------------------------------------------------------------------------
+# Configure and build SRT library using CMake on two architectures.
+#-----------------------------------------------------------------------------
+
+foreach ($Platform in @("x64", "Win32")) {
+
+    # Build directory. Cleanup to force a fresh cmake config.
+    $BuildDir = "$TmpDir\build.$Platform"
+    Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $BuildDir
+    [void](New-Item -Path $BuildDir -ItemType Directory -Force)
+
+    # Run CMake.
+    Write-Output "Configuring build for platform $Platform ..."
+    $SRoot = $SslRoot[$Platform]
+    & $CMake -S $RepoDir -B $BuildDir -A $Platform `
+        -DENABLE_STDCXX_SYNC=ON `
+        -DOPENSSL_ROOT_DIR="$SRoot" `
+        -DOPENSSL_LIBRARIES="$SRoot\lib\libssl_static.lib;$SRoot\lib\libcrypto_static.lib" `
+        -DOPENSSL_INCLUDE_DIR="$SRoot\include"
+
+    # Patch version string in version.h
+    Get-Content "$BuildDir\version.h" |
+        ForEach-Object {
+            $_ -replace "#define *SRT_VERSION_STRING .*","#define SRT_VERSION_STRING `"$Version`""
+        } |
+        Out-File "$BuildDir\version.new" -Encoding ascii
+    Move-Item "$BuildDir\version.new" "$BuildDir\version.h" -Force
+
+    # Compile SRT.
+    Write-Output "Building for platform $Platform ..."
+    foreach ($Conf in @("Release", "Debug")) {
+        & $MSBuild "$BuildDir\SRT.sln" /nologo /maxcpucount /property:Configuration=$Conf /property:Platform=$Platform /target:srt_static
+    }
+}
+
+# Verify the presence of compiled libraries.
+Write-Output "Checking compiled libraries ..."
+$Missing = 0
+foreach ($Conf in @("Release", "Debug")) {
+    foreach ($Platform in @("x64", "Win32")) {
+        $Path = "$TmpDir\build.$Platform\$Conf\srt_static.lib"
+        if (-not (Test-Path $Path)) {
+            Write-Output "**** Missing $Path"
+            $Missing = $Missing + 1
+        }
+    }
+}
+if ($Missing -gt 0) {
+    Exit-Script "Missing $Missing files"
+}
+
+
+#-----------------------------------------------------------------------------
+# Build the binary installer.
+#-----------------------------------------------------------------------------
+
+$InstallExe = "$OutDir\libsrt-$Version.exe"
+$InstallZip = "$OutDir\libsrt-$Version-win-installer.zip"
+
+Write-Output "Building installer ..."
+& $NSIS /V2 `
+    /DVersion="$Version" `
+    /DVersionInfo="$VersionInfo" `
+    /DOutDir="$OutDir" `
+    /DBuildRoot="$TmpDir" `
+    /DRepoDir="$RepoDir" `
+    "$ScriptDir\libsrt.nsi" 
+
+if (-not (Test-Path $InstallExe)) {
+    Exit-Script "**** Missing $InstallExe"
+}
+
+Write-Output "Building installer archive ..."
+Remove-Item -Force -ErrorAction SilentlyContinue $InstallZip
+Compress-Archive -Path $InstallExe -DestinationPath $InstallZip -CompressionLevel Optimal
+
+if (-not (Test-Path $InstallZip)) {
+    Exit-Script "**** Missing $InstallZip"
+}
+
+Exit-Script
diff --git a/scripts/win-installer/install-libsrt.ps1 b/scripts/win-installer/install-libsrt.ps1
new file mode 100644
index 000000000..ae1b8133e
--- /dev/null
+++ b/scripts/win-installer/install-libsrt.ps1
@@ -0,0 +1,131 @@
+# SRT library download and install for Windows.
+# Copyright (c) 2021, Thierry Lelegard
+# All rights reserved.
+
+<#
+ .SYNOPSIS
+
+  Download and install the libsrt library for Windows. This script is
+  provided to automate the build of Windows applications using libsrt.
+
+ .PARAMETER Destination
+
+  Specify a local directory where the libsrt package will be downloaded.
+  By default, use "tmp" subdirectory from this script.
+
+ .PARAMETER ForceDownload
+
+  Force a download even if the package is already downloaded.
+
+ .PARAMETER GitHubActions
+
+  When used in a GitHub Actions workflow, make sure that the LIBSRT
+  environment variable is propagated to subsequent jobs.
+
+ .PARAMETER NoInstall
+
+  Do not install the package. By default, libsrt is installed.
+
+ .PARAMETER NoPause
+
+  Do not wait for the user to press <enter> at end of execution. By default,
+  execute a "pause" instruction at the end of execution, which is useful
+  when the script was run from Windows Explorer.
+#>
+[CmdletBinding(SupportsShouldProcess=$true)]
+param(
+    [string]$Destination = "",
+    [switch]$ForceDownload = $false,
+    [switch]$GitHubActions = $false,
+    [switch]$NoInstall = $false,
+    [switch]$NoPause = $false
+)
+
+Write-Output "libsrt download and installation procedure"
+
+# Default directory for downloaded products.
+if (-not $Destination) {
+    $Destination = "$PSScriptRoot\tmp"
+}
+
+# A function to exit this script.
+function Exit-Script([string]$Message = "")
+{
+    $Code = 0
+    if ($Message -ne "") {
+        Write-Output "ERROR: $Message"
+        $Code = 1
+    }
+    if (-not $NoPause) {
+        pause
+    }
+    exit $Code
+}
+
+# Without this, Invoke-WebRequest is awfully slow.
+$ProgressPreference = 'SilentlyContinue'
+
+# Get the URL of the latest libsrt installer.
+$URL = (Invoke-RestMethod "https://api.github.com/repos/Haivision/srt/releases?per_page=20" |
+        ForEach-Object { $_.assets } |
+        ForEach-Object { $_.browser_download_url } |
+        Select-String @("/libsrt-.*\.exe$", "/libsrt-.*-win-installer\.zip$") |
+        Select-Object -First 1)
+
+if (-not $URL) {
+    Exit-Script "Could not find a libsrt installer on GitHub"
+}
+if (-not ($URL -match "\.zip$") -and -not ($URL -match "\.exe$")) {
+    Exit-Script "Unexpected URL, not .exe, not .zip: $URL"
+}
+
+# Installer name and path.
+$InstName = (Split-Path -Leaf $URL)
+$InstPath = "$Destination\$InstName"
+
+# Create the directory for downloaded products when necessary.
+[void](New-Item -Path $Destination -ItemType Directory -Force)
+
+# Download installer
+if (-not $ForceDownload -and (Test-Path $InstPath)) {
+    Write-Output "$InstName already downloaded, use -ForceDownload to download again"
+}
+else {
+    Write-Output "Downloading $URL ..."
+    Invoke-WebRequest $URL.ToString() -UseBasicParsing -UserAgent Download -OutFile $InstPath
+    if (-not (Test-Path $InstPath)) {
+        Exit-Script "$URL download failed"
+    }
+}
+
+# If installer is an archive, expect an exe with same name inside.
+if ($InstName -match "\.zip$") {
+
+    # Expected installer name in archive.
+    $ZipName = $InstName
+    $ZipPath = $InstPath
+    $InstName = $ZipName -replace '-win-installer.zip','.exe'
+    $InstPath = "$Destination\$InstName"
+
+    # Extract the installer.
+    Remove-Item -Force $InstPath -ErrorAction SilentlyContinue
+    Write-Output "Expanding $ZipName ..."
+    Expand-Archive $ZipPath -DestinationPath $Destination
+    if (-not (Test-Path $InstPath)) {
+        Exit-Script "$InstName not found in $ZipName"
+    }
+}
+
+# Install libsrt
+if (-not $NoInstall) {
+    Write-Output "Installing $InstName"
+    Start-Process -FilePath $InstPath -ArgumentList @("/S") -Wait
+}
+
+# Propagate LIBSRT in next jobs for GitHub Actions.
+if ($GitHubActions -and (-not -not $env:GITHUB_ENV) -and (Test-Path $env:GITHUB_ENV)) {
+    $libsrt = [System.Environment]::GetEnvironmentVariable("LIBSRT","Machine")
+    Write-Output "LIBSRT=$libsrt" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+}
+
+Exit-Script
diff --git a/scripts/win-installer/install-nsis.ps1 b/scripts/win-installer/install-nsis.ps1
new file mode 100644
index 000000000..14879b521
--- /dev/null
+++ b/scripts/win-installer/install-nsis.ps1
@@ -0,0 +1,122 @@
+#-----------------------------------------------------------------------------
+#
+#  SRT - Secure, Reliable, Transport
+#  Copyright (c) 2021, Thierry Lelegard
+# 
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+#-----------------------------------------------------------------------------
+
+<#
+ .SYNOPSIS
+
+  Download, expand and install NSIS, the NullSoft Installer Scripting.
+
+ .PARAMETER ForceDownload
+
+  Force a download even if NSIS is already downloaded.
+
+ .PARAMETER NoInstall
+
+  Do not install the NSIS package. By default, NSIS is installed.
+
+ .PARAMETER NoPause
+
+  Do not wait for the user to press <enter> at end of execution. By default,
+  execute a "pause" instruction at the end of execution, which is useful
+  when the script was run from Windows Explorer.
+#>
+[CmdletBinding(SupportsShouldProcess=$true)]
+param(
+    [switch]$ForceDownload = $false,
+    [switch]$NoInstall = $false,
+    [switch]$NoPause = $false
+)
+
+Write-Output "NSIS download and installation procedure"
+$NSISPage = "https://nsis.sourceforge.io/Download"
+$FallbackURL = "http://prdownloads.sourceforge.net/nsis/nsis-3.05-setup.exe?download"
+
+# A function to exit this script.
+function Exit-Script([string]$Message = "")
+{
+    $Code = 0
+    if ($Message -ne "") {
+        Write-Output "ERROR: $Message"
+        $Code = 1
+    }
+    if (-not $NoPause) {
+        pause
+    }
+    exit $Code
+}
+
+# Local file names.
+$RootDir = $PSScriptRoot
+$TmpDir = "$RootDir\tmp"
+
+# Create the directory for external products when necessary.
+[void] (New-Item -Path $TmpDir -ItemType Directory -Force)
+
+# Without this, Invoke-WebRequest is awfully slow.
+$ProgressPreference = 'SilentlyContinue'
+
+# Get the HTML page for NSIS downloads.
+$status = 0
+$message = ""
+$Ref = $null
+try {
+    $response = Invoke-WebRequest -UseBasicParsing -UserAgent Download -Uri $NSISPage
+    $status = [int] [Math]::Floor($response.StatusCode / 100)
+}
+catch {
+    $message = $_.Exception.Message
+}
+
+if ($status -ne 1 -and $status -ne 2) {
+    # Error fetch NSIS download page.
+    if ($message -eq "" -and (Test-Path variable:response)) {
+        Write-Output "Status code $($response.StatusCode), $($response.StatusDescription)"
+    }
+    else {
+        Write-Output "#### Error accessing ${NSISPage}: $message"
+    }
+}
+else {
+    # Parse HTML page to locate the latest installer.
+    $Ref = $response.Links.href | Where-Object { $_ -like "*/nsis-*-setup.exe?download" } | Select-Object -First 1
+}
+
+if (-not $Ref) {
+    # Could not find a reference to NSIS installer.
+    $Url = [System.Uri]$FallbackURL
+}
+else {
+    # Build the absolute URL's from base URL (the download page) and href links.
+    $Url = New-Object -TypeName 'System.Uri' -ArgumentList ([System.Uri]$NSISPage, $Ref)
+}
+
+$InstallerName = (Split-Path -Leaf $Url.LocalPath)
+$InstallerPath = "$TmpDir\$InstallerName"
+
+# Download installer
+if (-not $ForceDownload -and (Test-Path $InstallerPath)) {
+    Write-Output "$InstallerName already downloaded, use -ForceDownload to download again"
+}
+else {
+    Write-Output "Downloading $Url ..."
+    Invoke-WebRequest -UseBasicParsing -UserAgent Download -Uri $Url -OutFile $InstallerPath
+    if (-not (Test-Path $InstallerPath)) {
+        Exit-Script "$Url download failed"
+    }
+}
+
+# Install NSIS
+if (-not $NoInstall) {
+    Write-Output "Installing $InstallerName"
+    Start-Process -FilePath $InstallerPath -ArgumentList @("/S") -Wait
+}
+
+Exit-Script
diff --git a/scripts/win-installer/install-openssl.ps1 b/scripts/win-installer/install-openssl.ps1
new file mode 100644
index 000000000..83b59954f
--- /dev/null
+++ b/scripts/win-installer/install-openssl.ps1
@@ -0,0 +1,119 @@
+#-----------------------------------------------------------------------------
+#
+#  SRT - Secure, Reliable, Transport
+#  Copyright (c) 2021, Thierry Lelegard
+# 
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+#-----------------------------------------------------------------------------
+
+<#
+ .SYNOPSIS
+
+  Download, expand and install OpenSSL for Windows.
+
+ .PARAMETER ForceDownload
+
+  Force a download even if the OpenSSL installers are already downloaded.
+
+ .PARAMETER NoInstall
+
+  Do not install the OpenSSL packages. By default, OpenSSL is installed.
+
+ .PARAMETER NoPause
+
+  Do not wait for the user to press <enter> at end of execution. By default,
+  execute a "pause" instruction at the end of execution, which is useful
+  when the script was run from Windows Explorer.
+#>
+[CmdletBinding(SupportsShouldProcess=$true)]
+param(
+    [switch]$ForceDownload = $false,
+    [switch]$NoInstall = $false,
+    [switch]$NoPause = $false
+)
+
+Write-Output "OpenSSL download and installation procedure"
+$OpenSSLHomePage = "http://slproweb.com/products/Win32OpenSSL.html"
+
+# A function to exit this script.
+function Exit-Script([string]$Message = "")
+{
+    $Code = 0
+    if ($Message -ne "") {
+        Write-Output "ERROR: $Message"
+        $Code = 1
+    }
+    if (-not $NoPause) {
+        pause
+    }
+    exit $Code
+}
+
+# Local file names.
+$RootDir = $PSScriptRoot
+$TmpDir = "$RootDir\tmp"
+
+# Create the directory for external products when necessary.
+[void] (New-Item -Path $TmpDir -ItemType Directory -Force)
+
+# Without this, Invoke-WebRequest is awfully slow.
+$ProgressPreference = 'SilentlyContinue'
+
+# Get the HTML page for OpenSSL downloads.
+$status = 0
+$message = ""
+try {
+    $response = Invoke-WebRequest -UseBasicParsing -UserAgent Download -Uri $OpenSSLHomePage
+    $status = [int] [Math]::Floor($response.StatusCode / 100)
+}
+catch {
+    $message = $_.Exception.Message
+}
+if ($status -ne 1 -and $status -ne 2) {
+    if ($message -eq "" -and (Test-Path variable:response)) {
+        Exit-Script "Status code $($response.StatusCode), $($response.StatusDescription)"
+    }
+    else {
+        Exit-Script "#### Error accessing ${OpenSSLHomePage}: $message"
+    }
+}
+
+# Parse HTML page to locate the latest MSI files.
+$Ref32 = $response.Links.href | Where-Object { $_ -like "*/Win32OpenSSL-*.msi" } | Select-Object -First 1
+$Ref64 = $response.Links.href | Where-Object { $_ -like "*/Win64OpenSSL-*.msi" } | Select-Object -First 1
+
+# Build the absolute URL's from base URL (the download page) and href links.
+$Url32 = New-Object -TypeName 'System.Uri' -ArgumentList ([System.Uri]$OpenSSLHomePage, $Ref32)
+$Url64 = New-Object -TypeName 'System.Uri' -ArgumentList ([System.Uri]$OpenSSLHomePage, $Ref64)
+
+# Download and install one MSI package.
+function Download-Install([string]$Url)
+{
+    $MsiName = (Split-Path -Leaf $Url.toString())
+    $MsiPath = "$TmpDir\$MsiName"
+
+    if (-not $ForceDownload -and (Test-Path $MsiPath)) {
+        Write-Output "$MsiName already downloaded, use -ForceDownload to download again"
+    }
+    else {
+        Write-Output "Downloading $Url ..."
+        Invoke-WebRequest -UseBasicParsing -UserAgent Download -Uri $Url -OutFile $MsiPath
+    }
+
+    if (-not (Test-Path $MsiPath)) {
+        Exit-Script "$Url download failed"
+    }
+
+    if (-not $NoInstall) {
+        Write-Output "Installing $MsiName"
+        Start-Process msiexec.exe -ArgumentList @("/i", $MsiPath, "/qn", "/norestart") -Wait
+    }
+}
+
+# Download and install the two MSI packages.
+Download-Install $Url32
+Download-Install $Url64
+Exit-Script
diff --git a/scripts/win-installer/libsrt.nsi b/scripts/win-installer/libsrt.nsi
new file mode 100644
index 000000000..1dffc3fd1
--- /dev/null
+++ b/scripts/win-installer/libsrt.nsi
@@ -0,0 +1,219 @@
+;-----------------------------------------------------------------------------
+;
+; SRT - Secure, Reliable, Transport
+; Copyright (c) 2021, Thierry Lelegard
+; 
+; This Source Code Form is subject to the terms of the Mozilla Public
+; License, v. 2.0. If a copy of the MPL was not distributed with this
+; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;
+;-----------------------------------------------------------------------------
+;
+; NSIS script to build the SRT binary installer for Windows.
+; Do not invoke NSIS directly, use PowerShell script build-win-installer.ps1
+; to ensure that all parameters are properly passed.
+;
+;-----------------------------------------------------------------------------
+
+Name "SRT"
+Caption "SRT Libraries Installer"
+
+!verbose push
+!verbose 0
+!include "MUI2.nsh"
+!include "Sections.nsh"
+!include "TextFunc.nsh"
+!include "FileFunc.nsh"
+!include "WinMessages.nsh"
+!include "x64.nsh"
+!verbose pop
+
+!define ProductName "libsrt"
+!define Build32Dir  "${BuildRoot}\build.Win32"
+!define Build64Dir  "${BuildRoot}\build.x64"
+!define SSL32Dir    "C:\Program Files (x86)\OpenSSL-Win32"
+!define SSL64Dir    "C:\Program Files\OpenSSL-Win64"
+
+; Installer file information.
+VIProductVersion ${VersionInfo}
+VIAddVersionKey ProductName "${ProductName}"
+VIAddVersionKey ProductVersion "${Version}"
+VIAddVersionKey Comments "The SRT static libraries for Visual C++ on Windows"
+VIAddVersionKey CompanyName "Haivision"
+VIAddVersionKey LegalCopyright "Copyright (c) 2021 Haivision Systems Inc."
+VIAddVersionKey FileVersion "${VersionInfo}"
+VIAddVersionKey FileDescription "SRT Installer"
+
+; Name of binary installer file.
+OutFile "${OutDir}\${ProductName}-${Version}.exe"
+
+; Generate a Unicode installer (default is ANSI).
+Unicode true
+
+; Registry key for environment variables
+!define EnvironmentKey '"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
+
+; Registry entry for product info and uninstallation info.
+!define ProductKey "Software\${ProductName}"
+!define UninstallKey "Software\Microsoft\Windows\CurrentVersion\Uninstall\${ProductName}"
+
+; Use XP manifest.
+XPStyle on
+
+; Request administrator privileges for Windows Vista and higher.
+RequestExecutionLevel admin
+
+; "Modern User Interface" (MUI) settings.
+!define MUI_ABORTWARNING
+
+; Default installation folder.
+InstallDir "$PROGRAMFILES\${ProductName}"
+
+; Get installation folder from registry if available from a previous installation.
+InstallDirRegKey HKLM "${ProductKey}" "InstallDir"
+
+; Installer pages.
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+
+; Uninstaller pages.
+!insertmacro MUI_UNPAGE_CONFIRM
+!insertmacro MUI_UNPAGE_INSTFILES
+
+; Languages.
+!insertmacro MUI_LANGUAGE "English"
+
+; Installation initialization.
+function .onInit
+    ; In 64-bit installers, don't use registry redirection.
+    ${If} ${RunningX64}
+        SetRegView 64
+    ${EndIf}
+functionEnd
+
+; Uninstallation initialization.
+function un.onInit
+    ; In 64-bit installers, don't use registry redirection.
+    ${If} ${RunningX64}
+        SetRegView 64
+    ${EndIf}
+functionEnd
+
+; Installation section
+Section "Install"
+
+    ; Work on "all users" context, not current user.
+    SetShellVarContext all
+
+    ; Delete obsolete files from previous versions.
+    Delete "$INSTDIR\LICENSE.pthread.txt"
+    Delete "$INSTDIR\include\srt\srt4udt.h"
+    Delete "$INSTDIR\include\srt\udt.h"
+    Delete "$INSTDIR\lib\Release-x64\pthread.lib"
+    Delete "$INSTDIR\lib\Release-Win32\pthread.lib"
+    Delete "$INSTDIR\lib\Debug-x64\srt.pdb"
+    Delete "$INSTDIR\lib\Debug-x64\pthread.pdb"
+    Delete "$INSTDIR\lib\Debug-x64\pthread.lib"
+    Delete "$INSTDIR\lib\Debug-Win32\srt.pdb"
+    Delete "$INSTDIR\lib\Debug-Win32\pthread.pdb"
+    Delete "$INSTDIR\lib\Debug-Win32\pthread.lib"
+
+    SetOutPath "$INSTDIR"
+    File /oname=LICENSE.txt "${RepoDir}\LICENSE"
+    File "libsrt.props"
+
+    ; Header files.
+    CreateDirectory "$INSTDIR\include\srt"
+    SetOutPath "$INSTDIR\include\srt"
+    File "${RepoDir}\srtcore\access_control.h"
+    File "${RepoDir}\srtcore\logging_api.h"
+    File "${RepoDir}\srtcore\platform_sys.h"
+    File "${RepoDir}\srtcore\srt.h"
+    File "${RepoDir}\srtcore\udt.h"
+    File "${Build64Dir}\version.h"
+
+    CreateDirectory "$INSTDIR\include\win"
+    SetOutPath "$INSTDIR\include\win"
+    File "${RepoDir}\common\win\syslog_defs.h"
+
+    ; Libraries.
+    CreateDirectory "$INSTDIR\lib"
+    
+    CreateDirectory "$INSTDIR\lib\Release-x64"
+    SetOutPath "$INSTDIR\lib\Release-x64"
+    File /oname=srt.lib       "${Build64Dir}\Release\srt_static.lib"
+    File /oname=libcrypto.lib "${SSL64Dir}\lib\VC\static\libcrypto64MD.lib"
+    File /oname=libssl.lib    "${SSL64Dir}\lib\VC\static\libssl64MD.lib"
+
+    CreateDirectory "$INSTDIR\lib\Debug-x64"
+    SetOutPath "$INSTDIR\lib\Debug-x64"
+    File /oname=srt.lib       "${Build64Dir}\Debug\srt_static.lib"
+    File /oname=libcrypto.lib "${SSL64Dir}\lib\VC\static\libcrypto64MDd.lib"
+    File /oname=libssl.lib    "${SSL64Dir}\lib\VC\static\libssl64MDd.lib"
+
+    CreateDirectory "$INSTDIR\lib\Release-Win32"
+    SetOutPath "$INSTDIR\lib\Release-Win32"
+    File /oname=srt.lib       "${Build32Dir}\Release\srt_static.lib"
+    File /oname=libcrypto.lib "${SSL32Dir}\lib\VC\static\libcrypto32MD.lib"
+    File /oname=libssl.lib    "${SSL32Dir}\lib\VC\static\libssl32MD.lib"
+
+    CreateDirectory "$INSTDIR\lib\Debug-Win32"
+    SetOutPath "$INSTDIR\lib\Debug-Win32"
+    File /oname=srt.lib       "${Build32Dir}\Debug\srt_static.lib"
+    File /oname=libcrypto.lib "${SSL32Dir}\lib\VC\static\libcrypto32MDd.lib"
+    File /oname=libssl.lib    "${SSL32Dir}\lib\VC\static\libssl32MDd.lib"
+
+    ; Add an environment variable to installation root.
+    WriteRegStr HKLM ${EnvironmentKey} "LIBSRT" "$INSTDIR"
+
+    ; Store installation folder in registry.
+    WriteRegStr HKLM "${ProductKey}" "InstallDir" $INSTDIR
+
+    ; Create uninstaller
+    WriteUninstaller "$INSTDIR\Uninstall.exe"
+ 
+    ; Declare uninstaller in "Add/Remove Software" control panel
+    WriteRegStr HKLM "${UninstallKey}" "DisplayName" "${ProductName}"
+    WriteRegStr HKLM "${UninstallKey}" "Publisher" "Haivision"
+    WriteRegStr HKLM "${UninstallKey}" "URLInfoAbout" "https://github.com/Haivision/srt"
+    WriteRegStr HKLM "${UninstallKey}" "DisplayVersion" "${Version}"
+    WriteRegStr HKLM "${UninstallKey}" "DisplayIcon" "$INSTDIR\Uninstall.exe"
+    WriteRegStr HKLM "${UninstallKey}" "UninstallString" "$INSTDIR\Uninstall.exe"
+
+    ; Get estimated size of installed files
+    ${GetSize} "$INSTDIR" "/S=0K" $0 $1 $2
+    IntFmt $0 "0x%08X" $0
+    WriteRegDWORD HKLM "${UninstallKey}" "EstimatedSize" "$0"
+
+    ; Notify applications of environment modifications
+    SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+SectionEnd
+
+; Uninstallation section
+Section "Uninstall"
+
+    ; Work on "all users" context, not current user.
+    SetShellVarContext all
+
+    ; Get installation folder from registry
+    ReadRegStr $0 HKLM "${ProductKey}" "InstallDir"
+
+    ; Delete product registry entries
+    DeleteRegKey HKCU "${ProductKey}"
+    DeleteRegKey HKLM "${ProductKey}"
+    DeleteRegKey HKLM "${UninstallKey}"
+    DeleteRegValue HKLM ${EnvironmentKey} "LIBSRT"
+
+    ; Delete product files.
+    RMDir /r "$0\include"
+    RMDir /r "$0\lib"
+    Delete "$0\libsrt.props"
+    Delete "$0\LICENSE*"
+    Delete "$0\Uninstall.exe"
+    RMDir "$0"
+
+    ; Notify applications of environment modifications
+    SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+SectionEnd
diff --git a/scripts/win-installer/libsrt.props b/scripts/win-installer/libsrt.props
new file mode 100644
index 000000000..b1da74879
--- /dev/null
+++ b/scripts/win-installer/libsrt.props
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Visual Studio or MSBuild property file to use SRT static library -->
+
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!-- Normalize platform name to x64 and Win32 (some projects use x86 or Win64) -->
+  <Choose>
+    <When Condition="'$(Platform)' == 'x86'">
+      <PropertyGroup Label="UserMacros">
+        <SrtPlatform>Win32</SrtPlatform>
+      </PropertyGroup>
+    </When>
+    <When Condition="'$(Platform)' == 'Win64'">
+      <PropertyGroup Label="UserMacros">
+        <SrtPlatform>x64</SrtPlatform>
+      </PropertyGroup>
+    </When>
+    <Otherwise>
+      <PropertyGroup Label="UserMacros">
+        <SrtPlatform>$(Platform)</SrtPlatform>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+
+  <!-- Compilation and link options -->
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(LIBSRT)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>srt.lib;libssl.lib;libcrypto.lib;crypt32.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(LIBSRT)\lib\$(Configuration)-$(SrtPlatform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalOptions>/ignore:4099 %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+
+</Project>
diff --git a/sonar-project.properties b/sonar-project.properties
index 22b16d549..d11323df8 100644
--- a/sonar-project.properties
+++ b/sonar-project.properties
@@ -19,7 +19,6 @@ sonar.organization=haivision
 # =====================================================
 
 sonar.links.homepage=https://github.com/Haivision/srt
-sonar.links.ci=https://travis-ci.org/Haivision/srt
 sonar.links.scm=https://github.com/Haivision/srt
 sonar.links.issue=https://github.com/Haivision/srt/issues
 
@@ -29,8 +28,9 @@ sonar.links.issue=https://github.com/Haivision/srt/issues
 # =====================================================
 
 # SQ standard properties
-sonar.sources=.
+sonar.sources=srtcore/,apps/,common/,examples/,haicrypt/,scripts/,testing/
+sonar.tests=test/
 
 # Properties specific to the C/C++ analyzer:
-sonar.cfamily.build-wrapper-output=bw-output
+sonar.cfamily.build-wrapper-output=_build/sonar-output
 sonar.cfamily.gcov.reportsPath=.
diff --git a/srtcore/access_control.h b/srtcore/access_control.h
index 97a1104a8..611e1dad8 100644
--- a/srtcore/access_control.h
+++ b/srtcore/access_control.h
@@ -41,7 +41,7 @@ written by
 // CODE NOT IN USE 408: unused: no timeout predicted for listener callback
 #define SRT_REJX_CONFLICT 1409  // The resource being accessed is already locked for modification. This is in case of m=publish and the specified resource is currently read-only.
 // CODE NOT IN USE 410: unused: treated as a specific case of 404
-// CODE NOT IN USE 411: unused: no reason to include lenght in the protocol
+// CODE NOT IN USE 411: unused: no reason to include length in the protocol
 // CODE NOT IN USE 412: unused: preconditions not predicted in AC
 // CODE NOT IN USE 413: unused: AC size is already defined as 512
 // CODE NOT IN USE 414: unused: AC size is already defined as 512
diff --git a/srtcore/api.cpp b/srtcore/api.cpp
index 2e9c4014b..bb5dd64fe 100644
--- a/srtcore/api.cpp
+++ b/srtcore/api.cpp
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -70,75 +70,65 @@ modified by
 #include "udt.h"
 
 #ifdef _WIN32
-   #include <win/wintime.h>
+#include <win/wintime.h>
 #endif
 
 #ifdef _MSC_VER
-   #pragma warning(error: 4530)
+#pragma warning(error : 4530)
 #endif
 
 using namespace std;
 using namespace srt_logging;
 using namespace srt::sync;
-extern LogConfig srt_logger_config;
 
-
-void CUDTSocket::construct()
+void srt::CUDTSocket::construct()
 {
-#if ENABLE_EXPERIMENTAL_BONDING
-   m_IncludedGroup = NULL;
-   m_IncludedIter = CUDTGroup::gli_NULL();
+#if ENABLE_BONDING
+    m_GroupOf         = NULL;
+    m_GroupMemberData = NULL;
 #endif
-   setupMutex(m_AcceptLock, "Accept");
-   setupCond(m_AcceptCond, "Accept");
-   setupMutex(m_ControlLock, "Control");
+    setupMutex(m_AcceptLock, "Accept");
+    setupCond(m_AcceptCond, "Accept");
+    setupMutex(m_ControlLock, "Control");
 }
 
-CUDTSocket::~CUDTSocket()
+srt::CUDTSocket::~CUDTSocket()
 {
-
-   delete m_pUDT;
-   m_pUDT = NULL;
-
-   delete m_pQueuedSockets;
-   delete m_pAcceptSockets;
-
-   releaseMutex(m_AcceptLock);
-   releaseCond(m_AcceptCond);
-   releaseMutex(m_ControlLock);
+    releaseMutex(m_AcceptLock);
+    releaseCond(m_AcceptCond);
+    releaseMutex(m_ControlLock);
 }
 
-
-SRT_SOCKSTATUS CUDTSocket::getStatus()
+SRT_SOCKSTATUS srt::CUDTSocket::getStatus()
 {
     // TTL in CRendezvousQueue::updateConnStatus() will set m_bConnecting to false.
     // Although m_Status is still SRTS_CONNECTING, the connection is in fact to be closed due to TTL expiry.
     // In this case m_bConnected is also false. Both checks are required to avoid hitting
     // a regular state transition from CONNECTING to CONNECTED.
 
-    if (m_pUDT->m_bBroken)
+    if (m_UDT.m_bBroken)
         return SRTS_BROKEN;
 
     // Connecting timed out
-    if ((m_Status == SRTS_CONNECTING) && !m_pUDT->m_bConnecting && !m_pUDT->m_bConnected)
+    if ((m_Status == SRTS_CONNECTING) && !m_UDT.m_bConnecting && !m_UDT.m_bConnected)
         return SRTS_BROKEN;
 
     return m_Status;
 }
 
 // [[using locked(m_GlobControlLock)]]
-void CUDTSocket::breakSocket_LOCKED()
+void srt::CUDTSocket::breakSocket_LOCKED()
 {
     // This function is intended to be called from GC,
-    // under a lock of m_GlobControlLock. 
-    m_pUDT->m_bBroken = true;
-    m_pUDT->m_iBrokenCounter = 0;
+    // under a lock of m_GlobControlLock.
+    m_UDT.m_bBroken        = true;
+    m_UDT.m_iBrokenCounter = 0;
     HLOGC(smlog.Debug, log << "@" << m_SocketID << " CLOSING AS SOCKET");
-    m_pUDT->closeInternal();
+    m_UDT.closeInternal();
     setClosed();
 }
 
-void CUDTSocket::setClosed()
+void srt::CUDTSocket::setClosed()
 {
     m_Status = SRTS_CLOSED;
 
@@ -149,79 +139,64 @@ void CUDTSocket::setClosed()
     m_tsClosureTimeStamp = steady_clock::now();
 }
 
-void CUDTSocket::setBrokenClosed()
+void srt::CUDTSocket::setBrokenClosed()
 {
-    m_pUDT->m_iBrokenCounter = 60;
-    m_pUDT->m_bBroken = true;
+    m_UDT.m_iBrokenCounter = 60;
+    m_UDT.m_bBroken        = true;
     setClosed();
 }
 
-bool CUDTSocket::readReady()
+bool srt::CUDTSocket::readReady()
 {
-    if (m_pUDT->m_bConnected && m_pUDT->m_pRcvBuffer->isRcvDataReady())
+    if (m_UDT.m_bConnected && m_UDT.isRcvBufferReady())
         return true;
-    if (m_pUDT->m_bListening)
-    {
-        return m_pQueuedSockets->size() > 0;
-    }
+
+    if (m_UDT.m_bListening)
+        return !m_QueuedSockets.empty();
 
     return broken();
 }
 
-bool CUDTSocket::writeReady()
+bool srt::CUDTSocket::writeReady() const
 {
-    return (m_pUDT->m_bConnected
-                && (m_pUDT->m_pSndBuffer->getCurrBufSize() < m_pUDT->m_iSndBufSize))
-        || broken();
+    return (m_UDT.m_bConnected && (m_UDT.m_pSndBuffer->getCurrBufSize() < m_UDT.m_config.iSndBufSize)) || broken();
 }
 
-bool CUDTSocket::broken()
+bool srt::CUDTSocket::broken() const
 {
-    return m_pUDT->m_bBroken || !m_pUDT->m_bConnected;
+    return m_UDT.m_bBroken || !m_UDT.m_bConnected;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-CUDTUnited::CUDTUnited():
-m_Sockets(),
-m_GlobControlLock(),
-m_IDLock(),
-m_mMultiplexer(),
-m_MultiplexerLock(),
-m_pCache(NULL),
-m_bClosing(false),
-m_GCStopCond(),
-m_InitLock(),
-m_iInstanceCount(0),
-m_bGCStatus(false),
-m_ClosedSockets()
-{
-   // Socket ID MUST start from a random value
-   // Note. Don't use CTimer here, because s_UDTUnited is a static instance of CUDTUnited
-   // with dynamic initialization (calling this constructor), while CTimer has
-   // a static member s_ullCPUFrequency with dynamic initialization.
-   // The order of initialization is not guaranteed.
-   timeval t;
-
-   gettimeofday(&t, 0);
-   srand((unsigned int)t.tv_usec);
-
-   const double rand1_0 = double(rand())/RAND_MAX;
-
-   m_SocketIDGenerator = 1 + int(MAX_SOCKET_VAL * rand1_0);
-   m_SocketIDGenerator_init = m_SocketIDGenerator;
-
-   // XXX An unlikely exception thrown from the below calls
-   // might destroy the application before `main`. This shouldn't
-   // be a problem in general.
-   setupMutex(m_GlobControlLock, "GlobControl");
-   setupMutex(m_IDLock, "ID");
-   setupMutex(m_InitLock, "Init");
-
-   m_pCache = new CCache<CInfoBlock>;
-}
-
-CUDTUnited::~CUDTUnited()
+srt::CUDTUnited::CUDTUnited()
+    : m_Sockets()
+    , m_GlobControlLock()
+    , m_IDLock()
+    , m_mMultiplexer()
+    , m_pCache(new CCache<CInfoBlock>)
+    , m_bClosing(false)
+    , m_GCStopCond()
+    , m_InitLock()
+    , m_iInstanceCount(0)
+    , m_bGCStatus(false)
+    , m_ClosedSockets()
+{
+    // Socket ID MUST start from a random value
+    m_SocketIDGenerator      = genRandomInt(1, MAX_SOCKET_VAL);
+    m_SocketIDGenerator_init = m_SocketIDGenerator;
+
+    // XXX An unlikely exception thrown from the below calls
+    // might destroy the application before `main`. This shouldn't
+    // be a problem in general.
+    setupMutex(m_GCStopLock, "GCStop");
+    setupCond(m_GCStopCond, "GCStop");
+    setupMutex(m_GlobControlLock, "GlobControl");
+    setupMutex(m_IDLock, "ID");
+    setupMutex(m_InitLock, "Init");
+}
+
+srt::CUDTUnited::~CUDTUnited()
 {
     // Call it if it wasn't called already.
     // This will happen at the end of main() of the application,
@@ -234,13 +209,23 @@ CUDTUnited::~CUDTUnited()
     releaseMutex(m_GlobControlLock);
     releaseMutex(m_IDLock);
     releaseMutex(m_InitLock);
+    // XXX There's some weird bug here causing this
+    // to hangup on Windows. This might be either something
+    // bigger, or some problem in pthread-win32. As this is
+    // the application cleanup section, this can be temporarily
+    // tolerated with simply exit the application without cleanup,
+    // counting on that the system will take care of it anyway.
+#ifndef _WIN32
+    releaseCond(m_GCStopCond);
+#endif
+    releaseMutex(m_GCStopLock);
 
     delete m_pCache;
 }
 
-std::string CUDTUnited::CONID(SRTSOCKET sock)
+string srt::CUDTUnited::CONID(SRTSOCKET sock)
 {
-    if ( sock == 0 )
+    if (sock == 0)
         return "";
 
     std::ostringstream os;
@@ -248,88 +233,82 @@ std::string CUDTUnited::CONID(SRTSOCKET sock)
     return os.str();
 }
 
-int CUDTUnited::startup()
+int srt::CUDTUnited::startup()
 {
-   ScopedLock gcinit(m_InitLock);
+    ScopedLock gcinit(m_InitLock);
+    if (m_bGCStatus)
+        return 1;
 
-   if (m_iInstanceCount++ > 0)
-      return 1;
+    if (m_iInstanceCount++ > 0)
+        return 1;
 
-   // Global initialization code
+        // Global initialization code
 #ifdef _WIN32
-   WORD wVersionRequested;
-   WSADATA wsaData;
-   wVersionRequested = MAKEWORD(2, 2);
+    WORD    wVersionRequested;
+    WSADATA wsaData;
+    wVersionRequested = MAKEWORD(2, 2);
 
-   if (0 != WSAStartup(wVersionRequested, &wsaData))
-      throw CUDTException(MJ_SETUP, MN_NONE,  WSAGetLastError());
+    if (0 != WSAStartup(wVersionRequested, &wsaData))
+        throw CUDTException(MJ_SETUP, MN_NONE, WSAGetLastError());
 #endif
 
-   PacketFilter::globalInit();
+    CCryptoControl::globalInit();
+
+    PacketFilter::globalInit();
 
-   if (m_bGCStatus)
-      return 1;
+    m_bClosing = false;
 
-   m_bClosing = false;
+    if (!StartThread(m_GCThread, garbageCollect, this, "SRT:GC"))
+        return -1;
 
-   try
-   {
-       setupMutex(m_GCStopLock, "GCStop");
-       setupCond(m_GCStopCond, "GCStop");
-   }
-   catch (...)
-   {
-       return -1;
-   }
-   if (!StartThread(m_GCThread, garbageCollect, this, "SRT:GC"))
-      return -1;
+    m_bGCStatus = true;
 
-   m_bGCStatus = true;
+    HLOGC(inlog.Debug, log << "SRT Clock Type: " << SRT_SYNC_CLOCK_STR);
 
-   return 0;
+    return 0;
 }
 
-int CUDTUnited::cleanup()
+int srt::CUDTUnited::cleanup()
 {
-   ScopedLock gcinit(m_InitLock);
-
-   if (--m_iInstanceCount > 0)
-      return 0;
+    // IMPORTANT!!!
+    // In this function there must be NO LOGGING AT ALL.  This function may
+    // potentially be called from within the global program destructor, and
+    // therefore some of the facilities used by the logging system - including
+    // the default std::cerr object bound to it by default, but also a different
+    // stream that the user's app has bound to it, and which got destroyed
+    // together with already exited main() - may be already deleted when
+    // executing this procedure.
+    ScopedLock gcinit(m_InitLock);
 
-   if (!m_bGCStatus)
-      return 0;
+    if (--m_iInstanceCount > 0)
+        return 0;
 
-   m_bClosing = true;
-   HLOGC(inlog.Debug, log << "GarbageCollector: thread EXIT");
-   // NOTE: we can do relaxed signaling here because
-   // waiting on m_GCStopCond has a 1-second timeout,
-   // after which the m_bClosing flag is cheched, which
-   // is set here above. Worst case secenario, this
-   // pthread_join() call will block for 1 second.
-   CSync::signal_relaxed(m_GCStopCond);
-   m_GCThread.join();
+    if (!m_bGCStatus)
+        return 0;
 
-   // XXX There's some weird bug here causing this
-   // to hangup on Windows. This might be either something
-   // bigger, or some problem in pthread-win32. As this is
-   // the application cleanup section, this can be temporarily
-   // tolerated with simply exit the application without cleanup,
-   // counting on that the system will take care of it anyway.
-#ifndef _WIN32
-   releaseCond(m_GCStopCond);
-#endif
+    {
+        UniqueLock gclock(m_GCStopLock);
+        m_bClosing = true;
+    }
+    // NOTE: we can do relaxed signaling here because
+    // waiting on m_GCStopCond has a 1-second timeout,
+    // after which the m_bClosing flag is cheched, which
+    // is set here above. Worst case secenario, this
+    // pthread_join() call will block for 1 second.
+    CSync::notify_one_relaxed(m_GCStopCond);
+    m_GCThread.join();
 
-   m_bGCStatus = false;
+    m_bGCStatus = false;
 
-   // Global destruction code
+    // Global destruction code
 #ifdef _WIN32
-   WSACleanup();
+    WSACleanup();
 #endif
 
-   return 0;
+    return 0;
 }
 
-SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
+SRTSOCKET srt::CUDTUnited::generateSocketID(bool for_group)
 {
     ScopedLock guard(m_IDLock);
 
@@ -341,7 +320,8 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
     {
         // We have a rollover on the socket value, so
         // definitely we haven't made the Columbus mistake yet.
-        m_SocketIDGenerator = MAX_SOCKET_VAL-1;
+        m_SocketIDGenerator = MAX_SOCKET_VAL;
+        sockval = MAX_SOCKET_VAL;
     }
 
     // Check all sockets if any of them has this value.
@@ -357,7 +337,7 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
     // and reaches the same value from the opposite side.
     // This is still a valid socket value, but this time
     // we have to check, which sockets have been used already.
-    if ( sockval == m_SocketIDGenerator_init )
+    if (sockval == m_SocketIDGenerator_init)
     {
         // Mark that since this point on the checks for
         // whether the socket ID is in use must be done.
@@ -367,14 +347,14 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
     // This is when all socket numbers have been already used once.
     // This may happen after many years of running an application
     // constantly when the connection breaks and gets restored often.
-    if ( m_SocketIDGenerator_init == 0 )
+    if (m_SocketIDGenerator_init == 0)
     {
         int startval = sockval;
         for (;;) // Roll until an unused value is found
         {
             enterCS(m_GlobControlLock);
             const bool exists =
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
                 for_group
                 ? m_Groups.count(sockval | SRTGROUP_MASK)
                 :
@@ -387,7 +367,7 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
                 // The socket value is in use.
                 --sockval;
                 if (sockval <= 0)
-                    sockval = MAX_SOCKET_VAL-1;
+                    sockval = MAX_SOCKET_VAL;
 
                 // Before continuing, check if we haven't rolled back to start again
                 // This is virtually impossible, so just make an RTI error.
@@ -399,7 +379,7 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
                     // never happen". This should make the socket creation functions, from
                     // socket_create and accept, return this error.
 
-                    m_SocketIDGenerator = sockval+1; // so that any next call will cause the same error
+                    m_SocketIDGenerator = sockval + 1; // so that any next call will cause the same error
                     throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
                 }
 
@@ -431,448 +411,450 @@ SRTSOCKET CUDTUnited::generateSocketID(bool for_group)
     return sockval;
 }
 
-SRTSOCKET CUDTUnited::newSocket(CUDTSocket** pps)
-{
-   // XXX consider using some replacement of std::unique_ptr
-   // so that exceptions will clean up the object without the
-   // need for a dedicated code.
-   CUDTSocket* ns = NULL;
-
-   try
-   {
-      ns = new CUDTSocket;
-      ns->m_pUDT = new CUDT(ns);
-   }
-   catch (...)
-   {
-      delete ns;
-      throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-
-   try
-   {
-      ns->m_SocketID = generateSocketID();
-   }
-   catch (...)
-   {
-       delete ns;
-       throw;
-   }
-   ns->m_Status = SRTS_INIT;
-   ns->m_ListenSocket = 0;
-   ns->m_pUDT->m_SocketID = ns->m_SocketID;
-   ns->m_pUDT->m_pCache = m_pCache;
-
-   try
-   {
-      HLOGC(smlog.Debug, log << CONID(ns->m_SocketID)
-         << "newSocket: mapping socket "
-         << ns->m_SocketID);
-
-      // protect the m_Sockets structure.
-      ScopedLock cs(m_GlobControlLock);
-      m_Sockets[ns->m_SocketID] = ns;
-   }
-   catch (...)
-   {
-      //failure and rollback
-      delete ns;
-      ns = NULL;
-   }
-
-   if (!ns)
-      throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+SRTSOCKET srt::CUDTUnited::newSocket(CUDTSocket** pps)
+{
+    // XXX consider using some replacement of std::unique_ptr
+    // so that exceptions will clean up the object without the
+    // need for a dedicated code.
+    CUDTSocket* ns = NULL;
+
+    try
+    {
+        ns = new CUDTSocket;
+    }
+    catch (...)
+    {
+        delete ns;
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+
+    try
+    {
+        ns->m_SocketID = generateSocketID();
+    }
+    catch (...)
+    {
+        delete ns;
+        throw;
+    }
+    ns->m_Status          = SRTS_INIT;
+    ns->m_ListenSocket    = 0;
+    ns->core().m_SocketID = ns->m_SocketID;
+    ns->core().m_pCache   = m_pCache;
+
+    try
+    {
+        HLOGC(smlog.Debug, log << CONID(ns->m_SocketID) << "newSocket: mapping socket " << ns->m_SocketID);
+
+        // protect the m_Sockets structure.
+        ScopedLock cs(m_GlobControlLock);
+        m_Sockets[ns->m_SocketID] = ns;
+    }
+    catch (...)
+    {
+        // failure and rollback
+        delete ns;
+        ns = NULL;
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
 
     if (pps)
         *pps = ns;
 
-   return ns->m_SocketID;
-}
-
-int CUDTUnited::newConnection(const SRTSOCKET listen, const sockaddr_any& peer, const CPacket& hspkt,
-        CHandShake& w_hs, int& w_error, CUDT*& w_acpu)
-{
-   CUDTSocket* ns = NULL;
-   w_acpu = NULL;
-
-   w_error = SRT_REJ_IPE;
-
-   // Can't manage this error through an exception because this is
-   // running in the listener loop.
-   CUDTSocket* ls = locateSocket(listen);
-   if (!ls)
-   {
-       LOGC(cnlog.Error, log << "IPE: newConnection by listener socket id=" << listen << " which DOES NOT EXIST.");
-       return -1;
-   }
-
-   HLOGC(cnlog.Debug, log << "newConnection: creating new socket after listener @"
-         << listen << " contacted with backlog=" << ls->m_uiBackLog);
-
-   // if this connection has already been processed
-   if ((ns = locatePeer(peer, w_hs.m_iID, w_hs.m_iISN)) != NULL)
-   {
-      if (ns->m_pUDT->m_bBroken)
-      {
-         // last connection from the "peer" address has been broken
-         ns->setClosed();
-
-         ScopedLock acceptcg(ls->m_AcceptLock);
-         ls->m_pQueuedSockets->erase(ns->m_SocketID);
-         ls->m_pAcceptSockets->erase(ns->m_SocketID);
-      }
-      else
-      {
-         // connection already exist, this is a repeated connection request
-         // respond with existing HS information
-         HLOGC(cnlog.Debug, log
-               << "newConnection: located a WORKING peer @"
-               << w_hs.m_iID << " - ADAPTING.");
-
-         w_hs.m_iISN = ns->m_pUDT->m_iISN;
-         w_hs.m_iMSS = ns->m_pUDT->m_iMSS;
-         w_hs.m_iFlightFlagSize = ns->m_pUDT->m_iFlightFlagSize;
-         w_hs.m_iReqType = URQ_CONCLUSION;
-         w_hs.m_iID = ns->m_SocketID;
-
-         // Report the original UDT because it will be
-         // required to complete the HS data for conclusion response.
-         w_acpu = ns->m_pUDT;
-
-         return 0;
-
-         //except for this situation a new connection should be started
-      }
-   }
-   else
-   {
-       HLOGC(cnlog.Debug, log << "newConnection: NOT located any peer @"
-               << w_hs.m_iID << " - resuming with initial connection.");
-   }
-
-   // exceeding backlog, refuse the connection request
-   if (ls->m_pQueuedSockets->size() >= ls->m_uiBackLog)
-   {
-       w_error = SRT_REJ_BACKLOG;
-       LOGC(cnlog.Note, log << "newConnection: listen backlog=" << ls->m_uiBackLog << " EXCEEDED");
-       return -1;
-   }
-
-   try
-   {
-      ns = new CUDTSocket;
-      ns->m_pUDT = new CUDT(ns, *(ls->m_pUDT));
-      // No need to check the peer, this is the address from which the request has come.
-      ns->m_PeerAddr = peer;
-   }
-   catch (...)
-   {
-      w_error = SRT_REJ_RESOURCE;
-      delete ns;
-      LOGC(cnlog.Error, log << "IPE: newConnection: unexpected exception (probably std::bad_alloc)");
-      return -1;
-   }
-
-   ns->m_pUDT->m_RejectReason = SRT_REJ_UNKNOWN; // pre-set a universal value
-
-   try
-   {
-       ns->m_SocketID = generateSocketID();
-   }
-   catch (const CUDTException&)
-   {
-       LOGF(cnlog.Fatal, "newConnection: IPE: all sockets occupied? Last gen=%d", m_SocketIDGenerator);
-       // generateSocketID throws exception, which can be naturally handled
-       // when the call is derived from the API call, but here it's called
-       // internally in response to receiving a handshake. It must be handled
-       // here and turned into an erroneous return value.
-       delete ns;
-       return -1;
-   }
-
-   ns->m_ListenSocket = listen;
-   ns->m_pUDT->m_SocketID = ns->m_SocketID;
-   ns->m_PeerID = w_hs.m_iID;
-   ns->m_iISN = w_hs.m_iISN;
-
-   HLOGC(cnlog.Debug, log << "newConnection: DATA: lsnid=" << listen
-            << " id=" << ns->m_pUDT->m_SocketID
-            << " peerid=" << ns->m_pUDT->m_PeerID
-            << " ISN=" << ns->m_iISN);
-
-   int error = 0;
-   bool should_submit_to_accept = true;
-
-   // Set the error code for all prospective problems below.
-   // It won't be interpreted when result was successful.
-   w_error = SRT_REJ_RESOURCE;
-
-   // These can throw exception only when the memory allocation failed.
-   // CUDT::connect() translates exception into CUDTException.
-   // CUDT::open() may only throw original std::bad_alloc from new.
-   // This is only to make the library extra safe (when your machine lacks
-   // memory, it will continue to work, but fail to accept connection).
-
-   try
-   {
-       // This assignment must happen b4 the call to CUDT::connect() because
-       // this call causes sending the SRT Handshake through this socket.
-       // Without this mapping the socket cannot be found and therefore
-       // the SRT Handshake message would fail.
-       HLOGF(cnlog.Debug,
-               "newConnection: incoming %s, mapping socket %d",
-               peer.str().c_str(), ns->m_SocketID);
-       {
-           ScopedLock cg(m_GlobControlLock);
-           m_Sockets[ns->m_SocketID] = ns;
-       }
-
-       // bind to the same addr of listening socket
-       ns->m_pUDT->open();
-       updateListenerMux(ns, ls);
-       if (ls->m_pUDT->m_cbAcceptHook)
-       {
-           if (!ls->m_pUDT->runAcceptHook(ns->m_pUDT, peer.get(), w_hs, hspkt))
-           {
-               w_error = ns->m_pUDT->m_RejectReason;
-
-               error = 1;
-               goto ERR_ROLLBACK;
-           }
-       }
-       ns->m_pUDT->acceptAndRespond(ls->m_SelfAddr, peer, hspkt, (w_hs));
-   }
-   catch (...)
-   {
-       // Extract the error that was set in this new failed entity.
-       w_error = ns->m_pUDT->m_RejectReason;
-       error = 1;
-       goto ERR_ROLLBACK;
-   }
-
-   ns->m_Status = SRTS_CONNECTED;
-
-   // copy address information of local node
-   // Precisely, what happens here is:
-   // - Get the IP address and port from the system database
-   ns->m_pUDT->m_pSndQueue->m_pChannel->getSockAddr((ns->m_SelfAddr));
-   // - OVERWRITE just the IP address itself by a value taken from piSelfIP
-   // (the family is used exactly as the one taken from what has been returned
-   // by getsockaddr)
-   CIPAddress::pton((ns->m_SelfAddr), ns->m_pUDT->m_piSelfIP, peer);
-
-   {
-       // protect the m_PeerRec structure (and group existence)
-       ScopedLock glock (m_GlobControlLock);
-       try
-       {
-           HLOGF(cnlog.Debug,
-                   "newConnection: mapping peer %d to that socket (%d)\n",
-                   ns->m_PeerID, ns->m_SocketID);
-           m_PeerRec[ns->getPeerSpec()].insert(ns->m_SocketID);
-       }
-       catch (...)
-       {
-           LOGC(cnlog.Error, log << "newConnection: error when mapping peer!");
-           error = 2;
-       }
-
-       // The access to m_IncludedGroup should be also protected, as the group
-       // could be requested deletion in the meantime. This will hold any possible
-       // removal from group and resetting m_IncludedGroup field.
-
-#if ENABLE_EXPERIMENTAL_BONDING
-       if (ns->m_IncludedGroup)
-       {
-           // XXX this might require another check of group type.
-           // For redundancy group, at least, update the status in the group
-           CUDTGroup* g = ns->m_IncludedGroup;
-           ScopedLock glock (g->m_GroupLock);
-           if (g->m_bClosing)
-           {
-               error = 1; // "INTERNAL REJECTION"
-               goto ERR_ROLLBACK;
-           }
-
-           CUDTGroup::gli_t gi;
-
-           // Check if this is the first socket in the group.
-           // If so, give it up to accept, otherwise just do nothing
-           // The client will be informed about the newly added connection at the
-           // first moment when attempting to get the group status.
-           for (gi = g->m_Group.begin(); gi != g->m_Group.end(); ++gi)
-           {
-               if (gi->laststatus == SRTS_CONNECTED)
-               {
-                   HLOGC(cnlog.Debug, log << "Found another connected socket in the group: $"
-                           << gi->id << " - socket will be NOT given up for accepting");
-                   should_submit_to_accept = false;
-                   break;
-               }
-           }
-
-           // Update the status in the group so that the next
-           // operation can include the socket in the group operation.
-           gi = ns->m_IncludedIter;
-
-           HLOGC(cnlog.Debug, log << "newConnection(GROUP): Socket @" << ns->m_SocketID << " BELONGS TO $" << g->id()
-                   << " - will " << (should_submit_to_accept? "" : "NOT ") << "report in accept");
-           gi->sndstate = SRT_GST_IDLE;
-           gi->rcvstate = SRT_GST_IDLE;
-           gi->laststatus = SRTS_CONNECTED;
-
-           if (!g->m_bConnected)
-           {
-               HLOGC(cnlog.Debug, log << "newConnection(GROUP): First socket connected, SETTING GROUP CONNECTED");
-               g->m_bConnected = true;
-           }
-
-           // XXX PROLBEM!!! These events are subscribed here so that this is done once, lazily,
-           // but groupwise connections could be accepted from multiple listeners for the same group!
-           // m_listener MUST BE A CONTAINER, NOT POINTER!!!
-           // ALSO: Maybe checking "the same listener" is not necessary as subscruption may be done
-           // multiple times anyway?
-           if (!g->m_listener)
-           {
-               // Newly created group from the listener, which hasn't yet
-               // the listener set.
-               g->m_listener = ls;
-
-               // Listen on both first connected socket and continued sockets.
-               // This might help with jump-over situations, and in regular continued
-               // sockets the IN event won't be reported anyway.
-               int listener_modes = SRT_EPOLL_ACCEPT | SRT_EPOLL_UPDATE;
-               epoll_add_usock_INTERNAL(g->m_RcvEID, ls, &listener_modes);
-
-               // This listening should be done always when a first connected socket
-               // appears as accepted off the listener. This is for the sake of swait() calls
-               // inside the group receiving and sending functions so that they get
-               // interrupted when a new socket is connected.
-           }
-
-           // Add also per-direction subscription for the about-to-be-accepted socket.
-           // Both first accepted socket that makes the group-accept and every next
-           // socket that adds a new link.
-           int read_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;
-           int write_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
-           epoll_add_usock_INTERNAL(g->m_RcvEID, ns, &read_modes);
-           epoll_add_usock_INTERNAL(g->m_SndEID, ns, &write_modes);
-
-           // With app reader, do not set groupPacketArrival (block the
-           // provider array feature completely for now).
-
-
-           /* SETUP HERE IF NEEDED
-              ns->m_pUDT->m_cbPacketArrival.set(ns->m_pUDT, &CUDT::groupPacketArrival);
-            */
-       }
-       else
-       {
-           HLOGC(cnlog.Debug, log << "newConnection: Socket @" << ns->m_SocketID << " is not in a group");
-       }
+    return ns->m_SocketID;
+}
+
+int srt::CUDTUnited::newConnection(const SRTSOCKET     listen,
+                                   const sockaddr_any& peer,
+                                   const CPacket&      hspkt,
+                                   CHandShake&         w_hs,
+                                   int&                w_error,
+                                   CUDT*&              w_acpu)
+{
+    CUDTSocket* ns = NULL;
+    w_acpu         = NULL;
+
+    w_error = SRT_REJ_IPE;
+
+    // Can't manage this error through an exception because this is
+    // running in the listener loop.
+    CUDTSocket* ls = locateSocket(listen);
+    if (!ls)
+    {
+        LOGC(cnlog.Error, log << "IPE: newConnection by listener socket id=" << listen << " which DOES NOT EXIST.");
+        return -1;
+    }
+
+    HLOGC(cnlog.Debug,
+          log << "newConnection: creating new socket after listener @" << listen
+              << " contacted with backlog=" << ls->m_uiBackLog);
+
+    // if this connection has already been processed
+    if ((ns = locatePeer(peer, w_hs.m_iID, w_hs.m_iISN)) != NULL)
+    {
+        if (ns->core().m_bBroken)
+        {
+            // last connection from the "peer" address has been broken
+            ns->setClosed();
+
+            ScopedLock acceptcg(ls->m_AcceptLock);
+            ls->m_QueuedSockets.erase(ns->m_SocketID);
+        }
+        else
+        {
+            // connection already exist, this is a repeated connection request
+            // respond with existing HS information
+            HLOGC(cnlog.Debug, log << "newConnection: located a WORKING peer @" << w_hs.m_iID << " - ADAPTING.");
+
+            w_hs.m_iISN            = ns->core().m_iISN;
+            w_hs.m_iMSS            = ns->core().MSS();
+            w_hs.m_iFlightFlagSize = ns->core().m_config.iFlightFlagSize;
+            w_hs.m_iReqType        = URQ_CONCLUSION;
+            w_hs.m_iID             = ns->m_SocketID;
+
+            // Report the original UDT because it will be
+            // required to complete the HS data for conclusion response.
+            w_acpu = &ns->core();
+
+            return 0;
+
+            // except for this situation a new connection should be started
+        }
+    }
+    else
+    {
+        HLOGC(cnlog.Debug,
+              log << "newConnection: NOT located any peer @" << w_hs.m_iID << " - resuming with initial connection.");
+    }
+
+    // exceeding backlog, refuse the connection request
+    if (ls->m_QueuedSockets.size() >= ls->m_uiBackLog)
+    {
+        w_error = SRT_REJ_BACKLOG;
+        LOGC(cnlog.Note, log << "newConnection: listen backlog=" << ls->m_uiBackLog << " EXCEEDED");
+        return -1;
+    }
+
+    try
+    {
+        // Protect the config of the listener socket from a data race.
+        ScopedLock lck(ls->core().m_ConnectionLock);
+        ns = new CUDTSocket(*ls);
+        // No need to check the peer, this is the address from which the request has come.
+        ns->m_PeerAddr = peer;
+    }
+    catch (...)
+    {
+        w_error = SRT_REJ_RESOURCE;
+        delete ns;
+        LOGC(cnlog.Error, log << "IPE: newConnection: unexpected exception (probably std::bad_alloc)");
+        return -1;
+    }
+
+    ns->core().m_RejectReason = SRT_REJ_UNKNOWN; // pre-set a universal value
+
+    try
+    {
+        ns->m_SocketID = generateSocketID();
+    }
+    catch (const CUDTException&)
+    {
+        LOGC(cnlog.Fatal, log << "newConnection: IPE: all sockets occupied? Last gen=" << m_SocketIDGenerator);
+        // generateSocketID throws exception, which can be naturally handled
+        // when the call is derived from the API call, but here it's called
+        // internally in response to receiving a handshake. It must be handled
+        // here and turned into an erroneous return value.
+        delete ns;
+        return -1;
+    }
+
+    ns->m_ListenSocket    = listen;
+    ns->core().m_SocketID = ns->m_SocketID;
+    ns->m_PeerID          = w_hs.m_iID;
+    ns->m_iISN            = w_hs.m_iISN;
+
+    HLOGC(cnlog.Debug,
+          log << "newConnection: DATA: lsnid=" << listen << " id=" << ns->core().m_SocketID
+              << " peerid=" << ns->core().m_PeerID << " ISN=" << ns->m_iISN);
+
+    int  error                   = 0;
+    bool should_submit_to_accept = true;
+
+    // Set the error code for all prospective problems below.
+    // It won't be interpreted when result was successful.
+    w_error = SRT_REJ_RESOURCE;
+
+    // These can throw exception only when the memory allocation failed.
+    // CUDT::connect() translates exception into CUDTException.
+    // CUDT::open() may only throw original std::bad_alloc from new.
+    // This is only to make the library extra safe (when your machine lacks
+    // memory, it will continue to work, but fail to accept connection).
+
+    try
+    {
+        // This assignment must happen b4 the call to CUDT::connect() because
+        // this call causes sending the SRT Handshake through this socket.
+        // Without this mapping the socket cannot be found and therefore
+        // the SRT Handshake message would fail.
+        HLOGC(cnlog.Debug, log <<
+                "newConnection: incoming " << peer.str() << ", mapping socket " << ns->m_SocketID);
+        {
+            ScopedLock cg(m_GlobControlLock);
+            m_Sockets[ns->m_SocketID] = ns;
+        }
+
+        if (ls->core().m_cbAcceptHook)
+        {
+            if (!ls->core().runAcceptHook(&ns->core(), peer.get(), w_hs, hspkt))
+            {
+                w_error = ns->core().m_RejectReason;
+
+                error = 1;
+                goto ERR_ROLLBACK;
+            }
+        }
+
+        // bind to the same addr of listening socket
+        ns->core().open();
+        if (!updateListenerMux(ns, ls))
+        {
+            // This is highly unlikely if not impossible, but there's
+            // a theoretical runtime chance of failure so it should be
+            // handled
+            ns->core().m_RejectReason = SRT_REJ_IPE;
+            throw false; // let it jump directly into the omni exception handler
+        }
+
+        ns->core().acceptAndRespond(ls->m_SelfAddr, peer, hspkt, (w_hs));
+    }
+    catch (...)
+    {
+        // Extract the error that was set in this new failed entity.
+        w_error = ns->core().m_RejectReason;
+        error   = 1;
+        goto ERR_ROLLBACK;
+    }
+
+    ns->m_Status = SRTS_CONNECTED;
+
+    // copy address information of local node
+    // Precisely, what happens here is:
+    // - Get the IP address and port from the system database
+    ns->core().m_pSndQueue->m_pChannel->getSockAddr((ns->m_SelfAddr));
+    // - OVERWRITE just the IP address itself by a value taken from piSelfIP
+    // (the family is used exactly as the one taken from what has been returned
+    // by getsockaddr)
+    CIPAddress::pton((ns->m_SelfAddr), ns->core().m_piSelfIP, peer);
+
+    {
+        // protect the m_PeerRec structure (and group existence)
+        ScopedLock glock(m_GlobControlLock);
+        try
+        {
+            HLOGC(cnlog.Debug, log << "newConnection: mapping peer " << ns->m_PeerID
+                    << " to that socket (" << ns->m_SocketID << ")");
+            m_PeerRec[ns->getPeerSpec()].insert(ns->m_SocketID);
+
+            LOGC(cnlog.Note, log << "@" << ns->m_SocketID << " connection on listener @" << listen
+                << " (" << ns->m_SelfAddr.str() << ") from peer @" << ns->m_PeerID << " (" << peer.str() << ")");
+        }
+        catch (...)
+        {
+            LOGC(cnlog.Error, log << "newConnection: error when mapping peer!");
+            error = 2;
+        }
+
+        // The access to m_GroupOf should be also protected, as the group
+        // could be requested deletion in the meantime. This will hold any possible
+        // removal from group and resetting m_GroupOf field.
+
+#if ENABLE_BONDING
+        if (ns->m_GroupOf)
+        {
+            // XXX this might require another check of group type.
+            // For redundancy group, at least, update the status in the group
+            CUDTGroup* g = ns->m_GroupOf;
+            ScopedLock grlock(g->m_GroupLock);
+            if (g->m_bClosing)
+            {
+                error = 1; // "INTERNAL REJECTION"
+                goto ERR_ROLLBACK;
+            }
+
+            // Check if this is the first socket in the group.
+            // If so, give it up to accept, otherwise just do nothing
+            // The client will be informed about the newly added connection at the
+            // first moment when attempting to get the group status.
+            for (CUDTGroup::gli_t gi = g->m_Group.begin(); gi != g->m_Group.end(); ++gi)
+            {
+                if (gi->laststatus == SRTS_CONNECTED)
+                {
+                    HLOGC(cnlog.Debug,
+                          log << "Found another connected socket in the group: $" << gi->id
+                              << " - socket will be NOT given up for accepting");
+                    should_submit_to_accept = false;
+                    break;
+                }
+            }
+
+            // Update the status in the group so that the next
+            // operation can include the socket in the group operation.
+            CUDTGroup::SocketData* gm = ns->m_GroupMemberData;
+
+            HLOGC(cnlog.Debug,
+                  log << "newConnection(GROUP): Socket @" << ns->m_SocketID << " BELONGS TO $" << g->id() << " - will "
+                      << (should_submit_to_accept ? "" : "NOT ") << "report in accept");
+            gm->sndstate   = SRT_GST_IDLE;
+            gm->rcvstate   = SRT_GST_IDLE;
+            gm->laststatus = SRTS_CONNECTED;
+
+            if (!g->m_bConnected)
+            {
+                HLOGC(cnlog.Debug, log << "newConnection(GROUP): First socket connected, SETTING GROUP CONNECTED");
+                g->m_bConnected = true;
+            }
+
+            // XXX PROLBEM!!! These events are subscribed here so that this is done once, lazily,
+            // but groupwise connections could be accepted from multiple listeners for the same group!
+            // m_listener MUST BE A CONTAINER, NOT POINTER!!!
+            // ALSO: Maybe checking "the same listener" is not necessary as subscruption may be done
+            // multiple times anyway?
+            if (!g->m_listener)
+            {
+                // Newly created group from the listener, which hasn't yet
+                // the listener set.
+                g->m_listener = ls;
+
+                // Listen on both first connected socket and continued sockets.
+                // This might help with jump-over situations, and in regular continued
+                // sockets the IN event won't be reported anyway.
+                int listener_modes = SRT_EPOLL_ACCEPT | SRT_EPOLL_UPDATE;
+                epoll_add_usock_INTERNAL(g->m_RcvEID, ls, &listener_modes);
+
+                // This listening should be done always when a first connected socket
+                // appears as accepted off the listener. This is for the sake of swait() calls
+                // inside the group receiving and sending functions so that they get
+                // interrupted when a new socket is connected.
+            }
+
+            // Add also per-direction subscription for the about-to-be-accepted socket.
+            // Both first accepted socket that makes the group-accept and every next
+            // socket that adds a new link.
+            int read_modes  = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+            int write_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
+            epoll_add_usock_INTERNAL(g->m_RcvEID, ns, &read_modes);
+            epoll_add_usock_INTERNAL(g->m_SndEID, ns, &write_modes);
+
+            // With app reader, do not set groupPacketArrival (block the
+            // provider array feature completely for now).
+
+            /* SETUP HERE IF NEEDED
+               ns->core().m_cbPacketArrival.set(ns->m_pUDT, &CUDT::groupPacketArrival);
+             */
+        }
+        else
+        {
+            HLOGC(cnlog.Debug, log << "newConnection: Socket @" << ns->m_SocketID << " is not in a group");
+        }
 #endif
-   }
-
-   if (should_submit_to_accept)
-   {
-      enterCS(ls->m_AcceptLock);
-      try
-      {
-         ls->m_pQueuedSockets->insert(ns->m_SocketID);
-      }
-      catch (...)
-      {
-         LOGC(cnlog.Error, log << "newConnection: error when queuing socket!");
-         error = 3;
-      }
-      leaveCS(ls->m_AcceptLock);
-
-      HLOGC(cnlog.Debug, log << "ACCEPT: new socket @" << ns->m_SocketID << " submitted for acceptance");
-      // acknowledge users waiting for new connections on the listening socket
-      m_EPoll.update_events(listen, ls->m_pUDT->m_sPollID, SRT_EPOLL_ACCEPT, true);
-
-      CGlobEvent::triggerEvent();
-
-      // XXX the exact value of 'error' is ignored
-      if (error > 0)
-      {
-         goto ERR_ROLLBACK;
-      }
-
-      // wake up a waiting accept() call
-      CSync::lock_signal(ls->m_AcceptCond, ls->m_AcceptLock);
-   }
-   else
-   {
-      HLOGC(cnlog.Debug, log << "ACCEPT: new socket @" << ns->m_SocketID
-            << " NOT submitted to acceptance, another socket in the group is already connected");
-      {
-         ScopedLock cg (ls->m_AcceptLock);
-         ls->m_pAcceptSockets->insert(ls->m_pAcceptSockets->end(), ns->m_SocketID);
-      }
-
-      // acknowledge INTERNAL users waiting for new connections on the listening socket
-      // that are reported when a new socket is connected within an already connected group.
-      m_EPoll.update_events(listen, ls->m_pUDT->m_sPollID, SRT_EPOLL_UPDATE, true);
-      CGlobEvent::triggerEvent();
-   }
+    }
+
+    if (should_submit_to_accept)
+    {
+        enterCS(ls->m_AcceptLock);
+        try
+        {
+            ls->m_QueuedSockets[ns->m_SocketID] = ns->m_PeerAddr;
+        }
+        catch (...)
+        {
+            LOGC(cnlog.Error, log << "newConnection: error when queuing socket!");
+            error = 3;
+        }
+        leaveCS(ls->m_AcceptLock);
+
+        HLOGC(cnlog.Debug, log << "ACCEPT: new socket @" << ns->m_SocketID << " submitted for acceptance");
+        // acknowledge users waiting for new connections on the listening socket
+        m_EPoll.update_events(listen, ls->core().m_sPollID, SRT_EPOLL_ACCEPT, true);
+
+        CGlobEvent::triggerEvent();
+
+        // XXX the exact value of 'error' is ignored
+        if (error > 0)
+        {
+            goto ERR_ROLLBACK;
+        }
+
+        // wake up a waiting accept() call
+        CSync::lock_notify_one(ls->m_AcceptCond, ls->m_AcceptLock);
+    }
+    else
+    {
+        HLOGC(cnlog.Debug,
+              log << "ACCEPT: new socket @" << ns->m_SocketID
+                  << " NOT submitted to acceptance, another socket in the group is already connected");
+
+        // acknowledge INTERNAL users waiting for new connections on the listening socket
+        // that are reported when a new socket is connected within an already connected group.
+        m_EPoll.update_events(listen, ls->core().m_sPollID, SRT_EPOLL_UPDATE, true);
+        CGlobEvent::triggerEvent();
+    }
 
 ERR_ROLLBACK:
-   // XXX the exact value of 'error' is ignored
-   if (error > 0)
-   {
+    // XXX the exact value of 'error' is ignored
+    if (error > 0)
+    {
 #if ENABLE_LOGGING
-       static const char* why [] = {
-           "UNKNOWN ERROR",
-           "INTERNAL REJECTION",
-           "IPE when mapping a socket",
-           "IPE when inserting a socket"
-       };
-       LOGC(cnlog.Warn, log << CONID(ns->m_SocketID) << "newConnection: connection rejected due to: "
-               << why[error] << " - " << RequestTypeStr(URQFailure(w_error)));
+        static const char* why[] = {
+            "UNKNOWN ERROR", "INTERNAL REJECTION", "IPE when mapping a socket", "IPE when inserting a socket"};
+        LOGC(cnlog.Warn,
+             log << CONID(ns->m_SocketID) << "newConnection: connection rejected due to: " << why[error] << " - "
+                 << RequestTypeStr(URQFailure(w_error)));
 #endif
 
-      SRTSOCKET id = ns->m_SocketID;
-      ns->m_pUDT->closeInternal();
-      ns->setClosed();
-
-      // The mapped socket should be now unmapped to preserve the situation that
-      // was in the original UDT code.
-      // In SRT additionally the acceptAndRespond() function (it was called probably
-      // connect() in UDT code) may fail, in which case this socket should not be
-      // further processed and should be removed.
-      {
-          ScopedLock cg(m_GlobControlLock);
-
-#if ENABLE_EXPERIMENTAL_BONDING
-          if (ns->m_IncludedGroup)
-          {
-              HLOGC(smlog.Debug, log << "@" << ns->m_SocketID << " IS MEMBER OF $" << ns->m_IncludedGroup->id() << " - REMOVING FROM GROUP");
-              ns->removeFromGroup(true);
-          }
+        SRTSOCKET id = ns->m_SocketID;
+        ns->core().closeInternal();
+        ns->setClosed();
+
+        // The mapped socket should be now unmapped to preserve the situation that
+        // was in the original UDT code.
+        // In SRT additionally the acceptAndRespond() function (it was called probably
+        // connect() in UDT code) may fail, in which case this socket should not be
+        // further processed and should be removed.
+        {
+            ScopedLock cg(m_GlobControlLock);
+
+#if ENABLE_BONDING
+            if (ns->m_GroupOf)
+            {
+                HLOGC(smlog.Debug,
+                      log << "@" << ns->m_SocketID << " IS MEMBER OF $" << ns->m_GroupOf->id()
+                          << " - REMOVING FROM GROUP");
+                ns->removeFromGroup(true);
+            }
 #endif
-          m_Sockets.erase(id);
-          m_ClosedSockets[id] = ns;
-      }
+            m_Sockets.erase(id);
+            m_ClosedSockets[id] = ns;
+        }
 
-      return -1;
-   }
+        return -1;
+    }
 
-   return 1;
+    return 1;
 }
 
 // static forwarder
-int CUDT::installAcceptHook(SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq)
+int srt::CUDT::installAcceptHook(SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq)
 {
-    return s_UDTUnited.installAcceptHook(lsn, hook, opaq);
+    return uglobal().installAcceptHook(lsn, hook, opaq);
 }
 
-int CUDTUnited::installAcceptHook(const SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq)
+int srt::CUDTUnited::installAcceptHook(const SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq)
 {
     try
     {
         CUDTSocket* s = locateSocket(lsn, ERH_THROW);
-        s->m_pUDT->installAcceptHook(hook, opaq);
+        s->core().installAcceptHook(hook, opaq);
     }
     catch (CUDTException& e)
     {
@@ -883,25 +865,25 @@ int CUDTUnited::installAcceptHook(const SRTSOCKET lsn, srt_listen_callback_fn* h
     return 0;
 }
 
-int CUDT::installConnectHook(SRTSOCKET lsn, srt_connect_callback_fn* hook, void* opaq)
+int srt::CUDT::installConnectHook(SRTSOCKET lsn, srt_connect_callback_fn* hook, void* opaq)
 {
-    return s_UDTUnited.installConnectHook(lsn, hook, opaq);
+    return uglobal().installConnectHook(lsn, hook, opaq);
 }
 
-int CUDTUnited::installConnectHook(const SRTSOCKET u, srt_connect_callback_fn* hook, void* opaq)
+int srt::CUDTUnited::installConnectHook(const SRTSOCKET u, srt_connect_callback_fn* hook, void* opaq)
 {
     try
     {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         if (u & SRTGROUP_MASK)
         {
-            GroupKeeper k (*this, u, ERH_THROW);
+            GroupKeeper k(*this, u, ERH_THROW);
             k.group->installConnectHook(hook, opaq);
             return 0;
         }
 #endif
         CUDTSocket* s = locateSocket(u, ERH_THROW);
-        s->m_pUDT->installConnectHook(hook, opaq);
+        s->core().installConnectHook(hook, opaq);
     }
     catch (CUDTException& e)
     {
@@ -912,7 +894,7 @@ int CUDTUnited::installConnectHook(const SRTSOCKET u, srt_connect_callback_fn* h
     return 0;
 }
 
-SRT_SOCKSTATUS CUDTUnited::getStatus(const SRTSOCKET u)
+SRT_SOCKSTATUS srt::CUDTUnited::getStatus(const SRTSOCKET u)
 {
     // protects the m_Sockets structure
     ScopedLock cg(m_GlobControlLock);
@@ -929,130 +911,125 @@ SRT_SOCKSTATUS CUDTUnited::getStatus(const SRTSOCKET u)
     return i->second->getStatus();
 }
 
-int CUDTUnited::bind(CUDTSocket* s, const sockaddr_any& name)
+int srt::CUDTUnited::bind(CUDTSocket* s, const sockaddr_any& name)
 {
-   ScopedLock cg(s->m_ControlLock);
+    ScopedLock cg(s->m_ControlLock);
+
+    // cannot bind a socket more than once
+    if (s->m_Status != SRTS_INIT)
+        throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
+
+    if (s->core().m_config.iIpV6Only == -1 && name.family() == AF_INET6 && name.isany())
+    {
+        // V6ONLY option must be set explicitly if you want to bind to a wildcard address in IPv6
+        HLOGP(smlog.Error,
+                "bind: when binding to :: (IPv6 wildcard), SRTO_IPV6ONLY option must be set explicitly to 0 or 1");
 
-   // cannot bind a socket more than once
-   if (s->m_Status != SRTS_INIT)
-      throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
 
-   s->m_pUDT->open();
-   updateMux(s, name);
-   s->m_Status = SRTS_OPENED;
+    s->core().open();
+    updateMux(s, name);
+    s->m_Status = SRTS_OPENED;
 
-   // copy address information of local node
-   s->m_pUDT->m_pSndQueue->m_pChannel->getSockAddr((s->m_SelfAddr));
+    // copy address information of local node
+    s->core().m_pSndQueue->m_pChannel->getSockAddr((s->m_SelfAddr));
 
-   return 0;
+    return 0;
 }
 
-int CUDTUnited::bind(CUDTSocket* s, UDPSOCKET udpsock)
+int srt::CUDTUnited::bind(CUDTSocket* s, UDPSOCKET udpsock)
 {
-   ScopedLock cg(s->m_ControlLock);
+    ScopedLock cg(s->m_ControlLock);
 
-   // cannot bind a socket more than once
-   if (s->m_Status != SRTS_INIT)
-      throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
+    // cannot bind a socket more than once
+    if (s->m_Status != SRTS_INIT)
+        throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
 
-   sockaddr_any name;
-   socklen_t namelen = sizeof name; // max of inet and inet6
+    sockaddr_any name;
+    socklen_t    namelen = sizeof name; // max of inet and inet6
 
-   // This will preset the sa_family as well; the namelen is given simply large
-   // enough for any family here.
-   if (::getsockname(udpsock, &name.sa, &namelen) == -1)
-      throw CUDTException(MJ_NOTSUP, MN_INVAL);
+    // This will preset the sa_family as well; the namelen is given simply large
+    // enough for any family here.
+    if (::getsockname(udpsock, &name.sa, &namelen) == -1)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL);
 
-   // Successfully extracted, so update the size
-   name.len = namelen;
+    // Successfully extracted, so update the size
+    name.len = namelen;
 
-   s->m_pUDT->open();
-   updateMux(s, name, &udpsock);
-   s->m_Status = SRTS_OPENED;
+    s->core().open();
+    updateMux(s, name, &udpsock);
+    s->m_Status = SRTS_OPENED;
 
-   // copy address information of local node
-   s->m_pUDT->m_pSndQueue->m_pChannel->getSockAddr((s->m_SelfAddr));
+    // copy address information of local node
+    s->core().m_pSndQueue->m_pChannel->getSockAddr(s->m_SelfAddr);
 
-   return 0;
+    return 0;
 }
 
-int CUDTUnited::listen(const SRTSOCKET u, int backlog)
+int srt::CUDTUnited::listen(const SRTSOCKET u, int backlog)
 {
-   if (backlog <= 0)
-      throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-   // Don't search for the socket if it's already -1;
-   // this never is a valid socket.
-   if (u == UDT::INVALID_SOCK)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-
-   CUDTSocket* s = locateSocket(u);
-   if (!s)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+    if (backlog <= 0)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   ScopedLock cg(s->m_ControlLock);
+    // Don't search for the socket if it's already -1;
+    // this never is a valid socket.
+    if (u == UDT::INVALID_SOCK)
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
 
-   // NOTE: since now the socket is protected against simultaneous access.
-   // In the meantime the socket might have been closed, which means that
-   // it could have changed the state. It could be also set listen in another
-   // thread, so check it out.
+    CUDTSocket* s = locateSocket(u);
+    if (!s)
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
 
-   // do nothing if the socket is already listening
-   if (s->m_Status == SRTS_LISTENING)
-      return 0;
+    ScopedLock cg(s->m_ControlLock);
 
-   // a socket can listen only if is in OPENED status
-   if (s->m_Status != SRTS_OPENED)
-      throw CUDTException(MJ_NOTSUP, MN_ISUNBOUND, 0);
+    // NOTE: since now the socket is protected against simultaneous access.
+    // In the meantime the socket might have been closed, which means that
+    // it could have changed the state. It could be also set listen in another
+    // thread, so check it out.
 
-   // [[using assert(s->m_Status == OPENED)]];
+    // do nothing if the socket is already listening
+    if (s->m_Status == SRTS_LISTENING)
+        return 0;
 
-   // listen is not supported in rendezvous connection setup
-   if (s->m_pUDT->m_bRendezvous)
-      throw CUDTException(MJ_NOTSUP, MN_ISRENDEZVOUS, 0);
+    // a socket can listen only if is in OPENED status
+    if (s->m_Status != SRTS_OPENED)
+        throw CUDTException(MJ_NOTSUP, MN_ISUNBOUND, 0);
 
-   s->m_uiBackLog = backlog;
+    // [[using assert(s->m_Status == OPENED)]];
 
-   try
-   {
-      s->m_pQueuedSockets = new set<SRTSOCKET>;
-      s->m_pAcceptSockets = new set<SRTSOCKET>;
-   }
-   catch (...)
-   {
-      delete s->m_pQueuedSockets;
-      delete s->m_pAcceptSockets;
+    // listen is not supported in rendezvous connection setup
+    if (s->core().m_config.bRendezvous)
+        throw CUDTException(MJ_NOTSUP, MN_ISRENDEZVOUS, 0);
 
-      // XXX Translated std::bad_alloc into CUDTException specifying
-      // memory allocation failure...
-      throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
+    s->m_uiBackLog = backlog;
 
-   // [[using assert(s->m_Status == OPENED)]]; // (still, unchanged)
+    // [[using assert(s->m_Status == OPENED)]]; // (still, unchanged)
 
-   s->m_pUDT->setListenState();  // propagates CUDTException,
-                                 // if thrown, remains in OPENED state if so.
-   s->m_Status = SRTS_LISTENING;
+    s->core().setListenState(); // propagates CUDTException,
+                                // if thrown, remains in OPENED state if so.
+    s->m_Status = SRTS_LISTENING;
 
-   return 0;
+    return 0;
 }
 
-SRTSOCKET CUDTUnited::accept_bond(const SRTSOCKET listeners [], int lsize, int64_t msTimeOut)
+SRTSOCKET srt::CUDTUnited::accept_bond(const SRTSOCKET listeners[], int lsize, int64_t msTimeOut)
 {
-    CEPollDesc* ed = 0;
-    int eid = m_EPoll.create(&ed);
+    CEPollDesc* ed  = 0;
+    int         eid = m_EPoll.create(&ed);
 
     // Destroy it at return - this function can be interrupted
     // by an exception.
     struct AtReturn
     {
-        int eid;
+        int         eid;
         CUDTUnited* that;
-        AtReturn(CUDTUnited* t, int e): eid(e), that(t) {}
-        ~AtReturn()
+        AtReturn(CUDTUnited* t, int e)
+            : eid(e)
+            , that(t)
         {
-            that->m_EPoll.release(eid);
         }
+        ~AtReturn() { that->m_EPoll.release(eid); }
     } l_ar(this, eid);
 
     // Subscribe all of listeners for accept
@@ -1075,152 +1052,163 @@ SRTSOCKET CUDTUnited::accept_bond(const SRTSOCKET listeners [], int lsize, int64
     // Theoretically we can have a situation that more than one
     // listener is ready for accept. In this case simply get
     // only the first found.
-    int lsn = st.begin()->first;
+    int              lsn = st.begin()->first;
     sockaddr_storage dummy;
-    int outlen = sizeof dummy;
+    int              outlen = sizeof dummy;
     return accept(lsn, ((sockaddr*)&dummy), (&outlen));
 }
 
-SRTSOCKET CUDTUnited::accept(const SRTSOCKET listen, sockaddr* pw_addr, int* pw_addrlen)
-{
-   if (pw_addr && !pw_addrlen)
-      throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-   CUDTSocket* ls = locateSocket(listen);
-
-   if (ls == NULL)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-
-   // the "listen" socket must be in LISTENING status
-   if (ls->m_Status != SRTS_LISTENING)
-      throw CUDTException(MJ_NOTSUP, MN_NOLISTEN, 0);
-
-   // no "accept" in rendezvous connection setup
-   if (ls->m_pUDT->m_bRendezvous)
-   {
-       LOGC(cnlog.Fatal, log << "CUDTUnited::accept: RENDEZVOUS flag passed through check in srt_listen when it set listen state");
-       // This problem should never happen because `srt_listen` function should have
-       // checked this situation before and not set listen state in result.
-       // Inform the user about the invalid state in the universal way.
-       throw CUDTException(MJ_NOTSUP, MN_NOLISTEN, 0);
-   }
-
-   SRTSOCKET u = CUDT::INVALID_SOCK;
-   bool accepted = false;
-
-   // !!only one conection can be set up each time!!
-   while (!accepted)
-   {
-       UniqueLock accept_lock(ls->m_AcceptLock);
-       CSync accept_sync(ls->m_AcceptCond, accept_lock);
-
-       if ((ls->m_Status != SRTS_LISTENING) || ls->m_pUDT->m_bBroken)
-       {
-           // This socket has been closed.
-           accepted = true;
-       }
-       else if (ls->m_pQueuedSockets->size() > 0)
-       {
-           // XXX REFACTORING REQUIRED HERE!
-           // Actually this should at best be something like that:
-           // set<SRTSOCKET>::iterator b = ls->m_pQueuedSockets->begin();
-           // u = *b;
-           // ls->m_pQueuedSockets->erase(b);
-           // ls->m_pAcceptSockets->insert(u);
-           //
-           // It is also questionable why m_pQueuedSockets should be of type 'set'.
-           // There's no quick-searching capabilities of that container used anywhere except
-           // checkBrokenSockets and garbageCollect, which aren't performance-critical,
-           // whereas it's mainly used for getting the first element and iterating
-           // over elements, which is slow in case of std::set. It's also doubtful
-           // as to whether the sorting capability of std::set is properly used;
-           // the first is taken here, which is actually the socket with lowest
-           // possible descriptor value (as default operator< and ascending sorting
-           // used for std::set<SRTSOCKET> where SRTSOCKET=int).
-           //
-           // Consider using std::list or std::vector here.
-
-           u = *(ls->m_pQueuedSockets->begin());
-           ls->m_pAcceptSockets->insert(ls->m_pAcceptSockets->end(), u);
-           ls->m_pQueuedSockets->erase(ls->m_pQueuedSockets->begin());
-           accepted = true;
-       }
-       else if (!ls->m_pUDT->m_bSynRecving)
-       {
-           accepted = true;
-       }
-
-       if (!accepted && (ls->m_Status == SRTS_LISTENING))
-           accept_sync.wait();
-
-       if (ls->m_pQueuedSockets->empty())
-           m_EPoll.update_events(listen, ls->m_pUDT->m_sPollID, SRT_EPOLL_ACCEPT, false);
-   }
-
-   if (u == CUDT::INVALID_SOCK)
-   {
-      // non-blocking receiving, no connection available
-      if (!ls->m_pUDT->m_bSynRecving)
-         throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
-
-      // listening socket is closed
-      throw CUDTException(MJ_SETUP, MN_CLOSED, 0);
-   }
-
-   CUDTSocket* s = locateSocket(u);
-   if (s == NULL)
-      throw CUDTException(MJ_SETUP, MN_CLOSED, 0);
-
-   // Set properly the SRTO_GROUPCONNECT flag
-   s->core().m_OPT_GroupConnect = 0;
-
-   // Check if LISTENER has the SRTO_GROUPCONNECT flag set,
-   // and the already accepted socket has successfully joined
-   // the mirror group. If so, RETURN THE GROUP ID, not the socket ID.
-#if ENABLE_EXPERIMENTAL_BONDING
-   if (ls->m_pUDT->m_OPT_GroupConnect == 1 && s->m_IncludedGroup)
-   {
-       // Put a lock to protect the group against accidental deletion
-       // in the meantime.
-       ScopedLock glock (m_GlobControlLock);
-       // Check again; it's unlikely to happen, but
-       // it's a theoretically possible scenario
-       if (s->m_IncludedGroup)
-       {
-           u = s->m_IncludedGroup->m_GroupID;
-           s->core().m_OPT_GroupConnect = 1; // should be derived from ls, but make sure
-       }
-       else
-       {
-           LOGC(smlog.Error, log << "accept: IPE: socket's group deleted in the meantime of accept process???");
-       }
-   }
+SRTSOCKET srt::CUDTUnited::accept(const SRTSOCKET listen, sockaddr* pw_addr, int* pw_addrlen)
+{
+    if (pw_addr && !pw_addrlen)
+    {
+        LOGC(cnlog.Error, log << "srt_accept: provided address, but address length parameter is missing");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    CUDTSocket* ls = locateSocket(listen);
+
+    if (ls == NULL)
+    {
+        LOGC(cnlog.Error, log << "srt_accept: invalid listener socket ID value: " << listen);
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+    }
+
+    // the "listen" socket must be in LISTENING status
+    if (ls->m_Status != SRTS_LISTENING)
+    {
+        LOGC(cnlog.Error, log << "srt_accept: socket @" << listen << " is not in listening state (forgot srt_listen?)");
+        throw CUDTException(MJ_NOTSUP, MN_NOLISTEN, 0);
+    }
+
+    // no "accept" in rendezvous connection setup
+    if (ls->core().m_config.bRendezvous)
+    {
+        LOGC(cnlog.Fatal,
+             log << "CUDTUnited::accept: RENDEZVOUS flag passed through check in srt_listen when it set listen state");
+        // This problem should never happen because `srt_listen` function should have
+        // checked this situation before and not set listen state in result.
+        // Inform the user about the invalid state in the universal way.
+        throw CUDTException(MJ_NOTSUP, MN_NOLISTEN, 0);
+    }
+
+    SRTSOCKET u        = CUDT::INVALID_SOCK;
+    bool      accepted = false;
+
+    // !!only one connection can be set up each time!!
+    while (!accepted)
+    {
+        UniqueLock accept_lock(ls->m_AcceptLock);
+        CSync      accept_sync(ls->m_AcceptCond, accept_lock);
+
+        if ((ls->m_Status != SRTS_LISTENING) || ls->core().m_bBroken)
+        {
+            // This socket has been closed.
+            accepted = true;
+        }
+        else if (ls->m_QueuedSockets.size() > 0)
+        {
+            map<SRTSOCKET, sockaddr_any>::iterator b = ls->m_QueuedSockets.begin();
+
+            if (pw_addr != NULL && pw_addrlen != NULL)
+            {
+                // Check if the length of the buffer to fill the name in
+                // was large enough.
+                const int len = b->second.size();
+                if (*pw_addrlen < len)
+                {
+                    // In case when the address cannot be rewritten,
+                    // DO NOT accept, but leave the socket in the queue.
+                    throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+                }
+            }
+
+            u = b->first;
+            ls->m_QueuedSockets.erase(b);
+            accepted = true;
+        }
+        else if (!ls->core().m_config.bSynRecving)
+        {
+            accepted = true;
+        }
+
+        if (!accepted && (ls->m_Status == SRTS_LISTENING))
+            accept_sync.wait();
+
+        if (ls->m_QueuedSockets.empty())
+            m_EPoll.update_events(listen, ls->core().m_sPollID, SRT_EPOLL_ACCEPT, false);
+    }
+
+    if (u == CUDT::INVALID_SOCK)
+    {
+        // non-blocking receiving, no connection available
+        if (!ls->core().m_config.bSynRecving)
+        {
+            LOGC(cnlog.Error, log << "srt_accept: no pending connection available at the moment");
+            throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
+        }
+
+        LOGC(cnlog.Error, log << "srt_accept: listener socket @" << listen << " is already closed");
+        // listening socket is closed
+        throw CUDTException(MJ_SETUP, MN_CLOSED, 0);
+    }
+
+    CUDTSocket* s = locateSocket(u);
+    if (s == NULL)
+    {
+        LOGC(cnlog.Error, log << "srt_accept: pending connection has unexpectedly closed");
+        throw CUDTException(MJ_SETUP, MN_CLOSED, 0);
+    }
+
+    // Set properly the SRTO_GROUPCONNECT flag
+    s->core().m_config.iGroupConnect = 0;
+
+    // Check if LISTENER has the SRTO_GROUPCONNECT flag set,
+    // and the already accepted socket has successfully joined
+    // the mirror group. If so, RETURN THE GROUP ID, not the socket ID.
+#if ENABLE_BONDING
+    if (ls->core().m_config.iGroupConnect == 1 && s->m_GroupOf)
+    {
+        // Put a lock to protect the group against accidental deletion
+        // in the meantime.
+        ScopedLock glock(m_GlobControlLock);
+        // Check again; it's unlikely to happen, but
+        // it's a theoretically possible scenario
+        if (s->m_GroupOf)
+        {
+            u                                = s->m_GroupOf->m_GroupID;
+            s->core().m_config.iGroupConnect = 1; // should be derived from ls, but make sure
+
+            // Mark the beginning of the connection at the moment
+            // when the group ID is returned to the app caller
+            s->m_GroupOf->m_stats.tsLastSampleTime = steady_clock::now();
+        }
+        else
+        {
+            LOGC(smlog.Error, log << "accept: IPE: socket's group deleted in the meantime of accept process???");
+        }
+    }
 #endif
 
-   ScopedLock cg(s->m_ControlLock);
-   
-   if (pw_addr != NULL && pw_addrlen != NULL)
-   {
-      // Check if the length of the buffer to fill the name in
-      // was large enough.
-      const int len = s->m_PeerAddr.size();
-      if (*pw_addrlen < len)
-          throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    ScopedLock cg(s->m_ControlLock);
 
-      memcpy((pw_addr), &s->m_PeerAddr, len);
-      *pw_addrlen = len;
-   }
+    if (pw_addr != NULL && pw_addrlen != NULL)
+    {
+        memcpy((pw_addr), s->m_PeerAddr.get(), s->m_PeerAddr.size());
+        *pw_addrlen = s->m_PeerAddr.size();
+    }
 
-   return u;
+    return u;
 }
 
-int CUDTUnited::connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* tarname, int namelen)
+int srt::CUDTUnited::connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* tarname, int namelen)
 {
     // Here both srcname and tarname must be specified
-    if (!srcname || !tarname || size_t(namelen) < sizeof (sockaddr_in))
+    if (!srcname || !tarname || namelen < int(sizeof(sockaddr_in)))
     {
-        LOGC(aclog.Error, log << "connect(with source): invalid call: srcname="
-                << srcname << " tarname=" << tarname << " namelen=" << namelen);
+        LOGC(aclog.Error,
+             log << "connect(with source): invalid call: srcname=" << srcname << " tarname=" << tarname
+                 << " namelen=" << namelen);
         throw CUDTException(MJ_NOTSUP, MN_INVAL);
     }
 
@@ -1231,18 +1219,18 @@ int CUDTUnited::connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* ta
     if (target_addr.len == 0)
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // Check affiliation of the socket. It's now allowed for it to be
     // a group or socket. For a group, add automatically a socket to
     // the group.
     if (u & SRTGROUP_MASK)
     {
-        GroupKeeper k (*this, u, ERH_THROW);
+        GroupKeeper k(*this, u, ERH_THROW);
         // Note: forced_isn is ignored when connecting a group.
         // The group manages the ISN by itself ALWAYS, that is,
         // it's generated anew for the very first socket, and then
         // derived by all sockets in the group.
-        SRT_SOCKGROUPCONFIG gd[1] = { srt_prepare_endpoint(srcname, tarname, namelen) };
+        SRT_SOCKGROUPCONFIG gd[1] = {srt_prepare_endpoint(srcname, tarname, namelen)};
 
         // When connecting to exactly one target, only this very target
         // can be returned as a socket, so rewritten back array can be ignored.
@@ -1259,25 +1247,31 @@ int CUDTUnited::connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* ta
     return connectIn(s, target_addr, SRT_SEQNO_NONE);
 }
 
-int CUDTUnited::connect(const SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn)
+int srt::CUDTUnited::connect(const SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn)
 {
+    if (!name || namelen < int(sizeof(sockaddr_in)))
+    {
+        LOGC(aclog.Error, log << "connect(): invalid call: name=" << name << " namelen=" << namelen);
+        throw CUDTException(MJ_NOTSUP, MN_INVAL);
+    }
+
     sockaddr_any target_addr(name, namelen);
     if (target_addr.len == 0)
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // Check affiliation of the socket. It's now allowed for it to be
     // a group or socket. For a group, add automatically a socket to
     // the group.
     if (u & SRTGROUP_MASK)
     {
-        GroupKeeper k (*this, u, ERH_THROW);
+        GroupKeeper k(*this, u, ERH_THROW);
 
         // Note: forced_isn is ignored when connecting a group.
         // The group manages the ISN by itself ALWAYS, that is,
         // it's generated anew for the very first socket, and then
         // derived by all sockets in the group.
-        SRT_SOCKGROUPCONFIG gd[1] = { srt_prepare_endpoint(NULL, name, namelen) };
+        SRT_SOCKGROUPCONFIG gd[1] = {srt_prepare_endpoint(NULL, name, namelen)};
         return singleMemberConnect(k.group, gd);
     }
 #endif
@@ -1289,8 +1283,8 @@ int CUDTUnited::connect(const SRTSOCKET u, const sockaddr* name, int namelen, in
     return connectIn(s, target_addr, forced_isn);
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-int CUDTUnited::singleMemberConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* gd)
+#if ENABLE_BONDING
+int srt::CUDTUnited::singleMemberConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* gd)
 {
     int gstat = groupConnect(pg, gd, 1);
     if (gstat == -1)
@@ -1310,19 +1304,11 @@ int CUDTUnited::singleMemberConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* gd)
 }
 
 // [[using assert(pg->m_iBusy > 0)]]
-int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int arraysize)
+int srt::CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int arraysize)
 {
     CUDTGroup& g = *pg;
     SRT_ASSERT(g.m_iBusy > 0);
 
-    // The group must be managed to use srt_connect on it,
-    // as it must create particular socket automatically.
-
-    // Non-managed groups can't be "connected" - at best you can connect
-    // every socket individually.
-    if (!g.managed())
-        throw CUDTException(MJ_NOTSUP, MN_INVAL);
-
     // Check and report errors on data brought in by srt_prepare_endpoint,
     // as the latter function has no possibility to report errors.
     for (int tii = 0; tii < arraysize; ++tii)
@@ -1345,14 +1331,16 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
     // group is already OPENED returns immediately, regardless if the
     // connection is going to later succeed or fail (this will be
     // known in the group state information).
-    bool block_new_opened = !g.m_bOpened && g.m_bSynRecving;
-    const bool was_empty = g.groupEmpty();
+    bool       block_new_opened = !g.m_bOpened && g.m_bSynRecving;
+    const bool was_empty        = g.groupEmpty();
 
     // In case the group was retried connection, clear first all epoll readiness.
     const int ncleared = m_EPoll.update_events(g.id(), g.m_sPollID, SRT_EPOLL_ERR, false);
     if (was_empty || ncleared)
     {
-        HLOGC(aclog.Debug, log << "srt_connect/group: clearing IN/OUT because was_empty=" << was_empty << " || ncleared=" << ncleared);
+        HLOGC(aclog.Debug,
+              log << "srt_connect/group: clearing IN/OUT because was_empty=" << was_empty
+                  << " || ncleared=" << ncleared);
         // IN/OUT only in case when the group is empty, otherwise it would
         // clear out correct readiness resulting from earlier calls.
         // This also should happen if ERR flag was set, as IN and OUT could be set, too.
@@ -1360,7 +1348,7 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
     }
     SRTSOCKET retval = -1;
 
-    int eid = -1;
+    int eid           = -1;
     int connect_modes = SRT_EPOLL_CONNECT | SRT_EPOLL_ERR;
     if (block_new_opened)
     {
@@ -1373,16 +1361,17 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
     // overall map.
     map<SRTSOCKET, CUDTSocket*> spawned;
 
-    HLOGC(aclog.Debug, log << "groupConnect: will connect " << arraysize << " links and "
-            << (block_new_opened ? "BLOCK until any is ready" : "leave the process in background"));
+    HLOGC(aclog.Debug,
+          log << "groupConnect: will connect " << arraysize << " links and "
+              << (block_new_opened ? "BLOCK until any is ready" : "leave the process in background"));
 
     for (int tii = 0; tii < arraysize; ++tii)
     {
         sockaddr_any target_addr(targets[tii].peeraddr);
         sockaddr_any source_addr(targets[tii].srcaddr);
-        SRTSOCKET& sid_rloc = targets[tii].id;
-        int& erc_rloc = targets[tii].errorcode;
-        erc_rloc = SRT_SUCCESS; // preinitialized
+        SRTSOCKET&   sid_rloc = targets[tii].id;
+        int&         erc_rloc = targets[tii].errorcode;
+        erc_rloc              = SRT_SUCCESS; // preinitialized
         HLOGC(aclog.Debug, log << "groupConnect: taking on " << sockaddr_any(targets[tii].peeraddr).str());
 
         CUDTSocket* ns = 0;
@@ -1394,7 +1383,7 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
         if (pg->m_cbConnectHook)
         {
             // Derive the connect hook by the socket, if set on the group
-            ns->m_pUDT->m_cbConnectHook = pg->m_cbConnectHook;
+            ns->core().m_cbConnectHook = pg->m_cbConnectHook;
         }
 
         SRT_SocketOptionObject* config = targets[tii].config;
@@ -1408,14 +1397,14 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
 
         // Set all options that were requested by the options set on a group
         // prior to connecting.
-        string error_reason ATR_UNUSED;
+        string error_reason SRT_ATR_UNUSED;
         try
         {
             for (size_t i = 0; i < g.m_config.size(); ++i)
             {
                 HLOGC(aclog.Debug, log << "groupConnect: OPTION @" << sid << " #" << g.m_config[i].so);
-                error_reason = "setting group-derived option: #" + Sprint(g.m_config[i].so);
-                ns->core().setOpt(g.m_config[i].so, &g.m_config[i].value[0], g.m_config[i].value.size());
+                error_reason = "group-derived option: #" + Sprint(g.m_config[i].so);
+                ns->core().setOpt(g.m_config[i].so, &g.m_config[i].value[0], (int)g.m_config[i].value.size());
             }
 
             // Do not try to set a user option if failed already.
@@ -1429,7 +1418,6 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             // We got it. Bind the socket, if the source address was set
             if (!source_addr.empty())
                 bind(ns, source_addr);
-
         }
         catch (CUDTException& e)
         {
@@ -1449,7 +1437,7 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
         // Do it after setting all stored options, as some of them may
         // influence some group data.
 
-        CUDTGroup::SocketData data = g.prepareData(ns);
+        srt::groups::SocketData data = srt::groups::prepareSocketData(ns);
         if (targets[tii].token != -1)
         {
             // Reuse the token, if specified by the caller
@@ -1458,7 +1446,7 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
         else
         {
             // Otherwise generate and write back the token
-            data.token = CUDTGroup::genToken();
+            data.token         = CUDTGroup::genToken();
             targets[tii].token = data.token;
         }
 
@@ -1483,23 +1471,25 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
 
             if (targets[tii].errorcode != SRT_SUCCESS)
             {
-                HLOGC(aclog.Debug, log << "srt_connect_group: not processing @" << sid << " due to error in setting options");
+                HLOGC(aclog.Debug,
+                      log << "srt_connect_group: not processing @" << sid << " due to error in setting options");
                 proceed = false;
             }
 
             if (g.m_bClosing)
             {
-                HLOGC(aclog.Debug, log << "srt_connect_group: not processing @" << sid << " due to CLOSED GROUP $" << g.m_GroupID);
+                HLOGC(aclog.Debug,
+                      log << "srt_connect_group: not processing @" << sid << " due to CLOSED GROUP $" << g.m_GroupID);
                 proceed = false;
             }
 
             if (proceed)
             {
-                CUDTGroup::gli_t f = g.add(data);
-                ns->m_IncludedIter = f;
-                ns->m_IncludedGroup = &g;
-                f->weight = targets[tii].weight;
-                LOGC(aclog.Note, log << "srt_connect_group: socket @" << sid << " added to group $" << g.m_GroupID);
+                CUDTGroup::SocketData* f = g.add(data);
+                ns->m_GroupMemberData    = f;
+                ns->m_GroupOf            = &g;
+                f->weight                = targets[tii].weight;
+                HLOGC(aclog.Debug, log << "srt_connect_group: socket @" << sid << " added to group $" << g.m_GroupID);
             }
             else
             {
@@ -1513,33 +1503,24 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             }
         }
 
-
         // XXX This should be reenabled later, this should
         // be probably still in use to exchange information about
-        // packets assymetrically lost. But for no other purpose.
+        // packets asymmetrically lost. But for no other purpose.
         /*
-        ns->m_pUDT->m_cbPacketArrival.set(ns->m_pUDT, &CUDT::groupPacketArrival);
+        ns->core().m_cbPacketArrival.set(ns->m_pUDT, &CUDT::groupPacketArrival);
         */
 
         int isn = g.currentSchedSequence();
 
-        // Don't synchronize ISN in case of synch on msgno. Every link
-        // may send their own payloads independently.
-        if (g.synconmsgno())
-        {
-            HLOGC(aclog.Debug, log << "groupConnect: NOT synchronizing sequence numbers: will sync on msgno");
-            isn = -1;
-        }
-
         // Set it the groupconnect option, as all in-group sockets should have.
-        ns->m_pUDT->m_OPT_GroupConnect = 1;
+        ns->core().m_config.iGroupConnect = 1;
 
         // Every group member will have always nonblocking
         // (this implies also non-blocking connect/accept).
         // The group facility functions will block when necessary
         // using epoll_wait.
-        ns->m_pUDT->m_bSynRecving = false;
-        ns->m_pUDT->m_bSynSending = false;
+        ns->core().m_config.bSynRecving = false;
+        ns->core().m_config.bSynSending = false;
 
         HLOGC(aclog.Debug, log << "groupConnect: NOTIFIED AS PENDING @" << sid << " both read and write");
         // If this socket is not to block the current connect process,
@@ -1565,17 +1546,18 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             HLOGC(aclog.Debug, log << "groupConnect: connecting a new socket with ISN=" << isn);
             connectIn(ns, target_addr, isn);
         }
-        catch (CUDTException& e)
+        catch (const CUDTException& e)
         {
-            LOGC(aclog.Error, log << "groupConnect: socket @" << sid << " in group " << pg->id() << " failed to connect");
+            LOGC(aclog.Error,
+                 log << "groupConnect: socket @" << sid << " in group " << pg->id() << " failed to connect");
             // We know it does belong to a group.
             // Remove it first because this involves a mutex, and we want
             // to avoid locking more than one mutex at a time.
-            erc_rloc = e.getErrorCode();
+            erc_rloc               = e.getErrorCode();
             targets[tii].errorcode = e.getErrorCode();
-            targets[tii].id = CUDT::INVALID_SOCK;
+            targets[tii].id        = CUDT::INVALID_SOCK;
 
-            ScopedLock cl (m_GlobControlLock);
+            ScopedLock cl(m_GlobControlLock);
             ns->removeFromGroup(false);
             m_Sockets.erase(ns->m_SocketID);
             // Intercept to delete the socket on failure.
@@ -1586,8 +1568,8 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
         {
             LOGC(aclog.Fatal, log << "groupConnect: IPE: UNKNOWN EXCEPTION from connectIn");
             targets[tii].errorcode = SRT_ESYSOBJ;
-            targets[tii].id = CUDT::INVALID_SOCK;
-            ScopedLock cl (m_GlobControlLock);
+            targets[tii].id        = CUDT::INVALID_SOCK;
+            ScopedLock cl(m_GlobControlLock);
             ns->removeFromGroup(false);
             m_Sockets.erase(ns->m_SocketID);
             // Intercept to delete the socket on failure.
@@ -1599,16 +1581,16 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
 
         SRT_SOCKSTATUS st;
         {
-            ScopedLock grd (ns->m_ControlLock);
+            ScopedLock grd(ns->m_ControlLock);
             st = ns->getStatus();
         }
 
         {
             // NOTE: Not applying m_GlobControlLock because the group is now
             // set busy, so it won't be deleted, even if it was requested to be closed.
-            ScopedLock grd (g.m_GroupLock);
+            ScopedLock grd(g.m_GroupLock);
 
-            if (!ns->m_IncludedGroup)
+            if (!ns->m_GroupOf)
             {
                 // The situation could get changed between the unlock and lock of m_GroupLock.
                 // This must be checked again.
@@ -1621,8 +1603,8 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
                 continue;
             }
 
-            // If m_IncludedGroup is not NULL, the m_IncludedIter is still valid.
-            CUDTGroup::gli_t f = ns->m_IncludedIter;
+            // If m_GroupOf is not NULL, the m_IncludedIter is still valid.
+            CUDTGroup::SocketData* f = ns->m_GroupMemberData;
 
             // Now under a group lock, we need to make sure the group isn't being closed
             // in order not to add a socket to a dead group.
@@ -1635,18 +1617,14 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
                 // set BROKEN or PENDING.
                 f->sndstate = SRT_GST_PENDING;
                 f->rcvstate = SRT_GST_PENDING;
-                retval = -1;
+                retval      = -1;
                 break;
             }
 
-            if (was_empty)
-            {
-                g.syncWithSocket(ns->core(), HSD_INITIATOR);
-            }
-
-            HLOGC(aclog.Debug, log << "groupConnect: @" << sid << " connection successful, setting group OPEN (was "
-                    << (g.m_bOpened ? "ALREADY" : "NOT") << "), will " << (block_new_opened ? "" : "NOT ")
-                    << "block the connect call, status:" << SockStatusStr(st));
+            HLOGC(aclog.Debug,
+                  log << "groupConnect: @" << sid << " connection successful, setting group OPEN (was "
+                      << (g.m_bOpened ? "ALREADY" : "NOT") << "), will " << (block_new_opened ? "" : "NOT ")
+                      << "block the connect call, status:" << SockStatusStr(st));
 
             // XXX OPEN OR CONNECTED?
             // BLOCK IF NOT OPEN OR BLOCK IF NOT CONNECTED?
@@ -1658,12 +1636,14 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             // should block always if the group doesn't have neither 1 conencted link
             g.m_bOpened = true;
 
+            g.m_stats.tsLastSampleTime = steady_clock::now();
+
             f->laststatus = st;
             // Check the socket status and update it.
             // Turn the group state of the socket to IDLE only if
             // connection is established or in progress
             f->agent = source_addr;
-            f->peer = target_addr;
+            f->peer  = target_addr;
 
             if (st >= SRTS_BROKEN)
             {
@@ -1674,13 +1654,13 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             }
             else
             {
-                f->sndstate = SRT_GST_PENDING;
-                f->rcvstate = SRT_GST_PENDING;
+                f->sndstate  = SRT_GST_PENDING;
+                f->rcvstate  = SRT_GST_PENDING;
                 spawned[sid] = ns;
 
                 sid_rloc = sid;
                 erc_rloc = 0;
-                retval = sid;
+                retval   = sid;
             }
         }
     }
@@ -1702,15 +1682,18 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             break;
         }
         HLOGC(aclog.Debug, log << "groupConnect: first connection, applying EPOLL WAITING.");
-        int len = spawned.size();
+        int               len = (int)spawned.size();
         vector<SRTSOCKET> ready(spawned.size());
-        const int estat = srt_epoll_wait(eid,
-                    NULL, NULL,  // IN/ACCEPT
-                    &ready[0], &len, // OUT/CONNECT
-                    -1, // indefinitely (FIXME Check if it needs to REGARD CONNECTION TIMEOUT!)
-                    NULL, NULL,
-                    NULL, NULL
-                    );
+        const int         estat = srt_epoll_wait(eid,
+                                         NULL,
+                                         NULL, // IN/ACCEPT
+                                         &ready[0],
+                                         &len, // OUT/CONNECT
+                                         -1, // indefinitely (FIXME Check if it needs to REGARD CONNECTION TIMEOUT!)
+                                         NULL,
+                                         NULL,
+                                         NULL,
+                                         NULL);
 
         // Sanity check. Shouldn't happen if subs are in sync with spawned.
         if (estat == -1)
@@ -1719,8 +1702,9 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             CUDTException& x = CUDT::getlasterror();
             if (x.getErrorCode() != SRT_EPOLLEMPTY)
             {
-                LOGC(aclog.Error, log << "groupConnect: srt_epoll_wait failed not because empty, unexpected IPE:"
-                        << x.getErrorMessage());
+                LOGC(aclog.Error,
+                     log << "groupConnect: srt_epoll_wait failed not because empty, unexpected IPE:"
+                         << x.getErrorMessage());
             }
 #endif
             HLOGC(aclog.Debug, log << "groupConnect: srt_epoll_wait failed - breaking the wait loop");
@@ -1732,20 +1716,21 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
         // lock the groups so that no one messes up with something here
         // in the meantime.
 
-        ScopedLock lock (*g.exp_groupLock());
+        ScopedLock lock(*g.exp_groupLock());
 
         // NOTE: UNDER m_GroupLock, NO API FUNCTION CALLS DARE TO HAPPEN BELOW!
 
         // Check first if a socket wasn't closed in the meantime. It will be
         // automatically removed from all EIDs, but there's no sense in keeping
         // them in 'spawned' map.
-        for (map<SRTSOCKET, CUDTSocket*>::iterator y = spawned.begin();
-                y != spawned.end(); ++y)
+        for (map<SRTSOCKET, CUDTSocket*>::iterator y = spawned.begin(); y != spawned.end(); ++y)
         {
             SRTSOCKET sid = y->first;
             if (y->second->getStatus() >= SRTS_BROKEN)
             {
-                HLOGC(aclog.Debug, log << "groupConnect: Socket @" << sid << " got BROKEN in the meantine during the check, remove from candidates");
+                HLOGC(aclog.Debug,
+                      log << "groupConnect: Socket @" << sid
+                          << " got BROKEN in the meantine during the check, remove from candidates");
                 // Remove from spawned and try again
                 broken.push_back(sid);
 
@@ -1774,15 +1759,17 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
                 continue;
             }
 
-            SRTSOCKET sid = x->first;
-            CUDTSocket* s = x->second;
+            SRTSOCKET   sid = x->first;
+            CUDTSocket* s   = x->second;
 
             // Check status. If failed, remove from spawned
             // and try again.
             SRT_SOCKSTATUS st = s->getStatus();
             if (st >= SRTS_BROKEN)
             {
-                HLOGC(aclog.Debug, log << "groupConnect: Socket @" << sid << " got BROKEN during background connect, remove & TRY AGAIN");
+                HLOGC(aclog.Debug,
+                      log << "groupConnect: Socket @" << sid
+                          << " got BROKEN during background connect, remove & TRY AGAIN");
                 // Remove from spawned and try again
                 if (spawned.erase(sid))
                     broken.push_back(sid);
@@ -1796,9 +1783,10 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
 
             if (st == SRTS_CONNECTED)
             {
-                HLOGC(aclog.Debug, log << "groupConnect: Socket @" << sid << " got CONNECTED as first in the group - reporting");
-                retval = sid;
-                g.m_bConnected = true;
+                HLOGC(aclog.Debug,
+                      log << "groupConnect: Socket @" << sid << " got CONNECTED as first in the group - reporting");
+                retval           = sid;
+                g.m_bConnected   = true;
                 block_new_opened = false; // Interrupt also rolling epoll (outer loop)
 
                 // Remove this socket from SND EID because it doesn't need to
@@ -1811,8 +1799,9 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
             }
 
             // Spurious?
-            HLOGC(aclog.Debug, log << "groupConnect: Socket @" << sid << " got spurious wakeup in "
-                    << SockStatusStr(st) << " TRY AGAIN");
+            HLOGC(aclog.Debug,
+                  log << "groupConnect: Socket @" << sid << " got spurious wakeup in " << SockStatusStr(st)
+                      << " TRY AGAIN");
         }
         // END of m_GroupLock CS - you can safely use API functions now.
     }
@@ -1848,101 +1837,119 @@ int CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, int ar
 }
 #endif
 
+int srt::CUDTUnited::connectIn(CUDTSocket* s, const sockaddr_any& target_addr, int32_t forced_isn)
+{
+    ScopedLock cg(s->m_ControlLock);
+    // a socket can "connect" only if it is in the following states:
+    // - OPENED: assume the socket binding parameters are configured
+    // - INIT: configure binding parameters here
+    // - any other (meaning, already connected): report error
+
+    if (s->m_Status == SRTS_INIT)
+    {
+        if (s->core().m_config.bRendezvous)
+            throw CUDTException(MJ_NOTSUP, MN_ISRENDUNBOUND, 0);
+
+        // If bind() was done first on this socket, then the
+        // socket will not perform this step. This actually does the
+        // same thing as bind() does, just with empty address so that
+        // the binding parameters are autoselected.
+
+        s->core().open();
+        sockaddr_any autoselect_sa(target_addr.family());
+        // This will create such a sockaddr_any that
+        // will return true from empty().
+        updateMux(s, autoselect_sa); // <<---- updateMux
+        // -> C(Snd|Rcv)Queue::init
+        // -> pthread_create(...C(Snd|Rcv)Queue::worker...)
+        s->m_Status = SRTS_OPENED;
+    }
+    else
+    {
+        if (s->m_Status != SRTS_OPENED)
+            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
+
+        // status = SRTS_OPENED, so family should be known already.
+        if (target_addr.family() != s->m_SelfAddr.family())
+        {
+            LOGP(cnlog.Error, "srt_connect: socket is bound to a different family than target address");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+    }
+
+    // connect_complete() may be called before connect() returns.
+    // So we need to update the status before connect() is called,
+    // otherwise the status may be overwritten with wrong value
+    // (CONNECTED vs. CONNECTING).
+    s->m_Status = SRTS_CONNECTING;
+
+    /*
+     * In blocking mode, connect can block for up to 30 seconds for
+     * rendez-vous mode. Holding the s->m_ControlLock prevent close
+     * from cancelling the connect
+     */
+    try
+    {
+        // record peer address
+        s->m_PeerAddr = target_addr;
+        s->core().startConnect(target_addr, forced_isn);
+    }
+    catch (const CUDTException&) // Interceptor, just to change the state.
+    {
+        s->m_Status = SRTS_OPENED;
+        throw;
+    }
+
+    return 0;
+}
 
-int CUDTUnited::connectIn(CUDTSocket* s, const sockaddr_any& target_addr, int32_t forced_isn)
-{
-   ScopedLock cg(s->m_ControlLock);
-   // a socket can "connect" only if it is in the following states:
-   // - OPENED: assume the socket binding parameters are configured
-   // - INIT: configure binding parameters here
-   // - any other (meaning, already connected): report error
-
-   if (s->m_Status == SRTS_INIT)
-   {
-       if (s->m_pUDT->m_bRendezvous)
-           throw CUDTException(MJ_NOTSUP, MN_ISRENDUNBOUND, 0);
-
-       // If bind() was done first on this socket, then the
-       // socket will not perform this step. This actually does the
-       // same thing as bind() does, just with empty address so that
-       // the binding parameters are autoselected.
-
-       s->m_pUDT->open();
-       sockaddr_any autoselect_sa (target_addr.family());
-       // This will create such a sockaddr_any that
-       // will return true from empty(). 
-       updateMux(s, autoselect_sa);  // <<---- updateMux
-       // -> C(Snd|Rcv)Queue::init
-       // -> pthread_create(...C(Snd|Rcv)Queue::worker...)
-       s->m_Status = SRTS_OPENED;
-   }
-   else
-   {
-       if (s->m_Status != SRTS_OPENED)
-           throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-       // status = SRTS_OPENED, so family should be known already.
-       if (target_addr.family() != s->m_SelfAddr.family())
-       {
-           LOGP(cnlog.Error, "srt_connect: socket is bound to a different family than target address");
-           throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-       }
-   }
-
-
-   // connect_complete() may be called before connect() returns.
-   // So we need to update the status before connect() is called,
-   // otherwise the status may be overwritten with wrong value
-   // (CONNECTED vs. CONNECTING).
-   s->m_Status = SRTS_CONNECTING;
-
-  /* 
-   * In blocking mode, connect can block for up to 30 seconds for
-   * rendez-vous mode. Holding the s->m_ControlLock prevent close
-   * from cancelling the connect
-   */
-   try
-   {
-       // record peer address
-       s->m_PeerAddr = target_addr;
-       s->m_pUDT->startConnect(target_addr, forced_isn);
-   }
-   catch (CUDTException& e) // Interceptor, just to change the state.
-   {
-      s->m_Status = SRTS_OPENED;
-      throw e;
-   }
-
-   // ScopedLock destructor will delete cg and unlock s->m_ControlLock
-
-   return 0;
-}
-
-
-int CUDTUnited::close(const SRTSOCKET u)
-{
-#if ENABLE_EXPERIMENTAL_BONDING
+int srt::CUDTUnited::close(const SRTSOCKET u)
+{
+#if ENABLE_BONDING
     if (u & SRTGROUP_MASK)
     {
-        GroupKeeper k (*this, u, ERH_THROW);
+        GroupKeeper k(*this, u, ERH_THROW);
         k.group->close();
         deleteGroup(k.group);
         return 0;
     }
 #endif
-    CUDTSocket* s = locateSocket(u);
-    if (!s)
-        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+#if ENABLE_HEAVY_LOGGING
+    // Wrapping the log into a destructor so that it
+    // is printed AFTER the destructor of SocketKeeper.
+    struct ScopedExitLog
+    {
+        const CUDTSocket* const ps;
+        ScopedExitLog(const CUDTSocket* p): ps(p){}
+        ~ScopedExitLog()
+        {
+            if (ps) // Could be not acquired by SocketKeeper, occasionally
+            {
+                HLOGC(smlog.Debug, log << "CUDTUnited::close/end: @" << ps->m_SocketID << " busy=" << ps->isStillBusy());
+            }
+        }
+    };
+#endif
+
+    SocketKeeper k(*this, u, ERH_THROW);
+    IF_HEAVY_LOGGING(ScopedExitLog slog(k.socket));
+    HLOGC(smlog.Debug, log << "CUDTUnited::close/begin: @" << u << " busy=" << k.socket->isStillBusy());
 
-    return close(s);
+    return close(k.socket);
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-void CUDTUnited::deleteGroup(CUDTGroup* g)
+#if ENABLE_BONDING
+void srt::CUDTUnited::deleteGroup(CUDTGroup* g)
 {
     using srt_logging::gmlog;
 
-    srt::sync::ScopedLock cg (m_GlobControlLock);
+    srt::sync::ScopedLock cg(m_GlobControlLock);
+    return deleteGroup_LOCKED(g);
+}
+
+// [[using locked(m_GlobControlLock)]]
+void srt::CUDTUnited::deleteGroup_LOCKED(CUDTGroup* g)
+{
     SRT_ASSERT(g->groupEmpty());
 
     // After that the group is no longer findable by GroupKeeper
@@ -1953,485 +1960,472 @@ void CUDTUnited::deleteGroup(CUDTGroup* g)
     // it may potentially be deleted. Make sure no socket points
     // to it. Actually all sockets should have been already removed
     // from the group container, so if any does, it's invalid.
-    for (sockets_t::iterator i = m_Sockets.begin();
-            i != m_Sockets.end(); ++ i)
+    for (sockets_t::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++i)
     {
         CUDTSocket* s = i->second;
-        if (s->m_IncludedGroup == g)
+        if (s->m_GroupOf == g)
         {
             HLOGC(smlog.Debug, log << "deleteGroup: IPE: existing @" << s->m_SocketID << " points to a dead group!");
-            s->m_IncludedGroup = NULL;
-            s->m_IncludedIter = CUDTGroup::gli_NULL();
+            s->m_GroupOf         = NULL;
+            s->m_GroupMemberData = NULL;
         }
     }
 
     // Just in case, do it in closed sockets, too, although this should be
     // always done before moving to it.
-    for (sockets_t::iterator i = m_ClosedSockets.begin();
-            i != m_ClosedSockets.end(); ++ i)
+    for (sockets_t::iterator i = m_ClosedSockets.begin(); i != m_ClosedSockets.end(); ++i)
     {
         CUDTSocket* s = i->second;
-        if (s->m_IncludedGroup == g)
+        if (s->m_GroupOf == g)
         {
             HLOGC(smlog.Debug, log << "deleteGroup: IPE: closed @" << s->m_SocketID << " points to a dead group!");
-            s->m_IncludedGroup = NULL;
-            s->m_IncludedIter = CUDTGroup::gli_NULL();
+            s->m_GroupOf         = NULL;
+            s->m_GroupMemberData = NULL;
         }
     }
 }
 #endif
 
-int CUDTUnited::close(CUDTSocket* s)
-{
-   HLOGC(smlog.Debug, log << s->m_pUDT->CONID() << " CLOSE. Acquiring control lock");
-
-   ScopedLock socket_cg(s->m_ControlLock);
-
-   HLOGC(smlog.Debug, log << s->m_pUDT->CONID() << " CLOSING (removing from listening, closing CUDT)");
-
-   bool synch_close_snd = s->m_pUDT->m_bSynSending;
-
-   SRTSOCKET u = s->m_SocketID;
-
-   if (s->m_Status == SRTS_LISTENING)
-   {
-      if (s->m_pUDT->m_bBroken)
-         return 0;
-
-      s->m_tsClosureTimeStamp = steady_clock::now();
-      s->m_pUDT->m_bBroken    = true;
-
-      // Change towards original UDT: 
-      // Leave all the closing activities for garbageCollect to happen,
-      // however remove the listener from the RcvQueue IMMEDIATELY.
-      // Even though garbageCollect would eventually remove the listener
-      // as well, there would be some time interval between now and the
-      // moment when it's done, and during this time the application will
-      // be unable to bind to this port that the about-to-delete listener
-      // is currently occupying (due to blocked slot in the RcvQueue).
-
-      HLOGC(smlog.Debug, log << s->m_pUDT->CONID() << " CLOSING (removing listener immediately)");
-      s->m_pUDT->notListening();
-
-      // broadcast all "accept" waiting
-      CSync::lock_broadcast(s->m_AcceptCond, s->m_AcceptLock);
-   }
-   else
-   {
-       // Note: this call may be done on a socket that hasn't finished
-       // sending all packets scheduled for sending, which means, this call
-       // may block INDEFINITELY. As long as it's acceptable to block the
-       // call to srt_close(), and all functions in all threads where this
-       // very socket is used, this shall not block the central database.
-       s->m_pUDT->closeInternal();
-
-       // synchronize with garbage collection.
-       HLOGC(smlog.Debug, log << "@" << u << "U::close done. GLOBAL CLOSE: " << s->m_pUDT->CONID() << ". Acquiring GLOBAL control lock");
-       ScopedLock manager_cg(m_GlobControlLock);
-       // since "s" is located before m_GlobControlLock, locate it again in case
-       // it became invalid
-       // XXX This is very weird; if we state that the CUDTSocket object
-       // could not be deleted between locks, then definitely it couldn't
-       // also change the pointer value. There's no other reason for getting
-       // this iterator but to obtain the 's' pointer, which is impossible to
-       // be different than previous 's' (m_Sockets is a map that stores pointers
-       // transparently). This iterator isn't even later used to delete the socket
-       // from the container, though it would be more efficient.
-       // FURTHER RESEARCH REQUIRED.
-       sockets_t::iterator i = m_Sockets.find(u);
-       if ((i == m_Sockets.end()) || (i->second->m_Status == SRTS_CLOSED))
-       {
-           HLOGC(smlog.Debug, log << "@" << u << "U::close: NOT AN ACTIVE SOCKET, returning.");
-           return 0;
-       }
-       s = i->second;
-       s->setClosed();
-
-#if ENABLE_EXPERIMENTAL_BONDING
-       if (s->m_IncludedGroup)
-       {
-           HLOGC(smlog.Debug, log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_IncludedGroup->id() << " - REMOVING FROM GROUP");
-           s->removeFromGroup(true);
-       }
+int srt::CUDTUnited::close(CUDTSocket* s)
+{
+    HLOGC(smlog.Debug, log << s->core().CONID() << "CLOSE. Acquiring control lock");
+    ScopedLock socket_cg(s->m_ControlLock);
+    HLOGC(smlog.Debug, log << s->core().CONID() << "CLOSING (removing from listening, closing CUDT)");
+
+    const bool synch_close_snd = s->core().m_config.bSynSending;
+
+    SRTSOCKET u = s->m_SocketID;
+
+    if (s->m_Status == SRTS_LISTENING)
+    {
+        if (s->core().m_bBroken)
+            return 0;
+
+        s->m_tsClosureTimeStamp = steady_clock::now();
+        s->core().m_bBroken     = true;
+
+        // Change towards original UDT:
+        // Leave all the closing activities for garbageCollect to happen,
+        // however remove the listener from the RcvQueue IMMEDIATELY.
+        // Even though garbageCollect would eventually remove the listener
+        // as well, there would be some time interval between now and the
+        // moment when it's done, and during this time the application will
+        // be unable to bind to this port that the about-to-delete listener
+        // is currently occupying (due to blocked slot in the RcvQueue).
+
+        HLOGC(smlog.Debug, log << s->core().CONID() << "CLOSING (removing listener immediately)");
+        s->core().notListening();
+        s->m_Status = SRTS_CLOSING;
+
+        // broadcast all "accept" waiting
+        CSync::lock_notify_all(s->m_AcceptCond, s->m_AcceptLock);
+    }
+    else
+    {
+        s->m_Status = SRTS_CLOSING;
+        // Note: this call may be done on a socket that hasn't finished
+        // sending all packets scheduled for sending, which means, this call
+        // may block INDEFINITELY. As long as it's acceptable to block the
+        // call to srt_close(), and all functions in all threads where this
+        // very socket is used, this shall not block the central database.
+        s->core().closeInternal();
+
+        // synchronize with garbage collection.
+        HLOGC(smlog.Debug,
+              log << "@" << u << "U::close done. GLOBAL CLOSE: " << s->core().CONID()
+                  << "Acquiring GLOBAL control lock");
+        ScopedLock manager_cg(m_GlobControlLock);
+        // since "s" is located before m_GlobControlLock, locate it again in case
+        // it became invalid
+        // XXX This is very weird; if we state that the CUDTSocket object
+        // could not be deleted between locks, then definitely it couldn't
+        // also change the pointer value. There's no other reason for getting
+        // this iterator but to obtain the 's' pointer, which is impossible to
+        // be different than previous 's' (m_Sockets is a map that stores pointers
+        // transparently). This iterator isn't even later used to delete the socket
+        // from the container, though it would be more efficient.
+        // FURTHER RESEARCH REQUIRED.
+        sockets_t::iterator i = m_Sockets.find(u);
+        if ((i == m_Sockets.end()) || (i->second->m_Status == SRTS_CLOSED))
+        {
+            HLOGC(smlog.Debug, log << "@" << u << "U::close: NOT AN ACTIVE SOCKET, returning.");
+            return 0;
+        }
+        s = i->second;
+        s->setClosed();
+
+#if ENABLE_BONDING
+        if (s->m_GroupOf)
+        {
+            HLOGC(smlog.Debug,
+                  log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_GroupOf->id() << " - REMOVING FROM GROUP");
+            s->removeFromGroup(true);
+        }
 #endif
 
-       m_Sockets.erase(s->m_SocketID);
-       m_ClosedSockets[s->m_SocketID] = s;
-       HLOGC(smlog.Debug, log << "@" << u << "U::close: Socket MOVED TO CLOSED for collecting later.");
+        m_Sockets.erase(s->m_SocketID);
+        m_ClosedSockets[s->m_SocketID] = s;
+        HLOGC(smlog.Debug, log << "@" << u << "U::close: Socket MOVED TO CLOSED for collecting later.");
 
-       CGlobEvent::triggerEvent();
-   }
+        CGlobEvent::triggerEvent();
+    }
 
-   HLOGC(smlog.Debug, log << "@" << u << ": GLOBAL: CLOSING DONE");
+    HLOGC(smlog.Debug, log << "@" << u << ": GLOBAL: CLOSING DONE");
 
-   // Check if the ID is still in closed sockets before you access it
-   // (the last triggerEvent could have deleted it).
-   if ( synch_close_snd )
-   {
+    // Check if the ID is still in closed sockets before you access it
+    // (the last triggerEvent could have deleted it).
+    if (synch_close_snd)
+    {
 #if SRT_ENABLE_CLOSE_SYNCH
 
-       HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: sync-waiting for releasing sender resources...");
-       for (;;)
-       {
-           CSndBuffer* sb = s->m_pUDT->m_pSndBuffer;
-
-           // Disconnected from buffer - nothing more to check.
-           if (!sb)
-           {
-               HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: sending buffer disconnected. Allowed to close.");
-               break;
-           }
-
-           // Sender buffer empty
-           if (sb->getCurrBufSize() == 0)
-           {
-               HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: sending buffer depleted. Allowed to close.");
-               break;
-           }
-
-           // Ok, now you are keeping GC thread hands off the internal data.
-           // You can check then if it has already deleted the socket or not.
-           // The socket is either in m_ClosedSockets or is already gone.
-
-           // Done the other way, but still done. You can stop waiting.
-           bool isgone = false;
-           {
-               ScopedLock manager_cg(m_GlobControlLock);
-               isgone = m_ClosedSockets.count(u) == 0;
-           }
-           if (!isgone)
-           {
-               isgone = !s->m_pUDT->m_bOpened;
-           }
-           if (isgone)
-           {
-               HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: ... gone in the meantime, whatever. Exiting close().");
-               break;
-           }
-
-           HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: ... still waiting for any update.");
-           // How to handle a possible error here?
-           CGlobEvent::waitForEvent();
-
-           // Continue waiting in case when an event happened or 1s waiting time passed for checkpoint.
-       }
+        HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: sync-waiting for releasing sender resources...");
+        for (;;)
+        {
+            CSndBuffer* sb = s->core().m_pSndBuffer;
+
+            // Disconnected from buffer - nothing more to check.
+            if (!sb)
+            {
+                HLOGC(smlog.Debug,
+                      log << "@" << u << " GLOBAL CLOSING: sending buffer disconnected. Allowed to close.");
+                break;
+            }
+
+            // Sender buffer empty
+            if (sb->getCurrBufSize() == 0)
+            {
+                HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: sending buffer depleted. Allowed to close.");
+                break;
+            }
+
+            // Ok, now you are keeping GC thread hands off the internal data.
+            // You can check then if it has already deleted the socket or not.
+            // The socket is either in m_ClosedSockets or is already gone.
+
+            // Done the other way, but still done. You can stop waiting.
+            bool isgone = false;
+            {
+                ScopedLock manager_cg(m_GlobControlLock);
+                isgone = m_ClosedSockets.count(u) == 0;
+            }
+            if (!isgone)
+            {
+                isgone = !s->core().m_bOpened;
+            }
+            if (isgone)
+            {
+                HLOGC(smlog.Debug,
+                      log << "@" << u << " GLOBAL CLOSING: ... gone in the meantime, whatever. Exiting close().");
+                break;
+            }
+
+            HLOGC(smlog.Debug, log << "@" << u << " GLOBAL CLOSING: ... still waiting for any update.");
+            // How to handle a possible error here?
+            CGlobEvent::waitForEvent();
+
+            // Continue waiting in case when an event happened or 1s waiting time passed for checkpoint.
+        }
 #endif
-   }
+    }
 
-   /*
-      This code is PUT ASIDE for now.
-      Most likely this will be never required.
-      It had to hold the closing activity until the time when the receiver buffer is depleted.
-      However the closing of the socket should only happen when the receiver has received
-      an information about that the reading is no longer possible (error report from recv/recvfile).
-      When this happens, the receiver buffer is definitely depleted already and there's no need to check
-      anything.
+    /*
+       This code is PUT ASIDE for now.
+       Most likely this will be never required.
+       It had to hold the closing activity until the time when the receiver buffer is depleted.
+       However the closing of the socket should only happen when the receiver has received
+       an information about that the reading is no longer possible (error report from recv/recvfile).
+       When this happens, the receiver buffer is definitely depleted already and there's no need to check
+       anything.
 
-      Should there appear any other conditions in future under which the closing process should be
-      delayed until the receiver buffer is empty, this code can be filled here.
+       Should there appear any other conditions in future under which the closing process should be
+       delayed until the receiver buffer is empty, this code can be filled here.
 
-   if ( synch_close_rcv )
-   {
-   ...
-   }
-   */
+    if ( synch_close_rcv )
+    {
+    ...
+    }
+    */
+    CSync::notify_one_relaxed(m_GCStopCond);
 
-   return 0;
+    return 0;
 }
 
-void CUDTUnited::getpeername(const SRTSOCKET u, sockaddr* pw_name, int* pw_namelen)
+void srt::CUDTUnited::getpeername(const SRTSOCKET u, sockaddr* pw_name, int* pw_namelen)
 {
-   if (!pw_name || !pw_namelen)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    if (!pw_name || !pw_namelen)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   if (getStatus(u) != SRTS_CONNECTED)
-      throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
+    if (getStatus(u) != SRTS_CONNECTED)
+        throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
 
-   CUDTSocket* s = locateSocket(u);
+    CUDTSocket* s = locateSocket(u);
 
-   if (!s)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+    if (!s)
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
 
-   if (!s->m_pUDT->m_bConnected || s->m_pUDT->m_bBroken)
-      throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
+    if (!s->core().m_bConnected || s->core().m_bBroken)
+        throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
 
-   const int len = s->m_PeerAddr.size();
-   if (*pw_namelen < len)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    const int len = s->m_PeerAddr.size();
+    if (*pw_namelen < len)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   memcpy((pw_name), &s->m_PeerAddr.sa, len);
-   *pw_namelen = len;
+    memcpy((pw_name), &s->m_PeerAddr.sa, len);
+    *pw_namelen = len;
 }
 
-void CUDTUnited::getsockname(const SRTSOCKET u, sockaddr* pw_name, int* pw_namelen)
+void srt::CUDTUnited::getsockname(const SRTSOCKET u, sockaddr* pw_name, int* pw_namelen)
 {
-   if (!pw_name || !pw_namelen)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    if (!pw_name || !pw_namelen)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   CUDTSocket* s = locateSocket(u);
+    CUDTSocket* s = locateSocket(u);
 
-   if (!s)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+    if (!s)
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
 
-   if (s->m_pUDT->m_bBroken)
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+    if (s->core().m_bBroken)
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
 
-   if (s->m_Status == SRTS_INIT)
-      throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
+    if (s->m_Status == SRTS_INIT)
+        throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
 
-   const int len = s->m_SelfAddr.size();
-   if (*pw_namelen < len)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    const int len = s->m_SelfAddr.size();
+    if (*pw_namelen < len)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   memcpy((pw_name), &s->m_SelfAddr.sa, len);
-   *pw_namelen = len;
+    memcpy((pw_name), &s->m_SelfAddr.sa, len);
+    *pw_namelen = len;
 }
 
-int CUDTUnited::select(
-   UDT::UDSET* readfds, UDT::UDSET* writefds, UDT::UDSET* exceptfds, const timeval* timeout)
+int srt::CUDTUnited::select(UDT::UDSET* readfds, UDT::UDSET* writefds, UDT::UDSET* exceptfds, const timeval* timeout)
 {
-   const steady_clock::time_point entertime = steady_clock::now();
+    const steady_clock::time_point entertime = steady_clock::now();
 
-   const long timeo_us = timeout
-       ? timeout->tv_sec * 1000000 + timeout->tv_usec
-       : -1;
-   const steady_clock::duration timeo(microseconds_from(timeo_us));
+    const int64_t timeo_us = timeout ? static_cast<int64_t>(timeout->tv_sec) * 1000000 + timeout->tv_usec : -1;
+    const steady_clock::duration timeo(microseconds_from(timeo_us));
 
-   // initialize results
-   int count = 0;
-   set<SRTSOCKET> rs, ws, es;
+    // initialize results
+    int            count = 0;
+    set<SRTSOCKET> rs, ws, es;
 
-   // retrieve related UDT sockets
-   vector<CUDTSocket*> ru, wu, eu;
-   CUDTSocket* s;
-   if (readfds)
-      for (set<SRTSOCKET>::iterator i1 = readfds->begin();
-         i1 != readfds->end(); ++ i1)
-      {
-         if (getStatus(*i1) == SRTS_BROKEN)
-         {
-            rs.insert(*i1);
-            ++ count;
-         }
-         else if (!(s = locateSocket(*i1)))
-            throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-         else
-            ru.push_back(s);
-      }
-   if (writefds)
-      for (set<SRTSOCKET>::iterator i2 = writefds->begin();
-         i2 != writefds->end(); ++ i2)
-      {
-         if (getStatus(*i2) == SRTS_BROKEN)
-         {
-            ws.insert(*i2);
-            ++ count;
-         }
-         else if (!(s = locateSocket(*i2)))
-            throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-         else
-            wu.push_back(s);
-      }
-   if (exceptfds)
-      for (set<SRTSOCKET>::iterator i3 = exceptfds->begin();
-         i3 != exceptfds->end(); ++ i3)
-      {
-         if (getStatus(*i3) == SRTS_BROKEN)
-         {
-            es.insert(*i3);
-            ++ count;
-         }
-         else if (!(s = locateSocket(*i3)))
-            throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-         else
-            eu.push_back(s);
-      }
-
-   do
-   {
-      // query read sockets
-      for (vector<CUDTSocket*>::iterator j1 = ru.begin(); j1 != ru.end(); ++ j1)
-      {
-         s = *j1;
-
-         if (s->readReady() || s->m_Status == SRTS_CLOSED)
-         {
-            rs.insert(s->m_SocketID);
-            ++ count;
-         }
-      }
-
-      // query write sockets
-      for (vector<CUDTSocket*>::iterator j2 = wu.begin(); j2 != wu.end(); ++ j2)
-      {
-         s = *j2;
-
-         if (s->writeReady() || s->m_Status == SRTS_CLOSED)
-         {
-            ws.insert(s->m_SocketID);
-            ++ count;
-         }
-      }
-
-      // query exceptions on sockets
-      for (vector<CUDTSocket*>::iterator j3 = eu.begin(); j3 != eu.end(); ++ j3)
-      {
-         // check connection request status, not supported now
-      }
-
-      if (0 < count)
-         break;
-
-      CGlobEvent::waitForEvent();
-   } while (timeo > steady_clock::now() - entertime);
-
-   if (readfds)
-      *readfds = rs;
-
-   if (writefds)
-      *writefds = ws;
-
-   if (exceptfds)
-      *exceptfds = es;
-
-   return count;
-}
-
-int CUDTUnited::selectEx(
-   const vector<SRTSOCKET>& fds,
-   vector<SRTSOCKET>* readfds,
-   vector<SRTSOCKET>* writefds,
-   vector<SRTSOCKET>* exceptfds,
-   int64_t msTimeOut)
+    // retrieve related UDT sockets
+    vector<CUDTSocket*> ru, wu, eu;
+    CUDTSocket*         s;
+    if (readfds)
+        for (set<SRTSOCKET>::iterator i1 = readfds->begin(); i1 != readfds->end(); ++i1)
+        {
+            if (getStatus(*i1) == SRTS_BROKEN)
+            {
+                rs.insert(*i1);
+                ++count;
+            }
+            else if (!(s = locateSocket(*i1)))
+                throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+            else
+                ru.push_back(s);
+        }
+    if (writefds)
+        for (set<SRTSOCKET>::iterator i2 = writefds->begin(); i2 != writefds->end(); ++i2)
+        {
+            if (getStatus(*i2) == SRTS_BROKEN)
+            {
+                ws.insert(*i2);
+                ++count;
+            }
+            else if (!(s = locateSocket(*i2)))
+                throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+            else
+                wu.push_back(s);
+        }
+    if (exceptfds)
+        for (set<SRTSOCKET>::iterator i3 = exceptfds->begin(); i3 != exceptfds->end(); ++i3)
+        {
+            if (getStatus(*i3) == SRTS_BROKEN)
+            {
+                es.insert(*i3);
+                ++count;
+            }
+            else if (!(s = locateSocket(*i3)))
+                throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+            else
+                eu.push_back(s);
+        }
+
+    do
+    {
+        // query read sockets
+        for (vector<CUDTSocket*>::iterator j1 = ru.begin(); j1 != ru.end(); ++j1)
+        {
+            s = *j1;
+
+            if (s->readReady() || s->m_Status == SRTS_CLOSED)
+            {
+                rs.insert(s->m_SocketID);
+                ++count;
+            }
+        }
+
+        // query write sockets
+        for (vector<CUDTSocket*>::iterator j2 = wu.begin(); j2 != wu.end(); ++j2)
+        {
+            s = *j2;
+
+            if (s->writeReady() || s->m_Status == SRTS_CLOSED)
+            {
+                ws.insert(s->m_SocketID);
+                ++count;
+            }
+        }
+
+        // query exceptions on sockets
+        for (vector<CUDTSocket*>::iterator j3 = eu.begin(); j3 != eu.end(); ++j3)
+        {
+            // check connection request status, not supported now
+        }
+
+        if (0 < count)
+            break;
+
+        CGlobEvent::waitForEvent();
+    } while (timeo > steady_clock::now() - entertime);
+
+    if (readfds)
+        *readfds = rs;
+
+    if (writefds)
+        *writefds = ws;
+
+    if (exceptfds)
+        *exceptfds = es;
+
+    return count;
+}
+
+int srt::CUDTUnited::selectEx(const vector<SRTSOCKET>& fds,
+                              vector<SRTSOCKET>*       readfds,
+                              vector<SRTSOCKET>*       writefds,
+                              vector<SRTSOCKET>*       exceptfds,
+                              int64_t                  msTimeOut)
 {
     const steady_clock::time_point entertime = steady_clock::now();
 
-    const long timeo_us = msTimeOut >= 0
-        ? msTimeOut * 1000
-        : -1;
+    const int64_t                timeo_us = msTimeOut >= 0 ? msTimeOut * 1000 : -1;
     const steady_clock::duration timeo(microseconds_from(timeo_us));
 
-   // initialize results
-   int count = 0;
-   if (readfds)
-      readfds->clear();
-   if (writefds)
-      writefds->clear();
-   if (exceptfds)
-      exceptfds->clear();
-
-   do
-   {
-      for (vector<SRTSOCKET>::const_iterator i = fds.begin();
-         i != fds.end(); ++ i)
-      {
-         CUDTSocket* s = locateSocket(*i);
-
-         if ((!s) || s->m_pUDT->m_bBroken || (s->m_Status == SRTS_CLOSED))
-         {
-            if (exceptfds)
+    // initialize results
+    int count = 0;
+    if (readfds)
+        readfds->clear();
+    if (writefds)
+        writefds->clear();
+    if (exceptfds)
+        exceptfds->clear();
+
+    do
+    {
+        for (vector<SRTSOCKET>::const_iterator i = fds.begin(); i != fds.end(); ++i)
+        {
+            CUDTSocket* s = locateSocket(*i);
+
+            if ((!s) || s->core().m_bBroken || (s->m_Status == SRTS_CLOSED))
             {
-               exceptfds->push_back(*i);
-               ++ count;
+                if (exceptfds)
+                {
+                    exceptfds->push_back(*i);
+                    ++count;
+                }
+                continue;
             }
-            continue;
-         }
-
-         if (readfds)
-         {
-            if ((s->m_pUDT->m_bConnected
-                  && s->m_pUDT->m_pRcvBuffer->isRcvDataReady()
-               )
-               || (s->m_pUDT->m_bListening
-                  && (s->m_pQueuedSockets->size() > 0)))
+
+            if (readfds)
             {
-               readfds->push_back(s->m_SocketID);
-               ++ count;
+                if ((s->core().m_bConnected && s->core().m_pRcvBuffer->isRcvDataReady()) ||
+                    (s->core().m_bListening && (s->m_QueuedSockets.size() > 0)))
+                {
+                    readfds->push_back(s->m_SocketID);
+                    ++count;
+                }
             }
-         }
 
-         if (writefds)
-         {
-            if (s->m_pUDT->m_bConnected
-               && (s->m_pUDT->m_pSndBuffer->getCurrBufSize()
-                  < s->m_pUDT->m_iSndBufSize))
+            if (writefds)
             {
-               writefds->push_back(s->m_SocketID);
-               ++ count;
+                if (s->core().m_bConnected &&
+                    (s->core().m_pSndBuffer->getCurrBufSize() < s->core().m_config.iSndBufSize))
+                {
+                    writefds->push_back(s->m_SocketID);
+                    ++count;
+                }
             }
-         }
-      }
+        }
 
-      if (count > 0)
-         break;
+        if (count > 0)
+            break;
 
-      CGlobEvent::waitForEvent();
-   } while (timeo > steady_clock::now() - entertime);
+        CGlobEvent::waitForEvent();
+    } while (timeo > steady_clock::now() - entertime);
 
-   return count;
+    return count;
 }
 
-int CUDTUnited::epoll_create()
+int srt::CUDTUnited::epoll_create()
 {
-   return m_EPoll.create();
+    return m_EPoll.create();
 }
 
-int CUDTUnited::epoll_clear_usocks(int eid)
+int srt::CUDTUnited::epoll_clear_usocks(int eid)
 {
     return m_EPoll.clear_usocks(eid);
 }
 
-int CUDTUnited::epoll_add_usock(
-   const int eid, const SRTSOCKET u, const int* events)
+int srt::CUDTUnited::epoll_add_usock(const int eid, const SRTSOCKET u, const int* events)
 {
-   int ret = -1;
-#if ENABLE_EXPERIMENTAL_BONDING
-   if (u & SRTGROUP_MASK)
-   {
-       GroupKeeper k (*this, u, ERH_THROW);
-       ret = m_EPoll.update_usock(eid, u, events);
-       k.group->addEPoll(eid);
-       return 0;
-   }
+    int ret = -1;
+#if ENABLE_BONDING
+    if (u & SRTGROUP_MASK)
+    {
+        GroupKeeper k(*this, u, ERH_THROW);
+        ret = m_EPoll.update_usock(eid, u, events);
+        k.group->addEPoll(eid);
+        return 0;
+    }
 #endif
 
-   CUDTSocket* s = locateSocket(u);
-   if (s)
-   {
-      ret = epoll_add_usock_INTERNAL(eid, s, events);
-   }
-   else
-   {
-      throw CUDTException(MJ_NOTSUP, MN_SIDINVAL);
-   }
+    CUDTSocket* s = locateSocket(u);
+    if (s)
+    {
+        ret = epoll_add_usock_INTERNAL(eid, s, events);
+    }
+    else
+    {
+        throw CUDTException(MJ_NOTSUP, MN_SIDINVAL);
+    }
 
-   return ret;
+    return ret;
 }
 
 // NOTE: WILL LOCK (serially):
 // - CEPoll::m_EPollLock
 // - CUDT::m_RecvLock
-int CUDTUnited::epoll_add_usock_INTERNAL(const int eid, CUDTSocket* s, const int* events)
+int srt::CUDTUnited::epoll_add_usock_INTERNAL(const int eid, CUDTSocket* s, const int* events)
 {
     int ret = m_EPoll.update_usock(eid, s->m_SocketID, events);
-    s->m_pUDT->addEPoll(eid);
+    s->core().addEPoll(eid);
     return ret;
 }
 
-int CUDTUnited::epoll_add_ssock(
-   const int eid, const SYSSOCKET s, const int* events)
+int srt::CUDTUnited::epoll_add_ssock(const int eid, const SYSSOCKET s, const int* events)
 {
-   return m_EPoll.add_ssock(eid, s, events);
+    return m_EPoll.add_ssock(eid, s, events);
 }
 
-int CUDTUnited::epoll_update_ssock(
-   const int eid, const SYSSOCKET s, const int* events)
+int srt::CUDTUnited::epoll_update_ssock(const int eid, const SYSSOCKET s, const int* events)
 {
-   return m_EPoll.update_ssock(eid, s, events);
+    return m_EPoll.update_ssock(eid, s, events);
 }
 
 template <class EntityType>
-int CUDTUnited::epoll_remove_entity(const int eid, EntityType* ent)
+int srt::CUDTUnited::epoll_remove_entity(const int eid, EntityType* ent)
 {
     // XXX Not sure if this is anyhow necessary because setting readiness
     // to false doesn't actually trigger any action. Further research needed.
@@ -2447,77 +2441,73 @@ int CUDTUnited::epoll_remove_entity(const int eid, EntityType* ent)
 
     HLOGC(ealog.Debug, log << "epoll_remove_usock: CLEARING subscription on E" << eid << " of @" << ent->id());
     int no_events = 0;
-    int ret = m_EPoll.update_usock(eid, ent->id(), &no_events);
+    int ret       = m_EPoll.update_usock(eid, ent->id(), &no_events);
 
     return ret;
 }
 
 // Needed internal access!
-int CUDTUnited::epoll_remove_socket_INTERNAL(const int eid, CUDTSocket* s)
+int srt::CUDTUnited::epoll_remove_socket_INTERNAL(const int eid, CUDTSocket* s)
 {
-    return epoll_remove_entity(eid, s->m_pUDT);
+    return epoll_remove_entity(eid, &s->core());
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-int CUDTUnited::epoll_remove_group_INTERNAL(const int eid, CUDTGroup* g)
+#if ENABLE_BONDING
+int srt::CUDTUnited::epoll_remove_group_INTERNAL(const int eid, CUDTGroup* g)
 {
     return epoll_remove_entity(eid, g);
 }
 #endif
 
-int CUDTUnited::epoll_remove_usock(const int eid, const SRTSOCKET u)
+int srt::CUDTUnited::epoll_remove_usock(const int eid, const SRTSOCKET u)
 {
-   CUDTSocket* s = 0;
+    CUDTSocket* s = 0;
 
-#if ENABLE_EXPERIMENTAL_BONDING
-   CUDTGroup* g = 0;
-   if (u & SRTGROUP_MASK)
-   {
-       GroupKeeper k (*this, u, ERH_THROW);
-       g = k.group;
-       return epoll_remove_entity(eid, g);
-   }
-   else
+#if ENABLE_BONDING
+    CUDTGroup* g = 0;
+    if (u & SRTGROUP_MASK)
+    {
+        GroupKeeper k(*this, u, ERH_THROW);
+        g = k.group;
+        return epoll_remove_entity(eid, g);
+    }
+    else
 #endif
-   {
-       s = locateSocket(u);
-       if (s)
-           return epoll_remove_entity(eid, s->m_pUDT);
-   }
+    {
+        s = locateSocket(u);
+        if (s)
+            return epoll_remove_entity(eid, &s->core());
+    }
 
-   LOGC(ealog.Error, log << "remove_usock: @" << u
-           << " not found as either socket or group. Removing only from epoll system.");
-   int no_events = 0;
-   return m_EPoll.update_usock(eid, u, &no_events);
+    LOGC(ealog.Error,
+         log << "remove_usock: @" << u << " not found as either socket or group. Removing only from epoll system.");
+    int no_events = 0;
+    return m_EPoll.update_usock(eid, u, &no_events);
 }
 
-int CUDTUnited::epoll_remove_ssock(const int eid, const SYSSOCKET s)
+int srt::CUDTUnited::epoll_remove_ssock(const int eid, const SYSSOCKET s)
 {
-   return m_EPoll.remove_ssock(eid, s);
+    return m_EPoll.remove_ssock(eid, s);
 }
 
-int CUDTUnited::epoll_uwait(
-   const int eid,
-   SRT_EPOLL_EVENT* fdsSet,
-   int fdsSize, 
-   int64_t msTimeOut)
+int srt::CUDTUnited::epoll_uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut)
 {
-   return m_EPoll.uwait(eid, fdsSet, fdsSize, msTimeOut);
+    return m_EPoll.uwait(eid, fdsSet, fdsSize, msTimeOut);
 }
 
-int32_t CUDTUnited::epoll_set(int eid, int32_t flags)
+int32_t srt::CUDTUnited::epoll_set(int eid, int32_t flags)
 {
     return m_EPoll.setflags(eid, flags);
 }
 
-int CUDTUnited::epoll_release(const int eid)
+int srt::CUDTUnited::epoll_release(const int eid)
 {
-   return m_EPoll.release(eid);
+    return m_EPoll.release(eid);
 }
 
-CUDTSocket* CUDTUnited::locateSocket(const SRTSOCKET u, ErrorHandling erh)
+srt::CUDTSocket* srt::CUDTUnited::locateSocket(const SRTSOCKET u, ErrorHandling erh)
 {
-    ScopedLock cg (m_GlobControlLock);
+    ScopedLock  cg(m_GlobControlLock);
     CUDTSocket* s = locateSocket_LOCKED(u);
     if (!s)
     {
@@ -2530,7 +2520,7 @@ CUDTSocket* CUDTUnited::locateSocket(const SRTSOCKET u, ErrorHandling erh)
 }
 
 // [[using locked(m_GlobControlLock)]];
-CUDTSocket* CUDTUnited::locateSocket_LOCKED(SRTSOCKET u)
+srt::CUDTSocket* srt::CUDTUnited::locateSocket_LOCKED(SRTSOCKET u)
 {
     sockets_t::iterator i = m_Sockets.find(u);
 
@@ -2542,1148 +2532,1748 @@ CUDTSocket* CUDTUnited::locateSocket_LOCKED(SRTSOCKET u)
     return i->second;
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-CUDTGroup* CUDTUnited::locateAcquireGroup(SRTSOCKET u, ErrorHandling erh)
+#if ENABLE_BONDING
+srt::CUDTGroup* srt::CUDTUnited::locateAcquireGroup(SRTSOCKET u, ErrorHandling erh)
 {
-   ScopedLock cg (m_GlobControlLock);
+    ScopedLock cg(m_GlobControlLock);
 
-   const groups_t::iterator i = m_Groups.find(u);
-   if ( i == m_Groups.end() )
-   {
-       if (erh == ERH_THROW)
-           throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
-       return NULL;
-   }
+    const groups_t::iterator i = m_Groups.find(u);
+    if (i == m_Groups.end())
+    {
+        if (erh == ERH_THROW)
+            throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+        return NULL;
+    }
 
-   ScopedLock cgroup (*i->second->exp_groupLock());
-   i->second->apiAcquire();
-   return i->second;
+    ScopedLock cgroup(*i->second->exp_groupLock());
+    i->second->apiAcquire();
+    return i->second;
 }
 
-CUDTGroup* CUDTUnited::acquireSocketsGroup(CUDTSocket* s)
+srt::CUDTGroup* srt::CUDTUnited::acquireSocketsGroup(CUDTSocket* s)
 {
-   ScopedLock cg (m_GlobControlLock);
-   CUDTGroup* g = s->m_IncludedGroup;
-   if (!g)
-       return NULL;
+    ScopedLock cg(m_GlobControlLock);
+    CUDTGroup* g = s->m_GroupOf;
+    if (!g)
+        return NULL;
 
-   // With m_GlobControlLock locked, we are sure the group
-   // still exists, if it wasn't removed from this socket.
-   g->apiAcquire();
-   return g;
+    // With m_GlobControlLock locked, we are sure the group
+    // still exists, if it wasn't removed from this socket.
+    g->apiAcquire();
+    return g;
 }
 #endif
 
-CUDTSocket* CUDTUnited::locatePeer(
-   const sockaddr_any& peer,
-   const SRTSOCKET id,
-   int32_t isn)
+srt::CUDTSocket* srt::CUDTUnited::locateAcquireSocket(SRTSOCKET u, ErrorHandling erh)
 {
-   ScopedLock cg(m_GlobControlLock);
+    ScopedLock cg(m_GlobControlLock);
 
-   map<int64_t, set<SRTSOCKET> >::iterator i = m_PeerRec.find(
-      CUDTSocket::getPeerSpec(id, isn));
-   if (i == m_PeerRec.end())
-      return NULL;
+    CUDTSocket* s = locateSocket_LOCKED(u);
+    if (!s)
+    {
+        if (erh == ERH_THROW)
+            throw CUDTException(MJ_NOTSUP, MN_SIDINVAL, 0);
+        return NULL;
+    }
 
-   for (set<SRTSOCKET>::iterator j = i->second.begin();
-      j != i->second.end(); ++ j)
-   {
-      sockets_t::iterator k = m_Sockets.find(*j);
-      // this socket might have been closed and moved m_ClosedSockets
-      if (k == m_Sockets.end())
-         continue;
+    s->apiAcquire();
+    return s;
+}
 
-      if (k->second->m_PeerAddr == peer)
-      {
-         return k->second;
-      }
-   }
+bool srt::CUDTUnited::acquireSocket(CUDTSocket* s)
+{
+    // Note that before using this function you must be certain
+    // that the socket isn't broken already and it still has at least
+    // one more GC cycle to live. In other words, you must be certain
+    // that this pointer passed here isn't dangling and was obtained
+    // directly from m_Sockets, or even better, has been acquired
+    // by some other functionality already, which is only about to
+    // be released earlier than you need.
+    ScopedLock cg(m_GlobControlLock);
+    s->apiAcquire();
+    // Keep the lock so that no one changes anything in the meantime.
+    // If the socket m_Status == SRTS_CLOSED (set by setClosed()), then
+    // this socket is no longer present in the m_Sockets container
+    if (s->m_Status >= SRTS_BROKEN)
+    {
+        s->apiRelease();
+        return false;
+    }
 
-   return NULL;
+    return true;
 }
 
-void CUDTUnited::checkBrokenSockets()
+srt::CUDTSocket* srt::CUDTUnited::locatePeer(const sockaddr_any& peer, const SRTSOCKET id, int32_t isn)
 {
-   ScopedLock cg(m_GlobControlLock);
+    ScopedLock cg(m_GlobControlLock);
 
-   // set of sockets To Be Closed and To Be Removed
-   vector<SRTSOCKET> tbc;
-   vector<SRTSOCKET> tbr;
+    map<int64_t, set<SRTSOCKET> >::iterator i = m_PeerRec.find(CUDTSocket::getPeerSpec(id, isn));
+    if (i == m_PeerRec.end())
+        return NULL;
 
-#if ENABLE_EXPERIMENTAL_BONDING
-   vector<SRTSOCKET> delgids;
+    for (set<SRTSOCKET>::iterator j = i->second.begin(); j != i->second.end(); ++j)
+    {
+        sockets_t::iterator k = m_Sockets.find(*j);
+        // this socket might have been closed and moved m_ClosedSockets
+        if (k == m_Sockets.end())
+            continue;
 
-   for (groups_t::iterator i = m_ClosedGroups.begin(); i != m_ClosedGroups.end(); ++i)
-   {
-       // isStillBusy requires lock on the group, so only after an API
-       // function that uses it returns, and so clears the busy flag,
-       // a new API function won't be called anyway until it can acquire
-       // GlobControlLock, and all functions that have already seen this
-       // group as closing will not continue with the API and return.
-       // If we caught some API function still using the closed group,
-       // it's not going to wait, will be checked next time.
-       if (i->second->isStillBusy())
-           continue;
+        if (k->second->m_PeerAddr == peer)
+        {
+            return k->second;
+        }
+    }
 
-       delgids.push_back(i->first);
-       delete i->second;
-       i->second = NULL; // just for a case, avoid a dangling pointer
-   }
+    return NULL;
+}
 
-   for (vector<SRTSOCKET>::iterator di = delgids.begin(); di != delgids.end(); ++di)
-   {
-       m_ClosedGroups.erase(*di);
-   }
+void srt::CUDTUnited::checkBrokenSockets()
+{
+    ScopedLock cg(m_GlobControlLock);
 
-#endif
+#if ENABLE_BONDING
+    vector<SRTSOCKET> delgids;
 
-   for (sockets_t::iterator i = m_Sockets.begin();
-      i != m_Sockets.end(); ++ i)
-   {
-       CUDTSocket* s = i->second;
-
-      // check broken connection
-      if (s->m_pUDT->m_bBroken)
-      {
-         if (s->m_Status == SRTS_LISTENING)
-         {
-            const steady_clock::duration elapsed = steady_clock::now() - s->m_tsClosureTimeStamp;
-            // for a listening socket, it should wait an extra 3 seconds
-            // in case a client is connecting
-            if (elapsed < milliseconds_from(CUDT::COMM_CLOSE_BROKEN_LISTENER_TIMEOUT_MS))
-            {
-               continue;
-            }
-         }
-         else if ((s->m_pUDT->m_pRcvBuffer != NULL)
-            // FIXED: calling isRcvDataAvailable() just to get the information
-            // whether there are any data waiting in the buffer,
-            // NOT WHETHER THEY ARE ALSO READY TO PLAY at the time when
-            // this function is called (isRcvDataReady also checks if the
-            // available data is "ready to play").
-            && s->m_pUDT->m_pRcvBuffer->isRcvDataAvailable()
-            && (s->m_pUDT->m_iBrokenCounter -- > 0))
-         {
-            // HLOGF(smlog.Debug, "STILL KEEPING socket (still have data):
-            // %d\n", i->first);
-            // if there is still data in the receiver buffer, wait longer
+    for (groups_t::iterator i = m_ClosedGroups.begin(); i != m_ClosedGroups.end(); ++i)
+    {
+        // isStillBusy requires lock on the group, so only after an API
+        // function that uses it returns, and so clears the busy flag,
+        // a new API function won't be called anyway until it can acquire
+        // GlobControlLock, and all functions that have already seen this
+        // group as closing will not continue with the API and return.
+        // If we caught some API function still using the closed group,
+        // it's not going to wait, will be checked next time.
+        if (i->second->isStillBusy())
             continue;
-         }
-
-#if ENABLE_EXPERIMENTAL_BONDING
-         if (s->m_IncludedGroup)
-         {
-             LOGC(smlog.Note, log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_IncludedGroup->id() << " - REMOVING FROM GROUP");
-             s->removeFromGroup(true);
-         }
-#endif
 
-         HLOGC(smlog.Debug, log << "checkBrokenSockets: moving BROKEN socket to CLOSED: @" << i->first);
+        delgids.push_back(i->first);
+        delete i->second;
+        i->second = NULL; // just for a case, avoid a dangling pointer
+    }
 
-         //close broken connections and start removal timer
-         s->setClosed();
-         tbc.push_back(i->first);
-         m_ClosedSockets[i->first] = s;
+    for (vector<SRTSOCKET>::iterator di = delgids.begin(); di != delgids.end(); ++di)
+    {
+        m_ClosedGroups.erase(*di);
+    }
+#endif
 
-         // remove from listener's queue
-         sockets_t::iterator ls = m_Sockets.find(s->m_ListenSocket);
-         if (ls == m_Sockets.end())
-         {
-            ls = m_ClosedSockets.find(s->m_ListenSocket);
-            if (ls == m_ClosedSockets.end())
-               continue;
-         }
-
-         enterCS(ls->second->m_AcceptLock);
-         ls->second->m_pQueuedSockets->erase(s->m_SocketID);
-         ls->second->m_pAcceptSockets->erase(s->m_SocketID);
-         leaveCS(ls->second->m_AcceptLock);
-      }
-   }
-
-   for (sockets_t::iterator j = m_ClosedSockets.begin();
-      j != m_ClosedSockets.end(); ++ j)
-   {
-      // HLOGF(smlog.Debug, "checking CLOSED socket: %d\n", j->first);
-      if (!is_zero(j->second->m_pUDT->m_tsLingerExpiration))
-      {
-         // asynchronous close:
-         if ((!j->second->m_pUDT->m_pSndBuffer)
-            || (0 == j->second->m_pUDT->m_pSndBuffer->getCurrBufSize())
-            || (j->second->m_pUDT->m_tsLingerExpiration <= steady_clock::now()))
-         {
-            HLOGC(smlog.Debug, log << "checkBrokenSockets: marking CLOSED qualified @" << j->second->m_SocketID);
-            j->second->m_pUDT->m_tsLingerExpiration = steady_clock::time_point();
-            j->second->m_pUDT->m_bClosing = true;
-            j->second->m_tsClosureTimeStamp = steady_clock::now();
-         }
-      }
-
-      // timeout 1 second to destroy a socket AND it has been removed from
-      // RcvUList
-      const steady_clock::time_point now = steady_clock::now();
-      const steady_clock::duration closed_ago = now - j->second->m_tsClosureTimeStamp;
-      if ((closed_ago > seconds_from(1))
-         && ((!j->second->m_pUDT->m_pRNode)
-            || !j->second->m_pUDT->m_pRNode->m_bOnList))
-      {
-         HLOGC(smlog.Debug, log << "checkBrokenSockets: @" << j->second->m_SocketID << " closed "
-                 << FormatDuration(closed_ago) << " ago and removed from RcvQ - will remove");
-
-         // HLOGF(smlog.Debug, "will unref socket: %d\n", j->first);
-         tbr.push_back(j->first);
-      }
-   }
-
-   // move closed sockets to the ClosedSockets structure
-   for (vector<SRTSOCKET>::iterator k = tbc.begin(); k != tbc.end(); ++ k)
-      m_Sockets.erase(*k);
-
-   // remove those timeout sockets
-   for (vector<SRTSOCKET>::iterator l = tbr.begin(); l != tbr.end(); ++ l)
-      removeSocket(*l);
-}
+    // set of sockets To Be Closed and To Be Removed
+    vector<SRTSOCKET> tbc;
+    vector<SRTSOCKET> tbr;
 
-// [[using locked(m_GlobControlLock)]]
-void CUDTUnited::removeSocket(const SRTSOCKET u)
-{
-   sockets_t::iterator i = m_ClosedSockets.find(u);
+    for (sockets_t::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++i)
+    {
+        CUDTSocket* s = i->second;
+        if (!s->core().m_bBroken)
+            continue;
 
-   // invalid socket ID
-   if (i == m_ClosedSockets.end())
-      return;
+        if (s->m_Status == SRTS_LISTENING)
+        {
+            const steady_clock::duration elapsed = steady_clock::now() - s->m_tsClosureTimeStamp.load();
+            // A listening socket should wait an extra 3 seconds
+            // in case a client is connecting.
+            if (elapsed < milliseconds_from(CUDT::COMM_CLOSE_BROKEN_LISTENER_TIMEOUT_MS))
+                continue;
+        }
+        else
+        {
+            CUDT& u = s->core();
 
-   CUDTSocket* const s = i->second;
+            enterCS(u.m_RcvBufferLock);
+            bool has_avail_packets = u.m_pRcvBuffer && u.m_pRcvBuffer->hasAvailablePackets();
+            leaveCS(u.m_RcvBufferLock);
 
-#if ENABLE_EXPERIMENTAL_BONDING
-   if (s->m_IncludedGroup)
-   {
-       HLOGC(smlog.Debug, log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_IncludedGroup->id() << " - REMOVING FROM GROUP");
-       s->removeFromGroup(true);
-   }
-#endif
-   // decrease multiplexer reference count, and remove it if necessary
-   const int mid = s->m_iMuxID;
-
-   if (s->m_pQueuedSockets)
-   {
-      ScopedLock cg(s->m_AcceptLock);
-
-      // if it is a listener, close all un-accepted sockets in its queue
-      // and remove them later
-      for (set<SRTSOCKET>::iterator q = s->m_pQueuedSockets->begin();
-         q != s->m_pQueuedSockets->end(); ++ q)
-      {
-         sockets_t::iterator si = m_Sockets.find(*q);
-         if (si == m_Sockets.end())
-         {
-            // gone in the meantime
-            LOGC(smlog.Error, log << "removeSocket: IPE? socket @" << u
-                    << " being queued for listener socket @" << s->m_SocketID
-                    << " is GONE in the meantime ???");
-            continue;
-         }
-
-         CUDTSocket* as = si->second;
-
-         as->breakSocket_LOCKED();
-         m_ClosedSockets[*q] = as;
-         m_Sockets.erase(*q);
-      }
-   }
-
-   // remove from peer rec
-   map<int64_t, set<SRTSOCKET> >::iterator j = m_PeerRec.find(
-      s->getPeerSpec());
-   if (j != m_PeerRec.end())
-   {
-      j->second.erase(u);
-      if (j->second.empty())
-         m_PeerRec.erase(j);
-   }
-
-   /*
-   * Socket may be deleted while still having ePoll events set that would
-   * remains forever causing epoll_wait to unblock continuously for inexistent
-   * sockets. Get rid of all events for this socket.
-   */
-   m_EPoll.update_events(u, s->m_pUDT->m_sPollID,
-      SRT_EPOLL_IN|SRT_EPOLL_OUT|SRT_EPOLL_ERR, false);
-
-   // delete this one
-   m_ClosedSockets.erase(i);
-
-   HLOGC(smlog.Debug, log << "GC/removeSocket: closing associated UDT @" << u);
-   s->m_pUDT->closeInternal();
-   HLOGC(smlog.Debug, log << "GC/removeSocket: DELETING SOCKET @" << u);
-   delete s;
-
-   if (mid == -1)
-       return;
-
-   map<int, CMultiplexer>::iterator m;
-   m = m_mMultiplexer.find(mid);
-   if (m == m_mMultiplexer.end())
-   {
-      LOGC(smlog.Fatal, log << "IPE: For socket @" << u << " MUXER id=" << mid << " NOT FOUND!");
-      return;
-   }
-
-   CMultiplexer& mx = m->second;
-
-   mx.m_iRefCount --;
-   // HLOGF(smlog.Debug, "unrefing underlying socket for %u: %u\n",
-   //    u, mx.m_iRefCount);
-   if (0 == mx.m_iRefCount)
-   {
-       HLOGC(smlog.Debug, log << "MUXER id=" << mid << " lost last socket @"
-           << u << " - deleting muxer bound to port "
-           << mx.m_pChannel->bindAddressAny().hport());
-      // The channel has no access to the queues and
-      // it looks like the multiplexer is the master of all of them.
-      // The queues must be silenced before closing the channel
-      // because this will cause error to be returned in any operation
-      // being currently done in the queues, if any.
-      mx.m_pSndQueue->setClosing();
-      mx.m_pRcvQueue->setClosing();
-      mx.destroy();
-      m_mMultiplexer.erase(m);
-   }
-}
-
-void CUDTUnited::updateMux(
-   CUDTSocket* s, const sockaddr_any& addr, const UDPSOCKET* udpsock /*[[nullable]]*/)
-{
-   ScopedLock cg(m_GlobControlLock);
-
-   // Don't try to reuse given address, if udpsock was given.
-   // In such a case rely exclusively on that very socket and
-   // use it the way as it is configured, of course, create also
-   // always a new multiplexer for that very socket.
-   if (!udpsock && s->m_pUDT->m_bReuseAddr)
-   {
-      const int port = addr.hport();
-
-      // find a reusable address
-      for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin();
-         i != m_mMultiplexer.end(); ++ i)
-      {
-          // Use the "family" value blindly from the address; we
-          // need to find an existing multiplexer that binds to the
-          // given port in the same family as requested address.
-          if ((i->second.m_iIPversion == addr.family())
-                  && (i->second.m_iMSS == s->m_pUDT->m_iMSS)
-                  &&  (i->second.m_iIpTTL == s->m_pUDT->m_iIpTTL)
-                  && (i->second.m_iIpToS == s->m_pUDT->m_iIpToS)
-#ifdef SRT_ENABLE_BINDTODEVICE
-                  && (i->second.m_BindToDevice == s->m_pUDT->m_BindToDevice)
-#endif
-                  && (i->second.m_iIpV6Only == s->m_pUDT->m_iIpV6Only)
-                  &&  i->second.m_bReusable)
-          {
-            if (i->second.m_iPort == port)
+            if (has_avail_packets)
             {
-               // HLOGF(smlog.Debug, "reusing multiplexer for port
-               // %hd\n", port);
-               // reuse the existing multiplexer
-               ++ i->second.m_iRefCount;
-               s->m_pUDT->m_pSndQueue = i->second.m_pSndQueue;
-               s->m_pUDT->m_pRcvQueue = i->second.m_pRcvQueue;
-               s->m_iMuxID = i->second.m_iID;
-               s->m_SelfAddr.family(addr.family());
-               return;
+                const int bc = u.m_iBrokenCounter.load();
+                if (bc > 0)
+                {
+                    // if there is still data in the receiver buffer, wait longer
+                    s->core().m_iBrokenCounter.store(bc - 1);
+                    continue;
+                }
             }
-         }
-      }
-   }
-
-   // a new multiplexer is needed
-   CMultiplexer m;
-   m.m_iMSS = s->m_pUDT->m_iMSS;
-   m.m_iIPversion = addr.family();
-   m.m_iIpTTL = s->m_pUDT->m_iIpTTL;
-   m.m_iIpToS = s->m_pUDT->m_iIpToS;
-#ifdef SRT_ENABLE_BINDTODEVICE
-   m.m_BindToDevice = s->m_pUDT->m_BindToDevice;
-#endif
-   m.m_iRefCount = 1;
-   m.m_iIpV6Only = s->m_pUDT->m_iIpV6Only;
-   m.m_bReusable = s->m_pUDT->m_bReuseAddr;
-   m.m_iID = s->m_SocketID;
-
-   try
-   {
-       m.m_pChannel = new CChannel();
-       m.m_pChannel->setIpTTL(s->m_pUDT->m_iIpTTL);
-       m.m_pChannel->setIpToS(s->m_pUDT->m_iIpToS);
-#ifdef SRT_ENABLE_BINDTODEVICE
-       m.m_pChannel->setBind(m.m_BindToDevice);
+        }
+
+#if ENABLE_BONDING
+        if (s->m_GroupOf)
+        {
+            HLOGC(smlog.Debug,
+                 log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_GroupOf->id() << " - REMOVING FROM GROUP");
+            s->removeFromGroup(true);
+        }
 #endif
-       m.m_pChannel->setSndBufSize(s->m_pUDT->m_iUDPSndBufSize);
-       m.m_pChannel->setRcvBufSize(s->m_pUDT->m_iUDPRcvBufSize);
-       if (s->m_pUDT->m_iIpV6Only != -1)
-           m.m_pChannel->setIpV6Only(s->m_pUDT->m_iIpV6Only);
-
-       if (udpsock)
-       {
-           // In this case, addr contains the address
-           // that has been extracted already from the
-           // given socket
-           m.m_pChannel->attach(*udpsock, addr);
-       }
-       else if (addr.empty())
-       {
-           // The case of previously used case of a NULL address.
-           // This here is used to pass family only, in this case
-           // just automatically bind to the "0" address to autoselect
-           // everything.
-           m.m_pChannel->open(addr.family());
-       }
-       else
-       {
-           // If at least the IP address is specified, then bind to that
-           // address, but still possibly autoselect the outgoing port, if the
-           // port was specified as 0.
-           m.m_pChannel->open(addr);
-       }
-
-       sockaddr_any sa;
-       m.m_pChannel->getSockAddr((sa));
-       m.m_iPort = sa.hport();
-       s->m_SelfAddr = sa; // Will be also completed later, but here it's needed for later checks
-
-       m.m_pTimer = new CTimer;
-
-       m.m_pSndQueue = new CSndQueue;
-       m.m_pSndQueue->init(m.m_pChannel, m.m_pTimer);
-       m.m_pRcvQueue = new CRcvQueue;
-       m.m_pRcvQueue->init(
-               32, s->m_pUDT->maxPayloadSize(), m.m_iIPversion, 1024,
-               m.m_pChannel, m.m_pTimer);
-
-       m_mMultiplexer[m.m_iID] = m;
-
-       s->m_pUDT->m_pSndQueue = m.m_pSndQueue;
-       s->m_pUDT->m_pRcvQueue = m.m_pRcvQueue;
-       s->m_iMuxID = m.m_iID;
-   }
-   catch (const CUDTException&)
-   {
-       m.destroy();
-       throw;
-   }
-   catch (...)
-   {
-       m.destroy();
-       throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-
-   HLOGF(smlog.Debug, 
-      "creating new multiplexer for port %i\n", m.m_iPort);
-}
 
-// This function is going to find a multiplexer for the port contained
+        HLOGC(smlog.Debug, log << "checkBrokenSockets: moving BROKEN socket to CLOSED: @" << i->first);
+
+        // close broken connections and start removal timer
+        s->setClosed();
+        tbc.push_back(i->first);
+        m_ClosedSockets[i->first] = s;
+
+        // remove from listener's queue
+        sockets_t::iterator ls = m_Sockets.find(s->m_ListenSocket);
+        if (ls == m_Sockets.end())
+        {
+            ls = m_ClosedSockets.find(s->m_ListenSocket);
+            if (ls == m_ClosedSockets.end())
+                continue;
+        }
+
+        enterCS(ls->second->m_AcceptLock);
+        ls->second->m_QueuedSockets.erase(s->m_SocketID);
+        leaveCS(ls->second->m_AcceptLock);
+    }
+
+    for (sockets_t::iterator j = m_ClosedSockets.begin(); j != m_ClosedSockets.end(); ++j)
+    {
+        CUDTSocket* ps = j->second;
+
+        // NOTE: There is still a hypothetical risk here that ps
+        // was made busy while the socket was already moved to m_ClosedSocket,
+        // if the socket was acquired through CUDTUnited::acquireSocket (that is,
+        // busy flag acquisition was done through the CUDTSocket* pointer rather
+        // than through the numeric ID). Therefore this way of busy acquisition
+        // should be done only if at the moment of acquisition there are certainly
+        // other conditions applying on the socket that prevent it from being deleted.
+        if (ps->isStillBusy())
+        {
+            HLOGC(smlog.Debug, log << "checkBrokenSockets: @" << ps->m_SocketID << " is still busy, SKIPPING THIS CYCLE.");
+            continue;
+        }
+
+        CUDT& u = ps->core();
+
+        // HLOGC(smlog.Debug, log << "checking CLOSED socket: " << j->first);
+        if (!is_zero(u.m_tsLingerExpiration))
+        {
+            // asynchronous close:
+            if ((!u.m_pSndBuffer) || (0 == u.m_pSndBuffer->getCurrBufSize()) ||
+                (u.m_tsLingerExpiration <= steady_clock::now()))
+            {
+                HLOGC(smlog.Debug, log << "checkBrokenSockets: marking CLOSED qualified @" << ps->m_SocketID);
+                u.m_tsLingerExpiration = steady_clock::time_point();
+                u.m_bClosing           = true;
+                ps->m_tsClosureTimeStamp        = steady_clock::now();
+            }
+        }
+
+        // timeout 1 second to destroy a socket AND it has been removed from
+        // RcvUList
+        const steady_clock::time_point now        = steady_clock::now();
+        const steady_clock::duration   closed_ago = now - ps->m_tsClosureTimeStamp.load();
+        if (closed_ago > seconds_from(1))
+        {
+            CRNode* rnode = u.m_pRNode;
+            if (!rnode || !rnode->m_bOnList)
+            {
+                HLOGC(smlog.Debug,
+                      log << "checkBrokenSockets: @" << ps->m_SocketID << " closed "
+                          << FormatDuration(closed_ago) << " ago and removed from RcvQ - will remove");
+
+                // HLOGC(smlog.Debug, log << "will unref socket: " << j->first);
+                tbr.push_back(j->first);
+            }
+        }
+    }
+
+    // move closed sockets to the ClosedSockets structure
+    for (vector<SRTSOCKET>::iterator k = tbc.begin(); k != tbc.end(); ++k)
+        m_Sockets.erase(*k);
+
+    // remove those timeout sockets
+    for (vector<SRTSOCKET>::iterator l = tbr.begin(); l != tbr.end(); ++l)
+        removeSocket(*l);
+
+    HLOGC(smlog.Debug, log << "checkBrokenSockets: after removal: m_ClosedSockets.size()=" << m_ClosedSockets.size());
+}
+
+// [[using locked(m_GlobControlLock)]]
+void srt::CUDTUnited::removeSocket(const SRTSOCKET u)
+{
+    sockets_t::iterator i = m_ClosedSockets.find(u);
+
+    // invalid socket ID
+    if (i == m_ClosedSockets.end())
+        return;
+
+    CUDTSocket* const s = i->second;
+
+    // The socket may be in the trashcan now, but could
+    // still be under processing in the sender/receiver worker
+    // threads. If that's the case, SKIP IT THIS TIME. The
+    // socket will be checked next time the GC rollover starts.
+    CSNode* sn = s->core().m_pSNode;
+    if (sn && sn->m_iHeapLoc != -1)
+        return;
+
+    CRNode* rn = s->core().m_pRNode;
+    if (rn && rn->m_bOnList)
+        return;
+
+    if (s->isStillBusy())
+    {
+        HLOGC(smlog.Debug, log << "@" << s->m_SocketID << " is still busy, NOT deleting");
+        return;
+    }
+
+    LOGC(smlog.Note, log << "@" << s->m_SocketID << " busy=" << s->isStillBusy());
+
+#if ENABLE_BONDING
+    if (s->m_GroupOf)
+    {
+        HLOGC(smlog.Debug,
+              log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_GroupOf->id() << " - REMOVING FROM GROUP");
+        s->removeFromGroup(true);
+    }
+#endif
+    // decrease multiplexer reference count, and remove it if necessary
+    const int mid = s->m_iMuxID;
+
+    {
+        ScopedLock cg(s->m_AcceptLock);
+
+        // if it is a listener, close all un-accepted sockets in its queue
+        // and remove them later
+        for (map<SRTSOCKET, sockaddr_any>::iterator q = s->m_QueuedSockets.begin();
+                q != s->m_QueuedSockets.end(); ++ q)
+        {
+            sockets_t::iterator si = m_Sockets.find(q->first);
+            if (si == m_Sockets.end())
+            {
+                // gone in the meantime
+                LOGC(smlog.Error,
+                     log << "removeSocket: IPE? socket @" << (q->first) << " being queued for listener socket @"
+                        << s->m_SocketID << " is GONE in the meantime ???");
+                continue;
+            }
+
+            CUDTSocket* as = si->second;
+
+            as->breakSocket_LOCKED();
+            m_ClosedSockets[q->first] = as;
+            m_Sockets.erase(q->first);
+        }
+    }
+
+    // remove from peer rec
+    map<int64_t, set<SRTSOCKET> >::iterator j = m_PeerRec.find(s->getPeerSpec());
+    if (j != m_PeerRec.end())
+    {
+        j->second.erase(u);
+        if (j->second.empty())
+            m_PeerRec.erase(j);
+    }
+
+    /*
+     * Socket may be deleted while still having ePoll events set that would
+     * remains forever causing epoll_wait to unblock continuously for inexistent
+     * sockets. Get rid of all events for this socket.
+     */
+    m_EPoll.update_events(u, s->core().m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, false);
+
+    // delete this one
+    m_ClosedSockets.erase(i);
+
+   // XXX This below section can unlock m_GlobControlLock
+   // just for calling CUDT::closeInternal(), which is needed
+   // to avoid locking m_ConnectionLock after m_GlobControlLock,
+   // while m_ConnectionLock orders BEFORE m_GlobControlLock.
+   // This should be perfectly safe thing to do after the socket
+   // ID has been erased from m_ClosedSockets. No container access
+   // is done in this case.
+   //
+   // Report: P04-1.28, P04-2.27, P04-2.50, P04-2.55
+
+    HLOGC(smlog.Debug, log << "GC/removeSocket: closing associated UDT @" << u);
+    leaveCS(m_GlobControlLock);
+    s->core().closeInternal();
+    enterCS(m_GlobControlLock);
+    HLOGC(smlog.Debug, log << "GC/removeSocket: DELETING SOCKET @" << u);
+    delete s;
+    HLOGC(smlog.Debug, log << "GC/removeSocket: socket @" << u << " DELETED. Checking muxer.");
+
+    if (mid == -1)
+    {
+        HLOGC(smlog.Debug, log << "GC/removeSocket: no muxer found, finishing.");
+        return;
+    }
+
+    map<int, CMultiplexer>::iterator m;
+    m = m_mMultiplexer.find(mid);
+    if (m == m_mMultiplexer.end())
+    {
+        LOGC(smlog.Fatal, log << "IPE: For socket @" << u << " MUXER id=" << mid << " NOT FOUND!");
+        return;
+    }
+
+    CMultiplexer& mx = m->second;
+
+    mx.m_iRefCount--;
+    HLOGC(smlog.Debug, log << "unrefing underlying muxer " << mid << " for @" << u << ", ref=" << mx.m_iRefCount);
+    if (0 == mx.m_iRefCount)
+    {
+        HLOGC(smlog.Debug,
+              log << "MUXER id=" << mid << " lost last socket @" << u << " - deleting muxer bound to port "
+                  << mx.m_pChannel->bindAddressAny().hport());
+        // The channel has no access to the queues and
+        // it looks like the multiplexer is the master of all of them.
+        // The queues must be silenced before closing the channel
+        // because this will cause error to be returned in any operation
+        // being currently done in the queues, if any.
+        mx.m_pSndQueue->setClosing();
+        mx.m_pRcvQueue->setClosing();
+        mx.destroy();
+        m_mMultiplexer.erase(m);
+    }
+}
+
+void srt::CUDTUnited::configureMuxer(CMultiplexer& w_m, const CUDTSocket* s, int af)
+{
+    w_m.m_mcfg       = s->core().m_config;
+    w_m.m_iIPversion = af;
+    w_m.m_iRefCount  = 1;
+    w_m.m_iID        = s->m_SocketID;
+}
+
+uint16_t srt::CUDTUnited::installMuxer(CUDTSocket* w_s, CMultiplexer& fw_sm)
+{
+    w_s->core().m_pSndQueue = fw_sm.m_pSndQueue;
+    w_s->core().m_pRcvQueue = fw_sm.m_pRcvQueue;
+    w_s->m_iMuxID           = fw_sm.m_iID;
+    sockaddr_any sa;
+    fw_sm.m_pChannel->getSockAddr((sa));
+    w_s->m_SelfAddr = sa; // Will be also completed later, but here it's needed for later checks
+    return sa.hport();
+}
+
+bool srt::CUDTUnited::inet6SettingsCompat(const sockaddr_any& muxaddr, const CSrtMuxerConfig& cfgMuxer,
+        const sockaddr_any& reqaddr, const CSrtMuxerConfig& cfgSocket)
+{
+    if (muxaddr.family() != AF_INET6)
+        return true; // Don't check - the family has been checked already
+
+    if (reqaddr.isany())
+    {
+        if (cfgSocket.iIpV6Only == -1) // Treat as "adaptive"
+            return true;
+
+        // If set explicitly, then it must be equal to the one of found muxer.
+        return cfgSocket.iIpV6Only == cfgMuxer.iIpV6Only;
+    }
+
+    // If binding to the certain IPv6 address, then this setting doesn't matter.
+    return true;
+}
+
+bool srt::CUDTUnited::channelSettingsMatch(const CSrtMuxerConfig& cfgMuxer, const CSrtConfig& cfgSocket)
+{
+    if (!cfgMuxer.bReuseAddr)
+    {
+        HLOGP(smlog.Debug, "channelSettingsMatch: fail: the multiplexer is not reusable");
+        return false;
+    }
+
+    if (cfgMuxer.isCompatWith(cfgSocket))
+        return true;
+
+    HLOGP(smlog.Debug, "channelSettingsMatch: fail: some options have different values");
+    return false;
+}
+
+void srt::CUDTUnited::updateMux(CUDTSocket* s, const sockaddr_any& reqaddr, const UDPSOCKET* udpsock /*[[nullable]]*/)
+{
+    ScopedLock cg(m_GlobControlLock);
+
+    // If udpsock is provided, then this socket will be simply
+    // taken for binding as a good deal. It would be nice to make
+    // a sanity check to see if this UDP socket isn't already installed
+    // in some multiplexer, but we state this UDP socket isn't accessible
+    // anyway so this wouldn't be possible.
+    if (!udpsock)
+    {
+        // If not, we need to see if there exist already a multiplexer bound
+        // to the same endpoint.
+        const int         port      = reqaddr.hport();
+        const CSrtConfig& cfgSocket = s->core().m_config;
+
+        // This loop is going to check the attempted binding of
+        // address:port and socket settings against every existing
+        // multiplexer. Possible results of the check are:
+
+        // 1. MATCH: identical address - reuse it and quit.
+        // 2. CONFLICT: report error: the binding partially overlaps
+        //    so it neither can be reused nor is free to bind.
+        // 3. PASS: different and not overlapping - continue searching.
+
+        // In this function the convention is:
+        // MATCH: do nothing and proceed with binding reusage, THEN break.
+        // CONFLICT: throw an exception.
+        // PASS: use 'continue' to pass to the next element.
+
+        bool reuse_attempt = false;
+        for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin(); i != m_mMultiplexer.end(); ++i)
+        {
+            CMultiplexer const& m = i->second;
+
+            // First, we need to find a multiplexer with the same port.
+            if (m.m_iPort != port)
+            {
+                HLOGC(smlog.Debug,
+                      log << "bind: muxer @" << m.m_iID << " found, but for port " << m.m_iPort
+                          << " (requested port: " << port << ")");
+                continue;
+            }
+
+            // If this is bound to the wildcard address, it can be reused if:
+            // - reqaddr is also a wildcard
+            // - channel settings match
+            // Otherwise it's a conflict.
+            sockaddr_any mux_addr;
+            m.m_pChannel->getSockAddr((mux_addr));
+
+            HLOGC(smlog.Debug,
+                  log << "bind: Found existing muxer @" << m.m_iID << " : " << mux_addr.str() << " - check against "
+                      << reqaddr.str());
+
+            if (mux_addr.isany())
+            {
+                if (mux_addr.family() == AF_INET6)
+                {
+                    // With IPv6 we need to research two possibilities:
+                    // iIpV6Only == 1 -> This means that it binds only :: wildcard, but not 0.0.0.0
+                    // iIpV6Only == 0 -> This means that it binds both :: and 0.0.0.0.
+                    // iIpV6Only == -1 -> Hard to say what to do, but treat it as a potential conflict in any doubtful case.
+
+                    if (m.m_mcfg.iIpV6Only == 1)
+                    {
+                        // PASS IF: candidate is IPv4, no matter the address
+                        // MATCH IF: candidate is IPv6 with only=1
+                        // CONFLICT IF: candidate is IPv6 with only != 1 or IPv6 non-wildcard.
+
+                        if (reqaddr.family() == AF_INET)
+                        {
+                            HLOGC(smlog.Debug, log << "bind: muxer @" << m.m_iID
+                                    << " is :: v6only - requested IPv4 ANY is NOT IN THE WAY. Searching on.");
+                            continue;
+                        }
+
+                        // Candidate is AF_INET6
+
+                        if (cfgSocket.iIpV6Only != 1 || !reqaddr.isany())
+                        {
+                            // CONFLICT:
+                            // 1. attempting to make a wildcard IPv4 + IPv6
+                            // while the multiplexer for wildcard IPv6 exists.
+                            // 2. If binding to a given address, it conflicts with the wildcard
+                            LOGC(smlog.Error,
+                                    log << "bind: Address: " << reqaddr.str()
+                                    << " conflicts with existing IPv6 wildcard binding: " << mux_addr.str());
+                            throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                        }
+
+                        // Otherwise, MATCH.
+                    }
+                    else if (m.m_mcfg.iIpV6Only == 0)
+                    {
+                        // Muxer's address is a wildcard for :: and 0.0.0.0 at once.
+                        // This way only IPv6 wildcard with v6only=0 is a perfect match and everything
+                        // else is a conflict.
+
+                        if (reqaddr.family() == AF_INET6 && reqaddr.isany() && cfgSocket.iIpV6Only == 0)
+                        {
+                            // MATCH
+                        }
+                        else
+                        {
+                            // CONFLICT: attempting to make a wildcard IPv4 + IPv6 while
+                            // the multiplexer for wildcard IPv6 exists.
+                            LOGC(smlog.Error,
+                                    log << "bind: Address: " << reqaddr.str() << " v6only=" << cfgSocket.iIpV6Only
+                                    << " conflicts with existing IPv6 + IPv4 wildcard binding: " << mux_addr.str());
+                            throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                        }
+                    }
+                    else // Case -1, by unknown reason. Accept only with -1 setting, others are conflict.
+                    {
+                        if (reqaddr.family() == AF_INET6 && reqaddr.isany() && cfgSocket.iIpV6Only == -1)
+                        {
+                            // MATCH
+                        }
+                        else
+                        {
+                            LOGC(smlog.Error,
+                                    log << "bind: Address: " << reqaddr.str() << " v6only=" << cfgSocket.iIpV6Only
+                                    << " conflicts with existing IPv6 v6only=unknown wildcard binding: " << mux_addr.str());
+                            throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                        }
+                    }
+                }
+                else // muxer is IPv4 wildcard
+                {
+                    // Then only IPv4 wildcard is a match and:
+                    // - IPv6 with only=true is PASS (not a conflict)
+                    // - IPv6 with only=false is CONFLICT
+                    // - IPv6 with only=undefined is CONFLICT
+                    // REASON: we need to make a potential conflict a conflict as there will be
+                    // no bind() call to check if this wouldn't be a conflict in result. If you want
+                    // to have a binding to IPv6 that should avoid conflict with IPv4 wildcard binding,
+                    // then SRTO_IPV6ONLY option must be explicitly set before binding.
+                    // Also:
+                    if (reqaddr.family() == AF_INET)
+                    {
+                        if (reqaddr.isany())
+                        {
+                            // MATCH
+                        }
+                        else
+                        {
+                            LOGC(smlog.Error,
+                                    log << "bind: Address: " << reqaddr.str()
+                                    << " conflicts with existing IPv4 wildcard binding: " << mux_addr.str());
+                            throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                        }
+                    }
+                    else // AF_INET6
+                    {
+                        if (cfgSocket.iIpV6Only == 1 || !reqaddr.isany())
+                        {
+                            // PASS
+                            HLOGC(smlog.Debug, log << "bind: muxer @" << m.m_iID
+                                    << " is IPv4 wildcard - requested " << reqaddr.str() << " v6only=" << cfgSocket.iIpV6Only
+                                    << " is NOT IN THE WAY. Searching on.");
+                            continue;
+                        }
+                        else
+                        {
+                            LOGC(smlog.Error,
+                                    log << "bind: Address: " << reqaddr.str() << " v6only=" << cfgSocket.iIpV6Only
+                                    << " conflicts with existing IPv4 wildcard binding: " << mux_addr.str());
+                            throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                        }
+                    }
+                }
+
+                reuse_attempt = true;
+                HLOGC(smlog.Debug, log << "bind: wildcard address - multiplexer reusable");
+            }
+            // Muxer address is NOT a wildcard, so conflicts only with WILDCARD of the same type
+            else if (reqaddr.isany() && reqaddr.family() == mux_addr.family())
+            {
+                LOGC(smlog.Error,
+                     log << "bind: Wildcard address: " << reqaddr.str()
+                         << " conflicts with existting IP binding: " << mux_addr.str());
+                throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+            }
+            // If this is bound to a certain address, AND:
+            else if (mux_addr.equal_address(reqaddr))
+            {
+                // - the address is the same as reqaddr
+                reuse_attempt = true;
+                HLOGC(smlog.Debug, log << "bind: same IP address - multiplexer reusable");
+            }
+            else
+            {
+                HLOGC(smlog.Debug, log << "bind: IP addresses differ - ALLOWED to create a new multiplexer");
+                continue;
+            }
+            // Otherwise:
+            // - the address is different than reqaddr
+            //   - the address can't be reused, but this can go on with new one.
+
+            // If this is a reusage attempt:
+            if (reuse_attempt)
+            {
+                //   - if the channel settings match, it can be reused
+                if (channelSettingsMatch(m.m_mcfg, cfgSocket) && inet6SettingsCompat(mux_addr, m.m_mcfg, reqaddr, cfgSocket))
+                {
+                    HLOGC(smlog.Debug, log << "bind: reusing multiplexer for port " << port);
+                    // reuse the existing multiplexer
+                    ++i->second.m_iRefCount;
+                    installMuxer((s), (i->second));
+                    return;
+                }
+                else
+                {
+                    //   - if not, it's a conflict
+                    LOGC(smlog.Error,
+                         log << "bind: Address: " << reqaddr.str() << " conflicts with binding: " << mux_addr.str()
+                             << " due to channel settings");
+                    throw CUDTException(MJ_NOTSUP, MN_BUSYPORT, 0);
+                }
+            }
+            // If not, proceed to the next one, and when there are no reusage
+            // candidates, proceed with creating a new multiplexer.
+
+            // Note that a binding to a different IP address is not treated
+            // as a candidate for either reusage or conflict.
+            LOGC(smlog.Fatal, log << "SHOULD NOT GET HERE!!!");
+            SRT_ASSERT(false);
+        }
+    }
+
+    // a new multiplexer is needed
+    CMultiplexer m;
+    configureMuxer((m), s, reqaddr.family());
+
+    try
+    {
+        m.m_pChannel = new CChannel();
+        m.m_pChannel->setConfig(m.m_mcfg);
+
+        if (udpsock)
+        {
+            // In this case, reqaddr contains the address
+            // that has been extracted already from the
+            // given socket
+            m.m_pChannel->attach(*udpsock, reqaddr);
+        }
+        else if (reqaddr.empty())
+        {
+            // The case of previously used case of a NULL address.
+            // This here is used to pass family only, in this case
+            // just automatically bind to the "0" address to autoselect
+            // everything.
+            m.m_pChannel->open(reqaddr.family());
+        }
+        else
+        {
+            // If at least the IP address is specified, then bind to that
+            // address, but still possibly autoselect the outgoing port, if the
+            // port was specified as 0.
+            m.m_pChannel->open(reqaddr);
+        }
+
+        // AFTER OPENING, check the matter of IPV6_V6ONLY option,
+        // as it decides about the fact that the occupied binding address
+        // in case of wildcard is both :: and 0.0.0.0, or only ::.
+        if (reqaddr.family() == AF_INET6 && m.m_mcfg.iIpV6Only == -1)
+        {
+            // XXX We don't know how probable it is to get the error here
+            // and resulting -1 value. As a fallback for that case, the value -1
+            // is honored here, just all side-bindings for other sockes will be
+            // rejected as a potential conflict, even if binding would be accepted
+            // in these circumstances. Only a perfect match in case of potential
+            // overlapping will be accepted on the same port.
+            m.m_mcfg.iIpV6Only = m.m_pChannel->sockopt(IPPROTO_IPV6, IPV6_V6ONLY, -1);
+        }
+
+        m.m_pTimer    = new CTimer;
+        m.m_pSndQueue = new CSndQueue;
+        m.m_pSndQueue->init(m.m_pChannel, m.m_pTimer);
+        m.m_pRcvQueue = new CRcvQueue;
+        m.m_pRcvQueue->init(128, s->core().maxPayloadSize(), m.m_iIPversion, 1024, m.m_pChannel, m.m_pTimer);
+
+        // Rewrite the port here, as it might be only known upon return
+        // from CChannel::open.
+        m.m_iPort               = installMuxer((s), m);
+        m_mMultiplexer[m.m_iID] = m;
+    }
+    catch (const CUDTException&)
+    {
+        m.destroy();
+        throw;
+    }
+    catch (...)
+    {
+        m.destroy();
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+
+    HLOGC(smlog.Debug, log << "bind: creating new multiplexer for port " << m.m_iPort);
+}
+
+// This function is going to find a multiplexer for the port contained
 // in the 'ls' listening socket. The multiplexer must exist when the listener
 // exists, otherwise the dispatching procedure wouldn't even call this
 // function. By historical reasons there's also a fallback for a case when the
 // multiplexer wasn't found by id, the search by port number continues.
-bool CUDTUnited::updateListenerMux(CUDTSocket* s, const CUDTSocket* ls)
+bool srt::CUDTUnited::updateListenerMux(CUDTSocket* s, const CUDTSocket* ls)
 {
-   ScopedLock cg(m_GlobControlLock);
-   const int port = ls->m_SelfAddr.hport();
+    ScopedLock cg(m_GlobControlLock);
+    const int  port = ls->m_SelfAddr.hport();
+
+    HLOGC(smlog.Debug,
+          log << "updateListenerMux: finding muxer of listener socket @" << ls->m_SocketID << " muxid=" << ls->m_iMuxID
+              << " bound=" << ls->m_SelfAddr.str() << " FOR @" << s->m_SocketID << " addr=" << s->m_SelfAddr.str()
+              << "_->_" << s->m_PeerAddr.str());
+
+    // First thing that should be certain here is that there should exist
+    // a muxer with the ID written in the listener socket's mux ID.
+
+    CMultiplexer* mux = map_getp(m_mMultiplexer, ls->m_iMuxID);
+
+    // NOTE:
+    // THIS BELOW CODE is only for a highly unlikely situation when the listener
+    // socket has been closed in the meantime when the accepted socket is being
+    // processed. This procedure is different than updateMux because this time we
+    // only want to have a multiplexer socket to be assigned to the accepted socket.
+    // It is also unlikely that the listener socket is garbage-collected so fast, so
+    // this procedure will most likely find the multiplexer of the zombie listener socket,
+    // which no longer accepts new connections (the listener is withdrawn immediately from
+    // the port) that wasn't yet completely deleted.
+    CMultiplexer* fallback = NULL;
+    if (!mux)
+    {
+        LOGC(smlog.Error, log << "updateListenerMux: IPE? listener muxer not found by ID, trying by port");
 
-   HLOGC(smlog.Debug, log << "updateListenerMux: finding muxer of listener socket @"
-           << ls->m_SocketID << " muxid=" << ls->m_iMuxID
-           << " bound=" << ls->m_SelfAddr.str()
-           << " FOR @" << s->m_SocketID << " addr="
-           << s->m_SelfAddr.str() << "_->_" << s->m_PeerAddr.str());
+        // To be used as first found with different IP version
+
+        // find the listener's address
+        for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin(); i != m_mMultiplexer.end(); ++i)
+        {
+            CMultiplexer& m = i->second;
 
-   // First thing that should be certain here is that there should exist
-   // a muxer with the ID written in the listener socket's mux ID.
+#if ENABLE_HEAVY_LOGGING
+            ostringstream that_muxer;
+            that_muxer << "id=" << m.m_iID << " port=" << m.m_iPort
+                       << " ip=" << (m.m_iIPversion == AF_INET ? "v4" : "v6");
+#endif
 
-   CMultiplexer* mux = map_getp(m_mMultiplexer, ls->m_iMuxID);
+            if (m.m_iPort == port)
+            {
+                HLOGC(smlog.Debug, log << "updateListenerMux: reusing muxer: " << that_muxer.str());
+                if (m.m_iIPversion == s->m_PeerAddr.family())
+                {
+                    mux = &m; // best match
+                    break;
+                }
+                else if (m.m_iIPversion == AF_INET6)
+                {
+                    // Allowed fallback case when we only need an accepted socket.
+                    fallback = &m;
+                }
+            }
+            else
+            {
+                HLOGC(smlog.Debug, log << "updateListenerMux: SKIPPING muxer: " << that_muxer.str());
+            }
+        }
 
-   // NOTE:
-   // THIS BELOW CODE is only for a highly unlikely, and probably buggy,
-   // situation when the Multiplexer wasn't found by ID recorded in the listener.
-   CMultiplexer* fallback = NULL;
-   if (!mux)
-   {
-       LOGC(smlog.Error, log << "updateListenerMux: IPE? listener muxer not found by ID, trying by port");
+        if (!mux && fallback)
+        {
+            // It is allowed to reuse this multiplexer, but the socket must allow both IPv4 and IPv6
+            if (fallback->m_mcfg.iIpV6Only == 0)
+            {
+                HLOGC(smlog.Warn, log << "updateListenerMux: reusing multiplexer from different family");
+                mux = fallback;
+            }
+        }
+    }
 
-       // To be used as first found with different IP version
+    // Checking again because the above procedure could have set it
+    if (mux)
+    {
+        // reuse the existing multiplexer
+        ++mux->m_iRefCount;
+        s->core().m_pSndQueue = mux->m_pSndQueue;
+        s->core().m_pRcvQueue = mux->m_pRcvQueue;
+        s->m_iMuxID           = mux->m_iID;
+        return true;
+    }
 
-       // find the listener's address
-       for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin();
-               i != m_mMultiplexer.end(); ++ i)
-       {
-           CMultiplexer& m = i->second;
+    return false;
+}
 
-#if ENABLE_HEAVY_LOGGING
-           ostringstream that_muxer;
-           that_muxer << "id=" << m.m_iID
-               << " port=" << m.m_iPort
-               << " ip=" << (m.m_iIPversion == AF_INET ? "v4" : "v6");
-#endif
+void* srt::CUDTUnited::garbageCollect(void* p)
+{
+    CUDTUnited* self = (CUDTUnited*)p;
 
-           if (m.m_iPort == port)
-           {
-               HLOGC(smlog.Debug, log << "updateListenerMux: reusing muxer: " << that_muxer.str());
-               if (m.m_iIPversion == s->m_PeerAddr.family())
-               {
-                   mux = &m; // best match
-                   break;
-               }
-               else
-               {
-                   fallback = &m;
-               }
-           }
-           else
-           {
-               HLOGC(smlog.Debug, log << "updateListenerMux: SKIPPING muxer: " << that_muxer.str());
-           }
-       }
-
-       if (!mux && fallback)
-       {
-           // It is allowed to reuse this multiplexer, but the socket must allow both IPv4 and IPv6
-           if (fallback->m_iIpV6Only == 0)
-           {
-               HLOGC(smlog.Warn, log << "updateListenerMux: reusing multiplexer from different family");
-               mux = fallback;
-           }
-       }
-   }
-
-   // Checking again because the above procedure could have set it
-   if (mux)
-   {
-       // reuse the existing multiplexer
-       ++ mux->m_iRefCount;
-       s->m_pUDT->m_pSndQueue = mux->m_pSndQueue;
-       s->m_pUDT->m_pRcvQueue = mux->m_pRcvQueue;
-       s->m_iMuxID = mux->m_iID;
-       return true;
-   }
-
-   return false;
-}
-
-void* CUDTUnited::garbageCollect(void* p)
-{
-   CUDTUnited* self = (CUDTUnited*)p;
-
-   THREAD_STATE_INIT("SRT:GC");
-
-   UniqueLock gclock(self->m_GCStopLock);
-
-   while (!self->m_bClosing)
-   {
-       INCREMENT_THREAD_ITERATIONS();
-       self->checkBrokenSockets();
-
-       HLOGC(inlog.Debug, log << "GC: sleep 1 s");
-       self->m_GCStopCond.wait_for(gclock, seconds_from(1));
-   }
-
-   // remove all sockets and multiplexers
-   HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all pending sockets. Acquring control lock...");
-
-   {
-       ScopedLock glock (self->m_GlobControlLock);
-
-       for (sockets_t::iterator i = self->m_Sockets.begin();
-               i != self->m_Sockets.end(); ++ i)
-       {
-           CUDTSocket* s = i->second;
-           s->breakSocket_LOCKED();
-
-#if ENABLE_EXPERIMENTAL_BONDING
-           if (s->m_IncludedGroup)
-           {
-               HLOGC(smlog.Debug, log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_IncludedGroup->id() << " (IPE?) - REMOVING FROM GROUP");
-               s->removeFromGroup(false);
-           }
+    THREAD_STATE_INIT("SRT:GC");
+
+    UniqueLock gclock(self->m_GCStopLock);
+
+    while (!self->m_bClosing)
+    {
+        INCREMENT_THREAD_ITERATIONS();
+        self->checkBrokenSockets();
+
+        HLOGC(inlog.Debug, log << "GC: sleep 1 s");
+        self->m_GCStopCond.wait_for(gclock, seconds_from(1));
+    }
+
+    // remove all sockets and multiplexers
+    HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all pending sockets. Acquring control lock...");
+
+    {
+        ScopedLock glock(self->m_GlobControlLock);
+
+        for (sockets_t::iterator i = self->m_Sockets.begin(); i != self->m_Sockets.end(); ++i)
+        {
+            CUDTSocket* s = i->second;
+            s->breakSocket_LOCKED();
+
+#if ENABLE_BONDING
+            if (s->m_GroupOf)
+            {
+                HLOGC(smlog.Debug,
+                      log << "@" << s->m_SocketID << " IS MEMBER OF $" << s->m_GroupOf->id()
+                          << " (IPE?) - REMOVING FROM GROUP");
+                s->removeFromGroup(false);
+            }
 #endif
-           self->m_ClosedSockets[i->first] = s;
-
-           // remove from listener's queue
-           sockets_t::iterator ls = self->m_Sockets.find(
-                   s->m_ListenSocket);
-           if (ls == self->m_Sockets.end())
-           {
-               ls = self->m_ClosedSockets.find(s->m_ListenSocket);
-               if (ls == self->m_ClosedSockets.end())
-                   continue;
-           }
-
-           enterCS(ls->second->m_AcceptLock);
-           ls->second->m_pQueuedSockets->erase(s->m_SocketID);
-           ls->second->m_pAcceptSockets->erase(s->m_SocketID);
-           leaveCS(ls->second->m_AcceptLock);
-       }
-       self->m_Sockets.clear();
-
-       for (sockets_t::iterator j = self->m_ClosedSockets.begin();
-               j != self->m_ClosedSockets.end(); ++ j)
-       {
-           j->second->m_tsClosureTimeStamp = steady_clock::time_point();
-       }
-   }
-
-   HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all CLOSED sockets.");
-   while (true)
-   {
-      self->checkBrokenSockets();
-
-      enterCS(self->m_GlobControlLock);
-      bool empty = self->m_ClosedSockets.empty();
-      leaveCS(self->m_GlobControlLock);
-
-      if (empty)
-         break;
-
-      srt::sync::this_thread::sleep_for(milliseconds_from(1));
-   }
-
-   THREAD_EXIT();
-   return NULL;
+            self->m_ClosedSockets[i->first] = s;
+
+            // remove from listener's queue
+            sockets_t::iterator ls = self->m_Sockets.find(s->m_ListenSocket);
+            if (ls == self->m_Sockets.end())
+            {
+                ls = self->m_ClosedSockets.find(s->m_ListenSocket);
+                if (ls == self->m_ClosedSockets.end())
+                    continue;
+            }
+
+            enterCS(ls->second->m_AcceptLock);
+            ls->second->m_QueuedSockets.erase(s->m_SocketID);
+            leaveCS(ls->second->m_AcceptLock);
+        }
+        self->m_Sockets.clear();
+
+        for (sockets_t::iterator j = self->m_ClosedSockets.begin(); j != self->m_ClosedSockets.end(); ++j)
+        {
+            j->second->m_tsClosureTimeStamp = steady_clock::time_point();
+        }
+    }
+
+    HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all CLOSED sockets.");
+    while (true)
+    {
+        self->checkBrokenSockets();
+
+        enterCS(self->m_GlobControlLock);
+        bool empty = self->m_ClosedSockets.empty();
+        leaveCS(self->m_GlobControlLock);
+
+        if (empty)
+            break;
+
+        HLOGC(inlog.Debug, log << "GC: checkBrokenSockets didn't wipe all sockets, repeating after 1s sleep");
+        srt::sync::this_thread::sleep_for(milliseconds_from(1));
+    }
+
+    THREAD_EXIT();
+    return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-int CUDT::startup()
+int srt::CUDT::startup()
 {
-   return s_UDTUnited.startup();
+    return uglobal().startup();
 }
 
-int CUDT::cleanup()
+int srt::CUDT::cleanup()
 {
-   return s_UDTUnited.cleanup();
+    return uglobal().cleanup();
 }
 
-SRTSOCKET CUDT::socket()
+SRTSOCKET srt::CUDT::socket()
 {
-   if (!s_UDTUnited.m_bGCStatus)
-      s_UDTUnited.startup();
+    uglobal().startup();
 
-   try
-   {
-      return s_UDTUnited.newSocket();
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return INVALID_SOCK;
-   }
-   catch (const bad_alloc&)
-   {
-      SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
-      return INVALID_SOCK;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "socket: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name()
-         << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return INVALID_SOCK;
-   }
+    try
+    {
+        return uglobal().newSocket();
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return INVALID_SOCK;
+    }
+    catch (const bad_alloc&)
+    {
+        SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
+        return INVALID_SOCK;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "socket: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return INVALID_SOCK;
+    }
 }
 
-CUDT::APIError::APIError(const CUDTException& e)
+srt::CUDT::APIError::APIError(const CUDTException& e)
 {
     SetThreadLocalError(e);
 }
 
-CUDT::APIError::APIError(CodeMajor mj, CodeMinor mn, int syserr)
+srt::CUDT::APIError::APIError(CodeMajor mj, CodeMinor mn, int syserr)
 {
     SetThreadLocalError(CUDTException(mj, mn, syserr));
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 // This is an internal function; 'type' should be pre-checked if it has a correct value.
 // This doesn't have argument of GroupType due to header file conflicts.
 
 // [[using locked(s_UDTUnited.m_GlobControlLock)]]
-CUDTGroup& CUDT::newGroup(const int type)
+srt::CUDTGroup& srt::CUDT::newGroup(const int type)
 {
-    const SRTSOCKET id = s_UDTUnited.generateSocketID(true);
+    const SRTSOCKET id = uglobal().generateSocketID(true);
 
     // Now map the group
-    return s_UDTUnited.addGroup(id, SRT_GROUP_TYPE(type)).set_id(id);
+    return uglobal().addGroup(id, SRT_GROUP_TYPE(type)).set_id(id);
+}
+
+SRTSOCKET srt::CUDT::createGroup(SRT_GROUP_TYPE gt)
+{
+    // Doing the same lazy-startup as with srt_create_socket()
+    uglobal().startup();
+
+    try
+    {
+        srt::sync::ScopedLock globlock(uglobal().m_GlobControlLock);
+        return newGroup(gt).id();
+        // Note: potentially, after this function exits, the group
+        // could be deleted, immediately, from a separate thread (tho
+        // unlikely because the other thread would need some handle to
+        // keep it). But then, the first call to any API function would
+        // return invalid ID error.
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (...)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+
+    return SRT_INVALID_SOCK;
+}
+
+// [[using locked(m_ControlLock)]]
+// [[using locked(CUDT::s_UDTUnited.m_GlobControlLock)]]
+void srt::CUDTSocket::removeFromGroup(bool broken)
+{
+    CUDTGroup* g = m_GroupOf;
+    if (g)
+    {
+        // Reset group-related fields immediately. They won't be accessed
+        // in the below calls, while the iterator will be invalidated for
+        // a short moment between removal from the group container and the end,
+        // while the GroupLock would be already taken out. It is safer to reset
+        // it to a NULL iterator before removal.
+        m_GroupOf         = NULL;
+        m_GroupMemberData = NULL;
+
+        bool still_have = g->remove(m_SocketID);
+        if (broken)
+        {
+            // Activate the SRT_EPOLL_UPDATE event on the group
+            // if it was because of a socket that was earlier connected
+            // and became broken. This is not to be sent in case when
+            // it is a failure during connection, or the socket was
+            // explicitly removed from the group.
+            g->activateUpdateEvent(still_have);
+        }
+
+        HLOGC(smlog.Debug,
+              log << "removeFromGroup: socket @" << m_SocketID << " NO LONGER A MEMBER of $" << g->id() << "; group is "
+                  << (still_have ? "still ACTIVE" : "now EMPTY"));
+    }
+}
+
+SRTSOCKET srt::CUDT::getGroupOfSocket(SRTSOCKET socket)
+{
+    // Lock this for the whole function as we need the group
+    // to persist the call.
+    ScopedLock  glock(uglobal().m_GlobControlLock);
+    CUDTSocket* s = uglobal().locateSocket_LOCKED(socket);
+    if (!s || !s->m_GroupOf)
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+
+    return s->m_GroupOf->id();
+}
+
+int srt::CUDT::getGroupData(SRTSOCKET groupid, SRT_SOCKGROUPDATA* pdata, size_t* psize)
+{
+    if ((groupid & SRTGROUP_MASK) == 0 || !psize)
+    {
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    CUDTUnited::GroupKeeper k(uglobal(), groupid, CUDTUnited::ERH_RETURN);
+    if (!k.group)
+    {
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    // To get only the size of the group pdata=NULL can be used
+    return k.group->getGroupData(pdata, psize);
+}
+#endif
+
+int srt::CUDT::bind(SRTSOCKET u, const sockaddr* name, int namelen)
+{
+    try
+    {
+        sockaddr_any sa(name, namelen);
+        if (sa.len == 0)
+        {
+            // This happens if the namelen check proved it to be
+            // too small for particular family, or that family is
+            // not recognized (is none of AF_INET, AF_INET6).
+            // This is a user error.
+            return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        }
+        CUDTSocket* s = uglobal().locateSocket(u);
+        if (!s)
+            return APIError(MJ_NOTSUP, MN_INVAL, 0);
+
+        return uglobal().bind(s, sa);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "bind: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::bind(SRTSOCKET u, UDPSOCKET udpsock)
+{
+    try
+    {
+        CUDTSocket* s = uglobal().locateSocket(u);
+        if (!s)
+            return APIError(MJ_NOTSUP, MN_INVAL, 0);
+
+        return uglobal().bind(s, udpsock);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "bind/udp: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::listen(SRTSOCKET u, int backlog)
+{
+    try
+    {
+        return uglobal().listen(u, backlog);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "listen: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+SRTSOCKET srt::CUDT::accept_bond(const SRTSOCKET listeners[], int lsize, int64_t msTimeOut)
+{
+    try
+    {
+        return uglobal().accept_bond(listeners, lsize, msTimeOut);
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return INVALID_SOCK;
+    }
+    catch (bad_alloc&)
+    {
+        SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
+        return INVALID_SOCK;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "accept_bond: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return INVALID_SOCK;
+    }
+}
+
+SRTSOCKET srt::CUDT::accept(SRTSOCKET u, sockaddr* addr, int* addrlen)
+{
+    try
+    {
+        return uglobal().accept(u, addr, addrlen);
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return INVALID_SOCK;
+    }
+    catch (const bad_alloc&)
+    {
+        SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
+        return INVALID_SOCK;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "accept: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return INVALID_SOCK;
+    }
+}
+
+int srt::CUDT::connect(SRTSOCKET u, const sockaddr* name, const sockaddr* tname, int namelen)
+{
+    try
+    {
+        return uglobal().connect(u, name, tname, namelen);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+#if ENABLE_BONDING
+int srt::CUDT::connectLinks(SRTSOCKET grp, SRT_SOCKGROUPCONFIG targets[], int arraysize)
+{
+    if (arraysize <= 0)
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+
+    if ((grp & SRTGROUP_MASK) == 0)
+    {
+        // connectLinks accepts only GROUP id, not socket id.
+        return APIError(MJ_NOTSUP, MN_SIDINVAL, 0);
+    }
+
+    try
+    {
+        CUDTUnited::GroupKeeper k(uglobal(), grp, CUDTUnited::ERH_THROW);
+        return uglobal().groupConnect(k.group, targets, arraysize);
+    }
+    catch (CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+#endif
+
+int srt::CUDT::connect(SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn)
+{
+    try
+    {
+        return uglobal().connect(u, name, namelen, forced_isn);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::close(SRTSOCKET u)
+{
+    try
+    {
+        return uglobal().close(u);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "close: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::getpeername(SRTSOCKET u, sockaddr* name, int* namelen)
+{
+    try
+    {
+        uglobal().getpeername(u, name, namelen);
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "getpeername: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::getsockname(SRTSOCKET u, sockaddr* name, int* namelen)
+{
+    try
+    {
+        uglobal().getsockname(u, name, namelen);
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "getsockname: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::getsockopt(SRTSOCKET u, int, SRT_SOCKOPT optname, void* pw_optval, int* pw_optlen)
+{
+    if (!pw_optval || !pw_optlen)
+    {
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    try
+    {
+#if ENABLE_BONDING
+        if (u & SRTGROUP_MASK)
+        {
+            CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+            k.group->getOpt(optname, (pw_optval), (*pw_optlen));
+            return 0;
+        }
+#endif
+
+        CUDT& udt = uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core();
+        udt.getOpt(optname, (pw_optval), (*pw_optlen));
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "getsockopt: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::setsockopt(SRTSOCKET u, int, SRT_SOCKOPT optname, const void* optval, int optlen)
+{
+    if (!optval || optlen < 0)
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+
+    try
+    {
+#if ENABLE_BONDING
+        if (u & SRTGROUP_MASK)
+        {
+            CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+            k.group->setOpt(optname, optval, optlen);
+            return 0;
+        }
+#endif
+
+        CUDT& udt = uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core();
+        udt.setOpt(optname, optval, optlen);
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "setsockopt: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::send(SRTSOCKET u, const char* buf, int len, int)
+{
+    SRT_MSGCTRL mctrl = srt_msgctrl_default;
+    return sendmsg2(u, buf, len, (mctrl));
+}
+
+// --> CUDT::recv moved down
+
+int srt::CUDT::sendmsg(SRTSOCKET u, const char* buf, int len, int ttl, bool inorder, int64_t srctime)
+{
+    SRT_MSGCTRL mctrl = srt_msgctrl_default;
+    mctrl.msgttl      = ttl;
+    mctrl.inorder     = inorder;
+    mctrl.srctime     = srctime;
+    return sendmsg2(u, buf, len, (mctrl));
+}
+
+int srt::CUDT::sendmsg2(SRTSOCKET u, const char* buf, int len, SRT_MSGCTRL& w_m)
+{
+    try
+    {
+#if ENABLE_BONDING
+        if (u & SRTGROUP_MASK)
+        {
+            CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+            return k.group->send(buf, len, (w_m));
+        }
+#endif
+
+        return uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core().sendmsg2(buf, len, (w_m));
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "sendmsg: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::recv(SRTSOCKET u, char* buf, int len, int)
+{
+    SRT_MSGCTRL mctrl = srt_msgctrl_default;
+    int         ret   = recvmsg2(u, buf, len, (mctrl));
+    return ret;
+}
+
+int srt::CUDT::recvmsg(SRTSOCKET u, char* buf, int len, int64_t& srctime)
+{
+    SRT_MSGCTRL mctrl = srt_msgctrl_default;
+    int         ret   = recvmsg2(u, buf, len, (mctrl));
+    srctime           = mctrl.srctime;
+    return ret;
+}
+
+int srt::CUDT::recvmsg2(SRTSOCKET u, char* buf, int len, SRT_MSGCTRL& w_m)
+{
+    try
+    {
+#if ENABLE_BONDING
+        if (u & SRTGROUP_MASK)
+        {
+            CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+            return k.group->recv(buf, len, (w_m));
+        }
+#endif
+
+        return uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core().recvmsg2(buf, len, (w_m));
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "recvmsg: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int64_t srt::CUDT::sendfile(SRTSOCKET u, fstream& ifs, int64_t& offset, int64_t size, int block)
+{
+    try
+    {
+        CUDT& udt = uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core();
+        return udt.sendfile(ifs, offset, size, block);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "sendfile: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int64_t srt::CUDT::recvfile(SRTSOCKET u, fstream& ofs, int64_t& offset, int64_t size, int block)
+{
+    try
+    {
+        return uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core().recvfile(ofs, offset, size, block);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "recvfile: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::select(int, UDT::UDSET* readfds, UDT::UDSET* writefds, UDT::UDSET* exceptfds, const timeval* timeout)
+{
+    if ((!readfds) && (!writefds) && (!exceptfds))
+    {
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    try
+    {
+        return uglobal().select(readfds, writefds, exceptfds, timeout);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "select: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::selectEx(const vector<SRTSOCKET>& fds,
+                        vector<SRTSOCKET>*       readfds,
+                        vector<SRTSOCKET>*       writefds,
+                        vector<SRTSOCKET>*       exceptfds,
+                        int64_t                  msTimeOut)
+{
+    if ((!readfds) && (!writefds) && (!exceptfds))
+    {
+        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    try
+    {
+        return uglobal().selectEx(fds, readfds, writefds, exceptfds, msTimeOut);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (bad_alloc&)
+    {
+        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "selectEx: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN);
+    }
+}
+
+int srt::CUDT::epoll_create()
+{
+    try
+    {
+        return uglobal().epoll_create();
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "epoll_create: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
+
+int srt::CUDT::epoll_clear_usocks(int eid)
+{
+    try
+    {
+        return uglobal().epoll_clear_usocks(eid);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (std::exception& ee)
+    {
+        LOGC(aclog.Fatal,
+             log << "epoll_clear_usocks: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
 }
 
-SRTSOCKET CUDT::createGroup(SRT_GROUP_TYPE gt)
+int srt::CUDT::epoll_add_usock(const int eid, const SRTSOCKET u, const int* events)
 {
-    // Doing the same lazy-startup as with srt_create_socket()
-    if (!s_UDTUnited.m_bGCStatus)
-        s_UDTUnited.startup();
-
     try
     {
-        srt::sync::ScopedLock globlock (s_UDTUnited.m_GlobControlLock);
-        return newGroup(gt).id();
-        // Note: potentially, after this function exits, the group
-        // could be deleted, immediately, from a separate thread (tho
-        // unlikely because the other thread would need some handle to
-        // keep it). But then, the first call to any API function would
-        // return invalid ID error.
+        return uglobal().epoll_add_usock(eid, u, events);
     }
     catch (const CUDTException& e)
     {
         return APIError(e);
     }
-    catch (...)
+    catch (const std::exception& ee)
     {
-        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
+        LOGC(aclog.Fatal, log << "epoll_add_usock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
-
-    return SRT_INVALID_SOCK;
 }
 
-
-int CUDT::addSocketToGroup(SRTSOCKET socket, SRTSOCKET group)
+int srt::CUDT::epoll_add_ssock(const int eid, const SYSSOCKET s, const int* events)
 {
-    // Check if socket and group have been set correctly.
-    int32_t sid = socket & ~SRTGROUP_MASK;
-    int32_t gm = group & SRTGROUP_MASK;
-
-    if ( sid != socket || gm == 0 )
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    // Find the socket and the group
-    CUDTSocket* s = s_UDTUnited.locateSocket(socket);
-    CUDTUnited::GroupKeeper k (s_UDTUnited, group, s_UDTUnited.ERH_RETURN);
-
-    if (!s || !k.group)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    // Check if the socket is already IN SOME GROUP.
-    if (s->m_IncludedGroup)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    CUDTGroup* g = k.group;
-    if (g->managed())
+    try
     {
-        // This can be changed as long as the group is empty.
-        if (!g->groupEmpty())
-        {
-            return APIError(MJ_NOTSUP, MN_INVAL, 0);
-        }
-        g->set_managed(false);
+        return uglobal().epoll_add_ssock(eid, s, events);
     }
-
-    ScopedLock cg (s->m_ControlLock);
-    ScopedLock cglob (s_UDTUnited.m_GlobControlLock);
-    if (g->closing())
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    // Check if the socket already is in the group
-    CUDTGroup::gli_t f = g->find(socket);
-    if (f != CUDTGroup::gli_NULL())
+    catch (const CUDTException& e)
     {
-        // XXX This is internal error. Report it, but continue
-        LOGC(aclog.Error, log << "IPE (non-fatal): the socket is in the group, but has no clue about it!");
-        s->m_IncludedIter = f;
-        s->m_IncludedGroup = g;
-        return 0;
+        return APIError(e);
     }
-    s->m_IncludedIter = g->add(g->prepareData(s));
-    s->m_IncludedGroup = g;
-
-    return 0;
-}
-
-// dead function as for now. This is only for non-managed
-// groups.
-int CUDT::removeSocketFromGroup(SRTSOCKET socket)
-{
-    CUDTSocket* s = s_UDTUnited.locateSocket(socket);
-    if (!s)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    if (!s->m_IncludedGroup)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    ScopedLock cg (s->m_ControlLock);
-    ScopedLock glob_grd (s_UDTUnited.m_GlobControlLock);
-    s->removeFromGroup(false);
-    return 0;
-}
-
-// [[using locked(m_ControlLock)]]
-// [[using locked(CUDT::s_UDTUnited.m_GlobControlLock)]]
-void CUDTSocket::removeFromGroup(bool broken)
-{
-    CUDTGroup* g = m_IncludedGroup;
-    if (g)
+    catch (const std::exception& ee)
     {
-        // Reset group-related fields immediately. They won't be accessed
-        // in the below calls, while the iterator will be invalidated for
-        // a short moment between removal from the group container and the end,
-        // while the GroupLock would be already taken out. It is safer to reset
-        // it to a NULL iterator before removal.
-        m_IncludedGroup = NULL;
-        m_IncludedIter = CUDTGroup::gli_NULL();
-
-        bool still_have = g->remove(m_SocketID);
-        if (broken)
-        {
-            // Activate the SRT_EPOLL_UPDATE event on the group
-            // if it was because of a socket that was earlier connected
-            // and became broken. This is not to be sent in case when
-            // it is a failure during connection, or the socket was
-            // explicitly removed from the group.
-            g->activateUpdateEvent(still_have);
-        }
-
-        HLOGC(smlog.Debug, log << "removeFromGroup: socket @" << m_SocketID << " NO LONGER A MEMBER of $" << g->id() << "; group is "
-                << (still_have ? "still ACTIVE" : "now EMPTY"));
+        LOGC(aclog.Fatal, log << "epoll_add_ssock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
 }
 
-SRTSOCKET CUDT::getGroupOfSocket(SRTSOCKET socket)
-{
-    // Lock this for the whole function as we need the group
-    // to persist the call.
-    ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-    CUDTSocket* s = s_UDTUnited.locateSocket_LOCKED(socket);
-    if (!s || !s->m_IncludedGroup)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    return s->m_IncludedGroup->id();
-}
-
-int CUDT::configureGroup(SRTSOCKET groupid, const char* str)
+int srt::CUDT::epoll_update_usock(const int eid, const SRTSOCKET u, const int* events)
 {
-    if ( (groupid & SRTGROUP_MASK) == 0)
+    try
     {
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        return uglobal().epoll_add_usock(eid, u, events);
     }
-
-    CUDTUnited::GroupKeeper k (s_UDTUnited, groupid, s_UDTUnited.ERH_RETURN);
-    if (!k.group)
+    catch (const CUDTException& e)
     {
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal,
+             log << "epoll_update_usock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
-
-    return k.group->configure(str);
 }
 
-int CUDT::getGroupData(SRTSOCKET groupid, SRT_SOCKGROUPDATA* pdata, size_t* psize)
+int srt::CUDT::epoll_update_ssock(const int eid, const SYSSOCKET s, const int* events)
 {
-    if ((groupid & SRTGROUP_MASK) == 0 || !psize)
+    try
     {
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        return uglobal().epoll_update_ssock(eid, s, events);
     }
-
-    CUDTUnited::GroupKeeper k (s_UDTUnited, groupid, s_UDTUnited.ERH_RETURN);
-    if (!k.group)
+    catch (const CUDTException& e)
     {
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal,
+             log << "epoll_update_ssock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
-
-    // To get only the size of the group pdata=NULL can be used
-    return k.group->getGroupData(pdata, psize);
 }
-#endif
 
-int CUDT::bind(SRTSOCKET u, const sockaddr* name, int namelen)
-{
-   try
-   {
-       sockaddr_any sa (name, namelen);
-       if (sa.len == 0)
-       {
-           // This happens if the namelen check proved it to be
-           // too small for particular family, or that family is
-           // not recognized (is none of AF_INET, AF_INET6).
-           // This is a user error.
-           return APIError(MJ_NOTSUP, MN_INVAL, 0);
-       }
-       CUDTSocket* s = s_UDTUnited.locateSocket(u);
-       if (!s)
-           return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-       return s_UDTUnited.bind(s, sa);
-   }
-   catch (const CUDTException& e)
-   {
-       return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-       return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "bind: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name()
-         << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::bind(SRTSOCKET u, UDPSOCKET udpsock)
+int srt::CUDT::epoll_remove_usock(const int eid, const SRTSOCKET u)
 {
     try
     {
-        CUDTSocket* s = s_UDTUnited.locateSocket(u);
-        if (!s)
-            return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-        return s_UDTUnited.bind(s, udpsock);
+        return uglobal().epoll_remove_usock(eid, u);
     }
     catch (const CUDTException& e)
     {
         return APIError(e);
     }
-    catch (bad_alloc&)
-    {
-        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-    }
     catch (const std::exception& ee)
     {
-        LOGC(aclog.Fatal, log << "bind/udp: UNEXPECTED EXCEPTION: "
-                << typeid(ee).name() << ": " << ee.what());
+        LOGC(aclog.Fatal,
+             log << "epoll_remove_usock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
         return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
 }
 
-int CUDT::listen(SRTSOCKET u, int backlog)
-{
-   try
-   {
-      return s_UDTUnited.listen(u, backlog);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "listen: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-SRTSOCKET CUDT::accept_bond(const SRTSOCKET listeners [], int lsize, int64_t msTimeOut)
-{
-   try
-   {
-      return s_UDTUnited.accept_bond(listeners, lsize, msTimeOut);
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return INVALID_SOCK;
-   }
-   catch (bad_alloc&)
-   {
-      SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
-      return INVALID_SOCK;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "accept_bond: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return INVALID_SOCK;
-   }
-}
-
-SRTSOCKET CUDT::accept(SRTSOCKET u, sockaddr* addr, int* addrlen)
-{
-   try
-   {
-      return s_UDTUnited.accept(u, addr, addrlen);
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return INVALID_SOCK;
-   }
-   catch (const bad_alloc&)
-   {
-      SetThreadLocalError(CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0));
-      return INVALID_SOCK;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "accept: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return INVALID_SOCK;
-   }
-}
-
-int CUDT::connect(
-    SRTSOCKET u, const sockaddr* name, const sockaddr* tname, int namelen)
-{
-   try
-   {
-      return s_UDTUnited.connect(u, name, tname, namelen);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-#if ENABLE_EXPERIMENTAL_BONDING
-int CUDT::connectLinks(SRTSOCKET grp,
-        SRT_SOCKGROUPCONFIG targets [], int arraysize)
+int srt::CUDT::epoll_remove_ssock(const int eid, const SYSSOCKET s)
 {
-    if (arraysize <= 0)
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-    if ( (grp & SRTGROUP_MASK) == 0)
-    {
-        // connectLinks accepts only GROUP id, not socket id.
-        return APIError(MJ_NOTSUP, MN_SIDINVAL, 0);
-    }
-
     try
     {
-        CUDTUnited::GroupKeeper k(s_UDTUnited, grp, s_UDTUnited.ERH_THROW);
-        return s_UDTUnited.groupConnect(k.group, targets, arraysize);
+        return uglobal().epoll_remove_ssock(eid, s);
     }
-    catch (CUDTException& e)
+    catch (const CUDTException& e)
     {
         return APIError(e);
     }
-    catch (bad_alloc&)
-    {
-        return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-    }
-    catch (std::exception& ee)
+    catch (const std::exception& ee)
     {
-        LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: "
-                << typeid(ee).name() << ": " << ee.what());
+        LOGC(aclog.Fatal,
+             log << "epoll_remove_ssock: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
         return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
 }
-#endif
 
-int CUDT::connect(
-   SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn)
-{
-   try
-   {
-      return s_UDTUnited.connect(u, name, namelen, forced_isn);
-   }
-   catch (const CUDTException &e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "connect: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::close(SRTSOCKET u)
-{
-   try
-   {
-      return s_UDTUnited.close(u);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "close: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::getpeername(SRTSOCKET u, sockaddr* name, int* namelen)
-{
-   try
-   {
-      s_UDTUnited.getpeername(u, name, namelen);
-      return 0;
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "getpeername: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::getsockname(SRTSOCKET u, sockaddr* name, int* namelen)
-{
-   try
-   {
-      s_UDTUnited.getsockname(u, name, namelen);
-      return 0;
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "getsockname: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::getsockopt(
-   SRTSOCKET u, int, SRT_SOCKOPT optname, void* pw_optval, int* pw_optlen)
+int srt::CUDT::epoll_wait(const int       eid,
+                          set<SRTSOCKET>* readfds,
+                          set<SRTSOCKET>* writefds,
+                          int64_t         msTimeOut,
+                          set<SYSSOCKET>* lrfds,
+                          set<SYSSOCKET>* lwfds)
 {
-    if (!pw_optval || !pw_optlen)
+    try
     {
-        return APIError(MJ_NOTSUP, MN_INVAL, 0);
+        return uglobal().epoll_ref().wait(eid, readfds, writefds, msTimeOut, lrfds, lwfds);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
     }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "epoll_wait: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
+}
 
+int srt::CUDT::epoll_uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut)
+{
     try
     {
-#if ENABLE_EXPERIMENTAL_BONDING
-        if (u & SRTGROUP_MASK)
-        {
-            CUDTUnited::GroupKeeper k(s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-            k.group->getOpt(optname, (pw_optval), (*pw_optlen));
-            return 0;
-        }
-#endif
-
-        CUDT* udt = s_UDTUnited.locateSocket(u, s_UDTUnited.ERH_THROW)->m_pUDT;
-        udt->getOpt(optname, (pw_optval), (*pw_optlen));
-        return 0;
+        return uglobal().epoll_uwait(eid, fdsSet, fdsSize, msTimeOut);
     }
     catch (const CUDTException& e)
     {
@@ -3691,587 +4281,152 @@ int CUDT::getsockopt(
     }
     catch (const std::exception& ee)
     {
-        LOGC(aclog.Fatal, log << "getsockopt: UNEXPECTED EXCEPTION: "
-                << typeid(ee).name() << ": " << ee.what());
+        LOGC(aclog.Fatal, log << "epoll_uwait: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
         return APIError(MJ_UNKNOWN, MN_NONE, 0);
     }
 }
 
-int CUDT::setsockopt(SRTSOCKET u, int, SRT_SOCKOPT optname, const void* optval, int optlen)
+int32_t srt::CUDT::epoll_set(const int eid, int32_t flags)
 {
-   if (!optval)
-       return APIError(MJ_NOTSUP, MN_INVAL, 0);
-
-   try
-   {
-#if ENABLE_EXPERIMENTAL_BONDING
-       if (u & SRTGROUP_MASK)
-       {
-           CUDTUnited::GroupKeeper k(s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-           k.group->setOpt(optname, optval, optlen);
-           return 0;
-       }
-#endif
-
-       CUDT* udt = s_UDTUnited.locateSocket(u, s_UDTUnited.ERH_THROW)->m_pUDT;
-       udt->setOpt(optname, optval, optlen);
-       return 0;
-   }
-   catch (const CUDTException& e)
-   {
-       return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-       LOGC(aclog.Fatal, log << "setsockopt: UNEXPECTED EXCEPTION: "
-               << typeid(ee).name() << ": " << ee.what());
-       return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
+    try
+    {
+        return uglobal().epoll_set(eid, flags);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "epoll_set: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
 }
 
-int CUDT::send(SRTSOCKET u, const char* buf, int len, int)
+int srt::CUDT::epoll_release(const int eid)
 {
-    SRT_MSGCTRL mctrl = srt_msgctrl_default;
-    return sendmsg2(u, buf, len, (mctrl));
+    try
+    {
+        return uglobal().epoll_release(eid);
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "epoll_release: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
 }
 
-// --> CUDT::recv moved down
-
-int CUDT::sendmsg(
-   SRTSOCKET u, const char* buf, int len, int ttl, bool inorder,
-   int64_t srctime)
+srt::CUDTException& srt::CUDT::getlasterror()
 {
-    SRT_MSGCTRL mctrl = srt_msgctrl_default;
-    mctrl.msgttl = ttl;
-    mctrl.inorder = inorder;
-    mctrl.srctime = srctime;
-    return sendmsg2(u, buf, len, (mctrl));
+    return GetThreadLocalError();
 }
 
-int CUDT::sendmsg2(
-   SRTSOCKET u, const char* buf, int len, SRT_MSGCTRL& w_m)
+int srt::CUDT::bstats(SRTSOCKET u, CBytePerfMon* perf, bool clear, bool instantaneous)
 {
-   try
-   {
-#if ENABLE_EXPERIMENTAL_BONDING
-       if (u & SRTGROUP_MASK)
-       {
-           CUDTUnited::GroupKeeper k (s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-           return k.group->send(buf, len, (w_m));
-       }
+#if ENABLE_BONDING
+    if (u & SRTGROUP_MASK)
+        return groupsockbstats(u, perf, clear);
 #endif
 
-       return s_UDTUnited.locateSocket(u, CUDTUnited::ERH_THROW)->core().sendmsg2(buf, len, (w_m));
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "sendmsg: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::recv(SRTSOCKET u, char* buf, int len, int)
-{
-    SRT_MSGCTRL mctrl = srt_msgctrl_default;
-    int ret = recvmsg2(u, buf, len, (mctrl));
-    return ret;
-}
-
-int CUDT::recvmsg(SRTSOCKET u, char* buf, int len, int64_t& srctime)
-{
-    SRT_MSGCTRL mctrl = srt_msgctrl_default;
-    int ret = recvmsg2(u, buf, len, (mctrl));
-    srctime = mctrl.srctime;
-    return ret;
+    try
+    {
+        CUDT& udt = uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core();
+        udt.bstats(perf, clear, instantaneous);
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        return APIError(e);
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "bstats: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        return APIError(MJ_UNKNOWN, MN_NONE, 0);
+    }
 }
 
-int CUDT::recvmsg2(SRTSOCKET u, char* buf, int len, SRT_MSGCTRL& w_m)
+#if ENABLE_BONDING
+int srt::CUDT::groupsockbstats(SRTSOCKET u, CBytePerfMon* perf, bool clear)
 {
-   try
-   {
-#if ENABLE_EXPERIMENTAL_BONDING
-      if (u & SRTGROUP_MASK)
-      {
-          CUDTUnited::GroupKeeper k(s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-          return k.group->recv(buf, len, (w_m));
-      }
-#endif
-
-      return s_UDTUnited.locateSocket(u, CUDTUnited::ERH_THROW)->core().recvmsg2(buf, len, (w_m));
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "recvmsg: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int64_t CUDT::sendfile(
-   SRTSOCKET u, fstream& ifs, int64_t& offset, int64_t size, int block)
-{
-   try
-   {
-      CUDT* udt = s_UDTUnited.locateSocket(u, s_UDTUnited.ERH_THROW)->m_pUDT;
-      return udt->sendfile(ifs, offset, size, block);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "sendfile: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int64_t CUDT::recvfile(
-   SRTSOCKET u, fstream& ofs, int64_t& offset, int64_t size, int block)
-{
-   try
-   {
-       return s_UDTUnited.locateSocket(u, CUDTUnited::ERH_THROW)->core().recvfile(ofs, offset, size, block);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "recvfile: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::select(
-   int,
-   UDT::UDSET* readfds,
-   UDT::UDSET* writefds,
-   UDT::UDSET* exceptfds,
-   const timeval* timeout)
-{
-   if ((!readfds) && (!writefds) && (!exceptfds))
-   {
-      return APIError(MJ_NOTSUP, MN_INVAL, 0);
-   }
-
-   try
-   {
-      return s_UDTUnited.select(readfds, writefds, exceptfds, timeout);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "select: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::selectEx(
-   const vector<SRTSOCKET>& fds,
-   vector<SRTSOCKET>* readfds,
-   vector<SRTSOCKET>* writefds,
-   vector<SRTSOCKET>* exceptfds,
-   int64_t msTimeOut)
-{
-   if ((!readfds) && (!writefds) && (!exceptfds))
-   {
-      return APIError(MJ_NOTSUP, MN_INVAL, 0);
-   }
-
-   try
-   {
-      return s_UDTUnited.selectEx(fds, readfds, writefds, exceptfds, msTimeOut);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (bad_alloc&)
-   {
-      return APIError(MJ_SYSTEMRES, MN_MEMORY, 0);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "selectEx: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN);
-   }
-}
-
-int CUDT::epoll_create()
-{
-   try
-   {
-      return s_UDTUnited.epoll_create();
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_create: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_clear_usocks(int eid)
-{
-   try
-   {
-      return s_UDTUnited.epoll_clear_usocks(eid);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_clear_usocks: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_add_usock(const int eid, const SRTSOCKET u, const int* events)
-{
-   try
-   {
-      return s_UDTUnited.epoll_add_usock(eid, u, events);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_add_usock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_add_ssock(const int eid, const SYSSOCKET s, const int* events)
-{
-   try
-   {
-      return s_UDTUnited.epoll_add_ssock(eid, s, events);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_add_ssock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_update_usock(
-   const int eid, const SRTSOCKET u, const int* events)
-{
-   try
-   {
-      return s_UDTUnited.epoll_add_usock(eid, u, events);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_update_usock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_update_ssock(
-   const int eid, const SYSSOCKET s, const int* events)
-{
-   try
-   {
-      return s_UDTUnited.epoll_update_ssock(eid, s, events);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_update_ssock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-
-int CUDT::epoll_remove_usock(const int eid, const SRTSOCKET u)
-{
-   try
-   {
-      return s_UDTUnited.epoll_remove_usock(eid, u);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_remove_usock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_remove_ssock(const int eid, const SYSSOCKET s)
-{
-   try
-   {
-      return s_UDTUnited.epoll_remove_ssock(eid, s);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_remove_ssock: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_wait(
-   const int eid,
-   set<SRTSOCKET>* readfds,
-   set<SRTSOCKET>* writefds,
-   int64_t msTimeOut,
-   set<SYSSOCKET>* lrfds,
-   set<SYSSOCKET>* lwfds)
-{
-   try
-   {
-      return s_UDTUnited.epoll_ref().wait(
-              eid, readfds, writefds, msTimeOut, lrfds, lwfds);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_wait: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_uwait(
-   const int eid,
-   SRT_EPOLL_EVENT* fdsSet,
-   int fdsSize,
-   int64_t msTimeOut)
-{
-   try
-   {
-      return s_UDTUnited.epoll_uwait(eid, fdsSet, fdsSize, msTimeOut);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_uwait: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int32_t CUDT::epoll_set(
-   const int eid,
-   int32_t flags)
-{
-   try
-   {
-      return s_UDTUnited.epoll_set(eid, flags);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_set: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-int CUDT::epoll_release(const int eid)
-{
-   try
-   {
-      return s_UDTUnited.epoll_release(eid);
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "epoll_release: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-CUDTException& CUDT::getlasterror()
-{
-   return GetThreadLocalError();
-}
-
-int CUDT::bstats(SRTSOCKET u, CBytePerfMon* perf, bool clear, bool instantaneous)
-{
-#if ENABLE_EXPERIMENTAL_BONDING
-   if (u & SRTGROUP_MASK)
-       return groupsockbstats(u, perf, clear);
-#endif
-
-   try
-   {
-      CUDT* udt = s_UDTUnited.locateSocket(u, s_UDTUnited.ERH_THROW)->m_pUDT;
-      udt->bstats(perf, clear, instantaneous);
-      return 0;
-   }
-   catch (const CUDTException& e)
-   {
-      return APIError(e);
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "bstats: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      return APIError(MJ_UNKNOWN, MN_NONE, 0);
-   }
-}
-
-#if ENABLE_EXPERIMENTAL_BONDING
-int CUDT::groupsockbstats(SRTSOCKET u, CBytePerfMon* perf, bool clear)
-{
-   try
-   {
-      CUDTUnited::GroupKeeper k(s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-      k.group->bstatsSocket(perf, clear);
-      return 0;
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return ERROR;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "bstats: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return ERROR;
-   }
+    try
+    {
+        CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+        k.group->bstatsSocket(perf, clear);
+        return 0;
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return ERROR;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "bstats: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return ERROR;
+    }
 }
 #endif
 
-CUDT* CUDT::getUDTHandle(SRTSOCKET u)
+srt::CUDT* srt::CUDT::getUDTHandle(SRTSOCKET u)
 {
-   try
-   {
-      return s_UDTUnited.locateSocket(u, s_UDTUnited.ERH_THROW)->m_pUDT;
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return NULL;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "getUDTHandle: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return NULL;
-   }
+    try
+    {
+        return &uglobal().locateSocket(u, CUDTUnited::ERH_THROW)->core();
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return NULL;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "getUDTHandle: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return NULL;
+    }
 }
 
-vector<SRTSOCKET> CUDT::existingSockets()
+vector<SRTSOCKET> srt::CUDT::existingSockets()
 {
     vector<SRTSOCKET> out;
-    for (CUDTUnited::sockets_t::iterator i = s_UDTUnited.m_Sockets.begin();
-            i != s_UDTUnited.m_Sockets.end(); ++i)
+    for (CUDTUnited::sockets_t::iterator i = uglobal().m_Sockets.begin(); i != uglobal().m_Sockets.end(); ++i)
     {
         out.push_back(i->first);
     }
     return out;
 }
 
-SRT_SOCKSTATUS CUDT::getsockstate(SRTSOCKET u)
+SRT_SOCKSTATUS srt::CUDT::getsockstate(SRTSOCKET u)
 {
-   try
-   {
-#if ENABLE_EXPERIMENTAL_BONDING
-      if (isgroup(u))
-      {
-          CUDTUnited::GroupKeeper k(s_UDTUnited, u, s_UDTUnited.ERH_THROW);
-          return k.group->getStatus();
-      }
+    try
+    {
+#if ENABLE_BONDING
+        if (isgroup(u))
+        {
+            CUDTUnited::GroupKeeper k(uglobal(), u, CUDTUnited::ERH_THROW);
+            return k.group->getStatus();
+        }
 #endif
-      return s_UDTUnited.getStatus(u);
-   }
-   catch (const CUDTException& e)
-   {
-      SetThreadLocalError(e);
-      return SRTS_NONEXIST;
-   }
-   catch (const std::exception& ee)
-   {
-      LOGC(aclog.Fatal, log << "getsockstate: UNEXPECTED EXCEPTION: "
-         << typeid(ee).name() << ": " << ee.what());
-      SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
-      return SRTS_NONEXIST;
-   }
+        return uglobal().getStatus(u);
+    }
+    catch (const CUDTException& e)
+    {
+        SetThreadLocalError(e);
+        return SRTS_NONEXIST;
+    }
+    catch (const std::exception& ee)
+    {
+        LOGC(aclog.Fatal, log << "getsockstate: UNEXPECTED EXCEPTION: " << typeid(ee).name() << ": " << ee.what());
+        SetThreadLocalError(CUDTException(MJ_UNKNOWN, MN_NONE, 0));
+        return SRTS_NONEXIST;
+    }
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace UDT
@@ -4279,249 +4434,191 @@ namespace UDT
 
 int startup()
 {
-   return CUDT::startup();
+    return srt::CUDT::startup();
 }
 
 int cleanup()
 {
-   return CUDT::cleanup();
+    return srt::CUDT::cleanup();
 }
 
 int bind(SRTSOCKET u, const struct sockaddr* name, int namelen)
 {
-   return CUDT::bind(u, name, namelen);
+    return srt::CUDT::bind(u, name, namelen);
 }
 
 int bind2(SRTSOCKET u, UDPSOCKET udpsock)
 {
-   return CUDT::bind(u, udpsock);
+    return srt::CUDT::bind(u, udpsock);
 }
 
 int listen(SRTSOCKET u, int backlog)
 {
-   return CUDT::listen(u, backlog);
+    return srt::CUDT::listen(u, backlog);
 }
 
 SRTSOCKET accept(SRTSOCKET u, struct sockaddr* addr, int* addrlen)
 {
-   return CUDT::accept(u, addr, addrlen);
+    return srt::CUDT::accept(u, addr, addrlen);
 }
 
 int connect(SRTSOCKET u, const struct sockaddr* name, int namelen)
 {
-   return CUDT::connect(u, name, namelen, SRT_SEQNO_NONE);
+    return srt::CUDT::connect(u, name, namelen, SRT_SEQNO_NONE);
 }
 
 int close(SRTSOCKET u)
 {
-   return CUDT::close(u);
+    return srt::CUDT::close(u);
 }
 
 int getpeername(SRTSOCKET u, struct sockaddr* name, int* namelen)
 {
-   return CUDT::getpeername(u, name, namelen);
+    return srt::CUDT::getpeername(u, name, namelen);
 }
 
 int getsockname(SRTSOCKET u, struct sockaddr* name, int* namelen)
 {
-   return CUDT::getsockname(u, name, namelen);
+    return srt::CUDT::getsockname(u, name, namelen);
 }
 
-int getsockopt(
-   SRTSOCKET u, int level, SRT_SOCKOPT optname, void* optval, int* optlen)
+int getsockopt(SRTSOCKET u, int level, SRT_SOCKOPT optname, void* optval, int* optlen)
 {
-   return CUDT::getsockopt(u, level, optname, optval, optlen);
+    return srt::CUDT::getsockopt(u, level, optname, optval, optlen);
 }
 
-int setsockopt(
-   SRTSOCKET u, int level, SRT_SOCKOPT optname, const void* optval, int optlen)
+int setsockopt(SRTSOCKET u, int level, SRT_SOCKOPT optname, const void* optval, int optlen)
 {
-   return CUDT::setsockopt(u, level, optname, optval, optlen);
+    return srt::CUDT::setsockopt(u, level, optname, optval, optlen);
 }
 
 // DEVELOPER API
 
-int connect_debug(
-   SRTSOCKET u, const struct sockaddr* name, int namelen, int32_t forced_isn)
+int connect_debug(SRTSOCKET u, const struct sockaddr* name, int namelen, int32_t forced_isn)
 {
-   return CUDT::connect(u, name, namelen, forced_isn);
+    return srt::CUDT::connect(u, name, namelen, forced_isn);
 }
 
 int send(SRTSOCKET u, const char* buf, int len, int flags)
 {
-   return CUDT::send(u, buf, len, flags);
+    return srt::CUDT::send(u, buf, len, flags);
 }
 
 int recv(SRTSOCKET u, char* buf, int len, int flags)
 {
-   return CUDT::recv(u, buf, len, flags);
+    return srt::CUDT::recv(u, buf, len, flags);
 }
 
-
-int sendmsg(
-   SRTSOCKET u, const char* buf, int len, int ttl, bool inorder,
-   int64_t srctime)
+int sendmsg(SRTSOCKET u, const char* buf, int len, int ttl, bool inorder, int64_t srctime)
 {
-   return CUDT::sendmsg(u, buf, len, ttl, inorder, srctime);
+    return srt::CUDT::sendmsg(u, buf, len, ttl, inorder, srctime);
 }
 
 int recvmsg(SRTSOCKET u, char* buf, int len, int64_t& srctime)
 {
-   return CUDT::recvmsg(u, buf, len, srctime);
+    return srt::CUDT::recvmsg(u, buf, len, srctime);
 }
 
 int recvmsg(SRTSOCKET u, char* buf, int len)
 {
-   int64_t srctime;
-   return CUDT::recvmsg(u, buf, len, srctime);
+    int64_t srctime;
+    return srt::CUDT::recvmsg(u, buf, len, srctime);
 }
 
-int64_t sendfile(
-   SRTSOCKET u,
-   fstream& ifs,
-   int64_t& offset,
-   int64_t size,
-   int block)
+int64_t sendfile(SRTSOCKET u, fstream& ifs, int64_t& offset, int64_t size, int block)
 {
-   return CUDT::sendfile(u, ifs, offset, size, block);
+    return srt::CUDT::sendfile(u, ifs, offset, size, block);
 }
 
-int64_t recvfile(
-   SRTSOCKET u,
-   fstream& ofs,
-   int64_t& offset,
-   int64_t size,
-   int block)
+int64_t recvfile(SRTSOCKET u, fstream& ofs, int64_t& offset, int64_t size, int block)
 {
-   return CUDT::recvfile(u, ofs, offset, size, block);
+    return srt::CUDT::recvfile(u, ofs, offset, size, block);
 }
 
-int64_t sendfile2(
-   SRTSOCKET u,
-   const char* path,
-   int64_t* offset,
-   int64_t size,
-   int block)
+int64_t sendfile2(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block)
 {
-   fstream ifs(path, ios::binary | ios::in);
-   int64_t ret = CUDT::sendfile(u, ifs, *offset, size, block);
-   ifs.close();
-   return ret;
+    fstream ifs(path, ios::binary | ios::in);
+    int64_t ret = srt::CUDT::sendfile(u, ifs, *offset, size, block);
+    ifs.close();
+    return ret;
 }
 
-int64_t recvfile2(
-   SRTSOCKET u,
-   const char* path,
-   int64_t* offset,
-   int64_t size,
-   int block)
+int64_t recvfile2(SRTSOCKET u, const char* path, int64_t* offset, int64_t size, int block)
 {
-   fstream ofs(path, ios::binary | ios::out);
-   int64_t ret = CUDT::recvfile(u, ofs, *offset, size, block);
-   ofs.close();
-   return ret;
+    fstream ofs(path, ios::binary | ios::out);
+    int64_t ret = srt::CUDT::recvfile(u, ofs, *offset, size, block);
+    ofs.close();
+    return ret;
 }
 
-int select(
-   int nfds,
-   UDSET* readfds,
-   UDSET* writefds,
-   UDSET* exceptfds,
-   const struct timeval* timeout)
+int select(int nfds, UDSET* readfds, UDSET* writefds, UDSET* exceptfds, const struct timeval* timeout)
 {
-   return CUDT::select(nfds, readfds, writefds, exceptfds, timeout);
+    return srt::CUDT::select(nfds, readfds, writefds, exceptfds, timeout);
 }
 
-int selectEx(
-   const vector<SRTSOCKET>& fds,
-   vector<SRTSOCKET>* readfds,
-   vector<SRTSOCKET>* writefds,
-   vector<SRTSOCKET>* exceptfds,
-   int64_t msTimeOut)
+int selectEx(const vector<SRTSOCKET>& fds,
+             vector<SRTSOCKET>*       readfds,
+             vector<SRTSOCKET>*       writefds,
+             vector<SRTSOCKET>*       exceptfds,
+             int64_t                  msTimeOut)
 {
-   return CUDT::selectEx(fds, readfds, writefds, exceptfds, msTimeOut);
+    return srt::CUDT::selectEx(fds, readfds, writefds, exceptfds, msTimeOut);
 }
 
 int epoll_create()
 {
-   return CUDT::epoll_create();
+    return srt::CUDT::epoll_create();
 }
 
 int epoll_clear_usocks(int eid)
 {
-    return CUDT::epoll_clear_usocks(eid);
+    return srt::CUDT::epoll_clear_usocks(eid);
 }
 
 int epoll_add_usock(int eid, SRTSOCKET u, const int* events)
 {
-   return CUDT::epoll_add_usock(eid, u, events);
+    return srt::CUDT::epoll_add_usock(eid, u, events);
 }
 
 int epoll_add_ssock(int eid, SYSSOCKET s, const int* events)
 {
-   return CUDT::epoll_add_ssock(eid, s, events);
+    return srt::CUDT::epoll_add_ssock(eid, s, events);
 }
 
 int epoll_update_usock(int eid, SRTSOCKET u, const int* events)
 {
-   return CUDT::epoll_update_usock(eid, u, events);
+    return srt::CUDT::epoll_update_usock(eid, u, events);
 }
 
 int epoll_update_ssock(int eid, SYSSOCKET s, const int* events)
 {
-   return CUDT::epoll_update_ssock(eid, s, events);
+    return srt::CUDT::epoll_update_ssock(eid, s, events);
 }
 
 int epoll_remove_usock(int eid, SRTSOCKET u)
 {
-   return CUDT::epoll_remove_usock(eid, u);
+    return srt::CUDT::epoll_remove_usock(eid, u);
 }
 
 int epoll_remove_ssock(int eid, SYSSOCKET s)
 {
-   return CUDT::epoll_remove_ssock(eid, s);
+    return srt::CUDT::epoll_remove_ssock(eid, s);
 }
 
-int epoll_wait(
-   int eid,
-   set<SRTSOCKET>* readfds,
-   set<SRTSOCKET>* writefds,
-   int64_t msTimeOut,
-   set<SYSSOCKET>* lrfds,
-   set<SYSSOCKET>* lwfds)
+int epoll_wait(int             eid,
+               set<SRTSOCKET>* readfds,
+               set<SRTSOCKET>* writefds,
+               int64_t         msTimeOut,
+               set<SYSSOCKET>* lrfds,
+               set<SYSSOCKET>* lwfds)
 {
-   return CUDT::epoll_wait(eid, readfds, writefds, msTimeOut, lrfds, lwfds);
+    return srt::CUDT::epoll_wait(eid, readfds, writefds, msTimeOut, lrfds, lwfds);
 }
 
-/*
-
-#define SET_RESULT(val, num, fds, it) \
-   if (val != NULL) \
-   { \
-      if (val->empty()) \
-      { \
-         if (num) *num = 0; \
-      } \
-      else \
-      { \
-         if (*num > static_cast<int>(val->size())) \
-            *num = val->size(); \
-         int count = 0; \
-         for (it = val->begin(); it != val->end(); ++ it) \
-         { \
-            if (count >= *num) \
-               break; \
-            fds[count ++] = *it; \
-         } \
-      } \
-   }
-
-*/
-
 template <class SOCKTYPE>
 inline void set_result(set<SOCKTYPE>* val, int* num, SOCKTYPE* fds)
 {
-    if ( !val || !num || !fds )
+    if (!val || !num || !fds)
         return;
 
     if (*num > int(val->size()))
@@ -4529,110 +4626,111 @@ inline void set_result(set<SOCKTYPE>* val, int* num, SOCKTYPE* fds)
     int count = 0;
 
     // This loop will run 0 times if val->empty()
-    for (typename set<SOCKTYPE>::const_iterator it = val->begin(); it != val->end(); ++ it)
+    for (typename set<SOCKTYPE>::const_iterator it = val->begin(); it != val->end(); ++it)
     {
         if (count >= *num)
             break;
-        fds[count ++] = *it;
-    }
-}
-
-int epoll_wait2(
-   int eid, SRTSOCKET* readfds,
-   int* rnum, SRTSOCKET* writefds,
-   int* wnum,
-   int64_t msTimeOut,
-   SYSSOCKET* lrfds,
-   int* lrnum,
-   SYSSOCKET* lwfds,
-   int* lwnum)
-{
-   // This API is an alternative format for epoll_wait, created for
-   // compatability with other languages. Users need to pass in an array
-   // for holding the returned sockets, with the maximum array length
-   // stored in *rnum, etc., which will be updated with returned number
-   // of sockets.
-
-   set<SRTSOCKET> readset;
-   set<SRTSOCKET> writeset;
-   set<SYSSOCKET> lrset;
-   set<SYSSOCKET> lwset;
-   set<SRTSOCKET>* rval = NULL;
-   set<SRTSOCKET>* wval = NULL;
-   set<SYSSOCKET>* lrval = NULL;
-   set<SYSSOCKET>* lwval = NULL;
-   if ((readfds != NULL) && (rnum != NULL))
-      rval = &readset;
-   if ((writefds != NULL) && (wnum != NULL))
-      wval = &writeset;
-   if ((lrfds != NULL) && (lrnum != NULL))
-      lrval = &lrset;
-   if ((lwfds != NULL) && (lwnum != NULL))
-      lwval = &lwset;
-
-   int ret = CUDT::epoll_wait(eid, rval, wval, msTimeOut, lrval, lwval);
-   if (ret > 0)
-   {
-      //set<SRTSOCKET>::const_iterator i;
-      //SET_RESULT(rval, rnum, readfds, i);
-      set_result(rval, rnum, readfds);
-      //SET_RESULT(wval, wnum, writefds, i);
-      set_result(wval, wnum, writefds);
-
-      //set<SYSSOCKET>::const_iterator j;
-      //SET_RESULT(lrval, lrnum, lrfds, j);
-      set_result(lrval, lrnum, lrfds);
-      //SET_RESULT(lwval, lwnum, lwfds, j);
-      set_result(lwval, lwnum, lwfds);
-   }
-   return ret;
+        fds[count++] = *it;
+    }
+}
+
+int epoll_wait2(int        eid,
+                SRTSOCKET* readfds,
+                int*       rnum,
+                SRTSOCKET* writefds,
+                int*       wnum,
+                int64_t    msTimeOut,
+                SYSSOCKET* lrfds,
+                int*       lrnum,
+                SYSSOCKET* lwfds,
+                int*       lwnum)
+{
+    // This API is an alternative format for epoll_wait, created for
+    // compatibility with other languages. Users need to pass in an array
+    // for holding the returned sockets, with the maximum array length
+    // stored in *rnum, etc., which will be updated with returned number
+    // of sockets.
+
+    set<SRTSOCKET>  readset;
+    set<SRTSOCKET>  writeset;
+    set<SYSSOCKET>  lrset;
+    set<SYSSOCKET>  lwset;
+    set<SRTSOCKET>* rval  = NULL;
+    set<SRTSOCKET>* wval  = NULL;
+    set<SYSSOCKET>* lrval = NULL;
+    set<SYSSOCKET>* lwval = NULL;
+    if ((readfds != NULL) && (rnum != NULL))
+        rval = &readset;
+    if ((writefds != NULL) && (wnum != NULL))
+        wval = &writeset;
+    if ((lrfds != NULL) && (lrnum != NULL))
+        lrval = &lrset;
+    if ((lwfds != NULL) && (lwnum != NULL))
+        lwval = &lwset;
+
+    int ret = srt::CUDT::epoll_wait(eid, rval, wval, msTimeOut, lrval, lwval);
+    if (ret > 0)
+    {
+        // set<SRTSOCKET>::const_iterator i;
+        // SET_RESULT(rval, rnum, readfds, i);
+        set_result(rval, rnum, readfds);
+        // SET_RESULT(wval, wnum, writefds, i);
+        set_result(wval, wnum, writefds);
+
+        // set<SYSSOCKET>::const_iterator j;
+        // SET_RESULT(lrval, lrnum, lrfds, j);
+        set_result(lrval, lrnum, lrfds);
+        // SET_RESULT(lwval, lwnum, lwfds, j);
+        set_result(lwval, lwnum, lwfds);
+    }
+    return ret;
 }
 
 int epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut)
 {
-   return CUDT::epoll_uwait(eid, fdsSet, fdsSize, msTimeOut);
+    return srt::CUDT::epoll_uwait(eid, fdsSet, fdsSize, msTimeOut);
 }
 
 int epoll_release(int eid)
 {
-   return CUDT::epoll_release(eid);
+    return srt::CUDT::epoll_release(eid);
 }
 
 ERRORINFO& getlasterror()
 {
-   return CUDT::getlasterror();
+    return srt::CUDT::getlasterror();
 }
 
 int getlasterror_code()
 {
-   return CUDT::getlasterror().getErrorCode();
+    return srt::CUDT::getlasterror().getErrorCode();
 }
 
 const char* getlasterror_desc()
 {
-   return CUDT::getlasterror().getErrorMessage();
+    return srt::CUDT::getlasterror().getErrorMessage();
 }
 
 int getlasterror_errno()
 {
-   return CUDT::getlasterror().getErrno();
+    return srt::CUDT::getlasterror().getErrno();
 }
 
 // Get error string of a given error code
 const char* geterror_desc(int code, int err)
 {
-   CUDTException e (CodeMajor(code/1000), CodeMinor(code%1000), err);
-   return(e.getErrorMessage());
+    srt::CUDTException e(CodeMajor(code / 1000), CodeMinor(code % 1000), err);
+    return (e.getErrorMessage());
 }
 
 int bstats(SRTSOCKET u, SRT_TRACEBSTATS* perf, bool clear)
 {
-   return CUDT::bstats(u, perf, clear);
+    return srt::CUDT::bstats(u, perf, clear);
 }
 
 SRT_SOCKSTATUS getsockstate(SRTSOCKET u)
 {
-   return CUDT::getsockstate(u);
+    return srt::CUDT::getsockstate(u);
 }
 
 } // namespace UDT
@@ -4683,7 +4781,7 @@ void setloghandler(void* opaque, SRT_LOG_HANDLER_FN* handler)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.loghandler_opaque = opaque;
-    srt_logger_config.loghandler_fn = handler;
+    srt_logger_config.loghandler_fn     = handler;
 }
 
 void setlogflags(int flags)
@@ -4711,4 +4809,4 @@ int setrejectreason(SRTSOCKET u, int value)
     return CUDT::rejectReason(u, value);
 }
 
-}  // namespace srt
+} // namespace srt
diff --git a/srtcore/api.h b/srtcore/api.h
index 8ad6bb3fd..48e7827f8 100644
--- a/srtcore/api.h
+++ b/srtcore/api.h
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -45,15 +45,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /*****************************************************************************
 written by
-   Yunhong Gu, last updated 09/28/2010
+    Yunhong Gu, last updated 09/28/2010
 modified by
-   Haivision Systems Inc.
+    Haivision Systems Inc.
 *****************************************************************************/
 
 #ifndef INC_SRT_API_H
 #define INC_SRT_API_H
 
-
 #include <map>
 #include <vector>
 #include <string>
@@ -65,379 +64,506 @@ modified by
 #include "epoll.h"
 #include "handshake.h"
 #include "core.h"
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 #include "group.h"
 #endif
 
 // Please refer to structure and locking information provided in the
-// LowLevelInfo.md document.
+// docs/dev/low-level-info.md document.
+
+namespace srt
+{
 
 class CUDT;
 
+/// @brief Class CUDTSocket is a control layer on top of the CUDT core functionality layer.
+/// CUDTSocket owns CUDT.
 class CUDTSocket
 {
 public:
-   CUDTSocket()
-       : m_Status(SRTS_INIT)
-       , m_SocketID(0)
-       , m_ListenSocket(0)
-       , m_PeerID(0)
-#if ENABLE_EXPERIMENTAL_BONDING
-       , m_IncludedGroup()
+    CUDTSocket()
+        : m_Status(SRTS_INIT)
+        , m_SocketID(0)
+        , m_ListenSocket(0)
+        , m_PeerID(0)
+#if ENABLE_BONDING
+        , m_GroupMemberData()
+        , m_GroupOf()
 #endif
-       , m_iISN(0)
-       , m_pUDT(NULL)
-       , m_pQueuedSockets(NULL)
-       , m_pAcceptSockets(NULL)
-       , m_AcceptCond()
-       , m_AcceptLock()
-       , m_uiBackLog(0)
-       , m_iMuxID(-1)
-   {
-       construct();
-   }
-
-   ~CUDTSocket();
-
-   void construct();
-
-   SRT_SOCKSTATUS m_Status;                  //< current socket state
-
-   /// Time when the socket is closed.
-   /// When the socket is closed, it is not removed immediately from the list
-   /// of sockets in order to prevent other methods from accessing invalid address.
-   /// A timer is started and the socket will be removed after approximately
-   /// 1 second (see CUDTUnited::checkBrokenSockets()).
-   srt::sync::steady_clock::time_point m_tsClosureTimeStamp;
-
-   sockaddr_any m_SelfAddr;                    //< local address of the socket
-   sockaddr_any m_PeerAddr;                    //< peer address of the socket
-
-   SRTSOCKET m_SocketID;                     //< socket ID
-   SRTSOCKET m_ListenSocket;                 //< ID of the listener socket; 0 means this is an independent socket
-
-   SRTSOCKET m_PeerID;                       //< peer socket ID
-#if ENABLE_EXPERIMENTAL_BONDING
-   CUDTGroup::gli_t m_IncludedIter;          //< Container's iterator of the group to which it belongs, or gli_NULL() if it isn't
-   CUDTGroup* m_IncludedGroup;               //< Group this socket is a member of, or NULL if it isn't
+        , m_iISN(0)
+        , m_UDT(this)
+        , m_AcceptCond()
+        , m_AcceptLock()
+        , m_uiBackLog(0)
+        , m_iMuxID(-1)
+    {
+        construct();
+    }
+
+    CUDTSocket(const CUDTSocket& ancestor)
+        : m_Status(SRTS_INIT)
+        , m_SocketID(0)
+        , m_ListenSocket(0)
+        , m_PeerID(0)
+#if ENABLE_BONDING
+        , m_GroupMemberData()
+        , m_GroupOf()
 #endif
+        , m_iISN(0)
+        , m_UDT(this, ancestor.m_UDT)
+        , m_AcceptCond()
+        , m_AcceptLock()
+        , m_uiBackLog(0)
+        , m_iMuxID(-1)
+    {
+        construct();
+    }
 
-   int32_t m_iISN;                           //< initial sequence number, used to tell different connection from same IP:port
-
-   CUDT* m_pUDT;                             //< pointer to the UDT entity
-
-   std::set<SRTSOCKET>* m_pQueuedSockets;    //< set of connections waiting for accept()
-   std::set<SRTSOCKET>* m_pAcceptSockets;    //< set of accept()ed connections
+    ~CUDTSocket();
 
-   srt::sync::Condition m_AcceptCond;        //< used to block "accept" call
-   srt::sync::Mutex m_AcceptLock;            //< mutex associated to m_AcceptCond
+    void construct();
 
-   unsigned int m_uiBackLog;                 //< maximum number of connections in queue
-
-   // XXX A refactoring might be needed here.
+private:
+    srt::sync::atomic<int> m_iBusy;
+public:
+    void apiAcquire() { ++m_iBusy; }
+    void apiRelease() { --m_iBusy; }
 
-   // There are no reasons found why the socket can't contain a list iterator to a
-   // multiplexer INSTEAD of m_iMuxID. There's no danger in this solution because
-   // the multiplexer is never deleted until there's at least one socket using it.
-   //
-   // The multiplexer may even physically be contained in the CUDTUnited object,
-   // just track the multiple users of it (the listener and the accepted sockets).
-   // When deleting, you simply "unsubscribe" yourself from the multiplexer, which
-   // will unref it and remove the list element by the iterator kept by the
-   // socket.
-   int m_iMuxID;                             //< multiplexer ID
+    int isStillBusy() const
+    {
+        return m_iBusy;
+    }
 
-   srt::sync::Mutex m_ControlLock;           //< lock this socket exclusively for control APIs: bind/listen/connect
 
-   CUDT& core() { return *m_pUDT; }
+    SRT_ATTR_GUARDED_BY(m_ControlLock)
+    sync::atomic<SRT_SOCKSTATUS> m_Status; //< current socket state
 
-   static int64_t getPeerSpec(SRTSOCKET id, int32_t isn)
-   {
-       return (int64_t(id) << 30) + isn;
-   }
-   int64_t getPeerSpec()
-   {
-       return getPeerSpec(m_PeerID, m_iISN);
-   }
+    /// Time when the socket is closed.
+    /// When the socket is closed, it is not removed immediately from the list
+    /// of sockets in order to prevent other methods from accessing invalid address.
+    /// A timer is started and the socket will be removed after approximately
+    /// 1 second (see CUDTUnited::checkBrokenSockets()).
+    //sync::steady_clock::time_point m_tsClosureTimeStamp;
+    sync::AtomicClock<sync::steady_clock> m_tsClosureTimeStamp;
 
-   SRT_SOCKSTATUS getStatus();
+    sockaddr_any m_SelfAddr; //< local address of the socket
+    sockaddr_any m_PeerAddr; //< peer address of the socket
 
-   /// This function shall be called always wherever
-   /// you'd like to call cudtsocket->m_pUDT->close(),
-   /// from within the GC thread only (that is, only when
-   /// the socket should be no longer visible in the
-   /// connection, including for sending remaining data).
-   void breakSocket_LOCKED();
+    SRTSOCKET m_SocketID;     //< socket ID
+    SRTSOCKET m_ListenSocket; //< ID of the listener socket; 0 means this is an independent socket
 
+    SRTSOCKET m_PeerID; //< peer socket ID
+#if ENABLE_BONDING
+    groups::SocketData* m_GroupMemberData; //< Pointer to group member data, or NULL if not a group member
+    CUDTGroup*          m_GroupOf;         //< Group this socket is a member of, or NULL if it isn't
+#endif
 
-   /// This makes the socket no longer capable of performing any transmission
-   /// operation, but continues to be responsive in the connection in order
-   /// to finish sending the data that were scheduled for sending so far.
-   void setClosed();
+    int32_t m_iISN; //< initial sequence number, used to tell different connection from same IP:port
 
-   /// This does the same as setClosed, plus sets the m_bBroken to true.
-   /// Such a socket can still be read from so that remaining data from
-   /// the receiver buffer can be read, but no longer sends anything.
-   void setBrokenClosed();
-   void removeFromGroup(bool broken);
+private:
+    CUDT m_UDT; //< internal SRT socket logic
 
-   // Instrumentally used by select() and also required for non-blocking
-   // mode check in groups
-   bool readReady();
-   bool writeReady();
-   bool broken();
+public:
+    std::map<SRTSOCKET, sockaddr_any> m_QueuedSockets; //< set of connections waiting for accept()
+
+    sync::Condition m_AcceptCond; //< used to block "accept" call
+    sync::Mutex     m_AcceptLock; //< mutex associated to m_AcceptCond
+
+    unsigned int m_uiBackLog; //< maximum number of connections in queue
+
+    // XXX A refactoring might be needed here.
+
+    // There are no reasons found why the socket can't contain a list iterator to a
+    // multiplexer INSTEAD of m_iMuxID. There's no danger in this solution because
+    // the multiplexer is never deleted until there's at least one socket using it.
+    //
+    // The multiplexer may even physically be contained in the CUDTUnited object,
+    // just track the multiple users of it (the listener and the accepted sockets).
+    // When deleting, you simply "unsubscribe" yourself from the multiplexer, which
+    // will unref it and remove the list element by the iterator kept by the
+    // socket.
+    int m_iMuxID; //< multiplexer ID
+
+    sync::Mutex m_ControlLock; //< lock this socket exclusively for control APIs: bind/listen/connect
+
+    CUDT&       core() { return m_UDT; }
+    const CUDT& core() const { return m_UDT; }
+
+    static int64_t getPeerSpec(SRTSOCKET id, int32_t isn) { return (int64_t(id) << 30) + isn; }
+    int64_t        getPeerSpec() { return getPeerSpec(m_PeerID, m_iISN); }
+
+    SRT_SOCKSTATUS getStatus();
+
+    /// This function shall be called always wherever
+    /// you'd like to call cudtsocket->m_pUDT->close(),
+    /// from within the GC thread only (that is, only when
+    /// the socket should be no longer visible in the
+    /// connection, including for sending remaining data).
+    void breakSocket_LOCKED();
+
+    /// This makes the socket no longer capable of performing any transmission
+    /// operation, but continues to be responsive in the connection in order
+    /// to finish sending the data that were scheduled for sending so far.
+    void setClosed();
+
+    // This is necessary to be called from the group before the group clears
+    // the connection with the socket. As for managed groups (and there are
+    // currently no other group types), a socket disconnected from the group
+    // is no longer usable.
+    void setClosing()
+    {
+        core().m_bClosing = true;
+    }
+
+    /// This does the same as setClosed, plus sets the m_bBroken to true.
+    /// Such a socket can still be read from so that remaining data from
+    /// the receiver buffer can be read, but no longer sends anything.
+    void setBrokenClosed();
+    void removeFromGroup(bool broken);
+
+    // Instrumentally used by select() and also required for non-blocking
+    // mode check in groups
+    bool readReady();
+    bool writeReady() const;
+    bool broken() const;
 
 private:
-   CUDTSocket(const CUDTSocket&);
-   CUDTSocket& operator=(const CUDTSocket&);
+    CUDTSocket& operator=(const CUDTSocket&);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class CUDTUnited
 {
-friend class CUDT;
-friend class CUDTGroup;
-friend class CRendezvousQueue;
-
-public:
-   CUDTUnited();
-   ~CUDTUnited();
+    friend class CUDT;
+    friend class CUDTGroup;
+    friend class CRendezvousQueue;
+    friend class CCryptoControl;
 
 public:
+    CUDTUnited();
+    ~CUDTUnited();
 
-   enum ErrorHandling { ERH_RETURN, ERH_THROW, ERH_ABORT };
-   static std::string CONID(SRTSOCKET sock);
-
-      /// initialize the UDT library.
-      /// @return 0 if success, otherwise -1 is returned.
-
-   int startup();
-
-      /// release the UDT library.
-      /// @return 0 if success, otherwise -1 is returned.
-
-   int cleanup();
-
-      /// Create a new UDT socket.
-      /// @param [out] pps Variable (optional) to which the new socket will be written, if succeeded
-      /// @return The new UDT socket ID, or INVALID_SOCK.
-
-   SRTSOCKET newSocket(CUDTSocket** pps = NULL);
+    // Public constants
+    static const int32_t MAX_SOCKET_VAL = SRTGROUP_MASK - 1; // maximum value for a regular socket
 
-      /// Create a new UDT connection.
-      /// @param [in] listen the listening UDT socket;
-      /// @param [in] peer peer address.
-      /// @param [in,out] hs handshake information from peer side (in), negotiated value (out);
-      /// @param [out] w_error error code when failed
-      /// @param [out] w_acpu entity of accepted socket, if connection already exists
-      /// @return If the new connection is successfully created: 1 success, 0 already exist, -1 error.
-
-   int newConnection(const SRTSOCKET listen, const sockaddr_any& peer, const CPacket& hspkt,
-           CHandShake& w_hs, int& w_error, CUDT*& w_acpu);
-
-   int installAcceptHook(const SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq);
-   int installConnectHook(const SRTSOCKET lsn, srt_connect_callback_fn* hook, void* opaq);
-
-      /// Check the status of the UDT socket.
-      /// @param [in] u the UDT socket ID.
-      /// @return UDT socket status, or NONEXIST if not found.
-
-   SRT_SOCKSTATUS getStatus(const SRTSOCKET u);
-
-      // socket APIs
-
-   int bind(CUDTSocket* u, const sockaddr_any& name);
-   int bind(CUDTSocket* u, UDPSOCKET udpsock);
-   int listen(const SRTSOCKET u, int backlog);
-   SRTSOCKET accept(const SRTSOCKET listen, sockaddr* addr, int* addrlen);
-   SRTSOCKET accept_bond(const SRTSOCKET listeners [], int lsize, int64_t msTimeOut);
-   int connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* tarname, int tarlen);
-   int connect(const SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn);
-   int connectIn(CUDTSocket* s, const sockaddr_any& target, int32_t forced_isn);
-#if ENABLE_EXPERIMENTAL_BONDING
-   int groupConnect(CUDTGroup* g, SRT_SOCKGROUPCONFIG targets [], int arraysize);
-   int singleMemberConnect(CUDTGroup* g, SRT_SOCKGROUPCONFIG* target);
+public:
+    enum ErrorHandling
+    {
+        ERH_RETURN,
+        ERH_THROW,
+        ERH_ABORT
+    };
+    static std::string CONID(SRTSOCKET sock);
+
+    /// initialize the UDT library.
+    /// @return 0 if success, otherwise -1 is returned.
+    int startup();
+
+    /// release the UDT library.
+    /// @return 0 if success, otherwise -1 is returned.
+    int cleanup();
+
+    /// Create a new UDT socket.
+    /// @param [out] pps Variable (optional) to which the new socket will be written, if succeeded
+    /// @return The new UDT socket ID, or INVALID_SOCK.
+    SRTSOCKET newSocket(CUDTSocket** pps = NULL);
+
+    /// Create (listener-side) a new socket associated with the incoming connection request.
+    /// @param [in] listen the listening socket ID.
+    /// @param [in] peer peer address.
+    /// @param [in,out] hs handshake information from peer side (in), negotiated value (out);
+    /// @param [out] w_error error code in case of failure.
+    /// @param [out] w_acpu reference to the existing associated socket if already exists.
+    /// @return  1: if the new connection was successfully created (accepted), @a w_acpu is NULL;
+    ///          0: the connection already exists (reference to the corresponding socket is returned in @a w_acpu).
+    ///         -1: The connection processing failed due to memory alloation error, exceeding listener's backlog,
+    ///             any error propagated from CUDT::open and CUDT::acceptAndRespond.
+    int newConnection(const SRTSOCKET     listen,
+                      const sockaddr_any& peer,
+                      const CPacket&      hspkt,
+                      CHandShake&         w_hs,
+                      int&                w_error,
+                      CUDT*&              w_acpu);
+
+    int installAcceptHook(const SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq);
+    int installConnectHook(const SRTSOCKET lsn, srt_connect_callback_fn* hook, void* opaq);
+
+    /// Check the status of the UDT socket.
+    /// @param [in] u the UDT socket ID.
+    /// @return UDT socket status, or NONEXIST if not found.
+    SRT_SOCKSTATUS getStatus(const SRTSOCKET u);
+
+    // socket APIs
+
+    int       bind(CUDTSocket* u, const sockaddr_any& name);
+    int       bind(CUDTSocket* u, UDPSOCKET udpsock);
+    int       listen(const SRTSOCKET u, int backlog);
+    SRTSOCKET accept(const SRTSOCKET listen, sockaddr* addr, int* addrlen);
+    SRTSOCKET accept_bond(const SRTSOCKET listeners[], int lsize, int64_t msTimeOut);
+    int       connect(SRTSOCKET u, const sockaddr* srcname, const sockaddr* tarname, int tarlen);
+    int       connect(const SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn);
+    int       connectIn(CUDTSocket* s, const sockaddr_any& target, int32_t forced_isn);
+#if ENABLE_BONDING
+    int groupConnect(CUDTGroup* g, SRT_SOCKGROUPCONFIG targets[], int arraysize);
+    int singleMemberConnect(CUDTGroup* g, SRT_SOCKGROUPCONFIG* target);
 #endif
-   int close(const SRTSOCKET u);
-   int close(CUDTSocket* s);
-   void getpeername(const SRTSOCKET u, sockaddr* name, int* namelen);
-   void getsockname(const SRTSOCKET u, sockaddr* name, int* namelen);
-   int select(UDT::UDSET* readfds, UDT::UDSET* writefds, UDT::UDSET* exceptfds, const timeval* timeout);
-   int selectEx(const std::vector<SRTSOCKET>& fds, std::vector<SRTSOCKET>* readfds, std::vector<SRTSOCKET>* writefds, std::vector<SRTSOCKET>* exceptfds, int64_t msTimeOut);
-   int epoll_create();
-   int epoll_clear_usocks(int eid);
-   int epoll_add_usock(const int eid, const SRTSOCKET u, const int* events = NULL);
-   int epoll_add_usock_INTERNAL(const int eid, CUDTSocket* s, const int* events);
-   int epoll_add_ssock(const int eid, const SYSSOCKET s, const int* events = NULL);
-   int epoll_remove_usock(const int eid, const SRTSOCKET u);
-   template <class EntityType>
-   int epoll_remove_entity(const int eid, EntityType* ent);
-   int epoll_remove_socket_INTERNAL(const int eid, CUDTSocket* ent);
-#if ENABLE_EXPERIMENTAL_BONDING
-   int epoll_remove_group_INTERNAL(const int eid, CUDTGroup* ent);
+    int  close(const SRTSOCKET u);
+    int  close(CUDTSocket* s);
+    void getpeername(const SRTSOCKET u, sockaddr* name, int* namelen);
+    void getsockname(const SRTSOCKET u, sockaddr* name, int* namelen);
+    int  select(UDT::UDSET* readfds, UDT::UDSET* writefds, UDT::UDSET* exceptfds, const timeval* timeout);
+    int  selectEx(const std::vector<SRTSOCKET>& fds,
+                  std::vector<SRTSOCKET>*       readfds,
+                  std::vector<SRTSOCKET>*       writefds,
+                  std::vector<SRTSOCKET>*       exceptfds,
+                  int64_t                       msTimeOut);
+    int  epoll_create();
+    int  epoll_clear_usocks(int eid);
+    int  epoll_add_usock(const int eid, const SRTSOCKET u, const int* events = NULL);
+    int  epoll_add_usock_INTERNAL(const int eid, CUDTSocket* s, const int* events);
+    int  epoll_add_ssock(const int eid, const SYSSOCKET s, const int* events = NULL);
+    int  epoll_remove_usock(const int eid, const SRTSOCKET u);
+    template <class EntityType>
+    int epoll_remove_entity(const int eid, EntityType* ent);
+    int epoll_remove_socket_INTERNAL(const int eid, CUDTSocket* ent);
+#if ENABLE_BONDING
+    int epoll_remove_group_INTERNAL(const int eid, CUDTGroup* ent);
 #endif
-   int epoll_remove_ssock(const int eid, const SYSSOCKET s);
-   int epoll_update_ssock(const int eid, const SYSSOCKET s, const int* events = NULL);
-   int epoll_uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
-   int32_t epoll_set(const int eid, int32_t flags);
-   int epoll_release(const int eid);
-
-#if ENABLE_EXPERIMENTAL_BONDING
-   // [[using locked(m_GlobControlLock)]]
-   CUDTGroup& addGroup(SRTSOCKET id, SRT_GROUP_TYPE type)
-   {
-       // This only ensures that the element exists.
-       // If the element was newly added, it will be NULL.
-       CUDTGroup*& g = m_Groups[id];
-       if (!g)
-       {
-           // This is a reference to the cell, so it will
-           // rewrite it into the map.
-           g = new CUDTGroup(type);
-       }
-
-       // Now we are sure that g is not NULL,
-       // and persistence of this object is in the map.
-       // The reference to the object can be safely returned here.
-       return *g;
-   }
-
-   void deleteGroup(CUDTGroup* g);
-
-   // [[using locked(m_GlobControlLock)]]
-   CUDTGroup* findPeerGroup_LOCKED(SRTSOCKET peergroup)
-   {
-       for (groups_t::iterator i = m_Groups.begin();
-               i != m_Groups.end(); ++i)
-       {
-           if (i->second->peerid() == peergroup)
-               return i->second;
-       }
-       return NULL;
-   }
+    int     epoll_remove_ssock(const int eid, const SYSSOCKET s);
+    int     epoll_update_ssock(const int eid, const SYSSOCKET s, const int* events = NULL);
+    int     epoll_uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
+    int32_t epoll_set(const int eid, int32_t flags);
+    int     epoll_release(const int eid);
+
+#if ENABLE_BONDING
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_GlobControlLock)
+    CUDTGroup& addGroup(SRTSOCKET id, SRT_GROUP_TYPE type)
+    {
+        // This only ensures that the element exists.
+        // If the element was newly added, it will be NULL.
+        CUDTGroup*& g = m_Groups[id];
+        if (!g)
+        {
+            // This is a reference to the cell, so it will
+            // rewrite it into the map.
+            g = new CUDTGroup(type);
+        }
+
+        // Now we are sure that g is not NULL,
+        // and persistence of this object is in the map.
+        // The reference to the object can be safely returned here.
+        return *g;
+    }
+
+    void deleteGroup(CUDTGroup* g);
+    void deleteGroup_LOCKED(CUDTGroup* g);
+
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_GlobControlLock)
+    CUDTGroup* findPeerGroup_LOCKED(SRTSOCKET peergroup)
+    {
+        for (groups_t::iterator i = m_Groups.begin(); i != m_Groups.end(); ++i)
+        {
+            if (i->second->peerid() == peergroup)
+                return i->second;
+        }
+        return NULL;
+    }
 #endif
 
-   CEPoll& epoll_ref() { return m_EPoll; }
+    CEPoll& epoll_ref() { return m_EPoll; }
 
 private:
-//   void init();
-
-   /// Generates a new socket ID. This function starts from a randomly
-   /// generated value (at initialization time) and goes backward with
-   /// with next calls. The possible values come from the range without
-   /// the SRTGROUP_MASK bit, and the group bit is set when the ID is
-   /// generated for groups. It is also internally checked if the
-   /// newly generated ID isn't already used by an existing socket or group.
-   ///
-   /// @param group The socket id should be for socket group.
-   /// @return The new socket ID.
-   /// @throw CUDTException if after rolling over all possible ID values nothing can be returned
-   SRTSOCKET generateSocketID(bool group = false);
+    /// Generates a new socket ID. This function starts from a randomly
+    /// generated value (at initialization time) and goes backward with
+    /// with next calls. The possible values come from the range without
+    /// the SRTGROUP_MASK bit, and the group bit is set when the ID is
+    /// generated for groups. It is also internally checked if the
+    /// newly generated ID isn't already used by an existing socket or group.
+    ///
+    /// Socket ID value range.
+    /// - [0]: reserved for handshake procedure. If the destination Socket ID is 0
+    ///   (destination Socket ID unknown) the packet will be sent to the listening socket
+    ///   or to a socket that is in the rendezvous connection phase.
+    /// - [1; 2 ^ 30): single socket ID range.
+    /// - (2 ^ 30; 2 ^ 31): group socket ID range. Effectively any positive number
+    ///   from [1; 2 ^ 30) with bit 30 set to 1. Bit 31 is zero.
+    /// The most significant bit 31 (sign bit) is left unused so that checking for a value <= 0 identifies an invalid
+    /// socket ID.
+    ///
+    /// @param group The socket id should be for socket group.
+    /// @return The new socket ID.
+    /// @throw CUDTException if after rolling over all possible ID values nothing can be returned
+    SRTSOCKET generateSocketID(bool group = false);
 
 private:
-   typedef std::map<SRTSOCKET, CUDTSocket*> sockets_t;       // stores all the socket structures
-   sockets_t m_Sockets;
-
-#if ENABLE_EXPERIMENTAL_BONDING
-   typedef std::map<SRTSOCKET, CUDTGroup*> groups_t;
-   groups_t m_Groups;
+    typedef std::map<SRTSOCKET, CUDTSocket*> sockets_t; // stores all the socket structures
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    sockets_t m_Sockets;
+
+#if ENABLE_BONDING
+    typedef std::map<SRTSOCKET, CUDTGroup*> groups_t;
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    groups_t m_Groups;
 #endif
 
-   srt::sync::Mutex m_GlobControlLock;               // used to synchronize UDT API
+    sync::Mutex m_GlobControlLock; // used to synchronize UDT API
 
-   srt::sync::Mutex m_IDLock;                        // used to synchronize ID generation
+    sync::Mutex m_IDLock; // used to synchronize ID generation
 
-   static const int32_t MAX_SOCKET_VAL = 1 << 29;    // maximum value for a regular socket
+    SRTSOCKET m_SocketIDGenerator;      // seed to generate a new unique socket ID
+    SRTSOCKET m_SocketIDGenerator_init; // Keeps track of the very first one
 
-   SRTSOCKET m_SocketIDGenerator;                    // seed to generate a new unique socket ID
-   SRTSOCKET m_SocketIDGenerator_init;               // Keeps track of the very first one
-
-   std::map<int64_t, std::set<SRTSOCKET> > m_PeerRec;// record sockets from peers to avoid repeated connection request, int64_t = (socker_id << 30) + isn
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    std::map<int64_t, std::set<SRTSOCKET> >
+        m_PeerRec; // record sockets from peers to avoid repeated connection request, int64_t = (socker_id << 30) + isn
 
 private:
-   friend struct FLookupSocketWithEvent_LOCKED;
-
-   CUDTSocket* locateSocket(SRTSOCKET u, ErrorHandling erh = ERH_RETURN);
-   // This function does the same as locateSocket, except that:
-   // - lock on m_GlobControlLock is expected (so that you don't unlock between finding and using)
-   // - only return NULL if not found
-   CUDTSocket* locateSocket_LOCKED(SRTSOCKET u);
-   CUDTSocket* locatePeer(const sockaddr_any& peer, const SRTSOCKET id, int32_t isn);
-
-#if ENABLE_EXPERIMENTAL_BONDING
-   CUDTGroup* locateAcquireGroup(SRTSOCKET u, ErrorHandling erh = ERH_RETURN);
-   CUDTGroup* acquireSocketsGroup(CUDTSocket* s);
-
-   struct GroupKeeper
-   {
-       CUDTGroup* group;
-
-       // This is intended for API functions to lock the group's existence
-       // for the lifetime of their call.
-       GroupKeeper(CUDTUnited& glob, SRTSOCKET id, ErrorHandling erh)
-       {
-           group = glob.locateAcquireGroup(id, erh);
-       }
-
-       // This is intended for TSBPD thread that should lock the group's
-       // existence until it exits.
-       GroupKeeper(CUDTUnited& glob, CUDTSocket* s)
-       {
-           group = glob.acquireSocketsGroup(s);
-       }
-
-       ~GroupKeeper()
-       {
-           if (group)
-           {
-               // We have a guarantee that if `group` was set
-               // as non-NULL here, it is also acquired and will not
-               // be deleted until this busy flag is set back to false.
-               srt::sync::ScopedLock cgroup (*group->exp_groupLock());
-               group->apiRelease();
-               // Only now that the group lock is lifted, can the
-               // group be now deleted and this pointer potentially dangling
-           }
-       }
-   };
-
+    friend struct FLookupSocketWithEvent_LOCKED;
+
+    CUDTSocket* locateSocket(SRTSOCKET u, ErrorHandling erh = ERH_RETURN);
+    // This function does the same as locateSocket, except that:
+    // - lock on m_GlobControlLock is expected (so that you don't unlock between finding and using)
+    // - only return NULL if not found
+    CUDTSocket* locateSocket_LOCKED(SRTSOCKET u);
+    CUDTSocket* locatePeer(const sockaddr_any& peer, const SRTSOCKET id, int32_t isn);
+
+#if ENABLE_BONDING
+    CUDTGroup* locateAcquireGroup(SRTSOCKET u, ErrorHandling erh = ERH_RETURN);
+    CUDTGroup* acquireSocketsGroup(CUDTSocket* s);
+
+    struct GroupKeeper
+    {
+        CUDTGroup* group;
+
+        // This is intended for API functions to lock the group's existence
+        // for the lifetime of their call.
+        GroupKeeper(CUDTUnited& glob, SRTSOCKET id, ErrorHandling erh) { group = glob.locateAcquireGroup(id, erh); }
+
+        // This is intended for TSBPD thread that should lock the group's
+        // existence until it exits.
+        GroupKeeper(CUDTUnited& glob, CUDTSocket* s) { group = glob.acquireSocketsGroup(s); }
+
+        ~GroupKeeper()
+        {
+            if (group)
+            {
+                // We have a guarantee that if `group` was set
+                // as non-NULL here, it is also acquired and will not
+                // be deleted until this busy flag is set back to false.
+                sync::ScopedLock cgroup(*group->exp_groupLock());
+                group->apiRelease();
+                // Only now that the group lock is lifted, can the
+                // group be now deleted and this pointer potentially dangling
+            }
+        }
+    };
 #endif
-   void updateMux(CUDTSocket* s, const sockaddr_any& addr, const UDPSOCKET* = NULL);
-   bool updateListenerMux(CUDTSocket* s, const CUDTSocket* ls);
 
-private:
-   std::map<int, CMultiplexer> m_mMultiplexer;		// UDP multiplexer
-   srt::sync::Mutex            m_MultiplexerLock;
+    CUDTSocket* locateAcquireSocket(SRTSOCKET u, ErrorHandling erh = ERH_RETURN);
+    bool acquireSocket(CUDTSocket* s);
 
-private:
-   CCache<CInfoBlock>* m_pCache;			// UDT network information cache
+public:
+    struct SocketKeeper
+    {
+        CUDTSocket* socket;
+
+        SocketKeeper(): socket(NULL) {}
+
+        // This is intended for API functions to lock the socket's existence
+        // for the lifetime of their call.
+        SocketKeeper(CUDTUnited& glob, SRTSOCKET id, ErrorHandling erh = ERH_RETURN) { socket = glob.locateAcquireSocket(id, erh); }
+
+        // This is intended for TSBPD thread that should lock the socket's
+        // existence until it exits.
+        SocketKeeper(CUDTUnited& glob, CUDTSocket* s)
+        {
+            acquire(glob, s);
+        }
+
+        // Note: acquire doesn't check if the keeper already keeps anything.
+        // This is only for a use together with an empty constructor.
+        bool acquire(CUDTUnited& glob, CUDTSocket* s)
+        {
+            if (s == NULL)
+            {
+                socket = NULL;
+                return false;
+            }
+
+            const bool caught = glob.acquireSocket(s);
+            socket = caught ? s : NULL;
+            return caught;
+        }
+
+        ~SocketKeeper()
+        {
+            if (socket)
+            {
+                SRT_ASSERT(socket->isStillBusy() > 0);
+                socket->apiRelease();
+            }
+        }
+    };
 
 private:
-   volatile bool m_bClosing;
-   srt::sync::Mutex m_GCStopLock;
-   srt::sync::Condition m_GCStopCond;
 
-   srt::sync::Mutex m_InitLock;
-   int m_iInstanceCount;				// number of startup() called by application
-   bool m_bGCStatus;					// if the GC thread is working (true)
+    void updateMux(CUDTSocket* s, const sockaddr_any& addr, const UDPSOCKET* = NULL);
+    bool updateListenerMux(CUDTSocket* s, const CUDTSocket* ls);
 
-   srt::sync::CThread m_GCThread;
-   static void* garbageCollect(void*);
+    // Utility functions for updateMux
+    void     configureMuxer(CMultiplexer& w_m, const CUDTSocket* s, int af);
+    uint16_t installMuxer(CUDTSocket* w_s, CMultiplexer& sm);
 
-   sockets_t m_ClosedSockets;   // temporarily store closed sockets
-#if ENABLE_EXPERIMENTAL_BONDING
-   groups_t m_ClosedGroups;
+    /// @brief Checks if channel configuration matches the socket configuration.
+    /// @param cfgMuxer multiplexer configuration.
+    /// @param cfgSocket socket configuration.
+    /// @return tru if configurations match, false otherwise.
+    static bool channelSettingsMatch(const CSrtMuxerConfig& cfgMuxer, const CSrtConfig& cfgSocket);
+    static bool inet6SettingsCompat(const sockaddr_any& muxaddr, const CSrtMuxerConfig& cfgMuxer,
+        const sockaddr_any& reqaddr, const CSrtMuxerConfig& cfgSocket);
+
+private:
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    std::map<int, CMultiplexer> m_mMultiplexer; // UDP multiplexer
+
+    /// UDT network information cache.
+    /// Existence is guarded by m_GlobControlLock, but the cache itself is thread-safe.
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    CCache<CInfoBlock>* const m_pCache;
+
+private:
+    srt::sync::atomic<bool> m_bClosing;
+    sync::Mutex             m_GCStopLock;
+    sync::Condition         m_GCStopCond;
+
+    sync::Mutex m_InitLock;
+    SRT_ATTR_GUARDED_BY(m_InitLock)
+    int         m_iInstanceCount; // number of startup() called by application
+    SRT_ATTR_GUARDED_BY(m_InitLock)
+    bool        m_bGCStatus;      // if the GC thread is working (true)
+
+    SRT_ATTR_GUARDED_BY(m_InitLock)
+    sync::CThread m_GCThread;
+    static void*  garbageCollect(void*);
+
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    sockets_t m_ClosedSockets; // temporarily store closed sockets
+#if ENABLE_BONDING
+    SRT_ATTR_GUARDED_BY(m_GlobControlLock)
+    groups_t m_ClosedGroups;
 #endif
 
-   void checkBrokenSockets();
-   void removeSocket(const SRTSOCKET u);
+    void checkBrokenSockets();
+    void removeSocket(const SRTSOCKET u);
 
-   CEPoll m_EPoll;                                     // handling epoll data structures and events
+    CEPoll m_EPoll; // handling epoll data structures and events
 
 private:
-   CUDTUnited(const CUDTUnited&);
-   CUDTUnited& operator=(const CUDTUnited&);
+    CUDTUnited(const CUDTUnited&);
+    CUDTUnited& operator=(const CUDTUnited&);
 };
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/atomic.h b/srtcore/atomic.h
new file mode 100644
index 000000000..f391be941
--- /dev/null
+++ b/srtcore/atomic.h
@@ -0,0 +1,327 @@
+//----------------------------------------------------------------------------
+// This is free and unencumbered software released into the public domain.
+//
+// Anyone is free to copy, modify, publish, use, compile, sell, or distribute
+// this software, either in source code form or as a compiled binary, for any
+// purpose, commercial or non-commercial, and by any means.
+//
+// In jurisdictions that recognize copyright laws, the author or authors of
+// this software dedicate any and all copyright interest in the software to the
+// public domain. We make this dedication for the benefit of the public at
+// large and to the detriment of our heirs and successors. We intend this
+// dedication to be an overt act of relinquishment in perpetuity of all present
+// and future rights to this software under copyright law.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// For more information, please refer to <http://unlicense.org/>
+//-----------------------------------------------------------------------------
+
+// SRT Project information:
+// This file was adopted from a Public Domain project from
+// https://github.com/mbitsnbites/atomic
+// Only namespaces were changed to adopt it for SRT project.
+
+#ifndef SRT_SYNC_ATOMIC_H_
+#define SRT_SYNC_ATOMIC_H_
+
+// Macro for disallowing copying of an object.
+#if __cplusplus >= 201103L
+#define ATOMIC_DISALLOW_COPY(T) \
+  T(const T&) = delete;         \
+  T& operator=(const T&) = delete;
+#else
+#define ATOMIC_DISALLOW_COPY(T) \
+  T(const T&);                  \
+  T& operator=(const T&);
+#endif
+
+// A portable static assert.
+#if __cplusplus >= 201103L
+#define ATOMIC_STATIC_ASSERT(condition, message) \
+  static_assert((condition), message)
+#else
+// Based on: http://stackoverflow.com/a/809465/5778708
+#define ATOMIC_STATIC_ASSERT(condition, message) \
+  _impl_STATIC_ASSERT_LINE(condition, __LINE__)
+#define _impl_PASTE(a, b) a##b
+#ifdef __GNUC__
+#define _impl_UNUSED __attribute__((__unused__))
+#else
+#define _impl_UNUSED
+#endif
+#define _impl_STATIC_ASSERT_LINE(condition, line) \
+  typedef char _impl_PASTE(                       \
+      STATIC_ASSERT_failed_,                      \
+      line)[(2 * static_cast<int>(!!(condition))) - 1] _impl_UNUSED
+#endif
+
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+   // NOTE: Defined at the top level.
+#elif __cplusplus >= 201103L
+   // NOTE: Prefer to use the c++11 std::atomic.
+   #define ATOMIC_USE_CPP11_ATOMIC
+#elif (defined(__clang__) && defined(__clang_major__) && (__clang_major__ > 5)) \
+   || defined(__xlc__)
+   // NOTE: Clang <6 does not support GCC __atomic_* intrinsics. I am unsure
+   //    about Clang6. Since Clang sets __GNUC__ and __GNUC_MINOR__ of this era
+   //    to <4.5, older Clang will catch the setting below to use the
+   //    POSIX Mutex Implementation.
+   #define ATOMIC_USE_GCC_INTRINSICS
+#elif defined(__GNUC__) \
+   && ( (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) )
+   // NOTE: The __atomic_* family of intrisics were introduced in GCC-4.7.0.
+   // NOTE: This follows #if defined(__clang__), because most if, not all,
+   //    versions of Clang define __GNUC__ and __GNUC_MINOR__ but often define
+   //    them to 4.4 or an even earlier version. Most of the newish versions
+   //    of Clang also support GCC Atomic Intrisics even if they set GCC version
+   //    macros to <4.7.
+   #define ATOMIC_USE_GCC_INTRINSICS
+#elif defined(__GNUC__) && !defined(ATOMIC_USE_SRT_SYNC_MUTEX)
+   // NOTE: GCC compiler built-ins for atomic operations are pure
+   //    compiler extensions prior to GCC-4.7 and were grouped into the
+   //    the __sync_* family of functions. GCC-4.7, both the c++11 and C11
+   //    standards had been finalized, and GCC updated their built-ins to
+   //    better reflect the new memory model and the new functions grouped
+   //    into the __atomic_* family. Also the memory models were defined
+   //    differently, than in pre 4.7.
+   // TODO: PORT to the pre GCC-4.7 __sync_* intrinsics. In the meantime use
+   //    the POSIX Mutex Implementation.
+   #define ATOMIC_USE_SRT_SYNC_MUTEX 1
+#elif defined(_MSC_VER)
+   #define ATOMIC_USE_MSVC_INTRINSICS
+   #include "atomic_msvc.h"
+#else
+   #error Unsupported compiler / system.
+#endif
+// Include any necessary headers for the selected Atomic Implementation.
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+   #include "sync.h"
+#endif
+#if defined(ATOMIC_USE_CPP11_ATOMIC)
+   #include <atomic>
+#endif
+
+namespace srt {
+namespace sync {
+template <typename T>
+class atomic {
+public:
+  ATOMIC_STATIC_ASSERT(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+                           sizeof(T) == 8,
+                       "Only types of size 1, 2, 4 or 8 are supported");
+
+  atomic()
+    : value_(static_cast<T>(0))
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    , mutex_()
+#endif
+  {
+     // No-Op
+  }
+
+  explicit atomic(const T value)
+    : value_(value)
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    , mutex_()
+#endif
+  {
+     // No-Op
+  }
+
+  ~atomic()
+  {
+     // No-Op
+  }
+
+  /// @brief Performs an atomic increment operation (value + 1).
+  /// @returns The new value of the atomic object.
+  T operator++() {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    const T t = ++value_;
+    return t;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    return __atomic_add_fetch(&value_, 1, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    return msvc::interlocked<T>::increment(&value_);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    return ++value_;
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  /// @brief Performs an atomic decrement operation (value - 1).
+  /// @returns The new value of the atomic object.
+  T operator--() {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    const T t = --value_;
+    return t;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    return __atomic_sub_fetch(&value_, 1, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    return msvc::interlocked<T>::decrement(&value_);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    return --value_;
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  T operator|=(T i) {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    const T t = value_ |= i;
+    return t;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    return __atomic_or_fetch(&value_, i, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    return msvc::interlocked<T>::or_fetch(&value_, i);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    return value_ |= i;
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  /// @brief Performs an atomic compare-and-swap (CAS) operation.
+  ///
+  /// The value of the atomic object is only updated to the new value if the
+  /// old value of the atomic object matches @c expected_val.
+  ///
+  /// @param expected_val The expected value of the atomic object.
+  /// @param new_val The new value to write to the atomic object.
+  /// @returns True if new_value was written to the atomic object.
+  bool compare_exchange(const T expected_val, const T new_val) {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    bool result = false;
+    if (expected_val == value_)
+    {
+      value_ = new_val;
+      result = true;
+    }
+    return result;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    T e = expected_val;
+    return __atomic_compare_exchange_n(
+        &value_, &e, new_val, true, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    const T old_val =
+        msvc::interlocked<T>::compare_exchange(&value_, new_val, expected_val);
+    return (old_val == expected_val);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    T e = expected_val;
+    return value_.compare_exchange_weak(e, new_val);
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  /// @brief Performs an atomic set operation.
+  ///
+  /// The value of the atomic object is unconditionally updated to the new
+  /// value.
+  ///
+  /// @param new_val The new value to write to the atomic object.
+  void store(const T new_val) {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    value_ = new_val;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    __atomic_store_n(&value_, new_val, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    (void)msvc::interlocked<T>::exchange(&value_, new_val);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    value_.store(new_val);
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  /// @returns the current value of the atomic object.
+  /// @note Be careful about how this is used, since any operations on the
+  /// returned value are inherently non-atomic.
+  T load() const {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    const T t = value_;
+    return t;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    return __atomic_load_n(&value_, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    // TODO(m): Is there a better solution for MSVC?
+    return value_;
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    return value_;
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  /// @brief Performs an atomic exchange operation.
+  ///
+  /// The value of the atomic object is unconditionally updated to the new
+  /// value, and the old value is returned.
+  ///
+  /// @param new_val The new value to write to the atomic object.
+  /// @returns the old value.
+  T exchange(const T new_val) {
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+    ScopedLock lg_(mutex_);
+    const T t = value_;
+    value_ = new_val;
+    return t;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+    return __atomic_exchange_n(&value_, new_val, __ATOMIC_SEQ_CST);
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+    return msvc::interlocked<T>::exchange(&value_, new_val);
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+    return value_.exchange(new_val);
+#else
+    #error "Implement Me."
+#endif
+  }
+
+  T operator=(const T new_value) {
+    store(new_value);
+    return new_value;
+  }
+
+  operator T() const {
+    return load();
+  }
+
+private:
+#if defined(ATOMIC_USE_SRT_SYNC_MUTEX) && (ATOMIC_USE_SRT_SYNC_MUTEX == 1)
+  T value_;
+  mutable Mutex mutex_;
+#elif defined(ATOMIC_USE_GCC_INTRINSICS)
+  volatile T value_;
+#elif defined(ATOMIC_USE_MSVC_INTRINSICS)
+  volatile T value_;
+#elif defined(ATOMIC_USE_CPP11_ATOMIC)
+  std::atomic<T> value_;
+#else
+   #error "Implement Me. (value_ type)"
+#endif
+
+  ATOMIC_DISALLOW_COPY(atomic)
+};
+
+}  // namespace sync
+}  // namespace srt
+
+// Undef temporary defines.
+#undef ATOMIC_USE_GCC_INTRINSICS
+#undef ATOMIC_USE_MSVC_INTRINSICS
+#undef ATOMIC_USE_CPP11_ATOMIC
+
+#endif  // ATOMIC_ATOMIC_H_
diff --git a/srtcore/atomic_clock.h b/srtcore/atomic_clock.h
new file mode 100644
index 000000000..e01012313
--- /dev/null
+++ b/srtcore/atomic_clock.h
@@ -0,0 +1,91 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+#ifndef INC_SRT_SYNC_ATOMIC_CLOCK_H
+#define INC_SRT_SYNC_ATOMIC_CLOCK_H
+
+#include "sync.h"
+#include "atomic.h"
+
+namespace srt
+{
+namespace sync
+{
+
+template <class Clock>
+class AtomicDuration
+{
+    atomic<int64_t> dur;
+    typedef typename Clock::duration duration_type;
+    typedef typename Clock::time_point time_point_type;
+public:
+
+    AtomicDuration() ATR_NOEXCEPT : dur(0) {}
+
+    duration_type load()
+    {
+        int64_t val = dur.load();
+        return duration_type(val);
+    }
+
+    void store(const duration_type& d)
+    {
+        dur.store(d.count());
+    }
+
+    AtomicDuration<Clock>& operator=(const duration_type& s)
+    {
+        dur = s.count();
+        return *this;
+    }
+
+    operator duration_type() const
+    {
+        return duration_type(dur);
+    }
+};
+
+template <class Clock>
+class AtomicClock
+{
+    atomic<uint64_t> dur;
+    typedef typename Clock::duration duration_type;
+    typedef typename Clock::time_point time_point_type;
+public:
+
+    AtomicClock() ATR_NOEXCEPT : dur(0) {}
+
+    time_point_type load() const
+    {
+        int64_t val = dur.load();
+        return time_point_type(duration_type(val));
+    }
+
+    void store(const time_point_type& d)
+    {
+        dur.store(uint64_t(d.time_since_epoch().count()));
+    }
+
+    AtomicClock& operator=(const time_point_type& s)
+    {
+        dur = s.time_since_epoch().count();
+        return *this;
+    }
+
+    operator time_point_type() const
+    {
+        return time_point_type(duration_type(dur.load()));
+    }
+};
+
+} // namespace sync
+} // namespace srt
+
+#endif // INC_SRT_SYNC_ATOMIC_CLOCK_H
diff --git a/srtcore/atomic_msvc.h b/srtcore/atomic_msvc.h
new file mode 100644
index 000000000..735c7a660
--- /dev/null
+++ b/srtcore/atomic_msvc.h
@@ -0,0 +1,250 @@
+//-----------------------------------------------------------------------------
+// This is free and unencumbered software released into the public domain.
+//
+// Anyone is free to copy, modify, publish, use, compile, sell, or distribute
+// this software, either in source code form or as a compiled binary, for any
+// purpose, commercial or non-commercial, and by any means.
+//
+// In jurisdictions that recognize copyright laws, the author or authors of
+// this software dedicate any and all copyright interest in the software to the
+// public domain. We make this dedication for the benefit of the public at
+// large and to the detriment of our heirs and successors. We intend this
+// dedication to be an overt act of relinquishment in perpetuity of all present
+// and future rights to this software under copyright law.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// For more information, please refer to <http://unlicense.org/>
+//-----------------------------------------------------------------------------
+
+// SRT Project information:
+// This file was adopted from a Public Domain project from
+// https://github.com/mbitsnbites/atomic
+// Only namespaces were changed to adopt it for SRT project.
+
+#ifndef SRT_SYNC_ATOMIC_MSVC_H_
+#define SRT_SYNC_ATOMIC_MSVC_H_
+
+// Define which functions we need (don't include <intrin.h>).
+extern "C" {
+short _InterlockedIncrement16(short volatile*);
+long _InterlockedIncrement(long volatile*);
+__int64 _InterlockedIncrement64(__int64 volatile*);
+
+short _InterlockedDecrement16(short volatile*);
+long _InterlockedDecrement(long volatile*);
+__int64 _InterlockedDecrement64(__int64 volatile*);
+
+char _InterlockedExchange8(char volatile*, char);
+short _InterlockedExchange16(short volatile*, short);
+long __cdecl _InterlockedExchange(long volatile*, long);
+__int64 _InterlockedExchange64(__int64 volatile*, __int64);
+
+char _InterlockedCompareExchange8(char volatile*, char, char);
+short _InterlockedCompareExchange16(short volatile*, short, short);
+long __cdecl _InterlockedCompareExchange(long volatile*, long, long);
+__int64 _InterlockedCompareExchange64(__int64 volatile*, __int64, __int64);
+};
+
+// Define which functions we want to use as inline intriniscs.
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedIncrement16)
+
+#pragma intrinsic(_InterlockedDecrement)
+#pragma intrinsic(_InterlockedDecrement16)
+
+#pragma intrinsic(_InterlockedCompareExchange)
+#pragma intrinsic(_InterlockedCompareExchange8)
+#pragma intrinsic(_InterlockedCompareExchange16)
+
+#pragma intrinsic(_InterlockedExchange)
+#pragma intrinsic(_InterlockedExchange8)
+#pragma intrinsic(_InterlockedExchange16)
+
+#if defined(_M_X64)
+#pragma intrinsic(_InterlockedIncrement64)
+#pragma intrinsic(_InterlockedDecrement64)
+#pragma intrinsic(_InterlockedCompareExchange64)
+#pragma intrinsic(_InterlockedExchange64)
+#endif  // _M_X64
+
+namespace srt {
+namespace sync {
+namespace msvc {
+template <typename T, size_t N = sizeof(T)>
+struct interlocked {
+};
+
+template <typename T>
+struct interlocked<T, 1> {
+  static inline T increment(T volatile* x) {
+    // There's no _InterlockedIncrement8().
+    char old_val, new_val;
+    do {
+      old_val = static_cast<char>(*x);
+      new_val = old_val + static_cast<char>(1);
+    } while (_InterlockedCompareExchange8(reinterpret_cast<volatile char*>(x),
+                                          new_val,
+                                          old_val) != old_val);
+    return static_cast<T>(new_val);
+  }
+
+  static inline T decrement(T volatile* x) {
+    // There's no _InterlockedDecrement8().
+    char old_val, new_val;
+    do {
+      old_val = static_cast<char>(*x);
+      new_val = old_val - static_cast<char>(1);
+    } while (_InterlockedCompareExchange8(reinterpret_cast<volatile char*>(x),
+                                          new_val,
+                                          old_val) != old_val);
+    return static_cast<T>(new_val);
+  }
+
+  static inline T compare_exchange(T volatile* x,
+                                   const T new_val,
+                                   const T expected_val) {
+    return static_cast<T>(
+        _InterlockedCompareExchange8(reinterpret_cast<volatile char*>(x),
+                                     static_cast<const char>(new_val),
+                                     static_cast<const char>(expected_val)));
+  }
+
+  static inline T exchange(T volatile* x, const T new_val) {
+    return static_cast<T>(_InterlockedExchange8(
+        reinterpret_cast<volatile char*>(x), static_cast<const char>(new_val)));
+  }
+
+  static inline T or_fetch(T volatile* x, const T val) {
+    return static_cast<T>(_InterlockedOr8(
+        reinterpret_cast<volatile char*>(x), static_cast<const char>(val)));
+  }
+};
+
+template <typename T>
+struct interlocked<T, 2> {
+  static inline T increment(T volatile* x) {
+    return static_cast<T>(
+        _InterlockedIncrement16(reinterpret_cast<volatile short*>(x)));
+  }
+
+  static inline T decrement(T volatile* x) {
+    return static_cast<T>(
+        _InterlockedDecrement16(reinterpret_cast<volatile short*>(x)));
+  }
+
+  static inline T compare_exchange(T volatile* x,
+                                   const T new_val,
+                                   const T expected_val) {
+    return static_cast<T>(
+        _InterlockedCompareExchange16(reinterpret_cast<volatile short*>(x),
+                                      static_cast<const short>(new_val),
+                                      static_cast<const short>(expected_val)));
+  }
+
+  static inline T exchange(T volatile* x, const T new_val) {
+    return static_cast<T>(
+        _InterlockedExchange16(reinterpret_cast<volatile short*>(x),
+                               static_cast<const short>(new_val)));
+  }
+};
+
+template <typename T>
+struct interlocked<T, 4> {
+  static inline T increment(T volatile* x) {
+    return static_cast<T>(
+        _InterlockedIncrement(reinterpret_cast<volatile long*>(x)));
+  }
+
+  static inline T decrement(T volatile* x) {
+    return static_cast<T>(
+        _InterlockedDecrement(reinterpret_cast<volatile long*>(x)));
+  }
+
+  static inline T compare_exchange(T volatile* x,
+                                   const T new_val,
+                                   const T expected_val) {
+    return static_cast<T>(
+        _InterlockedCompareExchange(reinterpret_cast<volatile long*>(x),
+                                    static_cast<const long>(new_val),
+                                    static_cast<const long>(expected_val)));
+  }
+
+  static inline T exchange(T volatile* x, const T new_val) {
+    return static_cast<T>(_InterlockedExchange(
+        reinterpret_cast<volatile long*>(x), static_cast<const long>(new_val)));
+  }
+};
+
+template <typename T>
+struct interlocked<T, 8> {
+  static inline T increment(T volatile* x) {
+#if defined(_M_X64)
+    return static_cast<T>(
+        _InterlockedIncrement64(reinterpret_cast<volatile __int64*>(x)));
+#else
+    // There's no _InterlockedIncrement64() for 32-bit x86.
+    __int64 old_val, new_val;
+    do {
+      old_val = static_cast<__int64>(*x);
+      new_val = old_val + static_cast<__int64>(1);
+    } while (_InterlockedCompareExchange64(
+                 reinterpret_cast<volatile __int64*>(x), new_val, old_val) !=
+             old_val);
+    return static_cast<T>(new_val);
+#endif  // _M_X64
+  }
+
+  static inline T decrement(T volatile* x) {
+#if defined(_M_X64)
+    return static_cast<T>(
+        _InterlockedDecrement64(reinterpret_cast<volatile __int64*>(x)));
+#else
+    // There's no _InterlockedDecrement64() for 32-bit x86.
+    __int64 old_val, new_val;
+    do {
+      old_val = static_cast<__int64>(*x);
+      new_val = old_val - static_cast<__int64>(1);
+    } while (_InterlockedCompareExchange64(
+                 reinterpret_cast<volatile __int64*>(x), new_val, old_val) !=
+             old_val);
+    return static_cast<T>(new_val);
+#endif  // _M_X64
+  }
+
+  static inline T compare_exchange(T volatile* x,
+                                   const T new_val,
+                                   const T expected_val) {
+    return static_cast<T>(_InterlockedCompareExchange64(
+        reinterpret_cast<volatile __int64*>(x),
+        static_cast<const __int64>(new_val),
+        static_cast<const __int64>(expected_val)));
+  }
+
+  static inline T exchange(T volatile* x, const T new_val) {
+#if defined(_M_X64)
+    return static_cast<T>(
+        _InterlockedExchange64(reinterpret_cast<volatile __int64*>(x),
+                               static_cast<const __int64>(new_val)));
+#else
+    // There's no _InterlockedExchange64 for 32-bit x86.
+    __int64 old_val;
+    do {
+      old_val = static_cast<__int64>(*x);
+    } while (_InterlockedCompareExchange64(
+                 reinterpret_cast<volatile __int64*>(x), new_val, old_val) !=
+             old_val);
+    return static_cast<T>(old_val);
+#endif  // _M_X64
+  }
+};
+}  // namespace msvc
+}  // namespace sync
+}  // namespace srt
+
+#endif  // ATOMIC_ATOMIC_MSVC_H_
diff --git a/srtcore/buffer.cpp b/srtcore/buffer.cpp
deleted file mode 100644
index 5fa566ae9..000000000
--- a/srtcore/buffer.cpp
+++ /dev/null
@@ -1,2436 +0,0 @@
-/*
- * SRT - Secure, Reliable, Transport
- * Copyright (c) 2018 Haivision Systems Inc.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- */
-
-/*****************************************************************************
-Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the
-  above copyright notice, this list of conditions
-  and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the University of Illinois
-  nor the names of its contributors may be used to
-  endorse or promote products derived from this
-  software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-/*****************************************************************************
-written by
-   Yunhong Gu, last updated 03/12/2011
-modified by
-   Haivision Systems Inc.
-*****************************************************************************/
-
-#include "platform_sys.h"
-
-#include <cstring>
-#include <cmath>
-#include "buffer.h"
-#include "packet.h"
-#include "core.h" // provides some constants
-#include "logging.h"
-
-using namespace std;
-using namespace srt_logging;
-using namespace srt::sync;
-
-// You can change this value at build config by using "ENFORCE" options.
-#if !defined(SRT_MAVG_SAMPLING_RATE)
-#define SRT_MAVG_SAMPLING_RATE 40
-#endif
-
-bool AvgBufSize::isTimeToUpdate(const time_point& now) const
-{
-    const int      usMAvgBasePeriod = 1000000; // 1s in microseconds
-    const int      us2ms            = 1000;
-    const int      msMAvgPeriod     = (usMAvgBasePeriod / SRT_MAVG_SAMPLING_RATE) / us2ms;
-    const uint64_t elapsed_ms       = count_milliseconds(now - m_tsLastSamplingTime); // ms since last sampling
-    return (elapsed_ms >= msMAvgPeriod);
-}
-
-void AvgBufSize::update(const steady_clock::time_point& now, int pkts, int bytes, int timespan_ms)
-{
-    const uint64_t elapsed_ms       = count_milliseconds(now - m_tsLastSamplingTime); // ms since last sampling
-    m_tsLastSamplingTime            = now;
-    const uint64_t one_second_in_ms = 1000;
-    if (elapsed_ms > one_second_in_ms)
-    {
-        // No sampling in last 1 sec, initialize average
-        m_dCountMAvg      = pkts;
-        m_dBytesCountMAvg = bytes;
-        m_dTimespanMAvg   = timespan_ms;
-        return;
-    }
-
-    //
-    // weight last average value between -1 sec and last sampling time (LST)
-    // and new value between last sampling time and now
-    //                                      |elapsed_ms|
-    //   +----------------------------------+-------+
-    //  -1                                 LST      0(now)
-    //
-    m_dCountMAvg      = avg_iir_w<1000, double>(m_dCountMAvg, pkts, elapsed_ms);
-    m_dBytesCountMAvg = avg_iir_w<1000, double>(m_dBytesCountMAvg, bytes, elapsed_ms);
-    m_dTimespanMAvg   = avg_iir_w<1000, double>(m_dTimespanMAvg, timespan_ms, elapsed_ms);
-}
-
-int round_val(double val)
-{
-    return static_cast<int>(round(val));
-}
-
-CSndBuffer::CSndBuffer(int size, int mss)
-    : m_BufLock()
-    , m_pBlock(NULL)
-    , m_pFirstBlock(NULL)
-    , m_pCurrBlock(NULL)
-    , m_pLastBlock(NULL)
-    , m_pBuffer(NULL)
-    , m_iNextMsgNo(1)
-    , m_iSize(size)
-    , m_iMSS(mss)
-    , m_iCount(0)
-    , m_iBytesCount(0)
-    , m_iInRatePktsCount(0)
-    , m_iInRateBytesCount(0)
-    , m_InRatePeriod(INPUTRATE_FAST_START_US) // 0.5 sec (fast start)
-    , m_iInRateBps(INPUTRATE_INITIAL_BYTESPS)
-{
-    // initial physical buffer of "size"
-    m_pBuffer           = new Buffer;
-    m_pBuffer->m_pcData = new char[m_iSize * m_iMSS];
-    m_pBuffer->m_iSize  = m_iSize;
-    m_pBuffer->m_pNext  = NULL;
-
-    // circular linked list for out bound packets
-    m_pBlock  = new Block;
-    Block* pb = m_pBlock;
-    for (int i = 1; i < m_iSize; ++i)
-    {
-        pb->m_pNext        = new Block;
-        pb->m_iMsgNoBitset = 0;
-        pb                 = pb->m_pNext;
-    }
-    pb->m_pNext = m_pBlock;
-
-    pb       = m_pBlock;
-    char* pc = m_pBuffer->m_pcData;
-    for (int i = 0; i < m_iSize; ++i)
-    {
-        pb->m_pcData = pc;
-        pb           = pb->m_pNext;
-        pc += m_iMSS;
-    }
-
-    m_pFirstBlock = m_pCurrBlock = m_pLastBlock = m_pBlock;
-
-    setupMutex(m_BufLock, "Buf");
-}
-
-CSndBuffer::~CSndBuffer()
-{
-    Block* pb = m_pBlock->m_pNext;
-    while (pb != m_pBlock)
-    {
-        Block* temp = pb;
-        pb          = pb->m_pNext;
-        delete temp;
-    }
-    delete m_pBlock;
-
-    while (m_pBuffer != NULL)
-    {
-        Buffer* temp = m_pBuffer;
-        m_pBuffer    = m_pBuffer->m_pNext;
-        delete[] temp->m_pcData;
-        delete temp;
-    }
-
-    releaseMutex(m_BufLock);
-}
-
-void CSndBuffer::addBuffer(const char* data, int len, SRT_MSGCTRL& w_mctrl)
-{
-    int32_t&  w_msgno   = w_mctrl.msgno;
-    int32_t&  w_seqno   = w_mctrl.pktseq;
-    int64_t& w_srctime  = w_mctrl.srctime;
-    int&      w_ttl     = w_mctrl.msgttl;
-    int       size      = len / m_iMSS;
-    if ((len % m_iMSS) != 0)
-        size++;
-
-    HLOGC(bslog.Debug,
-          log << "addBuffer: size=" << m_iCount << " reserved=" << m_iSize << " needs=" << size << " buffers for "
-              << len << " bytes");
-
-    // dynamically increase sender buffer
-    while (size + m_iCount >= m_iSize)
-    {
-        HLOGC(bslog.Debug, log << "addBuffer: ... still lacking " << (size + m_iCount - m_iSize) << " buffers...");
-        increase();
-    }
-
-    const steady_clock::time_point time = steady_clock::now();
-    const int32_t inorder = w_mctrl.inorder ? MSGNO_PACKET_INORDER::mask : 0;
-
-    HLOGC(bslog.Debug,
-          log << CONID() << "addBuffer: adding " << size << " packets (" << len << " bytes) to send, msgno="
-              << (w_msgno > 0 ? w_msgno : m_iNextMsgNo) << (inorder ? "" : " NOT") << " in order");
-
-    // The sequence number passed to this function is the sequence number
-    // that the very first packet from the packet series should get here.
-    // If there's more than one packet, this function must increase it by itself
-    // and then return the accordingly modified sequence number in the reference.
-
-    Block* s = m_pLastBlock;
-
-    if (w_msgno == SRT_MSGNO_NONE) // DEFAULT-UNCHANGED msgno supplied
-    {
-        HLOGC(bslog.Debug, log << "addBuffer: using internally managed msgno=" << m_iNextMsgNo);
-        w_msgno = m_iNextMsgNo;
-    }
-    else
-    {
-        HLOGC(bslog.Debug, log << "addBuffer: OVERWRITTEN by msgno supplied by caller: msgno=" << w_msgno);
-        m_iNextMsgNo = w_msgno;
-    }
-
-    for (int i = 0; i < size; ++i)
-    {
-        int pktlen = len - i * m_iMSS;
-        if (pktlen > m_iMSS)
-            pktlen = m_iMSS;
-
-        HLOGC(bslog.Debug,
-              log << "addBuffer: %" << w_seqno << " #" << w_msgno << " spreading from=" << (i * m_iMSS)
-                  << " size=" << pktlen << " TO BUFFER:" << (void*)s->m_pcData);
-        memcpy((s->m_pcData), data + i * m_iMSS, pktlen);
-        s->m_iLength = pktlen;
-
-        s->m_iSeqNo = w_seqno;
-        w_seqno     = CSeqNo::incseq(w_seqno);
-
-        s->m_iMsgNoBitset = m_iNextMsgNo | inorder;
-        if (i == 0)
-            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_FIRST);
-        if (i == size - 1)
-            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_LAST);
-        // NOTE: if i is neither 0 nor size-1, it resuls with PB_SUBSEQUENT.
-        //       if i == 0 == size-1, it results with PB_SOLO.
-        // Packets assigned to one message can be:
-        // [PB_FIRST] [PB_SUBSEQUENT] [PB_SUBSEQUENT] [PB_LAST] - 4 packets per message
-        // [PB_FIRST] [PB_LAST] - 2 packets per message
-        // [PB_SOLO] - 1 packet per message
-
-        s->m_llSourceTime_us = w_srctime;
-        s->m_tsOriginTime = time;
-        s->m_tsRexmitTime = time_point();
-        s->m_iTTL = w_ttl;
-        // Rewrite the actual sending time back into w_srctime
-        // so that the calling facilities can reuse it
-        if (!w_srctime)
-            w_srctime = count_microseconds(s->m_tsOriginTime.time_since_epoch());
-
-        // XXX unchecked condition: s->m_pNext == NULL.
-        // Should never happen, as the call to increase() should ensure enough buffers.
-        SRT_ASSERT(s->m_pNext);
-        s = s->m_pNext;
-    }
-    m_pLastBlock = s;
-
-    enterCS(m_BufLock);
-    m_iCount += size;
-
-    m_iBytesCount += len;
-    m_tsLastOriginTime = time;
-
-    updateInputRate(time, size, len);
-
-    updAvgBufSize(time);
-
-    leaveCS(m_BufLock);
-
-    // MSGNO_SEQ::mask has a form: 00000011111111...
-    // At least it's known that it's from some index inside til the end (to bit 0).
-    // If this value has been reached in a step of incrementation, it means that the
-    // maximum value has been reached. Casting to int32_t to ensure the same sign
-    // in comparison, although it's far from reaching the sign bit.
-
-    const int nextmsgno = ++MsgNo(m_iNextMsgNo);
-    HLOGC(bslog.Debug, log << "CSndBuffer::addBuffer: updating msgno: #" << m_iNextMsgNo << " -> #" << nextmsgno);
-    m_iNextMsgNo = nextmsgno;
-}
-
-void CSndBuffer::setInputRateSmpPeriod(int period)
-{
-    m_InRatePeriod = (uint64_t)period; //(usec) 0=no input rate calculation
-}
-
-void CSndBuffer::updateInputRate(const steady_clock::time_point& time, int pkts, int bytes)
-{
-    // no input rate calculation
-    if (m_InRatePeriod == 0)
-        return;
-
-    if (is_zero(m_tsInRateStartTime))
-    {
-        m_tsInRateStartTime = time;
-        return;
-    }
-
-    m_iInRatePktsCount += pkts;
-    m_iInRateBytesCount += bytes;
-
-    // Trigger early update in fast start mode
-    const bool early_update = (m_InRatePeriod < INPUTRATE_RUNNING_US) && (m_iInRatePktsCount > INPUTRATE_MAX_PACKETS);
-
-    const uint64_t period_us = count_microseconds(time - m_tsInRateStartTime);
-    if (early_update || period_us > m_InRatePeriod)
-    {
-        // Required Byte/sec rate (payload + headers)
-        m_iInRateBytesCount += (m_iInRatePktsCount * CPacket::SRT_DATA_HDR_SIZE);
-        m_iInRateBps = (int)(((int64_t)m_iInRateBytesCount * 1000000) / period_us);
-        HLOGC(bslog.Debug,
-              log << "updateInputRate: pkts:" << m_iInRateBytesCount << " bytes:" << m_iInRatePktsCount
-                  << " rate=" << (m_iInRateBps * 8) / 1000 << "kbps interval=" << period_us);
-        m_iInRatePktsCount  = 0;
-        m_iInRateBytesCount = 0;
-        m_tsInRateStartTime = time;
-
-        setInputRateSmpPeriod(INPUTRATE_RUNNING_US);
-    }
-}
-
-int CSndBuffer::addBufferFromFile(fstream& ifs, int len)
-{
-    int size = len / m_iMSS;
-    if ((len % m_iMSS) != 0)
-        size++;
-
-    HLOGC(bslog.Debug,
-          log << "addBufferFromFile: size=" << m_iCount << " reserved=" << m_iSize << " needs=" << size
-              << " buffers for " << len << " bytes");
-
-    // dynamically increase sender buffer
-    while (size + m_iCount >= m_iSize)
-    {
-        HLOGC(bslog.Debug,
-              log << "addBufferFromFile: ... still lacking " << (size + m_iCount - m_iSize) << " buffers...");
-        increase();
-    }
-
-    HLOGC(bslog.Debug,
-          log << CONID() << "addBufferFromFile: adding " << size << " packets (" << len
-              << " bytes) to send, msgno=" << m_iNextMsgNo);
-
-    Block* s     = m_pLastBlock;
-    int    total = 0;
-    for (int i = 0; i < size; ++i)
-    {
-        if (ifs.bad() || ifs.fail() || ifs.eof())
-            break;
-
-        int pktlen = len - i * m_iMSS;
-        if (pktlen > m_iMSS)
-            pktlen = m_iMSS;
-
-        HLOGC(bslog.Debug,
-              log << "addBufferFromFile: reading from=" << (i * m_iMSS) << " size=" << pktlen
-                  << " TO BUFFER:" << (void*)s->m_pcData);
-        ifs.read(s->m_pcData, pktlen);
-        if ((pktlen = int(ifs.gcount())) <= 0)
-            break;
-
-        // currently file transfer is only available in streaming mode, message is always in order, ttl = infinite
-        s->m_iMsgNoBitset = m_iNextMsgNo | MSGNO_PACKET_INORDER::mask;
-        if (i == 0)
-            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_FIRST);
-        if (i == size - 1)
-            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_LAST);
-        // NOTE: PB_FIRST | PB_LAST == PB_SOLO.
-        // none of PB_FIRST & PB_LAST == PB_SUBSEQUENT.
-
-        s->m_iLength = pktlen;
-        s->m_iTTL    = SRT_MSGTTL_INF;
-        s            = s->m_pNext;
-
-        total += pktlen;
-    }
-    m_pLastBlock = s;
-
-    enterCS(m_BufLock);
-    m_iCount += size;
-    m_iBytesCount += total;
-
-    leaveCS(m_BufLock);
-
-    m_iNextMsgNo++;
-    if (m_iNextMsgNo == int32_t(MSGNO_SEQ::mask))
-        m_iNextMsgNo = 1;
-
-    return total;
-}
-
-steady_clock::time_point CSndBuffer::getSourceTime(const CSndBuffer::Block& block)
-{
-    if (block.m_llSourceTime_us)
-    {
-        return steady_clock::time_point() + microseconds_from(block.m_llSourceTime_us);
-    }
-
-    return block.m_tsOriginTime;
-}
-
-int CSndBuffer::readData(CPacket& w_packet, steady_clock::time_point& w_srctime, int kflgs)
-{
-    // No data to read
-    if (m_pCurrBlock == m_pLastBlock)
-        return 0;
-
-    // Make the packet REFLECT the data stored in the buffer.
-    w_packet.m_pcData = m_pCurrBlock->m_pcData;
-    int readlen       = m_pCurrBlock->m_iLength;
-    w_packet.setLength(readlen);
-    w_packet.m_iSeqNo = m_pCurrBlock->m_iSeqNo;
-
-    // XXX This is probably done because the encryption should happen
-    // just once, and so this sets the encryption flags to both msgno bitset
-    // IN THE PACKET and IN THE BLOCK. This is probably to make the encryption
-    // happen at the time when scheduling a new packet to send, but the packet
-    // must remain in the send buffer until it's ACKed. For the case of rexmit
-    // the packet will be taken "as is" (that is, already encrypted).
-    //
-    // The problem is in the order of things:
-    // 0. When the application stores the data, some of the flags for PH_MSGNO are set.
-    // 1. The readData() is called to get the original data sent by the application.
-    // 2. The data are original and must be encrypted. They WILL BE encrypted, later.
-    // 3. So far we are in readData() so the encryption flags must be updated NOW because
-    //    later we won't have access to the block's data.
-    // 4. After exiting from readData(), the packet is being encrypted. It's immediately
-    //    sent, however the data must remain in the sending buffer until they are ACKed.
-    // 5. In case when rexmission is needed, the second overloaded version of readData
-    //    is being called, and the buffer + PH_MSGNO value is extracted. All interesting
-    //    flags must be present and correct at that time.
-    //
-    // The only sensible way to fix this problem is to encrypt the packet not after
-    // extracting from here, but when the packet is stored into CSndBuffer. The appropriate
-    // flags for PH_MSGNO will be applied directly there. Then here the value for setting
-    // PH_MSGNO will be set as is.
-
-    if (kflgs == -1)
-    {
-        HLOGC(bslog.Debug, log << CONID() << " CSndBuffer: ERROR: encryption required and not possible. NOT SENDING.");
-        readlen = 0;
-    }
-    else
-    {
-        m_pCurrBlock->m_iMsgNoBitset |= MSGNO_ENCKEYSPEC::wrap(kflgs);
-    }
-
-    w_packet.m_iMsgNo = m_pCurrBlock->m_iMsgNoBitset;
-    w_srctime         = getSourceTime(*m_pCurrBlock);
-    m_pCurrBlock      = m_pCurrBlock->m_pNext;
-
-    HLOGC(bslog.Debug, log << CONID() << "CSndBuffer: extracting packet size=" << readlen << " to send");
-
-    return readlen;
-}
-
-int32_t CSndBuffer::getMsgNoAt(const int offset)
-{
-    ScopedLock bufferguard(m_BufLock);
-
-    Block* p = m_pFirstBlock;
-
-    if (p)
-    {
-        HLOGC(bslog.Debug,
-              log << "CSndBuffer::getMsgNoAt: FIRST MSG: size=" << p->m_iLength << " %" << p->m_iSeqNo << " #"
-                  << p->getMsgSeq() << " !" << BufferStamp(p->m_pcData, p->m_iLength));
-    }
-
-    if (offset >= m_iCount)
-    {
-        // Prevent accessing the last "marker" block
-        LOGC(bslog.Error,
-             log << "CSndBuffer::getMsgNoAt: IPE: offset=" << offset << " not found, max offset=" << m_iCount);
-        return SRT_MSGNO_CONTROL;
-    }
-
-    // XXX Suboptimal procedure to keep the blocks identifiable
-    // by sequence number. Consider using some circular buffer.
-    int       i;
-    Block* ee SRT_ATR_UNUSED = 0;
-    for (i = 0; i < offset && p; ++i)
-    {
-        ee = p;
-        p  = p->m_pNext;
-    }
-
-    if (!p)
-    {
-        LOGC(bslog.Error,
-             log << "CSndBuffer::getMsgNoAt: IPE: offset=" << offset << " not found, stopped at " << i << " with #"
-                 << (ee ? ee->getMsgSeq() : SRT_MSGNO_NONE));
-        return SRT_MSGNO_CONTROL;
-    }
-
-    HLOGC(bslog.Debug,
-          log << "CSndBuffer::getMsgNoAt: offset=" << offset << " found, size=" << p->m_iLength << " %" << p->m_iSeqNo
-              << " #" << p->getMsgSeq() << " !" << BufferStamp(p->m_pcData, p->m_iLength));
-
-    return p->getMsgSeq();
-}
-
-int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time_point& w_srctime, int& w_msglen)
-{
-    int32_t& msgno_bitset = w_packet.m_iMsgNo;
-
-    ScopedLock bufferguard(m_BufLock);
-
-    Block* p = m_pFirstBlock;
-
-    // XXX Suboptimal procedure to keep the blocks identifiable
-    // by sequence number. Consider using some circular buffer.
-    for (int i = 0; i < offset; ++i)
-        p = p->m_pNext;
-
-    // Check if the block that is the next candidate to send (m_pCurrBlock pointing) is stale.
-
-    // If so, then inform the caller that it should first take care of the whole
-    // message (all blocks with that message id). Shift the m_pCurrBlock pointer
-    // to the position past the last of them. Then return -1 and set the
-    // msgno_bitset return reference to the message id that should be dropped as
-    // a whole.
-
-    // After taking care of that, the caller should immediately call this function again,
-    // this time possibly in order to find the real data to be sent.
-
-    // if found block is stale
-    // (This is for messages that have declared TTL - messages that fail to be sent
-    // before the TTL defined time comes, will be dropped).
-    if ((p->m_iTTL >= 0) && (count_milliseconds(steady_clock::now() - p->m_tsOriginTime) > p->m_iTTL))
-    {
-        int32_t msgno = p->getMsgSeq();
-        w_msglen      = 1;
-        p             = p->m_pNext;
-        bool move     = false;
-        while (msgno == p->getMsgSeq())
-        {
-            if (p == m_pCurrBlock)
-                move = true;
-            p = p->m_pNext;
-            if (move)
-                m_pCurrBlock = p;
-            w_msglen++;
-        }
-
-        HLOGC(qslog.Debug,
-              log << "CSndBuffer::readData: due to TTL exceeded, " << w_msglen << " messages to drop, up to " << msgno);
-
-        // If readData returns -1, then msgno_bitset is understood as a Message ID to drop.
-        // This means that in this case it should be written by the message sequence value only
-        // (not the whole 4-byte bitset written at PH_MSGNO).
-        msgno_bitset = msgno;
-        return -1;
-    }
-
-    w_packet.m_pcData = p->m_pcData;
-    int readlen       = p->m_iLength;
-    w_packet.setLength(readlen);
-
-    // XXX Here the value predicted to be applied to PH_MSGNO field is extracted.
-    // As this function is predicted to extract the data to send as a rexmited packet,
-    // the packet must be in the form ready to send - so, in case of encryption,
-    // encrypted, and with all ENC flags already set. So, the first call to send
-    // the packet originally (the other overload of this function) must set these
-    // flags.
-    w_packet.m_iMsgNo = p->m_iMsgNoBitset;
-    w_srctime = getSourceTime(*p);
-
-    // This function is called when packet retransmission is triggered.
-    // Therefore we are setting the rexmit time.
-    p->m_tsRexmitTime = steady_clock::now();
-
-    HLOGC(qslog.Debug,
-          log << CONID() << "CSndBuffer: getting packet %" << p->m_iSeqNo << " as per %" << w_packet.m_iSeqNo
-              << " size=" << readlen << " to send [REXMIT]");
-
-    return readlen;
-}
-
-srt::sync::steady_clock::time_point CSndBuffer::getPacketRexmitTime(const int offset)
-{
-    ScopedLock bufferguard(m_BufLock);
-    const Block* p = m_pFirstBlock;
-
-    // XXX Suboptimal procedure to keep the blocks identifiable
-    // by sequence number. Consider using some circular buffer.
-    for (int i = 0; i < offset; ++i)
-    {
-        SRT_ASSERT(p);
-        p = p->m_pNext;
-    }
-
-    SRT_ASSERT(p);
-    return p->m_tsRexmitTime;
-}
-
-void CSndBuffer::ackData(int offset)
-{
-    ScopedLock bufferguard(m_BufLock);
-
-    bool move = false;
-    for (int i = 0; i < offset; ++i)
-    {
-        m_iBytesCount -= m_pFirstBlock->m_iLength;
-        if (m_pFirstBlock == m_pCurrBlock)
-            move = true;
-        m_pFirstBlock = m_pFirstBlock->m_pNext;
-    }
-    if (move)
-        m_pCurrBlock = m_pFirstBlock;
-
-    m_iCount -= offset;
-
-    updAvgBufSize(steady_clock::now());
-}
-
-int CSndBuffer::getCurrBufSize() const
-{
-    return m_iCount;
-}
-
-int CSndBuffer::getAvgBufSize(int& w_bytes, int& w_tsp)
-{
-    ScopedLock bufferguard(m_BufLock); /* Consistency of pkts vs. bytes vs. spantime */
-
-    /* update stats in case there was no add/ack activity lately */
-    updAvgBufSize(steady_clock::now());
-
-    // Average number of packets and timespan could be small,
-    // so rounding is beneficial, while for the number of
-    // bytes in the buffer is a higher value, so rounding can be omitted,
-    // but probably better to round all three values.
-    w_bytes = round_val(m_mavg.bytes());
-    w_tsp   = round_val(m_mavg.timespan_ms());
-    return round_val(m_mavg.pkts());
-}
-
-void CSndBuffer::updAvgBufSize(const steady_clock::time_point& now)
-{
-    if (!m_mavg.isTimeToUpdate(now))
-        return;
-
-    int       bytes       = 0;
-    int       timespan_ms = 0;
-    const int pkts        = getCurrBufSize((bytes), (timespan_ms));
-    m_mavg.update(now, pkts, bytes, timespan_ms);
-}
-
-int CSndBuffer::getCurrBufSize(int& w_bytes, int& w_timespan)
-{
-    w_bytes = m_iBytesCount;
-    /*
-     * Timespan can be less then 1000 us (1 ms) if few packets.
-     * Also, if there is only one pkt in buffer, the time difference will be 0.
-     * Therefore, always add 1 ms if not empty.
-     */
-    w_timespan = 0 < m_iCount ? count_milliseconds(m_tsLastOriginTime - m_pFirstBlock->m_tsOriginTime) + 1 : 0;
-
-    return m_iCount;
-}
-
-int CSndBuffer::dropLateData(int& w_bytes, int32_t& w_first_msgno, const steady_clock::time_point& too_late_time)
-{
-    int     dpkts  = 0;
-    int     dbytes = 0;
-    bool    move   = false;
-    int32_t msgno  = 0;
-
-    ScopedLock bufferguard(m_BufLock);
-    for (int i = 0; i < m_iCount && m_pFirstBlock->m_tsOriginTime < too_late_time; ++i)
-    {
-        dpkts++;
-        dbytes += m_pFirstBlock->m_iLength;
-        msgno = m_pFirstBlock->getMsgSeq();
-
-        if (m_pFirstBlock == m_pCurrBlock)
-            move = true;
-        m_pFirstBlock = m_pFirstBlock->m_pNext;
-    }
-
-    if (move)
-    {
-        m_pCurrBlock = m_pFirstBlock;
-    }
-    m_iCount -= dpkts;
-
-    m_iBytesCount -= dbytes;
-    w_bytes = dbytes;
-
-    // We report the increased number towards the last ever seen
-    // by the loop, as this last one is the last received. So remained
-    // (even if "should remain") is the first after the last removed one.
-    w_first_msgno = ++MsgNo(msgno);
-
-    updAvgBufSize(steady_clock::now());
-
-    return (dpkts);
-}
-
-void CSndBuffer::increase()
-{
-    int unitsize = m_pBuffer->m_iSize;
-
-    // new physical buffer
-    Buffer* nbuf = NULL;
-    try
-    {
-        nbuf           = new Buffer;
-        nbuf->m_pcData = new char[unitsize * m_iMSS];
-    }
-    catch (...)
-    {
-        delete nbuf;
-        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-    }
-    nbuf->m_iSize = unitsize;
-    nbuf->m_pNext = NULL;
-
-    // insert the buffer at the end of the buffer list
-    Buffer* p = m_pBuffer;
-    while (p->m_pNext != NULL)
-        p = p->m_pNext;
-    p->m_pNext = nbuf;
-
-    // new packet blocks
-    Block* nblk = NULL;
-    try
-    {
-        nblk = new Block;
-    }
-    catch (...)
-    {
-        delete nblk;
-        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-    }
-    Block* pb = nblk;
-    for (int i = 1; i < unitsize; ++i)
-    {
-        pb->m_pNext = new Block;
-        pb          = pb->m_pNext;
-    }
-
-    // insert the new blocks onto the existing one
-    pb->m_pNext           = m_pLastBlock->m_pNext;
-    m_pLastBlock->m_pNext = nblk;
-
-    pb       = nblk;
-    char* pc = nbuf->m_pcData;
-    for (int i = 0; i < unitsize; ++i)
-    {
-        pb->m_pcData = pc;
-        pb           = pb->m_pNext;
-        pc += m_iMSS;
-    }
-
-    m_iSize += unitsize;
-
-    HLOGC(bslog.Debug,
-          log << "CSndBuffer: BUFFER FULL - adding " << (unitsize * m_iMSS) << " bytes spread to " << unitsize
-              << " blocks"
-              << " (total size: " << m_iSize << " bytes)");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/*
- *   RcvBuffer (circular buffer):
- *
- *   |<------------------- m_iSize ----------------------------->|
- *   |       |<--- acked pkts -->|<--- m_iMaxPos --->|           |
- *   |       |                   |                   |           |
- *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
- *   | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 0 |...| 0 | m_pUnit[]
- *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
- *             |                 | |               |
- *             |                   |               \__last pkt received
- *             |                   \___ m_iLastAckPos: last ack sent
- *             \___ m_iStartPos: first message to read
- *
- *   m_pUnit[i]->m_iFlag: 0:free, 1:good, 2:passack, 3:dropped
- *
- *   thread safety:
- *    m_iStartPos:   CUDT::m_RecvLock
- *    m_iLastAckPos: CUDT::m_AckLock
- *    m_iMaxPos:     none? (modified on add and ack
- */
-
-// XXX Init values moved to in-class.
-// const uint32_t CRcvBuffer::TSBPD_WRAP_PERIOD = (30*1000000);    //30 seconds (in usec)
-// const int CRcvBuffer::TSBPD_DRIFT_MAX_VALUE   = 5000;  // usec
-// const int CRcvBuffer::TSBPD_DRIFT_MAX_SAMPLES = 1000;  // ACK-ACK packets
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-// const int CRcvBuffer::TSBPD_DRIFT_PRT_SAMPLES = 200;   // ACK-ACK packets
-#endif
-
-CRcvBuffer::CRcvBuffer(CUnitQueue* queue, int bufsize_pkts)
-    : m_pUnit(NULL)
-    , m_iSize(bufsize_pkts)
-    , m_pUnitQueue(queue)
-    , m_iStartPos(0)
-    , m_iLastAckPos(0)
-    , m_iMaxPos(0)
-    , m_iNotch(0)
-    , m_BytesCountLock()
-    , m_iBytesCount(0)
-    , m_iAckedPktsCount(0)
-    , m_iAckedBytesCount(0)
-    , m_uAvgPayloadSz(7 * 188)
-    , m_bTsbPdMode(false)
-    , m_tdTsbPdDelay(0)
-    , m_bTsbPdWrapCheck(false)
-{
-    m_pUnit = new CUnit*[m_iSize];
-    for (int i = 0; i < m_iSize; ++i)
-        m_pUnit[i] = NULL;
-
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-    memset(m_TsbPdDriftHisto100us, 0, sizeof(m_TsbPdDriftHisto100us));
-    memset(m_TsbPdDriftHisto1ms, 0, sizeof(m_TsbPdDriftHisto1ms));
-#endif
-
-    setupMutex(m_BytesCountLock, "BytesCount");
-}
-
-CRcvBuffer::~CRcvBuffer()
-{
-    for (int i = 0; i < m_iSize; ++i)
-    {
-        if (m_pUnit[i] != NULL)
-        {
-            m_pUnitQueue->makeUnitFree(m_pUnit[i]);
-        }
-    }
-
-    delete[] m_pUnit;
-
-    releaseMutex(m_BytesCountLock);
-}
-
-void CRcvBuffer::countBytes(int pkts, int bytes, bool acked)
-{
-    /*
-     * Byte counter changes from both sides (Recv & Ack) of the buffer
-     * so the higher level lock is not enough for thread safe op.
-     *
-     * pkts are...
-     *  added (bytes>0, acked=false),
-     *  acked (bytes>0, acked=true),
-     *  removed (bytes<0, acked=n/a)
-     */
-    ScopedLock cg(m_BytesCountLock);
-
-    if (!acked) // adding new pkt in RcvBuffer
-    {
-        m_iBytesCount += bytes; /* added or removed bytes from rcv buffer */
-        if (bytes > 0)          /* Assuming one pkt when adding bytes */
-            m_uAvgPayloadSz = ((m_uAvgPayloadSz * (100 - 1)) + bytes) / 100;
-    }
-    else // acking/removing pkts to/from buffer
-    {
-        m_iAckedPktsCount += pkts;   /* acked or removed pkts from rcv buffer */
-        m_iAckedBytesCount += bytes; /* acked or removed bytes from rcv buffer */
-
-        if (bytes < 0)
-            m_iBytesCount += bytes; /* removed bytes from rcv buffer */
-    }
-}
-
-int CRcvBuffer::addData(CUnit* unit, int offset)
-{
-    SRT_ASSERT(unit != NULL);
-    if (offset >= getAvailBufSize())
-        return -1;
-
-    const int pos = (m_iLastAckPos + offset) % m_iSize;
-    if (offset >= m_iMaxPos)
-        m_iMaxPos = offset + 1;
-
-    if (m_pUnit[pos] != NULL)
-    {
-        HLOGC(qrlog.Debug, log << "addData: unit %" << unit->m_Packet.m_iSeqNo << " rejected, already exists");
-        return -1;
-    }
-    m_pUnit[pos] = unit;
-    countBytes(1, (int)unit->m_Packet.getLength());
-
-    m_pUnitQueue->makeUnitGood(unit);
-
-    HLOGC(qrlog.Debug,
-          log << "addData: unit %" << unit->m_Packet.m_iSeqNo << " accepted, off=" << offset << " POS=" << pos);
-    return 0;
-}
-
-int CRcvBuffer::readBuffer(char* data, int len)
-{
-    int p       = m_iStartPos;
-    int lastack = m_iLastAckPos;
-    int rs      = len;
-    IF_HEAVY_LOGGING(char* begin = data);
-
-    const steady_clock::time_point now = (m_bTsbPdMode ? steady_clock::now() : steady_clock::time_point());
-
-    HLOGC(brlog.Debug, log << CONID() << "readBuffer: start=" << p << " lastack=" << lastack);
-    while ((p != lastack) && (rs > 0))
-    {
-        if (m_pUnit[p] == NULL)
-        {
-            LOGC(brlog.Error, log << CONID() << " IPE readBuffer on null packet pointer");
-            return -1;
-        }
-
-        const CPacket& pkt = m_pUnit[p]->m_Packet;
-
-        if (m_bTsbPdMode)
-        {
-            HLOGC(brlog.Debug,
-                  log << CONID() << "readBuffer: chk if time2play:"
-                      << " NOW=" << FormatTime(now)
-                      << " PKT TS=" << FormatTime(getPktTsbPdTime(pkt.getMsgTimeStamp())));
-
-            if ((getPktTsbPdTime(pkt.getMsgTimeStamp()) > now))
-                break; /* too early for this unit, return whatever was copied */
-        }
-
-        const int pktlen = pkt.getLength();
-        const int remain_pktlen = pktlen - m_iNotch;
-
-        const int unitsize = std::min(remain_pktlen, rs);
-
-        HLOGC(brlog.Debug,
-              log << CONID() << "readBuffer: copying buffer #" << p << " targetpos=" << int(data - begin)
-                  << " sourcepos=" << m_iNotch << " size=" << unitsize << " left=" << (unitsize - rs));
-        memcpy((data), pkt.m_pcData + m_iNotch, unitsize);
-
-        data += unitsize;
-
-        if (rs >= remain_pktlen)
-        {
-            freeUnitAt(p);
-            p = shiftFwd(p);
-
-            m_iNotch = 0;
-        }
-        else
-            m_iNotch += rs;
-
-        rs -= unitsize;
-    }
-
-    /* we removed acked bytes form receive buffer */
-    countBytes(-1, -(len - rs), true);
-    m_iStartPos = p;
-
-    return len - rs;
-}
-
-int CRcvBuffer::readBufferToFile(fstream& ofs, int len)
-{
-    int p       = m_iStartPos;
-    int lastack = m_iLastAckPos;
-    int rs      = len;
-
-    int32_t trace_seq ATR_UNUSED = SRT_SEQNO_NONE;
-    int trace_shift ATR_UNUSED = -1;
-
-    while ((p != lastack) && (rs > 0))
-    {
-#if ENABLE_LOGGING
-        ++trace_shift;
-#endif
-        // Skip empty units. Note that this shouldn't happen
-        // in case of a file transfer.
-        if (!m_pUnit[p])
-        {
-            p = shiftFwd(p);
-            LOGC(brlog.Error, log << "readBufferToFile: IPE: NULL unit found in file transmission, last good %"
-                    << trace_seq << " + " << trace_shift);
-            continue;
-        }
-
-        const CPacket& pkt = m_pUnit[p]->m_Packet;
-
-#if ENABLE_LOGGING
-        trace_seq = pkt.getSeqNo();
-#endif
-        const int pktlen = pkt.getLength();
-        const int remain_pktlen = pktlen - m_iNotch;
-
-        const int unitsize = std::min(remain_pktlen, rs);
-
-        ofs.write(pkt.m_pcData + m_iNotch, unitsize);
-        if (ofs.fail())
-            break;
-
-        if (rs >= remain_pktlen)
-        {
-            freeUnitAt(p);
-            p = shiftFwd(p);
-
-            m_iNotch = 0;
-        }
-        else
-            m_iNotch += rs;
-
-        rs -= unitsize;
-    }
-
-    /* we removed acked bytes form receive buffer */
-    countBytes(-1, -(len - rs), true);
-    m_iStartPos = p;
-
-    return len - rs;
-}
-
-int CRcvBuffer::ackData(int len)
-{
-    SRT_ASSERT(len < m_iSize);
-    SRT_ASSERT(len > 0);
-    int end = shift(m_iLastAckPos, len);
-
-    {
-        int pkts  = 0;
-        int bytes = 0;
-        for (int i = m_iLastAckPos; i != end; i = shiftFwd(i))
-        {
-            if (m_pUnit[i] == NULL)
-                continue;
-
-            pkts++;
-            bytes += (int)m_pUnit[i]->m_Packet.getLength();
-        }
-        if (pkts > 0)
-            countBytes(pkts, bytes, true);
-    }
-
-    HLOGC(brlog.Debug,
-          log << "ackData: shift by " << len << ", start=" << m_iStartPos << " end=" << m_iLastAckPos << " -> " << end);
-
-    m_iLastAckPos = end;
-    m_iMaxPos -= len;
-    if (m_iMaxPos < 0)
-        m_iMaxPos = 0;
-
-    // Returned value is the distance towards the starting
-    // position from m_iLastAckPos, which is in sync with CUDT::m_iRcvLastSkipAck.
-    // This should help determine the sequence number at first read-ready position.
-
-    const int dist = m_iLastAckPos - m_iStartPos;
-    if (dist < 0)
-        return dist + m_iSize;
-    return dist;
-}
-
-void CRcvBuffer::skipData(int len)
-{
-    /*
-     * Caller need protect both AckLock and RecvLock
-     * to move both m_iStartPos and m_iLastAckPost
-     */
-    if (m_iStartPos == m_iLastAckPos)
-        m_iStartPos = (m_iStartPos + len) % m_iSize;
-    m_iLastAckPos = (m_iLastAckPos + len) % m_iSize;
-    m_iMaxPos -= len;
-    if (m_iMaxPos < 0)
-        m_iMaxPos = 0;
-}
-
-size_t CRcvBuffer::dropData(int len)
-{
-    // This function does the same as skipData, although skipData
-    // should work in the condition of absence of data, so no need
-    // to force the units in the range to be freed. This function
-    // works in more general condition where we don't know if there
-    // are any data in the given range, but want to remove these
-    // "sequence positions" from the buffer, whether there are data
-    // at them or not.
-
-    size_t stats_bytes = 0;
-
-    int p      = m_iStartPos;
-    int past_q = shift(p, len);
-    while (p != past_q)
-    {
-        if (m_pUnit[p] && m_pUnit[p]->m_iFlag == CUnit::GOOD)
-        {
-            stats_bytes += m_pUnit[p]->m_Packet.getLength();
-            freeUnitAt(p);
-        }
-
-        p = shiftFwd(p);
-    }
-
-    m_iStartPos = past_q;
-    return stats_bytes;
-}
-
-bool CRcvBuffer::getRcvFirstMsg(steady_clock::time_point& w_tsbpdtime,
-                                bool&                     w_passack,
-                                int32_t&                  w_skipseqno,
-                                int32_t&                  w_curpktseq)
-{
-    w_skipseqno = SRT_SEQNO_NONE;
-    w_passack   = false;
-    // tsbpdtime will be retrieved by the below call
-    // Returned values:
-    // - tsbpdtime: real time when the packet is ready to play (whether ready to play or not)
-    // - w_passack: false (the report concerns a packet with an exactly next sequence)
-    // - w_skipseqno == SRT_SEQNO_NONE: no packets to skip towards the first RTP
-    // - w_curpktseq: that exactly packet that is reported (for debugging purposes)
-    // - @return: whether the reported packet is ready to play
-
-    /* Check the acknowledged packets */
-    // getRcvReadyMsg returns true if the time to play for the first message
-    // (returned in w_tsbpdtime) is in the past.
-    if (getRcvReadyMsg((w_tsbpdtime), (w_curpktseq), -1))
-    {
-        HLOGC(brlog.Debug, log << "getRcvFirstMsg: ready CONTIG packet: %" << w_curpktseq);
-        return true;
-    }
-    else if (!is_zero(w_tsbpdtime))
-    {
-        HLOGC(brlog.Debug, log << "getRcvFirstMsg: packets found, but in future");
-        // This means that a message next to be played, has been found,
-        // but the time to play is in future.
-        return false;
-    }
-
-    // Falling here means that there are NO PACKETS in the ACK-ed region
-    // (m_iStartPos - m_iLastAckPos), but we may have something in the
-    // region (m_iLastAckPos - (m_iLastAckPos+m_iMaxPos)), that is, packets
-    // that may be separated from the last ACK-ed by lost ones.
-
-    // Below this line we have only two options:
-    // - m_iMaxPos == 0, which means that no more packets are in the buffer
-    //    - returned: tsbpdtime=0, w_passack=true, w_skipseqno=SRT_SEQNO_NONE, w_curpktseq=<unchanged>, @return false
-    // - m_iMaxPos > 0, which means that there are packets arrived after a lost packet:
-    //    - returned: tsbpdtime=PKT.TS, w_passack=true, w_skipseqno=PKT.SEQ, w_curpktseq=PKT, @return LOCAL(PKT.TS) <=
-    //    NOW
-
-    /*
-     * No acked packets ready but caller want to know next packet to wait for
-     * Check the not yet acked packets that may be stuck by missing packet(s).
-     */
-    bool haslost = false;
-    w_tsbpdtime  = steady_clock::time_point(); // redundant, for clarity
-    w_passack    = true;
-
-    // XXX SUSPECTED ISSUE with this algorithm:
-    // The above call to getRcvReadyMsg() should report as to whether:
-    // - there is an EXACTLY NEXT SEQUENCE packet
-    // - this packet is ready to play.
-    //
-    // Situations handled after the call are when:
-    // - there's the next sequence packet available and it is ready to play
-    // - there are no packets at all, ready to play or not
-    //
-    // So, the remaining situation is that THERE ARE PACKETS that follow
-    // the current sequence, but they are not ready to play. This includes
-    // packets that have the exactly next sequence and packets that jump
-    // over a lost packet.
-    //
-    // As the getRcvReadyMsg() function walks through the incoming units
-    // to see if there's anything that satisfies these conditions, it *SHOULD*
-    // be also capable of checking if the next available packet, if it is
-    // there, is the next sequence packet or not. Retrieving this exactly
-    // packet would be most useful, as the test for play-readiness and
-    // sequentiality can be done on it directly.
-    //
-    // When done so, the below loop would be completely unnecessary.
-
-    // Logical description of the below algorithm:
-    // 1. Check if the VERY FIRST PACKET is valid; if so then:
-    //    - check if it's ready to play, return boolean value that marks it.
-
-    for (int i = m_iLastAckPos, n = shift(m_iLastAckPos, m_iMaxPos); i != n; i = shiftFwd(i))
-    {
-        if (!m_pUnit[i] || m_pUnit[i]->m_iFlag != CUnit::GOOD)
-        {
-            /* There are packets in the sequence not received yet */
-            haslost = true;
-            HLOGC(brlog.Debug, log << "getRcvFirstMsg: empty hole at *" << i);
-        }
-        else
-        {
-            /* We got the 1st valid packet */
-            w_tsbpdtime = getPktTsbPdTime(m_pUnit[i]->m_Packet.getMsgTimeStamp());
-            if (w_tsbpdtime <= steady_clock::now())
-            {
-                /* Packet ready to play */
-                if (haslost)
-                {
-                    /*
-                     * Packet stuck on non-acked side because of missing packets.
-                     * Tell 1st valid packet seqno so caller can skip (drop) the missing packets.
-                     */
-                    w_skipseqno = m_pUnit[i]->m_Packet.m_iSeqNo;
-                    w_curpktseq = w_skipseqno;
-                }
-
-                HLOGC(brlog.Debug,
-                      log << "getRcvFirstMsg: found ready packet, nSKIPPED: "
-                          << ((i - m_iLastAckPos + m_iSize) % m_iSize));
-
-                // NOTE: if haslost is not set, it means that this is the VERY FIRST
-                // packet, that is, packet currently at pos = m_iLastAckPos. There's no
-                // possibility that it is so otherwise because:
-                // - if this first good packet is ready to play, THIS HERE RETURNS NOW.
-                // ...
-                return true;
-            }
-            HLOGC(brlog.Debug,
-                  log << "getRcvFirstMsg: found NOT READY packet, nSKIPPED: "
-                      << ((i - m_iLastAckPos + m_iSize) % m_iSize));
-            // ... and if this first good packet WASN'T ready to play, THIS HERE RETURNS NOW, TOO,
-            // just states that there's no ready packet to play.
-            // ...
-            return false;
-        }
-        // ... and if this first packet WASN'T GOOD, the loop continues, however since now
-        // the 'haslost' is set, which means that it continues only to find the first valid
-        // packet after stating that the very first packet isn't valid.
-    }
-    HLOGC(brlog.Debug, log << "getRcvFirstMsg: found NO PACKETS");
-    return false;
-}
-
-steady_clock::time_point CRcvBuffer::debugGetDeliveryTime(int offset)
-{
-    int i;
-    if (offset > 0)
-        i = shift(m_iStartPos, offset);
-    else
-        i = m_iStartPos;
-
-    CUnit* u = m_pUnit[i];
-    if (!u || u->m_iFlag != CUnit::GOOD)
-        return steady_clock::time_point();
-
-    return getPktTsbPdTime(u->m_Packet.getMsgTimeStamp());
-}
-
-int32_t CRcvBuffer::getTopMsgno() const
-{
-    if (m_iStartPos == m_iLastAckPos)
-        return SRT_MSGNO_NONE; // No message is waiting
-
-    if (!m_pUnit[m_iStartPos])
-        return SRT_MSGNO_NONE; // pity
-
-    return m_pUnit[m_iStartPos]->m_Packet.getMsgSeq();
-}
-
-bool CRcvBuffer::getRcvReadyMsg(steady_clock::time_point& w_tsbpdtime, int32_t& w_curpktseq, int upto)
-{
-    const bool havelimit = upto != -1;
-    int        end = -1, past_end = -1;
-    if (havelimit)
-    {
-        int stretch = (m_iSize + m_iStartPos - m_iLastAckPos) % m_iSize;
-        if (upto > stretch)
-        {
-            HLOGC(brlog.Debug, log << "position back " << upto << " exceeds stretch " << stretch);
-            // Do nothing. This position is already gone.
-            return false;
-        }
-
-        end = m_iLastAckPos - upto;
-        if (end < 0)
-            end += m_iSize;
-        past_end = shiftFwd(end); // For in-loop comparison
-        HLOGC(brlog.Debug, log << "getRcvReadyMsg: will read from position " << end);
-    }
-
-    // NOTE: position m_iLastAckPos in the buffer represents the sequence number of
-    // CUDT::m_iRcvLastSkipAck. Therefore 'upto' contains a positive value that should
-    // be decreased from m_iLastAckPos to get the position in the buffer that represents
-    // the sequence number up to which we'd like to read.
-    IF_HEAVY_LOGGING(const char* reason = "NOT RECEIVED");
-
-    for (int i = m_iStartPos, n = m_iLastAckPos; i != n; i = shiftFwd(i))
-    {
-        // In case when we want to read only up to given sequence number, stop
-        // the loop if this number was reached. This number must be extracted from
-        // the buffer and any following must wait here for "better times". Note
-        // that the unit that points to the requested sequence must remain in
-        // the buffer, unless there is no valid packet at that position, in which
-        // case it is allowed to point to the NEXT sequence towards it, however
-        // if it does, this cell must remain in the buffer for prospective recovery.
-        if (havelimit && i == past_end)
-            break;
-
-        bool freeunit = false;
-
-        /* Skip any invalid skipped/dropped packets */
-        if (m_pUnit[i] == NULL)
-        {
-            HLOGC(brlog.Debug,
-                  log << "getRcvReadyMsg: POS=" << i << " +" << ((i - m_iStartPos + m_iSize) % m_iSize)
-                      << " SKIPPED - no unit there");
-            m_iStartPos = shiftFwd(m_iStartPos);
-            continue;
-        }
-
-        w_curpktseq = m_pUnit[i]->m_Packet.getSeqNo();
-
-        if (m_pUnit[i]->m_iFlag != CUnit::GOOD)
-        {
-            HLOGC(brlog.Debug,
-                  log << "getRcvReadyMsg: POS=" << i << " +" << ((i - m_iStartPos + m_iSize) % m_iSize)
-                      << " SKIPPED - unit not good");
-            freeunit = true;
-        }
-        else
-        {
-            // This does:
-            // 1. Get the TSBPD time of the unit. Stop and return false if this unit
-            //    is not yet ready to play.
-            // 2. If it's ready to play, check also if it's decrypted. If not, skip it.
-            // 3. If it's ready to play and decrypted, stop and return it.
-            if (!havelimit)
-            {
-                w_tsbpdtime                         = getPktTsbPdTime(m_pUnit[i]->m_Packet.getMsgTimeStamp());
-                const steady_clock::duration towait = (w_tsbpdtime - steady_clock::now());
-                if (towait.count() > 0)
-                {
-                    HLOGC(brlog.Debug,
-                          log << "getRcvReadyMsg: POS=" << i << " +" << ((i - m_iStartPos + m_iSize) % m_iSize)
-                              << " pkt %" << w_curpktseq << " NOT ready to play (only in " << count_milliseconds(towait)
-                              << "ms)");
-                    return false;
-                }
-
-                if (m_pUnit[i]->m_Packet.getMsgCryptoFlags() != EK_NOENC)
-                {
-                    IF_HEAVY_LOGGING(reason = "DECRYPTION FAILED");
-                    freeunit = true; /* packet not decrypted */
-                }
-                else
-                {
-                    HLOGC(brlog.Debug,
-                          log << "getRcvReadyMsg: POS=" << i << " +" << ((i - m_iStartPos + m_iSize) % m_iSize)
-                              << " pkt %" << w_curpktseq << " ready to play (delayed " << count_milliseconds(towait)
-                              << "ms)");
-                    return true;
-                }
-            }
-            // In this case:
-            // 1. We don't even look into the packet if this is not the requested sequence.
-            //    All packets that are earlier than the required sequence will be dropped.
-            // 2. When found the packet with expected sequence number, and the condition for
-            //    good unit is passed, we get the timestamp.
-            // 3. If the packet is not decrypted, we allow it to be removed
-            // 4. If we reached the required sequence, and the packet is good, KEEP IT in the buffer,
-            //    and return with the pointer pointing to this very buffer. Only then return true.
-            else
-            {
-                // We have a limit up to which the reading will be done,
-                // no matter if the time has come or not - although retrieve it.
-                if (i == end)
-                {
-                    HLOGC(brlog.Debug, log << "CAUGHT required seq position " << i);
-                    // We have the packet we need. Extract its data.
-                    w_tsbpdtime = getPktTsbPdTime(m_pUnit[i]->m_Packet.getMsgTimeStamp());
-
-                    // If we have a decryption failure, allow the unit to be released.
-                    if (m_pUnit[i]->m_Packet.getMsgCryptoFlags() != EK_NOENC)
-                    {
-                        IF_HEAVY_LOGGING(reason = "DECRYPTION FAILED");
-                        freeunit = true; /* packet not decrypted */
-                    }
-                    else
-                    {
-                        // Stop here and keep the packet in the buffer, so it will be
-                        // next extracted.
-                        HLOGC(brlog.Debug,
-                              log << "getRcvReadyMsg: packet seq=" << w_curpktseq << " ready for extraction");
-                        return true;
-                    }
-                }
-                else
-                {
-                    HLOGC(brlog.Debug, log << "SKIPPING position " << i);
-                    // Continue the loop and remove the current packet because
-                    // its sequence number is too old.
-                    freeunit = true;
-                }
-            }
-        }
-
-        if (freeunit)
-        {
-            HLOGC(brlog.Debug, log << "getRcvReadyMsg: POS=" << i << " FREED");
-            /* removed skipped, dropped, undecryptable bytes from rcv buffer */
-            const int rmbytes = (int)m_pUnit[i]->m_Packet.getLength();
-            countBytes(-1, -rmbytes, true);
-
-            freeUnitAt(i);
-            m_iStartPos = shiftFwd(m_iStartPos);
-        }
-    }
-
-    HLOGC(brlog.Debug, log << "getRcvReadyMsg: nothing to deliver: " << reason);
-    return false;
-}
-
-/*
- * Return receivable data status (packet timestamp_us ready to play if TsbPd mode)
- * Return playtime (tsbpdtime) of 1st packet in queue, ready to play or not
- *
- * Return data ready to be received (packet timestamp_us ready to play if TsbPd mode)
- * Using getRcvDataSize() to know if there is something to read as it was widely
- * used in the code (core.cpp) is expensive in TsbPD mode, hence this simpler function
- * that only check if first packet in queue is ready.
- */
-bool CRcvBuffer::isRcvDataReady(steady_clock::time_point& w_tsbpdtime, int32_t& w_curpktseq, int32_t seqdistance)
-{
-    w_tsbpdtime = steady_clock::time_point();
-
-    if (m_bTsbPdMode)
-    {
-        const CPacket* pkt = getRcvReadyPacket(seqdistance);
-        if (!pkt)
-        {
-            HLOGC(brlog.Debug, log << "isRcvDataReady: packet NOT extracted.");
-            return false;
-        }
-
-        /*
-         * Acknowledged data is available,
-         * Only say ready if time to deliver.
-         * Report the timestamp, ready or not.
-         */
-        w_curpktseq = pkt->getSeqNo();
-        w_tsbpdtime = getPktTsbPdTime(pkt->getMsgTimeStamp());
-
-        // If seqdistance was passed, then return true no matter what the
-        // TSBPD time states.
-        if (seqdistance != -1 || w_tsbpdtime <= steady_clock::now())
-        {
-            HLOGC(brlog.Debug,
-                  log << "isRcvDataReady: packet extracted seqdistance=" << seqdistance
-                      << " TsbPdTime=" << FormatTime(w_tsbpdtime));
-            return true;
-        }
-
-        HLOGC(brlog.Debug, log << "isRcvDataReady: packet extracted, but NOT READY");
-        return false;
-    }
-
-    return isRcvDataAvailable();
-}
-
-// XXX This function may be called only after checking
-// if m_bTsbPdMode.
-CPacket* CRcvBuffer::getRcvReadyPacket(int32_t seqdistance)
-{
-    // If asked for readiness of a packet at given sequence distance
-    // (that is, we need to extract the packet with given sequence number),
-    // only check if this cell is occupied in the buffer, and if so,
-    // if it's occupied with a "good" unit. That's all. It doesn't
-    // matter whether it's ready to play.
-    if (seqdistance != -1)
-    {
-        // Note: seqdistance is the value to to go BACKWARDS from m_iLastAckPos,
-        // which is the position that is in sync with CUDT::m_iRcvLastSkipAck. This
-        // position is the sequence number of a packet that is NOT received, but it's
-        // expected to be received as next. So the minimum value of seqdistance is 1.
-
-        // SANITY CHECK
-        if (seqdistance == 0)
-        {
-            LOGC(brlog.Fatal, log << "IPE: trying to extract packet past the last ACK-ed!");
-            return 0;
-        }
-
-        if (seqdistance > getRcvDataSize())
-        {
-            HLOGC(brlog.Debug,
-                  log << "getRcvReadyPacket: Sequence offset=" << seqdistance
-                      << " is in the past (start=" << m_iStartPos << " end=" << m_iLastAckPos << ")");
-            return 0;
-        }
-
-        int i = shift(m_iLastAckPos, -seqdistance);
-        if (m_pUnit[i] && m_pUnit[i]->m_iFlag == CUnit::GOOD)
-        {
-            HLOGC(brlog.Debug, log << "getRcvReadyPacket: FOUND PACKET %" << m_pUnit[i]->m_Packet.getSeqNo());
-            return &m_pUnit[i]->m_Packet;
-        }
-
-        HLOGC(brlog.Debug, log << "getRcvReadyPacket: Sequence offset=" << seqdistance << " IS NOT RECEIVED.");
-        return 0;
-    }
-    IF_HEAVY_LOGGING(int nskipped = 0);
-
-    for (int i = m_iStartPos, n = m_iLastAckPos; i != n; i = shiftFwd(i))
-    {
-        /*
-         * Skip missing packets that did not arrive in time.
-         */
-        if (m_pUnit[i] && m_pUnit[i]->m_iFlag == CUnit::GOOD)
-        {
-            HLOGC(brlog.Debug,
-                  log << "getRcvReadyPacket: Found next packet seq=%" << m_pUnit[i]->m_Packet.getSeqNo() << " ("
-                      << nskipped << " empty cells skipped)");
-            return &m_pUnit[i]->m_Packet;
-        }
-        IF_HEAVY_LOGGING(++nskipped);
-    }
-
-    return 0;
-}
-
-#if ENABLE_HEAVY_LOGGING
-// This function is for debug purposes only and it's called only
-// from within HLOG* macros.
-void CRcvBuffer::reportBufferStats() const
-{
-    int     nmissing = 0;
-    int32_t low_seq = SRT_SEQNO_NONE, high_seq = SRT_SEQNO_NONE;
-    int32_t low_ts = 0, high_ts = 0;
-
-    for (int i = m_iStartPos, n = m_iLastAckPos; i != n; i = (i + 1) % m_iSize)
-    {
-        if (m_pUnit[i] && m_pUnit[i]->m_iFlag == CUnit::GOOD)
-        {
-            low_seq = m_pUnit[i]->m_Packet.m_iSeqNo;
-            low_ts  = m_pUnit[i]->m_Packet.m_iTimeStamp;
-            break;
-        }
-        ++nmissing;
-    }
-
-    // Not sure if a packet MUST BE at the last ack pos position, so check, just in case.
-    int n = m_iLastAckPos;
-    if (m_pUnit[n] && m_pUnit[n]->m_iFlag == CUnit::GOOD)
-    {
-        high_ts  = m_pUnit[n]->m_Packet.m_iTimeStamp;
-        high_seq = m_pUnit[n]->m_Packet.m_iSeqNo;
-    }
-    else
-    {
-        // Possibilities are:
-        // m_iStartPos == m_iLastAckPos, high_ts == low_ts, defined.
-        // No packet: low_ts == 0, so high_ts == 0, too.
-        high_ts = low_ts;
-    }
-    // The 32-bit timestamps are relative and roll over oftten; what
-    // we really need is the timestamp difference. The only place where
-    // we can ask for the time base is the upper time because when trying
-    // to receive the time base for the lower time we'd break the requirement
-    // for monotonic clock.
-
-    uint64_t upper_time = high_ts;
-    uint64_t lower_time = low_ts;
-
-    if (lower_time > upper_time)
-        upper_time += uint64_t(CPacket::MAX_TIMESTAMP) + 1;
-
-    int32_t timespan = upper_time - lower_time;
-    int     seqspan  = 0;
-    if (low_seq != SRT_SEQNO_NONE && high_seq != SRT_SEQNO_NONE)
-    {
-        seqspan = CSeqNo::seqoff(low_seq, high_seq);
-    }
-
-    LOGC(brlog.Debug,
-         log << "RCV BUF STATS: seqspan=%(" << low_seq << "-" << high_seq << ":" << seqspan << ") missing=" << nmissing
-             << "pkts");
-    LOGC(brlog.Debug,
-         log << "RCV BUF STATS: timespan=" << timespan << "us (lo=" << lower_time << " hi=" << upper_time << ")");
-}
-
-#endif // ENABLE_HEAVY_LOGGING
-
-bool CRcvBuffer::isRcvDataReady()
-{
-    steady_clock::time_point tsbpdtime;
-    int32_t                  seq;
-
-    return isRcvDataReady((tsbpdtime), (seq), -1);
-}
-
-int CRcvBuffer::getAvailBufSize() const
-{
-    // One slot must be empty in order to tell the difference between "empty buffer" and "full buffer"
-    return m_iSize - getRcvDataSize() - 1;
-}
-
-int CRcvBuffer::getRcvDataSize() const
-{
-    if (m_iLastAckPos >= m_iStartPos)
-        return m_iLastAckPos - m_iStartPos;
-
-    return m_iSize + m_iLastAckPos - m_iStartPos;
-}
-
-int CRcvBuffer::debugGetSize() const
-{
-    // Does exactly the same as getRcvDataSize, but
-    // it should be used FOR INFORMATIONAL PURPOSES ONLY.
-    // The source values might be changed in another thread
-    // during the calculation, although worst case the
-    // resulting value may differ to the real buffer size by 1.
-    int from = m_iStartPos, to = m_iLastAckPos;
-    int size = to - from;
-    if (size < 0)
-        size += m_iSize;
-
-    return size;
-}
-
-/* Return moving average of acked data pkts, bytes, and timespan (ms) of the receive buffer */
-int CRcvBuffer::getRcvAvgDataSize(int& bytes, int& timespan)
-{
-    // Average number of packets and timespan could be small,
-    // so rounding is beneficial, while for the number of
-    // bytes in the buffer is a higher value, so rounding can be omitted,
-    // but probably better to round all three values.
-    timespan = round_val(m_mavg.timespan_ms());
-    bytes    = round_val(m_mavg.bytes());
-    return round_val(m_mavg.pkts());
-}
-
-/* Update moving average of acked data pkts, bytes, and timespan (ms) of the receive buffer */
-void CRcvBuffer::updRcvAvgDataSize(const steady_clock::time_point& now)
-{
-    if (!m_mavg.isTimeToUpdate(now))
-        return;
-
-    int       bytes       = 0;
-    int       timespan_ms = 0;
-    const int pkts        = getRcvDataSize(bytes, timespan_ms);
-    m_mavg.update(now, pkts, bytes, timespan_ms);
-}
-
-/* Return acked data pkts, bytes, and timespan (ms) of the receive buffer */
-int CRcvBuffer::getRcvDataSize(int& bytes, int& timespan)
-{
-    timespan = 0;
-    if (m_bTsbPdMode)
-    {
-        // Get a valid startpos.
-        // Skip invalid entries in the beginning, if any.
-        int startpos = m_iStartPos;
-        for (; startpos != m_iLastAckPos; startpos = shiftFwd(startpos))
-        {
-            if ((NULL != m_pUnit[startpos]) && (CUnit::GOOD == m_pUnit[startpos]->m_iFlag))
-                break;
-        }
-
-        int endpos = m_iLastAckPos;
-
-        if (m_iLastAckPos != startpos)
-        {
-            /*
-             *     |<--- DataSpan ---->|<- m_iMaxPos ->|
-             * +---+---+---+---+---+---+---+---+---+---+---+---
-             * |   | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 1 |   |     m_pUnits[]
-             * +---+---+---+---+---+---+---+---+---+---+---+---
-             *       |                   |
-             *       \_ m_iStartPos      \_ m_iLastAckPos
-             *
-             * m_pUnits[startpos] shall be valid (->m_iFlag==CUnit::GOOD).
-             * If m_pUnits[m_iLastAckPos-1] is not valid (NULL or ->m_iFlag!=CUnit::GOOD),
-             * it means m_pUnits[m_iLastAckPos] is valid since a valid unit is needed to skip.
-             * Favor m_pUnits[m_iLastAckPos] if valid over [m_iLastAckPos-1] to include the whole acked interval.
-             */
-            if ((m_iMaxPos <= 0) || (!m_pUnit[m_iLastAckPos]) || (m_pUnit[m_iLastAckPos]->m_iFlag != CUnit::GOOD))
-            {
-                endpos = (m_iLastAckPos == 0 ? m_iSize - 1 : m_iLastAckPos - 1);
-            }
-
-            if ((NULL != m_pUnit[endpos]) && (NULL != m_pUnit[startpos]))
-            {
-                const steady_clock::time_point startstamp =
-                    getPktTsbPdTime(m_pUnit[startpos]->m_Packet.getMsgTimeStamp());
-                const steady_clock::time_point endstamp = getPktTsbPdTime(m_pUnit[endpos]->m_Packet.getMsgTimeStamp());
-                /*
-                 * There are sampling conditions where spantime is < 0 (big unsigned value).
-                 * It has been observed after changing the SRT latency from 450 to 200 on the sender.
-                 *
-                 * Possible packet order corruption when dropping packet,
-                 * cause by bad thread protection when adding packet in queue
-                 * was later discovered and fixed. Security below kept.
-                 *
-                 * DateTime                 RecvRate LostRate DropRate AvailBw     RTT   RecvBufs PdDelay
-                 * 2014-12-08T15:04:25-0500     4712      110        0   96509  33.710        393     450
-                 * 2014-12-08T15:04:35-0500     4512       95        0  107771  33.493 1496542976     200
-                 * 2014-12-08T15:04:40-0500     4213      106        3  107352  53.657    9499425     200
-                 * 2014-12-08T15:04:45-0500     4575      104        0  102194  53.614      59666     200
-                 * 2014-12-08T15:04:50-0500     4475      124        0  100543  53.526        505     200
-                 */
-                if (endstamp > startstamp)
-                    timespan = count_milliseconds(endstamp - startstamp);
-            }
-            /*
-             * Timespan can be less then 1000 us (1 ms) if few packets.
-             * Also, if there is only one pkt in buffer, the time difference will be 0.
-             * Therefore, always add 1 ms if not empty.
-             */
-            if (0 < m_iAckedPktsCount)
-                timespan += 1;
-        }
-    }
-    HLOGF(brlog.Debug, "getRcvDataSize: %6d %6d %6d ms\n", m_iAckedPktsCount, m_iAckedBytesCount, timespan);
-    bytes = m_iAckedBytesCount;
-    return m_iAckedPktsCount;
-}
-
-unsigned CRcvBuffer::getRcvAvgPayloadSize() const
-{
-    return m_uAvgPayloadSz;
-}
-
-void CRcvBuffer::dropMsg(int32_t msgno, bool using_rexmit_flag)
-{
-    for (int i = m_iStartPos, n = shift(m_iLastAckPos, m_iMaxPos); i != n; i = shiftFwd(i))
-        if ((m_pUnit[i] != NULL) && (m_pUnit[i]->m_Packet.getMsgSeq(using_rexmit_flag) == msgno))
-            m_pUnit[i]->m_iFlag = CUnit::DROPPED;
-}
-
-steady_clock::time_point CRcvBuffer::getTsbPdTimeBase(uint32_t timestamp_us)
-{
-    /*
-     * Packet timestamps wrap around every 01h11m35s (32-bit in usec)
-     * When added to the peer start time (base time),
-     * wrapped around timestamps don't provide a valid local packet delevery time.
-     *
-     * A wrap check period starts 30 seconds before the wrap point.
-     * In this period, timestamps smaller than 30 seconds are considered to have wrapped around (then adjusted).
-     * The wrap check period ends 30 seconds after the wrap point, afterwhich time base has been adjusted.
-     */
-    int64_t carryover = 0;
-
-    // This function should generally return the timebase for the given timestamp_us.
-    // It's assumed that the timestamp_us, for which this function is being called,
-    // is received as monotonic clock. This function then traces the changes in the
-    // timestamps passed as argument and catches the moment when the 64-bit timebase
-    // should be increased by a "segment length" (MAX_TIMESTAMP+1).
-
-    // The checks will be provided for the following split:
-    // [INITIAL30][FOLLOWING30]....[LAST30] <-- == CPacket::MAX_TIMESTAMP
-    //
-    // The following actions should be taken:
-    // 1. Check if this is [LAST30]. If so, ENTER TSBPD-wrap-check state
-    // 2. Then, it should turn into [INITIAL30] at some point. If so, use carryover MAX+1.
-    // 3. Then it should switch to [FOLLOWING30]. If this is detected,
-    //    - EXIT TSBPD-wrap-check state
-    //    - save the carryover as the current time base.
-
-    if (m_bTsbPdWrapCheck)
-    {
-        // Wrap check period.
-
-        if (timestamp_us < TSBPD_WRAP_PERIOD)
-        {
-            carryover = int64_t(CPacket::MAX_TIMESTAMP) + 1;
-        }
-        //
-        else if ((timestamp_us >= TSBPD_WRAP_PERIOD) && (timestamp_us <= (TSBPD_WRAP_PERIOD * 2)))
-        {
-            /* Exiting wrap check period (if for packet delivery head) */
-            m_bTsbPdWrapCheck = false;
-            m_tsTsbPdTimeBase += microseconds_from(int64_t(CPacket::MAX_TIMESTAMP) + 1);
-            LOGC(tslog.Debug,
-                 log << "tsbpd wrap period ends with ts=" << timestamp_us << " - NEW TIME BASE: "
-                     << FormatTime(m_tsTsbPdTimeBase) << " drift: " << m_DriftTracer.drift() << "us");
-        }
-    }
-    // Check if timestamp_us is in the last 30 seconds before reaching the MAX_TIMESTAMP.
-    else if (timestamp_us > (CPacket::MAX_TIMESTAMP - TSBPD_WRAP_PERIOD))
-    {
-        /* Approching wrap around point, start wrap check period (if for packet delivery head) */
-        m_bTsbPdWrapCheck = true;
-        LOGC(tslog.Debug,
-             log << "tsbpd wrap period begins with ts=" << timestamp_us << " drift: " << m_DriftTracer.drift()
-                 << "us.");
-    }
-
-    return (m_tsTsbPdTimeBase + microseconds_from(carryover));
-}
-
-void CRcvBuffer::applyGroupTime(const steady_clock::time_point& timebase,
-                                bool                            wrp,
-                                uint32_t                        delay,
-                                const steady_clock::duration&   udrift)
-{
-    // Same as setRcvTsbPdMode, but predicted to be used for group members.
-    // This synchronizes the time from the INTERNAL TIMEBASE of an existing
-    // socket's internal timebase. This is required because the initial time
-    // base stays always the same, whereas the internal timebase undergoes
-    // adjustment as the 32-bit timestamps in the sockets wrap. The socket
-    // newly added to the group must get EXACTLY the same internal timebase
-    // or otherwise the TsbPd time calculation will ship different results
-    // on different sockets.
-
-    m_bTsbPdMode = true;
-
-    m_tsTsbPdTimeBase = timebase;
-    m_bTsbPdWrapCheck = wrp;
-    m_tdTsbPdDelay    = microseconds_from(delay);
-    m_DriftTracer.forceDrift(count_microseconds(udrift));
-}
-
-void CRcvBuffer::applyGroupDrift(const steady_clock::time_point& timebase,
-                                 bool                            wrp,
-                                 const steady_clock::duration&   udrift)
-{
-    // This is only when a drift was updated on one of the group members.
-    HLOGC(brlog.Debug,
-          log << "rcv-buffer: group synch uDRIFT: " << m_DriftTracer.drift() << " -> " << FormatDuration(udrift)
-              << " TB: " << FormatTime(m_tsTsbPdTimeBase) << " -> " << FormatTime(timebase));
-
-    m_tsTsbPdTimeBase = timebase;
-    m_bTsbPdWrapCheck = wrp;
-
-    m_DriftTracer.forceDrift(count_microseconds(udrift));
-}
-
-bool CRcvBuffer::getInternalTimeBase(steady_clock::time_point& w_timebase, steady_clock::duration& w_udrift)
-{
-    w_timebase = m_tsTsbPdTimeBase;
-    w_udrift   = microseconds_from(m_DriftTracer.drift());
-    return m_bTsbPdWrapCheck;
-}
-
-steady_clock::time_point CRcvBuffer::getPktTsbPdTime(uint32_t timestamp)
-{
-    const steady_clock::time_point time_base = getTsbPdTimeBase(timestamp);
-
-    // Display only ingredients, not the result, as the result will
-    // be displayed anyway in the next logs.
-    HLOGC(brlog.Debug,
-          log << "getPktTsbPdTime: TIMEBASE=" << FormatTime(time_base) << " + dTS=" << timestamp
-              << "us + LATENCY=" << FormatDuration<DUNIT_MS>(m_tdTsbPdDelay) << " + uDRIFT=" << m_DriftTracer.drift());
-    return (time_base + m_tdTsbPdDelay + microseconds_from(timestamp + m_DriftTracer.drift()));
-}
-
-int CRcvBuffer::setRcvTsbPdMode(const steady_clock::time_point& timebase, const steady_clock::duration& delay)
-{
-    m_bTsbPdMode      = true;
-    m_bTsbPdWrapCheck = false;
-
-    // Timebase passed here comes is calculated as:
-    // >>> CTimer::getTime() - ctrlpkt->m_iTimeStamp
-    // where ctrlpkt is the packet with SRT_CMD_HSREQ message.
-    //
-    // This function is called in the HSREQ reception handler only.
-    m_tsTsbPdTimeBase = timebase;
-    // XXX Seems like this may not work correctly.
-    // At least this solution this way won't work with application-supplied
-    // timestamps. For that case the timestamps should be taken exclusively
-    // from the data packets because in case of application-supplied timestamps
-    // they come from completely different server and undergo different rules
-    // of network latency and drift.
-    m_tdTsbPdDelay = delay;
-    return 0;
-}
-
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-void CRcvBuffer::printDriftHistogram(int64_t iDrift)
-{
-    /*
-     * Build histogram of drift values
-     * First line  (ms): <=-10.0 -9.0 ... -1.0 - 0.0 + 1.0 ... 9.0 >=10.0
-     * Second line (ms):         -0.9 ... -0.1 - 0.0 + 0.1 ... 0.9
-     *  0    0    0    0    0    0    0    0    0    0 -    0 +    0    0    0    1    0    0    0    0    0    0
-     *       0    0    0    0    0    0    0    0    0 -    0 +    0    0    0    0    0    0    0    0    0
-     */
-    iDrift /= 100; // uSec to 100 uSec (0.1ms)
-    if (-10 < iDrift && iDrift < 10)
-    {
-        /* Fill 100us histogram -900 .. 900 us 100 us increments */
-        m_TsbPdDriftHisto100us[10 + iDrift]++;
-    }
-    else
-    {
-        /* Fill 1ms histogram <=-10.0, -9.0 .. 9.0, >=10.0 ms in 1 ms increments */
-        iDrift /= 10; // 100uSec to 1ms
-        if (-10 < iDrift && iDrift < 10)
-            m_TsbPdDriftHisto1ms[10 + iDrift]++;
-        else if (iDrift <= -10)
-            m_TsbPdDriftHisto1ms[0]++;
-        else
-            m_TsbPdDriftHisto1ms[20]++;
-    }
-    ++m_iTsbPdDriftNbSamples;
-    if ((m_iTsbPdDriftNbSamples % TSBPD_DRIFT_PRT_SAMPLES) == 0)
-    {
-        int* histo = m_TsbPdDriftHisto1ms;
-
-        fprintf(stderr,
-                "%4d %4d %4d %4d %4d %4d %4d %4d %4d %4d - %4d + ",
-                histo[0],
-                histo[1],
-                histo[2],
-                histo[3],
-                histo[4],
-                histo[5],
-                histo[6],
-                histo[7],
-                histo[8],
-                histo[9],
-                histo[10]);
-        fprintf(stderr,
-                "%4d %4d %4d %4d %4d %4d %4d %4d %4d %4d\n",
-                histo[11],
-                histo[12],
-                histo[13],
-                histo[14],
-                histo[15],
-                histo[16],
-                histo[17],
-                histo[18],
-                histo[19],
-                histo[20]);
-
-        histo = m_TsbPdDriftHisto100us;
-        fprintf(stderr,
-                "     %4d %4d %4d %4d %4d %4d %4d %4d %4d - %4d + ",
-                histo[1],
-                histo[2],
-                histo[3],
-                histo[4],
-                histo[5],
-                histo[6],
-                histo[7],
-                histo[8],
-                histo[9],
-                histo[10]);
-        fprintf(stderr,
-                "%4d %4d %4d %4d %4d %4d %4d %4d %4d\n",
-                histo[11],
-                histo[12],
-                histo[13],
-                histo[14],
-                histo[15],
-                histo[16],
-                histo[17],
-                histo[18],
-                histo[19]);
-
-        m_iTsbPdDriftNbSamples = 0;
-    }
-}
-
-void CRcvBuffer::printDriftOffset(int tsbPdOffset, int tsbPdDriftAvg)
-{
-    fprintf(stderr,
-            "%s: tsbpd offset=%d drift=%d usec\n",
-            FormatTime(steady_clock::now()).c_str(),
-            tsbPdOffset,
-            tsbPdDriftAvg);
-    memset(m_TsbPdDriftHisto100us, 0, sizeof(m_TsbPdDriftHisto100us));
-    memset(m_TsbPdDriftHisto1ms, 0, sizeof(m_TsbPdDriftHisto1ms));
-}
-#endif /* SRT_DEBUG_TSBPD_DRIFT */
-
-bool CRcvBuffer::addRcvTsbPdDriftSample(uint32_t                  timestamp_us,
-                                        Mutex&                    mutex_to_lock,
-                                        steady_clock::duration&   w_udrift,
-                                        steady_clock::time_point& w_newtimebase)
-{
-    if (!m_bTsbPdMode) // Not checked unless in TSBPD mode
-        return false;
-    /*
-     * TsbPD time drift correction
-     * TsbPD time slowly drift over long period depleting decoder buffer or raising latency
-     * Re-evaluate the time adjustment value using a receiver control packet (ACK-ACK).
-     * ACK-ACK timestamp is RTT/2 ago (in sender's time base)
-     * Data packet have origin time stamp which is older when retransmitted so not suitable for this.
-     *
-     * Every TSBPD_DRIFT_MAX_SAMPLES packets, the average drift is calculated
-     * if -TSBPD_DRIFT_MAX_VALUE < avgTsbPdDrift < TSBPD_DRIFT_MAX_VALUE uSec, pass drift value to RcvBuffer to adjust
-     * delevery time. if outside this range, adjust this->TsbPdTimeOffset and RcvBuffer->TsbPdTimeBase by
-     * +-TSBPD_DRIFT_MAX_VALUE uSec to maintain TsbPdDrift values in reasonable range (-5ms .. +5ms).
-     */
-
-    // Note important thing: this function is being called _EXCLUSIVELY_ in the handler
-    // of UMSG_ACKACK command reception. This means that the timestamp used here comes
-    // from the CONTROL domain, not DATA domain (timestamps from DATA domain may be
-    // either schedule time or a time supplied by the application).
-
-    const steady_clock::duration iDrift =
-        steady_clock::now() - (getTsbPdTimeBase(timestamp_us) + microseconds_from(timestamp_us));
-
-    enterCS(mutex_to_lock);
-
-    bool updated = m_DriftTracer.update(count_microseconds(iDrift));
-
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-    printDriftHistogram(count_microseconds(iDrift));
-#endif /* SRT_DEBUG_TSBPD_DRIFT */
-
-    if (updated)
-    {
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-        printDriftOffset(m_DriftTracer.overdrift(), m_DriftTracer.drift());
-#endif /* SRT_DEBUG_TSBPD_DRIFT */
-
-#if ENABLE_HEAVY_LOGGING
-        const steady_clock::time_point oldbase = m_tsTsbPdTimeBase;
-#endif
-        steady_clock::duration overdrift = microseconds_from(m_DriftTracer.overdrift());
-        m_tsTsbPdTimeBase += overdrift;
-
-        HLOGC(brlog.Debug,
-              log << "DRIFT=" << FormatDuration(iDrift) << " AVG=" << (m_DriftTracer.drift() / 1000.0)
-                  << "ms, TB: " << FormatTime(oldbase) << " EXCESS: " << FormatDuration(overdrift)
-                  << " UPDATED TO: " << FormatTime(m_tsTsbPdTimeBase));
-    }
-    else
-    {
-        HLOGC(brlog.Debug,
-              log << "DRIFT=" << FormatDuration(iDrift) << " TB REMAINS: " << FormatTime(m_tsTsbPdTimeBase));
-    }
-
-    leaveCS(mutex_to_lock);
-    w_udrift      = iDrift;
-    w_newtimebase = m_tsTsbPdTimeBase;
-    return updated;
-}
-
-int CRcvBuffer::readMsg(char* data, int len)
-{
-    SRT_MSGCTRL dummy = srt_msgctrl_default;
-    return readMsg(data, len, (dummy), -1);
-}
-
-// NOTE: The order of ref-arguments is odd because:
-// - data and len shall be close to one another
-// - upto is last because it's a kind of unusual argument that has a default value
-int CRcvBuffer::readMsg(char* data, int len, SRT_MSGCTRL& w_msgctl, int upto)
-{
-    int  p = -1, q = -1;
-    bool passack;
-
-    bool empty = accessMsg((p), (q), (passack), (w_msgctl.srctime), upto);
-    if (empty)
-        return 0;
-
-    // This should happen just once. By 'empty' condition
-    // we have a guarantee that m_pUnit[p] exists and is valid.
-    CPacket& pkt1 = m_pUnit[p]->m_Packet;
-
-    // This returns the sequence number and message number to
-    // the API caller.
-    w_msgctl.pktseq = pkt1.getSeqNo();
-    w_msgctl.msgno  = pkt1.getMsgSeq();
-
-    return extractData((data), len, p, q, passack);
-}
-
-#ifdef SRT_DEBUG_TSBPD_OUTJITTER
-void CRcvBuffer::debugTraceJitter(int64_t rplaytime)
-{
-    uint64_t now = CTimer::getTime();
-    if ((now - rplaytime) / 10 < 10)
-        m_ulPdHisto[0][(now - rplaytime) / 10]++;
-    else if ((now - rplaytime) / 100 < 10)
-        m_ulPdHisto[1][(now - rplaytime) / 100]++;
-    else if ((now - rplaytime) / 1000 < 10)
-        m_ulPdHisto[2][(now - rplaytime) / 1000]++;
-    else
-        m_ulPdHisto[3][1]++;
-}
-#endif /* SRT_DEBUG_TSBPD_OUTJITTER */
-
-bool CRcvBuffer::accessMsg(int& w_p, int& w_q, bool& w_passack, int64_t& w_playtime, int upto)
-{
-    // This function should do the following:
-    // 1. Find the first packet starting the next message (or just next packet)
-    // 2. When found something ready for extraction, return true.
-    // 3. w_p and w_q point the index range for extraction
-    // 4. passack decides if this range shall be removed after extraction
-
-    bool empty = true;
-
-    if (m_bTsbPdMode)
-    {
-        w_passack = false;
-        int seq   = 0;
-
-        steady_clock::time_point play_time;
-        const bool               isReady = getRcvReadyMsg(play_time, (seq), upto);
-        w_playtime                       = count_microseconds(play_time.time_since_epoch());
-
-        if (isReady)
-        {
-            empty = false;
-            // In TSBPD mode you always read one message
-            // at a time and a message always fits in one UDP packet,
-            // so in one "unit".
-            w_p = w_q = m_iStartPos;
-
-            debugTraceJitter(w_playtime);
-        }
-    }
-    else
-    {
-        w_playtime = 0;
-        if (scanMsg((w_p), (w_q), (w_passack)))
-            empty = false;
-    }
-
-    return empty;
-}
-
-int CRcvBuffer::extractData(char* data, int len, int p, int q, bool passack)
-{
-    SRT_ASSERT(len > 0);
-    int       rs     = len > 0 ? len : 0;
-    const int past_q = shiftFwd(q);
-    while (p != past_q)
-    {
-        const int pktlen = (int)m_pUnit[p]->m_Packet.getLength();
-        // When unitsize is less than pktlen, only a fragment is copied to the output 'data',
-        // but still the whole packet is removed from the receiver buffer.
-        if (pktlen > 0)
-            countBytes(-1, -pktlen, true);
-
-        const int unitsize = ((rs >= 0) && (pktlen > rs)) ? rs : pktlen;
-
-        HLOGC(brlog.Debug, log << "readMsg: checking unit POS=" << p);
-
-        if (unitsize > 0)
-        {
-            memcpy((data), m_pUnit[p]->m_Packet.m_pcData, unitsize);
-            data += unitsize;
-            rs -= unitsize;
-            IF_HEAVY_LOGGING(readMsgHeavyLogging(p));
-        }
-        else
-        {
-            HLOGC(brlog.Debug, log << CONID() << "readMsg: SKIPPED POS=" << p << " - ZERO SIZE UNIT");
-        }
-
-        // Note special case for live mode (one packet per message and TSBPD=on):
-        //  - p == q (that is, this loop passes only once)
-        //  - no passack (the unit is always removed from the buffer)
-        if (!passack)
-        {
-            HLOGC(brlog.Debug, log << CONID() << "readMsg: FREEING UNIT POS=" << p);
-            freeUnitAt(p);
-        }
-        else
-        {
-            HLOGC(brlog.Debug, log << CONID() << "readMsg: PASSACK UNIT POS=" << p);
-            m_pUnit[p]->m_iFlag = CUnit::PASSACK;
-        }
-
-        p = shiftFwd(p);
-    }
-
-    if (!passack)
-        m_iStartPos = past_q;
-
-    HLOGC(brlog.Debug,
-          log << "rcvBuf/extractData: begin=" << m_iStartPos << " reporting extraction size=" << (len - rs));
-
-    return len - rs;
-}
-
-string CRcvBuffer::debugTimeState(size_t first_n_pkts) const
-{
-    stringstream ss;
-    int          ipos = m_iStartPos;
-    for (size_t i = 0; i < first_n_pkts; ++i, ipos = CSeqNo::incseq(ipos))
-    {
-        const CUnit* unit = m_pUnit[ipos];
-        if (!unit)
-        {
-            ss << "pkt[" << i << "] missing, ";
-            continue;
-        }
-
-        const CPacket& pkt = unit->m_Packet;
-        ss << "pkt[" << i << "] ts=" << pkt.getMsgTimeStamp() << ", ";
-    }
-    return ss.str();
-}
-
-#if ENABLE_HEAVY_LOGGING
-void CRcvBuffer::readMsgHeavyLogging(int p)
-{
-    static steady_clock::time_point prev_now;
-    static steady_clock::time_point prev_srctime;
-    const CPacket&                  pkt = m_pUnit[p]->m_Packet;
-
-    const int32_t seq = pkt.m_iSeqNo;
-
-    steady_clock::time_point nowtime = steady_clock::now();
-    steady_clock::time_point srctime = getPktTsbPdTime(m_pUnit[p]->m_Packet.getMsgTimeStamp());
-
-    const int64_t timediff_ms    = count_milliseconds(nowtime - srctime);
-    const int64_t nowdiff_ms     = is_zero(prev_now) ? count_milliseconds(nowtime - prev_now) : 0;
-    const int64_t srctimediff_ms = is_zero(prev_srctime) ? count_milliseconds(srctime - prev_srctime) : 0;
-
-    const int next_p = shiftFwd(p);
-    CUnit*    u      = m_pUnit[next_p];
-    string    next_playtime;
-    if (u && u->m_iFlag == CUnit::GOOD)
-    {
-        next_playtime = FormatTime(getPktTsbPdTime(u->m_Packet.getMsgTimeStamp()));
-    }
-    else
-    {
-        next_playtime = "NONE";
-    }
-
-    LOGC(brlog.Debug,
-         log << CONID() << "readMsg: DELIVERED seq=" << seq << " T=" << FormatTime(srctime) << " in " << timediff_ms
-             << "ms - TIME-PREVIOUS: PKT: " << srctimediff_ms << " LOCAL: " << nowdiff_ms << " !"
-             << BufferStamp(pkt.data(), pkt.size()) << " NEXT pkt T=" << next_playtime);
-
-    prev_now     = nowtime;
-    prev_srctime = srctime;
-}
-#endif
-
-bool CRcvBuffer::scanMsg(int& w_p, int& w_q, bool& w_passack)
-{
-    // empty buffer
-    if ((m_iStartPos == m_iLastAckPos) && (m_iMaxPos <= 0))
-    {
-        HLOGC(brlog.Debug, log << "scanMsg: empty buffer");
-        return false;
-    }
-
-    int rmpkts  = 0;
-    int rmbytes = 0;
-    // skip all bad msgs at the beginning
-    // This loop rolls until the "buffer is empty" (head == tail),
-    // in particular, there's no unit accessible for the reader.
-    while (m_iStartPos != m_iLastAckPos)
-    {
-        // Roll up to the first valid unit
-        if (!m_pUnit[m_iStartPos])
-        {
-            if (++m_iStartPos == m_iSize)
-                m_iStartPos = 0;
-            continue;
-        }
-
-        // Note: PB_FIRST | PB_LAST == PB_SOLO.
-        // testing if boundary() & PB_FIRST tests if the msg is first OR solo.
-        if (m_pUnit[m_iStartPos]->m_iFlag == CUnit::GOOD && m_pUnit[m_iStartPos]->m_Packet.getMsgBoundary() & PB_FIRST)
-        {
-            bool good = true;
-
-            // look ahead for the whole message
-
-            // We expect to see either of:
-            // [PB_FIRST] [PB_SUBSEQUENT] [PB_SUBSEQUENT] [PB_LAST]
-            // [PB_SOLO]
-            // but not:
-            // [PB_FIRST] NULL ...
-            // [PB_FIRST] FREE/PASSACK/DROPPED...
-            // If the message didn't look as expected, interrupt this.
-
-            // This begins with a message starting at m_iStartPos
-            // up to m_iLastAckPos OR until the PB_LAST message is found.
-            // If any of the units on this way isn't good, this OUTER loop
-            // will be interrupted.
-            for (int i = m_iStartPos; i != m_iLastAckPos;)
-            {
-                if (!m_pUnit[i] || m_pUnit[i]->m_iFlag != CUnit::GOOD)
-                {
-                    good = false;
-                    break;
-                }
-
-                // Likewise, boundary() & PB_LAST will be satisfied for last OR solo.
-                if (m_pUnit[i]->m_Packet.getMsgBoundary() & PB_LAST)
-                    break;
-
-                if (++i == m_iSize)
-                    i = 0;
-            }
-
-            if (good)
-                break;
-        }
-
-        rmpkts++;
-        rmbytes += freeUnitAt(m_iStartPos);
-
-        m_iStartPos = shiftFwd(m_iStartPos);
-    }
-    /* we removed bytes form receive buffer */
-    countBytes(-rmpkts, -rmbytes, true);
-
-    // Not sure if this is correct, but this above 'while' loop exits
-    // under the following conditions only:
-    // - m_iStartPos == m_iLastAckPos (that makes passack = true)
-    // - found at least GOOD unit with PB_FIRST and not all messages up to PB_LAST are good,
-    //   in which case it returns with m_iStartPos <% m_iLastAckPos (earlier)
-    // Also all units that lied before m_iStartPos are removed.
-
-    w_p        = -1;          // message head
-    w_q        = m_iStartPos; // message tail
-    w_passack  = m_iStartPos == m_iLastAckPos;
-    bool found = false;
-
-    // looking for the first message
-    //>>m_pUnit[size + m_iMaxPos] is not valid
-
-    // XXX Would be nice to make some very thorough refactoring here.
-
-    // This rolls by q variable from m_iStartPos up to m_iLastAckPos,
-    // actually from the first message up to the one with PB_LAST
-    // or PB_SOLO boundary.
-
-    // The 'i' variable used in this loop is just a stub and it's
-    // even hard to define the unit here. It is "shift towards
-    // m_iStartPos", so the upper value is m_iMaxPos + size.
-    // m_iMaxPos is itself relative to m_iLastAckPos, so
-    // the upper value is m_iMaxPos + difference between
-    // m_iLastAckPos and m_iStartPos, so that this value is relative
-    // to m_iStartPos.
-    //
-    // The 'i' value isn't used anywhere, although the 'q' value rolls
-    // in this loop in sync with 'i', with the difference that 'q' is
-    // wrapped around, and 'i' is just incremented normally.
-    //
-    // This makes that this loop rolls in the range by 'q' from
-    // m_iStartPos to m_iStartPos + UPPER,
-    // where UPPER = m_iLastAckPos -% m_iStartPos + m_iMaxPos
-    // This embraces the range from the current reading head up to
-    // the last packet ever received.
-    //
-    // 'passack' is set to true when the 'q' has passed through
-    // the border of m_iLastAckPos and fallen into the range
-    // of unacknowledged packets.
-
-    for (int i = 0, n = m_iMaxPos + getRcvDataSize(); i < n; ++i)
-    {
-        if (m_pUnit[w_q] && m_pUnit[w_q]->m_iFlag == CUnit::GOOD)
-        {
-            // Equivalent pseudocode:
-            // PacketBoundary bound = m_pUnit[w_q]->m_Packet.getMsgBoundary();
-            // if ( IsSet(bound, PB_FIRST) )
-            //     w_p = w_q;
-            // if ( IsSet(bound, PB_LAST) && w_p != -1 )
-            //     found = true;
-            //
-            // Not implemented this way because it uselessly check w_p for -1
-            // also after setting it explicitly.
-
-            switch (m_pUnit[w_q]->m_Packet.getMsgBoundary())
-            {
-            case PB_SOLO: // 11
-                w_p   = w_q;
-                found = true;
-                break;
-
-            case PB_FIRST: // 10
-                w_p = w_q;
-                break;
-
-            case PB_LAST: // 01
-                if (w_p != -1)
-                    found = true;
-                break;
-
-            case PB_SUBSEQUENT:; // do nothing (caught first, rolling for last)
-            }
-        }
-        else
-        {
-            // a hole in this message, not valid, restart search
-            w_p = -1;
-        }
-
-        // 'found' is set when the current iteration hit a message with PB_LAST
-        // (including PB_SOLO since the very first message).
-        if (found)
-        {
-            // the msg has to be ack'ed or it is allowed to read out of order, and was not read before
-            if (!w_passack || !m_pUnit[w_q]->m_Packet.getMsgOrderFlag())
-            {
-                HLOGC(brlog.Debug, log << "scanMsg: found next-to-broken message, delivering OUT OF ORDER.");
-                break;
-            }
-
-            found = false;
-        }
-
-        if (++w_q == m_iSize)
-            w_q = 0;
-
-        if (w_q == m_iLastAckPos)
-            w_passack = true;
-    }
-
-    // no msg found
-    if (!found)
-    {
-        // NOTE:
-        // This situation may only happen if:
-        // - Found a packet with PB_FIRST, so w_p = w_q at the moment when it was found
-        // - Possibly found following components of that message up to shifted w_q
-        // - Found no terminal packet (PB_LAST) for that message.
-
-        // if the message is larger than the receiver buffer, return part of the message
-        if ((w_p != -1) && (shiftFwd(w_q) == w_p))
-        {
-            HLOGC(brlog.Debug, log << "scanMsg: BUFFER FULL and message is INCOMPLETE. Returning PARTIAL MESSAGE.");
-            found = true;
-        }
-        else
-        {
-            HLOGC(brlog.Debug, log << "scanMsg: PARTIAL or NO MESSAGE found: p=" << w_p << " q=" << w_q);
-        }
-    }
-    else
-    {
-        HLOGC(brlog.Debug,
-              log << "scanMsg: extracted message p=" << w_p << " q=" << w_q << " ("
-                  << ((w_q - w_p + m_iSize + 1) % m_iSize) << " packets)");
-    }
-
-    return found;
-}
diff --git a/srtcore/buffer.h b/srtcore/buffer.h
deleted file mode 100644
index 3963d3432..000000000
--- a/srtcore/buffer.h
+++ /dev/null
@@ -1,630 +0,0 @@
-/*
- * SRT - Secure, Reliable, Transport
- * Copyright (c) 2018 Haivision Systems Inc.
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
- */
-
-/*****************************************************************************
-Copyright (c) 2001 - 2009, The Board of Trustees of the University of Illinois.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the
-  above copyright notice, this list of conditions
-  and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the University of Illinois
-  nor the names of its contributors may be used to
-  endorse or promote products derived from this
-  software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*****************************************************************************/
-
-/*****************************************************************************
-written by
-   Yunhong Gu, last updated 05/05/2009
-modified by
-   Haivision Systems Inc.
-*****************************************************************************/
-
-#ifndef INC_SRT_BUFFER_H
-#define INC_SRT_BUFFER_H
-
-
-#include "udt.h"
-#include "list.h"
-#include "queue.h"
-#include "utilities.h"
-#include <fstream>
-
-// The notation used for "circular numbers" in comments:
-// The "cicrular numbers" are numbers that when increased up to the
-// maximum become zero, and similarly, when the zero value is decreased,
-// it turns into the maximum value minus one. This wrapping works the
-// same for adding and subtracting. Circular numbers cannot be multiplied.
-
-// Operations done on these numbers are marked with additional % character:
-// a %> b : a is later than b
-// a ++% (++%a) : shift a by 1 forward
-// a +% b : shift a by b
-// a == b : equality is same as for just numbers
-
-/// The AvgBufSize class is used to calculate moving average of the buffer (RCV or SND)
-class AvgBufSize
-{
-    typedef srt::sync::steady_clock::time_point time_point;
-
-public:
-    AvgBufSize()
-        : m_dBytesCountMAvg(0.0)
-        , m_dCountMAvg(0.0)
-        , m_dTimespanMAvg(0.0)
-    { }
-
-public:
-    bool isTimeToUpdate(const time_point& now) const;
-    void update(const time_point& now, int pkts, int bytes, int timespan_ms);
-
-public:
-    inline double pkts() const { return m_dCountMAvg; }
-    inline double timespan_ms() const { return m_dTimespanMAvg; }
-    inline double bytes() const { return m_dBytesCountMAvg; }
-
-private:
-    time_point m_tsLastSamplingTime;
-    double     m_dBytesCountMAvg;
-    double     m_dCountMAvg;
-    double     m_dTimespanMAvg;
-};
-
-
-class CSndBuffer
-{
-   typedef srt::sync::steady_clock::time_point time_point;
-   typedef srt::sync::steady_clock::duration duration;
-
-public:
-
-   // XXX There's currently no way to access the socket ID set for
-   // whatever the buffer is currently working for. Required to find
-   // some way to do this, possibly by having a "reverse pointer".
-   // Currently just "unimplemented".
-   std::string CONID() const { return ""; }
-
-   CSndBuffer(int size = 32, int mss = 1500);
-   ~CSndBuffer();
-
-public:
-
-      /// Insert a user buffer into the sending list.
-      /// For @a w_mctrl the following fields are used:
-      /// INPUT:
-      /// - msgttl: timeout for retransmitting the message, if lost
-      /// - inorder: request to deliver the message in order of sending
-      /// - srctime: local time as a base for packet's timestamp (0 if unused)
-      /// - pktseq: sequence number to be stamped on the packet (-1 if unused)
-      /// - msgno: message number to be stamped on the packet (-1 if unused)
-      /// OUTPUT:
-      /// - srctime: local time stamped on the packet (same as input, if input wasn't 0)
-      /// - pktseq: sequence number to be stamped on the next packet
-      /// - msgno: message number stamped on the packet
-      /// @param [in] data pointer to the user data block.
-      /// @param [in] len size of the block.
-      /// @param [inout] w_mctrl Message control data
-   void addBuffer(const char* data, int len, SRT_MSGCTRL& w_mctrl);
-
-      /// Read a block of data from file and insert it into the sending list.
-      /// @param [in] ifs input file stream.
-      /// @param [in] len size of the block.
-      /// @return actual size of data added from the file.
-
-   int addBufferFromFile(std::fstream& ifs, int len);
-
-      /// Find data position to pack a DATA packet from the furthest reading point.
-      /// @param [out] data the pointer to the data position.
-      /// @param [out] msgno message number of the packet.
-      /// @param [out] origintime origin time stamp of the message
-      /// @param [in] kflags Odd|Even crypto key flag
-      /// @return Actual length of data read.
-
-   int readData(CPacket& w_packet, time_point& w_origintime, int kflgs);
-
-      /// Find data position to pack a DATA packet for a retransmission.
-      /// @param [out] data the pointer to the data position.
-      /// @param [in] offset offset from the last ACK point (backward sequence number difference)
-      /// @param [out] msgno message number of the packet.
-      /// @param [out] origintime origin time stamp of the message
-      /// @param [out] msglen length of the message
-      /// @return Actual length of data read.
-
-   int readData(const int offset, CPacket& w_packet, time_point& w_origintime, int& w_msglen);
-
-      /// Get the time of the last retransmission (if any) of the DATA packet.
-      /// @param [in] offset offset from the last ACK point (backward sequence number difference)
-      ///
-      /// @return Last time of the last retransmission event for the corresponding DATA packet.
-
-   time_point getPacketRexmitTime(const int offset);
-
-      /// Update the ACK point and may release/unmap/return the user data according to the flag.
-      /// @param [in] offset number of packets acknowledged.
-
-   int32_t getMsgNoAt(const int offset);
-
-   void ackData(int offset);
-
-      /// Read size of data still in the sending list.
-      /// @return Current size of the data in the sending list.
-
-   int getCurrBufSize() const;
-
-   int dropLateData(int& bytes, int32_t& w_first_msgno, const time_point& too_late_time);
-
-   void updAvgBufSize(const time_point& time);
-   int getAvgBufSize(int& bytes, int& timespan);
-   int getCurrBufSize(int& bytes, int& timespan);
-
-   uint64_t getInRatePeriod() const { return m_InRatePeriod; }
-
-   /// Retrieve input bitrate in bytes per second
-   int getInputRate() const { return m_iInRateBps; }
-
-   /// Update input rate calculation.
-   /// @param [in] time   current time in microseconds
-   /// @param [in] pkts   number of packets newly added to the buffer
-   /// @param [in] bytes  number of payload bytes in those newly added packets
-   ///
-   /// @return Current size of the data in the sending list.
-   void updateInputRate(const time_point& time, int pkts = 0, int bytes = 0);
-
-
-   void resetInputRateSmpPeriod(bool disable = false)
-   {
-       setInputRateSmpPeriod(disable ? 0 : INPUTRATE_FAST_START_US);
-   }
-
-private:
-   void increase();
-   void setInputRateSmpPeriod(int period);
-
-   struct Block; // Defined below
-   static time_point getSourceTime(const CSndBuffer::Block& block);
-
-private:    // Constants
-
-    static const uint64_t INPUTRATE_FAST_START_US   =      500000;    //  500 ms
-    static const uint64_t INPUTRATE_RUNNING_US      =     1000000;    // 1000 ms
-    static const int64_t  INPUTRATE_MAX_PACKETS     =        2000;    // ~ 21 Mbps of 1316 bytes payload
-    static const int      INPUTRATE_INITIAL_BYTESPS = BW_INFINITE;
-
-private:
-   srt::sync::Mutex m_BufLock;           // used to synchronize buffer operation
-
-   struct Block
-   {
-      char* m_pcData;                   // pointer to the data block
-      int m_iLength;                    // length of the block
-
-      int32_t m_iMsgNoBitset;           // message number
-      int32_t m_iSeqNo;                 // sequence number for scheduling
-      time_point m_tsOriginTime;        // original request time
-      time_point m_tsRexmitTime;        // packet retransmission time
-      uint64_t m_llSourceTime_us;
-      int m_iTTL;                       // time to live (milliseconds)
-
-      Block* m_pNext;                   // next block
-
-      int32_t getMsgSeq()
-      {
-          // NOTE: this extracts message ID with regard to REXMIT flag.
-          // This is valid only for message ID that IS GENERATED in this instance,
-          // not provided by the peer. This can be otherwise sent to the peer - it doesn't matter
-          // for the peer that it uses LESS bits to represent the message.
-          return m_iMsgNoBitset & MSGNO_SEQ::mask;
-      }
-
-   } *m_pBlock, *m_pFirstBlock, *m_pCurrBlock, *m_pLastBlock;
-
-   // m_pBlock:         The head pointer
-   // m_pFirstBlock:    The first block
-   // m_pCurrBlock:	The current block
-   // m_pLastBlock:     The last block (if first == last, buffer is empty)
-
-   struct Buffer
-   {
-      char* m_pcData;                   // buffer
-      int m_iSize;                      // size
-      Buffer* m_pNext;                  // next buffer
-   } *m_pBuffer;                        // physical buffer
-
-   int32_t m_iNextMsgNo;                // next message number
-
-   int m_iSize;                         // buffer size (number of packets)
-   int m_iMSS;                          // maximum seqment/packet size
-
-   int m_iCount;                        // number of used blocks
-
-   int m_iBytesCount;                   // number of payload bytes in queue
-   time_point m_tsLastOriginTime;
-
-   AvgBufSize m_mavg;
-
-   int m_iInRatePktsCount;  // number of payload bytes added since InRateStartTime
-   int m_iInRateBytesCount;  // number of payload bytes added since InRateStartTime
-   time_point m_tsInRateStartTime;
-   uint64_t m_InRatePeriod; // usec
-   int m_iInRateBps;        // Input Rate in Bytes/sec
-   int m_iAvgPayloadSz;     // Average packet payload size
-
-private:
-   CSndBuffer(const CSndBuffer&);
-   CSndBuffer& operator=(const CSndBuffer&);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-
-class CRcvBuffer
-{
-    typedef srt::sync::steady_clock::time_point time_point;
-    typedef srt::sync::steady_clock::duration duration;
-
-public:
-
-    // XXX There's currently no way to access the socket ID set for
-    // whatever the queue is currently working for. Required to find
-    // some way to do this, possibly by having a "reverse pointer".
-    // Currently just "unimplemented".
-    std::string CONID() const { return ""; }
-
-   static const int DEFAULT_SIZE = 65536;
-      /// Construct the buffer.
-      /// @param [in] queue  CUnitQueue that actually holds the units (packets)
-      /// @param [in] bufsize_pkts in units (packets)
-   CRcvBuffer(CUnitQueue* queue, int bufsize_pkts = DEFAULT_SIZE);
-   ~CRcvBuffer();
-
-
-public:
-
-      /// Write data into the buffer.
-      /// @param [in] unit pointer to a data unit containing new packet
-      /// @param [in] offset offset from last ACK point.
-      /// @return 0 is success, -1 if data is repeated.
-
-   int addData(CUnit* unit, int offset);
-
-      /// Read data into a user buffer.
-      /// @param [in] data pointer to user buffer.
-      /// @param [in] len length of user buffer.
-      /// @return size of data read.
-
-   int readBuffer(char* data, int len);
-
-      /// Read data directly into file.
-      /// @param [in] file C++ file stream.
-      /// @param [in] len expected length of data to write into the file.
-      /// @return size of data read.
-
-   int readBufferToFile(std::fstream& ofs, int len);
-
-      /// Update the ACK point of the buffer.
-      /// @param [in] len number of units to be acknowledged.
-      /// @return 1 if a user buffer is fulfilled, otherwise 0.
-
-   int ackData(int len);
-
-      /// Query how many buffer space left for data receiving.
-      /// Actually only acknowledged packets, that are still in the buffer,
-      /// are considered to take buffer space.
-      ///
-      /// @return size of available buffer space (including user buffer) for data receiving.
-      ///         Not counting unacknowledged packets.
-
-   int getAvailBufSize() const;
-
-      /// Query how many data has been continuously received (for reading) and ready to play (tsbpdtime < now).
-      /// @return size of valid (continous) data for reading.
-
-   int getRcvDataSize() const;
-
-      /// Query how many data was received and acknowledged.
-      /// @param [out] bytes bytes
-      /// @param [out] spantime spantime
-      /// @return size in pkts of acked data.
-
-   int getRcvDataSize(int& bytes, int &spantime);
-
-      /// Query a 1 sec moving average of how many data was received and acknowledged.
-      /// @param [out] bytes bytes
-      /// @param [out] spantime spantime
-      /// @return size in pkts of acked data.
-
-   int getRcvAvgDataSize(int& bytes, int& spantime);
-
-      /// Query how many data of the receive buffer is acknowledged.
-      /// @param [in] now current time in us.
-      /// @return none.
-
-   void updRcvAvgDataSize(const time_point& now);
-
-      /// Query the received average payload size.
-      /// @return size (bytes) of payload size
-
-   unsigned getRcvAvgPayloadSize() const;
-
-
-      /// Mark the message to be dropped from the message list.
-      /// @param [in] msgno message number.
-      /// @param [in] using_rexmit_flag whether the MSGNO field uses rexmit flag (if not, one more bit is part of the msgno value)
-
-   void dropMsg(int32_t msgno, bool using_rexmit_flag);
-
-      /// read a message.
-      /// @param [out] data buffer to write the message into.
-      /// @param [in] len size of the buffer.
-      /// @return actuall size of data read.
-
-   int readMsg(char* data, int len);
-
-#if ENABLE_HEAVY_LOGGING
-   void readMsgHeavyLogging(int p);
-#endif
-
-      /// read a message.
-      /// @param [out] data buffer to write the message into.
-      /// @param [in] len size of the buffer.
-      /// @param [out] tsbpdtime localtime-based (uSec) packet time stamp including buffering delay
-      /// @return actuall size of data read.
-
-   int readMsg(char* data, int len, SRT_MSGCTRL& w_mctrl, int upto);
-      /// Query if data is ready to read (tsbpdtime <= now if TsbPD is active).
-      /// @param [out] tsbpdtime localtime-based (uSec) packet time stamp including buffering delay
-      ///                        of next packet in recv buffer, ready or not.
-      /// @param [out] curpktseq Sequence number of the packet if there is one ready to play
-      /// @return true if ready to play, false otherwise (tsbpdtime may be !0 in
-      /// both cases).
-
-   bool isRcvDataReady(time_point& w_tsbpdtime, int32_t& w_curpktseq, int32_t seqdistance);
-
-#ifdef SRT_DEBUG_TSBPD_OUTJITTER
-   void debugTraceJitter(int64_t);
-#else
-   void debugTraceJitter(int64_t) {}
-#endif   /* SRT_DEBUG_TSBPD_OUTJITTER */
-
-   bool isRcvDataReady();
-   bool isRcvDataAvailable()
-   {
-       return m_iLastAckPos != m_iStartPos;
-   }
-   CPacket* getRcvReadyPacket(int32_t seqdistance);
-
-      ///    Set TimeStamp-Based Packet Delivery Rx Mode
-      ///    @param [in] timebase localtime base (uSec) of packet time stamps including buffering delay
-      ///    @param [in] delay aggreed TsbPD delay
-      /// @return 0
-
-   int setRcvTsbPdMode(const time_point& timebase, const duration& delay);
-
-      /// Add packet timestamp for drift caclculation and compensation
-      /// @param [in] timestamp packet time stamp
-      /// @param [ref] lock Mutex that should be locked for the operation
-
-   bool addRcvTsbPdDriftSample(uint32_t timestamp, srt::sync::Mutex& mutex_to_lock,
-           duration& w_udrift, time_point& w_newtimebase);
-
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-   void printDriftHistogram(int64_t iDrift);
-   void printDriftOffset(int tsbPdOffset, int tsbPdDriftAvg);
-#endif
-
-      /// Get information on the 1st message in queue.
-      // Parameters (of the 1st packet queue, ready to play or not):
-      /// @param [out] w_tsbpdtime localtime-based (uSec) packet time stamp including buffering delay of 1st packet or 0 if none
-      /// @param [out] w_passack   true if 1st ready packet is not yet acknowleged (allowed to be delivered to the app)
-      /// @param [out] w_skipseqno SRT_SEQNO_NONE or seq number of 1st unacknowledged pkt ready to play preceeded by missing packets.
-      /// @retval true 1st packet ready to play (tsbpdtime <= now). Not yet acknowledged if passack == true
-      /// @retval false IF tsbpdtime = 0: rcv buffer empty; ELSE:
-      ///                   IF skipseqno != SRT_SEQNO_NONE, packet ready to play preceeded by missing packets.;
-      ///                   IF skipseqno == SRT_SEQNO_NONE, no missing packet but 1st not ready to play.
-
-
-   bool getRcvFirstMsg(time_point& w_tsbpdtime, bool& w_passack, int32_t& w_skipseqno, int32_t& w_curpktseq);
-
-      /// Update the ACK point of the buffer.
-      /// @param [in] len size of data to be skip & acknowledged.
-
-   void skipData(int len);
-
-#if ENABLE_HEAVY_LOGGING
-   void reportBufferStats() const; // Heavy logging Debug only
-#endif
-   bool empty() const
-   {
-       // This will not always return the intended value,
-       // that is, it may return false when the buffer really is
-       // empty - but it will return true then in one of next calls.
-       // This function will be always called again at some point
-       // if it returned false, and on true the connection
-       // is going to be broken - so this behavior is acceptable.
-       return m_iStartPos == m_iLastAckPos;
-   }
-   bool full() const { return m_iStartPos == (m_iLastAckPos+1)%m_iSize; }
-   int capacity() const { return m_iSize; }
-
-
-private:
-   /// This gives up unit at index p. The unit is given back to the
-   /// free unit storage for further assignment for the new incoming
-   /// data.
-   size_t freeUnitAt(size_t p)
-   {
-       CUnit* u = m_pUnit[p];
-       m_pUnit[p] = NULL;
-       size_t rmbytes = u->m_Packet.getLength();
-       m_pUnitQueue->makeUnitFree(u);
-       return rmbytes;
-   }
-
-      /// Adjust receive queue to 1st ready to play message (tsbpdtime < now).
-      // Parameters (of the 1st packet queue, ready to play or not):
-      /// @param [out] tsbpdtime localtime-based (uSec) packet time stamp including buffering delay of 1st packet or 0 if none
-      /// @retval true 1st packet ready to play without discontinuity (no hole)
-      /// @retval false tsbpdtime = 0: no packet ready to play
-
-
-   bool getRcvReadyMsg(time_point& w_tsbpdtime, int32_t& w_curpktseq, int upto);
-
-public:
-
-      // (This is exposed as used publicly in logs)
-      /// Get packet delivery local time base (adjusted for wrap around)
-      /// @param [in] timestamp packet timestamp (relative to peer StartTime), wrapping around every ~72 min
-      /// @return local delivery time (usec)
-
-   time_point getTsbPdTimeBase(uint32_t timestamp_us);
-
-   int64_t getDrift() const { return m_DriftTracer.drift(); }
-
-public:
-   int32_t getTopMsgno() const;
-
-   // @return Wrap check value
-   bool getInternalTimeBase(time_point& w_tb, duration& w_udrift);
-
-   void applyGroupTime(const time_point& timebase, bool wrapcheck, uint32_t delay, const duration& udrift);
-   void applyGroupDrift(const time_point& timebase, bool wrapcheck, const duration& udrift);
-   time_point getPktTsbPdTime(uint32_t timestamp);
-   int debugGetSize() const;
-   time_point debugGetDeliveryTime(int offset);
-
-   size_t dropData(int len);
-
-private:
-   int extractData(char *data, int len, int p, int q, bool passack);
-   bool accessMsg(int& w_p, int& w_q, bool& w_passack, int64_t& w_playtime, int upto);
-
-   /// Describes the state of the first N packets
-   std::string debugTimeState(size_t first_n_pkts) const;
-   
-   /// thread safe bytes counter of the Recv & Ack buffer
-   /// @param [in] pkts  acked or removed pkts from rcv buffer (used with acked = true)
-   /// @param [in] bytes number of bytes added/delete (if negative) to/from rcv buffer.
-   /// @param [in] acked true when adding new pkt in RcvBuffer; false when acking/removing pkts to/from buffer
-
-   void countBytes(int pkts, int bytes, bool acked = false);
-
-private:
-   bool scanMsg(int& w_start, int& w_end, bool& w_passack);
-
-   int shift(int basepos, int shift) const
-   {
-       return (basepos + shift) % m_iSize;
-   }
-
-   // Simplified versions with ++ and --; avoid using division instruction
-   int shiftFwd(int basepos) const
-   {
-       if (++basepos == m_iSize)
-           return 0;
-       return basepos;
-   }
-
-   int shiftBack(int basepos) const
-   {
-       if (basepos == 0)
-           return m_iSize-1;
-       return --basepos;
-   }
-
-private:
-   CUnit** m_pUnit;                     // Array of pointed units collected in the buffer
-   const int m_iSize;                   // Size of the internal array of CUnit* items
-   CUnitQueue* m_pUnitQueue;            // the shared unit queue
-
-   int m_iStartPos;                     // HEAD: first packet available for reading
-   int m_iLastAckPos;                   // the last ACKed position (exclusive), follows the last readable
-                                        // EMPTY: m_iStartPos = m_iLastAckPos   FULL: m_iStartPos = m_iLastAckPos + 1
-   int m_iMaxPos;                       // delta between acked-TAIL and reception-TAIL
-
-
-   int m_iNotch;                        // the starting read point of the first unit
-                                        // (this is required for stream reading mode; it's
-                                        // the position in the first unit in the list
-                                        // up to which data are already retrieved;
-                                        // in message reading mode it's unused and always 0)
-
-   srt::sync::Mutex m_BytesCountLock;   // used to protect counters operations
-   int m_iBytesCount;                   // Number of payload bytes in the buffer
-   int m_iAckedPktsCount;               // Number of acknowledged pkts in the buffer
-   int m_iAckedBytesCount;              // Number of acknowledged payload bytes in the buffer
-   unsigned m_uAvgPayloadSz;           // Average payload size for dropped bytes estimation
-
-   bool m_bTsbPdMode;                   // true: apply TimeStamp-Based Rx Mode
-   duration m_tdTsbPdDelay;        // aggreed delay
-   time_point m_tsTsbPdTimeBase;   // localtime base for TsbPd mode
-   // Note: m_tsTsbPdTimeBase cumulates values from:
-   // 1. Initial SRT_CMD_HSREQ packet returned value diff to current time:
-   //    == (NOW - PACKET_TIMESTAMP), at the time of HSREQ reception
-   // 2. Timestamp overflow (@c CRcvBuffer::getTsbPdTimeBase), when overflow on packet detected
-   //    += CPacket::MAX_TIMESTAMP+1 (it's a hex round value, usually 0x1*e8).
-   // 3. Time drift (CRcvBuffer::addRcvTsbPdDriftSample, executed exclusively
-   //    from UMSG_ACKACK handler). This is updated with (positive or negative) TSBPD_DRIFT_MAX_VALUE
-   //    once the value of average drift exceeds this value in whatever direction.
-   //    += (+/-)CRcvBuffer::TSBPD_DRIFT_MAX_VALUE
-   //
-   // XXX Application-supplied timestamps won't work therefore. This requires separate
-   // calculation of all these things above.
-
-   bool m_bTsbPdWrapCheck;              // true: check packet time stamp wrap around
-   static const uint32_t TSBPD_WRAP_PERIOD = (30*1000000);    //30 seconds (in usec)
-
-   /// Max drift (usec) above which TsbPD Time Offset is adjusted
-   static const int TSBPD_DRIFT_MAX_VALUE = 5000;
-   /// Number of samples (UMSG_ACKACK packets) to perform drift caclulation and compensation
-   static const int TSBPD_DRIFT_MAX_SAMPLES = 1000;
-   DriftTracer<TSBPD_DRIFT_MAX_SAMPLES, TSBPD_DRIFT_MAX_VALUE> m_DriftTracer;
-   AvgBufSize m_mavg;
-#ifdef SRT_DEBUG_TSBPD_DRIFT
-   int m_TsbPdDriftHisto100us[22];              // Histogram of 100us TsbPD drift (-1.0 .. +1.0 ms in 0.1ms increment)
-   int m_TsbPdDriftHisto1ms[22];                // Histogram of TsbPD drift (-10.0 .. +10.0 ms, in 1.0 ms increment)
-   int m_iTsbPdDriftNbSamples = 0;              // Number of samples in sum and histogram
-   static const int TSBPD_DRIFT_PRT_SAMPLES = 200;    // Number of samples (UMSG_ACKACK packets) to print hostogram
-#endif /* SRT_DEBUG_TSBPD_DRIFT */
-
-#ifdef SRT_DEBUG_TSBPD_OUTJITTER
-   unsigned long m_ulPdHisto[4][10];
-#endif /* SRT_DEBUG_TSBPD_OUTJITTER */
-
-private:
-   CRcvBuffer();
-   CRcvBuffer(const CRcvBuffer&);
-   CRcvBuffer& operator=(const CRcvBuffer&);
-};
-
-
-#endif
diff --git a/srtcore/buffer_rcv.cpp b/srtcore/buffer_rcv.cpp
new file mode 100644
index 000000000..363bd7e9c
--- /dev/null
+++ b/srtcore/buffer_rcv.cpp
@@ -0,0 +1,1172 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2009, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+#include <cmath>
+#include <limits>
+#include "buffer_rcv.h"
+#include "logging.h"
+
+using namespace std;
+
+using namespace srt::sync;
+using namespace srt_logging;
+namespace srt_logging
+{
+    extern Logger brlog;
+}
+#define rbuflog brlog
+
+namespace srt {
+
+namespace {
+    struct ScopedLog
+    {
+        ScopedLog() {}
+
+        ~ScopedLog()
+        {
+            LOGC(rbuflog.Warn, log << ss.str());
+        }
+
+        stringstream ss;
+    };
+
+#define IF_RCVBUF_DEBUG(instr) (void)0
+
+    // Check if iFirstNonreadPos is in range [iStartPos, (iStartPos + iMaxPosOff) % iSize].
+    // The right edge is included because we expect iFirstNonreadPos to be
+    // right after the last valid packet position if all packets are available.
+    bool isInRange(int iStartPos, int iMaxPosOff, size_t iSize, int iFirstNonreadPos)
+    {
+        if (iFirstNonreadPos == iStartPos)
+            return true;
+
+        const int iLastPos = (iStartPos + iMaxPosOff) % iSize;
+        const bool isOverrun = iLastPos < iStartPos;
+
+        if (isOverrun)
+            return iFirstNonreadPos > iStartPos || iFirstNonreadPos <= iLastPos;
+
+        return iFirstNonreadPos > iStartPos && iFirstNonreadPos <= iLastPos;
+    }
+}
+
+
+/*
+ *   RcvBufferNew (circular buffer):
+ *
+ *   |<------------------- m_iSize ----------------------------->|
+ *   |       |<----------- m_iMaxPosOff ------------>|           |
+ *   |       |                                       |           |
+ *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
+ *   | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 0 |...| 0 | m_pUnit[]
+ *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
+ *             |                                   |
+ *             |                                   |__last pkt received
+ *             |___ m_iStartPos: first message to read
+ *
+ *   m_pUnit[i]->m_iFlag: 0:free, 1:good, 2:passack, 3:dropped
+ *
+ *   thread safety:
+ *    m_iStartPos:   CUDT::m_RecvLock
+ *    m_iLastAckPos: CUDT::m_AckLock
+ *    m_iMaxPosOff:     none? (modified on add and ack
+ */
+
+CRcvBuffer::CRcvBuffer(int initSeqNo, size_t size, CUnitQueue* unitqueue, bool bMessageAPI)
+    : m_entries(size)
+    , m_szSize(size) // TODO: maybe just use m_entries.size()
+    , m_pUnitQueue(unitqueue)
+    , m_iStartSeqNo(initSeqNo)
+    , m_iStartPos(0)
+    , m_iFirstNonreadPos(0)
+    , m_iMaxPosOff(0)
+    , m_iNotch(0)
+    , m_numOutOfOrderPackets(0)
+    , m_iFirstReadableOutOfOrder(-1)
+    , m_bPeerRexmitFlag(true)
+    , m_bMessageAPI(bMessageAPI)
+    , m_iBytesCount(0)
+    , m_iPktsCount(0)
+    , m_uAvgPayloadSz(0)
+{
+    SRT_ASSERT(size < size_t(std::numeric_limits<int>::max())); // All position pointers are integers
+}
+
+CRcvBuffer::~CRcvBuffer()
+{
+    // Can be optimized by only iterating m_iMaxPosOff from m_iStartPos.
+    for (FixedArray<Entry>::iterator it = m_entries.begin(); it != m_entries.end(); ++it)
+    {
+        if (!it->pUnit)
+            continue;
+        
+        m_pUnitQueue->makeUnitFree(it->pUnit);
+        it->pUnit = NULL;
+    }
+}
+
+int CRcvBuffer::insert(CUnit* unit)
+{
+    SRT_ASSERT(unit != NULL);
+    const int32_t seqno  = unit->m_Packet.getSeqNo();
+    const int     offset = CSeqNo::seqoff(m_iStartSeqNo, seqno);
+
+    IF_RCVBUF_DEBUG(ScopedLog scoped_log);
+    IF_RCVBUF_DEBUG(scoped_log.ss << "CRcvBuffer::insert: seqno " << seqno);
+    IF_RCVBUF_DEBUG(scoped_log.ss << " msgno " << unit->m_Packet.getMsgSeq(m_bPeerRexmitFlag));
+    IF_RCVBUF_DEBUG(scoped_log.ss << " m_iStartSeqNo " << m_iStartSeqNo << " offset " << offset);
+
+    if (offset < 0)
+    {
+        IF_RCVBUF_DEBUG(scoped_log.ss << " returns -2");
+        return -2;
+    }
+
+    if (offset >= (int)capacity())
+    {
+        IF_RCVBUF_DEBUG(scoped_log.ss << " returns -3");
+        return -3;
+    }
+
+    // TODO: Don't do assert here. Process this situation somehow.
+    // If >= 2, then probably there is a long gap, and buffer needs to be reset.
+    SRT_ASSERT((m_iStartPos + offset) / m_szSize < 2);
+
+    const int pos = (m_iStartPos + offset) % m_szSize;
+    if (offset >= m_iMaxPosOff)
+        m_iMaxPosOff = offset + 1;
+
+    // Packet already exists
+    SRT_ASSERT(pos >= 0 && pos < int(m_szSize));
+    if (m_entries[pos].status != EntryState_Empty)
+    {
+        IF_RCVBUF_DEBUG(scoped_log.ss << " returns -1");
+        return -1;
+    }
+    SRT_ASSERT(m_entries[pos].pUnit == NULL);
+
+    m_pUnitQueue->makeUnitTaken(unit);
+    m_entries[pos].pUnit  = unit;
+    m_entries[pos].status = EntryState_Avail;
+    countBytes(1, (int)unit->m_Packet.getLength());
+
+    // If packet "in order" flag is zero, it can be read out of order.
+    // With TSBPD enabled packets are always assumed in order (the flag is ignored).
+    if (!m_tsbpd.isEnabled() && m_bMessageAPI && !unit->m_Packet.getMsgOrderFlag())
+    {
+        ++m_numOutOfOrderPackets;
+        onInsertNotInOrderPacket(pos);
+    }
+
+    updateNonreadPos();
+    IF_RCVBUF_DEBUG(scoped_log.ss << " returns 0 (OK)");
+    return 0;
+}
+
+std::pair<int, int> CRcvBuffer::dropUpTo(int32_t seqno)
+{
+    IF_RCVBUF_DEBUG(ScopedLog scoped_log);
+    IF_RCVBUF_DEBUG(scoped_log.ss << "CRcvBuffer::dropUpTo: seqno " << seqno << " m_iStartSeqNo " << m_iStartSeqNo);
+
+    int len = CSeqNo::seqoff(m_iStartSeqNo, seqno);
+    if (len <= 0)
+    {
+        IF_RCVBUF_DEBUG(scoped_log.ss << ". Nothing to drop.");
+        return std::make_pair(0, 0);
+    }
+
+    m_iMaxPosOff -= len;
+    if (m_iMaxPosOff < 0)
+        m_iMaxPosOff = 0;
+
+    int iNumDropped = 0; // Number of dropped packets that were missing.
+    int iNumDiscarded = 0; // The number of dropped packets that existed in the buffer.
+    while (len > 0)
+    {
+        // Note! Dropping a EntryState_Read must not be counted as a drop because it was read.
+        // Note! Dropping a EntryState_Drop must not be counted as a drop because it was already dropped and counted earlier.
+        if (m_entries[m_iStartPos].status == EntryState_Avail)
+			++iNumDiscarded;
+        else if (m_entries[m_iStartPos].status == EntryState_Empty)
+			++iNumDropped;
+        dropUnitInPos(m_iStartPos);
+        m_entries[m_iStartPos].status = EntryState_Empty;
+        SRT_ASSERT(m_entries[m_iStartPos].pUnit == NULL && m_entries[m_iStartPos].status == EntryState_Empty);
+        m_iStartPos = incPos(m_iStartPos);
+        --len;
+    }
+
+    // Update positions
+    m_iStartSeqNo = seqno;
+    // Move forward if there are "read/drop" entries.
+    releaseNextFillerEntries();
+
+    // If the nonread position is now behind the starting position, set it to the starting position and update.
+    // Preceding packets were likely missing, and the non read position can probably be moved further now.
+    if (!isInRange(m_iStartPos, m_iMaxPosOff, m_szSize, m_iFirstNonreadPos))
+    {
+        m_iFirstNonreadPos = m_iStartPos;
+        updateNonreadPos();
+    }
+    if (!m_tsbpd.isEnabled() && m_bMessageAPI)
+        updateFirstReadableOutOfOrder();
+    return std::make_pair(iNumDropped, iNumDiscarded);
+}
+
+int CRcvBuffer::dropAll()
+{
+    if (empty())
+        return 0;
+
+    const int end_seqno = CSeqNo::incseq(m_iStartSeqNo, m_iMaxPosOff);
+    const std::pair<int, int> numDropped = dropUpTo(end_seqno);
+    return numDropped.first + numDropped.second;
+}
+
+int CRcvBuffer::dropMessage(int32_t seqnolo, int32_t seqnohi, int32_t msgno, DropActionIfExists actionOnExisting)
+{
+    IF_RCVBUF_DEBUG(ScopedLog scoped_log);
+    IF_RCVBUF_DEBUG(scoped_log.ss << "CRcvBuffer::dropMessage(): %(" << seqnolo << " - " << seqnohi << ")"
+                                  << " #" << msgno << " actionOnExisting=" << actionOnExisting << " m_iStartSeqNo=%"
+                                  << m_iStartSeqNo);
+
+    // Drop by packet seqno range to also wipe those packets that do not exist in the buffer.
+    const int offset_a = CSeqNo::seqoff(m_iStartSeqNo, seqnolo);
+    const int offset_b = CSeqNo::seqoff(m_iStartSeqNo, seqnohi);
+    if (offset_b < 0)
+    {
+        LOGC(rbuflog.Debug, log << "CRcvBuffer.dropMessage(): nothing to drop. Requested [" << seqnolo << "; "
+            << seqnohi << "]. Buffer start " << m_iStartSeqNo << ".");
+        return 0;
+    }
+
+    const bool bKeepExisting = (actionOnExisting == KEEP_EXISTING);
+    int minDroppedOffset = -1;
+    int iDropCnt = 0;
+    const int start_off = max(0, offset_a);
+    const int start_pos = incPos(m_iStartPos, start_off);
+    const int end_off = min((int) m_szSize - 1, offset_b + 1);
+    const int end_pos = incPos(m_iStartPos, end_off);
+    bool bDropByMsgNo = msgno > SRT_MSGNO_CONTROL; // Excluding both SRT_MSGNO_NONE (-1) and SRT_MSGNO_CONTROL (0).
+    for (int i = start_pos; i != end_pos; i = incPos(i))
+    {
+        // Check if the unit was already dropped earlier.
+        if (m_entries[i].status == EntryState_Drop)
+            continue;
+
+        if (m_entries[i].pUnit)
+        {
+            const PacketBoundary bnd = packetAt(i).getMsgBoundary();
+
+            // Don't drop messages, if all its packets are already in the buffer.
+            // TODO: Don't drop a several-packet message if all packets are in the buffer.
+            if (bKeepExisting && bnd == PB_SOLO)
+            {
+                bDropByMsgNo = false; // Solo packet, don't search for the rest of the message.
+                LOGC(rbuflog.Debug,
+                     log << "CRcvBuffer::dropMessage(): Skipped dropping an existing SOLO packet %"
+                         << packetAt(i).getSeqNo() << ".");
+                continue;
+            }
+
+            const int32_t msgseq = packetAt(i).getMsgSeq(m_bPeerRexmitFlag);
+            if (msgno > SRT_MSGNO_CONTROL && msgseq != msgno)
+            {
+                LOGC(rbuflog.Warn, log << "CRcvBuffer.dropMessage(): Packet seqno %" << packetAt(i).getSeqNo() << " has msgno " << msgseq << " differs from requested " << msgno);
+            }
+
+            if (bDropByMsgNo && bnd == PB_FIRST)
+            {
+                // First packet of the message is about to be dropped. That was the only reason to search for msgno.
+                bDropByMsgNo = false;
+            }
+        }
+
+        dropUnitInPos(i);
+        ++iDropCnt;
+        m_entries[i].status = EntryState_Drop;
+        if (minDroppedOffset == -1)
+            minDroppedOffset = offPos(m_iStartPos, i);
+    }
+
+    if (bDropByMsgNo)
+    {
+        // If msgno is specified, potentially not the whole message was dropped using seqno range.
+        // The sender might have removed the first packets of the message, and thus @a seqnolo may point to a packet in the middle.
+        // The sender should have the last packet of the message it is requesting to be dropped.
+        // Therefore we don't search forward, but need to check earlier packets in the RCV buffer.
+        // Try to drop by the message number in case the message starts earlier than @a seqnolo.
+        const int stop_pos = decPos(m_iStartPos);
+        for (int i = start_pos; i != stop_pos; i = decPos(i))
+        {
+            // Can't drop if message number is not known.
+            if (!m_entries[i].pUnit) // also dropped earlier.
+                continue;
+
+            const PacketBoundary bnd = packetAt(i).getMsgBoundary();
+            const int32_t msgseq = packetAt(i).getMsgSeq(m_bPeerRexmitFlag);
+            if (msgseq != msgno)
+                break;            
+
+            if (bKeepExisting && bnd == PB_SOLO)
+            {
+                LOGC(rbuflog.Debug,
+                     log << "CRcvBuffer::dropMessage(): Skipped dropping an existing SOLO message packet %"
+                         << packetAt(i).getSeqNo() << ".");
+                break;
+            }
+
+            ++iDropCnt;
+            dropUnitInPos(i);
+            m_entries[i].status = EntryState_Drop;
+            // As the search goes backward, i is always earlier than minDroppedOffset.
+            minDroppedOffset = offPos(m_iStartPos, i);
+
+            // Break the loop if the start of the message has been found. No need to search further.
+            if (bnd == PB_FIRST)
+                break;
+        }
+        IF_RCVBUF_DEBUG(scoped_log.ss << " iDropCnt " << iDropCnt);
+    }
+
+    // Check if units before m_iFirstNonreadPos are dropped.
+    const bool needUpdateNonreadPos = (minDroppedOffset != -1 && minDroppedOffset <= getRcvDataSize());
+    releaseNextFillerEntries();
+    if (needUpdateNonreadPos)
+    {
+        m_iFirstNonreadPos = m_iStartPos;
+        updateNonreadPos();
+    }
+    if (!m_tsbpd.isEnabled() && m_bMessageAPI)
+    {
+        if (!checkFirstReadableOutOfOrder())
+            m_iFirstReadableOutOfOrder = -1;
+        updateFirstReadableOutOfOrder();
+    }
+
+    return iDropCnt;
+}
+
+int CRcvBuffer::readMessage(char* data, size_t len, SRT_MSGCTRL* msgctrl)
+{
+    const bool canReadInOrder = hasReadableInorderPkts();
+    if (!canReadInOrder && m_iFirstReadableOutOfOrder < 0)
+    {
+        LOGC(rbuflog.Warn, log << "CRcvBuffer.readMessage(): nothing to read. Ignored isRcvDataReady() result?");
+        return 0;
+    }
+
+    const int readPos = canReadInOrder ? m_iStartPos : m_iFirstReadableOutOfOrder;
+
+    IF_RCVBUF_DEBUG(ScopedLog scoped_log);
+    IF_RCVBUF_DEBUG(scoped_log.ss << "CRcvBuffer::readMessage. m_iStartSeqNo " << m_iStartSeqNo << " m_iStartPos " << m_iStartPos << " readPos " << readPos);
+
+    size_t remain = len;
+    char* dst = data;
+    int    pkts_read = 0;
+    int    bytes_extracted = 0; // The total number of bytes extracted from the buffer.
+    const bool updateStartPos = (readPos == m_iStartPos); // Indicates if the m_iStartPos can be changed
+    for (int i = readPos;; i = incPos(i))
+    {
+        SRT_ASSERT(m_entries[i].pUnit);
+        if (!m_entries[i].pUnit)
+        {
+            LOGC(rbuflog.Error, log << "CRcvBuffer::readMessage(): null packet encountered.");
+            break;
+        }
+
+        const CPacket& packet  = packetAt(i);
+        const size_t   pktsize = packet.getLength();
+        const int32_t pktseqno = packet.getSeqNo();
+
+        // unitsize can be zero
+        const size_t unitsize = std::min(remain, pktsize);
+        memcpy(dst, packet.m_pcData, unitsize);
+        remain -= unitsize;
+        dst += unitsize;
+
+        ++pkts_read;
+        bytes_extracted += (int) pktsize;
+
+        if (m_tsbpd.isEnabled())
+            updateTsbPdTimeBase(packet.getMsgTimeStamp());
+
+        if (m_numOutOfOrderPackets && !packet.getMsgOrderFlag())
+            --m_numOutOfOrderPackets;
+
+        const bool pbLast  = packet.getMsgBoundary() & PB_LAST;
+        if (msgctrl && (packet.getMsgBoundary() & PB_FIRST))
+        {
+            msgctrl->msgno  = packet.getMsgSeq(m_bPeerRexmitFlag);
+        }
+        if (msgctrl && pbLast)
+        {
+            msgctrl->srctime = count_microseconds(getPktTsbPdTime(packet.getMsgTimeStamp()).time_since_epoch());
+        }
+        if (msgctrl)
+            msgctrl->pktseq = pktseqno;
+
+        releaseUnitInPos(i);
+        if (updateStartPos)
+        {
+            m_iStartPos = incPos(i);
+            --m_iMaxPosOff;
+            SRT_ASSERT(m_iMaxPosOff >= 0);
+            m_iStartSeqNo = CSeqNo::incseq(pktseqno);
+        }
+        else
+        {
+            // If out of order, only mark it read.
+            m_entries[i].status = EntryState_Read;
+        }
+
+        if (pbLast)
+        {
+            if (readPos == m_iFirstReadableOutOfOrder)
+                m_iFirstReadableOutOfOrder = -1;
+            break;
+        }
+    }
+
+    countBytes(-pkts_read, -bytes_extracted);
+
+    releaseNextFillerEntries();
+
+    if (!isInRange(m_iStartPos, m_iMaxPosOff, m_szSize, m_iFirstNonreadPos))
+    {
+        m_iFirstNonreadPos = m_iStartPos;
+        //updateNonreadPos();
+    }
+
+    if (!m_tsbpd.isEnabled())
+        // We need updateFirstReadableOutOfOrder() here even if we are reading inorder,
+        // incase readable inorder packets are all read out.
+        updateFirstReadableOutOfOrder();
+
+    const int bytes_read = int(dst - data);
+    if (bytes_read < bytes_extracted)
+    {
+        LOGC(rbuflog.Error, log << "readMessage: small dst buffer, copied only " << bytes_read << "/" << bytes_extracted << " bytes.");
+    }
+
+    IF_RCVBUF_DEBUG(scoped_log.ss << " pldi64 " << *reinterpret_cast<uint64_t*>(data));
+
+    return bytes_read;
+}
+
+namespace {
+    /// @brief Writes bytes to file stream.
+    /// @param data pointer to data to write.
+    /// @param len the number of bytes to write
+    /// @param dst_offset ignored
+    /// @param arg a void pointer to the fstream to write to.
+    /// @return true on success, false on failure
+    bool writeBytesToFile(char* data, int len, int dst_offset SRT_ATR_UNUSED, void* arg)
+    {
+        fstream* pofs = reinterpret_cast<fstream*>(arg);
+        pofs->write(data, len);
+        return !pofs->fail();
+    }
+
+    /// @brief Copies bytes to the destination buffer.
+    /// @param data pointer to data to copy.
+    /// @param len the number of bytes to copy
+    /// @param dst_offset offset in destination buffer
+    /// @param arg A pointer to the destination buffer
+    /// @return true on success, false on failure
+    bool copyBytesToBuf(char* data, int len, int dst_offset, void* arg)
+    {
+        char* dst = reinterpret_cast<char*>(arg) + dst_offset;
+        memcpy(dst, data, len);
+        return true;
+    }
+}
+
+int CRcvBuffer::readBufferTo(int len, copy_to_dst_f funcCopyToDst, void* arg)
+{
+    int p = m_iStartPos;
+    const int end_pos = m_iFirstNonreadPos;
+
+    const bool bTsbPdEnabled = m_tsbpd.isEnabled();
+    const steady_clock::time_point now = (bTsbPdEnabled ? steady_clock::now() : steady_clock::time_point());
+
+    int rs = len;
+    while ((p != end_pos) && (rs > 0))
+    {
+        if (!m_entries[p].pUnit)
+        {
+            p = incPos(p);
+            LOGC(rbuflog.Error, log << "readBufferTo: IPE: NULL unit found in file transmission");
+            return -1;
+        }
+
+        const srt::CPacket& pkt = packetAt(p);
+
+        if (bTsbPdEnabled)
+        {
+            const steady_clock::time_point tsPlay = getPktTsbPdTime(pkt.getMsgTimeStamp());
+            HLOGC(rbuflog.Debug,
+                log << "readBuffer: check if time to play:"
+                << " NOW=" << FormatTime(now)
+                << " PKT TS=" << FormatTime(tsPlay));
+
+            if ((tsPlay > now))
+                break; /* too early for this unit, return whatever was copied */
+        }
+
+        const int pktlen = (int)pkt.getLength();
+        const int remain_pktlen = pktlen - m_iNotch;
+        const int unitsize = std::min(remain_pktlen, rs);
+
+        if (!funcCopyToDst(pkt.m_pcData + m_iNotch, unitsize, len - rs, arg))
+            break;
+
+        if (rs >= remain_pktlen)
+        {
+            releaseUnitInPos(p);
+            p = incPos(p);
+            m_iNotch = 0;
+
+            m_iStartPos = p;
+            --m_iMaxPosOff;
+            SRT_ASSERT(m_iMaxPosOff >= 0);
+            m_iStartSeqNo = CSeqNo::incseq(m_iStartSeqNo);
+        }
+        else
+            m_iNotch += rs;
+
+        rs -= unitsize;
+    }
+
+    const int iBytesRead = len - rs;
+    /* we removed acked bytes form receive buffer */
+    countBytes(-1, -iBytesRead);
+
+    // Update positions
+    // Set nonread position to the starting position before updating,
+    // because start position was increased, and preceding packets are invalid.
+    if (!isInRange(m_iStartPos, m_iMaxPosOff, m_szSize, m_iFirstNonreadPos))
+    {
+        m_iFirstNonreadPos = m_iStartPos;
+    }
+
+    if (iBytesRead == 0)
+    {
+        LOGC(rbuflog.Error, log << "readBufferTo: 0 bytes read. m_iStartPos=" << m_iStartPos << ", m_iFirstNonreadPos=" << m_iFirstNonreadPos);
+    }
+
+    return iBytesRead;
+}
+
+int CRcvBuffer::readBuffer(char* dst, int len)
+{
+    return readBufferTo(len, copyBytesToBuf, reinterpret_cast<void*>(dst));
+}
+
+int CRcvBuffer::readBufferToFile(fstream& ofs, int len)
+{
+    return readBufferTo(len, writeBytesToFile, reinterpret_cast<void*>(&ofs));
+}
+
+bool CRcvBuffer::hasAvailablePackets() const
+{
+    return hasReadableInorderPkts() || (m_numOutOfOrderPackets > 0 && m_iFirstReadableOutOfOrder != -1);
+}
+
+int CRcvBuffer::getRcvDataSize() const
+{
+    if (m_iFirstNonreadPos >= m_iStartPos)
+        return m_iFirstNonreadPos - m_iStartPos;
+
+    return int(m_szSize + m_iFirstNonreadPos - m_iStartPos);
+}
+
+int CRcvBuffer::getTimespan_ms() const
+{
+    if (!m_tsbpd.isEnabled())
+        return 0;
+
+    if (m_iMaxPosOff == 0)
+        return 0;
+
+    int lastpos = incPos(m_iStartPos, m_iMaxPosOff - 1);
+    // Normally the last position should always be non empty
+    // if TSBPD is enabled (reading out of order is not allowed).
+    // However if decryption of the last packet fails, it may be dropped
+    // from the buffer (AES-GCM), and the position will be empty.
+    SRT_ASSERT(m_entries[lastpos].pUnit != NULL || m_entries[lastpos].status == EntryState_Drop);
+    while (m_entries[lastpos].pUnit == NULL && lastpos != m_iStartPos)
+    {
+        lastpos = decPos(lastpos);
+    }
+    
+    if (m_entries[lastpos].pUnit == NULL)
+        return 0;
+
+    int startpos = m_iStartPos;
+    while (m_entries[startpos].pUnit == NULL && startpos != lastpos)
+    {
+        startpos = incPos(startpos);
+    }
+
+    if (m_entries[startpos].pUnit == NULL)
+        return 0;
+
+    const steady_clock::time_point startstamp =
+        getPktTsbPdTime(packetAt(startpos).getMsgTimeStamp());
+    const steady_clock::time_point endstamp = getPktTsbPdTime(packetAt(lastpos).getMsgTimeStamp());
+    if (endstamp < startstamp)
+        return 0;
+
+    // One millisecond is added as a duration of a packet in the buffer.
+    // If there is only one packet in the buffer, one millisecond is returned.
+    return static_cast<int>(count_milliseconds(endstamp - startstamp) + 1);
+}
+
+int CRcvBuffer::getRcvDataSize(int& bytes, int& timespan) const
+{
+    ScopedLock lck(m_BytesCountLock);
+    bytes = m_iBytesCount;
+    timespan = getTimespan_ms();
+    return m_iPktsCount;
+}
+
+CRcvBuffer::PacketInfo CRcvBuffer::getFirstValidPacketInfo() const
+{
+    const int end_pos = incPos(m_iStartPos, m_iMaxPosOff);
+    for (int i = m_iStartPos; i != end_pos; i = incPos(i))
+    {
+        // TODO: Maybe check status?
+        if (!m_entries[i].pUnit)
+            continue;
+
+        const CPacket& packet = packetAt(i);
+        const PacketInfo info = { packet.getSeqNo(), i != m_iStartPos, getPktTsbPdTime(packet.getMsgTimeStamp()) };
+        return info;
+    }
+
+    const PacketInfo info = { -1, false, time_point() };
+    return info;
+}
+
+std::pair<int, int> CRcvBuffer::getAvailablePacketsRange() const
+{
+    const int seqno_last = CSeqNo::incseq(m_iStartSeqNo, (int) countReadable());
+    return std::pair<int, int>(m_iStartSeqNo, seqno_last);
+}
+
+size_t CRcvBuffer::countReadable() const
+{
+    if (m_iFirstNonreadPos >= m_iStartPos)
+        return m_iFirstNonreadPos - m_iStartPos;
+    return m_szSize + m_iFirstNonreadPos - m_iStartPos;
+}
+
+bool CRcvBuffer::isRcvDataReady(time_point time_now) const
+{
+    const bool haveInorderPackets = hasReadableInorderPkts();
+    if (!m_tsbpd.isEnabled())
+    {
+        if (haveInorderPackets)
+            return true;
+
+        SRT_ASSERT((!m_bMessageAPI && m_numOutOfOrderPackets == 0) || m_bMessageAPI);
+        return (m_numOutOfOrderPackets > 0 && m_iFirstReadableOutOfOrder != -1);
+    }
+
+    if (!haveInorderPackets)
+        return false;
+
+    const PacketInfo info = getFirstValidPacketInfo();
+
+    return info.tsbpd_time <= time_now;
+}
+
+CRcvBuffer::PacketInfo CRcvBuffer::getFirstReadablePacketInfo(time_point time_now) const
+{
+    const PacketInfo unreadableInfo    = {SRT_SEQNO_NONE, false, time_point()};
+    const bool       hasInorderPackets = hasReadableInorderPkts();
+
+    if (!m_tsbpd.isEnabled())
+    {
+        if (hasInorderPackets)
+        {
+            const CPacket&   packet = packetAt(m_iStartPos);
+            const PacketInfo info   = {packet.getSeqNo(), false, time_point()};
+            return info;
+        }
+        SRT_ASSERT((!m_bMessageAPI && m_numOutOfOrderPackets == 0) || m_bMessageAPI);
+        if (m_iFirstReadableOutOfOrder >= 0)
+        {
+            SRT_ASSERT(m_numOutOfOrderPackets > 0);
+            const CPacket&   packet = packetAt(m_iFirstReadableOutOfOrder);
+            const PacketInfo info   = {packet.getSeqNo(), true, time_point()};
+            return info;
+        }
+        return unreadableInfo;
+    }
+
+    if (!hasInorderPackets)
+        return unreadableInfo;
+
+    const PacketInfo info = getFirstValidPacketInfo();
+
+    if (info.tsbpd_time <= time_now)
+        return info;
+    else
+        return unreadableInfo;
+}
+
+int32_t CRcvBuffer::getFirstNonreadSeqNo() const
+{
+    const int offset = offPos(m_iStartPos, m_iFirstNonreadPos);
+    return CSeqNo::incseq(m_iStartSeqNo, offset);
+}
+
+void CRcvBuffer::countBytes(int pkts, int bytes)
+{
+    ScopedLock lock(m_BytesCountLock);
+    m_iBytesCount += bytes; // added or removed bytes from rcv buffer
+    m_iPktsCount  += pkts;
+    if (bytes > 0)          // Assuming one pkt when adding bytes
+    {
+        if (!m_uAvgPayloadSz)
+            m_uAvgPayloadSz = bytes;
+        else
+            m_uAvgPayloadSz = avg_iir<100>(m_uAvgPayloadSz, (unsigned) bytes);
+    }
+}
+
+void CRcvBuffer::releaseUnitInPos(int pos)
+{
+    CUnit* tmp = m_entries[pos].pUnit;
+    m_entries[pos] = Entry(); // pUnit = NULL; status = Empty
+    if (tmp != NULL)
+        m_pUnitQueue->makeUnitFree(tmp);
+}
+
+bool CRcvBuffer::dropUnitInPos(int pos)
+{
+    if (!m_entries[pos].pUnit)
+        return false;
+    if (m_tsbpd.isEnabled())
+    {
+        updateTsbPdTimeBase(packetAt(pos).getMsgTimeStamp());
+    }
+    else if (m_bMessageAPI && !packetAt(pos).getMsgOrderFlag())
+    {
+        --m_numOutOfOrderPackets;
+        if (pos == m_iFirstReadableOutOfOrder)
+            m_iFirstReadableOutOfOrder = -1;
+    }
+    releaseUnitInPos(pos);
+    return true;
+}
+
+void CRcvBuffer::releaseNextFillerEntries()
+{
+    int pos = m_iStartPos;
+    while (m_entries[pos].status == EntryState_Read || m_entries[pos].status == EntryState_Drop)
+    {
+        m_iStartSeqNo = CSeqNo::incseq(m_iStartSeqNo);
+        releaseUnitInPos(pos);
+        pos = incPos(pos);
+        m_iStartPos = pos;
+        --m_iMaxPosOff;
+        if (m_iMaxPosOff < 0)
+            m_iMaxPosOff = 0;
+    }
+}
+
+// TODO: Is this function complete? There are some comments left inside.
+void CRcvBuffer::updateNonreadPos()
+{
+    if (m_iMaxPosOff == 0)
+        return;
+
+    const int end_pos = incPos(m_iStartPos, m_iMaxPosOff); // The empty position right after the last valid entry.
+
+    int pos = m_iFirstNonreadPos;
+    while (m_entries[pos].pUnit && m_entries[pos].status == EntryState_Avail)
+    {
+        if (m_bMessageAPI && (packetAt(pos).getMsgBoundary() & PB_FIRST) == 0)
+            break;
+
+        for (int i = pos; i != end_pos; i = incPos(i))
+        {
+            if (!m_entries[i].pUnit || m_entries[pos].status != EntryState_Avail)
+            {
+                break;
+            }
+
+            // Check PB_LAST only in message mode.
+            if (!m_bMessageAPI || packetAt(i).getMsgBoundary() & PB_LAST)
+            {
+                m_iFirstNonreadPos = incPos(i);
+                break;
+            }
+        }
+
+        if (pos == m_iFirstNonreadPos || !m_entries[m_iFirstNonreadPos].pUnit)
+            break;
+
+        pos = m_iFirstNonreadPos;
+    }
+}
+
+int CRcvBuffer::findLastMessagePkt()
+{
+    for (int i = m_iStartPos; i != m_iFirstNonreadPos; i = incPos(i))
+    {
+        SRT_ASSERT(m_entries[i].pUnit);
+
+        if (packetAt(i).getMsgBoundary() & PB_LAST)
+        {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+void CRcvBuffer::onInsertNotInOrderPacket(int insertPos)
+{
+    if (m_numOutOfOrderPackets == 0)
+        return;
+
+    // If the following condition is true, there is already a packet,
+    // that can be read out of order. We don't need to search for
+    // another one. The search should be done when that packet is read out from the buffer.
+    //
+    // There might happen that the packet being added precedes the previously found one.
+    // However, it is allowed to re bead out of order, so no need to update the position.
+    if (m_iFirstReadableOutOfOrder >= 0)
+        return;
+
+    // Just a sanity check. This function is called when a new packet is added.
+    // So the should be unacknowledged packets.
+    SRT_ASSERT(m_iMaxPosOff > 0);
+    SRT_ASSERT(m_entries[insertPos].pUnit);
+    const CPacket& pkt = packetAt(insertPos);
+    const PacketBoundary boundary = pkt.getMsgBoundary();
+
+    //if ((boundary & PB_FIRST) && (boundary & PB_LAST))
+    //{
+    //    // This packet can be read out of order
+    //    m_iFirstReadableOutOfOrder = insertPos;
+    //    return;
+    //}
+
+    const int msgNo = pkt.getMsgSeq(m_bPeerRexmitFlag);
+    // First check last packet, because it is expected to be received last.
+    const bool hasLast = (boundary & PB_LAST) || (-1 < scanNotInOrderMessageRight(insertPos, msgNo));
+    if (!hasLast)
+        return;
+
+    const int firstPktPos = (boundary & PB_FIRST)
+        ? insertPos
+        : scanNotInOrderMessageLeft(insertPos, msgNo);
+    if (firstPktPos < 0)
+        return;
+
+    m_iFirstReadableOutOfOrder = firstPktPos;
+    return;
+}
+
+bool CRcvBuffer::checkFirstReadableOutOfOrder()
+{
+    if (m_numOutOfOrderPackets <= 0 || m_iFirstReadableOutOfOrder < 0 || m_iMaxPosOff == 0)
+        return false;
+
+    const int endPos = incPos(m_iStartPos, m_iMaxPosOff);
+    int msgno = -1;
+    for (int pos = m_iFirstReadableOutOfOrder; pos != endPos; pos = incPos(pos))
+    {
+        if (!m_entries[pos].pUnit)
+            return false;
+
+        const CPacket& pkt = packetAt(pos);
+        if (pkt.getMsgOrderFlag())
+            return false;
+
+        if (msgno == -1)
+            msgno = pkt.getMsgSeq(m_bPeerRexmitFlag);
+        else if (msgno != pkt.getMsgSeq(m_bPeerRexmitFlag))
+            return false;
+
+        if (pkt.getMsgBoundary() & PB_LAST)
+            return true;
+    }
+
+    return false;
+}
+
+void CRcvBuffer::updateFirstReadableOutOfOrder()
+{
+    if (hasReadableInorderPkts() || m_numOutOfOrderPackets <= 0 || m_iFirstReadableOutOfOrder >= 0)
+        return;
+
+    if (m_iMaxPosOff == 0)
+        return;
+
+    // TODO: unused variable outOfOrderPktsRemain?
+    int outOfOrderPktsRemain = (int) m_numOutOfOrderPackets;
+
+    // Search further packets to the right.
+    // First check if there are packets to the right.
+    const int lastPos = (m_iStartPos + m_iMaxPosOff - 1) % m_szSize;
+
+    int posFirst = -1;
+    int posLast = -1;
+    int msgNo = -1;
+
+    for (int pos = m_iStartPos; outOfOrderPktsRemain; pos = incPos(pos))
+    {
+        if (!m_entries[pos].pUnit)
+        {
+            posFirst = posLast = msgNo = -1;
+            continue;
+        }
+
+        const CPacket& pkt = packetAt(pos);
+
+        if (pkt.getMsgOrderFlag())   // Skip in order packet
+        {
+            posFirst = posLast = msgNo = -1;
+            continue;
+        }
+
+        --outOfOrderPktsRemain;
+
+        const PacketBoundary boundary = pkt.getMsgBoundary();
+        if (boundary & PB_FIRST)
+        {
+            posFirst = pos;
+            msgNo = pkt.getMsgSeq(m_bPeerRexmitFlag);
+        }
+
+        if (pkt.getMsgSeq(m_bPeerRexmitFlag) != msgNo)
+        {
+            posFirst = posLast = msgNo = -1;
+            continue;
+        }
+
+        if (boundary & PB_LAST)
+        {
+            m_iFirstReadableOutOfOrder = posFirst;
+            return;
+        }
+
+        if (pos == lastPos)
+            break;
+    }
+
+    return;
+}
+
+int CRcvBuffer::scanNotInOrderMessageRight(const int startPos, int msgNo) const
+{
+    // Search further packets to the right.
+    // First check if there are packets to the right.
+    const int lastPos = (m_iStartPos + m_iMaxPosOff - 1) % m_szSize;
+    if (startPos == lastPos)
+        return -1;
+
+    int pos = startPos;
+    do
+    {
+        pos = incPos(pos);
+        if (!m_entries[pos].pUnit)
+            break;
+
+        const CPacket& pkt = packetAt(pos);
+
+        if (pkt.getMsgSeq(m_bPeerRexmitFlag) != msgNo)
+        {
+            LOGC(rbuflog.Error, log << "Missing PB_LAST packet for msgNo " << msgNo);
+            return -1;
+        }
+
+        const PacketBoundary boundary = pkt.getMsgBoundary();
+        if (boundary & PB_LAST)
+            return pos;
+    } while (pos != lastPos);
+
+    return -1;
+}
+
+int CRcvBuffer::scanNotInOrderMessageLeft(const int startPos, int msgNo) const
+{
+    // Search preceding packets to the left.
+    // First check if there are packets to the left.
+    if (startPos == m_iStartPos)
+        return -1;
+
+    int pos = startPos;
+    do
+    {
+        pos = decPos(pos);
+
+        if (!m_entries[pos].pUnit)
+            return -1;
+
+        const CPacket& pkt = packetAt(pos);
+
+        if (pkt.getMsgSeq(m_bPeerRexmitFlag) != msgNo)
+        {
+            LOGC(rbuflog.Error, log << "Missing PB_FIRST packet for msgNo " << msgNo);
+            return -1;
+        }
+
+        const PacketBoundary boundary = pkt.getMsgBoundary();
+        if (boundary & PB_FIRST)
+            return pos;
+    } while (pos != m_iStartPos);
+
+    return -1;
+}
+
+bool CRcvBuffer::addRcvTsbPdDriftSample(uint32_t usTimestamp, const time_point& tsPktArrival, int usRTTSample)
+{
+    return m_tsbpd.addDriftSample(usTimestamp, tsPktArrival, usRTTSample);
+}
+
+void CRcvBuffer::setTsbPdMode(const steady_clock::time_point& timebase, bool wrap, duration delay)
+{
+    m_tsbpd.setTsbPdMode(timebase, wrap, delay);
+}
+
+void CRcvBuffer::applyGroupTime(const steady_clock::time_point& timebase,
+    bool                            wrp,
+    uint32_t                        delay,
+    const steady_clock::duration& udrift)
+{
+    m_tsbpd.applyGroupTime(timebase, wrp, delay, udrift);
+}
+
+void CRcvBuffer::applyGroupDrift(const steady_clock::time_point& timebase,
+    bool                            wrp,
+    const steady_clock::duration& udrift)
+{
+    m_tsbpd.applyGroupDrift(timebase, wrp, udrift);
+}
+
+CRcvBuffer::time_point CRcvBuffer::getTsbPdTimeBase(uint32_t usPktTimestamp) const
+{
+    return m_tsbpd.getTsbPdTimeBase(usPktTimestamp);
+}
+
+void CRcvBuffer::updateTsbPdTimeBase(uint32_t usPktTimestamp)
+{
+    m_tsbpd.updateTsbPdTimeBase(usPktTimestamp);
+}
+
+string CRcvBuffer::strFullnessState(int iFirstUnackSeqNo, const time_point& tsNow) const
+{
+    stringstream ss;
+
+    ss << "iFirstUnackSeqNo=" << iFirstUnackSeqNo << " m_iStartSeqNo=" << m_iStartSeqNo
+       << " m_iStartPos=" << m_iStartPos << " m_iMaxPosOff=" << m_iMaxPosOff << ". ";
+
+    ss << "Space avail " << getAvailSize(iFirstUnackSeqNo) << "/" << m_szSize << " pkts. ";
+
+    if (m_tsbpd.isEnabled() && m_iMaxPosOff > 0)
+    {
+        const PacketInfo nextValidPkt = getFirstValidPacketInfo();
+        ss << "(TSBPD ready in ";
+        if (!is_zero(nextValidPkt.tsbpd_time))
+        {
+            ss << count_milliseconds(nextValidPkt.tsbpd_time - tsNow) << "ms";
+            const int iLastPos = incPos(m_iStartPos, m_iMaxPosOff - 1);
+            if (m_entries[iLastPos].pUnit)
+            {
+                ss << ", timespan ";
+                const uint32_t usPktTimestamp = packetAt(iLastPos).getMsgTimeStamp();
+                ss << count_milliseconds(m_tsbpd.getPktTsbPdTime(usPktTimestamp) - nextValidPkt.tsbpd_time);
+                ss << " ms";
+            }
+        }
+        else
+        {
+            ss << "n/a";
+        }
+        ss << "). ";
+    }
+
+    ss << SRT_SYNC_CLOCK_STR " drift " << getDrift() / 1000 << " ms.";
+    return ss.str();
+}
+
+CRcvBuffer::time_point CRcvBuffer::getPktTsbPdTime(uint32_t usPktTimestamp) const
+{
+    return m_tsbpd.getPktTsbPdTime(usPktTimestamp);
+}
+
+/* Return moving average of acked data pkts, bytes, and timespan (ms) of the receive buffer */
+int CRcvBuffer::getRcvAvgDataSize(int& bytes, int& timespan)
+{
+    // Average number of packets and timespan could be small,
+    // so rounding is beneficial, while for the number of
+    // bytes in the buffer is a higher value, so rounding can be omitted,
+    // but probably better to round all three values.
+    timespan = static_cast<int>(round((m_mavg.timespan_ms())));
+    bytes = static_cast<int>(round((m_mavg.bytes())));
+    return static_cast<int>(round(m_mavg.pkts()));
+}
+
+/* Update moving average of acked data pkts, bytes, and timespan (ms) of the receive buffer */
+void CRcvBuffer::updRcvAvgDataSize(const steady_clock::time_point& now)
+{
+    if (!m_mavg.isTimeToUpdate(now))
+        return;
+
+    int       bytes = 0;
+    int       timespan_ms = 0;
+    const int pkts = getRcvDataSize(bytes, timespan_ms);
+    m_mavg.update(now, pkts, bytes, timespan_ms);
+}
+
+} // namespace srt
diff --git a/srtcore/buffer_rcv.h b/srtcore/buffer_rcv.h
new file mode 100644
index 000000000..c5fca428b
--- /dev/null
+++ b/srtcore/buffer_rcv.h
@@ -0,0 +1,416 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2020 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+#ifndef INC_SRT_BUFFER_RCV_H
+#define INC_SRT_BUFFER_RCV_H
+
+#include "buffer_tools.h" // AvgBufSize
+#include "common.h"
+#include "queue.h"
+#include "tsbpd_time.h"
+
+namespace srt
+{
+
+/*
+ *   Circular receiver buffer.
+ *
+ *   |<------------------- m_szSize ---------------------------->|
+ *   |       |<------------ m_iMaxPosOff ----------->|           |
+ *   |       |                                       |           |
+ *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
+ *   | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 0 |...| 0 | m_pUnit[]
+ *   +---+---+---+---+---+---+---+---+---+---+---+---+---+   +---+
+ *             |                                   |
+ *             |                                   \__last pkt received
+ *             |
+ *             \___ m_iStartPos: first message to read
+ *
+ *   m_pUnit[i]->status_: 0: free, 1: good, 2: read, 3: dropped (can be combined with read?)
+ *
+ *   thread safety:
+ *    start_pos_:      CUDT::m_RecvLock
+ *    first_unack_pos_:    CUDT::m_AckLock
+ *    max_pos_inc_:        none? (modified on add and ack
+ *    first_nonread_pos_:
+ */
+
+class CRcvBuffer
+{
+    typedef sync::steady_clock::time_point time_point;
+    typedef sync::steady_clock::duration   duration;
+
+public:
+    CRcvBuffer(int initSeqNo, size_t size, CUnitQueue* unitqueue, bool bMessageAPI);
+
+    ~CRcvBuffer();
+
+public:
+    /// Insert a unit into the buffer.
+    /// Similar to CRcvBuffer::addData(CUnit* unit, int offset)
+    ///
+    /// @param [in] unit pointer to a data unit containing new packet
+    /// @param [in] offset offset from last ACK point.
+    ///
+    /// @return  0 on success, -1 if packet is already in buffer, -2 if packet is before m_iStartSeqNo.
+    /// -3 if a packet is offset is ahead the buffer capacity.
+    // TODO: Previously '-2' also meant 'already acknowledged'. Check usage of this value.
+    int insert(CUnit* unit);
+
+    /// Drop packets in the receiver buffer from the current position up to the seqno (excluding seqno).
+    /// @param [in] seqno drop units up to this sequence number
+    /// @return number of dropped (missing) and discarded (available) packets as a pair(dropped, discarded).
+    std::pair<int, int> dropUpTo(int32_t seqno);
+
+    /// @brief Drop all the packets in the receiver buffer.
+    /// The starting position and seqno are shifted right after the last packet in the buffer.
+    /// @return the number of dropped packets.
+    int dropAll();
+
+    enum DropActionIfExists {
+        DROP_EXISTING = 0,
+        KEEP_EXISTING = 1
+    };
+
+    /// @brief Drop a sequence of packets from the buffer.
+    /// If @a msgno is valid, sender has requested to drop the whole message by TTL. In this case it has to also provide a pkt seqno range.
+    /// However, if a message has been partially acknowledged and already removed from the SND buffer,
+    /// the @a seqnolo might specify some position in the middle of the message, not the very first packet.
+    /// If those packets have been acknowledged, they must exist in the receiver buffer unless already read.
+    /// In this case the @a msgno should be used to determine starting packets of the message.
+    /// Some packets of the message can be missing on the receiver, therefore the actual drop should still be performed by pkt seqno range.
+    /// If message number is 0 or SRT_MSGNO_NONE, then use sequence numbers to locate sequence range to drop [seqnolo, seqnohi].
+    /// A SOLO message packet can be kept depending on @a actionOnExisting value.
+    /// TODO: A message in general can be kept if all of its packets are in the buffer, depending on @a actionOnExisting value.
+    /// This is done to avoid dropping existing packet when the sender was asked to re-transmit a packet from an outdated loss report,
+    /// which is already not available in the SND buffer.
+    /// @param seqnolo sequence number of the first packet in the dropping range.
+    /// @param seqnohi sequence number of the last packet in the dropping range.
+    /// @param msgno message number to drop (0 if unknown)
+    /// @param actionOnExisting Should an exising SOLO packet be dropped from the buffer or preserved?
+    /// @return the number of packets actually dropped.
+    int dropMessage(int32_t seqnolo, int32_t seqnohi, int32_t msgno, DropActionIfExists actionOnExisting);
+
+    /// Read the whole message from one or several packets.
+    ///
+    /// @param [in,out] data buffer to write the message into.
+    /// @param [in] len size of the buffer.
+    /// @param [in,out] message control data
+    ///
+    /// @return actual number of bytes extracted from the buffer.
+    ///          0 if nothing to read.
+    ///         -1 on failure.
+    int readMessage(char* data, size_t len, SRT_MSGCTRL* msgctrl = NULL);
+
+    /// Read acknowledged data into a user buffer.
+    /// @param [in, out] dst pointer to the target user buffer.
+    /// @param [in] len length of user buffer.
+    /// @return size of data read. -1 on error.
+    int readBuffer(char* dst, int len);
+
+    /// Read acknowledged data directly into file.
+    /// @param [in] ofs C++ file stream.
+    /// @param [in] len expected length of data to write into the file.
+    /// @return size of data read. -1 on error.
+    int readBufferToFile(std::fstream& ofs, int len);
+
+public:
+    /// Get the starting position of the buffer as a packet sequence number.
+    int getStartSeqNo() const { return m_iStartSeqNo; }
+
+    /// Sets the start seqno of the buffer.
+    /// Must be used with caution and only when the buffer is empty.
+    void setStartSeqNo(int seqno) { m_iStartSeqNo = seqno; }
+
+    /// Given the sequence number of the first unacknowledged packet
+    /// tells the size of the buffer available for packets.
+    /// Effective returns capacity of the buffer minus acknowledged packet still kept in it.
+    // TODO: Maybe does not need to return minus one slot now to distinguish full and empty buffer.
+    size_t getAvailSize(int iFirstUnackSeqNo) const
+    {
+        // Receiver buffer allows reading unacknowledged packets.
+        // Therefore if the first packet in the buffer is ahead of the iFirstUnackSeqNo
+        // then it does not have acknowledged packets and its full capacity is available.
+        // Otherwise subtract the number of acknowledged but not yet read packets from its capacity.
+        const int iRBufSeqNo  = getStartSeqNo();
+        if (CSeqNo::seqcmp(iRBufSeqNo, iFirstUnackSeqNo) >= 0) // iRBufSeqNo >= iFirstUnackSeqNo
+        {
+            // Full capacity is available.
+            return capacity();
+        }
+
+        // Note: CSeqNo::seqlen(n, n) returns 1.
+        return capacity() - CSeqNo::seqlen(iRBufSeqNo, iFirstUnackSeqNo) + 1;
+    }
+
+    /// @brief Checks if the buffer has packets available for reading regardless of the TSBPD.
+    /// A message is available for reading only if all of its packets are present in the buffer.
+    /// @return true if there are packets available for reading, false otherwise.
+    bool hasAvailablePackets() const;
+
+    /// Query how many data has been continuously received (for reading) and available for reading out
+    /// regardless of the TSBPD.
+    /// TODO: Rename to countAvailablePackets().
+    /// @return size of valid (continuous) data for reading.
+    int getRcvDataSize() const;
+
+    /// Get the number of packets, bytes and buffer timespan.
+    /// Differs from getRcvDataSize() that it counts all packets in the buffer, not only continious.
+    int getRcvDataSize(int& bytes, int& timespan) const;
+
+    struct PacketInfo
+    {
+        int        seqno;
+        bool       seq_gap; //< true if there are missing packets in the buffer, preceding current packet
+        time_point tsbpd_time;
+    };
+
+    /// Get information on the 1st message in queue.
+    /// Similar to CRcvBuffer::getRcvFirstMsg
+    /// Parameters (of the 1st packet queue, ready to play or not):
+    /// @param [out] tsbpdtime localtime-based (uSec) packet time stamp including buffering delay of 1st packet or 0 if
+    /// none
+    /// @param [out] passack   true if 1st ready packet is not yet acknowledged (allowed to be delivered to the app)
+    /// @param [out] skipseqno -1 or sequence number of 1st unacknowledged packet (after one or more missing packets) that is ready to play.
+    /// @retval true 1st packet ready to play (tsbpdtime <= now). Not yet acknowledged if passack == true
+    /// @retval false IF tsbpdtime = 0: rcv buffer empty; ELSE:
+    ///                   IF skipseqno != -1, packet ready to play preceded by missing packets.;
+    ///                   IF skipseqno == -1, no missing packet but 1st not ready to play.
+    PacketInfo getFirstValidPacketInfo() const;
+
+    PacketInfo getFirstReadablePacketInfo(time_point time_now) const;
+
+    /// @brief Get the sequence number of the first packet that can't be read
+    /// (either because it is missing, or because it is a part of a bigger message
+    /// that is not fully available yet).
+    int32_t getFirstNonreadSeqNo() const;
+
+    /// Get information on packets available to be read.
+    /// @returns a pair of sequence numbers (first available; first unavailable).
+    /// 
+    /// @note CSeqNo::seqoff(first, second) is 0 if nothing to read.
+    std::pair<int, int> getAvailablePacketsRange() const;
+
+    size_t countReadable() const;
+
+    bool empty() const
+    {
+        return (m_iMaxPosOff == 0);
+    }
+
+    /// Returns the currently used number of cells, including
+    /// gaps with empty cells, or in other words, the distance
+    /// between the initial position and the youngest received packet.
+    size_t size() const
+    {
+        return m_iMaxPosOff;
+    }
+
+    // Returns true if the buffer is full. Requires locking.
+    bool full() const
+    {
+        return size() == capacity();
+    }
+
+    /// Return buffer capacity.
+    /// One slot had to be empty in order to tell the difference between "empty buffer" and "full buffer".
+    /// E.g. m_iFirstNonreadPos would again point to m_iStartPos if m_szSize entries are added continiously.
+    /// TODO: Old receiver buffer capacity returns the actual size. Check for conflicts.
+    size_t capacity() const
+    {
+        return m_szSize - 1;
+    }
+
+    int64_t getDrift() const { return m_tsbpd.drift(); }
+
+    // TODO: make thread safe?
+    int debugGetSize() const
+    {
+        return getRcvDataSize();
+    }
+
+    /// Zero time to include all available packets.
+    /// TODO: Rename to 'canRead`.
+    bool isRcvDataReady(time_point time_now = time_point()) const;
+
+    int  getRcvAvgDataSize(int& bytes, int& timespan);
+    void updRcvAvgDataSize(const time_point& now);
+
+    unsigned getRcvAvgPayloadSize() const { return m_uAvgPayloadSz; }
+
+    void getInternalTimeBase(time_point& w_timebase, bool& w_wrp, duration& w_udrift)
+    {
+        return m_tsbpd.getInternalTimeBase(w_timebase, w_wrp, w_udrift);
+    }
+
+public: // Used for testing
+    /// Peek unit in position of seqno
+    const CUnit* peek(int32_t seqno);
+
+private:
+    inline int incPos(int pos, int inc = 1) const { return (pos + inc) % m_szSize; }
+    inline int decPos(int pos) const { return (pos - 1) >= 0 ? (pos - 1) : int(m_szSize - 1); }
+    inline int offPos(int pos1, int pos2) const { return (pos2 >= pos1) ? (pos2 - pos1) : int(m_szSize + pos2 - pos1); }
+
+    /// @brief Compares the two positions in the receiver buffer relative to the starting position.
+    /// @param pos2 a position in the receiver buffer.
+    /// @param pos1 a position in the receiver buffer.
+    /// @return a positive value if pos2 is ahead of pos1; a negative value, if pos2 is behind pos1; otherwise returns 0.
+    inline int cmpPos(int pos2, int pos1) const
+    {
+        // XXX maybe not the best implementation, but this keeps up to the rule.
+        // Maybe use m_iMaxPosOff to ensure a position is not behind the m_iStartPos.
+        const int off1 = pos1 >= m_iStartPos ? pos1 - m_iStartPos : pos1 + (int)m_szSize - m_iStartPos;
+        const int off2 = pos2 >= m_iStartPos ? pos2 - m_iStartPos : pos2 + (int)m_szSize - m_iStartPos;
+
+        return off2 - off1;
+    }
+
+    // NOTE: Assumes that pUnit != NULL
+    CPacket& packetAt(int pos) { return m_entries[pos].pUnit->m_Packet; }
+    const CPacket& packetAt(int pos) const { return m_entries[pos].pUnit->m_Packet; }
+
+private:
+    void countBytes(int pkts, int bytes);
+    void updateNonreadPos();
+    void releaseUnitInPos(int pos);
+
+    /// @brief Drop a unit from the buffer.
+    /// @param pos position in the m_entries of the unit to drop.
+    /// @return false if nothing to drop, true if the unit was dropped successfully.
+    bool dropUnitInPos(int pos);
+
+    /// Release entries following the current buffer position if they were already
+    /// read out of order (EntryState_Read) or dropped (EntryState_Drop).
+    void releaseNextFillerEntries();
+
+    bool hasReadableInorderPkts() const { return (m_iFirstNonreadPos != m_iStartPos); }
+
+    /// Find position of the last packet of the message.
+    int findLastMessagePkt();
+
+    /// Scan for availability of out of order packets.
+    void onInsertNotInOrderPacket(int insertpos);
+    // Check if m_iFirstReadableOutOfOrder is still readable.
+    bool checkFirstReadableOutOfOrder();
+    void updateFirstReadableOutOfOrder();
+    int  scanNotInOrderMessageRight(int startPos, int msgNo) const;
+    int  scanNotInOrderMessageLeft(int startPos, int msgNo) const;
+
+    typedef bool copy_to_dst_f(char* data, int len, int dst_offset, void* arg);
+
+    /// Read acknowledged data directly into file.
+    /// @param [in] ofs C++ file stream.
+    /// @param [in] len expected length of data to write into the file.
+    /// @return size of data read.
+    int readBufferTo(int len, copy_to_dst_f funcCopyToDst, void* arg);
+
+    /// @brief Estimate timespan of the stored packets (acknowledged and unacknowledged).
+    /// @return timespan in milliseconds
+    int getTimespan_ms() const;
+
+private:
+    // TODO: Call makeUnitTaken upon assignment, and makeUnitFree upon clearing.
+    // TODO: CUnitPtr is not in use at the moment, but may be a smart pointer.
+    // class CUnitPtr
+    // {
+    // public:
+    //     void operator=(CUnit* pUnit)
+    //     {
+    //         if (m_pUnit != NULL)
+    //         {
+    //             // m_pUnitQueue->makeUnitFree(m_entries[i].pUnit);
+    //         }
+    //         m_pUnit = pUnit;
+    //     }
+    // private:
+    //     CUnit* m_pUnit;
+    // };
+
+    enum EntryStatus
+    {
+        EntryState_Empty,   //< No CUnit record.
+        EntryState_Avail,   //< Entry is available for reading.
+        EntryState_Read,    //< Entry has already been read (out of order).
+        EntryState_Drop     //< Entry has been dropped.
+    };
+    struct Entry
+    {
+        Entry()
+            : pUnit(NULL)
+            , status(EntryState_Empty)
+        {}
+
+        CUnit*      pUnit;
+        EntryStatus status;
+    };
+
+    typedef FixedArray<Entry> entries_t;
+    entries_t m_entries;
+
+    const size_t m_szSize;     // size of the array of units (buffer)
+    CUnitQueue*  m_pUnitQueue; // the shared unit queue
+
+    int m_iStartSeqNo;
+    int m_iStartPos;        // the head position for I/O (inclusive)
+    int m_iFirstNonreadPos; // First position that can't be read (<= m_iLastAckPos)
+    int m_iMaxPosOff;       // the furthest data position
+    int m_iNotch;           // the starting read point of the first unit
+
+    size_t m_numOutOfOrderPackets;  // The number of stored packets with "inorder" flag set to false
+    int m_iFirstReadableOutOfOrder; // In case of out ouf order packet, points to a position of the first such packet to
+                                    // read
+    bool m_bPeerRexmitFlag;         // Needed to read message number correctly
+    const bool m_bMessageAPI;       // Operation mode flag: message or stream.
+
+public: // TSBPD public functions
+    /// Set TimeStamp-Based Packet Delivery Rx Mode
+    /// @param [in] timebase localtime base (uSec) of packet time stamps including buffering delay
+    /// @param [in] wrap Is in wrapping period
+    /// @param [in] delay agreed TsbPD delay
+    ///
+    /// @return 0
+    void setTsbPdMode(const time_point& timebase, bool wrap, duration delay);
+
+    void setPeerRexmitFlag(bool flag) { m_bPeerRexmitFlag = flag; } 
+
+    void applyGroupTime(const time_point& timebase, bool wrp, uint32_t delay, const duration& udrift);
+
+    void applyGroupDrift(const time_point& timebase, bool wrp, const duration& udrift);
+
+    bool addRcvTsbPdDriftSample(uint32_t usTimestamp, const time_point& tsPktArrival, int usRTTSample);
+
+    time_point getPktTsbPdTime(uint32_t usPktTimestamp) const;
+
+    time_point getTsbPdTimeBase(uint32_t usPktTimestamp) const;
+    void       updateTsbPdTimeBase(uint32_t usPktTimestamp);
+
+    bool isTsbPd() const { return m_tsbpd.isEnabled(); }
+
+    /// Form a string of the current buffer fullness state.
+    /// number of packets acknowledged, TSBPD readiness, etc.
+    std::string strFullnessState(int iFirstUnackSeqNo, const time_point& tsNow) const;
+
+private:
+    CTsbpdTime  m_tsbpd;
+
+private: // Statistics
+    AvgBufSize m_mavg;
+
+    // TODO: m_BytesCountLock is probably not needed as the buffer has to be protected from simultaneous access.
+    mutable sync::Mutex m_BytesCountLock;   // used to protect counters operations
+    int         m_iBytesCount;      // Number of payload bytes in the buffer
+    int         m_iPktsCount;       // Number of payload bytes in the buffer
+    unsigned    m_uAvgPayloadSz;    // Average payload size for dropped bytes estimation
+};
+
+} // namespace srt
+
+#endif // INC_SRT_BUFFER_RCV_H
diff --git a/srtcore/buffer_snd.cpp b/srtcore/buffer_snd.cpp
new file mode 100644
index 000000000..ef1bc498c
--- /dev/null
+++ b/srtcore/buffer_snd.cpp
@@ -0,0 +1,749 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 03/12/2011
+modified by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#include "platform_sys.h"
+
+#include <cmath>
+#include "buffer_snd.h"
+#include "packet.h"
+#include "core.h" // provides some constants
+#include "logging.h"
+
+namespace srt {
+
+using namespace std;
+using namespace srt_logging;
+using namespace sync;
+
+CSndBuffer::CSndBuffer(int ip_family, int size, int maxpld, int authtag)
+    : m_BufLock()
+    , m_pBlock(NULL)
+    , m_pFirstBlock(NULL)
+    , m_pCurrBlock(NULL)
+    , m_pLastBlock(NULL)
+    , m_pBuffer(NULL)
+    , m_iNextMsgNo(1)
+    , m_iSize(size)
+    , m_iBlockLen(maxpld)
+    , m_iAuthTagSize(authtag)
+    , m_iCount(0)
+    , m_iBytesCount(0)
+    , m_rateEstimator(ip_family)
+{
+    // initial physical buffer of "size"
+    m_pBuffer           = new Buffer;
+    m_pBuffer->m_pcData = new char[m_iSize * m_iBlockLen];
+    m_pBuffer->m_iSize  = m_iSize;
+    m_pBuffer->m_pNext  = NULL;
+
+    // circular linked list for out bound packets
+    m_pBlock  = new Block;
+    Block* pb = m_pBlock;
+    char* pc  = m_pBuffer->m_pcData;
+
+    for (int i = 0; i < m_iSize; ++i)
+    {
+        pb->m_iMsgNoBitset = 0;
+        pb->m_pcData       = pc;
+        pc                += m_iBlockLen;
+
+        if (i < m_iSize - 1)
+        {
+            pb->m_pNext        = new Block;
+            pb                 = pb->m_pNext;
+        }
+    }
+    pb->m_pNext = m_pBlock;
+
+    m_pFirstBlock = m_pCurrBlock = m_pLastBlock = m_pBlock;
+
+    setupMutex(m_BufLock, "Buf");
+}
+
+CSndBuffer::~CSndBuffer()
+{
+    Block* pb = m_pBlock->m_pNext;
+    while (pb != m_pBlock)
+    {
+        Block* temp = pb;
+        pb          = pb->m_pNext;
+        delete temp;
+    }
+    delete m_pBlock;
+
+    while (m_pBuffer != NULL)
+    {
+        Buffer* temp = m_pBuffer;
+        m_pBuffer    = m_pBuffer->m_pNext;
+        delete[] temp->m_pcData;
+        delete temp;
+    }
+
+    releaseMutex(m_BufLock);
+}
+
+void CSndBuffer::addBuffer(const char* data, int len, SRT_MSGCTRL& w_mctrl)
+{
+    int32_t& w_msgno     = w_mctrl.msgno;
+    int32_t& w_seqno     = w_mctrl.pktseq;
+    int64_t& w_srctime   = w_mctrl.srctime;
+    const int& ttl       = w_mctrl.msgttl;
+    const int iPktLen    = getMaxPacketLen();
+    const int iNumBlocks = countNumPacketsRequired(len, iPktLen);
+
+    HLOGC(bslog.Debug,
+          log << "addBuffer: needs=" << iNumBlocks << " buffers for " << len << " bytes. Taken=" << m_iCount << "/" << m_iSize);
+    // Retrieve current time before locking the mutex to be closer to packet submission event.
+    const steady_clock::time_point tnow = steady_clock::now();
+
+    ScopedLock bufferguard(m_BufLock);
+    // Dynamically increase sender buffer if there is not enough room.
+    while (iNumBlocks + m_iCount >= m_iSize)
+    {
+        HLOGC(bslog.Debug, log << "addBuffer: ... still lacking " << (iNumBlocks + m_iCount - m_iSize) << " buffers...");
+        increase();
+    }
+
+    const int32_t inorder = w_mctrl.inorder ? MSGNO_PACKET_INORDER::mask : 0;
+    HLOGC(bslog.Debug,
+          log << CONID() << "addBuffer: adding " << iNumBlocks << " packets (" << len << " bytes) to send, msgno="
+              << (w_msgno > 0 ? w_msgno : m_iNextMsgNo) << (inorder ? "" : " NOT") << " in order");
+
+    // Calculate origin time (same for all blocks of the message).
+    m_tsLastOriginTime = w_srctime ? time_point() + microseconds_from(w_srctime) : tnow;
+    // Rewrite back the actual value, even if it stays the same, so that the calling facilities can reuse it.
+    // May also be a subject to conversion error, thus the actual value is signalled back.
+    w_srctime = count_microseconds(m_tsLastOriginTime.time_since_epoch());
+
+    // The sequence number passed to this function is the sequence number
+    // that the very first packet from the packet series should get here.
+    // If there's more than one packet, this function must increase it by itself
+    // and then return the accordingly modified sequence number in the reference.
+
+    Block* s = m_pLastBlock;
+
+    if (w_msgno == SRT_MSGNO_NONE) // DEFAULT-UNCHANGED msgno supplied
+    {
+        HLOGC(bslog.Debug, log << "addBuffer: using internally managed msgno=" << m_iNextMsgNo);
+        w_msgno = m_iNextMsgNo;
+    }
+    else
+    {
+        HLOGC(bslog.Debug, log << "addBuffer: OVERWRITTEN by msgno supplied by caller: msgno=" << w_msgno);
+        m_iNextMsgNo = w_msgno;
+    }
+
+    for (int i = 0; i < iNumBlocks; ++i)
+    {
+        int pktlen = len - i * iPktLen;
+        if (pktlen > iPktLen)
+            pktlen = iPktLen;
+
+        HLOGC(bslog.Debug,
+              log << "addBuffer: %" << w_seqno << " #" << w_msgno << " offset=" << (i * iPktLen)
+                  << " size=" << pktlen << " TO BUFFER:" << (void*)s->m_pcData);
+        memcpy((s->m_pcData), data + i * iPktLen, pktlen);
+        s->m_iLength = pktlen;
+
+        s->m_iSeqNo = w_seqno;
+        w_seqno     = CSeqNo::incseq(w_seqno);
+
+        s->m_iMsgNoBitset = m_iNextMsgNo | inorder;
+        if (i == 0)
+            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_FIRST);
+        if (i == iNumBlocks - 1)
+            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_LAST);
+        // NOTE: if i is neither 0 nor size-1, it resuls with PB_SUBSEQUENT.
+        //       if i == 0 == size-1, it results with PB_SOLO.
+        // Packets assigned to one message can be:
+        // [PB_FIRST] [PB_SUBSEQUENT] [PB_SUBSEQUENT] [PB_LAST] - 4 packets per message
+        // [PB_FIRST] [PB_LAST] - 2 packets per message
+        // [PB_SOLO] - 1 packet per message
+
+        s->m_iTTL = ttl;
+        s->m_tsRexmitTime = time_point();
+        s->m_tsOriginTime = m_tsLastOriginTime;
+        
+        // Should never happen, as the call to increase() should ensure enough buffers.
+        SRT_ASSERT(s->m_pNext);
+        s = s->m_pNext;
+    }
+    m_pLastBlock = s;
+
+    m_iCount = m_iCount + iNumBlocks;
+    m_iBytesCount += len;
+
+    m_rateEstimator.updateInputRate(m_tsLastOriginTime, iNumBlocks, len);
+    updAvgBufSize(m_tsLastOriginTime);
+
+    // MSGNO_SEQ::mask has a form: 00000011111111...
+    // At least it's known that it's from some index inside til the end (to bit 0).
+    // If this value has been reached in a step of incrementation, it means that the
+    // maximum value has been reached. Casting to int32_t to ensure the same sign
+    // in comparison, although it's far from reaching the sign bit.
+
+    const int nextmsgno = ++MsgNo(m_iNextMsgNo);
+    HLOGC(bslog.Debug, log << "CSndBuffer::addBuffer: updating msgno: #" << m_iNextMsgNo << " -> #" << nextmsgno);
+    m_iNextMsgNo = nextmsgno;
+}
+
+int CSndBuffer::addBufferFromFile(fstream& ifs, int len)
+{
+    const int iPktLen    = getMaxPacketLen();
+    const int iNumBlocks = countNumPacketsRequired(len, iPktLen);
+
+    HLOGC(bslog.Debug,
+          log << "addBufferFromFile: size=" << m_iCount << " reserved=" << m_iSize << " needs=" << iPktLen
+              << " buffers for " << len << " bytes");
+
+    // dynamically increase sender buffer
+    while (iNumBlocks + m_iCount >= m_iSize)
+    {
+        HLOGC(bslog.Debug,
+              log << "addBufferFromFile: ... still lacking " << (iNumBlocks + m_iCount - m_iSize) << " buffers...");
+        increase();
+    }
+
+    HLOGC(bslog.Debug,
+          log << CONID() << "addBufferFromFile: adding " << iPktLen << " packets (" << len
+              << " bytes) to send, msgno=" << m_iNextMsgNo);
+
+    Block* s     = m_pLastBlock;
+    int    total = 0;
+    for (int i = 0; i < iNumBlocks; ++i)
+    {
+        if (ifs.bad() || ifs.fail() || ifs.eof())
+            break;
+
+        int pktlen = len - i * iPktLen;
+        if (pktlen > iPktLen)
+            pktlen = iPktLen;
+
+        HLOGC(bslog.Debug,
+              log << "addBufferFromFile: reading from=" << (i * iPktLen) << " size=" << pktlen
+                  << " TO BUFFER:" << (void*)s->m_pcData);
+        ifs.read(s->m_pcData, pktlen);
+        if ((pktlen = int(ifs.gcount())) <= 0)
+            break;
+
+        // currently file transfer is only available in streaming mode, message is always in order, ttl = infinite
+        s->m_iMsgNoBitset = m_iNextMsgNo | MSGNO_PACKET_INORDER::mask;
+        if (i == 0)
+            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_FIRST);
+        if (i == iNumBlocks - 1)
+            s->m_iMsgNoBitset |= PacketBoundaryBits(PB_LAST);
+        // NOTE: PB_FIRST | PB_LAST == PB_SOLO.
+        // none of PB_FIRST & PB_LAST == PB_SUBSEQUENT.
+
+        s->m_iLength = pktlen;
+        s->m_iTTL    = SRT_MSGTTL_INF;
+        s            = s->m_pNext;
+
+        total += pktlen;
+    }
+    m_pLastBlock = s;
+
+    enterCS(m_BufLock);
+    m_iCount = m_iCount + iNumBlocks;
+    m_iBytesCount += total;
+
+    leaveCS(m_BufLock);
+
+    m_iNextMsgNo++;
+    if (m_iNextMsgNo == int32_t(MSGNO_SEQ::mask))
+        m_iNextMsgNo = 1;
+
+    return total;
+}
+
+int CSndBuffer::readData(CPacket& w_packet, steady_clock::time_point& w_srctime, int kflgs, int& w_seqnoinc)
+{
+    int readlen = 0;
+    w_seqnoinc = 0;
+
+    ScopedLock bufferguard(m_BufLock);
+    while (m_pCurrBlock != m_pLastBlock)
+    {
+        // Make the packet REFLECT the data stored in the buffer.
+        w_packet.m_pcData = m_pCurrBlock->m_pcData;
+        readlen = m_pCurrBlock->m_iLength;
+        w_packet.setLength(readlen, m_iBlockLen);
+        w_packet.set_seqno(m_pCurrBlock->m_iSeqNo);
+
+        // 1. On submission (addBuffer), the KK flag is set to EK_NOENC (0).
+        // 2. The readData() is called to get the original (unique) payload not ever sent yet.
+        //    The payload must be encrypted for the first time if the encryption
+        //    is enabled (arg kflgs != EK_NOENC). The KK encryption flag of the data packet
+        //    header must be set and remembered accordingly (see EncryptionKeySpec).
+        // 3. The next time this packet is read (only for retransmission), the payload is already
+        //    encrypted, and the proper flag value is already stored.
+        
+        // TODO: Alternatively, encryption could happen before the packet is submitted to the buffer
+        // (before the addBuffer() call), and corresponding flags could be set accordingly.
+        // This may also put an encryption burden on the application thread, rather than the sending thread,
+        // which could be more efficient. Note that packet sequence number must be properly set in that case,
+        // as it is used as a counter for the AES encryption.
+        if (kflgs == -1)
+        {
+            HLOGC(bslog.Debug, log << CONID() << " CSndBuffer: ERROR: encryption required and not possible. NOT SENDING.");
+            readlen = 0;
+        }
+        else
+        {
+            m_pCurrBlock->m_iMsgNoBitset |= MSGNO_ENCKEYSPEC::wrap(kflgs);
+        }
+
+        Block* p = m_pCurrBlock;
+        w_packet.set_msgflags(m_pCurrBlock->m_iMsgNoBitset);
+        w_srctime = m_pCurrBlock->m_tsOriginTime;
+        m_pCurrBlock = m_pCurrBlock->m_pNext;
+
+        if ((p->m_iTTL >= 0) && (count_milliseconds(steady_clock::now() - w_srctime) > p->m_iTTL))
+        {
+            LOGC(bslog.Warn, log << CONID() << "CSndBuffer: skipping packet %" << p->m_iSeqNo << " #" << p->getMsgSeq() << " with TTL=" << p->m_iTTL);
+            // Skip this packet due to TTL expiry.
+            readlen = 0;
+            ++w_seqnoinc;
+            continue;
+        }
+
+        HLOGC(bslog.Debug, log << CONID() << "CSndBuffer: picked up packet to send: size=" << readlen
+                << " #" << w_packet.getMsgSeq()
+                << " %" << w_packet.seqno()
+                << " !" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
+
+        break;
+    }
+
+    return readlen;
+}
+
+CSndBuffer::time_point CSndBuffer::peekNextOriginal() const
+{
+    ScopedLock bufferguard(m_BufLock);
+    if (m_pCurrBlock == m_pLastBlock)
+        return time_point();
+
+    return m_pCurrBlock->m_tsOriginTime;
+}
+
+int32_t CSndBuffer::getMsgNoAt(const int offset)
+{
+    ScopedLock bufferguard(m_BufLock);
+
+    Block* p = m_pFirstBlock;
+
+    if (p)
+    {
+        HLOGC(bslog.Debug,
+              log << "CSndBuffer::getMsgNoAt: FIRST MSG: size=" << p->m_iLength << " %" << p->m_iSeqNo << " #"
+                  << p->getMsgSeq() << " !" << BufferStamp(p->m_pcData, p->m_iLength));
+    }
+
+    if (offset >= m_iCount)
+    {
+        // Prevent accessing the last "marker" block
+        LOGC(bslog.Error,
+             log << "CSndBuffer::getMsgNoAt: IPE: offset=" << offset << " not found, max offset=" << m_iCount);
+        return SRT_MSGNO_CONTROL;
+    }
+
+    // XXX Suboptimal procedure to keep the blocks identifiable
+    // by sequence number. Consider using some circular buffer.
+    int       i;
+    Block* ee SRT_ATR_UNUSED = 0;
+    for (i = 0; i < offset && p; ++i)
+    {
+        ee = p;
+        p  = p->m_pNext;
+    }
+
+    if (!p)
+    {
+        LOGC(bslog.Error,
+             log << "CSndBuffer::getMsgNoAt: IPE: offset=" << offset << " not found, stopped at " << i << " with #"
+                 << (ee ? ee->getMsgSeq() : SRT_MSGNO_NONE));
+        return SRT_MSGNO_CONTROL;
+    }
+
+    HLOGC(bslog.Debug,
+          log << "CSndBuffer::getMsgNoAt: offset=" << offset << " found, size=" << p->m_iLength << " %" << p->m_iSeqNo
+              << " #" << p->getMsgSeq() << " !" << BufferStamp(p->m_pcData, p->m_iLength));
+
+    return p->getMsgSeq();
+}
+
+int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time_point& w_srctime, DropRange& w_drop)
+{
+    // NOTE: w_packet.m_iSeqNo is expected to be set to the value
+    // of the sequence number with which this packet should be sent.
+
+    ScopedLock bufferguard(m_BufLock);
+
+    Block* p = m_pFirstBlock;
+
+    // XXX Suboptimal procedure to keep the blocks identifiable
+    // by sequence number. Consider using some circular buffer.
+    for (int i = 0; i < offset && p != m_pLastBlock; ++i)
+    {
+        p = p->m_pNext;
+    }
+    if (p == m_pLastBlock)
+    {
+        LOGC(qslog.Error, log << "CSndBuffer::readData: offset " << offset << " too large!");
+        return READ_NONE;
+    }
+#if ENABLE_HEAVY_LOGGING
+    const int32_t first_seq = p->m_iSeqNo;
+    int32_t last_seq = p->m_iSeqNo;
+#endif
+
+    // This is rexmit request, so the packet should have the sequence number
+    // already set when it was once sent uniquely.
+    SRT_ASSERT(p->m_iSeqNo == w_packet.seqno());
+
+    // Check if the block that is the next candidate to send (m_pCurrBlock pointing) is stale.
+
+    // If so, then inform the caller that it should first take care of the whole
+    // message (all blocks with that message id). Shift the m_pCurrBlock pointer
+    // to the position past the last of them. Then return -1 and set the
+    // msgno bitset packet field to the message id that should be dropped as
+    // a whole.
+
+    // After taking care of that, the caller should immediately call this function again,
+    // this time possibly in order to find the real data to be sent.
+
+    // if found block is stale
+    // (This is for messages that have declared TTL - messages that fail to be sent
+    // before the TTL defined time comes, will be dropped).
+
+    if ((p->m_iTTL >= 0) && (count_milliseconds(steady_clock::now() - p->m_tsOriginTime) > p->m_iTTL))
+    {
+        w_drop.msgno = p->getMsgSeq();
+        int msglen   = 1;
+        p            = p->m_pNext;
+        bool move    = false;
+        while (p != m_pLastBlock && w_drop.msgno == p->getMsgSeq())
+        {
+#if ENABLE_HEAVY_LOGGING
+            last_seq = p->m_iSeqNo;
+#endif
+            if (p == m_pCurrBlock)
+                move = true;
+            p = p->m_pNext;
+            if (move)
+                m_pCurrBlock = p;
+            msglen++;
+        }
+
+        HLOGC(qslog.Debug,
+              log << "CSndBuffer::readData: due to TTL exceeded, %(" << first_seq << " - " << last_seq << "), "
+                  << msglen << " packets to drop with #" << w_drop.msgno);
+
+        // Theoretically as the seq numbers are being tracked, you should be able
+        // to simply take the sequence number from the block. But this is a new
+        // feature and should be only used after refax for the sender buffer to
+        // make it manage the sequence numbers inside, instead of by CUDT::m_iSndLastDataAck.
+        w_drop.seqno[DropRange::BEGIN] = w_packet.seqno();
+        w_drop.seqno[DropRange::END] = CSeqNo::incseq(w_packet.seqno(), msglen - 1);
+
+        // Note the rules: here `p` is pointing to the first block AFTER the
+        // message to be dropped, so the end sequence should be one behind
+        // the one for p. Note that the loop rolls until hitting the first
+        // packet that doesn't belong to the message or m_pLastBlock, which
+        // is past-the-end for the occupied range in the sender buffer.
+        SRT_ASSERT(w_drop.seqno[DropRange::END] == CSeqNo::decseq(p->m_iSeqNo));
+        return READ_DROP;
+    }
+
+    w_packet.m_pcData = p->m_pcData;
+    const int readlen = p->m_iLength;
+    w_packet.setLength(readlen, m_iBlockLen);
+
+    // XXX Here the value predicted to be applied to PH_MSGNO field is extracted.
+    // As this function is predicted to extract the data to send as a rexmited packet,
+    // the packet must be in the form ready to send - so, in case of encryption,
+    // encrypted, and with all ENC flags already set. So, the first call to send
+    // the packet originally (the other overload of this function) must set these
+    // flags.
+    w_packet.set_msgflags(p->m_iMsgNoBitset);
+    w_srctime = p->m_tsOriginTime;
+
+    // This function is called when packet retransmission is triggered.
+    // Therefore we are setting the rexmit time.
+    p->m_tsRexmitTime = steady_clock::now();
+
+    HLOGC(qslog.Debug,
+          log << CONID() << "CSndBuffer: getting packet %" << p->m_iSeqNo << " as per %" << w_packet.seqno()
+              << " size=" << readlen << " to send [REXMIT]");
+
+    return readlen;
+}
+
+sync::steady_clock::time_point CSndBuffer::getPacketRexmitTime(const int offset)
+{
+    ScopedLock bufferguard(m_BufLock);
+    const Block* p = m_pFirstBlock;
+
+    // XXX Suboptimal procedure to keep the blocks identifiable
+    // by sequence number. Consider using some circular buffer.
+    for (int i = 0; i < offset; ++i)
+    {
+        SRT_ASSERT(p);
+        p = p->m_pNext;
+    }
+
+    SRT_ASSERT(p);
+    return p->m_tsRexmitTime;
+}
+
+void CSndBuffer::ackData(int offset)
+{
+    ScopedLock bufferguard(m_BufLock);
+
+    bool move = false;
+    for (int i = 0; i < offset; ++i)
+    {
+        m_iBytesCount -= m_pFirstBlock->m_iLength;
+        if (m_pFirstBlock == m_pCurrBlock)
+            move = true;
+        m_pFirstBlock = m_pFirstBlock->m_pNext;
+    }
+    if (move)
+        m_pCurrBlock = m_pFirstBlock;
+
+    m_iCount = m_iCount - offset;
+
+    updAvgBufSize(steady_clock::now());
+}
+
+int CSndBuffer::getCurrBufSize() const
+{
+    return m_iCount;
+}
+
+int CSndBuffer::getMaxPacketLen() const
+{
+    return m_iBlockLen - m_iAuthTagSize;
+}
+
+int CSndBuffer::countNumPacketsRequired(int iPldLen) const
+{
+    const int iPktLen = getMaxPacketLen();
+    return countNumPacketsRequired(iPldLen, iPktLen);
+}
+
+int CSndBuffer::countNumPacketsRequired(int iPldLen, int iPktLen) const
+{
+    return (iPldLen + iPktLen - 1) / iPktLen;
+}
+
+namespace {
+int round_val(double val)
+{
+    return static_cast<int>(round(val));
+}
+}
+
+int CSndBuffer::getAvgBufSize(int& w_bytes, int& w_tsp)
+{
+    ScopedLock bufferguard(m_BufLock); /* Consistency of pkts vs. bytes vs. spantime */
+
+    /* update stats in case there was no add/ack activity lately */
+    updAvgBufSize(steady_clock::now());
+
+    // Average number of packets and timespan could be small,
+    // so rounding is beneficial, while for the number of
+    // bytes in the buffer is a higher value, so rounding can be omitted,
+    // but probably better to round all three values.
+    w_bytes = round_val(m_mavg.bytes());
+    w_tsp   = round_val(m_mavg.timespan_ms());
+    return round_val(m_mavg.pkts());
+}
+
+void CSndBuffer::updAvgBufSize(const steady_clock::time_point& now)
+{
+    if (!m_mavg.isTimeToUpdate(now))
+        return;
+
+    int       bytes       = 0;
+    int       timespan_ms = 0;
+    const int pkts        = getCurrBufSize((bytes), (timespan_ms));
+    m_mavg.update(now, pkts, bytes, timespan_ms);
+}
+
+int CSndBuffer::getCurrBufSize(int& w_bytes, int& w_timespan) const
+{
+    w_bytes = m_iBytesCount;
+    /*
+     * Timespan can be less then 1000 us (1 ms) if few packets.
+     * Also, if there is only one pkt in buffer, the time difference will be 0.
+     * Therefore, always add 1 ms if not empty.
+     */
+    w_timespan = 0 < m_iCount ? (int) count_milliseconds(m_tsLastOriginTime - m_pFirstBlock->m_tsOriginTime) + 1 : 0;
+
+    return m_iCount;
+}
+
+CSndBuffer::duration CSndBuffer::getBufferingDelay(const time_point& tnow) const
+{
+    ScopedLock lck(m_BufLock);
+    SRT_ASSERT(m_pFirstBlock);
+    if (m_iCount == 0)
+        return duration(0);
+
+    return tnow - m_pFirstBlock->m_tsOriginTime;
+}
+
+int CSndBuffer::dropLateData(int& w_bytes, int32_t& w_first_msgno, const steady_clock::time_point& too_late_time)
+{
+    int     dpkts  = 0;
+    int     dbytes = 0;
+    bool    move   = false;
+    int32_t msgno  = 0;
+
+    ScopedLock bufferguard(m_BufLock);
+    for (int i = 0; i < m_iCount && m_pFirstBlock->m_tsOriginTime < too_late_time; ++i)
+    {
+        dpkts++;
+        dbytes += m_pFirstBlock->m_iLength;
+        msgno = m_pFirstBlock->getMsgSeq();
+
+        if (m_pFirstBlock == m_pCurrBlock)
+            move = true;
+        m_pFirstBlock = m_pFirstBlock->m_pNext;
+    }
+
+    if (move)
+    {
+        m_pCurrBlock = m_pFirstBlock;
+    }
+    m_iCount = m_iCount - dpkts;
+
+    m_iBytesCount -= dbytes;
+    w_bytes = dbytes;
+
+    // We report the increased number towards the last ever seen
+    // by the loop, as this last one is the last received. So remained
+    // (even if "should remain") is the first after the last removed one.
+    w_first_msgno = ++MsgNo(msgno);
+
+    updAvgBufSize(steady_clock::now());
+
+    return (dpkts);
+}
+
+void CSndBuffer::increase()
+{
+    int unitsize = m_pBuffer->m_iSize;
+
+    // new physical buffer
+    Buffer* nbuf = NULL;
+    try
+    {
+        nbuf           = new Buffer;
+        nbuf->m_pcData = new char[unitsize * m_iBlockLen];
+    }
+    catch (...)
+    {
+        delete nbuf;
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    nbuf->m_iSize = unitsize;
+    nbuf->m_pNext = NULL;
+
+    // insert the buffer at the end of the buffer list
+    Buffer* p = m_pBuffer;
+    while (p->m_pNext != NULL)
+        p = p->m_pNext;
+    p->m_pNext = nbuf;
+
+    // new packet blocks
+    Block* nblk = NULL;
+    try
+    {
+        nblk = new Block;
+    }
+    catch (...)
+    {
+        delete nblk;
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+    }
+    Block* pb = nblk;
+    for (int i = 1; i < unitsize; ++i)
+    {
+        pb->m_pNext = new Block;
+        pb          = pb->m_pNext;
+    }
+
+    // insert the new blocks onto the existing one
+    pb->m_pNext           = m_pLastBlock->m_pNext;
+    m_pLastBlock->m_pNext = nblk;
+
+    pb       = nblk;
+    char* pc = nbuf->m_pcData;
+    for (int i = 0; i < unitsize; ++i)
+    {
+        pb->m_pcData = pc;
+        pb           = pb->m_pNext;
+        pc += m_iBlockLen;
+    }
+
+    m_iSize += unitsize;
+
+    HLOGC(bslog.Debug,
+          log << "CSndBuffer: BUFFER FULL - adding " << (unitsize * m_iBlockLen) << " bytes spread to " << unitsize
+              << " blocks"
+              << " (total size: " << m_iSize << " bytes)");
+}
+
+} // namespace srt
diff --git a/srtcore/buffer_snd.h b/srtcore/buffer_snd.h
new file mode 100644
index 000000000..afd52110b
--- /dev/null
+++ b/srtcore/buffer_snd.h
@@ -0,0 +1,282 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2009, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 05/05/2009
+modified by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#ifndef INC_SRT_BUFFER_SND_H
+#define INC_SRT_BUFFER_SND_H
+
+#include "srt.h"
+#include "packet.h"
+#include "buffer_tools.h"
+
+// The notation used for "circular numbers" in comments:
+// The "cicrular numbers" are numbers that when increased up to the
+// maximum become zero, and similarly, when the zero value is decreased,
+// it turns into the maximum value minus one. This wrapping works the
+// same for adding and subtracting. Circular numbers cannot be multiplied.
+
+// Operations done on these numbers are marked with additional % character:
+// a %> b : a is later than b
+// a ++% (++%a) : shift a by 1 forward
+// a +% b : shift a by b
+// a == b : equality is same as for just numbers
+
+namespace srt {
+
+class CSndBuffer
+{
+    typedef sync::steady_clock::time_point time_point;
+    typedef sync::steady_clock::duration   duration;
+
+public:
+    // XXX There's currently no way to access the socket ID set for
+    // whatever the buffer is currently working for. Required to find
+    // some way to do this, possibly by having a "reverse pointer".
+    // Currently just "unimplemented".
+    std::string CONID() const { return ""; }
+
+    /// @brief CSndBuffer constructor.
+    /// @param size initial number of blocks (each block to store one packet payload).
+    /// @param maxpld maximum packet payload (including auth tag).
+    /// @param authtag auth tag length in bytes (16 for GCM, 0 otherwise).
+    CSndBuffer(int ip_family, int size, int maxpld, int authtag);
+    ~CSndBuffer();
+
+public:
+    /// Insert a user buffer into the sending list.
+    /// For @a w_mctrl the following fields are used:
+    /// INPUT:
+    /// - msgttl: timeout for retransmitting the message, if lost
+    /// - inorder: request to deliver the message in order of sending
+    /// - srctime: local time as a base for packet's timestamp (0 if unused)
+    /// - pktseq: sequence number to be stamped on the packet (-1 if unused)
+    /// - msgno: message number to be stamped on the packet (-1 if unused)
+    /// OUTPUT:
+    /// - srctime: local time stamped on the packet (same as input, if input wasn't 0)
+    /// - pktseq: sequence number to be stamped on the next packet
+    /// - msgno: message number stamped on the packet
+    /// @param [in] data pointer to the user data block.
+    /// @param [in] len size of the block.
+    /// @param [inout] w_mctrl Message control data
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    void addBuffer(const char* data, int len, SRT_MSGCTRL& w_mctrl);
+
+    /// Read a block of data from file and insert it into the sending list.
+    /// @param [in] ifs input file stream.
+    /// @param [in] len size of the block.
+    /// @return actual size of data added from the file.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    int addBufferFromFile(std::fstream& ifs, int len);
+
+    // Special values that can be returned by readData.
+    static const int READ_NONE = 0;
+    static const int READ_DROP = -1;
+
+    /// Find data position to pack a DATA packet from the furthest reading point.
+    /// @param [out] packet the packet to read.
+    /// @param [out] origintime origin time stamp of the message
+    /// @param [in] kflags Odd|Even crypto key flag
+    /// @param [out] seqnoinc the number of packets skipped due to TTL, so that seqno should be incremented.
+    /// @return Actual length of data read.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    int readData(CPacket& w_packet, time_point& w_origintime, int kflgs, int& w_seqnoinc);
+
+    /// Peek an information on the next original data packet to send.
+    /// @return origin time stamp of the next packet; epoch start time otherwise.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    time_point peekNextOriginal() const;
+
+    struct DropRange
+    {
+        static const size_t BEGIN = 0, END = 1;
+        int32_t seqno[2];
+        int32_t msgno;
+    };
+    /// Find data position to pack a DATA packet for a retransmission.
+    /// IMPORTANT: @a packet is [in,out] because it is expected to get set
+    /// the sequence number of the packet expected to be sent next. The sender
+    /// buffer normally doesn't handle sequence numbers and the consistency
+    /// between the sequence number of a packet already sent and kept in the
+    /// buffer is achieved by having the sequence number recorded in the
+    /// CUDT::m_iSndLastDataAck field that should represent the oldest packet
+    /// still in the buffer.
+    /// @param [in] offset offset from the last ACK point (backward sequence number difference)
+    /// @param [in,out] w_packet storage for the packet, preinitialized with sequence number
+    /// @param [out] w_origintime origin time stamp of the message
+    /// @param [out] w_drop the drop information in case when dropping is to be done instead
+    /// @retval >0 Length of the data read.
+    /// @retval READ_NONE No data available or @a offset points out of the buffer occupied space.
+    /// @retval READ_DROP The call requested data drop due to TTL exceeded, to be handled first.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    int readData(const int offset, CPacket& w_packet, time_point& w_origintime, DropRange& w_drop);
+
+    /// Get the time of the last retransmission (if any) of the DATA packet.
+    /// @param [in] offset offset from the last ACK point (backward sequence number difference)
+    ///
+    /// @return Last time of the last retransmission event for the corresponding DATA packet.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    time_point getPacketRexmitTime(const int offset);
+
+    /// Update the ACK point and may release/unmap/return the user data according to the flag.
+    /// @param [in] offset number of packets acknowledged.
+    int32_t getMsgNoAt(const int offset);
+
+    void ackData(int offset);
+
+    /// Read size of data still in the sending list.
+    /// @return Current size of the data in the sending list.
+    int getCurrBufSize() const;
+
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    int dropLateData(int& bytes, int32_t& w_first_msgno, const time_point& too_late_time);
+
+    void updAvgBufSize(const time_point& time);
+    int  getAvgBufSize(int& bytes, int& timespan);
+    int  getCurrBufSize(int& bytes, int& timespan) const;
+
+
+    /// Het maximum payload length per packet.
+    int getMaxPacketLen() const;
+
+    /// @brief Count the number of required packets to store the payload (message).
+    /// @param iPldLen the length of the payload to check.
+    /// @return the number of required data packets.
+    int countNumPacketsRequired(int iPldLen) const;
+
+    /// @brief Count the number of required packets to store the payload (message).
+    /// @param iPldLen the length of the payload to check.
+    /// @param iMaxPktLen the maximum payload length of the packet (the value returned from getMaxPacketLen()).
+    /// @return the number of required data packets.
+    int countNumPacketsRequired(int iPldLen, int iMaxPktLen) const;
+
+    /// @brief Get the buffering delay of the oldest message in the buffer.
+    /// @return the delay value.
+    SRT_ATTR_EXCLUDES(m_BufLock)
+    duration getBufferingDelay(const time_point& tnow) const;
+
+    uint64_t getInRatePeriod() const { return m_rateEstimator.getInRatePeriod(); }
+
+    /// Retrieve input bitrate in bytes per second
+    int getInputRate() const { return m_rateEstimator.getInputRate(); }
+
+    void resetInputRateSmpPeriod(bool disable = false) { m_rateEstimator.resetInputRateSmpPeriod(disable); }
+
+    const CRateEstimator& getRateEstimator() const { return m_rateEstimator; }
+
+    void setRateEstimator(const CRateEstimator& other) { m_rateEstimator = other; }
+
+private:
+    void increase();
+
+private:
+    mutable sync::Mutex m_BufLock; // used to synchronize buffer operation
+
+    struct Block
+    {
+        char* m_pcData;  // pointer to the data block
+        int   m_iLength; // payload length of the block (excluding auth tag).
+
+        int32_t    m_iMsgNoBitset; // message number
+        int32_t    m_iSeqNo;       // sequence number for scheduling
+        time_point m_tsOriginTime; // block origin time (either provided from above or equals the time a message was submitted for sending.
+        time_point m_tsRexmitTime; // packet retransmission time
+        int        m_iTTL; // time to live (milliseconds)
+
+        Block* m_pNext; // next block
+
+        int32_t getMsgSeq()
+        {
+            // NOTE: this extracts message ID with regard to REXMIT flag.
+            // This is valid only for message ID that IS GENERATED in this instance,
+            // not provided by the peer. This can be otherwise sent to the peer - it doesn't matter
+            // for the peer that it uses LESS bits to represent the message.
+            return m_iMsgNoBitset & MSGNO_SEQ::mask;
+        }
+
+    } * m_pBlock, *m_pFirstBlock, *m_pCurrBlock, *m_pLastBlock;
+
+    // m_pBlock:         The head pointer
+    // m_pFirstBlock:    The first block
+    // m_pCurrBlock:	 The current block
+    // m_pLastBlock:     The last block (if first == last, buffer is empty)
+
+    struct Buffer
+    {
+        char*   m_pcData; // buffer
+        int     m_iSize;  // size
+        Buffer* m_pNext;  // next buffer
+    } * m_pBuffer;        // physical buffer
+
+    int32_t m_iNextMsgNo; // next message number
+
+    int m_iSize; // buffer size (number of packets)
+    const int m_iBlockLen;  // maximum length of a block holding packet payload and AUTH tag (excluding packet header).
+    const int m_iAuthTagSize; // Authentication tag size (if GCM is enabled).
+
+    // NOTE: This is atomic AND under lock because the function getCurrBufSize()
+    // is returning it WITHOUT locking. Modification, however, must stay under
+    // a lock.
+    sync::atomic<int> m_iCount; // number of used blocks
+
+    int        m_iBytesCount; // number of payload bytes in queue
+    time_point m_tsLastOriginTime;
+
+    AvgBufSize m_mavg;
+    CRateEstimator m_rateEstimator;
+
+private:
+    CSndBuffer(const CSndBuffer&);
+    CSndBuffer& operator=(const CSndBuffer&);
+};
+
+} // namespace srt
+
+#endif
diff --git a/srtcore/buffer_tools.cpp b/srtcore/buffer_tools.cpp
new file mode 100644
index 000000000..7473e3824
--- /dev/null
+++ b/srtcore/buffer_tools.cpp
@@ -0,0 +1,277 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 03/12/2011
+modified by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#include "platform_sys.h"
+#include "buffer_tools.h"
+#include "packet.h"
+#include "logger_defs.h"
+#include "utilities.h"
+
+namespace srt {
+
+using namespace std;
+using namespace srt_logging;
+using namespace sync;
+
+// You can change this value at build config by using "ENFORCE" options.
+#if !defined(SRT_MAVG_SAMPLING_RATE)
+#define SRT_MAVG_SAMPLING_RATE 40
+#endif
+
+bool AvgBufSize::isTimeToUpdate(const time_point& now) const
+{
+    const int      usMAvgBasePeriod = 1000000; // 1s in microseconds
+    const int      us2ms            = 1000;
+    const int      msMAvgPeriod     = (usMAvgBasePeriod / SRT_MAVG_SAMPLING_RATE) / us2ms;
+    const uint64_t elapsed_ms       = count_milliseconds(now - m_tsLastSamplingTime); // ms since last sampling
+    return (elapsed_ms >= msMAvgPeriod);
+}
+
+void AvgBufSize::update(const steady_clock::time_point& now, int pkts, int bytes, int timespan_ms)
+{
+    const uint64_t elapsed_ms       = count_milliseconds(now - m_tsLastSamplingTime); // ms since last sampling
+    m_tsLastSamplingTime            = now;
+    const uint64_t one_second_in_ms = 1000;
+    if (elapsed_ms > one_second_in_ms)
+    {
+        // No sampling in last 1 sec, initialize average
+        m_dCountMAvg      = pkts;
+        m_dBytesCountMAvg = bytes;
+        m_dTimespanMAvg   = timespan_ms;
+        return;
+    }
+
+    //
+    // weight last average value between -1 sec and last sampling time (LST)
+    // and new value between last sampling time and now
+    //                                      |elapsed_ms|
+    //   +----------------------------------+-------+
+    //  -1                                 LST      0(now)
+    //
+    m_dCountMAvg      = avg_iir_w<1000, double>(m_dCountMAvg, pkts, elapsed_ms);
+    m_dBytesCountMAvg = avg_iir_w<1000, double>(m_dBytesCountMAvg, bytes, elapsed_ms);
+    m_dTimespanMAvg   = avg_iir_w<1000, double>(m_dTimespanMAvg, timespan_ms, elapsed_ms);
+}
+
+CRateEstimator::CRateEstimator(int /*family*/)
+    : m_iInRatePktsCount(0)
+    , m_iInRateBytesCount(0)
+    , m_InRatePeriod(INPUTRATE_FAST_START_US) // 0.5 sec (fast start)
+    , m_iInRateBps(INPUTRATE_INITIAL_BYTESPS)
+    , m_iFullHeaderSize(CPacket::UDP_HDR_SIZE + CPacket::HDR_SIZE)
+{}
+
+void CRateEstimator::setInputRateSmpPeriod(int period)
+{
+    m_InRatePeriod = (uint64_t)period; //(usec) 0=no input rate calculation
+}
+
+void CRateEstimator::updateInputRate(const time_point& time, int pkts, int bytes)
+{
+    // no input rate calculation
+    if (m_InRatePeriod == 0)
+        return;
+
+    if (is_zero(m_tsInRateStartTime))
+    {
+        m_tsInRateStartTime = time;
+        return;
+    }
+    else if (time < m_tsInRateStartTime)
+    {
+        // Old packets are being submitted for estimation, e.g. during the backup link activation.
+        return;
+    }
+
+    m_iInRatePktsCount  += pkts;
+    m_iInRateBytesCount += bytes;
+
+    // Trigger early update in fast start mode
+    const bool early_update = (m_InRatePeriod < INPUTRATE_RUNNING_US) && (m_iInRatePktsCount > INPUTRATE_MAX_PACKETS);
+
+    const uint64_t period_us = count_microseconds(time - m_tsInRateStartTime);
+    if (!early_update && period_us <= m_InRatePeriod)
+        return;
+
+    // Required Byte/sec rate (payload + headers)
+    m_iInRateBytesCount += (m_iInRatePktsCount * m_iFullHeaderSize);
+    m_iInRateBps = (int)(((int64_t)m_iInRateBytesCount * 1000000) / period_us);
+    HLOGC(bslog.Debug,
+        log << "updateInputRate: pkts:" << m_iInRateBytesCount << " bytes:" << m_iInRatePktsCount
+        << " rate=" << (m_iInRateBps * 8) / 1000 << "kbps interval=" << period_us);
+    m_iInRatePktsCount  = 0;
+    m_iInRateBytesCount = 0;
+    m_tsInRateStartTime = time;
+
+    setInputRateSmpPeriod(INPUTRATE_RUNNING_US);
+}
+
+CSndRateEstimator::CSndRateEstimator(const time_point& tsNow)
+    : m_tsFirstSampleTime(tsNow)
+    , m_iFirstSampleIdx(0)
+    , m_iCurSampleIdx(0)
+    , m_iRateBps(0)
+{
+    
+}
+
+void CSndRateEstimator::addSample(const time_point& ts, int pkts, size_t bytes)
+{
+    const int iSampleDeltaIdx = (int) count_milliseconds(ts - m_tsFirstSampleTime) / SAMPLE_DURATION_MS;
+    const int delta = NUM_PERIODS - iSampleDeltaIdx;
+
+    // TODO: -delta <= NUM_PERIODS, then just reset the state on the estimator.
+
+    if (iSampleDeltaIdx >= 2 * NUM_PERIODS)
+    {
+        // Just reset the estimator and start like if new.
+        for (int i = 0; i < NUM_PERIODS; ++i)
+        {
+            const int idx = incSampleIdx(m_iFirstSampleIdx, i);
+            m_Samples[idx].reset();
+
+            if (idx == m_iCurSampleIdx)
+                break;
+        }
+
+        m_iFirstSampleIdx = 0;
+        m_iCurSampleIdx = 0;
+        m_iRateBps = 0;
+        m_tsFirstSampleTime += milliseconds_from(iSampleDeltaIdx * SAMPLE_DURATION_MS);
+    }
+    else if (iSampleDeltaIdx > NUM_PERIODS)
+    {
+        // In run-time a constant flow of samples is expected. Once all periods are filled (after 1 second of sampling),
+        // the iSampleDeltaIdx should be either (NUM_PERIODS - 1),
+        // or NUM_PERIODS. In the later case it means the start of a new sampling period.
+        int d = delta;
+        while (d < 0)
+        {
+            m_Samples[m_iFirstSampleIdx].reset();
+            m_iFirstSampleIdx = incSampleIdx(m_iFirstSampleIdx);
+            m_tsFirstSampleTime += milliseconds_from(SAMPLE_DURATION_MS);
+            m_iCurSampleIdx = incSampleIdx(m_iCurSampleIdx);
+            ++d;
+        }
+    }
+
+    // Check if the new sample period has started.
+    const int iNewDeltaIdx = (int) count_milliseconds(ts - m_tsFirstSampleTime) / SAMPLE_DURATION_MS;
+    if (incSampleIdx(m_iFirstSampleIdx, iNewDeltaIdx) != m_iCurSampleIdx)
+    {
+        // Now there should be some periods (at most last NUM_PERIODS) ready to be summed,
+        // rate estimation updated, after which all the new entry should be added.
+        Sample sum;
+        int iNumPeriods = 0;
+        bool bMetNonEmpty = false;
+        for (int i = 0; i < NUM_PERIODS; ++i)
+        {
+            const int idx = incSampleIdx(m_iFirstSampleIdx, i);
+            const Sample& s = m_Samples[idx];
+            sum += s;
+            if (bMetNonEmpty || !s.empty())
+            {
+                ++iNumPeriods;
+                bMetNonEmpty = true;
+            }
+
+            if (idx == m_iCurSampleIdx)
+                break;
+        }
+
+        if (iNumPeriods == 0)
+        {
+            m_iRateBps = 0;
+        }
+        else
+        {
+            m_iRateBps = (sum.m_iBytesCount + CPacket::HDR_SIZE * sum.m_iPktsCount) * 1000 / (iNumPeriods * SAMPLE_DURATION_MS);
+        }
+
+        HLOGC(bslog.Note,
+            log << "CSndRateEstimator: new rate estimation :" << (m_iRateBps * 8) / 1000 << " kbps. Based on "
+                 << iNumPeriods << " periods, " << sum.m_iPktsCount << " packets, " << sum.m_iBytesCount << " bytes.");
+
+        // Shift one sampling period to start collecting the new one.
+        m_iCurSampleIdx = incSampleIdx(m_iCurSampleIdx);
+        m_Samples[m_iCurSampleIdx].reset();
+        
+        // If all NUM_SAMPLES are recorded, the first position has to be shifted as well.
+        if (delta <= 0)
+        {
+            m_iFirstSampleIdx = incSampleIdx(m_iFirstSampleIdx);
+            m_tsFirstSampleTime += milliseconds_from(SAMPLE_DURATION_MS);
+        }
+    }
+
+    m_Samples[m_iCurSampleIdx].m_iBytesCount += bytes;
+    m_Samples[m_iCurSampleIdx].m_iPktsCount += pkts;
+}
+
+int CSndRateEstimator::getCurrentRate() const
+{
+    SRT_ASSERT(m_iCurSampleIdx >= 0 && m_iCurSampleIdx < NUM_PERIODS);
+    const Sample& s = m_Samples[m_iCurSampleIdx];
+    return (int) avg_iir<16, unsigned long long>(m_iRateBps, (CPacket::HDR_SIZE * s.m_iPktsCount + s.m_iBytesCount) * 1000 / SAMPLE_DURATION_MS);
+}
+
+int CSndRateEstimator::incSampleIdx(int val, int inc) const
+{
+    SRT_ASSERT(inc >= 0 && inc <= NUM_PERIODS);
+    val += inc;
+    while (val >= NUM_PERIODS)
+        val -= NUM_PERIODS;
+    return val;
+}
+
+}
+
diff --git a/srtcore/buffer_tools.h b/srtcore/buffer_tools.h
new file mode 100644
index 000000000..88479827d
--- /dev/null
+++ b/srtcore/buffer_tools.h
@@ -0,0 +1,203 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2009, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 05/05/2009
+modified by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#ifndef INC_SRT_BUFFER_TOOLS_H
+#define INC_SRT_BUFFER_TOOLS_H
+
+#include "common.h"
+
+namespace srt
+{
+
+/// The AvgBufSize class is used to calculate moving average of the buffer (RCV or SND)
+class AvgBufSize
+{
+    typedef sync::steady_clock::time_point time_point;
+
+public:
+    AvgBufSize()
+        : m_dBytesCountMAvg(0.0)
+        , m_dCountMAvg(0.0)
+        , m_dTimespanMAvg(0.0)
+    {
+    }
+
+public:
+    bool isTimeToUpdate(const time_point& now) const;
+    void update(const time_point& now, int pkts, int bytes, int timespan_ms);
+
+public:
+    inline double pkts() const { return m_dCountMAvg; }
+    inline double timespan_ms() const { return m_dTimespanMAvg; }
+    inline double bytes() const { return m_dBytesCountMAvg; }
+
+private:
+    time_point m_tsLastSamplingTime;
+    double     m_dBytesCountMAvg;
+    double     m_dCountMAvg;
+    double     m_dTimespanMAvg;
+};
+
+/// The class to estimate source bitrate based on samples submitted to the buffer.
+/// Is currently only used by the CSndBuffer.
+class CRateEstimator
+{
+    typedef sync::steady_clock::time_point time_point;
+    typedef sync::steady_clock::duration   duration;
+public:
+    CRateEstimator(int family);
+
+public:
+    uint64_t getInRatePeriod() const { return m_InRatePeriod; }
+
+    /// Retrieve input bitrate in bytes per second
+    int getInputRate() const { return m_iInRateBps; }
+
+    void setInputRateSmpPeriod(int period);
+
+    /// Update input rate calculation.
+    /// @param [in] time   current time
+    /// @param [in] pkts   number of packets newly added to the buffer
+    /// @param [in] bytes  number of payload bytes in those newly added packets
+    void updateInputRate(const time_point& time, int pkts = 0, int bytes = 0);
+
+    void resetInputRateSmpPeriod(bool disable = false) { setInputRateSmpPeriod(disable ? 0 : INPUTRATE_FAST_START_US); }
+
+private:                                                       // Constants
+    static const uint64_t INPUTRATE_FAST_START_US   = 500000;  //  500 ms
+    static const uint64_t INPUTRATE_RUNNING_US      = 1000000; // 1000 ms
+    static const int64_t  INPUTRATE_MAX_PACKETS     = 2000;    // ~ 21 Mbps of 1316 bytes payload
+    static const int      INPUTRATE_INITIAL_BYTESPS = BW_INFINITE;
+
+private:
+    int        m_iInRatePktsCount;  // number of payload packets added since InRateStartTime.
+    int        m_iInRateBytesCount; // number of payload bytes added since InRateStartTime.
+    time_point m_tsInRateStartTime;
+    uint64_t   m_InRatePeriod; // usec
+    int        m_iInRateBps;   // Input Rate in Bytes/sec
+    int        m_iFullHeaderSize;
+};
+
+
+class CSndRateEstimator
+{
+    typedef sync::steady_clock::time_point time_point;
+
+public:
+    CSndRateEstimator(const time_point& tsNow);
+
+    /// Add sample.
+    /// @param [in] time   sample (sending) time.
+    /// @param [in] pkts   number of packets in the sample.
+    /// @param [in] bytes  number of payload bytes in the sample.
+    void addSample(const time_point& time, int pkts = 0, size_t bytes = 0);
+
+    /// Retrieve estimated bitrate in bytes per second with 16-byte packet header.
+    int getRate() const { return m_iRateBps; }
+
+    /// Retrieve estimated bitrate in bytes per second (with 16-byte packet header)
+    /// including the current sampling interval.
+    int getCurrentRate() const;
+
+private:
+    static const int NUM_PERIODS        = 10;
+    static const int SAMPLE_DURATION_MS = 100; // 100 ms
+    struct Sample
+    {
+        int m_iPktsCount;  // number of payload packets
+        int m_iBytesCount; // number of payload bytes
+
+        void reset()
+        {
+            m_iPktsCount  = 0;
+            m_iBytesCount = 0;
+        }
+
+        Sample()
+            : m_iPktsCount(0)
+            , m_iBytesCount(0)
+        {
+        }
+
+        Sample(int iPkts, int iBytes)
+            : m_iPktsCount(iPkts)
+            , m_iBytesCount(iBytes)
+        {
+        }
+
+        Sample operator+(const Sample& other)
+        {
+            return Sample(m_iPktsCount + other.m_iPktsCount, m_iBytesCount + other.m_iBytesCount);
+        }
+
+        Sample& operator+=(const Sample& other)
+        {
+            *this = *this + other;
+            return *this;
+        }
+
+        bool empty() const { return m_iPktsCount == 0; }
+    };
+
+    int incSampleIdx(int val, int inc = 1) const;
+
+    Sample m_Samples[NUM_PERIODS];
+
+    time_point m_tsFirstSampleTime; //< Start time of the first sample.
+    int        m_iFirstSampleIdx;   //< Index of the first sample.
+    int        m_iCurSampleIdx;     //< Index of the current sample being collected.
+    int        m_iRateBps;          //< Rate in Bytes/sec.
+};
+
+} // namespace srt
+
+#endif
diff --git a/srtcore/cache.cpp b/srtcore/cache.cpp
index bc9640655..2c6f624c4 100644
--- a/srtcore/cache.cpp
+++ b/srtcore/cache.cpp
@@ -38,7 +38,6 @@ written by
    Yunhong Gu, last updated 05/05/2009
 *****************************************************************************/
 
-
 #include "platform_sys.h"
 
 #include <cstring>
@@ -47,72 +46,72 @@ written by
 
 using namespace std;
 
-CInfoBlock& CInfoBlock::copyFrom(const CInfoBlock& obj)
+srt::CInfoBlock& srt::CInfoBlock::copyFrom(const CInfoBlock& obj)
 {
-   std::copy(obj.m_piIP, obj.m_piIP + 4, m_piIP);
-   m_iIPversion = obj.m_iIPversion;
-   m_ullTimeStamp = obj.m_ullTimeStamp;
-   m_iRTT = obj.m_iRTT;
-   m_iBandwidth = obj.m_iBandwidth;
-   m_iLossRate = obj.m_iLossRate;
-   m_iReorderDistance = obj.m_iReorderDistance;
-   m_dInterval = obj.m_dInterval;
-   m_dCWnd = obj.m_dCWnd;
-
-   return *this;
+    std::copy(obj.m_piIP, obj.m_piIP + 4, m_piIP);
+    m_iIPversion       = obj.m_iIPversion;
+    m_ullTimeStamp     = obj.m_ullTimeStamp;
+    m_iSRTT            = obj.m_iSRTT;
+    m_iBandwidth       = obj.m_iBandwidth;
+    m_iLossRate        = obj.m_iLossRate;
+    m_iReorderDistance = obj.m_iReorderDistance;
+    m_dInterval        = obj.m_dInterval;
+    m_dCWnd            = obj.m_dCWnd;
+
+    return *this;
 }
 
-bool CInfoBlock::operator==(const CInfoBlock& obj)
+bool srt::CInfoBlock::operator==(const CInfoBlock& obj) const
 {
-   if (m_iIPversion != obj.m_iIPversion)
-      return false;
+    if (m_iIPversion != obj.m_iIPversion)
+        return false;
 
-   else if (m_iIPversion == AF_INET)
-      return (m_piIP[0] == obj.m_piIP[0]);
+    else if (m_iIPversion == AF_INET)
+        return (m_piIP[0] == obj.m_piIP[0]);
 
-   for (int i = 0; i < 4; ++ i)
-   {
-      if (m_piIP[i] != obj.m_piIP[i])
-         return false;
-   }
+    for (int i = 0; i < 4; ++i)
+    {
+        if (m_piIP[i] != obj.m_piIP[i])
+            return false;
+    }
 
-   return true;
+    return true;
 }
 
-CInfoBlock* CInfoBlock::clone()
+srt::CInfoBlock* srt::CInfoBlock::clone()
 {
-   CInfoBlock* obj = new CInfoBlock;
-
-   std::copy(m_piIP, m_piIP + 4, obj->m_piIP);
-   obj->m_iIPversion = m_iIPversion;
-   obj->m_ullTimeStamp = m_ullTimeStamp;
-   obj->m_iRTT = m_iRTT;
-   obj->m_iBandwidth = m_iBandwidth;
-   obj->m_iLossRate = m_iLossRate;
-   obj->m_iReorderDistance = m_iReorderDistance;
-   obj->m_dInterval = m_dInterval;
-   obj->m_dCWnd = m_dCWnd;
-
-   return obj;
+    CInfoBlock* obj = new CInfoBlock;
+
+    std::copy(m_piIP, m_piIP + 4, obj->m_piIP);
+    obj->m_iIPversion       = m_iIPversion;
+    obj->m_ullTimeStamp     = m_ullTimeStamp;
+    obj->m_iSRTT            = m_iSRTT;
+    obj->m_iBandwidth       = m_iBandwidth;
+    obj->m_iLossRate        = m_iLossRate;
+    obj->m_iReorderDistance = m_iReorderDistance;
+    obj->m_dInterval        = m_dInterval;
+    obj->m_dCWnd            = m_dCWnd;
+
+    return obj;
 }
 
-int CInfoBlock::getKey()
+int srt::CInfoBlock::getKey()
 {
-   if (m_iIPversion == AF_INET)
-      return m_piIP[0];
+    if (m_iIPversion == AF_INET)
+        return m_piIP[0];
 
-   return m_piIP[0] + m_piIP[1] + m_piIP[2] + m_piIP[3];
+    return m_piIP[0] + m_piIP[1] + m_piIP[2] + m_piIP[3];
 }
 
-void CInfoBlock::convert(const sockaddr_any& addr, uint32_t aw_ip[4])
+void srt::CInfoBlock::convert(const sockaddr_any& addr, uint32_t aw_ip[4])
 {
-   if (addr.family() == AF_INET)
-   {
-      aw_ip[0] = addr.sin.sin_addr.s_addr;
-      aw_ip[1] = aw_ip[2] = aw_ip[3] = 0;
-   }
-   else
-   {
-      memcpy((aw_ip), addr.sin6.sin6_addr.s6_addr, sizeof addr.sin6.sin6_addr.s6_addr);
-   }
+    if (addr.family() == AF_INET)
+    {
+        aw_ip[0] = addr.sin.sin_addr.s_addr;
+        aw_ip[1] = aw_ip[2] = aw_ip[3] = 0;
+    }
+    else
+    {
+        memcpy((aw_ip), addr.sin6.sin6_addr.s6_addr, sizeof addr.sin6.sin6_addr.s6_addr);
+    }
 }
diff --git a/srtcore/cache.h b/srtcore/cache.h
index 71ec4435a..d7f586c20 100644
--- a/srtcore/cache.h
+++ b/srtcore/cache.h
@@ -48,222 +48,223 @@ written by
 #include "netinet_any.h"
 #include "udt.h"
 
+namespace srt
+{
+
 class CCacheItem
 {
 public:
-   virtual ~CCacheItem() {}
+    virtual ~CCacheItem() {}
 
 public:
-   virtual CCacheItem& operator=(const CCacheItem&) = 0;
+    virtual CCacheItem& operator=(const CCacheItem&) = 0;
 
-   // The "==" operator SHOULD only compare key values.
-   virtual bool operator==(const CCacheItem&) = 0;
+    // The "==" operator SHOULD only compare key values.
+    virtual bool operator==(const CCacheItem&) = 0;
 
-      /// get a deep copy clone of the current item
-      /// @return Pointer to the new item, or NULL if failed.
+    /// get a deep copy clone of the current item
+    /// @return Pointer to the new item, or NULL if failed.
 
-   virtual CCacheItem* clone() = 0;
+    virtual CCacheItem* clone() = 0;
 
-      /// get a random key value between 0 and MAX_INT to be used for the hash in cache
-      /// @return A random hash key.
+    /// get a random key value between 0 and MAX_INT to be used for the hash in cache
+    /// @return A random hash key.
 
-   virtual int getKey() = 0;
+    virtual int getKey() = 0;
 
-   // If there is any shared resources between the cache item and its clone,
-   // the shared resource should be released by this function.
-   virtual void release() {}
+    // If there is any shared resources between the cache item and its clone,
+    // the shared resource should be released by this function.
+    virtual void release() {}
 };
 
-template<typename T> class CCache
+template <typename T>
+class CCache
 {
 public:
-   CCache(int size = 1024):
-   m_iMaxSize(size),
-   m_iHashSize(size * 3),
-   m_iCurrSize(0)
-   {
-      m_vHashPtr.resize(m_iHashSize);
-      // Exception: -> CUDTUnited ctor
-      srt::sync::setupMutex(m_Lock, "Cache");
-   }
-
-   ~CCache()
-   {
-      clear();
-   }
+    CCache(int size = 1024)
+        : m_iMaxSize(size)
+        , m_iHashSize(size * 3)
+        , m_iCurrSize(0)
+    {
+        m_vHashPtr.resize(m_iHashSize);
+        // Exception: -> CUDTUnited ctor
+        srt::sync::setupMutex(m_Lock, "Cache");
+    }
+
+    ~CCache() { clear(); }
 
 public:
-      /// find the matching item in the cache.
-      /// @param [in,out] data storage for the retrieved item; initially it must carry the key information
-      /// @return 0 if found a match, otherwise -1.
-
-   int lookup(T* data)
-   {
-      srt::sync::ScopedLock cacheguard(m_Lock);
-
-      int key = data->getKey();
-      if (key < 0)
-         return -1;
-      if (key >= m_iMaxSize)
-         key %= m_iHashSize;
-
-      const ItemPtrList& item_list = m_vHashPtr[key];
-      for (typename ItemPtrList::const_iterator i = item_list.begin(); i != item_list.end(); ++ i)
-      {
-         if (*data == ***i)
-         {
-            // copy the cached info
-            *data = ***i;
-            return 0;
-         }
-      }
-
-      return -1;
-   }
-
-      /// update an item in the cache, or insert one if it doesn't exist; oldest item may be removed
-      /// @param [in] data the new item to updated/inserted to the cache
-      /// @return 0 if success, otherwise -1.
-
-   int update(T* data)
-   {
-      srt::sync::ScopedLock cacheguard(m_Lock);
-
-      int key = data->getKey();
-      if (key < 0)
-         return -1;
-      if (key >= m_iMaxSize)
-         key %= m_iHashSize;
-
-      T* curr = NULL;
-
-      ItemPtrList& item_list = m_vHashPtr[key];
-      for (typename ItemPtrList::iterator i = item_list.begin(); i != item_list.end(); ++ i)
-      {
-         if (*data == ***i)
-         {
-            // update the existing entry with the new value
-            ***i = *data;
-            curr = **i;
-
-            // remove the current entry
-            m_StorageList.erase(*i);
-            item_list.erase(i);
-
-            // re-insert to the front
-            m_StorageList.push_front(curr);
-            item_list.push_front(m_StorageList.begin());
-
-            return 0;
-         }
-      }
-
-      // create new entry and insert to front
-      curr = data->clone();
-      m_StorageList.push_front(curr);
-      item_list.push_front(m_StorageList.begin());
-
-      ++ m_iCurrSize;
-      if (m_iCurrSize >= m_iMaxSize)
-      {
-         // Cache overflow, remove oldest entry.
-         T* last_data = m_StorageList.back();
-         int last_key = last_data->getKey() % m_iHashSize;
-
-         ItemPtrList& last_item_list = m_vHashPtr[last_key];
-         for (typename ItemPtrList::iterator i = last_item_list.begin(); i != last_item_list.end(); ++ i)
-         {
-            if (*last_data == ***i)
+    /// find the matching item in the cache.
+    /// @param [in,out] data storage for the retrieved item; initially it must carry the key information
+    /// @return 0 if found a match, otherwise -1.
+
+    int lookup(T* data)
+    {
+        srt::sync::ScopedLock cacheguard(m_Lock);
+
+        int key = data->getKey();
+        if (key < 0)
+            return -1;
+        if (key >= m_iMaxSize)
+            key %= m_iHashSize;
+
+        const ItemPtrList& item_list = m_vHashPtr[key];
+        for (typename ItemPtrList::const_iterator i = item_list.begin(); i != item_list.end(); ++i)
+        {
+            if (*data == ***i)
             {
-               last_item_list.erase(i);
-               break;
+                // copy the cached info
+                *data = ***i;
+                return 0;
             }
-         }
-
-         last_data->release();
-         delete last_data;
-         m_StorageList.pop_back();
-         -- m_iCurrSize;
-      }
-
-      return 0;
-   }
-
-      /// Specify the cache size (i.e., max number of items).
-      /// @param [in] size max cache size.
-
-   void setSizeLimit(int size)
-   {
-      m_iMaxSize = size;
-      m_iHashSize = size * 3;
-      m_vHashPtr.resize(m_iHashSize);
-   }
-
-      /// Clear all entries in the cache, restore to initialization state.
-
-   void clear()
-   {
-      for (typename std::list<T*>::iterator i = m_StorageList.begin(); i != m_StorageList.end(); ++ i)
-      {
-         (*i)->release();
-         delete *i;
-      }
-      m_StorageList.clear();
-      for (typename std::vector<ItemPtrList>::iterator i = m_vHashPtr.begin(); i != m_vHashPtr.end(); ++ i)
-         i->clear();
-      m_iCurrSize = 0;
-   }
+        }
+
+        return -1;
+    }
+
+    /// update an item in the cache, or insert one if it doesn't exist; oldest item may be removed
+    /// @param [in] data the new item to updated/inserted to the cache
+    /// @return 0 if success, otherwise -1.
+
+    int update(T* data)
+    {
+        srt::sync::ScopedLock cacheguard(m_Lock);
+
+        int key = data->getKey();
+        if (key < 0)
+            return -1;
+        if (key >= m_iMaxSize)
+            key %= m_iHashSize;
+
+        T* curr = NULL;
+
+        ItemPtrList& item_list = m_vHashPtr[key];
+        for (typename ItemPtrList::iterator i = item_list.begin(); i != item_list.end(); ++i)
+        {
+            if (*data == ***i)
+            {
+                // update the existing entry with the new value
+                ***i = *data;
+                curr = **i;
+
+                // remove the current entry
+                m_StorageList.erase(*i);
+                item_list.erase(i);
+
+                // re-insert to the front
+                m_StorageList.push_front(curr);
+                item_list.push_front(m_StorageList.begin());
+
+                return 0;
+            }
+        }
+
+        // create new entry and insert to front
+        curr = data->clone();
+        m_StorageList.push_front(curr);
+        item_list.push_front(m_StorageList.begin());
+
+        ++m_iCurrSize;
+        if (m_iCurrSize >= m_iMaxSize)
+        {
+            // Cache overflow, remove oldest entry.
+            T*  last_data = m_StorageList.back();
+            int last_key  = last_data->getKey() % m_iHashSize;
+
+            ItemPtrList& last_item_list = m_vHashPtr[last_key];
+            for (typename ItemPtrList::iterator i = last_item_list.begin(); i != last_item_list.end(); ++i)
+            {
+                if (*last_data == ***i)
+                {
+                    last_item_list.erase(i);
+                    break;
+                }
+            }
+
+            last_data->release();
+            delete last_data;
+            m_StorageList.pop_back();
+            --m_iCurrSize;
+        }
+
+        return 0;
+    }
+
+private:
+    /// Specify the cache size (i.e., max number of items).
+    /// Private or else must be protected by a lock.
+    /// @param [in] size max cache size.
+    void setSizeLimit(int size)
+    {
+        m_iMaxSize  = size;
+        m_iHashSize = size * 3;
+        m_vHashPtr.resize(m_iHashSize);
+    }
+
+    /// Clear all entries in the cache, restore to initialization state.
+    /// Private or else must be protected by a lock.
+    void clear()
+    {
+        for (typename std::list<T*>::iterator i = m_StorageList.begin(); i != m_StorageList.end(); ++i)
+        {
+            (*i)->release();
+            delete *i;
+        }
+        m_StorageList.clear();
+        for (typename std::vector<ItemPtrList>::iterator i = m_vHashPtr.begin(); i != m_vHashPtr.end(); ++i)
+            i->clear();
+        m_iCurrSize = 0;
+    }
 
 private:
-   std::list<T*> m_StorageList;
-   typedef typename std::list<T*>::iterator ItemPtr;
-   typedef std::list<ItemPtr> ItemPtrList;
-   std::vector<ItemPtrList> m_vHashPtr;
+    std::list<T*>                            m_StorageList;
+    typedef typename std::list<T*>::iterator ItemPtr;
+    typedef std::list<ItemPtr>               ItemPtrList;
+    std::vector<ItemPtrList>                 m_vHashPtr;
 
-   int m_iMaxSize;
-   int m_iHashSize;
-   int m_iCurrSize;
+    int m_iMaxSize;
+    int m_iHashSize;
+    int m_iCurrSize;
 
-   srt::sync::Mutex m_Lock;
+    srt::sync::Mutex m_Lock;
 
 private:
-   CCache(const CCache&);
-   CCache& operator=(const CCache&);
+    CCache(const CCache&);
+    CCache& operator=(const CCache&);
 };
 
-
 class CInfoBlock
 {
 public:
-   uint32_t m_piIP[4];		// IP address, machine read only, not human readable format
-   int m_iIPversion;   		// Address family: AF_INET or AF_INET6
-   uint64_t m_ullTimeStamp;	// last update time
-   int m_iRTT;			// RTT
-   int m_iBandwidth;		// estimated bandwidth
-   int m_iLossRate;		// average loss rate
-   int m_iReorderDistance;	// packet reordering distance
-   double m_dInterval;		// inter-packet time, congestion control
-   double m_dCWnd;		// congestion window size, congestion control
+    uint32_t m_piIP[4];          // IP address, machine read only, not human readable format.
+    int      m_iIPversion;       // Address family: AF_INET or AF_INET6.
+    uint64_t m_ullTimeStamp;     // Last update time.
+    int      m_iSRTT;            // Smoothed RTT.
+    int      m_iBandwidth;       // Estimated link bandwidth.
+    int      m_iLossRate;        // Average loss rate.
+    int      m_iReorderDistance; // Packet reordering distance.
+    double   m_dInterval;        // Inter-packet time (Congestion Control).
+    double   m_dCWnd;            // Congestion window size (Congestion Control).
 
 public:
-   CInfoBlock() {} // NOTE: leaves uninitialized
-   CInfoBlock& copyFrom(const CInfoBlock& obj);
-   CInfoBlock(const CInfoBlock& src) { copyFrom(src); }
-   CInfoBlock& operator=(const CInfoBlock& src) { return copyFrom(src); }
-   bool operator==(const CInfoBlock& obj);
-   CInfoBlock* clone();
-   int getKey();
-   void release() {}
+    CInfoBlock() {} // NOTE: leaves uninitialized
+    CInfoBlock& copyFrom(const CInfoBlock& obj);
+    CInfoBlock(const CInfoBlock& src) { copyFrom(src); }
+    CInfoBlock& operator=(const CInfoBlock& src) { return copyFrom(src); }
+    bool        operator==(const CInfoBlock& obj) const;
+    CInfoBlock* clone();
+    int         getKey();
+    void        release() {}
 
 public:
+    /// convert sockaddr structure to an integer array
+    /// @param [in] addr network address
+    /// @param [in] ver IP version
+    /// @param [out] ip the result machine readable IP address in integer array
 
-      /// convert sockaddr structure to an integer array
-      /// @param [in] addr network address
-      /// @param [in] ver IP version
-      /// @param [out] ip the result machine readable IP address in integer array
-
-   static void convert(const sockaddr_any& addr, uint32_t ip[4]);
+    static void convert(const sockaddr_any& addr, uint32_t ip[4]);
 };
 
+} // namespace srt
 
 #endif
diff --git a/srtcore/channel.cpp b/srtcore/channel.cpp
index b371e11ab..0a4e1e318 100644
--- a/srtcore/channel.cpp
+++ b/srtcore/channel.cpp
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -51,9 +51,8 @@ modified by
 *****************************************************************************/
 
 #include "platform_sys.h"
-
 #include <iostream>
-#include <iomanip> // Logging 
+#include <iomanip> // Logging
 #include <srt_compat.h>
 #include <csignal>
 
@@ -65,32 +64,30 @@ modified by
 #include "utilities.h"
 
 #ifdef _WIN32
-    typedef int socklen_t;
+typedef int socklen_t;
 #endif
 
 using namespace std;
 using namespace srt_logging;
 
+namespace srt
+{
+
 #ifdef _WIN32
-    // use INVALID_SOCKET, as provided
+// use INVALID_SOCKET, as provided
 #else
-    static const int INVALID_SOCKET = -1;
+static const int INVALID_SOCKET = -1;
 #endif
 
 #if ENABLE_SOCK_CLOEXEC
 #ifndef _WIN32
 
-#if defined(_AIX) || \
-    defined(__APPLE__) || \
-    defined(__DragonFly__) || \
-    defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || \
-    defined(__linux__) || \
-    defined(__OpenBSD__) || \
-    defined(__NetBSD__)
+#if defined(_AIX) || defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) ||                           \
+    defined(__FreeBSD_kernel__) || defined(__linux__) || defined(__OpenBSD__) || defined(__NetBSD__)
 
 // Set the CLOEXEC flag using ioctl() function
-static int set_cloexec(int fd, int set) {
+static int set_cloexec(int fd, int set)
+{
     int r;
 
     do
@@ -104,7 +101,8 @@ static int set_cloexec(int fd, int set) {
 }
 #else
 // Set the CLOEXEC flag using fcntl() function
-static int set_cloexec(int fd, int set) {
+static int set_cloexec(int fd, int set)
+{
     int flags;
     int r;
 
@@ -136,22 +134,32 @@ static int set_cloexec(int fd, int set) {
 #endif // if defined(_AIX) ...
 #endif // ifndef _WIN32
 #endif // if ENABLE_CLOEXEC
+} // namespace srt
 
-CChannel::CChannel():
-m_iSocket(INVALID_SOCKET),
-m_iIpTTL(-1),   /* IPv4 TTL or IPv6 HOPs [1..255] (-1:undefined) */
-m_iIpToS(-1),   /* IPv4 Type of Service or IPv6 Traffic Class [0x00..0xff] (-1:undefined) */
-m_iSndBufSize(65536),
-m_iRcvBufSize(65536),
-m_iIpV6Only(-1)
+srt::CChannel::CChannel()
+    : m_iSocket(INVALID_SOCKET)
+#ifdef SRT_ENABLE_PKTINFO
+    , m_bBindMasked(true)
+#endif
 {
-}
+#ifdef SRT_ENABLE_PKTINFO
+   // Do the check for ancillary data buffer size, kinda assertion
+   static const size_t CMSG_MAX_SPACE = sizeof (CMSGNodeIPv4) + sizeof (CMSGNodeIPv6);
 
-CChannel::~CChannel()
-{
+   if (CMSG_MAX_SPACE < CMSG_SPACE(sizeof(in_pktinfo)) + CMSG_SPACE(sizeof(in6_pktinfo)))
+   {
+       LOGC(kmlog.Fatal, log << "Size of CMSG_MAX_SPACE="
+               << CMSG_MAX_SPACE << " too short for cmsg "
+               << CMSG_SPACE(sizeof(in_pktinfo)) << ", "
+               << CMSG_SPACE(sizeof(in6_pktinfo)) << " - PLEASE FIX");
+       throw CUDTException(MJ_SETUP, MN_NONE, 0);
+   }
+#endif
 }
 
-void CChannel::createSocket(int family)
+srt::CChannel::~CChannel() {}
+
+void srt::CChannel::createSocket(int family)
 {
 #if ENABLE_SOCK_CLOEXEC
     bool cloexec_flag = false;
@@ -160,14 +168,15 @@ void CChannel::createSocket(int family)
     m_iSocket = ::socket(family, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
     if (m_iSocket == INVALID_SOCKET)
     {
-        m_iSocket = ::socket(family, SOCK_DGRAM, IPPROTO_UDP);
+        m_iSocket    = ::socket(family, SOCK_DGRAM, IPPROTO_UDP);
         cloexec_flag = true;
     }
 #else
-    m_iSocket = ::socket(family, SOCK_DGRAM, IPPROTO_UDP);
+    m_iSocket    = ::socket(family, SOCK_DGRAM, IPPROTO_UDP);
     cloexec_flag = true;
 #endif
-#else // ENABLE_SOCK_CLOEXEC
+
+#else  // ENABLE_SOCK_CLOEXEC
     m_iSocket = ::socket(family, SOCK_DGRAM, IPPROTO_UDP);
 #endif // ENABLE_SOCK_CLOEXEC
 
@@ -175,32 +184,38 @@ void CChannel::createSocket(int family)
         throw CUDTException(MJ_SETUP, MN_NONE, NET_ERROR);
 
 #if ENABLE_SOCK_CLOEXEC
+
+    if (cloexec_flag)
+    {
 #ifdef _WIN32
-    // XXX ::SetHandleInformation(hInputWrite, HANDLE_FLAG_INHERIT, 0)
+       // XXX ::SetHandleInformation(hInputWrite, HANDLE_FLAG_INHERIT, 0)
 #else
-    if (cloexec_flag) {
-        if (0 != set_cloexec(m_iSocket, 1)) {
+        if (0 != set_cloexec(m_iSocket, 1))
+        {
             throw CUDTException(MJ_SETUP, MN_NONE, NET_ERROR);
         }
+#endif //_WIN32
     }
-#endif
 #endif // ENABLE_SOCK_CLOEXEC
 
-    if ((m_iIpV6Only != -1) && (family == AF_INET6)) // (not an error if it fails)
+    if ((m_mcfg.iIpV6Only != -1) && (family == AF_INET6)) // (not an error if it fails)
     {
-        int res ATR_UNUSED = ::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)(&m_iIpV6Only), sizeof(m_iIpV6Only));
+        const int res SRT_ATR_UNUSED =
+            ::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&m_mcfg.iIpV6Only, sizeof m_mcfg.iIpV6Only);
+#if ENABLE_LOGGING
         if (res == -1)
         {
-            int err = errno;
+            int  err = errno;
             char msg[160];
-            LOGC(kmlog.Error, log << "::setsockopt: failed to set IPPROTO_IPV6/IPV6_V6ONLY = " << m_iIpV6Only
-                    << ": " << SysStrError(err, msg, 159));
+            LOGC(kmlog.Error,
+                 log << "::setsockopt: failed to set IPPROTO_IPV6/IPV6_V6ONLY = " << m_mcfg.iIpV6Only << ": "
+                     << SysStrError(err, msg, 159));
         }
+#endif // ENABLE_LOGGING
     }
-
 }
 
-void CChannel::open(const sockaddr_any& addr)
+void srt::CChannel::open(const sockaddr_any& addr)
 {
     createSocket(addr.family());
     socklen_t namelen = addr.size();
@@ -209,23 +224,26 @@ void CChannel::open(const sockaddr_any& addr)
         throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
 
     m_BindAddr = addr;
+#ifdef SRT_ENABLE_PKTINFO
+    m_bBindMasked = m_BindAddr.isany();
+#endif
     LOGC(kmlog.Debug, log << "CHANNEL: Bound to local address: " << m_BindAddr.str());
 
     setUDPSockOpt();
 }
 
-void CChannel::open(int family)
+void srt::CChannel::open(int family)
 {
     createSocket(family);
 
-    //sendto or WSASendTo will also automatically bind the socket
-    addrinfo hints;
+    // sendto or WSASendTo will also automatically bind the socket
+    addrinfo  hints;
     addrinfo* res;
 
     memset(&hints, 0, sizeof(struct addrinfo));
 
-    hints.ai_flags = AI_PASSIVE;
-    hints.ai_family = family;
+    hints.ai_flags    = AI_PASSIVE;
+    hints.ai_family   = family;
     hints.ai_socktype = SOCK_DGRAM;
 
     const int eai = ::getaddrinfo(NULL, "0", &hints, &res);
@@ -247,7 +265,13 @@ void CChannel::open(int family)
         ::freeaddrinfo(res);
         throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
     }
-    m_BindAddr = sockaddr_any(res->ai_addr, res->ai_addrlen);
+    m_BindAddr = sockaddr_any(res->ai_addr, (sockaddr_any::len_t)res->ai_addrlen);
+
+#ifdef SRT_ENABLE_PKTINFO
+    // We know that this is intentionally bound now to "any",
+    // so the requester-destination address must be remembered and passed.
+    m_bBindMasked = true;
+#endif
 
     ::freeaddrinfo(res);
 
@@ -256,242 +280,330 @@ void CChannel::open(int family)
     setUDPSockOpt();
 }
 
-void CChannel::attach(UDPSOCKET udpsock, const sockaddr_any& udpsocks_addr)
+void srt::CChannel::attach(UDPSOCKET udpsock, const sockaddr_any& udpsocks_addr)
 {
     // The getsockname() call is done before calling it and the
     // result is placed into udpsocks_addr.
-    m_iSocket = udpsock;
+    m_iSocket  = udpsock;
     m_BindAddr = udpsocks_addr;
     setUDPSockOpt();
 }
 
-void CChannel::setUDPSockOpt()
+void srt::CChannel::setUDPSockOpt()
 {
-   #if defined(BSD) || TARGET_OS_MAC
-      // BSD system will fail setsockopt if the requested buffer size exceeds system maximum value
-      int maxsize = 64000;
-      if (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (char*)&m_iRcvBufSize, sizeof(int)))
-         ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (char*)&maxsize, sizeof(int));
-      if (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (char*)&m_iSndBufSize, sizeof(int)))
-         ::setsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (char*)&maxsize, sizeof(int));
-   #else
-      // for other systems, if requested is greated than maximum, the maximum value will be automactally used
-      if ((0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (char*)&m_iRcvBufSize, sizeof(int))) ||
-          (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (char*)&m_iSndBufSize, sizeof(int))))
-         throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-   #endif
-
-      if (-1 != m_iIpTTL)
-      {
-          if (m_BindAddr.family() == AF_INET)
-          {
-              if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (const char*)&m_iIpTTL, sizeof(m_iIpTTL)))
-                  throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-          }
-          else
-          {
-              // If IPv6 address is unspecified, set BOTH IP_TTL and IPV6_UNICAST_HOPS.
-
-              // For specified IPv6 address, set IPV6_UNICAST_HOPS ONLY UNLESS it's an IPv4-mapped-IPv6
-              if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || !IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
-              {
-                  if (0 != ::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (const char*)&m_iIpTTL, sizeof(m_iIpTTL)))
-                  {
-                      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-                  }
-              }
-              // For specified IPv6 address, set IP_TTL ONLY WHEN it's an IPv4-mapped-IPv6
-              if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
-              {
-                  if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (const char*)&m_iIpTTL, sizeof(m_iIpTTL)))
-                  {
-                      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-                  }
-              }
-          }
-      }
-
-      if (-1 != m_iIpToS)
-      {
-          if (m_BindAddr.family() == AF_INET)
-          {
-              if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (const char*)&m_iIpToS, sizeof(m_iIpToS)))
-                  throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-          }
-          else
-          {
-              // If IPv6 address is unspecified, set BOTH IP_TOS and IPV6_TCLASS.
+#if defined(SUNOS)
+    {
+        socklen_t optSize;
+        // Retrieve starting SND/RCV Buffer sizes.
+        int startRCVBUF = 0;
+        optSize         = sizeof(startRCVBUF);
+        if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (void*)&startRCVBUF, &optSize))
+        {
+            startRCVBUF = -1;
+        }
+        int startSNDBUF = 0;
+        optSize         = sizeof(startSNDBUF);
+        if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (void*)&startSNDBUF, &optSize))
+        {
+            startSNDBUF = -1;
+        }
+
+        // SunOS will fail setsockopt() if the requested buffer size exceeds system
+        //   maximum value.
+        // However, do not reduce the buffer size.
+        const int maxsize = 64000;
+        if (0 !=
+            ::setsockopt(
+                m_iSocket, SOL_SOCKET, SO_RCVBUF, (const char*)&m_mcfg.iUDPRcvBufSize, sizeof m_mcfg.iUDPRcvBufSize))
+        {
+            int currentRCVBUF = 0;
+            optSize           = sizeof(currentRCVBUF);
+            if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (void*)&currentRCVBUF, &optSize))
+            {
+                currentRCVBUF = -1;
+            }
+            if (maxsize > currentRCVBUF)
+            {
+                ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (const char*)&maxsize, sizeof maxsize);
+            }
+        }
+        if (0 !=
+            ::setsockopt(
+                m_iSocket, SOL_SOCKET, SO_SNDBUF, (const char*)&m_mcfg.iUDPSndBufSize, sizeof m_mcfg.iUDPSndBufSize))
+        {
+            int currentSNDBUF = 0;
+            optSize           = sizeof(currentSNDBUF);
+            if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (void*)&currentSNDBUF, &optSize))
+            {
+                currentSNDBUF = -1;
+            }
+            if (maxsize > currentSNDBUF)
+            {
+                ::setsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (const char*)&maxsize, sizeof maxsize);
+            }
+        }
+
+        // Retrieve ending SND/RCV Buffer sizes.
+        int endRCVBUF = 0;
+        optSize       = sizeof(endRCVBUF);
+        if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (void*)&endRCVBUF, &optSize))
+        {
+            endRCVBUF = -1;
+        }
+        int endSNDBUF = 0;
+        optSize       = sizeof(endSNDBUF);
+        if (0 != ::getsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (void*)&endSNDBUF, &optSize))
+        {
+            endSNDBUF = -1;
+        }
+        LOGC(kmlog.Debug,
+             log << "SO_RCVBUF:"
+                 << " startRCVBUF=" << startRCVBUF << " m_mcfg.iUDPRcvBufSize=" << m_mcfg.iUDPRcvBufSize
+                 << " endRCVBUF=" << endRCVBUF);
+        LOGC(kmlog.Debug,
+             log << "SO_SNDBUF:"
+                 << " startSNDBUF=" << startSNDBUF << " m_mcfg.iUDPSndBufSize=" << m_mcfg.iUDPSndBufSize
+                 << " endSNDBUF=" << endSNDBUF);
+    }
+#elif defined(BSD) || TARGET_OS_MAC
+    // BSD system will fail setsockopt if the requested buffer size exceeds system maximum value
+    int maxsize = 64000;
+    if (0 != ::setsockopt(
+                 m_iSocket, SOL_SOCKET, SO_RCVBUF, (const char*)&m_mcfg.iUDPRcvBufSize, sizeof m_mcfg.iUDPRcvBufSize))
+        ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (const char*)&maxsize, sizeof maxsize);
+    if (0 != ::setsockopt(
+                 m_iSocket, SOL_SOCKET, SO_SNDBUF, (const char*)&m_mcfg.iUDPSndBufSize, sizeof m_mcfg.iUDPSndBufSize))
+        ::setsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (const char*)&maxsize, sizeof maxsize);
+#else
+    // for other systems, if requested is greated than maximum, the maximum value will be automactally used
+    if ((0 !=
+         ::setsockopt(
+             m_iSocket, SOL_SOCKET, SO_RCVBUF, (const char*)&m_mcfg.iUDPRcvBufSize, sizeof m_mcfg.iUDPRcvBufSize)) ||
+        (0 != ::setsockopt(
+                  m_iSocket, SOL_SOCKET, SO_SNDBUF, (const char*)&m_mcfg.iUDPSndBufSize, sizeof m_mcfg.iUDPSndBufSize)))
+        throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+#endif
+
+    if (m_mcfg.iIpTTL != -1)
+    {
+        if (m_BindAddr.family() == AF_INET)
+        {
+            if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (const char*)&m_mcfg.iIpTTL, sizeof m_mcfg.iIpTTL))
+                throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+        }
+        else
+        {
+            // If IPv6 address is unspecified, set BOTH IP_TTL and IPV6_UNICAST_HOPS.
+
+            // For specified IPv6 address, set IPV6_UNICAST_HOPS ONLY UNLESS it's an IPv4-mapped-IPv6
+            if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) ||
+                !IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
+            {
+                if (0 !=
+                    ::setsockopt(
+                        m_iSocket, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (const char*)&m_mcfg.iIpTTL, sizeof m_mcfg.iIpTTL))
+                {
+                    throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+                }
+            }
+            // For specified IPv6 address, set IP_TTL ONLY WHEN it's an IPv4-mapped-IPv6
+            if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
+            {
+                if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (const char*)&m_mcfg.iIpTTL, sizeof m_mcfg.iIpTTL))
+                {
+                    throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+                }
+            }
+        }
+    }
+
+    if (m_mcfg.iIpToS != -1)
+    {
+        if (m_BindAddr.family() == AF_INET)
+        {
+            if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (const char*)&m_mcfg.iIpToS, sizeof m_mcfg.iIpToS))
+                throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+        }
+        else
+        {
+            // If IPv6 address is unspecified, set BOTH IP_TOS and IPV6_TCLASS.
 
 #ifdef IPV6_TCLASS
-              // For specified IPv6 address, set IPV6_TCLASS ONLY UNLESS it's an IPv4-mapped-IPv6
-              if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || !IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
-              {
-                  if (0 != ::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_TCLASS, (const char*)&m_iIpToS, sizeof(m_iIpToS)))
-                  {
-                      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-                  }
-              }
+            // For specified IPv6 address, set IPV6_TCLASS ONLY UNLESS it's an IPv4-mapped-IPv6
+            if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) ||
+                !IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
+            {
+                if (0 != ::setsockopt(
+                             m_iSocket, IPPROTO_IPV6, IPV6_TCLASS, (const char*)&m_mcfg.iIpToS, sizeof m_mcfg.iIpToS))
+                {
+                    throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+                }
+            }
 #endif
 
-              // For specified IPv6 address, set IP_TOS ONLY WHEN it's an IPv4-mapped-IPv6
-              if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
-              {
-                  if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (const char*)&m_iIpToS, sizeof(m_iIpToS)))
-                  {
-                      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-                  }
-              }
-          }
-      }
+            // For specified IPv6 address, set IP_TOS ONLY WHEN it's an IPv4-mapped-IPv6
+            if (IN6_IS_ADDR_UNSPECIFIED(&m_BindAddr.sin6.sin6_addr) || IN6_IS_ADDR_V4MAPPED(&m_BindAddr.sin6.sin6_addr))
+            {
+                if (0 != ::setsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (const char*)&m_mcfg.iIpToS, sizeof m_mcfg.iIpToS))
+                {
+                    throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+                }
+            }
+        }
+    }
 
 #ifdef SRT_ENABLE_BINDTODEVICE
-      if (!m_BindToDevice.empty())
-      {
-          if (m_BindAddr.family() != AF_INET)
-          {
-              LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE can only be set with AF_INET connections");
-              throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-          }
-
-          if (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_BINDTODEVICE, m_BindToDevice.c_str(), m_BindToDevice.size()))
-          {
-              char buf[255];
-              const char* err = SysStrError(NET_ERROR, buf, 255);
-              LOGC(kmlog.Error, log << "setsockopt(SRTO_BINDTODEVICE): " << err);
-              throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
-          }
-      }
+    if (!m_mcfg.sBindToDevice.empty())
+    {
+        if (m_BindAddr.family() != AF_INET)
+        {
+            LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE can only be set with AF_INET connections");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        if (0 != ::setsockopt(
+                     m_iSocket, SOL_SOCKET, SO_BINDTODEVICE, m_mcfg.sBindToDevice.c_str(), m_mcfg.sBindToDevice.size()))
+        {
+#if ENABLE_LOGGING
+            char        buf[255];
+            const char* err = SysStrError(NET_ERROR, buf, 255);
+            LOGC(kmlog.Error, log << "setsockopt(SRTO_BINDTODEVICE): " << err);
+#endif // ENABLE_LOGGING
+            throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+        }
+    }
 #endif
 
 #ifdef UNIX
-   // Set non-blocking I/O
-   // UNIX does not support SO_RCVTIMEO
-   int opts = ::fcntl(m_iSocket, F_GETFL);
-   if (-1 == ::fcntl(m_iSocket, F_SETFL, opts | O_NONBLOCK))
-      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+    // Set non-blocking I/O
+    // UNIX does not support SO_RCVTIMEO
+    int opts = ::fcntl(m_iSocket, F_GETFL);
+    if (-1 == ::fcntl(m_iSocket, F_SETFL, opts | O_NONBLOCK))
+        throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
 #elif defined(_WIN32)
-   u_long nonBlocking = 1;
-   if (0 != ioctlsocket (m_iSocket, FIONBIO, &nonBlocking))
-      throw CUDTException (MJ_SETUP, MN_NORES, NET_ERROR);
+    u_long nonBlocking = 1;
+    if (0 != ioctlsocket(m_iSocket, FIONBIO, &nonBlocking))
+        throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
 #else
-   timeval tv;
-   tv.tv_sec = 0;
-#if defined (BSD) || TARGET_OS_MAC
-   // Known BSD bug as the day I wrote this code.
-   // A small time out value will cause the socket to block forever.
-   tv.tv_usec = 10000;
+    timeval tv;
+    tv.tv_sec = 0;
+#if defined(BSD) || TARGET_OS_MAC
+    // Known BSD bug as the day I wrote this code.
+    // A small time out value will cause the socket to block forever.
+    tv.tv_usec = 10000;
 #else
-   tv.tv_usec = 100;
+    tv.tv_usec = 100;
 #endif
-   // Set receiving time-out value
-   if (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(timeval)))
-      throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
+    // Set receiving time-out value
+    if (0 != ::setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(timeval)))
+        throw CUDTException(MJ_SETUP, MN_NORES, NET_ERROR);
 #endif
-}
 
-void CChannel::close() const
-{
-   #ifndef _WIN32
-      ::close(m_iSocket);
-   #else
-      ::closesocket(m_iSocket);
-   #endif
+#ifdef SRT_ENABLE_PKTINFO
+    if (m_bBindMasked)
+    {
+        HLOGP(kmlog.Debug, "Socket bound to ANY - setting PKTINFO for address retrieval");
+        const int on = 1, off SRT_ATR_UNUSED = 0;
+
+        if (m_BindAddr.family() == AF_INET || m_mcfg.iIpV6Only == 0)
+        {
+            ::setsockopt(m_iSocket, IPPROTO_IP, IP_PKTINFO, (char*)&on, sizeof(on));
+        }
+
+        if (m_BindAddr.family() == AF_INET6)
+        {
+            ::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));
+        }
+
+        // XXX Unknown why this has to be off. RETEST.
+        //::setsockopt(m_iSocket, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
+    }
+#endif
 }
 
-int CChannel::getSndBufSize()
+void srt::CChannel::close() const
 {
-   socklen_t size = sizeof(socklen_t);
-   ::getsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (char *)&m_iSndBufSize, &size);
-   return m_iSndBufSize;
+#ifndef _WIN32
+    ::close(m_iSocket);
+#else
+    ::closesocket(m_iSocket);
+#endif
 }
 
-int CChannel::getRcvBufSize()
+int srt::CChannel::getSndBufSize()
 {
-   socklen_t size = sizeof(socklen_t);
-   ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (char *)&m_iRcvBufSize, &size);
-   return m_iRcvBufSize;
+    socklen_t size = (socklen_t)sizeof m_mcfg.iUDPSndBufSize;
+    ::getsockopt(m_iSocket, SOL_SOCKET, SO_SNDBUF, (char*)&m_mcfg.iUDPSndBufSize, &size);
+    return m_mcfg.iUDPSndBufSize;
 }
 
-void CChannel::setSndBufSize(int size)
+int srt::CChannel::getRcvBufSize()
 {
-   m_iSndBufSize = size;
+    socklen_t size = (socklen_t)sizeof m_mcfg.iUDPRcvBufSize;
+    ::getsockopt(m_iSocket, SOL_SOCKET, SO_RCVBUF, (char*)&m_mcfg.iUDPRcvBufSize, &size);
+    return m_mcfg.iUDPRcvBufSize;
 }
 
-void CChannel::setRcvBufSize(int size)
+void srt::CChannel::setConfig(const CSrtMuxerConfig& config)
 {
-   m_iRcvBufSize = size;
+    m_mcfg = config;
 }
 
-void CChannel::setIpV6Only(int ipV6Only) 
+void srt::CChannel::getSocketOption(int level, int option, char* pw_dataptr, socklen_t& w_len, int& w_status)
 {
-   m_iIpV6Only = ipV6Only;
+    w_status = ::getsockopt(m_iSocket, level, option, (pw_dataptr), (&w_len));
 }
 
-int CChannel::getIpTTL() const
+int srt::CChannel::getIpTTL() const
 {
-   if (m_iSocket == INVALID_SOCKET)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    if (m_iSocket == INVALID_SOCKET)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   socklen_t size = sizeof(m_iIpTTL);
-   if (m_BindAddr.family() == AF_INET)
-   {
-      ::getsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (char *)&m_iIpTTL, &size);
-   }
-   else if (m_BindAddr.family() == AF_INET6)
-   {
-      ::getsockopt(m_iSocket, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *)&m_iIpTTL, &size);
-   }
-   else
-   {
-       // If family is unspecified, the socket probably doesn't exist.
-       LOGC(kmlog.Error, log << "IPE: CChannel::getIpTTL called with unset family");
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-   }
-   return m_iIpTTL;
+    socklen_t size = (socklen_t)sizeof m_mcfg.iIpTTL;
+    if (m_BindAddr.family() == AF_INET)
+    {
+        ::getsockopt(m_iSocket, IPPROTO_IP, IP_TTL, (char*)&m_mcfg.iIpTTL, &size);
+    }
+    else if (m_BindAddr.family() == AF_INET6)
+    {
+        ::getsockopt(m_iSocket, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char*)&m_mcfg.iIpTTL, &size);
+    }
+    else
+    {
+        // If family is unspecified, the socket probably doesn't exist.
+        LOGC(kmlog.Error, log << "IPE: CChannel::getIpTTL called with unset family");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+    return m_mcfg.iIpTTL;
 }
 
-int CChannel::getIpToS() const
+int srt::CChannel::getIpToS() const
 {
-   if (m_iSocket == INVALID_SOCKET)
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    if (m_iSocket == INVALID_SOCKET)
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-   socklen_t size = sizeof(m_iIpToS);
-   if (m_BindAddr.family() == AF_INET)
-   {
-      ::getsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (char *)&m_iIpToS, &size);
-   }
-   else if (m_BindAddr.family() == AF_INET6)
-   {
+    socklen_t size = (socklen_t)sizeof m_mcfg.iIpToS;
+    if (m_BindAddr.family() == AF_INET)
+    {
+        ::getsockopt(m_iSocket, IPPROTO_IP, IP_TOS, (char*)&m_mcfg.iIpToS, &size);
+    }
+    else if (m_BindAddr.family() == AF_INET6)
+    {
 #ifdef IPV6_TCLASS
-      ::getsockopt(m_iSocket, IPPROTO_IPV6, IPV6_TCLASS, (char *)&m_iIpToS, &size);
+        ::getsockopt(m_iSocket, IPPROTO_IPV6, IPV6_TCLASS, (char*)&m_mcfg.iIpToS, &size);
 #endif
-   }
-   else
-   {
-       // If family is unspecified, the socket probably doesn't exist.
-       LOGC(kmlog.Error, log << "IPE: CChannel::getIpToS called with unset family");
-       throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-   }
-   return m_iIpToS;
-}
-
-void CChannel::setIpTTL(int ttl)
-{
-   m_iIpTTL = ttl;
-}
-
-void CChannel::setIpToS(int tos)
-{
-   m_iIpToS = tos;
+    }
+    else
+    {
+        // If family is unspecified, the socket probably doesn't exist.
+        LOGC(kmlog.Error, log << "IPE: CChannel::getIpToS called with unset family");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+    return m_mcfg.iIpToS;
 }
 
 #ifdef SRT_ENABLE_BINDTODEVICE
-void CChannel::setBind(const string& name)
-{
-    m_BindToDevice = name;
-}
-
-bool CChannel::getBind(char* dst, size_t len)
+bool srt::CChannel::getBind(char* dst, size_t len)
 {
     if (m_iSocket == INVALID_SOCKET)
         return false; // No socket to get data from
@@ -499,7 +611,7 @@ bool CChannel::getBind(char* dst, size_t len)
     // Try to obtain it directly from the function. If not possible,
     // then return from internal data.
     socklen_t length = len;
-    int res = ::getsockopt(m_iSocket, SOL_SOCKET, SO_BINDTODEVICE, dst, &length);
+    int       res    = ::getsockopt(m_iSocket, SOL_SOCKET, SO_BINDTODEVICE, dst, &length);
     if (res == -1)
         return false; // Happens on Linux v < 3.8
 
@@ -509,55 +621,60 @@ bool CChannel::getBind(char* dst, size_t len)
 }
 #endif
 
-int CChannel::ioctlQuery(int type SRT_ATR_UNUSED) const
+int srt::CChannel::ioctlQuery(int type SRT_ATR_UNUSED) const
 {
 #if defined(unix) || defined(__APPLE__)
     int value = 0;
-    int res = ::ioctl(m_iSocket, type, &value);
-    if ( res != -1 )
+    int res   = ::ioctl(m_iSocket, type, &value);
+    if (res != -1)
         return value;
 #endif
     return -1;
 }
 
-int CChannel::sockoptQuery(int level SRT_ATR_UNUSED, int option SRT_ATR_UNUSED) const
+int srt::CChannel::sockoptQuery(int level SRT_ATR_UNUSED, int option SRT_ATR_UNUSED) const
 {
 #if defined(unix) || defined(__APPLE__)
-    int value = 0;
-    socklen_t len = sizeof (int);
-    int res = ::getsockopt(m_iSocket, level, option, &value, &len);
-    if ( res != -1 )
+    int       value = 0;
+    socklen_t len   = sizeof(int);
+    int       res   = ::getsockopt(m_iSocket, level, option, &value, &len);
+    if (res != -1)
         return value;
 #endif
     return -1;
 }
 
-void CChannel::getSockAddr(sockaddr_any& w_addr) const
+void srt::CChannel::getSockAddr(sockaddr_any& w_addr) const
 {
     // The getsockname function requires only to have enough target
     // space to copy the socket name, it doesn't have to be correlated
     // with the address family. So the maximum space for any name,
     // regardless of the family, does the job.
-    socklen_t namelen = w_addr.storage_size();
+    socklen_t namelen = (socklen_t)w_addr.storage_size();
     ::getsockname(m_iSocket, (w_addr.get()), (&namelen));
     w_addr.len = namelen;
 }
 
-void CChannel::getPeerAddr(sockaddr_any& w_addr) const
+void srt::CChannel::getPeerAddr(sockaddr_any& w_addr) const
 {
-    socklen_t namelen = w_addr.storage_size();
+    socklen_t namelen = (socklen_t)w_addr.storage_size();
     ::getpeername(m_iSocket, (w_addr.get()), (&namelen));
     w_addr.len = namelen;
 }
 
-
-int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const
+int srt::CChannel::sendto(const sockaddr_any& addr, CPacket& packet, const sockaddr_any& source_addr SRT_ATR_UNUSED) const
 {
-    HLOGC(kslog.Debug, log << "CChannel::sendto: SENDING NOW DST=" << addr.str()
-        << " target=@" << packet.m_iID
-        << " size=" << packet.getLength()
-        << " pkt.ts=" << packet.m_iTimeStamp
-        << " " << packet.Info());
+#if ENABLE_HEAVY_LOGGING
+    ostringstream dsrc;
+#ifdef SRT_ENABLE_PKTINFO
+    dsrc << " sourceIP=" << (m_bBindMasked && !source_addr.isany() ? source_addr.str() : "default");
+#endif
+
+    LOGC(kslog.Debug,
+         log << "CChannel::sendto: SENDING NOW DST=" << addr.str() << " target=@" << packet.id()
+             << " size=" << packet.getLength() << " pkt.ts=" << packet.timestamp()
+             << dsrc.str() << " " << packet.Info());
+#endif
 
 #ifdef SRT_TEST_FAKE_LOSS
 
@@ -567,18 +684,18 @@ int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const
 #undef FAKELOSS_STRING
 #undef FAKELOSS_WRAP
 
-    static int dcounter = 0;
+    static int dcounter   = 0;
     static int flwcounter = 0;
 
     struct FakelossConfig
     {
-        pair<int,int> config;
+        pair<int, int> config;
         FakelossConfig(const char* f)
         {
             vector<string> out;
             Split(f, '+', back_inserter(out));
 
-            config.first = atoi(out[0].c_str());
+            config.first  = atoi(out[0].c_str());
             config.second = out.size() > 1 ? atoi(out[1].c_str()) : 8;
         }
     };
@@ -586,31 +703,29 @@ int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const
 
     if (!packet.isControl())
     {
-        if (dcounter == 0)
-        {
-            timeval tv;
-            gettimeofday(&tv, 0);
-            srand(tv.tv_usec & 0xFFFF);
-        }
         ++dcounter;
 
         if (flwcounter)
         {
             // This is a counter of how many packets in a row shall be lost
             --flwcounter;
-            HLOGC(kslog.Debug, log << "CChannel: TEST: FAKE LOSS OF %" << packet.getSeqNo() << " (" << flwcounter << " more to drop)");
+            HLOGC(kslog.Debug,
+                  log << "CChannel: TEST: FAKE LOSS OF %" << packet.getSeqNo() << " (" << flwcounter
+                      << " more to drop)");
             return packet.getLength(); // fake successful sendinf
         }
 
         if (dcounter > 8)
         {
             // Make a random number in the range between 8 and 24
-            int rnd = rand() % 16 + SRT_TEST_FAKE_LOSS;
+            const int rnd = srt::sync::genRandomInt(8, 24);
 
             if (dcounter > rnd)
             {
                 dcounter = 1;
-                HLOGC(kslog.Debug, log << "CChannel: TEST: FAKE LOSS OF %" << packet.getSeqNo() << " (will drop " << fakeloss.config.first << " more)");
+                HLOGC(kslog.Debug,
+                      log << "CChannel: TEST: FAKE LOSS OF %" << packet.getSeqNo() << " (will drop "
+                          << fakeloss.config.first << " more)");
                 flwcounter = fakeloss.config.first;
                 return packet.getLength(); // fake successful sendinf
             }
@@ -619,69 +734,165 @@ int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const
 
 #endif
 
-   // convert control information into network order
-   packet.toNL();
-
-   #ifndef _WIN32
-      msghdr mh;
-      mh.msg_name = (sockaddr*)&addr;
-      mh.msg_namelen = addr.size();
-      mh.msg_iov = (iovec*)packet.m_PacketVector;
-      mh.msg_iovlen = 2;
-      mh.msg_control = NULL;
-      mh.msg_controllen = 0;
-      mh.msg_flags = 0;
-
-      const int res = ::sendmsg(m_iSocket, &mh, 0);
-   #else
-      DWORD size = (DWORD) (CPacket::HDR_SIZE + packet.getLength());
-      int addrsize = addr.size();
-      int res = ::WSASendTo(m_iSocket, (LPWSABUF)packet.m_PacketVector, 2, &size, 0, addr.get(), addrsize, NULL, NULL);
-      res = (0 == res) ? size : -1;
-   #endif
-
-   packet.toHL();
-
-   return res;
+    // convert control information into network order
+    packet.toNetworkByteOrder();
+
+#ifndef _WIN32
+    msghdr mh;
+    mh.msg_name       = (sockaddr*)&addr;
+    mh.msg_namelen    = addr.size();
+    mh.msg_iov        = (iovec*)packet.m_PacketVector;
+    mh.msg_iovlen     = 2;
+    bool have_set_src = false;
+
+#ifdef SRT_ENABLE_PKTINFO
+
+    // Note that even if PKTINFO is desired, the first caller's packet will be sent
+    // without ancillary info anyway because there's no "peer" yet to know where to send it.
+    char mh_crtl_buf[sizeof(CMSGNodeIPv4) + sizeof(CMSGNodeIPv6)];
+    if (m_bBindMasked && source_addr.family() != AF_UNSPEC && !source_addr.isany())
+    {
+        if (!setSourceAddress(mh, mh_crtl_buf, source_addr))
+        {
+            LOGC(kslog.Error, log << "CChannel::setSourceAddress: source address invalid family #" << source_addr.family() << ", NOT setting.");
+        }
+        else
+        {
+            HLOGC(kslog.Debug, log << "CChannel::setSourceAddress: setting as " << source_addr.str());
+            have_set_src = true;
+        }
+    }
+
+#endif
+
+    if (!have_set_src)
+    {
+        mh.msg_control    = NULL;
+        mh.msg_controllen = 0;
+    }
+    mh.msg_flags      = 0;
+
+    const int res = (int)::sendmsg(m_iSocket, &mh, 0);
+#else
+    class WSAEventRef
+    {
+    public:
+        WSAEventRef()
+            : e(::WSACreateEvent())
+        {
+        }
+        ~WSAEventRef()
+        {
+            ::WSACloseEvent(e);
+            e = NULL;
+        }
+        void reset()
+        {
+            ::WSAResetEvent(e);
+        }
+        WSAEVENT Handle()
+        {
+            return e;
+        }
+
+    private:
+        WSAEVENT e;
+    };
+#if !defined(__MINGW32__) && defined(ENABLE_CXX11)
+    thread_local WSAEventRef lEvent;
+#else
+    WSAEventRef lEvent;
+#endif
+    WSAOVERLAPPED overlapped;
+    ::SecureZeroMemory(&overlapped, sizeof(overlapped));
+    overlapped.hEvent = lEvent.Handle();
+
+    DWORD size = (DWORD)(packet.m_PacketVector[0].size() + packet.m_PacketVector[1].size());
+    int   addrsize = addr.size();
+    int   res = ::WSASendTo(m_iSocket, (LPWSABUF)packet.m_PacketVector, 2, &size, 0, addr.get(), addrsize, &overlapped, NULL);
+
+    if (res == SOCKET_ERROR)
+    {
+        if (NET_ERROR == WSA_IO_PENDING)
+        {
+            DWORD dwFlags = 0;
+            const bool bCompleted = WSAGetOverlappedResult(m_iSocket, &overlapped, &size, TRUE, &dwFlags);
+            if (bCompleted)
+                res = 0;
+            else
+                LOGC(kslog.Warn, log << "CChannel::sendto call on ::WSAGetOverlappedResult failed with error: " << NET_ERROR);
+            lEvent.reset();
+        }
+        else
+        {
+            LOGC(kmlog.Error, log << CONID() << "WSASendTo failed with error: " << NET_ERROR);
+        }
+    }
+
+    res = (0 == res) ? size : -1;
+#endif
+
+    packet.toHostByteOrder();
+
+    return res;
 }
 
-EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
+srt::EReadStatus srt::CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
 {
-    EReadStatus status = RST_OK;
-    int msg_flags = 0;
-    int recv_size = -1;
+    EReadStatus status    = RST_OK;
+    int         msg_flags = 0;
+    int         recv_size = -1;
 
 #if defined(UNIX) || defined(_WIN32)
-    fd_set set;
+    fd_set  set;
     timeval tv;
     FD_ZERO(&set);
     FD_SET(m_iSocket, &set);
-    tv.tv_sec  = 0;
-    tv.tv_usec = 10000;
-    const int select_ret = ::select((int) m_iSocket + 1, &set, NULL, &set, &tv);
+    tv.tv_sec            = 0;
+    tv.tv_usec           = 10000;
+    const int select_ret = ::select((int)m_iSocket + 1, &set, NULL, &set, &tv);
 #else
-    const int select_ret = 1;   // the socket is expected to be in the blocking mode itself
+    const int select_ret = 1; // the socket is expected to be in the blocking mode itself
 #endif
 
-    if (select_ret == 0)   // timeout
+    if (select_ret == 0) // timeout
     {
         w_packet.setLength(-1);
         return RST_AGAIN;
     }
 
 #ifndef _WIN32
+    msghdr mh; // will not be used on failure
+
     if (select_ret > 0)
     {
-        msghdr mh;
-        mh.msg_name = (w_addr.get());
-        mh.msg_namelen = w_addr.size();
-        mh.msg_iov = (w_packet.m_PacketVector);
-        mh.msg_iovlen = 2;
-        mh.msg_control = NULL;
+        mh.msg_name       = (w_addr.get());
+        mh.msg_namelen    = w_addr.size();
+        mh.msg_iov        = (w_packet.m_PacketVector);
+        mh.msg_iovlen     = 2;
+
+        // Default
+        mh.msg_control    = NULL;
         mh.msg_controllen = 0;
-        mh.msg_flags = 0;
 
-        recv_size = ::recvmsg(m_iSocket, (&mh), 0);
+#ifdef SRT_ENABLE_PKTINFO
+        // Without m_bBindMasked, we don't need ancillary data - the source
+        // address will always be the bound address.
+        char mh_crtl_buf[sizeof(CMSGNodeIPv4) + sizeof(CMSGNodeIPv6)];
+        if (m_bBindMasked)
+        {
+            // Extract the destination IP address from the ancillary
+            // data. This might be interesting for the connection to
+            // know to which address the packet should be sent back during
+            // the handshake and then addressed when sending during connection.
+            mh.msg_control = (mh_crtl_buf);
+            mh.msg_controllen = sizeof mh_crtl_buf;
+        }
+#endif
+
+        mh.msg_flags      = 0;
+
+        recv_size = (int)::recvmsg(m_iSocket, (&mh), 0);
         msg_flags = mh.msg_flags;
     }
 
@@ -710,7 +921,8 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
     if (select_ret == -1 || recv_size == -1)
     {
         const int err = NET_ERROR;
-        if (err == EAGAIN || err == EINTR || err == ECONNREFUSED) // For EAGAIN, this isn't an error, just a useless call.
+        if (err == EAGAIN || err == EINTR ||
+            err == ECONNREFUSED) // For EAGAIN, this isn't an error, just a useless call.
         {
             status = RST_AGAIN;
         }
@@ -723,6 +935,17 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
         goto Return_error;
     }
 
+#ifdef SRT_ENABLE_PKTINFO
+    if (m_bBindMasked)
+    {
+        // Extract the address. Set it explicitly; if this returns address that isany(),
+        // it will simply set this on the packet so that it behaves as if nothing was
+        // extracted (it will "fail the old way").
+        w_packet.m_DestAddr = getTargetAddress(mh);
+        HLOGC(krlog.Debug, log << CONID() << "(sys)recvmsg: ANY BOUND, retrieved DEST ADDR: " << w_packet.m_DestAddr.str());
+    }
+#endif
+
 #else
     // XXX REFACTORING NEEDED!
     // This procedure uses the WSARecvFrom function that just reads
@@ -740,16 +963,23 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
     // value one Windows than 0, unless this procedure below is rewritten
     // to use WSARecvMsg().
 
-    int recv_ret = SOCKET_ERROR;
-    DWORD flag = 0;
+    int   recv_ret = SOCKET_ERROR;
+    DWORD flag     = 0;
 
-    if (select_ret > 0)     // the total number of socket handles that are ready
+    if (select_ret > 0) // the total number of socket handles that are ready
     {
-        DWORD size = (DWORD) (CPacket::HDR_SIZE + w_packet.getLength());
-        int addrsize = w_addr.size();
-
-        recv_ret = ::WSARecvFrom(m_iSocket, ((LPWSABUF)w_packet.m_PacketVector), 2,
-                (&size), (&flag), (w_addr.get()), (&addrsize), NULL, NULL);
+        DWORD size     = (DWORD)(CPacket::HDR_SIZE + w_packet.getLength());
+        int   addrsize = w_addr.size();
+
+        recv_ret = ::WSARecvFrom(m_iSocket,
+                                 ((LPWSABUF)w_packet.m_PacketVector),
+                                 2,
+                                 (&size),
+                                 (&flag),
+                                 (w_addr.get()),
+                                 (&addrsize),
+                                 NULL,
+                                 NULL);
         if (recv_ret == 0)
             recv_size = size;
     }
@@ -764,16 +994,9 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
         // WSAETIMEDOUT, which isn't mentioned in the documentation of WSARecvFrom at all.
         //
         // These below errors are treated as "fatal", all others are treated as "again".
-        static const int fatals [] =
-        {
-            WSAEFAULT,
-            WSAEINVAL,
-            WSAENETDOWN,
-            WSANOTINITIALISED,
-            WSA_OPERATION_ABORTED
-        };
+        static const int  fatals[]   = {WSAEFAULT, WSAEINVAL, WSAENETDOWN, WSANOTINITIALISED, WSA_OPERATION_ABORTED};
         static const int* fatals_end = fatals + Size(fatals);
-        const int err = NET_ERROR;
+        const int         err        = NET_ERROR;
         if (std::find(fatals, fatals_end, err) != fatals_end)
         {
             HLOGC(krlog.Debug, log << CONID() << "(sys)WSARecvFrom: " << SysStrError(err) << " [" << err << "]");
@@ -792,12 +1015,12 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
         msg_flags = 1;
 #endif
 
-
     // Sanity check for a case when it didn't fill in even the header
     if (size_t(recv_size) < CPacket::HDR_SIZE)
     {
         status = RST_AGAIN;
-        HLOGC(krlog.Debug, log << CONID() << "POSSIBLE ATTACK: received too short packet with " << recv_size << " bytes");
+        HLOGC(krlog.Debug,
+              log << CONID() << "POSSIBLE ATTACK: received too short packet with " << recv_size << " bytes");
         goto Return_error;
     }
 
@@ -818,35 +1041,48 @@ EReadStatus CChannel::recvfrom(sockaddr_any& w_addr, CPacket& w_packet) const
     // When this happens, then you have at best a fragment of the buffer and it's
     // useless anyway. This is solved by dropping the packet and fake that no
     // packet was received, so the packet will be then retransmitted.
-    if ( msg_flags != 0 )
+    if (msg_flags != 0)
     {
-        HLOGC(krlog.Debug, log << CONID() << "NET ERROR: packet size=" << recv_size
-            << " msg_flags=0x" << hex << msg_flags << ", possibly MSG_TRUNC (0x" << hex << int(MSG_TRUNC) << ")");
-        status = RST_AGAIN;
-        goto Return_error;
-    }
+#if ENABLE_HEAVY_LOGGING
 
-    w_packet.setLength(recv_size - CPacket::HDR_SIZE);
+        std::ostringstream flg;
 
-    // convert back into local host order
-    // XXX use NtoHLA().
-    //for (int i = 0; i < 4; ++ i)
-    //   w_packet.m_nHeader[i] = ntohl(w_packet.m_nHeader[i]);
-    {
-        uint32_t* p = w_packet.m_nHeader;
-        for (size_t i = 0; i < SRT_PH_E_SIZE; ++ i)
+#if !defined(_WIN32)
+
+        static const pair<int, const char* const> errmsgflg [] = {
+            make_pair<int>(MSG_OOB, "OOB"),
+            make_pair<int>(MSG_EOR, "EOR"),
+            make_pair<int>(MSG_TRUNC, "TRUNC"),
+            make_pair<int>(MSG_CTRUNC, "CTRUNC")
+        };
+
+        for (size_t i = 0; i < Size(errmsgflg); ++i)
+            if ((msg_flags & errmsgflg[i].first) != 0)
+                flg << " " << errmsgflg[i].second;
+
+        if (msg_flags & MSG_TRUNC)
         {
-            *p = ntohl(*p);
-            ++ p;
+            // Additionally show buffer information in this case
+            flg << " buffers: ";
+            for (size_t i = 0; i < CPacket::PV_SIZE; ++i)
+            {
+                flg << "[" << w_packet.m_PacketVector[i].iov_len << "] ";
+            }
         }
-    }
+        // This doesn't work the same way on Windows, so on Windows just skip it.
+#endif
 
-    if (w_packet.isControl())
-    {
-        for (size_t j = 0, n = w_packet.getLength() / sizeof (uint32_t); j < n; ++ j)
-            *((uint32_t *)w_packet.m_pcData + j) = ntohl(*((uint32_t *)w_packet.m_pcData + j));
+        HLOGC(krlog.Debug,
+              log << CONID() << "NET ERROR: packet size=" << recv_size << " msg_flags=0x" << hex << msg_flags
+                  << ", detected flags:" << flg.str());
+#endif
+        status = RST_AGAIN;
+        goto Return_error;
     }
 
+    w_packet.setLength(recv_size - CPacket::HDR_SIZE);
+    w_packet.toHostByteOrder();
+
     return RST_OK;
 
 Return_error:
diff --git a/srtcore/channel.h b/srtcore/channel.h
index 52508e47f..e12310001 100644
--- a/srtcore/channel.h
+++ b/srtcore/channel.h
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -49,143 +49,244 @@ written by
 modified by
    Haivision Systems Inc.
 *****************************************************************************/
-
 #ifndef INC_SRT_CHANNEL_H
 #define INC_SRT_CHANNEL_H
 
 #include "platform_sys.h"
 #include "udt.h"
 #include "packet.h"
+#include "socketconfig.h"
 #include "netinet_any.h"
 
-class CChannel
+namespace srt
 {
-   void createSocket(int family);
-public:
-
-   // XXX There's currently no way to access the socket ID set for
-   // whatever the channel is currently working for. Required to find
-   // some way to do this, possibly by having a "reverse pointer".
-   // Currently just "unimplemented".
-   std::string CONID() const { return ""; }
-
-   CChannel();
-   ~CChannel();
-
-      /// Open a UDP channel.
-      /// @param [in] addr The local address that UDP will use.
-
-   void open(const sockaddr_any& addr);
 
-   void open(int family);
-
-      /// Open a UDP channel based on an existing UDP socket.
-      /// @param [in] udpsock UDP socket descriptor.
+class CChannel
+{
+    void createSocket(int family);
 
-   void attach(UDPSOCKET udpsock, const sockaddr_any& adr);
+public:
+    // XXX There's currently no way to access the socket ID set for
+    // whatever the channel is currently working for. Required to find
+    // some way to do this, possibly by having a "reverse pointer".
+    // Currently just "unimplemented".
+    std::string CONID() const { return ""; }
 
-      /// Disconnect and close the UDP entity.
+    CChannel();
+    ~CChannel();
 
-   void close() const;
+    /// Open a UDP channel.
+    /// @param [in] addr The local address that UDP will use.
 
-      /// Get the UDP sending buffer size.
-      /// @return Current UDP sending buffer size.
+    void open(const sockaddr_any& addr);
 
-   int getSndBufSize();
+    void open(int family);
 
-      /// Get the UDP receiving buffer size.
-      /// @return Current UDP receiving buffer size.
+    /// Open a UDP channel based on an existing UDP socket.
+    /// @param [in] udpsock UDP socket descriptor.
 
-   int getRcvBufSize();
+    void attach(UDPSOCKET udpsock, const sockaddr_any& adr);
 
-      /// Set the UDP sending buffer size.
-      /// @param [in] size expected UDP sending buffer size.
+    /// Disconnect and close the UDP entity.
 
-   void setSndBufSize(int size);
+    void close() const;
 
-      /// Set the UDP receiving buffer size.
-      /// @param [in] size expected UDP receiving buffer size.
+    /// Get the UDP sending buffer size.
+    /// @return Current UDP sending buffer size.
 
-   void setRcvBufSize(int size);
+    int getSndBufSize();
 
-      /// Set the IPV6ONLY option.
-      /// @param [in] IPV6ONLY value.
+    /// Get the UDP receiving buffer size.
+    /// @return Current UDP receiving buffer size.
 
-   void setIpV6Only(int ipV6Only);
+    int getRcvBufSize();
 
-      /// Query the socket address that the channel is using.
-      /// @param [out] addr pointer to store the returned socket address.
+    /// Query the socket address that the channel is using.
+    /// @param [out] addr pointer to store the returned socket address.
 
-   void getSockAddr(sockaddr_any& addr) const;
+    void getSockAddr(sockaddr_any& addr) const;
 
-      /// Query the peer side socket address that the channel is connect to.
-      /// @param [out] addr pointer to store the returned socket address.
+    /// Query the peer side socket address that the channel is connect to.
+    /// @param [out] addr pointer to store the returned socket address.
 
-   void getPeerAddr(sockaddr_any& addr) const;
+    void getPeerAddr(sockaddr_any& addr) const;
 
-      /// Send a packet to the given address.
-      /// @param [in] addr pointer to the destination address.
-      /// @param [in] packet reference to a CPacket entity.
-      /// @return Actual size of data sent.
+    /// Send a packet to the given address.
+    /// @param [in] addr pointer to the destination address.
+    /// @param [in] packet reference to a CPacket entity.
+    /// @param [in] src source address to sent on an outgoing packet (if not ANY)
+    /// @return Actual size of data sent.
 
-   int sendto(const sockaddr_any& addr, CPacket& packet) const;
+    int sendto(const sockaddr_any& addr, srt::CPacket& packet, const sockaddr_any& src) const;
 
-      /// Receive a packet from the channel and record the source address.
-      /// @param [in] addr pointer to the source address.
-      /// @param [in] packet reference to a CPacket entity.
-      /// @return Actual size of data received.
+    /// Receive a packet from the channel and record the source address.
+    /// @param [in] addr pointer to the source address.
+    /// @param [in] packet reference to a CPacket entity.
+    /// @return Actual size of data received.
 
-   EReadStatus recvfrom(sockaddr_any& addr, CPacket& packet) const;
+    EReadStatus recvfrom(sockaddr_any& addr, srt::CPacket& packet) const;
 
-      /// Set the IP TTL.
-      /// @param [in] ttl IP Time To Live.
-      /// @return none.
+    void setConfig(const CSrtMuxerConfig& config);
 
-   void setIpTTL(int ttl);
+    void getSocketOption(int level, int sockoptname, char* pw_dataptr, socklen_t& w_len, int& w_status);
 
-      /// Set the IP Type of Service.
-      /// @param [in] tos IP Type of Service.
+    template<class Type>
+    Type sockopt(int level, int sockoptname, Type deflt)
+    {
+        Type retval;
+        socklen_t socklen = sizeof retval;
+        int status;
+        getSocketOption(level, sockoptname, ((char*)&retval), (socklen), (status));
+        if (status == -1)
+            return deflt;
 
-   void setIpToS(int tos);
+        return retval;
+    }
 
-      /// Get the IP TTL.
-      /// @param [in] ttl IP Time To Live.
-      /// @return TTL.
+    /// Get the IP TTL.
+    /// @param [in] ttl IP Time To Live.
+    /// @return TTL.
 
-   int getIpTTL() const;
+    int getIpTTL() const;
 
-      /// Get the IP Type of Service.
-      /// @return ToS.
+    /// Get the IP Type of Service.
+    /// @return ToS.
 
-   int getIpToS() const;
+    int getIpToS() const;
 
 #ifdef SRT_ENABLE_BINDTODEVICE
-   void setBind(const std::string& name);
-   bool getBind(char* dst, size_t len);
+    bool getBind(char* dst, size_t len);
 #endif
 
-   int ioctlQuery(int type) const;
-   int sockoptQuery(int level, int option) const;
+    int ioctlQuery(int type) const;
+    int sockoptQuery(int level, int option) const;
 
-   const sockaddr* bindAddress() { return m_BindAddr.get(); }
-   const sockaddr_any& bindAddressAny() { return m_BindAddr; }
+    const sockaddr*     bindAddress() { return m_BindAddr.get(); }
+    const sockaddr_any& bindAddressAny() { return m_BindAddr; }
 
 private:
-   void setUDPSockOpt();
+    void setUDPSockOpt();
 
 private:
+    UDPSOCKET m_iSocket; // socket descriptor
+
+    // Mutable because when querying original settings
+    // this comprises the cache for extracted values,
+    // although the object itself isn't considered modified.
+    mutable CSrtMuxerConfig m_mcfg; // Note: ReuseAddr is unused and ineffective.
+    sockaddr_any            m_BindAddr;
+
+    // This feature is not enabled on Windows, for now.
+    // This is also turned off in case of MinGW
+#ifdef SRT_ENABLE_PKTINFO
+    bool                    m_bBindMasked; // True if m_BindAddr is INADDR_ANY. Need for quick check.
+
+    // Calculating the required space is extremely tricky, and whereas on most
+    // platforms it's possible to define it this way:
+    //
+    // size_t s = max( CMSG_SPACE(sizeof(in_pktinfo)), CMSG_SPACE(sizeof(in6_pktinfo)) )
+    //
+    // ...on some platforms however CMSG_SPACE macro can't be resolved as constexpr.
+    //
+    // This structure is exclusively used to determine the required size for
+    // CMSG buffer so that it can be allocated in a solid block with CChannel.
+    // NOT TO BE USED to access any data inside the CMSG message.
+    struct CMSGNodeIPv4
+    {
+        in_pktinfo in4;
+        size_t extrafill;
+        cmsghdr hdr;
+    };
+
+    struct CMSGNodeIPv6
+    {
+        in6_pktinfo in6;
+        size_t extrafill;
+        cmsghdr hdr;
+    };
+
+    sockaddr_any getTargetAddress(const msghdr& msg) const
+    {
+        // Loop through IP header messages
+        cmsghdr* cmsg;
+        for (cmsg = CMSG_FIRSTHDR(&msg);
+                cmsg != NULL;
+                cmsg = CMSG_NXTHDR(((msghdr*)&msg), cmsg))
+        {
+            // This should be safe - this packet contains always either
+            // IPv4 headers or IPv6 headers.
+            if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
+            {
+                in_pktinfo dest_ip;
+                memcpy(&dest_ip, CMSG_DATA(cmsg), sizeof(struct in_pktinfo));
+                return sockaddr_any(dest_ip.ipi_addr, 0);
+            }
+
+            if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO)
+            {
+                in6_pktinfo dest_ip;
+                memcpy(&dest_ip, CMSG_DATA(cmsg), sizeof(struct in6_pktinfo));
+                return sockaddr_any(dest_ip.ipi6_addr, 0);
+            }
+        }
+
+        // Fallback for an error
+        return sockaddr_any(m_BindAddr.family());
+    }
+
+    // IMPORTANT!!! This function shall be called EXCLUSIVELY just before
+    // calling ::sendmsg function. It uses a static buffer to supply data
+    // for the call, and it's stated that only one thread is trying to
+    // use a CChannel object in sending mode.
+    bool setSourceAddress(msghdr& mh, char *buf, const sockaddr_any& adr) const
+    {
+        // In contrast to an advice followed on the net, there's no case of putting
+        // both IPv4 and IPv6 ancillary data, case we could have them. Only one
+        // IP version is used and it's the version as found in @a adr, which should
+        // be the version used for binding.
+
+        if (adr.family() == AF_INET)
+        {
+            mh.msg_control = (void *) buf;
+            mh.msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo));
+
+            cmsghdr* cmsg_send = CMSG_FIRSTHDR(&mh);
+            cmsg_send->cmsg_level = IPPROTO_IP;
+            cmsg_send->cmsg_type = IP_PKTINFO;
+            cmsg_send->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
+            
+            in_pktinfo pktinfo;
+            pktinfo.ipi_ifindex = 0;
+            pktinfo.ipi_spec_dst = adr.sin.sin_addr;
+            memcpy(CMSG_DATA(cmsg_send), &pktinfo, sizeof(in_pktinfo));
+
+            return true;
+        }
+
+        if (adr.family() == AF_INET6)
+        {
+            mh.msg_control = buf;
+            mh.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
+
+            cmsghdr* cmsg_send = CMSG_FIRSTHDR(&mh);
+            cmsg_send->cmsg_level = IPPROTO_IPV6;
+            cmsg_send->cmsg_type = IPV6_PKTINFO;
+            cmsg_send->cmsg_len = CMSG_LEN(sizeof(in6_pktinfo));
+
+            in6_pktinfo* pktinfo = (in6_pktinfo*) CMSG_DATA(cmsg_send);
+            pktinfo->ipi6_ifindex = 0;
+            pktinfo->ipi6_addr = adr.sin6.sin6_addr;
+
+            return true;
+        }
+
+        return false;
+    }
+
+#endif //SRT_ENABLE_PKTINFO
 
-   UDPSOCKET m_iSocket;                 // socket descriptor
-   int m_iIpTTL;
-   int m_iIpToS;
-#ifdef SRT_ENABLE_BINDTODEVICE
-   std::string m_BindToDevice;
-#endif
-   int m_iSndBufSize;                   // UDP sending buffer size
-   int m_iRcvBufSize;                   // UDP receiving buffer size
-   int m_iIpV6Only;                     // IPV6_V6ONLY option (-1 if not set)
-   sockaddr_any m_BindAddr;
 };
 
+} // namespace srt
 
 #endif
diff --git a/srtcore/common.cpp b/srtcore/common.cpp
index 52c19dbfe..d3fd4f22c 100644
--- a/srtcore/common.cpp
+++ b/srtcore/common.cpp
@@ -68,17 +68,23 @@ modified by
 #include "packet.h"
 #include "threadname.h"
 
-#include <srt_compat.h> // SysStrError
-
+using namespace std;
 using namespace srt::sync;
+using namespace srt_logging;
 
-namespace srt_logging {
-    extern Logger inlog;
+namespace srt_logging
+{
+extern Logger inlog;
 }
 
-using namespace srt_logging;
+namespace srt
+{
+
+const char* strerror_get_message(size_t major, size_t minor);
+} // namespace srt
+
 
-CUDTException::CUDTException(CodeMajor major, CodeMinor minor, int err):
+srt::CUDTException::CUDTException(CodeMajor major, CodeMinor minor, int err):
 m_iMajor(major),
 m_iMinor(minor)
 {
@@ -88,246 +94,30 @@ m_iMinor(minor)
       m_iErrno = err;
 }
 
-const char* CUDTException::getErrorMessage() const ATR_NOTHROW
+const char* srt::CUDTException::getErrorMessage() const ATR_NOTHROW
 {
-    return getErrorString().c_str();
+    return strerror_get_message(m_iMajor, m_iMinor);
 }
 
-const string& CUDTException::getErrorString() const
+std::string srt::CUDTException::getErrorString() const
 {
-   // translate "Major:Minor" code into text message.
-
-   switch (m_iMajor)
-   {
-      case MJ_SUCCESS:
-        m_strMsg = "Success";
-        break;
-
-      case MJ_SETUP:
-        m_strMsg = "Connection setup failure";
-
-        switch (m_iMinor)
-        {
-        case MN_TIMEOUT:
-           m_strMsg += ": connection time out";
-           break;
-
-        case MN_REJECTED:
-           m_strMsg += ": connection rejected";
-           break;
-
-        case MN_NORES:
-           m_strMsg += ": unable to create/configure SRT socket";
-           break;
-
-        case MN_SECURITY:
-           m_strMsg += ": abort for security reasons";
-           break;
-
-        case MN_CLOSED:
-           m_strMsg += ": socket closed during operation";
-           break;
-
-        default:
-           break;
-        }
-
-        break;
-
-      case MJ_CONNECTION:
-        switch (m_iMinor)
-        {
-        case MN_CONNLOST:
-           m_strMsg = "Connection was broken";
-           break;
-
-        case MN_NOCONN:
-           m_strMsg = "Connection does not exist";
-           break;
-
-        default:
-           break;
-        }
-
-        break;
-
-      case MJ_SYSTEMRES:
-        m_strMsg = "System resource failure";
-
-        switch (m_iMinor)
-        {
-        case MN_THREAD:
-           m_strMsg += ": unable to create new threads";
-           break;
-
-        case MN_MEMORY:
-           m_strMsg += ": unable to allocate buffers";
-           break;
-
-
-        case MN_OBJECT:
-           m_strMsg += ": unable to allocate system object";
-           break;
-
-        default:
-           break;
-        }
-
-        break;
-
-      case MJ_FILESYSTEM:
-        m_strMsg = "File system failure";
-
-        switch (m_iMinor)
-        {
-        case MN_SEEKGFAIL:
-           m_strMsg += ": cannot seek read position";
-           break;
-
-        case MN_READFAIL:
-           m_strMsg += ": failure in read";
-           break;
-
-        case MN_SEEKPFAIL:
-           m_strMsg += ": cannot seek write position";
-           break;
-
-        case MN_WRITEFAIL:
-           m_strMsg += ": failure in write";
-           break;
-
-        default:
-           break;
-        }
-
-        break;
-
-      case MJ_NOTSUP:
-        m_strMsg = "Operation not supported";
- 
-        switch (m_iMinor)
-        {
-        case MN_ISBOUND:
-           m_strMsg += ": Cannot do this operation on a BOUND socket";
-           break;
-
-        case MN_ISCONNECTED:
-           m_strMsg += ": Cannot do this operation on a CONNECTED socket";
-           break;
-
-        case MN_INVAL:
-           m_strMsg += ": Bad parameters";
-           break;
-
-        case MN_SIDINVAL:
-           m_strMsg += ": Invalid socket ID";
-           break;
-
-        case MN_ISUNBOUND:
-           m_strMsg += ": Cannot do this operation on an UNBOUND socket";
-           break;
-
-        case MN_NOLISTEN:
-           m_strMsg += ": Socket is not in listening state";
-           break;
-
-        case MN_ISRENDEZVOUS:
-           m_strMsg += ": Listen/accept is not supported in rendezous connection setup";
-           break;
-
-        case MN_ISRENDUNBOUND:
-           m_strMsg += ": Cannot call connect on UNBOUND socket in rendezvous connection setup";
-           break;
-
-        case MN_INVALMSGAPI:
-           m_strMsg += ": Incorrect use of Message API (sendmsg/recvmsg).";
-           break;
-
-        case MN_INVALBUFFERAPI:
-           m_strMsg += ": Incorrect use of Buffer API (send/recv) or File API (sendfile/recvfile).";
-           break;
-
-        case MN_BUSY:
-           m_strMsg += ": Another socket is already listening on the same port";
-           break;
-
-        case MN_XSIZE:
-           m_strMsg += ": Message is too large to send (it must be less than the SRT send buffer size)";
-           break;
-
-        case MN_EIDINVAL:
-           m_strMsg += ": Invalid epoll ID";
-           break;
-
-        case MN_EEMPTY:
-           m_strMsg += ": All sockets removed from epoll, waiting would deadlock";
-
-        default:
-           break;
-        }
-
-        break;
-
-     case MJ_AGAIN:
-        m_strMsg = "Non-blocking call failure";
-
-        switch (m_iMinor)
-        {
-        case MN_WRAVAIL:
-           m_strMsg += ": no buffer available for sending";
-           break;
-
-        case MN_RDAVAIL:
-           m_strMsg += ": no data available for reading";
-           break;
-
-        case MN_XMTIMEOUT:
-           m_strMsg += ": transmission timed out";
-           break;
-
-#ifdef SRT_ENABLE_ECN
-        case MN_CONGESTION:
-           m_strMsg += ": early congestion notification";
-           break;
-#endif /* SRT_ENABLE_ECN */
-        default:
-           break;
-        }
-
-        break;
-
-     case MJ_PEERERROR:
-        m_strMsg = "The peer side has signalled an error";
-
-        break;
-
-      default:
-        m_strMsg = "Unknown error";
-   }
-
-   // Adding "errno" information
-   if ((MJ_SUCCESS != m_iMajor) && (0 < m_iErrno))
-   {
-      m_strMsg += ": " + SysStrError(m_iErrno);
-   }
-
-   return m_strMsg;
+    return getErrorMessage();
 }
 
 #define UDT_XCODE(mj, mn) (int(mj)*1000)+int(mn)
 
-int CUDTException::getErrorCode() const
+int srt::CUDTException::getErrorCode() const
 {
     return UDT_XCODE(m_iMajor, m_iMinor);
 }
 
-int CUDTException::getErrno() const
+int srt::CUDTException::getErrno() const
 {
    return m_iErrno;
 }
 
 
-void CUDTException::clear()
+void srt::CUDTException::clear()
 {
    m_iMajor = MJ_SUCCESS;
    m_iMinor = MN_NONE;
@@ -337,7 +127,7 @@ void CUDTException::clear()
 #undef UDT_XCODE
 
 //
-bool CIPAddress::ipcmp(const sockaddr* addr1, const sockaddr* addr2, int ver)
+bool srt::CIPAddress::ipcmp(const sockaddr* addr1, const sockaddr* addr2, int ver)
 {
    if (AF_INET == ver)
    {
@@ -365,7 +155,7 @@ bool CIPAddress::ipcmp(const sockaddr* addr1, const sockaddr* addr2, int ver)
    return false;
 }
 
-void CIPAddress::ntop(const sockaddr_any& addr, uint32_t ip[4])
+void srt::CIPAddress::ntop(const sockaddr_any& addr, uint32_t ip[4])
 {
     if (addr.family() == AF_INET)
     {
@@ -376,14 +166,11 @@ void CIPAddress::ntop(const sockaddr_any& addr, uint32_t ip[4])
     }
     else
     {
-      const sockaddr_in6* a = &addr.sin6;
-      ip[3] = (a->sin6_addr.s6_addr[15] << 24) + (a->sin6_addr.s6_addr[14] << 16) + (a->sin6_addr.s6_addr[13] << 8) + a->sin6_addr.s6_addr[12];
-      ip[2] = (a->sin6_addr.s6_addr[11] << 24) + (a->sin6_addr.s6_addr[10] << 16) + (a->sin6_addr.s6_addr[9] << 8) + a->sin6_addr.s6_addr[8];
-      ip[1] = (a->sin6_addr.s6_addr[7] << 24) + (a->sin6_addr.s6_addr[6] << 16) + (a->sin6_addr.s6_addr[5] << 8) + a->sin6_addr.s6_addr[4];
-      ip[0] = (a->sin6_addr.s6_addr[3] << 24) + (a->sin6_addr.s6_addr[2] << 16) + (a->sin6_addr.s6_addr[1] << 8) + a->sin6_addr.s6_addr[0];
+        std::memcpy(ip, addr.sin6.sin6_addr.s6_addr, 16);
     }
 }
 
+namespace srt {
 bool checkMappedIPv4(const uint16_t* addr)
 {
     static const uint16_t ipv4on6_model [8] =
@@ -398,11 +185,13 @@ bool checkMappedIPv4(const uint16_t* addr)
 
     return std::equal(mbegin, mend, addr);
 }
+}
 
 // XXX This has void return and the first argument is passed by reference.
 // Consider simply returning sockaddr_any by value.
-void CIPAddress::pton(sockaddr_any& w_addr, const uint32_t ip[4], const sockaddr_any& peer)
+void srt::CIPAddress::pton(sockaddr_any& w_addr, const uint32_t ip[4], const sockaddr_any& peer)
 {
+    //using ::srt_logging::inlog;
     uint32_t* target_ipv4_addr = NULL;
 
     if (peer.family() == AF_INET)
@@ -414,7 +203,7 @@ void CIPAddress::pton(sockaddr_any& w_addr, const uint32_t ip[4], const sockaddr
     {
         // Check if the peer address is a model of IPv4-mapped-on-IPv6.
         // If so, it means that the `ip` array should be interpreted as IPv4.
-        const bool is_mapped_ipv4 = checkMappedIPv4((uint16_t*)peer.sin6.sin6_addr.s6_addr);
+        const bool is_mapped_ipv4 = checkMappedIPv4(peer.sin6);
 
         sockaddr_in6* a = (&w_addr.sin6);
 
@@ -428,18 +217,7 @@ void CIPAddress::pton(sockaddr_any& w_addr, const uint32_t ip[4], const sockaddr
             // Here both agent and peer use IPv6, in which case
             // `ip` contains the full IPv6 address, so just copy
             // it as is.
-
-            // XXX Possibly, a simple
-            // memcpy( (a->sin6_addr.s6_addr), ip, 16);
-            // would do the same thing, and faster. The address in `ip`,
-            // even though coded here as uint32_t, is still big endian.
-            for (int i = 0; i < 4; ++ i)
-            {
-                a->sin6_addr.s6_addr[i * 4 + 0] = ip[i] & 0xFF;
-                a->sin6_addr.s6_addr[i * 4 + 1] = (unsigned char)((ip[i] & 0xFF00) >> 8);
-                a->sin6_addr.s6_addr[i * 4 + 2] = (unsigned char)((ip[i] & 0xFF0000) >> 16);
-                a->sin6_addr.s6_addr[i * 4 + 3] = (unsigned char)((ip[i] & 0xFF000000) >> 24);
-            }
+            std::memcpy(a->sin6_addr.s6_addr, ip, 16);
             return; // The address is written, nothing left to do.
         }
 
@@ -519,8 +297,8 @@ void CIPAddress::pton(sockaddr_any& w_addr, const uint32_t ip[4], const sockaddr
     }
 }
 
-using namespace std;
 
+namespace srt {
 static string ShowIP4(const sockaddr_in* sin)
 {
     ostringstream os;
@@ -572,17 +350,19 @@ string CIPAddress::show(const sockaddr* adr)
     else
         return "(unsupported sockaddr type)";
 }
+} // namespace srt
 
 //
-void CMD5::compute(const char* input, unsigned char result[16])
+void srt::CMD5::compute(const char* input, unsigned char result[16])
 {
    md5_state_t state;
 
    md5_init(&state);
-   md5_append(&state, (const md5_byte_t *)input, strlen(input));
+   md5_append(&state, (const md5_byte_t *)input, (int) strlen(input));
    md5_finish(&state, result);
 }
 
+namespace srt {
 std::string MessageTypeStr(UDTMessageType mt, uint32_t extt)
 {
     using std::string;
@@ -649,7 +429,8 @@ std::string TransmissionEventStr(ETransmissionEvent ev)
         "checktimer",
         "send",
         "receive",
-        "custom"
+        "custom",
+        "sync"
     };
 
     size_t vals_size = Size(vals);
@@ -659,40 +440,7 @@ std::string TransmissionEventStr(ETransmissionEvent ev)
     return vals[ev];
 }
 
-extern const char* const srt_rejectreason_msg [] = {
-    "Unknown or erroneous",
-    "Error in system calls",
-    "Peer rejected connection",
-    "Resource allocation failure",
-    "Rogue peer or incorrect parameters",
-    "Listener's backlog exceeded",
-    "Internal Program Error",
-    "Socket is being closed",
-    "Peer version too old",
-    "Rendezvous-mode cookie collision",
-    "Incorrect passphrase",
-    "Password required or unexpected",
-    "MessageAPI/StreamAPI collision",
-    "Congestion controller type collision",
-    "Packet Filter type collision",
-    "Group settings collision",
-    "Connection timeout"
-};
-
-const char* srt_rejectreason_str(int id)
-{
-    if (id >= SRT_REJC_PREDEFINED)
-    {
-        return "Application-defined rejection reason";
-    }
-
-    static const size_t ra_size = Size(srt_rejectreason_msg);
-    if (size_t(id) >= ra_size)
-        return srt_rejectreason_msg[0];
-    return srt_rejectreason_msg[id];
-}
-
-bool SrtParseConfig(string s, SrtConfig& w_config)
+bool SrtParseConfig(const string& s, SrtConfig& w_config)
 {
     using namespace std;
 
@@ -707,18 +455,61 @@ bool SrtParseConfig(string s, SrtConfig& w_config)
         Split(*i, ':', back_inserter(keyval));
         if (keyval.size() != 2)
             return false;
-        w_config.parameters[keyval[0]] = keyval[1];
+        if (keyval[1] != "")
+            w_config.parameters[keyval[0]] = keyval[1];
     }
 
     return true;
 }
 
-uint64_t PacketMetric::fullBytes()
+std::string FormatLossArray(const std::vector< std::pair<int32_t, int32_t> >& lra)
 {
-    static const int PKT_HDR_SIZE = CPacket::HDR_SIZE + CPacket::UDP_HDR_SIZE;
-    return bytes + pkts * PKT_HDR_SIZE;
+    std::ostringstream os;
+
+    os << "[ ";
+    for (std::vector< std::pair<int32_t, int32_t> >::const_iterator i = lra.begin(); i != lra.end(); ++i)
+    {
+        int len = CSeqNo::seqoff(i->first, i->second);
+        os << "%" << i->first;
+        if (len > 1)
+            os << "+" << len;
+        os << " ";
+    }
+
+    os << "]";
+    return os.str();
 }
 
+ostream& PrintEpollEvent(ostream& os, int events, int et_events)
+{
+    static pair<int, const char*> const namemap [] = {
+        make_pair(SRT_EPOLL_IN, "R"),
+        make_pair(SRT_EPOLL_OUT, "W"),
+        make_pair(SRT_EPOLL_ERR, "E"),
+        make_pair(SRT_EPOLL_UPDATE, "U")
+    };
+    bool any = false;
+
+    const int N = (int)Size(namemap);
+
+    for (int i = 0; i < N; ++i)
+    {
+        if (events & namemap[i].first)
+        {
+            os << "[";
+            if (et_events & namemap[i].first)
+                os << "^";
+            os << namemap[i].second << "]";
+            any = true;
+        }
+    }
+
+    if (!any)
+        os << "[]";
+
+    return os;
+}
+} // namespace srt
 
 namespace srt_logging
 {
@@ -755,7 +546,7 @@ std::string SockStatusStr(SRT_SOCKSTATUS s)
     return names.names[int(s)-1];
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 std::string MemberStatusStr(SRT_MEMBERSTATUS s)
 {
     if (int(s) < int(SRT_GST_PENDING) || int(s) > int(SRT_GST_BROKEN))
@@ -780,123 +571,6 @@ std::string MemberStatusStr(SRT_MEMBERSTATUS s)
 }
 #endif
 
-// Logging system implementation
-
-#if ENABLE_LOGGING
-
-LogDispatcher::Proxy::Proxy(LogDispatcher& guy) : that(guy), that_enabled(that.CheckEnabled())
-{
-    if (that_enabled)
-    {
-        i_file = "";
-        i_line = 0;
-        flags = that.src_config->flags;
-        // Create logger prefix
-        that.CreateLogLinePrefix(os);
-    }
-}
-
-LogDispatcher::Proxy LogDispatcher::operator()()
-{
-    return Proxy(*this);
-}
-
-void LogDispatcher::CreateLogLinePrefix(std::ostringstream& serr)
-{
-    using namespace std;
-
-    char tmp_buf[512];
-    if ( !isset(SRT_LOGF_DISABLE_TIME) )
-    {
-        // Not necessary if sending through the queue.
-        timeval tv;
-        gettimeofday(&tv, 0);
-        struct tm tm = SysLocalTime((time_t) tv.tv_sec);
-
-        strftime(tmp_buf, 512, "%X.", &tm);
-        serr << tmp_buf << setw(6) << setfill('0') << tv.tv_usec;
-    }
-
-    string out_prefix;
-    if ( !isset(SRT_LOGF_DISABLE_SEVERITY) )
-    {
-        out_prefix = prefix;
-    }
-
-    // Note: ThreadName::get needs a buffer of size min. ThreadName::BUFSIZE
-    if ( !isset(SRT_LOGF_DISABLE_THREADNAME) && ThreadName::get(tmp_buf) )
-    {
-        serr << "/" << tmp_buf << out_prefix << ": ";
-    }
-    else
-    {
-        serr << out_prefix << ": ";
-    }
-}
-
-std::string LogDispatcher::Proxy::ExtractName(std::string pretty_function)
-{
-    if ( pretty_function == "" )
-        return "";
-    size_t pos = pretty_function.find('(');
-    if ( pos == std::string::npos )
-        return pretty_function; // return unchanged.
-
-    pretty_function = pretty_function.substr(0, pos);
-
-    // There are also template instantiations where the instantiating
-    // parameters are encrypted inside. Therefore, search for the first
-    // open < and if found, search for symmetric >.
-
-    int depth = 1;
-    pos = pretty_function.find('<');
-    if ( pos != std::string::npos )
-    {
-        size_t end = pos+1;
-        for(;;)
-        {
-            ++pos;
-            if ( pos == pretty_function.size() )
-            {
-                --pos;
-                break;
-            }
-            if ( pretty_function[pos] == '<' )
-            {
-                ++depth;
-                continue;
-            }
-
-            if ( pretty_function[pos] == '>' )
-            {
-                --depth;
-                if ( depth <= 0 )
-                    break;
-                continue;
-            }
-        }
-
-        std::string afterpart = pretty_function.substr(pos+1);
-        pretty_function = pretty_function.substr(0, end) + ">" + afterpart;
-    }
-
-    // Now see how many :: can be found in the name.
-    // If this occurs more than once, take the last two.
-    pos = pretty_function.rfind("::");
-
-    if ( pos == std::string::npos || pos < 2 )
-        return pretty_function; // return whatever this is. No scope name.
-
-    // Find the next occurrence of :: - if found, copy up to it. If not,
-    // return whatever is found.
-    pos -= 2;
-    pos = pretty_function.rfind("::", pos);
-    if ( pos == std::string::npos )
-        return pretty_function; // nothing to cut
-
-    return pretty_function.substr(pos+2);
-}
-#endif
 
 } // (end namespace srt_logging)
 
diff --git a/srtcore/common.h b/srtcore/common.h
index f5d042f09..ff84c3faf 100644
--- a/srtcore/common.h
+++ b/srtcore/common.h
@@ -53,7 +53,6 @@ modified by
 #ifndef INC_SRT_COMMON_H
 #define INC_SRT_COMMON_H
 
-#define _CRT_SECURE_NO_WARNINGS 1 // silences windows complaints for sscanf
 #include <memory>
 #include <cstdlib>
 #include <cstdio>
@@ -78,16 +77,37 @@ modified by
    #define NET_ERROR WSAGetLastError()
 #endif
 
-
 #ifdef _DEBUG
+#if defined(SRT_ENABLE_THREADCHECK)
+#include "threadcheck.h"
+#define SRT_ASSERT(cond) ASSERT(cond)
+#else
 #include <assert.h>
 #define SRT_ASSERT(cond) assert(cond)
+#endif
 #else
 #define SRT_ASSERT(cond)
 #endif
 
+#if HAVE_FULL_CXX11
+#define SRT_STATIC_ASSERT(cond, msg) static_assert(cond, msg)
+#else
+#define SRT_STATIC_ASSERT(cond, msg)
+#endif
+
 #include <exception>
 
+namespace srt_logging
+{
+    std::string SockStatusStr(SRT_SOCKSTATUS s);
+#if ENABLE_BONDING
+    std::string MemberStatusStr(SRT_MEMBERSTATUS s);
+#endif
+}
+
+namespace srt
+{
+
 // Class CUDTException exposed for C++ API.
 // This is actually useless, unless you'd use a DIRECT C++ API,
 // however there's no such API so far. The current C++ API for UDT/SRT
@@ -110,7 +130,7 @@ class CUDTException: public std::exception
         return getErrorMessage();
     }
 
-    const std::string& getErrorString() const;
+    std::string getErrorString() const;
 
     /// Get the system errno for the exception.
     /// @return errno.
@@ -279,12 +299,13 @@ enum ETransmissionEvent
 {
     TEV_INIT,       // --> After creation, and after any parameters were updated.
     TEV_ACK,        // --> When handling UMSG_ACK - older CCC:onAck()
-    TEV_ACKACK,     // --> UDT does only RTT sync, can be read from CUDT::RTT().
+    TEV_ACKACK,     // --> UDT does only RTT sync, can be read from CUDT::SRTT().
     TEV_LOSSREPORT, // --> When handling UMSG_LOSSREPORT - older CCC::onLoss()
     TEV_CHECKTIMER, // --> See TEV_CHT_REXMIT
     TEV_SEND,       // --> When the packet is scheduled for sending - older CCC::onPktSent
     TEV_RECEIVE,    // --> When a data packet was received - older CCC::onPktReceived
     TEV_CUSTOM,     // --> probably dead call - older CCC::processCustomMsg
+    TEV_SYNC,       // --> Backup group. When rate estimation is derived from an active member, and update is needed.
 
     TEV_E_SIZE
 };
@@ -317,7 +338,7 @@ struct EventVariant
     enum Type {UNDEFINED, PACKET, ARRAY, ACK, STAGE, INIT} type;
     union U
     {
-        const CPacket* packet;
+        const srt::CPacket* packet;
         int32_t ack;
         struct
         {
@@ -336,7 +357,7 @@ struct EventVariant
     // Note: UNDEFINED and ARRAY don't have assignment operator.
     // For ARRAY you'll use 'set' function. For UNDEFINED there's nothing.
 
-    explicit EventVariant(const CPacket* arg)
+    explicit EventVariant(const srt::CPacket* arg)
     {
         type = PACKET;
         u.packet = arg;
@@ -425,7 +446,7 @@ class EventArgType;
 // use a full-templated version. TBD.
 template<> struct EventVariant::VariantFor<EventVariant::PACKET>
 {
-    typedef const CPacket* type;
+    typedef const srt::CPacket* type;
     static type U::*field() {return &U::packet;}
 };
 
@@ -609,7 +630,7 @@ class CSeqNo
 
    /// This behaves like seq1 - seq2, in comparison to numbers,
    /// and with the statement that only the sign of the result matters.
-   /// That is, it returns a negative value if seq1 < seq2,
+   /// Returns a negative value if seq1 < seq2,
    /// positive if seq1 > seq2, and zero if they are equal.
    /// The only correct application of this function is when you
    /// compare two values and it works faster than seqoff. However
@@ -627,12 +648,16 @@ class CSeqNo
    /// WITH A PRECONDITION that certainly @a seq1 is earlier than @a seq2.
    /// This can also include an enormously large distance between them,
    /// that is, exceeding the m_iSeqNoTH value (can be also used to test
-   /// if this distance is larger). Prior to calling this function the
-   /// caller must be certain that @a seq2 is a sequence coming from a
-   /// later time than @a seq1, and still, of course, this distance didn't
-   /// exceed m_iMaxSeqNo.
+   /// if this distance is larger).
+   /// Prior to calling this function the caller must be certain that
+   /// @a seq2 is a sequence coming from a later time than @a seq1,
+   /// and that the distance does not exceed m_iMaxSeqNo.
    inline static int seqlen(int32_t seq1, int32_t seq2)
-   {return (seq1 <= seq2) ? (seq2 - seq1 + 1) : (seq2 - seq1 + m_iMaxSeqNo + 2);}
+   {
+       SRT_ASSERT(seq1 >= 0 && seq1 <= m_iMaxSeqNo);
+       SRT_ASSERT(seq2 >= 0 && seq2 <= m_iMaxSeqNo);
+       return (seq1 <= seq2) ? (seq2 - seq1 + 1) : (seq2 - seq1 + m_iMaxSeqNo + 2);
+   }
 
    /// This behaves like seq2 - seq1, with the precondition that the true
    /// distance between two sequence numbers never exceeds m_iSeqNoTH.
@@ -771,7 +796,7 @@ class RollNumber
         return right < *this;
     }
 
-    bool operator=(const this_t& right) const
+    bool operator==(const this_t& right) const
     {
         return number == right.number;
     }
@@ -1363,14 +1388,6 @@ class CircularBuffer
     }
 };
 
-namespace srt_logging
-{
-std::string SockStatusStr(SRT_SOCKSTATUS s);
-#if ENABLE_EXPERIMENTAL_BONDING
-std::string MemberStatusStr(SRT_MEMBERSTATUS s);
-#endif
-}
-
 // Version parsing
 inline ATR_CONSTEXPR uint32_t SrtVersion(int major, int minor, int patch)
 {
@@ -1380,8 +1397,11 @@ inline ATR_CONSTEXPR uint32_t SrtVersion(int major, int minor, int patch)
 inline int32_t SrtParseVersion(const char* v)
 {
     int major, minor, patch;
+#if defined(_MSC_VER)
+    int result = sscanf_s(v, "%d.%d.%d", &major, &minor, &patch);
+#else
     int result = sscanf(v, "%d.%d.%d", &major, &minor, &patch);
-
+#endif
     if (result != 3)
     {
         return 0;
@@ -1396,97 +1416,28 @@ inline std::string SrtVersionString(int version)
     int minor = (version/0x100)%0x100;
     int major = version/0x10000;
 
-    char buf[20];
-    sprintf(buf, "%d.%d.%d", major, minor, patch);
+    char buf[22];
+#if defined(_MSC_VER) && _MSC_VER < 1900
+    _snprintf(buf, sizeof(buf) - 1, "%d.%d.%d", major, minor, patch);
+#else
+    snprintf(buf, sizeof(buf), "%d.%d.%d", major, minor, patch);
+#endif
     return buf;
 }
 
-bool SrtParseConfig(std::string s, SrtConfig& w_config);
+bool SrtParseConfig(const std::string& s, SrtConfig& w_config);
 
-struct PacketMetric
-{
-    uint32_t pkts;
-    uint64_t bytes;
+bool checkMappedIPv4(const uint16_t* sa);
 
-    void update(uint64_t size)
-    {
-        ++pkts;
-        bytes += size;
-    }
-
-    void update(size_t mult, uint64_t value)
-    {
-        pkts += mult;
-        bytes += mult * value;
-    }
-
-    uint64_t fullBytes();
-};
-
-template <class METRIC_TYPE>
-struct MetricOp;
-
-template <class METRIC_TYPE>
-struct MetricUsage
-{
-    METRIC_TYPE local;
-    METRIC_TYPE total;
-
-    void Clear()
-    {
-        MetricOp<METRIC_TYPE>::Clear(local);
-    }
-
-    void Init()
-    {
-        MetricOp<METRIC_TYPE>::Clear(total);
-        Clear();
-    }
-
-    void Update(uint64_t value)
-    {
-        local += value;
-        total += value;
-    }
-
-    void UpdateTimes(size_t mult, uint64_t value)
-    {
-        local += mult * value;
-        total += mult * value;
-    }
-};
-
-template <>
-inline void MetricUsage<PacketMetric>::Update(uint64_t value)
+inline bool checkMappedIPv4(const sockaddr_in6& sa)
 {
-    local.update(value);
-    total.update(value);
+    const uint16_t* addr = reinterpret_cast<const uint16_t*>(&sa.sin6_addr.s6_addr);
+    return checkMappedIPv4(addr);
 }
 
-template <>
-inline void MetricUsage<PacketMetric>::UpdateTimes(size_t mult, uint64_t value)
-{
-    local.update(mult, value);
-    total.update(mult, value);
-}
+std::string FormatLossArray(const std::vector< std::pair<int32_t, int32_t> >& lra);
+std::ostream& PrintEpollEvent(std::ostream& os, int events, int et_events = 0);
 
-template <class METRIC_TYPE>
-struct MetricOp
-{
-    static void Clear(METRIC_TYPE& m)
-    {
-        m = 0;
-    }
-};
-
-template <>
-struct MetricOp<PacketMetric>
-{
-    static void Clear(PacketMetric& p)
-    {
-        p.pkts = 0;
-        p.bytes = 0;
-    }
-};
+} // namespace srt
 
 #endif
diff --git a/srtcore/congctl.cpp b/srtcore/congctl.cpp
index 721542c92..85d4cda97 100644
--- a/srtcore/congctl.cpp
+++ b/srtcore/congctl.cpp
@@ -37,6 +37,8 @@ using namespace std;
 using namespace srt::sync;
 using namespace srt_logging;
 
+namespace srt {
+
 SrtCongestionControlBase::SrtCongestionControlBase(CUDT* parent)
 {
     m_parent = parent;
@@ -59,8 +61,9 @@ void SrtCongestion::Check()
 class LiveCC: public SrtCongestionControlBase
 {
     int64_t  m_llSndMaxBW;          //Max bandwidth (bytes/sec)
-    size_t   m_zSndAvgPayloadSize;  //Average Payload Size of packets to xmit
+    srt::sync::atomic<size_t>   m_zSndAvgPayloadSize;  //Average Payload Size of packets to xmit
     size_t   m_zMaxPayloadSize;
+    size_t   m_zHeaderSize;
 
     // NAKREPORT stuff.
     int m_iMinNakInterval_us;                       // Minimum NAK Report Period (usec)
@@ -75,12 +78,14 @@ class LiveCC: public SrtCongestionControlBase
     {
         m_llSndMaxBW = BW_INFINITE;    // 1 Gbbps in Bytes/sec BW_INFINITE
         m_zMaxPayloadSize = parent->OPT_PayloadSize();
-        if ( m_zMaxPayloadSize == 0 )
+        if (m_zMaxPayloadSize == 0)
             m_zMaxPayloadSize = parent->maxPayloadSize();
         m_zSndAvgPayloadSize = m_zMaxPayloadSize;
 
+        m_zHeaderSize = parent->m_config.iMSS - parent->maxPayloadSize();
+
         m_iMinNakInterval_us = 20000;   //Minimum NAK Report Period (usec)
-        m_iNakReportAccel = 2;       //Default NAK Report Period (RTT) accelerator
+        m_iNakReportAccel = 2;       //Default NAK Report Period (RTT) accelerator (send periodic NAK every RTT/2)
 
         HLOGC(cclog.Debug, log << "Creating LiveCC: bw=" << m_llSndMaxBW << " avgplsize=" << m_zSndAvgPayloadSize);
 
@@ -91,11 +96,11 @@ class LiveCC: public SrtCongestionControlBase
         // from receiving thread.
         parent->ConnectSignal(TEV_SEND, SSLOT(updatePayloadSize));
 
-        /*
-         * Readjust the max SndPeriod onACK (and onTimeout)
-         */
-        parent->ConnectSignal(TEV_CHECKTIMER, SSLOT(updatePktSndPeriod_onTimer));
-        parent->ConnectSignal(TEV_ACK, SSLOT(updatePktSndPeriod_onAck));
+        //
+        // Adjust the max SndPeriod onACK and onTimeout.
+        //
+        parent->ConnectSignal(TEV_CHECKTIMER, SSLOT(onRTO));
+        parent->ConnectSignal(TEV_ACK, SSLOT(onAck));
     }
 
     bool checkTransArgs(SrtCongestion::TransAPI api, SrtCongestion::TransDir dir, const char* , size_t size, int , bool ) ATR_OVERRIDE
@@ -152,21 +157,26 @@ class LiveCC: public SrtCongestionControlBase
         HLOGC(cclog.Debug, log << "LiveCC: avg payload size updated: " << m_zSndAvgPayloadSize);
     }
 
-    void updatePktSndPeriod_onTimer(ETransmissionEvent , EventVariant var)
+    /// @brief On RTO event update an inter-packet send interval.
+    /// @param arg EventVariant::STAGE to distinguish between INIT and actual RTO.
+    void onRTO(ETransmissionEvent , EventVariant var)
     {
-        if ( var.get<EventVariant::STAGE>() != TEV_CHT_INIT )
+        if (var.get<EventVariant::STAGE>() != TEV_CHT_INIT )
             updatePktSndPeriod();
     }
 
-    void updatePktSndPeriod_onAck(ETransmissionEvent , EventVariant )
+    /// @brief Handle an incoming ACK event.
+    /// Mainly updates a send interval between packets relying on the maximum BW limit.
+    void onAck(ETransmissionEvent, EventVariant )
     {
         updatePktSndPeriod();
     }
 
+    /// @brief Updates a send interval between packets relying on the maximum BW limit.
     void updatePktSndPeriod()
     {
         // packet = payload + header
-        const double pktsize = (double) m_zSndAvgPayloadSize + CPacket::SRT_DATA_HDR_SIZE;
+        const double pktsize = (double) m_zSndAvgPayloadSize.load() + m_zHeaderSize;
         m_dPktSndPeriod = 1000 * 1000.0 * (pktsize / m_llSndMaxBW);
         HLOGC(cclog.Debug, log << "LiveCC: sending period updated: " << m_dPktSndPeriod
                 << " by avg pktsize=" << m_zSndAvgPayloadSize
@@ -223,7 +233,7 @@ class LiveCC: public SrtCongestionControlBase
          * For realtime Transport Stream content, pkts/sec is not a good indication of time to transmit
          * since packets are not filled to m_iMSS and packet size average is lower than (7*188)
          * for low bit rates.
-         * If NAK report is lost, another cycle (RTT) is requred which is bad for low latency so we
+         * If NAK report is lost, another cycle (RTT) is required which is bad for low latency so we
          * accelerate the NAK Reports frequency, at the cost of possible duplicate resend.
          * Finally, the UDT4 native minimum NAK interval (m_ullMinNakInt_tk) is 300 ms which is too high
          * (~10 i30 video frames) to maintain low latency.
@@ -288,9 +298,9 @@ class FileCC : public SrtCongestionControlBase
         m_dCWndSize = 16;
         m_dPktSndPeriod = 1;
 
-        parent->ConnectSignal(TEV_ACK,        SSLOT(updateSndPeriod));
-        parent->ConnectSignal(TEV_LOSSREPORT, SSLOT(slowdownSndPeriod));
-        parent->ConnectSignal(TEV_CHECKTIMER, SSLOT(speedupToWindowSize));
+        parent->ConnectSignal(TEV_ACK,        SSLOT(onACK));
+        parent->ConnectSignal(TEV_LOSSREPORT, SSLOT(onLossReport));
+        parent->ConnectSignal(TEV_CHECKTIMER, SSLOT(onRTO));
 
         HLOGC(cclog.Debug, log << "Creating FileCC");
     }
@@ -304,10 +314,11 @@ class FileCC : public SrtCongestionControlBase
         return true;
     }
 
+    /// Tells if an early ACK is needed (before the next Full ACK happening every 10ms).
+    /// In FileCC, treat non-full-payload as an end-of-message (stream)
+    /// and request ACK to be sent immediately.
     bool needsQuickACK(const CPacket& pkt) ATR_OVERRIDE
     {
-        // For FileCC, treat non-full-buffer situation as an end-of-message situation;
-        // request ACK to be sent immediately.
         if (pkt.getLength() < m_parent->maxPayloadSize())
         {
             // This is not a regular fixed size packet...
@@ -328,9 +339,10 @@ class FileCC : public SrtCongestionControlBase
     }
 
 private:
-
-    // SLOTS
-    void updateSndPeriod(ETransmissionEvent, EventVariant arg)
+    /// Handle icoming ACK event.
+    /// In slow start stage increase CWND. Leave slow start once maximum CWND is reached.
+    /// In congestion avoidance stage adjust inter packet send interval value to achieve maximum rate.
+    void onACK(ETransmissionEvent, EventVariant arg)
     {
         const int ack = arg.get<EventVariant::ACK>();
 
@@ -358,11 +370,11 @@ class FileCC : public SrtCongestionControlBase
                 }
                 else
                 {
-                    m_dPktSndPeriod = m_dCWndSize / (m_parent->RTT() + m_iRCInterval);
+                    m_dPktSndPeriod = m_dCWndSize / (m_parent->SRTT() + m_iRCInterval);
                     HLOGC(cclog.Debug, log << "FileCC: UPD (slowstart:ENDED) wndsize="
                         << m_dCWndSize << "/" << m_dMaxCWndSize
                         << " sndperiod=" << m_dPktSndPeriod << "us = wndsize/(RTT+RCIV) RTT="
-                        << m_parent->RTT() << " RCIV=" << m_iRCInterval);
+                        << m_parent->SRTT() << " RCIV=" << m_iRCInterval);
                 }
             }
             else
@@ -374,9 +386,9 @@ class FileCC : public SrtCongestionControlBase
         }
         else
         {
-            m_dCWndSize = m_parent->deliveryRate() / 1000000.0 * (m_parent->RTT() + m_iRCInterval) + 16;
+            m_dCWndSize = m_parent->deliveryRate() / 1000000.0 * (m_parent->SRTT() + m_iRCInterval) + 16;
             HLOGC(cclog.Debug, log << "FileCC: UPD (speed mode) wndsize="
-                << m_dCWndSize << "/" << m_dMaxCWndSize << " RTT = " << m_parent->RTT()
+                << m_dCWndSize << "/" << m_dMaxCWndSize << " RTT = " << m_parent->SRTT()
                 << " sndperiod=" << m_dPktSndPeriod << "us. deliverRate = "
                 << m_parent->deliveryRate() << " pkts/s)");
         }
@@ -391,7 +403,7 @@ class FileCC : public SrtCongestionControlBase
             else
             {
                 double inc = 0;
-                const int loss_bw = 2 * (1000000 / m_dLastDecPeriod); // 2 times last loss point
+                const int loss_bw = static_cast<int>(2 * (1000000 / m_dLastDecPeriod)); // 2 times last loss point
                 const int bw_pktps = min(loss_bw, m_parent->bandwidth());
 
                 int64_t B = (int64_t)(bw_pktps - 1000000.0 / m_dPktSndPeriod);
@@ -454,9 +466,10 @@ class FileCC : public SrtCongestionControlBase
 
     }
 
-    // When a lossreport has been received, it might be due to having
-    // reached the available bandwidth limit. Slowdown to avoid further losses.
-    void slowdownSndPeriod(ETransmissionEvent, EventVariant arg)
+    /// When a lossreport has been received, it might be due to having
+    /// reached the available bandwidth limit. Slowdown to avoid further losses.
+    /// Leave the slow start stage if it was active.
+    void onLossReport(ETransmissionEvent, EventVariant arg)
     {
         const int32_t* losslist = arg.get_ptr();
         size_t losslist_size = arg.get_len();
@@ -481,9 +494,9 @@ class FileCC : public SrtCongestionControlBase
             }
             else
             {
-                m_dPktSndPeriod = m_dCWndSize / (m_parent->RTT() + m_iRCInterval);
+                m_dPktSndPeriod = m_dCWndSize / (m_parent->SRTT() + m_iRCInterval);
                 HLOGC(cclog.Debug, log << "FileCC: LOSS, SLOWSTART:OFF, sndperiod=" << m_dPktSndPeriod << "us AS wndsize/(RTT+RCIV) (RTT="
-                    << m_parent->RTT() << " RCIV=" << m_iRCInterval << ")");
+                    << m_parent->SRTT() << " RCIV=" << m_iRCInterval << ")");
             }
 
         }
@@ -491,7 +504,7 @@ class FileCC : public SrtCongestionControlBase
         m_bLoss = true;
 
         // TODO: const int pktsInFlight = CSeqNo::seqoff(m_iLastAck, m_parent->sndSeqNo());
-        const int pktsInFlight = m_parent->RTT() / m_dPktSndPeriod;
+        const int pktsInFlight = static_cast<int>(m_parent->SRTT() / m_dPktSndPeriod);
         const int numPktsLost = m_parent->sndLossLength();
         const int lost_pcent_x10 = pktsInFlight > 0 ? (numPktsLost * 1000) / pktsInFlight : 0;
 
@@ -525,11 +538,8 @@ class FileCC : public SrtCongestionControlBase
 
             m_iLastDecSeq = m_parent->sndSeqNo();
 
-            // remove global synchronization using randomization
-            srand(m_iLastDecSeq);
-            m_iDecRandom = (int)ceil(m_iAvgNAKNum * (double(rand()) / RAND_MAX));
-            if (m_iDecRandom < 1)
-                m_iDecRandom = 1;
+            m_iDecRandom = m_iAvgNAKNum > 1 ? genRandomInt(1, m_iAvgNAKNum) : 1;
+            SRT_ASSERT(m_iDecRandom >= 1);
             HLOGC(cclog.Debug, log << "FileCC: LOSS:NEW lseqno=" << lossbegin
                 << ", lastsentseqno=" << m_iLastDecSeq
                 << ", seqdiff=" << CSeqNo::seqoff(m_iLastDecSeq, lossbegin)
@@ -560,7 +570,9 @@ class FileCC : public SrtCongestionControlBase
         }
     }
 
-    void speedupToWindowSize(ETransmissionEvent, EventVariant arg)
+    /// @brief  On retransmission timeout leave slow start stage if it was active.
+    /// @param arg EventVariant::STAGE to distinguish between INIT and actual RTO.
+    void onRTO(ETransmissionEvent, EventVariant arg)
     {
         ECheckTimerStage stg = arg.get<EventVariant::STAGE>();
 
@@ -581,9 +593,9 @@ class FileCC : public SrtCongestionControlBase
             }
             else
             {
-                m_dPktSndPeriod = m_dCWndSize / (m_parent->RTT() + m_iRCInterval);
+                m_dPktSndPeriod = m_dCWndSize / (m_parent->SRTT() + m_iRCInterval);
                 HLOGC(cclog.Debug, log << "FileCC: CHKTIMER, SLOWSTART:OFF, sndperiod=" << m_dPktSndPeriod << "us AS wndsize/(RTT+RCIV) (wndsize="
-                    << setprecision(6) << m_dCWndSize << " RTT=" << m_parent->RTT() << " RCIV=" << m_iRCInterval << ")");
+                    << m_dCWndSize << " RTT=" << m_parent->SRTT() << " RCIV=" << m_iRCInterval << ")");
             }
         }
         else
@@ -647,3 +659,5 @@ SrtCongestion::~SrtCongestion()
 {
     dispose();
 }
+
+} // namespace srt
diff --git a/srtcore/congctl.h b/srtcore/congctl.h
index cc44f02c9..a2264b594 100644
--- a/srtcore/congctl.h
+++ b/srtcore/congctl.h
@@ -11,14 +11,16 @@
 #ifndef INC_SRT_CONGCTL_H
 #define INC_SRT_CONGCTL_H
 
+#include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 
+namespace srt {
+
 class CUDT;
 class SrtCongestionControlBase;
-
-typedef SrtCongestionControlBase* srtcc_create_t(CUDT* parent);
+typedef SrtCongestionControlBase* srtcc_create_t(srt::CUDT* parent);
 
 class SrtCongestion
 {
@@ -50,18 +52,29 @@ class SrtCongestion
 
     struct IsName
     {
-        std::string n;
-        IsName(std::string nn): n(nn) {}
+        const std::string n;
+        IsName(const std::string& nn): n(nn) {}
         bool operator()(NamePtr np) { return n == np.first; }
     };
 
+    static NamePtr* find(const std::string& name)
+    {
+        NamePtr* end = congctls+N_CONTROLLERS;
+        NamePtr* try_selector = std::find_if(congctls, end, IsName(name));
+        return try_selector != end ? try_selector : NULL;
+    }
+
+    static bool exists(const std::string& name)
+    {
+        return find(name);
+    }
+
     // You can call select() multiple times, until finally
     // the 'configure' method is called.
     bool select(const std::string& name)
     {
-        NamePtr* end = congctls+N_CONTROLLERS;
-        NamePtr* try_selector = std::find_if(congctls, end, IsName(name));
-        if (try_selector == end)
+        NamePtr* try_selector = find(name);
+        if (!try_selector)
             return false;
         selector = try_selector - congctls;
         return true;
@@ -85,7 +98,7 @@ class SrtCongestion
     // in appropriate time. It should select appropriate
     // congctl basing on the value in selector, then
     // pin oneself in into CUDT for receiving event signals.
-    bool configure(CUDT* parent);
+    bool configure(srt::CUDT* parent);
 
     // This function will intentionally delete the contained object.
     // This makes future calls to ready() return false. Calling
@@ -117,12 +130,13 @@ class SrtCongestion
     };
 };
 
+class CPacket;
 
 class SrtCongestionControlBase
 {
 protected:
     // Here can be some common fields
-    CUDT* m_parent;
+    srt::CUDT* m_parent;
 
     double m_dPktSndPeriod;
     double m_dCWndSize;
@@ -133,11 +147,11 @@ class SrtCongestionControlBase
     //int m_iMSS;              // NOT REQUIRED. Use m_parent->MSS() instead.
     //int32_t m_iSndCurrSeqNo; // NOT REQUIRED. Use m_parent->sndSeqNo().
     //int m_iRcvRate;          // NOT REQUIRED. Use m_parent->deliveryRate() instead.
-    //int m_RTT;               // NOT REQUIRED. Use m_parent->RTT() instead.
+    //int m_RTT;               // NOT REQUIRED. Use m_parent->SRTT() instead.
     //char* m_pcParam;         // Used to access m_llMaxBw. Use m_parent->maxBandwidth() instead.
 
     // Constructor in protected section so that this class is semi-abstract.
-    SrtCongestionControlBase(CUDT* parent);
+    SrtCongestionControlBase(srt::CUDT* parent);
 public:
 
     // This could be also made abstract, but this causes a linkage
@@ -175,11 +189,11 @@ class SrtCongestionControlBase
     virtual int ACKTimeout_us() const { return 0; }
 
     // Called when the settings concerning m_llMaxBW were changed.
-    // Arg 1: value of CUDT::m_llMaxBW
-    // Arg 2: value calculated out of CUDT::m_llInputBW and CUDT::m_iOverheadBW.
+    // Arg 1: value of CUDT's m_config.m_llMaxBW
+    // Arg 2: value calculated out of CUDT's m_config.llInputBW and m_config.iOverheadBW.
     virtual void updateBandwidth(int64_t, int64_t) {}
 
-    virtual bool needsQuickACK(const CPacket&)
+    virtual bool needsQuickACK(const srt::CPacket&)
     {
         return false;
     }
@@ -207,6 +221,6 @@ class SrtCongestionControlBase
 };
 
 
-
+} // namespace srt
 
 #endif
diff --git a/srtcore/core.cpp b/srtcore/core.cpp
index dd5cb77a3..c33c8e4ab 100644
--- a/srtcore/core.cpp
+++ b/srtcore/core.cpp
@@ -62,6 +62,7 @@ modified by
 #include <algorithm>
 #include <iterator>
 #include "srt.h"
+#include "access_control.h" // Required for SRT_REJX_FALLBACK
 #include "queue.h"
 #include "api.h"
 #include "core.h"
@@ -70,6 +71,11 @@ modified by
 #include "logging_api.h" // Required due to containing extern srt_logger_config
 #include "logger_defs.h"
 
+#if !HAVE_CXX11
+// for pthread_once
+#include <pthread.h>
+#endif
+
 // Again, just in case when some "smart guy" provided such a global macro
 #ifdef min
 #undef min
@@ -79,23 +85,12 @@ modified by
 #endif
 
 using namespace std;
+using namespace srt;
 using namespace srt::sync;
 using namespace srt_logging;
 
-CUDTUnited CUDT::s_UDTUnited;
-
-const SRTSOCKET UDT::INVALID_SOCK = CUDT::INVALID_SOCK;
-const int       UDT::ERROR        = CUDT::ERROR;
-
-// SRT Version constants
-#define SRT_VERSION_UNK     0
-#define SRT_VERSION_MAJ1    0x010000            /* Version 1 major */
-#define SRT_VERSION_MAJ(v) (0xFF0000 & (v))     /* Major number ensuring backward compatibility */
-#define SRT_VERSION_MIN(v) (0x00FF00 & (v))
-#define SRT_VERSION_PCH(v) (0x0000FF & (v))
-
-// NOTE: SRT_VERSION is primarily defined in the build file.
-extern const int32_t SRT_DEF_VERSION = SrtParseVersion(SRT_VERSION);
+const SRTSOCKET UDT::INVALID_SOCK = srt::CUDT::INVALID_SOCK;
+const int       UDT::ERROR        = srt::CUDT::ERROR;
 
 //#define SRT_CMD_HSREQ       1           /* SRT Handshake Request (sender) */
 #define SRT_CMD_HSREQ_MINSZ 8 /* Minumum Compatible (1.x.x) packet size (bytes) */
@@ -124,15 +119,156 @@ extern const int32_t SRT_DEF_VERSION = SrtParseVersion(SRT_VERSION);
         2[15..0]:   TsbPD delay     [0..60000] msec
 */
 
-void CUDT::construct()
+// IMPORTANT!!! This array must be ordered by value, because std::binary_search is performed on it!
+extern const SRT_SOCKOPT srt_post_opt_list [SRT_SOCKOPT_NPOST] = {
+    SRTO_SNDSYN,
+    SRTO_RCVSYN,
+    SRTO_LINGER,
+    SRTO_SNDTIMEO,
+    SRTO_RCVTIMEO,
+    SRTO_MAXBW,
+    SRTO_INPUTBW,
+    SRTO_OHEADBW,
+    SRTO_SNDDROPDELAY,
+    SRTO_DRIFTTRACER,
+    SRTO_MININPUTBW,
+    SRTO_LOSSMAXTTL
+#ifdef ENABLE_MAXREXMITBW
+    ,SRTO_MAXREXMITBW
+#endif
+};
+
+const int32_t
+    SRTO_R_PREBIND = BIT(0), //< cannot be modified after srt_bind()
+    SRTO_R_PRE = BIT(1),     //< cannot be modified after connection is established
+    SRTO_POST_SPEC = BIT(2); //< executes some action after setting the option
+
+
+namespace srt
+{
+
+struct SrtOptionAction
+{
+    int flags[SRTO_E_SIZE];
+    std::map<SRT_SOCKOPT, std::string> private_default;
+    SrtOptionAction()
+    {
+        // Set everything to 0 to clear all flags
+        // When an option isn't present here, it means that:
+        // * it is not settable, or
+        // * the option is POST (non-restricted)
+        // * it has no post-actions
+        // The post-action may be defined independently on restrictions.
+        memset(flags, 0, sizeof flags);
+
+        flags[SRTO_MSS]                = SRTO_R_PREBIND;
+        flags[SRTO_FC]                 = SRTO_R_PRE;
+        flags[SRTO_SNDBUF]             = SRTO_R_PREBIND;
+        flags[SRTO_RCVBUF]             = SRTO_R_PREBIND;
+        flags[SRTO_UDP_SNDBUF]         = SRTO_R_PREBIND;
+        flags[SRTO_UDP_RCVBUF]         = SRTO_R_PREBIND;
+        flags[SRTO_RENDEZVOUS]         = SRTO_R_PRE;
+        flags[SRTO_REUSEADDR]          = SRTO_R_PREBIND;
+        flags[SRTO_MAXBW]              = SRTO_POST_SPEC;
+        flags[SRTO_SENDER]             = SRTO_R_PRE;
+        flags[SRTO_TSBPDMODE]          = SRTO_R_PRE;
+        flags[SRTO_LATENCY]            = SRTO_R_PRE;
+        flags[SRTO_INPUTBW]            = SRTO_POST_SPEC;
+        flags[SRTO_MININPUTBW]         = SRTO_POST_SPEC;
+        flags[SRTO_OHEADBW]            = SRTO_POST_SPEC;
+        flags[SRTO_PASSPHRASE]         = SRTO_R_PRE;
+        flags[SRTO_PBKEYLEN]           = SRTO_R_PRE;
+        flags[SRTO_IPTTL]              = SRTO_R_PREBIND;
+        flags[SRTO_IPTOS]              = SRTO_R_PREBIND;
+        flags[SRTO_TLPKTDROP]          = SRTO_R_PRE;
+        flags[SRTO_SNDDROPDELAY]       = SRTO_POST_SPEC;
+        flags[SRTO_NAKREPORT]          = SRTO_R_PRE;
+        flags[SRTO_VERSION]            = SRTO_R_PRE;
+        flags[SRTO_CONNTIMEO]          = SRTO_R_PRE;
+        flags[SRTO_LOSSMAXTTL]         = SRTO_POST_SPEC;
+        flags[SRTO_RCVLATENCY]         = SRTO_R_PRE;
+        flags[SRTO_PEERLATENCY]        = SRTO_R_PRE;
+        flags[SRTO_MINVERSION]         = SRTO_R_PRE;
+        flags[SRTO_STREAMID]           = SRTO_R_PRE;
+        flags[SRTO_CONGESTION]         = SRTO_R_PRE;
+        flags[SRTO_MESSAGEAPI]         = SRTO_R_PRE;
+        flags[SRTO_PAYLOADSIZE]        = SRTO_R_PRE;
+        flags[SRTO_TRANSTYPE]          = SRTO_R_PREBIND;
+        flags[SRTO_KMREFRESHRATE]      = SRTO_R_PRE;
+        flags[SRTO_KMPREANNOUNCE]      = SRTO_R_PRE;
+        flags[SRTO_ENFORCEDENCRYPTION] = SRTO_R_PRE;
+        flags[SRTO_IPV6ONLY]           = SRTO_R_PREBIND;
+        flags[SRTO_PEERIDLETIMEO]      = SRTO_R_PRE;
+#ifdef SRT_ENABLE_BINDTODEVICE
+        flags[SRTO_BINDTODEVICE]       = SRTO_R_PREBIND;
+#endif
+#if ENABLE_BONDING
+        flags[SRTO_GROUPCONNECT]       = SRTO_R_PRE;
+        flags[SRTO_GROUPMINSTABLETIMEO]= SRTO_R_PRE;
+#endif
+        flags[SRTO_PACKETFILTER]       = SRTO_R_PRE;
+        flags[SRTO_RETRANSMITALGO]     = SRTO_R_PRE;
+#ifdef ENABLE_AEAD_API_PREVIEW
+        flags[SRTO_CRYPTOMODE]         = SRTO_R_PRE;
+#endif
+
+        // For "private" options (not derived from the listener
+        // socket by an accepted socket) provide below private_default
+        // to which these options will be reset after blindly
+        // copying the option object from the listener socket.
+        // Note that this option cannot have runtime-dependent
+        // default value, like options affected by SRTO_TRANSTYPE.
+
+        // Options may be of different types, but this value should be only
+        // used as a source of the value. For example, in case of int64_t you'd
+        // have to place here a string of 8 characters. It should be copied
+        // always in the hardware order, as this is what will be directly
+        // passed to a setting function.
+        private_default[SRTO_STREAMID] = string();
+    }
+};
+
+const SrtOptionAction s_sockopt_action;
+
+} // namespace srt
+
+#if HAVE_CXX11
+
+CUDTUnited& srt::CUDT::uglobal()
+{
+    static CUDTUnited instance;
+    return instance;
+}
+
+#else // !HAVE_CXX11
+
+static pthread_once_t s_UDTUnitedOnce = PTHREAD_ONCE_INIT;
+
+static CUDTUnited *getInstance()
+{
+    static CUDTUnited instance;
+    return &instance;
+}
+
+CUDTUnited& srt::CUDT::uglobal()
+{
+    // We don't want lock each time, pthread_once can be faster than mutex.
+    pthread_once(&s_UDTUnitedOnce, reinterpret_cast<void (*)()>(getInstance));
+    return *getInstance();
+}
+
+#endif
+
+void srt::CUDT::construct()
 {
     m_pSndBuffer           = NULL;
     m_pRcvBuffer           = NULL;
     m_pSndLossList         = NULL;
     m_pRcvLossList         = NULL;
     m_iReorderTolerance    = 0;
-    m_iMaxReorderTolerance = 0; // Sensible optimal value is 10, 0 preserves old behavior
-    m_iConsecEarlyDelivery = 0; // how many times so far the packet considered lost has been received before TTL expires
+    // How many times so far the packet considered lost has been received
+    // before TTL expires.
+    m_iConsecEarlyDelivery   = 0; 
     m_iConsecOrderedDelivery = 0;
 
     m_pSndQueue = NULL;
@@ -140,9 +276,10 @@ void CUDT::construct()
     m_pSNode    = NULL;
     m_pRNode    = NULL;
 
-    m_iSndHsRetryCnt      = SRT_MAX_HSRETRY + 1; // Will be reset to 0 for HSv5, this value is important for HSv4
+    // Will be reset to 0 for HSv5, this value is important for HSv4.
+    m_iSndHsRetryCnt = SRT_MAX_HSRETRY + 1;
 
-    // Initial status
+    m_PeerID              = 0;
     m_bOpened             = false;
     m_bListening          = false;
     m_bConnecting         = false;
@@ -150,179 +287,105 @@ void CUDT::construct()
     m_bClosing            = false;
     m_bShutdown           = false;
     m_bBroken             = false;
-    // XXX m_iBrokenCounter should be still set to some default!
+    m_bBreakAsUnstable    = false;
+    // TODO: m_iBrokenCounter should be still set to some default.
     m_bPeerHealth         = true;
     m_RejectReason        = SRT_REJ_UNKNOWN;
-    m_tsLastReqTime       = steady_clock::time_point();
+    m_tsLastReqTime.store(steady_clock::time_point());
     m_SrtHsSide           = HSD_DRAW;
-
-    m_lSrtVersion            = SRT_DEF_VERSION;
-    m_lPeerSrtVersion        = 0; // not defined until connected.
-    m_lMinimumPeerSrtVersion = SRT_VERSION_MAJ1;
-
-    m_iTsbPdDelay_ms     = 0;
-    m_iPeerTsbPdDelay_ms = 0;
-
-    m_bPeerTsbPd         = false;
-    m_iPeerTsbPdDelay_ms = 0;
-    m_bTsbPd             = false;
-    m_bTsbPdAckWakeup    = false;
-    m_bGroupTsbPd = false;
-    m_bPeerTLPktDrop     = false;
-
-    m_uKmRefreshRatePkt = 0;
-    m_uKmPreAnnouncePkt = 0;
-
-    // Initilize mutex and condition variables
+    m_uPeerSrtVersion     = 0;  // Not defined until connected.
+    m_iTsbPdDelay_ms      = 0;
+    m_iPeerTsbPdDelay_ms  = 0;
+    m_bPeerTsbPd          = false;
+    m_bTsbPd              = false;
+    m_bTsbPdNeedsWakeup   = false;
+    m_bGroupTsbPd         = false;
+    m_bPeerTLPktDrop      = false;
+    m_bBufferWasFull      = false;
+
+    // Initilize mutex and condition variables.
     initSynch();
 
-    // XXX: Unblock, when the callback is implemented
+    // TODO: Uncomment when the callback is implemented.
     // m_cbPacketArrival.set(this, &CUDT::defaultPacketArrival);
 }
 
-CUDT::CUDT(CUDTSocket* parent): m_parent(parent)
+srt::CUDT::CUDT(CUDTSocket* parent)
+    : m_parent(parent)
+#ifdef ENABLE_MAXREXMITBW
+    , m_SndRexmitRate(sync::steady_clock::now())
+#endif
+    , m_iISN(-1)
+    , m_iPeerISN(-1)
 {
     construct();
 
     (void)SRT_DEF_VERSION;
 
-    // Default UDT configurations
-    m_iMSS            = DEF_MSS;
-    m_bSynSending     = true;
-    m_bSynRecving     = true;
-    m_iFlightFlagSize = DEF_FLIGHT_SIZE;
-    m_iSndBufSize     = DEF_BUFFER_SIZE;
-    m_iRcvBufSize     = DEF_BUFFER_SIZE;
-    m_iUDPSndBufSize  = DEF_UDP_BUFFER_SIZE;
-    m_iUDPRcvBufSize  = m_iRcvBufSize * m_iMSS;
-
-    // Linger: LIVE mode defaults, please refer to `SRTO_TRANSTYPE` option
-    // for other modes.
-    m_Linger.l_onoff  = 0;
-    m_Linger.l_linger = 0;
-    m_bRendezvous     = false;
-    m_tdConnTimeOut = seconds_from(DEF_CONNTIMEO_S);
-    m_bDriftTracer = true;
-    m_iSndTimeOut = -1;
-    m_iRcvTimeOut = -1;
-    m_bReuseAddr  = true;
-    m_llMaxBW     = -1;
-    m_iIpTTL = -1;
-    m_iIpToS = -1;
-    m_CryptoSecret.len = 0;
-    m_iSndCryptoKeyLen = 0;
-    // Cfg
-    m_bDataSender           = false; // Sender only if true: does not recv data
-    m_bOPT_TsbPd            = true;  // Enable TsbPd on sender
-    m_iOPT_TsbPdDelay       = SRT_LIVE_DEF_LATENCY_MS;
-    m_iOPT_PeerTsbPdDelay   = 0; // Peer's TsbPd delay as receiver (here is its minimum value, if used)
-    m_bOPT_TLPktDrop        = true;
-    m_iOPT_SndDropDelay     = 0;
-    m_bOPT_StrictEncryption = true;
-    m_iOPT_PeerIdleTimeout  = COMM_RESPONSE_TIMEOUT_MS;
-    m_uOPT_StabilityTimeout = CUDT::COMM_DEF_STABILITY_TIMEOUT_US;
-    m_OPT_GroupConnect      = 0;
-#if ENABLE_EXPERIMENTAL_BONDING
+    // Runtime fields
+#if ENABLE_BONDING
     m_HSGroupType           = SRT_GTYPE_UNDEFINED;
 #endif
-    m_iOPT_RetransmitAlgo       = 0;
     m_bTLPktDrop            = true; // Too-late Packet Drop
-    m_bMessageAPI           = true;
-    m_zOPT_ExpPayloadSize   = SRT_LIVE_DEF_PLSIZE;
-    m_iIpV6Only             = -1;
-    // Runtime
-    m_bRcvNakReport             = true; // Receiver's Periodic NAK Reports
-    m_llInputBW                 = 0;    // Application provided input bandwidth (0: internal input rate sampling)
-    m_iOverheadBW               = 25;   // Percent above input stream rate (applies if m_llMaxBW == 0)
-    m_OPT_PktFilterConfigString = "";
 
     m_pCache = NULL;
+    // This is in order to set it ANY kind of initial value, however
+    // this value should not be used when not connected and should be
+    // updated in the handshake. When this value is 0, it means that
+    // packets shall not be sent, as the other party doesn't have a
+    // room to receive and store it. Therefore this value should be
+    // overridden before any sending happens.
+    m_iFlowWindowSize = 0;
 
-    // Default congctl is "live".
-    // Available builtin congctl: "file".
-    // Other congctls can be registerred.
-
-    // Note that 'select' returns false if there's no such congctl.
-    // If so, congctl becomes unselected. Calling 'configure' on an
-    // unselected congctl results in exception.
-    m_CongCtl.select("live");
 }
 
-CUDT::CUDT(CUDTSocket* parent, const CUDT& ancestor): m_parent(parent)
+srt::CUDT::CUDT(CUDTSocket* parent, const CUDT& ancestor)
+    : m_parent(parent)
+#ifdef ENABLE_MAXREXMITBW
+    , m_SndRexmitRate(sync::steady_clock::now())
+#endif
+    , m_iISN(-1)
+    , m_iPeerISN(-1)
 {
     construct();
 
     // XXX Consider all below fields (except m_bReuseAddr) to be put
     // into a separate class for easier copying.
 
-    // Default UDT configurations
-    m_iMSS            = ancestor.m_iMSS;
-    m_bSynSending     = ancestor.m_bSynSending;
-    m_bSynRecving     = ancestor.m_bSynRecving;
-    m_iFlightFlagSize = ancestor.m_iFlightFlagSize;
-    m_iSndBufSize     = ancestor.m_iSndBufSize;
-    m_iRcvBufSize     = ancestor.m_iRcvBufSize;
-    m_Linger          = ancestor.m_Linger;
-    m_bDriftTracer    = ancestor.m_bDriftTracer;
-    m_iUDPSndBufSize  = ancestor.m_iUDPSndBufSize;
-    m_iUDPRcvBufSize  = ancestor.m_iUDPRcvBufSize;
-    m_bRendezvous     = ancestor.m_bRendezvous;
-    m_SrtHsSide = ancestor.m_SrtHsSide; // actually it sets it to HSD_RESPONDER
-    m_tdConnTimeOut = ancestor.m_tdConnTimeOut;
-    m_iSndTimeOut = ancestor.m_iSndTimeOut;
-    m_iRcvTimeOut = ancestor.m_iRcvTimeOut;
-    m_bReuseAddr  = true; // this must be true, because all accepted sockets share the same port with the listener
-    m_llMaxBW     = ancestor.m_llMaxBW;
-    m_iIpTTL = ancestor.m_iIpTTL;
-    m_iIpToS = ancestor.m_iIpToS;
-    m_llInputBW             = ancestor.m_llInputBW;
-    m_iOverheadBW           = ancestor.m_iOverheadBW;
-    m_bDataSender           = ancestor.m_bDataSender;
-    m_bOPT_TsbPd            = ancestor.m_bOPT_TsbPd;
-    m_iOPT_TsbPdDelay       = ancestor.m_iOPT_TsbPdDelay;
-    m_iOPT_PeerTsbPdDelay   = ancestor.m_iOPT_PeerTsbPdDelay;
-    m_bOPT_TLPktDrop        = ancestor.m_bOPT_TLPktDrop;
-    m_iOPT_SndDropDelay     = ancestor.m_iOPT_SndDropDelay;
-    m_bOPT_StrictEncryption = ancestor.m_bOPT_StrictEncryption;
-    m_iOPT_RetransmitAlgo   = ancestor.m_iOPT_RetransmitAlgo;
-    m_iOPT_PeerIdleTimeout  = ancestor.m_iOPT_PeerIdleTimeout;
-    m_uOPT_StabilityTimeout = ancestor.m_uOPT_StabilityTimeout;
-    m_OPT_GroupConnect      = ancestor.m_OPT_GroupConnect; // NOTE: on single accept set back to 0
-    m_zOPT_ExpPayloadSize   = ancestor.m_zOPT_ExpPayloadSize;
-    m_bTLPktDrop            = ancestor.m_bTLPktDrop;
-    m_bMessageAPI           = ancestor.m_bMessageAPI;
-    m_iIpV6Only             = ancestor.m_iIpV6Only;
-    m_iReorderTolerance     = ancestor.m_iMaxReorderTolerance;  // Initialize with maximum value
-    m_iMaxReorderTolerance  = ancestor.m_iMaxReorderTolerance;
-    // Runtime
-    m_bRcvNakReport             = ancestor.m_bRcvNakReport;
-    m_OPT_PktFilterConfigString = ancestor.m_OPT_PktFilterConfigString;
-
-    m_CryptoSecret     = ancestor.m_CryptoSecret;
-    m_iSndCryptoKeyLen = ancestor.m_iSndCryptoKeyLen;
+    m_config            = ancestor.m_config;
+    // Reset values that shall not be derived to default ones.
+    // These declarations should be consistent with SRTO_R_PRIVATE flag.
+    for (size_t i = 0; i < Size(s_sockopt_action.flags); ++i)
+    {
+        const string* pdef = map_getp(s_sockopt_action.private_default, SRT_SOCKOPT(i));
+        if (pdef)
+        {
+            try
+            {
+                // Ignore errors here - this is a development-time granted
+                // value, not user-provided value.
+                m_config.set(SRT_SOCKOPT(i), pdef->data(), (int) pdef->size());
+            }
+            catch (...)
+            {
+                LOGC(gglog.Error, log << "IPE: failed to set a declared default option!");
+            }
+        }
+    }
 
-    m_uKmRefreshRatePkt = ancestor.m_uKmRefreshRatePkt;
-    m_uKmPreAnnouncePkt = ancestor.m_uKmPreAnnouncePkt;
+    m_SrtHsSide         = ancestor.m_SrtHsSide; // actually it sets it to HSD_RESPONDER
+    m_bTLPktDrop        = ancestor.m_bTLPktDrop;
+    m_iReorderTolerance = m_config.iMaxReorderTolerance;  // Initialize with maximum value
 
+    // Runtime
     m_pCache = ancestor.m_pCache;
-
-    // SrtCongestion's copy constructor copies the selection,
-    // but not the underlying congctl object. After
-    // copy-constructed, the 'configure' must be called on it again.
-    m_CongCtl = ancestor.m_CongCtl;
-
-    m_lSrtVersion = ancestor.m_lSrtVersion;
-    m_lMinimumPeerSrtVersion = ancestor.m_lMinimumPeerSrtVersion;
 }
 
-CUDT::~CUDT()
+srt::CUDT::~CUDT()
 {
     // release mutex/condtion variables
     destroySynch();
 
-    // Wipeout critical data
-    memset(&m_CryptoSecret, 0, sizeof(m_CryptoSecret));
-
     // destroy the data structures
     delete m_pSndBuffer;
     delete m_pRcvBuffer;
@@ -332,26 +395,18 @@ CUDT::~CUDT()
     delete m_pRNode;
 }
 
-extern const SRT_SOCKOPT srt_post_opt_list [SRT_SOCKOPT_NPOST] = {
-    SRTO_SNDSYN,
-    SRTO_RCVSYN,
-    SRTO_LINGER,
-    SRTO_SNDTIMEO,
-    SRTO_RCVTIMEO,
-    SRTO_MAXBW,
-    SRTO_INPUTBW,
-    SRTO_OHEADBW,
-    SRTO_SNDDROPDELAY,
-    SRTO_CONNTIMEO,
-    SRTO_DRIFTTRACER,
-    SRTO_LOSSMAXTTL
-};
-
-void CUDT::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
+void srt::CUDT::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
 {
     if (m_bBroken || m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
+    // Match check (confirm optName as index for s_sockopt_action)
+    if (int(optName) < 0 || int(optName) >= int(SRTO_E_SIZE))
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+    // Restriction check
+    const int oflags = s_sockopt_action.flags[optName];
+
     ScopedLock cg (m_ConnectionLock);
     ScopedLock sendguard (m_SendLock);
     ScopedLock recvguard (m_RecvLock);
@@ -359,774 +414,221 @@ void CUDT::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
     HLOGC(aclog.Debug,
           log << CONID() << "OPTION: #" << optName << " value:" << FormatBinaryString((uint8_t*)optval, optlen));
 
-    switch (optName)
+    if (IsSet(oflags, SRTO_R_PREBIND) && m_bOpened)
+        throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
+
+    if (IsSet(oflags, SRTO_R_PRE) && (m_bConnected || m_bConnecting || m_bListening))
+        throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
+
+    // Option execution. If this returns -1, there's no such option.
+    const int status = m_config.set(optName, optval, optlen);
+    if (status == -1)
     {
-    case SRTO_MSS:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
+        LOGC(aclog.Error, log << CONID() << "OPTION: #" << optName << " UNKNOWN");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
 
-        if (cast_optval<int>(optval, optlen) < int(CPacket::UDP_HDR_SIZE + CHandShake::m_iContentSize))
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    // Post-action, if applicable
+    if (IsSet(oflags, SRTO_POST_SPEC) && m_bConnected)
+    {
+        switch (optName)
+        {
+        case SRTO_MAXBW:
+            updateCC(TEV_INIT, EventVariant(TEV_INIT_RESET));
+            break;
+
+        case SRTO_INPUTBW:
+        case SRTO_MININPUTBW:
+            updateCC(TEV_INIT, EventVariant(TEV_INIT_INPUTBW));
+            break;
+
+        case SRTO_OHEADBW:
+            updateCC(TEV_INIT, EventVariant(TEV_INIT_OHEADBW));
+            break;
+
+        case SRTO_LOSSMAXTTL:
+            m_iReorderTolerance = m_config.iMaxReorderTolerance;
 
-        m_iMSS = cast_optval<int>(optval);
+        default: break;
+        }
+    }
+}
 
-        // Packet size cannot be greater than UDP buffer size
-        if (m_iMSS > m_iUDPSndBufSize)
-            m_iMSS = m_iUDPSndBufSize;
-        if (m_iMSS > m_iUDPRcvBufSize)
-            m_iMSS = m_iUDPRcvBufSize;
+void srt::CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
+{
+    ScopedLock cg(m_ConnectionLock);
 
+    switch (optName)
+    {
+    case SRTO_MSS:
+        *(int *)optval = m_config.iMSS;
+        optlen         = sizeof(int);
         break;
 
     case SRTO_SNDSYN:
-        m_bSynSending = cast_optval<bool>(optval, optlen);
+        *(bool *)optval = m_config.bSynSending;
+        optlen          = sizeof(bool);
         break;
 
     case SRTO_RCVSYN:
-        m_bSynRecving = cast_optval<bool>(optval, optlen);
+        *(bool *)optval = m_config.bSynRecving;
+        optlen          = sizeof(bool);
         break;
 
-    case SRTO_FC:
-        if (m_bConnecting || m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        if (cast_optval<int>(optval, optlen) < 1)
-            throw CUDTException(MJ_NOTSUP, MN_INVAL);
-
-        // Mimimum recv flight flag size is 32 packets
-        if (cast_optval<int>(optval) > 32)
-            m_iFlightFlagSize = *(int *)optval;
-        else
-            m_iFlightFlagSize = 32;
+    case SRTO_ISN:
+        *(int *)optval = m_iISN;
+        optlen         = sizeof(int);
+        break;
 
+    case SRTO_FC:
+        *(int *)optval = m_config.iFlightFlagSize;
+        optlen         = sizeof(int);
         break;
 
+        // For SNDBUF/RCVBUF values take the variant that uses more memory.
+        // It is not possible to make sure what "family" is in use without
+        // checking if the socket is bound. This will also be the exact size
+        // of the memory in use.
     case SRTO_SNDBUF:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        if (cast_optval<int>(optval, optlen) <= 0)
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-        m_iSndBufSize = cast_optval<int>(optval) / (m_iMSS - CPacket::UDP_HDR_SIZE);
-
+        *(int *)optval = m_config.iSndBufSize * m_config.bytesPerPkt();
+        optlen         = sizeof(int);
         break;
 
     case SRTO_RCVBUF:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        {
-            const int val = cast_optval<int>(optval, optlen);
-            if (val <= 0)
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-            // Mimimum recv buffer size is 32 packets
-            const int mssin_size = m_iMSS - CPacket::UDP_HDR_SIZE;
-
-            // XXX This magic 32 deserves some constant
-            if (val > mssin_size * 32)
-                m_iRcvBufSize = val / mssin_size;
-            else
-                m_iRcvBufSize = 32;
-
-            // recv buffer MUST not be greater than FC size
-            if (m_iRcvBufSize > m_iFlightFlagSize)
-                m_iRcvBufSize = m_iFlightFlagSize;
-        }
-
+        *(int *)optval = m_config.iRcvBufSize * m_config.bytesPerPkt();
+        optlen         = sizeof(int);
         break;
 
     case SRTO_LINGER:
-        m_Linger = cast_optval<linger>(optval, optlen);
+        if (optlen < (int)(sizeof(linger)))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        *(linger *)optval = m_config.Linger;
+        optlen            = sizeof(linger);
         break;
 
     case SRTO_UDP_SNDBUF:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_iUDPSndBufSize = cast_optval<int>(optval, optlen);
-
-        if (m_iUDPSndBufSize < m_iMSS)
-            m_iUDPSndBufSize = m_iMSS;
-
+        *(int *)optval = m_config.iUDPSndBufSize;
+        optlen         = sizeof(int);
         break;
 
     case SRTO_UDP_RCVBUF:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_iUDPRcvBufSize = cast_optval<int>(optval, optlen);
-
-        if (m_iUDPRcvBufSize < m_iMSS)
-            m_iUDPRcvBufSize = m_iMSS;
-
+        *(int *)optval = m_config.iUDPRcvBufSize;
+        optlen         = sizeof(int);
         break;
 
     case SRTO_RENDEZVOUS:
-        if (m_bConnecting || m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-        m_bRendezvous = cast_optval<bool>(optval, optlen);
+        *(bool *)optval = m_config.bRendezvous;
+        optlen          = sizeof(bool);
         break;
 
     case SRTO_SNDTIMEO:
-        m_iSndTimeOut = cast_optval<int>(optval, optlen);
+        *(int *)optval = m_config.iSndTimeOut;
+        optlen         = sizeof(int);
         break;
 
     case SRTO_RCVTIMEO:
-        m_iRcvTimeOut = cast_optval<int>(optval, optlen);
+        *(int *)optval = m_config.iRcvTimeOut;
+        optlen         = sizeof(int);
         break;
 
     case SRTO_REUSEADDR:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-        m_bReuseAddr = cast_optval<bool>(optval, optlen);
+        *(bool *)optval = m_config.bReuseAddr;
+        optlen          = sizeof(bool);
         break;
 
     case SRTO_MAXBW:
-        m_llMaxBW = cast_optval<int64_t>(optval, optlen);
-
-        // This can be done on both connected and unconnected socket.
-        // When not connected, this will do nothing, however this
-        // event will be repeated just after connecting anyway.
-        if (m_bConnected)
-            updateCC(TEV_INIT, EventVariant(TEV_INIT_RESET));
-        break;
-
-    case SRTO_IPTTL:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-        if (!(cast_optval<int>(optval, optlen) == -1) && !((cast_optval<int>(optval) >= 1) && (cast_optval<int>(optval) <= 255)))
+        if (size_t(optlen) < sizeof(m_config.llMaxBW))
             throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        m_iIpTTL = cast_optval<int>(optval);
-        break;
-
-    case SRTO_IPTOS:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-        m_iIpToS = cast_optval<int>(optval, optlen);
+        *(int64_t *)optval = m_config.llMaxBW;
+        optlen             = sizeof(int64_t);
         break;
 
-    case SRTO_BINDTODEVICE:
-#ifdef SRT_ENABLE_BINDTODEVICE
-        {
-            string val;
-            if (optlen == -1)
-                val = (const char *)optval;
-            else
-                val.assign((const char *)optval, optlen);
-            if (val.size() >= IFNAMSIZ)
-            {
-                LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE: device name too long (max: IFNAMSIZ=" << IFNAMSIZ << ")");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
+    case SRTO_INPUTBW:
+        if (size_t(optlen) < sizeof(m_config.llInputBW))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+       *(int64_t*)optval = m_config.llInputBW;
+       optlen            = sizeof(int64_t);
+       break;
 
-            m_BindToDevice = val;
-        }
-#else
-        LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE is not supported on that platform");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-#endif
+    case SRTO_MININPUTBW:
+        if (size_t(optlen) < sizeof (m_config.llMinInputBW))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        *(int64_t*)optval = m_config.llMinInputBW;
+        optlen            = sizeof(int64_t);
         break;
 
-    case SRTO_INPUTBW:
-        m_llInputBW = cast_optval<int64_t>(optval, optlen);
-        // (only if connected; if not, then the value
-        // from m_iOverheadBW will be used initially)
-        if (m_bConnected)
-            updateCC(TEV_INIT, EventVariant(TEV_INIT_INPUTBW));
+    case SRTO_OHEADBW:
+        *(int32_t *)optval = m_config.iOverheadBW;
+        optlen = sizeof(int32_t);
         break;
 
-    case SRTO_OHEADBW:
-        if ((cast_optval<int32_t>(optval, optlen) < 5) || (cast_optval<int32_t>(optval) > 100))
+#ifdef ENABLE_MAXREXMITBW
+    case SRTO_MAXREXMITBW:
+        if (size_t(optlen) < sizeof(m_config.llMaxRexmitBW))
             throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        m_iOverheadBW = cast_optval<int32_t>(optval);
-
-        // Changed overhead BW, so spread the change
-        // (only if connected; if not, then the value
-        // from m_iOverheadBW will be used initially)
-        if (m_bConnected)
-            updateCC(TEV_INIT, EventVariant(TEV_INIT_OHEADBW));
+        *(int64_t*)optval = m_config.llMaxRexmitBW;
+        optlen = sizeof(int64_t);
         break;
+#endif
 
-    case SRTO_SENDER:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        m_bDataSender = cast_optval<bool>(optval, optlen);
+    case SRTO_STATE:
+        *(int32_t *)optval = uglobal().getStatus(m_SocketID);
+        optlen             = sizeof(int32_t);
         break;
 
-    case SRTO_TSBPDMODE:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_bOPT_TsbPd = cast_optval<bool>(optval, optlen);
+    case SRTO_EVENT:
+    {
+        int32_t event = 0;
+        if (m_bBroken)
+            event |= SRT_EPOLL_ERR;
+        else
+        {
+            enterCS(m_RecvLock);
+            if (m_pRcvBuffer && isRcvBufferReady())
+                event |= SRT_EPOLL_IN;
+            leaveCS(m_RecvLock);
+            if (m_pSndBuffer && (m_config.iSndBufSize > m_pSndBuffer->getCurrBufSize()))
+                event |= SRT_EPOLL_OUT;
+        }
+        *(int32_t *)optval = event;
+        optlen             = sizeof(int32_t);
         break;
+    }
 
-    case SRTO_LATENCY:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
+    case SRTO_SNDDATA:
+        if (m_pSndBuffer)
+            *(int32_t *)optval = m_pSndBuffer->getCurrBufSize();
+        else
+            *(int32_t *)optval = 0;
+        optlen = sizeof(int32_t);
+        break;
 
-        m_iOPT_TsbPdDelay     = cast_optval<int>(optval, optlen);
-        m_iOPT_PeerTsbPdDelay = cast_optval<int>(optval);
+    case SRTO_RCVDATA:
+        if (m_pRcvBuffer)
+        {
+            enterCS(m_RecvLock);
+            *(int32_t *)optval = m_pRcvBuffer->getRcvDataSize();
+            leaveCS(m_RecvLock);
+        }
+        else
+            *(int32_t *)optval = 0;
+        optlen = sizeof(int32_t);
         break;
 
-    case SRTO_RCVLATENCY:
+    case SRTO_IPTTL:
         if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_iOPT_TsbPdDelay = cast_optval<int>(optval, optlen);
+            *(int32_t *)optval = m_pSndQueue->getIpTTL();
+        else
+            *(int32_t *)optval = m_config.iIpTTL;
+        optlen = sizeof(int32_t);
         break;
 
-    case SRTO_PEERLATENCY:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_iOPT_PeerTsbPdDelay = cast_optval<int>(optval, optlen);
-        break;
-
-    case SRTO_TLPKTDROP:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_bOPT_TLPktDrop = cast_optval<bool>(optval, optlen);
-        break;
-
-    case SRTO_SNDDROPDELAY:
-        // Surprise: you may be connected to alter this option.
-        // The application may manipulate this option on sender while transmitting.
-        m_iOPT_SndDropDelay = cast_optval<int>(optval, optlen);
-        break;
-
-    case SRTO_PASSPHRASE:
-        // For consistency, throw exception when connected,
-        // no matter if otherwise the password can be set.
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-#ifdef SRT_ENABLE_ENCRYPTION
-        // Password must be 10-80 characters.
-        // Or it can be empty to clear the password.
-        if ((optlen != 0) && (optlen < 10 || optlen > HAICRYPT_SECRET_MAX_SZ))
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-        memset(&m_CryptoSecret, 0, sizeof(m_CryptoSecret));
-        m_CryptoSecret.typ = HAICRYPT_SECTYP_PASSPHRASE;
-        m_CryptoSecret.len = (optlen <= (int)sizeof(m_CryptoSecret.str) ? optlen : (int)sizeof(m_CryptoSecret.str));
-        memcpy((m_CryptoSecret.str), optval, m_CryptoSecret.len);
-#else
-        if (optlen == 0)
-            break;
-
-        LOGC(aclog.Error, log << "SRTO_PASSPHRASE: encryption not enabled at compile time");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-#endif
-        break;
-
-    case SRTO_PBKEYLEN:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-#ifdef SRT_ENABLE_ENCRYPTION
-        {
-            const int v    = cast_optval<int>(optval, optlen);
-            int allowed[4] = {
-                0,  // Default value, if this results for initiator, defaults to 16. See below.
-                16, // AES-128
-                24, // AES-192
-                32  // AES-256
-            };
-            int *allowed_end = allowed + 4;
-            if (find(allowed, allowed_end, v) == allowed_end)
-            {
-                LOGC(aclog.Error,
-                     log << "Invalid value for option SRTO_PBKEYLEN: " << v << "; allowed are: 0, 16, 24, 32");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            // Note: This works a little different in HSv4 and HSv5.
-
-            // HSv4:
-            // The party that is set SRTO_SENDER will send KMREQ, and it will
-            // use default value 16, if SRTO_PBKEYLEN is the default value 0.
-            // The responder that receives KMRSP has nothing to say about
-            // PBKEYLEN anyway and it will take the length of the key from
-            // the initiator (sender) as a good deal.
-            //
-            // HSv5:
-            // The initiator (independently on the sender) will send KMREQ,
-            // and as it should be the sender to decide about the PBKEYLEN.
-            // Your application should do the following then:
-            // 1. The sender should set PBKEYLEN to the required value.
-            // 2. If the sender is initiator, it will create the key using
-            //    its preset PBKEYLEN (or default 16, if not set) and the
-            //    receiver-responder will take it as a good deal.
-            // 3. Leave the PBKEYLEN value on the receiver as default 0.
-            // 4. If sender is responder, it should then advertise the PBKEYLEN
-            //    value in the initial handshake messages (URQ_INDUCTION if
-            //    listener, and both URQ_WAVEAHAND and URQ_CONCLUSION in case
-            //    of rendezvous, as it is the matter of luck who of them will
-            //    eventually become the initiator). This way the receiver
-            //    being an initiator will set m_iSndCryptoKeyLen before setting
-            //    up KMREQ for sending to the sender-responder.
-            //
-            // Note that in HSv5 if both sides set PBKEYLEN, the responder
-            // wins, unless the initiator is a sender (the effective PBKEYLEN
-            // will be the one advertised by the responder). If none sets,
-            // PBKEYLEN will default to 16.
-
-            m_iSndCryptoKeyLen = v;
-        }
-#else
-        LOGC(aclog.Error, log << "SRTO_PBKEYLEN: encryption not enabled at compile time");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-#endif
-        break;
-
-    case SRTO_NAKREPORT:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        m_bRcvNakReport = cast_optval<bool>(optval, optlen);
-        break;
-
-    case SRTO_CONNTIMEO:
-        m_tdConnTimeOut = milliseconds_from(cast_optval<int>(optval, optlen));
-        break;
-
-    case SRTO_DRIFTTRACER:
-        m_bDriftTracer = cast_optval<bool>(optval, optlen);
-        break;
-
-    case SRTO_LOSSMAXTTL:
-        m_iMaxReorderTolerance = cast_optval<int>(optval, optlen);
-        if (!m_bConnected)
-            m_iReorderTolerance = m_iMaxReorderTolerance;
-        break;
-
-    case SRTO_VERSION:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        m_lSrtVersion = cast_optval<uint32_t>(optval, optlen);
-        break;
-
-    case SRTO_MINVERSION:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        m_lMinimumPeerSrtVersion = cast_optval<uint32_t>(optval, optlen);
-        break;
-
-    case SRTO_STREAMID:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        if (size_t(optlen) > MAX_SID_LENGTH)
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-        m_sStreamName.assign((const char*)optval, optlen);
-        break;
-
-    case SRTO_CONGESTION:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        {
-            string val;
-            if (optlen == -1)
-                val = (const char*)optval;
-            else
-                val.assign((const char*)optval, optlen);
-
-            // Translate alias
-            if (val == "vod")
-                val = "file";
-
-            bool res = m_CongCtl.select(val);
-            if (!res)
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        }
-        break;
-
-    case SRTO_MESSAGEAPI:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        m_bMessageAPI = cast_optval<bool>(optval, optlen);
-        break;
-
-    case SRTO_PAYLOADSIZE:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        if (*(int *)optval > SRT_LIVE_MAX_PLSIZE)
-        {
-            LOGC(aclog.Error, log << "SRTO_PAYLOADSIZE: value exceeds SRT_LIVE_MAX_PLSIZE, maximum payload per MTU.");
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        }
-
-        if (m_OPT_PktFilterConfigString != "")
-        {
-            // This means that the filter might have been installed before,
-            // and the fix to the maximum payload size was already applied.
-            // This needs to be checked now.
-            SrtFilterConfig fc;
-            if (!ParseFilterConfig(m_OPT_PktFilterConfigString, fc))
-            {
-                // Break silently. This should not happen
-                LOGC(aclog.Error, log << "SRTO_PAYLOADSIZE: IPE: failing filter configuration installed");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            size_t efc_max_payload_size = SRT_LIVE_MAX_PLSIZE - fc.extra_size;
-            if (m_zOPT_ExpPayloadSize > efc_max_payload_size)
-            {
-                LOGC(aclog.Error,
-                     log << "SRTO_PAYLOADSIZE: value exceeds SRT_LIVE_MAX_PLSIZE decreased by " << fc.extra_size
-                         << " required for packet filter header");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-        }
-
-        m_zOPT_ExpPayloadSize = cast_optval<int>(optval, optlen);
-        break;
-
-    case SRTO_TRANSTYPE:
-        if (m_bOpened)
-            throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);
-
-        // XXX Note that here the configuration for SRTT_LIVE
-        // is the same as DEFAULT VALUES for these fields set
-        // in CUDT::CUDT.
-        switch (cast_optval<SRT_TRANSTYPE>(optval, optlen))
-        {
-        case SRTT_LIVE:
-            // Default live options:
-            // - tsbpd: on
-            // - latency: 120ms
-            // - linger: off
-            // - congctl: live
-            // - extraction method: message (reading call extracts one message)
-            m_bOPT_TsbPd          = true;
-            m_iOPT_TsbPdDelay     = SRT_LIVE_DEF_LATENCY_MS;
-            m_iOPT_PeerTsbPdDelay = 0;
-            m_bOPT_TLPktDrop      = true;
-            m_iOPT_SndDropDelay   = 0;
-            m_bMessageAPI         = true;
-            m_bRcvNakReport       = true;
-            m_zOPT_ExpPayloadSize = SRT_LIVE_DEF_PLSIZE;
-            m_Linger.l_onoff      = 0;
-            m_Linger.l_linger     = 0;
-            m_CongCtl.select("live");
-            break;
-
-        case SRTT_FILE:
-            // File transfer mode:
-            // - tsbpd: off
-            // - latency: 0
-            // - linger: 2 minutes (180s)
-            // - congctl: file (original UDT congestion control)
-            // - extraction method: stream (reading call extracts as many bytes as available and fits in buffer)
-            m_bOPT_TsbPd          = false;
-            m_iOPT_TsbPdDelay     = 0;
-            m_iOPT_PeerTsbPdDelay = 0;
-            m_bOPT_TLPktDrop      = false;
-            m_iOPT_SndDropDelay   = -1;
-            m_bMessageAPI         = false;
-            m_bRcvNakReport       = false;
-            m_zOPT_ExpPayloadSize = 0; // use maximum
-            m_Linger.l_onoff      = 1;
-            m_Linger.l_linger     = DEF_LINGER_S;
-            m_CongCtl.select("file");
-            break;
-
-        default:
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        }
-        break;
-
-#if ENABLE_EXPERIMENTAL_BONDING
-    case SRTO_GROUPCONNECT:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        m_OPT_GroupConnect = cast_optval<int>(optval, optlen);
-        break;
-#endif
-
-    case SRTO_KMREFRESHRATE:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        // If you first change the KMREFRESHRATE, KMPREANNOUNCE
-        // will be set to the maximum allowed value
-        m_uKmRefreshRatePkt = cast_optval<int>(optval, optlen);
-        if (m_uKmPreAnnouncePkt == 0 || m_uKmPreAnnouncePkt > (m_uKmRefreshRatePkt - 1) / 2)
-        {
-            m_uKmPreAnnouncePkt = (m_uKmRefreshRatePkt - 1) / 2;
-            LOGC(aclog.Warn,
-                 log << "SRTO_KMREFRESHRATE=0x" << hex << m_uKmRefreshRatePkt << ": setting SRTO_KMPREANNOUNCE=0x"
-                     << hex << m_uKmPreAnnouncePkt);
-        }
-        break;
-
-    case SRTO_KMPREANNOUNCE:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        {
-            const int val = cast_optval<int>(optval, optlen);
-            const int kmref = m_uKmRefreshRatePkt == 0 ? HAICRYPT_DEF_KM_REFRESH_RATE : m_uKmRefreshRatePkt;
-            if (val > (kmref - 1) / 2)
-            {
-                LOGC(aclog.Error,
-                     log << "SRTO_KMPREANNOUNCE=0x" << hex << val << " exceeds KmRefresh/2, 0x" << ((kmref - 1) / 2)
-                         << " - OPTION REJECTED.");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            m_uKmPreAnnouncePkt = val;
-        }
-        break;
-
-    case SRTO_ENFORCEDENCRYPTION:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        m_bOPT_StrictEncryption = cast_optval<bool>(optval, optlen);
-        break;
-
-    case SRTO_PEERIDLETIMEO:
-
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-        m_iOPT_PeerIdleTimeout = cast_optval<int>(optval, optlen);
-        break;
-
-    case SRTO_IPV6ONLY:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        m_iIpV6Only = cast_optval<int>(optval, optlen);
-        break;
-
-    case SRTO_PACKETFILTER:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        {
-            string arg((const char*)optval, optlen);
-            // Parse the configuration string prematurely
-            SrtFilterConfig fc;
-            if (!ParseFilterConfig(arg, fc))
-            {
-                LOGC(aclog.Error,
-                     log << "SRTO_FILTER: Incorrect syntax. Use: FILTERTYPE[,KEY:VALUE...]. "
-                            "FILTERTYPE ("
-                         << fc.type << ") must be installed (or builtin)");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            size_t efc_max_payload_size = SRT_LIVE_MAX_PLSIZE - fc.extra_size;
-            if (m_zOPT_ExpPayloadSize > efc_max_payload_size)
-            {
-                LOGC(aclog.Warn,
-                     log << "Due to filter-required extra " << fc.extra_size << " bytes, SRTO_PAYLOADSIZE fixed to "
-                         << efc_max_payload_size << " bytes");
-                m_zOPT_ExpPayloadSize = efc_max_payload_size;
-            }
-
-            m_OPT_PktFilterConfigString = arg;
-        }
-        break;
-
-#if ENABLE_EXPERIMENTAL_BONDING
-    case SRTO_GROUPSTABTIMEO:
-        {
-            // This option is meaningless for the socket itself.
-            // It's set here just for the sake of setting it on a listener
-            // socket so that it is then applied on the group when a
-            // group connection is configuired.
-            const int val = cast_optval<int>(optval, optlen);
-
-            // Search if you already have SRTO_PEERIDLETIMEO set
-
-            const int idletmo = m_iOPT_PeerIdleTimeout;
-
-            // Both are in milliseconds.
-            // This option is RECORDED in microseconds, while
-            // idletmp is recorded in milliseconds, only translated to
-            // microseconds directly before use.
-            if (val >= idletmo)
-            {
-                LOGC(aclog.Error, log << "group option: SRTO_GROUPSTABTIMEO(" << val
-                        << ") exceeds SRTO_PEERIDLETIMEO(" << idletmo << ")");
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            m_uOPT_StabilityTimeout = val * 1000;
-        }
-        break;
-#endif
-
-    case SRTO_RETRANSMITALGO:
-        if (m_bConnected)
-            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
-
-        m_iOPT_RetransmitAlgo = cast_optval<int32_t>(optval, optlen);
-        break;
-
-    default:
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-    }
-}
-
-void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
-{
-    ScopedLock cg(m_ConnectionLock);
-
-    switch (optName)
-    {
-    case SRTO_MSS:
-        *(int *)optval = m_iMSS;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_SNDSYN:
-        *(bool *)optval = m_bSynSending;
-        optlen          = sizeof(bool);
-        break;
-
-    case SRTO_RCVSYN:
-        *(bool *)optval = m_bSynRecving;
-        optlen          = sizeof(bool);
-        break;
-
-    case SRTO_ISN:
-        *(int *)optval = m_iISN;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_FC:
-        *(int *)optval = m_iFlightFlagSize;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_SNDBUF:
-        *(int *)optval = m_iSndBufSize * (m_iMSS - CPacket::UDP_HDR_SIZE);
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_RCVBUF:
-        *(int *)optval = m_iRcvBufSize * (m_iMSS - CPacket::UDP_HDR_SIZE);
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_LINGER:
-        if (optlen < (int)(sizeof(linger)))
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-        *(linger *)optval = m_Linger;
-        optlen            = sizeof(linger);
-        break;
-
-    case SRTO_UDP_SNDBUF:
-        *(int *)optval = m_iUDPSndBufSize;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_UDP_RCVBUF:
-        *(int *)optval = m_iUDPRcvBufSize;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_RENDEZVOUS:
-        *(bool *)optval = m_bRendezvous;
-        optlen          = sizeof(bool);
-        break;
-
-    case SRTO_SNDTIMEO:
-        *(int *)optval = m_iSndTimeOut;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_RCVTIMEO:
-        *(int *)optval = m_iRcvTimeOut;
-        optlen         = sizeof(int);
-        break;
-
-    case SRTO_REUSEADDR:
-        *(bool *)optval = m_bReuseAddr;
-        optlen          = sizeof(bool);
-        break;
-
-    case SRTO_MAXBW:
-        *(int64_t *)optval = m_llMaxBW;
-        optlen             = sizeof(int64_t);
-        break;
-
-    case SRTO_INPUTBW:
-       *(int64_t*)optval = m_llInputBW;
-       optlen             = sizeof(int64_t);
-       break;
-
-    case SRTO_OHEADBW:
-        *(int32_t *)optval = m_iOverheadBW;
-        optlen = sizeof(int32_t);
-        break;
-
-    case SRTO_STATE:
-        *(int32_t *)optval = s_UDTUnited.getStatus(m_SocketID);
-        optlen             = sizeof(int32_t);
-        break;
-
-    case SRTO_EVENT:
-    {
-        int32_t event = 0;
-        if (m_bBroken)
-            event |= SRT_EPOLL_ERR;
-        else
-        {
-            enterCS(m_RecvLock);
-            if (m_pRcvBuffer && m_pRcvBuffer->isRcvDataReady())
-                event |= SRT_EPOLL_IN;
-            leaveCS(m_RecvLock);
-            if (m_pSndBuffer && (m_iSndBufSize > m_pSndBuffer->getCurrBufSize()))
-                event |= SRT_EPOLL_OUT;
-        }
-        *(int32_t *)optval = event;
-        optlen             = sizeof(int32_t);
-        break;
-    }
-
-    case SRTO_SNDDATA:
-        if (m_pSndBuffer)
-            *(int32_t *)optval = m_pSndBuffer->getCurrBufSize();
-        else
-            *(int32_t *)optval = 0;
-        optlen = sizeof(int32_t);
-        break;
-
-    case SRTO_RCVDATA:
-        if (m_pRcvBuffer)
-        {
-            enterCS(m_RecvLock);
-            *(int32_t *)optval = m_pRcvBuffer->getRcvDataSize();
-            leaveCS(m_RecvLock);
-        }
-        else
-            *(int32_t *)optval = 0;
-        optlen = sizeof(int32_t);
-        break;
-
-    case SRTO_IPTTL:
-        if (m_bOpened)
-            *(int32_t *)optval = m_pSndQueue->getIpTTL();
-        else
-            *(int32_t *)optval = m_iIpTTL;
-        optlen = sizeof(int32_t);
-        break;
-
-    case SRTO_IPTOS:
+    case SRTO_IPTOS:
         if (m_bOpened)
             *(int32_t *)optval = m_pSndQueue->getIpToS();
         else
-            *(int32_t *)optval = m_iIpToS;
+            *(int32_t *)optval = m_config.iIpToS;
         optlen = sizeof(int32_t);
         break;
 
@@ -1142,8 +644,8 @@ void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
         }
 
         // Fallback: return from internal data
-        strcpy(((char*)optval), m_BindToDevice.c_str());
-        optlen = m_BindToDevice.size();
+        optlen = (int)m_config.sBindToDevice.copy((char*)optval, (size_t)optlen - 1);
+        ((char*)optval)[optlen] = '\0';
 #else
         LOGC(smlog.Error, log << "SRTO_BINDTODEVICE is not supported on that platform");
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
@@ -1151,48 +653,59 @@ void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
         break;
 
     case SRTO_SENDER:
-        *(int32_t *)optval = m_bDataSender;
-        optlen             = sizeof(int32_t);
+        *(bool *)optval = m_config.bDataSender;
+        optlen             = sizeof(bool);
         break;
 
     case SRTO_TSBPDMODE:
-        *(int32_t *)optval = m_bOPT_TsbPd;
-        optlen             = sizeof(int32_t);
+        *(bool *)optval = m_config.bTSBPD;
+        optlen             = sizeof(bool);
         break;
 
     case SRTO_LATENCY:
     case SRTO_RCVLATENCY:
-        *(int32_t *)optval = m_iTsbPdDelay_ms;
+        if (m_bConnected)
+            *(int32_t *)optval = m_iTsbPdDelay_ms;
+        else
+            *(int32_t *)optval = m_config.iRcvLatency;
         optlen             = sizeof(int32_t);
         break;
 
     case SRTO_PEERLATENCY:
-        *(int32_t *)optval = m_iPeerTsbPdDelay_ms;
+        if (m_bConnected)
+            *(int32_t *)optval = m_iPeerTsbPdDelay_ms;
+        else
+            *(int32_t *)optval = m_config.iPeerLatency;
+
         optlen             = sizeof(int32_t);
         break;
 
     case SRTO_TLPKTDROP:
-        *(int32_t *)optval = m_bTLPktDrop;
-        optlen             = sizeof(int32_t);
+        if (m_bConnected)
+            *(bool *)optval = m_bTLPktDrop;
+        else
+            *(bool *)optval = m_config.bTLPktDrop;
+
+        optlen          = sizeof(bool);
         break;
 
     case SRTO_SNDDROPDELAY:
-        *(int32_t *)optval = m_iOPT_SndDropDelay;
+        *(int32_t *)optval = m_config.iSndDropDelay;
         optlen             = sizeof(int32_t);
         break;
 
     case SRTO_PBKEYLEN:
         if (m_pCryptoControl)
-            *(int32_t *)optval = m_pCryptoControl->KeyLen(); // Running Key length.
+            *(int32_t *)optval = (int32_t) m_pCryptoControl->KeyLen(); // Running Key length.
         else
-            *(int32_t *)optval = m_iSndCryptoKeyLen; // May be 0.
+            *(int32_t *)optval = m_config.iSndCryptoKeyLen; // May be 0.
         optlen = sizeof(int32_t);
         break;
 
     case SRTO_KMSTATE:
         if (!m_pCryptoControl)
             *(int32_t *)optval = SRT_KM_S_UNSECURED;
-        else if (m_bDataSender)
+        else if (m_config.bDataSender)
             *(int32_t *)optval = m_pCryptoControl->m_SndKmState;
         else
             *(int32_t *)optval = m_pCryptoControl->m_RcvKmState;
@@ -1216,70 +729,85 @@ void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
         break;
 
     case SRTO_LOSSMAXTTL:
-        *(int32_t*)optval = m_iMaxReorderTolerance;
+        *(int32_t*)optval = m_config.iMaxReorderTolerance;
         optlen = sizeof(int32_t);
         break;
 
     case SRTO_NAKREPORT:
-        *(bool *)optval = m_bRcvNakReport;
+        *(bool *)optval = m_config.bRcvNakReport;
         optlen          = sizeof(bool);
         break;
 
     case SRTO_VERSION:
-        *(int32_t *)optval = m_lSrtVersion;
+        *(int32_t *)optval = m_config.uSrtVersion;
         optlen             = sizeof(int32_t);
         break;
 
     case SRTO_PEERVERSION:
-        *(int32_t *)optval = m_lPeerSrtVersion;
+        *(int32_t *)optval = m_uPeerSrtVersion;
         optlen             = sizeof(int32_t);
         break;
 
     case SRTO_CONNTIMEO:
-        *(int*)optval = count_milliseconds(m_tdConnTimeOut);
+        *(int*)optval = (int) count_milliseconds(m_config.tdConnTimeOut);
         optlen        = sizeof(int);
         break;
 
     case SRTO_DRIFTTRACER:
-        *(int*)optval = m_bDriftTracer;
-        optlen        = sizeof(int);
+        *(bool*)optval = m_config.bDriftTracer;
+        optlen         = sizeof(bool);
         break;
 
     case SRTO_MINVERSION:
-        *(uint32_t *)optval = m_lMinimumPeerSrtVersion;
+        *(uint32_t *)optval = m_config.uMinimumPeerSrtVersion;
         optlen              = sizeof(uint32_t);
         break;
 
     case SRTO_STREAMID:
-        if (size_t(optlen) < m_sStreamName.size() + 1)
+        if (size_t(optlen) < m_config.sStreamName.size() + 1)
             throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-        strcpy((char *)optval, m_sStreamName.c_str());
-        optlen = m_sStreamName.size();
+        optlen = (int)m_config.sStreamName.copy((char*)optval, (size_t)optlen - 1);
+        ((char*)optval)[optlen] = '\0';
         break;
 
     case SRTO_CONGESTION:
-    {
-        string tt = m_CongCtl.selected_name();
-        strcpy((char *)optval, tt.c_str());
-        optlen = tt.size();
-    }
-    break;
+        if (size_t(optlen) < m_config.sCongestion.size() + 1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        optlen = (int)m_config.sCongestion.copy((char*)optval, (size_t)optlen - 1);
+        ((char*)optval)[optlen] = '\0';
+        break;
 
     case SRTO_MESSAGEAPI:
         optlen          = sizeof(bool);
-        *(bool *)optval = m_bMessageAPI;
+        *(bool *)optval = m_config.bMessageAPI;
         break;
 
     case SRTO_PAYLOADSIZE:
         optlen         = sizeof(int);
-        *(int *)optval = m_zOPT_ExpPayloadSize;
+        *(int *)optval = (int) payloadSize();
         break;
 
-#if ENABLE_EXPERIMENTAL_BONDING
+    case SRTO_KMREFRESHRATE:
+        optlen = sizeof(int);
+        *(int*)optval = (int)m_config.uKmRefreshRatePkt;
+        break;
+
+    case SRTO_KMPREANNOUNCE:
+        optlen = sizeof(int);
+        *(int*)optval = (int)m_config.uKmPreAnnouncePkt;
+        break;
+
+#if ENABLE_BONDING
     case SRTO_GROUPCONNECT:
-        optlen         = sizeof (int);
-        *(int*)optval = m_OPT_GroupConnect;
+        optlen        = sizeof (int);
+        *(int*)optval = m_config.iGroupConnect;
+        break;
+
+    case SRTO_GROUPMINSTABLETIMEO:
+        optlen = sizeof(int);
+        *(int*)optval = (int)m_config.uMinStabilityTimeout_ms;
         break;
 
     case SRTO_GROUPTYPE:
@@ -1289,110 +817,56 @@ void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)
 #endif
 
     case SRTO_ENFORCEDENCRYPTION:
-        optlen             = sizeof(int32_t); // also with TSBPDMODE and SENDER
-        *(int32_t *)optval = m_bOPT_StrictEncryption;
+        optlen          = sizeof(bool);
+        *(bool *)optval = m_config.bEnforcedEnc;
         break;
 
     case SRTO_IPV6ONLY:
         optlen         = sizeof(int);
-        *(int *)optval = m_iIpV6Only;
+        *(int *)optval = m_config.iIpV6Only;
         break;
 
     case SRTO_PEERIDLETIMEO:
-        *(int *)optval = m_iOPT_PeerIdleTimeout;
+        *(int *)optval = m_config.iPeerIdleTimeout_ms;
         optlen         = sizeof(int);
         break;
 
     case SRTO_PACKETFILTER:
-        if (size_t(optlen) < m_OPT_PktFilterConfigString.size() + 1)
+        if (size_t(optlen) < m_config.sPacketFilterConfig.size() + 1)
             throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-        strcpy((char *)optval, m_OPT_PktFilterConfigString.c_str());
-        optlen = m_OPT_PktFilterConfigString.size();
+        optlen = (int)m_config.sPacketFilterConfig.copy((char*)optval, (size_t)optlen - 1);
+        ((char*)optval)[optlen] = '\0';
         break;
 
     case SRTO_RETRANSMITALGO:
-        *(int32_t *)optval = m_iOPT_RetransmitAlgo;
+        *(int32_t *)optval = m_config.iRetransmitAlgo;
         optlen         = sizeof(int32_t);
         break;
+#ifdef ENABLE_AEAD_API_PREVIEW
+    case SRTO_CRYPTOMODE:
+        if (m_pCryptoControl)
+            *(int32_t*)optval = m_pCryptoControl->getCryptoMode();
+        else
+            *(int32_t*)optval = m_config.iCryptoMode;
+        optlen = sizeof(int32_t);
+        break;
+#endif
 
     default:
         throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
     }
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-bool SRT_SocketOptionObject::add(SRT_SOCKOPT optname, const void* optval, size_t optlen)
-{
-    // Check first if this option is allowed to be set
-    // as on a member socket.
-
-    switch (optname)
-    {
-    case SRTO_BINDTODEVICE:
-    case SRTO_CONNTIMEO:
-    case SRTO_DRIFTTRACER:
-        //SRTO_FC - not allowed to be different among group members
-    case SRTO_GROUPSTABTIMEO:
-        //SRTO_INPUTBW - per transmission setting
-    case SRTO_IPTOS:
-    case SRTO_IPTTL:
-    case SRTO_KMREFRESHRATE:
-    case SRTO_KMPREANNOUNCE:
-        //SRTO_LATENCY - per transmission setting
-        //SRTO_LINGER - not for managed sockets
-    case SRTO_LOSSMAXTTL:
-        //SRTO_MAXBW - per transmission setting
-        //SRTO_MESSAGEAPI - groups are live mode only
-        //SRTO_MINVERSION - per group connection setting
-    case SRTO_NAKREPORT:
-        //SRTO_OHEADBW - per transmission setting
-        //SRTO_PACKETFILTER - per transmission setting
-        //SRTO_PASSPHRASE - per group connection setting
-        //SRTO_PASSPHRASE - per transmission setting
-        //SRTO_PBKEYLEN - per group connection setting
-    case SRTO_PEERIDLETIMEO:
-    case SRTO_RCVBUF:
-        //SRTO_RCVSYN - must be always false in groups
-        //SRTO_RCVTIMEO - must be alwyas -1 in groups
-    case SRTO_SNDBUF:
-    case SRTO_SNDDROPDELAY:
-        //SRTO_TLPKTDROP - per transmission setting
-        //SRTO_TSBPDMODE - per transmission setting
-    case SRTO_UDP_RCVBUF:
-    case SRTO_UDP_SNDBUF:
-        break;
-
-    default:
-        // Other options are not allowed
-        return false;
-
-    }
-
-    // Header size will get the size likely aligned, but it won't
-    // hurt if the memory size will be up to 4 bytes more than
-    // needed - and it's better to not risk that alighment rules
-    // will make these calculations result in less space than needed.
-    const size_t headersize = sizeof(SingleOption);
-    const size_t payload = min(sizeof(uint32_t), optlen);
-    unsigned char* mem = new unsigned char[headersize + payload];
-    SingleOption* option = reinterpret_cast<SingleOption*>(mem);
-    option->option = optname;
-    option->length = optlen;
-    memcpy(option->storage, optval, optlen);
 
-    options.push_back(option);
-
-    return true;
-}
-
-SRT_ERRNO CUDT::applyMemberConfigObject(const SRT_SocketOptionObject& opt)
+#if ENABLE_BONDING
+SRT_ERRNO srt::CUDT::applyMemberConfigObject(const SRT_SocketOptionObject& opt)
 {
     SRT_SOCKOPT this_opt = SRTO_VERSION;
     for (size_t i = 0; i < opt.options.size(); ++i)
     {
         SRT_SocketOptionObject::SingleOption* o = opt.options[i];
-        HLOGC(smlog.Debug, log << "applyMemberConfigObject: OPTION @" << m_SocketID << " #" << o->option);
+        HLOGC(smlog.Debug, log << CONID() << "applyMemberConfigObject: OPTION @" << m_SocketID << " #" << o->option);
         this_opt = SRT_SOCKOPT(o->option);
         setOpt(this_opt, o->storage, o->length);
     }
@@ -1400,41 +874,42 @@ SRT_ERRNO CUDT::applyMemberConfigObject(const SRT_SocketOptionObject& opt)
 }
 #endif
 
-bool CUDT::setstreamid(SRTSOCKET u, const std::string &sid)
+bool srt::CUDT::setstreamid(SRTSOCKET u, const std::string &sid)
 {
     CUDT *that = getUDTHandle(u);
     if (!that)
         return false;
 
-    if (sid.size() > MAX_SID_LENGTH)
+    if (sid.size() > CSrtConfig::MAX_SID_LENGTH)
         return false;
 
     if (that->m_bConnected)
         return false;
 
-    that->m_sStreamName = sid;
+    that->m_config.sStreamName.set(sid);
     return true;
 }
 
-std::string CUDT::getstreamid(SRTSOCKET u)
+string srt::CUDT::getstreamid(SRTSOCKET u)
 {
     CUDT *that = getUDTHandle(u);
     if (!that)
         return "";
 
-    return that->m_sStreamName;
+    return that->m_config.sStreamName.str();
 }
 
 // XXX REFACTOR: Make common code for CUDT constructor and clearData,
 // possibly using CUDT::construct.
-void CUDT::clearData()
+// Initial sequence number, loss, acknowledgement, etc.
+void srt::CUDT::clearData()
 {
-    // Initial sequence number, loss, acknowledgement, etc.
-    int udpsize = m_iMSS - CPacket::UDP_HDR_SIZE;
+    const size_t full_hdr_size = CPacket::UDP_HDR_SIZE - CPacket::HDR_SIZE;
+    m_iMaxSRTPayloadSize = m_config.iMSS - full_hdr_size;
+    HLOGC(cnlog.Debug, log << CONID() << "clearData: PAYLOAD SIZE: " << m_iMaxSRTPayloadSize);
 
-    m_iMaxSRTPayloadSize = udpsize - CPacket::HDR_SIZE;
-
-    HLOGC(cnlog.Debug, log << "clearData: PAYLOAD SIZE: " << m_iMaxSRTPayloadSize);
+    m_SndTimeWindow.initialize(full_hdr_size, m_iMaxSRTPayloadSize);
+    m_RcvTimeWindow.initialize(full_hdr_size, m_iMaxSRTPayloadSize);
 
     m_iEXPCount  = 1;
     m_iBandwidth = 1; // pkts/sec
@@ -1449,49 +924,12 @@ void CUDT::clearData()
         ScopedLock stat_lock(m_StatsLock);
 
         m_stats.tsStartTime = steady_clock::now();
-        m_stats.sentTotal = m_stats.sentUniqTotal = m_stats.recvTotal = m_stats.recvUniqTotal
-            = m_stats.sndLossTotal = m_stats.rcvLossTotal = m_stats.retransTotal
-            = m_stats.sentACKTotal = m_stats.recvACKTotal = m_stats.sentNAKTotal = m_stats.recvNAKTotal = 0;
-        m_stats.tsLastSampleTime = steady_clock::now();
-        m_stats.traceSent = m_stats.traceSentUniq = m_stats.traceRecv = m_stats.traceRecvUniq
-            = m_stats.traceSndLoss = m_stats.traceRcvLoss = m_stats.traceRetrans
-            = m_stats.sentACK = m_stats.recvACK = m_stats.sentNAK = m_stats.recvNAK = 0;
-        m_stats.traceRcvRetrans                                                   = 0;
-        m_stats.traceReorderDistance                                              = 0;
-        m_stats.traceBelatedTime                                                  = 0.0;
-        m_stats.traceRcvBelated                                                   = 0;
-
-        m_stats.sndDropTotal = 0;
-        m_stats.traceSndDrop = 0;
-        m_stats.rcvDropTotal = 0;
-        m_stats.traceRcvDrop = 0;
-
-        m_stats.m_rcvUndecryptTotal = 0;
-        m_stats.traceRcvUndecrypt   = 0;
-
-        m_stats.bytesSentTotal    = 0;
-        m_stats.bytesSentUniqTotal    = 0;
-        m_stats.bytesRecvTotal    = 0;
-        m_stats.bytesRecvUniqTotal    = 0;
-        m_stats.bytesRetransTotal = 0;
-        m_stats.traceBytesSent    = 0;
-        m_stats.traceBytesSentUniq    = 0;
-        m_stats.traceBytesRecv    = 0;
-        m_stats.traceBytesRecvUniq    = 0;
-        m_stats.sndFilterExtra    = 0;
-        m_stats.rcvFilterExtra    = 0;
-        m_stats.rcvFilterSupply   = 0;
-        m_stats.rcvFilterLoss     = 0;
-
-        m_stats.traceBytesRetrans = 0;
-        m_stats.traceRcvBytesLoss = 0;
-        m_stats.sndBytesDropTotal        = 0;
-        m_stats.rcvBytesDropTotal        = 0;
-        m_stats.traceSndBytesDrop        = 0;
-        m_stats.traceRcvBytesDrop        = 0;
-        m_stats.m_rcvBytesUndecryptTotal = 0;
-        m_stats.traceRcvBytesUndecrypt   = 0;
+        m_stats.sndr.reset();
+        m_stats.rcvr.reset();
 
+        m_stats.tsLastSampleTime = steady_clock::now();
+        m_stats.traceReorderDistance = 0;
+        m_stats.traceBelatedTime = 0;
         m_stats.sndDuration = m_stats.m_sndDurationTotal = 0;
     }
 
@@ -1502,21 +940,21 @@ void CUDT::clearData()
     // TSBPD as state should be set to FALSE here.
     // Only when the HSREQ handshake is exchanged,
     // should they be set to possibly true.
-    m_bTsbPd = false;
-    m_bGroupTsbPd = false;
-    m_iTsbPdDelay_ms = m_iOPT_TsbPdDelay;
-    m_bTLPktDrop     = m_bOPT_TLPktDrop;
+    m_bTsbPd         = false;
+    m_bGroupTsbPd    = false;
+    m_iTsbPdDelay_ms = m_config.iRcvLatency;
+    m_bTLPktDrop     = m_config.bTLPktDrop;
     m_bPeerTLPktDrop = false;
 
     m_bPeerNakReport = false;
 
     m_bPeerRexmitFlag = false;
 
-    m_RdvState         = CHandShake::RDV_INVALID;
+    m_RdvState           = CHandShake::RDV_INVALID;
     m_tsRcvPeerStartTime = steady_clock::time_point();
 }
 
-void CUDT::open()
+void srt::CUDT::open()
 {
     ScopedLock cg(m_ConnectionLock);
 
@@ -1536,9 +974,10 @@ void CUDT::open()
     m_pRNode->m_pPrev = m_pRNode->m_pNext = NULL;
     m_pRNode->m_bOnList                   = false;
 
-    m_iRTT    = 10 * COMM_SYN_INTERVAL_US;
-    m_iRTTVar = m_iRTT >> 1;
-
+    // Set initial values of smoothed RTT and RTT variance.
+    m_iSRTT               = INITIAL_RTT;
+    m_iRTTVar             = INITIAL_RTTVAR;
+    m_bIsFirstRTTReceived = false;
 
     // set minimum NAK and EXP timeout to 300ms
     m_tdMinNakInterval = milliseconds_from(300);
@@ -1548,18 +987,22 @@ void CUDT::open()
     m_tdNAKInterval = m_tdMinNakInterval;
 
     const steady_clock::time_point currtime = steady_clock::now();
-    m_tsLastRspTime                        = currtime;
-    m_tsNextACKTime                        = currtime + m_tdACKInterval;
-    m_tsNextNAKTime                        = currtime + m_tdNAKInterval;
-    m_tsLastRspAckTime                     = currtime;
-    m_tsLastSndTime                        = currtime;
+    m_tsLastRspTime.store(currtime);
+    m_tsNextACKTime.store(currtime + m_tdACKInterval);
+    m_tsNextNAKTime.store(currtime + m_tdNAKInterval);
+    m_tsLastRspAckTime = currtime;
+    m_tsLastSndTime.store(currtime);
+
+#if ENABLE_BONDING
+    m_tsUnstableSince   = steady_clock::time_point();
+    m_tsFreshActivation = steady_clock::time_point();
+    m_tsWarySince       = steady_clock::time_point();
+#endif
 
     m_iReXmitCount   = 1;
-    m_tsUnstableSince = steady_clock::time_point();
-    m_tsTmpActiveTime = steady_clock::time_point();
+    memset(&m_aSuppressedMsg, 0, sizeof m_aSuppressedMsg);
     m_iPktCount      = 0;
     m_iLightACKCount = 1;
-
     m_tsNextSendTime = steady_clock::time_point();
     m_tdSendTimeDiff = microseconds_from(0);
 
@@ -1567,7 +1010,7 @@ void CUDT::open()
     m_bOpened = true;
 }
 
-void CUDT::setListenState()
+void srt::CUDT::setListenState()
 {
     ScopedLock cg(m_ConnectionLock);
 
@@ -1588,12 +1031,12 @@ void CUDT::setListenState()
     m_bListening = true;
 }
 
-size_t CUDT::fillSrtHandshake(uint32_t *aw_srtdata, size_t srtlen, int msgtype, int hs_version)
+size_t srt::CUDT::fillSrtHandshake(uint32_t *aw_srtdata, size_t srtlen, int msgtype, int hs_version)
 {
     if (srtlen < SRT_HS_E_SIZE)
     {
         LOGC(cnlog.Fatal,
-             log << "IPE: fillSrtHandshake: buffer too small: " << srtlen << " (expected: " << SRT_HS_E_SIZE << ")");
+             log << CONID() << "IPE: fillSrtHandshake: buffer too small: " << srtlen << " (expected: " << SRT_HS_E_SIZE << ")");
         return 0;
     }
 
@@ -1601,7 +1044,7 @@ size_t CUDT::fillSrtHandshake(uint32_t *aw_srtdata, size_t srtlen, int msgtype,
 
     memset((aw_srtdata), 0, sizeof(uint32_t) * srtlen);
     /* Current version (1.x.x) SRT handshake */
-    aw_srtdata[SRT_HS_VERSION] = m_lSrtVersion; /* Required version */
+    aw_srtdata[SRT_HS_VERSION] = m_config.uSrtVersion; /* Required version */
     aw_srtdata[SRT_HS_FLAGS] |= SrtVersionCapabilities();
 
     switch (msgtype)
@@ -1611,12 +1054,12 @@ size_t CUDT::fillSrtHandshake(uint32_t *aw_srtdata, size_t srtlen, int msgtype,
     case SRT_CMD_HSRSP:
         return fillSrtHandshake_HSRSP((aw_srtdata), srtlen, hs_version);
     default:
-        LOGC(cnlog.Fatal, log << "IPE: fillSrtHandshake/sendSrtMsg called with value " << msgtype);
+        LOGC(cnlog.Fatal, log << CONID() << "IPE: fillSrtHandshake/sendSrtMsg called with value " << msgtype);
         return 0;
     }
 }
 
-size_t CUDT::fillSrtHandshake_HSREQ(uint32_t *aw_srtdata, size_t /* srtlen - unused */, int hs_version)
+size_t srt::CUDT::fillSrtHandshake_HSREQ(uint32_t *aw_srtdata, size_t /* srtlen - unused */, int hs_version)
 {
     // INITIATOR sends HSREQ.
 
@@ -1628,10 +1071,10 @@ size_t CUDT::fillSrtHandshake_HSREQ(uint32_t *aw_srtdata, size_t /* srtlen - unu
     // not set TsbPd mode, it will simply ignore the proposed latency (PeerTsbPdDelay), although
     // if it has received the Rx latency as well, it must honor it and respond accordingly
     // (the latter is only in case of HSv5 and bidirectional connection).
-    if (m_bOPT_TsbPd)
+    if (m_config.bTSBPD)
     {
-        m_iTsbPdDelay_ms     = m_iOPT_TsbPdDelay;
-        m_iPeerTsbPdDelay_ms = m_iOPT_PeerTsbPdDelay;
+        m_iTsbPdDelay_ms     = m_config.iRcvLatency;
+        m_iPeerTsbPdDelay_ms = m_config.iPeerLatency;
         /*
          * Sent data is real-time, use Time-based Packet Delivery,
          * set option bit and configured delay
@@ -1660,7 +1103,7 @@ size_t CUDT::fillSrtHandshake_HSREQ(uint32_t *aw_srtdata, size_t /* srtlen - unu
         }
     }
 
-    if (m_bRcvNakReport)
+    if (m_config.bRcvNakReport)
         aw_srtdata[SRT_HS_FLAGS] |= SRT_OPT_NAKREPORT;
 
     // I support SRT_OPT_REXMITFLG. Do you?
@@ -1668,25 +1111,25 @@ size_t CUDT::fillSrtHandshake_HSREQ(uint32_t *aw_srtdata, size_t /* srtlen - unu
 
     // Declare the API used. The flag is set for "stream" API because
     // the older versions will never set this flag, but all old SRT versions use message API.
-    if (!m_bMessageAPI)
+    if (!m_config.bMessageAPI)
         aw_srtdata[SRT_HS_FLAGS] |= SRT_OPT_STREAM;
 
     HLOGC(cnlog.Debug,
-          log << "HSREQ/snd: LATENCY[SND:" << SRT_HS_LATENCY_SND::unwrap(aw_srtdata[SRT_HS_LATENCY])
+          log << CONID() << "HSREQ/snd: LATENCY[SND:" << SRT_HS_LATENCY_SND::unwrap(aw_srtdata[SRT_HS_LATENCY])
               << " RCV:" << SRT_HS_LATENCY_RCV::unwrap(aw_srtdata[SRT_HS_LATENCY]) << "] FLAGS["
               << SrtFlagString(aw_srtdata[SRT_HS_FLAGS]) << "]");
 
     return 3;
 }
 
-size_t CUDT::fillSrtHandshake_HSRSP(uint32_t *aw_srtdata, size_t /* srtlen - unused */, int hs_version)
+size_t srt::CUDT::fillSrtHandshake_HSRSP(uint32_t *aw_srtdata, size_t /* srtlen - unused */, int hs_version)
 {
     // Setting m_tsRcvPeerStartTime is done in processSrtMsg_HSREQ(), so
     // this condition will be skipped only if this function is called without
     // getting first received HSREQ. Doesn't look possible in both HSv4 and HSv5.
     if (is_zero(m_tsRcvPeerStartTime))
     {
-        LOGC(cnlog.Fatal, log << "IPE: fillSrtHandshake_HSRSP: m_tsRcvPeerStartTime NOT SET!");
+        LOGC(cnlog.Fatal, log << CONID() << "IPE: fillSrtHandshake_HSRSP: m_tsRcvPeerStartTime NOT SET!");
         return 0;
     }
 
@@ -1714,7 +1157,7 @@ size_t CUDT::fillSrtHandshake_HSRSP(uint32_t *aw_srtdata, size_t /* srtlen - unu
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "HSRSP/snd: TSBPD off, NOT responding TSBPDRCV flag.");
+        HLOGC(cnlog.Debug, log << CONID() << "HSRSP/snd: TSBPD off, NOT responding TSBPDRCV flag.");
     }
 
     // Hsv5, only when peer has declared TSBPD mode.
@@ -1727,19 +1170,20 @@ size_t CUDT::fillSrtHandshake_HSRSP(uint32_t *aw_srtdata, size_t /* srtlen - unu
         aw_srtdata[SRT_HS_LATENCY] |= SRT_HS_LATENCY_SND::wrap(m_iPeerTsbPdDelay_ms);
 
         HLOGC(cnlog.Debug,
-              log << "HSRSP/snd: HSv5 peer uses TSBPD, responding TSBPDSND latency=" << m_iPeerTsbPdDelay_ms);
+              log << CONID()
+                  << "HSRSP/snd: HSv5 peer uses TSBPD, responding TSBPDSND latency=" << m_iPeerTsbPdDelay_ms);
     }
     else
     {
         HLOGC(cnlog.Debug,
-              log << "HSRSP/snd: HSv" << (hs_version == CUDT::HS_VERSION_UDT4 ? 4 : 5)
+              log << CONID() << "HSRSP/snd: HSv" << (hs_version == CUDT::HS_VERSION_UDT4 ? 4 : 5)
                   << " with peer TSBPD=" << (m_bPeerTsbPd ? "on" : "off") << " - NOT responding TSBPDSND");
     }
 
     if (m_bTLPktDrop)
         aw_srtdata[SRT_HS_FLAGS] |= SRT_OPT_TLPKTDROP;
 
-    if (m_bRcvNakReport)
+    if (m_config.bRcvNakReport)
     {
         // HSv5: Note that this setting is independent on the value of
         // m_bPeerNakReport, which represent this setting in the peer.
@@ -1753,73 +1197,64 @@ size_t CUDT::fillSrtHandshake_HSRSP(uint32_t *aw_srtdata, size_t /* srtlen - unu
          * Disabling TLPktDrop in the receiver SRT Handshake Reply prevents the sender
          * from enabling Too-Late Packet Drop.
          */
-        if (m_lPeerSrtVersion <= SrtVersion(1, 0, 7))
+        if (m_uPeerSrtVersion <= SrtVersion(1, 0, 7))
             aw_srtdata[SRT_HS_FLAGS] &= ~SRT_OPT_TLPKTDROP;
     }
 
-    if (m_lSrtVersion >= SrtVersion(1, 2, 0))
+    if (m_config.uSrtVersion >= SrtVersion(1, 2, 0))
     {
         if (!m_bPeerRexmitFlag)
         {
             // Peer does not request to use rexmit flag, if so,
             // we won't use as well.
-            HLOGC(cnlog.Debug, log << "HSRSP/snd: AGENT understands REXMIT flag, but PEER DOES NOT. NOT setting.");
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "HSRSP/snd: AGENT understands REXMIT flag, but PEER DOES NOT. NOT setting.");
         }
         else
         {
             // Request that the rexmit bit be used as a part of msgno.
             aw_srtdata[SRT_HS_FLAGS] |= SRT_OPT_REXMITFLG;
-            HLOGF(cnlog.Debug, "HSRSP/snd: AGENT UNDERSTANDS REXMIT flag and PEER reported that it does, too.");
+            HLOGP(cnlog.Debug, "HSRSP/snd: AGENT UNDERSTANDS REXMIT flag and PEER reported that it does, too.");
         }
     }
     else
     {
         // Since this is now in the code, it can occur only in case when you change the
         // version specification in the build configuration.
-        HLOGF(cnlog.Debug, "HSRSP/snd: AGENT DOES NOT UNDERSTAND REXMIT flag");
+        HLOGP(cnlog.Debug, "HSRSP/snd: AGENT DOES NOT UNDERSTAND REXMIT flag");
     }
 
     HLOGC(cnlog.Debug,
-          log << "HSRSP/snd: LATENCY[SND:" << SRT_HS_LATENCY_SND::unwrap(aw_srtdata[SRT_HS_LATENCY])
+          log << CONID() << "HSRSP/snd: LATENCY[SND:" << SRT_HS_LATENCY_SND::unwrap(aw_srtdata[SRT_HS_LATENCY])
               << " RCV:" << SRT_HS_LATENCY_RCV::unwrap(aw_srtdata[SRT_HS_LATENCY]) << "] FLAGS["
               << SrtFlagString(aw_srtdata[SRT_HS_FLAGS]) << "]");
 
     return 3;
 }
 
-size_t CUDT::prepareSrtHsMsg(int cmd, uint32_t *srtdata, size_t size)
+size_t srt::CUDT::prepareSrtHsMsg(int cmd, uint32_t *srtdata, size_t size)
 {
     size_t srtlen = fillSrtHandshake(srtdata, size, cmd, handshakeVersion());
-    HLOGF(cnlog.Debug,
-          "CMD:%s(%d) Len:%d Version: %s Flags: %08X (%s) sdelay:%d",
-          MessageTypeStr(UMSG_EXT, cmd).c_str(),
-          cmd,
-          (int)(srtlen * sizeof(int32_t)),
-          SrtVersionString(srtdata[SRT_HS_VERSION]).c_str(),
-          srtdata[SRT_HS_FLAGS],
-          SrtFlagString(srtdata[SRT_HS_FLAGS]).c_str(),
-          srtdata[SRT_HS_LATENCY]);
+    HLOGC(cnlog.Debug, log << "CMD:" << MessageTypeStr(UMSG_EXT, cmd) << "(" << cmd << ") Len:"
+                           << int(srtlen * sizeof(int32_t))
+                           << " Version: " << SrtVersionString(srtdata[SRT_HS_VERSION])
+                           << " Flags: " << srtdata[SRT_HS_FLAGS]
+                           << " (" << SrtFlagString(srtdata[SRT_HS_FLAGS]) << ") sdelay:"
+                           << srtdata[SRT_HS_LATENCY]);
 
     return srtlen;
 }
 
-void CUDT::sendSrtMsg(int cmd, uint32_t *srtdata_in, int srtlen_in)
+void srt::CUDT::sendSrtMsg(int cmd, uint32_t *srtdata_in, size_t srtlen_in)
 {
     CPacket srtpkt;
     int32_t srtcmd = (int32_t)cmd;
 
-    static const size_t SRTDATA_MAXSIZE = SRT_CMD_MAXSZ / sizeof(int32_t);
+    SRT_STATIC_ASSERT(SRTDATA_MAXSIZE >= SRT_HS_E_SIZE, "SRT_CMD_MAXSZ is too small to hold all the data");
+    // This will be effectively larger than SRT_HS_E_SIZE, but it will be also used for incoming data.
+    uint32_t srtdata[SRTDATA_MAXSIZE];
 
-    // This is in order to issue a compile error if the SRT_CMD_MAXSZ is
-    // too small to keep all the data. As this is "static const", declaring
-    // an array of such specified size in C++ isn't considered VLA.
-    static const int SRTDATA_SIZE = SRTDATA_MAXSIZE >= SRT_HS_E_SIZE ? SRTDATA_MAXSIZE : -1;
-
-    // This will be effectively larger than SRT_HS_E_SIZE, but it will be also used
-    // for incoming data. We have a guarantee that it won't be larger than SRTDATA_MAXSIZE.
-    uint32_t srtdata[SRTDATA_SIZE];
-
-    int srtlen = 0;
+    size_t srtlen = 0;
 
     if (cmd == SRT_CMD_REJECT)
     {
@@ -1833,7 +1268,7 @@ void CUDT::sendSrtMsg(int cmd, uint32_t *srtdata_in, int srtlen_in)
     {
     case SRT_CMD_HSREQ:
     case SRT_CMD_HSRSP:
-        srtlen = prepareSrtHsMsg(cmd, srtdata, SRTDATA_SIZE);
+        srtlen = prepareSrtHsMsg(cmd, srtdata, SRTDATA_MAXSIZE);
         break;
 
     case SRT_CMD_KMREQ: // Sender
@@ -1849,7 +1284,7 @@ void CUDT::sendSrtMsg(int cmd, uint32_t *srtdata_in, int srtlen_in)
         break;
 
     default:
-        LOGF(cnlog.Error, "sndSrtMsg: IPE: cmd=%d unsupported", cmd);
+        LOGC(cnlog.Error, log << "sndSrtMsg: IPE: cmd=" << cmd << " unsupported");
         break;
     }
 
@@ -1861,7 +1296,7 @@ void CUDT::sendSrtMsg(int cmd, uint32_t *srtdata_in, int srtlen_in)
     }
 }
 
-size_t CUDT::fillHsExtConfigString(uint32_t* pcmdspec, int cmd, const string& str)
+size_t srt::CUDT::fillHsExtConfigString(uint32_t* pcmdspec, int cmd, const string& str)
 {
     uint32_t* space = pcmdspec + 1;
     size_t wordsize         = (str.size() + 3) / 4;
@@ -1872,29 +1307,23 @@ size_t CUDT::fillHsExtConfigString(uint32_t* pcmdspec, int cmd, const string& st
     // Preswap to little endian (in place due to possible padding zeros)
     HtoILA((space), space, wordsize);
 
-    *pcmdspec = HS_CMDSPEC_CMD::wrap(cmd) | HS_CMDSPEC_SIZE::wrap(wordsize);
+    *pcmdspec = HS_CMDSPEC_CMD::wrap(cmd) | HS_CMDSPEC_SIZE::wrap((uint32_t) wordsize);
 
     return wordsize;
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 // [[using locked(m_parent->m_ControlLock)]]
 // [[using locked(s_UDTUnited.m_GlobControlLock)]]
-size_t CUDT::fillHsExtGroup(uint32_t* pcmdspec)
+size_t srt::CUDT::fillHsExtGroup(uint32_t* pcmdspec)
 {
-    SRT_ASSERT(m_parent->m_IncludedGroup != NULL);
+    SRT_ASSERT(m_parent->m_GroupOf != NULL);
     uint32_t* space = pcmdspec + 1;
 
-    SRTSOCKET id = m_parent->m_IncludedGroup->id();
-    SRT_GROUP_TYPE tp = m_parent->m_IncludedGroup->type();
+    SRTSOCKET id = m_parent->m_GroupOf->id();
+    SRT_GROUP_TYPE tp = m_parent->m_GroupOf->type();
     uint32_t flags = 0;
 
-    // Note: if agent is a listener, and the current version supports
-    // both sync methods, this flag might have been changed according to
-    // the wish of the caller.
-    if (m_parent->m_IncludedGroup->synconmsgno())
-        flags |= SRT_GFLAG_SYNCONMSG;
-
     // NOTE: this code remains as is for historical reasons.
     // The initial implementation stated that the peer id be
     // extracted so that it can be reported and possibly the
@@ -1902,7 +1331,7 @@ size_t CUDT::fillHsExtGroup(uint32_t* pcmdspec)
     // extension, but it was later seen not necessary. Therefore
     // this code remains, but now it's informational only.
 #if ENABLE_HEAVY_LOGGING
-    m_parent->m_IncludedGroup->debugMasterData(m_SocketID);
+    m_parent->m_GroupOf->debugMasterData(m_SocketID);
 #endif
 
     // See CUDT::interpretGroup()
@@ -1910,7 +1339,7 @@ size_t CUDT::fillHsExtGroup(uint32_t* pcmdspec)
     uint32_t dataword = 0
         | SrtHSRequest::HS_GROUP_TYPE::wrap(tp)
         | SrtHSRequest::HS_GROUP_FLAGS::wrap(flags)
-        | SrtHSRequest::HS_GROUP_WEIGHT::wrap(m_parent->m_IncludedIter->weight);
+        | SrtHSRequest::HS_GROUP_WEIGHT::wrap(m_parent->m_GroupMemberData->weight);
 
     const uint32_t storedata [GRPD_E_SIZE] = { uint32_t(id), dataword };
     memcpy((space), storedata, sizeof storedata);
@@ -1922,7 +1351,7 @@ size_t CUDT::fillHsExtGroup(uint32_t* pcmdspec)
 }
 #endif
 
-size_t CUDT::fillHsExtKMREQ(uint32_t* pcmdspec, size_t ki)
+size_t srt::CUDT::fillHsExtKMREQ(uint32_t* pcmdspec, size_t ki)
 {
     uint32_t* space = pcmdspec + 1;
 
@@ -1932,7 +1361,7 @@ size_t CUDT::fillHsExtKMREQ(uint32_t* pcmdspec, size_t ki)
     size_t ra_size = (msglen / sizeof(uint32_t)) + (msglen % sizeof(uint32_t) ? 1 : 0);
 
     // Store the CMD + SIZE in the next field
-    *pcmdspec = HS_CMDSPEC_CMD::wrap(SRT_CMD_KMREQ) | HS_CMDSPEC_SIZE::wrap(ra_size);
+    *pcmdspec = HS_CMDSPEC_CMD::wrap(SRT_CMD_KMREQ) | HS_CMDSPEC_SIZE::wrap((uint32_t) ra_size);
 
     // Copy the key - do the endian inversion because another endian inversion
     // will be done for every control message before sending, and this KM message
@@ -1940,8 +1369,8 @@ size_t CUDT::fillHsExtKMREQ(uint32_t* pcmdspec, size_t ki)
     const uint32_t* keydata = reinterpret_cast<const uint32_t*>(m_pCryptoControl->getKmMsg_data(ki));
 
     HLOGC(cnlog.Debug,
-            log << "createSrtHandshake: KMREQ: adding key #" << ki << " length=" << ra_size
-            << " words (KmMsg_size=" << msglen << ")");
+          log << CONID() << "createSrtHandshake: KMREQ: adding key #" << ki << " length=" << ra_size
+              << " words (KmMsg_size=" << msglen << ")");
     // XXX INSECURE ": [" << FormatBinaryString((uint8_t*)keydata, msglen) << "]";
 
     // Yes, I know HtoNLA and NtoHLA do exactly the same operation, but I want
@@ -1951,7 +1380,7 @@ size_t CUDT::fillHsExtKMREQ(uint32_t* pcmdspec, size_t ki)
     return ra_size;
 }
 
-size_t CUDT::fillHsExtKMRSP(uint32_t* pcmdspec, const uint32_t* kmdata, size_t kmdata_wordsize)
+size_t srt::CUDT::fillHsExtKMRSP(uint32_t* pcmdspec, const uint32_t* kmdata, size_t kmdata_wordsize)
 {
     uint32_t* space = pcmdspec + 1;
     const uint32_t failure_kmrsp[] = {SRT_KM_S_UNSECURED};
@@ -1964,7 +1393,9 @@ size_t CUDT::fillHsExtKMRSP(uint32_t* pcmdspec, const uint32_t* kmdata, size_t k
 
     if (kmdata_wordsize == 0)
     {
-        LOGC(cnlog.Warn, log << "createSrtHandshake: Agent has PW, but Peer sent no KMREQ. Sending error KMRSP response");
+        LOGC(cnlog.Warn,
+             log << CONID()
+                 << "createSrtHandshake: Agent has PW, but Peer sent no KMREQ. Sending error KMRSP response");
         ra_size = 1;
         keydata = failure_kmrsp;
 
@@ -1977,18 +1408,18 @@ size_t CUDT::fillHsExtKMRSP(uint32_t* pcmdspec, const uint32_t* kmdata, size_t k
         if (!kmdata)
         {
             m_RejectReason = SRT_REJ_IPE;
-            LOGC(cnlog.Fatal, log << "createSrtHandshake: IPE: srtkm_cmd=SRT_CMD_KMRSP and no kmdata!");
-            return false;
+            LOGC(cnlog.Fatal, log << CONID() << "createSrtHandshake: IPE: srtkm_cmd=SRT_CMD_KMRSP and no kmdata!");
+            return 0;
         }
         ra_size = kmdata_wordsize;
         keydata = reinterpret_cast<const uint32_t *>(kmdata);
     }
 
-    *pcmdspec = HS_CMDSPEC_CMD::wrap(SRT_CMD_KMRSP) | HS_CMDSPEC_SIZE::wrap(ra_size);
+    *pcmdspec = HS_CMDSPEC_CMD::wrap(SRT_CMD_KMRSP) | HS_CMDSPEC_SIZE::wrap((uint32_t) ra_size);
     HLOGC(cnlog.Debug,
-            log << "createSrtHandshake: KMRSP: applying returned key length="
-            << ra_size); // XXX INSECURE << " words: [" << FormatBinaryString((uint8_t*)kmdata,
-            // kmdata_wordsize*sizeof(uint32_t)) << "]";
+          log << CONID() << "createSrtHandshake: KMRSP: applying returned key length="
+              << ra_size); // XXX INSECURE << " words: [" << FormatBinaryString((uint8_t*)kmdata,
+                           // kmdata_wordsize*sizeof(uint32_t)) << "]";
 
     NtoHLA((space), keydata, ra_size);
     return ra_size;
@@ -1998,7 +1429,7 @@ size_t CUDT::fillHsExtKMRSP(uint32_t* pcmdspec, const uint32_t* kmdata, size_t k
 // PREREQUISITE:
 // pkt must be set the buffer and configured for UMSG_HANDSHAKE.
 // Note that this function replaces also serialization for the HSv4.
-bool CUDT::createSrtHandshake(
+bool srt::CUDT::createSrtHandshake(
         int             srths_cmd,
         int             srtkm_cmd,
         const uint32_t* kmdata,
@@ -2017,7 +1448,8 @@ bool CUDT::createSrtHandshake(
         if (w_hs.m_extension)
         {
             // Should be impossible
-            LOGC(cnlog.Error, log << "createSrtHandshake: IPE: EXTENSION SET WHEN peer reports version 4 - fixing...");
+            LOGC(cnlog.Error,
+                 log << CONID() << "createSrtHandshake: IPE: EXTENSION SET WHEN peer reports version 4 - fixing...");
             w_hs.m_extension = false;
         }
     }
@@ -2027,9 +1459,9 @@ bool CUDT::createSrtHandshake(
     }
 
     HLOGC(cnlog.Debug,
-          log << "createSrtHandshake: buf size=" << w_pkt.getLength() << " hsx=" << MessageTypeStr(UMSG_EXT, srths_cmd)
-              << " kmx=" << MessageTypeStr(UMSG_EXT, srtkm_cmd) << " kmdata_wordsize=" << kmdata_wordsize
-              << " version=" << w_hs.m_iVersion);
+          log << CONID() << "createSrtHandshake: buf size=" << w_pkt.getLength()
+              << " hsx=" << MessageTypeStr(UMSG_EXT, srths_cmd) << " kmx=" << MessageTypeStr(UMSG_EXT, srtkm_cmd)
+              << " kmdata_wordsize=" << kmdata_wordsize << " version=" << w_hs.m_iVersion);
 
     // Once you are certain that the version is HSv5, set the enc type flags
     // to advertise pbkeylen. Otherwise make sure that the old interpretation
@@ -2045,7 +1477,8 @@ bool CUDT::createSrtHandshake(
         if (w_hs.m_iReqType == URQ_CONCLUSION && srths_cmd == SRT_CMD_HSRSP && is_zero(m_tsRcvPeerStartTime))
         {
             LOGC(cnlog.Error,
-                 log << "createSrtHandshake: IPE (non-fatal): Attempting to craft HSRSP without received HSREQ. "
+                 log << CONID()
+                     << "createSrtHandshake: IPE (non-fatal): Attempting to craft HSRSP without received HSREQ. "
                         "BLOCKING extensions.");
             w_hs.m_extension = false;
         }
@@ -2057,12 +1490,12 @@ bool CUDT::createSrtHandshake(
         //
         // Keep 0 in the SRT_HSTYPE_HSFLAGS field, but still advertise PBKEYLEN
         // in the SRT_HSTYPE_ENCFLAGS field.
-        w_hs.m_iType                  = SrtHSRequest::wrapFlags(false /*no magic in HSFLAGS*/, m_iSndCryptoKeyLen);
+        w_hs.m_iType                  = SrtHSRequest::wrapFlags(false /*no magic in HSFLAGS*/, m_config.iSndCryptoKeyLen);
 
-        IF_HEAVY_LOGGING(bool whether = m_iSndCryptoKeyLen != 0);
+        IF_HEAVY_LOGGING(bool whether = m_config.iSndCryptoKeyLen != 0);
         HLOGC(cnlog.Debug,
-              log << "createSrtHandshake: " << (whether ? "" : "NOT ")
-                  << " Advertising PBKEYLEN - value = " << m_iSndCryptoKeyLen);
+              log << CONID() << "createSrtHandshake: " << (whether ? "" : "NOT ")
+                  << " Advertising PBKEYLEN - value = " << m_config.iSndCryptoKeyLen);
 
         // Note: This is required only when sending a HS message without SRT extensions.
         // When this is to be sent with SRT extensions, then KMREQ will be attached here
@@ -2085,7 +1518,8 @@ bool CUDT::createSrtHandshake(
         size_t hs_size = w_pkt.getLength();
         w_hs.store_to((w_pkt.m_pcData), (hs_size));
         w_pkt.setLength(hs_size);
-        HLOGC(cnlog.Debug, log << "createSrtHandshake: (no ext) size=" << hs_size << " data: " << w_hs.show());
+        HLOGC(cnlog.Debug,
+              log << CONID() << "createSrtHandshake: (no ext) size=" << hs_size << " data: " << w_hs.show());
         return true;
     }
 
@@ -2093,7 +1527,8 @@ bool CUDT::createSrtHandshake(
     if (srths_cmd == SRT_CMD_HSREQ && m_SrtHsSide == HSD_RESPONDER)
     {
         m_RejectReason = SRT_REJ_IPE;
-        LOGC(cnlog.Fatal, log << "IPE: SRT_CMD_HSREQ was requested to be sent in HSv5 by an INITIATOR side!");
+        LOGC(cnlog.Fatal,
+             log << CONID() << "IPE: SRT_CMD_HSREQ was requested to be sent in HSv5 by an INITIATOR side!");
         return false; // should cause rejection
     }
 
@@ -2104,14 +1539,11 @@ bool CUDT::createSrtHandshake(
     w_hs.m_iType |= CHandShake::HS_EXT_HSREQ;
 
     bool have_sid = false;
-    if (srths_cmd == SRT_CMD_HSREQ)
+    if (srths_cmd == SRT_CMD_HSREQ && !m_config.sStreamName.empty())
     {
-        if (m_sStreamName != "")
-        {
-            have_sid = true;
-            w_hs.m_iType |= CHandShake::HS_EXT_CONFIG;
-            logext << ",SID";
-        }
+        have_sid = true;
+        w_hs.m_iType |= CHandShake::HS_EXT_CONFIG;
+        logext << ",SID";
     }
 
     // If this is a response, we have also information
@@ -2124,7 +1556,7 @@ bool CUDT::createSrtHandshake(
         {
             peer_filter_capable = true;
         }
-        else if (IsSet(m_lPeerSrtFlags, SRT_OPT_FILTERCAP))
+        else if (IsSet(m_uPeerSrtFlags, SRT_OPT_FILTERCAP))
         {
             peer_filter_capable = true;
         }
@@ -2143,7 +1575,7 @@ bool CUDT::createSrtHandshake(
     // possibly confronted with the contents of m_OPT_FECConfigString,
     // and if it decided to go with filter, it will be nonempty.
     bool have_filter  = false;
-    if (peer_filter_capable && m_OPT_PktFilterConfigString != "")
+    if (peer_filter_capable && !m_config.sPacketFilterConfig.empty())
     {
         have_filter = true;
         w_hs.m_iType |= CHandShake::HS_EXT_CONFIG;
@@ -2151,7 +1583,7 @@ bool CUDT::createSrtHandshake(
     }
 
     bool have_congctl = false;
-    const string& sm = m_CongCtl.selected_name();
+    const string sm = m_config.sCongestion.str();
     if (sm != "" && sm != "live")
     {
         have_congctl = true;
@@ -2166,14 +1598,14 @@ bool CUDT::createSrtHandshake(
     // KMRSP must be always sent when:
     // - Agent set a password, Peer did not send KMREQ: Agent sets snd=NOSECRET.
     // - Agent set no password, but Peer sent KMREQ: Ageng sets rcv=NOSECRET.
-    if (m_CryptoSecret.len > 0 || kmdata_wordsize > 0)
+    if (m_config.CryptoSecret.len > 0 || kmdata_wordsize > 0)
     {
         have_kmreq = true;
         w_hs.m_iType |= CHandShake::HS_EXT_KMREQ;
         logext << ",KMX";
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     bool have_group = false;
 
     // Note: this is done without locking because we have the following possibilities:
@@ -2193,7 +1625,7 @@ bool CUDT::createSrtHandshake(
     // hurt, even if this field could be dangling in the moment. This will be
     // followed by an additional check, done this time under lock, and there will
     // be no dangling pointers at this time.
-    if (m_parent->m_IncludedGroup)
+    if (m_parent->m_GroupOf)
     {
         // Whatever group this socket belongs to, the information about
         // the group is always sent the same way with the handshake.
@@ -2203,7 +1635,7 @@ bool CUDT::createSrtHandshake(
     }
 #endif
 
-    HLOGC(cnlog.Debug, log << "createSrtHandshake: (ext: " << logext.str() << ") data: " << w_hs.show());
+    HLOGC(cnlog.Debug, log << CONID() << "createSrtHandshake: (ext: " << logext.str() << ") data: " << w_hs.show());
 
     // NOTE: The HSREQ is practically always required, although may happen
     // in future that CONCLUSION can be sent multiple times for a separate
@@ -2230,10 +1662,10 @@ bool CUDT::createSrtHandshake(
     // NOTE: so far, ra_size is m_iMaxSRTPayloadSize expressed in number of elements.
     // WILL BE CHANGED HERE.
     ra_size   = fillSrtHandshake((p + offset), total_ra_size - offset, srths_cmd, HS_VERSION_SRT1);
-    *pcmdspec = HS_CMDSPEC_CMD::wrap(srths_cmd) | HS_CMDSPEC_SIZE::wrap(ra_size);
+    *pcmdspec = HS_CMDSPEC_CMD::wrap(srths_cmd) | HS_CMDSPEC_SIZE::wrap((uint32_t) ra_size);
 
     HLOGC(cnlog.Debug,
-          log << "createSrtHandshake: after HSREQ: offset=" << offset << " HSREQ size=" << ra_size
+          log << CONID() << "createSrtHandshake: after HSREQ: offset=" << offset << " HSREQ size=" << ra_size
               << " space left: " << (total_ra_size - offset));
 
     // Use only in REQ phase and only if stream name is set
@@ -2244,21 +1676,22 @@ bool CUDT::createSrtHandshake(
         // the conclusion packet.
         size_t size_limit = m_iMaxSRTPayloadSize / 2;
 
-        if (m_sStreamName.size() >= size_limit)
+        if (m_config.sStreamName.size() >= size_limit)
         {
             m_RejectReason = SRT_REJ_ROGUE;
             LOGC(cnlog.Warn,
-                 log << "createSrtHandshake: stream id too long, limited to " << (size_limit - 1) << " bytes");
+                 log << CONID() << "createSrtHandshake: stream id too long, limited to " << (size_limit - 1)
+                     << " bytes");
             return false;
         }
 
         offset += ra_size + 1;
-        ra_size = fillHsExtConfigString(p + offset - 1, SRT_CMD_SID, m_sStreamName);
+        ra_size = fillHsExtConfigString(p + offset - 1, SRT_CMD_SID, m_config.sStreamName.str());
 
         HLOGC(cnlog.Debug,
-              log << "createSrtHandshake: after SID [" << m_sStreamName << "] length=" << m_sStreamName.size()
-                  << " alignedln=" << (4*ra_size) << ": offset=" << offset << " SID size=" << ra_size
-                  << " space left: " << (total_ra_size - offset));
+              log << CONID() << "createSrtHandshake: after SID [" << m_config.sStreamName.c_str()
+                  << "] length=" << m_config.sStreamName.size() << " alignedln=" << (4 * ra_size)
+                  << ": offset=" << offset << " SID size=" << ra_size << " space left: " << (total_ra_size - offset));
     }
 
     if (have_congctl)
@@ -2271,23 +1704,23 @@ bool CUDT::createSrtHandshake(
         ra_size = fillHsExtConfigString(p + offset - 1, SRT_CMD_CONGESTION, sm);
 
         HLOGC(cnlog.Debug,
-              log << "createSrtHandshake: after CONGCTL [" << sm << "] length=" << sm.size()
-                  << " alignedln=" << (4*ra_size) << ": offset=" << offset << " CONGCTL size=" << ra_size
+              log << CONID() << "createSrtHandshake: after CONGCTL [" << sm << "] length=" << sm.size()
+                  << " alignedln=" << (4 * ra_size) << ": offset=" << offset << " CONGCTL size=" << ra_size
                   << " space left: " << (total_ra_size - offset));
     }
 
     if (have_filter)
     {
         offset += ra_size + 1;
-        ra_size = fillHsExtConfigString(p + offset - 1, SRT_CMD_FILTER, m_OPT_PktFilterConfigString);
+        ra_size = fillHsExtConfigString(p + offset - 1, SRT_CMD_FILTER, m_config.sPacketFilterConfig.str());
 
         HLOGC(cnlog.Debug,
-              log << "createSrtHandshake: after filter [" << m_OPT_PktFilterConfigString << "] length="
-                  << m_OPT_PktFilterConfigString.size() << " alignedln=" << (4*ra_size) << ": offset=" << offset
-                  << " filter size=" << ra_size << " space left: " << (total_ra_size - offset));
+              log << CONID() << "createSrtHandshake: after filter [" << m_config.sPacketFilterConfig.c_str()
+                  << "] length=" << m_config.sPacketFilterConfig.size() << " alignedln=" << (4 * ra_size) << ": offset="
+                  << offset << " filter size=" << ra_size << " space left: " << (total_ra_size - offset));
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // Note that this will fire in both cases:
     // - When the group has been set by the user on a socket (or socket was created as a part of the group),
     //   and the handshake request is to be sent with informing the peer that this conenction belongs to a group
@@ -2301,30 +1734,30 @@ bool CUDT::createSrtHandshake(
     if (have_group)
     {
         // NOTE: See information about mutex ordering in api.h
-        ScopedLock grd (m_parent->m_ControlLock); // Required to make sure 
-        ScopedLock gdrg (s_UDTUnited.m_GlobControlLock);
-        if (!m_parent->m_IncludedGroup)
+        ScopedLock gdrg (uglobal().m_GlobControlLock);
+        if (!m_parent->m_GroupOf)
         {
-            // This may only happen if since last check of m_IncludedGroup pointer the socket was removed
+            // This may only happen if since last check of m_GroupOf pointer the socket was removed
             // from the group in the meantime, which can only happen due to that the group was closed.
             // In such a case it simply means that the handshake process was requested to be interrupted.
-            LOGC(cnlog.Fatal, log << "GROUP DISAPPEARED. Socket not capable of continuing HS");
+            LOGC(cnlog.Fatal, log << CONID() << "GROUP DISAPPEARED. Socket not capable of continuing HS");
             return false;
         }
         else
         {
-            if (m_parent->m_IncludedGroup->closing())
+            if (m_parent->m_GroupOf->closing())
             {
                 m_RejectReason = SRT_REJ_IPE;
-                LOGC(cnlog.Error, log << "createSrtHandshake: group is closing during the process, rejecting.");
+                LOGC(cnlog.Error,
+                     log << CONID() << "createSrtHandshake: group is closing during the process, rejecting.");
                 return false;
-
             }
             offset += ra_size + 1;
             ra_size = fillHsExtGroup(p + offset - 1);
 
-            HLOGC(cnlog.Debug, log << "createSrtHandshake: after GROUP [" << sm << "] length=" << sm.size()
-                    << ": offset=" << offset << " GROUP size=" << ra_size << " space left: " << (total_ra_size - offset));
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "createSrtHandshake: after GROUP [" << sm << "] length=" << sm.size() << ": offset="
+                      << offset << " GROUP size=" << ra_size << " space left: " << (total_ra_size - offset));
         }
     }
 #endif
@@ -2333,8 +1766,19 @@ bool CUDT::createSrtHandshake(
     if (have_kmreq)
     {
         HLOGC(cnlog.Debug,
-              log << "createSrtHandshake: "
-                  << (m_CryptoSecret.len > 0 ? "Agent uses ENCRYPTION" : "Peer requires ENCRYPTION"));
+              log << CONID() << "createSrtHandshake: "
+                  << (m_config.CryptoSecret.len > 0 ? "Agent uses ENCRYPTION" : "Peer requires ENCRYPTION"));
+
+        if (!m_pCryptoControl && (srtkm_cmd == SRT_CMD_KMREQ || srtkm_cmd == SRT_CMD_KMRSP))
+        {
+            m_RejectReason = SRT_REJ_IPE;
+            LOGC(cnlog.Error,
+                 log << CONID() << "createSrtHandshake: IPE: need to send KM, but CryptoControl does not exist."
+                     << " Socket state: connected=" << boolalpha << m_bConnected << ", connecting=" << m_bConnecting
+                     << ", broken=" << m_bBroken << ", closing=" << m_bClosing << ".");
+            return false;
+        }
+
         if (srtkm_cmd == SRT_CMD_KMREQ)
         {
             bool have_any_keys = false;
@@ -2355,7 +1799,7 @@ bool CUDT::createSrtHandshake(
             if (!have_any_keys)
             {
                 m_RejectReason = SRT_REJ_IPE;
-                LOGC(cnlog.Error, log << "createSrtHandshake: IPE: all keys have expired, no KM to send.");
+                LOGC(cnlog.Error, log << CONID() << "createSrtHandshake: IPE: all keys have expired, no KM to send.");
                 return false;
             }
         }
@@ -2363,23 +1807,28 @@ bool CUDT::createSrtHandshake(
         {
             offset += ra_size + 1;
             ra_size = fillHsExtKMRSP(p + offset - 1, kmdata, kmdata_wordsize);
-
         }
         else
         {
             m_RejectReason = SRT_REJ_IPE;
-            LOGC(cnlog.Fatal, log << "createSrtHandshake: IPE: wrong value of srtkm_cmd: " << srtkm_cmd);
+            LOGC(cnlog.Fatal, log << CONID() << "createSrtHandshake: IPE: wrong value of srtkm_cmd: " << srtkm_cmd);
             return false;
         }
     }
 
+    if (ra_size == 0)
+    {
+        // m_RejectReason is expected to be set by fillHsExtKMRSP(..) in this case.
+        return false;
+    }
+
     // ra_size + offset has a value in element unit.
     // Switch it again to byte unit.
     w_pkt.setLength((ra_size + offset) * sizeof(int32_t));
 
     HLOGC(cnlog.Debug,
-          log << "createSrtHandshake: filled HSv5 handshake flags: " << CHandShake::ExtensionFlagStr(w_hs.m_iType)
-              << " length: " << w_pkt.getLength() << " bytes");
+          log << CONID() << "createSrtHandshake: filled HSv5 handshake flags: "
+              << CHandShake::ExtensionFlagStr(w_hs.m_iType) << " length: " << w_pkt.getLength() << " bytes");
 
     return true;
 }
@@ -2473,17 +1922,86 @@ void SrtExtractHandshakeExtensions(const char* bufbegin, size_t buflength,
     }
 }
 
+#if SRT_DEBUG_RTT
+class RttTracer
+{
+public:
+    RttTracer()
+    {
+    }
+
+    ~RttTracer()
+    {
+        srt::sync::ScopedLock lck(m_mtx);
+        m_fout.close();
+    }
+
+    void trace(const srt::sync::steady_clock::time_point& currtime,
+               const std::string& event, int rtt_sample, int rttvar_sample,
+               bool is_smoothed_rtt_reset, int64_t recvTotal,
+               int smoothed_rtt, int rttvar)
+    {
+        srt::sync::ScopedLock lck(m_mtx);
+        create_file();
+        
+        m_fout << srt::sync::FormatTimeSys(currtime) << ",";
+        m_fout << srt::sync::FormatTime(currtime) << ",";
+        m_fout << event << ",";
+        m_fout << rtt_sample << ",";
+        m_fout << rttvar_sample << ",";
+        m_fout << is_smoothed_rtt_reset << ",";
+        m_fout << recvTotal << ",";
+        m_fout << smoothed_rtt << ",";
+        m_fout << rttvar << "\n";
+        m_fout.flush();
+    }
+
+private:
+    void print_header()
+    {
+        m_fout << "Timepoint_SYST,Timepoint_STDY,Event,usRTTSample,"
+                  "usRTTVarSample,IsSmoothedRTTReset,pktsRecvTotal,"
+                  "usSmoothedRTT,usRTTVar\n";
+    }
+
+    void create_file()
+    {
+        if (m_fout.is_open())
+            return;
+
+        std::string str_tnow = srt::sync::FormatTimeSys(srt::sync::steady_clock::now());
+        str_tnow.resize(str_tnow.size() - 7); // remove trailing ' [SYST]' part
+        while (str_tnow.find(':') != std::string::npos) {
+            str_tnow.replace(str_tnow.find(':'), 1, 1, '_');
+        }
+        const std::string fname = "rtt_trace_" + str_tnow + "_" + SRT_SYNC_CLOCK_STR + ".csv";
+        m_fout.open(fname, std::ofstream::out);
+        if (!m_fout)
+            std::cerr << "IPE: Failed to open " << fname << "!!!\n";
+
+        print_header();
+    }
+
+private:
+    srt::sync::Mutex m_mtx;
+    std::ofstream m_fout;
+};
+
+RttTracer s_rtt_trace;
+#endif
+
 
-bool CUDT::processSrtMsg(const CPacket *ctrlpkt)
+bool srt::CUDT::processSrtMsg(const CPacket *ctrlpkt)
 {
     uint32_t *srtdata = (uint32_t *)ctrlpkt->m_pcData;
     size_t    len     = ctrlpkt->getLength();
     int       etype   = ctrlpkt->getExtendedType();
-    uint32_t  ts      = ctrlpkt->m_iTimeStamp;
+    uint32_t  ts      = ctrlpkt->timestamp();
 
     int res = SRT_CMD_NONE;
 
-    HLOGC(cnlog.Debug, log << "Dispatching message type=" << etype << " data length=" << (len / sizeof(int32_t)));
+    HLOGC(cnlog.Debug,
+          log << CONID() << "Dispatching message type=" << etype << " data length=" << (len / sizeof(int32_t)));
     switch (etype)
     {
     case SRT_CMD_HSREQ:
@@ -2503,26 +2021,27 @@ bool CUDT::processSrtMsg(const CPacket *ctrlpkt)
         {
             uint32_t srtdata_out[SRTDATA_MAXSIZE];
             size_t   len_out = 0;
-            res = m_pCryptoControl->processSrtMsg_KMREQ(srtdata, len, CUDT::HS_VERSION_UDT4,
+            res = m_pCryptoControl->processSrtMsg_KMREQ(srtdata, len, CUDT::HS_VERSION_UDT4, m_uPeerSrtVersion,
                     (srtdata_out), (len_out));
             if (res == SRT_CMD_KMRSP)
             {
                 if (len_out == 1)
                 {
-                    if (m_bOPT_StrictEncryption)
+                    if (m_config.bEnforcedEnc)
                     {
                         LOGC(cnlog.Warn,
-                             log << "KMREQ FAILURE: " << KmStateStr(SRT_KM_STATE(srtdata_out[0]))
+                             log << CONID() << "KMREQ FAILURE: " << KmStateStr(SRT_KM_STATE(srtdata_out[0]))
                                  << " - rejecting per enforced encryption");
                         res = SRT_CMD_NONE;
                         break;
                     }
                     HLOGC(cnlog.Debug,
-                          log << "MKREQ -> KMRSP FAILURE state: " << KmStateStr(SRT_KM_STATE(srtdata_out[0])));
+                          log << CONID()
+                              << "MKREQ -> KMRSP FAILURE state: " << KmStateStr(SRT_KM_STATE(srtdata_out[0])));
                 }
                 else
                 {
-                    HLOGC(cnlog.Debug, log << "KMREQ -> requested to send KMRSP length=" << len_out);
+                    HLOGC(cnlog.Debug, log << CONID() << "KMREQ -> requested to send KMRSP length=" << len_out);
                 }
                 sendSrtMsg(SRT_CMD_KMRSP, srtdata_out, len_out);
             }
@@ -2530,7 +2049,7 @@ bool CUDT::processSrtMsg(const CPacket *ctrlpkt)
             // Please review later.
             else
             {
-                LOGC(cnlog.Warn, log << "KMREQ failed to process the request - ignoring");
+                LOGC(cnlog.Warn, log << CONID() << "KMREQ failed to process the request - ignoring");
             }
 
             return true; // already done what's necessary
@@ -2539,7 +2058,7 @@ bool CUDT::processSrtMsg(const CPacket *ctrlpkt)
     case SRT_CMD_KMRSP:
     {
         // KMRSP doesn't expect any following action
-        m_pCryptoControl->processSrtMsg_KMRSP(srtdata, len, CUDT::HS_VERSION_UDT4);
+        m_pCryptoControl->processSrtMsg_KMRSP(srtdata, len, m_uPeerSrtVersion);
         return true; // nothing to do
     }
 
@@ -2556,7 +2075,7 @@ bool CUDT::processSrtMsg(const CPacket *ctrlpkt)
     return true;
 }
 
-int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t ts, int hsv)
+int srt::CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t ts, int hsv)
 {
     // Set this start time in the beginning, regardless as to whether TSBPD is being
     // used or not. This must be done in the Initiator as well as Responder.
@@ -2572,81 +2091,79 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
 
     // Prepare the initial runtime values of latency basing on the option values.
     // They are going to get the value fixed HERE.
-    m_iTsbPdDelay_ms     = m_iOPT_TsbPdDelay;
-    m_iPeerTsbPdDelay_ms = m_iOPT_PeerTsbPdDelay;
+    m_iTsbPdDelay_ms     = m_config.iRcvLatency;
+    m_iPeerTsbPdDelay_ms = m_config.iPeerLatency;
 
     if (bytelen < SRT_CMD_HSREQ_MINSZ)
     {
         m_RejectReason = SRT_REJ_ROGUE;
         /* Packet smaller than minimum compatible packet size */
-        LOGF(cnlog.Error, "HSREQ/rcv: cmd=%d(HSREQ) len=%" PRIzu " invalid", SRT_CMD_HSREQ, bytelen);
+        LOGC(cnlog.Error, log << "HSREQ/rcv: cmd=" << SRT_CMD_HSREQ << "(HSREQ) len=" << bytelen << " invalid");
         return SRT_CMD_NONE;
     }
 
-    LOGF(cnlog.Note,
-         "HSREQ/rcv: cmd=%d(HSREQ) len=%" PRIzu " vers=0x%x opts=0x%x delay=%d",
-         SRT_CMD_HSREQ,
-         bytelen,
-         srtdata[SRT_HS_VERSION],
-         srtdata[SRT_HS_FLAGS],
-         SRT_HS_LATENCY_RCV::unwrap(srtdata[SRT_HS_LATENCY]));
+    LOGC(cnlog.Debug, log << "HSREQ/rcv: cmd=" << SRT_CMD_HSREQ << "(HSREQ) len=" << bytelen
+                          << hex << " vers=0x" << srtdata[SRT_HS_VERSION] << " opts=0x" << srtdata[SRT_HS_FLAGS]
+                          << dec << " delay=" << SRT_HS_LATENCY_RCV::unwrap(srtdata[SRT_HS_LATENCY]));
 
-    m_lPeerSrtVersion = srtdata[SRT_HS_VERSION];
-    m_lPeerSrtFlags   = srtdata[SRT_HS_FLAGS];
+    m_uPeerSrtVersion = srtdata[SRT_HS_VERSION];
+    m_uPeerSrtFlags   = srtdata[SRT_HS_FLAGS];
 
     if (hsv == CUDT::HS_VERSION_UDT4)
     {
-        if (m_lPeerSrtVersion >= SRT_VERSION_FEAT_HSv5)
+        if (m_uPeerSrtVersion >= SRT_VERSION_FEAT_HSv5)
         {
             m_RejectReason = SRT_REJ_ROGUE;
             LOGC(cnlog.Error,
-                 log << "HSREQ/rcv: With HSv4 version >= " << SrtVersionString(SRT_VERSION_FEAT_HSv5)
+                 log << CONID() << "HSREQ/rcv: With HSv4 version >= " << SrtVersionString(SRT_VERSION_FEAT_HSv5)
                      << " is not acceptable.");
             return SRT_CMD_REJECT;
         }
     }
     else
     {
-        if (m_lPeerSrtVersion < SRT_VERSION_FEAT_HSv5)
+        if (m_uPeerSrtVersion < SRT_VERSION_FEAT_HSv5)
         {
             m_RejectReason = SRT_REJ_ROGUE;
             LOGC(cnlog.Error,
-                 log << "HSREQ/rcv: With HSv5 version must be >= " << SrtVersionString(SRT_VERSION_FEAT_HSv5) << " .");
+                 log << CONID() << "HSREQ/rcv: With HSv5 version must be >= " << SrtVersionString(SRT_VERSION_FEAT_HSv5)
+                     << " .");
             return SRT_CMD_REJECT;
         }
     }
 
     // Check also if the version satisfies the minimum required version
-    if (m_lPeerSrtVersion < m_lMinimumPeerSrtVersion)
+    if (m_uPeerSrtVersion < m_config.uMinimumPeerSrtVersion)
     {
         m_RejectReason = SRT_REJ_VERSION;
         LOGC(cnlog.Error,
-             log << "HSREQ/rcv: Peer version: " << SrtVersionString(m_lPeerSrtVersion)
-                 << " is too old for requested: " << SrtVersionString(m_lMinimumPeerSrtVersion) << " - REJECTING");
+             log << CONID() << "HSREQ/rcv: Peer version: " << SrtVersionString(m_uPeerSrtVersion)
+                 << " is too old for requested: " << SrtVersionString(m_config.uMinimumPeerSrtVersion)
+                 << " - REJECTING");
         return SRT_CMD_REJECT;
     }
 
     HLOGC(cnlog.Debug,
-          log << "HSREQ/rcv: PEER Version: " << SrtVersionString(m_lPeerSrtVersion) << " Flags: " << m_lPeerSrtFlags
-              << "(" << SrtFlagString(m_lPeerSrtFlags) << ") Min req version:" << SrtVersionString(m_lMinimumPeerSrtVersion));
+          log << CONID() << "HSREQ/rcv: PEER Version: " << SrtVersionString(m_uPeerSrtVersion)
+              << " Flags: " << m_uPeerSrtFlags << "(" << SrtFlagString(m_uPeerSrtFlags)
+              << ") Min req version:" << SrtVersionString(m_config.uMinimumPeerSrtVersion));
 
-    m_bPeerRexmitFlag = IsSet(m_lPeerSrtFlags, SRT_OPT_REXMITFLG);
-    HLOGF(cnlog.Debug, "HSREQ/rcv: peer %s REXMIT flag", m_bPeerRexmitFlag ? "UNDERSTANDS" : "DOES NOT UNDERSTAND");
+    m_bPeerRexmitFlag = IsSet(m_uPeerSrtFlags, SRT_OPT_REXMITFLG);
+    HLOGC(cnlog.Debug, log << CONID() << "HSREQ/rcv: peer " << (m_bPeerRexmitFlag ? "UNDERSTANDS" : "DOES NOT UNDERSTAND") << " REXMIT flag");
 
     // Check if both use the same API type. Reject if not.
-    bool peer_message_api = !IsSet(m_lPeerSrtFlags, SRT_OPT_STREAM);
-    if (peer_message_api != m_bMessageAPI)
+    bool peer_message_api = !IsSet(m_uPeerSrtFlags, SRT_OPT_STREAM);
+    if (peer_message_api != m_config.bMessageAPI)
     {
         m_RejectReason = SRT_REJ_MESSAGEAPI;
         LOGC(cnlog.Error,
-             log << "HSREQ/rcv: Agent uses " << (m_bMessageAPI ? "MESSAGE" : "STREAM") << " API, but the Peer declares "
-                 << (peer_message_api ? "MESSAGE" : "STREAM") << " API. Not compatible transmission type, rejecting.");
+             log << CONID() << "HSREQ/rcv: Agent uses " << (m_config.bMessageAPI ? "MESSAGE" : "STREAM")
+                 << " API, but the Peer declares " << (peer_message_api ? "MESSAGE" : "STREAM")
+                 << " API. Not compatible transmission type, rejecting.");
         return SRT_CMD_REJECT;
     }
 
-#if HAVE_CXX11
-    static_assert(SRT_HS_E_SIZE == SRT_HS_LATENCY + 1, "Assuming latency is the last field");
-#endif
+    SRT_STATIC_ASSERT(SRT_HS_E_SIZE == SRT_HS_LATENCY + 1, "Assuming latency is the last field");
     if (bytelen < (SRT_HS_E_SIZE * sizeof(uint32_t)))
     {
         // Handshake extension message includes VERSION, FLAGS and LATENCY
@@ -2662,15 +2179,17 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         // |      Receiver TSBPD Delay     |       Sender TSBPD Delay      |
         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDSND) || IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDRCV))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDSND) || IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDRCV))
         {
             m_RejectReason = SRT_REJ_ROGUE;
             LOGC(cnlog.Error,
-                 log << "HSREQ/rcv: Peer sent only VERSION + FLAGS HSREQ, but TSBPD flags are set. Rejecting.");
+                 log << CONID()
+                     << "HSREQ/rcv: Peer sent only VERSION + FLAGS HSREQ, but TSBPD flags are set. Rejecting.");
             return SRT_CMD_REJECT;
         }
 
-        LOGC(cnlog.Warn, log << "HSREQ/rcv: Peer sent only VERSION + FLAGS HSREQ, not getting any TSBPD settings.");
+        LOGC(cnlog.Warn,
+             log << CONID() << "HSREQ/rcv: Peer sent only VERSION + FLAGS HSREQ, not getting any TSBPD settings.");
         // Don't process any further settings in this case. Turn off TSBPD, just for a case.
         m_bTsbPd     = false;
         m_bPeerTsbPd = false;
@@ -2679,12 +2198,13 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
 
     const uint32_t latencystr = srtdata[SRT_HS_LATENCY];
 
-    if (IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDSND))
+    if (IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDSND))
     {
         // TimeStamp-based Packet Delivery feature enabled
         if (!isOPT_TsbPd())
         {
-            LOGC(cnlog.Warn, log << "HSREQ/rcv: Agent did not set rcv-TSBPD - ignoring proposed latency from peer");
+            LOGC(cnlog.Warn,
+                 log << CONID() << "HSREQ/rcv: Agent did not set rcv-TSBPD - ignoring proposed latency from peer");
 
             // Note: also don't set the peer TSBPD flag HERE because
             // - in HSv4 it will be a sender, so it doesn't matter anyway
@@ -2712,8 +2232,8 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
             // "proposed" by the peer.
             int maxdelay = std::max(m_iTsbPdDelay_ms, peer_decl_latency);
             HLOGC(cnlog.Debug,
-                  log << "HSREQ/rcv: LOCAL/RCV LATENCY: Agent:" << m_iTsbPdDelay_ms << " Peer:" << peer_decl_latency
-                      << "  Selecting:" << maxdelay);
+                  log << CONID() << "HSREQ/rcv: LOCAL/RCV LATENCY: Agent:" << m_iTsbPdDelay_ms
+                      << " Peer:" << peer_decl_latency << "  Selecting:" << maxdelay);
             m_iTsbPdDelay_ms = maxdelay;
             m_bTsbPd = true;
         }
@@ -2721,14 +2241,14 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
     else
     {
         std::string how_about_agent = isOPT_TsbPd() ? "BUT AGENT DOES" : "and nor does Agent";
-        HLOGC(cnlog.Debug, log << "HSREQ/rcv: Peer DOES NOT USE latency for sending - " << how_about_agent);
+        HLOGC(cnlog.Debug, log << CONID() << "HSREQ/rcv: Peer DOES NOT USE latency for sending - " << how_about_agent);
     }
 
     // This happens when the HSv5 RESPONDER receives the HSREQ message; it declares
     // that the peer INITIATOR will receive the data and informs about its predefined
     // latency. We need to maximize this with our setting of the peer's latency and
     // record as peer's latency, which will be then sent back with HSRSP.
-    if (hsv > CUDT::HS_VERSION_UDT4 && IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDRCV))
+    if (hsv > CUDT::HS_VERSION_UDT4 && IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDRCV))
     {
         // So, PEER uses TSBPD, set the flag.
         // NOTE: it doesn't matter, if AGENT uses TSBPD.
@@ -2740,26 +2260,27 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
         int peer_decl_latency = SRT_HS_LATENCY_RCV::unwrap(latencystr);
         int maxdelay          = std::max(m_iPeerTsbPdDelay_ms, peer_decl_latency);
         HLOGC(cnlog.Debug,
-              log << "HSREQ/rcv: PEER/RCV LATENCY: Agent:" << m_iPeerTsbPdDelay_ms << " Peer:" << peer_decl_latency
-                  << " Selecting:" << maxdelay);
+              log << CONID() << "HSREQ/rcv: PEER/RCV LATENCY: Agent:" << m_iPeerTsbPdDelay_ms
+                  << " Peer:" << peer_decl_latency << " Selecting:" << maxdelay);
         m_iPeerTsbPdDelay_ms = maxdelay;
     }
     else
     {
         std::string how_about_agent = isOPT_TsbPd() ? "BUT AGENT DOES" : "and nor does Agent";
-        HLOGC(cnlog.Debug, log << "HSREQ/rcv: Peer DOES NOT USE latency for receiving - " << how_about_agent);
+        HLOGC(cnlog.Debug,
+              log << CONID() << "HSREQ/rcv: Peer DOES NOT USE latency for receiving - " << how_about_agent);
     }
 
     if (hsv > CUDT::HS_VERSION_UDT4)
     {
         // This is HSv5, do the same things as required for the sending party in HSv4,
         // as in HSv5 this can also be a sender.
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_TLPKTDROP))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_TLPKTDROP))
         {
             // Too late packets dropping feature supported
             m_bPeerTLPktDrop = true;
         }
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_NAKREPORT))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_NAKREPORT))
         {
             // Peer will send Periodic NAK Reports
             m_bPeerNakReport = true;
@@ -2769,20 +2290,20 @@ int CUDT::processSrtMsg_HSREQ(const uint32_t *srtdata, size_t bytelen, uint32_t
     return SRT_CMD_HSRSP;
 }
 
-int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t ts, int hsv)
+int srt::CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t ts, int hsv)
 {
     // XXX Check for mis-version
     // With HSv4 we accept only version less than 1.3.0
     if (hsv == CUDT::HS_VERSION_UDT4 && srtdata[SRT_HS_VERSION] >= SRT_VERSION_FEAT_HSv5)
     {
-        LOGC(cnlog.Error, log << "HSRSP/rcv: With HSv4 version >= 1.2.0 is not acceptable.");
+        LOGC(cnlog.Error, log << CONID() << "HSRSP/rcv: With HSv4 version >= 1.2.0 is not acceptable.");
         return SRT_CMD_NONE;
     }
 
     if (bytelen < SRT_CMD_HSRSP_MINSZ)
     {
         /* Packet smaller than minimum compatible packet size */
-        LOGF(cnlog.Error, "HSRSP/rcv: cmd=%d(HSRSP) len=%" PRIzu " invalid", SRT_CMD_HSRSP, bytelen);
+        LOGC(cnlog.Error, log << CONID() << "HSRSP/rcv: cmd=" << SRT_CMD_HSRSP << "(HSRSP) len=" << bytelen << " invalid");
         return SRT_CMD_NONE;
     }
 
@@ -2802,42 +2323,44 @@ int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t
         // if the agent has this value already "borrowed" from a master socket
         // that was in the group at the time when it was added.
         m_tsRcvPeerStartTime = steady_clock::now() - microseconds_from(ts);
-        HLOGC(cnlog.Debug, log << "HSRSP/rcv: PEER START TIME not yet defined, setting: " << FormatTime(m_tsRcvPeerStartTime));
+        HLOGC(cnlog.Debug,
+              log << CONID()
+                  << "HSRSP/rcv: PEER START TIME not yet defined, setting: " << FormatTime(m_tsRcvPeerStartTime));
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "HSRSP/rcv: PEER START TIME already set (derived): " << FormatTime(m_tsRcvPeerStartTime));
+        HLOGC(cnlog.Debug,
+              log << CONID()
+                  << "HSRSP/rcv: PEER START TIME already set (derived): " << FormatTime(m_tsRcvPeerStartTime));
     }
 
-    m_lPeerSrtVersion = srtdata[SRT_HS_VERSION];
-    m_lPeerSrtFlags   = srtdata[SRT_HS_FLAGS];
-
-    HLOGF(cnlog.Debug,
-          "HSRSP/rcv: Version: %s Flags: SND:%08X (%s)",
-          SrtVersionString(m_lPeerSrtVersion).c_str(),
-          m_lPeerSrtFlags,
-          SrtFlagString(m_lPeerSrtFlags).c_str());
+    m_uPeerSrtVersion = srtdata[SRT_HS_VERSION];
+    m_uPeerSrtFlags   = srtdata[SRT_HS_FLAGS];
 
+    HLOGC(cnlog.Debug, log << "HSRSP/rcv: Version: " << SrtVersionString(m_uPeerSrtVersion)
+                           << " Flags: SND:" << setw(8) << setfill('0') << hex << m_uPeerSrtFlags
+                           << setw(0) << " (" << SrtFlagString(m_uPeerSrtFlags) << ")");
     // Basic version check
-    if (m_lPeerSrtVersion < m_lMinimumPeerSrtVersion)
+    if (m_uPeerSrtVersion < m_config.uMinimumPeerSrtVersion)
     {
         m_RejectReason = SRT_REJ_VERSION;
         LOGC(cnlog.Error,
-             log << "HSRSP/rcv: Peer version: " << SrtVersionString(m_lPeerSrtVersion)
-                 << " is too old for requested: " << SrtVersionString(m_lMinimumPeerSrtVersion) << " - REJECTING");
+             log << CONID() << "HSRSP/rcv: Peer version: " << SrtVersionString(m_uPeerSrtVersion)
+                 << " is too old for requested: " << SrtVersionString(m_config.uMinimumPeerSrtVersion)
+                 << " - REJECTING");
         return SRT_CMD_REJECT;
     }
 
     if (hsv == CUDT::HS_VERSION_UDT4)
     {
         // The old HSv4 way: extract just one value and put it under peer.
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDRCV))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDRCV))
         {
             // TsbPd feature enabled
             m_bPeerTsbPd         = true;
             m_iPeerTsbPdDelay_ms = SRT_HS_LATENCY_LEG::unwrap(srtdata[SRT_HS_LATENCY]);
             HLOGC(cnlog.Debug,
-                  log << "HSRSP/rcv: LATENCY: Peer/snd:" << m_iPeerTsbPdDelay_ms
+                  log << CONID() << "HSRSP/rcv: LATENCY: Peer/snd:" << m_iPeerTsbPdDelay_ms
                       << " (Agent: declared:" << m_iTsbPdDelay_ms << " rcv:" << m_iTsbPdDelay_ms << ")");
         }
         // TSBPDSND isn't set in HSv4 by the RESPONDER, because HSv4 RESPONDER is always RECEIVER.
@@ -2847,25 +2370,26 @@ int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t
         // HSv5 way: extract the receiver latency and sender latency, if used.
 
         // PEER WILL RECEIVE TSBPD == AGENT SHALL SEND TSBPD.
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDRCV))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDRCV))
         {
             // TsbPd feature enabled
             m_bPeerTsbPd         = true;
             m_iPeerTsbPdDelay_ms = SRT_HS_LATENCY_RCV::unwrap(srtdata[SRT_HS_LATENCY]);
-            HLOGC(cnlog.Debug, log << "HSRSP/rcv: LATENCY: Peer/snd:" << m_iPeerTsbPdDelay_ms << "ms");
+            HLOGC(cnlog.Debug, log << CONID() << "HSRSP/rcv: LATENCY: Peer/snd:" << m_iPeerTsbPdDelay_ms << "ms");
         }
         else
         {
-            HLOGC(cnlog.Debug, log << "HSRSP/rcv: Peer (responder) DOES NOT USE latency");
+            HLOGC(cnlog.Debug, log << CONID() << "HSRSP/rcv: Peer (responder) DOES NOT USE latency");
         }
 
         // PEER WILL SEND TSBPD == AGENT SHALL RECEIVE TSBPD.
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_TSBPDSND))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_TSBPDSND))
         {
             if (!isOPT_TsbPd())
             {
                 LOGC(cnlog.Warn,
-                     log << "HSRSP/rcv: BUG? Peer (responder) declares sending latency, but Agent turned off TSBPD.");
+                     log << CONID()
+                         << "HSRSP/rcv: BUG? Peer (responder) declares sending latency, but Agent turned off TSBPD.");
             }
             else
             {
@@ -2873,26 +2397,26 @@ int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t
                 // Take this value as a good deal. In case when the Peer did not "correct" the latency
                 // because it has TSBPD turned off, just stay with the present value defined in options.
                 m_iTsbPdDelay_ms = SRT_HS_LATENCY_SND::unwrap(srtdata[SRT_HS_LATENCY]);
-                HLOGC(cnlog.Debug, log << "HSRSP/rcv: LATENCY Agent/rcv: " << m_iTsbPdDelay_ms << "ms");
+                HLOGC(cnlog.Debug, log << CONID() << "HSRSP/rcv: LATENCY Agent/rcv: " << m_iTsbPdDelay_ms << "ms");
             }
         }
     }
 
-    if ((m_lSrtVersion >= SrtVersion(1, 0, 5)) && IsSet(m_lPeerSrtFlags, SRT_OPT_TLPKTDROP))
+    if ((m_config.uSrtVersion >= SrtVersion(1, 0, 5)) && IsSet(m_uPeerSrtFlags, SRT_OPT_TLPKTDROP))
     {
         // Too late packets dropping feature supported
         m_bPeerTLPktDrop = true;
     }
 
-    if ((m_lSrtVersion >= SrtVersion(1, 1, 0)) && IsSet(m_lPeerSrtFlags, SRT_OPT_NAKREPORT))
+    if ((m_config.uSrtVersion >= SrtVersion(1, 1, 0)) && IsSet(m_uPeerSrtFlags, SRT_OPT_NAKREPORT))
     {
         // Peer will send Periodic NAK Reports
         m_bPeerNakReport = true;
     }
 
-    if (m_lSrtVersion >= SrtVersion(1, 2, 0))
+    if (m_config.uSrtVersion >= SrtVersion(1, 2, 0))
     {
-        if (IsSet(m_lPeerSrtFlags, SRT_OPT_REXMITFLG))
+        if (IsSet(m_uPeerSrtFlags, SRT_OPT_REXMITFLG))
         {
             // Peer will use REXMIT flag in packet retransmission.
             m_bPeerRexmitFlag = true;
@@ -2905,7 +2429,7 @@ int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t
     }
     else
     {
-        HLOGF(cnlog.Debug, "HSRSP/rcv: <1.2.0 Agent DOESN'T understand REXMIT flag");
+        HLOGP(cnlog.Debug, "HSRSP/rcv: <1.2.0 Agent DOESN'T understand REXMIT flag");
     }
 
     handshakeDone();
@@ -2914,9 +2438,9 @@ int CUDT::processSrtMsg_HSRSP(const uint32_t *srtdata, size_t bytelen, uint32_t
 }
 
 // This function is called only when the URQ_CONCLUSION handshake has been received from the peer.
-bool CUDT::interpretSrtHandshake(const CHandShake& hs,
+bool srt::CUDT::interpretSrtHandshake(const CHandShake& hs,
                                  const CPacket&    hspkt,
-                                 uint32_t*         out_data,
+                                 uint32_t*         out_data SRT_ATR_UNUSED,
                                  size_t*           pw_len)
 {
     // Initialize pw_len to 0 to handle the unencrypted case
@@ -2928,12 +2452,22 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
     if (m_ConnRes.m_iVersion > HS_VERSION_UDT4 && hs.m_iVersion == 0)
     {
         m_RejectReason = SRT_REJ_PEER;
-        LOGC(cnlog.Error, log << "HS VERSION = 0, meaning the handshake has been rejected.");
+        LOGC(cnlog.Error, log << CONID() << "HS VERSION = 0, meaning the handshake has been rejected.");
         return false;
     }
 
     if (hs.m_iVersion < HS_VERSION_SRT1)
+    {
+        if (m_config.uMinimumPeerSrtVersion && m_config.uMinimumPeerSrtVersion >= SRT_VERSION_FEAT_HSv5)
+        {
+            m_RejectReason = SRT_REJ_VERSION;
+            // This means that a version with minimum 1.3.0 that features HSv5 is required,
+            // hence all HSv4 clients should be rejected.
+            LOGP(cnlog.Error, "interpretSrtHandshake: minimum peer version 1.3.0 (HSv5 only), rejecting HSv4 client");
+            return false;
+        }
         return true; // do nothing
+    }
 
     // Anyway, check if the handshake contains any extra data.
     if (hspkt.getLength() <= CHandShake::m_iContentSize)
@@ -2941,31 +2475,33 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
         m_RejectReason = SRT_REJ_ROGUE;
         // This would mean that the handshake was at least HSv5, but somehow no extras were added.
         // Dismiss it then, however this has to be logged.
-        LOGC(cnlog.Error, log << "HS VERSION=" << hs.m_iVersion << " but no handshake extension found!");
+        LOGC(cnlog.Error, log << CONID() << "HS VERSION=" << hs.m_iVersion << " but no handshake extension found!");
         return false;
     }
 
     // We still believe it should work, let's check the flags.
-    int ext_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(hs.m_iType);
+    const int ext_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(hs.m_iType);
     if (ext_flags == 0)
     {
         m_RejectReason = SRT_REJ_ROGUE;
-        LOGC(cnlog.Error, log << "HS VERSION=" << hs.m_iVersion << " but no handshake extension flags are set!");
+        LOGC(cnlog.Error,
+             log << CONID() << "HS VERSION=" << hs.m_iVersion << " but no handshake extension flags are set!");
         return false;
     }
 
     HLOGC(cnlog.Debug,
-          log << "HS VERSION=" << hs.m_iVersion << " EXTENSIONS: " << CHandShake::ExtensionFlagStr(ext_flags));
+          log << CONID() << "HS VERSION=" << hs.m_iVersion
+              << " EXTENSIONS: " << CHandShake::ExtensionFlagStr(ext_flags));
 
     // Ok, now find the beginning of an int32_t array that follows the UDT handshake.
     uint32_t* p    = reinterpret_cast<uint32_t*>(hspkt.m_pcData + CHandShake::m_iContentSize);
     size_t    size = hspkt.getLength() - CHandShake::m_iContentSize; // Due to previous cond check we grant it's >0
 
-    int hsreq_type_cmd ATR_UNUSED = SRT_CMD_NONE;
+    int hsreq_type_cmd SRT_ATR_UNUSED = SRT_CMD_NONE;
 
     if (IsSet(ext_flags, CHandShake::HS_EXT_HSREQ))
     {
-        HLOGC(cnlog.Debug, log << "interpretSrtHandshake: extracting HSREQ/RSP type extension");
+        HLOGC(cnlog.Debug, log << CONID() << "interpretSrtHandshake: extracting HSREQ/RSP type extension");
         uint32_t *begin    = p;
         uint32_t *next     = 0;
         size_t    length   = size / sizeof(uint32_t);
@@ -2986,18 +2522,18 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 {
                     m_RejectReason = SRT_REJ_ROGUE;
                     LOGC(cnlog.Error,
-                         log << "HS-ext HSREQ found but invalid size: " << bytelen << " (expected: " << SRT_HS_E_SIZE
-                             << ")");
+                         log << CONID() << "HS-ext HSREQ found but invalid size: " << bytelen
+                             << " (expected: " << SRT_HS_E_SIZE << ")");
                     return false; // don't interpret
                 }
 
-                int rescmd = processSrtMsg_HSREQ(begin + 1, bytelen, hspkt.m_iTimeStamp, HS_VERSION_SRT1);
+                int rescmd = processSrtMsg_HSREQ(begin + 1, bytelen, hspkt.timestamp(), HS_VERSION_SRT1);
                 // Interpreted? Then it should be responded with SRT_CMD_HSRSP.
                 if (rescmd != SRT_CMD_HSRSP)
                 {
                     // m_RejectReason already set
                     LOGC(cnlog.Error,
-                         log << "interpretSrtHandshake: process HSREQ returned unexpected value " << rescmd);
+                         log << CONID() << "interpretSrtHandshake: process HSREQ returned unexpected value " << rescmd);
                     return false;
                 }
                 handshakeDone();
@@ -3012,13 +2548,13 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 {
                     m_RejectReason = SRT_REJ_ROGUE;
                     LOGC(cnlog.Error,
-                         log << "HS-ext HSRSP found but invalid size: " << bytelen << " (expected: " << SRT_HS_E_SIZE
-                             << ")");
+                         log << CONID() << "HS-ext HSRSP found but invalid size: " << bytelen
+                             << " (expected: " << SRT_HS_E_SIZE << ")");
 
                     return false; // don't interpret
                 }
 
-                int rescmd = processSrtMsg_HSRSP(begin + 1, bytelen, hspkt.m_iTimeStamp, HS_VERSION_SRT1);
+                int rescmd = processSrtMsg_HSRSP(begin + 1, bytelen, hspkt.timestamp(), HS_VERSION_SRT1);
                 // Interpreted? Then it should be responded with SRT_CMD_NONE.
                 // (nothing to be responded for HSRSP, unless there was some kinda problem)
                 if (rescmd != SRT_CMD_NONE)
@@ -3028,7 +2564,7 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                     if (m_RejectReason == SRT_REJ_UNKNOWN)
                         m_RejectReason = SRT_REJ_ROGUE;
                     LOGC(cnlog.Error,
-                         log << "interpretSrtHandshake: process HSRSP returned unexpected value " << rescmd);
+                         log << CONID() << "interpretSrtHandshake: process HSRSP returned unexpected value " << rescmd);
                     return false;
                 }
                 handshakeDone();
@@ -3037,7 +2573,8 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             else if (cmd == SRT_CMD_NONE)
             {
                 m_RejectReason = SRT_REJ_ROGUE;
-                LOGC(cnlog.Warn, log << "interpretSrtHandshake: no HSREQ/HSRSP block found in the handshake msg!");
+                LOGC(cnlog.Warn,
+                     log << CONID() << "interpretSrtHandshake: no HSREQ/HSRSP block found in the handshake msg!");
                 // This means that there can be no more processing done by FindExtensionBlock().
                 // And we haven't found what we need - otherwise one of the above cases would pass
                 // and lead to exit this loop immediately.
@@ -3056,7 +2593,7 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
         }
     }
 
-    HLOGC(cnlog.Debug, log << "interpretSrtHandshake: HSREQ done, checking KMREQ");
+    HLOGC(cnlog.Debug, log << CONID() << "interpretSrtHandshake: HSREQ done, checking KMREQ");
 
     // Now check the encrypted
 
@@ -3064,21 +2601,24 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
 
     if (IsSet(ext_flags, CHandShake::HS_EXT_KMREQ))
     {
-        HLOGC(cnlog.Debug, log << "interpretSrtHandshake: extracting KMREQ/RSP type extension");
+        HLOGC(cnlog.Debug, log << CONID() << "interpretSrtHandshake: extracting KMREQ/RSP type extension");
 
 #ifdef SRT_ENABLE_ENCRYPTION
         if (!m_pCryptoControl->hasPassphrase())
         {
-            if (m_bOPT_StrictEncryption)
+            if (m_config.bEnforcedEnc)
             {
                 m_RejectReason = SRT_REJ_UNSECURE;
                 LOGC(cnlog.Error,
-                    log << "HS KMREQ: Peer declares encryption, but agent does not - rejecting per enforced encryption");
+                     log << CONID()
+                         << "HS KMREQ: Peer declares encryption, but agent does not - rejecting per enforced "
+                            "encryption");
                 return false;
             }
 
             LOGC(cnlog.Warn,
-                 log << "HS KMREQ: Peer declares encryption, but agent does not - still allowing connection.");
+                 log << CONID()
+                     << "HS KMREQ: Peer declares encryption, but agent does not - still allowing connection.");
 
             // Still allow for connection, and allow Agent to send unencrypted stream to the peer.
             // Also normally allow the key to be processed; worst case it will send the failure response.
@@ -3094,7 +2634,8 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             int cmd = FindExtensionBlock(begin, length, (blocklen), (next));
 
             HLOGC(cnlog.Debug,
-                  log << "interpretSrtHandshake: found extension: (" << cmd << ") " << MessageTypeStr(UMSG_EXT, cmd));
+                  log << CONID() << "interpretSrtHandshake: found extension: (" << cmd << ") "
+                      << MessageTypeStr(UMSG_EXT, cmd));
 
             size_t bytelen = blocklen * sizeof(uint32_t);
             if (cmd == SRT_CMD_KMREQ)
@@ -3102,25 +2643,38 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 if (!out_data || !pw_len)
                 {
                     m_RejectReason = SRT_REJ_IPE;
-                    LOGC(cnlog.Fatal, log << "IPE: HS/KMREQ extracted without passing target buffer!");
+                    LOGC(cnlog.Fatal, log << CONID() << "IPE: HS/KMREQ extracted without passing target buffer!");
                     return false;
                 }
 
-                int res = m_pCryptoControl->processSrtMsg_KMREQ(begin + 1, bytelen, HS_VERSION_SRT1,
+                int res = m_pCryptoControl->processSrtMsg_KMREQ(begin + 1, bytelen, HS_VERSION_SRT1, m_uPeerSrtVersion,
                             (out_data), (*pw_len));
                 if (res != SRT_CMD_KMRSP)
                 {
                     m_RejectReason = SRT_REJ_IPE;
                     // Something went wrong.
                     HLOGC(cnlog.Debug,
-                          log << "interpretSrtHandshake: IPE/EPE KMREQ processing failed - returned " << res);
+                          log << CONID() << "interpretSrtHandshake: IPE/EPE KMREQ processing failed - returned "
+                              << res);
                     return false;
                 }
                 if (*pw_len == 1)
                 {
+#ifdef ENABLE_AEAD_API_PREVIEW
+                    if (m_pCryptoControl->m_RcvKmState == SRT_KM_S_BADCRYPTOMODE)
+                    {
+                        // Cryptographic modes mismatch. Not acceptable at all.
+                        m_RejectReason = SRT_REJ_CRYPTO;
+                        LOGC(cnlog.Error,
+                             log << CONID()
+                                 << "interpretSrtHandshake: KMREQ result: Bad crypto mode - rejecting");
+                        return false;
+                    }
+#endif
+
                     // This means that there was an abnormal encryption situation occurred.
                     // This is inacceptable in case of strict encryption.
-                    if (m_bOPT_StrictEncryption)
+                    if (m_config.bEnforcedEnc)
                     {
                         if (m_pCryptoControl->m_RcvKmState == SRT_KM_S_BADSECRET)
                         {
@@ -3131,7 +2685,8 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                             m_RejectReason = SRT_REJ_UNSECURE;
                         }
                         LOGC(cnlog.Error,
-                             log << "interpretSrtHandshake: KMREQ result abnornal - rejecting per enforced encryption");
+                             log << CONID()
+                                 << "interpretSrtHandshake: KMREQ result abnornal - rejecting per enforced encryption");
                         return false;
                     }
                 }
@@ -3139,11 +2694,19 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             }
             else if (cmd == SRT_CMD_KMRSP)
             {
-                int res = m_pCryptoControl->processSrtMsg_KMRSP(begin + 1, bytelen, HS_VERSION_SRT1);
-                if (m_bOPT_StrictEncryption && res == -1)
+                int res = m_pCryptoControl->processSrtMsg_KMRSP(begin + 1, bytelen, m_uPeerSrtVersion);
+                if (m_config.bEnforcedEnc && res == -1)
                 {
-                    m_RejectReason = SRT_REJ_UNSECURE;
-                    LOGC(cnlog.Error, log << "KMRSP failed - rejecting connection as per enforced encryption.");
+                    if (m_pCryptoControl->m_SndKmState == SRT_KM_S_BADSECRET)
+                        m_RejectReason = SRT_REJ_BADSECRET;
+#ifdef ENABLE_AEAD_API_PREVIEW
+                    else if (m_pCryptoControl->m_SndKmState == SRT_KM_S_BADCRYPTOMODE)
+                        m_RejectReason = SRT_REJ_CRYPTO;
+#endif
+                    else
+                        m_RejectReason = SRT_REJ_UNSECURE;
+                    LOGC(cnlog.Error,
+                         log << CONID() << "KMRSP failed - rejecting connection as per enforced encryption.");
                     return false;
                 }
                 encrypted = true;
@@ -3151,12 +2714,12 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             else if (cmd == SRT_CMD_NONE)
             {
                 m_RejectReason = SRT_REJ_ROGUE;
-                LOGC(cnlog.Error, log << "HS KMREQ expected - none found!");
+                LOGC(cnlog.Error, log << CONID() << "HS KMREQ expected - none found!");
                 return false;
             }
             else
             {
-                HLOGC(cnlog.Debug, log << "interpretSrtHandshake: ... skipping " << MessageTypeStr(UMSG_EXT, cmd));
+                HLOGC(cnlog.Debug, log << CONID() << "interpretSrtHandshake: ... skipping " << MessageTypeStr(UMSG_EXT, cmd));
                 if (NextExtensionBlock((begin), next, (length)))
                     continue;
             }
@@ -3167,17 +2730,19 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
         // When encryption is not enabled at compile time, behave as if encryption wasn't set,
         // so accordingly to StrictEncryption flag.
 
-        if (m_bOPT_StrictEncryption)
+        if (m_config.bEnforcedEnc)
         {
             m_RejectReason = SRT_REJ_UNSECURE;
             LOGC(cnlog.Error,
-                 log << "HS KMREQ: Peer declares encryption, but agent didn't enable it at compile time - rejecting "
+                 log << CONID()
+                     << "HS KMREQ: Peer declares encryption, but agent didn't enable it at compile time - rejecting "
                         "per enforced encryption");
             return false;
         }
 
         LOGC(cnlog.Warn,
-             log << "HS KMREQ: Peer declares encryption, but agent didn't enable it at compile time - still allowing "
+             log << CONID()
+                 << "HS KMREQ: Peer declares encryption, but agent didn't enable it at compile time - still allowing "
                     "connection.");
         encrypted = true;
 #endif
@@ -3185,18 +2750,18 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
 
     bool   have_congctl = false;
     bool   have_filter  = false;
-    string agsm         = m_CongCtl.selected_name();
+    string agsm = m_config.sCongestion.str();
     if (agsm == "")
     {
         agsm = "live";
-        m_CongCtl.select("live");
+        m_config.sCongestion.set("live", 4);
     }
 
-    bool have_group ATR_UNUSED = false;
+    bool have_group SRT_ATR_UNUSED = false;
 
     if (IsSet(ext_flags, CHandShake::HS_EXT_CONFIG))
     {
-        HLOGC(cnlog.Debug, log << "interpretSrtHandshake: extracting various CONFIG extensions");
+        HLOGC(cnlog.Debug, log << CONID() << "interpretSrtHandshake: extracting various CONFIG extensions");
 
         uint32_t *begin    = p;
         uint32_t *next     = 0;
@@ -3208,59 +2773,74 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             int cmd = FindExtensionBlock(begin, length, (blocklen), (next));
 
             HLOGC(cnlog.Debug,
-                  log << "interpretSrtHandshake: found extension: (" << cmd << ") " << MessageTypeStr(UMSG_EXT, cmd));
+                  log << CONID() << "interpretSrtHandshake: found extension: (" << cmd << ") "
+                      << MessageTypeStr(UMSG_EXT, cmd));
 
             const size_t bytelen = blocklen * sizeof(uint32_t);
             if (cmd == SRT_CMD_SID)
             {
-                if (!bytelen || bytelen > MAX_SID_LENGTH)
+                if (!bytelen || bytelen > CSrtConfig::MAX_SID_LENGTH)
                 {
                     LOGC(cnlog.Error,
-                         log << "interpretSrtHandshake: STREAMID length " << bytelen << " is 0 or > " << +MAX_SID_LENGTH
-                             << " - PROTOCOL ERROR, REJECTING");
+                         log << CONID() << "interpretSrtHandshake: STREAMID length " << bytelen << " is 0 or > "
+                             << +CSrtConfig::MAX_SID_LENGTH << " - PROTOCOL ERROR, REJECTING");
                     return false;
                 }
                 // Copied through a cleared array. This is because the length is aligned to 4
                 // where the padding is filled by zero bytes. For the case when the string is
                 // exactly of a 4-divisible length, we make a big array with maximum allowed size
                 // filled with zeros. Copying to this array should then copy either only the valid
-                // characters of the string (if the lenght is divisible by 4), or the string with
+                // characters of the string (if the length is divisible by 4), or the string with
                 // padding zeros. In all these cases in the resulting array we should have all
                 // subsequent characters of the string plus at least one '\0' at the end. This will
                 // make it a perfect NUL-terminated string, to be used to initialize a string.
-                char target[MAX_SID_LENGTH + 1];
-                memset((target), 0, MAX_SID_LENGTH + 1);
+                char target[CSrtConfig::MAX_SID_LENGTH + 1];
+                memset((target), 0, CSrtConfig::MAX_SID_LENGTH + 1);
                 memcpy((target), begin + 1, bytelen);
 
                 // Un-swap on big endian machines
                 ItoHLA((uint32_t *)target, (uint32_t *)target, blocklen);
 
-                m_sStreamName = target;
+                // Determine the length by dropping all but one of terminal NUL characters.
+
+                size_t targetlen = bytelen;
+                for (size_t pos = bytelen - 1; pos != 0; --pos)
+                {
+                    if (target[pos])
+                    {
+                        // Found the first non-NUL character backwards
+                        // So the length is pos+1
+                        targetlen = pos + 1;
+                        break;
+                    }
+                }
+
+                m_config.sStreamName.set(target, targetlen);
                 HLOGC(cnlog.Debug,
-                      log << "CONNECTOR'S REQUESTED SID [" << m_sStreamName << "] (bytelen=" << bytelen
-                          << " blocklen=" << blocklen << ")");
+                      log << CONID() << "CONNECTOR'S REQUESTED SID [" << m_config.sStreamName.c_str()
+                          << "] (bytelen=" << bytelen << " blocklen=" << blocklen << ")");
             }
             else if (cmd == SRT_CMD_CONGESTION)
             {
                 if (have_congctl)
                 {
                     m_RejectReason = SRT_REJ_ROGUE;
-                    LOGC(cnlog.Error, log << "CONGCTL BLOCK REPEATED!");
+                    LOGC(cnlog.Error, log << CONID() << "CONGCTL BLOCK REPEATED!");
                     return false;
                 }
 
-                if (!bytelen || bytelen > MAX_SID_LENGTH)
+                if (!bytelen || bytelen > CSrtConfig::MAX_CONG_LENGTH)
                 {
                     LOGC(cnlog.Error,
-                         log << "interpretSrtHandshake: CONGESTION-control type length " << bytelen << " is 0 or > "
-                             << +MAX_SID_LENGTH << " - PROTOCOL ERROR, REJECTING");
+                         log << CONID() << "interpretSrtHandshake: CONGESTION-control type length " << bytelen
+                             << " is 0 or > " << +CSrtConfig::MAX_CONG_LENGTH << " - PROTOCOL ERROR, REJECTING");
                     return false;
                 }
                 // Declare that congctl has been received
                 have_congctl = true;
 
-                char target[MAX_SID_LENGTH + 1];
-                memset((target), 0, MAX_SID_LENGTH + 1);
+                char target[CSrtConfig::MAX_CONG_LENGTH + 1];
+                memset((target), 0, CSrtConfig::MAX_CONG_LENGTH + 1);
                 memcpy((target), begin + 1, bytelen);
                 // Un-swap on big endian machines
                 ItoHLA((uint32_t *)target, (uint32_t *)target, blocklen);
@@ -3274,44 +2854,54 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 {
                     m_RejectReason = SRT_REJ_CONGESTION;
                     LOGC(cnlog.Error,
-                         log << "PEER'S CONGCTL '" << sm << "' does not match AGENT'S CONGCTL '" << agsm << "'");
+                         log << CONID() << "PEER'S CONGCTL '" << sm << "' does not match AGENT'S CONGCTL '" << agsm
+                             << "'");
                     return false;
                 }
 
                 HLOGC(cnlog.Debug,
-                      log << "CONNECTOR'S CONGCTL [" << sm << "] (bytelen=" << bytelen << " blocklen=" << blocklen
-                          << ")");
+                      log << CONID() << "CONNECTOR'S CONGCTL [" << sm << "] (bytelen=" << bytelen
+                          << " blocklen=" << blocklen << ")");
             }
             else if (cmd == SRT_CMD_FILTER)
             {
                 if (have_filter)
                 {
                     m_RejectReason = SRT_REJ_FILTER;
-                    LOGC(cnlog.Error, log << "FILTER BLOCK REPEATED!");
+                    LOGC(cnlog.Error, log << CONID() << "FILTER BLOCK REPEATED!");
+                    return false;
+                }
+
+                if (!bytelen || bytelen > CSrtConfig::MAX_PFILTER_LENGTH)
+                {
+                    LOGC(cnlog.Error,
+                         log << CONID() << "interpretSrtHandshake: packet-filter type length " << bytelen
+                             << " is 0 or > " << +CSrtConfig::MAX_PFILTER_LENGTH << " - PROTOCOL ERROR, REJECTING");
                     return false;
                 }
                 // Declare that filter has been received
                 have_filter = true;
 
-                // XXX This is the maximum string, but filter config
-                // shall be normally limited somehow, especially if used
-                // together with SID!
-                char target[MAX_SID_LENGTH + 1];
-                memset((target), 0, MAX_SID_LENGTH + 1);
+                char target[CSrtConfig::MAX_PFILTER_LENGTH + 1];
+                memset((target), 0, CSrtConfig::MAX_PFILTER_LENGTH + 1);
                 memcpy((target), begin + 1, bytelen);
+                // Un-swap on big endian machines
+                ItoHLA((uint32_t *)target, (uint32_t *)target, blocklen);
+
                 string fltcfg = target;
 
                 HLOGC(cnlog.Debug,
-                      log << "PEER'S FILTER CONFIG [" << fltcfg << "] (bytelen=" << bytelen << " blocklen=" << blocklen
-                          << ")");
+                      log << CONID() << "PEER'S FILTER CONFIG [" << fltcfg << "] (bytelen=" << bytelen
+                          << " blocklen=" << blocklen << ")");
 
                 if (!checkApplyFilterConfig(fltcfg))
                 {
-                    LOGC(cnlog.Error, log << "PEER'S FILTER CONFIG [" << fltcfg << "] has been rejected");
+                    m_RejectReason = SRT_REJ_FILTER;
+                    LOGC(cnlog.Error, log << CONID() << "PEER'S FILTER CONFIG [" << fltcfg << "] has been rejected");
                     return false;
                 }
             }
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
             else if ( cmd == SRT_CMD_GROUP )
             {
                 // Note that this will fire in both cases:
@@ -3321,10 +2911,10 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 // - When receiving HS response from the Responder, with its mirror group ID, so the agent
                 //   must put the group into his peer group data
                 int32_t groupdata[GRPD_E_SIZE] = {};
-                if (bytelen < GRPD_MIN_SIZE * GRPD_FIELD_SIZE || bytelen % GRPD_FIELD_SIZE || blocklen > GRPD_E_SIZE)
+                if (bytelen < GRPD_MIN_SIZE * GRPD_FIELD_SIZE || bytelen % GRPD_FIELD_SIZE)
                 {
                     m_RejectReason = SRT_REJ_ROGUE;
-                    LOGC(cnlog.Error, log << "PEER'S GROUP wrong size: " << (bytelen/GRPD_FIELD_SIZE));
+                    LOGC(cnlog.Error, log << CONID() << "PEER'S GROUP wrong size: " << (bytelen/GRPD_FIELD_SIZE));
                     return false;
                 }
                 size_t groupdata_size = bytelen / GRPD_FIELD_SIZE;
@@ -3337,7 +2927,9 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
                 }
 
                 have_group = true;
-                HLOGC(cnlog.Debug, log << "CONNECTOR'S PEER GROUP [" << groupdata[0] << "] (bytelen=" << bytelen << " blocklen=" << blocklen << ")");
+                HLOGC(cnlog.Debug,
+                      log << CONID() << "CONNECTOR'S PEER GROUP [" << groupdata[0] << "] (bytelen=" << bytelen
+                          << " blocklen=" << blocklen << ")");
             }
 #endif
             else if (cmd == SRT_CMD_NONE)
@@ -3347,7 +2939,8 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
             else
             {
                 // Found some block that is not interesting here. Skip this and get the next one.
-                HLOGC(cnlog.Debug, log << "interpretSrtHandshake: ... skipping " << MessageTypeStr(UMSG_EXT, cmd));
+                HLOGC(cnlog.Debug,
+                      log << CONID() << "interpretSrtHandshake: ... skipping " << MessageTypeStr(UMSG_EXT, cmd));
             }
 
             if (!NextExtensionBlock((begin), next, (length)))
@@ -3357,19 +2950,21 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
 
     // Post-checks
     // Check if peer declared encryption
-    if (!encrypted && m_CryptoSecret.len > 0)
+    if (!encrypted && m_config.CryptoSecret.len > 0)
     {
-        if (m_bOPT_StrictEncryption)
+        if (m_config.bEnforcedEnc)
         {
             m_RejectReason = SRT_REJ_UNSECURE;
             LOGC(cnlog.Error,
-                 log << "HS EXT: Agent declares encryption, but Peer does not - rejecting connection per "
+                 log << CONID()
+                     << "HS EXT: Agent declares encryption, but Peer does not - rejecting connection per "
                         "enforced encryption.");
             return false;
         }
 
         LOGC(cnlog.Warn,
-             log << "HS EXT: Agent declares encryption, but Peer does not (Agent can still receive unencrypted packets "
+             log << CONID()
+                 << "HS EXT: Agent declares encryption, but Peer does not (Agent can still receive unencrypted packets "
                     "from Peer).");
 
         // This is required so that the sender is still allowed to send data, when encryption is required,
@@ -3385,14 +2980,15 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
     {
         m_RejectReason = SRT_REJ_CONGESTION;
         LOGC(cnlog.Error,
-             log << "HS EXT: Agent uses '" << agsm << "' congctl, but peer DID NOT DECLARE congctl (assuming 'live').");
+             log << CONID() << "HS EXT: Agent uses '" << agsm
+                 << "' congctl, but peer DID NOT DECLARE congctl (assuming 'live').");
         return false;
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-    // m_IncludedGroup and locking info: NULL check won't hurt here. If the group
+#if ENABLE_BONDING
+    // m_GroupOf and locking info: NULL check won't hurt here. If the group
     // was deleted in the meantime, it will be found out later anyway and result with error.
-    if (m_SrtHsSide == HSD_INITIATOR && m_parent->m_IncludedGroup)
+    if (m_SrtHsSide == HSD_INITIATOR && m_parent->m_GroupOf)
     {
         // XXX Later probably needs to check if this group REQUIRES the group
         // response. Currently this implements the bonding-category group, and this
@@ -3401,7 +2997,9 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
         if (!have_group)
         {
             m_RejectReason = SRT_REJ_GROUP;
-            LOGC(cnlog.Error, log << "HS EXT: agent is a group member, but the listener did not respond with group ID. Rejecting.");
+            LOGC(cnlog.Error,
+                 log << CONID()
+                     << "HS EXT: agent is a group member, but the listener did not respond with group ID. Rejecting.");
             return false;
         }
     }
@@ -3411,10 +3009,10 @@ bool CUDT::interpretSrtHandshake(const CHandShake& hs,
     return true;
 }
 
-bool CUDT::checkApplyFilterConfig(const std::string &confstr)
+bool srt::CUDT::checkApplyFilterConfig(const std::string &confstr)
 {
     SrtFilterConfig cfg;
-    if (!ParseFilterConfig(confstr, cfg))
+    if (!ParseFilterConfig(confstr, (cfg)))
         return false;
 
     // Now extract the type, if present, and
@@ -3422,17 +3020,19 @@ bool CUDT::checkApplyFilterConfig(const std::string &confstr)
     if (!PacketFilter::correctConfig(cfg))
         return false;
 
+    string thisconf = m_config.sPacketFilterConfig.str();
+
     // Now parse your own string, if you have it.
-    if (m_OPT_PktFilterConfigString != "")
+    if (thisconf != "")
     {
-        // - for rendezvous, both must be exactly the same, or only one side specified.
-        if (m_bRendezvous && m_OPT_PktFilterConfigString != confstr)
+        // - for rendezvous, both must be exactly the same (it's unspecified, which will be the first one)
+        if (m_config.bRendezvous && thisconf != confstr)
         {
             return false;
         }
 
         SrtFilterConfig mycfg;
-        if (!ParseFilterConfig(m_OPT_PktFilterConfigString, mycfg))
+        if (!ParseFilterConfig(thisconf, (mycfg)))
             return false;
 
         // Check only if both have set a filter of the same type.
@@ -3452,16 +3052,12 @@ bool CUDT::checkApplyFilterConfig(const std::string &confstr)
         }
         else
         {
-            // On a listener, only apply those that you haven't set
-            for (map<string, string>::iterator x = cfg.parameters.begin(); x != cfg.parameters.end(); ++x)
-            {
-                if (!mycfg.parameters.count(x->first))
-                    mycfg.parameters[x->first] = x->second;
-            }
+            if (!CheckFilterCompat((mycfg), cfg))
+                return false;
         }
 
         HLOGC(cnlog.Debug,
-              log << "checkApplyFilterConfig: param: LOCAL: " << Printable(mycfg.parameters)
+              log << CONID() << "checkApplyFilterConfig: param: LOCAL: " << Printable(mycfg.parameters)
                   << " FORGN: " << Printable(cfg.parameters));
 
         ostringstream myos;
@@ -3471,31 +3067,33 @@ bool CUDT::checkApplyFilterConfig(const std::string &confstr)
             myos << "," << x->first << ":" << x->second;
         }
 
-        m_OPT_PktFilterConfigString = myos.str();
+        m_config.sPacketFilterConfig.set(myos.str());
 
-        HLOGC(cnlog.Debug, log << "checkApplyFilterConfig: Effective config: " << m_OPT_PktFilterConfigString);
+        HLOGC(cnlog.Debug, log << CONID() << "checkApplyFilterConfig: Effective config: " << thisconf);
     }
     else
     {
         // Take the foreign configuration as a good deal.
-        HLOGC(cnlog.Debug, log << "checkApplyFilterConfig: Good deal config: " << m_OPT_PktFilterConfigString);
-        m_OPT_PktFilterConfigString = confstr;
+        HLOGC(cnlog.Debug, log << CONID() << "checkApplyFilterConfig: Good deal config: " << thisconf);
+        m_config.sPacketFilterConfig.set(confstr);
     }
 
+    // XXX Using less maximum payload size of IPv4 and IPv6; this is only about the payload size
+    // for live.
     size_t efc_max_payload_size = SRT_LIVE_MAX_PLSIZE - cfg.extra_size;
-    if (m_zOPT_ExpPayloadSize > efc_max_payload_size)
+    if (m_config.zExpPayloadSize > efc_max_payload_size)
     {
         LOGC(cnlog.Warn,
-             log << "Due to filter-required extra " << cfg.extra_size << " bytes, SRTO_PAYLOADSIZE fixed to "
+             log << CONID() << "Due to filter-required extra " << cfg.extra_size << " bytes, SRTO_PAYLOADSIZE fixed to "
                  << efc_max_payload_size << " bytes");
-        m_zOPT_ExpPayloadSize = efc_max_payload_size;
+        m_config.zExpPayloadSize = efc_max_payload_size;
     }
 
     return true;
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UNUSED, int hsreq_type_cmd SRT_ATR_UNUSED)
+#if ENABLE_BONDING
+bool srt::CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UNUSED, int hsreq_type_cmd SRT_ATR_UNUSED)
 {
     // `data_size` isn't checked because we believe it's checked earlier.
     // Also this code doesn't predict to get any other format than the official one,
@@ -3510,10 +3108,10 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
     int link_weight = SrtHSRequest::HS_GROUP_WEIGHT::unwrap(gd);
     uint32_t link_flags = SrtHSRequest::HS_GROUP_FLAGS::unwrap(gd);
 
-    if (m_OPT_GroupConnect == 0)
+    if (m_config.iGroupConnect == 0)
     {
         m_RejectReason = SRT_REJ_GROUP;
-        LOGC(cnlog.Error, log << "HS/GROUP: this socket is not allowed for group connect.");
+        LOGC(cnlog.Error, log << CONID() << "HS/GROUP: this socket is not allowed for group connect.");
         return false;
     }
 
@@ -3521,14 +3119,15 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
     if (gtp >= SRT_GTYPE_E_END)
     {
         m_RejectReason = SRT_REJ_GROUP;
-        LOGC(cnlog.Error, log << "HS/GROUP: incorrect group type value " << gtp << " (max is " << SRT_GTYPE_E_END << ")");
+        LOGC(cnlog.Error,
+             log << CONID() << "HS/GROUP: incorrect group type value " << gtp << " (max is " << SRT_GTYPE_E_END << ")");
         return false;
     }
 
     if ((grpid & SRTGROUP_MASK) == 0)
     {
         m_RejectReason = SRT_REJ_ROGUE;
-        LOGC(cnlog.Error, log << "HS/GROUP: socket ID passed as a group ID is not a group ID");
+        LOGC(cnlog.Error, log << CONID() << "HS/GROUP: socket ID passed as a group ID is not a group ID");
         return false;
     }
 
@@ -3539,8 +3138,10 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
 
 #if ENABLE_HEAVY_LOGGING
     static const char* hs_side_name[] = {"draw", "initiator", "responder"};
-    HLOGC(cnlog.Debug, log << "interpretGroup: STATE: HsSide=" << hs_side_name[m_SrtHsSide] << " HS MSG: " << MessageTypeStr(UMSG_EXT, hsreq_type_cmd)
-            << " $" << grpid << " type=" << gtp << " weight=" << link_weight << " flags=0x" << std::hex << link_flags);
+    HLOGC(cnlog.Debug,
+          log << CONID() << "interpretGroup: STATE: HsSide=" << hs_side_name[m_SrtHsSide]
+              << " HS MSG: " << MessageTypeStr(UMSG_EXT, hsreq_type_cmd) << " $" << grpid << " type=" << gtp
+              << " weight=" << link_weight << " flags=0x" << std::hex << link_flags);
 #endif
 
     // XXX Here are two separate possibilities:
@@ -3552,11 +3153,14 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
     if (m_SrtHsSide == HSD_DRAW)
     {
         m_RejectReason = SRT_REJ_IPE;
-        LOGC(cnlog.Error, log << "IPE: interpretGroup: The HS side should have been already decided; it's still DRAW. Grouping rejected.");
+        LOGC(cnlog.Error,
+             log << CONID()
+                 << "IPE: interpretGroup: The HS side should have been already decided; it's still DRAW. Grouping "
+                    "rejected.");
         return false;
     }
 
-    ScopedLock guard_group_existence (s_UDTUnited.m_GlobControlLock);
+    ScopedLock guard_group_existence (uglobal().m_GlobControlLock);
 
     if (m_SrtHsSide == HSD_INITIATOR)
     {
@@ -3567,21 +3171,24 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
         // the same id, otherwise the connection should be rejected.
 
         // So, first check the group of the current socket and see if a peer is set.
-        CUDTGroup* pg = m_parent->m_IncludedGroup;
+        CUDTGroup* pg = m_parent->m_GroupOf;
         if (!pg)
         {
             // This means that the responder has responded with a group membership,
             // but the initiator did not request any group membership presence.
             // Currently impossible situation.
             m_RejectReason = SRT_REJ_IPE;
-            LOGC(cnlog.Error, log << "IPE: HS/RSP: group membership responded, while not requested.");
+            LOGC(cnlog.Error, log << CONID() << "IPE: HS/RSP: group membership responded, while not requested.");
             return false;
         }
 
+        // Group existence is guarded, so we can now lock the group as well.
+        ScopedLock gl(*pg->exp_groupLock());
+
         // Now we know the group exists, but it might still be closed
         if (pg->closing())
         {
-            LOGC(cnlog.Error, log << "HS/RSP: group was closed in the process, can't continue connecting");
+            LOGC(cnlog.Error, log << CONID() << "HS/RSP: group was closed in the process, can't continue connecting");
             m_RejectReason = SRT_REJ_IPE;
             return false;
         }
@@ -3592,23 +3199,33 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
             // This is the first connection within this group, so this group
             // has just been informed about the peer membership. Accept it.
             pg->set_peerid(grpid);
-            HLOGC(cnlog.Debug, log << "HS/RSP: group $" << pg->id() << " mapped to peer mirror $" << pg->peerid());
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "HS/RSP: group $" << pg->id() << " -> peer $" << pg->peerid()
+                      << ", copying characteristic data");
+
+            // The call to syncWithSocket is copying
+            // some interesting data from the first connected
+            // socket. This should be only done for the first successful connection.
+            pg->syncWithSocket(*this, HSD_INITIATOR);
         }
         // Otherwise the peer id must be the same as existing, otherwise
         // this group is considered already bound to another peer group.
         // (Note that the peer group is peer-specific, and peer id numbers
         // may repeat among sockets connected to groups established on
         // different peers).
-        else if (pg->peerid() != grpid)
+        else if (peer != grpid)
         {
-            LOGC(cnlog.Error, log << "IPE: HS/RSP: group membership responded for peer $" << grpid
-                    << " but the current socket's group $" << pg->id() << " has already a peer $" << peer);
+            LOGC(cnlog.Error,
+                 log << CONID() << "IPE: HS/RSP: group membership responded for peer $" << grpid
+                     << " but the current socket's group $" << pg->id() << " has already a peer $" << peer);
             m_RejectReason = SRT_REJ_GROUP;
             return false;
         }
         else
         {
-            HLOGC(cnlog.Debug, log << "HS/RSP: group $" << pg->id() << " ALREADY MAPPED to peer mirror $" << pg->peerid());
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "HS/RSP: group $" << pg->id() << " ALREADY MAPPED to peer mirror $"
+                      << pg->peerid());
         }
     }
     else
@@ -3630,22 +3247,22 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
             return false; // error occurred
         }
 
-        if (!m_parent->m_IncludedGroup)
+        if (!m_parent->m_GroupOf)
         {
             // Strange, we just added it...
             m_RejectReason = SRT_REJ_IPE;
-            LOGC(cnlog.Fatal, log << "IPE: socket not in group after adding to it");
+            LOGC(cnlog.Fatal, log << CONID() << "IPE: socket not in group after adding to it");
             return false;
         }
 
-        CUDTGroup::gli_t f = m_parent->m_IncludedIter;
+        groups::SocketData* f = m_parent->m_GroupMemberData;
 
         f->weight = link_weight;
         f->agent = m_parent->m_SelfAddr;
         f->peer = m_PeerAddr;
     }
 
-    m_parent->m_IncludedGroup->debugGroup();
+    m_parent->m_GroupOf->debugGroup();
 
     // That's all. For specific things concerning group
     // types, this will be later.
@@ -3653,12 +3270,12 @@ bool CUDT::interpretGroup(const int32_t groupdata[], size_t data_size SRT_ATR_UN
 }
 #endif
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 // NOTE: This function is called only in one place and it's done
 // exclusively on the listener side (HSD_RESPONDER, HSv5+).
 
 // [[using locked(s_UDTUnited.m_GlobControlLock)]]
-SRTSOCKET CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t link_flags)
+SRTSOCKET srt::CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t link_flags)
 {
     // Note: This function will lock pg->m_GroupLock!
 
@@ -3670,18 +3287,19 @@ SRTSOCKET CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t l
     // it right now so there's no need to lock s->m_ControlLock.
 
     // Check if there exists a group that this one is a peer of.
-    CUDTGroup* gp = s_UDTUnited.findPeerGroup_LOCKED(peergroup);
+    CUDTGroup* gp = uglobal().findPeerGroup_LOCKED(peergroup);
     bool was_empty = true;
     if (gp)
     {
         if (gp->type() != gtp)
         {
-            LOGC(gmlog.Error, log << "HS: GROUP TYPE COLLISION: peer group=$" << peergroup << " type " << gtp
-                << " agent group=$" << gp->id() << " type" << gp->type());
+            LOGC(gmlog.Error,
+                 log << CONID() << "HS: GROUP TYPE COLLISION: peer group=$" << peergroup << " type " << gtp
+                     << " agent group=$" << gp->id() << " type" << gp->type());
             return -1;
         }
 
-        HLOGC(gmlog.Debug, log << "makeMePeerOf: group for peer=$" << peergroup << " found: $" << gp->id());
+        HLOGC(gmlog.Debug, log << CONID() << "makeMePeerOf: group for peer=$" << peergroup << " found: $" << gp->id());
 
         if (!gp->groupEmpty())
             was_empty = false;
@@ -3701,7 +3319,7 @@ SRTSOCKET CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t l
         if (!gp->applyFlags(link_flags, m_SrtHsSide))
         {
             // Wrong settings. Must reject. Delete group.
-            s_UDTUnited.deleteGroup(gp);
+            uglobal().deleteGroup_LOCKED(gp);
             return -1;
         }
 
@@ -3713,10 +3331,11 @@ SRTSOCKET CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t l
         // Therefore such a group shall always be considered opened.
         gp->setOpen();
 
-        HLOGC(gmlog.Debug, log << "makeMePeerOf: no group has peer=$" << peergroup << " - creating new mirror group $" << gp->id());
+        HLOGC(gmlog.Debug,
+              log << CONID() << "makeMePeerOf: no group has peer=$" << peergroup << " - creating new mirror group $"
+                  << gp->id());
     }
 
-
     {
         ScopedLock glock (*gp->exp_groupLock());
         if (gp->closing())
@@ -3731,32 +3350,33 @@ SRTSOCKET CUDT::makeMePeerOf(SRTSOCKET peergroup, SRT_GROUP_TYPE gtp, uint32_t l
     }
 
     // Setting non-blocking reading for group socket.
-    s->core().m_bSynRecving = false;
-    s->core().m_bSynSending = false;
+    s->core().m_config.bSynRecving = false;
+    s->core().m_config.bSynSending = false;
 
     // Copy of addSocketToGroup. No idea how many parts could be common, not much.
 
     // Check if the socket already is in the group
-    CUDTGroup::gli_t f = gp->find(m_SocketID);
-    if (f != CUDTGroup::gli_NULL())
+    groups::SocketData* f;
+    if (gp->contains(m_SocketID, (f)))
     {
         // XXX This is internal error. Report it, but continue
         // (A newly created socket from acceptAndRespond should not have any group membership yet)
-        LOGC(gmlog.Error, log << "IPE (non-fatal): the socket is in the group, but has no clue about it!");
-        s->m_IncludedGroup = gp;
-        s->m_IncludedIter = f;
+        LOGC(gmlog.Error, log << CONID() << "IPE (non-fatal): the socket is in the group, but has no clue about it!");
+        s->m_GroupOf         = gp;
+        s->m_GroupMemberData = f;
         return 0;
     }
 
-    s->m_IncludedIter = gp->add(gp->prepareData(s));
-    s->m_IncludedGroup = gp;
+    s->m_GroupMemberData = gp->add(groups::prepareSocketData(s));
+    s->m_GroupOf = gp;
+    m_HSGroupType = gtp;
 
     // Record the remote address in the group data.
 
     return gp->id();
 }
 
-void CUDT::synchronizeWithGroup(CUDTGroup* gp)
+void srt::CUDT::synchronizeWithGroup(CUDTGroup* gp)
 {
     ScopedLock gl (*gp->exp_groupLock());
 
@@ -3770,22 +3390,19 @@ void CUDT::synchronizeWithGroup(CUDTGroup* gp)
 
     if (!gp->applyGroupTime((start_time), (peer_start_time)))
     {
-        HLOGC(gmlog.Debug, log << "synchronizeWithGroup: @" << m_SocketID
-                << " DERIVED: ST="
-                << FormatTime(m_stats.tsStartTime) << " -> "
-                << FormatTime(start_time) << " PST="
-                << FormatTime(m_tsRcvPeerStartTime) << " -> "
-                << FormatTime(peer_start_time));
-        m_stats.tsStartTime = start_time;
+        HLOGC(gmlog.Debug,
+              log << CONID() << "synchronizeWithGroup: ST=" << FormatTime(m_stats.tsStartTime) << " -> "
+                  << FormatTime(start_time) << " PST=" << FormatTime(m_tsRcvPeerStartTime) << " -> "
+                  << FormatTime(peer_start_time));
+        m_stats.tsStartTime  = start_time;
         m_tsRcvPeerStartTime = peer_start_time;
     }
     else
     {
         // This was the first connected socket and it defined start time.
-        HLOGC(gmlog.Debug, log << "synchronizeWithGroup: @" << m_SocketID
-                << " DEFINED: ST="
-                << FormatTime(m_stats.tsStartTime)
-                << " PST=" << FormatTime(m_tsRcvPeerStartTime));
+        HLOGC(gmlog.Debug,
+              log << CONID() << "synchronizeWithGroup: ST=" << FormatTime(m_stats.tsStartTime)
+                  << " PST=" << FormatTime(m_tsRcvPeerStartTime));
     }
 
     steady_clock::time_point rcv_buffer_time_base;
@@ -3809,17 +3426,19 @@ void CUDT::synchronizeWithGroup(CUDTGroup* gp)
         // time to not fill a network window.
         enterCS(m_RecvLock);
         m_pRcvBuffer->applyGroupTime(rcv_buffer_time_base, rcv_buffer_wrap_period, m_iTsbPdDelay_ms * 1000, rcv_buffer_udrift);
+        m_pRcvBuffer->setPeerRexmitFlag(m_bPeerRexmitFlag);
         leaveCS(m_RecvLock);
 
-        HLOGF(gmlog.Debug,  "AFTER HS: Set Rcv TsbPd mode: delay=%u.%03us GROUP TIME BASE: %s%s",
-                m_iTsbPdDelay_ms/1000,
-                m_iTsbPdDelay_ms%1000,
-                FormatTime(rcv_buffer_time_base).c_str(),
-                rcv_buffer_wrap_period ? " (WRAP PERIOD)" : " (NOT WRAP PERIOD)");
+        HLOGC(gmlog.Debug, log << "AFTER HS: Set Rcv TsbPd mode: delay="
+                << (m_iTsbPdDelay_ms/1000) << "." << (m_iTsbPdDelay_ms%1000)
+                << "s GROUP TIME BASE: " << FormatTime(rcv_buffer_time_base)
+                << " (" << (rcv_buffer_wrap_period ? "" : "NOT") << " WRAP PERIOD)");
     }
     else
     {
-        HLOGC(gmlog.Debug, log << "AFTER HS: (GROUP, but " << (m_bTsbPd ? "FIRST SOCKET is initialized normally)" : "no TSBPD set)"));
+        HLOGC(gmlog.Debug,
+              log << CONID() << "AFTER HS: (GROUP, but "
+                  << (m_bTsbPd ? "FIRST SOCKET is initialized normally)" : "no TSBPD set)"));
         updateSrtRcvSettings();
     }
 
@@ -3827,40 +3446,32 @@ void CUDT::synchronizeWithGroup(CUDTGroup* gp)
     // with updateAfterSrtHandshake().
     updateSrtSndSettings();
 
-    if (gp->synconmsgno())
+    // These are the values that are normally set initially by setters.
+    int32_t snd_isn = m_iSndLastAck, rcv_isn = m_iRcvLastAck;
+    if (!gp->applyGroupSequences(m_SocketID, (snd_isn), (rcv_isn)))
     {
-        HLOGC(gmlog.Debug, log << "synchronizeWithGroup: @" << m_SocketID << ": NOT synchronizing sequence numbers.");
+        HLOGC(gmlog.Debug,
+                log << CONID() << "synchronizeWithGroup: DERIVED ISN: RCV=%" << m_iRcvLastAck << " -> %" << rcv_isn
+                << " (shift by " << CSeqNo::seqcmp(rcv_isn, m_iRcvLastAck) << ") SND=%" << m_iSndLastAck
+                << " -> %" << snd_isn << " (shift by " << CSeqNo::seqcmp(snd_isn, m_iSndLastAck) << ")");
+        setInitialRcvSeq(rcv_isn);
+        setInitialSndSeq(snd_isn);
     }
     else
     {
-        // These are the values that are normally set initially by setters.
-        int32_t snd_isn = m_iSndLastAck, rcv_isn = m_iRcvLastAck;
-        if (!gp->applyGroupSequences(m_SocketID, (snd_isn), (rcv_isn)))
-        {
-            HLOGC(gmlog.Debug, log << "synchronizeWithGroup: @" << m_SocketID
-                    << " DERIVED ISN: RCV=%" << m_iRcvLastAck << " -> %" << rcv_isn
-                    << " (shift by " << CSeqNo::seqcmp(rcv_isn, m_iRcvLastAck)
-                    << ") SND=%" << m_iSndLastAck << " -> %" << snd_isn
-                    << " (shift by " << CSeqNo::seqcmp(snd_isn, m_iSndLastAck) << ")");
-            setInitialRcvSeq(rcv_isn);
-            setInitialSndSeq(snd_isn);
-        }
-        else
-        {
-            HLOGC(gmlog.Debug, log << "synchronizeWithGroup: @" << m_SocketID
-                    << " DEFINED ISN: RCV=%" << m_iRcvLastAck
-                    << " SND=%" << m_iSndLastAck);
-        }
+        HLOGC(gmlog.Debug,
+                log << CONID() << "synchronizeWithGroup: DEFINED ISN: RCV=%" << m_iRcvLastAck << " SND=%"
+                << m_iSndLastAck);
     }
 }
-
 #endif
-void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
+
+void srt::CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
 {
     ScopedLock cg (m_ConnectionLock);
 
     HLOGC(aclog.Debug, log << CONID() << "startConnect: -> " << serv_addr.str()
-            << (m_bSynRecving ? " (SYNCHRONOUS)" : " (ASYNCHRONOUS)") << "...");
+            << (m_config.bSynRecving ? " (SYNCHRONOUS)" : " (ASYNCHRONOUS)") << "...");
 
     if (!m_bOpened)
         throw CUDTException(MJ_NOTSUP, MN_NONE, 0);
@@ -3877,9 +3488,9 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     // register this socket in the rendezvous queue
     // RendezevousQueue is used to temporarily store incoming handshake, non-rendezvous connections also require this
     // function
-    steady_clock::duration ttl = m_tdConnTimeOut;
+    steady_clock::duration ttl = m_config.tdConnTimeOut;
 
-    if (m_bRendezvous)
+    if (m_config.bRendezvous)
         ttl *= 10;
 
     const steady_clock::time_point ttl_time = steady_clock::now() + ttl;
@@ -3892,8 +3503,12 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     // handle handshake extension flags.
     m_ConnReq.m_iType = UDT_DGRAM;
 
+    // Auto mode for Caller and in Rendezvous is equivalent to CIPHER_MODE_AES_CTR.
+    if (m_config.iCryptoMode == CSrtConfig::CIPHER_MODE_AUTO)
+        m_config.iCryptoMode = CSrtConfig::CIPHER_MODE_AES_CTR;
+
     // This is my current configuration
-    if (m_bRendezvous)
+    if (m_config.bRendezvous)
     {
         // For rendezvous, use version 5 in the waveahand and the cookie.
         // In case when you get the version 4 waveahand, simply switch to
@@ -3910,11 +3525,11 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
 
         // This will be also passed to a HSv4 rendezvous, but fortunately the old
         // SRT didn't read this field from URQ_WAVEAHAND message, only URQ_CONCLUSION.
-        m_ConnReq.m_iType           = SrtHSRequest::wrapFlags(false /* no MAGIC here */, m_iSndCryptoKeyLen);
-        bool whether SRT_ATR_UNUSED = m_iSndCryptoKeyLen != 0;
+        m_ConnReq.m_iType           = SrtHSRequest::wrapFlags(false /* no MAGIC here */, m_config.iSndCryptoKeyLen);
+        IF_HEAVY_LOGGING(const bool whether = m_config.iSndCryptoKeyLen != 0);
         HLOGC(aclog.Debug,
-              log << "startConnect (rnd): " << (whether ? "" : "NOT ")
-                  << " Advertising PBKEYLEN - value = " << m_iSndCryptoKeyLen);
+              log << CONID() << "startConnect (rnd): " << (whether ? "" : "NOT ")
+                  << " Advertising PBKEYLEN - value = " << m_config.iSndCryptoKeyLen);
         m_RdvState  = CHandShake::RDV_WAVING;
         m_SrtHsSide = HSD_DRAW; // initially not resolved.
     }
@@ -3935,26 +3550,26 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
         m_RdvState           = CHandShake::RDV_INVALID;
     }
 
-    m_ConnReq.m_iMSS            = m_iMSS;
-    m_ConnReq.m_iFlightFlagSize = (m_iRcvBufSize < m_iFlightFlagSize) ? m_iRcvBufSize : m_iFlightFlagSize;
+    m_ConnReq.m_iMSS            = m_config.iMSS;
+    // Defined as the size of the receiver buffer in packets, unless
+    // SRTO_FC has been set to a less value.
+    m_ConnReq.m_iFlightFlagSize = m_config.flightCapacity();
     m_ConnReq.m_iID             = m_SocketID;
     CIPAddress::ntop(serv_addr, (m_ConnReq.m_piPeerIP));
 
     if (forced_isn == SRT_SEQNO_NONE)
     {
         forced_isn = generateISN();
-        HLOGC(aclog.Debug, log << "startConnect: ISN generated = " << forced_isn);
+        HLOGC(aclog.Debug, log << CONID() << "startConnect: ISN generated = " << forced_isn);
     }
     else
     {
-        HLOGC(aclog.Debug, log << "startConnect: ISN forced = " << forced_isn);
+        HLOGC(aclog.Debug, log << CONID() << "startConnect: ISN forced = " << forced_isn);
     }
 
     m_iISN = m_ConnReq.m_iISN = forced_isn;
 
     setInitialSndSeq(m_iISN);
-    m_SndLastAck2Time = steady_clock::now();
-
     // Inform the server my configurations.
     CPacket reqpkt;
     reqpkt.setControl(UMSG_HANDSHAKE);
@@ -3971,7 +3586,7 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     // control of methods.)
 
     // ID = 0, connection request
-    reqpkt.m_iID = 0;
+    reqpkt.set_id(0);
 
     size_t hs_size = m_iMaxSRTPayloadSize;
     m_ConnReq.store_to((reqpkt.m_pcData), (hs_size));
@@ -3981,20 +3596,26 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     // necessarily is to be the size of the data.
     reqpkt.setLength(hs_size);
 
-    steady_clock::time_point now = steady_clock::now();
-    setPacketTS(reqpkt, now);
+    const steady_clock::time_point tnow = steady_clock::now();
+    m_SndLastAck2Time = tnow;
+    setPacketTS(reqpkt, tnow);
 
     HLOGC(cnlog.Debug,
-          log << CONID() << "CUDT::startConnect: REQ-TIME set HIGH (TimeStamp: " << reqpkt.m_iTimeStamp << "). SENDING HS: " << m_ConnReq.show());
+          log << CONID() << "CUDT::startConnect: REQ-TIME set HIGH (TimeStamp: " << reqpkt.timestamp()
+              << "). SENDING HS: " << m_ConnReq.show());
 
     /*
      * Race condition if non-block connect response thread scheduled before we set m_bConnecting to true?
      * Connect response will be ignored and connecting will wait until timeout.
      * Maybe m_ConnectionLock handling problem? Not used in CUDT::connect(const CPacket& response)
      */
-    m_tsLastReqTime = now;
+    m_tsLastReqTime = tnow;
     m_bConnecting = true;
-    m_pSndQueue->sendto(serv_addr, reqpkt);
+
+    // At this point m_SourceAddr is probably default-any, but this function
+    // now requires that the address be specified here because there will be
+    // no possibility to do it at any next stage of sending.
+    m_pSndQueue->sendto(serv_addr, reqpkt, m_SourceAddr);
 
     //
     ///
@@ -4009,7 +3630,7 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     //////////////////////////////////////////////////////
     // SYNCHRO BAR
     //////////////////////////////////////////////////////
-    if (!m_bSynRecving)
+    if (!m_config.bSynRecving)
     {
         HLOGC(cnlog.Debug, log << CONID() << "startConnect: ASYNC MODE DETECTED. Deferring the process to RcvQ:worker");
         return;
@@ -4028,10 +3649,14 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
 
     CUDTException  e;
     EConnectStatus cst = CONN_CONTINUE;
+    // This is a temporary place to store the DESTINATION IP from the incoming packet.
+    // We can't record this address yet until the cookie-confirmation is done, for safety reasons.
+    sockaddr_any use_source_adr(serv_addr.family());
 
     while (!m_bClosing)
     {
-        const steady_clock::duration tdiff = steady_clock::now() - m_tsLastReqTime;
+        const steady_clock::time_point local_tnow = steady_clock::now();
+        const steady_clock::duration tdiff = local_tnow - m_tsLastReqTime.load();
         // avoid sending too many requests, at most 1 request per 250ms
 
         // SHORT VERSION:
@@ -4044,12 +3669,12 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
         if (count_milliseconds(tdiff) > 250)
         {
             HLOGC(cnlog.Debug,
-                  log << "startConnect: LOOP: time to send (" << count_milliseconds(tdiff) << " > 250 ms). size=" << reqpkt.getLength());
+                  log << CONID() << "startConnect: LOOP: time to send (" << count_milliseconds(tdiff)
+                      << " > 250 ms). size=" << reqpkt.getLength());
 
-            if (m_bRendezvous)
-                reqpkt.m_iID = m_ConnRes.m_iID;
+            if (m_config.bRendezvous)
+                reqpkt.set_id(m_ConnRes.m_iID);
 
-            now = steady_clock::now();
 #if ENABLE_HEAVY_LOGGING
             {
                 CHandShake debughs;
@@ -4060,19 +3685,23 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             }
 #endif
 
-            m_tsLastReqTime       = now;
-            setPacketTS(reqpkt, now);
-            m_pSndQueue->sendto(serv_addr, reqpkt);
+            m_tsLastReqTime = local_tnow;
+            setPacketTS(reqpkt, local_tnow);
+            m_pSndQueue->sendto(serv_addr, reqpkt, use_source_adr);
         }
         else
         {
-            HLOGC(cnlog.Debug, log << "startConnect: LOOP: too early to send - " << count_milliseconds(tdiff) << " < 250ms");
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "startConnect: LOOP: too early to send - " << count_milliseconds(tdiff)
+                      << " < 250ms");
         }
 
         cst = CONN_CONTINUE;
         response.setLength(m_iMaxSRTPayloadSize);
         if (m_pRcvQueue->recvfrom(m_SocketID, (response)) > 0)
         {
+            use_source_adr = response.udpDestAddr();
+
             HLOGC(cnlog.Debug, log << CONID() << "startConnect: got response for connect request");
             cst = processConnectResponse(response, &e);
 
@@ -4107,14 +3736,32 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
                 // it means that it has done all that was required, however none of the below
                 // things has to be done (this function will do it by itself if needed).
                 // Otherwise the handshake rolling can be interrupted and considered complete.
-                cst = processRendezvous(response, serv_addr, RST_OK, (reqpkt));
+                cst = processRendezvous(&response, serv_addr, RST_OK, (reqpkt));
                 if (cst == CONN_CONTINUE)
                     continue;
-                break;
+
+                HLOGC(cnlog.Debug,
+                        log << CONID() << "startConnect: processRendezvous returned cst=" << ConnectStatusStr(cst));
+
+                if (cst == CONN_REJECT)
+                {
+                    // Just in case it wasn't set, set this as a fallback
+                    if (m_RejectReason == SRT_REJ_UNKNOWN)
+                        m_RejectReason = SRT_REJ_ROGUE;
+
+                    // rejection or erroneous code.
+                    reqpkt.setLength(m_iMaxSRTPayloadSize);
+                    reqpkt.setControl(UMSG_HANDSHAKE);
+                    sendRendezvousRejection(serv_addr, (reqpkt));
+                }
             }
 
             if (cst == CONN_REJECT)
+            {
+                HLOGC(cnlog.Debug,
+                        log << CONID() << "startConnect: REJECTED by processConnectResponse - sending SHUTDOWN");
                 sendCtrl(UMSG_SHUTDOWN);
+            }
 
             if (cst != CONN_CONTINUE && cst != CONN_CONFUSED)
                 break; // --> OUTSIDE-LOOP
@@ -4122,9 +3769,10 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             // IMPORTANT
             // [[using assert(m_pCryptoControl != nullptr)]];
 
-            // new request/response should be sent out immediately on receving a response
+            // new request/response should be sent out immediately on receiving a response
             HLOGC(cnlog.Debug,
-                  log << "startConnect: SYNC CONNECTION STATUS:" << ConnectStatusStr(cst) << ", REQ-TIME: LOW.");
+                  log << CONID() << "startConnect: SYNC CONNECTION STATUS:" << ConnectStatusStr(cst)
+                      << ", REQ-TIME: LOW.");
             m_tsLastReqTime = steady_clock::time_point();
 
             // Now serialize the handshake again to the existing buffer so that it's
@@ -4137,7 +3785,8 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             // small to store the CONCLUSION handshake (with HSv5 extensions).
             reqpkt.setLength(m_iMaxSRTPayloadSize);
 
-            HLOGC(cnlog.Debug, log << "startConnect: creating HS CONCLUSION: buffer size=" << reqpkt.getLength());
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "startConnect: creating HS CONCLUSION: buffer size=" << reqpkt.getLength());
 
             // NOTE: BUGFIX: SERIALIZE AGAIN.
             // The original UDT code didn't do it, so it was theoretically
@@ -4155,7 +3804,7 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             // are sent only when there is a rendezvous mode or non-blocking mode.
             if (!createSrtHandshake(SRT_CMD_HSREQ, SRT_CMD_KMREQ, 0, 0, (reqpkt), (m_ConnReq)))
             {
-                LOGC(cnlog.Warn, log << "createSrtHandshake failed - REJECTING.");
+                LOGC(cnlog.Warn, log << CONID() << "createSrtHandshake failed - REJECTING.");
                 cst = CONN_REJECT;
                 break;
             }
@@ -4167,14 +3816,15 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
         }
 
         HLOGC(cnlog.Debug,
-              log << "startConnect: timeout from Q:recvfrom, looping again; cst=" << ConnectStatusStr(cst));
+              log << CONID() << "startConnect: timeout from Q:recvfrom, looping again; cst=" << ConnectStatusStr(cst));
 
 #if ENABLE_HEAVY_LOGGING
         // Non-fatal assertion
         if (cst == CONN_REJECT) // Might be returned by processRendezvous
         {
             LOGC(cnlog.Error,
-                 log << "startConnect: IPE: cst=REJECT NOT EXPECTED HERE, the loop should've been interrupted!");
+                 log << CONID()
+                     << "startConnect: IPE: cst=REJECT NOT EXPECTED HERE, the loop should've been interrupted!");
             break;
         }
 #endif
@@ -4184,7 +3834,8 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             // timeout
             e = CUDTException(MJ_SETUP, MN_TIMEOUT, 0);
             m_RejectReason = SRT_REJ_TIMEOUT;
-            HLOGC(cnlog.Debug, log << "startConnect: TTL time " << FormatTime(ttl_time) << " exceeded, TIMEOUT.");
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "startConnect: TTL time " << FormatTime(ttl_time) << " exceeded, TIMEOUT.");
             break;
         }
     }
@@ -4207,7 +3858,7 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
             m_RejectReason = RejectReasonForURQ(m_ConnRes.m_iReqType);
             e              = CUDTException(MJ_SETUP, MN_REJECTED, 0);
         }
-        else if ((!m_bRendezvous) && (m_ConnRes.m_iISN != m_iISN)) // secuity check
+        else if ((!m_config.bRendezvous) && (m_ConnRes.m_iISN != m_iISN)) // secuity check
             e = CUDTException(MJ_SETUP, MN_SECURITY, 0);
     }
 
@@ -4221,18 +3872,17 @@ void CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     }
 
     HLOGC(cnlog.Debug,
-          log << CONID() << "startConnect: handshake exchange succeeded.");
+          log << CONID() << "startConnect: handshake exchange succeeded. sourceIP=" << m_SourceAddr.str());
 
     // Parameters at the end.
     HLOGC(cnlog.Debug,
-          log << "startConnect: END. Parameters:"
-                 " mss="
-              << m_iMSS << " max-cwnd-size=" << m_CongCtl->cgWindowMaxSize()
-              << " cwnd-size=" << m_CongCtl->cgWindowSize() << " rtt=" << m_iRTT << " bw=" << m_iBandwidth);
+          log << CONID() << "startConnect: END. Parameters: mss=" << m_config.iMSS
+              << " max-cwnd-size=" << m_CongCtl->cgWindowMaxSize() << " cwnd-size=" << m_CongCtl->cgWindowSize()
+              << " rtt=" << m_iSRTT << " bw=" << m_iBandwidth);
 }
 
 // Asynchronous connection
-EConnectStatus CUDT::processAsyncConnectResponse(const CPacket &pkt) ATR_NOEXCEPT
+EConnectStatus srt::CUDT::processAsyncConnectResponse(const CPacket &pkt) ATR_NOEXCEPT
 {
     EConnectStatus cst = CONN_CONTINUE;
     CUDTException  e;
@@ -4249,9 +3899,9 @@ EConnectStatus CUDT::processAsyncConnectResponse(const CPacket &pkt) ATR_NOEXCEP
     return cst;
 }
 
-bool CUDT::processAsyncConnectRequest(EReadStatus         rst,
+bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
                                       EConnectStatus      cst,
-                                      const CPacket&      response,
+                                      const CPacket*      pResponse /*[[nullable]]*/,
                                       const sockaddr_any& serv_addr)
 {
     // IMPORTANT!
@@ -4261,30 +3911,33 @@ bool CUDT::processAsyncConnectRequest(EReadStatus         rst,
     // This should have got the original value returned from
     // processConnectResponse through processAsyncConnectResponse.
 
-    CPacket request;
-    request.setControl(UMSG_HANDSHAKE);
-    request.allocate(m_iMaxSRTPayloadSize);
+    CPacket reqpkt;
+    reqpkt.setControl(UMSG_HANDSHAKE);
+    reqpkt.allocate(m_iMaxSRTPayloadSize);
     const steady_clock::time_point now = steady_clock::now();
-    setPacketTS(request, now);
+    setPacketTS(reqpkt, now);
 
     HLOGC(cnlog.Debug,
-          log << "processAsyncConnectRequest: REQ-TIME: HIGH. Should prevent too quick responses.");
+          log << CONID() << "processAsyncConnectRequest: REQ-TIME: HIGH. Should prevent too quick responses.");
     m_tsLastReqTime = now;
     // ID = 0, connection request
-    request.m_iID = !m_bRendezvous ? 0 : m_ConnRes.m_iID;
+    reqpkt.set_id(!m_config.bRendezvous ? 0 : m_ConnRes.m_iID);
 
     bool status = true;
 
     ScopedLock cg(m_ConnectionLock);
+    if (!m_bOpened) // Check the socket has not been closed before already.
+        return false;
 
     if (cst == CONN_RENDEZVOUS)
     {
-        HLOGC(cnlog.Debug, log << "processAsyncConnectRequest: passing to processRendezvous");
-        cst = processRendezvous(response, serv_addr, rst, (request));
+        HLOGC(cnlog.Debug, log << CONID() << "processAsyncConnectRequest: passing to processRendezvous");
+        cst = processRendezvous(pResponse, serv_addr, rst, (reqpkt));
         if (cst == CONN_ACCEPT)
         {
             HLOGC(cnlog.Debug,
-                  log << "processAsyncConnectRequest: processRendezvous completed the process and responded by itself. "
+                  log << CONID()
+                      << "processAsyncConnectRequest: processRendezvous completed the process and responded by itself. "
                          "Done.");
             return true;
         }
@@ -4293,7 +3946,13 @@ bool CUDT::processAsyncConnectRequest(EReadStatus         rst,
         {
             // processRendezvous already set the reject reason
             LOGC(cnlog.Warn,
-                 log << "processAsyncConnectRequest: REJECT reported from processRendezvous, not processing further.");
+                 log << CONID()
+                     << "processAsyncConnectRequest: REJECT reported from processRendezvous, not processing further.");
+
+            if (m_RejectReason == SRT_REJ_UNKNOWN)
+                m_RejectReason = SRT_REJ_ROGUE;
+
+            sendRendezvousRejection(serv_addr, (reqpkt));
             status = false;
         }
     }
@@ -4301,27 +3960,29 @@ bool CUDT::processAsyncConnectRequest(EReadStatus         rst,
     {
         // m_RejectReason already set at worker_ProcessAddressedPacket.
         LOGC(cnlog.Warn,
-             log << "processAsyncConnectRequest: REJECT reported from HS processing:"
-             << srt_rejectreason_str(m_RejectReason)
-             << "- not processing further"); //; REQ-TIME LOW"); XXX ?
+             log << CONID() << "processAsyncConnectRequest: REJECT reported from HS processing: "
+                 << srt_rejectreason_str(m_RejectReason) << " - not processing further");
         // m_tsLastReqTime = steady_clock::time_point(); XXX ?
         return false;
     }
     else
     {
         // (this procedure will be also run for HSv4 rendezvous)
-        HLOGC(cnlog.Debug, log << "processAsyncConnectRequest: serializing HS: buffer size=" << request.getLength());
-        if (!createSrtHandshake(SRT_CMD_HSREQ, SRT_CMD_KMREQ, 0, 0, (request), (m_ConnReq)))
+        HLOGC(cnlog.Debug,
+              log << CONID() << "processAsyncConnectRequest: serializing HS: buffer size=" << reqpkt.getLength());
+        if (!createSrtHandshake(SRT_CMD_HSREQ, SRT_CMD_KMREQ, 0, 0, (reqpkt), (m_ConnReq)))
         {
             // All 'false' returns from here are IPE-type, mostly "invalid argument" plus "all keys expired".
-            LOGC(cnlog.Error, log << "IPE: processAsyncConnectRequest: createSrtHandshake failed, dismissing.");
+            LOGC(cnlog.Error,
+                 log << CONID() << "IPE: processAsyncConnectRequest: createSrtHandshake failed, dismissing.");
             status = false;
         }
         else
         {
             HLOGC(cnlog.Debug,
-                  log << "processAsyncConnectRequest: sending HS reqtype=" << RequestTypeStr(m_ConnReq.m_iReqType)
-                      << " to socket " << request.m_iID << " size=" << request.getLength());
+                  log << CONID()
+                      << "processAsyncConnectRequest: sending HS reqtype=" << RequestTypeStr(m_ConnReq.m_iReqType)
+                      << " to socket " << reqpkt.id() << " size=" << reqpkt.getLength());
         }
     }
 
@@ -4331,25 +3992,47 @@ bool CUDT::processAsyncConnectRequest(EReadStatus         rst,
         /* XXX Shouldn't it send a single response packet for the rejection?
         // Set the version to 0 as "handshake rejection" status and serialize it
         CHandShake zhs;
-        size_t size = request.getLength();
-        zhs.store_to((request.m_pcData), (size));
-        request.setLength(size);
+        size_t size = reqpkt.getLength();
+        zhs.store_to((reqpkt.m_pcData), (size));
+        reqpkt.setLength(size);
         */
     }
 
-    HLOGC(cnlog.Debug, log << "processAsyncConnectRequest: setting REQ-TIME HIGH, SENDING HS:" << m_ConnReq.show());
+    HLOGC(cnlog.Debug,
+          log << CONID() << "processAsyncConnectRequest: setting REQ-TIME HIGH, SENDING HS:" << m_ConnReq.show());
     m_tsLastReqTime = steady_clock::now();
-    m_pSndQueue->sendto(serv_addr, request);
+    m_pSndQueue->sendto(serv_addr, reqpkt, m_SourceAddr);
     return status;
 }
 
-void CUDT::cookieContest()
+void srt::CUDT::sendRendezvousRejection(const sockaddr_any& serv_addr, CPacket& r_rsppkt)
+{
+    // We can reuse m_ConnReq because we are about to abandon the connection process.
+    m_ConnReq.m_iReqType = URQFailure(m_RejectReason);
+
+    // Assumed that r_rsppkt refers to a packet object that was already prepared
+    // to be used for storing the handshake there.
+    size_t size = r_rsppkt.getLength();
+    m_ConnReq.store_to((r_rsppkt.m_pcData), (size));
+    r_rsppkt.setLength(size);
+
+    HLOGC(cnlog.Debug, log << CONID() << "sendRendezvousRejection: using code=" << m_ConnReq.m_iReqType
+            << " for reject reason code " << m_RejectReason << " (" << srt_rejectreason_str(m_RejectReason) << ")");
+
+    setPacketTS(r_rsppkt, steady_clock::now());
+    m_pSndQueue->sendto(serv_addr, r_rsppkt, m_SourceAddr);
+}
+
+void srt::CUDT::cookieContest()
 {
     if (m_SrtHsSide != HSD_DRAW)
         return;
 
-    HLOGC(cnlog.Debug, log << "cookieContest: agent=" << m_ConnReq.m_iCookie << " peer=" << m_ConnRes.m_iCookie);
+    LOGC(cnlog.Debug,
+         log << CONID() << "cookieContest: agent=" << m_ConnReq.m_iCookie << " peer=" << m_ConnRes.m_iCookie);
 
+    // Here m_ConnReq.m_iCookie is a local cookie value sent in connection request to the peer.
+    // m_ConnRes.m_iCookie is a cookie value sent by the peer in its connection request.
     if (m_ConnReq.m_iCookie == 0 || m_ConnRes.m_iCookie == 0)
     {
         // Note that it's virtually impossible that Agent's cookie is not ready, this
@@ -4362,31 +4045,43 @@ void CUDT::cookieContest()
     //
     // The cookie contest must be repeated every time because it
     // may change the state at some point.
-    int better_cookie = m_ConnReq.m_iCookie - m_ConnRes.m_iCookie;
-
-    if (better_cookie > 0)
-    {
-        m_SrtHsSide = HSD_INITIATOR;
+    // 
+    // In SRT v1.4.3 and prior the below subtraction was performed in 32-bit arithmetic.
+    // The result of subtraction can overflow 32-bits. 
+    // Example
+    // m_ConnReq.m_iCookie = -1480577720;
+    // m_ConnRes.m_iCookie = 811599203;
+    // int64_t llBetterCookie = -1480577720 - 811599203 = -2292176923 (FFFF FFFF 7760 27E5);
+    // int32_t iBetterCookie  = 2002790373 (7760 27E5);
+    // 
+    // Now 64-bit arithmetic is used to calculate the actual result of subtraction.
+    // The 31-st bit is then checked to check if the resulting is negative in 32-bit aritmetics.
+    // This way the old contest behavior is preserved, and potential compiler optimisations are avoided.
+    const int64_t contest = int64_t(m_ConnReq.m_iCookie) - int64_t(m_ConnRes.m_iCookie);
+
+    if ((contest & 0xFFFFFFFF) == 0)
+    {
+        // DRAW! The only way to continue would be to force the
+        // cookies to be regenerated and to start over. But it's
+        // not worth a shot - this is an extremely rare case.
+        // This can simply do reject so that it can be started again.
+
+        // Pretend then that the cookie contest wasn't done so that
+        // it's done again. Cookies are baked every time anew, however
+        // the successful initial contest remains valid no matter how
+        // cookies will change.
+
+        m_SrtHsSide = HSD_DRAW;
         return;
     }
 
-    if (better_cookie < 0)
+    if (contest & 0x80000000)
     {
         m_SrtHsSide = HSD_RESPONDER;
         return;
     }
 
-    // DRAW! The only way to continue would be to force the
-    // cookies to be regenerated and to start over. But it's
-    // not worth a shot - this is an extremely rare case.
-    // This can simply do reject so that it can be started again.
-
-    // Pretend then that the cookie contest wasn't done so that
-    // it's done again. Cookies are baked every time anew, however
-    // the successful initial contest remains valid no matter how
-    // cookies will change.
-
-    m_SrtHsSide = HSD_DRAW;
+    m_SrtHsSide = HSD_INITIATOR;
 }
 
 // This function should complete the data for KMX needed for an out-of-band
@@ -4394,13 +4089,23 @@ void CUDT::cookieContest()
 // - There's no KMX (including first responder's handshake in rendezvous). This writes 0 to w_kmdatasize.
 // - The encryption status is failure. Respond with fail code and w_kmdatasize = 1.
 // - The last KMX was successful. Respond with the original kmdata and their size in w_kmdatasize.
-EConnectStatus CUDT::craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize)
+EConnectStatus srt::CUDT::craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize)
 {
     // If the last CONCLUSION message didn't contain the KMX extension, there's
     // no key recorded yet, so it can't be extracted. Mark this w_kmdatasize empty though.
     int hs_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
     if (IsSet(hs_flags, CHandShake::HS_EXT_KMREQ))
     {
+        // m_pCryptoControl can be NULL if the socket has been closed already. See issue #2231.
+        if (!m_pCryptoControl)
+        {
+            m_RejectReason = SRT_REJ_IPE;
+            LOGC(cnlog.Error,
+                 log << CONID() << "IPE: craftKmResponse needs to send KM, but CryptoControl does not exist."
+                     << " Socket state: connected=" << boolalpha << m_bConnected << ", connecting=" << m_bConnecting
+                     << ", broken=" << m_bBroken << ", opened " << m_bOpened << ", closing=" << m_bClosing << ".");
+            return CONN_REJECT;
+        }
         // This is a periodic handshake update, so you need to extract the KM data from the
         // first message, provided that it is there.
         size_t msgsize = m_pCryptoControl->getKmMsg_size(0);
@@ -4414,8 +4119,8 @@ EConnectStatus CUDT::craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize)
             case SRT_KM_S_BADSECRET:
                 {
                     HLOGC(cnlog.Debug,
-                            log << "craftKmResponse: No KMX recorded, status = "
-                            << KmStateStr(m_pCryptoControl->m_RcvKmState) << ". Respond it.");
+                          log << CONID() << "craftKmResponse: No KMX recorded, status = "
+                              << KmStateStr(m_pCryptoControl->m_RcvKmState) << ". Respond it.");
 
                     // Just do the same thing as in CCryptoControl::processSrtMsg_KMREQ for that case,
                     // that is, copy the NOSECRET code into KMX message.
@@ -4434,9 +4139,9 @@ EConnectStatus CUDT::craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize)
                     // Remaining situations:
                     // - password only on this site: shouldn't be considered to be sent to a no-password site
                     LOGC(cnlog.Error,
-                            log << "craftKmResponse: IPE: PERIODIC HS: NO KMREQ RECORDED KMSTATE: RCV="
-                            << KmStateStr(m_pCryptoControl->m_RcvKmState)
-                            << " SND=" << KmStateStr(m_pCryptoControl->m_SndKmState));
+                         log << CONID() << "craftKmResponse: IPE: PERIODIC HS: NO KMREQ RECORDED KMSTATE: RCV="
+                             << KmStateStr(m_pCryptoControl->m_RcvKmState)
+                             << " SND=" << KmStateStr(m_pCryptoControl->m_SndKmState));
                     return CONN_REJECT;
                 }
                 break;
@@ -4448,33 +4153,33 @@ EConnectStatus CUDT::craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize)
             if (msgsize > w_kmdatasize * 4)
             {
                 // Sanity check
-                LOGC(cnlog.Error, log << "IPE: KMX data not aligned to 4 bytes! size=" << msgsize);
+                LOGC(cnlog.Error, log << CONID() << "IPE: KMX data not aligned to 4 bytes! size=" << msgsize);
                 memset((aw_kmdata + (w_kmdatasize * 4)), 0, msgsize - (w_kmdatasize * 4));
                 ++w_kmdatasize;
             }
 
             HLOGC(cnlog.Debug,
-                    log << "craftKmResponse: getting KM DATA from the fore-recorded KMX from KMREQ, size="
-                    << w_kmdatasize);
+                  log << CONID() << "craftKmResponse: getting KM DATA from the fore-recorded KMX from KMREQ, size="
+                      << w_kmdatasize);
             memcpy((aw_kmdata), m_pCryptoControl->getKmMsg_data(0), msgsize);
         }
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "craftKmResponse: no KMX flag - not extracting KM data for KMRSP");
+        HLOGC(cnlog.Debug, log << CONID() << "craftKmResponse: no KMX flag - not extracting KM data for KMRSP");
         w_kmdatasize = 0;
     }
 
     return CONN_ACCEPT;
 }
 
-EConnectStatus CUDT::processRendezvous(
-    const CPacket& response, const sockaddr_any& serv_addr,
+EConnectStatus srt::CUDT::processRendezvous(
+    const CPacket* pResponse /*[[nullable]]*/, const sockaddr_any& serv_addr,
     EReadStatus rst, CPacket& w_reqpkt)
 {
     if (m_RdvState == CHandShake::RDV_CONNECTED)
     {
-        HLOGC(cnlog.Debug, log << "processRendezvous: already in CONNECTED state.");
+        HLOGC(cnlog.Debug, log << CONID() << "processRendezvous: already in CONNECTED state.");
         return CONN_ACCEPT;
     }
 
@@ -4490,7 +4195,7 @@ EConnectStatus CUDT::processRendezvous(
     {
         m_RejectReason = SRT_REJ_RDVCOOKIE;
         LOGC(cnlog.Error,
-             log << "COOKIE CONTEST UNRESOLVED: can't assign connection roles, please wait another minute.");
+             log << CONID() << "COOKIE CONTEST UNRESOLVED: can't assign connection roles, please wait another minute.");
         return CONN_REJECT;
     }
 
@@ -4508,7 +4213,8 @@ EConnectStatus CUDT::processRendezvous(
     {
         m_RejectReason = RejectReasonForURQ(rsp_type);
         HLOGC(cnlog.Debug,
-              log << "processRendezvous: rejecting due to switch-state response: " << RequestTypeStr(rsp_type));
+              log << CONID()
+                  << "processRendezvous: rejecting due to switch-state response: " << RequestTypeStr(rsp_type));
         return CONN_REJECT;
     }
     checkUpdateCryptoKeyLen("processRendezvous", m_ConnRes.m_iType);
@@ -4521,14 +4227,20 @@ EConnectStatus CUDT::processRendezvous(
     m_ConnReq.m_iReqType  = rsp_type;
     m_ConnReq.m_extension = needs_extension;
 
-    // This must be done before prepareConnectionObjects().
-    applyResponseSettings();
+    // This must be done before prepareConnectionObjects(), because it sets ISN and m_iMaxSRTPayloadSize needed to create buffers.
+    if (!applyResponseSettings(pResponse))
+    {
+        LOGC(cnlog.Error, log << CONID() << "processRendezvous: peer settings rejected");
+        return CONN_REJECT;
+    }
 
-    // This must be done before interpreting and creating HSv5 extensions.
-    if (!prepareConnectionObjects(m_ConnRes, m_SrtHsSide, 0))
+    // The CryptoControl must be created by the prepareConnectionObjects() before interpreting and creating HSv5 extensions
+    // because the it will be used there.
+    if (!prepareConnectionObjects(m_ConnRes, m_SrtHsSide, NULL) || !prepareBuffers(NULL))
     {
         // m_RejectReason already handled
-        HLOGC(cnlog.Debug, log << "processRendezvous: rejecting due to problems in prepareConnectionObjects.");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "processRendezvous: rejecting due to problems in prepareConnectionObjects.");
         return CONN_REJECT;
     }
 
@@ -4542,25 +4254,25 @@ EConnectStatus CUDT::processRendezvous(
             // We have JUST RECEIVED packet in this session (not that this is called as periodic update).
             // Sanity check
             m_tsLastReqTime = steady_clock::time_point();
-            if (response.getLength() == size_t(-1))
+            if (!pResponse || pResponse->getLength() == size_t(-1))
             {
                 m_RejectReason = SRT_REJ_IPE;
                 LOGC(cnlog.Fatal,
-                     log << "IPE: rst=RST_OK, but the packet has set -1 length - REJECTING (REQ-TIME: LOW)");
+                     log << CONID() << "IPE: rst=RST_OK, but the packet has set -1 length - REJECTING (REQ-TIME: LOW)");
                 return CONN_REJECT;
             }
 
-            if (!interpretSrtHandshake(m_ConnRes, response, kmdata, &kmdatasize))
+            if (!interpretSrtHandshake(m_ConnRes, *pResponse, kmdata, &kmdatasize))
             {
                 HLOGC(cnlog.Debug,
-                      log << "processRendezvous: rejecting due to problems in interpretSrtHandshake REQ-TIME: LOW.");
+                      log << CONID() << "processRendezvous: rejecting due to problems in interpretSrtHandshake REQ-TIME: LOW.");
                 return CONN_REJECT;
             }
 
             updateAfterSrtHandshake(HS_VERSION_SRT1);
 
             // Pass on, inform about the shortened response-waiting period.
-            HLOGC(cnlog.Debug, log << "processRendezvous: setting REQ-TIME: LOW. Forced to respond immediately.");
+            HLOGC(cnlog.Debug, log << CONID() << "processRendezvous: setting REQ-TIME: LOW. Forced to respond immediately.");
         }
         else
         {
@@ -4576,7 +4288,8 @@ EConnectStatus CUDT::processRendezvous(
         m_ConnReq.m_extension = true;
 
         HLOGC(cnlog.Debug,
-              log << "processRendezvous: HSREQ extension ok, creating HSRSP response. kmdatasize=" << kmdatasize);
+              log << CONID()
+                  << "processRendezvous: HSREQ extension ok, creating HSRSP response. kmdatasize=" << kmdatasize);
 
         w_reqpkt.setLength(m_iMaxSRTPayloadSize);
         if (!createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP,
@@ -4584,7 +4297,8 @@ EConnectStatus CUDT::processRendezvous(
                     (w_reqpkt), (m_ConnReq)))
         {
             HLOGC(cnlog.Debug,
-                  log << "processRendezvous: rejecting due to problems in createSrtHandshake. REQ-TIME: LOW");
+                  log << CONID()
+                      << "processRendezvous: rejecting due to problems in createSrtHandshake. REQ-TIME: LOW");
             m_tsLastReqTime = steady_clock::time_point();
             return CONN_REJECT;
         }
@@ -4603,27 +4317,30 @@ EConnectStatus CUDT::processRendezvous(
         // not be done in case of rendezvous. The section in postConnect() is
         // predicted to run only in regular CALLER handling.
 
-        if (rst != RST_OK || response.getLength() == size_t(-1))
+        if (rst != RST_OK || !pResponse || pResponse->getLength() == size_t(-1))
         {
             // Actually the -1 length would be an IPE, but it's likely that this was reported already.
             HLOGC(
                 cnlog.Debug,
-                log << "processRendezvous: no INCOMING packet, NOT interpreting extensions (relying on exising data)");
+                log << CONID()
+                    << "processRendezvous: no INCOMING packet, NOT interpreting extensions (relying on exising data)");
         }
         else
         {
             HLOGC(cnlog.Debug,
-                  log << "processRendezvous: INITIATOR, will send AGREEMENT - interpreting HSRSP extension");
-            if (!interpretSrtHandshake(m_ConnRes, response, 0, 0))
+                  log << CONID() << "processRendezvous: INITIATOR, will send AGREEMENT - interpreting HSRSP extension");
+            if (!interpretSrtHandshake(m_ConnRes, *pResponse, 0, 0))
             {
                 // m_RejectReason is already set, so set the reqtype accordingly
                 m_ConnReq.m_iReqType = URQFailure(m_RejectReason);
+                return CONN_REJECT;
             }
         }
         // This should be false, make a kinda assert here.
         if (needs_extension)
         {
-            LOGC(cnlog.Fatal, log << "IPE: INITIATOR responding AGREEMENT should declare no extensions to HS");
+            LOGC(cnlog.Fatal,
+                 log << CONID() << "IPE: INITIATOR responding AGREEMENT should declare no extensions to HS");
             m_ConnReq.m_extension = false;
         }
         updateAfterSrtHandshake(HS_VERSION_SRT1);
@@ -4636,13 +4353,13 @@ EConnectStatus CUDT::processRendezvous(
 
     if (rsp_type == URQ_DONE)
     {
-        HLOGC(cnlog.Debug, log << "... WON'T SEND any response, both sides considered connected");
+        HLOGC(cnlog.Debug, log << CONID() << "... WON'T SEND any response, both sides considered connected");
     }
     else
     {
         HLOGC(cnlog.Debug,
-              log << "... WILL SEND " << RequestTypeStr(rsp_type) << " " << (m_ConnReq.m_extension ? "with" : "without")
-                  << " SRT HS extensions");
+              log << CONID() << "... WILL SEND " << RequestTypeStr(rsp_type) << " "
+                  << (m_ConnReq.m_extension ? "with" : "without") << " SRT HS extensions");
     }
 
     // This marks the information for the serializer that
@@ -4654,14 +4371,11 @@ EConnectStatus CUDT::processRendezvous(
     w_reqpkt.setLength(m_iMaxSRTPayloadSize);
     if (m_RdvState == CHandShake::RDV_CONNECTED)
     {
-        // When synchro=false, don't lock a mutex for rendezvous queue.
-        // This is required when this function is called in the
-        // receive queue worker thread - it would lock itself.
-        int cst = postConnect(response, true, 0);
+        int cst = postConnect(pResponse, true, 0);
         if (cst == CONN_REJECT)
         {
             // m_RejectReason already set
-            HLOGC(cnlog.Debug, log << "processRendezvous: rejecting due to problems in postConnect.");
+            HLOGC(cnlog.Debug, log << CONID() << "processRendezvous: rejecting due to problems in postConnect.");
             return CONN_REJECT;
         }
     }
@@ -4672,7 +4386,7 @@ EConnectStatus CUDT::processRendezvous(
     // this time with URQ_AGREEMENT message, but still consider yourself connected.
     if (rsp_type == URQ_DONE)
     {
-        HLOGC(cnlog.Debug, log << "processRendezvous: rsp=DONE, reporting ACCEPT (nothing to respond)");
+        HLOGC(cnlog.Debug, log << CONID() << "processRendezvous: rsp=DONE, reporting ACCEPT (nothing to respond)");
         return CONN_ACCEPT;
     }
 
@@ -4686,7 +4400,7 @@ EConnectStatus CUDT::processRendezvous(
                 (w_reqpkt), (m_ConnReq)))
     {
         // m_RejectReason already set
-        LOGC(cnlog.Warn, log << "createSrtHandshake failed (IPE?), connection rejected. REQ-TIME: LOW");
+        LOGC(cnlog.Warn, log << CONID() << "createSrtHandshake failed (IPE?), connection rejected. REQ-TIME: LOW");
         m_tsLastReqTime = steady_clock::time_point();
         return CONN_REJECT;
     }
@@ -4711,9 +4425,10 @@ EConnectStatus CUDT::processRendezvous(
         m_tsLastReqTime                    = now;
         setPacketTS(w_reqpkt, now);
         HLOGC(cnlog.Debug,
-              log << "processRendezvous: rsp=AGREEMENT, reporting ACCEPT and sending just this one, REQ-TIME HIGH.");
+              log << CONID()
+                  << "processRendezvous: rsp=AGREEMENT, reporting ACCEPT and sending just this one, REQ-TIME HIGH.");
 
-        m_pSndQueue->sendto(serv_addr, w_reqpkt);
+        m_pSndQueue->sendto(serv_addr, w_reqpkt, m_SourceAddr);
 
         return CONN_ACCEPT;
     }
@@ -4728,13 +4443,14 @@ EConnectStatus CUDT::processRendezvous(
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "processRendezvous: REQ-TIME: remains previous value, consider yourself connected");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "processRendezvous: REQ-TIME: remains previous value, consider yourself connected");
     }
     return CONN_CONTINUE;
 }
 
 // [[using locked(m_ConnectionLock)]];
-EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTException* eout) ATR_NOEXCEPT
+EConnectStatus srt::CUDT::processConnectResponse(const CPacket& response, CUDTException* eout) ATR_NOEXCEPT
 {
     // NOTE: ASSUMED LOCK ON: m_ConnectionLock.
 
@@ -4750,7 +4466,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
     // This is required in HSv5 rendezvous, in which it should send the URQ_AGREEMENT message to
     // the peer, however switch to connected state.
     HLOGC(cnlog.Debug,
-          log << "processConnectResponse: TYPE:"
+          log << CONID() << "processConnectResponse: TYPE:"
               << (response.isControl() ? MessageTypeStr(response.getType(), response.getExtendedType())
                                        : string("DATA")));
     // ConnectStatus res = CONN_REJECT; // used later for status - must be declared here due to goto POST_CONNECT.
@@ -4758,7 +4474,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
     // For HSv4, the data sender is INITIATOR, and the data receiver is RESPONDER,
     // regardless of the connecting side affiliation. This will be changed for HSv5.
     bool          bidirectional = false;
-    HandshakeSide hsd           = m_bDataSender ? HSD_INITIATOR : HSD_RESPONDER;
+    HandshakeSide hsd           = m_config.bDataSender ? HSD_INITIATOR : HSD_RESPONDER;
     // (defined here due to 'goto' below).
 
     // SRT peer may send the SRT handshake private message (type 0x7fff) before a keep-alive.
@@ -4772,7 +4488,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
     // For the initial form this value should not be checked.
     bool hsv5 = m_ConnRes.m_iVersion >= HS_VERSION_SRT1;
 
-    if (m_bRendezvous &&
+    if (m_config.bRendezvous &&
         (m_RdvState == CHandShake::RDV_CONNECTED   // somehow Rendezvous-v5 switched it to CONNECTED.
          || !response.isControl()                  // WAS A PAYLOAD PACKET.
          || (response.getType() == UMSG_KEEPALIVE) // OR WAS A UMSG_KEEPALIVE message.
@@ -4793,7 +4509,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
             m_RdvState = CHandShake::RDV_CONNECTED;
         }
 
-        return postConnect(response, hsv5, eout);
+        return postConnect(&response, hsv5, eout);
     }
 
     if (!response.isControl(UMSG_HANDSHAKE))
@@ -4810,10 +4526,33 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
                      << "processConnectResponse: CONFUSED: expected UMSG_HANDSHAKE as connection not yet established, "
                         "got: "
                      << MessageTypeStr(response.getType(), response.getExtendedType()));
+
+            if (response.getType() == UMSG_SHUTDOWN)
+            {
+                LOGC(cnlog.Error,
+                        log << CONID() << "processConnectResponse: UMSG_SHUTDOWN received, rejecting connection.");
+                return CONN_REJECT;
+            }
+        }
+
+        if (m_config.bRendezvous)
+        {
+            // In rendezvous mode we expect that both sides are known
+            // to the service operator (unlike a listener, which may
+            // operate connections from unknown sources). This means that
+            // the connection process should be terminated anyway, on
+            // whichever side it would happen.
+            return CONN_REJECT;
         }
+
         return CONN_CONFUSED;
     }
 
+    if (m_config.bRendezvous)
+    {
+        m_SourceAddr = response.udpDestAddr();
+    }
+
     if (m_ConnRes.load_from(response.m_pcData, response.getLength()) == -1)
     {
         m_RejectReason = SRT_REJ_ROGUE;
@@ -4825,9 +4564,12 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
     }
 
     HLOGC(cnlog.Debug, log << CONID() << "processConnectResponse: HS RECEIVED: " << m_ConnRes.show());
-    if (m_ConnRes.m_iReqType > URQ_FAILURE_TYPES)
+    if (m_ConnRes.m_iReqType >= URQ_FAILURE_TYPES)
     {
         m_RejectReason = RejectReasonForURQ(m_ConnRes.m_iReqType);
+        LOGC(cnlog.Warn,
+                log << CONID() << "processConnectResponse: rejecting per reception of a rejection HS response: "
+                    << RequestTypeStr(m_ConnRes.m_iReqType));
         return CONN_REJECT;
     }
 
@@ -4836,7 +4578,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
         // Yes, we do abort to prevent buffer overrun. Set your MSS correctly
         // and you'll avoid problems.
         m_RejectReason = SRT_REJ_ROGUE;
-        LOGC(cnlog.Fatal, log << "MSS size " << m_iMSS << "exceeds MTU size!");
+        LOGC(cnlog.Fatal, log << CONID() << "MSS size " << m_config.iMSS << "exceeds MTU size!");
         return CONN_REJECT;
     }
 
@@ -4845,7 +4587,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
     // The CCryptoControl attached object must be created early
     // because it will be required to create a conclusion handshake in HSv5
     //
-    if (m_bRendezvous)
+    if (m_config.bRendezvous)
     {
         // SANITY CHECK: A rendezvous socket should reject any caller requests (it's not a listener)
         if (m_ConnRes.m_iReqType == URQ_INDUCTION)
@@ -4919,11 +4661,14 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
             // it means that it is HSv5 capable. It can still accept the HSv4 handshake.
             if (m_ConnRes.m_iVersion > HS_VERSION_UDT4)
             {
-                int hs_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
+                const int hs_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
 
                 if (hs_flags != SrtHSRequest::SRT_MAGIC_CODE)
                 {
-                    LOGC(cnlog.Warn, log << "processConnectResponse: Listener HSv5 did not set the SRT_MAGIC_CODE");
+                    LOGC(cnlog.Warn,
+                         log << CONID() << "processConnectResponse: Listener HSv5 did not set the SRT_MAGIC_CODE.");
+                    m_RejectReason = SRT_REJ_ROGUE;
+                    return CONN_REJECT;
                 }
 
                 checkUpdateCryptoKeyLen("processConnectResponse", m_ConnRes.m_iType);
@@ -4933,7 +4678,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
                 m_ConnReq.m_iVersion = HS_VERSION_SRT1;
                 // CONTROVERSIAL: use 0 as m_iType according to the meaning in HSv5.
                 // The HSv4 client might not understand it, which means that agent
-                // must switch itself to HSv4 rendezvous, and this time iType sould
+                // must switch itself to HSv4 rendezvous, and this time iType should
                 // be set to UDT_DGRAM value.
                 m_ConnReq.m_iType = 0;
 
@@ -4944,7 +4689,7 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
                 m_ConnReq.m_extension = true;
 
                 // For HSv5, the caller is INITIATOR and the listener is RESPONDER.
-                // The m_bDataSender value should be completely ignored and the
+                // The m_config.bDataSender value should be completely ignored and the
                 // connection is always bidirectional.
                 bidirectional = true;
                 hsd           = HSD_INITIATOR;
@@ -4963,31 +4708,48 @@ EConnectStatus CUDT::processConnectResponse(const CPacket& response, CUDTExcepti
         }
     }
 
-    return postConnect(response, false, eout);
+    return postConnect(&response, false, eout);
 }
 
-void CUDT::applyResponseSettings() ATR_NOEXCEPT
+bool srt::CUDT::applyResponseSettings(const CPacket* pHspkt /*[[nullable]]*/) ATR_NOEXCEPT
 {
+    if (!m_ConnRes.valid())
+    {
+        LOGC(cnlog.Error, log << CONID() << "applyResponseSettings: ROGUE HANDSHAKE - rejecting");
+        m_RejectReason = SRT_REJ_ROGUE;
+        return false;
+    }
+
     // Re-configure according to the negotiated values.
-    m_iMSS               = m_ConnRes.m_iMSS;
+    m_config.iMSS        = m_ConnRes.m_iMSS;
+
+    const size_t full_hdr_size = CPacket::UDP_HDR_SIZE + CPacket::HDR_SIZE;
+    m_iMaxSRTPayloadSize = m_config.iMSS - full_hdr_size;
+    HLOGC(cnlog.Debug, log << CONID() << "applyResponseSettings: PAYLOAD SIZE: " << m_iMaxSRTPayloadSize);
+
     m_iFlowWindowSize    = m_ConnRes.m_iFlightFlagSize;
-    int udpsize          = m_iMSS - CPacket::UDP_HDR_SIZE;
+    const int udpsize    = m_config.iMSS - CPacket::UDP_HDR_SIZE;
     m_iMaxSRTPayloadSize = udpsize - CPacket::HDR_SIZE;
     m_iPeerISN           = m_ConnRes.m_iISN;
 
     setInitialRcvSeq(m_iPeerISN);
 
-    m_iRcvCurrPhySeqNo = m_ConnRes.m_iISN - 1;
+    m_iRcvCurrPhySeqNo = CSeqNo::decseq(m_ConnRes.m_iISN);
     m_PeerID           = m_ConnRes.m_iID;
     memcpy((m_piSelfIP), m_ConnRes.m_piPeerIP, sizeof m_piSelfIP);
+    if (pHspkt)
+        m_SourceAddr = pHspkt->udpDestAddr();
 
     HLOGC(cnlog.Debug,
           log << CONID() << "applyResponseSettings: HANSHAKE CONCLUDED. SETTING: payload-size=" << m_iMaxSRTPayloadSize
-              << " mss=" << m_ConnRes.m_iMSS << " flw=" << m_ConnRes.m_iFlightFlagSize << " isn=" << m_ConnRes.m_iISN
-              << " peerID=" << m_ConnRes.m_iID);
+              << " mss=" << m_ConnRes.m_iMSS << " flw=" << m_ConnRes.m_iFlightFlagSize << " peer-ISN=" << m_ConnRes.m_iISN
+              << " local-ISN=" << m_iISN
+              << " peerID=" << m_ConnRes.m_iID
+              << " sourceIP=" << m_SourceAddr.str());
+    return true;
 }
 
-EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTException *eout) ATR_NOEXCEPT
+EConnectStatus srt::CUDT::postConnect(const CPacket* pResponse, bool rendezvous, CUDTException *eout) ATR_NOEXCEPT
 {
     if (m_ConnRes.m_iVersion < HS_VERSION_SRT1)
         m_tsRcvPeerStartTime = steady_clock::time_point(); // will be set correctly in SRT HS.
@@ -5006,6 +4768,22 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     // in rendezvous it's completed before calling this function.
     if (!rendezvous)
     {
+        HLOGC(cnlog.Debug, log << CONID() << boolalpha << "postConnect: packet:" << bool(pResponse) << " rendezvous:" << rendezvous);
+        // The "local storage depleted" case shouldn't happen here, but
+        // this is a theoretical path that needs prevention.
+        bool ok = pResponse;
+        if (!ok)
+        {
+            m_RejectReason = SRT_REJ_IPE;
+            if (eout)
+            {
+                *eout = CUDTException(MJ_SETUP, MN_REJECTED, 0);
+            }
+            return CONN_REJECT;
+        }
+
+        // [[assert (pResponse != NULL)]];
+
         // NOTE: THIS function must be called before calling prepareConnectionObjects.
         // The reason why it's not part of prepareConnectionObjects is that the activities
         // done there are done SIMILAR way in acceptAndRespond, which also calls this
@@ -5017,32 +4795,38 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
         //
         // Currently just this function must be called always BEFORE prepareConnectionObjects
         // everywhere except acceptAndRespond().
-        applyResponseSettings();
+        ok = applyResponseSettings(pResponse);
 
         // This will actually be done also in rendezvous HSv4,
         // however in this case the HSREQ extension will not be attached,
         // so it will simply go the "old way".
-        bool ok = prepareConnectionObjects(m_ConnRes, m_SrtHsSide, eout);
+        // (&&: skip if failed already)
+        // Must be called before interpretSrtHandshake() to create the CryptoControl.
+        ok = ok &&  prepareConnectionObjects(m_ConnRes, m_SrtHsSide, eout);
+
         // May happen that 'response' contains a data packet that was sent in rendezvous mode.
         // In this situation the interpretation of handshake was already done earlier.
-        if (ok && response.isControl())
+        ok = ok && pResponse->isControl();
+        ok = ok && interpretSrtHandshake(m_ConnRes, *pResponse, 0, 0);
+        ok = ok && prepareBuffers(eout);
+
+        if (!ok)
         {
-            ok = interpretSrtHandshake(m_ConnRes, response, 0, 0);
-            if (!ok && eout)
+            if (eout)
             {
                 *eout = CUDTException(MJ_SETUP, MN_REJECTED, 0);
             }
-        }
-        if (!ok) // m_RejectReason already set
+            // m_RejectReason already set
             return CONN_REJECT;
+        }
     }
 
     bool have_group = false;
 
     {
-#if ENABLE_EXPERIMENTAL_BONDING
-        ScopedLock cl (s_UDTUnited.m_GlobControlLock);
-        CUDTGroup* g = m_parent->m_IncludedGroup;
+#if ENABLE_BONDING
+        ScopedLock cl (uglobal().m_GlobControlLock);
+        CUDTGroup* g = m_parent->m_GroupOf;
         if (g)
         {
             // This is the last moment when this can be done.
@@ -5067,10 +4851,16 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     CInfoBlock::convert(m_PeerAddr, ib.m_piIP);
     if (m_pCache->lookup(&ib) >= 0)
     {
-        m_iRTT       = ib.m_iRTT;
+        m_iSRTT      = ib.m_iSRTT;
+        m_iRTTVar    = ib.m_iSRTT / 2;
         m_iBandwidth = ib.m_iBandwidth;
     }
 
+#if SRT_DEBUG_RTT
+    s_rtt_trace.trace(steady_clock::now(), "Connect", -1, -1,
+                      m_bIsFirstRTTReceived, -1, m_iSRTT, m_iRTTVar);
+#endif
+
     SRT_REJECT_REASON rr = setupCC();
     if (rr != SRT_REJ_UNKNOWN)
     {
@@ -5085,7 +4875,7 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     // the socket could have been started removal before this function
     // has started. Do a sanity check before you continue with the
     // connection process.
-    CUDTSocket* s = s_UDTUnited.locateSocket(m_SocketID);
+    CUDTSocket* s = uglobal().locateSocket(m_SocketID);
     if (s)
     {
         // The socket could be closed at this very moment.
@@ -5101,7 +4891,7 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     // XXX Problem around CONN_CONFUSED!
     // If some too-eager packets were received from a listener
     // that thinks it's connected, but his last handshake was missed,
-    // they are collected by CRcvQueue::storePkt. The removeConnector
+    // they are collected by CRcvQueue::storePktClone. The removeConnector
     // function will want to delete them all, so it would be nice
     // if these packets can be re-delivered. Of course the listener
     // should be prepared to resend them (as every packet can be lost
@@ -5123,7 +4913,7 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     // Ok, no more things to be done as per "clear connecting state"
     if (!s)
     {
-        LOGC(cnlog.Error, log << "Connection broken in the process - socket @" << m_SocketID << " closed");
+        LOGC(cnlog.Error, log << CONID() << "Connection broken in the process - socket closed");
         m_RejectReason = SRT_REJ_CLOSE;
         if (eout)
         {
@@ -5136,19 +4926,14 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     // the local port must be correctly assigned BEFORE CUDT::startConnect(),
     // otherwise if startConnect() fails, the multiplexer cannot be located
     // by garbage collection and will cause leak
-    s->m_pUDT->m_pSndQueue->m_pChannel->getSockAddr((s->m_SelfAddr));
-    CIPAddress::pton((s->m_SelfAddr), s->m_pUDT->m_piSelfIP, m_PeerAddr);
-
-    s->m_Status = SRTS_CONNECTED;
-
-    // acknowledde any waiting epolls to write
-    s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_CONNECT, true);
+    s->core().m_pSndQueue->m_pChannel->getSockAddr((s->m_SelfAddr));
+    CIPAddress::pton((s->m_SelfAddr), s->core().m_piSelfIP, m_PeerAddr);
 
     //int token = -1;
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     {
-        ScopedLock cl (s_UDTUnited.m_GlobControlLock);
-        CUDTGroup* g = m_parent->m_IncludedGroup;
+        ScopedLock cl (uglobal().m_GlobControlLock);
+        CUDTGroup* g = m_parent->m_GroupOf;
         if (g)
         {
             // XXX this might require another check of group type.
@@ -5157,13 +4942,13 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
             // LEAVING as comment for historical reasons. Locking is here most
             // likely not necessary because the socket cannot be removed from the
             // group until the socket isn't removed, and this requires locking of
-            // m_GlobControlLock. This should ensure that when m_IncludedGroup is
-            // not NULL, m_IncludedIter is also valid.
+            // m_GlobControlLock. This should ensure that when m_GroupOf is
+            // not NULL, m_GroupMemberData is also valid.
             // ScopedLock glock(g->m_GroupLock);
 
             HLOGC(cnlog.Debug, log << "group: Socket @" << m_parent->m_SocketID << " fresh connected, setting IDLE");
 
-            CUDTGroup::gli_t gi       = m_parent->m_IncludedIter;
+            groups::SocketData* gi       = m_parent->m_GroupMemberData;
             gi->sndstate   = SRT_GST_IDLE;
             gi->rcvstate   = SRT_GST_IDLE;
             gi->laststatus = SRTS_CONNECTED;
@@ -5173,6 +4958,11 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     }
 #endif
 
+    s->m_Status = SRTS_CONNECTED;
+
+    // acknowledde any waiting epolls to write
+    uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_CONNECT, true);
+
     CGlobEvent::triggerEvent();
 
 /* XXX Likely it should NOT be called here for two reasons:
@@ -5189,13 +4979,14 @@ EConnectStatus CUDT::postConnect(const CPacket &response, bool rendezvous, CUDTE
     }
 
     */
-
-    LOGC(cnlog.Note, log << CONID() << "Connection established to: " << m_PeerAddr.str());
+    
+    LOGC(cnlog.Note, log << CONID() << "Connection established from ("
+        << m_SourceAddr.str() << ") to peer @" << m_PeerID << " (" << m_PeerAddr.str() << ")");
 
     return CONN_ACCEPT;
 }
 
-void CUDT::checkUpdateCryptoKeyLen(const char *loghdr SRT_ATR_UNUSED, int32_t typefield)
+void srt::CUDT::checkUpdateCryptoKeyLen(const char *loghdr SRT_ATR_UNUSED, int32_t typefield)
 {
     int enc_flags = SrtHSRequest::SRT_HSTYPE_ENCFLAGS::unwrap(typefield);
 
@@ -5205,42 +4996,44 @@ void CUDT::checkUpdateCryptoKeyLen(const char *loghdr SRT_ATR_UNUSED, int32_t ty
     if (enc_flags >= 2 && enc_flags <= 4) // 2 = 128, 3 = 192, 4 = 256
     {
         int rcv_pbkeylen = SrtHSRequest::SRT_PBKEYLEN_BITS::wrap(enc_flags);
-        if (m_iSndCryptoKeyLen == 0)
+        if (m_config.iSndCryptoKeyLen == 0)
         {
-            m_iSndCryptoKeyLen = rcv_pbkeylen;
-            HLOGC(cnlog.Debug, log << loghdr << ": PBKEYLEN adopted from advertised value: " << m_iSndCryptoKeyLen);
+            m_config.iSndCryptoKeyLen = rcv_pbkeylen;
+            HLOGC(cnlog.Debug,
+                  log << CONID() << loghdr
+                      << ": PBKEYLEN adopted from advertised value: " << m_config.iSndCryptoKeyLen);
         }
-        else if (m_iSndCryptoKeyLen != rcv_pbkeylen)
+        else if (m_config.iSndCryptoKeyLen != rcv_pbkeylen)
         {
             // Conflict. Use SRTO_SENDER flag to check if this side should accept
             // the enforcement, otherwise simply let it win.
-            if (!m_bDataSender)
+            if (!m_config.bDataSender)
             {
                 LOGC(cnlog.Warn,
-                     log << loghdr << ": PBKEYLEN conflict - OVERRIDDEN " << m_iSndCryptoKeyLen << " by "
-                         << rcv_pbkeylen << " from PEER (as AGENT is not SRTO_SENDER)");
-                m_iSndCryptoKeyLen = rcv_pbkeylen;
+                     log << CONID() << loghdr << ": PBKEYLEN conflict - OVERRIDDEN " << m_config.iSndCryptoKeyLen
+                         << " by " << rcv_pbkeylen << " from PEER (as AGENT is not SRTO_SENDER)");
+                m_config.iSndCryptoKeyLen = rcv_pbkeylen;
             }
             else
             {
                 LOGC(cnlog.Warn,
-                     log << loghdr << ": PBKEYLEN conflict - keep " << m_iSndCryptoKeyLen
+                     log << CONID() << loghdr << ": PBKEYLEN conflict - keep " << m_config.iSndCryptoKeyLen
                          << "; peer-advertised PBKEYLEN " << rcv_pbkeylen << " rejected because Agent is SRTO_SENDER");
             }
         }
     }
     else if (enc_flags != 0)
     {
-        LOGC(cnlog.Error, log << loghdr << ": IPE: enc_flags outside allowed 2, 3, 4: " << enc_flags);
+        LOGC(cnlog.Error, log << CONID() << loghdr << ": IPE: enc_flags outside allowed 2, 3, 4: " << enc_flags);
     }
     else
     {
-        HLOGC(cnlog.Debug, log << loghdr << ": No encryption flags found in type field: " << typefield);
+        HLOGC(cnlog.Debug, log << CONID() << loghdr << ": No encryption flags found in type field: " << typefield);
     }
 }
 
 // Rendezvous
-void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extension, bool& w_needs_hsrsp)
+void srt::CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extension, bool& w_needs_hsrsp)
 {
     UDTRequestType req           = m_ConnRes.m_iReqType;
     int            hs_flags      = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
@@ -5286,7 +5079,7 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
 
 #if ENABLE_HEAVY_LOGGING
 
-    HLOGC(cnlog.Debug, log << "rendezvousSwitchState: HS: " << m_ConnRes.show());
+    HLOGC(cnlog.Debug, log << CONID() << "rendezvousSwitchState: HS: " << m_ConnRes.show());
 
     struct LogAtTheEnd
     {
@@ -5371,10 +5164,10 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
                 // If no HSRSP attached, stay in this state.
                 if (hs_flags == 0)
                 {
-                    HLOGC(
-                        cnlog.Debug,
-                        log << "rendezvousSwitchState: "
-                               "{INITIATOR}[ATTENTION] awaits CONCLUSION+HSRSP, got CONCLUSION, remain in [ATTENTION]");
+                    HLOGC(cnlog.Debug,
+                          log << CONID()
+                              << "rendezvousSwitchState: {INITIATOR}[ATTENTION] awaits CONCLUSION+HSRSP, got "
+                                 "CONCLUSION, remain in [ATTENTION]");
                     w_rsptype         = URQ_CONCLUSION;
                     w_needs_extension = true; // If you expect to receive HSRSP, continue sending HSREQ
                     return;
@@ -5391,10 +5184,10 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
                 // (Although this seems completely impossible).
                 if (hs_flags == 0)
                 {
-                    LOGC(
-                        cnlog.Warn,
-                        log << "rendezvousSwitchState: (IPE!)"
-                               "{RESPONDER}[ATTENTION] awaits CONCLUSION+HSREQ, got CONCLUSION, remain in [ATTENTION]");
+                    LOGC(cnlog.Warn,
+                         log << CONID()
+                             << "rendezvousSwitchState: (IPE!){RESPONDER}[ATTENTION] awaits CONCLUSION+HSREQ, got "
+                                "CONCLUSION, remain in [ATTENTION]");
                     w_rsptype         = URQ_CONCLUSION;
                     w_needs_extension = false; // If you received WITHOUT extensions, respond WITHOUT extensions (wait
                                                // for the right message)
@@ -5407,7 +5200,7 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
                 return;
             }
 
-            LOGC(cnlog.Error, log << "RENDEZVOUS COOKIE DRAW! Cannot resolve to a valid state.");
+            LOGC(cnlog.Error, log << CONID() << "RENDEZVOUS COOKIE DRAW! Cannot resolve to a valid state.");
             // Fallback for cookie draw
             m_RdvState = CHandShake::RDV_INVALID;
             w_rsptype   = URQFailure(SRT_REJ_RDVCOOKIE);
@@ -5472,7 +5265,8 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
                 // Received REPEATED empty conclusion that has initially switched it into FINE state.
                 // To exit FINE state we need the CONCLUSION message with HSRSP.
                 HLOGC(cnlog.Debug,
-                      log << "rendezvousSwitchState: {INITIATOR}[FINE] <CONCLUSION without HSRSP. Stay in [FINE], "
+                      log << CONID()
+                          << "rendezvousSwitchState: {INITIATOR}[FINE] <CONCLUSION without HSRSP. Stay in [FINE], "
                              "await CONCLUSION+HSRSP");
             }
             else if (hsd == HSD_RESPONDER)
@@ -5483,7 +5277,8 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
                 // so if this is a repeated CONCLUSION+HSREQ, it should be responded with
                 // CONCLUSION+HSRSP.
                 HLOGC(cnlog.Debug,
-                      log << "rendezvousSwitchState: {RESPONDER}[FINE] <CONCLUSION. Stay in [FINE], await AGREEMENT");
+                      log << CONID()
+                          << "rendezvousSwitchState: {RESPONDER}[FINE] <CONCLUSION. Stay in [FINE], await AGREEMENT");
             }
             else
             {
@@ -5531,11 +5326,11 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
             // No matter in which state we'd be, just switch to connected.
             if (m_RdvState == CHandShake::RDV_CONNECTED)
             {
-                HLOGC(cnlog.Debug, log << "<-- AGREEMENT: already connected");
+                HLOGC(cnlog.Debug, log << CONID() << "<-- AGREEMENT: already connected");
             }
             else
             {
-                HLOGC(cnlog.Debug, log << "<-- AGREEMENT: switched to connected");
+                HLOGC(cnlog.Debug, log << CONID() << "<-- AGREEMENT: switched to connected");
             }
             m_RdvState = CHandShake::RDV_CONNECTED;
             w_rsptype   = URQ_DONE;
@@ -5551,8 +5346,8 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
             if (hsd == HSD_RESPONDER)
             {
                 HLOGC(cnlog.Debug,
-                      log << "rendezvousSwitchState: "
-                             "{RESPONDER}[INITIATED] awaits AGREEMENT, "
+                      log << CONID()
+                          << "rendezvousSwitchState: {RESPONDER}[INITIATED] awaits AGREEMENT, "
                              "got CONCLUSION, sending CONCLUSION+HSRSP");
                 w_needs_extension = true;
                 w_needs_hsrsp     = true;
@@ -5566,16 +5361,16 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
             if (hs_flags == 0)
             {
                 HLOGC(cnlog.Debug,
-                      log << "rendezvousSwitchState: "
-                             "{INITIATOR}[INITIATED] awaits AGREEMENT, "
+                      log << CONID()
+                          << "rendezvousSwitchState: {INITIATOR}[INITIATED] awaits AGREEMENT, "
                              "got empty CONCLUSION, STILL RESPONDING CONCLUSION+HSRSP");
             }
             else
             {
 
                 HLOGC(cnlog.Debug,
-                      log << "rendezvousSwitchState: "
-                             "{INITIATOR}[INITIATED] awaits AGREEMENT, "
+                      log << CONID()
+                          << "rendezvousSwitchState: {INITIATOR}[INITIATED] awaits AGREEMENT, "
                              "got CONCLUSION+HSREQ, responding CONCLUSION+HSRSP");
             }
             w_needs_extension = true;
@@ -5593,7 +5388,7 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
         return;
     }
 
-    HLOGC(cnlog.Debug, log << "rendezvousSwitchState: INVALID STATE TRANSITION, result: INVALID");
+    HLOGC(cnlog.Debug, log << CONID() << "rendezvousSwitchState: INVALID STATE TRANSITION, result: INVALID");
     // All others are treated as errors
     m_RdvState = CHandShake::RDV_WAVING;
     w_rsptype   = URQFailure(SRT_REJ_ROGUE);
@@ -5604,128 +5399,118 @@ void CUDT::rendezvousSwitchState(UDTRequestType& w_rsptype, bool& w_needs_extens
  * This thread runs only if TsbPd mode is enabled
  * Hold received packets until its time to 'play' them, at PktTimeStamp + TsbPdDelay.
  */
-void *CUDT::tsbpd(void *param)
+void * srt::CUDT::tsbpd(void* param)
 {
-    CUDT *self = (CUDT *)param;
+    CUDT* self = (CUDT*)param;
 
     THREAD_STATE_INIT("SRT:TsbPd");
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // Make the TSBPD thread a "client" of the group,
     // which will ensure that the group will not be physically
     // deleted until this thread exits.
     // NOTE: DO NOT LEAD TO EVER CANCEL THE THREAD!!!
-    CUDTUnited::GroupKeeper gkeeper (self->s_UDTUnited, self->m_parent);
+    CUDTUnited::GroupKeeper gkeeper(self->uglobal(), self->m_parent);
 #endif
 
-    UniqueLock recv_lock  (self->m_RecvLock);
-    CSync recvdata_cc (self->m_RecvDataCond, recv_lock);
-    CSync tsbpd_cc    (self->m_RcvTsbPdCond, recv_lock);
+    CUniqueSync recvdata_lcc (self->m_RecvLock, self->m_RecvDataCond);
+    CSync tsbpd_cc(self->m_RcvTsbPdCond, recvdata_lcc.locker());
 
-    self->m_bTsbPdAckWakeup = true;
+    self->m_bTsbPdNeedsWakeup = true;
     while (!self->m_bClosing)
     {
-        int32_t                  current_pkt_seq = 0;
-        steady_clock::time_point tsbpdtime;
+        steady_clock::time_point tsNextDelivery; // Next packet delivery time
         bool                     rxready = false;
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         bool shall_update_group = false;
 #endif
 
+        INCREMENT_THREAD_ITERATIONS();
+
         enterCS(self->m_RcvBufferLock);
+        const steady_clock::time_point tnow = steady_clock::now();
 
-        self->m_pRcvBuffer->updRcvAvgDataSize(steady_clock::now());
+        self->m_pRcvBuffer->updRcvAvgDataSize(tnow);
+        const srt::CRcvBuffer::PacketInfo info = self->m_pRcvBuffer->getFirstValidPacketInfo();
 
-        if (self->m_bTLPktDrop)
-        {
-            int32_t skiptoseqno = SRT_SEQNO_NONE;
-            bool    passack     = true; // Get next packet to wait for even if not acked
+        const bool is_time_to_deliver = !is_zero(info.tsbpd_time) && (tnow >= info.tsbpd_time);
+        tsNextDelivery = info.tsbpd_time;
 
-            rxready = self->m_pRcvBuffer->getRcvFirstMsg((tsbpdtime), (passack), (skiptoseqno), (current_pkt_seq));
+#if ENABLE_HEAVY_LOGGING
+        if (info.seqno == SRT_SEQNO_NONE)
+        {
+            HLOGC(tslog.Debug, log << self->CONID() << "sok/tsbpd: packet check: NO PACKETS");
+        }
+        else
+        {
+            HLOGC(tslog.Debug, log << self->CONID() << "sok/tsbpd: packet check: %"
+                << info.seqno << " T=" << FormatTime(tsNextDelivery)
+                << " diff-now-playtime=" << FormatDuration(tnow - tsNextDelivery)
+                << " ready=" << is_time_to_deliver
+                << " ondrop=" << info.seq_gap);
+        }
+#endif
 
-            HLOGC(tslog.Debug,
-                  log << boolalpha << "NEXT PKT CHECK: rdy=" << rxready << " passack=" << passack << " skipto=%"
-                      << skiptoseqno << " current=%" << current_pkt_seq << " buf-base=%" << self->m_iRcvLastSkipAck);
-            /*
-             * VALUES RETURNED:
-             *
-             * rxready:     if true, packet at head of queue ready to play
-             * tsbpdtime:   timestamp of packet at head of queue, ready or not. 0 if none.
-             * passack:     if true, ready head of queue not yet acknowledged
-             * skiptoseqno: sequence number of packet at head of queue if ready to play but
-             *              some preceeding packets are missing (need to be skipped). -1 if none.
-             */
-            if (rxready)
+        if (!self->m_bTLPktDrop)
+        {
+            rxready = !info.seq_gap && is_time_to_deliver;
+        }
+        else if (is_time_to_deliver)
+        {
+            rxready = true;
+            if (info.seq_gap)
             {
-                /* Packet ready to play according to time stamp but... */
-                int seqlen = CSeqNo::seqoff(self->m_iRcvLastSkipAck, skiptoseqno);
-
-                if (skiptoseqno != SRT_SEQNO_NONE && seqlen > 0)
-                {
-                    /*
-                     * skiptoseqno != SRT_SEQNO_NONE,
-                     * packet ready to play but preceeded by missing packets (hole).
-                     */
-
-                    self->updateForgotten(seqlen, self->m_iRcvLastSkipAck, skiptoseqno);
-                    self->m_pRcvBuffer->skipData(seqlen);
-
-                    self->m_iRcvLastSkipAck = skiptoseqno;
-#if ENABLE_EXPERIMENTAL_BONDING
-                    shall_update_group = true;
+                const int iDropCnt SRT_ATR_UNUSED = self->rcvDropTooLateUpTo(info.seqno);
+#if ENABLE_BONDING
+                shall_update_group = true;
 #endif
 
 #if ENABLE_LOGGING
-                    int64_t timediff_us = 0;
-                    if (!is_zero(tsbpdtime))
-                        timediff_us = count_microseconds(steady_clock::now() - tsbpdtime);
+                const int64_t timediff_us = count_microseconds(tnow - info.tsbpd_time);
 #if ENABLE_HEAVY_LOGGING
-                    HLOGC(tslog.Debug,
-                          log << self->CONID() << "tsbpd: DROPSEQ: up to seqno %" << CSeqNo::decseq(skiptoseqno) << " ("
-                              << seqlen << " packets) playable at " << FormatTime(tsbpdtime) << " delayed "
-                              << (timediff_us / 1000) << "." << std::setw(3) << std::setfill('0') << (timediff_us % 1000) << " ms");
-#endif
-                    LOGC(brlog.Warn,
-                         log << "RCV-DROPPED " << seqlen << " packet(s), packet seqno %" << skiptoseqno
-                             << " delayed for " << (timediff_us / 1000) << "." << std::setw(3) << std::setfill('0')
-                             << (timediff_us % 1000) << " ms");
+                HLOGC(tslog.Debug,
+                    log << self->CONID() << "tsbpd: DROPSEQ: up to seqno %" << CSeqNo::decseq(info.seqno) << " ("
+                    << iDropCnt << " packets) playable at " << FormatTime(info.tsbpd_time) << " delayed "
+                    << (timediff_us / 1000) << "." << std::setw(3) << std::setfill('0') << (timediff_us % 1000) << " ms");
 #endif
-
-                    tsbpdtime = steady_clock::time_point(); //Next sent ack will unblock
-                    rxready   = false;
+                string why;
+                if (self->frequentLogAllowed(FREQLOGFA_RCV_DROPPED, tnow, (why)))
+                {
+                    LOGC(brlog.Warn, log << self->CONID() << "RCV-DROPPED " << iDropCnt << " packet(s). Packet seqno %" << info.seqno
+                            << " delayed for " << (timediff_us / 1000) << "." << std::setw(3) << std::setfill('0')
+                            << (timediff_us % 1000) << " ms " << why);
                 }
-                else if (passack)
+#if SRT_ENABLE_FREQUENT_LOG_TRACE
+                else
                 {
-                    /* Packets ready to play but not yet acknowledged (should happen within 10ms) */
-                    rxready   = false;
-                    tsbpdtime = steady_clock::time_point(); // Next sent ack will unblock
-                }                  /* else packet ready to play */
-            }                      /* else packets not ready to play */
-        }
-        else
-        {
-            rxready = self->m_pRcvBuffer->isRcvDataReady((tsbpdtime), (current_pkt_seq), -1 /*get first ready*/);
+                    LOGC(brlog.Warn, log << "SUPPRESSED: RCV-DROPPED LOG: " << why);
+                }
+#endif
+#endif
+
+                tsNextDelivery = steady_clock::time_point(); // Ready to read, nothing to wait for.
+            }
         }
         leaveCS(self->m_RcvBufferLock);
 
         if (rxready)
         {
             HLOGC(tslog.Debug,
-                  log << self->CONID() << "tsbpd: PLAYING PACKET seq=" << current_pkt_seq << " (belated "
-                      << (count_milliseconds(steady_clock::now() - tsbpdtime)) << "ms)");
+                  log << self->CONID() << "tsbpd: PLAYING PACKET seq=" << info.seqno << " (belated "
+                      << FormatDuration<DUNIT_MS>(steady_clock::now() - info.tsbpd_time) << ")");
             /*
              * There are packets ready to be delivered
              * signal a waiting "recv" call if there is any data available
              */
-            if (self->m_bSynRecving)
+            if (self->m_config.bSynRecving)
             {
-                recvdata_cc.signal_locked(recv_lock);
+                recvdata_lcc.notify_one();
             }
             /*
              * Set EPOLL_IN to wakeup any thread waiting on epoll
              */
-            self->s_UDTUnited.m_EPoll.update_events(self->m_SocketID, self->m_sPollID, SRT_EPOLL_IN, true);
-#if ENABLE_EXPERIMENTAL_BONDING
+            self->uglobal().m_EPoll.update_events(self->m_SocketID, self->m_sPollID, SRT_EPOLL_IN, true);
+#if ENABLE_BONDING
             // If this is NULL, it means:
             // - the socket never was a group member
             // - the socket was a group member, but:
@@ -5754,8 +5539,8 @@ void *CUDT::tsbpd(void *param)
                 // When the group is read-ready, it should update its pollers as it sees fit.
 
                 // NOTE: this call will set lock to m_IncludedGroup->m_GroupLock
-                HLOGC(tslog.Debug, log << self->CONID() << "tsbpd: GROUP: checking if %" << current_pkt_seq << " makes group readable");
-                gkeeper.group->updateReadState(self->m_SocketID, current_pkt_seq);
+                HLOGC(tslog.Debug, log << self->CONID() << "tsbpd: GROUP: checking if %" << info.seqno << " makes group readable");
+                gkeeper.group->updateReadState(self->m_SocketID, info.seqno);
 
                 if (shall_update_group)
                 {
@@ -5768,22 +5553,28 @@ void *CUDT::tsbpd(void *param)
             }
 #endif
             CGlobEvent::triggerEvent();
-            tsbpdtime = steady_clock::time_point();
+            tsNextDelivery = steady_clock::time_point(); // Ready to read, nothing to wait for.
         }
 
-        if (!is_zero(tsbpdtime))
+        // We may just briefly unlocked the m_RecvLock, so we need to check m_bClosing again to avoid deadlock.
+        if (self->m_bClosing)
+            break;
+
+        SRT_ATR_UNUSED bool bWokeUpOnSignal = true;
+
+        if (!is_zero(tsNextDelivery))
         {
-            const steady_clock::duration timediff = tsbpdtime - steady_clock::now();
+            IF_HEAVY_LOGGING(const steady_clock::duration timediff = tsNextDelivery - tnow);
             /*
              * Buffer at head of queue is not ready to play.
              * Schedule wakeup when it will be.
              */
-            self->m_bTsbPdAckWakeup = false;
+            self->m_bTsbPdNeedsWakeup = false;
             HLOGC(tslog.Debug,
-                  log << self->CONID() << "tsbpd: FUTURE PACKET seq=" << current_pkt_seq
-                      << " T=" << FormatTime(tsbpdtime) << " - waiting " << count_milliseconds(timediff) << "ms");
+                  log << self->CONID() << "tsbpd: FUTURE PACKET seq=" << info.seqno
+                      << " T=" << FormatTime(tsNextDelivery) << " - waiting " << FormatDuration<DUNIT_MS>(timediff));
             THREAD_PAUSED();
-            tsbpd_cc.wait_for(timediff);
+            bWokeUpOnSignal = tsbpd_cc.wait_until(tsNextDelivery);
             THREAD_RESUMED();
         }
         else
@@ -5800,51 +5591,86 @@ void *CUDT::tsbpd(void *param)
              * - Closing the connection
              */
             HLOGC(tslog.Debug, log << self->CONID() << "tsbpd: no data, scheduling wakeup at ack");
-            self->m_bTsbPdAckWakeup = true;
+            self->m_bTsbPdNeedsWakeup = true;
             THREAD_PAUSED();
             tsbpd_cc.wait();
             THREAD_RESUMED();
         }
 
-        HLOGC(tslog.Debug, log << self->CONID() << "tsbpd: WAKE UP!!!");
+        HLOGC(tslog.Debug,
+              log << self->CONID() << "tsbpd: WAKE UP [" << (bWokeUpOnSignal ? "signal" : "timeout") << "]!!! - "
+                  << "NOW=" << FormatTime(steady_clock::now()));
     }
     THREAD_EXIT();
     HLOGC(tslog.Debug, log << self->CONID() << "tsbpd: EXITING");
     return NULL;
 }
 
-void CUDT::updateForgotten(int seqlen, int32_t lastack, int32_t skiptoseqno)
+int srt::CUDT::rcvDropTooLateUpTo(int seqno, DropReason reason)
 {
-    /* Update drop/skip stats */
-    enterCS(m_StatsLock);
-    m_stats.rcvDropTotal += seqlen;
-    m_stats.traceRcvDrop += seqlen;
-    /* Estimate dropped/skipped bytes from average payload */
-    const uint64_t avgpayloadsz = m_pRcvBuffer->getRcvAvgPayloadSize();
-    m_stats.rcvBytesDropTotal += seqlen * avgpayloadsz;
-    m_stats.traceRcvBytesDrop += seqlen * avgpayloadsz;
-    leaveCS(m_StatsLock);
+    // Make sure that it would not drop over m_iRcvCurrSeqNo, which may break senders.
+    if (CSeqNo::seqcmp(seqno, CSeqNo::incseq(m_iRcvCurrSeqNo)) > 0)
+        seqno = CSeqNo::incseq(m_iRcvCurrSeqNo);
+
+    dropFromLossLists(SRT_SEQNO_NONE, CSeqNo::decseq(seqno));
+
+    const std::pair<int, int> iDropDiscardedPkts = m_pRcvBuffer->dropUpTo(seqno);
+    const int iDropCnt = iDropDiscardedPkts.first;
+    const int iDiscardedCnt = iDropDiscardedPkts.second;
+    const int iDropCntTotal = iDropCnt + iDiscardedCnt;
+
+    // In case of DROP_TOO_LATE discarded packets should also be counted because they are not read from another member socket.
+    const int iDropStatCnt = (reason == DROP_DISCARD) ? iDropCnt : iDropCntTotal;
+    if (iDropStatCnt > 0)
+    {
+        enterCS(m_StatsLock);
+        // Estimate dropped bytes from average payload size.
+        const uint64_t avgpayloadsz = m_pRcvBuffer->getRcvAvgPayloadSize();
+        m_stats.rcvr.dropped.count(stats::BytesPackets(iDropStatCnt * avgpayloadsz, (uint32_t)iDropStatCnt));
+        leaveCS(m_StatsLock);
+    }
+    return iDropCntTotal;
+}
+
+void srt::CUDT::setInitialRcvSeq(int32_t isn)
+{
+    m_iRcvLastAck = isn;
+#ifdef ENABLE_LOGGING
+    m_iDebugPrevLastAck = isn;
+#endif
+    m_iRcvLastAckAck = isn;
+    m_iRcvCurrSeqNo = CSeqNo::decseq(isn);
+
+    sync::ScopedLock rb(m_RcvBufferLock);
+    if (m_pRcvBuffer)
+    {
+        if (!m_pRcvBuffer->empty())
+        {
+            LOGC(cnlog.Error, log << CONID() << "IPE: setInitialRcvSeq expected empty RCV buffer. Dropping all.");
+            const int        iDropCnt     = m_pRcvBuffer->dropAll();
+            const uint64_t   avgpayloadsz = m_pRcvBuffer->getRcvAvgPayloadSize();
+            sync::ScopedLock sl(m_StatsLock);
+            m_stats.rcvr.dropped.count(stats::BytesPackets(iDropCnt * avgpayloadsz, (uint32_t) iDropCnt));
+        }
 
-    dropFromLossLists(lastack, CSeqNo::decseq(skiptoseqno)); //remove(from,to-inclusive)
+        m_pRcvBuffer->setStartSeqNo(isn);
+    }
 }
 
-bool CUDT::prepareConnectionObjects(const CHandShake &hs, HandshakeSide hsd, CUDTException *eout)
+bool srt::CUDT::prepareConnectionObjects(const CHandShake &hs, HandshakeSide hsd, CUDTException *eout)
 {
     // This will be lazily created due to being the common
     // code with HSv5 rendezvous, in which this will be run
     // in a little bit "randomly selected" moment, but must
     // be run once in the whole connection process.
-    if (m_pSndBuffer)
+    if (m_pCryptoControl)
     {
-        HLOGC(rslog.Debug, log << "prepareConnectionObjects: (lazy) already created.");
+        HLOGC(rslog.Debug, log << CONID() << "prepareConnectionObjects: (lazy) already created.");
         return true;
     }
 
-    bool bidirectional = false;
-    if (hs.m_iVersion > HS_VERSION_UDT4)
-    {
-        bidirectional = true; // HSv5 is always bidirectional
-    }
+    // HSv5 is always bidirectional
+    const bool bidirectional = (hs.m_iVersion > HS_VERSION_UDT4);
 
     // HSD_DRAW is received only if this side is listener.
     // If this side is caller with HSv5, HSD_INITIATOR should be passed.
@@ -5858,45 +5684,73 @@ bool CUDT::prepareConnectionObjects(const CHandShake &hs, HandshakeSide hsd, CUD
         }
         else
         {
-            hsd = m_bDataSender ? HSD_INITIATOR : HSD_RESPONDER;
+            hsd = m_config.bDataSender ? HSD_INITIATOR : HSD_RESPONDER;
         }
     }
 
+    if (!createCrypter(hsd, bidirectional)) // Make sure CC is created (lazy)
+    {
+        if (eout)
+            *eout = CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
+        m_RejectReason = SRT_REJ_RESOURCE;
+        return false;
+    }
+
+    return true;
+}
+
+int srt::CUDT::getAuthTagSize() const
+{
+    if (m_pCryptoControl && m_pCryptoControl->getCryptoMode() == CSrtConfig::CIPHER_MODE_AES_GCM)
+        return HAICRYPT_AUTHTAG_MAX;
+
+    return 0;
+}
+
+bool srt::CUDT::prepareBuffers(CUDTException* eout)
+{
+    if (m_pSndBuffer)
+    {
+        HLOGC(rslog.Debug, log << CONID() << "prepareBuffers: (lazy) already created.");
+        return true;
+    }
+    
     try
     {
-        m_pSndBuffer = new CSndBuffer(32, m_iMaxSRTPayloadSize);
-        m_pRcvBuffer = new CRcvBuffer(&(m_pRcvQueue->m_UnitQueue), m_iRcvBufSize);
-        // after introducing lite ACK, the sndlosslist may not be cleared in time, so it requires twice space.
+        // CryptoControl has to be initialized and in case of RESPONDER the KM REQ must be processed (interpretSrtHandshake(..)) for the crypto mode to be deduced.
+        const int authtag = getAuthTagSize();
+
+        SRT_ASSERT(m_iMaxSRTPayloadSize != 0);
+
+        HLOGC(rslog.Debug, log << CONID() << "Creating buffers: snd-plsize=" << m_iMaxSRTPayloadSize
+                << " snd-bufsize=" << 32
+                << " authtag=" << authtag);
+
+        m_pSndBuffer = new CSndBuffer(AF_INET, 32, m_iMaxSRTPayloadSize, authtag);
+        SRT_ASSERT(m_iPeerISN != -1);
+        m_pRcvBuffer = new srt::CRcvBuffer(m_iPeerISN, m_config.iRcvBufSize, m_pRcvQueue->m_pUnitQueue, m_config.bMessageAPI);
+        // After introducing lite ACK, the sndlosslist may not be cleared in time, so it requires twice a space.
         m_pSndLossList = new CSndLossList(m_iFlowWindowSize * 2);
-        m_pRcvLossList = new CRcvLossList(m_iFlightFlagSize);
+        m_pRcvLossList = new CRcvLossList(m_config.iFlightFlagSize);
     }
     catch (...)
     {
         // Simply reject.
         if (eout)
-        {
             *eout = CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
-        }
         m_RejectReason = SRT_REJ_RESOURCE;
         return false;
     }
-
-    if (!createCrypter(hsd, bidirectional)) // Make sure CC is created (lazy)
-    {
-        m_RejectReason = SRT_REJ_RESOURCE;
-        return false;
-    }
-
     return true;
 }
 
-void CUDT::rewriteHandshakeData(const sockaddr_any& peer, CHandShake& w_hs)
+void srt::CUDT::rewriteHandshakeData(const sockaddr_any& peer, CHandShake& w_hs)
 {
-    // this is a reponse handshake
-    w_hs.m_iReqType = URQ_CONCLUSION;
-    w_hs.m_iMSS = m_iMSS;
-    w_hs.m_iFlightFlagSize = (m_iRcvBufSize < m_iFlightFlagSize) ? m_iRcvBufSize : m_iFlightFlagSize;
-    w_hs.m_iID = m_SocketID;
+    // this is a response handshake
+    w_hs.m_iReqType        = URQ_CONCLUSION;
+    w_hs.m_iMSS            = m_config.iMSS;
+    w_hs.m_iFlightFlagSize = m_config.flightCapacity();
+    w_hs.m_iID             = m_SocketID;
 
     if (w_hs.m_iVersion > HS_VERSION_UDT4)
     {
@@ -5909,24 +5763,29 @@ void CUDT::rewriteHandshakeData(const sockaddr_any& peer, CHandShake& w_hs)
     CIPAddress::ntop(peer, (w_hs.m_piPeerIP));
 }
 
-void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer, const CPacket& hspkt, CHandShake& w_hs)
+void srt::CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer, const CPacket& hspkt, CHandShake& w_hs)
 {
-    HLOGC(cnlog.Debug, log << "acceptAndRespond: setting up data according to handshake");
+    HLOGC(cnlog.Debug, log << CONID() << "acceptAndRespond: setting up data according to handshake");
 
     ScopedLock cg(m_ConnectionLock);
 
     m_tsRcvPeerStartTime = steady_clock::time_point(); // will be set correctly at SRT HS
 
     // Uses the smaller MSS between the peers
-    m_iMSS = std::min(m_iMSS, w_hs.m_iMSS);
+    m_config.iMSS = std::min(m_config.iMSS, w_hs.m_iMSS);
+
+    const size_t full_hdr_size = CPacket::UDP_HDR_SIZE + CPacket::HDR_SIZE;
+    m_iMaxSRTPayloadSize = m_config.iMSS - full_hdr_size;
+
+    HLOGC(cnlog.Debug, log << CONID() << "acceptAndRespond: PAYLOAD SIZE: " << m_iMaxSRTPayloadSize);
 
     // exchange info for maximum flow window size
     m_iFlowWindowSize = w_hs.m_iFlightFlagSize;
-    m_iPeerISN = w_hs.m_iISN;
+    m_iPeerISN        = w_hs.m_iISN;
     setInitialRcvSeq(m_iPeerISN);
     m_iRcvCurrPhySeqNo = CSeqNo::decseq(w_hs.m_iISN);
 
-    m_PeerID  = w_hs.m_iID;
+    m_PeerID = w_hs.m_iID;
 
     // use peer's ISN and send it back for security check
     m_iISN = w_hs.m_iISN;
@@ -5941,14 +5800,12 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
 
     rewriteHandshakeData(peer, (w_hs));
 
-    int udpsize          = m_iMSS - CPacket::UDP_HDR_SIZE;
-    m_iMaxSRTPayloadSize = udpsize - CPacket::HDR_SIZE;
-    HLOGC(cnlog.Debug, log << "acceptAndRespond: PAYLOAD SIZE: " << m_iMaxSRTPayloadSize);
 
     // Prepare all structures
     if (!prepareConnectionObjects(w_hs, HSD_DRAW, 0))
     {
-        HLOGC(cnlog.Debug, log << "acceptAndRespond: prepareConnectionObjects failed - responding with REJECT.");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "acceptAndRespond: prepareConnectionObjects failed - responding with REJECT.");
         // If the SRT Handshake extension was provided and wasn't interpreted
         // correctly, the connection should be rejected.
         //
@@ -5964,10 +5821,16 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
     CInfoBlock::convert(peer, ib.m_piIP);
     if (m_pCache->lookup(&ib) >= 0)
     {
-        m_iRTT       = ib.m_iRTT;
+        m_iSRTT      = ib.m_iSRTT;
+        m_iRTTVar    = ib.m_iSRTT / 2;
         m_iBandwidth = ib.m_iBandwidth;
     }
 
+#if SRT_DEBUG_RTT
+    s_rtt_trace.trace(steady_clock::now(), "Accept", -1, -1,
+                      m_bIsFirstRTTReceived, -1, m_iSRTT, m_iRTTVar);
+#endif
+
     m_PeerAddr = peer;
 
     // This should extract the HSREQ and KMREQ portion in the handshake packet.
@@ -5978,7 +5841,8 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
     size_t   kmdatasize = SRTDATA_MAXSIZE;
     if (!interpretSrtHandshake(w_hs, hspkt, (kmdata), (&kmdatasize)))
     {
-        HLOGC(cnlog.Debug, log << "acceptAndRespond: interpretSrtHandshake failed - responding with REJECT.");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "acceptAndRespond: interpretSrtHandshake failed - responding with REJECT.");
         // If the SRT Handshake extension was provided and wasn't interpreted
         // correctly, the connection should be rejected.
         //
@@ -5989,14 +5853,38 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
         throw CUDTException(MJ_SETUP, MN_REJECTED, 0);
     }
 
+#if ENABLE_BONDING
+    m_ConnectionLock.unlock();
+    // The socket and the group are only linked to each other after interpretSrtHandshake(..) has been called.
+    // Keep the group alive for the lifetime of this function,
+    // and do it BEFORE acquiring m_ConnectionLock to avoid
+    // lock inversion.
+    // This will check if a socket belongs to a group and if so
+    // it will remember this group and keep it alive here.
+    CUDTUnited::GroupKeeper group_keeper(uglobal(), m_parent);
+    m_ConnectionLock.lock();
+#endif
+
+    if (!prepareBuffers(NULL))
+    {
+        HLOGC(cnlog.Debug,
+            log << CONID() << "acceptAndRespond: prepareConnectionObjects failed - responding with REJECT.");
+        // If the SRT buffers failed to be allocated,
+        // the connection must be rejected.
+        //
+        // Respond with the rejection message and exit with exception
+        // so that the caller will know that this new socket should be deleted.
+        w_hs.m_iReqType = URQFailure(m_RejectReason);
+        throw CUDTException(MJ_SETUP, MN_REJECTED, 0);
+    }
+
    // Synchronize the time NOW because the following function is about
    // to use the start time to pass it to the receiver buffer data.
     bool have_group = false;
 
     {
-#if ENABLE_EXPERIMENTAL_BONDING
-        ScopedLock cl (s_UDTUnited.m_GlobControlLock);
-        CUDTGroup* g = m_parent->m_IncludedGroup;
+#if ENABLE_BONDING
+        CUDTGroup* g = group_keeper.group;
         if (g)
         {
             // This is the last moment when this can be done.
@@ -6028,7 +5916,7 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
     // And of course, it is connected.
     m_bConnected = true;
 
-    // register this socket for receiving data packets
+    // Register this socket for receiving data packets.
     m_pRNode->m_bOnList = true;
     m_pRcvQueue->setNewEntry(this);
 
@@ -6042,51 +5930,102 @@ void CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer,
     // received the listener's handshake.
     //return;
 
-    if (!createSendHSResponse(kmdata, kmdatasize, (w_hs)))
+    if (!createSendHSResponse(kmdata, kmdatasize, hspkt.udpDestAddr(), (w_hs)))
     {
         throw CUDTException(MJ_SETUP, MN_REJECTED, 0);
     }
 }
 
-bool CUDT::createSendHSResponse(uint32_t* kmdata, size_t kmdatasize, CHandShake& w_hs) ATR_NOTHROW
+bool CUDT::createSendHSResponse(uint32_t* kmdata, size_t kmdatasize, const sockaddr_any& hsaddr, CHandShake& w_hs) ATR_NOTHROW
 {
-    // send the response to the peer, see listen() for more discussions about this
-    // XXX Here create CONCLUSION RESPONSE with:
+    // Send the response to the peer, see listen() for more discussions
+    // about this.
+    // TODO: Here create CONCLUSION RESPONSE with:
     // - just the UDT handshake, if HS_VERSION_UDT4,
-    // - if higher, the UDT handshake, the SRT HSRSP, the SRT KMRSP
+    // - if higher, the UDT handshake, the SRT HSRSP, the SRT KMRSP.
     size_t size = m_iMaxSRTPayloadSize;
     // Allocate the maximum possible memory for an SRT payload.
     // This is a maximum you can send once.
-    CPacket response;
-    response.setControl(UMSG_HANDSHAKE);
-    response.allocate(size);
+    CPacket rsppkt;
+    rsppkt.setControl(UMSG_HANDSHAKE);
+    rsppkt.allocate(size);
 
     // This will serialize the handshake according to its current form.
     HLOGC(cnlog.Debug,
+          log << CONID()
           log << "createSendHSResponse: creating CONCLUSION response (HSv5: with HSRSP/KMRSP) buffer size=" << size);
-    if (!createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (response), (w_hs)))
+    if (!createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (rsppkt), (w_hs)))
     {
-        LOGC(cnlog.Error, log << "createSendHSResponse: error creating handshake response");
+        LOGC(cnlog.Error, log << CONID() << "createSendHSResponse: error creating handshake response");
         return false;
     }
 
+    // We can safely assign it here stating that this has passed the cookie test.
+    m_SourceAddr = hsaddr;
+
 #if ENABLE_HEAVY_LOGGING
     {
         // To make sure what REALLY is being sent, parse back the handshake
         // data that have been just written into the buffer.
         CHandShake debughs;
-        debughs.load_from(response.m_pcData, response.getLength());
+        debughs.load_from(rsppkt.m_pcData, rsppkt.getLength());
         HLOGC(cnlog.Debug,
               log << CONID() << "createSendHSResponse: sending HS from agent @"
                 << debughs.m_iID << " to peer @" << m_PeerID // <-- will be used by addressAndSend
-                << "HS:" << debughs.show());
+                << "HS:" << debughs.show()
+                << " sourceIP=" << m_SourceAddr.str());
     }
 #endif
 
-    addressAndSend((response));
+    // NOTE: BLOCK THIS instruction in order to cause the final
+    // handshake to be missed and cause the problem solved in PR #417.
+    // When missed this message, the caller should not accept packets
+    // coming as connected, but continue repeated handshake until finally
+    // received the listener's handshake.
+    addressAndSend((rsppkt));
     return true;
 }
 
+bool srt::CUDT::frequentLogAllowed(size_t logid, const time_point& tnow, std::string& w_why)
+{
+#ifndef SRT_LOG_SLOWDOWN_FREQ_MS
+#define SRT_LOG_SLOWDOWN_FREQ_MS 1000
+#endif
+
+    bool is_suppressed = IsSet(m_LogSlowDownExpired, BIT(logid));
+    const bool isnow = (m_tsLogSlowDown[logid].load() + milliseconds_from(SRT_LOG_SLOWDOWN_FREQ_MS)) <= tnow;
+    if (isnow)
+    {
+        // Theoretically this should prevent other calls of this function to take
+        // set their values simultaneously, but if it happened that the time is
+        // also set, this section will not fire for the other log, if it didn't do
+        // the check yet.
+        m_LogSlowDownExpired.store(uint8_t(BIT(logid))); // Clear all other bits
+
+        // Note: it may happen that two threads could intermix one another between
+        // the check and setting up, but this will at worst case set the slightly
+        // later time again.
+        m_tsLogSlowDown[logid].store(tnow);
+
+        is_suppressed = false;
+
+        const int supr = m_aSuppressedMsg[logid];
+
+        if (supr > 0)
+            w_why = Sprint("++SUPPRESSED: ", supr);
+        m_aSuppressedMsg[logid] = 0;
+    }
+    else
+    {
+        w_why = Sprint("Too early - last one was ", FormatDuration<DUNIT_MS>(tnow - m_tsLogSlowDown[logid].load()));
+        // Set YOUR OWN bit, atomically.
+        m_LogSlowDownExpired |= uint8_t(BIT(logid));
+        ++m_aSuppressedMsg[logid];
+    }
+
+    return !is_suppressed;
+}
+
 // This function is required to be called when a caller receives an INDUCTION
 // response from the listener and would like to create a CONCLUSION that includes
 // the SRT handshake extension. This extension requires that the crypter object
@@ -6095,7 +6034,7 @@ bool CUDT::createSendHSResponse(uint32_t* kmdata, size_t kmdatasize, CHandShake&
 // be created, as this happens before the completion of the connection (and
 // therefore configuration of the crypter object), which can only take place upon
 // reception of CONCLUSION response from the listener.
-bool CUDT::createCrypter(HandshakeSide side, bool bidirectional)
+bool srt::CUDT::createCrypter(HandshakeSide side, bool bidirectional)
 {
     // Lazy initialization
     if (m_pCryptoControl)
@@ -6104,58 +6043,72 @@ bool CUDT::createCrypter(HandshakeSide side, bool bidirectional)
     // Write back this value, when it was just determined.
     m_SrtHsSide = side;
 
-    m_pCryptoControl.reset(new CCryptoControl(this, m_SocketID));
+    m_pCryptoControl.reset(new CCryptoControl(m_SocketID));
 
     // XXX These below are a little bit controversial.
     // These data should probably be filled only upon
     // reception of the conclusion handshake - otherwise
     // they have outdated values.
-    m_pCryptoControl->setCryptoSecret(m_CryptoSecret);
+    m_pCryptoControl->setCryptoSecret(m_config.CryptoSecret);
+
+    const bool useGcm153 = m_uPeerSrtVersion <= SrtVersion(1, 5, 3);
 
-    if (bidirectional || m_bDataSender)
+    if (bidirectional || m_config.bDataSender)
     {
-        HLOGC(rslog.Debug, log << "createCrypter: setting RCV/SND KeyLen=" << m_iSndCryptoKeyLen);
-        m_pCryptoControl->setCryptoKeylen(m_iSndCryptoKeyLen);
+        HLOGC(rslog.Debug, log << CONID() << "createCrypter: setting RCV/SND KeyLen=" << m_config.iSndCryptoKeyLen);
+        m_pCryptoControl->setCryptoKeylen(m_config.iSndCryptoKeyLen);
     }
 
-    return m_pCryptoControl->init(side, bidirectional);
+    return m_pCryptoControl->init(side, m_config, bidirectional, useGcm153);
 }
 
-SRT_REJECT_REASON CUDT::setupCC()
+SRT_REJECT_REASON srt::CUDT::setupCC()
 {
     // Prepare configuration object,
     // Create the CCC object and configure it.
 
     // UDT also sets back the congestion window: ???
-    // m_dCongestionWindow = m_pCC->m_dCWndSize;
+    // m_iCongestionWindow = m_pCC->m_dCWndSize;
 
     // XXX Not sure about that. May happen that AGENT wants
     // tsbpd mode, but PEER doesn't, even in bidirectional mode.
     // This way, the reception side should get precedense.
-    // if (bidirectional || m_bDataSender || m_bTwoWayData)
-    //    m_bPeerTsbPd = m_bOPT_TsbPd;
+    // if (bidirectional || m_config.bDataSender || m_bTwoWayData)
+    //    m_bPeerTsbPd = m_bTSBPD;
 
     // SrtCongestion will retrieve whatever parameters it needs
     // from *this.
-    if (!m_CongCtl.configure(this))
+
+    bool res = m_CongCtl.select(m_config.sCongestion.str());
+    if (!res || !m_CongCtl.configure(this))
     {
         return SRT_REJ_CONGESTION;
     }
 
     // Configure filter module
-    if (m_OPT_PktFilterConfigString != "")
+    if (!m_config.sPacketFilterConfig.empty())
     {
         // This string, when nonempty, defines that the corrector shall be
         // configured. Otherwise it's left uninitialized.
 
         // At this point we state everything is checked and the appropriate
         // corrector type is already selected, so now create it.
-        HLOGC(pflog.Debug, log << "filter: Configuring: " << m_OPT_PktFilterConfigString);
-        if (!m_PacketFilter.configure(this, &(m_pRcvQueue->m_UnitQueue), m_OPT_PktFilterConfigString))
+        HLOGC(pflog.Debug, log << CONID() << "filter: Configuring: " << m_config.sPacketFilterConfig.c_str());
+        bool status = true;
+        try
         {
-            return SRT_REJ_FILTER;
+            // The filter configurer is build the way that allows to quit immediately
+            // exit by exception, but the exception is meant for the filter only.
+            status = m_PacketFilter.configure(this, m_pRcvQueue->m_pUnitQueue, m_config.sPacketFilterConfig.str());
+        }
+        catch (CUDTException& )
+        {
+            status = false;
         }
 
+        if (!status)
+            return SRT_REJ_FILTER;
+
         m_PktFilterRexmitLevel = m_PacketFilter.arqLevel();
     }
     else
@@ -6173,36 +6126,36 @@ SRT_REJECT_REASON CUDT::setupCC()
 
     // Update timers
     const steady_clock::time_point currtime = steady_clock::now();
-    m_tsLastRspTime          = currtime;
-    m_tsNextACKTime          = currtime + m_tdACKInterval;
-    m_tsNextNAKTime          = currtime + m_tdNAKInterval;
-    m_tsLastRspAckTime       = currtime;
-    m_tsLastSndTime          = currtime;
+    m_tsLastRspTime.store(currtime);
+    m_tsNextACKTime.store(currtime + m_tdACKInterval);
+    m_tsNextNAKTime.store(currtime + m_tdNAKInterval);
+    m_tsLastRspAckTime = currtime;
+    m_tsLastSndTime.store(currtime);
 
     HLOGC(rslog.Debug,
-          log << "setupCC: setting parameters: mss=" << m_iMSS << " maxCWNDSize/FlowWindowSize=" << m_iFlowWindowSize
-              << " rcvrate=" << m_iDeliveryRate << "p/s (" << m_iByteDeliveryRate << "B/S)"
-              << " rtt=" << m_iRTT << " bw=" << m_iBandwidth);
+          log << CONID() << "setupCC: setting parameters: mss=" << m_config.iMSS << " maxCWNDSize/FlowWindowSize="
+              << m_iFlowWindowSize << " rcvrate=" << m_iDeliveryRate << "p/s (" << m_iByteDeliveryRate << "B/S)"
+              << " rtt=" << m_iSRTT << " bw=" << m_iBandwidth);
 
     if (!updateCC(TEV_INIT, EventVariant(TEV_INIT_RESET)))
     {
-        LOGC(rslog.Error, log << "setupCC: IPE: resrouces not yet initialized!");
+        LOGC(rslog.Error, log << CONID() << "setupCC: IPE: resrouces not yet initialized!");
         return SRT_REJ_IPE;
     }
     return SRT_REJ_UNKNOWN;
 }
 
-void CUDT::considerLegacySrtHandshake(const steady_clock::time_point &timebase)
+void srt::CUDT::considerLegacySrtHandshake(const steady_clock::time_point &timebase)
 {
     // Do a fast pre-check first - this simply declares that agent uses HSv5
     // and the legacy SRT Handshake is not to be done. Second check is whether
     // agent is sender (=initiator in HSv4).
-    if (!isOPT_TsbPd() || !m_bDataSender)
+    if (!isOPT_TsbPd() || !m_config.bDataSender)
         return;
 
     if (m_iSndHsRetryCnt <= 0)
     {
-        HLOGC(cnlog.Debug, log << "Legacy HSREQ: not needed, expire counter=" << m_iSndHsRetryCnt);
+        HLOGC(cnlog.Debug, log << CONID() << "Legacy HSREQ: not needed, expire counter=" << m_iSndHsRetryCnt);
         return;
     }
 
@@ -6222,7 +6175,8 @@ void CUDT::considerLegacySrtHandshake(const steady_clock::time_point &timebase)
          */
         if (timebase > now) // too early
         {
-            HLOGC(cnlog.Debug, log << "Legacy HSREQ: TOO EARLY, will still retry " << m_iSndHsRetryCnt << " times");
+            HLOGC(cnlog.Debug,
+                  log << CONID() << "Legacy HSREQ: TOO EARLY, will still retry " << m_iSndHsRetryCnt << " times");
             return;
         }
     }
@@ -6231,48 +6185,53 @@ void CUDT::considerLegacySrtHandshake(const steady_clock::time_point &timebase)
     else if (m_iSndHsRetryCnt < SRT_MAX_HSRETRY + 1)
     {
         HLOGC(cnlog.Debug,
-              log << "Legacy HSREQ: INITIAL, REPEATED, so not to be done. Will repeat on sending " << m_iSndHsRetryCnt
-                  << " times");
+              log << CONID() << "Legacy HSREQ: INITIAL, REPEATED, so not to be done. Will repeat on sending "
+                  << m_iSndHsRetryCnt << " times");
         return;
     }
 
-    HLOGC(cnlog.Debug, log << "Legacy HSREQ: SENDING, will repeat " << m_iSndHsRetryCnt << " times if no response");
+    HLOGC(cnlog.Debug,
+          log << CONID() << "Legacy HSREQ: SENDING, will repeat " << m_iSndHsRetryCnt << " times if no response");
     m_iSndHsRetryCnt--;
     m_tsSndHsLastTime = now;
     sendSrtMsg(SRT_CMD_HSREQ);
 }
 
-void CUDT::checkSndTimers(Whether2RegenKm regen)
+void srt::CUDT::checkSndTimers()
 {
     if (m_SrtHsSide == HSD_INITIATOR)
     {
-        HLOGC(cnlog.Debug, log << "checkSndTimers: HS SIDE: INITIATOR, considering legacy handshake with timebase");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "checkSndTimers: HS SIDE: INITIATOR, considering legacy handshake with timebase");
         // Legacy method for HSREQ, only if initiator.
-        considerLegacySrtHandshake(m_tsSndHsLastTime + microseconds_from(m_iRTT * 3 / 2));
+        considerLegacySrtHandshake(m_tsSndHsLastTime + microseconds_from(m_iSRTT * 3 / 2));
     }
     else
     {
         HLOGC(cnlog.Debug,
-              log << "checkSndTimers: HS SIDE: " << (m_SrtHsSide == HSD_RESPONDER ? "RESPONDER" : "DRAW (IPE?)")
+              log << CONID()
+                  << "checkSndTimers: HS SIDE: " << (m_SrtHsSide == HSD_RESPONDER ? "RESPONDER" : "DRAW (IPE?)")
                   << " - not considering legacy handshake");
     }
 
-    // This must be done always on sender, regardless of HS side.
-    // When regen == DONT_REGEN_KM, it's a handshake call, so do
-    // it only for initiator.
-    if (regen || m_SrtHsSide == HSD_INITIATOR)
-    {
-        // Don't call this function in "non-regen mode" (sending only),
-        // if this side is RESPONDER. This shall be called only with
-        // regeneration request, which is required by the sender.
-        if (m_pCryptoControl)
-            m_pCryptoControl->sendKeysToPeer(regen);
-    }
+    // Retransmit KM request after a timeout if there is no response (KM RSP).
+    // Or send KM REQ in case of the HSv4.
+    ScopedLock lck(m_ConnectionLock);
+    if (m_pCryptoControl)
+        m_pCryptoControl->sendKeysToPeer(this, SRTT());
+}
+
+void srt::CUDT::checkSndKMRefresh()
+{
+    // Do not apply the regenerated key to the to the receiver context.
+    const bool bidir = false;
+    if (m_pCryptoControl)
+        m_pCryptoControl->regenCryptoKm(this, bidir);
 }
 
-void CUDT::addressAndSend(CPacket& w_pkt)
+void srt::CUDT::addressAndSend(CPacket& w_pkt)
 {
-    w_pkt.m_iID        = m_PeerID;
+    w_pkt.set_id(m_PeerID);
     setPacketTS(w_pkt, steady_clock::now());
 
     // NOTE: w_pkt isn't modified in this call,
@@ -6280,11 +6239,12 @@ void CUDT::addressAndSend(CPacket& w_pkt)
     // before sending for performance purposes,
     // and then modification is undone. Logically then
     // there's no modification here.
-    m_pSndQueue->sendto(m_PeerAddr, w_pkt);
+    m_pSndQueue->sendto(m_PeerAddr, w_pkt, m_SourceAddr);
 }
 
-// [[using maybe_locked(m_GlobControlLock, if called from GC)]]
-bool CUDT::closeInternal()
+// [[using maybe_locked(m_GlobControlLock, if called from breakSocket_LOCKED, usually from GC)]]
+// [[using maybe_locked(m_parent->m_ControlLock, if called from srt_close())]]
+bool srt::CUDT::closeInternal() ATR_NOEXCEPT
 {
     // NOTE: this function is called from within the garbage collector thread.
 
@@ -6298,28 +6258,28 @@ bool CUDT::closeInternal()
     // that has m_bBroken == false or m_bConnected == true.
     // If it is intended to forcefully close the socket, make sure
     // that it's in response to a broken connection.
-    HLOGC(smlog.Debug, log << CONID() << " - closing socket:");
+    HLOGC(smlog.Debug, log << CONID() << "closing socket");
 
-    if (m_Linger.l_onoff != 0)
+    if (m_config.Linger.l_onoff != 0)
     {
         const steady_clock::time_point entertime = steady_clock::now();
 
-        HLOGC(smlog.Debug, log << CONID() << " ... (linger)");
+        HLOGC(smlog.Debug, log << CONID() << "... (linger)");
         while (!m_bBroken && m_bConnected && (m_pSndBuffer->getCurrBufSize() > 0) &&
-               (steady_clock::now() - entertime < seconds_from(m_Linger.l_linger)))
+               (steady_clock::now() - entertime < seconds_from(m_config.Linger.l_linger)))
         {
             // linger has been checked by previous close() call and has expired
             if (m_tsLingerExpiration >= entertime)
                 break;
 
-            if (!m_bSynSending)
+            if (!m_config.bSynSending)
             {
                 // if this socket enables asynchronous sending, return immediately and let GC to close it later
                 if (is_zero(m_tsLingerExpiration))
-                    m_tsLingerExpiration = entertime + seconds_from(m_Linger.l_linger);
+                    m_tsLingerExpiration = entertime + seconds_from(m_config.Linger.l_linger);
 
                 HLOGC(smlog.Debug,
-                      log << "CUDT::close: linger-nonblocking, setting expire time T="
+                      log << CONID() << "CUDT::close: linger-nonblocking, setting expire time T="
                           << FormatTime(m_tsLingerExpiration));
 
                 return false;
@@ -6350,21 +6310,21 @@ bool CUDT::closeInternal()
 
     // Make a copy under a lock because other thread might access it
     // at the same time.
-    enterCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    enterCS(uglobal().m_EPoll.m_EPollLock);
     set<int> epollid = m_sPollID;
-    leaveCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    leaveCS(uglobal().m_EPoll.m_EPollLock);
 
     // trigger any pending IO events.
-    HLOGC(smlog.Debug, log << "close: SETTING ERR readiness on E" << Printable(epollid) << " of @" << m_SocketID);
-    s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_ERR, true);
+    HLOGC(smlog.Debug, log << CONID() << "close: SETTING ERR readiness on E" << Printable(epollid));
+    uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_ERR, true);
     // then remove itself from all epoll monitoring
     int no_events = 0;
     for (set<int>::iterator i = epollid.begin(); i != epollid.end(); ++i)
     {
-        HLOGC(smlog.Debug, log << "close: CLEARING subscription on E" << (*i) << " of @" << m_SocketID);
+        HLOGC(smlog.Debug, log << CONID() << "close: CLEARING subscription on E" << (*i));
         try
         {
-            s_UDTUnited.m_EPoll.update_usock(*i, m_SocketID, &no_events);
+            uglobal().m_EPoll.update_usock(*i, m_SocketID, &no_events);
         }
         catch (...)
         {
@@ -6372,7 +6332,7 @@ bool CUDT::closeInternal()
             // the epoll system to this socket. If it's unsubscribed already,
             // that's even better.
         }
-        HLOGC(smlog.Debug, log << "close: removing E" << (*i) << " from back-subscribers of @" << m_SocketID);
+        HLOGC(smlog.Debug, log << CONID() << "close: removing E" << (*i) << " from back-subscribers");
     }
 
     // Not deleting elements from m_sPollID inside the loop because it invalidates
@@ -6381,9 +6341,9 @@ bool CUDT::closeInternal()
     // IMPORTANT: there's theoretically little time between setting ERR readiness
     // and unsubscribing, however if there's an application waiting on this event,
     // it should be informed before this below instruction locks the epoll mutex.
-    enterCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    enterCS(uglobal().m_EPoll.m_EPollLock);
     m_sPollID.clear();
-    leaveCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    leaveCS(uglobal().m_EPoll.m_EPollLock);
 
     // XXX What's this, could any of the above actions make it !m_bOpened?
     if (!m_bOpened)
@@ -6417,7 +6377,7 @@ bool CUDT::closeInternal()
     {
         if (!m_bShutdown)
         {
-            HLOGC(smlog.Debug, log << CONID() << "CLOSING - sending SHUTDOWN to the peer");
+            HLOGC(smlog.Debug, log << CONID() << "CLOSING - sending SHUTDOWN to the peer @" << m_PeerID);
             sendCtrl(UMSG_SHUTDOWN);
         }
 
@@ -6425,14 +6385,19 @@ bool CUDT::closeInternal()
         CInfoBlock ib;
         ib.m_iIPversion = m_PeerAddr.family();
         CInfoBlock::convert(m_PeerAddr, ib.m_piIP);
-        ib.m_iRTT       = m_iRTT;
+        ib.m_iSRTT      = m_iSRTT;
         ib.m_iBandwidth = m_iBandwidth;
         m_pCache->update(&ib);
 
+#if SRT_DEBUG_RTT
+    s_rtt_trace.trace(steady_clock::now(), "Cache", -1, -1,
+                      m_bIsFirstRTTReceived, -1, m_iSRTT, -1);
+#endif
+
         m_bConnected = false;
     }
 
-    HLOGC(smlog.Debug, log << "CLOSING, joining send/receive threads");
+    HLOGC(smlog.Debug, log << CONID() << "CLOSING, joining send/receive threads");
 
     // waiting all send and recv calls to stop
     ScopedLock sendguard(m_SendLock);
@@ -6447,9 +6412,7 @@ bool CUDT::closeInternal()
     m_pCryptoControl.reset();
     leaveCS(m_RcvBufferLock);
 
-    m_lSrtVersion            = SRT_DEF_VERSION;
-    m_lPeerSrtVersion        = SRT_VERSION_UNK;
-    m_lMinimumPeerSrtVersion = SRT_VERSION_MAJ1;
+    m_uPeerSrtVersion        = SRT_VERSION_UNK;
     m_tsRcvPeerStartTime     = steady_clock::time_point();
 
     m_bOpened = false;
@@ -6457,7 +6420,7 @@ bool CUDT::closeInternal()
     return true;
 }
 
-int CUDT::receiveBuffer(char *data, int len)
+int srt::CUDT::receiveBuffer(char *data, int len)
 {
     if (!m_CongCtl->checkTransArgs(SrtCongestion::STA_BUFFER, SrtCongestion::STAD_RECV, data, len, SRT_MSGTTL_INF, false))
         throw CUDTException(MJ_NOTSUP, MN_INVALBUFFERAPI, 0);
@@ -6470,7 +6433,7 @@ int CUDT::receiveBuffer(char *data, int len)
 
     UniqueLock recvguard(m_RecvLock);
 
-    if ((m_bBroken || m_bClosing) && !m_pRcvBuffer->isRcvDataReady())
+    if ((m_bBroken || m_bClosing) && !isRcvBufferReady())
     {
         if (m_bShutdown)
         {
@@ -6491,47 +6454,46 @@ int CUDT::receiveBuffer(char *data, int len)
             // make this function return 0, potentially also without breaking
             // the connection and potentially also with losing no ability to
             // send some larger portion of data next time.
-            HLOGC(arlog.Debug, log << "STREAM API, SHUTDOWN: marking as EOF");
+            HLOGC(arlog.Debug, log << CONID() << "STREAM API, SHUTDOWN: marking as EOF");
             return 0;
         }
         HLOGC(arlog.Debug,
-              log << (m_bMessageAPI ? "MESSAGE" : "STREAM") << " API, " << (m_bShutdown ? "" : "no")
+              log << CONID() << (m_config.bMessageAPI ? "MESSAGE" : "STREAM") << " API, " << (m_bShutdown ? "" : "no")
                   << " SHUTDOWN. Reporting as BROKEN.");
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
     CSync rcond  (m_RecvDataCond, recvguard);
     CSync tscond (m_RcvTsbPdCond, recvguard);
-    if (!m_pRcvBuffer->isRcvDataReady())
+    if (!isRcvBufferReady())
     {
-        if (!m_bSynRecving)
+        if (!m_config.bSynRecving)
         {
             throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
         }
-        else
+
+        // Kick TsbPd thread to schedule the next wakeup (if running)
+        if (m_config.iRcvTimeOut < 0)
         {
-            /* Kick TsbPd thread to schedule next wakeup (if running) */
-            if (m_iRcvTimeOut < 0)
+            THREAD_PAUSED();
+            while (stillConnected() && !isRcvBufferReady())
             {
-                THREAD_PAUSED();
-                while (stillConnected() && !m_pRcvBuffer->isRcvDataReady())
-                {
-                    // Do not block forever, check connection status each 1 sec.
-                    rcond.wait_for(seconds_from(1));
-                }
-                THREAD_RESUMED();
+                // Do not block forever, check connection status each 1 sec.
+                rcond.wait_for(seconds_from(1));
             }
-            else
-            {
-                const steady_clock::time_point exptime = steady_clock::now() + milliseconds_from(m_iRcvTimeOut);
-                THREAD_PAUSED();
-                while (stillConnected() && !m_pRcvBuffer->isRcvDataReady())
-                {
-                    if (!rcond.wait_until(exptime)) // NOT means "not received a signal"
-                        break; // timeout
-                }
-                THREAD_RESUMED();
+            THREAD_RESUMED();
+        }
+        else
+        {
+            const steady_clock::time_point exptime =
+                steady_clock::now() + milliseconds_from(m_config.iRcvTimeOut);
+            THREAD_PAUSED();
+            while (stillConnected() && !isRcvBufferReady())
+            {
+                if (!rcond.wait_until(exptime)) // NOT means "not received a signal"
+                    break; // timeout
             }
+            THREAD_RESUMED();
         }
     }
 
@@ -6539,145 +6501,139 @@ int CUDT::receiveBuffer(char *data, int len)
     if (!m_bConnected)
         throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
 
-    if ((m_bBroken || m_bClosing) && !m_pRcvBuffer->isRcvDataReady())
+    if ((m_bBroken || m_bClosing) && !isRcvBufferReady())
     {
         // See at the beginning
-        if (!m_bMessageAPI && m_bShutdown)
+        if (!m_config.bMessageAPI && m_bShutdown)
         {
-            HLOGC(arlog.Debug, log << "STREAM API, SHUTDOWN: marking as EOF");
+            HLOGC(arlog.Debug, log << CONID() << "STREAM API, SHUTDOWN: marking as EOF");
             return 0;
         }
         HLOGC(arlog.Debug,
-              log << (m_bMessageAPI ? "MESSAGE" : "STREAM") << " API, " << (m_bShutdown ? "" : "no")
+              log << CONID() << (m_config.bMessageAPI ? "MESSAGE" : "STREAM") << " API, " << (m_bShutdown ? "" : "no")
                   << " SHUTDOWN. Reporting as BROKEN.");
 
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
+    enterCS(m_RcvBufferLock);
     const int res = m_pRcvBuffer->readBuffer(data, len);
+    leaveCS(m_RcvBufferLock);
 
     /* Kick TsbPd thread to schedule next wakeup (if running) */
     if (m_bTsbPd)
     {
         HLOGP(tslog.Debug, "Ping TSBPD thread to schedule wakeup");
-        tscond.signal_locked(recvguard);
+        tscond.notify_one_locked(recvguard);
     }
     else
     {
         HLOGP(tslog.Debug, "NOT pinging TSBPD - not set");
     }
 
-    if (!m_pRcvBuffer->isRcvDataReady())
+    if (!isRcvBufferReady())
     {
         // read is not available any more
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
     }
 
-    if ((res <= 0) && (m_iRcvTimeOut >= 0))
+    if ((res <= 0) && (m_config.iRcvTimeOut >= 0))
         throw CUDTException(MJ_AGAIN, MN_XMTIMEOUT, 0);
 
     return res;
 }
 
-// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_IncludedGroup != NULL)]];
+// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_GroupOf != NULL)]];
 // [[using locked(m_SendLock)]];
-void CUDT::checkNeedDrop(bool& w_bCongestion)
+int srt::CUDT::sndDropTooLate()
 {
     if (!m_bPeerTLPktDrop)
-        return;
+        return 0;
 
-    if (!m_bMessageAPI)
+    if (!m_config.bMessageAPI)
     {
-        LOGC(aslog.Error, log << "The SRTO_TLPKTDROP flag can only be used with message API.");
+        LOGC(aslog.Error, log << CONID() << "The SRTO_TLPKTDROP flag can only be used with message API.");
         throw CUDTException(MJ_NOTSUP, MN_INVALBUFFERAPI, 0);
     }
 
-    int bytes, timespan_ms;
-    // (returns buffer size in buffer units, ignored)
-    m_pSndBuffer->getCurrBufSize((bytes), (timespan_ms));
+    const time_point tnow = steady_clock::now();
+    const int buffdelay_ms = (int) count_milliseconds(m_pSndBuffer->getBufferingDelay(tnow));
 
     // high threshold (msec) at tsbpd_delay plus sender/receiver reaction time (2 * 10ms)
-    // Minimum value must accomodate an I-Frame (~8 x average frame size)
+    // Minimum value must accommodate an I-Frame (~8 x average frame size)
     // >>need picture rate or app to set min treshold
     // >>using 1 sec for worse case 1 frame using all bit budget.
     // picture rate would be useful in auto SRT setting for min latency
     // XXX Make SRT_TLPKTDROP_MINTHRESHOLD_MS option-configurable
-    int threshold_ms = 0;
-    if (m_iOPT_SndDropDelay >= 0)
-    {
-        threshold_ms = std::max(m_iPeerTsbPdDelay_ms + m_iOPT_SndDropDelay, +SRT_TLPKTDROP_MINTHRESHOLD_MS) +
-                       (2 * COMM_SYN_INTERVAL_US / 1000);
-    }
+    const int threshold_ms = (m_config.iSndDropDelay >= 0)
+        ? std::max(m_iPeerTsbPdDelay_ms + m_config.iSndDropDelay, +SRT_TLPKTDROP_MINTHRESHOLD_MS)
+            + (2 * COMM_SYN_INTERVAL_US / 1000)
+        : 0;
 
-    if (threshold_ms && timespan_ms > threshold_ms)
-    {
-        // protect packet retransmission
-        enterCS(m_RecvAckLock);
-        int dbytes;
-        int32_t first_msgno;
-        int dpkts = m_pSndBuffer->dropLateData((dbytes), (first_msgno), steady_clock::now() - milliseconds_from(threshold_ms));
-        if (dpkts > 0)
-        {
-            enterCS(m_StatsLock);
-            m_stats.traceSndDrop += dpkts;
-            m_stats.sndDropTotal += dpkts;
-            m_stats.traceSndBytesDrop += dbytes;
-            m_stats.sndBytesDropTotal += dbytes;
-            leaveCS(m_StatsLock);
+    if (threshold_ms == 0 || buffdelay_ms <= threshold_ms)
+        return 0;
 
-            IF_HEAVY_LOGGING(const int32_t realack = m_iSndLastDataAck);
-            const int32_t fakeack = CSeqNo::incseq(m_iSndLastDataAck, dpkts);
+    // protect packet retransmission
+    ScopedLock rcvlck(m_RecvAckLock);
+    int dbytes;
+    int32_t first_msgno;
+    const int dpkts = m_pSndBuffer->dropLateData((dbytes), (first_msgno), tnow - milliseconds_from(threshold_ms));
+    if (dpkts <= 0)
+        return 0;
 
-            m_iSndLastAck     = fakeack;
-            m_iSndLastDataAck = fakeack;
+    m_iFlowWindowSize = m_iFlowWindowSize + dpkts;
 
-            int32_t minlastack = CSeqNo::decseq(m_iSndLastDataAck);
-            m_pSndLossList->removeUpTo(minlastack);
-            /* If we dropped packets not yet sent, advance current position */
-            // THIS MEANS: m_iSndCurrSeqNo = MAX(m_iSndCurrSeqNo, m_iSndLastDataAck-1)
-            if (CSeqNo::seqcmp(m_iSndCurrSeqNo, minlastack) < 0)
-            {
-                m_iSndCurrSeqNo = minlastack;
-            }
+    // If some packets were dropped update stats, socket state, loss list and the parent group if any.
+    enterCS(m_StatsLock);
+    m_stats.sndr.dropped.count(stats::BytesPackets((uint64_t) dbytes, (uint32_t) dpkts));
+    leaveCS(m_StatsLock);
 
-            HLOGC(aslog.Debug, log << "SND-DROP: %(" << realack << "-" <<  m_iSndCurrSeqNo << ") n="
-                    << dpkts << "pkt " <<  dbytes << "B, span=" <<  timespan_ms << " ms, FIRST #" << first_msgno);
+    IF_HEAVY_LOGGING(const int32_t realack = m_iSndLastDataAck);
+    const int32_t fakeack = CSeqNo::incseq(m_iSndLastDataAck, dpkts);
 
-#if ENABLE_EXPERIMENTAL_BONDING
-            // This is done with a presumption that the group
-            // exists and if this is not NULL, it means that this
-            // function was called with locked m_GroupLock, as sendmsg2
-            // function was called from inside CUDTGroup::send, which
-            // locks the whole function.
-            //
-            // XXX This is true only because all existing groups are managed
-            // groups, that is, sockets cannot be added or removed from group
-            // manually, nor can send/recv operation be done on a single socket
-            // from the API call directly. This should be extra verified, if that
-            // changes in the future.
-            //
-            // What's important is that the lock on GroupLock cannot be applied
-            // here, both because it might be applied already, and because the
-            // locks on the later lock ordered mutexes are already set.
-            if (m_parent->m_IncludedGroup)
-            {
-                m_parent->m_IncludedGroup->ackMessage(first_msgno);
-            }
-#endif
-        }
-        w_bCongestion = true;
-        leaveCS(m_RecvAckLock);
-    }
-    else if (timespan_ms > (m_iPeerTsbPdDelay_ms / 2))
+    m_iSndLastAck     = fakeack;
+    m_iSndLastDataAck = fakeack;
+
+    const int32_t minlastack = CSeqNo::decseq(m_iSndLastDataAck);
+    m_pSndLossList->removeUpTo(minlastack);
+    /* If we dropped packets not yet sent, advance current position */
+    // THIS MEANS: m_iSndCurrSeqNo = MAX(m_iSndCurrSeqNo, m_iSndLastDataAck-1)
+    if (CSeqNo::seqcmp(m_iSndCurrSeqNo, minlastack) < 0)
     {
-        HLOGC(aslog.Debug,
-              log << "cong, BYTES " << bytes << ", TMSPAN " << timespan_ms << "ms");
+        m_iSndCurrSeqNo = minlastack;
+    }
 
-        w_bCongestion = true;
+    HLOGC(qslog.Debug,
+          log << CONID() << "SND-DROP: %(" << realack << "-" << m_iSndCurrSeqNo << ") n=" << dpkts << "pkt " << dbytes
+              << "B, span=" << buffdelay_ms << " ms, FIRST #" << first_msgno);
+
+#if ENABLE_BONDING
+    // This is done with a presumption that the group
+    // exists and if this is not NULL, it means that this
+    // function was called with locked m_GroupLock, as sendmsg2
+    // function was called from inside CUDTGroup::send, which
+    // locks the whole function.
+    //
+    // XXX This is true only because all existing groups are managed
+    // groups, that is, sockets cannot be added or removed from group
+    // manually, nor can send/recv operation be done on a single socket
+    // from the API call directly. This should be extra verified, if that
+    // changes in the future.
+    //
+    if (m_parent->m_GroupOf)
+    {
+        // What's important is that the lock on GroupLock cannot be applied
+        // here, both because it might be applied already, that is, according
+        // to the condition defined at this function's header, it is applied
+        // under this condition. Hence ackMessage can be defined as 100% locked.
+        m_parent->m_GroupOf->ackMessage(first_msgno);
     }
+#endif
+
+    return dpkts;
 }
 
-int CUDT::sendmsg(const char *data, int len, int msttl, bool inorder, int64_t srctime)
+int srt::CUDT::sendmsg(const char *data, int len, int msttl, bool inorder, int64_t srctime)
 {
     SRT_MSGCTRL mctrl = srt_msgctrl_default;
     mctrl.msgttl      = msttl;
@@ -6686,13 +6642,11 @@ int CUDT::sendmsg(const char *data, int len, int msttl, bool inorder, int64_t sr
     return this->sendmsg2(data, len, (mctrl));
 }
 
-// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_IncludedGroup != NULL)]]
+// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_GroupOf != NULL)]]
 // GroupLock is applied when this function is called from inside CUDTGroup::send,
-// which is the only case when the m_parent->m_IncludedGroup is not NULL.
-int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
+// which is the only case when the m_parent->m_GroupOf is not NULL.
+int srt::CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
 {
-    bool         bCongestion = false;
-
     // throw an exception if not connected
     if (m_bBroken || m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
@@ -6701,7 +6655,7 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
 
     if (len <= 0)
     {
-        LOGC(aslog.Error, log << "INVALID: Data size for sending declared with length: " << len);
+        LOGC(aslog.Error, log << CONID() << "INVALID: Data size for sending declared with length: " << len);
         return 0;
     }
 
@@ -6709,7 +6663,9 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
     {
         if (w_mctrl.msgno < 1 || w_mctrl.msgno > MSGNO_SEQ_MAX)
         {
-            LOGC(aslog.Error, log << "INVALID forced msgno " << w_mctrl.msgno << ": can be -1 (trap) or <1..." << MSGNO_SEQ_MAX << ">");
+            LOGC(aslog.Error,
+                 log << CONID() << "INVALID forced msgno " << w_mctrl.msgno << ": can be -1 (trap) or <1..."
+                     << MSGNO_SEQ_MAX << ">");
             throw CUDTException(MJ_NOTSUP, MN_INVAL);
         }
     }
@@ -6723,7 +6679,7 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
     {
         SrtCongestion::TransAPI api = SrtCongestion::STA_MESSAGE;
         CodeMinor               mn  = MN_INVALMSGAPI;
-        if (!m_bMessageAPI)
+        if (!m_config.bMessageAPI)
         {
             api = SrtCongestion::STA_BUFFER;
             mn  = MN_INVALBUFFERAPI;
@@ -6751,11 +6707,11 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
     //   out a message of a length that exceeds the total size of the sending
     //   buffer (configurable by SRTO_SNDBUF).
 
-    if (m_bMessageAPI && len > int(m_iSndBufSize * m_iMaxSRTPayloadSize))
+    if (m_config.bMessageAPI && len > int(m_config.iSndBufSize * m_iMaxSRTPayloadSize))
     {
         LOGC(aslog.Error,
-             log << "Message length (" << len << ") exceeds the size of sending buffer: "
-                 << (m_iSndBufSize * m_iMaxSRTPayloadSize) << ". Use SRTO_SNDBUF if needed.");
+             log << CONID() << "Message length (" << len << ") exceeds the size of sending buffer: "
+                 << (m_config.iSndBufSize * m_iMaxSRTPayloadSize) << ". Use SRTO_SNDBUF if needed.");
         throw CUDTException(MJ_NOTSUP, MN_XSIZE, 0);
     }
 
@@ -6779,39 +6735,45 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
         m_iReXmitCount   = 1;
     }
 
-    // checkNeedDrop(...) may lock m_RecvAckLock
+    // sndDropTooLate(...) may lock m_RecvAckLock
     // to modify m_pSndBuffer and m_pSndLossList
-    checkNeedDrop((bCongestion));
+    const int iPktsTLDropped SRT_ATR_UNUSED = sndDropTooLate();
 
-    int minlen = 1; // Minimum sender buffer space required for STREAM API
-    if (m_bMessageAPI)
+    // For MESSAGE API the minimum outgoing buffer space required is
+    // the size that can carry over the whole message as passed here.
+    // Otherwise it is allowed to send less bytes.
+    const int iNumPktsRequired = m_config.bMessageAPI ? m_pSndBuffer->countNumPacketsRequired(len) : 1;
+
+    if (m_bTsbPd && iNumPktsRequired > 1)
     {
-        // For MESSAGE API the minimum outgoing buffer space required is
-        // the size that can carry over the whole message as passed here.
-        minlen = (len + m_iMaxSRTPayloadSize - 1) / m_iMaxSRTPayloadSize;
+        LOGC(aslog.Error,
+            log << CONID() << "Message length (" << len << ") can't fit into a single data packet ("
+                << m_pSndBuffer->getMaxPacketLen() << " bytes max).");
+        throw CUDTException(MJ_NOTSUP, MN_XSIZE, 0);
     }
 
-    if (sndBuffersLeft() < minlen)
+    if (sndBuffersLeft() < iNumPktsRequired)
     {
         //>>We should not get here if SRT_ENABLE_TLPKTDROP
         // XXX Check if this needs to be removed, or put to an 'else' condition for m_bTLPktDrop.
-        if (!m_bSynSending)
+        if (!m_config.bSynSending)
             throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
 
         {
             // wait here during a blocking sending
             UniqueLock sendblock_lock (m_SendBlockLock);
 
-            if (m_iSndTimeOut < 0)
+            if (m_config.iSndTimeOut < 0)
             {
-                while (stillConnected() && sndBuffersLeft() < minlen && m_bPeerHealth)
+                while (stillConnected() && sndBuffersLeft() < iNumPktsRequired && m_bPeerHealth)
                     m_SendBlockCond.wait(sendblock_lock);
             }
             else
             {
-                const steady_clock::time_point exptime = steady_clock::now() + milliseconds_from(m_iSndTimeOut);
+                const steady_clock::time_point exptime =
+                    steady_clock::now() + milliseconds_from(m_config.iSndTimeOut);
                 THREAD_PAUSED();
-                while (stillConnected() && sndBuffersLeft() < minlen && m_bPeerHealth)
+                while (stillConnected() && sndBuffersLeft() < iNumPktsRequired && m_bPeerHealth)
                 {
                     if (!m_SendBlockCond.wait_until(sendblock_lock, exptime))
                         break;
@@ -6833,13 +6795,13 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
 
         /*
          * The code below is to return ETIMEOUT when blocking mode could not get free buffer in time.
-         * If no free buffer available in non-blocking mode, we alredy returned. If buffer availaible,
+         * If no free buffer available in non-blocking mode, we alredy returned. If buffer available,
          * we test twice if this code is outside the else section.
          * This fix move it in the else (blocking-mode) section
          */
-        if (sndBuffersLeft() < minlen)
+        if (sndBuffersLeft() < iNumPktsRequired)
         {
-            if (m_iSndTimeOut >= 0)
+            if (m_config.iSndTimeOut >= 0)
                 throw CUDTException(MJ_AGAIN, MN_XMTIMEOUT, 0);
 
             // XXX This looks very weird here, however most likely
@@ -6857,7 +6819,8 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
             //
             // ERGO: never happens?
             LOGC(aslog.Fatal,
-                 log << "IPE: sendmsg: the loop exited, while not enough size, still connected, peer healthy. "
+                 log << CONID()
+                     << "IPE: sendmsg: the loop exited, while not enough size, still connected, peer healthy. "
                         "Impossible.");
 
             return 0;
@@ -6873,7 +6836,7 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
     }
 
     int size = len;
-    if (!m_bMessageAPI)
+    if (!m_config.bMessageAPI)
     {
         // For STREAM API it's allowed to send less bytes than the given buffer.
         // Just return how many bytes were actually scheduled for writing.
@@ -6888,12 +6851,20 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
 
         int32_t seqno = m_iSndNextSeqNo;
         IF_HEAVY_LOGGING(int32_t orig_seqno = seqno);
-        IF_HEAVY_LOGGING(steady_clock::time_point ts_srctime = steady_clock::time_point() + microseconds_from(w_mctrl.srctime));
+        IF_HEAVY_LOGGING(steady_clock::time_point ts_srctime =
+                             steady_clock::time_point() + microseconds_from(w_mctrl.srctime));
 
+#if ENABLE_BONDING
         // Check if seqno has been set, in case when this is a group sender.
         // If the sequence is from the past towards the "next sequence",
         // simply return the size, pretending that it has been sent.
-        if (w_mctrl.pktseq != SRT_SEQNO_NONE && m_iSndNextSeqNo != SRT_SEQNO_NONE)
+
+        // NOTE: it's assumed that if this is a group member, then
+        // an attempt to call srt_sendmsg2 has been rejected, and so
+        // the pktseq field has been set by the internal group sender function.
+        if (m_parent->m_GroupOf
+                && w_mctrl.pktseq != SRT_SEQNO_NONE
+                && m_iSndNextSeqNo != SRT_SEQNO_NONE)
         {
             if (CSeqNo::seqcmp(w_mctrl.pktseq, seqno) < 0)
             {
@@ -6902,6 +6873,7 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
                 return size;
             }
         }
+#endif
 
         // Set this predicted next sequence to the control information.
         // It's the sequence of the FIRST (!) packet from all packets used to send
@@ -6919,14 +6891,16 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
         if (w_mctrl.srctime && w_mctrl.srctime < count_microseconds(m_stats.tsStartTime.time_since_epoch()))
         {
             LOGC(aslog.Error,
-                log << "Wrong source time was provided. Sending is rejected.");
+                log << CONID() << "Wrong source time was provided. Sending is rejected.");
             throw CUDTException(MJ_NOTSUP, MN_INVALMSGAPI);
         }
 
-        if (w_mctrl.srctime && (!m_bMessageAPI || !m_bTsbPd))
+        if (w_mctrl.srctime && (!m_config.bMessageAPI || !m_bTsbPd))
         {
-            HLOGC(aslog.Warn,
-                log << "Source time can only be used with TSBPD and Message API enabled. Using default time instead.");
+            HLOGC(
+                aslog.Warn,
+                log << CONID()
+                    << "Source time can only be used with TSBPD and Message API enabled. Using default time instead.");
             w_mctrl.srctime = 0;
         }
 
@@ -6946,18 +6920,19 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
         if (sndBuffersLeft() < 1) // XXX Not sure if it should test if any space in the buffer, or as requried.
         {
             // write is not available any more
-            s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, false);
+            uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, false);
         }
     }
 
-    // insert this socket to the snd list if it is not on the list yet
+    // Insert this socket to the snd list if it is not on the list already.
     // m_pSndUList->pop may lock CSndUList::m_ListLock and then m_RecvAckLock
-    m_pSndQueue->m_pSndUList->update(this, CSndUList::rescheduleIf(bCongestion));
+    m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE);
 
 #ifdef SRT_ENABLE_ECN
-    if (bCongestion)
+    // IF there was a packet drop on the sender side, report congestion to the app.
+    if (iPktsTLDropped > 0)
     {
-        LOGC(aslog.Error, log << "sendmsg2: CONGESTION; reporting error");
+        LOGC(aslog.Error, log << CONID() << "sendmsg2: CONGESTION; reporting error");
         throw CUDTException(MJ_AGAIN, MN_CONGESTION, 0);
     }
 #endif /* SRT_ENABLE_ECN */
@@ -6966,13 +6941,13 @@ int CUDT::sendmsg2(const char *data, int len, SRT_MSGCTRL& w_mctrl)
     return size;
 }
 
-int CUDT::recv(char* data, int len)
+int srt::CUDT::recv(char* data, int len)
 {
     SRT_MSGCTRL mctrl = srt_msgctrl_default;
     return recvmsg2(data, len, (mctrl));
 }
 
-int CUDT::recvmsg(char* data, int len, int64_t& srctime)
+int srt::CUDT::recvmsg(char* data, int len, int64_t& srctime)
 {
     SRT_MSGCTRL mctrl = srt_msgctrl_default;
     int res = recvmsg2(data, len, (mctrl));
@@ -6980,16 +6955,16 @@ int CUDT::recvmsg(char* data, int len, int64_t& srctime)
     return res;
 }
 
-// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_IncludedGroup != NULL)]]
+// [[using maybe_locked(CUDTGroup::m_GroupLock, m_parent->m_GroupOf != NULL)]]
 // GroupLock is applied when this function is called from inside CUDTGroup::recv,
-// which is the only case when the m_parent->m_IncludedGroup is not NULL.
-int CUDT::recvmsg2(char* data, int len, SRT_MSGCTRL& w_mctrl)
+// which is the only case when the m_parent->m_GroupOf is not NULL.
+int srt::CUDT::recvmsg2(char* data, int len, SRT_MSGCTRL& w_mctrl)
 {
     // Check if the socket is a member of a receiver group.
     // If so, then reading by receiveMessage is disallowed.
 
-#if ENABLE_EXPERIMENTAL_BONDING
-    if (m_parent->m_IncludedGroup && m_parent->m_IncludedGroup->isGroupReceiver())
+#if ENABLE_BONDING
+    if (m_parent->m_GroupOf && m_parent->m_GroupOf->isGroupReceiver())
     {
         LOGP(arlog.Error, "recv*: This socket is a receiver group member. Use group ID, NOT socket ID.");
         throw CUDTException(MJ_NOTSUP, MN_INVALMSGAPI, 0);
@@ -7001,21 +6976,44 @@ int CUDT::recvmsg2(char* data, int len, SRT_MSGCTRL& w_mctrl)
 
     if (len <= 0)
     {
-        LOGC(arlog.Error, log << "Length of '" << len << "' supplied to srt_recvmsg.");
+        LOGC(arlog.Error, log << CONID() << "Length of '" << len << "' supplied to srt_recvmsg.");
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
     }
 
-    if (m_bMessageAPI)
+    if (m_config.bMessageAPI)
         return receiveMessage(data, len, (w_mctrl));
 
     return receiveBuffer(data, len);
 }
 
+// [[using locked(m_RcvBufferLock)]]
+size_t srt::CUDT::getAvailRcvBufferSizeNoLock() const
+{
+    return m_pRcvBuffer->getAvailSize(m_iRcvLastAck);
+}
+
+bool srt::CUDT::isRcvBufferReady() const
+{
+    ScopedLock lck(m_RcvBufferLock);
+    return m_pRcvBuffer->isRcvDataReady(steady_clock::now());
+}
+
+bool srt::CUDT::isRcvBufferReadyNoLock() const
+{
+    return m_pRcvBuffer->isRcvDataReady(steady_clock::now());
+}
+
+bool srt::CUDT::isRcvBufferFull() const
+{
+    ScopedLock lck(m_RcvBufferLock);
+    return m_pRcvBuffer->full();
+}
+
 // int by_exception: accepts values of CUDTUnited::ErrorHandling:
 // - 0 - by return value
 // - 1 - by exception
 // - 2 - by abort (unused)
-int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_exception)
+int srt::CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_exception)
 {
     // Recvmsg isn't restricted to the congctl type, it's the most
     // basic method of passing the data. You can retrieve data as
@@ -7041,7 +7039,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
        ptrn[pos[0]] = charbool[m_bBroken];
        ptrn[pos[1]] = charbool[m_bConnected];
        ptrn[pos[2]] = charbool[m_bClosing];
-       ptrn[pos[3]] = charbool[m_bSynRecving];
+       ptrn[pos[3]] = charbool[m_config.m_bSynRecving];
        int wrtlen = sprintf(ptrn + pos[4], "%d", m_pRcvBuffer->getRcvMsgNum());
        strcpy(ptrn + pos[4] + wrtlen, "\n");
        fputs(ptrn, stderr);
@@ -7051,30 +7049,31 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
     {
         HLOGC(arlog.Debug, log << CONID() << "receiveMessage: CONNECTION BROKEN - reading from recv buffer just for formality");
         enterCS(m_RcvBufferLock);
-        int res       = m_pRcvBuffer->readMsg(data, len);
+        const int res = (m_pRcvBuffer->isRcvDataReady(steady_clock::now()))
+            ? m_pRcvBuffer->readMessage(data, len, &w_mctrl)
+            : 0;
         leaveCS(m_RcvBufferLock);
-        w_mctrl.srctime = 0;
 
         // Kick TsbPd thread to schedule next wakeup (if running)
         if (m_bTsbPd)
         {
             HLOGP(tslog.Debug, "Ping TSBPD thread to schedule wakeup");
-            tscond.signal_locked(recvguard);
+            tscond.notify_one_locked(recvguard);
         }
         else
         {
             HLOGP(tslog.Debug, "NOT pinging TSBPD - not set");
         }
 
-        if (!m_pRcvBuffer->isRcvDataReady())
+        if (!isRcvBufferReady())
         {
             // read is not available any more
-            s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+            uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
         }
 
         if (res == 0)
         {
-            if (!m_bMessageAPI && m_bShutdown)
+            if (!m_config.bMessageAPI && m_bShutdown)
                 return 0;
             // Forced to return error instead of throwing exception.
             if (!by_exception)
@@ -7085,13 +7084,13 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
             return res;
     }
 
-    const int seqdistance = -1;
-
-    if (!m_bSynRecving)
+    if (!m_config.bSynRecving)
     {
         HLOGC(arlog.Debug, log << CONID() << "receiveMessage: BEGIN ASYNC MODE. Going to extract payload size=" << len);
         enterCS(m_RcvBufferLock);
-        const int res = m_pRcvBuffer->readMsg(data, len, (w_mctrl), seqdistance);
+        const int res = (m_pRcvBuffer->isRcvDataReady(steady_clock::now()))
+            ? m_pRcvBuffer->readMessage(data, len, &w_mctrl)
+            : 0;
         leaveCS(m_RcvBufferLock);
         HLOGC(arlog.Debug, log << CONID() << "AFTER readMsg: (NON-BLOCKING) result=" << res);
 
@@ -7102,7 +7101,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
             if (m_bTsbPd)
             {
                 HLOGP(arlog.Debug, "receiveMessage: nothing to read, kicking TSBPD, return AGAIN");
-                tscond.signal_locked(recvguard);
+                tscond.notify_one_locked(recvguard);
             }
             else
             {
@@ -7110,20 +7109,20 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
             }
 
             // Shut up EPoll if no more messages in non-blocking mode
-            s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+            uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
             // Forced to return 0 instead of throwing exception, in case of AGAIN/READ
             if (!by_exception)
                 return 0;
             throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
         }
 
-        if (!m_pRcvBuffer->isRcvDataReady())
+        if (!isRcvBufferReady())
         {
             // Kick TsbPd thread to schedule next wakeup (if running)
             if (m_bTsbPd)
             {
                 HLOGP(arlog.Debug, "receiveMessage: DATA READ, but nothing more - kicking TSBPD.");
-                tscond.signal_locked(recvguard);
+                tscond.notify_one_locked(recvguard);
             }
             else
             {
@@ -7131,11 +7130,11 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
             }
 
             // Shut up EPoll if no more messages in non-blocking mode
-            s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+            uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
 
             // After signaling the tsbpd for ready data, report the bandwidth.
 #if ENABLE_HEAVY_LOGGING
-            double bw = Bps2Mbps( m_iBandwidth * m_iMaxSRTPayloadSize );
+            double bw = Bps2Mbps(int64_t(m_iBandwidth) * m_iMaxSRTPayloadSize );
             HLOGC(arlog.Debug, log << CONID() << "CURRENT BANDWIDTH: " << bw << "Mbps (" << m_iBandwidth << " buffers per second)");
 #endif
         }
@@ -7147,15 +7146,13 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
     int  res     = 0;
     bool timeout = false;
     // Do not block forever, check connection status each 1 sec.
-    const steady_clock::duration recv_timeout = m_iRcvTimeOut < 0 ? seconds_from(1) : milliseconds_from(m_iRcvTimeOut);
+    const steady_clock::duration recv_timeout = m_config.iRcvTimeOut < 0 ? seconds_from(1) : milliseconds_from(m_config.iRcvTimeOut);
 
     CSync recv_cond (m_RecvDataCond, recvguard);
 
     do
     {
-        steady_clock::time_point tstime SRT_ATR_UNUSED;
-        int32_t seqno;
-        if (stillConnected() && !timeout && !m_pRcvBuffer->isRcvDataReady((tstime), (seqno), seqdistance))
+        if (stillConnected() && !timeout && !isRcvBufferReady())
         {
             /* Kick TsbPd thread to schedule next wakeup (if running) */
             if (m_bTsbPd)
@@ -7168,8 +7165,8 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
                 // of kicking TSBPD.
                 // bool spurious = (tstime != 0);
 
-                HLOGC(tslog.Debug, log << CONID() << "receiveMessage: KICK tsbpd" << (is_zero(tstime) ? " (SPURIOUS!)" : ""));
-                tscond.signal_locked(recvguard);
+                HLOGC(tslog.Debug, log << CONID() << "receiveMessage: KICK tsbpd");
+                tscond.notify_one_locked(recvguard);
             }
 
             THREAD_PAUSED();
@@ -7182,12 +7179,12 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
                 const steady_clock::time_point exptime = steady_clock::now() + recv_timeout;
 
                 HLOGC(tslog.Debug,
-                      log << CONID() << "receiveMessage: fall asleep up to TS=" << FormatTime(exptime) << " lock=" << (&m_RecvLock)
-                          << " cond=" << (&m_RecvDataCond));
+                      log << CONID() << "receiveMessage: fall asleep up to TS=" << FormatTime(exptime)
+                          << " lock=" << (&m_RecvLock) << " cond=" << (&m_RecvDataCond));
 
                 if (!recv_cond.wait_until(exptime))
                 {
-                    if (m_iRcvTimeOut >= 0) // otherwise it's "no timeout set"
+                    if (m_config.iRcvTimeOut >= 0) // otherwise it's "no timeout set"
                         timeout = true;
                     HLOGP(tslog.Debug,
                           "receiveMessage: DATA COND: EXPIRED -- checking connection conditions and rolling again");
@@ -7196,12 +7193,12 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
                 {
                     HLOGP(tslog.Debug, "receiveMessage: DATA COND: KICKED.");
                 }
-            } while (stillConnected() && !timeout && (!m_pRcvBuffer->isRcvDataReady()));
+            } while (stillConnected() && !timeout && (!isRcvBufferReady()));
             THREAD_RESUMED();
 
             HLOGC(tslog.Debug,
                   log << CONID() << "receiveMessage: lock-waiting loop exited: stillConntected=" << stillConnected()
-                      << " timeout=" << timeout << " data-ready=" << m_pRcvBuffer->isRcvDataReady());
+                      << " timeout=" << timeout << " data-ready=" << isRcvBufferReady());
         }
 
         /* XXX DEBUG STUFF - enable when required
@@ -7211,7 +7208,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
                 */
 
         enterCS(m_RcvBufferLock);
-        res = m_pRcvBuffer->readMsg((data), len, (w_mctrl), seqdistance);
+        res = m_pRcvBuffer->readMessage((data), len, &w_mctrl);
         leaveCS(m_RcvBufferLock);
         HLOGC(arlog.Debug, log << CONID() << "AFTER readMsg: (BLOCKING) result=" << res);
 
@@ -7220,7 +7217,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
             // Forced to return 0 instead of throwing exception.
             if (!by_exception)
                 return APIError(MJ_CONNECTION, MN_CONNLOST, 0);
-            if (!m_bMessageAPI && m_bShutdown)
+            if (!m_config.bMessageAPI && m_bShutdown)
                 return 0;
             throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
         }
@@ -7233,7 +7230,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
         }
     } while ((res == 0) && !timeout);
 
-    if (!m_pRcvBuffer->isRcvDataReady())
+    if (!isRcvBufferReady())
     {
         // Falling here means usually that res == 0 && timeout == true.
         // res == 0 would repeat the above loop, unless there was also a timeout.
@@ -7246,17 +7243,17 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
         if (m_bTsbPd)
         {
             HLOGP(tslog.Debug, "recvmsg: KICK tsbpd() (buffer empty)");
-            tscond.signal_locked(recvguard);
+            tscond.notify_one_locked(recvguard);
         }
 
         // Shut up EPoll if no more messages in non-blocking mode
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
     }
 
     // Unblock when required
     // LOGC(tslog.Debug, "RECVMSG/EXIT RES " << res << " RCVTIMEOUT");
 
-    if ((res <= 0) && (m_iRcvTimeOut >= 0))
+    if ((res <= 0) && (m_config.iRcvTimeOut >= 0))
     {
         // Forced to return -1 instead of throwing exception.
         if (!by_exception)
@@ -7267,7 +7264,7 @@ int CUDT::receiveMessage(char* data, int len, SRT_MSGCTRL& w_mctrl, int by_excep
     return res;
 }
 
-int64_t CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
+int64_t srt::CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
 {
     if (m_bBroken || m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
@@ -7283,7 +7280,8 @@ int64_t CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
     if (!m_pCryptoControl || !m_pCryptoControl->isSndEncryptionOK())
     {
         LOGC(aslog.Error,
-             log << "Encryption is required, but the peer did not supply correct credentials. Sending rejected.");
+             log << CONID()
+                 << "Encryption is required, but the peer did not supply correct credentials. Sending rejected.");
         throw CUDTException(MJ_SETUP, MN_SECURITY, 0);
     }
 
@@ -7292,6 +7290,7 @@ int64_t CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
     if (m_pSndBuffer->getCurrBufSize() == 0)
     {
         // delay the EXP timer to avoid mis-fired timeout
+        ScopedLock ack_lock(m_RecvAckLock);
         m_tsLastRspAckTime = steady_clock::now();
         m_iReXmitCount   = 1;
     }
@@ -7378,7 +7377,7 @@ int64_t CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
             if (sndBuffersLeft() <= 0)
             {
                 // write is not available any more
-                s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, false);
+                uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, false);
             }
         }
 
@@ -7389,13 +7388,13 @@ int64_t CUDT::sendfile(fstream &ifs, int64_t &offset, int64_t size, int block)
     return size - tosend;
 }
 
-int64_t CUDT::recvfile(fstream &ofs, int64_t &offset, int64_t size, int block)
+int64_t srt::CUDT::recvfile(fstream &ofs, int64_t &offset, int64_t size, int block)
 {
     if (!m_bConnected || !m_CongCtl.ready())
         throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
-    else if ((m_bBroken || m_bClosing) && !m_pRcvBuffer->isRcvDataReady())
+    else if ((m_bBroken || m_bClosing) && !isRcvBufferReady())
     {
-        if (!m_bMessageAPI && m_bShutdown)
+        if (!m_config.bMessageAPI && m_bShutdown)
             return 0;
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
@@ -7408,7 +7407,8 @@ int64_t CUDT::recvfile(fstream &ofs, int64_t &offset, int64_t size, int block)
 
     if (isOPT_TsbPd())
     {
-        LOGC(arlog.Error, log << "Reading from file is incompatible with TSBPD mode and would cause a deadlock\n");
+        LOGC(arlog.Error,
+             log << CONID() << "Reading from file is incompatible with TSBPD mode and would cause a deadlock");
         throw CUDTException(MJ_NOTSUP, MN_INVALBUFFERAPI, 0);
     }
 
@@ -7475,22 +7475,24 @@ int64_t CUDT::recvfile(fstream &ofs, int64_t &offset, int64_t size, int block)
             CSync rcond (m_RecvDataCond, recvguard);
 
             THREAD_PAUSED();
-            while (stillConnected() && !m_pRcvBuffer->isRcvDataReady())
+            while (stillConnected() && !isRcvBufferReady())
                 rcond.wait();
             THREAD_RESUMED();
         }
 
         if (!m_bConnected)
             throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
-        else if ((m_bBroken || m_bClosing) && !m_pRcvBuffer->isRcvDataReady())
+        else if ((m_bBroken || m_bClosing) && !isRcvBufferReady())
         {
-            if (!m_bMessageAPI && m_bShutdown)
+            if (!m_config.bMessageAPI && m_bShutdown)
                 return 0;
             throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
         }
 
         unitsize = int((torecv > block) ? block : torecv);
+        enterCS(m_RcvBufferLock);
         recvsize = m_pRcvBuffer->readBufferToFile(ofs, unitsize);
+        leaveCS(m_RcvBufferLock);
 
         if (recvsize > 0)
         {
@@ -7499,114 +7501,130 @@ int64_t CUDT::recvfile(fstream &ofs, int64_t &offset, int64_t size, int block)
         }
     }
 
-    if (!m_pRcvBuffer->isRcvDataReady())
+    if (!isRcvBufferReady())
     {
         // read is not available any more
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, false);
     }
 
     return size - torecv;
 }
 
-void CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
+void srt::CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
 {
     if (!m_bConnected)
         throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
     if (m_bBroken || m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
-    ScopedLock statsguard(m_StatsLock);
-
-    const steady_clock::time_point currtime = steady_clock::now();
-
-    perf->msTimeStamp          = count_milliseconds(currtime - m_stats.tsStartTime);
-    perf->pktSent              = m_stats.traceSent;
-    perf->pktSentUnique        = m_stats.traceSentUniq;
-    perf->pktRecv              = m_stats.traceRecv;
-    perf->pktRecvUnique        = m_stats.traceRecvUniq;
-    perf->pktSndLoss           = m_stats.traceSndLoss;
-    perf->pktRcvLoss           = m_stats.traceRcvLoss;
-    perf->pktRetrans           = m_stats.traceRetrans;
-    perf->pktRcvRetrans        = m_stats.traceRcvRetrans;
-    perf->pktSentACK           = m_stats.sentACK;
-    perf->pktRecvACK           = m_stats.recvACK;
-    perf->pktSentNAK           = m_stats.sentNAK;
-    perf->pktRecvNAK           = m_stats.recvNAK;
-    perf->usSndDuration        = m_stats.sndDuration;
-    perf->pktReorderDistance   = m_stats.traceReorderDistance;
-    perf->pktReorderTolerance  = m_iReorderTolerance;
-    perf->pktRcvAvgBelatedTime = m_stats.traceBelatedTime;
-    perf->pktRcvBelated        = m_stats.traceRcvBelated;
-
-    perf->pktSndFilterExtra  = m_stats.sndFilterExtra;
-    perf->pktRcvFilterExtra  = m_stats.rcvFilterExtra;
-    perf->pktRcvFilterSupply = m_stats.rcvFilterSupply;
-    perf->pktRcvFilterLoss   = m_stats.rcvFilterLoss;
-
-    /* perf byte counters include all headers (SRT+UDP+IP) */
     const int pktHdrSize = CPacket::HDR_SIZE + CPacket::UDP_HDR_SIZE;
-    perf->byteSent       = m_stats.traceBytesSent + (m_stats.traceSent * pktHdrSize);
-    perf->byteSentUnique = m_stats.traceBytesSentUniq + (m_stats.traceSentUniq * pktHdrSize);
-    perf->byteRecv       = m_stats.traceBytesRecv + (m_stats.traceRecv * pktHdrSize);
-    perf->byteRecvUnique = m_stats.traceBytesRecvUniq + (m_stats.traceRecvUniq * pktHdrSize);
-    perf->byteRetrans    = m_stats.traceBytesRetrans + (m_stats.traceRetrans * pktHdrSize);
-    perf->byteRcvLoss = m_stats.traceRcvBytesLoss + (m_stats.traceRcvLoss * pktHdrSize);
-
-    perf->pktSndDrop  = m_stats.traceSndDrop;
-    perf->pktRcvDrop  = m_stats.traceRcvDrop + m_stats.traceRcvUndecrypt;
-    perf->byteSndDrop = m_stats.traceSndBytesDrop + (m_stats.traceSndDrop * pktHdrSize);
-    perf->byteRcvDrop =
-        m_stats.traceRcvBytesDrop + (m_stats.traceRcvDrop * pktHdrSize) + m_stats.traceRcvBytesUndecrypt;
-    perf->pktRcvUndecrypt  = m_stats.traceRcvUndecrypt;
-    perf->byteRcvUndecrypt = m_stats.traceRcvBytesUndecrypt;
-
-    perf->pktSentTotal       = m_stats.sentTotal;
-    perf->pktSentUniqueTotal = m_stats.sentUniqTotal;
-    perf->pktRecvTotal       = m_stats.recvTotal;
-    perf->pktRecvUniqueTotal = m_stats.recvUniqTotal;
-    perf->pktSndLossTotal    = m_stats.sndLossTotal;
-    perf->pktRcvLossTotal    = m_stats.rcvLossTotal;
-    perf->pktRetransTotal    = m_stats.retransTotal;
-    perf->pktSentACKTotal    = m_stats.sentACKTotal;
-    perf->pktRecvACKTotal    = m_stats.recvACKTotal;
-    perf->pktSentNAKTotal    = m_stats.sentNAKTotal;
-    perf->pktRecvNAKTotal    = m_stats.recvNAKTotal;
-    perf->usSndDurationTotal = m_stats.m_sndDurationTotal;
-
-    perf->byteSentTotal           = m_stats.bytesSentTotal + (m_stats.sentTotal * pktHdrSize);
-    perf->byteSentUniqueTotal     = m_stats.bytesSentUniqTotal + (m_stats.sentUniqTotal * pktHdrSize);
-    perf->byteRecvTotal           = m_stats.bytesRecvTotal + (m_stats.recvTotal * pktHdrSize);
-    perf->byteRecvUniqueTotal     = m_stats.bytesRecvUniqTotal + (m_stats.recvUniqTotal * pktHdrSize);
-    perf->byteRetransTotal        = m_stats.bytesRetransTotal + (m_stats.retransTotal * pktHdrSize);
-    perf->pktSndFilterExtraTotal  = m_stats.sndFilterExtraTotal;
-    perf->pktRcvFilterExtraTotal  = m_stats.rcvFilterExtraTotal;
-    perf->pktRcvFilterSupplyTotal = m_stats.rcvFilterSupplyTotal;
-    perf->pktRcvFilterLossTotal   = m_stats.rcvFilterLossTotal;
-
-    perf->byteRcvLossTotal = m_stats.rcvBytesLossTotal + (m_stats.rcvLossTotal * pktHdrSize);
-    perf->pktSndDropTotal  = m_stats.sndDropTotal;
-    perf->pktRcvDropTotal  = m_stats.rcvDropTotal + m_stats.m_rcvUndecryptTotal;
-    perf->byteSndDropTotal = m_stats.sndBytesDropTotal + (m_stats.sndDropTotal * pktHdrSize);
-    perf->byteRcvDropTotal =
-        m_stats.rcvBytesDropTotal + (m_stats.rcvDropTotal * pktHdrSize) + m_stats.m_rcvBytesUndecryptTotal;
-    perf->pktRcvUndecryptTotal  = m_stats.m_rcvUndecryptTotal;
-    perf->byteRcvUndecryptTotal = m_stats.m_rcvBytesUndecryptTotal;
-
-    double interval = count_microseconds(currtime - m_stats.tsLastSampleTime);
-    perf->mbpsSendRate = double(perf->byteSent) * 8.0 / interval;
-    perf->mbpsRecvRate = double(perf->byteRecv) * 8.0 / interval;
-    perf->usPktSndPeriod      = count_microseconds(m_tdSendInterval);
-    perf->pktFlowWindow       = m_iFlowWindowSize;
-    perf->pktCongestionWindow = (int)m_dCongestionWindow;
-    perf->pktFlightSize       = getFlightSpan();
-    perf->msRTT               = (double)m_iRTT / 1000.0;
-    perf->msSndTsbPdDelay = m_bPeerTsbPd ? m_iPeerTsbPdDelay_ms : 0;
-    perf->msRcvTsbPdDelay = isOPT_TsbPd() ? m_iTsbPdDelay_ms : 0;
-    perf->byteMSS         = m_iMSS;
-
-    perf->mbpsMaxBW = m_llMaxBW > 0 ? Bps2Mbps(m_llMaxBW) : m_CongCtl.ready() ? Bps2Mbps(m_CongCtl->sndBandwidth()) : 0;
-
-    const int64_t availbw = m_iBandwidth == 1 ? m_RcvTimeWindow.getBandwidth() : m_iBandwidth;
+    {
+        int32_t flight_span = getFlightSpan();
+
+        ScopedLock statsguard(m_StatsLock);
+
+        const steady_clock::time_point currtime = steady_clock::now();
+
+        perf->msTimeStamp          = count_milliseconds(currtime - m_stats.tsStartTime);
+        perf->pktSent              = m_stats.sndr.sent.trace.count();
+        perf->pktSentUnique        = m_stats.sndr.sentUnique.trace.count();
+        perf->pktRecv              = m_stats.rcvr.recvd.trace.count();
+        perf->pktRecvUnique        = m_stats.rcvr.recvdUnique.trace.count();
+
+        perf->pktSndLoss           = m_stats.sndr.lost.trace.count();
+        perf->pktRcvLoss           = m_stats.rcvr.lost.trace.count();
+        perf->pktRetrans           = m_stats.sndr.sentRetrans.trace.count();
+        perf->pktRcvRetrans        = m_stats.rcvr.recvdRetrans.trace.count();
+        perf->pktSentACK           = m_stats.rcvr.sentAck.trace.count();
+        perf->pktRecvACK           = m_stats.sndr.recvdAck.trace.count();
+        perf->pktSentNAK           = m_stats.rcvr.sentNak.trace.count();
+        perf->pktRecvNAK           = m_stats.sndr.recvdNak.trace.count();
+        perf->usSndDuration        = m_stats.sndDuration;
+        perf->pktReorderDistance   = m_stats.traceReorderDistance;
+        perf->pktReorderTolerance  = m_iReorderTolerance;
+        perf->pktRcvAvgBelatedTime = m_stats.traceBelatedTime;
+        perf->pktRcvBelated        = m_stats.rcvr.recvdBelated.trace.count();
+
+        perf->pktSndFilterExtra  = m_stats.sndr.sentFilterExtra.trace.count();
+        perf->pktRcvFilterExtra  = m_stats.rcvr.recvdFilterExtra.trace.count();
+        perf->pktRcvFilterSupply = m_stats.rcvr.suppliedByFilter.trace.count();
+        perf->pktRcvFilterLoss   = m_stats.rcvr.lossFilter.trace.count();
+
+        /* perf byte counters include all headers (SRT+UDP+IP) */
+        perf->byteSent       = m_stats.sndr.sent.trace.bytesWithHdr(pktHdrSize);
+        perf->byteSentUnique = m_stats.sndr.sentUnique.trace.bytesWithHdr(pktHdrSize);
+        perf->byteRecv       = m_stats.rcvr.recvd.trace.bytesWithHdr(pktHdrSize);
+        perf->byteRecvUnique = m_stats.rcvr.recvdUnique.trace.bytesWithHdr(pktHdrSize);
+        perf->byteRetrans    = m_stats.sndr.sentRetrans.trace.bytesWithHdr(pktHdrSize);
+        perf->byteRcvLoss    = m_stats.rcvr.lost.trace.bytesWithHdr(pktHdrSize);
+
+        perf->pktSndDrop  = m_stats.sndr.dropped.trace.count();
+        perf->pktRcvDrop  = m_stats.rcvr.dropped.trace.count();
+        perf->byteSndDrop = m_stats.sndr.dropped.trace.bytesWithHdr(pktHdrSize);
+        perf->byteRcvDrop = m_stats.rcvr.dropped.trace.bytesWithHdr(pktHdrSize);
+        perf->pktRcvUndecrypt  = m_stats.rcvr.undecrypted.trace.count();
+        perf->byteRcvUndecrypt = m_stats.rcvr.undecrypted.trace.bytes();
+
+        perf->pktSentTotal       = m_stats.sndr.sent.total.count();
+        perf->pktSentUniqueTotal = m_stats.sndr.sentUnique.total.count();
+        perf->pktRecvTotal       = m_stats.rcvr.recvd.total.count();
+        perf->pktRecvUniqueTotal = m_stats.rcvr.recvdUnique.total.count();
+        perf->pktSndLossTotal    = m_stats.sndr.lost.total.count();
+        perf->pktRcvLossTotal    = m_stats.rcvr.lost.total.count();
+        perf->pktRetransTotal    = m_stats.sndr.sentRetrans.total.count();
+        perf->pktSentACKTotal    = m_stats.rcvr.sentAck.total.count();
+        perf->pktRecvACKTotal    = m_stats.sndr.recvdAck.total.count();
+        perf->pktSentNAKTotal    = m_stats.rcvr.sentNak.total.count();
+        perf->pktRecvNAKTotal    = m_stats.sndr.recvdNak.total.count();
+        perf->usSndDurationTotal = m_stats.m_sndDurationTotal;
+
+        perf->byteSentTotal           = m_stats.sndr.sent.total.bytesWithHdr(pktHdrSize);
+        perf->byteSentUniqueTotal     = m_stats.sndr.sentUnique.total.bytesWithHdr(pktHdrSize);
+        perf->byteRecvTotal           = m_stats.rcvr.recvd.total.bytesWithHdr(pktHdrSize);
+        perf->byteRecvUniqueTotal     = m_stats.rcvr.recvdUnique.total.bytesWithHdr(pktHdrSize);
+        perf->byteRetransTotal        = m_stats.sndr.sentRetrans.total.bytesWithHdr(pktHdrSize);
+        perf->pktSndFilterExtraTotal  = m_stats.sndr.sentFilterExtra.total.count();
+        perf->pktRcvFilterExtraTotal  = m_stats.rcvr.recvdFilterExtra.total.count();
+        perf->pktRcvFilterSupplyTotal = m_stats.rcvr.suppliedByFilter.total.count();
+        perf->pktRcvFilterLossTotal   = m_stats.rcvr.lossFilter.total.count();
+
+        perf->byteRcvLossTotal = m_stats.rcvr.lost.total.bytesWithHdr(pktHdrSize);
+        perf->pktSndDropTotal  = m_stats.sndr.dropped.total.count();
+        perf->pktRcvDropTotal  = m_stats.rcvr.dropped.total.count();
+        // TODO: The payload is dropped. Probably header sizes should not be counted?
+        perf->byteSndDropTotal = m_stats.sndr.dropped.total.bytesWithHdr(pktHdrSize);
+        perf->byteRcvDropTotal = m_stats.rcvr.dropped.total.bytesWithHdr(pktHdrSize);
+        perf->pktRcvUndecryptTotal  = m_stats.rcvr.undecrypted.total.count();
+        perf->byteRcvUndecryptTotal = m_stats.rcvr.undecrypted.total.bytes();
+
+        // TODO: The following class members must be protected with a different mutex, not the m_StatsLock.
+        const double interval     = (double) count_microseconds(currtime - m_stats.tsLastSampleTime);
+        perf->mbpsSendRate        = double(perf->byteSent) * 8.0 / interval;
+        perf->mbpsRecvRate        = double(perf->byteRecv) * 8.0 / interval;
+        perf->usPktSndPeriod      = (double) count_microseconds(m_tdSendInterval.load());
+        perf->pktFlowWindow       = m_iFlowWindowSize.load();
+        perf->pktCongestionWindow = m_iCongestionWindow;
+        perf->pktFlightSize       = flight_span;
+        perf->msRTT               = (double)m_iSRTT / 1000.0;
+        perf->msSndTsbPdDelay     = m_bPeerTsbPd ? m_iPeerTsbPdDelay_ms : 0;
+        perf->msRcvTsbPdDelay     = isOPT_TsbPd() ? m_iTsbPdDelay_ms : 0;
+        perf->byteMSS             = m_config.iMSS;
+
+        perf->mbpsMaxBW = m_config.llMaxBW > 0 ? Bps2Mbps(m_config.llMaxBW)
+                        : m_CongCtl.ready()    ? Bps2Mbps(m_CongCtl->sndBandwidth())
+                                                : 0;
+
+        if (clear)
+        {
+            m_stats.sndr.resetTrace();
+            m_stats.rcvr.resetTrace();
+
+            m_stats.sndDuration = 0;
+            m_stats.tsLastSampleTime = currtime;
+        }
+    }
+
+    const int64_t availbw = m_iBandwidth == 1 ? m_RcvTimeWindow.getBandwidth() : m_iBandwidth.load();
 
     perf->mbpsBandwidth = Bps2Mbps(availbw * (m_iMaxSRTPayloadSize + pktHdrSize));
 
@@ -7625,8 +7643,7 @@ void CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
                 perf->pktSndBuf = m_pSndBuffer->getAvgBufSize((perf->byteSndBuf), (perf->msSndBuf));
             }
             perf->byteSndBuf += (perf->pktSndBuf * pktHdrSize);
-            //<
-            perf->byteAvailSndBuf = (m_iSndBufSize - perf->pktSndBuf) * m_iMSS;
+            perf->byteAvailSndBuf = (m_config.iSndBufSize - perf->pktSndBuf) * m_config.iMSS;
         }
         else
         {
@@ -7638,7 +7655,8 @@ void CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
 
         if (m_pRcvBuffer)
         {
-            perf->byteAvailRcvBuf = m_pRcvBuffer->getAvailBufSize() * m_iMSS;
+            ScopedLock lck(m_RcvBufferLock);
+            perf->byteAvailRcvBuf = (int) getAvailRcvBufferSizeNoLock() * m_config.iMSS;
             if (instantaneous) // no need for historical API for Rcv side
             {
                 perf->pktRcvBuf = m_pRcvBuffer->getRcvDataSize(perf->byteRcvBuf, perf->msRcvBuf);
@@ -7668,37 +7686,9 @@ void CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
         perf->byteRcvBuf = 0;
         perf->msRcvBuf   = 0;
     }
-
-    if (clear)
-    {
-        m_stats.traceSndDrop           = 0;
-        m_stats.traceRcvDrop           = 0;
-        m_stats.traceSndBytesDrop      = 0;
-        m_stats.traceRcvBytesDrop      = 0;
-        m_stats.traceRcvUndecrypt      = 0;
-        m_stats.traceRcvBytesUndecrypt = 0;
-        m_stats.traceBytesSent = m_stats.traceBytesRecv = m_stats.traceBytesRetrans = 0;
-        m_stats.traceBytesSentUniq = m_stats.traceBytesRecvUniq = 0;
-        m_stats.traceSent = m_stats.traceRecv
-            = m_stats.traceSentUniq = m_stats.traceRecvUniq
-            = m_stats.traceSndLoss = m_stats.traceRcvLoss = m_stats.traceRetrans
-            = m_stats.sentACK = m_stats.recvACK = m_stats.sentNAK = m_stats.recvNAK = 0;
-        m_stats.sndDuration                                                       = 0;
-        m_stats.traceRcvRetrans                                                   = 0;
-        m_stats.traceRcvBelated                                                   = 0;
-        m_stats.traceRcvBytesLoss = 0;
-
-        m_stats.sndFilterExtra = 0;
-        m_stats.rcvFilterExtra = 0;
-
-        m_stats.rcvFilterSupply = 0;
-        m_stats.rcvFilterLoss   = 0;
-
-        m_stats.tsLastSampleTime = currtime;
-    }
 }
 
-bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
+bool srt::CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
 {
     // Special things that must be done HERE, not in SrtCongestion,
     // because it involves the input buffer in CUDT. It would be
@@ -7715,7 +7705,7 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
         return false;
     }
 
-    HLOGC(rslog.Debug, log << "updateCC: EVENT:" << TransmissionEventStr(evt));
+    HLOGC(rslog.Debug, log << CONID() << "updateCC: EVENT:" << TransmissionEventStr(evt));
 
     if (evt == TEV_INIT)
     {
@@ -7726,24 +7716,24 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
         EInitEvent only_input = arg.get<EventVariant::INIT>();
         // false = TEV_INIT_RESET: in the beginning, or when MAXBW was changed.
 
-        if (only_input && m_llMaxBW)
+        if (only_input != TEV_INIT_RESET && m_config.llMaxBW)
         {
-            HLOGC(rslog.Debug, log << CONID() << "updateCC/TEV_INIT: non-RESET stage and m_llMaxBW already set to " << m_llMaxBW);
+            HLOGC(rslog.Debug, log << CONID() << "updateCC/TEV_INIT: non-RESET stage and m_config.llMaxBW already set to " << m_config.llMaxBW);
             // Don't change
         }
-        else // either m_llMaxBW == 0 or only_input == TEV_INIT_RESET
+        else // either m_config.llMaxBW == 0 or only_input == TEV_INIT_RESET
         {
             // Use the values:
             // - if SRTO_MAXBW is >0, use it.
             // - if SRTO_MAXBW == 0, use SRTO_INPUTBW + SRTO_OHEADBW
             // - if SRTO_INPUTBW == 0, pass 0 to requst in-buffer sampling
             // Bytes/s
-            int bw = m_llMaxBW != 0 ? m_llMaxBW :                       // When used SRTO_MAXBW
-                         m_llInputBW != 0 ? withOverhead(m_llInputBW) : // SRTO_INPUTBW + SRT_OHEADBW
-                             0; // When both MAXBW and INPUTBW are 0, request in-buffer sampling
+            const int64_t bw = m_config.llMaxBW != 0 ? m_config.llMaxBW :                   // When used SRTO_MAXBW
+                               m_config.llInputBW != 0 ? withOverhead(m_config.llInputBW) : // SRTO_INPUTBW + SRT_OHEADBW
+                               0; // When both MAXBW and INPUTBW are 0, request in-buffer sampling
 
             // Note: setting bw == 0 uses BW_INFINITE value in LiveCC
-            m_CongCtl->updateBandwidth(m_llMaxBW, bw);
+            m_CongCtl->updateBandwidth(m_config.llMaxBW, bw);
 
             if (only_input == TEV_INIT_OHEADBW)
             {
@@ -7752,13 +7742,13 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
             }
             else
             {
-                // No need to calculate input reate if the bandwidth is set
+                // No need to calculate input rate if the bandwidth is set
                 const bool disable_in_rate_calc = (bw != 0);
                 m_pSndBuffer->resetInputRateSmpPeriod(disable_in_rate_calc);
             }
 
             HLOGC(rslog.Debug,
-                  log << CONID() << "updateCC/TEV_INIT: updating BW=" << m_llMaxBW
+                  log << CONID() << "updateCC/TEV_INIT: updating BW=" << m_config.llMaxBW
                       << (only_input == TEV_INIT_RESET
                               ? " (UNCHANGED)"
                               : only_input == TEV_INIT_OHEADBW ? " (only Overhead)" : " (updated sampling rate)"));
@@ -7767,11 +7757,11 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
 
     // This part is also required only by LiveCC, however not
     // moved there due to that it needs access to CSndBuffer.
-    if (evt == TEV_ACK || evt == TEV_LOSSREPORT || evt == TEV_CHECKTIMER)
+    if (evt == TEV_ACK || evt == TEV_LOSSREPORT || evt == TEV_CHECKTIMER || evt == TEV_SYNC)
     {
         // Specific part done when MaxBW is set to 0 (auto) and InputBW is 0.
         // This requests internal input rate sampling.
-        if (m_llMaxBW == 0 && m_llInputBW == 0)
+        if (m_config.llMaxBW == 0 && m_config.llInputBW == 0)
         {
             // Get auto-calculated input rate, Bytes per second
             const int64_t inputbw = m_pSndBuffer->getInputRate();
@@ -7783,8 +7773,8 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
              * and sendrate skyrockets for retransmission.
              * Keep previously set maximum in that case (inputbw == 0).
              */
-            if (inputbw != 0)
-                m_CongCtl->updateBandwidth(0, withOverhead(inputbw)); // Bytes/sec
+            if (inputbw >= 0)
+                m_CongCtl->updateBandwidth(0, withOverhead(std::max(m_config.llMinInputBW, inputbw))); // Bytes/sec
         }
     }
 
@@ -7802,21 +7792,22 @@ bool CUDT::updateCC(ETransmissionEvent evt, const EventVariant arg)
         // - m_dPktSndPeriod
         // - m_dCWndSize
         m_tdSendInterval    = microseconds_from((int64_t)m_CongCtl->pktSndPeriod_us());
-        m_dCongestionWindow = m_CongCtl->cgWindowSize();
+        const double cgwindow = m_CongCtl->cgWindowSize();
+        m_iCongestionWindow = (int) cgwindow;
 #if ENABLE_HEAVY_LOGGING
         HLOGC(rslog.Debug,
-              log << CONID() << "updateCC: updated values from congctl: interval=" << count_microseconds(m_tdSendInterval) << " us ("
-                  << "tk (" << m_CongCtl->pktSndPeriod_us() << "us) cgwindow="
-                  << std::setprecision(3) << m_dCongestionWindow);
+              log << CONID() << "updateCC: updated values from congctl: interval=" << FormatDuration<DUNIT_US>(m_tdSendInterval)
+                  << " (cfg:" << m_CongCtl->pktSndPeriod_us() << "us) cgwindow="
+                  << std::setprecision(3) << cgwindow);
 #endif
     }
 
-    HLOGC(rslog.Debug, log << "udpateCC: finished handling for EVENT:" << TransmissionEventStr(evt));
+    HLOGC(rslog.Debug, log << CONID() << "udpateCC: finished handling for EVENT:" << TransmissionEventStr(evt));
 
     return true;
 }
 
-void CUDT::initSynch()
+void srt::CUDT::initSynch()
 {
     setupMutex(m_SendBlockLock, "SendBlock");
     setupCond(m_SendBlockCond, "SendBlock");
@@ -7831,7 +7822,7 @@ void CUDT::initSynch()
     setupCond(m_RcvTsbPdCond, "RcvTsbPd");
 }
 
-void CUDT::destroySynch()
+void srt::CUDT::destroySynch()
 {
     releaseMutex(m_SendBlockLock);
 
@@ -7856,18 +7847,18 @@ void CUDT::destroySynch()
     releaseCond(m_RcvTsbPdCond);
 }
 
-void CUDT::releaseSynch()
+void srt::CUDT::releaseSynch()
 {
     SRT_ASSERT(m_bClosing);
     // wake up user calls
-    CSync::lock_signal(m_SendBlockCond, m_SendBlockLock);
+    CSync::lock_notify_one(m_SendBlockCond, m_SendBlockLock);
 
     enterCS(m_SendLock);
     leaveCS(m_SendLock);
 
     // Awake tsbpd() and srt_recv*(..) threads for them to check m_bClosing.
-    CSync::lock_signal(m_RecvDataCond, m_RecvLock);
-    CSync::lock_signal(m_RcvTsbPdCond, m_RecvLock);
+    CSync::lock_notify_one(m_RecvDataCond, m_RecvLock);
+    CSync::lock_notify_one(m_RcvTsbPdCond, m_RecvLock);
 
     // Azquiring m_RcvTsbPdStartupLock protects race in starting
     // the tsbpd() thread in CUDT::processData().
@@ -7885,33 +7876,7 @@ void CUDT::releaseSynch()
     leaveCS(m_RecvLock);
 }
 
-// [[using locked(m_RcvBufferLock)]];
-int32_t CUDT::ackDataUpTo(int32_t ack)
-{
-    int acksize = CSeqNo::seqoff(m_iRcvLastSkipAck, ack);
-
-    HLOGC(xtlog.Debug, log << "ackDataUpTo: %" << ack << " vs. current %" << m_iRcvLastSkipAck
-            << " (signing off " << acksize << " packets)");
-
-    m_iRcvLastAck = ack;
-    m_iRcvLastSkipAck = ack;
-
-    // NOTE: This is new towards UDT and prevents spurious
-    // wakeup of select/epoll functions when no new packets
-    // were signed off for extraction.
-    if (acksize > 0)
-    {
-        const int distance = m_pRcvBuffer->ackData(acksize);
-        return CSeqNo::decseq(ack, distance);
-    }
-
-    // If nothing was confirmed, then use the current buffer span
-    const int distance = m_pRcvBuffer->getRcvDataSize();
-    if (distance > 0)
-        return CSeqNo::decseq(ack, distance);
-    return ack;
-}
-
+namespace srt {
 #if ENABLE_HEAVY_LOGGING
 static void DebugAck(string hdr, int prev, int ack)
 {
@@ -7921,7 +7886,6 @@ static void DebugAck(string hdr, int prev, int ack)
         return;
     }
 
-    prev     = CSeqNo::incseq(prev);
     int diff = CSeqNo::seqoff(prev, ack);
     if (diff < 0)
     {
@@ -7943,8 +7907,9 @@ static void DebugAck(string hdr, int prev, int ack)
 #else
 static inline void DebugAck(string, int, int) {}
 #endif
+}
 
-void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam, int size)
+void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam, int size)
 {
     CPacket ctrlpkt;
     setPacketTS(ctrlpkt, steady_clock::now());
@@ -7961,8 +7926,8 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
 
     case UMSG_ACKACK: // 110 - Acknowledgement of Acknowledgement
         ctrlpkt.pack(pkttype, lparam);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
@@ -7976,12 +7941,11 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
             size_t bytes = sizeof(*lossdata) * size;
             ctrlpkt.pack(pkttype, NULL, lossdata, bytes);
 
-            ctrlpkt.m_iID = m_PeerID;
-            nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+            ctrlpkt.set_id(m_PeerID);
+            nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
             enterCS(m_StatsLock);
-            ++m_stats.sentNAK;
-            ++m_stats.sentNAKTotal;
+            m_stats.rcvr.sentNak.count(1);
             leaveCS(m_StatsLock);
         }
         // Call with no arguments - get loss list from internal data.
@@ -7998,12 +7962,11 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
             if (0 < losslen)
             {
                 ctrlpkt.pack(pkttype, NULL, data, losslen * 4);
-                ctrlpkt.m_iID = m_PeerID;
-                nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+                ctrlpkt.set_id(m_PeerID);
+                nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
                 enterCS(m_StatsLock);
-                ++m_stats.sentNAK;
-                ++m_stats.sentNAKTotal;
+                m_stats.rcvr.sentNak.count(1);
                 leaveCS(m_StatsLock);
             }
 
@@ -8011,7 +7974,7 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
         }
 
         // update next NAK time, which should wait enough time for the retansmission, but not too long
-        m_tdNAKInterval = microseconds_from(m_iRTT + 4 * m_iRTTVar);
+        m_tdNAKInterval = microseconds_from(m_iSRTT + 4 * m_iRTTVar);
 
         // Fix the NAKreport period according to the congctl
         m_tdNAKInterval =
@@ -8029,8 +7992,8 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
 
     case UMSG_CGWARNING: // 100 - Congestion Warning
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         m_tsLastWarningTime = steady_clock::now();
 
@@ -8038,36 +8001,38 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
 
     case UMSG_KEEPALIVE: // 001 - Keep-alive
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_HANDSHAKE: // 000 - Handshake
         ctrlpkt.pack(pkttype, NULL, rparam, sizeof(CHandShake));
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_SHUTDOWN: // 101 - Shutdown
+        if (m_PeerID == 0) // Dont't send SHUTDOWN if we don't know peer ID.
+            break;
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_DROPREQ: // 111 - Msg drop request
         ctrlpkt.pack(pkttype, lparam, rparam, 8);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_PEERERROR: // 1000 - acknowledge the peer side a special error
         ctrlpkt.pack(pkttype, lparam);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
@@ -8080,16 +8045,58 @@ void CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rparam,
 
     // Fix keepalive
     if (nbsent)
-        m_tsLastSndTime = steady_clock::now();
+        m_tsLastSndTime.store(steady_clock::now());
+}
+
+// [[using locked(m_RcvBufferLock)]]
+bool srt::CUDT::getFirstNoncontSequence(int32_t& w_seq, string& w_log_reason)
+{
+    if (m_config.bTSBPD || !m_config.bMessageAPI)
+    {
+        // The getFirstNonreadSeqNo() function retuens the sequence number of the first packet
+        // that cannot be read. In cases when a message can consist of several data packets,
+        // an existing packet of partially available message also cannot be read.
+        // If TSBPD mode is enabled, a message must consist of a single data packet only.
+        w_seq = m_pRcvBuffer->getFirstNonreadSeqNo();
+
+        const int32_t iNextSeqNo = CSeqNo::incseq(m_iRcvCurrSeqNo);
+        SRT_ASSERT(CSeqNo::seqcmp(w_seq, iNextSeqNo) <= 0);
+        w_log_reason = iNextSeqNo != w_seq ? "first lost" : "expected next";
+
+        if (CSeqNo::seqcmp(w_seq, iNextSeqNo) > 0)
+        {
+            LOGC(xtlog.Error, log << "IPE: NONCONT-SEQUENCE: RCV buffer first non-read %" << w_seq << ", RCV latest seqno %" << m_iRcvCurrSeqNo);
+            w_seq = iNextSeqNo;
+        }
+        
+        return true;
+    }
+
+    {
+        ScopedLock losslock (m_RcvLossLock);
+        const int32_t seq = m_pRcvLossList->getFirstLostSeq();
+        if (seq != SRT_SEQNO_NONE)
+        {
+            HLOGC(xtlog.Debug, log << "NONCONT-SEQUENCE: first loss %" << seq << " (loss len=" <<
+                    m_pRcvLossList->getLossLength() << ")");
+            w_seq = seq;
+            w_log_reason = "first lost";
+            return true;
+        }
+    }
+
+    w_seq = CSeqNo::incseq(m_iRcvCurrSeqNo);
+    HLOGC(xtlog.Debug, log << "NONCONT-SEQUENCE: past-recv %" << w_seq);
+    w_log_reason = "expected next";
+
+    return true;
 }
 
-int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
+
+int srt::CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
 {
-    SRT_ASSERT(ctrlpkt.getMsgTimeStamp() != 0);
-    int32_t ack;
     int nbsent = 0;
     int local_prevack = 0;
-
 #if ENABLE_HEAVY_LOGGING
     struct SaveBack
     {
@@ -8102,53 +8109,73 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
 
     local_prevack = m_iDebugPrevLastAck;
 
-    string reason = "first lost"; // just for "a reason" of giving particular % for ACK
 #endif
+    string reason; // just for "a reason" of giving particular % for ACK
 
-    {
-        // If there is no loss, the ACK is the current largest sequence number plus 1;
-        // Otherwise it is the smallest sequence number in the receiver loss list.
-        ScopedLock lock(m_RcvLossLock);
-        ack = m_pRcvLossList->getFirstLostSeq();
-    }
+    // The TSBPD thread may change the first lost sequence record (TLPKTDROP).
+    // To avoid it the m_RcvBufferLock has to be acquired.
+    UniqueLock bufflock(m_RcvBufferLock);
+    // The full ACK should be sent to indicate there is now available space in the RCV buffer
+    // since the last full ACK. It should unblock the sender to proceed further.
+    const bool bNeedFullAck = (m_bBufferWasFull && getAvailRcvBufferSizeNoLock() > 0);
+    int32_t ack;    // First unacknowledged packet sequence number (acknowledge up to ack).
 
-    // We don't need to check the length prematurely,
-    // if length is 0, this will return SRT_SEQNO_NONE.
-    // If so happened, simply use the latest received pkt + 1.
-    if (ack == SRT_SEQNO_NONE)
-    {
-        ack = CSeqNo::incseq(m_iRcvCurrSeqNo);
-        IF_HEAVY_LOGGING(reason = "expected next");
-    }
+    if (!getFirstNoncontSequence((ack), (reason)))
+        return nbsent;
 
-    if (m_iRcvLastAckAck == ack)
+    if (m_iRcvLastAckAck == ack && !bNeedFullAck)
     {
-        HLOGC(xtlog.Debug, log << "sendCtrl(UMSG_ACK): last ACK %" << ack << "(" << reason << ") == last ACKACK");
-        return nbsent;
+        HLOGC(xtlog.Debug,      
+                log << CONID() << "sendCtrl(UMSG_ACK): last ACK %" << ack << "(" << reason << ") == last ACKACK");     
+        return nbsent;    
     }
-
     // send out a lite ACK
     // to save time on buffer processing and bandwidth/AS measurement, a lite ACK only feeds back an ACK number
-    if (size == SEND_LITE_ACK)
+    if (size == SEND_LITE_ACK && !bNeedFullAck)
     {
+        bufflock.unlock();
         ctrlpkt.pack(UMSG_ACK, NULL, &ack, size);
-        ctrlpkt.m_iID = m_PeerID;
-        nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
-        DebugAck("sendCtrl(lite):" + CONID(), local_prevack, ack);
+        ctrlpkt.set_id(m_PeerID);
+        nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
+        DebugAck(CONID() + "sendCtrl(lite): ", local_prevack, ack);
         return nbsent;
     }
 
-    // There are new received packets to acknowledge, update related information.
-    /* tsbpd thread may also call ackData when skipping packet so protect code */
-    UniqueLock bufflock(m_RcvBufferLock);
-
     // IF ack %> m_iRcvLastAck
+    // There are new received packets to acknowledge, update related information.
     if (CSeqNo::seqcmp(ack, m_iRcvLastAck) > 0)
     {
-        const int32_t first_seq ATR_UNUSED = ackDataUpTo(ack);
+        // Sanity check if the "selected ACK" points to a sequence
+        // in the past for the buffer. This SHOULD NEVER HAPPEN because
+        // on drop the loss records should have been removed, and the last received
+        // sequence also can't be in the past towards the buffer.
+
+        // NOTE: This problem has been observed when the packet sequence
+        // was incorrectly removed from the receiver loss list. This should
+        // then stay here as a condition in order to detect this problem,
+        // should it happen in the future.
+        if (CSeqNo::seqcmp(ack, m_pRcvBuffer->getStartSeqNo()) < 0)
+        {
+            LOGC(xtlog.Error,
+                    log << CONID() << "sendCtrlAck: IPE: invalid ACK from %" << m_iRcvLastAck << " to %" << ack << " ("
+                    << CSeqNo::seqoff(m_iRcvLastAck, ack) << " packets) buffer=%" << m_pRcvBuffer->getStartSeqNo());
+        }
+        else
+        {
+            HLOGC(xtlog.Debug,
+                    log << CONID() << "sendCtrlAck: %" << m_iRcvLastAck << " -> %" << ack << " ("
+                    << CSeqNo::seqoff(m_iRcvLastAck, ack) << " packets)");
+        }
+
+        m_iRcvLastAck = ack;
+
+#if ENABLE_BONDING
+        const int32_t group_read_seq = m_pRcvBuffer->getFirstReadablePacketInfo(steady_clock::now()).seqno;
+#endif
+
         InvertedLock un_bufflock (m_RcvBufferLock);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         // This actually should be done immediately after the ACK pointers were
         // updated in this socket, but it can't be done inside this function due
         // to being run under a lock.
@@ -8160,86 +8187,104 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
         // required in the defined order. At present we only need the lock
         // on m_GlobControlLock to prevent the group from being deleted
         // in the meantime
-        if (m_parent->m_IncludedGroup)
+        if (m_parent->m_GroupOf)
         {
             // Check is first done before locking to avoid unnecessary
             // mutex locking. The condition for this field is that it
             // can be either never set, already reset, or ever set
             // and possibly dangling. The re-check after lock eliminates
             // the dangling case.
-            ScopedLock glock (s_UDTUnited.m_GlobControlLock);
+            ScopedLock glock (uglobal().m_GlobControlLock);
 
-            // Note that updateLatestRcv will lock m_IncludedGroup->m_GroupLock,
+            // Note that updateLatestRcv will lock m_GroupOf->m_GroupLock,
             // but this is an intended order.
-            if (m_parent->m_IncludedGroup)
+            if (m_parent->m_GroupOf)
             {
                 // A group may need to update the parallelly used idle links,
                 // should it have any. Pass the current socket position in order
                 // to skip it from the group loop.
-                m_parent->m_IncludedGroup->updateLatestRcv(m_parent);
+                m_parent->m_GroupOf->updateLatestRcv(m_parent);
             }
         }
 #endif
-        IF_HEAVY_LOGGING(int32_t oldack = m_iRcvLastSkipAck);
-
         // If TSBPD is enabled, then INSTEAD OF signaling m_RecvDataCond,
         // signal m_RcvTsbPdCond. This will kick in the tsbpd thread, which
         // will signal m_RecvDataCond when there's time to play for particular
         // data packet.
-        HLOGC(xtlog.Debug, log << "ACK: clip %" << oldack << "-%" << ack
-            << ", REVOKED " << CSeqNo::seqoff(ack, m_iRcvLastAck) << " from RCV buffer");
+        HLOGC(xtlog.Debug,
+              log << CONID() << "ACK: clip %" << m_iRcvLastAck << "-%" << ack << ", REVOKED "
+                  << CSeqNo::seqoff(ack, m_iRcvLastAck) << " from RCV buffer");
 
         if (m_bTsbPd)
         {
             /* Newly acknowledged data, signal TsbPD thread */
-            UniqueLock rcvlock(m_RecvLock);
-            CSync tscond(m_RcvTsbPdCond, rcvlock);
+            CUniqueSync tslcc (m_RecvLock, m_RcvTsbPdCond);
             // m_bTsbPdAckWakeup is protected by m_RecvLock in the tsbpd() thread
-            if (m_bTsbPdAckWakeup)
-                tscond.signal_locked(rcvlock);
+            if (m_bTsbPdNeedsWakeup)
+                tslcc.notify_one();
         }
         else
         {
-            if (m_bSynRecving)
             {
-                // signal a waiting "recv" call if there is any data available
-                CSync::lock_signal(m_RecvDataCond, m_RecvLock);
+                CUniqueSync rdcc (m_RecvLock, m_RecvDataCond);
+
+                // Locks m_RcvBufferLock, which is unlocked above by InvertedLock un_bufflock.
+                // Must check read-readiness under m_RecvLock to protect the epoll from concurrent changes in readBuffer()
+                if (isRcvBufferReady())
+                {
+                    if (m_config.bSynRecving)
+                    {
+                        // signal a waiting "recv" call if there is any data available
+                        rdcc.notify_one();
+                    }
+                    // acknowledge any waiting epolls to read
+                    // fix SRT_EPOLL_IN event loss but rcvbuffer still have data：
+                    // 1. user call receive/receivemessage(about line number:6482)
+                    // 2. after read/receive, if rcvbuffer is empty, will set SRT_EPOLL_IN event to false
+                    // 3. but if we do not do some lock work here, will cause some sync problems between threads:
+                    //      (1) user thread: call receive/receivemessage
+                    //      (2) user thread: read data
+                    //      (3) user thread: no data in rcvbuffer, set SRT_EPOLL_IN event to false
+                    //      (4) receive thread: receive data and set SRT_EPOLL_IN to true
+                    //      (5) user thread: set SRT_EPOLL_IN to false
+                    // 4. so , m_RecvLock must be used here to protect epoll event
+                    uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, true);
+                }
             }
-            // acknowledge any waiting epolls to read
-            s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, true);
-#if ENABLE_EXPERIMENTAL_BONDING
-            if (m_parent->m_IncludedGroup)
+#if ENABLE_BONDING
+            if (group_read_seq != SRT_SEQNO_NONE && m_parent->m_GroupOf)
             {
                 // See above explanation for double-checking
-                ScopedLock glock (s_UDTUnited.m_GlobControlLock);
+                ScopedLock glock (uglobal().m_GlobControlLock);
 
-                if (m_parent->m_IncludedGroup)
+                if (m_parent->m_GroupOf)
                 {
                     // The current "APP reader" needs to simply decide as to whether
                     // the next CUDTGroup::recv() call should return with no blocking or not.
                     // When the group is read-ready, it should update its pollers as it sees fit.
-                    m_parent->m_IncludedGroup->updateReadState(m_SocketID, first_seq);
+                    m_parent->m_GroupOf->updateReadState(m_SocketID, group_read_seq);
                 }
             }
 #endif
             CGlobEvent::triggerEvent();
         }
     }
-    else if (ack == m_iRcvLastAck)
+    else if (ack == m_iRcvLastAck && !bNeedFullAck)
     {
         // If the ACK was just sent already AND elapsed time did not exceed RTT,
         if ((steady_clock::now() - m_tsLastAckTime) <
-            (microseconds_from(m_iRTT + 4 * m_iRTTVar)))
+            (microseconds_from(m_iSRTT + 4 * m_iRTTVar)))
         {
-            HLOGC(xtlog.Debug, log << "sendCtrl(UMSG_ACK): ACK %" << ack << " just sent - too early to repeat");
+            HLOGC(xtlog.Debug,
+                  log << CONID() << "sendCtrl(UMSG_ACK): ACK %" << ack << " just sent - too early to repeat");
             return nbsent;
         }
     }
-    else
+    else if (!bNeedFullAck)
     {
         // Not possible (m_iRcvCurrSeqNo+1 <% m_iRcvLastAck ?)
-        LOGC(xtlog.Error, log << "sendCtrl(UMSG_ACK): IPE: curr %" << ack
-            << " <% last %" << m_iRcvLastAck);
+        LOGC(xtlog.Error, log << CONID() << "sendCtrl(UMSG_ACK): IPE: curr(" << reason << ") %"
+             << ack << " <% last %" << m_iRcvLastAck);
         return nbsent;
     }
 
@@ -8247,7 +8292,7 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
     // [[using locked(m_RcvBufferLock)]];
 
     // Send out the ACK only if has not been received by the sender before
-    if (CSeqNo::seqcmp(m_iRcvLastAck, m_iRcvLastAckAck) > 0)
+    if (CSeqNo::seqcmp(m_iRcvLastAck, m_iRcvLastAckAck) > 0 || bNeedFullAck)
     {
         // NOTE: The BSTATS feature turns on extra fields above size 6
         // also known as ACKD_TOTAL_SIZE_VER100.
@@ -8260,13 +8305,10 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
         // number), but still the numbers are from exactly the same domain.
         m_iAckSeqNo = CAckNo::incack(m_iAckSeqNo);
         data[ACKD_RCVLASTACK] = m_iRcvLastAck;
-        data[ACKD_RTT] = m_iRTT;
+        data[ACKD_RTT] = m_iSRTT;
         data[ACKD_RTTVAR] = m_iRTTVar;
-        data[ACKD_BUFFERLEFT] = m_pRcvBuffer->getAvailBufSize();
-        // a minimum flow window of 2 is used, even if buffer is full, to break potential deadlock
-        if (data[ACKD_BUFFERLEFT] < 2)
-            data[ACKD_BUFFERLEFT] = 2;
-
+        data[ACKD_BUFFERLEFT] = (int) getAvailRcvBufferSizeNoLock();
+        m_bBufferWasFull = data[ACKD_BUFFERLEFT] == 0;
         if (steady_clock::now() - m_tsLastAckTime > m_tdACKInterval)
         {
             int rcvRate;
@@ -8276,13 +8318,13 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
             data[ACKD_BANDWIDTH] = m_RcvTimeWindow.getBandwidth();
 
             //>>Patch while incompatible (1.0.2) receiver floating around
-            if (m_lPeerSrtVersion == SrtVersion(1, 0, 2))
+            if (m_uPeerSrtVersion == SrtVersion(1, 0, 2))
             {
                 data[ACKD_RCVRATE] = rcvRate;                                     // bytes/sec
-                data[ACKD_XMRATE] = data[ACKD_BANDWIDTH] * m_iMaxSRTPayloadSize; // bytes/sec
-                ctrlsz = ACKD_FIELD_SIZE * ACKD_TOTAL_SIZE_VER102;
+                data[ACKD_XMRATE_VER102_ONLY] = data[ACKD_BANDWIDTH] * m_iMaxSRTPayloadSize; // bytes/sec
+                ctrlsz = ACKD_FIELD_SIZE * ACKD_TOTAL_SIZE_VER102_ONLY;
             }
-            else if (m_lPeerSrtVersion >= SrtVersion(1, 0, 3))
+            else if (m_uPeerSrtVersion >= SrtVersion(1, 0, 3))
             {
                 // Normal, currently expected version.
                 data[ACKD_RCVRATE] = rcvRate; // bytes/sec
@@ -8298,34 +8340,33 @@ int CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
             ctrlpkt.pack(UMSG_ACK, &m_iAckSeqNo, data, ACKD_FIELD_SIZE * ACKD_TOTAL_SIZE_SMALL);
         }
 
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         setPacketTS(ctrlpkt, steady_clock::now());
-        nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt);
-        DebugAck("sendCtrl(UMSG_ACK): " + CONID(), local_prevack, ack);
+        nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
+        DebugAck(CONID() + "sendCtrl(UMSG_ACK): ", local_prevack, ack);
 
         m_ACKWindow.store(m_iAckSeqNo, m_iRcvLastAck);
 
         enterCS(m_StatsLock);
-        ++m_stats.sentACK;
-        ++m_stats.sentACKTotal;
+        m_stats.rcvr.sentAck.count(1);
         leaveCS(m_StatsLock);
     }
     else
     {
-        HLOGC(xtlog.Debug, log << "sendCtrl(UMSG_ACK): " << CONID() << "ACK %" << m_iRcvLastAck
+        HLOGC(xtlog.Debug, log << CONID() << "sendCtrl(UMSG_ACK): " << "ACK %" << m_iRcvLastAck
             << " <=%  ACKACK %" << m_iRcvLastAckAck << " - NOT SENDING ACK");
     }
 
     return nbsent;
 }
 
-void CUDT::updateSndLossListOnACK(int32_t ackdata_seqno)
+void srt::CUDT::updateSndLossListOnACK(int32_t ackdata_seqno)
 {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // This is for the call of CSndBuffer::getMsgNoAt that returns
     // this value as a notfound-trap.
     int32_t msgno_at_last_acked_seq = SRT_MSGNO_CONTROL;
-    bool is_group = m_parent->m_IncludedGroup;
+    bool is_group = m_parent->m_GroupOf;
 #endif
 
     // Update sender's loss list and acknowledge packets in the sender's buffer
@@ -8341,7 +8382,7 @@ void CUDT::updateSndLossListOnACK(int32_t ackdata_seqno)
         // update sending variables
         m_iSndLastDataAck = ackdata_seqno;
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         if (is_group)
         {
             // Get offset-1 because 'offset' points actually to past-the-end
@@ -8361,35 +8402,43 @@ void CUDT::updateSndLossListOnACK(int32_t ackdata_seqno)
         m_pSndBuffer->ackData(offset);
 
         // acknowledde any waiting epolls to write
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
         CGlobEvent::triggerEvent();
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     if (is_group)
     {
         // m_RecvAckLock is ordered AFTER m_GlobControlLock, so this can only
         // be done now that m_RecvAckLock is unlocked.
-        ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-        if (m_parent->m_IncludedGroup)
+        ScopedLock glock (uglobal().m_GlobControlLock);
+        if (m_parent->m_GroupOf)
         {
-            HLOGC(xtlog.Debug, log << "ACK: acking group sender buffer for #" << msgno_at_last_acked_seq);
+            HLOGC(inlog.Debug, log << CONID() << "ACK: acking group sender buffer for #" << msgno_at_last_acked_seq);
+
+            // Guard access to m_iSndAckedMsgNo field
+            // Note: This can't be done inside CUDTGroup::ackMessage
+            // because this function is also called from CUDT::sndDropTooLate
+            // called from CUDT::sendmsg2 called from CUDTGroup::send, which
+            // applies the lock on m_GroupLock already.
+            ScopedLock glk (*m_parent->m_GroupOf->exp_groupLock());
+
             // NOTE: ackMessage also accepts and ignores the trap representation
             // which is SRT_MSGNO_CONTROL.
-            m_parent->m_IncludedGroup->ackMessage(msgno_at_last_acked_seq);
+            m_parent->m_GroupOf->ackMessage(msgno_at_last_acked_seq);
         }
     }
 #endif
 
     // insert this socket to snd list if it is not on the list yet
-    m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE);
+    const steady_clock::time_point currtime = steady_clock::now();
+    m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE, currtime);
 
-    if (m_bSynSending)
+    if (m_config.bSynSending)
     {
-        CSync::lock_signal(m_SendBlockCond, m_SendBlockLock);
+        CSync::lock_notify_one(m_SendBlockCond, m_SendBlockLock);
     }
 
-    const steady_clock::time_point currtime = steady_clock::now();
     // record total time used for sending
     enterCS(m_StatsLock);
     m_stats.sndDuration += count_microseconds(currtime - m_stats.sndDurationCounter);
@@ -8398,7 +8447,7 @@ void CUDT::updateSndLossListOnACK(int32_t ackdata_seqno)
     leaveCS(m_StatsLock);
 }
 
-void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point& currtime)
+void srt::CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point& currtime)
 {
     const int32_t* ackdata       = (const int32_t*)ctrlpkt.m_pcData;
     const int32_t  ackdata_seqno = ackdata[ACKD_RCVLASTACK];
@@ -8425,18 +8474,15 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
     // Process a lite ACK
     if (isLiteAck)
     {
+        ScopedLock ack_lock(m_RecvAckLock);
         if (CSeqNo::seqcmp(ackdata_seqno, m_iSndLastAck) >= 0)
         {
-            ScopedLock ack_lock(m_RecvAckLock);
-            m_iFlowWindowSize -= CSeqNo::seqoff(m_iSndLastAck, ackdata_seqno);
+            m_iFlowWindowSize = m_iFlowWindowSize - CSeqNo::seqoff(m_iSndLastAck, ackdata_seqno);
             m_iSndLastAck = ackdata_seqno;
 
-            // TODO: m_tsLastRspAckTime should be protected with m_RecvAckLock
-            // because the sendmsg2 may want to change it at the same time.
             m_tsLastRspAckTime = currtime;
             m_iReXmitCount         = 1; // Reset re-transmit count since last ACK
         }
-
         return;
     }
 
@@ -8462,61 +8508,70 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
     //
 
     // Protect packet retransmission
-    enterCS(m_RecvAckLock);
-
-    // Check the validation of the ack
-    if (CSeqNo::seqcmp(ackdata_seqno, CSeqNo::incseq(m_iSndCurrSeqNo)) > 0)
     {
-        leaveCS(m_RecvAckLock);
-        // this should not happen: attack or bug
-        LOGC(gglog.Error,
-                log << CONID() << "ATTACK/IPE: incoming ack seq " << ackdata_seqno << " exceeds current "
+        ScopedLock ack_lock(m_RecvAckLock);
+
+        // Check the validation of the ack
+        if (CSeqNo::seqcmp(ackdata_seqno, CSeqNo::incseq(m_iSndCurrSeqNo)) > 0)
+        {
+            // this should not happen: attack or bug
+            LOGC(gglog.Error,
+                    log << CONID() << "ATTACK/IPE: incoming ack seq " << ackdata_seqno << " exceeds current "
                     << m_iSndCurrSeqNo << " by " << (CSeqNo::seqoff(m_iSndCurrSeqNo, ackdata_seqno) - 1) << "!");
-        m_bBroken        = true;
-        m_iBrokenCounter = 0;
-        return;
-    }
+            m_bBroken        = true;
+            m_iBrokenCounter = 0;
+            return;
+        }
 
     if (CSeqNo::seqcmp(ackdata_seqno, m_iSndLastAck) >= 0)
     {
+        const int cwnd1   = std::min<int>(m_iFlowWindowSize, m_iCongestionWindow);
+        const bool bWasStuck = cwnd1<= getFlightSpan();
         // Update Flow Window Size, must update before and together with m_iSndLastAck
         m_iFlowWindowSize = ackdata[ACKD_BUFFERLEFT];
         m_iSndLastAck     = ackdata_seqno;
         m_tsLastRspAckTime  = currtime;
         m_iReXmitCount    = 1; // Reset re-transmit count since last ACK
+
+        const int cwnd    = std::min<int>(m_iFlowWindowSize, m_iCongestionWindow);
+        if (bWasStuck && cwnd > getFlightSpan())
+        {
+            m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE);
+            HLOGC(gglog.Debug,
+                    log << CONID() << "processCtrlAck: could reschedule SND. iFlowWindowSize " << m_iFlowWindowSize
+                    << " SPAN " << getFlightSpan() << " ackdataseqno %" << ackdata_seqno);
+        }
     }
 
-    /*
-     * We must not ignore full ack received by peer
-     * if data has been artificially acked by late packet drop.
-     * Therefore, a distinct ack state is used for received Ack (iSndLastFullAck)
-     * and ack position in send buffer (m_iSndLastDataAck).
-     * Otherwise, when severe congestion causing packet drops (and m_iSndLastDataAck update)
-     * occures, we drop received acks (as duplicates) and do not update stats like RTT,
-     * which may go crazy and stay there, preventing proper stream recovery.
-     */
+        /*
+         * We must not ignore full ack received by peer
+         * if data has been artificially acked by late packet drop.
+         * Therefore, a distinct ack state is used for received Ack (iSndLastFullAck)
+         * and ack position in send buffer (m_iSndLastDataAck).
+         * Otherwise, when severe congestion causing packet drops (and m_iSndLastDataAck update)
+         * occures, we drop received acks (as duplicates) and do not update stats like RTT,
+         * which may go crazy and stay there, preventing proper stream recovery.
+         */
 
-    if (CSeqNo::seqoff(m_iSndLastFullAck, ackdata_seqno) <= 0)
-    {
-        // discard it if it is a repeated ACK
-        leaveCS(m_RecvAckLock);
-        return;
+        if (CSeqNo::seqoff(m_iSndLastFullAck, ackdata_seqno) <= 0)
+        {
+            // discard it if it is a repeated ACK
+            return;
+        }
+        m_iSndLastFullAck = ackdata_seqno;
     }
-    m_iSndLastFullAck = ackdata_seqno;
-
     //
     // END of the new code with TLPKTDROP
     //
-    leaveCS(m_RecvAckLock);
-#if ENABLE_EXPERIMENTAL_BONDING
-    if (m_parent->m_IncludedGroup)
+#if ENABLE_BONDING
+    if (m_parent->m_GroupOf)
     {
-        ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-        if (m_parent->m_IncludedGroup)
+        ScopedLock glock (uglobal().m_GlobControlLock);
+        if (m_parent->m_GroupOf)
         {
             // Will apply m_GroupLock, ordered after m_GlobControlLock.
             // m_GlobControlLock is necessary for group existence.
-            m_parent->m_IncludedGroup->updateWriteState();
+            m_parent->m_GroupOf->updateWriteState();
         }
     }
 #endif
@@ -8542,15 +8597,65 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
     }
     // This check covers fields up to ACKD_BUFFERLEFT.
 
-    // Update RTT
-    // m_iRTT = ackdata[ACKD_RTT];
-    // m_iRTTVar = ackdata[ACKD_RTTVAR];
-    // XXX These ^^^ commented-out were blocked in UDT;
-    // the current RTT calculations are exactly the same as in UDT4.
-    const int rtt = ackdata[ACKD_RTT];
+    // Extract RTT estimate and RTTVar from the ACK packet.
+    const int rtt    = ackdata[ACKD_RTT];
+    const int rttvar = ackdata[ACKD_RTTVAR];
+
+    // Update the values of smoothed RTT and the variation in RTT samples
+    // on subsequent RTT estimates extracted from the ACK packets
+    // (during transmission).
+    if (m_bIsFirstRTTReceived)
+    {
+        // Suppose transmission is bidirectional if sender is also receiving
+        // data packets.
+        enterCS(m_StatsLock);
+        const bool bPktsReceived = m_stats.rcvr.recvd.total.count() != 0;
+        leaveCS(m_StatsLock);
+
+        if (bPktsReceived)  // Transmission is bidirectional.
+        {
+            // RTT value extracted from the ACK packet (rtt) is already smoothed
+            // RTT obtained at the receiver side. Apply EWMA anyway for the second
+            // time on the sender side. Ignore initial values which might arrive
+            // after the smoothed RTT on the sender side has been
+            // reset to the very first RTT sample received from the receiver.
+            // TODO: The case of bidirectional transmission requires further
+            // improvements and testing. Double smoothing is applied here to be
+            // consistent with the previous behavior.
+            if (rtt != INITIAL_RTT || rttvar != INITIAL_RTTVAR)
+            {
+                int iSRTT = m_iSRTT.load(), iRTTVar = m_iRTTVar.load();
+                iRTTVar = avg_iir<4>(iRTTVar, abs(rtt - iSRTT));
+                iSRTT   = avg_iir<8>(iSRTT, rtt);
+                m_iSRTT = iSRTT;
+                m_iRTTVar = iRTTVar;
+            }
+        }
+        else  // Transmission is unidirectional.
+        {
+            // Simply take the values of smoothed RTT and RTT variance from
+            // the ACK packet.
+            m_iSRTT   = rtt;
+            m_iRTTVar = rttvar;
+        }
+    }
+    // Reset the value of smoothed RTT to the first real RTT estimate extracted
+    // from an ACK after initialization (at the beginning of transmission).
+    // In case of resumed connection over the same network, the very first RTT
+    // value sent within an ACK will be taken from cache and equal to previous
+    // connection's final smoothed RTT value. The reception of such a value
+    // will also trigger the smoothed RTT reset at the sender side.
+    else if (rtt != INITIAL_RTT && rttvar != INITIAL_RTTVAR)
+    {
+        m_iSRTT               = rtt;
+        m_iRTTVar             = rttvar;
+        m_bIsFirstRTTReceived = true;
+    }
 
-    m_iRTTVar = avg_iir<4>(m_iRTTVar, abs(rtt - m_iRTT));
-    m_iRTT    = avg_iir<8>(m_iRTT, rtt);
+#if SRT_DEBUG_RTT
+    s_rtt_trace.trace(currtime, "ACK", rtt, rttvar, m_bIsFirstRTTReceived,
+                      m_stats.recvTotal, m_iSRTT, m_iRTTVar);
+#endif
 
     /* Version-dependent fields:
      * Original UDT (total size: ACKD_TOTAL_SIZE_SMALL):
@@ -8561,10 +8666,10 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
      * Additional UDT fields, not always attached:
      *   ACKD_RCVSPEED
      *   ACKD_BANDWIDTH
-     * SRT extension version 1.0.2 (bstats):
+     * SRT extension since v1.0.1:
      *   ACKD_RCVRATE
-     * SRT extension version 1.0.4:
-     *   ACKD_XMRATE
+     * SRT extension in v1.0.2 only:
+     *   ACKD_XMRATE_VER102_ONLY
      */
 
     if (acksize > ACKD_TOTAL_SIZE_SMALL)
@@ -8574,7 +8679,7 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
         int bandwidth = ackdata[ACKD_BANDWIDTH];
         int bytesps;
 
-        /* SRT v1.0.2 Bytes-based stats: bandwidth (pcData[ACKD_XMRATE]) and delivery rate (pcData[ACKD_RCVRATE]) in
+        /* SRT v1.0.2 Bytes-based stats: bandwidth (pcData[ACKD_XMRATE_VER102_ONLY]) and delivery rate (pcData[ACKD_RCVRATE]) in
          * bytes/sec instead of pkts/sec */
         /* SRT v1.0.3 Bytes-based stats: only delivery rate (pcData[ACKD_RCVRATE]) in bytes/sec instead of pkts/sec */
         if (acksize > ACKD_TOTAL_SIZE_UDTBASE)
@@ -8582,11 +8687,9 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
         else
             bytesps = pktps * m_iMaxSRTPayloadSize;
 
-        m_iBandwidth        = avg_iir<8>(m_iBandwidth, bandwidth);
-        m_iDeliveryRate     = avg_iir<8>(m_iDeliveryRate, pktps);
-        m_iByteDeliveryRate = avg_iir<8>(m_iByteDeliveryRate, bytesps);
-        // XXX not sure if ACKD_XMRATE is of any use. This is simply
-        // calculated as ACKD_BANDWIDTH * m_iMaxSRTPayloadSize.
+        m_iBandwidth        = avg_iir<8>(m_iBandwidth.load(), bandwidth);
+        m_iDeliveryRate     = avg_iir<8>(m_iDeliveryRate.load(), pktps);
+        m_iByteDeliveryRate = avg_iir<8>(m_iByteDeliveryRate.load(), bytesps);
 
         // Update Estimated Bandwidth and packet delivery rate
         // m_iRcvRate = m_iDeliveryRate;
@@ -8595,16 +8698,112 @@ void CUDT::processCtrlAck(const CPacket &ctrlpkt, const steady_clock::time_point
         // cudt->deliveryRate() instead.
     }
 
-    checkSndTimers(REGEN_KM);
     updateCC(TEV_ACK, EventVariant(ackdata_seqno));
 
     enterCS(m_StatsLock);
-    ++m_stats.recvACK;
-    ++m_stats.recvACKTotal;
+    m_stats.sndr.recvdAck.count(1);
     leaveCS(m_StatsLock);
 }
 
-void CUDT::processCtrlLossReport(const CPacket& ctrlpkt)
+void srt::CUDT::processCtrlAckAck(const CPacket& ctrlpkt, const time_point& tsArrival)
+{
+    int32_t ack = 0;
+
+    // Calculate RTT estimate on the receiver side based on ACK/ACKACK pair.
+    const int rtt = m_ACKWindow.acknowledge(ctrlpkt.getAckSeqNo(), ack, tsArrival);
+
+    if (rtt == -1)
+    {
+        if (ctrlpkt.getAckSeqNo() > (m_iAckSeqNo - static_cast<int>(ACK_WND_SIZE)) && ctrlpkt.getAckSeqNo() <= m_iAckSeqNo)
+        {
+            string why;
+            if (frequentLogAllowed(FREQLOGFA_ACKACK_OUTOFORDER, tsArrival, (why)))
+            {
+                LOGC(inlog.Note,
+                    log << CONID() << "ACKACK out of order, skipping RTT calculation "
+                    << "(ACK number: " << ctrlpkt.getAckSeqNo() << ", last ACK sent: " << m_iAckSeqNo
+                    << ", RTT (EWMA): " << m_iSRTT << ")." << why);
+            }
+#if SRT_ENABLE_FREQUENT_LOG_TRACE
+            else
+            {
+                LOGC(qrlog.Note, log << "SUPPRESSED: ACKACK out of order LOG: " << why);
+            }
+#endif
+
+            return;
+        }
+
+        LOGC(inlog.Error,
+             log << CONID() << "ACK record not found, can't estimate RTT "
+                 << "(ACK number: " << ctrlpkt.getAckSeqNo() << ", last ACK sent: " << m_iAckSeqNo
+                 << ", RTT (EWMA): " << m_iSRTT << ")");
+        return;
+    }
+
+    if (rtt <= 0)
+    {
+        LOGC(inlog.Error,
+            log << CONID() << "IPE: invalid RTT estimate " << rtt
+            << ", possible time shift. Clock: " << SRT_SYNC_CLOCK_STR);
+        return;
+    }
+
+    // If increasing delay is detected.
+    //   sendCtrl(UMSG_CGWARNING);
+
+    // Update the values of smoothed RTT and the variation in RTT samples
+    // on subsequent RTT samples (during transmission).
+    if (m_bIsFirstRTTReceived)
+    {
+        m_iRTTVar = avg_iir<4>(m_iRTTVar.load(), abs(rtt - m_iSRTT.load()));
+        m_iSRTT   = avg_iir<8>(m_iSRTT.load(), rtt);
+    }
+    // Reset the value of smoothed RTT on the first RTT sample after initialization
+    // (at the beginning of transmission).
+    // In case of resumed connection over the same network, the initial RTT
+    // value will be taken from cache and equal to previous connection's
+    // final smoothed RTT value.
+    else
+    {
+        m_iSRTT               = rtt;
+        m_iRTTVar             = rtt / 2;
+        m_bIsFirstRTTReceived = true;
+    }
+
+#if SRT_DEBUG_RTT
+    s_rtt_trace.trace(tsArrival, "ACKACK", rtt, -1, m_bIsFirstRTTReceived,
+                      -1, m_iSRTT, m_iRTTVar);
+#endif
+
+    updateCC(TEV_ACKACK, EventVariant(ack));
+
+    // This function will put a lock on m_RecvLock by itself, as needed.
+    // It must be done inside because this function reads the current time
+    // and if waiting for the lock has caused a delay, the time will be
+    // inaccurate. Additionally it won't lock if TSBPD mode is off, and
+    // won't update anything. Note that if you set TSBPD mode and use
+    // srt_recvfile (which doesn't make any sense), you'll have a deadlock.
+    if (m_config.bDriftTracer)
+    {
+#if ENABLE_BONDING
+        ScopedLock glock(uglobal().m_GlobControlLock); // XXX not too excessive?
+        const bool drift_updated =
+#endif
+        m_pRcvBuffer->addRcvTsbPdDriftSample(ctrlpkt.getMsgTimeStamp(), tsArrival, rtt);
+
+#if ENABLE_BONDING
+        if (drift_updated && m_parent->m_GroupOf)
+            m_parent->m_GroupOf->synchronizeDrift(this);
+#endif
+    }
+
+    // Update last ACK that has been received by the sender
+    if (CSeqNo::seqcmp(ack, m_iRcvLastAckAck) > 0)
+        m_iRcvLastAckAck = ack;
+}
+
+void srt::CUDT::processCtrlLossReport(const CPacket& ctrlpkt)
 {
     const int32_t* losslist = (int32_t*)(ctrlpkt.m_pcData);
     const size_t   losslist_len = ctrlpkt.getLength() / 4;
@@ -8613,115 +8812,130 @@ void CUDT::processCtrlLossReport(const CPacket& ctrlpkt)
 
     // This variable is used in "normal" logs, so it may cause a warning
     // when logging is forcefully off.
-    int32_t wrong_loss SRT_ATR_UNUSED = CSeqNo::m_iMaxSeqNo;
+    int32_t wrong_loss SRT_ATR_UNUSED = SRT_SEQNO_NONE;
 
     // protect packet retransmission
     {
         ScopedLock ack_lock(m_RecvAckLock);
 
         // decode loss list message and insert loss into the sender loss list
-        for (int i = 0, n = (int)(ctrlpkt.getLength() / 4); i < n; ++i)
+        for (int i = 0, n = (int)losslist_len; i < n; ++i)
         {
+            // IF the loss is a range <LO, HI>
             if (IsSet(losslist[i], LOSSDATA_SEQNO_RANGE_FIRST))
             {
-                // Then it's this is a <lo, hi> specification with HI in a consecutive cell.
+                // Then it's this is a <LO, HI> specification with HI in a consecutive cell.
                 const int32_t losslist_lo = SEQNO_VALUE::unwrap(losslist[i]);
                 const int32_t losslist_hi = losslist[i + 1];
-                // <lo, hi> specification means that the consecutive cell has been already interpreted.
+                // <LO, HI> specification means that the consecutive cell has been already interpreted.
                 ++i;
 
-                HLOGF(inlog.Debug,
-                    "%sreceived UMSG_LOSSREPORT: %d-%d (%d packets)...", CONID().c_str(),
-                    losslist_lo,
-                    losslist_hi,
-                    CSeqNo::seqoff(losslist_lo, losslist_hi) + 1);
+                HLOGC(inlog.Debug, log << CONID() << "received UMSG_LOSSREPORT: "
+                                       << losslist_lo << "-" << losslist_hi
+                                       << " (" << CSeqNo::seqlen(losslist_lo, losslist_hi) << " packets)...");
 
                 if ((CSeqNo::seqcmp(losslist_lo, losslist_hi) > 0) ||
                     (CSeqNo::seqcmp(losslist_hi, m_iSndCurrSeqNo) > 0))
                 {
+                    // LO must not be greater than HI.
+                    // HI must not be greater than the most recent sent seq.
                     LOGC(inlog.Warn, log << CONID() << "rcv LOSSREPORT rng " << losslist_lo << " - " << losslist_hi
                         << " with last sent " << m_iSndCurrSeqNo << " - DISCARDING");
-                    // seq_a must not be greater than seq_b; seq_b must not be greater than the most recent sent seq
                     secure = false;
                     wrong_loss = losslist_hi;
                     break;
                 }
 
                 int num = 0;
-                //   IF losslist_lo %>= m_iSndLastAck
+                // IF losslist_lo %>= m_iSndLastAck
                 if (CSeqNo::seqcmp(losslist_lo, m_iSndLastAck) >= 0)
                 {
                     HLOGC(inlog.Debug, log << CONID() << "LOSSREPORT: adding "
                         << losslist_lo << " - " << losslist_hi << " to loss list");
                     num = m_pSndLossList->insert(losslist_lo, losslist_hi);
                 }
-                // ELSE IF losslist_hi %>= m_iSndLastAck
-                else if (CSeqNo::seqcmp(losslist_hi, m_iSndLastAck) >= 0)
-                {
-                    // This should be theoretically impossible because this would mean
-                    // that the received packet loss report informs about the loss that predates
-                    // the ACK sequence.
-                    // However, this can happen if the packet reordering has caused the earlier sent
-                    // LOSSREPORT will be delivered after later sent ACK. Whatever, ACK should be
-                    // more important, so simply drop the part that predates ACK.
-                    HLOGC(inlog.Debug, log << CONID() << "LOSSREPORT: adding "
-                        << m_iSndLastAck << "[ACK] - " << losslist_hi << " to loss list");
-                    num = m_pSndLossList->insert(m_iSndLastAck, losslist_hi);
-                }
+                // ELSE losslist_lo %< m_iSndLastAck
                 else
                 {
-                    // This should be treated as IPE, but this may happen in one situtation:
+                    // This should be theoretically impossible because this would mean that
+                    // the received packet loss report informs about the loss that predates
+                    // the ACK sequence.
+                    // However, this can happen in these situations:
+                    // - if the packet reordering has caused the earlier sent LOSSREPORT will be
+                    // delivered after later sent ACK. Whatever, ACK should be more important,
+                    // so simply drop the part that predates ACK.
                     // - redundancy second link (ISN was screwed up initially, but late towards last sent)
                     // - initial DROPREQ was lost
                     // This just causes repeating DROPREQ, as when the receiver continues sending
                     // LOSSREPORT, it's probably UNAWARE OF THE SITUATION.
-                    //
+                    int32_t dropreq_hi = losslist_hi;
+                    IF_HEAVY_LOGGING(const char* drop_type = "completely");
+
+                    // IF losslist_hi %>= m_iSndLastAck
+                    if (CSeqNo::seqcmp(losslist_hi, m_iSndLastAck) >= 0)
+                    {
+                        HLOGC(inlog.Debug, log << CONID() << "LOSSREPORT: adding "
+                                << m_iSndLastAck << "[ACK] - " << losslist_hi << " to loss list");
+                        num = m_pSndLossList->insert(m_iSndLastAck, losslist_hi);
+                        dropreq_hi = CSeqNo::decseq(m_iSndLastAck);
+                        IF_HEAVY_LOGGING(drop_type = "partially");
+                    }
+
+                    // In distinction to losslist, DROPREQ has always just one range,
+                    // and the data are <LO, HI>, with no range bit.
+                    int32_t seqpair[2] = { losslist_lo, dropreq_hi };
+                    const int32_t no_msgno = 0; // We don't know.
+
                     // When this DROPREQ gets lost in UDP again, the receiver will do one of these:
                     // - repeatedly send LOSSREPORT (as per NAKREPORT), so this will happen again
                     // - finally give up rexmit request as per TLPKTDROP (DROPREQ should make
                     //   TSBPD wake up should it still wait for new packets to get ACK-ed)
-
-                    HLOGC(inlog.Debug, log << CONID() << "LOSSREPORT: IGNORED with SndLastAck=%"
-                        << m_iSndLastAck << ": %" << losslist_lo << "-" << losslist_hi
-                        << " - sending DROPREQ (IPE or DROPREQ lost with ISN screw)");
-
-                    // This means that the loss touches upon a range that wasn't ever sent.
-                    // Normally this should never happen, but this might be a case when the
-                    // ISN FIX for redundant connection was missed.
-
-                    // In distinction to losslist, DROPREQ has always a range
-                    // always just one range, and the data are <LO, HI>, with no range bit.
-                    int32_t seqpair[2] = { losslist_lo, losslist_hi };
-                    const int32_t no_msgno = 0; // We don't know - this wasn't ever sent
-
+                    HLOGC(inlog.Debug,
+                          log << CONID() << "LOSSREPORT: " << drop_type << " IGNORED with SndLastAck=%" << m_iSndLastAck
+                              << ": %" << losslist_lo << "-" << dropreq_hi << " - sending DROPREQ");
                     sendCtrl(UMSG_DROPREQ, &no_msgno, seqpair, sizeof(seqpair));
                 }
 
                 enterCS(m_StatsLock);
-                m_stats.traceSndLoss += num;
-                m_stats.sndLossTotal += num;
+                m_stats.sndr.lost.count(num);
                 leaveCS(m_StatsLock);
             }
-            else if (CSeqNo::seqcmp(losslist[i], m_iSndLastAck) >= 0)
+            // ELSE the loss is a single seq
+            else
             {
-                if (CSeqNo::seqcmp(losslist[i], m_iSndCurrSeqNo) > 0)
+                // IF loss_seq %>= m_iSndLastAck
+                if (CSeqNo::seqcmp(losslist[i], m_iSndLastAck) >= 0)
                 {
-                    LOGC(inlog.Warn, log << CONID() << "rcv LOSSREPORT pkt %" << losslist[i]
-                        << " with last sent %" << m_iSndCurrSeqNo << " - DISCARDING");
-                    // seq_a must not be greater than the most recent sent seq
-                    secure = false;
-                    wrong_loss = losslist[i];
-                    break;
-                }
+                    if (CSeqNo::seqcmp(losslist[i], m_iSndCurrSeqNo) > 0)
+                    {
+                        LOGC(inlog.Warn, log << CONID() << "rcv LOSSREPORT pkt %" << losslist[i]
+                                << " with last sent %" << m_iSndCurrSeqNo << " - DISCARDING");
+                        // loss_seq must not be greater than the most recent sent seq
+                        secure = false;
+                        wrong_loss = losslist[i];
+                        break;
+                    }
 
-                HLOGC(inlog.Debug, log << CONID() << "rcv LOSSREPORT: %"
-                    << losslist[i] << " (1 packet)");
-                const int num = m_pSndLossList->insert(losslist[i], losslist[i]);
+                    HLOGC(inlog.Debug,
+                            log << CONID() << "LOSSREPORT: adding %" << losslist[i] << " (1 packet) to loss list");
+                    const int num = m_pSndLossList->insert(losslist[i], losslist[i]);
 
-                enterCS(m_StatsLock);
-                m_stats.traceSndLoss += num;
-                m_stats.sndLossTotal += num;
-                leaveCS(m_StatsLock);
+                    enterCS(m_StatsLock);
+                    m_stats.sndr.lost.count(num);
+                    leaveCS(m_StatsLock);
+                }
+                // ELSE loss_seq %< m_iSndLastAck
+                else
+                {
+                    // In distinction to losslist, DROPREQ has always just one range,
+                    // and the data are <LO, HI>, with no range bit.
+                    int32_t seqpair[2] = { losslist[i], losslist[i] };
+                    const int32_t no_msgno = 0; // We don't know.
+                    HLOGC(inlog.Debug,
+                            log << CONID() << "LOSSREPORT: IGNORED with SndLastAck=%" << m_iSndLastAck << ": %" << losslist[i]
+                            << " - sending DROPREQ");
+                    sendCtrl(UMSG_DROPREQ, &no_msgno, seqpair, sizeof(seqpair));
+                }
             }
         }
     }
@@ -8740,86 +8954,256 @@ void CUDT::processCtrlLossReport(const CPacket& ctrlpkt)
     }
 
     // the lost packet (retransmission) should be sent out immediately
-    m_pSndQueue->m_pSndUList->update(this, CSndUList::DO_RESCHEDULE);
+    m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE);
 
     enterCS(m_StatsLock);
-    ++m_stats.recvNAK;
-    ++m_stats.recvNAKTotal;
+    m_stats.sndr.recvdNak.count(1);
     leaveCS(m_StatsLock);
 }
 
-void CUDT::processCtrl(const CPacket &ctrlpkt)
+void srt::CUDT::processCtrlHS(const CPacket& ctrlpkt)
 {
-    // Just heard from the peer, reset the expiration count.
-    m_iEXPCount = 1;
-    const steady_clock::time_point currtime = steady_clock::now();
-    m_tsLastRspTime = currtime;
-    bool using_rexmit_flag = m_bPeerRexmitFlag;
+    CHandShake req;
+    req.load_from(ctrlpkt.m_pcData, ctrlpkt.getLength());
+
+    HLOGC(inlog.Debug, log << CONID() << "processCtrl: got HS: " << req.show());
+
+    if ((req.m_iReqType > URQ_INDUCTION_TYPES) // acually it catches URQ_INDUCTION and URQ_ERROR_* symbols...???
+        || (m_config.bRendezvous && (req.m_iReqType != URQ_AGREEMENT))) // rnd sends AGREEMENT in rsp to CONCLUSION
+    {
+        // The peer side has not received the handshake message, so it keeps querying
+        // resend the handshake packet
+
+        // This condition embraces cases when:
+        // - this is normal accept() and URQ_INDUCTION was received
+        // - this is rendezvous accept() and there's coming any kind of URQ except AGREEMENT (should be RENDEZVOUS
+        // or CONCLUSION)
+        // - this is any of URQ_ERROR_* - well...
+        CHandShake initdata;
+        initdata.m_iISN = m_iISN;
+        initdata.m_iMSS = m_config.iMSS;
+        initdata.m_iFlightFlagSize = m_config.iFlightFlagSize;
+
+        // For rendezvous we do URQ_WAVEAHAND/URQ_CONCLUSION --> URQ_AGREEMENT.
+        // For client-server we do URQ_INDUCTION --> URQ_CONCLUSION.
+        initdata.m_iReqType = (!m_config.bRendezvous) ? URQ_CONCLUSION : URQ_AGREEMENT;
+        initdata.m_iID = m_SocketID;
+
+        uint32_t kmdata[SRTDATA_MAXSIZE];
+        size_t   kmdatasize = SRTDATA_MAXSIZE;
+        bool     have_hsreq = false;
+        if (req.m_iVersion > HS_VERSION_UDT4)
+        {
+            initdata.m_iVersion = HS_VERSION_SRT1; // if I remember correctly, this is induction/listener...
+            const int hs_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
+            if (hs_flags != 0) // has SRT extensions
+            {
+                HLOGC(inlog.Debug,
+                    log << CONID() << "processCtrl/HS: got HS reqtype=" << RequestTypeStr(req.m_iReqType)
+                    << " WITH SRT ext");
+                have_hsreq = interpretSrtHandshake(req, ctrlpkt, (kmdata), (&kmdatasize));
+                if (!have_hsreq)
+                {
+                    initdata.m_iVersion = 0;
+                    m_RejectReason = SRT_REJ_ROGUE;
+                    initdata.m_iReqType = URQFailure(m_RejectReason);
+                }
+                else
+                {
+                    // Extensions are added only in case of CONCLUSION (not AGREEMENT).
+                    // Actually what is expected here is that this may either process the
+                    // belated-repeated handshake from a caller (and then it's CONCLUSION,
+                    // and should be added with HSRSP/KMRSP), or it's a belated handshake
+                    // of Rendezvous when it has already considered itself connected.
+                    // Sanity check - according to the rules, there should be no such situation
+                    if (m_config.bRendezvous && m_SrtHsSide == HSD_RESPONDER)
+                    {
+                        LOGC(inlog.Error,
+                            log << CONID() << "processCtrl/HS: IPE???: RESPONDER should receive all its handshakes in "
+                            "handshake phase.");
+                    }
 
-    HLOGC(inlog.Debug,
-          log << CONID() << "incoming UMSG:" << ctrlpkt.getType() << " ("
-              << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType()) << ") socket=%" << ctrlpkt.m_iID);
+                    // The 'extension' flag will be set from this variable; set it to false
+                    // in case when the AGREEMENT response is to be sent.
+                    have_hsreq = initdata.m_iReqType == URQ_CONCLUSION;
+                    HLOGC(inlog.Debug,
+                        log << CONID() << "processCtrl/HS: processing ok, reqtype=" << RequestTypeStr(initdata.m_iReqType)
+                        << " kmdatasize=" << kmdatasize);
+                }
+            }
+            else
+            {
+                HLOGC(inlog.Debug, log << CONID() << "processCtrl/HS: got HS reqtype=" << RequestTypeStr(req.m_iReqType));
+            }
+        }
+        else
+        {
+            initdata.m_iVersion = HS_VERSION_UDT4;
+            kmdatasize = 0; // HSv4 doesn't add any extensions, no KMX
+        }
 
-    switch (ctrlpkt.getType())
-    {
-    case UMSG_ACK: // 010 - Acknowledgement
-        processCtrlAck(ctrlpkt, currtime);
-        break;
+        initdata.m_extension = have_hsreq;
 
-    case UMSG_ACKACK: // 110 - Acknowledgement of Acknowledgement
-    {
-        int32_t ack = 0;
-        int     rtt = -1;
+        HLOGC(inlog.Debug,
+            log << CONID() << "processCtrl: responding HS reqtype=" << RequestTypeStr(initdata.m_iReqType)
+            << (have_hsreq ? " WITH SRT HS response extensions" : ""));
+
+        CPacket rsppkt;
+        rsppkt.setControl(UMSG_HANDSHAKE);
+        rsppkt.allocate(m_iMaxSRTPayloadSize);
 
-        // update RTT
-        rtt = m_ACKWindow.acknowledge(ctrlpkt.getAckSeqNo(), ack);
-        if (rtt <= 0)
+        // If createSrtHandshake failed, don't send anything. Actually it can only fail on IPE.
+        // There is also no possible IPE condition in case of HSv4 - for this version it will always return true.
+        enterCS(m_ConnectionLock);
+        bool create_ok = createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (rsppkt), (initdata));
+        leaveCS(m_ConnectionLock);
+        if (create_ok)
         {
-            LOGC(inlog.Error,
-                 log << CONID() << "IPE: ACK node overwritten when acknowledging " << ctrlpkt.getAckSeqNo()
-                     << " (ack extracted: " << ack << ")");
-            break;
+            rsppkt.set_id(m_PeerID);
+            setPacketTS(rsppkt, steady_clock::now());
+            const int nbsent = m_pSndQueue->sendto(m_PeerAddr, rsppkt, m_SourceAddr);
+            if (nbsent)
+            {
+                m_tsLastSndTime.store(steady_clock::now());
+            }
         }
+    }
+    else
+    {
+        HLOGC(inlog.Debug, log << CONID() << "processCtrl: ... not INDUCTION, not ERROR, not rendezvous - IGNORED.");
+    }
+}
 
-        // if increasing delay detected...
-        //   sendCtrl(UMSG_CGWARNING);
-
-        // RTT EWMA
-        m_iRTTVar = avg_iir<4>(m_iRTTVar, abs(rtt - m_iRTT));
-        m_iRTT = avg_iir<8>(m_iRTT, rtt);
-
-        updateCC(TEV_ACKACK, EventVariant(ack));
+void srt::CUDT::processCtrlDropReq(const CPacket& ctrlpkt)
+{
+    const int32_t* dropdata = (const int32_t*) ctrlpkt.m_pcData;
 
-        // This function will put a lock on m_RecvLock by itself, as needed.
-        // It must be done inside because this function reads the current time
-        // and if waiting for the lock has caused a delay, the time will be
-        // inaccurate. Additionally it won't lock if TSBPD mode is off, and
-        // won't update anything. Note that if you set TSBPD mode and use
-        // srt_recvfile (which doesn't make any sense), you'll have a deadlock.
-        if (m_bDriftTracer)
+    {
+        CUniqueSync rcvtscc (m_RecvLock, m_RcvTsbPdCond);
+        // With both TLPktDrop and TsbPd enabled, a message always consists only of one packet.
+        // It will be dropped as too late anyway. Not dropping it from the receiver buffer
+        // in advance reduces false drops if the packet somehow manages to arrive.
+        // Still remove the record from the loss list to cease further retransmission requests.
+        if (!m_bTLPktDrop || !m_bTsbPd)
         {
-            steady_clock::duration udrift(0);
-            steady_clock::time_point newtimebase;
-            const bool drift_updated ATR_UNUSED = m_pRcvBuffer->addRcvTsbPdDriftSample(ctrlpkt.getMsgTimeStamp(), m_RecvLock,
-                    (udrift), (newtimebase));
-#if ENABLE_EXPERIMENTAL_BONDING
-            if (drift_updated && m_parent->m_IncludedGroup)
+            const bool using_rexmit_flag = m_bPeerRexmitFlag;
+            ScopedLock rblock(m_RcvBufferLock);
+            const int iDropCnt = m_pRcvBuffer->dropMessage(dropdata[0], dropdata[1], ctrlpkt.getMsgSeq(using_rexmit_flag), CRcvBuffer::KEEP_EXISTING);
+
+            if (iDropCnt > 0)
             {
-                ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-                if (m_parent->m_IncludedGroup)
+                ScopedLock lg (m_StatsLock);
+                const steady_clock::time_point tnow = steady_clock::now();
+                string why;
+                if (frequentLogAllowed(FREQLOGFA_RCV_DROPPED, tnow, (why)))
                 {
-                    m_parent->m_IncludedGroup->synchronizeDrift(this, udrift, newtimebase);
+                    LOGC(brlog.Warn, log << CONID() << "RCV-DROPPED " << iDropCnt << " packet(s), seqno range %"
+                            << dropdata[0] << "-%" << dropdata[1] << ", msgno " << ctrlpkt.getMsgSeq(using_rexmit_flag)
+                            << " (SND DROP REQUEST). " << why);
+                }
+#if SRT_ENABLE_FREQUENT_LOG_TRACE
+                else
+                {
+                    LOGC(brlog.Warn, log << "SUPPRESSED: RCV-DROPPED LOG: " << why);
                 }
-            }
 #endif
+
+                // Estimate dropped bytes from average payload size.
+                const uint64_t avgpayloadsz = m_pRcvBuffer->getRcvAvgPayloadSize();
+                m_stats.rcvr.dropped.count(stats::BytesPackets(iDropCnt * avgpayloadsz, (uint32_t) iDropCnt));
+            }
         }
+        // When the drop request was received, it means that there are
+        // packets for which there will never be ACK sent; if the TSBPD thread
+        // is currently in the ACK-waiting state, it may never exit.
+        if (m_bTsbPd)
+        {
+            HLOGP(inlog.Debug, "DROPREQ: signal TSBPD");
+            rcvtscc.notify_one();
+        }
+    }
 
-        // update last ACK that has been received by the sender
-        if (CSeqNo::seqcmp(ack, m_iRcvLastAckAck) > 0)
-            m_iRcvLastAckAck = ack;
+    dropFromLossLists(dropdata[0], dropdata[1]);
 
-        break;
+    // If dropping ahead of the current largest sequence number,
+    // move the recv seq number forward.
+    if ((CSeqNo::seqcmp(dropdata[0], CSeqNo::incseq(m_iRcvCurrSeqNo)) <= 0)
+        && (CSeqNo::seqcmp(dropdata[1], m_iRcvCurrSeqNo) > 0))
+    {
+        HLOGC(inlog.Debug, log << CONID() << "DROPREQ: dropping %"
+            << dropdata[0] << "-" << dropdata[1] << " <-- set as current seq");
+        m_iRcvCurrSeqNo = dropdata[1];
+    }
+    else
+    {
+        HLOGC(inlog.Debug, log << CONID() << "DROPREQ: dropping %"
+            << dropdata[0] << "-" << dropdata[1] << " current %" << m_iRcvCurrSeqNo);
+    }
+}
+
+void srt::CUDT::processCtrlShutdown()
+{
+    m_bShutdown = true;
+    m_bClosing = true;
+    m_bBroken = true;
+    m_iBrokenCounter = 60;
+
+    // This does the same as it would happen on connection timeout,
+    // just we know about this state prematurely thanks to this message.
+    updateBrokenConnection();
+    completeBrokenConnectionDependencies(SRT_ECONNLOST); // LOCKS!
+}
+
+void srt::CUDT::processCtrlUserDefined(const CPacket& ctrlpkt)
+{
+    HLOGC(inlog.Debug, log << CONID() << "CONTROL EXT MSG RECEIVED:"
+        << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType())
+        << ", value=" << ctrlpkt.getExtendedType());
+
+    // This has currently two roles in SRT:
+    // - HSv4 (legacy) handshake
+    // - refreshed KMX (initial KMX is done still in the HS process in HSv5)
+    const bool understood = processSrtMsg(&ctrlpkt);
+    // CAREFUL HERE! This only means that this update comes from the UMSG_EXT
+    // message received, REGARDLESS OF WHAT IT IS. This version doesn't mean
+    // the handshake version, but the reason of calling this function.
+    //
+    // Fortunately, the only messages taken into account in this function
+    // are HSREQ and HSRSP, which should *never* be interchanged when both
+    // parties are HSv5.
+    if (understood)
+    {
+        if (ctrlpkt.getExtendedType() == SRT_CMD_HSREQ || ctrlpkt.getExtendedType() == SRT_CMD_HSRSP)
+        {
+            updateAfterSrtHandshake(HS_VERSION_UDT4);
+        }
+    }
+    else
+    {
+        updateCC(TEV_CUSTOM, EventVariant(&ctrlpkt));
     }
+}
+
+void srt::CUDT::processCtrl(const CPacket &ctrlpkt)
+{
+    // Just heard from the peer, reset the expiration count.
+    m_iEXPCount = 1;
+    const steady_clock::time_point currtime = steady_clock::now();
+    m_tsLastRspTime = currtime;
+
+    HLOGC(inlog.Debug,
+          log << CONID() << "incoming UMSG:" << ctrlpkt.getType() << " ("
+              << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType()) << ") socket=%" << ctrlpkt.id());
+
+    switch (ctrlpkt.getType())
+    {
+    case UMSG_ACK: // 010 - Acknowledgement
+        processCtrlAck(ctrlpkt, currtime);
+        break;
+
+    case UMSG_ACKACK: // 110 - Acknowledgement of Acknowledgement
+        processCtrlAckAck(ctrlpkt, currtime);
+        break;
 
     case UMSG_LOSSREPORT: // 011 - Loss Report
         processCtrlLossReport(ctrlpkt);
@@ -8827,7 +9211,7 @@ void CUDT::processCtrl(const CPacket &ctrlpkt)
 
     case UMSG_CGWARNING: // 100 - Delay Warning
         // One way packet delay is increasing, so decrease the sending rate
-        m_tdSendInterval = (m_tdSendInterval * 1125) / 1000;
+        m_tdSendInterval = (m_tdSendInterval.load() * 1125) / 1000;
         // XXX Note as interesting fact: this is only prepared for handling,
         // but nothing in the code is sending this message. Probably predicted
         // for a custom congctl. There's a predicted place to call it under
@@ -8836,174 +9220,19 @@ void CUDT::processCtrl(const CPacket &ctrlpkt)
         break;
 
     case UMSG_KEEPALIVE: // 001 - Keep-alive
-
-        handleKeepalive(ctrlpkt.m_pcData, ctrlpkt.getLength());
-
+        processKeepalive(ctrlpkt, currtime);
         break;
 
     case UMSG_HANDSHAKE: // 000 - Handshake
-    {
-        CHandShake req;
-        req.load_from(ctrlpkt.m_pcData, ctrlpkt.getLength());
-
-        HLOGC(inlog.Debug, log << CONID() << "processCtrl: got HS: " << req.show());
-
-        if ((req.m_iReqType > URQ_INDUCTION_TYPES) // acually it catches URQ_INDUCTION and URQ_ERROR_* symbols...???
-            || (m_bRendezvous && (req.m_iReqType != URQ_AGREEMENT))) // rnd sends AGREEMENT in rsp to CONCLUSION
-        {
-            // The peer side has not received the handshake message, so it keeps querying
-            // resend the handshake packet
-
-            // This condition embraces cases when:
-            // - this is normal accept() and URQ_INDUCTION was received
-            // - this is rendezvous accept() and there's coming any kind of URQ except AGREEMENT (should be RENDEZVOUS
-            // or CONCLUSION)
-            // - this is any of URQ_ERROR_* - well...
-            CHandShake initdata;
-            initdata.m_iISN            = m_iISN;
-            initdata.m_iMSS            = m_iMSS;
-            initdata.m_iFlightFlagSize = m_iFlightFlagSize;
-
-            // For rendezvous we do URQ_WAVEAHAND/URQ_CONCLUSION --> URQ_AGREEMENT.
-            // For client-server we do URQ_INDUCTION --> URQ_CONCLUSION.
-            initdata.m_iReqType = (!m_bRendezvous) ? URQ_CONCLUSION : URQ_AGREEMENT;
-            initdata.m_iID      = m_SocketID;
-
-            uint32_t kmdata[SRTDATA_MAXSIZE];
-            size_t   kmdatasize = SRTDATA_MAXSIZE;
-            bool     have_hsreq = false;
-            if (req.m_iVersion > HS_VERSION_UDT4)
-            {
-                initdata.m_iVersion = HS_VERSION_SRT1; // if I remember correctly, this is induction/listener...
-                int hs_flags        = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(m_ConnRes.m_iType);
-                if (hs_flags != 0) // has SRT extensions
-                {
-                    HLOGC(inlog.Debug,
-                          log << CONID() << "processCtrl/HS: got HS reqtype=" << RequestTypeStr(req.m_iReqType)
-                              << " WITH SRT ext");
-                    have_hsreq = interpretSrtHandshake(req, ctrlpkt, (kmdata), (&kmdatasize));
-                    if (!have_hsreq)
-                    {
-                        initdata.m_iVersion = 0;
-                        m_RejectReason      = SRT_REJ_ROGUE;
-                        initdata.m_iReqType = URQFailure(m_RejectReason);
-                    }
-                    else
-                    {
-                        // Extensions are added only in case of CONCLUSION (not AGREEMENT).
-                        // Actually what is expected here is that this may either process the
-                        // belated-repeated handshake from a caller (and then it's CONCLUSION,
-                        // and should be added with HSRSP/KMRSP), or it's a belated handshake
-                        // of Rendezvous when it has already considered itself connected.
-                        // Sanity check - according to the rules, there should be no such situation
-                        if (m_bRendezvous && m_SrtHsSide == HSD_RESPONDER)
-                        {
-                            LOGC(inlog.Error,
-                                 log << CONID() << "processCtrl/HS: IPE???: RESPONDER should receive all its handshakes in "
-                                        "handshake phase.");
-                        }
-
-                        // The 'extension' flag will be set from this variable; set it to false
-                        // in case when the AGREEMENT response is to be sent.
-                        have_hsreq = initdata.m_iReqType == URQ_CONCLUSION;
-                        HLOGC(inlog.Debug,
-                              log << CONID() << "processCtrl/HS: processing ok, reqtype=" << RequestTypeStr(initdata.m_iReqType)
-                                  << " kmdatasize=" << kmdatasize);
-                    }
-                }
-                else
-                {
-                    HLOGC(inlog.Debug, log << CONID() << "processCtrl/HS: got HS reqtype=" << RequestTypeStr(req.m_iReqType));
-                }
-            }
-            else
-            {
-                initdata.m_iVersion = HS_VERSION_UDT4;
-                kmdatasize = 0; // HSv4 doesn't add any extensions, no KMX
-            }
-
-            initdata.m_extension = have_hsreq;
-
-            HLOGC(inlog.Debug,
-                  log << CONID() << "processCtrl: responding HS reqtype=" << RequestTypeStr(initdata.m_iReqType)
-                      << (have_hsreq ? " WITH SRT HS response extensions" : ""));
-
-            CPacket response;
-            response.setControl(UMSG_HANDSHAKE);
-            response.allocate(m_iMaxSRTPayloadSize);
-
-            // If createSrtHandshake failed, don't send anything. Actually it can only fail on IPE.
-            // There is also no possible IPE condition in case of HSv4 - for this version it will always return true.
-            if (createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize,
-                        (response), (initdata)))
-            {
-                response.m_iID        = m_PeerID;
-                setPacketTS(response, steady_clock::now());
-                const int nbsent      = m_pSndQueue->sendto(m_PeerAddr, response);
-                if (nbsent)
-                {
-                    m_tsLastSndTime = steady_clock::now();
-                }
-            }
-        }
-        else
-        {
-            HLOGC(inlog.Debug, log << CONID() << "processCtrl: ... not INDUCTION, not ERROR, not rendezvous - IGNORED.");
-        }
-
+        processCtrlHS(ctrlpkt);
         break;
-    }
 
     case UMSG_SHUTDOWN: // 101 - Shutdown
-        m_bShutdown      = true;
-        m_bClosing       = true;
-        m_bBroken        = true;
-        m_iBrokenCounter = 60;
-
-        // This does the same as it would happen on connection timeout,
-        // just we know about this state prematurely thanks to this message.
-        updateBrokenConnection();
-        completeBrokenConnectionDependencies(SRT_ECONNLOST); // LOCKS!
+        processCtrlShutdown();
         break;
 
     case UMSG_DROPREQ: // 111 - Msg drop request
-        {
-            UniqueLock rlock(m_RecvLock);
-            m_pRcvBuffer->dropMsg(ctrlpkt.getMsgSeq(using_rexmit_flag), using_rexmit_flag);
-            // When the drop request was received, it means that there are
-            // packets for which there will never be ACK sent; if the TSBPD thread
-            // is currently in the ACK-waiting state, it may never exit.
-            if (m_bTsbPd)
-            {
-                HLOGP(inlog.Debug, "DROPREQ: signal TSBPD");
-                CSync cc(m_RcvTsbPdCond, rlock);
-                cc.signal_locked(rlock);
-            }
-        }
-
-        {
-            int32_t* dropdata = (int32_t*)ctrlpkt.m_pcData;
-
-            dropFromLossLists(dropdata[0], dropdata[1]);
-
-            // move forward with current recv seq no.
-            // SYMBOLIC:
-            // if (dropdata[0]  <=%  1 +% m_iRcvCurrSeqNo
-            //   && dropdata[1] >% m_iRcvCurrSeqNo )
-            if ((CSeqNo::seqcmp(dropdata[0], CSeqNo::incseq(m_iRcvCurrSeqNo)) <= 0)
-                    && (CSeqNo::seqcmp(dropdata[1], m_iRcvCurrSeqNo) > 0))
-            {
-                HLOGC(inlog.Debug, log << CONID() << "DROPREQ: dropping %"
-                        << dropdata[0] << "-" << dropdata[1] << " <-- set as current seq");
-                m_iRcvCurrSeqNo = dropdata[1];
-            }
-            else
-            {
-                HLOGC(inlog.Debug, log << CONID() << "DROPREQ: dropping %"
-                        << dropdata[0] << "-" << dropdata[1] << " current %" << m_iRcvCurrSeqNo);
-            }
-        }
-
+        processCtrlDropReq(ctrlpkt);
         break;
 
     case UMSG_PEERERROR: // 1000 - An error has happened to the peer side
@@ -9012,39 +9241,12 @@ void CUDT::processCtrl(const CPacket &ctrlpkt)
         // currently only this error is signalled from the peer side
         // if recvfile() failes (e.g., due to disk fail), blcoked sendfile/send should return immediately
         // giving the app a chance to fix the issue
-
         m_bPeerHealth = false;
 
         break;
 
     case UMSG_EXT: // 0x7FFF - reserved and user defined messages
-        HLOGC(inlog.Debug, log << CONID() << "CONTROL EXT MSG RECEIVED:"
-                << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType())
-                << ", value=" << ctrlpkt.getExtendedType());
-        {
-            // This has currently two roles in SRT:
-            // - HSv4 (legacy) handshake
-            // - refreshed KMX (initial KMX is done still in the HS process in HSv5)
-            bool understood = processSrtMsg(&ctrlpkt);
-            // CAREFUL HERE! This only means that this update comes from the UMSG_EXT
-            // message received, REGARDLESS OF WHAT IT IS. This version doesn't mean
-            // the handshake version, but the reason of calling this function.
-            //
-            // Fortunately, the only messages taken into account in this function
-            // are HSREQ and HSRSP, which should *never* be interchanged when both
-            // parties are HSv5.
-            if (understood)
-            {
-                if (ctrlpkt.getExtendedType() == SRT_CMD_HSREQ || ctrlpkt.getExtendedType() == SRT_CMD_HSRSP)
-                {
-                    updateAfterSrtHandshake(HS_VERSION_UDT4);
-                }
-            }
-            else
-            {
-                updateCC(TEV_CUSTOM, EventVariant(&ctrlpkt));
-            }
-        }
+        processCtrlUserDefined(ctrlpkt);
         break;
 
     default:
@@ -9052,7 +9254,7 @@ void CUDT::processCtrl(const CPacket &ctrlpkt)
     }
 }
 
-void CUDT::updateSrtRcvSettings()
+void srt::CUDT::updateSrtRcvSettings()
 {
     // CHANGED: we need to apply the tsbpd delay only for socket TSBPD.
     // For Group TSBPD the buffer will have to deliver packets always on request
@@ -9061,54 +9263,52 @@ void CUDT::updateSrtRcvSettings()
     // the packet can be retrieved from the buffer before its time to play comes
     // (unlike in normal situation when reading directly from socket), however
     // its time to play shall be properly defined.
+    ScopedLock lock(m_RecvLock);
+
+    // NOTE: remember to also update synchronizeWithGroup() if more settings are updated here.
+    m_pRcvBuffer->setPeerRexmitFlag(m_bPeerRexmitFlag);
 
     // XXX m_bGroupTsbPd is ignored with SRT_ENABLE_APP_READER
     if (m_bTsbPd || m_bGroupTsbPd)
     {
-        /* We are TsbPd receiver */
-        enterCS(m_RecvLock);
-        m_pRcvBuffer->setRcvTsbPdMode(m_tsRcvPeerStartTime, milliseconds_from(m_iTsbPdDelay_ms));
-        leaveCS(m_RecvLock);
+        m_pRcvBuffer->setTsbPdMode(m_tsRcvPeerStartTime, false, milliseconds_from(m_iTsbPdDelay_ms));
 
-        HLOGF(cnlog.Debug,
-              "AFTER HS: Set Rcv TsbPd mode%s: delay=%u.%03us RCV START: %s",
-              (m_bGroupTsbPd ? " (AS GROUP MEMBER)" : ""),
-              m_iTsbPdDelay_ms/1000, // XXX use FormatDuration ?
-              m_iTsbPdDelay_ms%1000,
-              FormatTime(m_tsRcvPeerStartTime).c_str());
+        HLOGC(cnlog.Debug, log << "AFTER HS: Set Rcv TsbPd mode"
+                << (m_bGroupTsbPd ? " (AS GROUP MEMBER)" : "")
+                << ": delay=" << (m_iTsbPdDelay_ms / 1000) << "." << (m_iTsbPdDelay_ms % 1000)
+                << "s RCV START: " << FormatTime(m_tsRcvPeerStartTime).c_str());
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "AFTER HS: Rcv TsbPd mode not set");
+        HLOGC(cnlog.Debug, log << CONID() << "AFTER HS: Rcv TsbPd mode not set");
     }
 }
 
-void CUDT::updateSrtSndSettings()
+void srt::CUDT::updateSrtSndSettings()
 {
     if (m_bPeerTsbPd)
     {
         /* We are TsbPd sender */
         // XXX Check what happened here.
-        // m_iPeerTsbPdDelay_ms = m_CongCtl->getSndPeerTsbPdDelay();// + ((m_iRTT + (4 * m_iRTTVar)) / 1000);
+        // m_iPeerTsbPdDelay_ms = m_CongCtl->getSndPeerTsbPdDelay();// + ((m_iSRTT + (4 * m_iRTTVar)) / 1000);
         /*
          * For sender to apply Too-Late Packet Drop
          * option (m_bTLPktDrop) must be enabled and receiving peer shall support it
          */
-        HLOGF(cnlog.Debug,
-              "AFTER HS: Set Snd TsbPd mode %s TLPktDrop: delay=%d.%03ds START TIME: %s",
-              m_bPeerTLPktDrop ? "with" : "without",
-              m_iPeerTsbPdDelay_ms/1000, m_iPeerTsbPdDelay_ms%1000,
-              FormatTime(m_stats.tsStartTime).c_str());
+        HLOGC(cnlog.Debug, log << "AFTER HS: Set Snd TsbPd mode "
+                << (m_bPeerTLPktDrop ? "with" : "without")
+                << " TLPktDrop: delay=" << (m_iPeerTsbPdDelay_ms/1000) << "." << (m_iPeerTsbPdDelay_ms%1000)
+                << "s START TIME: " << FormatTime(m_stats.tsStartTime).c_str());
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "AFTER HS: Snd TsbPd mode not set");
+        HLOGC(cnlog.Debug, log << CONID() << "AFTER HS: Snd TsbPd mode not set");
     }
 }
 
-void CUDT::updateAfterSrtHandshake(int hsv)
+void srt::CUDT::updateAfterSrtHandshake(int hsv)
 {
-    HLOGC(cnlog.Debug, log << "updateAfterSrtHandshake: HS version " << hsv);
+    HLOGC(cnlog.Debug, log << CONID() << "updateAfterSrtHandshake: HS version " << hsv);
     // This is blocked from being run in the "app reader" version because here
     // every socket does its TsbPd independently, just the sequence screwup is
     // done and the application reader sorts out packets by sequence numbers,
@@ -9125,23 +9325,23 @@ void CUDT::updateAfterSrtHandshake(int hsv)
     // instance, through either HSREQ or HSRSP.
 #if ENABLE_HEAVY_LOGGING
     const char* hs_side[] = { "DRAW", "INITIATOR", "RESPONDER" };
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     string grpspec;
 
-    if (m_parent->m_IncludedGroup)
+    if (m_parent->m_GroupOf)
     {
-        ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-        grpspec = m_parent->m_IncludedGroup
-            ? " group=$" + Sprint(m_parent->m_IncludedGroup->id())
+        ScopedLock glock (uglobal().m_GlobControlLock);
+        grpspec = m_parent->m_GroupOf
+            ? " group=$" + Sprint(m_parent->m_GroupOf->id())
             : string();
     }
 #else
     const char* grpspec = "";
 #endif
 
-    HLOGC(cnlog.Debug, log << "updateAfterSrtHandshake: version="
-            << m_ConnRes.m_iVersion << " side=" << hs_side[m_SrtHsSide]
-            << grpspec);
+    HLOGC(cnlog.Debug,
+          log << CONID() << "updateAfterSrtHandshake: version=" << m_ConnRes.m_iVersion
+              << " side=" << hs_side[m_SrtHsSide] << grpspec);
 #endif
 
     if (hsv > HS_VERSION_UDT4)
@@ -9161,131 +9361,313 @@ void CUDT::updateAfterSrtHandshake(int hsv)
     }
 }
 
-int CUDT::packLostData(CPacket& w_packet, steady_clock::time_point& w_origintime)
+int srt::CUDT::packLostData(CPacket& w_packet)
 {
     // protect m_iSndLastDataAck from updating by ACK processing
     UniqueLock ackguard(m_RecvAckLock);
     const steady_clock::time_point time_now = steady_clock::now();
-    const steady_clock::time_point time_nak = time_now - microseconds_from(m_iRTT - 4 * m_iRTTVar);
+    const steady_clock::time_point time_nak = time_now - microseconds_from(m_iSRTT - 4 * m_iRTTVar);
 
-    while ((w_packet.m_iSeqNo = m_pSndLossList->popLostSeq()) >= 0)
+    for (;;)
     {
+        w_packet.set_seqno(m_pSndLossList->popLostSeq());
+        if (w_packet.seqno() == SRT_SEQNO_NONE)
+            break;
+
         // XXX See the note above the m_iSndLastDataAck declaration in core.h
         // This is the place where the important sequence numbers for
         // sender buffer are actually managed by this field here.
-        const int offset = CSeqNo::seqoff(m_iSndLastDataAck, w_packet.m_iSeqNo);
+        const int offset = CSeqNo::seqoff(m_iSndLastDataAck, w_packet.seqno());
         if (offset < 0)
         {
             // XXX Likely that this will never be executed because if the upper
             // sequence is not in the sender buffer, then most likely the loss 
             // was completely ignored.
-            LOGC(qrlog.Error, log << "IPE/EPE: packLostData: LOST packet negative offset: seqoff(m_iSeqNo "
-                << w_packet.m_iSeqNo << ", m_iSndLastDataAck " << m_iSndLastDataAck
-                << ")=" << offset << ". Continue");
+            LOGC(qrlog.Error,
+                 log << CONID() << "IPE/EPE: packLostData: LOST packet negative offset: seqoff(seqno() "
+                     << w_packet.seqno() << ", m_iSndLastDataAck " << m_iSndLastDataAck << ")=" << offset
+                     << ". Continue, request DROP");
 
             // No matter whether this is right or not (maybe the attack case should be
             // considered, and some LOSSREPORT flood prevention), send the drop request
             // to the peer.
-            int32_t seqpair[2];
-            seqpair[0] = w_packet.m_iSeqNo;
-            seqpair[1] = m_iSndLastDataAck;
+            int32_t seqpair[2] = {
+                w_packet.seqno(),
+                CSeqNo::decseq(m_iSndLastDataAck)
+            };
+
+            HLOGC(qrlog.Debug,
+                  log << CONID() << "PEER reported LOSS not from the sending buffer - requesting DROP: #"
+                      << MSGNO_SEQ::unwrap(w_packet.msgflags()) << " SEQ:" << seqpair[0] << " - " << seqpair[1] << "("
+                      << (-offset) << " packets)");
 
-            HLOGC(qrlog.Debug, log << "PEER reported LOSS not from the sending buffer - requesting DROP: "
-                    << "msg=" << MSGNO_SEQ::unwrap(w_packet.m_iMsgNo) << " SEQ:"
-                    << seqpair[0] << " - " << seqpair[1] << "(" << (-offset) << " packets)");
+            // See interpretation in processCtrlDropReq(). We don't know the message number,
+            // so we request that the drop be exclusively sequence number based.
+            int32_t msgno = SRT_MSGNO_CONTROL;
 
-            sendCtrl(UMSG_DROPREQ, &w_packet.m_iMsgNo, seqpair, sizeof(seqpair));
+            sendCtrl(UMSG_DROPREQ, &msgno, seqpair, sizeof(seqpair));
             continue;
         }
 
-        if (m_bPeerNakReport && m_iOPT_RetransmitAlgo != 0)
+        if (m_bPeerNakReport && m_config.iRetransmitAlgo != 0)
         {
             const steady_clock::time_point tsLastRexmit = m_pSndBuffer->getPacketRexmitTime(offset);
             if (tsLastRexmit >= time_nak)
             {
                 HLOGC(qrlog.Debug, log << CONID() << "REXMIT: ignoring seqno "
-                    << w_packet.m_iSeqNo << ", last rexmit " << (is_zero(tsLastRexmit) ? "never" : FormatTime(tsLastRexmit))
-                    << " RTT=" << m_iRTT << " RTTVar=" << m_iRTTVar
+                    << w_packet.seqno() << ", last rexmit " << (is_zero(tsLastRexmit) ? "never" : FormatTime(tsLastRexmit))
+                    << " RTT=" << m_iSRTT << " RTTVar=" << m_iRTTVar
                     << " now=" << FormatTime(time_now));
                 continue;
             }
         }
 
-        int msglen;
+        typedef CSndBuffer::DropRange DropRange;
 
-        const int payload = m_pSndBuffer->readData(offset, (w_packet), (w_origintime), (msglen));
-        SRT_ASSERT(payload != 0);
-        if (payload == -1)
+        DropRange buffer_drop;
+        steady_clock::time_point tsOrigin;
+        const int payload = m_pSndBuffer->readData(offset, (w_packet), (tsOrigin), (buffer_drop));
+        if (payload == CSndBuffer::READ_DROP)
         {
-            int32_t seqpair[2];
-            seqpair[0] = w_packet.m_iSeqNo;
-            seqpair[1] = CSeqNo::incseq(seqpair[0], msglen);
+            SRT_ASSERT(CSeqNo::seqoff(buffer_drop.seqno[DropRange::BEGIN], buffer_drop.seqno[DropRange::END]) >= 0);
+
+            HLOGC(qrlog.Debug,
+                  log << CONID() << "loss-reported packets expired in SndBuf - requesting DROP: #"
+                      << buffer_drop.msgno << " %(" << buffer_drop.seqno[DropRange::BEGIN] << " - "
+                      << buffer_drop.seqno[DropRange::END] << ")");
+            sendCtrl(UMSG_DROPREQ, &buffer_drop.msgno, buffer_drop.seqno, sizeof(buffer_drop.seqno));
+
+            // skip all dropped packets
+            m_pSndLossList->removeUpTo(buffer_drop.seqno[DropRange::END]);
+            m_iSndCurrSeqNo = CSeqNo::maxseq(m_iSndCurrSeqNo, buffer_drop.seqno[DropRange::END]);
+            continue;
+        }
+        else if (payload == CSndBuffer::READ_NONE)
+            continue;
+
+        // The packet has been ecrypted, thus the authentication tag is expected to be stored
+        // in the SND buffer as well right after the payload.
+        if (m_pCryptoControl && m_pCryptoControl->getCryptoMode() == CSrtConfig::CIPHER_MODE_AES_GCM)
+        {
+            w_packet.setLength(w_packet.getLength() + HAICRYPT_AUTHTAG_MAX);
+        }
+
+        // At this point we no longer need the ACK lock,
+        // because we are going to return from the function.
+        // Therefore unlocking in order not to block other threads.
+        ackguard.unlock();
+
+        enterCS(m_StatsLock);
+        m_stats.sndr.sentRetrans.count(payload);
+        leaveCS(m_StatsLock);
+
+        // Despite the contextual interpretation of packet.m_iMsgNo around
+        // CSndBuffer::readData version 2 (version 1 doesn't return -1), in this particular
+        // case we can be sure that this is exactly the value of PH_MSGNO as a bitset.
+        // So, set here the rexmit flag if the peer understands it.
+        if (m_bPeerRexmitFlag)
+        {
+            w_packet.set_msgflags(w_packet.msgflags() | PACKET_SND_REXMIT);
+        }
+        setDataPacketTS(w_packet, tsOrigin);
+
+#ifdef ENABLE_MAXREXMITBW
+        m_SndRexmitRate.addSample(time_now, 1, w_packet.getLength());
+#endif
+
+        return payload;
+    }
+
+    return 0;
+}
+
+#if SRT_DEBUG_TRACE_SND
+class snd_logger
+{
+    typedef srt::sync::steady_clock steady_clock;
+
+public:
+    snd_logger() {}
+
+    ~snd_logger()
+    {
+        ScopedLock lck(m_mtx);
+        m_fout.close();
+    }
 
-            HLOGC(qrlog.Debug, log << "IPE: loss-reported packets not found in SndBuf - requesting DROP: "
-                    << "msg=" << MSGNO_SEQ::unwrap(w_packet.m_iMsgNo) << " SEQ:"
-                    << seqpair[0] << " - " << seqpair[1] << "(" << (-offset) << " packets)");
-            sendCtrl(UMSG_DROPREQ, &w_packet.m_iMsgNo, seqpair, sizeof(seqpair));
+    struct
+    {
+        typedef srt::sync::steady_clock steady_clock;
+        long long usElapsed;
+        steady_clock::time_point tsNow;
+        int usSRTT;
+        int usRTTVar;
+        int msSndBuffSpan;
+        int msTimespanTh;
+        int msNextUniqueToSend;
+        long long usElapsedLastDrop;
+        bool canRexmit;
+        int iPktSeqno;
+        bool isRetransmitted;
+    } state;
+
+    void trace()
+    {
+        using namespace srt::sync;
+        ScopedLock lck(m_mtx);
+        create_file();
+
+        m_fout << state.usElapsed << ",";
+        m_fout << state.usSRTT << ",";
+        m_fout << state.usRTTVar << ",";
+        m_fout << state.msSndBuffSpan << ",";
+        m_fout << state.msTimespanTh << ",";
+        m_fout << state.msNextUniqueToSend << ",";
+        m_fout << state.usElapsedLastDrop << ",";
+        m_fout << state.canRexmit << ",";
+        m_fout << state.iPktSeqno << ',';
+        m_fout << state.isRetransmitted << '\n';
+
+        m_fout.flush();
+    }
+
+private:
+    void print_header()
+    {
+        m_fout << "usElapsed,usSRTT,usRTTVar,msSndBuffTimespan,msTimespanTh,msNextUniqueToSend,usDLastDrop,canRexmit,sndPktSeqno,isRexmit";
+        m_fout << "\n";
+    }
+
+    void create_file()
+    {
+        if (m_fout.is_open())
+            return;
+
+        m_start_time = srt::sync::steady_clock::now();
+        std::string str_tnow = srt::sync::FormatTimeSys(m_start_time);
+        str_tnow.resize(str_tnow.size() - 7); // remove trailing ' [SYST]' part
+        while (str_tnow.find(':') != std::string::npos)
+        {
+            str_tnow.replace(str_tnow.find(':'), 1, 1, '_');
+        }
+        const std::string fname = "snd_trace_" + str_tnow + ".csv";
+        m_fout.open(fname, std::ofstream::out);
+        if (!m_fout)
+            std::cerr << "IPE: Failed to open " << fname << "!!!\n";
+
+        print_header();
+    }
+
+private:
+    srt::sync::Mutex                    m_mtx;
+    std::ofstream                       m_fout;
+    srt::sync::steady_clock::time_point m_start_time;
+};
+
+snd_logger g_snd_logger;
+#endif // SRT_DEBUG_TRACE_SND
+
+void srt::CUDT::setPacketTS(CPacket& p, const time_point& ts)
+{
+    enterCS(m_StatsLock);
+    const time_point tsStart = m_stats.tsStartTime;
+    leaveCS(m_StatsLock);
+    p.set_timestamp(makeTS(ts, tsStart));
+}
+
+void srt::CUDT::setDataPacketTS(CPacket& p, const time_point& ts)
+{
+    enterCS(m_StatsLock);
+    const time_point tsStart = m_stats.tsStartTime;
+    leaveCS(m_StatsLock);
 
-            // only one msg drop request is necessary
-            m_pSndLossList->removeUpTo(seqpair[1]);
+    if (!m_bPeerTsbPd)
+    {
+        // If TSBPD is disabled, use the current time as the source (timestamp using the sending time).
+        p.set_timestamp(makeTS(steady_clock::now(), tsStart));
+        return;
+    }
 
-            // skip all dropped packets
-            m_iSndCurrSeqNo = CSeqNo::maxseq(m_iSndCurrSeqNo, CSeqNo::incseq(seqpair[1]));
+    // TODO: Might be better for performance to ensure this condition is always false, and just use SRT_ASSERT here.
+    if (ts < tsStart)
+    {
+        p.set_timestamp(makeTS(steady_clock::now(), tsStart));
+        LOGC(qslog.Warn,
+            log << CONID() << "setPacketTS: reference time=" << FormatTime(ts)
+            << " is in the past towards start time=" << FormatTime(tsStart)
+            << " - setting NOW as reference time for the data packet");
+        return;
+    }
 
-            continue;
-        }
-        // NOTE: This is just a sanity check. Returning 0 is impossible to happen
-        // in case of retransmission. If the offset was a positive value, then the
-        // block must exist in the old blocks because it wasn't yet cut off by ACK
-        // and has been already recorded as sent (otherwise the peer wouldn't send
-        // back the loss report). May something happen here in case when the send
-        // loss record has been updated by the FASTREXMIT.
-        else if (payload == 0)
-            continue;
+    // Use the provided source time for the timestamp.
+    p.set_timestamp(makeTS(ts, tsStart));
+}
 
-        // At this point we no longer need the ACK lock,
-        // because we are going to return from the function.
-        // Therefore unlocking in order not to block other threads.
-        ackguard.unlock();
+bool srt::CUDT::isRetransmissionAllowed(const time_point& tnow SRT_ATR_UNUSED)
+{
+    // Prioritization of original packets only applies to Live CC.
+    if (!m_bPeerTLPktDrop || !m_config.bMessageAPI)
+        return true;
 
-        enterCS(m_StatsLock);
-        ++m_stats.traceRetrans;
-        ++m_stats.retransTotal;
-        m_stats.traceBytesRetrans += payload;
-        m_stats.bytesRetransTotal += payload;
-        leaveCS(m_StatsLock);
+    // TODO: lock sender buffer?
+    const time_point tsNextPacket = m_pSndBuffer->peekNextOriginal();
+
+#if SRT_DEBUG_TRACE_SND
+    const int buffdelay_ms = count_milliseconds(m_pSndBuffer->getBufferingDelay(tnow));
+    // If there is a small loss, still better to retransmit. If timespan is already big,
+    // then consider sending original packets.
+    const int threshold_ms_min = (2 * m_iSRTT + 4 * m_iRTTVar + COMM_SYN_INTERVAL_US) / 1000;
+    const int msNextUniqueToSend = count_milliseconds(tnow - tsNextPacket) + m_iPeerTsbPdDelay_ms;
+
+    g_snd_logger.state.tsNow = tnow;
+    g_snd_logger.state.usElapsed = count_microseconds(tnow - m_stats.tsStartTime);
+    g_snd_logger.state.usSRTT = m_iSRTT;
+    g_snd_logger.state.usRTTVar = m_iRTTVar;
+    g_snd_logger.state.msSndBuffSpan = buffdelay_ms;
+    g_snd_logger.state.msTimespanTh = threshold_ms_min;
+    g_snd_logger.state.msNextUniqueToSend = msNextUniqueToSend;
+    g_snd_logger.state.usElapsedLastDrop = count_microseconds(tnow - m_tsLastTLDrop);
+    g_snd_logger.state.canRexmit = false;
+#endif
 
-        // Despite the contextual interpretation of packet.m_iMsgNo around
-        // CSndBuffer::readData version 2 (version 1 doesn't return -1), in this particular
-        // case we can be sure that this is exactly the value of PH_MSGNO as a bitset.
-        // So, set here the rexmit flag if the peer understands it.
-        if (m_bPeerRexmitFlag)
-        {
-            w_packet.m_iMsgNo |= PACKET_SND_REXMIT;
-        }
+    if (tsNextPacket != time_point())
+    {
+        // Can send original packet, so just send it
+        return false;
+    }
 
-        return payload;
+#ifdef ENABLE_MAXREXMITBW
+    m_SndRexmitRate.addSample(tnow, 0, 0); // Update the estimation.
+    const int64_t iRexmitRateBps = m_SndRexmitRate.getRate();
+    const int64_t iRexmitRateLimitBps = m_config.llMaxRexmitBW;
+    if (iRexmitRateLimitBps >= 0 && iRexmitRateBps > iRexmitRateLimitBps)
+    {
+        // Too many retransmissions, so don't send anything.
+        // TODO: When to wake up next time?
+        return false;
     }
+#endif
 
-    return 0;
+#if SRT_DEBUG_TRACE_SND
+    g_snd_logger.state.canRexmit = true;
+#endif
+    return true;
 }
 
-std::pair<int, steady_clock::time_point> CUDT::packData(CPacket& w_packet)
+bool srt::CUDT::packData(CPacket& w_packet, steady_clock::time_point& w_nexttime, sockaddr_any& w_src_addr)
 {
     int payload = 0;
     bool probe = false;
-    steady_clock::time_point origintime;
     bool new_packet_packed = false;
-    bool filter_ctl_pkt = false;
-
-    int kflg = EK_NOENC;
 
     const steady_clock::time_point enter_time = steady_clock::now();
 
-    if (!is_zero(m_tsNextSendTime) && enter_time > m_tsNextSendTime)
-        m_tdSendTimeDiff += enter_time - m_tsNextSendTime;
+    w_nexttime = enter_time;
 
-    string reason = "reXmit";
+    if (!is_zero(m_tsNextSendTime) && enter_time > m_tsNextSendTime)
+    {
+        m_tdSendTimeDiff = m_tdSendTimeDiff.load() + (enter_time - m_tsNextSendTime);
+    }
 
     ScopedLock connectguard(m_ConnectionLock);
     // If a closing action is done simultaneously, then
@@ -9296,203 +9678,62 @@ std::pair<int, steady_clock::time_point> CUDT::packData(CPacket& w_packet)
     // start the dissolving process, this process will
     // not be started until this function is finished.
     if (!m_bOpened)
-        return std::make_pair(0, enter_time);
+        return false;
 
-    payload = packLostData((w_packet), (origintime));
+    payload = isRetransmissionAllowed(enter_time)
+        ? packLostData((w_packet))
+        : 0;
+
+    IF_HEAVY_LOGGING(const char* reason); // The source of the data packet (normal/rexmit/filter)
     if (payload > 0)
     {
-        reason = "reXmit";
+        IF_HEAVY_LOGGING(reason = "reXmit");
     }
     else if (m_PacketFilter &&
              m_PacketFilter.packControlPacket(m_iSndCurrSeqNo, m_pCryptoControl->getSndCryptoFlags(), (w_packet)))
     {
-        HLOGC(qslog.Debug, log << "filter: filter/CTL packet ready - packing instead of data.");
-        payload        = w_packet.getLength();
-        reason         = "filter";
-        filter_ctl_pkt = true; // Mark that this packet ALREADY HAS timestamp field and it should not be set
+        HLOGC(qslog.Debug, log << CONID() << "filter: filter/CTL packet ready - packing instead of data.");
+        payload        = (int) w_packet.getLength();
+        IF_HEAVY_LOGGING(reason = "filter");
 
         // Stats
-        {
-            ScopedLock lg(m_StatsLock);
-            ++m_stats.sndFilterExtra;
-            ++m_stats.sndFilterExtraTotal;
-        }
+        ScopedLock lg(m_StatsLock);
+        m_stats.sndr.sentFilterExtra.count(1);
     }
     else
     {
-        // If no loss, and no packetfilter control packet, pack a new packet.
-
-        // Check the congestion/flow window limit
-        const int cwnd    = std::min(int(m_iFlowWindowSize), int(m_dCongestionWindow));
-        const int flightspan = getFlightSpan();
-        if (cwnd > flightspan)
-        {
-            // XXX Here it's needed to set kflg to msgno_bitset in the block stored in the
-            // send buffer. This should be somehow avoided, the crypto flags should be set
-            // together with encrypting, and the packet should be sent as is, when rexmitting.
-            // It would be nice to research as to whether CSndBuffer::Block::m_iMsgNoBitset field
-            // isn't a useless redundant state copy. If it is, then taking the flags here can be removed.
-            kflg    = m_pCryptoControl->getSndCryptoFlags();
-            payload = m_pSndBuffer->readData((w_packet), (origintime), kflg);
-            if (payload)
-            {
-                // A CHANGE. The sequence number is currently added to the packet
-                // when scheduling, not when extracting. This is a inter-migration form,
-                // so still override the value, but trace it.
-                m_iSndCurrSeqNo = CSeqNo::incseq(m_iSndCurrSeqNo);
-
-                // Do this checking only for groups and only at the very first moment,
-                // when there's still nothing in the buffer. Otherwise there will be
-                // a serious data discrepancy between the agent and the peer.
-                // After increasing by 1, but being previously set as ISN-1, this should be == ISN,
-                // if this is the very first packet to send.
-#if ENABLE_EXPERIMENTAL_BONDING
-                // Fortunately here is only the procedure that verifies if the extraction
-                // sequence is moved due to the difference between ISN caught during the existing
-                // transmission and the first sequence possible to be used at the first sending
-                // instruction. The group itself isn't being accessed.
-                if (m_parent->m_IncludedGroup && m_iSndCurrSeqNo != w_packet.m_iSeqNo && m_iSndCurrSeqNo == m_iISN)
-                {
-                    const int packetspan = CSeqNo::seqcmp(w_packet.m_iSeqNo, m_iSndCurrSeqNo);
-
-                    HLOGC(qslog.Debug, log << CONID() << "packData: Fixing EXTRACTION sequence " << m_iSndCurrSeqNo
-                            << " from SCHEDULING sequence " << w_packet.m_iSeqNo
-                            << " DIFF: " << packetspan << " STAMP:" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
-
-                    // This is the very first packet to be sent; so there's nothing in
-                    // the sending buffer yet, and therefore we are in a situation as just
-                    // after connection. No packets in the buffer, no packets are sent,
-                    // no ACK to be awaited. We can screw up all the variables that are
-                    // initialized from ISN just after connection.
-                    //
-                    // Additionally send the drop request to the peer so that it
-                    // won't stupidly request the packets to be retransmitted.
-                    // Don't do it if the difference isn't positive or exceeds the threshold.
-                    if (packetspan > 0)
-                    {
-                        int32_t seqpair[2];
-                        seqpair[0] = m_iSndCurrSeqNo;
-                        seqpair[1] = w_packet.m_iSeqNo;
-                        HLOGC(qslog.Debug, log << "... sending INITIAL DROP (ISN FIX): "
-                                << "msg=" << MSGNO_SEQ::unwrap(w_packet.m_iMsgNo) << " SEQ:"
-                                << seqpair[0] << " - " << seqpair[1] << "(" << packetspan << " packets)");
-                        sendCtrl(UMSG_DROPREQ, &w_packet.m_iMsgNo, seqpair, sizeof(seqpair));
-
-                        // In case when this message is lost, the peer will still get the
-                        // UMSG_DROPREQ message when the agent realizes that the requested
-                        // packet are not present in the buffer (preadte the send buffer).
-                    }
-                }
-                else
-#endif
-                {
-                    HLOGC(qslog.Debug, log << CONID() << "packData: Applying EXTRACTION sequence " << m_iSndCurrSeqNo
-                            << " over SCHEDULING sequence " << w_packet.m_iSeqNo
-                            << " DIFF: " << CSeqNo::seqcmp(m_iSndCurrSeqNo, w_packet.m_iSeqNo)
-                            << " STAMP:" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
-
-#if ENABLE_EXPERIMENTAL_BONDING
-                    HLOGC(qslog.Debug, log << "... CONDITION: IN GROUP: " << (m_parent->m_IncludedGroup ? "yes":"no")
-                            << " extraction-seq=" << m_iSndCurrSeqNo << " scheduling-seq=" << w_packet.m_iSeqNo << " ISN=" << m_iISN);
-#endif
-
-                    // Do this always when not in a group, 
-                    w_packet.m_iSeqNo = m_iSndCurrSeqNo;
-                }
-
-                // every 16 (0xF) packets, a packet pair is sent
-                if ((w_packet.m_iSeqNo & PUMASK_SEQNO_PROBE) == 0)
-                    probe = true;
-
-                new_packet_packed = true;
-            }
-            else
-            {
-                m_tsNextSendTime = steady_clock::time_point();
-                m_tdSendTimeDiff = m_tdSendTimeDiff.zero();
-                return std::make_pair(0, enter_time);
-            }
-        }
-        else
+        if (!packUniqueData(w_packet))
         {
-            HLOGC(qslog.Debug, log << "packData: CONGESTED: cwnd=min(" << m_iFlowWindowSize << "," << m_dCongestionWindow
-                << ")=" << cwnd << " seqlen=(" << m_iSndLastAck << "-" << m_iSndCurrSeqNo << ")=" << flightspan);
             m_tsNextSendTime = steady_clock::time_point();
-            m_tdSendTimeDiff = m_tdSendTimeDiff.zero();
-            return std::make_pair(0, enter_time);
+            m_tdSendTimeDiff = steady_clock::duration();
+            return false;
         }
+        new_packet_packed = true;
 
-        reason = "normal";
-    }
+        // every 16 (0xF) packets, a packet pair is sent
+        if ((w_packet.seqno() & PUMASK_SEQNO_PROBE) == 0)
+            probe = true;
 
-    // Normally packet.m_iTimeStamp field is set exactly here,
-    // usually as taken from m_stats.tsStartTime and current time, unless live
-    // mode in which case it is based on 'origintime' as set during scheduling.
-    // In case when this is a filter control packet, the m_iTimeStamp field already
-    // contains the exactly needed value, and it's a timestamp clip, not a real
-    // timestamp.
-    if (!filter_ctl_pkt)
-    {
-        if (m_bPeerTsbPd)
-        {
-            /*
-             * When timestamp is carried over in this sending stream from a received stream,
-             * it may be older than the session start time causing a negative packet time
-             * that may block the receiver's Timestamp-based Packet Delivery.
-             * XXX Isn't it then better to not decrease it by m_stats.tsStartTime? As long as it
-             * doesn't screw up the start time on the other side.
-             */
-            if (origintime >= m_stats.tsStartTime)
-            {
-                setPacketTS(w_packet, origintime);
-            }
-            else
-            {
-                setPacketTS(w_packet, steady_clock::now());
-                LOGC(qslog.Warn, log << "packData: reference time=" << FormatTime(origintime)
-                        << " is in the past towards start time=" << FormatTime(m_stats.tsStartTime)
-                        << " - setting NOW as reference time for the data packet");
-            }
-        }
-        else
-        {
-            setPacketTS(w_packet, steady_clock::now());
-        }
+        payload = (int) w_packet.getLength();
+        IF_HEAVY_LOGGING(reason = "normal");
     }
 
-    w_packet.m_iID = m_PeerID;
-
-    /* Encrypt if 1st time this packet is sent and crypto is enabled */
-    if (kflg)
-    {
-        // XXX Encryption flags are already set on the packet before calling this.
-        // See readData() above.
-        if (m_pCryptoControl->encrypt((w_packet)))
-        {
-            // Encryption failed
-            //>>Add stats for crypto failure
-            LOGC(qslog.Warn, log << "ENCRYPT FAILED - packet won't be sent, size=" << payload);
-            // Encryption failed
-            return std::make_pair(-1, enter_time);
-        }
-        payload = w_packet.getLength(); /* Cipher may change length */
-        reason += " (encrypted)";
-    }
+    w_packet.set_id(m_PeerID); // Set the destination SRT socket ID.
 
     if (new_packet_packed && m_PacketFilter)
     {
-        HLOGC(qslog.Debug, log << "filter: Feeding packet for source clip");
+        HLOGC(qslog.Debug, log << CONID() << "filter: Feeding packet for source clip");
         m_PacketFilter.feedSource((w_packet));
     }
 
 #if ENABLE_HEAVY_LOGGING // Required because of referring to MessageFlagStr()
     HLOGC(qslog.Debug,
-          log << CONID() << "packData: " << reason << " packet seq=" << w_packet.m_iSeqNo << " (ACK=" << m_iSndLastAck
+          log << CONID() << "packData: " << reason << " packet seq=" << w_packet.seqno() << " (ACK=" << m_iSndLastAck
               << " ACKDATA=" << m_iSndLastDataAck << " MSG/FLAGS: " << w_packet.MessageFlagStr() << ")");
 #endif
 
     // Fix keepalive
-    m_tsLastSndTime = enter_time;
+    m_tsLastSndTime.store(enter_time);
 
     considerLegacySrtHandshake(steady_clock::time_point());
 
@@ -9506,52 +9747,208 @@ std::pair<int, steady_clock::time_point> CUDT::packData(CPacket& w_packet)
     // Left untouched for historical reasons.
     // Might be possible that it was because of that this is send from
     // different thread than the rest of the signals.
-    // m_pSndTimeWindow->onPktSent(w_packet.m_iTimeStamp);
+    // m_pSndTimeWindow->onPktSent(w_packet.timestamp());
 
     enterCS(m_StatsLock);
-    m_stats.traceBytesSent += payload;
-    m_stats.bytesSentTotal += payload;
-    ++m_stats.traceSent;
-    ++m_stats.sentTotal;
+    m_stats.sndr.sent.count(payload);
     if (new_packet_packed)
-    {
-        ++m_stats.traceSentUniq;
-        ++m_stats.sentUniqTotal;
-        m_stats.traceBytesSentUniq += payload;
-        m_stats.bytesSentUniqTotal += payload;
-    }
+        m_stats.sndr.sentUnique.count(payload);
     leaveCS(m_StatsLock);
 
+    const duration sendint = m_tdSendInterval;
     if (probe)
     {
         // sends out probing packet pair
         m_tsNextSendTime = enter_time;
+        // Sending earlier, need to adjust the pace later on.
+        m_tdSendTimeDiff = m_tdSendTimeDiff.load() - sendint;
         probe          = false;
     }
     else
     {
 #if USE_BUSY_WAITING
-        m_tsNextSendTime = enter_time + m_tdSendInterval;
+        m_tsNextSendTime = enter_time + m_tdSendInterval.load();
 #else
-        if (m_tdSendTimeDiff >= m_tdSendInterval)
+        const duration sendbrw = m_tdSendTimeDiff;
+
+        if (sendbrw >= sendint)
         {
-            // Send immidiately
+            // Send immediately
             m_tsNextSendTime = enter_time;
-            m_tdSendTimeDiff -= m_tdSendInterval;
+
+            // ATOMIC NOTE: this is the only thread that
+            // modifies this field
+            m_tdSendTimeDiff = sendbrw - sendint;
         }
         else
         {
-            m_tsNextSendTime = enter_time + (m_tdSendInterval - m_tdSendTimeDiff);
-            m_tdSendTimeDiff = m_tdSendTimeDiff.zero();
+            m_tsNextSendTime = enter_time + (sendint - sendbrw);
+            m_tdSendTimeDiff = duration();
+        }
+#endif
+    }
+    HLOGC(qslog.Debug, log << "packData: Setting source address: " << m_SourceAddr.str());
+    w_src_addr = m_SourceAddr;
+    w_nexttime = m_tsNextSendTime;
+
+    return payload >= 0; // XXX shouldn't be > 0 ? == 0 is only when buffer range exceeded.
+}
+
+bool srt::CUDT::packUniqueData(CPacket& w_packet)
+{
+    int current_sequence_number; // reflexing variable
+    int kflg;
+    time_point tsOrigin;
+    int pld_size;
+
+    {
+        ScopedLock lkrack (m_RecvAckLock);
+        // Check the congestion/flow window limit
+        const int cwnd    = std::min<int>(m_iFlowWindowSize, m_iCongestionWindow);
+        const int flightspan = getFlightSpan();
+        if (cwnd <= flightspan)
+        {
+            HLOGC(qslog.Debug,
+                    log << CONID() << "packUniqueData: CONGESTED: cwnd=min(" << m_iFlowWindowSize << "," << m_iCongestionWindow
+                    << ")=" << cwnd << " seqlen=(" << m_iSndLastAck << "-" << m_iSndCurrSeqNo << ")=" << flightspan);
+            return false;
+        }
+
+        // XXX Here it's needed to set kflg to msgno_bitset in the block stored in the
+        // send buffer. This should be somehow avoided, the crypto flags should be set
+        // together with encrypting, and the packet should be sent as is, when rexmitting.
+        // It would be nice to research as to whether CSndBuffer::Block::m_iMsgNoBitset field
+        // isn't a useless redundant state copy. If it is, then taking the flags here can be removed.
+        kflg = m_pCryptoControl->getSndCryptoFlags();
+        int pktskipseqno = 0;
+        pld_size = m_pSndBuffer->readData((w_packet), (tsOrigin), kflg, (pktskipseqno));
+        if (pktskipseqno)
+        {
+            // Some packets were skipped due to TTL expiry.
+            m_iSndCurrSeqNo = CSeqNo::incseq(m_iSndCurrSeqNo, pktskipseqno);
+            HLOGC(qslog.Debug, log << "packUniqueData: reading skipped " << pktskipseqno << " seq up to %" << m_iSndCurrSeqNo
+                    << " due to TTL expiry");
+        }
+
+        if (pld_size == 0)
+        {
+            HLOGC(qslog.Debug, log << "packUniqueData: nothing extracted from the buffer");
+            return false;
+        }
+
+        // A CHANGE. The sequence number is currently added to the packet
+        // when scheduling, not when extracting. This is a inter-migration form,
+        // only override extraction sequence with scheduling sequence in group mode.
+        m_iSndCurrSeqNo = CSeqNo::incseq(m_iSndCurrSeqNo);
+        current_sequence_number = m_iSndCurrSeqNo;
+    }
+
+#if ENABLE_BONDING
+    // Fortunately the group itself isn't being accessed.
+    if (m_parent->m_GroupOf)
+    {
+        const int packetspan = CSeqNo::seqoff(current_sequence_number, w_packet.seqno());
+        if (packetspan > 0)
+        {
+            // After increasing by 1, but being previously set as ISN-1, this should be == ISN,
+            // if this is the very first packet to send.
+            if (current_sequence_number == m_iISN)
+            {
+                // This is the very first packet to be sent; so there's nothing in
+                // the sending buffer yet, and therefore we are in a situation as just
+                // after connection. No packets in the buffer, no packets are sent,
+                // no ACK to be awaited. We can screw up all the variables that are
+                // initialized from ISN just after connection.
+                LOGC(qslog.Note,
+                     log << CONID() << "packUniqueData: Fixing EXTRACTION sequence " << current_sequence_number
+                         << " from SCHEDULING sequence " << w_packet.seqno() << " for the first packet: DIFF="
+                         << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
+            }
+            else
+            {
+                // There will be a serious data discrepancy between the agent and the peer.
+                LOGC(qslog.Error,
+                     log << CONID() << "IPE: packUniqueData: Fixing EXTRACTION sequence " << current_sequence_number
+                         << " from SCHEDULING sequence " << w_packet.seqno() << " in the middle of transition: DIFF="
+                         << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
+            }
+
+            // Additionally send the drop request to the peer so that it
+            // won't stupidly request the packets to be retransmitted.
+            // Don't do it if the difference isn't positive or exceeds the threshold.
+            int32_t seqpair[2];
+            seqpair[0]             = current_sequence_number;
+            seqpair[1]             = CSeqNo::decseq(w_packet.seqno());
+            const int32_t no_msgno = 0;
+            LOGC(qslog.Debug,
+                 log << CONID() << "packUniqueData: Sending DROPREQ: SEQ: " << seqpair[0] << " - " << seqpair[1] << " ("
+                     << packetspan << " packets)");
+            sendCtrl(UMSG_DROPREQ, &no_msgno, seqpair, sizeof(seqpair));
+            // In case when this message is lost, the peer will still get the
+            // UMSG_DROPREQ message when the agent realizes that the requested
+            // packet are not present in the buffer (preadte the send buffer).
+
+            // Override extraction sequence with scheduling sequence.
+            ScopedLock ackguard(m_RecvAckLock);
+            m_iSndCurrSeqNo = w_packet.seqno();
+            m_iSndLastAck     = w_packet.seqno();
+            m_iSndLastDataAck = w_packet.seqno();
+            m_iSndLastFullAck = w_packet.seqno();
+            m_iSndLastAck2    = w_packet.seqno();
+        }
+        else if (packetspan < 0)
+        {
+            LOGC(qslog.Error,
+                 log << CONID() << "IPE: packData: SCHEDULING sequence " << w_packet.seqno()
+                     << " is behind of EXTRACTION sequence " << current_sequence_number << ", dropping this packet: DIFF="
+                     << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
+            // XXX: Probably also change the socket state to broken?
+            return false;
         }
+    }
+    else
 #endif
+    {
+        HLOGC(qslog.Debug,
+              log << CONID() << "packUniqueData: Applying EXTRACTION sequence " << current_sequence_number
+                  << " over SCHEDULING sequence " << w_packet.seqno() << " for socket not in group:"
+                  << " DIFF=" << CSeqNo::seqcmp(current_sequence_number, w_packet.seqno())
+                  << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
+        // Do this always when not in a group.
+        w_packet.set_seqno(current_sequence_number);
+    }
+
+    // Set missing fields before encrypting the packet, because those fields might be used for encryption.
+    w_packet.set_id(m_PeerID); // Destination SRT Socket ID
+    setDataPacketTS(w_packet, tsOrigin);
+
+    if (kflg != EK_NOENC)
+    {
+        // Note that the packet header must have a valid seqno set, as it is used as a counter for encryption.
+        // Other fields of the data packet header (e.g. timestamp, destination socket ID) are not used for the counter.
+        // Cypher may change packet length!
+        if (m_pCryptoControl->encrypt((w_packet)) != ENCS_CLEAR)
+        {
+            // Encryption failed
+            //>>Add stats for crypto failure
+            LOGC(qslog.Warn, log << CONID() << "ENCRYPT FAILED - packet won't be sent, size=" << pld_size);
+            return false;
+        }
+
+        checkSndKMRefresh();
     }
 
-    return std::make_pair(payload, m_tsNextSendTime);
+#if SRT_DEBUG_TRACE_SND
+    g_snd_logger.state.iPktSeqno = w_packet.seqno();
+    g_snd_logger.state.isRetransmitted = w_packet.getRexmitFlag(); 
+    g_snd_logger.trace();
+#endif
+
+    return true;
 }
 
 // This is a close request, but called from the
-void CUDT::processClose()
+void srt::CUDT::processClose()
 {
     sendCtrl(UMSG_SHUTDOWN);
 
@@ -9565,22 +9962,20 @@ void CUDT::processClose()
     if (m_bTsbPd)
     {
         HLOGP(smlog.Debug, "processClose: lock-and-signal TSBPD");
-        CSync::lock_signal(m_RcvTsbPdCond, m_RecvLock);
+        CSync::lock_notify_one(m_RcvTsbPdCond, m_RecvLock);
     }
 
     // Signal the sender and recver if they are waiting for data.
     releaseSynch();
     // Unblock any call so they learn the connection_broken error
-    s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_ERR, true);
+    uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_ERR, true);
 
     HLOGP(smlog.Debug, "processClose: triggering timer event to spread the bad news");
     CGlobEvent::triggerEvent();
 }
 
-void CUDT::sendLossReport(const std::vector<std::pair<int32_t, int32_t> > &loss_seqs)
+void srt::CUDT::sendLossReport(const std::vector<std::pair<int32_t, int32_t> > &loss_seqs)
 {
-    typedef vector<pair<int32_t, int32_t> > loss_seqs_t;
-
     vector<int32_t> seqbuffer;
     seqbuffer.reserve(2 * loss_seqs.size()); // pessimistic
     for (loss_seqs_t::const_iterator i = loss_seqs.begin(); i != loss_seqs.end(); ++i)
@@ -9588,31 +9983,28 @@ void CUDT::sendLossReport(const std::vector<std::pair<int32_t, int32_t> > &loss_
         if (i->first == i->second)
         {
             seqbuffer.push_back(i->first);
-            HLOGF(qrlog.Debug, "lost packet %d: sending LOSSREPORT", i->first);
+            HLOGC(qrlog.Debug, log << "lost packet " << i->first << ": sending LOSSREPORT");
         }
         else
         {
             seqbuffer.push_back(i->first | LOSSDATA_SEQNO_RANGE_FIRST);
             seqbuffer.push_back(i->second);
-            HLOGF(qrlog.Debug,
-                  "lost packets %d-%d (%d packets): sending LOSSREPORT",
-                  i->first,
-                  i->second,
-                  1 + CSeqNo::seqcmp(i->second, i->first));
+            HLOGC(qrlog.Debug, log << "lost packets " << i->first << "-" << i->second
+                    << " (" << (1 + CSeqNo::seqcmp(i->second, i->first)) << " packets): sending LOSSREPORT");
         }
     }
 
     if (!seqbuffer.empty())
     {
-        sendCtrl(UMSG_LOSSREPORT, NULL, &seqbuffer[0], seqbuffer.size());
+        sendCtrl(UMSG_LOSSREPORT, NULL, &seqbuffer[0], (int) seqbuffer.size());
     }
 }
 
 
-bool CUDT::overrideSndSeqNo(int32_t seq)
+bool srt::CUDT::overrideSndSeqNo(int32_t seq)
 {
     // This function is intended to be called from the socket
-    // group managmenet functions to synchronize the sequnece in
+    // group management functions to synchronize the sequnece in
     // all sockes in the bonding group. THIS sequence given
     // here is the sequence TO BE STAMPED AT THE EXACTLY NEXT
     // sent payload. Therefore, screw up the ISN to exactly this
@@ -9637,30 +10029,318 @@ bool CUDT::overrideSndSeqNo(int32_t seq)
     const int diff = CSeqNo(seq) - CSeqNo(m_iSndCurrSeqNo);
     if (diff < 0 || diff > CSeqNo::m_iSeqNoTH)
     {
-        LOGC(gslog.Error, log << CONID() << "IPE: Overridding with seq %" << seq << " DISCREPANCY against current %"
+        LOGC(gslog.Error, log << CONID() << "IPE: Overriding with seq %" << seq << " DISCREPANCY against current %"
                 << m_iSndCurrSeqNo << " and next sched %" << m_iSndNextSeqNo << " - diff=" << diff);
         return false;
     }
 
-    //
-    // The peer will have to do the same, as a reaction on perceived
-    // packet loss. When it recognizes that this initial screwing up
-    // has happened, it should simply ignore the loss and go on.
-    // ISN isn't being changed here - it doesn't make much sense now.
+    //
+    // The peer will have to do the same, as a reaction on perceived
+    // packet loss. When it recognizes that this initial screwing up
+    // has happened, it should simply ignore the loss and go on.
+    // ISN isn't being changed here - it doesn't make much sense now.
+
+    setInitialSndSeq(seq);
+
+    // m_iSndCurrSeqNo will be most likely lower than m_iSndNextSeqNo because
+    // the latter is ahead with the number of packets already scheduled, but
+    // not yet sent.
+
+    HLOGC(gslog.Debug,
+          log << CONID() << "overrideSndSeqNo: sched-seq=" << m_iSndNextSeqNo << " send-seq=" << m_iSndCurrSeqNo
+              << " (unchanged)");
+    return true;
+}
+
+int srt::CUDT::checkLazySpawnTsbPdThread()
+{
+    const bool need_tsbpd = m_bTsbPd || m_bGroupTsbPd;
+    if (!need_tsbpd)
+        return 0;
+
+    ScopedLock lock(m_RcvTsbPdStartupLock);
+    if (!m_RcvTsbPdThread.joinable())
+    {
+        if (m_bClosing) // Check m_bClosing to protect join() in CUDT::releaseSync().
+            return -1;
+
+        HLOGP(qrlog.Debug, "Spawning Socket TSBPD thread");
+#if ENABLE_HEAVY_LOGGING
+        std::ostringstream tns1, tns2;
+        // Take the last 2 ciphers from the socket ID.
+        tns1 << setfill('0') << setw(2) << m_SocketID;
+        std::string s = tns1.str();
+        tns2 << "SRT:TsbPd:@" << s.substr(s.size()-2, 2);
+        const string thname = tns2.str();
+#else
+        const string thname = "SRT:TsbPd";
+#endif
+        if (!StartThread(m_RcvTsbPdThread, CUDT::tsbpd, this, thname))
+            return -1;
+    }
+
+    return 0;
+}
+
+CUDT::time_point srt::CUDT::getPktTsbPdTime(void*, const CPacket& packet)
+{
+    return m_pRcvBuffer->getPktTsbPdTime(packet.getMsgTimeStamp());
+}
+
+SRT_ATR_UNUSED static const char *const s_rexmitstat_str[] = {"ORIGINAL", "REXMITTED", "RXS-UNKNOWN"};
+
+// [[using locked(m_RcvBufferLock)]]
+int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool& w_new_inserted, bool& w_was_sent_in_order, CUDT::loss_seqs_t& w_srt_loss_seqs)
+{
+    bool excessive SRT_ATR_UNUSED = true; // stays true unless it was successfully added
+
+    w_new_inserted = false;
+    const int32_t bufseq = m_pRcvBuffer->getStartSeqNo();
+
+    // Loop over all incoming packets that were filtered out.
+    // In case when there is no filter, there's just one packet in 'incoming',
+    // the one that came in the input of this function.
+    for (vector<CUnit *>::const_iterator unitIt = incoming.begin(); unitIt != incoming.end(); ++unitIt)
+    {
+        CUnit *  u    = *unitIt;
+        CPacket &rpkt = u->m_Packet;
+        const int pktrexmitflag = m_bPeerRexmitFlag ? (rpkt.getRexmitFlag() ? 1 : 0) : 2;
+        const bool retransmitted = pktrexmitflag == 1;
+
+        bool adding_successful = true;
+
+        const int32_t bufidx = CSeqNo::seqoff(bufseq, rpkt.seqno());
+
+        IF_HEAVY_LOGGING(const char *exc_type = "EXPECTED");
+
+        // bufidx < 0: the packet is in the past for the buffer
+        // seqno <% m_iRcvLastAck : the sequence may be within the buffer,
+        // but if so, it is in the acknowledged-but-not-retrieved area.
+
+        // NOTE: if we have a situation when there are any packets in the
+        // acknowledged area, but they aren't retrieved, this area DOES NOT
+        // contain any losses. So a packet in this area is at best a duplicate.
+
+        // In case when a loss would be abandoned (TLPKTDROP), there must at
+        // some point happen to be an empty first cell in the buffer, followed
+        // somewhere by a valid packet. If this state is achieved at some point,
+        // the acknowledgement sequence should be equal to the beginning of the
+        // buffer. Then, when TSBPD decides to drop these initial empty cells,
+        // we'll have: (m_iRcvLastAck <% buffer->getStartSeqNo()) - and in this
+        // case (bufidx < 0) condition will be satisfied also for this case.
+        //
+        // The only case when bufidx > 0, but packet seq is <% m_iRcvLastAck
+        // is when the packet sequence is within the initial contiguous area,
+        // which never contains losses, so discarding this packet does not
+        // discard a loss coverage, even if this were past ACK.
+
+        if (bufidx < 0 || CSeqNo::seqcmp(rpkt.seqno(), m_iRcvLastAck) < 0)
+        {
+            time_point pts = getPktTsbPdTime(NULL, rpkt);
+
+            enterCS(m_StatsLock);
+            const double bltime = (double) CountIIR<uint64_t>(
+                    uint64_t(m_stats.traceBelatedTime) * 1000,
+                    count_microseconds(steady_clock::now() - pts), 0.2);
+
+            m_stats.traceBelatedTime = bltime / 1000.0;
+            m_stats.rcvr.recvdBelated.count(rpkt.getLength());
+            leaveCS(m_StatsLock);
+            HLOGC(qrlog.Debug,
+                    log << CONID() << "RECEIVED: %" << rpkt.seqno() << " bufidx=" << bufidx << " (BELATED/"
+                    << s_rexmitstat_str[pktrexmitflag] << ") with ACK %" << m_iRcvLastAck
+                    << " FLAGS: " << rpkt.MessageFlagStr());
+            continue;
+        }
+
+        if (bufidx >= int(m_pRcvBuffer->capacity()))
+        {
+            // This is already a sequence discrepancy. Probably there could be found
+            // some way to make it continue reception by overriding the sequence and
+            // make a kinda TLKPTDROP, but there has been found no reliable way to do this.
+            if (m_bTsbPd && m_bTLPktDrop && m_pRcvBuffer->empty())
+            {
+                // Only in live mode. In File mode this shall not be possible
+                // because the sender should stop sending in this situation.
+                // In Live mode this means that there is a gap between the
+                // lowest sequence in the empty buffer and the incoming sequence
+                // that exceeds the buffer size. Receiving data in this situation
+                // is no longer possible and this is a point of no return.
+
+                LOGC(qrlog.Error, log << CONID() <<
+                        "SEQUENCE DISCREPANCY. BREAKING CONNECTION."
+                        " %" << rpkt.seqno()
+                        << " buffer=(%" << bufseq
+                        << ":%" << m_iRcvCurrSeqNo                   // -1 = size to last index
+                        << "+%" << CSeqNo::incseq(bufseq, int(m_pRcvBuffer->capacity()) - 1)
+                        << "), " << (m_pRcvBuffer->capacity() - bufidx + 1)
+                        << " past max. Reception no longer possible. REQUESTING TO CLOSE.");
+
+                return -2;
+            }
+            else
+            {
+                LOGC(qrlog.Warn, log << CONID() << "No room to store incoming packet seqno " << rpkt.seqno()
+                        << ", insert offset " << bufidx << ". "
+                        << m_pRcvBuffer->strFullnessState(m_iRcvLastAck, steady_clock::now())
+                    );
+
+                return -1;
+            }
+        }
+
+        const int buffer_add_result = m_pRcvBuffer->insert(u);
+        if (buffer_add_result < 0)
+        {
+            // The insert() result is -1 if at the position evaluated from this packet's
+            // sequence number there already is a packet.
+            // So this packet is "redundant".
+            IF_HEAVY_LOGGING(exc_type = "UNACKED");
+            adding_successful = false;
+        }
+        else
+        {
+            w_new_inserted = true;
+
+            IF_HEAVY_LOGGING(exc_type = "ACCEPTED");
+            excessive = false;
+            if (u->m_Packet.getMsgCryptoFlags() != EK_NOENC)
+            {
+                // TODO: reset and restore the timestamp if TSBPD is disabled.
+                // Reset retransmission flag (must be excluded from GCM auth tag).
+                u->m_Packet.setRexmitFlag(false);
+                const EncryptionStatus rc = m_pCryptoControl ? m_pCryptoControl->decrypt((u->m_Packet)) : ENCS_NOTSUP;
+                u->m_Packet.setRexmitFlag(retransmitted); // Recover the flag.
+
+                if (rc != ENCS_CLEAR)
+                {
+                    adding_successful = false;
+                    IF_HEAVY_LOGGING(exc_type = "UNDECRYPTED");
+
+                    // If TSBPD is disabled, then SRT either operates in buffer mode, of in message API without a restriction
+                    // of a single message packet. In that case just dropping a packet is not enough.
+                    // In message mode the whole message has to be dropped.
+                    // However, when decryption fails the message number in the packet cannot be trusted.
+                    // The packet has to be removed from the RCV buffer based on that pkt sequence number,
+                    // and the sequence number itself must go into the RCV loss list.
+                    // See issue ##2626.
+                    SRT_ASSERT(m_bTsbPd);
+
+                    // Drop the packet from the receiver buffer.
+                    // The packet was added to the buffer based on the sequence number, therefore sequence number should be used to drop it from the buffer.
+                    // A drawback is that it would prevent a valid packet with the same sequence number, if it happens to arrive later, to end up in the buffer.
+                    const int iDropCnt = m_pRcvBuffer->dropMessage(u->m_Packet.getSeqNo(), u->m_Packet.getSeqNo(), SRT_MSGNO_NONE, CRcvBuffer::DROP_EXISTING);
+
+                    const steady_clock::time_point tnow = steady_clock::now();
+                    ScopedLock lg(m_StatsLock);
+                    m_stats.rcvr.dropped.count(stats::BytesPackets(iDropCnt * rpkt.getLength(), iDropCnt));
+                    m_stats.rcvr.undecrypted.count(stats::BytesPackets(rpkt.getLength(), 1));
+                    string why;
+                    if (frequentLogAllowed(FREQLOGFA_ENCRYPTION_FAILURE, tnow, (why)))
+                    {
+                        LOGC(qrlog.Warn, log << CONID() << "Decryption failed (seqno %" << u->m_Packet.getSeqNo() << "), dropped "
+                            << iDropCnt << ". pktRcvUndecryptTotal=" << m_stats.rcvr.undecrypted.total.count() << "." << why);
+                    }
+#if SRT_ENABLE_FREQUENT_LOG_TRACE
+                    else
+                    {
+
+                        LOGC(qrlog.Warn, log << "SUPPRESSED: Decryption failed LOG: " << why);
+                    }
+#endif
+                }
+            }
+            else if (m_pCryptoControl && m_pCryptoControl->m_RcvKmState == SRT_KM_S_SECURED)
+            {
+                // Unencrypted packets are not allowed.
+                const int iDropCnt = m_pRcvBuffer->dropMessage(u->m_Packet.getSeqNo(), u->m_Packet.getSeqNo(), SRT_MSGNO_NONE, CRcvBuffer::DROP_EXISTING);
+
+                const steady_clock::time_point tnow = steady_clock::now();
+                ScopedLock lg(m_StatsLock);
+                m_stats.rcvr.dropped.count(stats::BytesPackets(iDropCnt* rpkt.getLength(), iDropCnt));
+                m_stats.rcvr.undecrypted.count(stats::BytesPackets(rpkt.getLength(), 1));
+                string why;
+                if (frequentLogAllowed(FREQLOGFA_ENCRYPTION_FAILURE, tnow, (why)))
+                {
+                    LOGC(qrlog.Warn, log << CONID() << "Packet not encrypted (seqno %" << u->m_Packet.getSeqNo() << "), dropped "
+                        << iDropCnt << ". pktRcvUndecryptTotal=" << m_stats.rcvr.undecrypted.total.count() << ".");
+                }
+            }
+        }
+
+        if (adding_successful)
+        {
+            ScopedLock statslock(m_StatsLock);
+            m_stats.rcvr.recvdUnique.count(u->m_Packet.getLength());
+        }
+
+#if ENABLE_HEAVY_LOGGING
+        std::ostringstream expectspec;
+        if (excessive)
+            expectspec << "EXCESSIVE(" << exc_type << ")";
+        else
+            expectspec << "ACCEPTED";
+
+        std::ostringstream bufinfo;
+
+        if (m_pRcvBuffer)
+        {
+            // XXX Fix this when the end of contiguous region detection is added.
+            const int ackidx = std::max(0, CSeqNo::seqoff(m_pRcvBuffer->getStartSeqNo(), m_iRcvLastAck));
+
+            bufinfo << " BUF.s=" << m_pRcvBuffer->capacity()
+                << " avail=" << (int(m_pRcvBuffer->capacity()) - ackidx)
+                << " buffer=(%" << bufseq
+                << ":%" << m_iRcvCurrSeqNo                   // -1 = size to last index
+                << "+%" << CSeqNo::incseq(bufseq, int(m_pRcvBuffer->capacity()) - 1)
+                << ")";
+        }
+
+        // Empty buffer info in case of groupwise receiver.
+        // There's no way to obtain this information here.
+
+        LOGC(qrlog.Debug, log << CONID() << "RECEIVED: %" << rpkt.seqno()
+                << bufinfo.str()
+                << " RSL=" << expectspec.str()
+                << " SN=" << s_rexmitstat_str[pktrexmitflag]
+                << " FLAGS: "
+                << rpkt.MessageFlagStr());
+#endif
+
+        // Decryption should have made the crypto flags EK_NOENC.
+        // Otherwise it's an error.
+        if (adding_successful)
+        {
+            HLOGC(qrlog.Debug,
+                      log << CONID()
+                          << "CONTIGUITY CHECK: sequence distance: " << CSeqNo::seqoff(m_iRcvCurrSeqNo, rpkt.seqno()));
 
-    setInitialSndSeq(seq);
+            if (CSeqNo::seqcmp(rpkt.seqno(), CSeqNo::incseq(m_iRcvCurrSeqNo)) > 0) // Loss detection.
+            {
+                int32_t seqlo = CSeqNo::incseq(m_iRcvCurrSeqNo);
+                int32_t seqhi = CSeqNo::decseq(rpkt.seqno());
+                w_srt_loss_seqs.push_back(make_pair(seqlo, seqhi));
+                HLOGC(qrlog.Debug, log << "pkt/LOSS DETECTED: %" << seqlo << " - %" << seqhi);
+            }
+        }
 
-    // m_iSndCurrSeqNo will be most likely lower than m_iSndNextSeqNo because
-    // the latter is ahead with the number of packets already scheduled, but
-    // not yet sent.
+        // Update the current largest sequence number that has been received.
+        // Or it is a retransmitted packet, remove it from receiver loss list.
+        if (CSeqNo::seqcmp(rpkt.seqno(), m_iRcvCurrSeqNo) > 0)
+        {
+            m_iRcvCurrSeqNo = rpkt.seqno(); // Latest possible received
+        }
+        else
+        {
+            unlose(rpkt); // was BELATED or RETRANSMITTED
+            w_was_sent_in_order &= 0 != pktrexmitflag;
+        }
+    }
 
-    HLOGC(gslog.Debug, log << CONID() << "overrideSndSeqNo: sched-seq=" << m_iSndNextSeqNo << " send-seq=" << m_iSndCurrSeqNo
-        << " (unchanged)"
-        );
-    return true;
+    return 0;
 }
 
-int CUDT::processData(CUnit* in_unit)
+int srt::CUDT::processData(CUnit* in_unit)
 {
     if (m_bClosing)
         return -1;
@@ -9669,53 +10349,34 @@ int CUDT::processData(CUnit* in_unit)
 
     // Just heard from the peer, reset the expiration count.
     m_iEXPCount = 1;
-    m_tsLastRspTime = steady_clock::now();
+    m_tsLastRspTime.store(steady_clock::now());
 
-    const bool need_tsbpd = m_bTsbPd || m_bGroupTsbPd;
 
     // We are receiving data, start tsbpd thread if TsbPd is enabled
-    if (need_tsbpd && !m_RcvTsbPdThread.joinable())
+    if (-1 == checkLazySpawnTsbPdThread())
     {
-        ScopedLock lock(m_RcvTsbPdStartupLock);
-
-        if (m_bClosing) // Check again to protect join() in CUDT::releaseSync()
-            return -1;
-
-        HLOGP(qrlog.Debug, "Spawning Socket TSBPD thread");
-#if ENABLE_HEAVY_LOGGING
-        std::ostringstream tns1, tns2;
-        // Take the last 2 ciphers from the socket ID.
-        tns1 << m_SocketID;
-        std::string s = tns1.str();
-        tns2 << "SRT:TsbPd:@" << s.substr(s.size()-2, 2);
-
-        ThreadName tn(tns2.str().c_str());
-        const char* thname = tns2.str().c_str();
-#else
-        const char* thname = "SRT:TsbPd";
-#endif
-        if (!StartThread(m_RcvTsbPdThread, CUDT::tsbpd, this, thname))
-            return -1;
+        return -1;
     }
 
     const int pktrexmitflag = m_bPeerRexmitFlag ? (packet.getRexmitFlag() ? 1 : 0) : 2;
+    const bool retransmitted = pktrexmitflag == 1;
 #if ENABLE_HEAVY_LOGGING
-    static const char *const rexmitstat[] = {"ORIGINAL", "REXMITTED", "RXS-UNKNOWN"};
     string                   rexmit_reason;
 #endif
 
-    if (pktrexmitflag == 1)
+    if (retransmitted)
     {
         // This packet was retransmitted
         enterCS(m_StatsLock);
-        m_stats.traceRcvRetrans++;
+        m_stats.rcvr.recvdRetrans.count(packet.getLength());
         leaveCS(m_StatsLock);
 
 #if ENABLE_HEAVY_LOGGING
         // Check if packet was retransmitted on request or on ack timeout
         // Search the sequence in the loss record.
         rexmit_reason = " by ";
-        if (!m_pRcvLossList->find(packet.m_iSeqNo, packet.m_iSeqNo))
+        ScopedLock lock(m_RcvLossLock);
+        if (!m_pRcvLossList->find(packet.seqno(), packet.seqno()))
             rexmit_reason += "BLIND";
         else
             rexmit_reason += "NAKREPORT";
@@ -9743,7 +10404,7 @@ int CUDT::processData(CUnit* in_unit)
     updateCC(TEV_RECEIVE, EventVariant(&packet));
     ++m_iPktCount;
 
-    const int pktsz = packet.getLength();
+    const int pktsz = (int) packet.getLength();
     // Update time information
     // XXX Note that this adds the byte size of a packet
     // of which we don't yet know as to whether this has
@@ -9759,8 +10420,7 @@ int CUDT::processData(CUnit* in_unit)
     // Conditions and any extra data required for the packet
     // this function will extract and test as needed.
 
-    const bool unordered = CSeqNo::seqcmp(packet.m_iSeqNo, m_iRcvCurrSeqNo) <= 0;
-    const bool retransmitted = m_bPeerRexmitFlag && packet.getRexmitFlag();
+    const bool unordered = CSeqNo::seqcmp(packet.seqno(), m_iRcvCurrSeqNo) <= 0;
 
     // Retransmitted and unordered packets do not provide expected measurement.
     // We expect the 16th and 17th packet to be sent regularly,
@@ -9768,17 +10428,13 @@ int CUDT::processData(CUnit* in_unit)
     m_RcvTimeWindow.probeArrival(packet, unordered || retransmitted);
 
     enterCS(m_StatsLock);
-    m_stats.traceBytesRecv += pktsz;
-    m_stats.bytesRecvTotal += pktsz;
-    ++m_stats.traceRecv;
-    ++m_stats.recvTotal;
+    m_stats.rcvr.recvd.count(pktsz);
     leaveCS(m_StatsLock);
 
     loss_seqs_t                             filter_loss_seqs;
     loss_seqs_t                             srt_loss_seqs;
     vector<CUnit *>                         incoming;
     bool                                    was_sent_in_order          = true;
-    bool                                    reorder_prevent_lossreport = false;
 
     // If the peer doesn't understand REXMIT flag, send rexmit request
     // always immediately.
@@ -9786,55 +10442,39 @@ int CUDT::processData(CUnit* in_unit)
     if (m_bPeerRexmitFlag)
         initial_loss_ttl = m_iReorderTolerance;
 
-    // After introduction of packet filtering, the "recordable loss detection"
-    // does not exactly match the true loss detection. When a FEC filter is
-    // working, for example, then getting one group filled with all packet but
-    // the last one and the FEC control packet, in this special case this packet
-    // won't be notified at all as lost because it will be recovered by the
-    // filter immediately before anyone notices what happened (and the loss
-    // detection for the further functionality is checked only afterwards,
-    // and in this case the immediate recovery makes the loss to not be noticed
-    // at all).
-    //
-    // Because of that the check for losses must happen BEFORE passing the packet
-    // to the filter and before the filter could recover the packet before anyone
-    // notices :)
-
-    if (packet.getMsgSeq() != SRT_MSGNO_CONTROL) // disregard filter-control packets, their seq may mean nothing
-    {
-        int diff = CSeqNo::seqoff(m_iRcvCurrPhySeqNo, packet.m_iSeqNo);
-       // Difference between these two sequence numbers is expected to be:
-       // 0 - duplicated last packet (theory only)
-       // 1 - subsequent packet (alright)
-       // <0 - belated or recovered packet
-       // >1 - jump over a packet loss (loss = seqdiff-1)
+    // Track packet loss in statistics early, because a packet filter (e.g. FEC) might recover it later on,
+    // supply the missing packet(s), and the loss will no longer be visible for the code that follows.
+    if (packet.getMsgSeq(m_bPeerRexmitFlag) != SRT_MSGNO_CONTROL) // disregard filter-control packets, their seq may mean nothing
+    {
+        const int diff = CSeqNo::seqoff(m_iRcvCurrPhySeqNo, packet.seqno());
+        // Difference between these two sequence numbers is expected to be:
+        // 0 - duplicated last packet (theory only)
+        // 1 - subsequent packet (alright)
+        // <0 - belated or recovered packet
+        // >1 - jump over a packet loss (loss = seqdiff-1)
         if (diff > 1)
         {
+            const int loss = diff - 1; // loss is all that is above diff == 1
+
             ScopedLock lg(m_StatsLock);
-            int    loss = diff - 1; // loss is all that is above diff == 1
-            m_stats.traceRcvLoss += loss;
-            m_stats.rcvLossTotal += loss;
             const uint64_t avgpayloadsz = m_pRcvBuffer->getRcvAvgPayloadSize();
-            const uint64_t lossbytes = loss * avgpayloadsz;
-            m_stats.traceRcvBytesLoss += lossbytes;
-            m_stats.rcvBytesLossTotal += lossbytes;
+            m_stats.rcvr.lost.count(stats::BytesPackets(loss * avgpayloadsz, (uint32_t) loss));
+
             HLOGC(qrlog.Debug,
-                  log << "LOSS STATS: n=" << loss << " SEQ: [" << CSeqNo::incseq(m_iRcvCurrPhySeqNo) << " "
-                      << CSeqNo::decseq(packet.m_iSeqNo) << "]");
+                  log << CONID() << "LOSS STATS: n=" << loss << " SEQ: [" << CSeqNo::incseq(m_iRcvCurrPhySeqNo) << " "
+                      << CSeqNo::decseq(packet.seqno()) << "]");
         }
 
         if (diff > 0)
         {
             // Record if it was further than latest
-            m_iRcvCurrPhySeqNo = packet.m_iSeqNo;
+            m_iRcvCurrPhySeqNo = packet.seqno();
         }
     }
 
-    bool need_notify_loss = true;
-
     // [[using locked()]];  // (NOTHING locked)
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     // Switch to RUNNING even if there was a discrepancy, unless
     // it was long way forward.
     // XXX Important: This code is in the dead function defaultPacketArrival
@@ -9842,265 +10482,99 @@ int CUDT::processData(CUnit* in_unit)
     // accepted or rejected because if it was belated it may result in a
     // "runaway train" problem as the IDLE links are being updated the base
     // reception sequence pointer stating that this link is not receiving.
-    if (m_parent->m_IncludedGroup)
+    if (m_parent->m_GroupOf)
     {
-        ScopedLock protect_group_existence (s_UDTUnited.m_GlobControlLock);
-        CUDTGroup::gli_t gi = m_parent->m_IncludedIter;
+        ScopedLock protect_group_existence (uglobal().m_GlobControlLock);
+        groups::SocketData* gi = m_parent->m_GroupMemberData;
 
         // This check is needed as after getting the lock the socket
         // could be potentially removed. It is however granted that as long
         // as gi is non-NULL iterator, the group does exist and it does contain
-        // this socket as member (that is, 'gi' cannot be a dangling iterator).
-        if (gi != CUDTGroup::gli_NULL())
+        // this socket as member (that is, 'gi' cannot be a dangling pointer).
+        if (gi != NULL)
         {
             if (gi->rcvstate < SRT_GST_RUNNING) // PENDING or IDLE, tho PENDING is unlikely
             {
-                HLOGC(qrlog.Debug, log << "processData: IN-GROUP rcv state transition "
-                        << srt_log_grp_state[gi->rcvstate]
-                        << " -> RUNNING. NOT checking for loss");
+                HLOGC(qrlog.Debug,
+                      log << CONID() << "processData: IN-GROUP rcv state transition " << srt_log_grp_state[gi->rcvstate]
+                          << " -> RUNNING.");
                 gi->rcvstate = SRT_GST_RUNNING;
-
-                // The function unfortunately can't return here.
-                // We just need to skip loss reporting.
-                need_notify_loss = false;
             }
             else
             {
-                HLOGC(qrlog.Debug, log << "processData: IN-GROUP rcv state transition NOT DONE - state:"
-                        << srt_log_grp_state[gi->rcvstate]);
+                HLOGC(qrlog.Debug,
+                      log << CONID() << "processData: IN-GROUP rcv state transition NOT DONE - state:"
+                          << srt_log_grp_state[gi->rcvstate]);
             }
         }
     }
 #endif
 
+    bool new_inserted = false;
+
+    if (m_PacketFilter)
+    {
+        // Stuff this data into the filter
+        m_PacketFilter.receive(in_unit, (incoming), (filter_loss_seqs));
+        HLOGC(qrlog.Debug,
+              log << CONID() << "(FILTER) fed data, received " << incoming.size() << " pkts, " << Printable(filter_loss_seqs)
+                  << " loss to report, "
+                  << (m_PktFilterRexmitLevel == SRT_ARQ_ALWAYS ? "FIND & REPORT LOSSES YOURSELF"
+                                                               : "REPORT ONLY THOSE"));
+    }
+    else
+    {
+        // Stuff in just one packet that has come in.
+        incoming.push_back(in_unit);
+    }
+
     {
         // Start of offset protected section
         // Prevent TsbPd thread from modifying Ack position while adding data
         // offset from RcvLastAck in RcvBuffer must remain valid between seqoff() and addData()
         UniqueLock recvbuf_acklock(m_RcvBufferLock);
+        // Needed for possibly check for needsQuickACK.
+        const bool incoming_belated = (CSeqNo::seqcmp(in_unit->m_Packet.seqno(), m_pRcvBuffer->getStartSeqNo()) < 0);
 
-        // vector<CUnit*> undec_units;
-        if (m_PacketFilter)
+        const int res = handleSocketPacketReception(incoming,
+                (new_inserted),
+                (was_sent_in_order),
+                (srt_loss_seqs));
+
+        if (res == -2)
         {
-            // Stuff this data into the filter
-            m_PacketFilter.receive(in_unit, (incoming), (filter_loss_seqs));
-            HLOGC(qrlog.Debug,
-                  log << "(FILTER) fed data, received " << incoming.size() << " pkts, " << Printable(filter_loss_seqs)
-                      << " loss to report, "
-                      << (m_PktFilterRexmitLevel == SRT_ARQ_ALWAYS ? "FIND & REPORT LOSSES YOURSELF"
-                                                                   : "REPORT ONLY THOSE"));
+            // This is a scoped lock with AckLock, but for the moment
+            // when processClose() is called this lock must be taken out,
+            // otherwise this will cause a deadlock. We don't need this
+            // lock anymore, and at 'return' it will be unlocked anyway.
+            recvbuf_acklock.unlock();
+            processClose();
+
+            return -1;
         }
-        else
+
+        if (res == -1)
         {
-            // Stuff in just one packet that has come in.
-            incoming.push_back(in_unit);
+            return -1;
         }
 
-        bool excessive = true; // stays true unless it was successfully added
-
-        // Needed for possibly check for needsQuickACK.
-        bool incoming_belated = (CSeqNo::seqcmp(in_unit->m_Packet.m_iSeqNo, m_iRcvLastSkipAck) < 0);
-
-        // Loop over all incoming packets that were filtered out.
-        // In case when there is no filter, there's just one packet in 'incoming',
-        // the one that came in the input of this function.
-        for (vector<CUnit *>::iterator i = incoming.begin(); i != incoming.end(); ++i)
+        if (!srt_loss_seqs.empty())
         {
-            CUnit *  u    = *i;
-            CPacket &rpkt = u->m_Packet;
-
-            // m_iRcvLastSkipAck is the base sequence number for the receiver buffer.
-            // This is the offset in the buffer; if this is negative, it means that
-            // this sequence is already in the past and the buffer is not interested.
-            // Meaning, this packet will be rejected, even if it could potentially be
-            // one of missing packets in the transmission.
-            int32_t offset = CSeqNo::seqoff(m_iRcvLastSkipAck, rpkt.m_iSeqNo);
-
-            IF_HEAVY_LOGGING(const char *exc_type = "EXPECTED");
-
-            if (offset < 0)
-            {
-                IF_HEAVY_LOGGING(exc_type = "BELATED");
-                steady_clock::time_point tsbpdtime = m_pRcvBuffer->getPktTsbPdTime(rpkt.getMsgTimeStamp());
-                long bltime = CountIIR<uint64_t>(
-                        uint64_t(m_stats.traceBelatedTime) * 1000,
-                        count_microseconds(steady_clock::now() - tsbpdtime), 0.2);
-
-                enterCS(m_StatsLock);
-                m_stats.traceBelatedTime = double(bltime) / 1000.0;
-                m_stats.traceRcvBelated++;
-                leaveCS(m_StatsLock);
-                HLOGC(qrlog.Debug,
-                      log << CONID() << "RECEIVED: seq=" << packet.m_iSeqNo << " offset=" << offset << " (BELATED/"
-                          << rexmitstat[pktrexmitflag] << rexmit_reason << ") FLAGS: " << packet.MessageFlagStr());
-                continue;
-            }
-
-            const int avail_bufsize = m_pRcvBuffer->getAvailBufSize();
-            if (offset >= avail_bufsize)
-            {
-                // This is already a sequence discrepancy. Probably there could be found
-                // some way to make it continue reception by overriding the sequence and
-                // make a kinda TLKPTDROP, but there has been found no reliable way to do this.
-                if (m_bTsbPd && m_bTLPktDrop && m_pRcvBuffer->empty())
-                {
-                    // Only in live mode. In File mode this shall not be possible
-                    // because the sender should stop sending in this situation.
-                    // In Live mode this means that there is a gap between the
-                    // lowest sequence in the empty buffer and the incoming sequence
-                    // that exceeds the buffer size. Receiving data in this situation
-                    // is no longer possible and this is a point of no return.
-
-                    LOGC(qrlog.Error, log << CONID() <<
-                            "SEQUENCE DISCREPANCY. BREAKING CONNECTION."
-                            " seq=" << rpkt.m_iSeqNo
-                            << " buffer=(" << m_iRcvLastSkipAck
-                            << ":" << m_iRcvCurrSeqNo                   // -1 = size to last index
-                            << "+" << CSeqNo::incseq(m_iRcvLastSkipAck, m_pRcvBuffer->capacity()-1)
-                            << "), " << (offset-avail_bufsize+1)
-                            << " past max. Reception no longer possible. REQUESTING TO CLOSE.");
-
-                    // This is a scoped lock with AckLock, but for the moment
-                    // when processClose() is called this lock must be taken out,
-                    // otherwise this will cause a deadlock. We don't need this
-                    // lock anymore, and at 'return' it will be unlocked anyway.
-                    recvbuf_acklock.unlock();
-                    processClose();
-                    return -1;
-                }
-                else
-                {
-                    LOGC(qrlog.Warn, log << CONID() << "No room to store incoming packet: offset="
-                            << offset << " avail=" << avail_bufsize
-                            << " ack.seq=" << m_iRcvLastSkipAck << " pkt.seq=" << rpkt.m_iSeqNo
-                            << " rcv-remain=" << m_pRcvBuffer->debugGetSize()
-                            << " drift=" << m_pRcvBuffer->getDrift()
-                        );
-                    return -1;
-                }
-            }
-
-            bool adding_successful = true;
-            if (m_pRcvBuffer->addData(*i, offset) < 0)
-            {
-                // addData returns -1 if at the m_iLastAckPos+offset position there already is a packet.
-                // So this packet is "redundant".
-                IF_HEAVY_LOGGING(exc_type = "UNACKED");
-                adding_successful = false;
-            }
-            else
-            {
-                IF_HEAVY_LOGGING(exc_type = "ACCEPTED");
-                excessive = false;
-                if (u->m_Packet.getMsgCryptoFlags())
-                {
-                    EncryptionStatus rc = m_pCryptoControl ? m_pCryptoControl->decrypt((u->m_Packet)) : ENCS_NOTSUP;
-                    if (rc != ENCS_CLEAR)
-                    {
-                        // Could not decrypt
-                        // Keep packet in received buffer
-                        // Crypto flags are still set
-                        // It will be acknowledged
-                        {
-                            ScopedLock lg(m_StatsLock);
-                            m_stats.traceRcvUndecrypt += 1;
-                            m_stats.traceRcvBytesUndecrypt += pktsz;
-                            m_stats.m_rcvUndecryptTotal += 1;
-                            m_stats.m_rcvBytesUndecryptTotal += pktsz;
-                        }
-
-                        // Log message degraded to debug because it may happen very often
-                        HLOGC(qrlog.Debug, log << CONID() << "ERROR: packet not decrypted, dropping data.");
-                        adding_successful = false;
-                        IF_HEAVY_LOGGING(exc_type = "UNDECRYPTED");
-                    }
-                }
-            }
-
-            if (adding_successful)
-            {
-                ScopedLock statslock(m_StatsLock);
-                ++m_stats.traceRecvUniq;
-                ++m_stats.recvUniqTotal;
-                m_stats.traceBytesRecvUniq += u->m_Packet.getLength();
-                m_stats.bytesRecvUniqTotal += u->m_Packet.getLength();
-            }
-
-#if ENABLE_HEAVY_LOGGING
-            std::ostringstream timebufspec;
-            if (m_bTsbPd)
-            {
-                int dsize = m_pRcvBuffer->getRcvDataSize();
-                timebufspec << "(" << FormatTime(m_pRcvBuffer->debugGetDeliveryTime(0))
-                    << "-" << FormatTime(m_pRcvBuffer->debugGetDeliveryTime(dsize-1)) << ")";
-            }
+            ScopedLock lock(m_RcvLossLock);
 
-            std::ostringstream expectspec;
-            if (excessive)
-                expectspec << "EXCESSIVE(" << exc_type << rexmit_reason << ")";
-            else
-                expectspec << "ACCEPTED";
-
-            LOGC(qrlog.Debug, log << CONID() << "RECEIVED: seq=" << rpkt.m_iSeqNo
-                    << " offset=" << offset
-                    << " BUFr=" << avail_bufsize
-                    << " avail=" << m_pRcvBuffer->getAvailBufSize()
-                    << " buffer=(" << m_iRcvLastSkipAck
-                    << ":" << m_iRcvCurrSeqNo                   // -1 = size to last index
-                    << "+" << CSeqNo::incseq(m_iRcvLastSkipAck, m_pRcvBuffer->capacity()-1)
-                    << ") "
-                    << " RSL=" << expectspec.str()
-                    << " SN=" << rexmitstat[pktrexmitflag]
-                    << " DLVTM=" << timebufspec.str()
-                    << " FLAGS: "
-                    << rpkt.MessageFlagStr());
-#endif
+            HLOGC(qrlog.Debug,
+                  log << CONID() << "processData: RECORDING LOSS: " << Printable(srt_loss_seqs)
+                      << " tolerance=" << initial_loss_ttl);
 
-            // Decryption should have made the crypto flags EK_NOENC.
-            // Otherwise it's an error.
-            if (adding_successful)
+            for (loss_seqs_t::iterator i = srt_loss_seqs.begin(); i != srt_loss_seqs.end(); ++i)
             {
-                // XXX move this code do CUDT::defaultPacketArrival and call it from here:
-                // srt_loss_seqs = CALLBACK_CALL(m_cbPacketArrival, rpkt);
-
-                HLOGC(qrlog.Debug,
-                      log << "CONTIGUITY CHECK: sequence distance: " << CSeqNo::seqoff(m_iRcvCurrSeqNo, rpkt.m_iSeqNo));
-
-                if (need_notify_loss && CSeqNo::seqcmp(rpkt.m_iSeqNo, CSeqNo::incseq(m_iRcvCurrSeqNo)) > 0) // Loss detection.
+                m_pRcvLossList->insert(i->first, i->second);
+                if (initial_loss_ttl)
                 {
-                    int32_t seqlo = CSeqNo::incseq(m_iRcvCurrSeqNo);
-                    int32_t seqhi = CSeqNo::decseq(rpkt.m_iSeqNo);
-
-                    srt_loss_seqs.push_back(make_pair(seqlo, seqhi));
-
-                    if (initial_loss_ttl)
-                    {
-                        // pack loss list for (possibly belated) NAK
-                        // The LOSSREPORT will be sent in a while.
-
-                        for (loss_seqs_t::iterator i = srt_loss_seqs.begin(); i != srt_loss_seqs.end(); ++i)
-                        {
-                            m_FreshLoss.push_back(CRcvFreshLoss(i->first, i->second, initial_loss_ttl));
-                        }
-                        HLOGC(qrlog.Debug,
-                              log << "FreshLoss: added sequences: " << Printable(srt_loss_seqs)
-                                  << " tolerance: " << initial_loss_ttl);
-                        reorder_prevent_lossreport = true;
-                    }
+                    // The LOSSREPORT will be sent after initial_loss_ttl.
+                    m_FreshLoss.push_back(CRcvFreshLoss(i->first, i->second, initial_loss_ttl));
                 }
             }
-
-            // Update the current largest sequence number that has been received.
-            // Or it is a retransmitted packet, remove it from receiver loss list.
-            if (CSeqNo::seqcmp(rpkt.m_iSeqNo, m_iRcvCurrSeqNo) > 0)
-            {
-                m_iRcvCurrSeqNo = rpkt.m_iSeqNo; // Latest possible received
-            }
-            else
-            {
-                unlose(rpkt); // was BELATED or RETRANSMITTED
-                was_sent_in_order &= 0 != pktrexmitflag;
-            }
         }
 
         // This is moved earlier after introducing filter because it shouldn't
@@ -10117,11 +10591,11 @@ int CUDT::processData(CUnit* in_unit)
             // a given period).
             if (m_CongCtl->needsQuickACK(packet))
             {
-                m_tsNextACKTime = steady_clock::now();
+                m_tsNextACKTime.store(steady_clock::now());
             }
         }
 
-        if (excessive)
+        if (!new_inserted)
         {
             return -1;
         }
@@ -10147,37 +10621,21 @@ int CUDT::processData(CUnit* in_unit)
 
     if (!srt_loss_seqs.empty())
     {
-        // A loss is detected
-        {
-            // TODO: Can unlock rcvloss after m_pRcvLossList->insert(...)?
-            // And probably protect m_FreshLoss as well.
-
-            HLOGC(qrlog.Debug, log << "processData: LOSS DETECTED, %: " << Printable(srt_loss_seqs) << " - RECORDING.");
-            // if record_loss == false, nothing will be contained here
-            // Insert lost sequence numbers to the receiver loss list
-            ScopedLock lg(m_RcvLossLock);
-            for (loss_seqs_t::iterator i = srt_loss_seqs.begin(); i != srt_loss_seqs.end(); ++i)
-            {
-                // If loss found, insert them to the receiver loss list
-                m_pRcvLossList->insert(i->first, i->second);
-            }
-        }
-
         const bool report_recorded_loss = !m_PacketFilter || m_PktFilterRexmitLevel == SRT_ARQ_ALWAYS;
-        if (!reorder_prevent_lossreport && report_recorded_loss)
+        if (!initial_loss_ttl && report_recorded_loss)
         {
-            HLOGC(qrlog.Debug, log << "WILL REPORT LOSSES (SRT): " << Printable(srt_loss_seqs));
+            HLOGC(qrlog.Debug, log << CONID() << "WILL REPORT LOSSES (SRT): " << Printable(srt_loss_seqs));
             sendLossReport(srt_loss_seqs);
         }
 
         if (m_bTsbPd)
         {
-            HLOGC(qrlog.Debug, log << "loss: signaling TSBPD cond");
-            CSync::lock_signal(m_RcvTsbPdCond, m_RecvLock);
+            HLOGC(qrlog.Debug, log << CONID() << "loss: signaling TSBPD cond");
+            CSync::lock_notify_one(m_RcvTsbPdCond, m_RecvLock);
         }
         else
         {
-            HLOGC(qrlog.Debug, log << "loss: socket is not TSBPD, not signaling");
+            HLOGC(qrlog.Debug, log << CONID() << "loss: socket is not TSBPD, not signaling");
         }
     }
 
@@ -10188,13 +10646,13 @@ int CUDT::processData(CUnit* in_unit)
     // With NEVER, nothing is to be reported.
     if (!filter_loss_seqs.empty())
     {
-        HLOGC(qrlog.Debug, log << "WILL REPORT LOSSES (filter): " << Printable(filter_loss_seqs));
+        HLOGC(qrlog.Debug, log << CONID() << "WILL REPORT LOSSES (filter): " << Printable(filter_loss_seqs));
         sendLossReport(filter_loss_seqs);
 
         if (m_bTsbPd)
         {
-            HLOGC(qrlog.Debug, log << "loss: signaling TSBPD cond");
-            CSync::lock_signal(m_RcvTsbPdCond, m_RecvLock);
+            HLOGC(qrlog.Debug, log << CONID() << "loss: signaling TSBPD cond");
+            CSync::lock_notify_one(m_RcvTsbPdCond, m_RecvLock);
         }
     }
 
@@ -10232,11 +10690,8 @@ int CUDT::processData(CUnit* in_unit)
             // into two records.
             for (; i != m_FreshLoss.end() && i->ttl <= 0; ++i)
             {
-                HLOGF(qrlog.Debug,
-                      "Packet seq %d-%d (%d packets) considered lost - sending LOSSREPORT",
-                      i->seq[0],
-                      i->seq[1],
-                      CSeqNo::seqoff(i->seq[0], i->seq[1]) + 1);
+                HLOGC(qrlog.Debug, log << "Packet seq " << i->seq[0] << "-" << i->seq[1]
+                        << " (" << (CSeqNo::seqoff(i->seq[0], i->seq[1]) + 1) << " packets) considered lost - sending LOSSREPORT");
                 addLossRecord(lossdata, i->seq[0], i->seq[1]);
             }
 
@@ -10253,13 +10708,9 @@ int CUDT::processData(CUnit* in_unit)
             }
             else
             {
-                HLOGF(qrlog.Debug,
-                      "STILL %" PRIzu " FRESH LOSS RECORDS, FIRST: %d-%d (%d) TTL: %d",
-                      m_FreshLoss.size(),
-                      i->seq[0],
-                      i->seq[1],
-                      1 + CSeqNo::seqoff(i->seq[0], i->seq[1]),
-                      i->ttl);
+                HLOGC(qrlog.Debug, log << "STILL " << m_FreshLoss.size() << " FRESH LOSS RECORDS, FIRST: "
+                        << i->seq[0] << "-" << i->seq[1]
+                        << " (" << (1 + CSeqNo::seqoff(i->seq[0], i->seq[1])) << ") TTL: " << i->ttl);
             }
 
             // Phase 2: rest of the records should have TTL decreased.
@@ -10269,7 +10720,7 @@ int CUDT::processData(CUnit* in_unit)
     }
     if (!lossdata.empty())
     {
-        sendCtrl(UMSG_LOSSREPORT, NULL, &lossdata[0], lossdata.size());
+        sendCtrl(UMSG_LOSSREPORT, NULL, &lossdata[0], (int) lossdata.size());
     }
 
     // was_sent_in_order means either of:
@@ -10288,9 +10739,8 @@ int CUDT::processData(CUnit* in_unit)
                 enterCS(m_StatsLock);
                 m_stats.traceReorderDistance--;
                 leaveCS(m_StatsLock);
-                HLOGF(qrlog.Debug,
-                      "ORDERED DELIVERY of 50 packets in a row - decreasing tolerance to %d",
-                      m_iReorderTolerance);
+                HLOGC(qrlog.Debug, log << "ORDERED DELIVERY of 50 packets in a row - decreasing tolerance to "
+                        << m_iReorderTolerance);
             }
         }
     }
@@ -10298,9 +10748,23 @@ int CUDT::processData(CUnit* in_unit)
     return 0;
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-void CUDT::updateIdleLinkFrom(CUDT* source)
+#if ENABLE_BONDING
+
+// NOTE: this is updated from the value of m_iRcvLastAck,
+// which might be past the buffer and potentially cause setting
+// the value to the last received and re-requiring retransmission.
+// Worst case is that there could be a few packets to tear the transmission
+// even more (as there will be likely no time to recover them), but
+// if the transmission was already torn in the previously active link
+// this shouldn't be a problem that these packets won't be recovered
+// after activating the second link, although will be retried this way.
+void srt::CUDT::updateIdleLinkFrom(CUDT* source)
 {
+    int bufseq;
+    {
+        ScopedLock lg (m_RcvBufferLock);
+        bufseq = source->m_pRcvBuffer->getStartSeqNo();
+    }
     ScopedLock lg (m_RecvLock);
 
     if (!m_pRcvBuffer->empty())
@@ -10309,14 +10773,19 @@ void CUDT::updateIdleLinkFrom(CUDT* source)
         return;
     }
 
-    // XXX Try to optimize this. Note that here happens:
-    // - decseq just to have a value to compare directly
-    // - seqcmp with that value
-    // - if passed, in setInitialRcvSeq there's the same decseq again
-    int32_t new_last_rcv = CSeqNo::decseq(source->m_iRcvLastSkipAck);
+    int32_t new_last_rcv = source->m_iRcvLastAck;
+
+    if (CSeqNo::seqcmp(new_last_rcv, bufseq) < 0)
+    {
+        // Emergency check whether the last ACK was behind the
+        // buffer. This may happen when TSBPD dropped empty cells.
+        // This may cause that the newly activated link may derive
+        // these empty cells which will never be recovered.
+        new_last_rcv = bufseq;
+    }
 
-    // if (new_last_rcv <% m_iRcvCurrSeqNo)
-    if (CSeqNo::seqcmp(new_last_rcv, m_iRcvCurrSeqNo) < 0)
+    // if (new_last_rcv <=% m_iRcvCurrSeqNo)
+    if (CSeqNo::seqcmp(new_last_rcv, m_iRcvCurrSeqNo) <= 0)
     {
         // Reject the change because that would shift the reception pointer backwards.
         HLOGC(grlog.Debug, log << "grp: NOT updating rcv-seq in @" << m_SocketID
@@ -10326,71 +10795,10 @@ void CUDT::updateIdleLinkFrom(CUDT* source)
     }
 
     HLOGC(grlog.Debug, log << "grp: updating rcv-seq in @" << m_SocketID
-            << " from @" << source->m_SocketID << ": %" << source->m_iRcvLastSkipAck);
-    setInitialRcvSeq(source->m_iRcvLastSkipAck);
+            << " from @" << source->m_SocketID << ": %" << new_last_rcv);
+    setInitialRcvSeq(new_last_rcv);
 }
 
-// XXX This function is currently unused. It should be fixed and put into use.
-// See the blocked call in CUDT::processData().
-// XXX REVIEW LOCKS WHEN REACTIVATING!
-CUDT::loss_seqs_t CUDT::defaultPacketArrival(void* vself, CPacket& pkt)
-{
-// [[using affinity(m_pRcvBuffer->workerThread())]];
-    CUDT* self = (CUDT*)vself;
-    loss_seqs_t output;
-
-    // XXX When an alternative packet arrival callback is installed
-    // in case of groups, move this part to the groupwise version.
-
-    if (self->m_parent->m_IncludedGroup)
-    {
-        CUDTGroup::gli_t gi = self->m_parent->m_IncludedIter;
-        if (gi->rcvstate < SRT_GST_RUNNING) // PENDING or IDLE, tho PENDING is unlikely
-        {
-            HLOGC(qrlog.Debug, log << "defaultPacketArrival: IN-GROUP rcv state transition to RUNNING. NOT checking for loss");
-            gi->rcvstate = SRT_GST_RUNNING;
-            return output;
-        }
-    }
-
-    const int initial_loss_ttl = (self->m_bPeerRexmitFlag) ? self->m_iReorderTolerance : 0;
-
-    int seqdiff = CSeqNo::seqcmp(pkt.m_iSeqNo, self->m_iRcvCurrSeqNo);
-
-    HLOGC(qrlog.Debug, log << "defaultPacketArrival: checking sequence " << pkt.m_iSeqNo
-            << " against latest " << self->m_iRcvCurrSeqNo << " (distance: " << seqdiff << ")");
-
-    // Loss detection.
-    if (seqdiff > 1) // packet is later than the very subsequent packet
-    {
-        const int32_t seqlo = CSeqNo::incseq(self->m_iRcvCurrSeqNo);
-        const int32_t seqhi = CSeqNo::decseq(pkt.m_iSeqNo);
-
-        {
-            // If loss found, insert them to the receiver loss list
-            ScopedLock lg (self->m_RcvLossLock);
-            self->m_pRcvLossList->insert(seqlo, seqhi);
-
-            if (initial_loss_ttl)
-            {
-                // pack loss list for (possibly belated) NAK
-                // The LOSSREPORT will be sent in a while.
-                self->m_FreshLoss.push_back(CRcvFreshLoss(seqlo, seqhi, initial_loss_ttl));
-                HLOGF(qrlog.Debug, "defaultPacketArrival: added loss sequence %d-%d (%d) with tolerance %d", seqlo, seqhi,
-                        1+CSeqNo::seqcmp(seqhi, seqlo), initial_loss_ttl);
-            }
-        }
-
-        if (!initial_loss_ttl)
-        {
-            // old code; run immediately when tolerance = 0
-            // or this feature isn't used because of the peer
-            output.push_back(make_pair(seqlo, seqhi));
-        }
-    }
-
-    return output;
-}
 #endif
 
 /// This function is called when a packet has arrived, which was behind the current
@@ -10406,12 +10814,12 @@ CUDT::loss_seqs_t CUDT::defaultPacketArrival(void* vself, CPacket& pkt)
 /// will be set to the tolerance value, which means that later packet retransmission
 /// will not be required immediately, but only after receiving N next packets that
 /// do not include the lacking packet.
-/// The tolerance is not increased infinitely - it's bordered by m_iMaxReorderTolerance.
+/// The tolerance is not increased infinitely - it's bordered by iMaxReorderTolerance.
 /// This value can be set in options - SRT_LOSSMAXTTL.
-void CUDT::unlose(const CPacket &packet)
+void srt::CUDT::unlose(const CPacket &packet)
 {
     ScopedLock lg(m_RcvLossLock);
-    int32_t sequence = packet.m_iSeqNo;
+    int32_t sequence = packet.seqno();
     m_pRcvLossList->remove(sequence);
 
     // Rest of this code concerns only the "belated lossreport" feature.
@@ -10429,20 +10837,17 @@ void CUDT::unlose(const CPacket &packet)
         was_reordered = !packet.getRexmitFlag();
         if (was_reordered)
         {
-            HLOGF(qrlog.Debug, "received out-of-band packet seq %d", sequence);
+            HLOGC(qrlog.Debug, log << "received out-of-band packet %" << sequence);
 
-            const int seqdiff = abs(CSeqNo::seqcmp(m_iRcvCurrSeqNo, packet.m_iSeqNo));
+            const int seqdiff = abs(CSeqNo::seqcmp(m_iRcvCurrSeqNo, packet.seqno()));
             enterCS(m_StatsLock);
             m_stats.traceReorderDistance = max(seqdiff, m_stats.traceReorderDistance);
             leaveCS(m_StatsLock);
             if (seqdiff > m_iReorderTolerance)
             {
-                const int new_tolerance = min(seqdiff, m_iMaxReorderTolerance);
-                HLOGF(qrlog.Debug,
-                      "Belated by %d seqs - Reorder tolerance %s %d",
-                      seqdiff,
-                      (new_tolerance == m_iReorderTolerance) ? "REMAINS with" : "increased to",
-                      new_tolerance);
+                const int new_tolerance = min(seqdiff, m_config.iMaxReorderTolerance);
+                HLOGC(qrlog.Debug, log << "Belated by " << seqdiff << " seqs - Reorder tolerance "
+                        << (new_tolerance == m_iReorderTolerance ? "REMAINS with " : "increased to ") << new_tolerance);
                 m_iReorderTolerance = new_tolerance;
                 has_increased_tolerance =
                     true; // Yes, even if reorder tolerance is already at maximum - this prevents decreasing tolerance.
@@ -10455,7 +10860,7 @@ void CUDT::unlose(const CPacket &packet)
     }
     else
     {
-        HLOGF(qrlog.Debug, "received reXmitted or belated packet seq %d (distinction not supported by peer)", sequence);
+        HLOGC(qrlog.Debug, log << "received reXmitted or belated packet seq " << sequence << " (distinction not supported by peer)");
     }
 
     // Don't do anything if "belated loss report" feature is not used.
@@ -10469,55 +10874,10 @@ void CUDT::unlose(const CPacket &packet)
     if (m_bPeerRexmitFlag == 0 || m_iReorderTolerance == 0)
         return;
 
-    size_t i       = 0;
-    int    had_ttl = 0;
-    for (i = 0; i < m_FreshLoss.size(); ++i)
-    {
-        had_ttl = m_FreshLoss[i].ttl;
-        switch (m_FreshLoss[i].revoke(sequence))
-        {
-        case CRcvFreshLoss::NONE:
-            continue; // Not found. Search again.
-
-        case CRcvFreshLoss::STRIPPED:
-            goto breakbreak; // Found and the modification is applied. We're done here.
-
-        case CRcvFreshLoss::DELETE:
-            // No more elements. Kill it.
-            m_FreshLoss.erase(m_FreshLoss.begin() + i);
-            // Every loss is unique. We're done here.
-            goto breakbreak;
-
-        case CRcvFreshLoss::SPLIT:
-            // Oh, this will be more complicated. This means that it was in between.
-            {
-                // So create a new element that will hold the upper part of the range,
-                // and this one modify to be the lower part of the range.
-
-                // Keep the current end-of-sequence value for the second element
-                int32_t next_end = m_FreshLoss[i].seq[1];
-
-                // seq-1 set to the end of this element
-                m_FreshLoss[i].seq[1] = CSeqNo::decseq(sequence);
-                // seq+1 set to the begin of the next element
-                int32_t next_begin = CSeqNo::incseq(sequence);
-
-                // Use position of the NEXT element because insertion happens BEFORE pointed element.
-                // Use the same TTL (will stay the same in the other one).
-                m_FreshLoss.insert(m_FreshLoss.begin() + i + 1,
-                                   CRcvFreshLoss(next_begin, next_end, m_FreshLoss[i].ttl));
-            }
-            goto breakbreak;
-        }
-    }
-
-    // Could have made the "return" instruction instead of goto, but maybe there will be something
-    // to add in future, so keeping that.
-breakbreak:;
-
-    if (i != m_FreshLoss.size())
+    int had_ttl = 0;
+    if (CRcvFreshLoss::removeOne((m_FreshLoss), sequence, (&had_ttl)))
     {
-        HLOGF(qrlog.Debug, "sequence %d removed from belated lossreport record", sequence);
+        HLOGC(qrlog.Debug, log << "sequence " << sequence << " removed from belated lossreport record");
     }
 
     if (was_reordered)
@@ -10530,7 +10890,7 @@ breakbreak:;
         else if (had_ttl > 2)
         {
             ++m_iConsecEarlyDelivery; // otherwise, and if it arrived quite earlier, increase counter
-            HLOGF(qrlog.Debug, "... arrived at TTL %d case %d", had_ttl, m_iConsecEarlyDelivery);
+            HLOGC(qrlog.Debug, log << "... arrived at TTL " << had_ttl << " case " << m_iConsecEarlyDelivery);
 
             // After 10 consecutive
             if (m_iConsecEarlyDelivery >= 10)
@@ -10542,10 +10902,8 @@ breakbreak:;
                     enterCS(m_StatsLock);
                     m_stats.traceReorderDistance--;
                     leaveCS(m_StatsLock);
-                    HLOGF(qrlog.Debug,
-                          "... reached %d times - decreasing tolerance to %d",
-                          m_iConsecEarlyDelivery,
-                          m_iReorderTolerance);
+                    HLOGC(qrlog.Debug, log << "... reached " << m_iConsecEarlyDelivery
+                            << " times - decreasing tolerance to " << m_iReorderTolerance);
                 }
             }
         }
@@ -10553,12 +10911,50 @@ breakbreak:;
     }
 }
 
-void CUDT::dropFromLossLists(int32_t from, int32_t to)
+void srt::CUDT::dropFromLossLists(int32_t from, int32_t to)
 {
     ScopedLock lg(m_RcvLossLock);
-    m_pRcvLossList->remove(from, to);
 
-    HLOGF(qrlog.Debug, "%sTLPKTDROP seq %d-%d (%d packets)", CONID().c_str(), from, to, CSeqNo::seqoff(from, to));
+    IF_HEAVY_LOGGING(bool autodetected = false);
+    int32_t begin SRT_ATR_UNUSED;
+    if (from == SRT_SEQNO_NONE)
+    {
+        begin = m_pRcvLossList->removeUpTo(to);
+        IF_HEAVY_LOGGING(autodetected = true);
+    }
+    else
+    {
+        begin = from;
+        m_pRcvLossList->remove(from, to);
+    }
+
+#if ENABLE_HEAVY_LOGGING
+    ostringstream range;
+    if (begin == SRT_SEQNO_NONE)
+    {
+        range << "no";
+    }
+    else
+    {
+        int off = CSeqNo::seqoff(begin, to);
+        if (off < 0)
+        {
+            range << "WEIRD NUMBER OF";
+        }
+        else
+        {
+            range << (off + 1);
+        }
+    }
+
+    static const char* const beginwhere[2] = {"explicit", "detected"};
+
+    const char* const reqtype = (from == SRT_SEQNO_NONE) ? "TLPKTDROP" : "DROPREQ";
+
+    HLOGC(qrlog.Debug, log << CONID() << "DROP PER " << reqtype << " %" << begin
+            << "[" << beginwhere[1*autodetected] << "]-" << to << " ("
+            << range.str() << " packets)");
+#endif
 
     if (m_bPeerRexmitFlag == 0 || m_iReorderTolerance == 0)
         return;
@@ -10596,7 +10992,7 @@ void CUDT::dropFromLossLists(int32_t from, int32_t to)
 }
 
 // This function, as the name states, should bake a new cookie.
-int32_t CUDT::bake(const sockaddr_any& addr, int32_t current_cookie, int correction)
+int32_t srt::CUDT::bake(const sockaddr_any& addr, int32_t current_cookie, int correction)
 {
     static unsigned int distractor = 0;
     unsigned int        rollover   = distractor + 10;
@@ -10613,7 +11009,7 @@ int32_t CUDT::bake(const sockaddr_any& addr, int32_t current_cookie, int correct
                     clientport,
                     sizeof(clientport),
                     NI_NUMERICHOST | NI_NUMERICSERV);
-        int64_t timestamp = (count_microseconds(steady_clock::now() - m_stats.tsStartTime) / 60000000) + distractor -
+        int64_t timestamp = (count_microseconds(steady_clock::now() - m_stats.tsStartTime) / 60000000) + distractor +
                             correction; // secret changes every one minute
         stringstream cookiestr;
         cookiestr << clienthost << ":" << clientport << ":" << timestamp;
@@ -10655,17 +11051,17 @@ int32_t CUDT::bake(const sockaddr_any& addr, int32_t current_cookie, int correct
 // and this will be directly passed to the caller.
 
 // [[using locked(m_pRcvQueue->m_LSLock)]];
-int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
+int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
 {
     // XXX ASSUMPTIONS:
-    // [[using assert(packet.m_iID == 0)]]
+    // [[using assert(packet.id() == 0)]]
 
-    HLOGC(cnlog.Debug, log << "processConnectRequest: received a connection request");
+    HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: received a connection request");
 
     if (m_bClosing)
     {
         m_RejectReason = SRT_REJ_CLOSE;
-        HLOGC(cnlog.Debug, log << "processConnectRequest: ... NOT. Rejecting because closing.");
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ... NOT. Rejecting because closing.");
         return m_RejectReason;
     }
 
@@ -10677,11 +11073,11 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
     if (m_bBroken)
     {
         m_RejectReason = SRT_REJ_CLOSE;
-        HLOGC(cnlog.Debug, log << "processConnectRequest: ... NOT. Rejecting because broken.");
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ... NOT. Rejecting because broken.");
         return m_RejectReason;
     }
-    size_t exp_len =
-        CHandShake::m_iContentSize; // When CHandShake::m_iContentSize is used in log, the file fails to link!
+    // When CHandShake::m_iContentSize is used in log, the file fails to link!
+    size_t exp_len = CHandShake::m_iContentSize;
 
     // NOTE!!! Old version of SRT code checks if the size of the HS packet
     // is EQUAL to the above CHandShake::m_iContentSize.
@@ -10693,8 +11089,8 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
     {
         m_RejectReason = SRT_REJ_ROGUE;
         HLOGC(cnlog.Debug,
-              log << "processConnectRequest: ... NOT. Wrong size: " << packet.getLength() << " (expected: " << exp_len
-                  << ")");
+              log << CONID() << "processConnectRequest: ... NOT. Wrong size: " << packet.getLength()
+                  << " (expected: " << exp_len << ")");
         return m_RejectReason;
     }
 
@@ -10704,7 +11100,8 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
     if (!packet.isControl(UMSG_HANDSHAKE))
     {
         m_RejectReason = SRT_REJ_ROGUE;
-        LOGC(cnlog.Error, log << "processConnectRequest: the packet received as handshake is not a handshake message");
+        LOGC(cnlog.Error,
+             log << CONID() << "processConnectRequest: the packet received as handshake is not a handshake message");
         return m_RejectReason;
     }
 
@@ -10722,14 +11119,22 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
 
     int32_t cookie_val = bake(addr);
 
-    HLOGC(cnlog.Debug, log << "processConnectRequest: new cookie: " << hex << cookie_val);
+    HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: new cookie: " << hex << cookie_val);
+
+    // Remember the incoming destination address here and use it as a source
+    // address when responding. It's not possible to record this address yet
+    // because this happens still in the frames of the listener socket. Only
+    // when processing switches to the newly spawned accepted socket can the
+    // address be recorded in its m_SourceAddr field.
+    sockaddr_any use_source_addr = packet.udpDestAddr();
 
     // REQUEST:INDUCTION.
     // Set a cookie, a target ID, and send back the same as
     // RESPONSE:INDUCTION.
     if (hs.m_iReqType == URQ_INDUCTION)
     {
-        HLOGC(cnlog.Debug, log << "processConnectRequest: received type=induction, sending back with cookie+socket");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "processConnectRequest: received type=induction, sending back with cookie+socket");
 
         // XXX That looks weird - the calculated md5 sum out of the given host/port/timestamp
         // is 16 bytes long, but CHandShake::m_iCookie has 4 bytes. This then effectively copies
@@ -10737,7 +11142,7 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         // array need not be aligned to int32_t - changed to union in a hope that using int32_t
         // inside a union will enforce whole union to be aligned to int32_t.
         hs.m_iCookie = cookie_val;
-        packet.m_iID = hs.m_iID;
+        packet.set_id(hs.m_iID);
 
         // Ok, now's the time. The listener sets here the version 5 handshake,
         // even though the request was 4. This is because the old client would
@@ -10755,20 +11160,20 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         // Additionally, set this field to a MAGIC value. This field isn't used during INDUCTION
         // by HSv4 client, HSv5 client can use it to additionally verify that this is a HSv5 listener.
         // In this field we also advertise the PBKEYLEN value. When 0, it's considered not advertised.
-        hs.m_iType = SrtHSRequest::wrapFlags(true /*put SRT_MAGIC_CODE in HSFLAGS*/, m_iSndCryptoKeyLen);
-        bool whether SRT_ATR_UNUSED = m_iSndCryptoKeyLen != 0;
+        hs.m_iType = SrtHSRequest::wrapFlags(true /*put SRT_MAGIC_CODE in HSFLAGS*/, m_config.iSndCryptoKeyLen);
+        bool whether SRT_ATR_UNUSED = m_config.iSndCryptoKeyLen != 0;
         HLOGC(cnlog.Debug,
-              log << "processConnectRequest: " << (whether ? "" : "NOT ")
-                  << " Advertising PBKEYLEN - value = " << m_iSndCryptoKeyLen);
+              log << CONID() << "processConnectRequest: " << (whether ? "" : "NOT ")
+                  << " Advertising PBKEYLEN - value = " << m_config.iSndCryptoKeyLen);
 
         size_t size = packet.getLength();
         hs.store_to((packet.m_pcData), (size));
         setPacketTS(packet, steady_clock::now());
 
         // Display the HS before sending it to peer
-        HLOGC(cnlog.Debug, log << "processConnectRequest: SENDING HS (i): " << hs.show());
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING HS (i): " << hs.show());
 
-        m_pSndQueue->sendto(addr, packet);
+        m_pSndQueue->sendto(addr, packet, use_source_addr);
         return SRT_REJ_UNKNOWN; // EXCEPTION: this is a "no-error" code.
     }
 
@@ -10777,8 +11182,16 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
     // set in the above INDUCTION, in the HS_VERSION_SRT1
     // should also contain extra data.
 
+    if (!hs.valid())
+    {
+        LOGC(cnlog.Error, log << CONID() << "processConnectRequest: ROGUE HS RECEIVED. Rejecting");
+        m_RejectReason = SRT_REJ_ROGUE;
+        return SRT_REJ_ROGUE;
+    }
+
     HLOGC(cnlog.Debug,
-          log << "processConnectRequest: received type=" << RequestTypeStr(hs.m_iReqType) << " - checking cookie...");
+          log << CONID() << "processConnectRequest: received type=" << RequestTypeStr(hs.m_iReqType)
+              << " - checking cookie...");
     if (hs.m_iCookie != cookie_val)
     {
         cookie_val = bake(addr, cookie_val, -1); // SHOULD generate an earlier, distracted cookie
@@ -10786,18 +11199,18 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         if (hs.m_iCookie != cookie_val)
         {
             m_RejectReason = SRT_REJ_RDVCOOKIE;
-            HLOGC(cnlog.Debug, log << "processConnectRequest: ...wrong cookie " << hex << cookie_val << ". Ignoring.");
+            HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ...wrong cookie " << hex << cookie_val << ". Ignoring.");
             return m_RejectReason;
         }
 
-        HLOGC(cnlog.Debug, log << "processConnectRequest: ... correct (FIXED) cookie. Proceeding.");
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ... correct (FIXED) cookie. Proceeding.");
     }
     else
     {
-        HLOGC(cnlog.Debug, log << "processConnectRequest: ... correct (ORIGINAL) cookie. Proceeding.");
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ... correct (ORIGINAL) cookie. Proceeding.");
     }
 
-    int32_t id = hs.m_iID;
+    SRTSOCKET id = hs.m_iID;
 
     // HANDSHAKE: The old client sees the version that does not match HS_VERSION_UDT4 (5).
     // In this case it will respond with URQ_ERROR_REJECT. Rest of the data are the same
@@ -10839,22 +11252,27 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
     if (!accepted_hs)
     {
         HLOGC(cnlog.Debug,
-              log << "processConnectRequest: version/type mismatch. Sending REJECT code:" << m_RejectReason
-              << " MSG: " << srt_rejectreason_str(m_RejectReason));
+              log << CONID() << "processConnectRequest: version/type mismatch. Sending REJECT code:" << m_RejectReason
+                  << " MSG: " << srt_rejectreason_str(m_RejectReason));
         // mismatch, reject the request
         hs.m_iReqType = URQFailure(m_RejectReason);
         size_t size   = CHandShake::m_iContentSize;
         hs.store_to((packet.m_pcData), (size));
-        packet.m_iID        = id;
-        setPacketTS(packet, steady_clock::now());
-        HLOGC(cnlog.Debug, log << "processConnectRequest: SENDING HS (e): " << hs.show());
-        m_pSndQueue->sendto(addr, packet);
+        packet.set_id(id);
+        setPacketTS((packet), steady_clock::now());
+        HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING HS (e): " << hs.show());
+        m_pSndQueue->sendto(addr, packet, use_source_addr);
     }
     else
     {
+        // IMPORTANT!!!
+        // If the newConnection() detects there is already a socket connection associated with the remote peer,
+        // it returns the socket via `acpu`, and the `result` returned is 0.
+        // Else if a new connection is successfully created, the conclusion handshake response
+        // is sent by the function itself (it calls the acceptAndRespond(..)), the `acpu` remains null, the `result` is 1.
         int error  = SRT_REJ_UNKNOWN;
         CUDT* acpu = NULL;
-        int result = s_UDTUnited.newConnection(m_SocketID, addr, packet, (hs), (error), (acpu));
+        int result = uglobal().newConnection(m_SocketID, addr, packet, (hs), (error), (acpu));
 
         // This is listener - m_RejectReason need not be set
         // because listener has no functionality of giving the app
@@ -10866,44 +11284,14 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         if (result == -1)
         {
             hs.m_iReqType = URQFailure(error);
-            LOGF(cnlog.Warn, "processConnectRequest: rsp(REJECT): %d - %s", hs.m_iReqType, srt_rejectreason_str(error));
+            LOGC(cnlog.Warn, log << "processConnectRequest: rsp(REJECT): " << hs.m_iReqType << " - " << srt_rejectreason_str(error));
         }
 
-        // CONFUSION WARNING!
-        //
-        // The newConnection() will call acceptAndRespond() if the processing
-        // was successful - IN WHICH CASE THIS PROCEDURE SHOULD DO NOTHING.
-        // Ok, almost nothing - see update_events below.
-        //
-        // If newConnection() failed, acceptAndRespond() will not be called.
-        // Ok, more precisely, the thing that acceptAndRespond() is expected to do
-        // will not be done (this includes sending any response to the peer).
-        //
-        // Now read CAREFULLY. The newConnection() will return:
-        //
-        // - -1: The connection processing failed due to errors like:
-        //       - memory alloation error
-        //       - listen backlog exceeded
-        //       - any error propagated from CUDT::open and CUDT::acceptAndRespond
-        // - 0: The connection already exists
-        // - 1: Connection accepted.
-        //
-        // So, update_events is called only if the connection is established.
-        // Both 0 (repeated) and -1 (error) require that a response be sent.
-        // The CPacket object that has arrived as a connection request is here
-        // reused for the connection rejection response (see URQ_ERROR_REJECT set
-        // as m_iReqType).
-
-        // The 'acpu' should be set to a new socket, if found;
-        // this means simultaneously that result == 0, but it's safest to
-        // check this condition only. This means that 'newConnection' found
-        // that the connection attempt has already been accepted, just the
-        // caller side somehow didn't get the answer. The rule is that every
-        // connection request HS must be completed with a symmetric HS response,
-        // so craft one here.
-
-        // Note that this function runs in the listener socket context, while 'acpu'
-        // is the CUDT entity for the accepted socket.
+        // The `acpu` not NULL means connection exists, the `result` should be 0. It is not checked here though.
+        // The `newConnection(..)` only sends response for newly created connection.
+        // The connection already exists (no new connection has been created, no response sent).
+        // Send the conclusion response manually here in case the peer has missed the first one.
+        // The value  `result` here should be 0.
         if (acpu)
         {
             // This is an existing connection, so the handshake is only needed
@@ -10942,52 +11330,70 @@ int CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
                         (packet), (hs)))
             {
                 HLOGC(cnlog.Debug,
-                        log << "processConnectRequest: rejecting due to problems in createSrtHandshake.");
-                result = -1; // enforce fallthrough for the below condition!
-                hs.m_iReqType = URQFailure(m_RejectReason == SRT_REJ_UNKNOWN ? SRT_REJ_IPE : m_RejectReason);
+                      log << CONID() << "processConnectRequest: rejecting due to problems in createSrtHandshake.");
+                result        = -1; // enforce fallthrough for the below condition!
+                hs.m_iReqType = URQFailure(m_RejectReason == SRT_REJ_UNKNOWN ? int(SRT_REJ_IPE) : m_RejectReason.load());
             }
             else
             {
                 // Send the crafted handshake
-                HLOGC(cnlog.Debug, log << "processConnectRequest: SENDING (repeated) HS (a): " << hs.show());
+                HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING (repeated) HS (a): " << hs.show());
                 acpu->addressAndSend((packet));
             }
         }
 
-        // send back a response if connection failed or connection already existed
-        // (or the above procedure failed)
-        if (result == -1)
+        if (result == 1)
         {
+            // BUG! There is no need to update write-readiness on the listener socket once new connection is accepted.
+            // Only read-readiness has to be updated, but it is done so in the newConnection(..) function.
+            // See PR #1831 and issue #1667.
             HLOGC(cnlog.Debug,
-                  log << CONID() << "processConnectRequest: sending ABNORMAL handshake info req="
-                      << RequestTypeStr(hs.m_iReqType));
-            size_t size = CHandShake::m_iContentSize;
-            hs.store_to((packet.m_pcData), (size));
-            packet.setLength(size);
-            packet.m_iID        = id;
-            setPacketTS(packet, steady_clock::now());
-            HLOGC(cnlog.Debug, log << "processConnectRequest: SENDING HS (a): " << hs.show());
-            m_pSndQueue->sendto(addr, packet);
-        }
-        // new connection response should be sent in acceptAndRespond()
-        // turn the socket writable if this is the first time when this was found out.
-        else
-        {
-            // a new connection has been created, enable epoll for write
-           HLOGC(cnlog.Debug, log << "processConnectRequest: @" << m_SocketID
-                   << " connected, setting epoll to connect:");
+                  log << CONID() << "processConnectRequest: accepted connection, updating epoll to write-ready");
 
-           // Note: not using SRT_EPOLL_CONNECT symbol because this is a procedure
-           // executed for the accepted socket.
-           s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
+            // New connection has been accepted or an existing one has been found. Update epoll write-readiness.
+            // a new connection has been created, enable epoll for write
+            // Note: not using SRT_EPOLL_CONNECT symbol because this is a procedure
+            // executed for the accepted socket.
+            uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
+        }
+        else if (result == -1)
+        {
+            // The new connection failed
+            // or the connection already existed, but manually sending the HS response above has failed.
+            // HSv4: Send the SHUTDOWN message to the peer (see PR #2010) in order to disallow the peer to connect.
+            //       The HSv4 clients do not interpret the error handshake response correctly.
+            // HSv5: Send a handshake with an error code (hs.m_iReqType set earlier) to the peer.
+            if (hs.m_iVersion < HS_VERSION_SRT1)
+            {
+                HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: HSv4 caller, sending SHUTDOWN after rejection with "
+                        << RequestTypeStr(hs.m_iReqType));
+                CPacket rsp;
+                setPacketTS((rsp), steady_clock::now());
+                rsp.pack(UMSG_SHUTDOWN);
+                rsp.set_id(m_PeerID);
+                m_pSndQueue->sendto(addr, rsp, use_source_addr);
+            }
+            else
+            {
+                HLOGC(cnlog.Debug,
+                        log << CONID() << "processConnectRequest: sending ABNORMAL handshake info req="
+                        << RequestTypeStr(hs.m_iReqType));
+                size_t size = CHandShake::m_iContentSize;
+                hs.store_to((packet.m_pcData), (size));
+                packet.setLength(size);
+                packet.set_id(id);
+                setPacketTS(packet, steady_clock::now());
+                HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING HS (a): " << hs.show());
+                m_pSndQueue->sendto(addr, packet, use_source_addr);
+            }
         }
     }
-    LOGC(cnlog.Note, log << "listen ret: " << hs.m_iReqType << " - " << RequestTypeStr(hs.m_iReqType));
+    LOGC(cnlog.Debug, log << CONID() << "listen ret: " << hs.m_iReqType << " - " << RequestTypeStr(hs.m_iReqType));
 
     return RejectReasonForURQ(hs.m_iReqType);
 }
 
-void CUDT::addLossRecord(std::vector<int32_t> &lr, int32_t lo, int32_t hi)
+void srt::CUDT::addLossRecord(std::vector<int32_t> &lr, int32_t lo, int32_t hi)
 {
     if (lo == hi)
         lr.push_back(lo);
@@ -10998,10 +11404,10 @@ void CUDT::addLossRecord(std::vector<int32_t> &lr, int32_t lo, int32_t hi)
     }
 }
 
-int CUDT::checkACKTimer(const steady_clock::time_point &currtime)
+int srt::CUDT::checkACKTimer(const steady_clock::time_point &currtime)
 {
     int because_decision = BECAUSE_NO_REASON;
-    if (currtime > m_tsNextACKTime  // ACK time has come
+    if (currtime > m_tsNextACKTime.load()  // ACK time has come
                                   // OR the number of sent packets since last ACK has reached
                                   // the congctl-defined value of ACK Interval
                                   // (note that none of the builtin congctls defines ACK Interval)
@@ -11013,7 +11419,7 @@ int CUDT::checkACKTimer(const steady_clock::time_point &currtime)
         const steady_clock::duration ack_interval = m_CongCtl->ACKTimeout_us() > 0
             ? microseconds_from(m_CongCtl->ACKTimeout_us())
             : m_tdACKInterval;
-        m_tsNextACKTime = currtime + ack_interval;
+        m_tsNextACKTime.store(currtime + ack_interval);
 
         m_iPktCount      = 0;
         m_iLightACKCount = 1;
@@ -11037,7 +11443,7 @@ int CUDT::checkACKTimer(const steady_clock::time_point &currtime)
     return because_decision;
 }
 
-int CUDT::checkNAKTimer(const steady_clock::time_point& currtime)
+int srt::CUDT::checkNAKTimer(const steady_clock::time_point& currtime)
 {
     // XXX The problem with working NAKREPORT with SRT_ARQ_ONREQ
     // is not that it would be inappropriate, but because it's not
@@ -11050,33 +11456,36 @@ int CUDT::checkNAKTimer(const steady_clock::time_point& currtime)
     // by the filter. By this reason they appear often out of order
     // and for adding them properly the loss list container wasn't
     // prepared. This then requires some more effort to implement.
-    if (!m_bRcvNakReport || m_PktFilterRexmitLevel != SRT_ARQ_ALWAYS)
+    if (!m_config.bRcvNakReport || m_PktFilterRexmitLevel != SRT_ARQ_ALWAYS)
         return BECAUSE_NO_REASON;
 
     /*
-     * m_bRcvNakReport enables NAK reports for SRT.
+     * m_config.bRcvNakReport enables NAK reports for SRT.
      * Retransmission based on timeout is bandwidth consuming,
      * not knowing what to retransmit when the only NAK sent by receiver is lost,
      * all packets past last ACK are retransmitted (rexmitMethod() == SRM_FASTREXMIT).
      */
+    enterCS(m_RcvLossLock);
     const int loss_len = m_pRcvLossList->getLossLength();
+    leaveCS(m_RcvLossLock);
+
     SRT_ASSERT(loss_len >= 0);
     int debug_decision = BECAUSE_NO_REASON;
 
     if (loss_len > 0)
     {
-        if (currtime <= m_tsNextNAKTime)
+        if (currtime <= m_tsNextNAKTime.load())
             return BECAUSE_NO_REASON; // wait for next NAK time
 
         sendCtrl(UMSG_LOSSREPORT);
         debug_decision = BECAUSE_NAKREPORT;
     }
 
-    m_tsNextNAKTime = currtime + m_tdNAKInterval;
+    m_tsNextNAKTime.store(currtime + m_tdNAKInterval);
     return debug_decision;
 }
 
-bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_reason ATR_UNUSED)
+bool srt::CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_reason SRT_ATR_UNUSED)
 {
     // VERY HEAVY LOGGING
 #if ENABLE_HEAVY_LOGGING & 1
@@ -11108,26 +11517,27 @@ bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_rea
     steady_clock::time_point next_exp_time;
     if (m_CongCtl->RTO())
     {
-        next_exp_time = m_tsLastRspTime + microseconds_from(m_CongCtl->RTO());
+        next_exp_time = m_tsLastRspTime.load() + microseconds_from(m_CongCtl->RTO());
     }
     else
     {
         steady_clock::duration exp_timeout =
-            microseconds_from(m_iEXPCount * (m_iRTT + 4 * m_iRTTVar) + COMM_SYN_INTERVAL_US);
+            microseconds_from(m_iEXPCount * (m_iSRTT + 4 * m_iRTTVar) + COMM_SYN_INTERVAL_US);
         if (exp_timeout < (m_iEXPCount * m_tdMinExpInterval))
             exp_timeout = m_iEXPCount * m_tdMinExpInterval;
-        next_exp_time = m_tsLastRspTime + exp_timeout;
+        next_exp_time = m_tsLastRspTime.load() + exp_timeout;
     }
 
-    if (currtime <= next_exp_time)
+    if (currtime <= next_exp_time && !m_bBreakAsUnstable)
         return false;
 
     // ms -> us
-    const int PEER_IDLE_TMO_US = m_iOPT_PeerIdleTimeout * 1000;
+    const int PEER_IDLE_TMO_US = m_config.iPeerIdleTimeout_ms * 1000;
     // Haven't received any information from the peer, is it dead?!
     // timeout: at least 16 expirations and must be greater than 5 seconds
-    if ((m_iEXPCount > COMM_RESPONSE_MAX_EXP) &&
-        (currtime - m_tsLastRspTime > microseconds_from(PEER_IDLE_TMO_US)))
+    time_point last_rsp_time = m_tsLastRspTime.load();
+    if (m_bBreakAsUnstable || ((m_iEXPCount > COMM_RESPONSE_MAX_EXP) &&
+        (currtime - last_rsp_time > microseconds_from(PEER_IDLE_TMO_US))))
     {
         //
         // Connection is broken.
@@ -11135,7 +11545,7 @@ bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_rea
         // Application will detect this when it calls any UDT methods next time.
         //
         HLOGC(xtlog.Debug,
-              log << "CONNECTION EXPIRED after " << count_milliseconds(currtime - m_tsLastRspTime) << "ms");
+              log << CONID() << "CONNECTION EXPIRED after " << FormatDuration<DUNIT_MS>(currtime - last_rsp_time) << " - BREAKING");
         m_bClosing       = true;
         m_bBroken        = true;
         m_iBrokenCounter = 30;
@@ -11150,8 +11560,8 @@ bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_rea
     }
 
     HLOGC(xtlog.Debug,
-          log << "EXP TIMER: count=" << m_iEXPCount << "/" << (+COMM_RESPONSE_MAX_EXP) << " elapsed="
-              << (count_microseconds(currtime - m_tsLastRspTime)) << "/" << (+PEER_IDLE_TMO_US) << "us");
+          log << CONID() << "EXP TIMER: count=" << m_iEXPCount << "/" << (+COMM_RESPONSE_MAX_EXP)
+              << " elapsed=" << (count_microseconds(currtime - last_rsp_time)) << "/" << (+PEER_IDLE_TMO_US) << "us");
 
     ++m_iEXPCount;
 
@@ -11159,7 +11569,7 @@ bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_rea
      * (keepalive fix)
      * duB:
      * It seems there is confusion of the direction of the Response here.
-     * LastRspTime is supposed to be when receiving (data/ctrl) from peer
+     * lastRspTime is supposed to be when receiving (data/ctrl) from peer
      * as shown in processCtrl and processData,
      * Here we set because we sent something?
      *
@@ -11171,48 +11581,54 @@ bool CUDT::checkExpTimer(const steady_clock::time_point& currtime, int check_rea
     return false;
 }
 
-void CUDT::checkRexmitTimer(const steady_clock::time_point& currtime)
+void srt::CUDT::checkRexmitTimer(const steady_clock::time_point& currtime)
 {
-    /* There are two algorithms of blind packet retransmission: LATEREXMIT and FASTREXMIT.
-     *
-     * LATEREXMIT is only used with FileCC.
-     * The mode is triggered when some time has passed since the last ACK from
-     * the receiver, while there is still some unacknowledged data in the sender's buffer,
-     * and the loss list is empty.
-     *
-     * FASTREXMIT is only used with LiveCC.
-     * The mode is triggered if the receiver does not send periodic NAK reports,
-     * when some time has passed since the last ACK from the receiver,
-     * while there is still some unacknowledged data in the sender's buffer.
-     *
-     * In case the above conditions are met, the unacknowledged packets
-     * in the sender's buffer will be added to loss list and retransmitted.
-     */
+    // Check if HSv4 should be retransmitted, and if KM_REQ should be resent if the side is INITIATOR.
+    checkSndTimers();
 
-    const uint64_t rtt_syn = (m_iRTT + 4 * m_iRTTVar + 2 * COMM_SYN_INTERVAL_US);
-    const uint64_t exp_int_us = (m_iReXmitCount * rtt_syn + COMM_SYN_INTERVAL_US);
+    // There are two algorithms of blind packet retransmission: LATEREXMIT and FASTREXMIT.
+    //
+    // LATEREXMIT is only used with FileCC.
+    // The RTO is triggered when some time has passed since the last ACK from
+    // the receiver, while there is still some unacknowledged data in the sender's buffer,
+    // and the loss list is empty at the moment of RTO (nothing to retransmit yet).
+    //
+    // FASTREXMIT is only used with LiveCC.
+    // The RTO is triggered if the receiver is not configured to send periodic NAK reports,
+    // when some time has passed since the last ACK from the receiver,
+    // while there is still some unacknowledged data in the sender's buffer.
+    //
+    // In case the above conditions are met, the unacknowledged packets
+    // in the sender's buffer will be added to the SND loss list and retransmitted.
+    //
 
-    if (currtime <= (m_tsLastRspAckTime + microseconds_from(exp_int_us)))
-        return;
+    {
+        ScopedLock ack_lock(m_RecvAckLock);
+        const uint64_t rtt_syn = (m_iSRTT + 4 * m_iRTTVar + 2 * COMM_SYN_INTERVAL_US);
+        const uint64_t exp_int_us = (m_iReXmitCount * rtt_syn + COMM_SYN_INTERVAL_US);
+
+        if (currtime <= (m_tsLastRspAckTime + microseconds_from(exp_int_us)))
+            return;
+    }
 
     // If there is no unacknowledged data in the sending buffer,
     // then there is nothing to retransmit.
     if (m_pSndBuffer->getCurrBufSize() <= 0)
         return;
 
-    const bool is_laterexmit = m_CongCtl->rexmitMethod() == SrtCongestion::SRM_LATEREXMIT;
-    const bool is_fastrexmit = m_CongCtl->rexmitMethod() == SrtCongestion::SRM_FASTREXMIT;
+    const bool is_laterexmit = m_CongCtl->rexmitMethod() == SrtCongestion::SRM_LATEREXMIT; // FileCC
+    const bool is_fastrexmit = m_CongCtl->rexmitMethod() == SrtCongestion::SRM_FASTREXMIT; // LiveCC
 
     // If the receiver will send periodic NAK reports, then FASTREXMIT (live) is inactive.
     // TODO: Probably some method of "blind rexmit" MUST BE DONE, when TLPKTDROP is off.
     if (is_fastrexmit && m_bPeerNakReport)
         return;
 
-    // Schedule for retransmission IF:
+    // Schedule a retransmission IF:
     // - there are packets in flight (getFlightSpan() > 0);
     // - in case of LATEREXMIT (File Mode): the sender loss list is empty
     //   (the receiver didn't send any LOSSREPORT, or LOSSREPORT was lost on track).
-    // - in case of FASTREXMIT (Live Mode): there is the latency constraint, therefore
+    // - in case of FASTREXMIT (Live Mode): the RTO (rtt_syn) was triggered, therefore
     //   schedule unacknowledged packets for retransmission regardless of the loss list emptiness.
     if (getFlightSpan() > 0 && (!is_laterexmit || m_pSndLossList->getLossLength() == 0))
     {
@@ -11224,8 +11640,7 @@ void CUDT::checkRexmitTimer(const steady_clock::time_point& currtime)
         if (num > 0)
         {
             enterCS(m_StatsLock);
-            m_stats.traceSndLoss += num;
-            m_stats.sndLossTotal += num;
+            m_stats.sndr.lost.count(num);
             leaveCS(m_StatsLock);
 
             HLOGC(xtlog.Debug,
@@ -11237,15 +11652,14 @@ void CUDT::checkRexmitTimer(const steady_clock::time_point& currtime)
 
     ++m_iReXmitCount;
 
-    checkSndTimers(DONT_REGEN_KM);
     const ECheckTimerStage stage = is_fastrexmit ? TEV_CHT_FASTREXMIT : TEV_CHT_REXMIT;
     updateCC(TEV_CHECKTIMER, EventVariant(stage));
 
-    // immediately restart transmission
-    m_pSndQueue->m_pSndUList->update(this, CSndUList::DO_RESCHEDULE);
+    // schedule sending if not scheduled already
+    m_pSndQueue->m_pSndUList->update(this, CSndUList::DONT_RESCHEDULE);
 }
 
-void CUDT::checkTimers()
+void srt::CUDT::checkTimers()
 {
     // update CC parameters
     updateCC(TEV_CHECKTIMER, EventVariant(TEV_CHT_INIT));
@@ -11272,19 +11686,19 @@ void CUDT::checkTimers()
     // Check if FAST or LATE packet retransmission is required
     checkRexmitTimer(currtime);
 
-    if (currtime > m_tsLastSndTime + microseconds_from(COMM_KEEPALIVE_PERIOD_US))
+    if (currtime > m_tsLastSndTime.load() + microseconds_from(COMM_KEEPALIVE_PERIOD_US))
     {
         sendCtrl(UMSG_KEEPALIVE);
-#if ENABLE_EXPERIMENTAL_BONDING
-        if (m_parent->m_IncludedGroup)
+#if ENABLE_BONDING
+        if (m_parent->m_GroupOf)
         {
-            ScopedLock glock (s_UDTUnited.m_GlobControlLock);
-            if (m_parent->m_IncludedGroup)
+            ScopedLock glock (uglobal().m_GlobControlLock);
+            if (m_parent->m_GroupOf)
             {
                 // Pass socket ID because it's about changing group socket data
-                m_parent->m_IncludedGroup->internalKeepalive(m_parent->m_IncludedIter);
+                m_parent->m_GroupOf->internalKeepalive(m_parent->m_GroupMemberData);
                 // NOTE: GroupLock is unnecessary here because the only data read and
-                // modified is the target of the iterator from m_IncludedIter. The
+                // modified is the target of the iterator from m_GroupMemberData. The
                 // iterator will be valid regardless of any container modifications.
             }
         }
@@ -11293,37 +11707,41 @@ void CUDT::checkTimers()
     }
 }
 
-void CUDT::updateBrokenConnection()
+void srt::CUDT::updateBrokenConnection()
 {
+    m_bClosing = true;
     releaseSynch();
     // app can call any UDT API to learn the connection_broken error
-    s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
+    uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
     CGlobEvent::triggerEvent();
 }
 
-void CUDT::completeBrokenConnectionDependencies(int errorcode)
+void srt::CUDT::completeBrokenConnectionDependencies(int errorcode)
 {
     int token = -1;
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     bool pending_broken = false;
     {
-        ScopedLock guard_group_existence (s_UDTUnited.m_GlobControlLock);
-        if (m_parent->m_IncludedGroup)
+        ScopedLock guard_group_existence (uglobal().m_GlobControlLock);
+        if (m_parent->m_GroupOf)
         {
-            token = m_parent->m_IncludedIter->token;
-            if (m_parent->m_IncludedIter->sndstate == SRT_GST_PENDING)
+            token = m_parent->m_GroupMemberData->token;
+            if (m_parent->m_GroupMemberData->sndstate == SRT_GST_PENDING)
             {
-                HLOGC(gmlog.Debug, log << "updateBrokenConnection: a pending link was broken - will be removed");
+                HLOGC(gmlog.Debug, log << CONID() << "updateBrokenConnection: a pending link was broken - will be removed");
                 pending_broken = true;
             }
             else
             {
-                HLOGC(gmlog.Debug, log << "updateBrokenConnection: state=" << CUDTGroup::StateStr(m_parent->m_IncludedIter->sndstate) << " a used link was broken - not closing automatically");
+                HLOGC(gmlog.Debug,
+                      log << CONID() << "updateBrokenConnection: state="
+                          << CUDTGroup::StateStr(m_parent->m_GroupMemberData->sndstate)
+                          << " a used link was broken - not closing automatically");
             }
 
-            m_parent->m_IncludedIter->sndstate = SRT_GST_BROKEN;
-            m_parent->m_IncludedIter->rcvstate = SRT_GST_BROKEN;
+            m_parent->m_GroupMemberData->sndstate = SRT_GST_BROKEN;
+            m_parent->m_GroupMemberData->rcvstate = SRT_GST_BROKEN;
         }
     }
 #endif
@@ -11333,72 +11751,76 @@ void CUDT::completeBrokenConnectionDependencies(int errorcode)
         CALLBACK_CALL(m_cbConnectHook, m_SocketID, errorcode, m_PeerAddr.get(), token);
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     {
         // Lock GlobControlLock in order to make sure that
         // the state if the socket having the group and the
         // existence of the group will not be changed during
         // the operation. The attempt of group deletion will
         // have to wait until this operation completes.
-        ScopedLock lock(s_UDTUnited.m_GlobControlLock);
-        CUDTGroup* pg = m_parent->m_IncludedGroup;
+        ScopedLock lock(uglobal().m_GlobControlLock);
+        CUDTGroup* pg = m_parent->m_GroupOf;
         if (pg)
         {
             // Bound to one call because this requires locking
             pg->updateFailedLink();
         }
+        // Sockets that never succeeded to connect must be deleted
+        // explicitly, otherwise they will never be deleted. OTOH
+        // the socket can be on the path of deletion already, so
+        // this only makes sure that the socket will be deleted,
+        // one way or another.
+        if (pending_broken)
+        {
+            // XXX This somehow can cause a deadlock
+            // uglobal()->close(m_parent);
+            LOGC(smlog.Debug, log << "updateBrokenConnection...: BROKEN SOCKET @" << m_SocketID << " - CLOSING, to be removed from group.");
+            m_parent->setBrokenClosed();
+        }
     }
 
-    // Sockets that never succeeded to connect must be deleted
-    // explicitly, otherwise they will never be deleted.
-    if (pending_broken)
-    {
-        // XXX This somehow can cause a deadlock
-        // s_UDTUnited.close(m_parent);
-        m_parent->setBrokenClosed();
-    }
 #endif
 }
 
-void CUDT::addEPoll(const int eid)
+void srt::CUDT::addEPoll(const int eid)
 {
-    enterCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    enterCS(uglobal().m_EPoll.m_EPollLock);
     m_sPollID.insert(eid);
-    leaveCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    leaveCS(uglobal().m_EPoll.m_EPollLock);
 
     if (!stillConnected())
         return;
 
     enterCS(m_RecvLock);
-    if (m_pRcvBuffer->isRcvDataReady())
+    if (isRcvBufferReady())
     {
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, true);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_IN, true);
     }
     leaveCS(m_RecvLock);
 
-    if (m_iSndBufSize > m_pSndBuffer->getCurrBufSize())
+    if (m_config.iSndBufSize > m_pSndBuffer->getCurrBufSize())
     {
-        s_UDTUnited.m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
+        uglobal().m_EPoll.update_events(m_SocketID, m_sPollID, SRT_EPOLL_OUT, true);
     }
 }
 
-void CUDT::removeEPollEvents(const int eid)
+void srt::CUDT::removeEPollEvents(const int eid)
 {
     // clear IO events notifications;
     // since this happens after the epoll ID has been removed, they cannot be set again
     set<int> remove;
     remove.insert(eid);
-    s_UDTUnited.m_EPoll.update_events(m_SocketID, remove, SRT_EPOLL_IN | SRT_EPOLL_OUT, false);
+    uglobal().m_EPoll.update_events(m_SocketID, remove, SRT_EPOLL_IN | SRT_EPOLL_OUT, false);
 }
 
-void CUDT::removeEPollID(const int eid)
+void srt::CUDT::removeEPollID(const int eid)
 {
-    enterCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    enterCS(uglobal().m_EPoll.m_EPollLock);
     m_sPollID.erase(eid);
-    leaveCS(s_UDTUnited.m_EPoll.m_EPollLock);
+    leaveCS(uglobal().m_EPoll.m_EPollLock);
 }
 
-void CUDT::ConnectSignal(ETransmissionEvent evt, EventSlot sl)
+void srt::CUDT::ConnectSignal(ETransmissionEvent evt, EventSlot sl)
 {
     if (evt >= TEV_E_SIZE)
         return; // sanity check
@@ -11406,7 +11828,7 @@ void CUDT::ConnectSignal(ETransmissionEvent evt, EventSlot sl)
     m_Slots[evt].push_back(sl);
 }
 
-void CUDT::DisconnectSignal(ETransmissionEvent evt)
+void srt::CUDT::DisconnectSignal(ETransmissionEvent evt)
 {
     if (evt >= TEV_E_SIZE)
         return; // sanity check
@@ -11414,7 +11836,7 @@ void CUDT::DisconnectSignal(ETransmissionEvent evt)
     m_Slots[evt].clear();
 }
 
-void CUDT::EmitSignal(ETransmissionEvent tev, EventVariant var)
+void srt::CUDT::EmitSignal(ETransmissionEvent tev, EventVariant var)
 {
     for (std::vector<EventSlot>::iterator i = m_Slots[tev].begin(); i != m_Slots[tev].end(); ++i)
     {
@@ -11422,13 +11844,13 @@ void CUDT::EmitSignal(ETransmissionEvent tev, EventVariant var)
     }
 }
 
-int CUDT::getsndbuffer(SRTSOCKET u, size_t *blocks, size_t *bytes)
+int srt::CUDT::getsndbuffer(SRTSOCKET u, size_t *blocks, size_t *bytes)
 {
-    CUDTSocket *s = s_UDTUnited.locateSocket(u);
-    if (!s || !s->m_pUDT)
+    CUDTSocket *s = uglobal().locateSocket(u);
+    if (!s)
         return -1;
 
-    CSndBuffer *b = s->m_pUDT->m_pSndBuffer;
+    CSndBuffer *b = s->core().m_pSndBuffer;
 
     if (!b)
         return -1;
@@ -11445,44 +11867,44 @@ int CUDT::getsndbuffer(SRTSOCKET u, size_t *blocks, size_t *bytes)
     return std::abs(timespan);
 }
 
-int CUDT::rejectReason(SRTSOCKET u)
+int srt::CUDT::rejectReason(SRTSOCKET u)
 {
-    CUDTSocket* s = s_UDTUnited.locateSocket(u);
-    if (!s || !s->m_pUDT)
+    CUDTSocket* s = uglobal().locateSocket(u);
+    if (!s)
         return SRT_REJ_UNKNOWN;
 
-    return s->m_pUDT->m_RejectReason;
+    return s->core().m_RejectReason;
 }
 
-int CUDT::rejectReason(SRTSOCKET u, int value)
+int srt::CUDT::rejectReason(SRTSOCKET u, int value)
 {
-    CUDTSocket* s = s_UDTUnited.locateSocket(u);
-    if (!s || !s->m_pUDT)
+    CUDTSocket* s = uglobal().locateSocket(u);
+    if (!s)
         return APIError(MJ_NOTSUP, MN_SIDINVAL);
 
     if (value < SRT_REJC_PREDEFINED)
         return APIError(MJ_NOTSUP, MN_INVAL);
 
-    s->m_pUDT->m_RejectReason = value;
+    s->core().m_RejectReason = value;
     return 0;
 }
 
-int64_t CUDT::socketStartTime(SRTSOCKET u)
+int64_t srt::CUDT::socketStartTime(SRTSOCKET u)
 {
-    CUDTSocket* s = s_UDTUnited.locateSocket(u);
-    if (!s || !s->m_pUDT)
+    CUDTSocket* s = uglobal().locateSocket(u);
+    if (!s)
         return APIError(MJ_NOTSUP, MN_SIDINVAL);
 
-    return count_microseconds(s->m_pUDT->m_stats.tsStartTime.time_since_epoch());
+    return count_microseconds(s->core().m_stats.tsStartTime.time_since_epoch());
 }
 
-bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs, const CPacket& hspkt)
+bool srt::CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs, const CPacket& hspkt)
 {
     // Prepare the information for the hook.
 
     // We need streamid.
-    char target[MAX_SID_LENGTH + 1];
-    memset((target), 0, MAX_SID_LENGTH + 1);
+    char target[CSrtConfig::MAX_SID_LENGTH + 1];
+    memset((target), 0, CSrtConfig::MAX_SID_LENGTH + 1);
 
     // Just for a case, check the length.
     // This wasn't done before, and we could risk memory crash.
@@ -11491,7 +11913,7 @@ bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs
 
     int ext_flags = SrtHSRequest::SRT_HSTYPE_HSFLAGS::unwrap(hs.m_iType);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     bool have_group = false;
     SRT_GROUP_TYPE gt = SRT_GTYPE_UNDEFINED;
 #endif
@@ -11513,11 +11935,11 @@ bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs
 
             if (cmd == SRT_CMD_SID)
             {
-                if (!bytelen || bytelen > MAX_SID_LENGTH)
+                if (!bytelen || bytelen > CSrtConfig::MAX_SID_LENGTH)
                 {
                     LOGC(cnlog.Error,
-                         log << "interpretSrtHandshake: STREAMID length " << bytelen << " is 0 or > " << +MAX_SID_LENGTH
-                             << " - PROTOCOL ERROR, REJECTING");
+                         log << CONID() << "interpretSrtHandshake: STREAMID length " << bytelen << " is 0 or > "
+                             << +CSrtConfig::MAX_SID_LENGTH << " - PROTOCOL ERROR, REJECTING");
                     return false;
                 }
                 // See comment at CUDT::interpretSrtHandshake().
@@ -11526,7 +11948,7 @@ bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs
                 // Un-swap on big endian machines
                 ItoHLA(((uint32_t *)target), (uint32_t *)target, blocklen);
             }
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
             else if (cmd == SRT_CMD_GROUP)
             {
                 uint32_t* groupdata = begin + 1;
@@ -11550,18 +11972,21 @@ bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs
         }
     }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-    if (have_group && acore->m_OPT_GroupConnect == 0)
+#if ENABLE_BONDING
+    if (have_group && acore->m_config.iGroupConnect == 0)
     {
-        HLOGC(cnlog.Debug, log << "runAcceptHook: REJECTING connection WITHOUT calling the hook - groups not allowed");
+        HLOGC(cnlog.Debug,
+              log << CONID() << "runAcceptHook: REJECTING connection WITHOUT calling the hook - groups not allowed");
         return false;
     }
 
     // Update the groupconnect flag
-    acore->m_OPT_GroupConnect = have_group ? 1 : 0;
+    acore->m_config.iGroupConnect = have_group ? 1 : 0;
     acore->m_HSGroupType = gt;
 #endif
 
+    // Set the default value
+    acore->m_RejectReason = SRT_REJX_FALLBACK;
     try
     {
         int result = CALLBACK_CALL(m_cbAcceptHook, acore->m_SocketID, hs.m_iVersion, peer, target);
@@ -11574,32 +11999,37 @@ bool CUDT::runAcceptHook(CUDT *acore, const sockaddr* peer, const CHandShake& hs
         return false;
     }
 
+    acore->m_RejectReason = SRT_REJ_UNKNOWN;
     return true;
 }
 
-void CUDT::handleKeepalive(const char* /*data*/, size_t /*size*/)
+void srt::CUDT::processKeepalive(const CPacket& ctrlpkt, const time_point& tsArrival)
 {
     // Here can be handled some protocol definition
     // for extra data sent through keepalive.
 
-#if ENABLE_EXPERIMENTAL_BONDING
-    if (m_parent->m_IncludedGroup)
+#if ENABLE_BONDING
+    if (m_parent->m_GroupOf)
     {
         // Lock GlobControlLock in order to make sure that
-        // the state if the socket having the group and the
+        // the state of the socket having the group and the
         // existence of the group will not be changed during
         // the operation. The attempt of group deletion will
         // have to wait until this operation completes.
-        ScopedLock lock(s_UDTUnited.m_GlobControlLock);
-        CUDTGroup* pg = m_parent->m_IncludedGroup;
+        ScopedLock lock(uglobal().m_GlobControlLock);
+        CUDTGroup* pg = m_parent->m_GroupOf;
         if (pg)
         {
             // Whether anything is to be done with this socket
             // about the fact that keepalive arrived, let the
             // group handle it
-            pg->handleKeepalive(m_parent->m_IncludedIter);
+            pg->processKeepalive(m_parent->m_GroupMemberData);
         }
     }
 #endif
-}
 
+    ScopedLock lck(m_RcvBufferLock);
+    m_pRcvBuffer->updateTsbPdTimeBase(ctrlpkt.getMsgTimeStamp());
+    if (m_config.bDriftTracer)
+        m_pRcvBuffer->addRcvTsbPdDriftSample(ctrlpkt.getMsgTimeStamp(), tsArrival, -1);
+}
diff --git a/srtcore/core.h b/srtcore/core.h
index dae4dace0..ae427934d 100644
--- a/srtcore/core.h
+++ b/srtcore/core.h
@@ -56,11 +56,11 @@ modified by
 
 #include <deque>
 #include <sstream>
-
 #include "srt.h"
 #include "common.h"
 #include "list.h"
-#include "buffer.h"
+#include "buffer_snd.h"
+#include "buffer_rcv.h"
 #include "window.h"
 #include "packet.h"
 #include "channel.h"
@@ -69,13 +69,20 @@ modified by
 #include "handshake.h"
 #include "congctl.h"
 #include "packetfilter.h"
+#include "socketconfig.h"
 #include "utilities.h"
 #include "logger_defs.h"
 
+#include "stats.h"
+
 #include <haicrypt.h>
 
+#ifndef SRT_ENABLE_FREQUENT_LOG_TRACE
+#define SRT_ENABLE_FREQUENT_LOG_TRACE 0
+#endif
+
 
-// XXX Utility function - to be moved to utilities.h?
+// TODO: Utility function - to be moved to utilities.h?
 template <class T>
 inline T CountIIR(T base, T newval, double factor)
 {
@@ -86,36 +93,39 @@ inline T CountIIR(T base, T newval, double factor)
     return base+T(diff*factor);
 }
 
-// XXX Probably a better rework for that can be done - this can be
-// turned into a serializable structure, just like it's for CHandShake.
+// TODO: Probably a better rework for that can be done - this can be
+// turned into a serializable structure, just like it's done for CHandShake.
 enum AckDataItem
 {
-    ACKD_RCVLASTACK = 0,
-    ACKD_RTT = 1,
-    ACKD_RTTVAR = 2,
-    ACKD_BUFFERLEFT = 3,
-    ACKD_TOTAL_SIZE_SMALL = 4,
-
-    // Extra fields existing in UDT (not always sent)
-
-    ACKD_RCVSPEED = 4,   // length would be 16
-    ACKD_BANDWIDTH = 5,
-    ACKD_TOTAL_SIZE_UDTBASE = 6, // length = 24
-    // Extra stats for SRT
-
-    ACKD_RCVRATE = 6,
-    ACKD_TOTAL_SIZE_VER101 = 7, // length = 28
-    ACKD_XMRATE = 7, // XXX This is a weird compat stuff. Version 1.1.3 defines it as ACKD_BANDWIDTH*m_iMaxSRTPayloadSize when set. Never got.
-                     // XXX NOTE: field number 7 may be used for something in future, need to confirm destruction of all !compat 1.0.2 version
-
-    ACKD_TOTAL_SIZE_VER102 = 8, // 32
-// FEATURE BLOCKED. Probably not to be restored.
-//  ACKD_ACKBITMAP = 8,
-    ACKD_TOTAL_SIZE = ACKD_TOTAL_SIZE_VER102 // length = 32 (or more)
+    ACKD_RCVLASTACK       = 0,
+    ACKD_RTT              = 1,
+    ACKD_RTTVAR           = 2,
+    ACKD_BUFFERLEFT       = 3,
+    ACKD_TOTAL_SIZE_SMALL = 4,  // Size of the Small ACK, packet length = 16.
+
+    // Extra fields for Full ACK.
+    ACKD_RCVSPEED           = 4,
+    ACKD_BANDWIDTH          = 5,
+    ACKD_TOTAL_SIZE_UDTBASE = 6,  // Packet length = 24.
+
+    // Extra stats since SRT v1.0.1.
+    ACKD_RCVRATE           = 6,
+    ACKD_TOTAL_SIZE_VER101 = 7,  // Packet length = 28.
+
+    // Only in SRT v1.0.2.
+    ACKD_XMRATE_VER102_ONLY     = 7,
+    ACKD_TOTAL_SIZE_VER102_ONLY = 8,  // Packet length = 32.
+
+    ACKD_TOTAL_SIZE = ACKD_TOTAL_SIZE_VER102_ONLY  // The maximum known ACK length is 32 bytes.
 };
 const size_t ACKD_FIELD_SIZE = sizeof(int32_t);
 
+#ifdef ENABLE_MAXREXMITBW
+static const size_t SRT_SOCKOPT_NPOST = 13;
+#else
 static const size_t SRT_SOCKOPT_NPOST = 12;
+#endif
+
 extern const SRT_SOCKOPT srt_post_opt_list [];
 
 enum GroupDataItem
@@ -138,76 +148,16 @@ enum SeqPairItems
     SEQ_BEGIN = 0, SEQ_END = 1, SEQ_SIZE = 2
 };
 
-#if ENABLE_EXPERIMENTAL_BONDING
-
-struct SRT_SocketOptionObject
-{
-    struct SingleOption
-    {
-        uint16_t option;
-        uint16_t length;
-        unsigned char storage[1]; // NOTE: Variable length object!
-    };
-
-    std::vector<SingleOption*> options;
-
-    SRT_SocketOptionObject() {}
-
-    ~SRT_SocketOptionObject()
-    {
-        for (size_t i = 0; i < options.size(); ++i)
-        {
-            // Convert back
-            unsigned char* mem = reinterpret_cast<unsigned char*>(options[i]);
-            delete [] mem;
-        }
-    }
-
-    bool add(SRT_SOCKOPT optname, const void* optval, size_t optlen);
-};
-
-class CUDTGroup;
-#endif
-
-template <typename T>
-inline T cast_optval(const void* optval)
-{
-    return *reinterpret_cast<const T*>(optval);
-}
-
-template <typename T>
-inline T cast_optval(const void* optval, int optlen)
-{
-    if (optlen > 0 && optlen != sizeof(T))
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-
-    return cast_optval<T>(optval);
-}
-
-// This function is to make it possible for both C and C++
-// API to accept both bool and int types for boolean options.
-// (it's not that C couldn't use <stdbool.h>, it's that people
-// often forget to use correct type).
-template <>
-inline bool cast_optval(const void* optval, int optlen)
-{
-    if (optlen == sizeof(bool))
-    {
-        return *reinterpret_cast<const bool*>(optval);
-    }
-
-    if (optlen == sizeof(int))
-    {
-        // 0!= is a windows warning-killer int-to-bool conversion
-        return 0 != *reinterpret_cast<const int*>(optval);
-    }
-    return false;
-}
 
 // Extended SRT Congestion control class - only an incomplete definition required
 class CCryptoControl;
+
+namespace srt {
 class CUDTUnited;
 class CUDTSocket;
+#if ENABLE_BONDING
+class CUDTGroup;
+#endif
 
 // XXX REFACTOR: The 'CUDT' class is to be merged with 'CUDTSocket'.
 // There's no reason for separating them, there's no case of having them
@@ -229,10 +179,12 @@ class CUDT
     friend class CRcvUList;
     friend class PacketFilter;
     friend class CUDTGroup;
-    friend struct FByOldestActive; // this functional will use private fields
+    friend class TestMockCUDT; // unit tests
 
-    typedef srt::sync::steady_clock::time_point time_point;
-    typedef srt::sync::steady_clock::duration duration;
+    typedef sync::steady_clock::time_point time_point;
+    typedef sync::steady_clock::duration duration;
+    typedef sync::AtomicClock<sync::steady_clock> atomic_time_point;
+    typedef sync::AtomicDuration<sync::steady_clock> atomic_duration;
 
 private: // constructor and desctructor
     void construct();
@@ -246,13 +198,10 @@ class CUDT
     static int startup();
     static int cleanup();
     static SRTSOCKET socket();
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     static SRTSOCKET createGroup(SRT_GROUP_TYPE);
-    static int addSocketToGroup(SRTSOCKET socket, SRTSOCKET group);
-    static int removeSocketFromGroup(SRTSOCKET socket);
     static SRTSOCKET getGroupOfSocket(SRTSOCKET socket);
     static int getGroupData(SRTSOCKET groupid, SRT_SOCKGROUPDATA* pdata, size_t* psize);
-    static int configureGroup(SRTSOCKET groupid, const char* str);
     static bool isgroup(SRTSOCKET sock) { return (sock & SRTGROUP_MASK) != 0; }
 #endif
     static int bind(SRTSOCKET u, const sockaddr* name, int namelen);
@@ -262,7 +211,7 @@ class CUDT
     static SRTSOCKET accept_bond(const SRTSOCKET listeners [], int lsize, int64_t msTimeOut);
     static int connect(SRTSOCKET u, const sockaddr* name, int namelen, int32_t forced_isn);
     static int connect(SRTSOCKET u, const sockaddr* name, const sockaddr* tname, int namelen);
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     static int connectLinks(SRTSOCKET grp, SRT_SOCKGROUPCONFIG links [], int arraysize);
 #endif
     static int close(SRTSOCKET u);
@@ -295,7 +244,7 @@ class CUDT
     static int epoll_release(const int eid);
     static CUDTException& getlasterror();
     static int bstats(SRTSOCKET u, CBytePerfMon* perf, bool clear = true, bool instantaneous = false);
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     static int groupsockbstats(SRTSOCKET u, CBytePerfMon* perf, bool clear = true);
 #endif
     static SRT_SOCKSTATUS getsockstate(SRTSOCKET u);
@@ -319,34 +268,25 @@ class CUDT
         }
     };
 
-    static const SRTSOCKET INVALID_SOCK = -1;         // invalid socket descriptor
-    static const int ERROR = -1;                      // socket api error returned value
+    static const       SRTSOCKET INVALID_SOCK   = -1;           // Invalid socket descriptor
+    static const int   ERROR                    = -1;           // Socket api error returned value
 
     static const int HS_VERSION_UDT4 = 4;
     static const int HS_VERSION_SRT1 = 5;
 
     // Parameters
     //
-    // Note: use notation with X*1000*1000* ... instead of million zeros in a row.
-    // In C++17 there is a possible notation of 5'000'000 for convenience, but that's
-    // something only for a far future.
-    static const int COMM_RESPONSE_TIMEOUT_MS = 5*1000; // 5 seconds
-    static const int COMM_RESPONSE_MAX_EXP = 16;
-    static const int SRT_TLPKTDROP_MINTHRESHOLD_MS = 1000;
-    static const uint64_t COMM_KEEPALIVE_PERIOD_US = 1*1000*1000;
-    static const int32_t COMM_SYN_INTERVAL_US = 10*1000;
-    static const uint32_t COMM_DEF_STABILITY_TIMEOUT_US = 80*1000;
-    static const int COMM_CLOSE_BROKEN_LISTENER_TIMEOUT_MS = 3000;
-    static const uint16_t MAX_WEIGHT = 32767;
-
-    static const int
-        DEF_MSS = 1500,
-        DEF_FLIGHT_SIZE = 25600,
-        DEF_BUFFER_SIZE = 8192, //Rcv buffer MUST NOT be bigger than Flight Flag size
-        DEF_LINGER_S = 3*60,  // 3 minutes
-        DEF_UDP_BUFFER_SIZE = 65536,
-        DEF_CONNTIMEO_S = 3; // 3 seconds
-
+    // NOTE: Use notation with X*1000*1000*... instead of
+    // million zeros in a row.
+    static const int       COMM_RESPONSE_MAX_EXP                 = 16;
+    static const int       SRT_TLPKTDROP_MINTHRESHOLD_MS         = 1000;
+    static const uint64_t  COMM_KEEPALIVE_PERIOD_US              = 1*1000*1000;
+    static const int32_t   COMM_SYN_INTERVAL_US                  = 10*1000;
+    static const int       COMM_CLOSE_BROKEN_LISTENER_TIMEOUT_MS = 3000;
+    static const uint16_t  MAX_WEIGHT                            = 32767;
+    static const size_t    ACK_WND_SIZE                          = 1024;
+    static const int       INITIAL_RTT                           = 10 * COMM_SYN_INTERVAL_US;
+    static const int       INITIAL_RTTVAR                        = INITIAL_RTT / 2;
 
     int handshakeVersion()
     {
@@ -357,7 +297,7 @@ class CUDT
     {
 #if ENABLE_LOGGING
         std::ostringstream os;
-        os << "@" << m_SocketID << ":";
+        os << "@" << m_SocketID << ": ";
         return os.str();
 #else
         return "";
@@ -367,33 +307,57 @@ class CUDT
     SRTSOCKET socketID() const { return m_SocketID; }
     SRTSOCKET peerID() const { return m_PeerID; }
 
-    static CUDT* getUDTHandle(SRTSOCKET u);
-    static std::vector<SRTSOCKET> existingSockets();
+    static CUDT*                    getUDTHandle(SRTSOCKET u);
+    static std::vector<SRTSOCKET>   existingSockets();
 
     void addressAndSend(CPacket& pkt);
-    void sendSrtMsg(int cmd, uint32_t *srtdata_in = NULL, int srtlen_in = 0);
-
-    bool isOPT_TsbPd() const { return m_bOPT_TsbPd; }
-    int RTT() const { return m_iRTT; }
-    int32_t sndSeqNo() const { return m_iSndCurrSeqNo; }
-    int32_t schedSeqNo() const { return m_iSndNextSeqNo; }
-    bool overrideSndSeqNo(int32_t seq);
-
-    int32_t rcvSeqNo() const { return m_iRcvCurrSeqNo; }
-    int flowWindowSize() const { return m_iFlowWindowSize; }
-    int32_t deliveryRate() const { return m_iDeliveryRate; }
-    int bandwidth() const { return m_iBandwidth; }
-    int64_t maxBandwidth() const { return m_llMaxBW; }
-    int MSS() const { return m_iMSS; }
-
-    uint32_t latency_us() const {return m_iTsbPdDelay_ms*1000; }
-    size_t maxPayloadSize() const { return m_iMaxSRTPayloadSize; }
-    size_t OPT_PayloadSize() const { return m_zOPT_ExpPayloadSize; }
-    int sndLossLength() { return m_pSndLossList->getLossLength(); }
-    int32_t ISN() const { return m_iISN; }
-    int32_t peerISN() const { return m_iPeerISN; }
-    duration minNAKInterval() const { return m_tdMinNakInterval; }
-    sockaddr_any peerAddr() const { return m_PeerAddr; }
+
+    SRT_ATTR_REQUIRES(m_ConnectionLock)
+    void sendSrtMsg(int cmd, uint32_t *srtdata_in = NULL, size_t srtlen_in = 0);
+
+    bool        isOPT_TsbPd()                   const { return m_config.bTSBPD; }
+    int         SRTT()                          const { return m_iSRTT; }
+    int         RTTVar()                        const { return m_iRTTVar; }
+    int32_t     sndSeqNo()                      const { return m_iSndCurrSeqNo; }
+    int32_t     schedSeqNo()                    const { return m_iSndNextSeqNo; }
+    bool        overrideSndSeqNo(int32_t seq);
+
+#if ENABLE_BONDING
+    sync::steady_clock::time_point   lastRspTime()          const { return m_tsLastRspTime.load(); }
+    sync::steady_clock::time_point   freshActivationStart() const { return m_tsFreshActivation; }
+#endif
+
+    int32_t     rcvSeqNo()          const { return m_iRcvCurrSeqNo; }
+    SRT_ATTR_REQUIRES(m_RecvAckLock)
+    int         flowWindowSize()    const { return m_iFlowWindowSize; }
+    int32_t     deliveryRate()      const { return m_iDeliveryRate; }
+    int         bandwidth()         const { return m_iBandwidth; }
+    int64_t     maxBandwidth()      const { return m_config.llMaxBW; }
+    int         MSS()               const { return m_config.iMSS; }
+
+    uint32_t        peerLatency_us()        const { return m_iPeerTsbPdDelay_ms * 1000; }
+    int             peerIdleTimeout_ms()    const { return m_config.iPeerIdleTimeout_ms; }
+    size_t          maxPayloadSize()        const { return m_iMaxSRTPayloadSize; }
+    size_t          OPT_PayloadSize()       const { return m_config.zExpPayloadSize; }
+    size_t          payloadSize()           const
+    {
+        // If payloadsize is set, it should already be checked that
+        // it is less than the possible maximum payload size. So return it
+        // if it is set to nonzero value. In case when the connection isn't
+        // yet established, return also 0, if the value wasn't set.
+        if (m_config.zExpPayloadSize || !m_bConnected)
+            return m_config.zExpPayloadSize;
+
+        // If SRTO_PAYLOADSIZE was remaining with 0 (default for FILE mode)
+        // then return the maximum payload size per packet.
+        return m_iMaxSRTPayloadSize;
+    }
+
+    int             sndLossLength()               { return m_pSndLossList->getLossLength(); }
+    int32_t         ISN()                   const { return m_iISN; }
+    int32_t         peerISN()               const { return m_iPeerISN; }
+    duration        minNAKInterval()        const { return m_tdMinNakInterval; }
+    sockaddr_any    peerAddr()              const { return m_PeerAddr; }
 
     /// Returns the number of packets in flight (sent, but not yet acknowledged).
     /// @param lastack is the sequence number of the first unacknowledged packet.
@@ -426,6 +390,7 @@ class CUDT
 
     /// Returns the number of packets in flight (sent, but not yet acknowledged).
     /// @returns The number of packets in flight belonging to the interval [0; ...)
+    SRT_ATTR_REQUIRES(m_RecvAckLock)
     int32_t getFlightSpan() const
     {
         return getFlightSpan(m_iSndLastAck, m_iSndCurrSeqNo);
@@ -433,64 +398,72 @@ class CUDT
 
     int minSndSize(int len = 0) const
     {
-        if (len == 0) // wierd, can't use non-static data member as default argument!
-            len = m_iMaxSRTPayloadSize;
-        return m_bMessageAPI ? (len+m_iMaxSRTPayloadSize-1)/m_iMaxSRTPayloadSize : 1;
+        const int ps = (int) maxPayloadSize();
+        if (len == 0) // weird, can't use non-static data member as default argument!
+            len = ps;
+        return m_config.bMessageAPI ? (len+ps-1)/ps : 1;
     }
 
-    int32_t makeTS(const time_point& from_time) const
+    static int32_t makeTS(const time_point& from_time, const time_point& tsStartTime)
     {
         // NOTE:
         // - This calculates first the time difference towards start time.
         // - This difference value is also CUT OFF THE SEGMENT information
         //   (a multiple of MAX_TIMESTAMP+1)
         // So, this can be simply defined as: TS = (RTS - STS) % (MAX_TIMESTAMP+1)
-        // XXX Would be nice to check if local_time > m_tsStartTime,
-        // otherwise it may go unnoticed with clock skew.
-        return srt::sync::count_microseconds(from_time - m_stats.tsStartTime);
+        SRT_ASSERT(from_time >= tsStartTime);
+        return (int32_t) sync::count_microseconds(from_time - tsStartTime);
     }
 
-    void setPacketTS(CPacket& p, const time_point& local_time)
+    static void setPacketTS(CPacket& p, const time_point& start_time, const time_point& ts)
     {
-        p.m_iTimeStamp = makeTS(local_time);
+        p.set_timestamp(makeTS(ts, start_time));
     }
 
+    /// @brief Set the timestamp field of the packet using the provided value (no check)
+    /// @param p the packet structure to set the timestamp on.
+    /// @param ts timestamp to use as a source for packet timestamp.
+    SRT_ATTR_EXCLUDES(m_StatsLock)
+    void setPacketTS(CPacket& p, const time_point& ts);
+
+    /// @brief Set the timestamp field of the packet according the TSBPD mode.
+    /// Also checks the connection start time (m_tsStartTime).
+    /// @param p the packet structure to set the timestamp on.
+    /// @param ts timestamp to use as a source for packet timestamp. Ignored if m_bPeerTsbPd is false.
+    SRT_ATTR_EXCLUDES(m_StatsLock)
+    void setDataPacketTS(CPacket& p, const time_point& ts);
+
     // Utility used for closing a listening socket
     // immediately to free the socket
     void notListening()
     {
-        srt::sync::ScopedLock cg(m_ConnectionLock);
+        sync::ScopedLock cg(m_ConnectionLock);
         m_bListening = false;
         m_pRcvQueue->removeListener(this);
     }
 
     static int32_t generateISN()
     {
-        using namespace srt::sync;
-        // Random Initial Sequence Number (normal mode)
-        srand(count_microseconds(steady_clock::now().time_since_epoch()));
-        return (int32_t)(CSeqNo::m_iMaxSeqNo * (double(rand()) / RAND_MAX));
+        using namespace sync;
+        return genRandomInt(0, CSeqNo::m_iMaxSeqNo);
     }
 
-    // XXX See CUDT::tsbpd() to see how to implement it. This should
-    // do the same as TLPKTDROP feature when skipping packets that are agreed
-    // to be lost. Note that this is predicted to be called with TSBPD off.
-    // This is to be exposed for the application so that it can require this
-    // sequence to be skipped, if that packet has been otherwise arrived through
-    // a different channel.
-    void skipIncoming(int32_t seq);
+    static CUDTUnited& uglobal();                      // UDT global management base
 
-    // For SRT_tsbpdLoop
-    CUDTUnited* uglobal() { return &s_UDTUnited; } // needed by tsbpdLoop
     std::set<int>& pollset() { return m_sPollID; }
 
+    CSrtConfig m_config;
+
     SRTU_PROPERTY_RO(SRTSOCKET, id, m_SocketID);
     SRTU_PROPERTY_RO(bool, isClosing, m_bClosing);
-    SRTU_PROPERTY_RO(CRcvBuffer*, rcvBuffer, m_pRcvBuffer);
+    SRTU_PROPERTY_RO(srt::CRcvBuffer*, rcvBuffer, m_pRcvBuffer);
     SRTU_PROPERTY_RO(bool, isTLPktDrop, m_bTLPktDrop);
-    SRTU_PROPERTY_RO(bool, isSynReceiving, m_bSynRecving);
-    SRTU_PROPERTY_RR(srt::sync::Condition*, recvDataCond, &m_RecvDataCond);
-    SRTU_PROPERTY_RR(srt::sync::Condition*, recvTsbPdCond, &m_RcvTsbPdCond);
+    SRTU_PROPERTY_RO(bool, isSynReceiving, m_config.bSynRecving);
+    SRTU_PROPERTY_RR(sync::Condition*, recvDataCond, &m_RecvDataCond);
+    SRTU_PROPERTY_RR(sync::Condition*, recvTsbPdCond, &m_RcvTsbPdCond);
+
+    /// @brief  Request a socket to be broken due to too long instability (normally by a group).
+    void breakAsUnstable() { m_bBreakAsUnstable = true; }
 
     void ConnectSignal(ETransmissionEvent tev, EventSlot sl);
     void DisconnectSignal(ETransmissionEvent tev);
@@ -504,16 +477,13 @@ class CUDT
 
 private:
     /// initialize a UDT entity and bind to a local address.
-
     void open();
 
     /// Start listening to any connection request.
-
     void setListenState();
 
     /// Connect to a UDT entity listening at address "peer".
     /// @param peer [in] The address of the listening UDT entity.
-
     void startConnect(const sockaddr_any& peer, int32_t forced_isn);
 
     /// Process the response handshake packet. Failure reasons can be:
@@ -524,8 +494,8 @@ class CUDT
     /// @retval 0 Connection successful
     /// @retval 1 Connection in progress (m_ConnReq turned into RESPONSE)
     /// @retval -1 Connection failed
-
-    SRT_ATR_NODISCARD EConnectStatus processConnectResponse(const CPacket& pkt, CUDTException* eout) ATR_NOEXCEPT;
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    EConnectStatus processConnectResponse(const CPacket& pkt, CUDTException* eout) ATR_NOEXCEPT;
 
     // This function works in case of HSv5 rendezvous. It changes the state
     // according to the present state and received message type, as well as the
@@ -544,12 +514,25 @@ class CUDT
     /// @param response incoming handshake response packet to be interpreted
     /// @param serv_addr incoming packet's address
     /// @param rst Current read status to know if the HS packet was freshly received from the peer, or this is only a periodic update (RST_AGAIN)
-    SRT_ATR_NODISCARD EConnectStatus processRendezvous(const CPacket &response, const sockaddr_any& serv_addr, EReadStatus, CPacket& reqpkt);
-    SRT_ATR_NODISCARD bool prepareConnectionObjects(const CHandShake &hs, HandshakeSide hsd, CUDTException *eout);
-    SRT_ATR_NODISCARD EConnectStatus postConnect(const CPacket& response, bool rendezvous, CUDTException* eout) ATR_NOEXCEPT;
-    void applyResponseSettings() ATR_NOEXCEPT;
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    EConnectStatus processRendezvous(const CPacket* response, const sockaddr_any& serv_addr, EReadStatus, CPacket& reqpkt);
+    void sendRendezvousRejection(const sockaddr_any& serv_addr, CPacket& request);
+
+    /// Create the CryptoControl object based on the HS packet.
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    bool prepareConnectionObjects(const CHandShake &hs, HandshakeSide hsd, CUDTException* eout);
+
+    /// Allocates sender and receiver buffers and loss lists.
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    bool prepareBuffers(CUDTException* eout);
+    int getAuthTagSize() const;
+
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    EConnectStatus postConnect(const CPacket* response, bool rendezvous, CUDTException* eout) ATR_NOEXCEPT;
+
+    SRT_ATR_NODISCARD bool applyResponseSettings(const CPacket* hspkt /*[[nullable]]*/) ATR_NOEXCEPT;
     SRT_ATR_NODISCARD EConnectStatus processAsyncConnectResponse(const CPacket& pkt) ATR_NOEXCEPT;
-    SRT_ATR_NODISCARD bool processAsyncConnectRequest(EReadStatus rst, EConnectStatus cst, const CPacket& response, const sockaddr_any& serv_addr);
+    SRT_ATR_NODISCARD bool processAsyncConnectRequest(EReadStatus rst, EConnectStatus cst, const CPacket* response, const sockaddr_any& serv_addr);
     SRT_ATR_NODISCARD EConnectStatus craftKmResponse(uint32_t* aw_kmdata, size_t& w_kmdatasize);
 
     void checkUpdateCryptoKeyLen(const char* loghdr, int32_t typefield);
@@ -558,14 +541,17 @@ class CUDT
     SRT_ATR_NODISCARD size_t fillSrtHandshake_HSRSP(uint32_t* srtdata, size_t srtlen, int hs_version);
     SRT_ATR_NODISCARD size_t fillSrtHandshake(uint32_t* srtdata, size_t srtlen, int msgtype, int hs_version);
 
-    SRT_ATR_NODISCARD bool createSrtHandshake(int srths_cmd, int srtkm_cmd, const uint32_t* data, size_t datalen,
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    bool createSrtHandshake(int srths_cmd, int srtkm_cmd, const uint32_t* data, size_t datalen,
             CPacket& w_reqpkt, CHandShake& w_hs);
 
     SRT_ATR_NODISCARD size_t fillHsExtConfigString(uint32_t *pcmdspec, int cmd, const std::string &str);
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     SRT_ATR_NODISCARD size_t fillHsExtGroup(uint32_t *pcmdspec);
 #endif
-    SRT_ATR_NODISCARD size_t fillHsExtKMREQ(uint32_t *pcmdspec, size_t ki);
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
+    size_t fillHsExtKMREQ(uint32_t *pcmdspec, size_t ki);
+
     SRT_ATR_NODISCARD size_t fillHsExtKMRSP(uint32_t *pcmdspec, const uint32_t *kmdata, size_t kmdata_wordsize);
 
     SRT_ATR_NODISCARD size_t prepareSrtHsMsg(int cmd, uint32_t* srtdata, size_t size);
@@ -576,7 +562,7 @@ class CUDT
     SRT_ATR_NODISCARD bool interpretSrtHandshake(const CHandShake& hs, const CPacket& hspkt, uint32_t* out_data, size_t* out_len);
     SRT_ATR_NODISCARD bool checkApplyFilterConfig(const std::string& cs);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     static CUDTGroup& newGroup(const int); // defined EXCEPTIONALLY in api.cpp for convenience reasons
     // Note: This is an "interpret" function, which should treat the tp as
     // "possibly group type" that might be out of the existing values.
@@ -592,7 +578,16 @@ class CUDT
 
     void updateIdleLinkFrom(CUDT* source);
 
-    void checkNeedDrop(bool& bCongestion);
+    /// @brief Drop packets too late to be delivered if any.
+    /// @returns the number of packets actually dropped.
+    SRT_ATTR_REQUIRES2(m_RecvAckLock, m_StatsLock)
+    int sndDropTooLate();
+
+    /// @bried Allow packet retransmission.
+    /// Depending on the configuration mode (live / file), retransmission
+    /// can be blocked if e.g. there are original packets pending to be sent.
+    /// @return true if retransmission is allowed; false otherwise.
+    bool isRetransmissionAllowed(const time_point& tnow);
 
     /// Connect to a UDT entity as per hs request. This will update
     /// required data in the entity, then update them also in the hs structure,
@@ -602,7 +597,8 @@ class CUDT
     /// @param hspkt [in] The original packet that brought the handshake.
     /// @param hs [in/out] The handshake information sent by the peer side (in), negotiated value (out).
     void acceptAndRespond(const sockaddr_any& agent, const sockaddr_any& peer, const CPacket& hspkt, CHandShake& hs);
-    bool createSendHSResponse(uint32_t* kmdata, size_t kmdatasize, CHandShake& w_hs) ATR_NOTHROW;
+    bool createSendHSResponse(uint32_t* kmdata, size_t kmdatasize, const sockaddr_any& hsaddr, CHandShake& w_hs) ATR_NOTHROW;
+
     /// Write back to the hs structure the data after they have been
     /// negotiated by acceptAndRespond.
     void rewriteHandshakeData(const sockaddr_any& peer, CHandShake& w_hs);
@@ -610,7 +606,7 @@ class CUDT
 
     /// Close the opened UDT entity.
 
-    bool closeInternal();
+    bool closeInternal() ATR_NOEXCEPT;
     void updateBrokenConnection();
     void completeBrokenConnectionDependencies(int errorcode);
 
@@ -686,7 +682,7 @@ class CUDT
 
     void getOpt(SRT_SOCKOPT optName, void* optval, int& w_optlen);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     /// Applies the configuration set on the socket.
     /// Any errors in this process are reported by exception.
     SRT_ERRNO applyMemberConfigObject(const SRT_SocketOptionObject& opt);
@@ -706,7 +702,15 @@ class CUDT
     void unlose(const CPacket& oldpacket);
     void dropFromLossLists(int32_t from, int32_t to);
 
-    void checkSndTimers(Whether2RegenKm regen = DONT_REGEN_KM);
+    SRT_ATTR_REQUIRES(m_RecvAckLock)
+    bool getFirstNoncontSequence(int32_t& w_seq, std::string& w_log_reason);
+
+    SRT_ATTR_EXCLUDES(m_ConnectionLock)
+    void checkSndTimers();
+    
+    /// @brief Check and perform KM refresh if needed.
+    void checkSndKMRefresh();
+
     void handshakeDone()
     {
         m_iSndHsRetryCnt = 0;
@@ -714,7 +718,7 @@ class CUDT
 
     int64_t withOverhead(int64_t basebw)
     {
-        return (basebw * (100 + m_iOverheadBW))/100;
+        return (basebw * (100 + m_config.iOverheadBW))/100;
     }
 
     static double Bps2Mbps(int64_t basebw)
@@ -735,12 +739,12 @@ class CUDT
 
     int sndSpaceLeft()
     {
-        return sndBuffersLeft() * m_iMaxSRTPayloadSize;
+        return static_cast<int>(sndBuffersLeft() * maxPayloadSize());
     }
 
     int sndBuffersLeft()
     {
-        return m_iSndBufSize - m_pSndBuffer->getCurrBufSize();
+        return m_config.iSndBufSize - m_pSndBuffer->getCurrBufSize();
     }
 
     time_point socketStartTime()
@@ -748,125 +752,108 @@ class CUDT
         return m_stats.tsStartTime;
     }
 
+    SRT_ATTR_EXCLUDES(m_RcvBufferLock)
+    bool isRcvBufferReady() const;
+
+    SRT_ATTR_REQUIRES(m_RcvBufferLock)
+    bool isRcvBufferReadyNoLock() const;
+
+    SRT_ATTR_EXCLUDES(m_RcvBufferLock)
+    bool isRcvBufferFull() const;
+
     // TSBPD thread main function.
     static void* tsbpd(void* param);
 
-    void updateForgotten(int seqlen, int32_t lastack, int32_t skiptoseqno);
+    enum DropReason
+    {
+        DROP_TOO_LATE, //< Drop to keep up to the live pace (TLPKTDROP).
+        DROP_DISCARD   //< Drop because another group member already provided these packets.
+    };
+
+    /// Drop too late packets (receiver side). Update loss lists and ACK positions.
+    /// The @a seqno packet itself is not dropped.
+    /// @param seqno [in] The sequence number of the first packets following those to be dropped.
+    /// @param reason A reason for dropping (see @a DropReason).
+    /// @return The number of packets dropped.
+    SRT_ATTR_EXCLUDES(m_RcvBufferLock, m_RcvLossLock)
+    int rcvDropTooLateUpTo(int seqno, DropReason reason = DROP_TOO_LATE);
 
     static loss_seqs_t defaultPacketArrival(void* vself, CPacket& pkt);
     static loss_seqs_t groupPacketArrival(void* vself, CPacket& pkt);
 
-    static CUDTUnited s_UDTUnited;               // UDT global management base
+    void setRateEstimator(const CRateEstimator& rate)
+    {
+        if (!m_pSndBuffer)
+            return;
 
-private: // Identification
-    CUDTSocket* const m_parent; // temporary, until the CUDTSocket class is merged with CUDT
-    SRTSOCKET m_SocketID;                        // UDT socket number
-    SRTSOCKET m_PeerID;                          // peer id, for multiplexer
-
-    int m_iMaxSRTPayloadSize;                 // Maximum/regular payload size, in bytes
-    size_t m_zOPT_ExpPayloadSize;                    // Expected average payload size (user option)
-
-    // Options
-    int m_iMSS;                                  // Maximum Segment Size, in bytes
-    bool m_bSynSending;                          // Sending syncronization mode
-    bool m_bSynRecving;                          // Receiving syncronization mode
-    int m_iFlightFlagSize;                       // Maximum number of packets in flight from the peer side
-    int m_iSndBufSize;                           // Maximum UDT sender buffer size
-    int m_iRcvBufSize;                           // Maximum UDT receiver buffer size
-    linger m_Linger;                             // Linger information on close
-    int m_iUDPSndBufSize;                        // UDP sending buffer size
-    int m_iUDPRcvBufSize;                        // UDP receiving buffer size
-    bool m_bRendezvous;                          // Rendezvous connection mode
-
-    duration m_tdConnTimeOut;    // connect timeout in milliseconds
-    bool m_bDriftTracer;
-    int m_iSndTimeOut;                           // sending timeout in milliseconds
-    int m_iRcvTimeOut;                           // receiving timeout in milliseconds
-    bool m_bReuseAddr;                           // reuse an exiting port or not, for UDP multiplexer
-    int64_t m_llMaxBW;                           // maximum data transfer rate (threshold)
-    int m_iIpTTL;
-    int m_iIpToS;
-#ifdef SRT_ENABLE_BINDTODEVICE
-    std::string m_BindToDevice;
-#endif
-    // These fields keep the options for encryption
-    // (SRTO_PASSPHRASE, SRTO_PBKEYLEN). Crypto object is
-    // created later and takes values from these.
-    HaiCrypt_Secret m_CryptoSecret;
-    int m_iSndCryptoKeyLen;
+        m_pSndBuffer->setRateEstimator(rate);
+        updateCC(TEV_SYNC, EventVariant(0));
+    }
 
-    // XXX Consider removing. The m_bDataSender stays here
-    // in order to maintain the HS side selection in HSv4.
-    bool m_bDataSender;
+
+private: // Identification
+    CUDTSocket* const   m_parent;                       // Temporary, until the CUDTSocket class is merged with CUDT
+    SRTSOCKET           m_SocketID;                     // UDT socket number
+    SRTSOCKET           m_PeerID;                       // Peer ID, for multiplexer
 
     // HSv4 (legacy handshake) support)
-    time_point m_tsSndHsLastTime;	    //Last SRT handshake request time
-    int      m_iSndHsRetryCnt;       //SRT handshake retries left
-
-    bool m_bMessageAPI;
-    bool m_bOPT_TsbPd;               // Whether AGENT will do TSBPD Rx (whether peer does, is not agent's problem)
-    int m_iOPT_TsbPdDelay;           // Agent's Rx latency
-    int m_iOPT_PeerTsbPdDelay;       // Peer's Rx latency for the traffic made by Agent's Tx.
-    bool m_bOPT_TLPktDrop;           // Whether Agent WILL DO TLPKTDROP on Rx.
-    int m_iOPT_SndDropDelay;         // Extra delay when deciding to snd-drop for TLPKTDROP, -1 to off
-    bool m_bOPT_StrictEncryption;    // Off by default. When on, any connection other than nopw-nopw & pw1-pw1 is rejected.
-    int m_OPT_GroupConnect;
-    std::string m_sStreamName;
-    int m_iOPT_PeerIdleTimeout;      // Timeout for hearing anything from the peer.
-    uint32_t m_uOPT_StabilityTimeout;
-    int m_iOPT_RetransmitAlgo;
-
-    int m_iTsbPdDelay_ms;                           // Rx delay to absorb burst in milliseconds
-    int m_iPeerTsbPdDelay_ms;                       // Tx delay that the peer uses to absorb burst in milliseconds
-    bool m_bTLPktDrop;                           // Enable Too-late Packet Drop
-    int64_t m_llInputBW;                         // Input stream rate (bytes/sec)
-                                                 // 0: use internally estimated input bandwidth
-    int m_iOverheadBW;                           // Percent above input stream rate (applies if m_llMaxBW == 0)
-    bool m_bRcvNakReport;                        // Enable Receiver Periodic NAK Reports
-    int m_iIpV6Only;                             // IPV6_V6ONLY option (-1 if not set)
-#if ENABLE_EXPERIMENTAL_BONDING
-    SRT_GROUP_TYPE m_HSGroupType;   // group type about-to-be-set in the handshake
+    time_point  m_tsSndHsLastTime;                      // Last SRT handshake request time
+    int         m_iSndHsRetryCnt;                       // SRT handshake retries left
+
+#if ENABLE_BONDING
+    SRT_GROUP_TYPE m_HSGroupType;   // Group type about-to-be-set in the handshake
 #endif
 
 private:
-    UniquePtr<CCryptoControl> m_pCryptoControl;                            // congestion control SRT class (small data extension)
-    CCache<CInfoBlock>* m_pCache;                // network information cache
+    int                       m_iMaxSRTPayloadSize;     // Maximum/regular payload size, in bytes
+    int                       m_iTsbPdDelay_ms;         // Rx delay to absorb burst, in milliseconds
+    int                       m_iPeerTsbPdDelay_ms;     // Tx delay that the peer uses to absorb burst, in milliseconds
+    bool                      m_bTLPktDrop;             // Enable Too-late Packet Drop
+    SRT_ATTR_PT_GUARDED_BY(m_ConnectionLock)
+    UniquePtr<CCryptoControl> m_pCryptoControl;         // Crypto control module
+    CCache<CInfoBlock>*       m_pCache;                 // Network information cache
 
     // Congestion control
     std::vector<EventSlot> m_Slots[TEV_E_SIZE];
-    SrtCongestion m_CongCtl;
+    SrtCongestion          m_CongCtl;
 
     // Packet filtering
     PacketFilter m_PacketFilter;
-    std::string m_OPT_PktFilterConfigString;
     SRT_ARQLevel m_PktFilterRexmitLevel;
-    std::string m_sPeerPktFilterConfigString;
+    std::string  m_sPeerPktFilterConfigString;
 
     // Attached tool function
     void EmitSignal(ETransmissionEvent tev, EventVariant var);
 
     // Internal state
-    volatile bool m_bListening;                  // If the UDT entit is listening to connection
-    volatile bool m_bConnecting;                 // The short phase when connect() is called but not yet completed
-    volatile bool m_bConnected;                  // Whether the connection is on or off
-    volatile bool m_bClosing;                    // If the UDT entity is closing
-    volatile bool m_bShutdown;                   // If the peer side has shutdown the connection
-    volatile bool m_bBroken;                     // If the connection has been broken
-    volatile bool m_bPeerHealth;                 // If the peer status is normal
-    volatile int m_RejectReason;
+    sync::atomic<bool> m_bListening;             // If the UDT entity is listening to connection
+    sync::atomic<bool> m_bConnecting;            // The short phase when connect() is called but not yet completed
+    sync::atomic<bool> m_bConnected;             // Whether the connection is on or off
+    sync::atomic<bool> m_bClosing;               // If the UDT entity is closing
+    sync::atomic<bool> m_bShutdown;              // If the peer side has shutdown the connection
+    sync::atomic<bool> m_bBroken;                // If the connection has been broken
+    sync::atomic<bool> m_bBreakAsUnstable;       // A flag indicating that the socket should become broken because it has been unstable for too long.
+    sync::atomic<bool> m_bPeerHealth;            // If the peer status is normal
+    sync::atomic<int> m_RejectReason;
     bool m_bOpened;                              // If the UDT entity has been opened
-    int m_iBrokenCounter;                        // a counter (number of GC checks) to let the GC tag this socket as disconnected
+                                                 // A counter (number of GC checks happening every 1s) to let the GC tag this socket as closed.   
+    sync::atomic<int> m_iBrokenCounter;          // If a broken socket still has data in the receiver buffer, it is not marked closed until the counter is 0.
 
     int m_iEXPCount;                             // Expiration counter
-    int m_iBandwidth;                            // Estimated bandwidth, number of packets per second
-    int m_iRTT;                                  // RTT, in microseconds
-    int m_iRTTVar;                               // RTT variance
-    int m_iDeliveryRate;                         // Packet arrival rate at the receiver side
-    int m_iByteDeliveryRate;                     // Byte arrival rate at the receiver side
-
-
-    CHandShake m_ConnReq;                        // connection request
-    CHandShake m_ConnRes;                        // connection response
+    sync::atomic<int> m_iBandwidth;              // Estimated bandwidth, number of packets per second
+    sync::atomic<int> m_iSRTT;                   // Smoothed RTT (an exponentially-weighted moving average (EWMA)
+                                                 // of an endpoint's RTT samples), in microseconds
+    sync::atomic<int> m_iRTTVar;                 // The variation in the RTT samples (RTT variance), in microseconds
+    sync::atomic<bool> m_bIsFirstRTTReceived;    // True if the first RTT sample was obtained from the ACK/ACKACK pair
+                                                 // at the receiver side or received by the sender from an ACK packet.
+                                                 // It's used to reset the initial value of smoothed RTT (m_iSRTT)
+                                                 // at the beginning of transmission (including the one taken from
+                                                 // cache). False by default.
+    sync::atomic<int> m_iDeliveryRate;           // Packet arrival rate at the receiver side
+    sync::atomic<int> m_iByteDeliveryRate;       // Byte arrival rate at the receiver side
+
+    CHandShake m_ConnReq;                        // Connection request
+    CHandShake m_ConnRes;                        // Connection response
     CHandShake::RendezvousState m_RdvState;      // HSv5 rendezvous state
     HandshakeSide m_SrtHsSide;                   // HSv5 rendezvous handshake side resolved from cookie contest (DRAW if not yet resolved)
 
@@ -874,50 +861,58 @@ class CUDT
     CSndBuffer* m_pSndBuffer;                    // Sender buffer
     CSndLossList* m_pSndLossList;                // Sender loss list
     CPktTimeWindow<16, 16> m_SndTimeWindow;      // Packet sending time window
+#ifdef ENABLE_MAXREXMITBW
+    CSndRateEstimator      m_SndRexmitRate;      // Retransmission rate estimation.
+#endif
 
-    /*volatile*/ duration m_tdSendInterval;      // Inter-packet time, in CPU clock cycles
+    atomic_duration m_tdSendInterval;            // Inter-packet time, in CPU clock cycles
 
-    /*volatile*/ duration m_tdSendTimeDiff;      // aggregate difference in inter-packet sending time
+    atomic_duration m_tdSendTimeDiff;            // Aggregate difference in inter-packet sending time
 
-    volatile int m_iFlowWindowSize;              // Flow control window size
-    volatile double m_dCongestionWindow;         // congestion window size
+    SRT_ATTR_GUARDED_BY(m_RecvAckLock)
+    sync::atomic<int> m_iFlowWindowSize;         // Flow control window size
+    sync::atomic<int> m_iCongestionWindow;       // Congestion window size
 
 private: // Timers
-    /*volatile*/ time_point m_tsNextACKTime;    // Next ACK time, in CPU clock cycles, same below
-    /*volatile*/ time_point m_tsNextNAKTime;    // Next NAK time
-
-    /*volatile*/ duration   m_tdACKInterval;    // ACK interval
-    /*volatile*/ duration   m_tdNAKInterval;    // NAK interval
-    /*volatile*/ time_point m_tsLastRspTime;    // time stamp of last response from the peer
-    /*volatile*/ time_point m_tsLastRspAckTime; // time stamp of last ACK from the peer
-    /*volatile*/ time_point m_tsLastSndTime;    // time stamp of last data/ctrl sent (in system ticks)
-    time_point m_tsLastWarningTime;             // Last time that a warning message is sent
-    time_point m_tsLastReqTime;                 // last time when a connection request is sent
+    atomic_time_point m_tsNextACKTime;           // Next ACK time, in CPU clock cycles, same below
+    atomic_time_point m_tsNextNAKTime;           // Next NAK time
+
+    duration   m_tdACKInterval;                  // ACK interval
+    duration   m_tdNAKInterval;                  // NAK interval
+
+    SRT_ATTR_GUARDED_BY(m_RecvAckLock)
+    atomic_time_point m_tsLastRspTime;           // Timestamp of last response from the peer
+    time_point m_tsLastRspAckTime;               // (SND) Timestamp of last ACK from the peer
+    atomic_time_point m_tsLastSndTime;           // Timestamp of last data/ctrl sent (in system ticks)
+    time_point m_tsLastWarningTime;              // Last time that a warning message is sent
+    atomic_time_point m_tsLastReqTime;           // last time when a connection request is sent
     time_point m_tsRcvPeerStartTime;
-    time_point m_tsLingerExpiration;            // Linger expiration time (for GC to close a socket with data in sending buffer)
-    time_point m_tsLastAckTime;                 // Timestamp of last ACK
-    duration m_tdMinNakInterval;                // NAK timeout lower bound; too small value can cause unnecessary retransmission
-    duration m_tdMinExpInterval;                // timeout lower bound threshold: too small timeout can cause problem
+    time_point m_tsLingerExpiration;             // Linger expiration time (for GC to close a socket with data in sending buffer)
+    time_point m_tsLastAckTime;                  // (RCV) Timestamp of last ACK
+    duration m_tdMinNakInterval;                 // NAK timeout lower bound; too small value can cause unnecessary retransmission
+    duration m_tdMinExpInterval;                 // Timeout lower bound threshold: too small timeout can cause problem
 
-    int m_iPktCount;                          // packet counter for ACK
-    int m_iLightACKCount;                     // light ACK counter
+    int m_iPktCount;                             // Packet counter for ACK
+    int m_iLightACKCount;                        // Light ACK counter
 
-    time_point m_tsNextSendTime;     // scheduled time of next packet sending
+    time_point m_tsNextSendTime;                 // Scheduled time of next packet sending
 
-    volatile int32_t m_iSndLastFullAck;          // Last full ACK received
-    volatile int32_t m_iSndLastAck;              // Last ACK received
+    sync::atomic<int32_t> m_iSndLastFullAck;     // Last full ACK received
+    SRT_ATTR_GUARDED_BY(m_RecvAckLock)
+    sync::atomic<int32_t> m_iSndLastAck;         // Last ACK received
 
     // NOTE: m_iSndLastDataAck is the value strictly bound to the CSndBufer object (m_pSndBuffer)
     // and this is the sequence number that refers to the block at position [0]. Upon acknowledgement,
     // this value is shifted to the acknowledged position, and the blocks are removed from the
     // m_pSndBuffer buffer up to excluding this sequence number.
-    // XXX CONSIDER removing this field and give up the maintenance of this sequence number
+    // XXX CONSIDER removing this field and giving up the maintenance of this sequence number
     // to the sending buffer. This way, extraction of an old packet for retransmission should
     // require only the lost sequence number, and how to find the packet with this sequence
     // will be up to the sending buffer.
-    volatile int32_t m_iSndLastDataAck;          // The real last ACK that updates the sender buffer and loss list
-    volatile int32_t m_iSndCurrSeqNo;            // The largest sequence number that HAS BEEN SENT
-    volatile int32_t m_iSndNextSeqNo;            // The sequence number predicted to be placed at the currently scheduled packet
+    sync::atomic<int32_t> m_iSndLastDataAck;     // The real last ACK that updates the sender buffer and loss list
+    SRT_ATTR_GUARDED_BY(m_RecvAckLock)
+    sync::atomic<int32_t> m_iSndCurrSeqNo;       // The largest sequence number that HAS BEEN SENT
+    sync::atomic<int32_t> m_iSndNextSeqNo;       // The sequence number predicted to be placed at the currently scheduled packet
 
     // Note important differences between Curr and Next fields:
     // - m_iSndCurrSeqNo: this is used by SRT:SndQ:worker thread and it's operated from CUDT::packData
@@ -943,64 +938,74 @@ class CUDT
         m_iSndLastAck2 = isn;
     }
 
-    void setInitialRcvSeq(int32_t isn)
-    {
-        m_iRcvLastAck = isn;
-#ifdef ENABLE_LOGGING
-        m_iDebugPrevLastAck = m_iRcvLastAck;
-#endif
-        m_iRcvLastSkipAck = m_iRcvLastAck;
-        m_iRcvLastAckAck = isn;
-        m_iRcvCurrSeqNo = CSeqNo::decseq(isn);
-    }
+    void setInitialRcvSeq(int32_t isn);
 
     int32_t m_iISN;                              // Initial Sequence Number
     bool m_bPeerTsbPd;                           // Peer accept TimeStamp-Based Rx mode
     bool m_bPeerTLPktDrop;                       // Enable sender late packet dropping
     bool m_bPeerNakReport;                       // Sender's peer (receiver) issues Periodic NAK Reports
     bool m_bPeerRexmitFlag;                      // Receiver supports rexmit flag in payload packets
+
+    SRT_ATTR_GUARDED_BY(m_RecvAckLock)
     int32_t m_iReXmitCount;                      // Re-Transmit Count since last ACK
 
+    static const size_t
+                FREQLOGFA_ENCRYPTION_FAILURE = 0,
+                FREQLOGFA_RCV_DROPPED = 1,
+                FREQLOGFA_ACKACK_OUTOFORDER = 2,
+                MAX_FREQLOGFA = 3;
+
+    atomic_time_point m_tsLogSlowDown[MAX_FREQLOGFA]; // The last time a log message from the "slow down" group was shown.
+                                                      // The "slow down" group of logs are those that can be printed too often otherwise, but can't be turned off (warnings and errors).
+                                                      // Currently only used by decryption failure message, therefore no mutex protection needed.
+    sync::atomic<uint8_t> m_LogSlowDownExpired;       // Can't use bitset because atomic
+    sync::atomic<int> m_aSuppressedMsg[MAX_FREQLOGFA];
+
+    /// @brief Check if a frequent log can be shown.
+    /// @param tnow current time
+    /// @return true if it is ok to print a frequent log message.
+    bool frequentLogAllowed(size_t logid, const time_point& tnow, std::string& why);
+
 private: // Receiving related data
+    SRT_ATTR_GUARDED_BY(m_RcvBufferLock)
     CRcvBuffer* m_pRcvBuffer;                    //< Receiver buffer
+    SRT_ATTR_GUARDED_BY(m_RcvLossLock)
     CRcvLossList* m_pRcvLossList;                //< Receiver loss list
+    SRT_ATTR_GUARDED_BY(m_RcvLossLock)
     std::deque<CRcvFreshLoss> m_FreshLoss;       //< Lost sequence already added to m_pRcvLossList, but not yet sent UMSG_LOSSREPORT for.
+
     int m_iReorderTolerance;                     //< Current value of dynamic reorder tolerance
-    int m_iMaxReorderTolerance;                  //< Maximum allowed value for dynamic reorder tolerance
     int m_iConsecEarlyDelivery;                  //< Increases with every OOO packet that came <TTL-2 time, resets with every increased reorder tolerance
     int m_iConsecOrderedDelivery;                //< Increases with every packet coming in order or retransmitted, resets with every out-of-order packet
 
-    CACKWindow<1024> m_ACKWindow;                //< ACK history window
-    CPktTimeWindow<16, 64> m_RcvTimeWindow;      //< Packet arrival time window
+    CACKWindow<ACK_WND_SIZE> m_ACKWindow;        // ACK history window
+    CPktTimeWindow<16, 64> m_RcvTimeWindow;      // Packet arrival time window
 
-    int32_t m_iRcvLastAck;                       //< Last sent ACK
+    int32_t m_iRcvLastAck;                       // First unacknowledged packet seqno sent in the latest ACK.
 #ifdef ENABLE_LOGGING
     int32_t m_iDebugPrevLastAck;
 #endif
-    int32_t m_iRcvLastSkipAck;                   // Last dropped sequence ACK
-    int32_t m_iRcvLastAckAck;                    // Last sent ACK that has been acknowledged
+    int32_t m_iRcvLastAckAck;                    // (RCV) Latest packet seqno in a sent ACK acknowledged by ACKACK. RcvQTh (sendCtrlAck {r}, processCtrlAckAck {r}, processCtrlAck {r}, connection {w}).
     int32_t m_iAckSeqNo;                         // Last ACK sequence number
-    int32_t m_iRcvCurrSeqNo;                     // Largest received sequence number
+    sync::atomic<int32_t> m_iRcvCurrSeqNo;       // (RCV) Largest received sequence number. RcvQTh, TSBPDTh.
     int32_t m_iRcvCurrPhySeqNo;                  // Same as m_iRcvCurrSeqNo, but physical only (disregarding a filter)
-
+    bool m_bBufferWasFull;                        // Indicate that RX buffer was full last time a ack was sent
     int32_t m_iPeerISN;                          // Initial Sequence Number of the peer side
 
-    uint32_t m_lSrtVersion;
-    uint32_t m_lMinimumPeerSrtVersion;
-    uint32_t m_lPeerSrtVersion;
-    uint32_t m_lPeerSrtFlags;
+    uint32_t m_uPeerSrtVersion;
+    uint32_t m_uPeerSrtFlags;
 
     bool m_bTsbPd;                               // Peer sends TimeStamp-Based Packet Delivery Packets 
-    bool m_bGroupTsbPd;                          // TSBPD should be used for GROUP RECEIVER instead.
+    bool m_bGroupTsbPd;                          // TSBPD should be used for GROUP RECEIVER instead
 
-    srt::sync::CThread m_RcvTsbPdThread;         // Rcv TsbPD Thread handle
-    srt::sync::Condition m_RcvTsbPdCond;         // TSBPD signals if reading is ready. Use together with m_RecvLock.
-    bool m_bTsbPdAckWakeup;                      // Signal TsbPd thread on Ack sent
-    srt::sync::Mutex m_RcvTsbPdStartupLock;      // Protects TSBPD thread creating and joining
+    SRT_ATTR_GUARDED_BY(m_RcvTsbPdStartupLock)
+    sync::CThread m_RcvTsbPdThread;              // Rcv TsbPD Thread handle
+    sync::Condition m_RcvTsbPdCond;              // TSBPD signals if reading is ready. Use together with m_RecvLock
+    bool m_bTsbPdNeedsWakeup;                    // Signal TsbPd thread to wake up on RCV buffer state change.
+    sync::Mutex m_RcvTsbPdStartupLock;           // Protects TSBPD thread creation and joining.
 
     CallbackHolder<srt_listen_callback_fn> m_cbAcceptHook;
     CallbackHolder<srt_connect_callback_fn> m_cbConnectHook;
-
     // FORWARDER
 public:
     static int installAcceptHook(SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq);
@@ -1008,31 +1013,37 @@ class CUDT
 private:
     void installAcceptHook(srt_listen_callback_fn* hook, void* opaq)
     {
+        if (m_bConnected || m_bConnecting || m_bListening || m_bBroken)
+            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
+
         m_cbAcceptHook.set(opaq, hook);
     }
 
     void installConnectHook(srt_connect_callback_fn* hook, void* opaq)
     {
+        if (m_bConnected || m_bConnecting || m_bListening || m_bBroken)
+            throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
+
         m_cbConnectHook.set(opaq, hook);
     }
 
 
 private: // synchronization: mutexes and conditions
-    srt::sync::Mutex m_ConnectionLock;           // used to synchronize connection operation
+    sync::Mutex m_ConnectionLock;                // used to synchronize connection operation
 
-    srt::sync::Condition m_SendBlockCond;        // used to block "send" call
-    srt::sync::Mutex m_SendBlockLock;            // lock associated to m_SendBlockCond
+    sync::Condition m_SendBlockCond;             // used to block "send" call
+    sync::Mutex m_SendBlockLock;                 // lock associated to m_SendBlockCond
 
-    srt::sync::Mutex m_RcvBufferLock;            // Protects the state of the m_pRcvBuffer
+    mutable sync::Mutex m_RcvBufferLock;         // Protects the state of the m_pRcvBuffer
     // Protects access to m_iSndCurrSeqNo, m_iSndLastAck
-    srt::sync::Mutex m_RecvAckLock;              // Protects the state changes while processing incomming ACK (SRT_EPOLL_OUT)
+    mutable sync::Mutex m_RecvAckLock;                   // Protects the state changes while processing incoming ACK (SRT_EPOLL_OUT)
 
-    srt::sync::Condition m_RecvDataCond;         // used to block "srt_recv*" when there is no data. Use together with m_RecvLock
-    srt::sync::Mutex m_RecvLock;                 // used to synchronize "srt_recv*" call, protects TSBPD drift updates (CRcvBuffer::isRcvDataReady())
+    sync::Condition m_RecvDataCond;              // used to block "srt_recv*" when there is no data. Use together with m_RecvLock
+    sync::Mutex m_RecvLock;                      // used to synchronize "srt_recv*" call, protects TSBPD drift updates (CRcvBuffer::isRcvDataReady())
 
-    srt::sync::Mutex m_SendLock;                 // used to synchronize "send" call
-    srt::sync::Mutex m_RcvLossLock;              // Protects the receiver loss list (access: CRcvQueue::worker, CUDT::tsbpd)
-    srt::sync::Mutex m_StatsLock;                // used to synchronize access to trace statistics
+    sync::Mutex m_SendLock;                      // used to synchronize "send" call
+    sync::Mutex m_RcvLossLock;                   // Protects the receiver loss list (access: CRcvQueue::worker, CUDT::tsbpd)
+    mutable sync::Mutex m_StatsLock;             // used to synchronize access to trace statistics
 
     void initSynch();
     void destroySynch();
@@ -1051,7 +1062,7 @@ class CUDT
 
     // Failure to create the crypter means that an encrypted
     // connection should be rejected if ENFORCEDENCRYPTION is on.
-    SRT_ATR_NODISCARD
+    SRT_ATR_NODISCARD SRT_ATTR_REQUIRES(m_ConnectionLock)
     bool createCrypter(HandshakeSide side, bool bidi);
 
 private: // Generation and processing of packets
@@ -1065,35 +1076,92 @@ class CUDT
     ///
     /// @returns the nmber of packets sent.
     int  sendCtrlAck(CPacket& ctrlpkt, int size);
+    void sendLossReport(const std::vector< std::pair<int32_t, int32_t> >& losslist);
 
     void processCtrl(const CPacket& ctrlpkt);
-    void sendLossReport(const std::vector< std::pair<int32_t, int32_t> >& losslist);
-    void processCtrlAck(const CPacket& ctrlpkt, const time_point &currtime);
+    
+    /// @brief Process incoming control ACK packet.
+    /// @param ctrlpkt incoming ACK packet
+    /// @param currtime current clock time
+    void processCtrlAck(const CPacket& ctrlpkt, const time_point& currtime);
+
+    /// @brief Process incoming control ACKACK packet.
+    /// @param ctrlpkt incoming ACKACK packet
+    /// @param tsArrival time when packet has arrived (used to calculate RTT)
+    void processCtrlAckAck(const CPacket& ctrlpkt, const time_point& tsArrival);
+
+    /// @brief Process incoming loss report (NAK) packet.
+    /// @param ctrlpkt incoming NAK packet
     void processCtrlLossReport(const CPacket& ctrlpkt);
 
-    ///
+    /// @brief Process incoming handshake control packet
+    /// @param ctrlpkt incoming HS packet
+    void processCtrlHS(const CPacket& ctrlpkt);
+
+    /// @brief Process incoming drop request control packet
+    /// @param ctrlpkt incoming drop request packet
+    void processCtrlDropReq(const CPacket& ctrlpkt);
+
+    /// @brief Process incoming shutdown control packet
+    void processCtrlShutdown();
+    /// @brief Process incoming user defined control packet
+    /// @param ctrlpkt incoming user defined packet
+    void processCtrlUserDefined(const CPacket& ctrlpkt);
+
+    /// @brief Update sender's loss list on an incoming acknowledgement.
     /// @param ackdata_seqno    sequence number of a data packet being acknowledged
     void updateSndLossListOnACK(int32_t ackdata_seqno);
 
     /// Pack a packet from a list of lost packets.
-    ///
     /// @param packet [in, out] a packet structure to fill
-    /// @param origintime [in, out] origin timestamp of the packet
-    ///
     /// @return payload size on success, <=0 on failure
-    int packLostData(CPacket &packet, time_point &origintime);
+    int packLostData(CPacket &packet);
+
+    /// Pack a unique data packet (never sent so far) in CPacket for sending.
+    /// @param packet [in, out] a CPacket structure to fill.
+    ///
+    /// @return true if a packet has been packets; false otherwise.
+    bool packUniqueData(CPacket& packet);
 
     /// Pack in CPacket the next data to be send.
     ///
-    /// @param packet [in, out] a CPacket structure to fill
+    /// @param packet [out] a CPacket structure to fill
+    /// @param nexttime [out] Time when this socket should be next time picked up for processing.
+    /// @param src_addr [out] Source address to pass to channel's sendto
     ///
-    /// @return A pair of values is returned (payload, timestamp).
-    ///         The payload tells the size of the payload, packed in CPacket.
-    ///         The timestamp is the full source/origin timestamp of the data.
-    ///         If payload is <= 0, consider the timestamp value invalid.
-    std::pair<int, time_point> packData(CPacket& packet);
+    /// @retval true A packet was extracted for sending, the socket should be rechecked at @a nexttime
+    /// @retval false Nothing was extracted for sending, @a nexttime should be ignored
+    bool packData(CPacket& packet, time_point& nexttime, sockaddr_any& src_addr);
 
+    /// Also excludes srt::CUDTUnited::m_GlobControlLock.
+    SRT_ATTR_EXCLUDES(m_RcvTsbPdStartupLock, m_StatsLock, m_RecvLock, m_RcvLossLock, m_RcvBufferLock)
     int processData(CUnit* unit);
+
+    /// This function passes the incoming packet to the initial processing
+    /// (like packet filter) and is about to store it effectively to the
+    /// receiver buffer and do some postprocessing (decryption) if necessary
+    /// and report the status thereof.
+    ///
+    /// @param incoming [in] The packet coming from the network medium
+    /// @param w_new_inserted [out] Set false, if the packet already exists, otherwise true (packet added)
+    /// @param w_was_sent_in_order [out] Set false, if the packet was belated, but had no R flag set.
+    /// @param w_srt_loss_seqs [out] Gets inserted a loss, if this function has detected it.
+    ///
+    /// @return 0 The call was successful (regardless if the packet was accepted or not).
+    /// @return -1 The call has failed: no space left in the buffer.
+    /// @return -2 The incoming packet exceeds the expected sequence by more than a length of the buffer (irrepairable discrepancy).
+    int handleSocketPacketReception(const std::vector<CUnit*>& incoming, bool& w_new_inserted, bool& w_was_sent_in_order, CUDT::loss_seqs_t& w_srt_loss_seqs);
+
+    /// Get the packet's TSBPD time -
+    /// the time when it is passed to the reading application.
+    /// The @a grp passed by void* is not used yet
+    /// and shall not be used when ENABLE_BONDING=0.
+    time_point getPktTsbPdTime(void* grp, const CPacket& packet);
+
+    SRT_ATTR_EXCLUDES(m_RcvTsbPdStartupLock)
+    /// Checks and spawns the TSBPD thread if required.
+    int checkLazySpawnTsbPdThread();
+
     void processClose();
 
     /// Process the request after receiving the handshake from caller.
@@ -1106,80 +1174,31 @@ class CUDT
     int processConnectRequest(const sockaddr_any& addr, CPacket& packet);
     static void addLossRecord(std::vector<int32_t>& lossrecord, int32_t lo, int32_t hi);
     int32_t bake(const sockaddr_any& addr, int32_t previous_cookie = 0, int correction = 0);
-    int32_t ackDataUpTo(int32_t seq);
-    void handleKeepalive(const char* data, size_t lenghth);
+
+    void processKeepalive(const CPacket& ctrlpkt, const time_point& tsArrival);
+
+
+    SRT_ATTR_REQUIRES(m_RcvBufferLock)
+    /// Retrieves the available size of the receiver buffer.
+    /// Expects that m_RcvBufferLock is locked.
+    size_t getAvailRcvBufferSizeNoLock() const;
 
 private: // Trace
     struct CoreStats
     {
-        time_point tsStartTime;                 // timestamp when the UDT entity is started
-        int64_t sentTotal;                  // total number of sent data packets, including retransmissions
-        int64_t sentUniqTotal;              // total number of sent data packets, excluding rexmit and filter control
-        int64_t recvTotal;                  // total number of received packets
-        int64_t recvUniqTotal;              // total number of received and delivered packets
-        int sndLossTotal;                   // total number of lost packets (sender side)
-        int rcvLossTotal;                   // total number of lost packets (receiver side)
-        int retransTotal;                   // total number of retransmitted packets
-        int sentACKTotal;                   // total number of sent ACK packets
-        int recvACKTotal;                   // total number of received ACK packets
-        int sentNAKTotal;                   // total number of sent NAK packets
-        int recvNAKTotal;                   // total number of received NAK packets
-        int sndDropTotal;
-        int rcvDropTotal;
-        uint64_t bytesSentTotal;            // total number of bytes sent,  including retransmissions
-        uint64_t bytesSentUniqTotal;        // total number of bytes sent,  including retransmissions
-        uint64_t bytesRecvTotal;            // total number of received bytes
-        uint64_t bytesRecvUniqTotal;        // total number of received bytes
-        uint64_t rcvBytesLossTotal;         // total number of loss bytes (estimate)
-        uint64_t bytesRetransTotal;         // total number of retransmitted bytes
-        uint64_t sndBytesDropTotal;
-        uint64_t rcvBytesDropTotal;
-        int m_rcvUndecryptTotal;
-        uint64_t m_rcvBytesUndecryptTotal;
-
-        int sndFilterExtraTotal;
-        int rcvFilterExtraTotal;
-        int rcvFilterSupplyTotal;
-        int rcvFilterLossTotal;
+        time_point tsStartTime;             // timestamp when the UDT entity is started
+        stats::Sender sndr;                 // sender statistics
+        stats::Receiver rcvr;               // receiver statistics
 
         int64_t m_sndDurationTotal;         // total real time for sending
 
-        time_point tsLastSampleTime;            // last performance sample time
-        int64_t traceSent;                  // number of packets sent in the last trace interval
-        int64_t traceSentUniq;              // number of original packets sent in the last trace interval
-        int64_t traceRecv;                  // number of packets received in the last trace interval
-        int64_t traceRecvUniq;              // number of packets received AND DELIVERED in the last trace interval
-        int traceSndLoss;                   // number of lost packets in the last trace interval (sender side)
-        int traceRcvLoss;                   // number of lost packets in the last trace interval (receiver side)
-        int traceRetrans;                   // number of retransmitted packets in the last trace interval
-        int sentACK;                        // number of ACKs sent in the last trace interval
-        int recvACK;                        // number of ACKs received in the last trace interval
-        int sentNAK;                        // number of NAKs sent in the last trace interval
-        int recvNAK;                        // number of NAKs received in the last trace interval
-        int traceSndDrop;
-        int traceRcvDrop;
-        int traceRcvRetrans;
+        time_point tsLastSampleTime;        // last performance sample time
         int traceReorderDistance;
         double traceBelatedTime;
-        int64_t traceRcvBelated;
-        uint64_t traceBytesSent;            // number of bytes sent in the last trace interval
-        uint64_t traceBytesSentUniq;        // number of bytes sent in the last trace interval
-        uint64_t traceBytesRecv;            // number of bytes sent in the last trace interval
-        uint64_t traceBytesRecvUniq;        // number of bytes sent in the last trace interval
-        uint64_t traceRcvBytesLoss;         // number of bytes bytes lost in the last trace interval (estimate)
-        uint64_t traceBytesRetrans;         // number of bytes retransmitted in the last trace interval
-        uint64_t traceSndBytesDrop;
-        uint64_t traceRcvBytesDrop;
-        int traceRcvUndecrypt;
-        uint64_t traceRcvBytesUndecrypt;
-
-        int sndFilterExtra;
-        int rcvFilterExtra;
-        int rcvFilterSupply;
-        int rcvFilterLoss;
 
         int64_t sndDuration;                // real time for sending
-        time_point sndDurationCounter;         // timers to record the sending Duration
+        time_point sndDurationCounter;      // timers to record the sending Duration
+
     } m_stats;
 
 public:
@@ -1187,12 +1206,13 @@ class CUDT
     static const int SEND_LITE_ACK = sizeof(int32_t); // special size for ack containing only ack seq
     static const int PACKETPAIR_MASK = 0xF;
 
-    static const size_t MAX_SID_LENGTH = 512;
-
 private: // Timers functions
-    time_point m_tsTmpActiveTime;  // time since temporary activated, or 0 if not temporary activated
-    time_point m_tsUnstableSince;  // time since unexpected ACK delay experienced, or 0 if link seems healthy
-    
+#if ENABLE_BONDING
+    time_point m_tsFreshActivation; // GROUPS: time of fresh activation of the link, or 0 if past the activation phase or idle
+    time_point m_tsUnstableSince;   // GROUPS: time since unexpected ACK delay experienced, or 0 if link seems healthy
+    time_point m_tsWarySince;       // GROUPS: time since an unstable link has first some response
+#endif
+
     static const int BECAUSE_NO_REASON = 0, // NO BITS
                      BECAUSE_ACK       = 1 << 0,
                      BECAUSE_LITEACK   = 1 << 1,
@@ -1206,19 +1226,15 @@ class CUDT
     bool checkExpTimer (const time_point& currtime, int check_reason);  // returns true if the connection is expired
     void checkRexmitTimer(const time_point& currtime);
 
-public: // For the use of CCryptoControl
-    // HaiCrypt configuration
-    unsigned int m_uKmRefreshRatePkt;
-    unsigned int m_uKmPreAnnouncePkt;
-
 
 private: // for UDP multiplexer
-    CSndQueue* m_pSndQueue;         // packet sending queue
-    CRcvQueue* m_pRcvQueue;         // packet receiving queue
-    sockaddr_any m_PeerAddr;        // peer address
-    uint32_t m_piSelfIP[4];         // local UDP IP address
-    CSNode* m_pSNode;               // node information for UDT list used in snd queue
-    CRNode* m_pRNode;               // node information for UDT list used in rcv queue
+    CSndQueue* m_pSndQueue;    // packet sending queue
+    CRcvQueue* m_pRcvQueue;    // packet receiving queue
+    sockaddr_any m_PeerAddr;   // peer address
+    sockaddr_any m_SourceAddr; // override UDP source address with this one when sending
+    uint32_t m_piSelfIP[4];    // local UDP IP address
+    CSNode* m_pSNode;          // node information for UDT list used in snd queue
+    CRNode* m_pRNode;          // node information for UDT list used in rcv queue
 
 public: // For SrtCongestion
     const CSndQueue* sndQueue() { return m_pSndQueue; }
@@ -1231,5 +1247,6 @@ class CUDT
     void removeEPollID(const int eid);
 };
 
+} // namespace srt
 
 #endif
diff --git a/srtcore/crypto.cpp b/srtcore/crypto.cpp
index d412bfe17..e7fe0be89 100644
--- a/srtcore/crypto.cpp
+++ b/srtcore/crypto.cpp
@@ -26,6 +26,7 @@ written by
 #include "crypto.h"
 #include "logging.h"
 #include "core.h"
+#include "api.h"
 
 using namespace srt_logging;
 
@@ -42,7 +43,7 @@ using namespace srt_logging;
 */
 
 // 10* HAICRYPT_DEF_KM_PRE_ANNOUNCE
-const int SRT_CRYPT_KM_PRE_ANNOUNCE = 0x10000;
+const int SRT_CRYPT_KM_PRE_ANNOUNCE SRT_ATR_UNUSED = 0x10000;
 
 namespace srt_logging
 {
@@ -56,11 +57,18 @@ std::string KmStateStr(SRT_KM_STATE state)
         TAKE(SECURING);
         TAKE(NOSECRET);
         TAKE(BADSECRET);
+#ifdef ENABLE_AEAD_API_PREVIEW
+        TAKE(BADCRYPTOMODE);
+#endif
 #undef TAKE
     default:
         {
             char buf[256];
-            sprintf(buf, "??? (%d)", state);
+#if defined(_MSC_VER) && _MSC_VER < 1900
+            _snprintf(buf, sizeof(buf) - 1, "??? (%d)", state);
+#else
+            snprintf(buf, sizeof(buf), "??? (%d)", state);
+#endif
             return buf;
         }
     }
@@ -69,8 +77,26 @@ std::string KmStateStr(SRT_KM_STATE state)
 
 using srt_logging::KmStateStr;
 
+void srt::CCryptoControl::globalInit()
+{
+#ifdef SRT_ENABLE_ENCRYPTION
+    // We need to force the Cryspr to be initialized during startup to avoid the
+    // possibility of multiple threads initialzing the same static data later on.
+    HaiCryptCryspr_Get_Instance();
+#endif
+}
+
+bool srt::CCryptoControl::isAESGCMSupported()
+{
+#ifdef SRT_ENABLE_ENCRYPTION
+    return HaiCrypt_IsAESGCM_Supported() != 0;
+#else
+    return false;
+#endif
+}
+
 #if ENABLE_LOGGING
-std::string CCryptoControl::FormatKmMessage(std::string hdr, int cmd, size_t srtlen)
+std::string srt::CCryptoControl::FormatKmMessage(std::string hdr, int cmd, size_t srtlen)
 {
     std::ostringstream os;
     os << hdr << ": cmd=" << cmd << "(" << (cmd == SRT_CMD_KMREQ ? "KMREQ":"KMRSP") <<") len="
@@ -81,7 +107,7 @@ std::string CCryptoControl::FormatKmMessage(std::string hdr, int cmd, size_t srt
 }
 #endif
 
-void CCryptoControl::updateKmState(int cmd, size_t srtlen SRT_ATR_UNUSED)
+void srt::CCryptoControl::updateKmState(int cmd, size_t srtlen SRT_ATR_UNUSED)
 {
     if (cmd == SRT_CMD_KMREQ)
     {
@@ -97,22 +123,22 @@ void CCryptoControl::updateKmState(int cmd, size_t srtlen SRT_ATR_UNUSED)
     }
 }
 
-void CCryptoControl::createFakeSndContext()
+void srt::CCryptoControl::createFakeSndContext()
 {
     if (!m_iSndKmKeyLen)
         m_iSndKmKeyLen = 16;
 
-    if (!createCryptoCtx(m_iSndKmKeyLen, HAICRYPT_CRYPTO_DIR_TX, (m_hSndCrypto)))
+    if (!createCryptoCtx((m_hSndCrypto), m_iSndKmKeyLen, HAICRYPT_CRYPTO_DIR_TX, false))
     {
         HLOGC(cnlog.Debug, log << "Error: Can't create fake crypto context for sending - sending will return ERROR!");
         m_hSndCrypto = 0;
     }
 }
 
-int CCryptoControl::processSrtMsg_KMREQ(
+int srt::CCryptoControl::processSrtMsg_KMREQ(
         const uint32_t* srtdata SRT_ATR_UNUSED,
         size_t bytelen SRT_ATR_UNUSED,
-        int hsv SRT_ATR_UNUSED,
+        int hsv SRT_ATR_UNUSED, unsigned srtv SRT_ATR_UNUSED,
         uint32_t pw_srtdata_out[], size_t& w_srtlen)
 {
     //Receiver
@@ -125,13 +151,11 @@ int CCryptoControl::processSrtMsg_KMREQ(
     HtoNLA((pw_srtdata_out), srtdata, w_srtlen);
     unsigned char* kmdata = reinterpret_cast<unsigned char*>(pw_srtdata_out);
 
-    std::vector<unsigned char> kmcopy(kmdata, kmdata + bytelen);
-
     // The side that has received KMREQ is always an HSD_RESPONDER, regardless of
     // what has called this function. The HSv5 handshake only enforces bidirectional
     // connection.
 
-    bool bidirectional = hsv > CUDT::HS_VERSION_UDT4;
+    const bool bidirectional = hsv > CUDT::HS_VERSION_UDT4;
 
     // Local macro to return rejection appropriately.
     // CHANGED. The first version made HSv5 reject the connection.
@@ -144,6 +168,12 @@ int CCryptoControl::processSrtMsg_KMREQ(
     bool wasb4 SRT_ATR_UNUSED = false;
     size_t sek_len = 0;
 
+    const bool bUseGCM =
+        (m_iCryptoMode == CSrtConfig::CIPHER_MODE_AUTO && kmdata[HCRYPT_MSG_KM_OFS_CIPHER] == HCRYPT_CIPHER_AES_GCM) ||
+        (m_iCryptoMode == CSrtConfig::CIPHER_MODE_AES_GCM);
+
+    m_bUseGcm153 = srtv <= SrtVersion(1, 5, 3);
+
     // What we have to do:
     // If encryption is on (we know that by having m_KmSecret nonempty), create
     // the crypto context (if bidirectional, create for both sending and receiving).
@@ -191,13 +221,16 @@ int CCryptoControl::processSrtMsg_KMREQ(
     }
     wasb4 = m_hRcvCrypto;
 
-    if (!createCryptoCtx(m_iRcvKmKeyLen, HAICRYPT_CRYPTO_DIR_RX, (m_hRcvCrypto)))
+    if (!createCryptoCtx((m_hRcvCrypto), m_iRcvKmKeyLen, HAICRYPT_CRYPTO_DIR_RX, bUseGCM))
     {
         LOGC(cnlog.Error, log << "processSrtMsg_KMREQ: Can't create RCV CRYPTO CTX - must reject...");
         m_RcvKmState = SRT_KM_S_NOSECRET;
         KMREQ_RESULT_REJECTION();
     }
 
+    // Deduce resulting mode.
+    m_iCryptoMode = bUseGCM ? CSrtConfig::CIPHER_MODE_AES_GCM : CSrtConfig::CIPHER_MODE_AES_CTR;
+
     if (!wasb4)
     {
         HLOGC(cnlog.Debug, log << "processSrtMsg_KMREQ: created RX ENC with KeyLen=" << m_iRcvKmKeyLen);
@@ -222,6 +255,15 @@ int CCryptoControl::processSrtMsg_KMREQ(
         w_srtlen = 1;
         LOGC(cnlog.Warn, log << "KMREQ/rcv: (snd) Rx process failure - BADSECRET");
         break;
+    case HAICRYPT_ERROR_CIPHER:
+#ifdef ENABLE_AEAD_API_PREVIEW
+        m_RcvKmState = m_SndKmState = SRT_KM_S_BADCRYPTOMODE;
+#else
+        m_RcvKmState = m_SndKmState = SRT_KM_S_BADSECRET; // Use "bad secret" as a fallback.
+#endif
+        w_srtlen = 1;
+        LOGC(cnlog.Warn, log << "KMREQ/rcv: (snd) Rx process failure - BADCRYPTOMODE");
+        break;
     case HAICRYPT_ERROR: //Other errors
     default:
         m_RcvKmState = m_SndKmState = SRT_KM_S_NOSECRET;
@@ -236,13 +278,12 @@ int CCryptoControl::processSrtMsg_KMREQ(
     // until the next KMREQ is received as a key regeneration.
     m_bErrorReported = false;
 
-
     if (w_srtlen == 1)
         goto HSv4_ErrorReport;
 
     // Configure the sender context also, if it succeeded to configure the
     // receiver context and we are using bidirectional mode.
-    if ( bidirectional )
+    if (bidirectional)
     {
         // Note: 'bidirectional' means that we want a bidirectional key update,
         // which happens only and exclusively with HSv5 handshake - not when the
@@ -292,6 +333,13 @@ int CCryptoControl::processSrtMsg_KMREQ(
         HLOGC(cnlog.Debug, log << "processSrtMsg_KMREQ: NOT REPLAYING the key update to TX CRYPTO CTX.");
     }
 
+#ifdef SRT_ENABLE_ENCRYPTION
+    if (m_hRcvCrypto != NULL)
+        HaiCrypt_UpdateGcm153(m_hRcvCrypto, m_bUseGcm153);
+    if (m_hSndCrypto != NULL)
+        HaiCrypt_UpdateGcm153(m_hSndCrypto, m_bUseGcm153);
+#endif
+
     return SRT_CMD_KMRSP;
 
 HSv4_ErrorReport:
@@ -320,7 +368,7 @@ int CCryptoControl::processSrtMsg_KMREQ(
     return SRT_CMD_KMRSP;
 }
 
-int CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int /* XXX unused? hsv*/)
+int srt::CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, unsigned srtv)
 {
     /* All 32-bit msg fields (if present) swapped on reception
      * But HaiCrypt expect network order message
@@ -332,9 +380,6 @@ int CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int
 
     int retstatus = -1;
 
-    // Unused?
-    //bool bidirectional = hsv > CUDT::HS_VERSION_UDT4;
-
     // Since now, when CCryptoControl::decrypt() encounters an error, it will print it, ONCE,
     // until the next KMREQ is received as a key regeneration.
     m_bErrorReported = false;
@@ -371,6 +416,14 @@ int CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int
             m_SndKmState = SRT_KM_S_UNSECURED;
             retstatus = 0;
             break;
+#ifdef ENABLE_AEAD_API_PREVIEW
+        case SRT_KM_S_BADCRYPTOMODE:
+            // The peer expects to use a different cryptographic mode (e.g. AES-GCM, not AES-CTR).
+            m_RcvKmState = SRT_KM_S_BADCRYPTOMODE;
+            m_SndKmState = SRT_KM_S_BADCRYPTOMODE;
+            retstatus = -1;
+            break;
+#endif
 
         default:
             LOGC(cnlog.Fatal, log << "processSrtMsg_KMRSP: IPE: unknown peer error state: "
@@ -412,6 +465,14 @@ int CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int
         }
         HLOGC(cnlog.Debug, log << "processSrtMsg_KMRSP: key[0]: len=" << m_SndKmMsg[0].MsgLen << " retry=" << m_SndKmMsg[0].iPeerRetry
             << "; key[1]: len=" << m_SndKmMsg[1].MsgLen << " retry=" << m_SndKmMsg[1].iPeerRetry);
+
+        m_bUseGcm153 = srtv <= SrtVersion(1, 5, 3);
+#ifdef SRT_ENABLE_ENCRYPTION
+        if (m_hRcvCrypto != NULL)
+            HaiCrypt_UpdateGcm153(m_hRcvCrypto, m_bUseGcm153);
+        if (m_hSndCrypto != NULL)
+            HaiCrypt_UpdateGcm153(m_hSndCrypto, m_bUseGcm153);
+#endif
     }
 
     LOGP(cnlog.Note, FormatKmMessage("processSrtMsg_KMRSP", SRT_CMD_KMRSP, len));
@@ -419,9 +480,10 @@ int CCryptoControl::processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int
     return retstatus;
 }
 
-void CCryptoControl::sendKeysToPeer(Whether2RegenKm regen SRT_ATR_UNUSED)
+void srt::CCryptoControl::sendKeysToPeer(CUDT* sock SRT_ATR_UNUSED, int iSRTT SRT_ATR_UNUSED)
 {
-    if ( !m_hSndCrypto || m_SndKmState == SRT_KM_S_UNSECURED)
+    sync::ScopedLock lck(m_mtxLock);
+    if (!m_hSndCrypto || m_SndKmState == SRT_KM_S_UNSECURED)
     {
         HLOGC(cnlog.Debug, log << "sendKeysToPeer: NOT sending/regenerating keys: "
                 << (m_hSndCrypto ? "CONNECTION UNSECURED" : "NO TX CRYPTO CTX created"));
@@ -439,7 +501,7 @@ void CCryptoControl::sendKeysToPeer(Whether2RegenKm regen SRT_ATR_UNUSED)
      * then (re-)send handshake request.
      */
     if (((m_SndKmMsg[0].iPeerRetry > 0) || (m_SndKmMsg[1].iPeerRetry > 0))
-        && ((m_SndKmLastTime + srt::sync::microseconds_from((m_parent->RTT() * 3)/2)) <= now))
+        && ((m_SndKmLastTime + srt::sync::microseconds_from((iSRTT * 3)/2)) <= now))
     {
         for (int ki = 0; ki < 2; ki++)
         {
@@ -449,25 +511,17 @@ void CCryptoControl::sendKeysToPeer(Whether2RegenKm regen SRT_ATR_UNUSED)
                 HLOGC(cnlog.Debug, log << "sendKeysToPeer: SENDING ki=" << ki << " len=" << m_SndKmMsg[ki].MsgLen
                         << " retry(updated)=" << m_SndKmMsg[ki].iPeerRetry);
                 m_SndKmLastTime = now;
-                m_parent->sendSrtMsg(SRT_CMD_KMREQ, (uint32_t *)m_SndKmMsg[ki].Msg, m_SndKmMsg[ki].MsgLen/sizeof(uint32_t));
+                sock->sendSrtMsg(SRT_CMD_KMREQ, (uint32_t *)m_SndKmMsg[ki].Msg, m_SndKmMsg[ki].MsgLen / sizeof(uint32_t));
             }
         }
     }
-
-
-    if (regen)
-    {
-        regenCryptoKm(
-            true, // send UMSG_EXT + SRT_CMD_KMREQ to the peer, if regenerated the key
-            false // Do not apply the regenerated key to the to the receiver context
-        ); // regenerate and send
-    }
 #endif
 }
 
-#ifdef SRT_ENABLE_ENCRYPTION
-void CCryptoControl::regenCryptoKm(bool sendit, bool bidirectional)
+void srt::CCryptoControl::regenCryptoKm(CUDT* sock SRT_ATR_UNUSED, bool bidirectional SRT_ATR_UNUSED)
 {
+#ifdef SRT_ENABLE_ENCRYPTION
+    sync::ScopedLock lck(m_mtxLock);
     if (!m_hSndCrypto)
         return;
 
@@ -477,7 +531,7 @@ void CCryptoControl::regenCryptoKm(bool sendit, bool bidirectional)
     int sent = 0;
 
     HLOGC(cnlog.Debug, log << "regenCryptoKm: regenerating crypto keys nbo=" << nbo <<
-            " THEN=" << (sendit ? "SEND" : "KEEP") << " DIR=" << (bidirectional ? "BOTH" : "SENDER"));
+            " THEN=" << (sock ? "SEND" : "KEEP") << " DIR=" << (bidirectional ? "BOTH" : "SENDER"));
 
     for (int i = 0; i < nbo && i < 2; i++)
     {
@@ -505,7 +559,7 @@ void CCryptoControl::regenCryptoKm(bool sendit, bool bidirectional)
             m_SndKmMsg[ki].MsgLen = out_len_p[i];
             m_SndKmMsg[ki].iPeerRetry = SRT_MAX_KMRETRY;  
 
-            if (bidirectional && !sendit)
+            if (bidirectional && !sock)
             {
                 // "Send" this key also to myself, just to be applied to the receiver crypto,
                 // exactly the same way how this key is interpreted on the peer side into its receiver crypto
@@ -518,11 +572,11 @@ void CCryptoControl::regenCryptoKm(bool sendit, bool bidirectional)
                 }
             }
 
-            if (sendit)
+            if (sock)
             {
                 HLOGC(cnlog.Debug, log << "regenCryptoKm: SENDING ki=" << ki << " len=" << m_SndKmMsg[ki].MsgLen
                         << " retry(updated)=" << m_SndKmMsg[ki].iPeerRetry);
-                m_parent->sendSrtMsg(SRT_CMD_KMREQ, (uint32_t *)m_SndKmMsg[ki].Msg, m_SndKmMsg[ki].MsgLen/sizeof(uint32_t));
+                sock->sendSrtMsg(SRT_CMD_KMREQ, (uint32_t *)m_SndKmMsg[ki].Msg, m_SndKmMsg[ki].MsgLen / sizeof(uint32_t));
                 sent++;
             }
         }
@@ -541,21 +595,21 @@ void CCryptoControl::regenCryptoKm(bool sendit, bool bidirectional)
 
     if (sent)
         m_SndKmLastTime = srt::sync::steady_clock::now();
-}
 #endif
+}
 
-CCryptoControl::CCryptoControl(CUDT* parent, SRTSOCKET id):
-m_parent(parent), // should be initialized in createCC()
-m_SocketID(id),
-m_iSndKmKeyLen(0),
-m_iRcvKmKeyLen(0),
-m_SndKmState(SRT_KM_S_UNSECURED),
-m_RcvKmState(SRT_KM_S_UNSECURED),
-m_KmRefreshRatePkt(0),
-m_KmPreAnnouncePkt(0),
-m_bErrorReported(false)
+srt::CCryptoControl::CCryptoControl(SRTSOCKET id)
+    : m_SocketID(id)
+    , m_iSndKmKeyLen(0)
+    , m_iRcvKmKeyLen(0)
+    , m_SndKmState(SRT_KM_S_UNSECURED)
+    , m_RcvKmState(SRT_KM_S_UNSECURED)
+    , m_KmRefreshRatePkt(0)
+    , m_KmPreAnnouncePkt(0)
+    , m_iCryptoMode(CSrtConfig::CIPHER_MODE_AUTO)
+    , m_bUseGcm153(false)
+    , m_bErrorReported(false)
 {
-
     m_KmSecret.len = 0;
     //send
     m_SndKmMsg[0].MsgLen = 0;
@@ -567,7 +621,7 @@ m_bErrorReported(false)
     m_hRcvCrypto = NULL;
 }
 
-bool CCryptoControl::init(HandshakeSide side, bool bidirectional SRT_ATR_UNUSED)
+bool srt::CCryptoControl::init(HandshakeSide side, const CSrtConfig& cfg, bool bidirectional SRT_ATR_UNUSED, bool bUseGcm153 SRT_ATR_UNUSED)
 {
     // NOTE: initiator creates m_hSndCrypto. When bidirectional,
     // it creates also m_hRcvCrypto with the same key length.
@@ -580,14 +634,28 @@ bool CCryptoControl::init(HandshakeSide side, bool bidirectional SRT_ATR_UNUSED)
 
     // Set UNSECURED state as default
     m_RcvKmState = SRT_KM_S_UNSECURED;
+    m_iCryptoMode = cfg.iCryptoMode;
+    m_bUseGcm153 = bUseGcm153;
+
+#ifdef SRT_ENABLE_ENCRYPTION
+    if (!cfg.bTSBPD && m_iCryptoMode == CSrtConfig::CIPHER_MODE_AUTO)
+        m_iCryptoMode = CSrtConfig::CIPHER_MODE_AES_CTR;
+    const bool bUseGCM = m_iCryptoMode == CSrtConfig::CIPHER_MODE_AES_GCM;
+
+    if (bUseGCM && !isAESGCMSupported())
+    {
+        LOGC(cnlog.Warn, log << "CCryptoControl: AES GCM is not supported by the crypto service provider.");
+        return false;
+    }
+#endif
 
     // Set security-pending state, if a password was set.
     m_SndKmState = hasPassphrase() ? SRT_KM_S_SECURING : SRT_KM_S_UNSECURED;
 
-    m_KmPreAnnouncePkt = m_parent->m_uKmPreAnnouncePkt;
-    m_KmRefreshRatePkt = m_parent->m_uKmRefreshRatePkt;
+    m_KmPreAnnouncePkt = cfg.uKmPreAnnouncePkt;
+    m_KmRefreshRatePkt = cfg.uKmRefreshRatePkt;
 
-    if ( side == HSD_INITIATOR )
+    if (side == HSD_INITIATOR)
     {
         if (hasPassphrase())
         {
@@ -598,13 +666,13 @@ bool CCryptoControl::init(HandshakeSide side, bool bidirectional SRT_ATR_UNUSED)
                 m_iSndKmKeyLen = 16;
             }
 
-            bool ok = createCryptoCtx(m_iSndKmKeyLen, HAICRYPT_CRYPTO_DIR_TX, (m_hSndCrypto));
+            bool ok = createCryptoCtx((m_hSndCrypto), m_iSndKmKeyLen, HAICRYPT_CRYPTO_DIR_TX, bUseGCM);
             HLOGC(cnlog.Debug, log << "CCryptoControl::init: creating SND crypto context: " << ok);
 
             if (ok && bidirectional)
             {
                 m_iRcvKmKeyLen = m_iSndKmKeyLen;
-                int st = HaiCrypt_Clone(m_hSndCrypto, HAICRYPT_CRYPTO_DIR_RX, &m_hRcvCrypto);
+                const int st = HaiCrypt_Clone(m_hSndCrypto, HAICRYPT_CRYPTO_DIR_RX, &m_hRcvCrypto);
                 HLOGC(cnlog.Debug, log << "CCryptoControl::init: creating CLONED RCV crypto context: status=" << st);
                 ok = st == 0;
             }
@@ -620,15 +688,17 @@ bool CCryptoControl::init(HandshakeSide side, bool bidirectional SRT_ATR_UNUSED)
             }
 
             regenCryptoKm(
-                    false,  // Do not send the key (will be attached it to the HSv5 handshake)
-                    bidirectional // replicate the key to the receiver context, if bidirectional
-                    );
+                NULL, // Do not send the key (the KM msg will be attached to the HSv5 handshake)
+                bidirectional // replicate the key to the receiver context, if bidirectional
+            );
+
+            m_iCryptoMode = bUseGCM ? CSrtConfig::CIPHER_MODE_AES_GCM : CSrtConfig::CIPHER_MODE_AES_CTR;
 #else
             // This error would be a consequence of setting the passphrase, while encryption
             // is turned off at compile time. Setting the password itself should be not allowed
             // so this could only happen as a consequence of an IPE.
             LOGC(cnlog.Error, log << "CCryptoControl::init: IPE: encryption not supported");
-            return true;
+            return false;
 #endif
         }
         else
@@ -644,15 +714,16 @@ bool CCryptoControl::init(HandshakeSide side, bool bidirectional SRT_ATR_UNUSED)
     return true;
 }
 
-void CCryptoControl::close() 
+void srt::CCryptoControl::close() 
 {
     /* Wipeout secrets */
+    sync::ScopedLock lck(m_mtxLock);
     memset(&m_KmSecret, 0, sizeof(m_KmSecret));
 }
 
-std::string CCryptoControl::CONID() const
+std::string srt::CCryptoControl::CONID() const
 {
-    if ( m_SocketID == 0 )
+    if (m_SocketID == 0)
         return "";
 
     std::ostringstream os;
@@ -661,7 +732,10 @@ std::string CCryptoControl::CONID() const
     return os.str();
 }
 
+#ifdef SRT_ENABLE_ENCRYPTION
+
 #if ENABLE_HEAVY_LOGGING
+namespace srt {
 static std::string CryptoFlags(int flg)
 {
     using namespace std;
@@ -678,12 +752,11 @@ static std::string CryptoFlags(int flg)
     copy(f.begin(), f.end(), ostream_iterator<string>(os, "|"));
     return os.str();
 }
-#endif
+} // namespace srt
+#endif // ENABLE_HEAVY_LOGGING
 
-#ifdef SRT_ENABLE_ENCRYPTION
-bool CCryptoControl::createCryptoCtx(size_t keylen, HaiCrypt_CryptoDir cdir, HaiCrypt_Handle& w_hCrypto)
+bool srt::CCryptoControl::createCryptoCtx(HaiCrypt_Handle& w_hCrypto, size_t keylen, HaiCrypt_CryptoDir cdir, bool bAESGCM)
 {
-
     if (w_hCrypto)
     {
         // XXX You can check here if the existing handle represents
@@ -705,7 +778,7 @@ bool CCryptoControl::createCryptoCtx(size_t keylen, HaiCrypt_CryptoDir cdir, Hai
     m_KmRefreshRatePkt = 2000;
     m_KmPreAnnouncePkt = 500;
 #endif
-    crypto_cfg.flags = HAICRYPT_CFG_F_CRYPTO | (cdir == HAICRYPT_CRYPTO_DIR_TX ? HAICRYPT_CFG_F_TX : 0);
+    crypto_cfg.flags = HAICRYPT_CFG_F_CRYPTO | (cdir == HAICRYPT_CRYPTO_DIR_TX ? HAICRYPT_CFG_F_TX : 0) | (bAESGCM ? HAICRYPT_CFG_F_GCM : 0);
     crypto_cfg.xport = HAICRYPT_XPT_SRT;
     crypto_cfg.cryspr = HaiCryptCryspr_Get_Instance();
     crypto_cfg.key_len = (size_t)keylen;
@@ -714,7 +787,6 @@ bool CCryptoControl::createCryptoCtx(size_t keylen, HaiCrypt_CryptoDir cdir, Hai
     crypto_cfg.km_refresh_rate_pkt = m_KmRefreshRatePkt == 0 ? HAICRYPT_DEF_KM_REFRESH_RATE : m_KmRefreshRatePkt;
     crypto_cfg.km_pre_announce_pkt = m_KmPreAnnouncePkt == 0 ? SRT_CRYPT_KM_PRE_ANNOUNCE : m_KmPreAnnouncePkt;
     crypto_cfg.secret = m_KmSecret;
-    //memcpy(&crypto_cfg.secret, &m_KmSecret, sizeof(crypto_cfg.secret));
 
     HLOGC(cnlog.Debug, log << "CRYPTO CFG: flags=" << CryptoFlags(crypto_cfg.flags) << " xport=" << crypto_cfg.xport << " cryspr=" << crypto_cfg.cryspr
         << " keylen=" << crypto_cfg.key_len << " passphrase_length=" << crypto_cfg.secret.len);
@@ -730,26 +802,28 @@ bool CCryptoControl::createCryptoCtx(size_t keylen, HaiCrypt_CryptoDir cdir, Hai
     return true;
 }
 #else
-bool CCryptoControl::createCryptoCtx(size_t, HaiCrypt_CryptoDir, HaiCrypt_Handle&)
+bool srt::CCryptoControl::createCryptoCtx(HaiCrypt_Handle&, size_t, HaiCrypt_CryptoDir, bool)
 {
     return false;
 }
-#endif
+#endif // SRT_ENABLE_ENCRYPTION
 
 
-EncryptionStatus CCryptoControl::encrypt(CPacket& w_packet SRT_ATR_UNUSED)
+srt::EncryptionStatus srt::CCryptoControl::encrypt(CPacket& w_packet SRT_ATR_UNUSED)
 {
 #ifdef SRT_ENABLE_ENCRYPTION
     // Encryption not enabled - do nothing.
     if ( getSndCryptoFlags() == EK_NOENC )
         return ENCS_CLEAR;
 
+    // Note that in case of GCM the header has to zero Retransmitted Packet Flag (R).
+    // If TSBPD is disabled, timestamp also has to be zeroed.
     int rc = HaiCrypt_Tx_Data(m_hSndCrypto, ((uint8_t*)w_packet.getHeader()), ((uint8_t*)w_packet.m_pcData), w_packet.getLength());
     if (rc < 0)
     {
         return ENCS_FAILED;
     }
-    else if ( rc > 0 )
+    else if (rc > 0)
     {
         // XXX what happens if the encryption is said to be "succeeded",
         // but the length is 0? Shouldn't this be treated as unwanted?
@@ -762,7 +836,7 @@ EncryptionStatus CCryptoControl::encrypt(CPacket& w_packet SRT_ATR_UNUSED)
 #endif
 }
 
-EncryptionStatus CCryptoControl::decrypt(CPacket& w_packet SRT_ATR_UNUSED)
+srt::EncryptionStatus srt::CCryptoControl::decrypt(CPacket& w_packet SRT_ATR_UNUSED)
 {
 #ifdef SRT_ENABLE_ENCRYPTION
     if (w_packet.getMsgCryptoFlags() == EK_NOENC)
@@ -816,10 +890,10 @@ EncryptionStatus CCryptoControl::decrypt(CPacket& w_packet SRT_ATR_UNUSED)
         return ENCS_FAILED;
     }
 
-    int rc = HaiCrypt_Rx_Data(m_hRcvCrypto, ((uint8_t *)w_packet.getHeader()), ((uint8_t *)w_packet.m_pcData), w_packet.getLength());
-    if ( rc <= 0 )
+    const int rc = HaiCrypt_Rx_Data(m_hRcvCrypto, ((uint8_t *)w_packet.getHeader()), ((uint8_t *)w_packet.m_pcData), w_packet.getLength());
+    if (rc <= 0)
     {
-        LOGC(cnlog.Error, log << "decrypt ERROR (IPE): HaiCrypt_Rx_Data failure=" << rc << " - returning failed decryption");
+        LOGC(cnlog.Note, log << "decrypt ERROR: HaiCrypt_Rx_Data failure=" << rc << " - returning failed decryption");
         // -1: decryption failure
         // 0: key not received yet
         return ENCS_FAILED;
@@ -838,7 +912,7 @@ EncryptionStatus CCryptoControl::decrypt(CPacket& w_packet SRT_ATR_UNUSED)
 }
 
 
-CCryptoControl::~CCryptoControl()
+srt::CCryptoControl::~CCryptoControl()
 {
 #ifdef SRT_ENABLE_ENCRYPTION
     close();
@@ -853,38 +927,3 @@ CCryptoControl::~CCryptoControl()
     }
 #endif
 }
-
-
-std::string SrtFlagString(int32_t flags)
-{
-#define LEN(arr) (sizeof (arr)/(sizeof ((arr)[0])))
-
-    std::string output;
-    static std::string namera[] = { "TSBPD-snd", "TSBPD-rcv", "haicrypt", "TLPktDrop", "NAKReport", "ReXmitFlag", "StreamAPI" };
-
-    size_t i = 0;
-    for ( ; i < LEN(namera); ++i )
-    {
-        if ( (flags & 1) == 1 )
-        {
-            output += "+" + namera[i] + " ";
-        }
-        else
-        {
-            output += "-" + namera[i] + " ";
-        }
-
-        flags >>= 1;
-       //if ( flags == 0 )
-       //    break;
-    }
-
-#undef LEN
-
-    if ( flags != 0 )
-    {
-        output += "+unknown";
-    }
-
-    return output;
-}
diff --git a/srtcore/crypto.h b/srtcore/crypto.h
index 9d1dafc3d..613ded8dd 100644
--- a/srtcore/crypto.h
+++ b/srtcore/crypto.h
@@ -38,23 +38,24 @@ extern Logger cnlog;
 #endif
 }
 
+namespace srt
+{
+class CUDT;
+struct CSrtConfig;
+
 
 // For KMREQ/KMRSP. Only one field is used.
 const size_t SRT_KMR_KMSTATE = 0;
 
 #define SRT_CMD_MAXSZ       HCRYPT_MSG_KM_MAX_SZ  /* Maximum SRT custom messages payload size (bytes) */
-const size_t SRTDATA_MAXSIZE = SRT_CMD_MAXSZ/sizeof(int32_t);
-
-enum Whether2RegenKm {DONT_REGEN_KM = 0, REGEN_KM = 1};
+const size_t SRTDATA_MAXSIZE = SRT_CMD_MAXSZ/sizeof(uint32_t);
 
 class CCryptoControl
 {
-//public:
-    class CUDT* m_parent;
-    SRTSOCKET   m_SocketID;
+    SRTSOCKET m_SocketID;
 
-    size_t      m_iSndKmKeyLen;        //Key length
-    size_t      m_iRcvKmKeyLen;        //Key length from rx KM
+    size_t    m_iSndKmKeyLen;        //Key length
+    size_t    m_iRcvKmKeyLen;        //Key length from rx KM
 
     // Temporarily allow these to be accessed.
 public:
@@ -66,10 +67,13 @@ class CCryptoControl
     // putting the whole HaiCrypt_Cfg object here.
     int m_KmRefreshRatePkt;
     int m_KmPreAnnouncePkt;
+    int m_iCryptoMode;
+    bool m_bUseGcm153; // Older AES-GCM version existed up to SRT v1.5.3.
 
     HaiCrypt_Secret m_KmSecret;     //Key material shared secret
     // Sender
-    srt::sync::steady_clock::time_point     m_SndKmLastTime;
+    sync::steady_clock::time_point m_SndKmLastTime;
+    sync::Mutex m_mtxLock; // A mutex to protect concurrent access to CCryptoControl.
     struct {
         unsigned char Msg[HCRYPT_MSG_KM_MAX_SZ];
         size_t MsgLen;
@@ -82,6 +86,9 @@ class CCryptoControl
     bool m_bErrorReported;
 
 public:
+    static void globalInit();
+
+    static bool isAESGCMSupported();
 
     bool sendingAllowed()
     {
@@ -105,28 +112,34 @@ class CCryptoControl
         return m_KmSecret.len > 0;
     }
 
-private:
-
-#ifdef SRT_ENABLE_ENCRYPTION
-    void regenCryptoKm(bool sendit, bool bidirectional);
-#endif
+    int getCryptoMode() const
+    {
+        return m_iCryptoMode;
+    }
 
-public:
+    /// Regenerate cryptographic key material if needed.
+    /// @param[in] sock If not null, the socket will be used to send the KM message to the peer (e.g. KM refresh).
+    /// @param[in] bidirectional If true, the key material will be regenerated for both directions (receiver and sender).
+    SRT_ATTR_EXCLUDES(m_mtxLock)
+    void regenCryptoKm(CUDT* sock, bool bidirectional);
 
     size_t KeyLen() { return m_iSndKmKeyLen; }
 
     // Needed for CUDT
     void updateKmState(int cmd, size_t srtlen);
 
-    // Detailed processing
-    int processSrtMsg_KMREQ(const uint32_t* srtdata, size_t len, int hsv,
+    /// Process the KM request message.
+    /// @param srtv peer's SRT version.
+    int processSrtMsg_KMREQ(const uint32_t* srtdata, size_t len, int hsv, unsigned srtv,
             uint32_t srtdata_out[], size_t&);
 
-    // This returns:
-    // 1 - the given payload is the same as the currently used key
-    // 0 - there's no key in agent or the payload is error message with agent NOSECRET.
-    // -1 - the payload is error message with other state or it doesn't match the key
-    int processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, int hsv);
+    /// Process the KM response message.
+    /// @param srtv peer's SRT version.
+    /// @returns
+    /// 1 - the given payload is the same as the currently used key
+    /// 0 - there's no key in agent or the payload is error message with agent NOSECRET.
+    /// -1 - the payload is error message with other state or it doesn't match the key
+    int processSrtMsg_KMRSP(const uint32_t* srtdata, size_t len, unsigned srtv);
     void createFakeSndContext();
 
     const unsigned char* getKmMsg_data(size_t ki) const { return m_SndKmMsg[ki].Msg; }
@@ -162,7 +175,7 @@ class CCryptoControl
         using srt_logging::cnlog;
 #endif
 
-        m_SndKmLastTime = srt::sync::steady_clock::now();
+        m_SndKmLastTime = sync::steady_clock::now();
         if (runtime)
         {
             m_SndKmMsg[ki].iPeerRetry--;
@@ -192,25 +205,28 @@ class CCryptoControl
         return false;
     }
 
-    CCryptoControl(CUDT* parent, SRTSOCKET id);
+    CCryptoControl(SRTSOCKET id);
 
     // DEBUG PURPOSES:
     std::string CONID() const;
     std::string FormatKmMessage(std::string hdr, int cmd, size_t srtlen);
 
-    bool init(HandshakeSide, bool);
+    bool init(HandshakeSide, const CSrtConfig&, bool bidir, bool bUseGcm153);
+    SRT_ATTR_EXCLUDES(m_mtxLock)
     void close();
 
-    // This function is used in:
-    // - HSv4 (initial key material exchange - in HSv5 it's attached to handshake)
-    // - case of key regeneration, which should be then exchanged again
-    void sendKeysToPeer(Whether2RegenKm regen);
-
+    /// (Re)send KM request to a peer on timeout.
+    /// This function is used in:
+    /// - HSv4 (initial key material exchange - in HSv5 it's attached to handshake).
+    /// - The case of key regeneration (KM refresh), when a new key has to be sent again.
+    ///   In this case the first sending happens in regenCryptoKm(..). This function
+    ///   retransmits the KM request by timeout if not KM response has been received.
+    SRT_ATTR_EXCLUDES(m_mtxLock)
+    void sendKeysToPeer(CUDT* sock, int iSRTT);
 
     void setCryptoSecret(const HaiCrypt_Secret& secret)
     {
         m_KmSecret = secret;
-        //memcpy(&m_KmSecret, &secret, sizeof(m_KmSecret));
     }
 
     void setCryptoKeylen(size_t keylen)
@@ -219,7 +235,7 @@ class CCryptoControl
         m_iRcvKmKeyLen = keylen;
     }
 
-    bool createCryptoCtx(size_t keylen, HaiCrypt_CryptoDir tx, HaiCrypt_Handle& rh);
+    bool createCryptoCtx(HaiCrypt_Handle& rh, size_t keylen, HaiCrypt_CryptoDir tx, bool bAESGCM);
 
     int getSndCryptoFlags() const
     {
@@ -266,4 +282,6 @@ class CCryptoControl
     ~CCryptoControl();
 };
 
+} // namespace srt
+
 #endif // SRT_CONGESTION_CONTROL_H
diff --git a/srtcore/epoll.cpp b/srtcore/epoll.cpp
index 9d2317c0d..8cd8440c7 100644
--- a/srtcore/epoll.cpp
+++ b/srtcore/epoll.cpp
@@ -58,19 +58,19 @@ modified by
 #include <cstring>
 #include <iterator>
 
+#if defined(__FreeBSD_kernel__)
+#include <sys/event.h>
+#endif
+
 #include "common.h"
 #include "epoll.h"
 #include "logging.h"
 #include "udt.h"
-#include "logging.h"
+#include "utilities.h"
 
 using namespace std;
 using namespace srt::sync;
 
-#if ENABLE_HEAVY_LOGGING
-static ostream& PrintEpollEvent(ostream& os, int events, int et_events = 0);
-#endif
-
 namespace srt_logging
 {
     extern Logger eilog, ealog;
@@ -82,19 +82,19 @@ using namespace srt_logging;
 #define IF_DIRNAME(tested, flag, name) (tested & flag ? name : "")
 #endif
 
-CEPoll::CEPoll():
+srt::CEPoll::CEPoll():
 m_iIDSeed(0)
 {
    // Exception -> CUDTUnited ctor.
    setupMutex(m_EPollLock, "EPoll");
 }
 
-CEPoll::~CEPoll()
+srt::CEPoll::~CEPoll()
 {
    releaseMutex(m_EPollLock);
 }
 
-int CEPoll::create(CEPollDesc** pout)
+int srt::CEPoll::create(CEPollDesc** pout)
 {
    ScopedLock pg(m_EPollLock);
 
@@ -108,7 +108,31 @@ int CEPoll::create(CEPollDesc** pout)
    int localid = 0;
 
    #ifdef LINUX
-   localid = epoll_create(1024);
+
+   // NOTE: epoll_create1() and EPOLL_CLOEXEC were introduced in GLIBC-2.9.
+   //    So earlier versions of GLIBC, must use epoll_create() and set
+   //       FD_CLOEXEC on the file descriptor returned by it after the fact.
+   #if defined(EPOLL_CLOEXEC)
+      int flags = 0;
+      #if ENABLE_SOCK_CLOEXEC
+      flags |= EPOLL_CLOEXEC;
+      #endif
+      localid = epoll_create1(flags);
+   #else
+      localid = epoll_create(1);
+      #if ENABLE_SOCK_CLOEXEC
+      if (localid != -1)
+      {
+         int fdFlags = fcntl(localid, F_GETFD);
+         if (fdFlags != -1)
+         {
+            fdFlags |= FD_CLOEXEC;
+            fcntl(localid, F_SETFD, fdFlags);
+         }
+      }
+      #endif
+   #endif
+
    /* Possible reasons of -1 error:
 EMFILE: The per-user limit on the number of epoll instances imposed by /proc/sys/fs/epoll/max_user_instances was encountered.
 ENFILE: The system limit on the total number of open files has been reached.
@@ -121,7 +145,8 @@ ENOMEM: There was insufficient memory to create the kernel object.
    if (localid < 0)
       throw CUDTException(MJ_SETUP, MN_NONE, errno);
    #else
-   // on Solaris, use /dev/poll
+   // TODO: Solaris, use port_getn()
+   //    https://docs.oracle.com/cd/E86824_01/html/E54766/port-get-3c.html
    // on Windows, select
    #endif
 
@@ -134,7 +159,7 @@ ENOMEM: There was insufficient memory to create the kernel object.
    return m_iIDSeed;
 }
 
-int CEPoll::clear_usocks(int eid)
+int srt::CEPoll::clear_usocks(int eid)
 {
     // This should remove all SRT sockets from given eid.
    ScopedLock pg (m_EPollLock);
@@ -151,7 +176,7 @@ int CEPoll::clear_usocks(int eid)
 }
 
 
-void CEPoll::clear_ready_usocks(CEPollDesc& d, int direction)
+void srt::CEPoll::clear_ready_usocks(CEPollDesc& d, int direction)
 {
     if ((direction & ~SRT_EPOLL_EVENTTYPES) != 0)
     {
@@ -184,11 +209,11 @@ void CEPoll::clear_ready_usocks(CEPollDesc& d, int direction)
         }
     }
 
-    for (size_t i = 0; i < cleared.size(); ++i)
-        d.removeSubscription(cleared[i]);
+    for (size_t j = 0; j < cleared.size(); ++j)
+        d.removeSubscription(cleared[j]);
 }
 
-int CEPoll::add_ssock(const int eid, const SYSSOCKET& s, const int* events)
+int srt::CEPoll::add_ssock(const int eid, const SYSSOCKET& s, const int* events)
 {
    ScopedLock pg(m_EPollLock);
 
@@ -260,7 +285,7 @@ int CEPoll::add_ssock(const int eid, const SYSSOCKET& s, const int* events)
    return 0;
 }
 
-int CEPoll::remove_ssock(const int eid, const SYSSOCKET& s)
+int srt::CEPoll::remove_ssock(const int eid, const SYSSOCKET& s)
 {
    ScopedLock pg(m_EPollLock);
 
@@ -291,7 +316,7 @@ int CEPoll::remove_ssock(const int eid, const SYSSOCKET& s)
 }
 
 // Need this to atomically modify polled events (ex: remove write/keep read)
-int CEPoll::update_usock(const int eid, const SRTSOCKET& u, const int* events)
+int srt::CEPoll::update_usock(const int eid, const SRTSOCKET& u, const int* events)
 {
     ScopedLock pg(m_EPollLock);
     IF_HEAVY_LOGGING(ostringstream evd);
@@ -363,7 +388,7 @@ int CEPoll::update_usock(const int eid, const SRTSOCKET& u, const int* events)
     return 0;
 }
 
-int CEPoll::update_ssock(const int eid, const SYSSOCKET& s, const int* events)
+int srt::CEPoll::update_ssock(const int eid, const SYSSOCKET& s, const int* events)
 {
    ScopedLock pg(m_EPollLock);
 
@@ -434,7 +459,7 @@ int CEPoll::update_ssock(const int eid, const SYSSOCKET& s, const int* events)
    return 0;
 }
 
-int CEPoll::setflags(const int eid, int32_t flags)
+int srt::CEPoll::setflags(const int eid, int32_t flags)
 {
     ScopedLock pg(m_EPollLock);
     map<int, CEPollDesc>::iterator p = m_mPolls.find(eid);
@@ -459,7 +484,7 @@ int CEPoll::setflags(const int eid, int32_t flags)
     return oflags;
 }
 
-int CEPoll::uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut)
+int srt::CEPoll::uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut)
 {
     // It is allowed to call this function witn fdsSize == 0
     // and therefore also NULL fdsSet. This will then only report
@@ -524,7 +549,7 @@ int CEPoll::uwait(const int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t m
     return 0;
 }
 
-int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefds, int64_t msTimeOut, set<SYSSOCKET>* lrfds, set<SYSSOCKET>* lwfds)
+int srt::CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefds, int64_t msTimeOut, set<SYSSOCKET>* lrfds, set<SYSSOCKET>* lwfds)
 {
     // if all fields is NULL and waiting time is infinite, then this would be a deadlock
     if (!readfds && !writefds && !lrfds && !lwfds && (msTimeOut < 0))
@@ -608,9 +633,9 @@ int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefd
             {
 #ifdef LINUX
                 const int max_events = ed.m_sLocals.size();
-                SRT_ASSERT(max_event > 0);
-                epoll_event ev[max_events];
-                int nfds = ::epoll_wait(ed.m_iLocalID, ev, max_events, 0);
+                SRT_ASSERT(max_events > 0);
+                srt::FixedArray<epoll_event> ev(max_events);
+                int nfds = ::epoll_wait(ed.m_iLocalID, ev.data(), ev.size(), 0);
 
                 IF_HEAVY_LOGGING(const int prev_total = total);
                 for (int i = 0; i < nfds; ++ i)
@@ -630,23 +655,23 @@ int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefd
 
 #elif defined(BSD) || TARGET_OS_MAC
                 struct timespec tmout = {0, 0};
-                const int max_events = ed.m_sLocals.size();
-                SRT_ASSERT(max_event > 0);
-                struct kevent ke[max_events];
+                const int max_events = (int)ed.m_sLocals.size();
+                SRT_ASSERT(max_events > 0);
+                srt::FixedArray<struct kevent> ke(max_events);
 
-                int nfds = kevent(ed.m_iLocalID, NULL, 0, ke, max_events, &tmout);
+                int nfds = kevent(ed.m_iLocalID, NULL, 0, ke.data(), (int)ke.size(), &tmout);
                 IF_HEAVY_LOGGING(const int prev_total = total);
 
                 for (int i = 0; i < nfds; ++ i)
                 {
                     if ((NULL != lrfds) && (ke[i].filter == EVFILT_READ))
                     {
-                        lrfds->insert(ke[i].ident);
+                        lrfds->insert((int)ke[i].ident);
                         ++ total;
                     }
                     if ((NULL != lwfds) && (ke[i].filter == EVFILT_WRITE))
                     {
-                        lwfds->insert(ke[i].ident);
+                        lwfds->insert((int)ke[i].ident);
                         ++ total;
                     }
                 }
@@ -672,7 +697,7 @@ int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefd
                     if (lwfds)
                         FD_SET(*i, &rqwritefds);
                     if ((int)*i > max_fd)
-                        max_fd = *i;
+                        max_fd = (int)*i;
                 }
 
                 IF_HEAVY_LOGGING(const int prev_total = total);
@@ -713,7 +738,7 @@ int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefd
             throw CUDTException(MJ_AGAIN, MN_XMTIMEOUT, 0);
         }
 
-        const bool wait_signaled ATR_UNUSED = CGlobEvent::waitForEvent();
+        const bool wait_signaled SRT_ATR_UNUSED = CGlobEvent::waitForEvent();
         HLOGC(ealog.Debug, log << "CEPoll::wait: EVENT WAITING: "
             << (wait_signaled ? "TRIGGERED" : "CHECKPOINT"));
     }
@@ -721,7 +746,7 @@ int CEPoll::wait(const int eid, set<SRTSOCKET>* readfds, set<SRTSOCKET>* writefd
     return 0;
 }
 
-int CEPoll::swait(CEPollDesc& d, map<SRTSOCKET, int>& st, int64_t msTimeOut, bool report_by_exception)
+int srt::CEPoll::swait(CEPollDesc& d, map<SRTSOCKET, int>& st, int64_t msTimeOut, bool report_by_exception)
 {
     {
         ScopedLock lg (m_EPollLock);
@@ -779,7 +804,7 @@ int CEPoll::swait(CEPollDesc& d, map<SRTSOCKET, int>& st, int64_t msTimeOut, boo
                     st[i->fd] = i->events;
                     IF_HEAVY_LOGGING(singles << "@" << i->fd << ":");
                     IF_HEAVY_LOGGING(PrintEpollEvent(singles, i->events, i->parent->edgeOnly()));
-                    const bool edged ATR_UNUSED = d.checkEdge(i++); // NOTE: potentially deletes `i`
+                    const bool edged SRT_ATR_UNUSED = d.checkEdge(i++); // NOTE: potentially deletes `i`
                     IF_HEAVY_LOGGING(singles << (edged ? "<^> " : " "));
                 }
 
@@ -808,7 +833,13 @@ int CEPoll::swait(CEPollDesc& d, map<SRTSOCKET, int>& st, int64_t msTimeOut, boo
     return 0;
 }
 
-int CEPoll::release(const int eid)
+bool srt::CEPoll::empty(const CEPollDesc& d) const
+{
+    ScopedLock lg (m_EPollLock);
+    return d.watch_empty();
+}
+
+int srt::CEPoll::release(const int eid)
 {
    ScopedLock pg(m_EPollLock);
 
@@ -829,7 +860,7 @@ int CEPoll::release(const int eid)
 }
 
 
-int CEPoll::update_events(const SRTSOCKET& uid, std::set<int>& eids, const int events, const bool enable)
+int srt::CEPoll::update_events(const SRTSOCKET& uid, std::set<int>& eids, const int events, const bool enable)
 {
     // As event flags no longer contain only event types, check now.
     if ((events & ~SRT_EPOLL_EVENTTYPES) != 0)
@@ -916,30 +947,8 @@ int CEPoll::update_events(const SRTSOCKET& uid, std::set<int>& eids, const int e
 
 // Debug use only.
 #if ENABLE_HEAVY_LOGGING
-static ostream& PrintEpollEvent(ostream& os, int events, int et_events)
+namespace srt
 {
-    static pair<int, const char*> const namemap [] = {
-        make_pair(SRT_EPOLL_IN, "R"),
-        make_pair(SRT_EPOLL_OUT, "W"),
-        make_pair(SRT_EPOLL_ERR, "E"),
-        make_pair(SRT_EPOLL_UPDATE, "U")
-    };
-
-    int N = Size(namemap);
-
-    for (int i = 0; i < N; ++i)
-    {
-        if (events & namemap[i].first)
-        {
-            os << "[";
-            if (et_events & namemap[i].first)
-                os << "^";
-            os << namemap[i].second << "]";
-        }
-    }
-
-    return os;
-}
 
 string DisplayEpollResults(const std::map<SRTSOCKET, int>& sockset)
 {
@@ -968,4 +977,6 @@ string CEPollDesc::DisplayEpollWatch()
     return os.str();
 }
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/epoll.h b/srtcore/epoll.h
index 97fe22b5c..00d46ceb4 100644
--- a/srtcore/epoll.h
+++ b/srtcore/epoll.h
@@ -59,11 +59,21 @@ modified by
 #include <list>
 #include "udt.h"
 
+namespace srt
+{
+
+class CUDT;
+class CRendezvousQueue;
+class CUDTGroup;
+
 
-struct CEPollDesc
+class CEPollDesc
 {
+#ifdef __GNUG__
    const int m_iID;                                // epoll ID
-
+#else
+   const int m_iID SRT_ATR_UNUSED;                 // epoll ID
+#endif
    struct Wait;
 
    struct Notice: public SRT_EPOLL_EVENT
@@ -143,8 +153,6 @@ struct CEPollDesc
 std::string DisplayEpollWatch();
 #endif
 
-private:
-
    /// Sockets that are subscribed for events in this eid.
    ewatch_t m_USockWatchState;
 
@@ -159,7 +167,10 @@ std::string DisplayEpollWatch();
 
    enotice_t::iterator nullNotice() { return m_USockEventNotice.end(); }
 
-public:
+   // Only CEPoll class should have access to it.
+   // Guarding private access to the class is not necessary
+   // within the epoll module.
+   friend class CEPoll;
 
    CEPollDesc(int id, int localID)
        : m_iID(id)
@@ -349,9 +360,9 @@ std::string DisplayEpollWatch();
 
 class CEPoll
 {
-friend class CUDT;
-friend class CUDTGroup;
-friend class CRendezvousQueue;
+friend class srt::CUDT;
+friend class srt::CUDTGroup;
+friend class srt::CRendezvousQueue;
 
 public:
    CEPoll();
@@ -423,6 +434,9 @@ friend class CRendezvousQueue;
    /// @retval >=0 number of ready sockets (actually size of `st`)
    int swait(CEPollDesc& d, fmap_t& st, int64_t msTimeOut, bool report_by_exception = true);
 
+   /// Empty subscription check - for internal use only.
+   bool empty(const CEPollDesc& d) const;
+
    /// Reports which events are ready on the given socket.
    /// @param mp socket event map retirned by `swait`
    /// @param sock which socket to ask
@@ -482,12 +496,14 @@ friend class CRendezvousQueue;
    srt::sync::Mutex m_SeedLock;
 
    std::map<int, CEPollDesc> m_mPolls;       // all epolls
-   srt::sync::Mutex m_EPollLock;
+   mutable srt::sync::Mutex m_EPollLock;
 };
 
 #if ENABLE_HEAVY_LOGGING
 std::string DisplayEpollResults(const std::map<SRTSOCKET, int>& sockset);
 #endif
 
+} // namespace srt
+
 
 #endif
diff --git a/srtcore/fec.cpp b/srtcore/fec.cpp
index 308f45b75..fd762b88b 100644
--- a/srtcore/fec.cpp
+++ b/srtcore/fec.cpp
@@ -14,6 +14,7 @@
 #include <map>
 #include <vector>
 #include <deque>
+#include <iterator>
 
 #include "packetfilter.h"
 #include "core.h"
@@ -22,9 +23,106 @@
 
 #include "fec.h"
 
+// Maximum allowed "history" remembered in the receiver groups.
+// This is calculated in series, that is, this number will be
+// multiplied by sizeRow() and sizeCol() to get the value being
+// a maximum distance between the FEC group base sequence and
+// the sequence to which a request comes in.
+
+// XXX Might be that this parameter should be configurable
+#define SRT_FEC_MAX_RCV_HISTORY 10
+
 using namespace std;
 using namespace srt_logging;
 
+namespace srt {
+
+const char FECFilterBuiltin::defaultConfig [] = "fec,rows:1,layout:staircase,arq:onreq";
+
+struct StringKeys
+{
+    string operator()(const pair<const string, const string> item)
+    {
+        return item.first;
+    }
+};
+
+bool FECFilterBuiltin::verifyConfig(const SrtFilterConfig& cfg, string& w_error)
+{
+    string arspec = map_get(cfg.parameters, "layout");
+
+    if (arspec != "" && arspec != "even" && arspec != "staircase")
+    {
+        w_error = "value for 'layout' must be 'even' or 'staircase'";
+        return false;
+    }
+
+    string colspec = map_get(cfg.parameters, "cols"), rowspec = map_get(cfg.parameters, "rows");
+
+    int out_rows = 1;
+
+    if (colspec != "")
+    {
+        int out_cols = atoi(colspec.c_str());
+        if (out_cols < 2)
+        {
+            w_error = "at least 'cols' must be specified and > 1";
+            return false;
+        }
+    }
+
+    if (rowspec != "")
+    {
+        out_rows = atoi(rowspec.c_str());
+        if (out_rows >= -1 && out_rows < 1)
+        {
+            w_error = "'rows' must be >=1 or negative < -1";
+            return false;
+        }
+    }
+
+    // Extra interpret level, if found, default never.
+    // Check only those that are managed.
+    string level = map_get(cfg.parameters, "arq");
+    if (level != "")
+    {
+        static const char* const levelnames [] = {"never", "onreq", "always"};
+        size_t i = 0;
+        for (i = 0; i < Size(levelnames); ++i)
+        {
+            if (strcmp(level.c_str(), levelnames[i]) == 0)
+                break;
+        }
+
+        if (i == Size(levelnames))
+        {
+            w_error = "'arq' value '" + level + "' invalid. Allowed: never, onreq, always";
+            return false;
+        }
+    }
+
+    set<string> keys;
+    transform(cfg.parameters.begin(), cfg.parameters.end(), inserter(keys, keys.begin()), StringKeys());
+
+    // Delete all default parameters
+    SrtFilterConfig defconf;
+    ParseFilterConfig(defaultConfig, (defconf));
+    for (map<string,string>::const_iterator i = defconf.parameters.begin();
+            i != defconf.parameters.end(); ++i)
+        keys.erase(i->first);
+
+    // Delete mandatory parameters
+    keys.erase("cols");
+
+    if (!keys.empty())
+    {
+        w_error = "Extra parameters. Allowed only: cols, rows, layout, arq";
+        return false;
+    }
+
+    return true;
+}
+
 FECFilterBuiltin::FECFilterBuiltin(const SrtFilterInitializer &init, std::vector<SrtPacket> &provided, const string &confstr)
     : SrtPacketFilterBase(init)
     , m_fallback_level(SRT_ARQ_ONREQ)
@@ -34,6 +132,13 @@ FECFilterBuiltin::FECFilterBuiltin(const SrtFilterInitializer &init, std::vector
     if (!ParseFilterConfig(confstr, cfg))
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
+    string ermsg;
+    if (!verifyConfig(cfg, (ermsg)))
+    {
+        LOGC(pflog.Error, log << "IPE: Filter config failed: " << ermsg);
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
     // Configuration supported:
     // - row only (number_rows == 1)
     // - columns only, no row FEC/CTL (number_rows < -1)
@@ -48,33 +153,23 @@ FECFilterBuiltin::FECFilterBuiltin(const SrtFilterInitializer &init, std::vector
     string shorter = arspec.size() > 5 ? arspec.substr(0, 5) : arspec;
     if (shorter == "even")
         m_arrangement_staircase = false;
-    else if (shorter != "" && shorter != "stair")
-    {
-        LOGC(pflog.Error, log << "FILTER/FEC: CONFIG: value for 'layout' must be 'even' or 'staircase'");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-    }
 
     string colspec = map_get(cfg.parameters, "cols"), rowspec = map_get(cfg.parameters, "rows");
 
-    int out_rows = 1;
-    int out_cols = atoi(colspec.c_str());
-
-    if (colspec == "" || out_cols < 2)
+    if (colspec == "")
     {
-        LOGC(pflog.Error, log << "FILTER/FEC: CONFIG: at least 'cols' must be specified and > 1");
+        LOGC(pflog.Error, log << "FEC filter config: parameter 'cols' is mandatory");
         throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
     }
 
+    int out_rows = 1;
+    int out_cols = atoi(colspec.c_str());
+
     m_number_cols = out_cols;
 
     if (rowspec != "")
     {
         out_rows = atoi(rowspec.c_str());
-        if (out_rows >= -1 && out_rows < 1)
-        {
-            LOGC(pflog.Error, log << "FILTER/FEC: CONFIG: 'rows' must be >=1 or negative < -1");
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        }
     }
 
     if (out_rows < 0)
@@ -100,17 +195,14 @@ FECFilterBuiltin::FECFilterBuiltin(const SrtFilterInitializer &init, std::vector
         {
             if (level == levelnames[i])
             {
-                lv = i;
+                lv = int(i);
                 break;
             }
         }
+    }
 
-        if (lv == -1)
-        {
-            LOGC(pflog.Error, log << "FILTER/FEC: CONFIG: 'arq': value '" << level << "' unknown");
-            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-        }
-
+    if (lv != -1)
+    {
         m_fallback_level = SRT_ARQLevel(lv);
     }
     else
@@ -118,7 +210,6 @@ FECFilterBuiltin::FECFilterBuiltin(const SrtFilterInitializer &init, std::vector
         m_fallback_level = SRT_ARQ_ONREQ;
     }
 
-
     // Required to store in the header when rebuilding
     rcv.id = socketID();
 
@@ -244,7 +335,7 @@ void FECFilterBuiltin::ConfigureColumns(Container& which, int32_t isn)
 
     for (size_t i = zero; i < which.size(); ++i)
     {
-        int32_t seq = CSeqNo::incseq(isn, offset);
+        int32_t seq = CSeqNo::incseq(isn, int(offset));
         size_t col = i - zero;
 
         HLOGC(pflog.Debug, log << "ConfigureColumns: [" << col << "]: -> ConfigureGroup...");
@@ -253,14 +344,14 @@ void FECFilterBuiltin::ConfigureColumns(Container& which, int32_t isn)
         if (col % numberRows() == numberRows() - 1)
         {
             offset = col + 1; // +1 because we want it for the next column
-            HLOGC(pflog.Debug, log << "ConfigureColumns: [" << (col+1) << "]... (resetting to row 0: +"
-                    << offset << " %" << CSeqNo::incseq(isn, offset) << ")");
+            HLOGC(pflog.Debug, log << "ConfigureColumns: [" << (int(col)+1) << "]... (resetting to row 0: +"
+                    << offset << " %" << CSeqNo::incseq(isn, (int32_t)offset) << ")");
         }
         else
         {
             offset += 1 + sizeRow();
-            HLOGC(pflog.Debug, log << "ConfigureColumns: [" << (col+1) << "] ... (continue +"
-                    << offset << " %" << CSeqNo::incseq(isn, offset) << ")");
+            HLOGC(pflog.Debug, log << "ConfigureColumns: [" << (int(col)+1) << "] ... (continue +"
+                    << offset << " %" << CSeqNo::incseq(isn, (int32_t)offset) << ")");
         }
     }
 }
@@ -293,7 +384,7 @@ void FECFilterBuiltin::ConfigureGroup(Group& g, int32_t seqno, size_t gstep, siz
 
 void FECFilterBuiltin::ResetGroup(Group& g)
 {
-    int32_t new_seq_base = CSeqNo::incseq(g.base, g.drop);
+    const int32_t new_seq_base = CSeqNo::incseq(g.base, int(g.drop));
 
     HLOGC(pflog.Debug, log << "FEC: ResetGroup (step=" << g.step << "): base %" << g.base << " -> %" << new_seq_base);
 
@@ -362,7 +453,9 @@ void FECFilterBuiltin::feedSource(CPacket& packet)
     HLOGC(pflog.Debug, log << "FEC:feedSource: %" << packet.getSeqNo() << " rowoff=" << baseoff
             << " column=" << vert_gx << " .base=%" << vert_base << " coloff=" << vert_off);
 
-    if (vert_off >= 0 && sizeCol() > 1)
+    // [[assert sizeCol() >= 2]]; // see the condition above.
+
+    if (vert_off >= 0)
     {
         // BEWARE! X % Y with different signedness upgrades int to unsigned!
 
@@ -377,7 +470,8 @@ void FECFilterBuiltin::feedSource(CPacket& packet)
             return;
         }
 
-        int vert_pos = vert_off / sizeRow();
+        // [[assert vert_off >= 0]]; // this condition branch
+        int vert_pos = vert_off / int(sizeRow());
 
         HLOGC(pflog.Debug, log << "FEC:feedSource: %" << packet.getSeqNo()
                 << " B:%" << baseoff << " H:*[" << horiz_pos << "] V(B=%" << vert_base
@@ -404,7 +498,6 @@ void FECFilterBuiltin::feedSource(CPacket& packet)
     }
     else
     {
-
         HLOGC(pflog.Debug, log << "FEC:feedSource: %" << packet.getSeqNo()
                 << " B:%" << baseoff << " H:*[" << horiz_pos << "] V(B=%" << vert_base
                 << ")[col=" << vert_gx << "]<NO-COLUMN>"
@@ -429,7 +522,7 @@ void FECFilterBuiltin::ClipPacket(Group& g, const CPacket& pkt)
     // Both length and timestamp must be taken as NETWORK ORDER
     // before applying the clip.
 
-    uint16_t length_net = htons(pkt.size());
+    uint16_t length_net = htons(uint16_t(pkt.size()));
     uint8_t kflg = uint8_t(pkt.getMsgCryptoFlags());
 
     // NOTE: Unlike length, the TIMESTAMP is NOT endian-reordered
@@ -478,7 +571,7 @@ void FECFilterBuiltin::ClipControlPacket(Group& g, const CPacket& pkt)
 
 void FECFilterBuiltin::ClipRebuiltPacket(Group& g, Receive::PrivPacket& pkt)
 {
-    uint16_t length_net = htons(pkt.length);
+    uint16_t length_net = htons(uint16_t(pkt.length));
     uint8_t kflg = MSGNO_ENCKEYSPEC::unwrap(pkt.hdr[SRT_PH_MSGNO]);
 
     // NOTE: Unlike length, the TIMESTAMP is NOT endian-reordered
@@ -505,6 +598,9 @@ void FECFilterBuiltin::ClipData(Group& g, uint16_t length_net, uint8_t kflg,
     g.flag_clip = g.flag_clip ^ kflg;
     g.timestamp_clip = g.timestamp_clip ^ timestamp_hw;
 
+    HLOGC(pflog.Debug, log << "FEC CLIP: data pkt.size=" << payload_size
+            << " to a clip buffer size=" << payloadSize());
+
     // Payload goes "as is".
     for (size_t i = 0; i < payload_size; ++i)
     {
@@ -512,8 +608,8 @@ void FECFilterBuiltin::ClipData(Group& g, uint16_t length_net, uint8_t kflg,
     }
 
     // Fill the rest with zeros. When this packet is going to be
-    // recovered, the payload extraced from this process will have
-    // the maximum lenght, but it will be cut to the right length
+    // recovered, the payload extracted from this process will have
+    // the maximum length, but it will be cut to the right length
     // and these padding 0s taken out.
     for (size_t i = payload_size; i < payloadSize(); ++i)
         g.payload_clip[i] = g.payload_clip[i] ^ 0;
@@ -558,7 +654,7 @@ bool FECFilterBuiltin::packControlPacket(SrtPacket& rpkt, int32_t seq)
     else
     {
         int offset_to_row_base = CSeqNo::seqoff(snd.row.base, seq);
-        int vert_gx = (offset_to_row_base + m_number_cols) % m_number_cols;
+        int vert_gx = (offset_to_row_base + int(m_number_cols)) % int(m_number_cols);
 
         // This can actually happen only for the very first sent packet.
         // It looks like "following the last packet from the previous group",
@@ -719,6 +815,11 @@ bool FECFilterBuiltin::receive(const CPacket& rpkt, loss_seqs_t& loss_seqs)
         }
 
         HLOGC(pflog.Debug, log << "FEC: RECEIVED %" << rpkt.getSeqNo() << " msgno=0, FEC/CTL packet. INDEX=" << int(payload[0]));
+
+        // This marks the cell as NOT received, but still does extend the
+        // cell container up to this sequence. The HangHorizontal and HangVertical
+        // functions that would also do cell dismissal, RELY ON IT.
+        MarkCellReceived(rpkt.getSeqNo(), CELL_EXTEND);
     }
     else
     {
@@ -753,38 +854,61 @@ bool FECFilterBuiltin::receive(const CPacket& rpkt, loss_seqs_t& loss_seqs)
 
     loss_seqs_t irrecover_row, irrecover_col;
 
-    bool ok = true;
+#if ENABLE_HEAVY_LOGGING
+    static string hangname [] = {"NOT-DONE", "SUCCESS", "PAST", "CRAZY"};
+#endif
+
+    // Required for EHangStatus
+    using namespace std::rel_ops;
+
+    EHangStatus okh = HANG_NOTDONE;
     if (!isfec.col) // == regular packet or FEC/ROW
     {
         // Don't manage this packet for horizontal group,
         // if it was a vertical FEC/CTL packet.
-        ok = HangHorizontal(rpkt, isfec.row, irrecover_row);
+        okh = HangHorizontal(rpkt, isfec.row, irrecover_row);
         HLOGC(pflog.Debug, log << "FEC: HangHorizontal %" << rpkt.getSeqNo()
                 << " msgno=" << rpkt.getMsgSeq()
-                << " RESULT=" << boolalpha << ok << " IRRECOVERABLE: " << Printable(irrecover_row));
+                << " RESULT=" << hangname[okh] << " IRRECOVERABLE: " << Printable(irrecover_row));
     }
 
-    if (!ok)
+    if (okh > HANG_SUCCESS)
     {
         // Just informative.
         LOGC(pflog.Warn, log << "FEC/H: rebuilding/hanging FAILED.");
     }
 
+    EHangStatus okv = HANG_NOTDONE;
     // Don't do HangVertical in case of row-only configuration
     if (!isfec.row && m_number_rows > 1) // == regular packet or FEC/COL
     {
-        ok = HangVertical(rpkt, isfec.colx, irrecover_col);
+        // NOTE FOR IPE REPORTING:
+        // It is allowed that
+        // - Both HangVertical and HangHorizontal
+
+        okv = HangVertical(rpkt, isfec.colx, irrecover_col);
+        IF_HEAVY_LOGGING(bool discrep = (okv == HANG_CRAZY) ? int(okh) < HANG_CRAZY : false);
         HLOGC(pflog.Debug, log << "FEC: HangVertical %" << rpkt.getSeqNo()
                 << " msgno=" << rpkt.getMsgSeq()
-                << " RESULT=" << boolalpha << ok << " IRRECOVERABLE: " << Printable(irrecover_col));
+                << " RESULT=" << hangname[okh]
+                << (discrep ? " IPE: H successul and V failed!" : "")
+                << " IRRECOVERABLE: " << Printable(irrecover_col));
     }
 
-    if (!ok)
+    if (okv > HANG_SUCCESS)
     {
         // Just informative.
         LOGC(pflog.Warn, log << "FEC/V: rebuilding/hanging FAILED.");
     }
 
+    if (okv == HANG_CRAZY || okh == HANG_CRAZY)
+    {
+        // Mark the cell not received, if it was rejected by the
+        // FEC group facility, otherwise it will deny to try to rebuild an
+        // allegedly existing packet.
+        MarkCellReceived(rpkt.getSeqNo(), CELL_REMOVE);
+    }
+
     // Pack the following packets as irrecoverable:
     if (m_fallback_level == SRT_ARQ_ONREQ)
     {
@@ -845,7 +969,7 @@ void FECFilterBuiltin::CheckLargeDrop(int32_t seqno)
 
             int32_t oldbase = rcv.rowq[0].base;
             size_t rowdist = offset / sizeRow();
-            int32_t newbase = CSeqNo::incseq(oldbase, rowdist * sizeRow());
+            int32_t newbase = CSeqNo::incseq(oldbase, int(rowdist * sizeRow()));
 
             LOGC(pflog.Warn, log << "FEC: LARGE DROP detected! Resetting row groups. Base: %" << oldbase
                     << " -> %" << newbase << "(shift by " << CSeqNo::seqoff(oldbase, newbase) << ")");
@@ -886,16 +1010,17 @@ void FECFilterBuiltin::CheckLargeDrop(int32_t seqno)
         return;
     }
 
-    size_t matrix = numberRows() * numberCols();
+    const size_t size_in_packets = colx * numberRows();
+    const size_t matrix = numberRows() * numberCols();
 
-    int colseries = coloff / matrix;
+    const int colseries = coloff / int(matrix);
 
-    if (colseries > 2 || reset_anyway)
+    if (size_in_packets > rcvBufferSize()/2 || colseries > SRT_FEC_MAX_RCV_HISTORY || reset_anyway)
     {
         // Ok, now define the new ABSOLUTE BASE. This is the base of the column 0
         // column group from the series previous towards this one.
         int32_t oldbase = rcv.colq[0].base;
-        int32_t newbase = CSeqNo::incseq(oldbase, (colseries-1) * matrix);
+        int32_t newbase = CSeqNo::incseq(oldbase, (colseries-1) * int(matrix));
 
         LOGC(pflog.Warn, log << "FEC: LARGE DROP detected! Resetting all groups. Base: %" << oldbase
                 << " -> %" << newbase << "(shift by " << CSeqNo::seqoff(oldbase, newbase) << ")");
@@ -939,7 +1064,7 @@ void FECFilterBuiltin::CollectIrrecoverRow(RcvGroup& g, loss_seqs_t& irrecover)
     {
         LOGC(pflog.Error, log << "FEC: IPE: Collecting loss from row %"
                 << g.base << "+" << m_number_cols << " while cells <= %"
-                << CSeqNo::seqoff(rcv.cell_base, rcv.cells.size()-1));
+                << CSeqNo::seqoff(rcv.cell_base, int(rcv.cells.size())-1));
         return;
     }
 
@@ -953,11 +1078,11 @@ void FECFilterBuiltin::CollectIrrecoverRow(RcvGroup& g, loss_seqs_t& irrecover)
         if (gone && !last)
         {
             // Switch full -> loss. Store the sequence, as single (for now)
-            val.first = val.second = CSeqNo::incseq(base, i);
+            val.first = val.second = CSeqNo::incseq(base, int(i));
         }
         else if (last && !gone)
         {
-            val.second = CSeqNo::incseq(base, i);
+            val.second = CSeqNo::incseq(base, int(i));
             irrecover.push_back(val);
         }
     }
@@ -983,47 +1108,50 @@ static inline char CellMark(const std::deque<bool>& cells, int index)
     return cells[index] ? '#' : '.';
 }
 
-static void DebugPrintCells(int32_t base, const std::deque<bool>& cells, int row_size)
+static void DebugPrintCells(int32_t base, const std::deque<bool>& cells, size_t row_size)
 {
-    int i = 0;
+    size_t i = 0;
     // Shift to the first empty cell
-    for ( ; i < int(cells.size()); ++i)
+    for ( ; i < cells.size(); ++i)
         if (cells[i] == false)
             break;
 
-    if (i == int(cells.size()))
+    if (i == cells.size())
     {
         LOGC(pflog.Debug, log << "FEC: ... cell[0-" << (cells.size()-1) << "]: ALL CELLS EXIST");
         return;
     }
 
     // Ok, we have some empty cells, so just adjust to the start of a row.
-    i -= i % row_size;
-    if (i < 0)
-        i = 0; // you never know...
-
-    for ( ; i < int(cells.size()); i += row_size )
+    size_t bstep = i % row_size;
+    if (i < bstep)  // you never know...
+        i = 0;
+    else
+        i -= bstep;
+    
+    for ( ; i < cells.size(); i += row_size )
     {
         std::ostringstream os;
-        os << "cell[" << i << "-" << (i+row_size-1) << "] %" << CSeqNo::incseq(base, i) << ":";
-        for (int y = 0; y < row_size; ++y)
+        os << "cell[" << i << "-" << (i+row_size-1) << "] %" << CSeqNo::incseq(base, (int32_t)i) << ":";
+        for (size_t y = 0; y < row_size; ++y)
         {
-            os << " " << CellMark(cells, i+y);
+            os << " " << CellMark(cells, (int)(i+y));
         }
         LOGP(pflog.Debug, os.str());
     }
 }
 #else
-static void DebugPrintCells(int32_t /*base*/, const std::deque<bool>& /*cells*/, int /*row_size*/) {}
+static void DebugPrintCells(int32_t /*base*/, const std::deque<bool>& /*cells*/, size_t /*row_size*/) {}
 #endif
 
-bool FECFilterBuiltin::HangHorizontal(const CPacket& rpkt, bool isfec, loss_seqs_t& irrecover)
+FECFilterBuiltin::EHangStatus FECFilterBuiltin::HangHorizontal(const CPacket& rpkt, bool isfec, loss_seqs_t& irrecover)
 {
-    int32_t seq = rpkt.getSeqNo();
+    const int32_t seq = rpkt.getSeqNo();
 
-    int rowx = RcvGetRowGroupIndex(seq);
+    EHangStatus stat;
+    const int rowx = RcvGetRowGroupIndex(seq, (stat));
     if (rowx == -1)
-        return false;
+        return stat;
 
     RcvGroup& rowg = rcv.rowq[rowx];
     // Clip the packet into the horizontal group.
@@ -1094,9 +1222,9 @@ bool FECFilterBuiltin::HangHorizontal(const CPacket& rpkt, bool isfec, loss_seqs
         }
     }
 
-    if (want_collect_irrecover)
+    if (want_collect_irrecover) // AND rcv.rowq.size() > 1
     {
-        int current = rcv.rowq.size() - 2;
+        int current = int(rcv.rowq.size()) - 2;
         // We know we have at least 2 rows.
         // This value is then 0 or more.
         int past = current - 1;
@@ -1143,17 +1271,21 @@ bool FECFilterBuiltin::HangHorizontal(const CPacket& rpkt, bool isfec, loss_seqs
                 CollectIrrecoverRow(rcv.rowq[i], irrecover);
             }
 
-            if (want_remove_cells)
+            // Sanity check condition - rcv.rowq must be of size
+            // greater than the number of rows to remove so that
+            // the rcv.rowq[0] exists after the operation.
+            if (want_remove_cells && rcv.rowq.size() > size_t(nrowremove))
             {
+                // nrowremove >= 1
                 size_t npktremove = sizeRow() * nrowremove;
-                size_t ersize = min(npktremove, rcv.cells.size());
+                size_t ersize = min(npktremove, rcv.cells.size()); // ersize <= rcv.cells.size()
 
                 HLOGC(pflog.Debug, log << "FEC/H: Dismissing rows n=" << nrowremove
                         << ", starting at %" << rcv.rowq[0].base
                         << " AND " << npktremove << " CELLS, base switch %"
                         << rcv.cell_base << " -> %" << rcv.rowq[past].base);
 
-                rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + 1 + past);
+                rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + nrowremove);
                 rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + ersize);
 
                 // We state that we have removed as many cells as for the removed
@@ -1172,7 +1304,7 @@ bool FECFilterBuiltin::HangHorizontal(const CPacket& rpkt, bool isfec, loss_seqs
 
     }
 
-    return true;
+    return HANG_SUCCESS;
 }
 
 int32_t FECFilterBuiltin::RcvGetLossSeqHoriz(Group& g)
@@ -1193,10 +1325,10 @@ int32_t FECFilterBuiltin::RcvGetLossSeqHoriz(Group& g)
     {
         if (!rcv.CellAt(cix))
         {
-            offset = cix;
+            offset = int(cix);
 #if ENABLE_HEAVY_LOGGING
             // For heavy logging case, show all cells in the range
-            LOGC(pflog.Debug, log << "FEC/H: cell %" << CSeqNo::incseq(rcv.cell_base, cix)
+            LOGC(pflog.Debug, log << "FEC/H: cell %" << CSeqNo::incseq(rcv.cell_base, int(cix))
                     << " (+" << cix << "): MISSING");
 
 #else
@@ -1210,7 +1342,7 @@ int32_t FECFilterBuiltin::RcvGetLossSeqHoriz(Group& g)
 #if ENABLE_HEAVY_LOGGING
         else
         {
-            LOGC(pflog.Debug, log << "FEC/H: cell %" << CSeqNo::incseq(rcv.cell_base, cix)
+            LOGC(pflog.Debug, log << "FEC/H: cell %" << CSeqNo::incseq(rcv.cell_base, int(cix))
                     << " (+" << cix << "): exists");
         }
 #endif
@@ -1246,10 +1378,10 @@ int32_t FECFilterBuiltin::RcvGetLossSeqVert(Group& g)
         size_t cix = baseoff + (col * sizeRow());
         if (!rcv.CellAt(cix))
         {
-            offset = cix;
+            offset = int(cix);
 #if ENABLE_HEAVY_LOGGING
             // For heavy logging case, show all cells in the range
-            LOGC(pflog.Debug, log << "FEC/V: cell %" << CSeqNo::incseq(rcv.cell_base, cix)
+            LOGC(pflog.Debug, log << "FEC/V: cell %" << CSeqNo::incseq(rcv.cell_base, int(cix))
                     << " (+" << cix << "): MISSING");
 
 #else
@@ -1263,7 +1395,7 @@ int32_t FECFilterBuiltin::RcvGetLossSeqVert(Group& g)
 #if ENABLE_HEAVY_LOGGING
         else
         {
-            LOGC(pflog.Debug, log << "FEC/V: cell %" << CSeqNo::incseq(rcv.cell_base, cix)
+            LOGC(pflog.Debug, log << "FEC/V: cell %" << CSeqNo::incseq(rcv.cell_base, int(cix))
                     << " (+" << cix << "): exists");
         }
 #endif
@@ -1344,13 +1476,13 @@ void FECFilterBuiltin::RcvRebuild(Group& g, int32_t seqno, Group::Type tp)
     if (tp == Group::SINGLE)
         return;
 
-    // This flips HORIZ/VERT
-    Group::Type crosstype = Group::Type(!tp);
+    Group::Type crosstype = Group::FlipType(tp);
+    EHangStatus stat;
 
     if (crosstype == Group::HORIZ)
     {
         // Find this packet in the horizontal group
-        int rowx = RcvGetRowGroupIndex(seqno);
+        const int rowx = RcvGetRowGroupIndex(seqno, (stat));
         if (rowx == -1)
             return; // can't access any group to rebuild
         RcvGroup& rowg = rcv.rowq[rowx];
@@ -1387,7 +1519,7 @@ void FECFilterBuiltin::RcvRebuild(Group& g, int32_t seqno, Group::Type tp)
     else // crosstype == Group::VERT
     {
         // Find this packet in the vertical group
-        int colx = RcvGetColumnGroupIndex(seqno);
+        const int colx = RcvGetColumnGroupIndex(seqno, (stat));
         if (colx == -1)
             return; // can't access any group to rebuild
         RcvGroup& colg = rcv.colq[colx];
@@ -1424,7 +1556,7 @@ void FECFilterBuiltin::RcvRebuild(Group& g, int32_t seqno, Group::Type tp)
 
 }
 
-int FECFilterBuiltin::ExtendRows(int rowx)
+size_t FECFilterBuiltin::ExtendRows(size_t rowx)
 {
     // Check if oversize. Oversize is when the
     // index is > 2*m_number_cols. If so, shrink
@@ -1437,17 +1569,13 @@ int FECFilterBuiltin::ExtendRows(int rowx)
         LOGC(pflog.Debug, log << "... [" << i << "] " << rcv.rowq[i].DisplayStats());
 #endif
 
-    if (rowx > int(m_number_cols*3))
-    {
-        LOGC(pflog.Warn, log << "FEC/H: OFFSET=" << rowx << " exceeds maximum row container size, SHRINKING rows and cells");
-
-        rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + m_number_cols);
-        rowx -= m_number_cols;
+    const size_t size_in_packets = rowx * numberCols();
+    const int n_series = int(rowx / numberRows());
 
-        // With rows, delete also an appropriate number of cells.
-        int nerase = min(int(rcv.cells.size()), CSeqNo::seqoff(rcv.cell_base, rcv.rowq[0].base));
-        rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + nerase);
-        rcv.cell_base = rcv.rowq[0].base;
+    if (CheckEmergencyShrink(n_series, size_in_packets))
+    {
+        HLOGC(pflog.Debug, log << "FEC: DONE Emergency resize, rowx=" << rowx << " series=" << n_series
+                << "npackets=" << size_in_packets << " exceeds buf=" << rcvBufferSize());
     }
 
     // Create and configure next groups.
@@ -1460,7 +1588,7 @@ int FECFilterBuiltin::ExtendRows(int rowx)
     for (size_t i = old; i < rcv.rowq.size(); ++i)
     {
         // Initialize the base for the row group
-        int32_t ibase = CSeqNo::incseq(rcv.rowq[0].base, i*m_number_cols);
+        int32_t ibase = CSeqNo::incseq(rcv.rowq[0].base, int(i*m_number_cols));
         ConfigureGroup(rcv.rowq[i], ibase, 1, m_number_cols);
     }
 
@@ -1474,17 +1602,18 @@ int FECFilterBuiltin::ExtendRows(int rowx)
     return rowx;
 }
 
-int FECFilterBuiltin::RcvGetRowGroupIndex(int32_t seq)
+int FECFilterBuiltin::RcvGetRowGroupIndex(int32_t seq, EHangStatus& w_status)
 {
     RcvGroup& head = rcv.rowq[0];
-    int32_t base = head.base;
+    const int32_t base = head.base;
 
-    int offset = CSeqNo::seqoff(base, seq);
+    const int offset = CSeqNo::seqoff(base, seq);
 
     // Discard the packet, if older than base.
     if (offset < 0)
     {
         HLOGC(pflog.Debug, log << "FEC/H: Packet %" << seq << " is in the past, ignoring");
+        w_status = HANG_PAST;
         return -1;
     }
 
@@ -1510,18 +1639,20 @@ int FECFilterBuiltin::RcvGetRowGroupIndex(int32_t seq)
     // First, possibly extend the row container
     if (rowx >= rcv.rowq.size())
     {
+        // Never returns -1
         rowx = ExtendRows(rowx);
     }
 
-    return rowx;
+    w_status = HANG_SUCCESS;
+    return int(rowx);
 }
 
-void FECFilterBuiltin::MarkCellReceived(int32_t seq)
+void FECFilterBuiltin::MarkCellReceived(int32_t seq, ECellReceived is_received)
 {
     // Mark the packet as received. This will allow later to
     // determine, which exactly packet is lost and needs rebuilding.
-    int cellsize = rcv.cells.size();
-    int cell_offset = CSeqNo::seqoff(rcv.cell_base, seq);
+    const int cellsize = int(rcv.cells.size());
+    const int cell_offset = CSeqNo::seqoff(rcv.cell_base, seq);
     bool resized SRT_ATR_UNUSED = false;
     if (cell_offset >= cellsize)
     {
@@ -1531,48 +1662,200 @@ void FECFilterBuiltin::MarkCellReceived(int32_t seq)
         resized = true;
         rcv.cells.resize(cell_offset+1, false);
     }
-    rcv.cells[cell_offset] = true;
 
-    HLOGC(pflog.Debug, log << "FEC: MARK CELL RECEIVED: %" << seq << " - cells base=%"
+    if (resized || is_received != CELL_EXTEND)
+    {
+        // In both RECEIVED and REMOVE cases, forcefully set the value always.
+        // In EXTEND, only if it was received
+        // Value set should be true only if RECEIVED, false otherwise
+        rcv.cells[cell_offset] = (is_received == CELL_RECEIVED);
+    }
+
+#if ENABLE_HEAVY_LOGGING
+    static string const cellop [] = { "RECEIVED", "EXTEND", "REMOVE" };
+    LOGC(pflog.Debug, log << "FEC: MARK CELL " << cellop[is_received]
+            << "(" << (rcv.cells[cell_offset] ? "SET" : "CLR") << ")"
+            << ": %" << seq << " - cells base=%"
             << rcv.cell_base << "[" << cell_offset << "]+" << rcv.cells.size()
             << (resized ? "(resized)":"") << " :");
+#endif
 
     DebugPrintCells(rcv.cell_base, rcv.cells, sizeRow());
 }
 
 bool FECFilterBuiltin::IsLost(int32_t seq) const
 {
-    int offset = CSeqNo::seqoff(rcv.cell_base, seq);
+    const int offset = CSeqNo::seqoff(rcv.cell_base, seq);
     if (offset < 0)
     {
         LOGC(pflog.Error, log << "FEC: IsLost: IPE: %" << seq
                 << " is earlier than the cell base %" << rcv.cell_base);
-        return true; // fake we have the packet - this is to collect losses only
+        return true; // This might be due to emergency shrinking; pretend the packet is lost
     }
     if (offset >= int(rcv.cells.size()))
     {
         // XXX IPE!
         LOGC(pflog.Error, log << "FEC: IsLost: IPE: %" << seq << " is past the cells %"
                 << rcv.cell_base << " + " << rcv.cells.size());
-        return true;
+        return false; // Don't notify it yet
     }
 
     return rcv.cells[offset];
 }
 
-bool FECFilterBuiltin::HangVertical(const CPacket& rpkt, signed char fec_col, loss_seqs_t& irrecover)
+bool FECFilterBuiltin::CheckEmergencyShrink(size_t n_series, size_t size_in_packets)
+{
+    // The minimum required size of the covered sequence range must be such
+    // that groups for packets from the previous range must be still reachable.
+    // It's then "this and previous" series in case of even arrangement.
+    //
+    // For staircase arrangement the potential range for a single column series
+    // (number of columns equal to a row size) spans for 2 matrices (rows * cols)
+    // minus one row. As dismissal is only allowed to be done by one full series
+    // of rows and columns, the history must keep as many groups as needed to reach
+    // out for this very packet of this group and all packets in the same row.
+    // Hence we need two series of columns to cover a similar range as two row, twice.
+
+    const size_t min_series_history = m_arrangement_staircase ? 4 : 2;
+
+    if (n_series <= min_series_history)
+        return false;
+
+    if (size_in_packets < rcvBufferSize() && n_series < SRT_FEC_MAX_RCV_HISTORY)
+        return false;
+
+    // Shrink is required in order to prepare place for
+    // either vertical or horizontal group in series `n_series`.
+
+    // The n_series can be calculated as:
+    // n_series = colgx / numberCols()
+    // n_series = rowgx / numberRows()
+    //
+    // The (Column or Row) Group Index value is calculated as
+    // the number of column where the desired sequence number
+    // should be located towards the very first container item
+    // (row/column 0).
+
+    // The task for this function is to leave only one series
+    // of groups and therefore initialize the containers. Likely
+    // the part that contains the last series should be already
+    // there, so in this case just remove some initial items from
+    // the container so that only those remain that are intended
+    // to remain. However, by various reasons (like e.g. that all
+    // packets from the whole series have been lost) particular
+    // container (colq, rowq, cell) doesn't contain this last 
+    // series at all. In that case clear the container completely
+    // and just add an initial configuration for the first part
+    // (which will be then dynamically extended as packets come in).
+
+    const int32_t oldbase = rcv.colq[0].base;
+    const size_t shift_series = n_series - 1;
+
+    // This is simply a situation when the size is so excessive
+    // that it couldn't be withstood by the receiver buffer, so
+    // even if this isn't an extremely big size for allocation for
+    // FEC, it doesn't make sense anyway.
+    //
+    // Minimum of 2 series must remain in the group container,
+    // otherwise there's no need to guard the size.
+
+    // This requires simply resetting all group containers to
+    // the very initial state, just take the calculated base seq
+    // from the value of colgx reset to column 0.
+
+    // As colgx is calculated by stating that colgx == 0 represents
+    // the very first cell in the column groups, take this, shift
+    // by the number of series. 
+
+    // SHIFT BY: n_series * matrix size
+    // n_series is at least 2 (see condition)
+    const size_t shift = shift_series * numberCols() * numberRows();
+
+    // Always positive: colgx, and so n_series, and so shift
+    const int32_t newbase = CSeqNo::incseq(oldbase, int(shift));
+
+    const size_t shift_rows = shift_series * numberRows();
+
+    bool need_reset = rcv.rowq.size() < shift_rows;
+    if (!need_reset)
+    {
+        // Sanity check - you should have the exact value
+        // of `newbase` at the next series beginning position
+        if (rcv.rowq[numberRows()].base != newbase)
+        {
+            LOGC(pflog.Error, log << "FEC: IPE: row start at %" << rcv.rowq[0].base << " next series %" << rcv.rowq[numberRows()].base
+                    << " (expected %" << newbase << "). RESETTING ROWS.");
+            need_reset = true;
+        }
+    }
+
+    if (need_reset)
+    {
+        rcv.rowq.clear();
+        // This n_series is the number rounded downwards,
+        // So you just need to prepare place for ONE series.
+        // The procedure below will extend them to the required
+        // size for the received colgx.
+        rcv.rowq.resize(1);
+
+        HLOGC(pflog.Debug, log << "FEC: Reset recv row %" << oldbase << " -> %" << newbase << ", INIT ROWS:");
+        ConfigureGroup(rcv.rowq[0], newbase, 1, sizeRow());
+    }
+    else
+    {
+        HLOGC(pflog.Debug, log << "FEC: Shifting rcv row %" << oldbase << " -> %" << newbase);
+        rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + shift_rows);
+    }
+
+    const size_t shift_cols = shift_series * numberCols();
+    need_reset = rcv.colq.size() < shift_cols;
+    if (!need_reset)
+    {
+        // Sanity check - you should have the exact value
+        // of `newbase` at the next series beginning position
+        if (rcv.colq[numberCols()].base != newbase)
+        {
+            LOGC(pflog.Error, log << "FEC: IPE: col start at %" << rcv.colq[0].base << " next series %" << rcv.colq[numberCols()].base
+                    << " (expected %" << newbase << "). RESETTING ROWS.");
+            need_reset = true;
+        }
+    }
+
+    if (need_reset)
+    {
+        rcv.colq.clear();
+        HLOGC(pflog.Debug, log << "FEC: Reset recv row %" << oldbase << " -> %" << newbase << ", INIT first " << numberCols() << ":");
+        ConfigureColumns(rcv.colq, newbase);
+    }
+
+    if (rcv.cells.size() > shift)
+    {
+        rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + shift);
+    }
+    else
+    {
+        rcv.cells.clear();
+        rcv.cells.push_back(false);
+    }
+    rcv.cell_base = newbase;
+
+    return true;
+}
+
+FECFilterBuiltin::EHangStatus FECFilterBuiltin::HangVertical(const CPacket& rpkt, signed char fec_col, loss_seqs_t& irrecover)
 {
     bool fec_ctl = (fec_col != -1);
     // Now hang the packet in the vertical group
 
-    int32_t seq = rpkt.getSeqNo();
+    const int32_t seq = rpkt.getSeqNo();
 
     // Ok, now we have the column index, we know it exists.
     // Apply the packet.
 
-    int colgx = RcvGetColumnGroupIndex(seq);
+    EHangStatus stat;
+    const int colgx = RcvGetColumnGroupIndex(seq, (stat));
     if (colgx == -1)
-        return false;
+        return stat;
 
     RcvGroup& colg = rcv.colq[colgx];
 
@@ -1618,7 +1901,7 @@ bool FECFilterBuiltin::HangVertical(const CPacket& rpkt, signed char fec_col, lo
         LOGC(pflog.Debug, log << "... [" << i << "] " << rcv.colq[i].DisplayStats());
 #endif
 
-    return true;
+    return HANG_SUCCESS;
 }
 
 void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t& irrecover)
@@ -1629,7 +1912,7 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
     // - get the series for this column
     // - if series is 0, just return
 
-    int series = colgx / numberCols();
+    const size_t series = colgx / numberCols();
     if (series == 0)
         return;
 
@@ -1640,7 +1923,7 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
 
     set<int32_t> loss;
 
-    int colx SRT_ATR_UNUSED = colgx % numberCols();
+    size_t colx SRT_ATR_UNUSED = colgx % numberCols();
 
     HLOGC(pflog.Debug, log << "FEC/V: going to DISMISS cols past %" << seq
             << " at INDEX=" << colgx << " col=" << colx
@@ -1667,13 +1950,13 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
         // because they can't be dismissed yet. Jump them over, so maybe
         // they can be dismissed in future.
         int this_col_offset = CSeqNo::seqoff(pg.base, seq);
-        int last_seq_offset = this_col_offset - (sizeCol()-1)*sizeRow();
+        int last_seq_offset = this_col_offset - int((sizeCol()-1)*sizeRow());
 
         if (last_seq_offset < 0)
         {
             HLOGC(pflog.Debug, log << "FEC/V: ... [" << i << "] base=%"
                     << pg.base << " TOO EARLY (last=%"
-                    << CSeqNo::incseq(pg.base, (sizeCol()-1)*sizeRow())
+                    << CSeqNo::incseq(pg.base, (int32_t)((sizeCol()-1)*sizeRow()))
                     << ")");
             continue;
         }
@@ -1684,13 +1967,13 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
 
         HLOGC(pflog.Debug, log << "FEC/V: ... [" << i << "] base=%"
                 << pg.base << " - PAST last=%"
-                << CSeqNo::incseq(pg.base, (sizeCol()-1)*sizeRow())
+                << CSeqNo::incseq(pg.base, (int32_t)((sizeCol()-1)*sizeRow()))
                 << " - collecting losses.");
 
         pg.dismissed = true; // mark irrecover already collected
         for (size_t sof = 0; sof < pg.step * sizeCol(); sof += pg.step)
         {
-            int32_t lseq = CSeqNo::incseq(pg.base, sof);
+            int32_t lseq = CSeqNo::incseq(pg.base, int(sof));
             if (!IsLost(lseq))
             {
                 loss.insert(lseq);
@@ -1721,31 +2004,46 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
     int32_t base0 = rcv.colq[0].base;
     int this_off = CSeqNo::seqoff(base0, seq);
 
-    int mindist =
+    int mindist = int(
         m_arrangement_staircase ?
         (numberCols() * numberRows() * 2)
         :
-        (numberCols() * numberRows());
+        (numberCols() * numberRows()));
 
     bool any_dismiss SRT_ATR_UNUSED = false;
 
+    // Here's a change.
+    // The number of existing column groups is supposed to always cover
+    // at least one full series, whereas the number of row groups are
+    // created always one per necessity, so the number of existing row
+    // groups may be less than required for a full series, whereas here
+    // it is intended to simply dismiss groups for full series. This may
+    // cause that it is aiming for removing more row groups than currently
+    // exist. This is completely ok, as the sequence that triggered removal
+    // is long past these series anyway, so the groups for packets that will
+    // never be received makes no sense. Simply accept this state and delete
+    // all row groups and reinitialize them into the new base, where the base
+    // is the current base for column 0 group.
+    //
+    // Therefore dismissal is triggered whenever you have a cover of one column
+    // series. If the number of row groups doesn't cover it, simply delete all
+    // row groups, that's all.
+
     // if (base0 +% mindist) <% seq
-    if (this_off < mindist)
+    if (this_off < mindist) // COND 1: minimum remaining
     {
         HLOGC(pflog.Debug, log << "FEC/V: NOT dismissing any columns at %" << seq
                 << ", need to pass %" << CSeqNo::incseq(base0, mindist));
     }
-    else if (rcv.colq.size() < numberCols())
-    {
-        HLOGC(pflog.Debug, log << "FEC/V: IPE: about to dismiss past %" << seq
-                << " with required %" << CSeqNo::incseq(base0, mindist)
-                << " but col container size still " << rcv.colq.size());
-    }
-    else if (rcv.rowq.size() < numberRows())
+    else if (rcv.colq.size() - 1 < numberCols()) // COND 2: full matrix in columns
     {
-        HLOGC(pflog.Debug, log << "FEC/V: IPE: about to dismiss past %" << seq
+#if ENABLE_HEAVY_LOGGING
+        LOGC(pflog.Debug, log << "FEC/V: IPE: about to dismiss past %" << seq
                 << " with required %" << CSeqNo::incseq(base0, mindist)
-                << " but row container size still " << rcv.rowq.size());
+                << " but col container size still " << rcv.colq.size() << "; COL STATS:");
+        for (size_t i = 0; i < rcv.colq.size(); ++i)
+            LOGC(pflog.Debug, log << "... [" << i << "] " << rcv.colq[i].DisplayStats());
+#endif
     }
     else
     {
@@ -1753,9 +2051,30 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
         // is numberCols(), regardless of the required 'mindinst'.
         any_dismiss = true;
 
-        int32_t newbase = rcv.colq[numberCols()].base;
-        int32_t newbase_row = rcv.rowq[numberRows()].base;
-        int matrix_size = numberCols() * numberRows();
+        const int32_t newbase = rcv.colq[numberCols()].base;
+        int32_t newbase_row SRT_ATR_UNUSED; // For logging only, but including FATAL.
+        // Sanity check
+        // If sanity check failed OR if the number of existing row
+        // groups doesn't enclose those that need to be dismissed,
+        // clear row groups completely - these packets are lost and
+        // irrecoverable anyway.
+        bool insane = false;
+        bool undercounted = false;
+
+        if (rcv.rowq.size() - 1 < numberRows()) // COND 3: full matrix in rows
+        {
+            // Do not reach to index=numberRows() because it doesn't exist.
+            // Take the value from the columns as a good deal - actually
+            // row base and col base shall be always in sync.
+            newbase_row = newbase;
+            undercounted = true;
+        }
+        else
+        {
+            newbase_row = rcv.rowq[numberRows()].base;
+            insane = newbase_row != newbase;
+        }
+        const size_t matrix_size = numberCols() * numberRows();
 
         HLOGC(pflog.Debug, log << "FEC/V: DISMISSING " << numberCols() << " COLS. Base %"
                 << rcv.colq[0].base << " -> %" << newbase
@@ -1763,6 +2082,7 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
                 << rcv.rowq[0].base << " -> %" << newbase_row
                 << " AND " << matrix_size << " cells");
 
+        // ensured existence of the removed range: see COND 2 above.
         rcv.colq.erase(rcv.colq.begin(), rcv.colq.begin() + numberCols());
 
 #if ENABLE_HEAVY_LOGGING
@@ -1773,11 +2093,24 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
 #endif
 
         // Now erase accordingly one matrix of rows.
-        // Sanity check
-        if (newbase_row != newbase)
+        if (insane || undercounted)
         {
-            LOGC(pflog.Fatal, log << "FEC/V: IPE: DISCREPANCY in base0 col=%"
-                    << newbase << " row=%" << newbase_row << " - DELETING ALL ROWS");
+            if (insane)
+            {
+                LOGC(pflog.Fatal, log << "FEC/V: IPE: DISCREPANCY in new base0 col=%"
+                        << newbase << " row=%" << newbase_row << " - DELETING ALL ROWS");
+            }
+            else
+            {
+
+#if ENABLE_HEAVY_LOGGING
+                LOGC(pflog.Debug, log << "FEC/V: about to dismiss past %" << seq
+                        << " with required %" << CSeqNo::incseq(base0, mindist)
+                        << " but row container size still " << rcv.rowq.size() << " (will clear to %" << newbase << " instead); ROW STATS:");
+                for (size_t i = 0; i < rcv.rowq.size(); ++i)
+                    LOGC(pflog.Debug, log << "... [" << i << "] " << rcv.rowq[i].DisplayStats());
+#endif
+            }
 
             // Delete all rows and reinitialize them.
             rcv.rowq.clear();
@@ -1787,27 +2120,31 @@ void FECFilterBuiltin::RcvCheckDismissColumn(int32_t seq, int colgx, loss_seqs_t
         else
         {
             // Remove "legally" a matrix of rows.
+            // ensured existence of the removed range: see COND 3 above
             rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + numberRows());
         }
 
         // And now accordingly remove cells. Exactly one matrix of cells.
         // Sanity check first.
-        int32_t newbase_cell = CSeqNo::incseq(rcv.cell_base, matrix_size);
+        int32_t newbase_cell = CSeqNo::incseq(rcv.cell_base, int32_t(matrix_size));
         if (newbase != newbase_cell)
         {
-            LOGC(pflog.Fatal, log << "FEC/V: IPE: DISCREPANCY in base0 col=%"
-                    << newbase << " row=%" << newbase_row << " - DELETING ALL ROWS");
+            LOGC(pflog.Fatal, log << "FEC/V: IPE: DISCREPANCY in new base0 col=%"
+                    << newbase << " cell_base=%" << newbase_cell << " - DELETING ALL CELLS");
 
             // Try to shift it gently first. Find the cell that matches the base.
             int shift = CSeqNo::seqoff(rcv.cell_base, newbase);
-            if (shift < 0)
+            if (shift < 0 || size_t(shift) > rcv.cells.size())
                 rcv.cells.clear();
             else
                 rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + shift);
         }
         else
         {
-            rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + matrix_size);
+            if (rcv.cells.size() <= size_t(matrix_size))
+                rcv.cells.clear();
+            else
+                rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + matrix_size);
         }
         rcv.cell_base = newbase;
         DebugPrintCells(rcv.cell_base, rcv.cells, sizeRow());
@@ -1974,7 +2311,7 @@ void FECFilterBuiltin::TranslateLossRecords(const set<int32_t>& loss, loss_seqs_
     irrecover.push_back(make_pair(fi_start, fi_end));
 }
 
-int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno)
+int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno, EHangStatus& w_status)
 {
     // The column is only the column, not yet
     // exactly the index of the column group in the container.
@@ -2048,32 +2385,35 @@ int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno)
     //
     // GROUP_INDEX = COLUMN_INDEX + (COLUMN_SERIES * m_number_cols)
 
-    int offset = CSeqNo::seqoff(rcv.colq[0].base, seqno);
+    const int offset = CSeqNo::seqoff(rcv.colq[0].base, seqno);
     if (offset < 0)
     {
         HLOGC(pflog.Debug, log << "FEC/V: %" << seqno << " in the past of col ABSOLUTE base %" << rcv.colq[0].base);
+        w_status = HANG_PAST;
         return -1;
     }
 
     if (offset > CSeqNo::m_iSeqNoTH/2)
     {
         LOGC(pflog.Error, log << "FEC/V: IPE/ATTACK: pkt %" << seqno << " has CRAZY OFFSET towards the base %" << rcv.colq[0].base);
+        w_status = HANG_CRAZY;
         return -1;
     }
 
-    int colx = offset % m_number_cols;
-    int32_t colbase = rcv.colq[colx].base;
-    int coloff = CSeqNo::seqoff(colbase, seqno);
+    const int colx = offset % m_number_cols;
+    const int32_t colbase = rcv.colq[colx].base;
+    const int coloff = CSeqNo::seqoff(colbase, seqno);
     if (coloff < 0)
     {
         HLOGC(pflog.Debug, log << "FEC/V: %" << seqno << " in the past of col #" << colx << " base %" << colbase);
         // This means that this sequence number predates the earliest
         // sequence number supported by the very first column.
+        w_status = HANG_PAST;
         return -1;
     }
 
-    int colseries = coloff / (m_number_cols * m_number_rows);
-    size_t colgx = colx + (colseries * m_number_cols);
+    const int colseries = coloff / int(m_number_cols * m_number_rows);
+    size_t colgx = colx + int(colseries * m_number_cols);
 
     HLOGC(pflog.Debug, log << "FEC/V: Lookup group for %" << seqno << ": cg_base=%" << rcv.colq[0].base
             << " column=" << colx << " with base %" << colbase << ": SERIES=" << colseries
@@ -2081,10 +2421,11 @@ int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno)
 
     // Check oversize. Dismiss some earlier items if it exceeds the size.
     // before you extend the size enormously.
-    if (colgx > m_number_rows * m_number_cols * 2)
+    if (colgx > m_number_rows * m_number_cols * SRT_FEC_MAX_RCV_HISTORY)
     {
         // That's too much
         LOGC(pflog.Error, log << "FEC/V: IPE or ATTACK: offset " << colgx << " is too crazy, ABORTING lookup");
+        w_status = HANG_CRAZY;
         return -1;
     }
 
@@ -2092,8 +2433,8 @@ int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno)
     {
         colgx = ExtendColumns(colgx);
     }
-
-    return colgx;
+    w_status = HANG_SUCCESS;
+    return int(colgx);
 
     //
     // Even though column groups are arranged in a "staircase", it only means
@@ -2146,56 +2487,45 @@ int FECFilterBuiltin::RcvGetColumnGroupIndex(int32_t seqno)
     //     gmax = SHIFT(g.base, m_number_cols * m_number_rows)
     //     IF ( gs %> gmax )
     //        DISMISS COLUMNS from 0 to GROUP_INDEX - i; break
-
 }
 
-int FECFilterBuiltin::ExtendColumns(int colgx)
+size_t FECFilterBuiltin::ExtendColumns(size_t colgx)
 {
-    if (colgx > int(sizeRow() * 2))
-    {
-        // This shouldn't happen because columns should be dismissed
-        // once the last row of the first series is closed.
-        LOGC(pflog.Warn, log << "FEC/V: OFFSET=" << colgx << " exceeds maximum col container size, SHRINKING container by " << sizeRow());
-
-        // Delete one series of columns.
-        int32_t oldbase SRT_ATR_UNUSED = rcv.colq[0].base;
-        rcv.colq.erase(rcv.colq.begin(), rcv.colq.begin() + numberCols());
-        colgx -= numberCols();
-        int32_t newbase = rcv.colq[0].base;
-
-        // Delete also appropriate number of rows for one series
-        rcv.rowq.erase(rcv.rowq.begin(), rcv.rowq.begin() + numberRows());
-
-        // Sanity-check if the resulting row absolute base is equal to column
-        if (rcv.rowq[0].base != newbase)
-        {
-            LOGC(pflog.Error, log << "FEC/V: IPE: removal of " << numberRows()
-                    << " rows ships no same seq: rowbase=%"
-                    << rcv.rowq[0].base
-                    << " colbase=%" << oldbase << " -> %" << newbase << " - RESETTING ROWS");
-
-            // How much you need, depends on the columns.
-            size_t nseries = rcv.colq.size() / numberCols() + 1;
-            size_t needrows = nseries * numberRows();
-
-            rcv.rowq.clear();
-            rcv.rowq.resize(needrows);
-            int32_t rowbase = newbase;
-            for (size_t i = 0; i < rcv.rowq.size(); ++i)
-            {
-                ConfigureGroup(rcv.rowq[i], rowbase, 1, sizeRow());
-                rowbase = CSeqNo::incseq(newbase, sizeRow());
-            }
-        }
+    // This isn't safe to allow the group container to get expanded to any
+    // size, however with some very tolerant settings, such as 10 seconds of
+    // latency and very large receiver buffer, this might be tolerable.
+    //
+    // Therefore put only two conditions here:
+    //
+    // 1. The group containers must keep at most place for so many
+    // packets as it is intended for the receiver buffer. Keeping
+    // group cells for more packets doesn't make sense anyway.
+    //
+    // 2. Existing group containers should contain at least size
+    // for two series. If they don't contain that much, there's no
+    // need to do any emergency shrinking. Unknown whether this is
+    // physically possible, although it may also happen in case when
+    // you have very large FEC matrix size not coordinated with the
+    // receiver buffer size.
 
-        size_t ncellrem = CSeqNo::seqoff(rcv.cell_base, newbase);
-        rcv.cells.erase(rcv.cells.begin(), rcv.cells.begin() + ncellrem);
-        rcv.cell_base = newbase;
+    // colgx is the number of column + NSERIES * numberCols().
+    // We can state that for every column we should have a number
+    // of packets as many as the number of rows, so simply multiply this.
+    const size_t size_in_packets = colgx * numberRows();
+    const size_t n_series = colgx / numberCols();
 
-        // Note that after this shift, column groups that were
-        // in particular column, remain in that column.
+    if (CheckEmergencyShrink(n_series, size_in_packets))
+    {
+        HLOGC(pflog.Debug, log << "FEC: DONE Emergency resize, colgx=" << colgx << " series=" << n_series
+                << "npackets=" << size_in_packets << " exceeds buf=" << rcvBufferSize());
+    }
+    else
+    {
+        HLOGC(pflog.Debug, log << "FEC: Will extend up to colgx=" << colgx << " series=" << n_series
+                << " for npackets=" << size_in_packets);
     }
 
+
 #if ENABLE_HEAVY_LOGGING
     LOGC(pflog.Debug, log << "FEC: COL STATS BEFORE: n=" << rcv.colq.size());
 
@@ -2204,11 +2534,11 @@ int FECFilterBuiltin::ExtendColumns(int colgx)
 #endif
 
     // First, obtain the "series" of columns, possibly fixed.
-    int series = colgx / numberCols();
+    const int series = int(colgx / numberCols());
 
     // Now, the base of the series is the base increased by one matrix size.
 
-    int32_t base = rcv.colq[0].base;
+    const int32_t base = rcv.colq[0].base;
 
     // This is the base for series 0, but this procedure must be prepared
     // for that the series will not necessarily be 1, may be greater.
@@ -2218,7 +2548,7 @@ int FECFilterBuiltin::ExtendColumns(int colgx)
 
     // Check, up to which series the columns are initialized.
     // Start with the series that doesn't exist
-    int old_series = rcv.colq.size() / numberCols();
+    const int old_series = int(rcv.colq.size() / numberCols());
 
     // Each iteration of this loop adds one series of columns.
     // One series count numberCols() columns.
@@ -2231,7 +2561,7 @@ int FECFilterBuiltin::ExtendColumns(int colgx)
         // Every base sequence for a series of columns is the series 0
         // base increased by one matrix size times series number.
         // THIS REMAINS TRUE NO MATTER IF WE USE STRAIGNT OR STAIRCASE ARRANGEMENT.
-        int32_t sbase = CSeqNo::incseq(base, (numberCols()*numberRows()) * s);
+        const int32_t sbase = CSeqNo::incseq(base, int(numberCols()*numberRows()) * s);
         HLOGC(pflog.Debug, log << "FEC/V: EXTENDING column groups series " << s
                 << ", size " << rcv.colq.size() << " -> "
                 << (rcv.colq.size() + numberCols())
@@ -2252,3 +2582,4 @@ int FECFilterBuiltin::ExtendColumns(int colgx)
     return colgx;
 }
 
+} // namespace srt
diff --git a/srtcore/fec.h b/srtcore/fec.h
index 1fa158fff..029709475 100644
--- a/srtcore/fec.h
+++ b/srtcore/fec.h
@@ -19,6 +19,8 @@
 
 #include "packetfilter_api.h"
 
+namespace srt {
+
 class FECFilterBuiltin: public SrtPacketFilterBase
 {
     SrtFilterConfig cfg;
@@ -45,7 +47,7 @@ class FECFilterBuiltin: public SrtPacketFilterBase
         size_t drop;      //< by how much the sequence should increase to get to the next series
         size_t collected; //< how many packets were taken to collect the clip
 
-        Group(): base(CSeqNo::m_iMaxSeqNo), step(0), drop(0), collected(0)
+        Group(): base(SRT_SEQNO_NONE), step(0), drop(0), collected(0)
         {
         }
 
@@ -68,6 +70,12 @@ class FECFilterBuiltin: public SrtPacketFilterBase
             SINGLE  // Horizontal-only with no recursion
         };
 
+        static Type FlipType(Type t)
+        {
+            SRT_ASSERT(t != SINGLE);
+            return (t == HORIZ) ? VERT : HORIZ;
+        }
+
     };
 
     struct RcvGroup: Group
@@ -79,7 +87,7 @@ class FECFilterBuiltin: public SrtPacketFilterBase
 #if ENABLE_HEAVY_LOGGING
         std::string DisplayStats()
         {
-            if (base == CSeqNo::m_iMaxSeqNo)
+            if (base == SRT_SEQNO_NONE)
                 return "UNINITIALIZED!!!";
 
             std::ostringstream os;
@@ -183,21 +191,43 @@ class FECFilterBuiltin: public SrtPacketFilterBase
 
     // Receiving
     void CheckLargeDrop(int32_t seqno);
-    int ExtendRows(int rowx);
-    int ExtendColumns(int colgx);
-    void MarkCellReceived(int32_t seq);
-    bool HangHorizontal(const CPacket& pkt, bool fec_ctl, loss_seqs_t& irrecover);
-    bool HangVertical(const CPacket& pkt, signed char fec_colx, loss_seqs_t& irrecover);
+    size_t ExtendRows(size_t rowx);
+    size_t ExtendColumns(size_t colgx);
+
+    enum ECellReceived
+    {
+        CELL_RECEIVED, //< mark cell for a received packet (no matter current value)
+        CELL_EXTEND,  //< just make sure there's a place for a packet, set false if not
+        CELL_REMOVE  //< even if a packet was marked true, remove the cell existence confirmation
+    };
+    void MarkCellReceived(int32_t seq, ECellReceived recv = CELL_RECEIVED);
+
+    enum EHangStatus
+    {
+        HANG_NOTDONE,
+        HANG_SUCCESS,
+        HANG_PAST,
+        HANG_CRAZY
+    };
+
+    friend bool operator <(FECFilterBuiltin::EHangStatus a, FECFilterBuiltin::EHangStatus b)
+    {
+        return int(a) < int(b);
+    }
+
+    EHangStatus HangHorizontal(const CPacket& pkt, bool fec_ctl, loss_seqs_t& irrecover);
+    EHangStatus HangVertical(const CPacket& pkt, signed char fec_colx, loss_seqs_t& irrecover);
     void ClipControlPacket(Group& g, const CPacket& pkt);
     void ClipRebuiltPacket(Group& g, Receive::PrivPacket& pkt);
     void RcvRebuild(Group& g, int32_t seqno, Group::Type tp);
     int32_t RcvGetLossSeqHoriz(Group& g);
     int32_t RcvGetLossSeqVert(Group& g);
+    bool CheckEmergencyShrink(size_t n_series, size_t size_in_packets);
 
     static void TranslateLossRecords(const std::set<int32_t>& loss, loss_seqs_t& irrecover);
     void RcvCheckDismissColumn(int32_t seqno, int colgx, loss_seqs_t& irrecover);
-    int RcvGetRowGroupIndex(int32_t seq);
-    int RcvGetColumnGroupIndex(int32_t seq);
+    int RcvGetRowGroupIndex(int32_t seq, EHangStatus& w_status);
+    int RcvGetColumnGroupIndex(int32_t seqno, EHangStatus& w_status);
     void CollectIrrecoverRow(RcvGroup& g, loss_seqs_t& irrecover) const;
     bool IsLost(int32_t seq) const;
 
@@ -243,6 +273,11 @@ class FECFilterBuiltin: public SrtPacketFilterBase
     static const size_t EXTRA_SIZE = 4;
 
     virtual SRT_ARQLevel arqLevel() ATR_OVERRIDE { return m_fallback_level; }
+
+    static const char defaultConfig [];
+    static bool verifyConfig(const SrtFilterConfig& config, std::string& w_errormsg);
 };
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/filelist.maf b/srtcore/filelist.maf
index 74759f515..e801c8b7f 100644
--- a/srtcore/filelist.maf
+++ b/srtcore/filelist.maf
@@ -2,7 +2,9 @@
 
 SOURCES
 api.cpp
-buffer.cpp
+buffer_snd.cpp
+buffer_rcv.cpp
+buffer_tools.cpp
 cache.cpp
 channel.cpp
 common.cpp
@@ -14,18 +16,24 @@ handshake.cpp
 list.cpp
 logger_default.cpp
 logger_defs.cpp
+logging.cpp
 md5.cpp
 packet.cpp
 packetfilter.cpp
 queue.cpp
 congctl.cpp
+socketconfig.cpp
 srt_c_api.cpp
-window.cpp
 srt_compat.c
+strerror_defs.cpp
 sync.cpp
+tsbpd_time.cpp
+window.cpp
 
-SOURCES - ENABLE_EXPERIMENTAL_BONDING
+SOURCES - ENABLE_BONDING
 group.cpp
+group_backup.cpp
+group_common.cpp
 
 SOURCES - !ENABLE_STDCXX_SYNC
 sync_posix.cpp
@@ -47,7 +55,9 @@ udt.h
 
 PRIVATE HEADERS
 api.h
-buffer.h
+buffer_snd.h
+buffer_rcv.h
+buffer_tools.h
 cache.h
 channel.h
 common.h
@@ -63,10 +73,15 @@ packet.h
 sync.h
 queue.h
 congctl.h
+socketconfig.h
 srt_compat.h
+stats.h
 threadname.h
+tsbpd_time.h
 utilities.h
 window.h
 
-PRIVATE HEADERS - ENABLE_EXPERIMENTAL_BONDING
+PRIVATE HEADERS - ENABLE_BONDING
 group.h
+group_backup.h
+group_common.h
diff --git a/srtcore/group.cpp b/srtcore/group.cpp
index 9b3a26a01..5601cdeee 100644
--- a/srtcore/group.cpp
+++ b/srtcore/group.cpp
@@ -7,11 +7,14 @@
 
 using namespace std;
 using namespace srt::sync;
+using namespace srt::groups;
 using namespace srt_logging;
 
 // The SRT_DEF_VERSION is defined in core.cpp.
 extern const int32_t SRT_DEF_VERSION;
 
+namespace srt {
+
 int32_t CUDTGroup::s_tokenGen = 0;
 
 // [[using locked(this->m_GroupLock)]];
@@ -48,7 +51,7 @@ bool CUDTGroup::getBufferTimeBase(CUDT*                     forthesakeof,
     if (!master)
         return false;
 
-    w_wp = master->m_pRcvBuffer->getInternalTimeBase((w_tb), (w_dr));
+    master->m_pRcvBuffer->getInternalTimeBase((w_tb), (w_wp), (w_dr));
 
     // Sanity check
     if (is_zero(w_tb))
@@ -82,7 +85,7 @@ bool CUDTGroup::applyGroupSequences(SRTSOCKET target, int32_t& w_snd_isn, int32_
 
             // SndCurrSeqNo is initially set to ISN-1, this next one is
             // the sequence that is about to be stamped on the next sent packet
-            // over that socket. Using this field is safer because it is volatile
+            // over that socket. Using this field is safer because it is atomic
             // and its affinity is to the same thread as the sending function.
 
             // NOTE: the groupwise scheduling sequence might have been set
@@ -115,7 +118,7 @@ bool CUDTGroup::applyGroupSequences(SRTSOCKET target, int32_t& w_snd_isn, int32_
 
             HLOGC(gmlog.Debug,
                   log << "applyGroupSequences: @" << target << " gets seq from @" << gi->id << " rcv %" << (w_rcv_isn)
-                      << " snd %" << (w_rcv_isn) << " as " << update_reason);
+                      << " snd %" << (w_snd_isn) << " as " << update_reason);
             return false;
         }
     }
@@ -147,8 +150,8 @@ void CUDTGroup::debugMasterData(SRTSOCKET slave)
     // time when the connection process is done, until the first reading/writing happens.
     ScopedLock cg(m_GroupLock);
 
-    SRTSOCKET mpeer;
-    steady_clock::time_point start_time;
+    IF_LOGGING(SRTSOCKET mpeer = SRT_INVALID_SOCK);
+    IF_LOGGING(steady_clock::time_point start_time);
 
     bool found = false;
 
@@ -159,8 +162,8 @@ void CUDTGroup::debugMasterData(SRTSOCKET slave)
             // Found it. Get the socket's peer's ID and this socket's
             // Start Time. Once it's delivered, this can be used to calculate
             // the Master-to-Slave start time difference.
-            mpeer = gi->ps->m_PeerID;
-            start_time    = gi->ps->core().socketStartTime();
+            IF_LOGGING(mpeer = gi->ps->m_PeerID);
+            IF_LOGGING(start_time = gi->ps->core().socketStartTime());
             HLOGC(gmlog.Debug,
                   log << "getMasterData: found RUNNING master @" << gi->id << " - reporting master's peer $" << mpeer
                       << " starting at " << FormatTime(start_time));
@@ -185,8 +188,8 @@ void CUDTGroup::debugMasterData(SRTSOCKET slave)
             // Found it. Get the socket's peer's ID and this socket's
             // Start Time. Once it's delivered, this can be used to calculate
             // the Master-to-Slave start time difference.
-            mpeer = gi->ps->core().m_PeerID;
-            start_time    = gi->ps->core().socketStartTime();
+            IF_LOGGING(mpeer = gi->ps->core().m_PeerID);
+            IF_LOGGING(start_time    = gi->ps->core().socketStartTime());
             HLOGC(gmlog.Debug,
                     log << "getMasterData: found IDLE/PENDING master @" << gi->id << " - reporting master's peer $" << mpeer
                     << " starting at " << FormatTime(start_time));
@@ -203,7 +206,7 @@ void CUDTGroup::debugMasterData(SRTSOCKET slave)
     {
         // The returned master_st is the master's start time. Calculate the
         // differene time.
-        steady_clock::duration master_tdiff = m_tsStartTime - start_time;
+        IF_LOGGING(steady_clock::duration master_tdiff = m_tsStartTime - start_time);
         LOGC(cnlog.Debug, log << CONID() << "FOUND GROUP MASTER LINK: peer=$" << mpeer
                 << " - start time diff: " << FormatDuration<DUNIT_S>(master_tdiff));
     }
@@ -211,9 +214,7 @@ void CUDTGroup::debugMasterData(SRTSOCKET slave)
 
 // GROUP
 
-std::list<CUDTGroup::SocketData> CUDTGroup::GroupContainer::s_NoList;
-
-CUDTGroup::gli_t CUDTGroup::add(SocketData data)
+CUDTGroup::SocketData* CUDTGroup::add(SocketData data)
 {
     ScopedLock g(m_GroupLock);
 
@@ -225,12 +226,12 @@ CUDTGroup::gli_t CUDTGroup::add(SocketData data)
     data.sndstate = SRT_GST_PENDING;
     data.rcvstate = SRT_GST_PENDING;
 
-    HLOGC(gmlog.Debug, log << "CUDTGroup::add: adding new member @" << data.id);
+    LOGC(gmlog.Note, log << "group/add: adding member @" << data.id << " into group $" << id());
     m_Group.push_back(data);
     gli_t end = m_Group.end();
     if (m_iMaxPayloadSize == -1)
     {
-        int plsize = data.ps->m_pUDT->OPT_PayloadSize();
+        int plsize = (int)data.ps->core().OPT_PayloadSize();
         HLOGC(gmlog.Debug,
               log << "CUDTGroup::add: taking MAX payload size from socket @" << data.ps->m_SocketID << ": " << plsize
                   << " " << (plsize ? "(explicit)" : "(unspecified = fallback to 1456)"));
@@ -242,58 +243,23 @@ CUDTGroup::gli_t CUDTGroup::add(SocketData data)
         m_iMaxPayloadSize = plsize;
     }
 
-    return --end;
-}
-
-CUDTGroup::SocketData CUDTGroup::prepareData(CUDTSocket* s)
-{
-    // This uses default SRT_GST_BROKEN because when the group operation is done,
-    // then the SRT_GST_IDLE state automatically turns into SRT_GST_RUNNING. This is
-    // recognized as an initial state of the fresh added socket to the group,
-    // so some "initial configuration" must be done on it, after which it's
-    // turned into SRT_GST_RUNNING, that is, it's treated as all others. When
-    // set to SRT_GST_BROKEN, this socket is disregarded. This socket isn't cleaned
-    // up, however, unless the status is simultaneously SRTS_BROKEN.
-
-    // The order of operations is then:
-    // - add the socket to the group in this "broken" initial state
-    // - connect the socket (or get it extracted from accept)
-    // - update the socket state (should be SRTS_CONNECTED)
-    // - once the connection is established (may take time with connect), set SRT_GST_IDLE
-    // - the next operation of send/recv will automatically turn it into SRT_GST_RUNNING
-    SocketData sd = {
-        s->m_SocketID,
-        s,
-        -1,
-        SRTS_INIT,
-        SRT_GST_BROKEN,
-        SRT_GST_BROKEN,
-        -1,
-        -1,
-        sockaddr_any(),
-        sockaddr_any(),
-        false,
-        false,
-        false,
-        0 // weight
-    };
-    return sd;
+    --end;
+    return &*end;
 }
 
 CUDTGroup::CUDTGroup(SRT_GROUP_TYPE gtype)
-    : m_pGlobal(&CUDT::s_UDTUnited)
+    : m_Global(CUDT::uglobal())
     , m_GroupID(-1)
     , m_PeerGroupID(-1)
-    , m_selfManaged(true)
-    , m_bSyncOnMsgNo(false)
     , m_type(gtype)
     , m_listener()
     , m_iBusy()
     , m_iSndOldestMsgNo(SRT_MSGNO_NONE)
     , m_iSndAckedMsgNo(SRT_MSGNO_NONE)
-    , m_uOPT_StabilityTimeout(CUDT::COMM_DEF_STABILITY_TIMEOUT_US)
+    , m_uOPT_MinStabilityTimeout_us(1000 * CSrtConfig::COMM_DEF_MIN_STABILITY_TIMEOUT_MS)
     // -1 = "undefined"; will become defined with first added socket
     , m_iMaxPayloadSize(-1)
+    , m_iAvgPayloadSize(-1)
     , m_bSynRecving(true)
     , m_bSynSending(true)
     , m_bTsbPd(true)
@@ -313,38 +279,16 @@ CUDTGroup::CUDTGroup(SRT_GROUP_TYPE gtype)
     , m_iLastSchedMsgNo(SRT_MSGNO_NONE)
 {
     setupMutex(m_GroupLock, "Group");
-    setupMutex(m_RcvDataLock, "RcvData");
-    setupCond(m_RcvDataCond, "RcvData");
-    m_RcvEID = m_pGlobal->m_EPoll.create(&m_RcvEpolld);
-    m_SndEID = m_pGlobal->m_EPoll.create(&m_SndEpolld);
+    setupMutex(m_RcvDataLock, "G/RcvData");
+    setupCond(m_RcvDataCond, "G/RcvData");
+    m_RcvEID = m_Global.m_EPoll.create(&m_RcvEpolld);
+    m_SndEID = m_Global.m_EPoll.create(&m_SndEpolld);
+
+    m_stats.init();
 
     // Set this data immediately during creation before
     // two or more sockets start arguing about it.
     m_iLastSchedSeqNo = CUDT::generateISN();
-
-    // Configure according to type
-    switch (gtype)
-    {
-    case SRT_GTYPE_BROADCAST:
-        m_selfManaged = true;
-        break;
-
-    case SRT_GTYPE_BACKUP:
-        m_selfManaged = true;
-        break;
-
-    case SRT_GTYPE_BALANCING:
-        m_selfManaged  = true;
-        m_bSyncOnMsgNo = true;
-        break;
-
-    case SRT_GTYPE_MULTICAST:
-        m_selfManaged = false;
-        break;
-
-    default:
-        break;
-    }
 }
 
 CUDTGroup::~CUDTGroup()
@@ -363,6 +307,7 @@ void CUDTGroup::GroupContainer::erase(CUDTGroup::gli_t it)
         if (m_List.empty())
         {
             LOGC(gmlog.Error, log << "IPE: GroupContainer is empty and 'erase' is called on it.");
+            m_LastActiveLink = m_List.end();
             return; // this avoids any misunderstandings in iterator checks
         }
 
@@ -371,7 +316,7 @@ void CUDTGroup::GroupContainer::erase(CUDTGroup::gli_t it)
         if (bb == m_List.end()) // means: m_List.size() == 1
         {
             // One element, this one being deleted, nothing to point to.
-            m_LastActiveLink = null();
+            m_LastActiveLink = m_List.end();
         }
         else
         {
@@ -391,6 +336,7 @@ void CUDTGroup::GroupContainer::erase(CUDTGroup::gli_t it)
         }
     }
     m_List.erase(it);
+    --m_SizeCache;
 }
 
 void CUDTGroup::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
@@ -417,12 +363,19 @@ void CUDTGroup::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
         m_iRcvTimeOut = cast_optval<int>(optval, optlen);
         break;
 
-    case SRTO_GROUPSTABTIMEO:
+    case SRTO_GROUPMINSTABLETIMEO:
     {
-        const int val = cast_optval<int>(optval, optlen);
+        const int val_ms = cast_optval<int>(optval, optlen);
+        const int min_timeo_ms = (int) CSrtConfig::COMM_DEF_MIN_STABILITY_TIMEOUT_MS;
+        if (val_ms < min_timeo_ms)
+        {
+            LOGC(qmlog.Error,
+                 log << "group option: SRTO_GROUPMINSTABLETIMEO min allowed value is " << min_timeo_ms << " ms.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
 
         // Search if you already have SRTO_PEERIDLETIMEO set
-        int                          idletmo = CUDT::COMM_RESPONSE_TIMEOUT_MS;
+        int idletmo = CSrtConfig::COMM_RESPONSE_TIMEOUT_MS;
         vector<ConfigItem>::iterator f =
             find_if(m_config.begin(), m_config.end(), ConfigItem::OfType(SRTO_PEERIDLETIMEO));
         if (f != m_config.end())
@@ -430,29 +383,18 @@ void CUDTGroup::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
             f->get(idletmo); // worst case, it will leave it unchanged.
         }
 
-        if (val >= idletmo)
+        if (val_ms > idletmo)
         {
             LOGC(qmlog.Error,
-                 log << "group option: SRTO_GROUPSTABTIMEO(" << val << ") exceeds SRTO_PEERIDLETIMEO(" << idletmo
-                     << ")");
+                 log << "group option: SRTO_GROUPMINSTABLETIMEO=" << val_ms << " exceeds SRTO_PEERIDLETIMEO=" << idletmo);
             throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
         }
 
-        m_uOPT_StabilityTimeout = val * 1000;
+        m_uOPT_MinStabilityTimeout_us = 1000 * val_ms;
     }
 
     break;
 
-        // XXX Currently no socket groups allow any other
-        // congestion control mode other than live.
-    case SRTO_CONGESTION:
-    {
-        LOGP(gmlog.Error, "group option: SRTO_CONGESTION is only allowed as 'live' and cannot be changed");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-    }
-
-        // Other options to be specifically interpreted by group may follow.
-
     default:
         break;
     }
@@ -460,12 +402,11 @@ void CUDTGroup::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
     // All others must be simply stored for setting on a socket.
     // If the group is already open and any post-option is about
     // to be modified, it must be allowed and applied on all sockets.
-
     if (m_bOpened)
     {
         // There's at least one socket in the group, so only
         // post-options are allowed.
-        if (!std::binary_search(srt_post_opt_list, srt_post_opt_list + SRT_SOCKOPT_NPOST, optName))
+        if (!binary_search(srt_post_opt_list, srt_post_opt_list + SRT_SOCKOPT_NPOST, optName))
         {
             LOGC(gmlog.Error, log << "setsockopt(group): Group is connected, this option can't be altered");
             throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);
@@ -474,10 +415,19 @@ void CUDTGroup::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)
         HLOGC(gmlog.Debug, log << "... SPREADING to existing sockets.");
         // This means that there are sockets already, so apply
         // this option on them.
-        ScopedLock gg(m_GroupLock);
-        for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
+        std::vector<CUDTSocket*> ps_vec;
+        {
+            // Do copy to avoid deadlock. CUDT::setOpt() cannot be called directly inside this loop, because
+            // CUDT::setOpt() will lock m_ConnectionLock, which should be locked before m_GroupLock.
+            ScopedLock gg(m_GroupLock);
+            for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
+            {
+                ps_vec.push_back(gi->ps);
+            }
+        }
+        for (std::vector<CUDTSocket*>::iterator it = ps_vec.begin(); it != ps_vec.end(); ++it)
         {
-            gi->ps->core().setOpt(optName, optval, optlen);
+            (*it)->core().setOpt(optName, optval, optlen);
         }
     }
 
@@ -525,16 +475,19 @@ void CUDTGroup::deriveSettings(CUDT* u)
     // the option is altered on the group.
 
     // SRTO_RCVSYN
-    m_bSynRecving = u->m_bSynRecving;
+    m_bSynRecving = u->m_config.bSynRecving;
 
     // SRTO_SNDSYN
-    m_bSynSending = u->m_bSynSending;
+    m_bSynSending = u->m_config.bSynSending;
 
     // SRTO_RCVTIMEO
-    m_iRcvTimeOut = u->m_iRcvTimeOut;
+    m_iRcvTimeOut = u->m_config.iRcvTimeOut;
 
     // SRTO_SNDTIMEO
-    m_iSndTimeOut = u->m_iSndTimeOut;
+    m_iSndTimeOut = u->m_config.iSndTimeOut;
+
+    // SRTO_GROUPMINSTABLETIMEO
+    m_uOPT_MinStabilityTimeout_us = 1000 * u->m_config.uMinStabilityTimeout_ms;
 
     // Ok, this really is disgusting, but there's only one way
     // to properly do it. Would be nice to have some more universal
@@ -547,61 +500,65 @@ void CUDTGroup::deriveSettings(CUDT* u)
     // to be potentially replicated on the socket. So both pre
     // and post options apply.
 
-#define IM(option, field) importOption(m_config, option, u->field)
+#define IM(option, field) importOption(m_config, option, u->m_config.field)
+#define IMF(option, field) importOption(m_config, option, u->field)
 
-    IM(SRTO_MSS, m_iMSS);
-    IM(SRTO_FC, m_iFlightFlagSize);
+    IM(SRTO_MSS, iMSS);
+    IM(SRTO_FC, iFlightFlagSize);
 
     // Nonstandard
-    importOption(m_config, SRTO_SNDBUF, u->m_iSndBufSize * (u->m_iMSS - CPacket::UDP_HDR_SIZE));
-    importOption(m_config, SRTO_RCVBUF, u->m_iRcvBufSize * (u->m_iMSS - CPacket::UDP_HDR_SIZE));
+    importOption(m_config, SRTO_SNDBUF, u->m_config.iSndBufSize * (u->m_config.iMSS - CPacket::UDP_HDR_SIZE));
+    importOption(m_config, SRTO_RCVBUF, u->m_config.iRcvBufSize * (u->m_config.iMSS - CPacket::UDP_HDR_SIZE));
 
-    IM(SRTO_LINGER, m_Linger);
-    IM(SRTO_UDP_SNDBUF, m_iUDPSndBufSize);
-    IM(SRTO_UDP_RCVBUF, m_iUDPRcvBufSize);
+    IM(SRTO_LINGER, Linger);
+    IM(SRTO_UDP_SNDBUF, iUDPSndBufSize);
+    IM(SRTO_UDP_RCVBUF, iUDPRcvBufSize);
     // SRTO_RENDEZVOUS: impossible to have it set on a listener socket.
     // SRTO_SNDTIMEO/RCVTIMEO: groupwise setting
-    IM(SRTO_CONNTIMEO, m_tdConnTimeOut);
-    IM(SRTO_DRIFTTRACER, m_bDriftTracer);
+    IM(SRTO_CONNTIMEO, tdConnTimeOut);
+    IM(SRTO_DRIFTTRACER, bDriftTracer);
     // Reuseaddr: true by default and should only be true.
-    IM(SRTO_MAXBW, m_llMaxBW);
-    IM(SRTO_INPUTBW, m_llInputBW);
-    IM(SRTO_OHEADBW, m_iOverheadBW);
-    IM(SRTO_IPTOS, m_iIpToS);
-    IM(SRTO_IPTTL, m_iIpTTL);
-    IM(SRTO_TSBPDMODE, m_bOPT_TsbPd);
-    IM(SRTO_RCVLATENCY, m_iOPT_TsbPdDelay);
-    IM(SRTO_PEERLATENCY, m_iOPT_PeerTsbPdDelay);
-    IM(SRTO_SNDDROPDELAY, m_iOPT_SndDropDelay);
-    IM(SRTO_PAYLOADSIZE, m_zOPT_ExpPayloadSize);
-    IM(SRTO_TLPKTDROP, m_bTLPktDrop);
-    IM(SRTO_STREAMID, m_sStreamName);
-    IM(SRTO_MESSAGEAPI, m_bMessageAPI);
-    IM(SRTO_NAKREPORT, m_bRcvNakReport);
-    IM(SRTO_MINVERSION, m_lMinimumPeerSrtVersion);
-    IM(SRTO_ENFORCEDENCRYPTION, m_bOPT_StrictEncryption);
-    IM(SRTO_IPV6ONLY, m_iIpV6Only);
-    IM(SRTO_PEERIDLETIMEO, m_iOPT_PeerIdleTimeout);
-    IM(SRTO_GROUPSTABTIMEO, m_uOPT_StabilityTimeout);
-    IM(SRTO_PACKETFILTER, m_OPT_PktFilterConfigString);
+    IM(SRTO_MAXBW, llMaxBW);
+    IM(SRTO_INPUTBW, llInputBW);
+    IM(SRTO_MININPUTBW, llMinInputBW);
+    IM(SRTO_OHEADBW, iOverheadBW);
+    IM(SRTO_IPTOS, iIpToS);
+    IM(SRTO_IPTTL, iIpTTL);
+    IM(SRTO_TSBPDMODE, bTSBPD);
+    IM(SRTO_RCVLATENCY, iRcvLatency);
+    IM(SRTO_PEERLATENCY, iPeerLatency);
+    IM(SRTO_SNDDROPDELAY, iSndDropDelay);
+    IM(SRTO_PAYLOADSIZE, zExpPayloadSize);
+    IMF(SRTO_TLPKTDROP, m_bTLPktDrop);
+
+    importOption(m_config, SRTO_STREAMID, u->m_config.sStreamName.str());
+
+    IM(SRTO_MESSAGEAPI, bMessageAPI);
+    IM(SRTO_NAKREPORT, bRcvNakReport);
+    IM(SRTO_MINVERSION, uMinimumPeerSrtVersion);
+    IM(SRTO_ENFORCEDENCRYPTION, bEnforcedEnc);
+    IM(SRTO_IPV6ONLY, iIpV6Only);
+    IM(SRTO_PEERIDLETIMEO, iPeerIdleTimeout_ms);
+
+    importOption(m_config, SRTO_PACKETFILTER, u->m_config.sPacketFilterConfig.str());
 
     importOption(m_config, SRTO_PBKEYLEN, u->m_pCryptoControl->KeyLen());
 
     // Passphrase is empty by default. Decipher the passphrase and
     // store as passphrase option
-    if (u->m_CryptoSecret.len)
+    if (u->m_config.CryptoSecret.len)
     {
-        string password((const char*)u->m_CryptoSecret.str, u->m_CryptoSecret.len);
-        m_config.push_back(ConfigItem(SRTO_PASSPHRASE, password.c_str(), password.size()));
+        string password((const char*)u->m_config.CryptoSecret.str, u->m_config.CryptoSecret.len);
+        m_config.push_back(ConfigItem(SRTO_PASSPHRASE, password.c_str(), (int)password.size()));
     }
 
-    IM(SRTO_KMREFRESHRATE, m_uKmRefreshRatePkt);
-    IM(SRTO_KMPREANNOUNCE, m_uKmPreAnnouncePkt);
+    IM(SRTO_KMREFRESHRATE, uKmRefreshRatePkt);
+    IM(SRTO_KMPREANNOUNCE, uKmPreAnnouncePkt);
 
     string cc = u->m_CongCtl.selected_name();
     if (cc != "live")
     {
-        m_config.push_back(ConfigItem(SRTO_CONGESTION, cc.c_str(), cc.size()));
+        m_config.push_back(ConfigItem(SRTO_CONGESTION, cc.c_str(), (int)cc.size()));
     }
 
     // NOTE: This is based on information extracted from the "semi-copy-constructor" of CUDT class.
@@ -609,40 +566,18 @@ void CUDTGroup::deriveSettings(CUDT* u)
     // are assigned to configurable items.
 
 #undef IM
+#undef IMF
 }
 
-bool CUDTGroup::applyFlags(uint32_t flags, HandshakeSide hsd)
+bool CUDTGroup::applyFlags(uint32_t flags, HandshakeSide)
 {
-    bool synconmsg = IsSet(flags, SRT_GFLAG_SYNCONMSG);
-
-    if (m_type == SRT_GTYPE_BALANCING)
-    {
-        // We support only TRUE for this flag
-        if (!synconmsg)
-        {
-            HLOGP(gmlog.Debug, "GROUP: Balancing mode implemented only with sync on msgno - overridden request");
-            return true; // accept, but override
-        }
-
-        // We have this flag set; change it in yourself, if needed.
-        if (hsd == HSD_INITIATOR && !m_bSyncOnMsgNo)
-        {
-            // With this you can change in future the default value to false.
-            HLOGP(gmlog.Debug, "GROUP: Balancing requrested msgno-sync, OVERRIDING original setting");
-            m_bSyncOnMsgNo = true;
-            return true;
-        }
-    }
-    else
+    const bool synconmsg = IsSet(flags, SRT_GFLAG_SYNCONMSG);
+    if (synconmsg)
     {
-        if (synconmsg)
-        {
-            LOGP(gmlog.Error, "GROUP: non-balancing type requested sync on msgno - IPE/EPE?");
-            return false;
-        }
+        LOGP(gmlog.Error, "GROUP: requested sync on msgno - not supported.");
+        return false;
     }
 
-    // Ignore the flag anyway. This can change in future versions though.
     return true;
 }
 
@@ -663,7 +598,7 @@ inline int Value<std::string>::fill(void* optval, int len, std::string value)
     if (size_t(len) < value.size())
         return 0;
     memcpy(optval, value.c_str(), value.size());
-    return value.size();
+    return (int) value.size();
 }
 
 template <class V>
@@ -674,7 +609,7 @@ inline int fillValue(void* optval, int len, V value)
 
 static bool getOptDefault(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
 {
-    static const linger def_linger = {1, CUDT::DEF_LINGER_S};
+    static const linger def_linger = {1, CSrtConfig::DEF_LINGER_S};
     switch (optname)
     {
     default:
@@ -692,7 +627,7 @@ static bool getOptDefault(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
         RD(16);
 
     case SRTO_MSS:
-        RD(CUDT::DEF_MSS);
+        RD(CSrtConfig::DEF_MSS);
 
     case SRTO_SNDSYN:
         RD(true);
@@ -701,18 +636,18 @@ static bool getOptDefault(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
     case SRTO_ISN:
         RD(SRT_SEQNO_NONE);
     case SRTO_FC:
-        RD(CUDT::DEF_FLIGHT_SIZE);
+        RD(CSrtConfig::DEF_FLIGHT_SIZE);
 
     case SRTO_SNDBUF:
     case SRTO_RCVBUF:
-        w_optlen = fillValue((pw_optval), w_optlen, CUDT::DEF_BUFFER_SIZE * (CUDT::DEF_MSS - CPacket::UDP_HDR_SIZE));
+        w_optlen = fillValue((pw_optval), w_optlen, CSrtConfig::DEF_BUFFER_SIZE * (CSrtConfig::DEF_MSS - CPacket::UDP_HDR_SIZE));
         break;
 
     case SRTO_LINGER:
         RD(def_linger);
     case SRTO_UDP_SNDBUF:
     case SRTO_UDP_RCVBUF:
-        RD(CUDT::DEF_UDP_BUFFER_SIZE);
+        RD(CSrtConfig::DEF_UDP_BUFFER_SIZE);
     case SRTO_RENDEZVOUS:
         RD(false);
     case SRTO_SNDTIMEO:
@@ -775,12 +710,24 @@ static bool getOptDefault(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
         RD(true);
     case SRTO_PAYLOADSIZE:
         RD(0);
+    case SRTO_GROUPMINSTABLETIMEO:
+        RD(CSrtConfig::COMM_DEF_MIN_STABILITY_TIMEOUT_MS);
     }
 
 #undef RD
     return true;
 }
 
+struct FOptionValue
+{
+    SRT_SOCKOPT expected;
+    FOptionValue(SRT_SOCKOPT v): expected(v) {}
+    bool operator()(const CUDTGroup::ConfigItem& i) const
+    {
+        return i.so == expected;
+    }
+};
+
 void CUDTGroup::getOpt(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
 {
     // Options handled in group
@@ -796,57 +743,134 @@ void CUDTGroup::getOpt(SRT_SOCKOPT optname, void* pw_optval, int& w_optlen)
         w_optlen          = sizeof(bool);
         return;
 
+    case SRTO_SNDTIMEO:
+        *(int*)pw_optval = m_iSndTimeOut;
+        w_optlen = sizeof(int);
+        return;
+
+    case SRTO_RCVTIMEO:
+        *(int*)pw_optval = m_iRcvTimeOut;
+        w_optlen = sizeof(int);
+        return;
+
+    case SRTO_GROUPMINSTABLETIMEO:
+        *(uint32_t*)pw_optval = m_uOPT_MinStabilityTimeout_us / 1000;
+        w_optlen = sizeof(uint32_t);
+        return;
+
+    case SRTO_KMSTATE:
+        *(uint32_t*)pw_optval = getGroupEncryptionState();
+        w_optlen = sizeof(uint32_t);
+        return;
+
+        // Write-only options for security reasons or
+        // options that refer to a socket state, that
+        // makes no sense for a group.
+    case SRTO_PASSPHRASE:
+    case SRTO_KMPREANNOUNCE:
+    case SRTO_KMREFRESHRATE:
+    case SRTO_BINDTODEVICE:
+    case SRTO_GROUPCONNECT:
+    case SRTO_STATE:
+    case SRTO_EVENT:
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
     default:; // pass on
     }
 
-    // XXX Suspicous: may require locking of GlobControlLock
-    // to prevent from deleting a socket in the meantime.
-    // Deleting a socket requires removing from the group first,
-    // so after GroupLock this will be either already NULL or
-    // a valid socket that will only be closed after time in
-    // the GC, so this is likely safe like all other API functions.
-    CUDTSocket* ps = 0;
-
+    bool is_set_on_socket = false;
     {
-        // In sockets. All sockets should have all options
-        // set the same and should represent the group state
-        // well enough. If there are no sockets, just use default.
-
-        // Group lock to protect the container itself.
-        // Once a socket is extracted, we state it cannot be
-        // closed without the group send/recv function or closing
-        // being involved.
-        ScopedLock lg(m_GroupLock);
-        if (m_Group.empty())
+        // Can't have m_GroupLock locked while calling getOpt on a member socket
+        // because the call will acquire m_ControlLock leading to a lock-order-inversion.
+        enterCS(m_GroupLock);
+        gli_t gi = m_Group.begin();
+        CUDTSocket* const ps = (gi != m_Group.end()) ? gi->ps : NULL;
+        CUDTUnited::SocketKeeper sk(CUDT::uglobal(), ps);
+        leaveCS(m_GroupLock);
+        if (sk.socket)
         {
-            if (!getOptDefault(optname, (pw_optval), (w_optlen)))
-                throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+            // Return the value from the first member socket, if any is present
+            // Note: Will throw exception if the request is wrong.
+            sk.socket->core().getOpt(optname, (pw_optval), (w_optlen));
+            is_set_on_socket = true;
+        }
+    }
+
+    // Check if the option is in the storage, which means that
+    // it was modified on the group.
 
+    vector<ConfigItem>::const_iterator i = find_if(m_config.begin(), m_config.end(),
+            FOptionValue(optname));
+
+    if (i == m_config.end())
+    {
+        // Already written to the target variable.
+        if (is_set_on_socket)
             return;
-        }
 
-        ps = m_Group.begin()->ps;
+        // Not found, see the defaults
+        if (!getOptDefault(optname, (pw_optval), (w_optlen)))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
 
-        // Release the lock on the group, as it's not necessary,
-        // as well as it might cause a deadlock when combined
-        // with the others.
+        return;
     }
+    // NOTE: even if is_set_on_socket, if it was also found in the group
+    // settings, overwrite with the value from the group.
 
-    if (!ps)
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    // Found, return the value from the storage.
+    // Check the size first.
+    if (w_optlen < int(i->value.size()))
+        throw CUDTException(MJ_NOTSUP, MN_XSIZE, 0);
 
-    return ps->core().getOpt(optname, (pw_optval), (w_optlen));
+    w_optlen = i->value.size();
+    memcpy((pw_optval), &i->value[0], i->value.size());
 }
 
-struct HaveState : public unary_function<pair<SRTSOCKET, SRT_SOCKSTATUS>, bool>
+SRT_KM_STATE CUDTGroup::getGroupEncryptionState()
 {
-    SRT_SOCKSTATUS s;
-    HaveState(SRT_SOCKSTATUS ss)
-        : s(ss)
+    multiset<SRT_KM_STATE> kmstates;
     {
+        ScopedLock lk (m_GroupLock);
+
+        // First check the container. If empty, return UNSECURED
+        if (m_Group.empty())
+            return SRT_KM_S_UNSECURED;
+
+        for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
+        {
+            CCryptoControl* cc = gi->ps->core().m_pCryptoControl.get();
+            if (!cc)
+                continue;
+            SRT_KM_STATE gst = cc->m_RcvKmState;
+            // A fix to NOSECRET is because this is the state when agent has set
+            // no password, but peer did, and ENFORCEDENCRYPTION=false allowed
+            // this connection to be established. UNSECURED can't be taken in this
+            // case because this would suggest that BOTH are unsecured, that is,
+            // we have established an unsecured connection (which ain't true).
+            if (gst == SRT_KM_S_UNSECURED && cc->m_SndKmState == SRT_KM_S_NOSECRET)
+                gst = SRT_KM_S_NOSECRET;
+            kmstates.insert(gst);
+        }
     }
-    bool operator()(pair<SRTSOCKET, SRT_SOCKSTATUS> i) const { return i.second == s; }
-};
+
+    // Criteria are:
+    // 1. UNSECURED, if no member sockets, or at least one UNSECURED found.
+    // 2. SECURED, if at least one SECURED found (cut off the previous criteria).
+    // 3. BADSECRET otherwise, although return NOSECRET if no BADSECRET is found.
+
+    if (kmstates.count(SRT_KM_S_UNSECURED))
+        return SRT_KM_S_UNSECURED;
+
+    // Now we have UNSECURED ruled out. Remaining may be NOSECRET, BADSECRET or SECURED.
+    // NOTE: SECURING is an intermediate state for HSv4 and can't occur in groups.
+    if (kmstates.count(SRT_KM_S_SECURED))
+        return SRT_KM_S_SECURED;
+
+    if (kmstates.count(SRT_KM_S_BADSECRET))
+        return SRT_KM_S_BADSECRET;
+
+    return SRT_KM_S_NOSECRET;
+}
 
 SRT_SOCKSTATUS CUDTGroup::getStatus()
 {
@@ -893,7 +917,7 @@ SRT_SOCKSTATUS CUDTGroup::getStatus()
         if (i->second == SRTS_NONEXIST)
         {
             // Otherwise find at least one socket, which's state isn't broken.
-            i->second = m_pGlobal->getStatus(i->first);
+            i->second = m_Global.getStatus(i->first);
             if (pending_state == SRTS_NONEXIST)
                 pending_state = i->second;
         }
@@ -919,23 +943,14 @@ void CUDTGroup::syncWithSocket(const CUDT& core, const HandshakeSide side)
         set_currentSchedSequence(core.ISN());
     }
 
-    // XXX
-    // Might need further investigation as to whether this isn't
-    // wrong for some cases. By having this -1 here the value will be
-    // laziliy set from the first reading one. It is believed that
-    // it covers all possible scenarios, that is:
-    //
-    // - no readers - no problem!
-    // - have some readers and a new is attached - this is set already
-    // - connect multiple links, but none has read yet - you'll be the first.
-    //
-    // Previous implementation used setting to: core.m_iPeerISN
-    resetInitialRxSequence();
+    // Only set if was not initialized to avoid problems on a running connection.
+    if (m_RcvBaseSeqNo == SRT_SEQNO_NONE) 
+        m_RcvBaseSeqNo = CSeqNo::decseq(core.m_iPeerISN);
 
     // Get the latency (possibly fixed against the opposite side)
     // from the first socket (core.m_iTsbPdDelay_ms),
     // and set it on the current socket.
-    set_latency(core.m_iTsbPdDelay_ms * int64_t(1000));
+    set_latency_us(core.m_iTsbPdDelay_ms * int64_t(1000));
 }
 
 void CUDTGroup::close()
@@ -944,19 +959,9 @@ void CUDTGroup::close()
     vector<SRTSOCKET> ids;
 
     {
-        ScopedLock glob(CUDT::s_UDTUnited.m_GlobControlLock);
+        ScopedLock glob(CUDT::uglobal().m_GlobControlLock);
         ScopedLock g(m_GroupLock);
 
-        // A non-managed group may only be closed if there are no
-        // sockets in the group.
-
-        // XXX Fortunately there are currently no non-self-managed
-        // groups, so this error cannot ever happen, but this error
-        // has the overall code suggesting that it's about the listener,
-        // so either the name should be changed here, or a different code used.
-        if (!m_selfManaged && !m_Group.empty())
-            throw CUDTException(MJ_NOTSUP, MN_BUSY, 0);
-
         m_bClosing = true;
 
         // Copy the list of IDs into the array.
@@ -965,14 +970,24 @@ void CUDTGroup::close()
             ids.push_back(ig->id);
             // Immediately cut ties to this group.
             // Just for a case, redispatch the socket, to stay safe.
-            CUDTSocket* s = CUDT::s_UDTUnited.locateSocket_LOCKED(ig->id);
+            CUDTSocket* s = CUDT::uglobal().locateSocket_LOCKED(ig->id);
             if (!s)
             {
                 HLOGC(smlog.Debug, log << "group/close: IPE(NF): group member @" << ig->id << " already deleted");
                 continue;
             }
-            s->m_IncludedGroup = NULL;
-            s->m_IncludedIter = gli_NULL();
+
+            // Make the socket closing BEFORE withdrawing its group membership
+            // because a socket created as a group member cannot be valid
+            // without the group.
+            // This is not true in case of non-managed groups, which
+            // only collect sockets, but also non-managed groups should not
+            // use common group buffering and tsbpd. Also currently there are
+            // no other groups than managed one.
+            s->setClosing();
+
+            s->m_GroupOf = NULL;
+            s->m_GroupMemberData = NULL;
             HLOGC(smlog.Debug, log << "group/close: CUTTING OFF @" << ig->id << " (found as @" << s->m_SocketID << ") from the group");
         }
 
@@ -987,7 +1002,7 @@ void CUDTGroup::close()
         {
             // Global EPOLL lock must be applied to access any socket's epoll set.
             // This is a set of all epoll ids subscribed to it.
-            ScopedLock elock (CUDT::s_UDTUnited.m_EPoll.m_EPollLock);
+            ScopedLock elock (CUDT::uglobal().m_EPoll.m_EPollLock);
             epollid = m_sPollID; // use move() in C++11
             m_sPollID.clear();
         }
@@ -998,7 +1013,7 @@ void CUDTGroup::close()
             HLOGC(smlog.Debug, log << "close: CLEARING subscription on E" << (*i) << " of $" << id());
             try
             {
-                CUDT::s_UDTUnited.m_EPoll.update_usock(*i, id(), &no_events);
+                CUDT::uglobal().m_EPoll.update_usock(*i, id(), &no_events);
             }
             catch (...)
             {
@@ -1018,7 +1033,7 @@ void CUDTGroup::close()
     {
         try
         {
-            CUDT::s_UDTUnited.close(*i);
+            CUDT::uglobal().close(*i);
         }
         catch (CUDTException&)
         {
@@ -1047,10 +1062,10 @@ void CUDTGroup::close()
     // XXX This looks like a dead code. Group receiver functions
     // do not use any lock on m_RcvDataLock, it is likely a remainder
     // of the old, internal impementation. 
-    // CSync::lock_signal(m_RcvDataCond, m_RcvDataLock);
+    // CSync::lock_notify_one(m_RcvDataCond, m_RcvDataLock);
 }
 
-// [[using locked(m_pGlobal->m_GlobControlLock)]]
+// [[using locked(m_Global->m_GlobControlLock)]]
 // [[using locked(m_GroupLock)]]
 void CUDTGroup::send_CheckValidSockets()
 {
@@ -1059,7 +1074,7 @@ void CUDTGroup::send_CheckValidSockets()
     for (gli_t d = m_Group.begin(), d_next = d; d != m_Group.end(); d = d_next)
     {
         ++d_next; // it's now safe to erase d
-        CUDTSocket* revps = m_pGlobal->locateSocket_LOCKED(d->id);
+        CUDTSocket* revps = m_Global.locateSocket_LOCKED(d->id);
         if (revps != d->ps)
         {
             // Note: the socket might STILL EXIST, just in the trash, so
@@ -1115,25 +1130,26 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
     // for which NO ITERATORS ARE INVALIDATED after a node at particular
     // iterator has been removed, except for that iterator itself.
     vector<SRTSOCKET> wipeme;
-    vector<gli_t> idlers;
-    vector<SRTSOCKET> pending; // need sock ids as it will be checked out of lock
+    vector<gli_t> idleLinks;
+    vector<SRTSOCKET> pendingSockets; // need sock ids as it will be checked out of lock
 
-    int32_t curseq = SRT_SEQNO_NONE;
+    int32_t curseq = SRT_SEQNO_NONE;  // The seqno of the first packet of this message.
+    int32_t nextseq = SRT_SEQNO_NONE;  // The seqno of the first packet of next message.
 
     int rstat = -1;
 
     int                          stat = 0;
     SRT_ATR_UNUSED CUDTException cx(MJ_SUCCESS, MN_NONE, 0);
 
-    vector<gli_t> sendable;
+    vector<gli_t> activeLinks;
 
     // First, acquire GlobControlLock to make sure all member sockets still exist
-    enterCS(m_pGlobal->m_GlobControlLock);
+    enterCS(m_Global.m_GlobControlLock);
     ScopedLock guard(m_GroupLock);
 
     if (m_bClosing)
     {
-        leaveCS(m_pGlobal->m_GlobControlLock);
+        leaveCS(m_Global.m_GlobControlLock);
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
@@ -1141,7 +1157,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
 
     // LOCKED: GlobControlLock, GroupLock (RIGHT ORDER!)
     send_CheckValidSockets();
-    leaveCS(m_pGlobal->m_GlobControlLock);
+    leaveCS(m_Global.m_GlobControlLock);
     // LOCKED: GroupLock (only)
     // Since this moment GlobControlLock may only be locked if GroupLock is unlocked first.
 
@@ -1200,7 +1216,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             {
                 HLOGC(gslog.Debug,
                       log << "CUDTGroup::send. @" << d->id << " is still " << SockStatusStr(st) << ", skipping.");
-                pending.push_back(d->id);
+                pendingSockets.push_back(d->id);
                 continue;
             }
 
@@ -1211,7 +1227,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             // - we need at least one running socket to work BEFORE activating the idle one.
             // - if ALL SOCKETS ARE IDLE, then we simply activate the first from the list,
             //   and all others will be activated using the ISN from the first one.
-            idlers.push_back(d);
+            idleLinks.push_back(d);
             continue;
         }
 
@@ -1219,7 +1235,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         {
             HLOGC(gslog.Debug,
                   log << "grp/sendBroadcast: socket in RUNNING state: @" << d->id << " - will send a payload");
-            sendable.push_back(d);
+            activeLinks.push_back(d);
             continue;
         }
 
@@ -1227,12 +1243,14 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
               log << "grp/sendBroadcast: socket @" << d->id << " not ready, state: " << StateStr(d->sndstate) << "("
                   << int(d->sndstate) << ") - NOT sending, SET AS PENDING");
 
-        pending.push_back(d->id);
+        pendingSockets.push_back(d->id);
     }
 
     vector<Sendstate> sendstates;
+    if (w_mc.srctime == 0)
+        w_mc.srctime = count_microseconds(steady_clock::now().time_since_epoch());
 
-    for (vector<gli_t>::iterator snd = sendable.begin(); snd != sendable.end(); ++snd)
+    for (vector<gli_t>::iterator snd = activeLinks.begin(); snd != activeLinks.end(); ++snd)
     {
         gli_t d   = *snd;
         int   erc = 0; // success
@@ -1255,9 +1273,10 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         if (stat != -1)
         {
             curseq = w_mc.pktseq;
+            nextseq = d->ps->core().schedSeqNo();
         }
 
-        const Sendstate cstate = {d->id, d, stat, erc};
+        const Sendstate cstate = {d->id, &*d, stat, erc};
         sendstates.push_back(cstate);
         d->sndresult  = stat;
         d->laststatus = d->ps->getStatus();
@@ -1293,21 +1312,19 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
     // and therefore take over the leading role in setting the ISN. If the
     // second one fails, too, then the only remaining idle link will simply
     // go with its own original sequence.
-    //
-    // On the opposite side the reader should know that the link is inactive
-    // so the first received payload activates it. Activation of an idle link
-    // means that the very first packet arriving is TAKEN AS A GOOD DEAL, that is,
-    // no LOSSREPORT is sent even if the sequence looks like a "jumped over".
-    // Only for activated links is the LOSSREPORT sent upon seqhole detection.
+
+    // On the opposite side, if the first packet arriving looks like a jump over,
+    // the corresponding LOSSREPORT is sent. For packets that are truly lost,
+    // the sender retransmits them, for packets that before ISN, DROPREQ is sent.
 
     // Now we can go to the idle links and attempt to send the payload
     // also over them.
 
-    // { sendBroadcast_ActivateIdlers
-    for (vector<gli_t>::iterator i = idlers.begin(); i != idlers.end(); ++i)
+    // TODO: { sendBroadcast_ActivateIdleLinks
+    for (vector<gli_t>::iterator i = idleLinks.begin(); i != idleLinks.end(); ++i)
     {
         gli_t d       = *i;
-        if (!d->ps->m_IncludedGroup)
+        if (!d->ps->m_GroupOf)
             continue;
 
         int   erc     = 0;
@@ -1348,6 +1365,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             // Note: this will override the sequence number
             // for all next iterations in this loop.
             curseq = w_mc.pktseq;
+            nextseq = d->ps->core().schedSeqNo();
             HLOGC(gslog.Debug,
                     log << "@" << d->id << ":... sending SUCCESSFUL %" << curseq << " MEMBER STATUS: RUNNING");
         }
@@ -1355,21 +1373,22 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         d->sndresult  = stat;
         d->laststatus = d->ps->getStatus();
 
-        const Sendstate cstate = {d->id, d, stat, erc};
+        const Sendstate cstate = {d->id, &*d, stat, erc};
         sendstates.push_back(cstate);
     }
 
-    if (curseq != SRT_SEQNO_NONE)
+    if (nextseq != SRT_SEQNO_NONE)
     {
-        HLOGC(gslog.Debug, log << "grp/sendBroadcast: updating current scheduling sequence %" << curseq);
-        m_iLastSchedSeqNo = curseq;
+        HLOGC(gslog.Debug,
+              log << "grp/sendBroadcast: $" << id() << ": updating current scheduling sequence %" << nextseq);
+        m_iLastSchedSeqNo = nextseq;
     }
 
     // }
 
     // { send_CheckBrokenSockets()
 
-    if (!pending.empty())
+    if (!pendingSockets.empty())
     {
         HLOGC(gslog.Debug, log << "grp/sendBroadcast: found pending sockets, polling them.");
 
@@ -1377,12 +1396,12 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // at the connecting stage.
         CEPoll::fmap_t sready;
 
-        if (m_SndEpolld->watch_empty())
+        if (m_Global.m_EPoll.empty(*m_SndEpolld))
         {
             // Sanity check - weird pending reported.
             LOGC(gslog.Error,
                  log << "grp/sendBroadcast: IPE: reported pending sockets, but EID is empty - wiping pending!");
-            copy(pending.begin(), pending.end(), back_inserter(wipeme));
+            copy(pendingSockets.begin(), pendingSockets.end(), back_inserter(wipeme));
         }
         else
         {
@@ -1390,7 +1409,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                 InvertedLock ug(m_GroupLock);
 
                 THREAD_PAUSED();
-                m_pGlobal->m_EPoll.swait(
+                m_Global.m_EPoll.swait(
                     *m_SndEpolld, sready, 0, false /*report by retval*/); // Just check if anything happened
                 THREAD_RESUMED();
             }
@@ -1404,7 +1423,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             HLOGC(gslog.Debug, log << "grp/sendBroadcast: RDY: " << DisplayEpollResults(sready));
 
             // sockets in EX: should be moved to wipeme.
-            for (vector<SRTSOCKET>::iterator i = pending.begin(); i != pending.end(); ++i)
+            for (vector<SRTSOCKET>::iterator i = pendingSockets.begin(); i != pendingSockets.end(); ++i)
             {
                 if (CEPoll::isready(sready, *i, SRT_EPOLL_ERR))
                 {
@@ -1413,7 +1432,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                     // Failed socket. Move d to wipeme. Remove from eid.
                     wipeme.push_back(*i);
                     int no_events = 0;
-                    m_pGlobal->m_EPoll.update_usock(m_SndEID, *i, &no_events);
+                    m_Global.m_EPoll.update_usock(m_SndEID, *i, &no_events);
                 }
             }
 
@@ -1423,7 +1442,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             // as redundant links at the connecting stage and became
             // writable (connected) before this function had a chance
             // to check them.
-            m_pGlobal->m_EPoll.clear_ready_usocks(*m_SndEpolld, SRT_EPOLL_CONNECT);
+            m_Global.m_EPoll.clear_ready_usocks(*m_SndEpolld, SRT_EPOLL_CONNECT);
         }
     }
 
@@ -1447,12 +1466,11 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
     // Links that were successful, have the len value in state.
 
     // First thing then, find out if at least one link was successful.
-    // This might even be one of the idlers only, this doesn't matter.
-    // If there were any running links successful, they have set the sequence.
-    // If there were only some reactivated idlers successful, the first
-    // idler has defined the sequence.
+    // The first successful link sets the sequence value,
+    // the following links derive it. This might be also the first idle
+    // link with its random-generated ISN, if there were no active links.
 
-    vector<gli_t> successful, blocked;
+    vector<SocketData*> successful, blocked;
 
     // This iteration of the state will simply
     // qualify the remaining sockets into three categories:
@@ -1464,12 +1482,12 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
     // Now - sendstates contain directly sockets.
     // In order to update members, you need to have locked:
     // - GlobControlLock to prevent sockets from disappearing or being closed
-    // - then GroupLock to latch the validity of m_IncludedIter field.
+    // - then GroupLock to latch the validity of m_GroupMemberData field.
 
     {
         {
             InvertedLock ung (m_GroupLock);
-            enterCS(CUDT::s_UDTUnited.m_GlobControlLock);
+            enterCS(CUDT::uglobal().m_GlobControlLock);
             HLOGC(gslog.Debug, log << "grp/sendBroadcast: Locked GlobControlLock, locking back GroupLock");
         }
 
@@ -1477,7 +1495,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // the Sendstate::it field shall not be used here!
         for (vector<Sendstate>::iterator is = sendstates.begin(); is != sendstates.end(); ++is)
         {
-            CUDTSocket* ps = CUDT::s_UDTUnited.locateSocket_LOCKED(is->id);
+            CUDTSocket* ps = CUDT::uglobal().locateSocket_LOCKED(is->id);
 
             // Is the socket valid? If not, simply SKIP IT. Nothing to be done with it,
             // it's already deleted.
@@ -1486,11 +1504,11 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
 
             // Is the socket still group member? If not, SKIP IT. It could only be taken ownership
             // by being explicitly closed and so it's deleted from the container.
-            if (!ps->m_IncludedGroup)
+            if (!ps->m_GroupOf)
                 continue;
 
-            // Now we are certain that m_IncludedIter is valid.
-            gli_t d = ps->m_IncludedIter;
+            // Now we are certain that m_GroupMemberData is valid.
+            SocketData* d = ps->m_GroupMemberData;
 
             if (is->stat == len)
             {
@@ -1521,7 +1539,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         }
 
         // Now you can leave GlobControlLock, while GroupLock is still locked.
-        leaveCS(CUDT::s_UDTUnited.m_GlobControlLock);
+        leaveCS(CUDT::uglobal().m_GlobControlLock);
     }
 
     // Re-check after the waiting lock has been reacquired
@@ -1542,7 +1560,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // Good. All blocked links are now qualified as broken.
         // You had your chance, but I can't leave you here,
         // there will be no further chance to reattempt sending.
-        for (vector<gli_t>::iterator b = blocked.begin(); b != blocked.end(); ++b)
+        for (vector<SocketData*>::iterator b = blocked.begin(); b != blocked.end(); ++b)
         {
             (*b)->sndstate = SRT_GST_BROKEN;
         }
@@ -1556,9 +1574,12 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
 
     int ercode = 0;
 
-    if (was_blocked)
+    // This block causes waiting for any socket to accept the payload.
+    // This should be done only in blocking mode and only if no other socket
+    // accepted the payload.
+    if (was_blocked && none_succeeded && m_bSynSending)
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
         if (!m_bSynSending)
         {
             throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
@@ -1573,15 +1594,13 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // haven't sent the payload over any link so far, so we still have
         // a chance to retry.
         int modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
-        for (vector<gli_t>::iterator b = blocked.begin(); b != blocked.end(); ++b)
+        for (vector<SocketData*>::iterator b = blocked.begin(); b != blocked.end(); ++b)
         {
             HLOGC(gslog.Debug,
                   log << "Will block on blocked socket @" << (*b)->id << " as only blocked socket remained");
-            CUDT::s_UDTUnited.epoll_add_usock_INTERNAL(m_SndEID, (*b)->ps, &modes);
+            CUDT::uglobal().epoll_add_usock_INTERNAL(m_SndEID, (*b)->ps, &modes);
         }
 
-        const int blocklen = blocked.size();
-
         int            blst = 0;
         CEPoll::fmap_t sready;
 
@@ -1592,7 +1611,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
 
             // m_iSndTimeOut is -1 by default, which matches the meaning of waiting forever
             THREAD_PAUSED();
-            blst = m_pGlobal->m_EPoll.swait(*m_SndEpolld, sready, m_iSndTimeOut);
+            blst = m_Global.m_EPoll.swait(*m_SndEpolld, sready, m_iSndTimeOut);
             THREAD_RESUMED();
 
             // NOTE EXCEPTIONS:
@@ -1613,7 +1632,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         }
         else
         {
-            sendable.clear();
+            activeLinks.clear();
             sendstates.clear();
             // Extract gli's from the whole group that have id found in the array.
 
@@ -1631,10 +1650,10 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                     dd->sndstate = SRT_GST_BROKEN;
                 }
                 else if (rdev & SRT_EPOLL_OUT)
-                    sendable.push_back(dd);
+                    activeLinks.push_back(dd);
             }
 
-            for (vector<gli_t>::iterator snd = sendable.begin(); snd != sendable.end(); ++snd)
+            for (vector<gli_t>::iterator snd = activeLinks.begin(); snd != activeLinks.end(); ++snd)
             {
                 gli_t d   = *snd;
 
@@ -1645,8 +1664,8 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                     // This must be wrapped in try-catch because on error it throws an exception.
                     // Possible return values are only 0, in case when len was passed 0, or a positive
                     // >0 value that defines the size of the data that it has sent, that is, in case
-                    // of Live mode, equal to 'blocklen'.
-                    stat = d->ps->core().sendmsg2(buf, blocklen, (w_mc));
+                    // of Live mode, equal to 'len'.
+                    stat = d->ps->core().sendmsg2(buf, len, (w_mc));
                 }
                 catch (CUDTException& e)
                 {
@@ -1657,7 +1676,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                 if (stat != -1)
                     curseq = w_mc.pktseq;
 
-                const Sendstate cstate = {d->id, d, stat, erc};
+                const Sendstate cstate = {d->id, &*d, stat, erc};
                 sendstates.push_back(cstate);
                 d->sndresult  = stat;
                 d->laststatus = d->ps->getStatus();
@@ -1668,10 +1687,10 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
             // NOTE: m_GroupLock is continuously locked - you can safely use Sendstate::it field.
             for (vector<Sendstate>::iterator is = sendstates.begin(); is != sendstates.end(); ++is)
             {
-                if (is->stat == blocklen)
+                if (is->stat == len)
                 {
                     // Successful.
-                    successful.push_back(is->it);
+                    successful.push_back(is->mb);
                     rstat          = is->stat;
                     was_blocked    = false;
                     none_succeeded = false;
@@ -1684,7 +1703,7 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
                           << "). Setting this socket broken status.");
 #endif
                 // Turn this link broken
-                is->it->sndstate = SRT_GST_BROKEN;
+                is->mb->sndstate = SRT_GST_BROKEN;
             }
         }
     }
@@ -1694,8 +1713,8 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
     if (none_succeeded)
     {
         HLOGC(gslog.Debug, log << "grp/sendBroadcast: all links broken (none succeeded to send a payload)");
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
         // Reparse error code, if set.
         // It might be set, if the last operation was failed.
         // If any operation succeeded, this will not be executed anyway.
@@ -1705,8 +1724,21 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         throw CUDTException(major, minor, 0);
     }
 
+    for (vector<Sendstate>::iterator is = sendstates.begin(); is != sendstates.end(); ++is)
+    {
+        // Here we have a situation that at least 1 link successfully sent a packet.
+        // All links for which sending has failed must be closed.
+        if (is->stat == -1)
+        {
+            // This only sets the state to the socket; the GC process should
+            // pick it up at the next time.
+            HLOGC(gslog.Debug, log << "grp/sendBroadcast: per PARTIAL SUCCESS, closing failed @" << is->id);
+            is->mb->ps->setBrokenClosed();
+        }
+    }
+
     // Now that at least one link has succeeded, update sending stats.
-    m_stats.sent.Update(len);
+    m_stats.sent.count(len);
 
     // Pity that the blocking mode only determines as to whether this function should
     // block or not, but the epoll flags must be updated regardless of the mode.
@@ -1742,13 +1774,13 @@ int CUDTGroup::sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // is performed, and this one will result in none-write-ready, this will
         // be fixed just after returning from this function.
 
-        ready_again = ready_again | d->ps->writeReady();
+        ready_again = ready_again || d->ps->writeReady();
     }
     w_mc.grpdata_size = i;
 
     if (!ready_again)
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
     }
 
     return rstat;
@@ -1789,7 +1821,7 @@ int CUDTGroup::getGroupData_LOCKED(SRT_SOCKGROUPDATA* pdata, size_t* psize)
         copyGroupData(*d, (pdata[i]));
     }
 
-    return m_Group.size();
+    return (int)m_Group.size();
 }
 
 // [[using locked(this->m_GroupLock)]]
@@ -1894,7 +1926,7 @@ void CUDTGroup::fillGroupData(SRT_MSGCTRL&       w_out, // MSGCTRL to be written
     w_out.grpdata = grpdata;
 }
 
-// [[using locked(CUDT::s_UDTUnited.m_GlobControLock)]]
+// [[using locked(CUDT::uglobal()->m_GlobControLock)]]
 // [[using locked(m_GroupLock)]]
 struct FLookupSocketWithEvent_LOCKED
 {
@@ -1919,6 +1951,201 @@ struct FLookupSocketWithEvent_LOCKED
     }
 };
 
+void CUDTGroup::recv_CollectAliveAndBroken(vector<CUDTSocket*>& alive, set<CUDTSocket*>& broken)
+{
+#if ENABLE_HEAVY_LOGGING
+    std::ostringstream ds;
+    ds << "E(" << m_RcvEID << ") ";
+#define HCLOG(expr) expr
+#else
+#define HCLOG(x) if (false) {}
+#endif
+
+    alive.reserve(m_Group.size());
+
+    HLOGC(grlog.Debug, log << "group/recv: Reviewing member sockets for polling");
+    for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
+    {
+        if (gi->laststatus == SRTS_CONNECTING)
+        {
+            HCLOG(ds << "@" << gi->id << "<pending> ");
+            continue; // don't read over a failed or pending socket
+        }
+
+        if (gi->laststatus >= SRTS_BROKEN)
+        {
+            broken.insert(gi->ps);
+        }
+
+        if (broken.count(gi->ps))
+        {
+            HCLOG(ds << "@" << gi->id << "<broken> ");
+            continue;
+        }
+
+        if (gi->laststatus != SRTS_CONNECTED)
+        {
+            HCLOG(ds << "@" << gi->id << "<unstable:" << SockStatusStr(gi->laststatus) << "> ");
+            // Sockets in this state are ignored. We are waiting until it
+            // achieves CONNECTING state, then it's added to write.
+            // Or gets broken and closed in the next step.
+            continue;
+        }
+
+        // Don't skip packets that are ahead because if we have a situation
+        // that all links are either "elephants" (do not report read readiness)
+        // and "kangaroos" (have already delivered an ahead packet) then
+        // omitting kangaroos will result in only elephants to be polled for
+        // reading. Due to the strict timing requirements and ensurance that
+        // TSBPD on every link will result in exactly the same delivery time
+        // for a packet of given sequence, having an elephant and kangaroo in
+        // one cage means that the elephant is simply a broken or half-broken
+        // link (the data are not delivered, but it will get repaired soon,
+        // enough for SRT to maintain the connection, but it will still drop
+        // packets that didn't arrive in time), in both cases it may
+        // potentially block the reading for an indefinite time, while
+        // simultaneously a kangaroo might be a link that got some packets
+        // dropped, but then it's still capable to deliver packets on time.
+
+        // Note that gi->id might be a socket that was previously being polled
+        // on write, when it's attempting to connect, but now it's connected.
+        // This will update the socket with the new event set.
+
+        alive.push_back(gi->ps);
+        HCLOG(ds << "@" << gi->id << "[READ] ");
+    }
+
+    HLOGC(grlog.Debug, log << "group/recv: " << ds.str() << " --> EPOLL/SWAIT");
+#undef HCLOG
+}
+
+vector<CUDTSocket*> CUDTGroup::recv_WaitForReadReady(const vector<CUDTSocket*>& aliveMembers, set<CUDTSocket*>& w_broken)
+{
+    if (aliveMembers.empty())
+    {
+        LOGC(grlog.Error, log << "group/recv: all links broken");
+        throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
+    }
+
+    for (vector<CUDTSocket*>::const_iterator i = aliveMembers.begin(); i != aliveMembers.end(); ++i)
+    {
+        // NOT using the official srt_epoll_add_usock because this will do socket dispatching,
+        // which requires lock on m_GlobControlLock, while this lock cannot be applied without
+        // first unlocking m_GroupLock.
+        const int read_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+        CUDT::uglobal().epoll_add_usock_INTERNAL(m_RcvEID, *i, &read_modes);
+    }
+
+    // Here we need to make an additional check.
+    // There might be a possibility that all sockets that
+    // were added to the reader group, are ahead. At least
+    // surely we don't have a situation that any link contains
+    // an ahead-read subsequent packet, because GroupCheckPacketAhead
+    // already handled that case.
+    //
+    // What we can have is that every link has:
+    // - no known seq position yet (is not registered in the position map yet)
+    // - the position equal to the latest delivered sequence
+    // - the ahead position
+
+    // Now the situation is that we don't have any packets
+    // waiting for delivery so we need to wait for any to report one.
+
+    // The non-blocking mode would need to simply check the readiness
+    // with only immediate report, and read-readiness would have to
+    // be done in background.
+
+    // In blocking mode, use m_iRcvTimeOut, which's default value -1
+    // means to block indefinitely, also in swait().
+    // In non-blocking mode use 0, which means to always return immediately.
+    int timeout = m_bSynRecving ? m_iRcvTimeOut : 0;
+    int nready = 0;
+    // Poll on this descriptor until reading is available, indefinitely.
+    CEPoll::fmap_t sready;
+
+    // GlobControlLock is required for dispatching the sockets.
+    // Therefore it must be applied only when GroupLock is off.
+    {
+        // This call may wait indefinite time, so GroupLock must be unlocked.
+        InvertedLock ung (m_GroupLock);
+        THREAD_PAUSED();
+        nready  = m_Global.m_EPoll.swait(*m_RcvEpolld, sready, timeout, false /*report by retval*/);
+        THREAD_RESUMED();
+
+        // HERE GlobControlLock is locked first, then GroupLock is applied back
+        enterCS(CUDT::uglobal().m_GlobControlLock);
+    }
+    // BOTH m_GlobControlLock AND m_GroupLock are locked here.
+
+    HLOGC(grlog.Debug, log << "group/recv: " << nready << " RDY: " << DisplayEpollResults(sready));
+
+    if (nready == 0)
+    {
+        // GlobControlLock is applied manually, so unlock manually.
+        // GroupLock will be unlocked as per scope.
+        leaveCS(CUDT::uglobal().m_GlobControlLock);
+        // This can only happen when 0 is passed as timeout and none is ready.
+        // And 0 is passed only in non-blocking mode. So this is none ready in
+        // non-blocking mode.
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+        throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
+    }
+
+    // Handle sockets of pending connection and with errors.
+
+    // Nice to have something like:
+
+    // broken = FilterIf(sready, [] (auto s)
+    //                   { return s.second == SRT_EPOLL_ERR && (auto cs = g->locateSocket(s.first, ERH_RETURN))
+    //                          ? {cs, true}
+    //                          : {nullptr, false}
+    //                   });
+
+    FilterIf(
+        /*FROM*/ sready.begin(),
+        sready.end(),
+        /*TO*/ std::inserter(w_broken, w_broken.begin()),
+        /*VIA*/ FLookupSocketWithEvent_LOCKED(&m_Global, SRT_EPOLL_ERR));
+
+    
+    // If this set is empty, it won't roll even once, therefore output
+    // will be surely empty. This will be checked then same way as when
+    // reading from every socket resulted in error.
+    vector<CUDTSocket*> readReady;
+    readReady.reserve(aliveMembers.size());
+    for (vector<CUDTSocket*>::const_iterator sockiter = aliveMembers.begin(); sockiter != aliveMembers.end(); ++sockiter)
+    {
+        CUDTSocket* sock = *sockiter;
+        const CEPoll::fmap_t::const_iterator ready_iter = sready.find(sock->m_SocketID);
+        if (ready_iter != sready.end())
+        {
+            if (ready_iter->second & SRT_EPOLL_ERR)
+                continue; // broken already
+
+            if ((ready_iter->second & SRT_EPOLL_IN) == 0)
+                continue; // not ready for reading
+
+            readReady.push_back(*sockiter);
+        }
+        else
+        {
+            // No read-readiness reported by epoll, but can be missed or not yet handled
+            // while the receiver buffer is in fact read-ready.
+            ScopedLock lg(sock->core().m_RcvBufferLock);
+            if (!sock->core().m_pRcvBuffer)
+                continue;
+            // Checking for the next packet in the RCV buffer is safer that isReadReady(tnow).
+            const CRcvBuffer::PacketInfo info = sock->core().m_pRcvBuffer->getFirstValidPacketInfo();
+            if (info.seqno != SRT_SEQNO_NONE && !info.seq_gap)
+                readReady.push_back(sock);
+        }
+    }
+    
+    leaveCS(CUDT::uglobal().m_GlobControlLock);
+
+    return readReady;
+}
+
 void CUDTGroup::updateReadState(SRTSOCKET /* not sure if needed */, int32_t sequence)
 {
     bool       ready = false;
@@ -1965,31 +2192,63 @@ void CUDTGroup::updateReadState(SRTSOCKET /* not sure if needed */, int32_t sequ
 
     if (ready)
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, true);
     }
 }
 
+int32_t CUDTGroup::getRcvBaseSeqNo()
+{
+    ScopedLock lg(m_GroupLock);
+    return m_RcvBaseSeqNo;
+}
+
 void CUDTGroup::updateWriteState()
 {
     ScopedLock lg(m_GroupLock);
-    m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, true);
+    m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, true);
 }
 
-// The "app reader" version of the reading function.
-// This reads the packets from every socket treating them as independent
-// and prepared to work with the application. Then packets are sorted out
-// by getting the sequence number.
-int CUDTGroup::recv(char* buf, int len, SRT_MSGCTRL& w_mc)
+/// Validate iPktSeqno is in range
+/// (iBaseSeqno - m_iSeqNoTH/2; iBaseSeqno + m_iSeqNoTH).
+///
+/// EXPECT_EQ(isValidSeqno(125, 124), true); // behind
+/// EXPECT_EQ(isValidSeqno(125, 125), true); // behind
+/// EXPECT_EQ(isValidSeqno(125, 126), true); // the next in order
+///
+/// EXPECT_EQ(isValidSeqno(0, 0x3FFFFFFF - 2), true);  // ahead, but ok.
+/// EXPECT_EQ(isValidSeqno(0, 0x3FFFFFFF - 1), false); // too far ahead.
+/// EXPECT_EQ(isValidSeqno(0x3FFFFFFF + 2, 0x7FFFFFFF), false); // too far ahead.
+/// EXPECT_EQ(isValidSeqno(0x3FFFFFFF + 3, 0x7FFFFFFF), true); // ahead, but ok.
+/// EXPECT_EQ(isValidSeqno(0x3FFFFFFF, 0x1FFFFFFF + 2), false); // too far (behind)
+/// EXPECT_EQ(isValidSeqno(0x3FFFFFFF, 0x1FFFFFFF + 3), true); // behind, but ok
+/// EXPECT_EQ(isValidSeqno(0x70000000, 0x0FFFFFFF), true); // ahead, but ok
+/// EXPECT_EQ(isValidSeqno(0x70000000, 0x30000000 - 2), false); // too far ahead.
+/// EXPECT_EQ(isValidSeqno(0x70000000, 0x30000000 - 3), true); // ahead, but ok
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0), true);
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0x7FFFFFFF), true);
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0x70000000), false);
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0x70000001), false);
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0x70000002), true);  // behind by 536870910
+/// EXPECT_EQ(isValidSeqno(0x0FFFFFFF, 0x70000003), true);
+///
+/// @return false if @a iPktSeqno is not inside the valid range; otherwise true.
+static bool isValidSeqno(int32_t iBaseSeqno, int32_t iPktSeqno)
 {
-    typedef map<SRTSOCKET, ReadPos>::iterator pit_t;
-    // Later iteration over it might be less efficient than
-    // by vector, but we'll also often try to check a single id
-    // if it was ever seen broken, so that it's skipped.
-    set<CUDTSocket*> broken;
-    size_t output_size = 0;
+    const int32_t iLenAhead = CSeqNo::seqlen(iBaseSeqno, iPktSeqno);
+    if (iLenAhead >= 0 && iLenAhead < CSeqNo::m_iSeqNoTH)
+        return true;
+
+    const int32_t iLenBehind = CSeqNo::seqlen(iPktSeqno, iBaseSeqno);
+    if (iLenBehind >= 0 && iLenBehind < CSeqNo::m_iSeqNoTH / 2)
+        return true;
 
+    return false;
+}
+
+int CUDTGroup::recv(char* buf, int len, SRT_MSGCTRL& w_mc)
+{
     // First, acquire GlobControlLock to make sure all member sockets still exist
-    enterCS(m_pGlobal->m_GlobControlLock);
+    enterCS(m_Global.m_GlobControlLock);
     ScopedLock guard(m_GroupLock);
 
     if (m_bClosing)
@@ -1999,749 +2258,201 @@ int CUDTGroup::recv(char* buf, int len, SRT_MSGCTRL& w_mc)
         // must fist wait for being able to acquire this lock.
         // The group will not be deleted now because it is added usage counter
         // by this call, but will be released once it exits.
-        leaveCS(m_pGlobal->m_GlobControlLock);
+        leaveCS(m_Global.m_GlobControlLock);
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
     // Now, still under lock, check if all sockets still can be dispatched
     send_CheckValidSockets();
-    leaveCS(m_pGlobal->m_GlobControlLock);
+    leaveCS(m_Global.m_GlobControlLock);
 
     if (m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
+    // Later iteration over it might be less efficient than
+    // by vector, but we'll also often try to check a single id
+    // if it was ever seen broken, so that it's skipped.
+    set<CUDTSocket*> broken;
+
     for (;;)
     {
         if (!m_bOpened || !m_bConnected)
         {
             LOGC(grlog.Error,
-                 log << boolalpha << "group/recv: ERROR opened=" << m_bOpened << " connected=" << m_bConnected);
+                 log << boolalpha << "grp/recv: $" << id() << ": ABANDONING: opened=" << m_bOpened
+                     << " connected=" << m_bConnected);
             throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
         }
 
-        // Check first the ahead packets if you have any to deliver.
-        if (m_RcvBaseSeqNo != SRT_SEQNO_NONE && !m_Positions.empty())
+        vector<CUDTSocket*> aliveMembers;
+        recv_CollectAliveAndBroken(aliveMembers, broken);
+        if (aliveMembers.empty())
         {
-            // This function also updates the group sequence pointer.
-            ReadPos* pos = checkPacketAhead();
-            if (pos)
-            {
-                if (size_t(len) < pos->packet.size())
-                    throw CUDTException(MJ_NOTSUP, MN_XSIZE, 0);
-
-                HLOGC(grlog.Debug,
-                      log << "group/recv: delivering AHEAD packet %" << pos->mctrl.pktseq << " #" << pos->mctrl.msgno
-                          << ": " << BufferStamp(&pos->packet[0], pos->packet.size()));
-                memcpy(buf, &pos->packet[0], pos->packet.size());
-                fillGroupData((w_mc), pos->mctrl);
-                len = pos->packet.size();
-                pos->packet.clear();
-
-                // Update stats as per delivery
-                m_stats.recv.Update(len);
-                updateAvgPayloadSize(len);
-
-                // We predict to have only one packet ahead, others are pending to be reported by tsbpd.
-                // This will be "re-enabled" if the later check puts any new packet into ahead.
-                m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
-
-                return len;
-            }
+            LOGC(grlog.Error, log << "grp/recv: ALL LINKS BROKEN, ABANDONING.");
+            m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+            throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
         }
 
-        // LINK QUALIFICATION NAMES:
-        //
-        // HORSE: Correct link, which delivers the very next sequence.
-        // Not necessarily this link is currently active.
-        //
-        // KANGAROO: Got some packets dropped and the sequence number
-        // of the packet jumps over the very next sequence and delivers
-        // an ahead packet.
-        //
-        // ELEPHANT: Is not ready to read, while others are, or reading
-        // up to the current latest delivery sequence number does not
-        // reach this sequence and the link becomes non-readable earlier.
-
-        // The above condition has ruled out one kangaroo and turned it
-        // into a horse.
-
-        // Below there's a loop that will try to extract packets. Kangaroos
-        // will be among the polled ones because skipping them risks that
-        // the elephants will take over the reading. Links already known as
-        // elephants will be also polled in an attempt to revitalize the
-        // connection that experienced just a short living choking.
-        //
-        // After polling we attempt to read from every link that reported
-        // read-readiness and read at most up to the sequence equal to the
-        // current delivery sequence.
-
-        // Links that deliver a packet below that sequence will be retried
-        // until they deliver no more packets or deliver the packet of
-        // expected sequence. Links that don't have a record in m_Positions
-        // and report readiness will be always read, at least to know what
-        // sequence they currently stand on.
-        //
-        // Links that are already known as kangaroos will be polled, but
-        // no reading attempt will be done. If after the reading series
-        // it will turn out that we have no more horses, the slowest kangaroo
-        // will be "upgraded to a horse" (the ahead link with a sequence
-        // closest to the current delivery sequence will get its sequence
-        // set as current delivered and its recorded ahead packet returned
-        // as the read packet).
-
-        // If we find at least one horse, the packet read from that link
-        // will be delivered. All other link will be just ensured update
-        // up to this sequence number, or at worst all available packets
-        // will be read. In this case all kangaroos remain kangaroos,
-        // until the current delivery sequence m_RcvBaseSeqNo will be lifted
-        // to the sequence recorded for these links in m_Positions,
-        // during the next time ahead check, after which they will become
-        // horses.
-
-#if ENABLE_HEAVY_LOGGING
-        std::ostringstream ds;
-        ds << "E(" << m_RcvEID << ") ";
-#define HCLOG(expr) expr
-#else
-#define HCLOG(x)                                                                                                       \
-    if (false)                                                                                                         \
-    {                                                                                                                  \
-    }
-#endif
-
-        bool   still_alive = false;
-        size_t size        = 0;
-
-        // You can't lock the whole group for that
-        // action because this will result in a deadlock.
-        // Prepare first the list of sockets to be added as connect-pending
-        // and as read-ready, then unlock the group, and then add them to epoll.
-        vector<CUDTSocket*> read_ready;
-        vector<SRTSOCKET> connect_pending;
+        vector<CUDTSocket*> readySockets;
+        if (m_bSynRecving)
+            readySockets = recv_WaitForReadReady(aliveMembers, broken);
+        else
+            readySockets = aliveMembers;
 
+        if (m_bClosing)
         {
-            HLOGC(grlog.Debug, log << "group/recv: Reviewing member sockets to epoll-add");
-            for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
-            {
-                ++size; // list::size loops over all elements anyway, so this hits two birds with one stone
-                if (gi->laststatus == SRTS_CONNECTING)
-                {
-                    HCLOG(ds << "@" << gi->id << "<pending> ");
-                    /*
-                       connect_pending.push_back(gi->id);
-                     */
+            HLOGC(grlog.Debug, log << "grp/recv: $" << id() << ": GROUP CLOSED, ABANDONING.");
+            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
+        }
 
-                    continue; // don't read over a failed or pending socket
-                }
+        // Find the first readable packet among all member sockets.
+        steady_clock::time_point tnow = steady_clock::now();
+        CUDTSocket*               socketToRead = NULL;
+        CRcvBuffer::PacketInfo infoToRead   = {-1, false, time_point()};
+        for (vector<CUDTSocket*>::const_iterator si = readySockets.begin(); si != readySockets.end(); ++si)
+        {
+            CUDTSocket* ps = *si;
 
-                if (gi->laststatus >= SRTS_BROKEN)
+            ScopedLock lg(ps->core().m_RcvBufferLock);
+            if (m_RcvBaseSeqNo != SRT_SEQNO_NONE)
+            {
+                // Drop here to make sure the getFirstReadablePacketInfo() below return fresher packet.
+                int cnt = ps->core().rcvDropTooLateUpTo(CSeqNo::incseq(m_RcvBaseSeqNo));
+                if (cnt > 0)
                 {
-                    broken.insert(gi->ps);
+                    HLOGC(grlog.Debug,
+                          log << "grp/recv: $" << id() << ": @" << ps->m_SocketID << ": dropped " << cnt
+                              << " packets before reading: m_RcvBaseSeqNo=" << m_RcvBaseSeqNo);
                 }
+            }
 
-                if (broken.count(gi->ps))
-                {
-                    HCLOG(ds << "@" << gi->id << "<broken> ");
-                    continue;
-                }
+            const CRcvBuffer::PacketInfo info =
+                ps->core().m_pRcvBuffer->getFirstReadablePacketInfo(tnow);
+            if (info.seqno == SRT_SEQNO_NONE)
+            {
+                HLOGC(grlog.Debug, log << "grp/recv: $" << id() << ": @" << ps->m_SocketID << ": Nothing to read.");
+                continue;
+            }
+            // We need to qualify the sequence, just for a case.
+            if (m_RcvBaseSeqNo != SRT_SEQNO_NONE && !isValidSeqno(m_RcvBaseSeqNo, info.seqno))
+            {
+                LOGC(grlog.Error,
+                     log << "grp/recv: $" << id() << ": @" << ps->m_SocketID << ": SEQUENCE DISCREPANCY: base=%"
+                         << m_RcvBaseSeqNo << " vs pkt=%" << info.seqno << ", setting ESECFAIL");
+                ps->core().m_bBroken = true;
+                broken.insert(ps);
+                continue;
+            }
+            if (socketToRead == NULL || CSeqNo::seqcmp(info.seqno, infoToRead.seqno) < 0)
+            {
+                socketToRead = ps;
+                infoToRead   = info;
 
-                if (gi->laststatus != SRTS_CONNECTED)
+                if (m_RcvBaseSeqNo != SRT_SEQNO_NONE && ((CSeqNo(w_mc.pktseq) - CSeqNo(m_RcvBaseSeqNo)) == 1))
                 {
-                    HCLOG(ds << "@" << gi->id << "<unstable:" << SockStatusStr(gi->laststatus) << "> ");
-                    // Sockets in this state are ignored. We are waiting until it
-                    // achieves CONNECTING state, then it's added to write.
-                    // Or gets broken and closed in the next step.
-                    continue;
+                    // We have the next packet. No need to check other read-ready sockets.
+                    break;
                 }
-
-                still_alive = true;
-
-                // Don't skip packets that are ahead because if we have a situation
-                // that all links are either "elephants" (do not report read readiness)
-                // and "kangaroos" (have already delivered an ahead packet) then
-                // omiting kangaroos will result in only elephants to be polled for
-                // reading. Due to the strict timing requirements and ensurance that
-                // TSBPD on every link will result in exactly the same delivery time
-                // for a packet of given sequence, having an elephant and kangaroo in
-                // one cage means that the elephant is simply a broken or half-broken
-                // link (the data are not delivered, but it will get repaired soon,
-                // enough for SRT to maintain the connection, but it will still drop
-                // packets that didn't arrive in time), in both cases it may
-                // potentially block the reading for an indefinite time, while
-                // simultaneously a kangaroo might be a link that got some packets
-                // dropped, but then it's still capable to deliver packets on time.
-
-                // Note that gi->id might be a socket that was previously being polled
-                // on write, when it's attempting to connect, but now it's connected.
-                // This will update the socket with the new event set.
-
-                read_ready.push_back(gi->ps);
-                HCLOG(ds << "@" << gi->id << "[READ] ");
             }
         }
 
-        int read_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;
-
-        /* Done at the connecting stage so that it won't be missed.
-
-           int connect_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
-           for (vector<SRTSOCKET>::iterator i = connect_pending.begin(); i != connect_pending.end(); ++i)
-           {
-           XXX This is wrong code; this should use the internal function and pass CUDTSocket*
-           epoll_add_usock_INTERNAL(m_RcvEID, i->second, &connect_modes);
-           }
-
-           AND this below additionally for sockets that were so far pending connection,
-           will be now "upgraded" to readable sockets. The epoll adding function for a
-           socket that already is in the eid container will only change the poll flags,
-           but will not re-add it, that is, event reports that are both in old and new
-           flags will survive the operation.
-
-         */
-
-        for (vector<CUDTSocket*>::iterator i = read_ready.begin(); i != read_ready.end(); ++i)
+        if (socketToRead == NULL)
         {
-            // NOT using the official srt_epoll_add_usock because this will do socket dispatching,
-            // which requires lock on m_GlobControlLock, while this lock cannot be applied without
-            // first unlocking m_GroupLock.
-            CUDT::s_UDTUnited.epoll_add_usock_INTERNAL(m_RcvEID, *i, &read_modes);
+            if (m_bSynRecving)
+            {
+                HLOGC(grlog.Debug,
+                      log << "grp/recv: $" << id() << ": No links reported any fresher packet, re-polling.");
+                continue;
+            }
+            else
+            {
+                HLOGC(grlog.Debug,
+                      log << "grp/recv: $" << id() << ": No links reported any fresher packet, clearing readiness.");
+                m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+                throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
+            }
         }
-
-        HLOGC(grlog.Debug, log << "group/recv: " << ds.str() << " --> EPOLL/SWAIT");
-#undef HCLOG
-
-        if (!still_alive)
+        else
         {
-            LOGC(grlog.Error, log << "group/recv: all links broken");
-            throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
+            HLOGC(grlog.Debug,
+                  log << "grp/recv: $" << id() << ": Found first readable packet from @" << socketToRead->m_SocketID
+                      << ": seq=" << infoToRead.seqno << " gap=" << infoToRead.seq_gap
+                      << " time=" << FormatTime(infoToRead.tsbpd_time));
         }
 
-        // Here we need to make an additional check.
-        // There might be a possibility that all sockets that
-        // were added to the reader group, are ahead. At least
-        // surely we don't have a situation that any link contains
-        // an ahead-read subsequent packet, because GroupCheckPacketAhead
-        // already handled that case.
-        //
-        // What we can have is that every link has:
-        // - no known seq position yet (is not registered in the position map yet)
-        // - the position equal to the latest delivered sequence
-        // - the ahead position
-
-        // Now the situation is that we don't have any packets
-        // waiting for delivery so we need to wait for any to report one.
-
-        // XXX We support blocking mode only at the moment.
-        // The non-blocking mode would need to simply check the readiness
-        // with only immediate report, and read-readiness would have to
-        // be done in background.
-
-        // Poll on this descriptor until reading is available, indefinitely.
-        CEPoll::fmap_t sready;
-
-        // In blocking mode, use m_iRcvTimeOut, which's default value -1
-        // means to block indefinitely, also in swait().
-        // In non-blocking mode use 0, which means to always return immediately.
-        int timeout = m_bSynRecving ? m_iRcvTimeOut : 0;
-        int nready = 0;
-
-        // GlobControlLock is required for dispatching the sockets.
-        // Therefore it must be applied only when GroupLock is off.
-        {
-            // This call may wait indefinite time, so GroupLock must be unlocked.
-            InvertedLock ung (m_GroupLock);
-            THREAD_PAUSED();
-            nready  = m_pGlobal->m_EPoll.swait(*m_RcvEpolld, sready, timeout, false /*report by retval*/);
-            THREAD_RESUMED();
-
-            // HERE GlobControlLock is locked first, then GroupLock is applied back
-            enterCS(CUDT::s_UDTUnited.m_GlobControlLock);
-        }
-        // BOTH m_GlobControlLock AND m_GroupLock are locked here.
-
-        HLOGC(grlog.Debug, log << "group/recv: " << nready << " RDY: " << DisplayEpollResults(sready));
-
-        if (nready == 0)
-        {
-            // GlobControlLock is applied manually, so unlock manually.
-            // GroupLock will be unlocked as per scope.
-            leaveCS(CUDT::s_UDTUnited.m_GlobControlLock);
-            // This can only happen when 0 is passed as timeout and none is ready.
-            // And 0 is passed only in non-blocking mode. So this is none ready in
-            // non-blocking mode.
-            throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
-        }
-
-        // Handle sockets of pending connection and with errors.
-
-        // Nice to have something like:
-
-        // broken = FilterIf(sready, [] (auto s)
-        //                   { return s.second == SRT_EPOLL_ERR && (auto cs = g->locateSocket(s.first, ERH_RETURN))
-        //                          ? {cs, true}
-        //                          : {nullptr, false}
-        //                   });
-
-        FilterIf(
-            /*FROM*/ sready.begin(),
-            sready.end(),
-            /*TO*/ std::inserter(broken, broken.begin()),
-            /*VIA*/ FLookupSocketWithEvent_LOCKED(m_pGlobal, SRT_EPOLL_ERR));
-
-        // Ok, now we need to have some extra qualifications:
-        // 1. If a socket has no registry yet, we read anyway, just
-        // to notify the current position. We read ONLY ONE PACKET this time,
-        // we'll worry later about adjusting it to the current group sequence
-        // position.
-        // 2. If a socket is already position ahead, DO NOT read from it, even
-        // if it is ready.
-
-        // The state of things whether we were able to extract the very next
-        // sequence will be simply defined by the fact that `output` is nonempty.
-
-        int32_t next_seq = m_RcvBaseSeqNo;
-
-        // If this set is empty, it won't roll even once, therefore output
-        // will be surely empty. This will be checked then same way as when
-        // reading from every socket resulted in error.
-
-        vector<CUDTSocket*> ready_sockets;
-
-        for (CEPoll::fmap_t::const_iterator i = sready.begin(); i != sready.end(); ++i)
-        {
-            if (i->second & SRT_EPOLL_ERR)
-                continue; // broken already
-
-            if ((i->second & SRT_EPOLL_IN) == 0)
-                continue; // not ready for reading
-
-            // Check if this socket is in aheads
-            // If so, don't read from it, wait until the ahead is flushed.
-            SRTSOCKET   id = i->first;
-            CUDTSocket* ps = m_pGlobal->locateSocket_LOCKED(id);
-            if (ps)
-                ready_sockets.push_back(ps);
-        }
-        leaveCS(CUDT::s_UDTUnited.m_GlobControlLock);
-
-        // m_GlobControlLock lifted, m_GroupLock still locked.
-        // Now we can safely do this scoped way.
-
-        if (m_bClosing)
-        {
-            HLOGC(gslog.Debug, log << "grp/sendBroadcast: GROUP CLOSED, ABANDONING");
-            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-        }
-        //
-        // NOTE: Although m_GlobControlLock is lifted here so potentially sockets
-        // colected in ready_sockets could be closed at any time, all of them are member
-        // sockets of this group. Therefore the first socket attempted to be closed will
-        // have to remove the socket from the group, and this will require lock on GroupLock,
-        // which is still applied here. So this will have to wait for this function to finish
-        // (or block on swait, in which case the lock is lifted) anyway.
-
-        for (vector<CUDTSocket*>::iterator si = ready_sockets.begin(); si != ready_sockets.end(); ++si)
-        {
-            CUDTSocket* ps = *si;
-            SRTSOCKET id = ps->m_SocketID;
-            ReadPos*    p  = NULL;
-            pit_t       pe = m_Positions.find(id);
-            if (pe != m_Positions.end())
-            {
-                p = &pe->second;
-
-                // Possible results of comparison:
-                // x < 0: the sequence is in the past, the socket should be adjusted FIRST
-                // x = 0: the socket should be ready to get the exactly next packet
-                // x = 1: the case is already handled by GroupCheckPacketAhead.
-                // x > 1: AHEAD. DO NOT READ.
-                int seqdiff = CSeqNo::seqcmp(p->mctrl.pktseq, m_RcvBaseSeqNo);
-                if (seqdiff > 1)
-                {
-                    HLOGC(grlog.Debug,
-                          log << "group/recv: EPOLL: @" << id << " %" << p->mctrl.pktseq << " AHEAD %" << m_RcvBaseSeqNo
-                              << ", not reading.");
-                    continue;
-                }
-            }
-            else
-            {
-                // The position is not known, so get the position on which
-                // the socket is currently standing.
-                pair<pit_t, bool> ee = m_Positions.insert(make_pair(id, ReadPos(ps->core().m_iRcvLastSkipAck)));
-                p                    = &(ee.first->second);
-                HLOGC(grlog.Debug,
-                      log << "group/recv: EPOLL: @" << id << " %" << p->mctrl.pktseq << " NEW SOCKET INSERTED");
-            }
-
-            // Read from this socket stubbornly, until:
-            // - reading is no longer possible (AGAIN)
-            // - the sequence difference is >= 1
-
-            for (;;)
-            {
-                SRT_MSGCTRL mctrl = srt_msgctrl_default;
-
-                // Read the data into the user's buffer. This is an optimistic
-                // prediction that we'll read the right data. This will be overwritten
-                // by "more correct data" if found more appropriate later. But we have to
-                // copy these data anyway anywhere, even if they need to fall on the floor later.
-                int stat;
-                if (output_size)
-                {
-                    // We have already the data, so this must fall on the floor
-                    char lostbuf[SRT_LIVE_MAX_PLSIZE];
-                    stat = ps->core().receiveMessage((lostbuf), SRT_LIVE_MAX_PLSIZE, (mctrl), CUDTUnited::ERH_RETURN);
-                    HLOGC(grlog.Debug,
-                          log << "group/recv: @" << id << " IGNORED data with %" << mctrl.pktseq << " #" << mctrl.msgno
-                              << ": " << (stat <= 0 ? "(NOTHING)" : BufferStamp(lostbuf, stat)));
-                    if (stat > 0)
-                    {
-                        m_stats.recvDiscard.Update(stat);
-                    }
-                }
-                else
-                {
-                    stat = ps->core().receiveMessage((buf), len, (mctrl), CUDTUnited::ERH_RETURN);
-                    HLOGC(grlog.Debug,
-                          log << "group/recv: @" << id << " EXTRACTED data with %" << mctrl.pktseq << " #"
-                              << mctrl.msgno << ": " << (stat <= 0 ? "(NOTHING)" : BufferStamp(buf, stat)));
-                }
-                if (stat == 0)
-                {
-                    HLOGC(grlog.Debug, log << "group/recv: SPURIOUS epoll, ignoring");
-                    // This is returned in case of "again". In case of errors, we have SRT_ERROR.
-                    // Do not treat this as spurious, just stop reading.
-                    break;
-                }
-
-                if (stat == SRT_ERROR)
-                {
-                    HLOGC(grlog.Debug, log << "group/recv: @" << id << ": " << srt_getlasterror_str());
-                    broken.insert(ps);
-                    break;
-                }
-
-                // NOTE: checks against m_RcvBaseSeqNo and decisions based on it
-                // must NOT be done if m_RcvBaseSeqNo is SRT_SEQNO_NONE, which
-                // means that we are about to deliver the very first packet and we
-                // take its sequence number as a good deal.
-
-                // The order must be:
-                // - check discrepancy
-                // - record the sequence
-                // - check ordering.
-                // The second one must be done always, but failed discrepancy
-                // check should exclude the socket from any further checks.
-                // That's why the common check for m_RcvBaseSeqNo != SRT_SEQNO_NONE can't
-                // embrace everything below.
-
-                // We need to first qualify the sequence, just for a case
-                if (m_RcvBaseSeqNo != SRT_SEQNO_NONE && abs(m_RcvBaseSeqNo - mctrl.pktseq) > CSeqNo::m_iSeqNoTH)
-                {
-                    // This error should be returned if the link turns out
-                    // to be the only one, or set to the group data.
-                    // err = SRT_ESECFAIL;
-                    LOGC(grlog.Error,
-                         log << "group/recv: @" << id << ": SEQUENCE DISCREPANCY: base=%" << m_RcvBaseSeqNo
-                             << " vs pkt=%" << mctrl.pktseq << ", setting ESECFAIL");
-                    broken.insert(ps);
-                    break;
-                }
-
-                // Rewrite it to the state for a case when next reading
-                // would not succeed. Do not insert the buffer here because
-                // this is only required when the sequence is ahead; for that
-                // it will be fixed later.
-                p->mctrl.pktseq = mctrl.pktseq;
-
-                if (m_RcvBaseSeqNo != SRT_SEQNO_NONE)
-                {
-                    // Now we can safely check it.
-                    int seqdiff = CSeqNo::seqcmp(mctrl.pktseq, m_RcvBaseSeqNo);
-
-                    if (seqdiff <= 0)
-                    {
-                        HLOGC(grlog.Debug,
-                              log << "group/recv: @" << id << " %" << mctrl.pktseq << " #" << mctrl.msgno
-                                  << " BEHIND base=%" << m_RcvBaseSeqNo << " - discarding");
-                        // The sequence is recorded, the packet has to be discarded.
-                        // That's all.
-                        continue;
-                    }
-
-                    // Now we have only two possibilities:
-                    // seqdiff == 1: The very next sequence, we want to read and return the packet.
-                    // seqdiff > 1: The packet is ahead - record the ahead packet, but continue with the others.
-
-                    if (seqdiff > 1)
-                    {
-                        HLOGC(grlog.Debug,
-                              log << "@" << id << " %" << mctrl.pktseq << " #" << mctrl.msgno << " AHEAD base=%"
-                                  << m_RcvBaseSeqNo);
-                        p->packet.assign(buf, buf + stat);
-                        p->mctrl = mctrl;
-                        break; // Don't read from that socket anymore.
-                    }
-                }
-
-                // We have seqdiff = 1, or we simply have the very first packet
-                // which's sequence is taken as a good deal. Update the sequence
-                // and record output.
-
-                if (output_size)
-                {
-                    HLOGC(grlog.Debug,
-                          log << "group/recv: @" << id << " %" << mctrl.pktseq << " #" << mctrl.msgno << " REDUNDANT");
-                    break;
-                }
-
-                HLOGC(grlog.Debug,
-                      log << "group/recv: @" << id << " %" << mctrl.pktseq << " #" << mctrl.msgno << " DELIVERING");
-                output_size = stat;
-                fillGroupData((w_mc), mctrl);
-
-                // Update stats as per delivery
-                m_stats.recv.Update(output_size);
-                updateAvgPayloadSize(output_size);
-
-                // Record, but do not update yet, until all sockets are handled.
-                next_seq = mctrl.pktseq;
-                break;
-            }
-        }
-
-#if ENABLE_HEAVY_LOGGING
-        if (!broken.empty())
-        {
-            std::ostringstream brks;
-            for (set<CUDTSocket*>::iterator b = broken.begin(); b != broken.end(); ++b)
-                brks << "@" << (*b)->m_SocketID << " ";
-            LOGC(grlog.Debug, log << "group/recv: REMOVING BROKEN: " << brks.str());
-        }
-#endif
-
-        vector<SRTSOCKET> brokenid;
-        // Now remove all broken sockets from aheads, if any.
-        // Even if they have already delivered a packet.
-        for (set<CUDTSocket*>::iterator di = broken.begin(); di != broken.end(); ++di)
-        {
-            CUDTSocket* ps = *di;
-            m_Positions.erase(ps->m_SocketID);
-            //ps->setBrokenClosed();
-        }
-
-        // Force closing
+        const int res = socketToRead->core().receiveMessage((buf), len, (w_mc), CUDTUnited::ERH_RETURN);
+        HLOGC(grlog.Debug,
+              log << "grp/recv: $" << id() << ": @" << socketToRead->m_SocketID << ": Extracted data with %"
+                  << w_mc.pktseq << " #" << w_mc.msgno << ": " << (res <= 0 ? "(NOTHING)" : BufferStamp(buf, res)));
+        if (res == 0)
         {
-            InvertedLock ung (m_GroupLock);
-            for (set<CUDTSocket*>::iterator b = broken.begin(); b != broken.end(); ++b)
-            {
-                CUDT::s_UDTUnited.close(*b);
-            }
+            LOGC(grlog.Warn,
+                 log << "grp/recv: $" << id() << ": @" << socketToRead->m_SocketID << ": Retrying next socket...");
+            // This socket will not be socketToRead in the next turn because receiveMessage() return 0 here.
+            continue;
         }
-
-        if (broken.size() >= size) // This > is for sanity check
+        if (res == SRT_ERROR)
         {
-            // All broken
-            HLOGC(grlog.Debug, log << "group/recv: All sockets broken");
-            m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
-
-            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
+            LOGC(grlog.Warn,
+                 log << "grp/recv: $" << id() << ": @" << socketToRead->m_SocketID << ": " << srt_getlasterror_str()
+                     << ". Retrying next socket...");
+            broken.insert(socketToRead);
+            continue;
         }
+        fillGroupData((w_mc), w_mc);
 
-        // May be required to be re-read.
-        broken.clear();
-
-        if (output_size)
+        // m_RcvBaseSeqNo is expected to be set to the PeerISN with the first connected member,
+        // so a packet drop at the start should also be detected by this condition.
+        if (m_RcvBaseSeqNo != SRT_SEQNO_NONE)
         {
-            // We have extracted something, meaning that we have the sequence shift.
-            // Update it now and don't do anything else with the sockets.
-
-            // Sanity check
-            if (next_seq == SRT_SEQNO_NONE)
-            {
-                LOGP(grlog.Error, "IPE: next_seq not set after output extracted!");
-
-                // This should never happen, but the only way to keep the code
-                // safe an recoverable is to use the incremented sequence. By
-                // leaving the sequence as is there's a risk of hangup.
-                // Not doing it in case of SRT_SEQNO_NONE as it would make a valid %0.
-                if (m_RcvBaseSeqNo != SRT_SEQNO_NONE)
-                    m_RcvBaseSeqNo = CSeqNo::incseq(m_RcvBaseSeqNo);
-            }
-            else
-            {
-                m_RcvBaseSeqNo = next_seq;
-            }
-
-            ReadPos* pos = checkPacketAhead();
-            if (!pos)
+            const int32_t iNumDropped = (CSeqNo(w_mc.pktseq) - CSeqNo(m_RcvBaseSeqNo)) - 1;
+            if (iNumDropped > 0)
             {
-                // Don't clear the read-readinsess state if you have a packet ahead because
-                // if you have, the next read call will return it.
-                m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+                m_stats.recvDrop.count(stats::BytesPackets(iNumDropped * static_cast<uint64_t>(avgRcvPacketSize()), iNumDropped));
+                LOGC(grlog.Warn,
+                    log << "@" << m_GroupID << " GROUP RCV-DROPPED " << iNumDropped << " packet(s): seqno %"
+                        << CSeqNo::incseq(m_RcvBaseSeqNo) << " to %" << CSeqNo::decseq(w_mc.pktseq));
             }
-
-            HLOGC(grlog.Debug,
-                  log << "group/recv: successfully extracted packet size=" << output_size << " - returning");
-            return output_size;
         }
 
-        HLOGC(grlog.Debug, log << "group/recv: NOT extracted anything - checking for a need to kick kangaroos");
-
-        // Check if we have any sockets left :D
+        HLOGC(grlog.Debug,
+              log << "grp/recv: $" << id() << ": Update m_RcvBaseSeqNo: %" << m_RcvBaseSeqNo << " -> %" << w_mc.pktseq);
+        m_RcvBaseSeqNo = w_mc.pktseq;
 
-        // Here we surely don't have any more HORSES,
-        // only ELEPHANTS and KANGAROOS. Qualify them and
-        // attempt to at least take advantage of KANGAROOS.
+        // Update stats as per delivery
+        m_stats.recv.count(res);
+        updateAvgPayloadSize(res);
 
-        // In this position all links are either:
-        // - updated to the current position
-        // - updated to the newest possible possition available
-        // - not yet ready for extraction (not present in the group)
-
-        // If we haven't extracted the very next sequence position,
-        // it means that we might only have the ahead packets read,
-        // that is, the next sequence has been dropped by all links.
-
-        if (!m_Positions.empty())
+        bool canReadFurther = false;
+        for (vector<CUDTSocket*>::const_iterator si = aliveMembers.begin(); si != aliveMembers.end(); ++si)
         {
-            // This might notify both lingering links, which didn't
-            // deliver the required sequence yet, and links that have
-            // the sequence ahead. Review them, and if you find at
-            // least one packet behind, just wait for it to be ready.
-            // Use again the waiting function because we don't want
-            // the general waiting procedure to skip others.
-            set<SRTSOCKET> elephants;
-
-            // const because it's `typename decltype(m_Positions)::value_type`
-            pair<const SRTSOCKET, ReadPos>* slowest_kangaroo = 0;
-
-            for (pit_t rp = m_Positions.begin(); rp != m_Positions.end(); ++rp)
-            {
-                // NOTE that m_RcvBaseSeqNo in this place wasn't updated
-                // because we haven't successfully extracted anything.
-                int seqdiff = CSeqNo::seqcmp(rp->second.mctrl.pktseq, m_RcvBaseSeqNo);
-                if (seqdiff < 0)
-                {
-                    elephants.insert(rp->first);
-                }
-                // If seqdiff == 0, we have a socket ON TRACK.
-                else if (seqdiff > 0)
-                {
-                    // If there's already a slowest_kangaroo, seqdiff decides if this one is slower.
-                    // Otherwise it is always slower by having no competition.
-                    seqdiff = slowest_kangaroo
-                                  ? CSeqNo::seqcmp(slowest_kangaroo->second.mctrl.pktseq, rp->second.mctrl.pktseq)
-                                  : 1;
-                    if (seqdiff > 0)
-                    {
-                        slowest_kangaroo = &*rp;
-                    }
-                }
-            }
-
-            // Note that if no "slowest_kangaroo" was found, it means
-            // that we don't have kangaroos.
-            if (slowest_kangaroo)
+            CUDTSocket* ps = *si;
+            ScopedLock  lg(ps->core().m_RcvBufferLock);
+            if (m_RcvBaseSeqNo != SRT_SEQNO_NONE)
             {
-                // We have a slowest kangaroo. Elephants must be ignored.
-                // Best case, they will get revived, worst case they will be
-                // soon broken.
-                //
-                // As we already have the packet delivered by the slowest
-                // kangaroo, we can simply return it.
-
-                // Check how many were skipped and add them to the stats
-                const int32_t jump = (CSeqNo(slowest_kangaroo->second.mctrl.pktseq) - CSeqNo(m_RcvBaseSeqNo)) - 1;
-                if (jump > 0)
-                {
-                    m_stats.recvDrop.UpdateTimes(jump, avgRcvPacketSize());
-                }
-
-                m_RcvBaseSeqNo    = slowest_kangaroo->second.mctrl.pktseq;
-                vector<char>& pkt = slowest_kangaroo->second.packet;
-                if (size_t(len) < pkt.size())
-                    throw CUDTException(MJ_NOTSUP, MN_XSIZE, 0);
-
-                HLOGC(grlog.Debug,
-                      log << "@" << slowest_kangaroo->first << " KANGAROO->HORSE %"
-                          << slowest_kangaroo->second.mctrl.pktseq << " #" << slowest_kangaroo->second.mctrl.msgno
-                          << ": " << BufferStamp(&pkt[0], pkt.size()));
-
-                memcpy(buf, &pkt[0], pkt.size());
-                fillGroupData((w_mc), slowest_kangaroo->second.mctrl);
-                len = pkt.size();
-                pkt.clear();
-
-                // Update stats as per delivery
-                m_stats.recv.Update(len);
-                updateAvgPayloadSize(len);
-
-                // It is unlikely to have a packet ahead because usually having one packet jumped-ahead
-                // clears the possibility of having aheads at all.
-                // XXX Research if this is possible at all; if it isn't, then don't waste time on
-                // looking for it.
-                ReadPos* pos = checkPacketAhead();
-                if (!pos)
+                const int cnt = ps->core().rcvDropTooLateUpTo(CSeqNo::incseq(m_RcvBaseSeqNo), CUDT::DROP_DISCARD);
+                if (cnt > 0)
                 {
-                    // Don't clear the read-readinsess state if you have a packet ahead because
-                    // if you have, the next read call will return it.
-                    m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+                    HLOGC(grlog.Debug,
+                          log << "grp/recv: $" << id() << ": @" << ps->m_SocketID << ": dropped " << cnt
+                              << " packets after reading: m_RcvBaseSeqNo=" << m_RcvBaseSeqNo);
                 }
-                return len;
             }
 
-            HLOGC(grlog.Debug,
-                  log << "group/recv: "
-                      << (elephants.empty() ? "NO LINKS REPORTED ANY FRESHER PACKET." : "ALL LINKS ELEPHANTS.")
-                      << " Re-polling.");
-        }
-        else
-        {
-            HLOGC(grlog.Debug, log << "group/recv: POSITIONS EMPTY - Re-polling.");
+            if (!ps->core().isRcvBufferReadyNoLock())
+                m_Global.m_EPoll.update_events(ps->m_SocketID, ps->core().m_sPollID, SRT_EPOLL_IN, false);
+            else
+                canReadFurther = true;
         }
-    }
-}
-
-// [[using locked(m_GroupLock)]]
-CUDTGroup::ReadPos* CUDTGroup::checkPacketAhead()
-{
-    typedef map<SRTSOCKET, ReadPos>::iterator pit_t;
-    ReadPos*                                  out = 0;
 
-    // This map no longer maps only ahead links.
-    // Here are all links, and whether ahead, it's defined by the sequence.
-    for (pit_t i = m_Positions.begin(); i != m_Positions.end(); ++i)
-    {
-        // i->first: socket ID
-        // i->second: ReadPos { sequence, packet }
-        // We are not interested with the socket ID because we
-        // aren't going to read from it - we have the packet already.
-        ReadPos& a = i->second;
+        if (!canReadFurther)
+            m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
 
-        const int seqdiff = CSeqNo::seqcmp(a.mctrl.pktseq, m_RcvBaseSeqNo);
-        if (seqdiff == 1)
-        {
-            // The very next packet. Return it.
-            // XXX SETTING THIS ONE IS PROBABLY A BUG.
-            m_RcvBaseSeqNo = a.mctrl.pktseq;
-            HLOGC(grlog.Debug,
-                  log << "group/recv: Base %" << m_RcvBaseSeqNo << " ahead delivery POSSIBLE %" << a.mctrl.pktseq << "#"
-                      << a.mctrl.msgno << " from @" << i->first << ")");
-            out = &a;
-        }
-        else if (seqdiff < 1 && !a.packet.empty())
-        {
-            HLOGC(grlog.Debug,
-                  log << "group/recv: @" << i->first << " dropping collected ahead %" << a.mctrl.pktseq << "#"
-                      << a.mctrl.msgno << " with base %" << m_RcvBaseSeqNo);
-            a.packet.clear();
-        }
-        // In case when it's >1, keep it in ahead
+        return res;
     }
-
-    return out;
+    LOGC(grlog.Error, log << "grp/recv: UNEXPECTED RUN PATH, ABANDONING.");
+    m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, false);
+    throw CUDTException(MJ_AGAIN, MN_RDAVAIL, 0);
 }
 
 const char* CUDTGroup::StateStr(CUDTGroup::GroupState st)
@@ -2754,47 +2465,24 @@ const char* CUDTGroup::StateStr(CUDTGroup::GroupState st)
     return unknown;
 }
 
-void CUDTGroup::synchronizeDrift(CUDT* cu, steady_clock::duration udrift, steady_clock::time_point newtimebase)
+void CUDTGroup::synchronizeDrift(const srt::CUDT* srcMember)
 {
+    SRT_ASSERT(srcMember != NULL);
     ScopedLock glock(m_GroupLock);
-
-    bool wrap_period = false;
-
-    bool anycheck = false;
-
-    for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
-    {
-        // Skip non-connected; these will be synchronized when ready
-        if (gi->laststatus != SRTS_CONNECTED)
-            continue;
-
-        // Skip the entity that has reported this
-        if (cu == gi->ps->m_pUDT)
-            continue;
-
-        steady_clock::time_point this_timebase;
-        steady_clock::duration   this_udrift(0);
-        bool wrp = gi->ps->m_pUDT->m_pRcvBuffer->getInternalTimeBase((this_timebase), (this_udrift));
-
-        udrift                                   = std::min(udrift, this_udrift);
-        steady_clock::time_point new_newtimebase = std::min(newtimebase, this_timebase);
-        if (new_newtimebase != newtimebase)
-        {
-            wrap_period = wrp;
-        }
-        newtimebase = new_newtimebase;
-        anycheck    = true;
-    }
-
-    if (!anycheck)
+    if (m_Group.size() <= 1)
     {
         HLOGC(grlog.Debug, log << "GROUP: synch uDRIFT NOT DONE, no other links");
         return;
     }
 
+    steady_clock::time_point timebase;
+    steady_clock::duration   udrift(0);
+    bool wrap_period = false;
+    srcMember->m_pRcvBuffer->getInternalTimeBase((timebase), (wrap_period), (udrift));
+
     HLOGC(grlog.Debug,
-          log << "GROUP: synch uDRIFT=" << FormatDuration(udrift) << " TB=" << FormatTime(newtimebase) << "("
-              << (wrap_period ? "" : "NO ") << "wrap period)");
+        log << "GROUP: synch uDRIFT=" << FormatDuration(udrift) << " TB=" << FormatTime(timebase) << "("
+        << (wrap_period ? "" : "NO ") << "wrap period)");
 
     // Now that we have the minimum timebase and drift calculated, apply this to every link,
     // INCLUDING THE REPORTER.
@@ -2804,8 +2492,11 @@ void CUDTGroup::synchronizeDrift(CUDT* cu, steady_clock::duration udrift, steady
         // Skip non-connected; these will be synchronized when ready
         if (gi->laststatus != SRTS_CONNECTED)
             continue;
+        CUDT& member = gi->ps->core();
+        if (srcMember == &member)
+            continue;
 
-        gi->ps->m_pUDT->m_pRcvBuffer->applyGroupDrift(newtimebase, wrap_period, udrift);
+        member.m_pRcvBuffer->applyGroupDrift(timebase, wrap_period, udrift);
     }
 }
 
@@ -2818,27 +2509,33 @@ void CUDTGroup::bstatsSocket(CBytePerfMon* perf, bool clear)
 
     const steady_clock::time_point currtime = steady_clock::now();
 
+    // NOTE: Potentially in the group we might be using both IPv4 and IPv6
+    // links and sending a single packet over these two links could be different.
+    // These stats then don't make much sense in this form, this has to be
+    // redesigned. We use the header size as per IPv4, as it was everywhere.
+    const int pktHdrSize = CPacket::HDR_SIZE + CPacket::UDP_HDR_SIZE;
+
     memset(perf, 0, sizeof *perf);
 
     ScopedLock gg(m_GroupLock);
 
     perf->msTimeStamp = count_milliseconds(currtime - m_tsStartTime);
 
-    perf->pktSentUnique = m_stats.sent.local.pkts;
-    perf->pktRecvUnique = m_stats.recv.local.pkts;
-    perf->pktRcvDrop    = m_stats.recvDrop.local.pkts;
+    perf->pktSentUnique = m_stats.sent.trace.count();
+    perf->pktRecvUnique = m_stats.recv.trace.count();
+    perf->pktRcvDrop    = m_stats.recvDrop.trace.count();
 
-    perf->byteSentUnique = m_stats.sent.local.fullBytes();
-    perf->byteRecvUnique = m_stats.recv.local.fullBytes();
-    perf->byteRcvDrop    = m_stats.recvDrop.local.fullBytes();
+    perf->byteSentUnique = m_stats.sent.trace.bytesWithHdr(pktHdrSize);
+    perf->byteRecvUnique = m_stats.recv.trace.bytesWithHdr(pktHdrSize);
+    perf->byteRcvDrop    = m_stats.recvDrop.trace.bytesWithHdr(pktHdrSize);
 
-    perf->pktSentUniqueTotal = m_stats.sent.total.pkts;
-    perf->pktRecvUniqueTotal = m_stats.recv.total.pkts;
-    perf->pktRcvDropTotal    = m_stats.recvDrop.total.pkts;
+    perf->pktSentUniqueTotal = m_stats.sent.total.count();
+    perf->pktRecvUniqueTotal = m_stats.recv.total.count();
+    perf->pktRcvDropTotal    = m_stats.recvDrop.total.count();
 
-    perf->byteSentUniqueTotal = m_stats.sent.total.fullBytes();
-    perf->byteRecvUniqueTotal = m_stats.recv.total.fullBytes();
-    perf->byteRcvDropTotal    = m_stats.recvDrop.total.fullBytes();
+    perf->byteSentUniqueTotal = m_stats.sent.total.bytesWithHdr(pktHdrSize);
+    perf->byteRecvUniqueTotal = m_stats.recv.total.bytesWithHdr(pktHdrSize);
+    perf->byteRcvDropTotal    = m_stats.recvDrop.total.bytesWithHdr(pktHdrSize);
 
     const double interval = static_cast<double>(count_microseconds(currtime - m_stats.tsLastSampleTime));
     perf->mbpsSendRate    = double(perf->byteSent) * 8.0 / interval;
@@ -2850,26 +2547,45 @@ void CUDTGroup::bstatsSocket(CBytePerfMon* perf, bool clear)
     }
 }
 
-// For sorting group members by priority
-
-struct FPriorityOrder
+/// @brief Compares group members by their weight (higher weight comes first).
+struct FCompareByWeight
 {
-    // returned true = "elements are in the right order"
-    static bool check(uint16_t preceding, uint16_t succeeding)
+    typedef CUDTGroup::gli_t gli_t;
+
+    /// @returns true if the first argument is less than (i.e. is ordered before) the second.
+    bool operator()(const gli_t preceding, const gli_t succeeding)
     {
-        return preceding > succeeding;
+        return preceding->weight > succeeding->weight;
     }
+};
 
-    typedef CUDTGroup::gli_t gli_t;
+// [[using maybe_locked(this->m_GroupLock)]]
+BackupMemberState CUDTGroup::sendBackup_QualifyIfStandBy(const gli_t d)
+{
+    if (!d->ps)
+        return BKUPST_BROKEN;
+
+    const SRT_SOCKSTATUS st = d->ps->getStatus();
+    // If the socket is already broken, move it to broken.
+    if (int(st) >= int(SRTS_BROKEN))
+    {
+        HLOGC(gslog.Debug,
+            log << "CUDTGroup::send.$" << id() << ": @" << d->id << " became " << SockStatusStr(st)
+            << ", WILL BE CLOSED.");
+        return BKUPST_BROKEN;
+    }
 
-    bool operator()(gli_t preceding, gli_t succeeding)
+    if (st != SRTS_CONNECTED)
     {
-        return check(preceding->weight, succeeding->weight);
+        HLOGC(gslog.Debug, log << "CUDTGroup::send. @" << d->id << " is still " << SockStatusStr(st) << ", skipping.");
+        return BKUPST_PENDING;
     }
-};
+
+    return BKUPST_STANDBY;
+}
 
 // [[using maybe_locked(this->m_GroupLock)]]
-bool CUDTGroup::send_CheckIdle(const gli_t d, vector<SRTSOCKET>& w_wipeme, vector<SRTSOCKET>& w_pending)
+bool CUDTGroup::send_CheckIdle(const gli_t d, vector<SRTSOCKET>& w_wipeme, vector<SRTSOCKET>& w_pendingSockets)
 {
     SRT_SOCKSTATUS st = SRTS_NONEXIST;
     if (d->ps)
@@ -2887,252 +2603,356 @@ bool CUDTGroup::send_CheckIdle(const gli_t d, vector<SRTSOCKET>& w_wipeme, vecto
     if (st != SRTS_CONNECTED)
     {
         HLOGC(gslog.Debug, log << "CUDTGroup::send. @" << d->id << " is still " << SockStatusStr(st) << ", skipping.");
-        w_pending.push_back(d->id);
+        w_pendingSockets.push_back(d->id);
         return false;
     }
 
     return true;
 }
 
-// [[using locked(this->m_GroupLock)]]
-void CUDTGroup::sendBackup_CheckIdleTime(gli_t w_d)
+
+#if SRT_DEBUG_BONDING_STATES
+class StabilityTracer
 {
-    // Check if it was fresh set as idle, we had to wait until its sender
-    // buffer gets empty so that we can make sure that KEEPALIVE will be the
-    // really last sent for longer time.
-    CUDT& u = w_d->ps->core();
-    if (!is_zero(u.m_tsTmpActiveTime))
+public:
+    StabilityTracer()
     {
-        CSndBuffer* b = u.m_pSndBuffer;
-        if (b && b->getCurrBufSize() == 0)
-        {
-            HLOGC(gslog.Debug,
-                  log << "grp/sendBackup: FRESH IDLE LINK reached empty buffer - setting permanent and KEEPALIVE");
-            u.m_tsTmpActiveTime = steady_clock::time_point();
-
-            // Send first immediate keepalive. The link is to be turn to IDLE
-            // now so nothing will be sent to it over time and it will start
-            // getting KEEPALIVES since now. Send the first one now to increase
-            // probability that the link will be recognized as IDLE on the
-            // reception side ASAP.
-            int32_t arg = 1;
-            w_d->ps->m_pUDT->sendCtrl(UMSG_KEEPALIVE, &arg);
-        }
     }
-}
 
-// [[using locked(this->m_GroupLock)]]
-bool CUDTGroup::sendBackup_CheckRunningStability(const gli_t d, const time_point currtime)
-{
-    CUDT& u = d->ps->core();
-    // This link might be unstable, check its responsiveness status
-    // NOTE: currtime - last_rsp_time: we believe this value will be always positive as
-    // the Tk clock is believed to be monotonic. The resulting value
-
-    // IMPORTANT: the socket could be potentially updated IN THE MEANTIME in another
-    // thread AFTER (!!!) currtime has been read, but BEFORE (!!!) this value us used
-    // for calculation - which could make the difference negative.
-    // There's no way to avoid it because it would require making a mutex-locking for
-    // updating the m_tsLastRspTime field. This is useless because avoiding the
-    // negative value is relatively easy, while introducing a mutex would only add a
-    // deadlock risk and performance degradation.
+    ~StabilityTracer()
+    {
+        srt::sync::ScopedLock lck(m_mtx);
+        m_fout.close();
+    }
 
-    bool is_unstable = false;
+    void trace(const CUDT& u, const srt::sync::steady_clock::time_point& currtime, uint32_t activation_period_us,
+        int64_t stability_tmo_us, const std::string& state, uint16_t weight)
+    {
+        srt::sync::ScopedLock lck(m_mtx);
+        create_file();
+
+        m_fout << srt::sync::FormatTime(currtime) << ",";
+        m_fout << u.id() << ",";
+        m_fout << weight << ",";
+        m_fout << u.peerLatency_us() << ",";
+        m_fout << u.SRTT() << ",";
+        m_fout << u.RTTVar() << ",";
+        m_fout << stability_tmo_us << ",";
+        m_fout << count_microseconds(currtime - u.lastRspTime()) << ",";
+        m_fout << state << ",";
+        m_fout << (srt::sync::is_zero(u.freshActivationStart()) ? -1 : (count_microseconds(currtime - u.freshActivationStart()))) << ",";
+        m_fout << activation_period_us << "\n";
+        m_fout.flush();
+    }
 
-    HLOGC(gslog.Debug,
-          log << "grp/sendBackup: CHECK STABLE: @" << d->id
-              << ": TIMEDIFF {response= " << FormatDuration<DUNIT_MS>(currtime - u.m_tsLastRspTime)
-              << " ACK=" << FormatDuration<DUNIT_MS>(currtime - u.m_tsLastRspAckTime) << " activation="
-              << (!is_zero(u.m_tsTmpActiveTime) ? FormatDuration<DUNIT_MS>(currtime - u.m_tsTmpActiveTime) : "PAST")
-              << " unstable="
-              << (!is_zero(u.m_tsUnstableSince) ? FormatDuration<DUNIT_MS>(currtime - u.m_tsUnstableSince) : "NEVER")
-              << "}");
+private:
+    void print_header()
+    {
+        //srt::sync::ScopedLock lck(m_mtx);
+        m_fout << "Timepoint,SocketID,weight,usLatency,usRTT,usRTTVar,usStabilityTimeout,usSinceLastResp,State,usSinceActivation,usActivationPeriod\n";
+    }
 
-    if (currtime > u.m_tsLastRspTime)
+    void create_file()
     {
-        // The last response predates the start of this function, look at the difference
-        steady_clock::duration td_responsive = currtime - u.m_tsLastRspTime;
+        if (m_fout.is_open())
+            return;
+
+        std::string str_tnow = srt::sync::FormatTimeSys(srt::sync::steady_clock::now());
+        str_tnow.resize(str_tnow.size() - 7); // remove trailing ' [SYST]' part
+        while (str_tnow.find(':') != std::string::npos) {
+            str_tnow.replace(str_tnow.find(':'), 1, 1, '_');
+        }
+        const std::string fname = "stability_trace_" + str_tnow + ".csv";
+        m_fout.open(fname.c_str(), std::ofstream::out);
+        if (!m_fout)
+            std::cerr << "IPE: Failed to open " << fname << "!!!\n";
+
+        print_header();
+    }
 
-        IF_HEAVY_LOGGING(string source = "heard");
+private:
+    srt::sync::Mutex m_mtx;
+    std::ofstream m_fout;
+};
 
-        bool check_stability = true;
+StabilityTracer s_stab_trace;
+#endif
 
-        if (!is_zero(u.m_tsTmpActiveTime) && u.m_tsTmpActiveTime < currtime)
+void CUDTGroup::sendBackup_QualifyMemberStates(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime)
+{
+    // First, check status of every link - no matter if idle or active.
+    for (gli_t d = m_Group.begin(); d != m_Group.end(); ++d)
+    {
+        if (d->sndstate != SRT_GST_BROKEN)
         {
-            // The link is temporary-activated. Calculate then since the activation time.
-
-            // Check the last received ACK time first. This time is initialized with 'now'
-            // at the CUDT::open call, so you can't count on the trap zero time here, but
-            // it's still possible to check if activation time predates the ACK time. Things
-            // are here in the following possible order:
-            //
-            // - ACK time (old because defined at open)
-            // - Response time (old because the time of received handshake or keepalive counts)
-            // ... long time nothing ...
-            // - Activation time.
-            //
-            // If we have this situation, we have to wait for at least one ACK that is
-            // newer than activation time. However, if in this situation we have a fresh
-            // response, that is:
-            //
-            // - ACK time
-            // ...
-            // - Activation time
-            // - Response time (because a Keepalive had a caprice to come accidentally after sending)
-            //
-            // We still wait for a situation that there's at least one ACK that is newer than activation.
-
-            // As we DO have activation time, we need to check if there's at least
-            // one ACK newer than activation, that is, td_acked < td_active
-            if (u.m_tsLastRspAckTime < u.m_tsTmpActiveTime)
-            {
-                check_stability = false;
-                HLOGC(gslog.Debug,
-                      log << "grp/sendBackup: link @" << d->id
-                          << " activated after ACK, "
-                             "not checking for stability");
-            }
-            else
+            // Check the socket state prematurely in order not to uselessly
+            // send over a socket that is broken.
+            CUDT* const pu = (d->ps)
+                ?  &d->ps->core()
+                :  NULL;
+
+            if (!pu || pu->m_bBroken)
             {
-                u.m_tsTmpActiveTime = steady_clock::time_point();
+                HLOGC(gslog.Debug, log << "grp/sendBackup: socket @" << d->id << " detected +Broken - transit to BROKEN");
+                d->sndstate = SRT_GST_BROKEN;
+                d->rcvstate = SRT_GST_BROKEN;
             }
         }
 
-        if (check_stability && count_microseconds(td_responsive) > m_uOPT_StabilityTimeout)
+        // Check socket sndstate before sending
+        if (d->sndstate == SRT_GST_BROKEN)
         {
-            if (is_zero(u.m_tsUnstableSince))
-            {
-                HLOGC(gslog.Debug,
-                      log << "grp/sendBackup: socket NEW UNSTABLE: @" << d->id << " last " << source << " "
-                          << FormatDuration(td_responsive) << " > " << m_uOPT_StabilityTimeout
-                          << " (stability timeout)");
-                // The link seems to have missed two ACKs already.
-                // Qualify this link as unstable
-                // Notify that it has been seen so since now
-                u.m_tsUnstableSince = currtime;
-            }
-
-            is_unstable = true;
+            HLOGC(gslog.Debug,
+                  log << "grp/sendBackup: socket in BROKEN state: @" << d->id
+                      << ", sockstatus=" << SockStatusStr(d->ps ? d->ps->getStatus() : SRTS_NONEXIST));
+            sendBackup_AssignBackupState(d->ps->core(), BKUPST_BROKEN, currtime);
+            w_sendBackupCtx.recordMemberState(&(*d), BKUPST_BROKEN);
+#if SRT_DEBUG_BONDING_STATES
+            s_stab_trace.trace(d->ps->core(), currtime, 0, 0, stateToStr(BKUPST_BROKEN), d->weight);
+#endif
+            continue;
         }
-    }
 
-    if (!is_unstable)
-    {
-        // If stability is ok, but unstable-since was set before, reset it.
-        HLOGC(gslog.Debug,
-              log << "grp/sendBackup: link STABLE: @" << d->id
-                  << (!is_zero(u.m_tsUnstableSince) ? " - RESTORED" : " - CONTINUED"));
+        if (d->sndstate == SRT_GST_IDLE)
+        {
+            const BackupMemberState idle_state = sendBackup_QualifyIfStandBy(d);
+            sendBackup_AssignBackupState(d->ps->core(), idle_state, currtime);
+            w_sendBackupCtx.recordMemberState(&(*d), idle_state);
 
-        u.m_tsUnstableSince = steady_clock::time_point();
-        is_unstable         = false;
-    }
+            if (idle_state == BKUPST_STANDBY)
+            {
+                // TODO: Check if this is some abandoned logic.
+                sendBackup_CheckIdleTime(d);
+            }
+#if SRT_DEBUG_BONDING_STATES
+            s_stab_trace.trace(d->ps->core(), currtime, 0, 0, stateToStr(idle_state), d->weight);
+#endif
+            continue;
+        }
+
+        if (d->sndstate == SRT_GST_RUNNING)
+        {
+            const BackupMemberState active_state = sendBackup_QualifyActiveState(d, currtime);
+            sendBackup_AssignBackupState(d->ps->core(), active_state, currtime);
+            w_sendBackupCtx.recordMemberState(&(*d), active_state);
+#if SRT_DEBUG_BONDING_STATES
+            s_stab_trace.trace(d->ps->core(), currtime, 0, 0, stateToStr(active_state), d->weight);
+#endif
+            continue;
+        }
 
-#if ENABLE_HEAVY_LOGGING
-    // Could be set above
-    if (is_unstable)
-    {
         HLOGC(gslog.Debug,
-              log << "grp/sendBackup: link UNSTABLE for " << FormatDuration(currtime - u.m_tsUnstableSince) << " : @"
-                  << d->id << " - will send a payload");
+              log << "grp/sendBackup: socket @" << d->id << " not ready, state: " << StateStr(d->sndstate) << "("
+                  << int(d->sndstate) << ") - NOT sending, SET AS PENDING");
+
+        // Otherwise connection pending
+        sendBackup_AssignBackupState(d->ps->core(), BKUPST_PENDING, currtime);
+        w_sendBackupCtx.recordMemberState(&(*d), BKUPST_PENDING);
+#if SRT_DEBUG_BONDING_STATES
+        s_stab_trace.trace(d->ps->core(), currtime, 0, 0, stateToStr(BKUPST_PENDING), d->weight);
+#endif
     }
-    else
+}
+
+
+void CUDTGroup::sendBackup_AssignBackupState(CUDT& sock, BackupMemberState state, const steady_clock::time_point& currtime)
+{
+    switch (state)
     {
-        HLOGC(gslog.Debug, log << "grp/sendBackup: socket in RUNNING state: @" << d->id << " - will send a payload");
+    case BKUPST_PENDING:
+    case BKUPST_STANDBY:
+    case BKUPST_BROKEN:
+        sock.m_tsFreshActivation = steady_clock::time_point();
+        sock.m_tsUnstableSince = steady_clock::time_point();
+        sock.m_tsWarySince = steady_clock::time_point();
+        break;
+    case BKUPST_ACTIVE_FRESH:
+        if (is_zero(sock.freshActivationStart()))
+        {
+            sock.m_tsFreshActivation = currtime;
+        }
+        sock.m_tsUnstableSince = steady_clock::time_point();
+        sock.m_tsWarySince     = steady_clock::time_point();;
+        break;
+    case BKUPST_ACTIVE_STABLE:
+        sock.m_tsFreshActivation = steady_clock::time_point();
+        sock.m_tsUnstableSince = steady_clock::time_point();
+        sock.m_tsWarySince = steady_clock::time_point();
+        break;
+    case BKUPST_ACTIVE_UNSTABLE:
+        if (is_zero(sock.m_tsUnstableSince))
+        {
+            sock.m_tsUnstableSince = currtime;
+        }
+        sock.m_tsFreshActivation = steady_clock::time_point();
+        sock.m_tsWarySince = steady_clock::time_point();
+        break;
+    case BKUPST_ACTIVE_UNSTABLE_WARY:
+        if (is_zero(sock.m_tsWarySince))
+        {
+            sock.m_tsWarySince = currtime;
+        }
+        break;
+    default:
+        break;
     }
-#endif
+}
 
-    return !is_unstable;
+// [[using locked(this->m_GroupLock)]]
+void CUDTGroup::sendBackup_CheckIdleTime(gli_t w_d)
+{
+    // Check if it was fresh set as idle, we had to wait until its sender
+    // buffer gets empty so that we can make sure that KEEPALIVE will be the
+    // really last sent for longer time.
+    CUDT& u = w_d->ps->core();
+    if (is_zero(u.m_tsFreshActivation)) // TODO: Check if this condition is ever false
+        return;
+
+    CSndBuffer* b = u.m_pSndBuffer;
+    if (b && b->getCurrBufSize() == 0)
+    {
+        HLOGC(gslog.Debug,
+                log << "grp/sendBackup: FRESH IDLE LINK reached empty buffer - setting permanent and KEEPALIVE");
+        u.m_tsFreshActivation = steady_clock::time_point();
+
+        // Send first immediate keepalive. The link is to be turn to IDLE
+        // now so nothing will be sent to it over time and it will start
+        // getting KEEPALIVES since now. Send the first one now to increase
+        // probability that the link will be recognized as IDLE on the
+        // reception side ASAP.
+        int32_t arg = 1;
+        w_d->ps->core().sendCtrl(UMSG_KEEPALIVE, &arg);
+    }
 }
 
 // [[using locked(this->m_GroupLock)]]
-bool CUDTGroup::sendBackup_CheckSendStatus(gli_t                                    d,
-                                           const steady_clock::time_point& currtime ATR_UNUSED,
-                                           const int                                stat,
-                                           const int                                erc,
-                                           const int32_t                            lastseq,
-                                           const int32_t                            pktseq,
-                                           CUDT&                                    w_u,
-                                           int32_t&                                 w_curseq,
-                                           vector<gli_t>&                           w_parallel,
-                                           int&                                     w_final_stat,
-                                           set<uint16_t>&                           w_sendable_pri,
-                                           size_t&                                  w_nsuccessful,
-                                           bool&                                    w_is_nunstable)
+CUDTGroup::BackupMemberState CUDTGroup::sendBackup_QualifyActiveState(const gli_t d, const time_point currtime)
 {
-    bool none_succeeded = true;
+    const CUDT& u = d->ps->core();
 
-    if (stat != -1)
+    const uint32_t latency_us = u.peerLatency_us();
+
+    const int32_t min_stability_us = m_uOPT_MinStabilityTimeout_us;
+    const int64_t initial_stabtout_us = max<int64_t>(min_stability_us, latency_us);
+    const int64_t probing_period_us = initial_stabtout_us + 5 * CUDT::COMM_SYN_INTERVAL_US;
+
+    // RTT and RTTVar values are still being refined during the probing period,
+    // therefore the dymanic timeout should not be used during the probing period.
+    const bool is_activation_phase = !is_zero(u.freshActivationStart())
+        && (count_microseconds(currtime - u.freshActivationStart()) <= probing_period_us);
+
+    // Initial stability timeout is used only in activation phase.
+    // Otherwise runtime stability is used, including the WARY state.
+    const int64_t stability_tout_us = is_activation_phase
+        ? initial_stabtout_us // activation phase
+        : min<int64_t>(max<int64_t>(min_stability_us, 2 * u.SRTT() + 4 * u.RTTVar()), latency_us);
+
+    const steady_clock::time_point last_rsp = max(u.freshActivationStart(), u.lastRspTime());
+    const steady_clock::duration td_response = currtime - last_rsp;
+
+    // No response for a long time
+    if (count_microseconds(td_response) > stability_tout_us)
     {
-        if (w_curseq == SRT_SEQNO_NONE)
-        {
-            w_curseq = pktseq;
-        }
-        else if (w_curseq != lastseq)
-        {
-            // We believe that all running links use the same seq.
-            // But we can do some sanity check.
-            LOGC(gslog.Error,
-                 log << "grp/sendBackup: @" << w_u.m_SocketID << ": IPE: another running link seq discrepancy: %"
-                     << lastseq << " vs. previous %" << w_curseq << " - fixing");
-
-            // Override must be done with a sequence number greater by one.
-
-            // Example:
-            //
-            // Link 1 before sending: curr=1114, next=1115
-            // After sending it reports pktseq=1115
-            //
-            // Link 2 before sending: curr=1110, next=1111 (->lastseq before sending)
-            // THIS CHECK done after sending:
-            //  -- w_curseq(1115) != lastseq(1111)
-            //
-            // NOW: Link 1 after sending is:
-            // curr=1115, next=1116
-            //
-            // The value of w_curseq here = 1115, while overrideSndSeqNo
-            // calls setInitialSndSeq(seq), which sets:
-            // - curr = seq - 1
-            // - next = seq
-            //
-            // So, in order to set curr=1115, next=1116
-            // this must set to 1115+1.
-
-            w_u.overrideSndSeqNo(CSeqNo::incseq(w_curseq));
-        }
+        return BKUPST_ACTIVE_UNSTABLE;
+    }
 
-        // If this link is already found as unstable,
-        // do not add it to the "w_parallel", as all links out
-        // of these "w_parallels" will be later tried to be
-        // shrunk to 1. Out of all links currently running we need
-        // only 1 link STABLE, and we allow any nymber of unstable
-        // links.
+    enterCS(u.m_StatsLock);
+    const int64_t drop_total = u.m_stats.sndr.dropped.total.count();
+    leaveCS(u.m_StatsLock);
 
-        if (is_zero(w_u.m_tsUnstableSince))
-        {
-            w_parallel.push_back(d);
-        }
-        else
-        {
-            HLOGC(gslog.Debug,
-                  log << "grp/sendBackup: Link @" << w_u.m_SocketID << " still UNSTABLE for "
-                      << FormatDuration(currtime - w_u.m_tsUnstableSince) << ", not counting as w_parallel");
-        }
+    const bool have_new_drops = d->pktSndDropTotal != drop_total;
+    if (have_new_drops)
+    {
+        d->pktSndDropTotal = drop_total;
+        if (!is_activation_phase)
+            return BKUPST_ACTIVE_UNSTABLE;
+    }
+
+    // Responsive: either stable, wary or still fresh activated.
+    if (is_activation_phase)
+        return BKUPST_ACTIVE_FRESH;
+
+    const bool is_wary = !is_zero(u.m_tsWarySince);
+    const bool is_wary_probing = is_wary
+        && (count_microseconds(currtime - u.m_tsWarySince) <= 4 * u.peerLatency_us());
+
+    const bool is_unstable = !is_zero(u.m_tsUnstableSince);
+
+    // If unstable and not in wary, become wary.
+    if (is_unstable && !is_wary)
+        return BKUPST_ACTIVE_UNSTABLE_WARY;
+
+    // Still probing for stability.
+    if (is_wary_probing)
+        return BKUPST_ACTIVE_UNSTABLE_WARY;
+
+    if (is_wary)
+    {
+        LOGC(gslog.Debug,
+            log << "grp/sendBackup: @" << u.id() << " wary->stable after " << count_milliseconds(currtime - u.m_tsWarySince) << " ms");
+    }
 
-        // State it as succeeded, though. We don't know if the link
-        // is broken until we get the connection broken confirmation,
-        // and the instability state may wear off next time.
-        none_succeeded = false;
-        w_final_stat   = stat;
-        ++w_nsuccessful;
-        w_sendable_pri.insert(d->weight);
+    return BKUPST_ACTIVE_STABLE;
+}
+
+// [[using locked(this->m_GroupLock)]]
+bool CUDTGroup::sendBackup_CheckSendStatus(const steady_clock::time_point& currtime SRT_ATR_UNUSED,
+                                           const int                       send_status,
+                                           const int32_t                   lastseq,
+                                           const int32_t                   pktseq,
+                                           CUDT&                           w_u,
+                                           int32_t&                        w_curseq,
+                                           int&                            w_final_stat)
+{
+    if (send_status == -1)
+        return false; // Sending failed.
+
+
+    bool send_succeeded = false;
+    if (w_curseq == SRT_SEQNO_NONE)
+    {
+        w_curseq = pktseq;
     }
-    else if (erc == SRT_EASYNCSND)
+    else if (w_curseq != lastseq)
     {
-        HLOGC(gslog.Debug, log << "grp/sendBackup: Link @" << w_u.m_SocketID << " DEEMED UNSTABLE (not ready to send)");
-        w_is_nunstable = true;
+        // We believe that all active links use the same seq.
+        // But we can do some sanity check.
+        LOGC(gslog.Error,
+                log << "grp/sendBackup: @" << w_u.m_SocketID << ": IPE: another running link seq discrepancy: %"
+                    << lastseq << " vs. previous %" << w_curseq << " - fixing");
+
+        // Override must be done with a sequence number greater by one.
+
+        // Example:
+        //
+        // Link 1 before sending: curr=1114, next=1115
+        // After sending it reports pktseq=1115
+        //
+        // Link 2 before sending: curr=1110, next=1111 (->lastseq before sending)
+        // THIS CHECK done after sending:
+        //  -- w_curseq(1115) != lastseq(1111)
+        //
+        // NOW: Link 1 after sending is:
+        // curr=1115, next=1116
+        //
+        // The value of w_curseq here = 1115, while overrideSndSeqNo
+        // calls setInitialSndSeq(seq), which sets:
+        // - curr = seq - 1
+        // - next = seq
+        //
+        // So, in order to set curr=1115, next=1116
+        // this must set to 1115+1.
+
+        w_u.overrideSndSeqNo(CSeqNo::incseq(w_curseq));
     }
 
-    return none_succeeded;
+    // State it as succeeded, though. We don't know if the link
+    // is broken until we get the connection broken confirmation,
+    // and the instability state may wear off next time.
+    send_succeeded = true;
+    w_final_stat   = send_status;
+
+    return send_succeeded;
 }
 
 // [[using locked(this->m_GroupLock)]]
@@ -3186,39 +3006,75 @@ void CUDTGroup::sendBackup_Buffering(const char* buf, const int len, int32_t& w_
         m_iLastSchedSeqNo = oldest_buffer_seq;
 }
 
-// [[using locked(this->m_GroupLock)]]
-size_t CUDTGroup::sendBackup_CheckNeedActivate(const vector<gli_t>&        idlers,
-                                             const char*                   buf,
-                                             const int                     len,
-                                             bool&                         w_none_succeeded,
-                                             SRT_MSGCTRL&                  w_mc,
-                                             int32_t&                      w_curseq,
-                                             int32_t&                      w_final_stat,
-                                             CUDTException&                w_cx,
-                                             vector<Sendstate>&            w_sendstates,
-                                             vector<gli_t>&                w_parallel,
-                                             vector<SRTSOCKET>&            w_wipeme,
-                                             const string& activate_reason ATR_UNUSED)
+size_t CUDTGroup::sendBackup_TryActivateStandbyIfNeeded(
+    const char* buf,
+    const int   len,
+    bool& w_none_succeeded,
+    SRT_MSGCTRL& w_mc,
+    int32_t& w_curseq,
+    int32_t& w_final_stat,
+    SendBackupCtx& w_sendBackupCtx,
+    CUDTException& w_cx,
+    const steady_clock::time_point& currtime)
 {
-    int stat = -1;
+    const unsigned num_standby = w_sendBackupCtx.countMembersByState(BKUPST_STANDBY);
+    if (num_standby == 0)
+    {
+        return 0;
+    }
 
-    // If we have no stable links, activate one of idle links.
+    const unsigned num_stable = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_STABLE);
+    const unsigned num_fresh  = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_FRESH);
 
-    HLOGC(gslog.Debug,
-          log << "grp/sendBackup: " << activate_reason << ", trying to activate an idle link (" << idlers.size()
-              << " available)");
+    if (num_stable + num_fresh == 0)
+    {
+        LOGC(gslog.Warn,
+            log << "grp/sendBackup: trying to activate a stand-by link (" << num_standby << " available). "
+            << "Reason: no stable links"
+        );
+    }
+    else if (w_sendBackupCtx.maxActiveWeight() < w_sendBackupCtx.maxStandbyWeight())
+    {
+        LOGC(gslog.Warn,
+            log << "grp/sendBackup: trying to activate a stand-by link (" << num_standby << " available). "
+                << "Reason: max active weight " << w_sendBackupCtx.maxActiveWeight()
+                << ", max stand by weight " << w_sendBackupCtx.maxStandbyWeight()
+        );
+    }
+    else
+    {
+        /*LOGC(gslog.Warn,
+            log << "grp/sendBackup: no need to activate (" << num_standby << " available). "
+            << "Max active weight " << w_sendBackupCtx.maxActiveWeight()
+            << ", max stand by weight " << w_sendBackupCtx.maxStandbyWeight()
+        );*/
+        return 0;
+    }
+
+    int stat = -1;
 
-    size_t nactive = 0;
+    size_t num_activated = 0;
 
-    for (vector<gli_t>::const_iterator i = idlers.begin(); i != idlers.end(); ++i)
+    w_sendBackupCtx.sortByWeightAndState();
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
     {
+        if (member->state != BKUPST_STANDBY)
+            continue;
+
         int   erc = 0;
-        gli_t d   = *i;
+        SocketData* d = member->pSocketData;
         // Now send and check the status
         // The link could have got broken
 
         try
         {
+            CUDT& cudt = d->ps->core();
+            // Take source rate estimation from an active member (needed for the input rate estimation mode).
+            cudt.setRateEstimator(w_sendBackupCtx.getRateEstimate());
+
+            // TODO: At this point all packets that could be sent
+            // are located in m_SenderBuffer. So maybe just use sendBackupRexmit()?
             if (w_curseq == SRT_SEQNO_NONE)
             {
                 // This marks the fact that the given here packet
@@ -3226,9 +3082,9 @@ size_t CUDTGroup::sendBackup_CheckNeedActivate(const vector<gli_t>&        idler
                 // situation of sending the very first packet after connection.
 
                 HLOGC(gslog.Debug,
-                      log << "grp/sendBackup: ... trying @" << d->id << " - sending the VERY FIRST message");
+                    log << "grp/sendBackup: ... trying @" << d->id << " - sending the VERY FIRST message");
 
-                stat = d->ps->core().sendmsg2(buf, len, (w_mc));
+                stat = cudt.sendmsg2(buf, len, (w_mc));
                 if (stat != -1)
                 {
                     // This will be no longer used, but let it stay here.
@@ -3241,13 +3097,13 @@ size_t CUDTGroup::sendBackup_CheckNeedActivate(const vector<gli_t>&        idler
             else
             {
                 HLOGC(gslog.Debug,
-                      log << "grp/sendBackup: ... trying @" << d->id << " - resending " << m_SenderBuffer.size()
-                          << " collected messages...");
+                    log << "grp/sendBackup: ... trying @" << d->id << " - resending " << m_SenderBuffer.size()
+                    << " collected messages...");
                 // Note: this will set the currently required packet
                 // because it has been just freshly added to the sender buffer
-                stat = sendBackupRexmit(d->ps->core(), (w_mc));
+                stat = sendBackupRexmit(cudt, (w_mc));
             }
-            ++nactive;
+            ++num_activated;
         }
         catch (CUDTException& e)
         {
@@ -3255,46 +3111,24 @@ size_t CUDTGroup::sendBackup_CheckNeedActivate(const vector<gli_t>&        idler
             // but that's ok - we want this sending interrupted even in half.
             w_cx = e;
             stat = -1;
-            erc  = e.getErrorCode();
+            erc = e.getErrorCode();
         }
 
-        d->sndresult  = stat;
+        d->sndresult = stat;
         d->laststatus = d->ps->getStatus();
 
-        const Sendstate cstate = {d->id, d, stat, erc};
-        w_sendstates.push_back(cstate);
-
         if (stat != -1)
         {
-            if (d->sndstate != SRT_GST_RUNNING)
-            {
-                steady_clock::time_point currtime = steady_clock::now();
-                d->ps->core().m_tsTmpActiveTime   = currtime;
-                HLOGC(gslog.Debug,
-                      log << "@" << d->id << ":... sending SUCCESSFUL #" << w_mc.msgno
-                          << " LINK ACTIVATED (pri: " << d->weight << ").");
-            }
-            else
-            {
-                LOGC(gslog.Warn,
-                     log << "@" << d->id << ":... sending SUCCESSFUL #" << w_mc.msgno
-                         << " LINK ACTIVATED (pri: " << d->weight << ").");
-            }
+            d->sndstate = SRT_GST_RUNNING;
+            sendBackup_AssignBackupState(d->ps->core(), BKUPST_ACTIVE_FRESH, currtime);
+            w_sendBackupCtx.updateMemberState(d, BKUPST_ACTIVE_FRESH);
             // Note: this will override the sequence number
             // for all next iterations in this loop.
-            d->sndstate = SRT_GST_RUNNING;
-
-            if (is_zero(d->ps->core().m_tsUnstableSince))
-            {
-                w_parallel.push_back(d);
-            }
-            else
-            {
-                HLOGC(gslog.Debug,
-                      log << "grp/sendBackup: Link @" << d->id << " (idle) UNSTABLE, not counting as parallel");
-            }
             w_none_succeeded = false;
-            w_final_stat     = stat;
+            w_final_stat = stat;
+
+            LOGC(gslog.Warn,
+                log << "@" << d->id << " FRESH-ACTIVATED");
 
             // We've activated the link, so that's enough.
             break;
@@ -3305,88 +3139,128 @@ size_t CUDTGroup::sendBackup_CheckNeedActivate(const vector<gli_t>&        idler
         if (erc != SRT_EASYNCSND)
         {
             isblocked = false;
-            w_wipeme.push_back(d->id);
+            sendBackup_AssignBackupState(d->ps->core(), BKUPST_BROKEN, currtime);
+            w_sendBackupCtx.updateMemberState(d, BKUPST_BROKEN);
         }
 
         // If we found a blocked link, leave it alone, however
         // still try to send something over another link
 
-        HLOGC(gslog.Debug,
-              log << "@" << d->id << " FAILED (" << (isblocked ? "blocked" : "ERROR")
-                  << "), trying to activate another link.");
+        LOGC(gslog.Warn,
+            log << "@" << d->id << " FAILED (" << (isblocked ? "blocked" : "ERROR")
+            << "), trying to activate another link.");
     }
 
-    return nactive;
+    return num_activated;
 }
 
 // [[using locked(this->m_GroupLock)]]
-void CUDTGroup::send_CheckPendingSockets(const vector<SRTSOCKET>& pending, vector<SRTSOCKET>& w_wipeme)
+void CUDTGroup::sendBackup_CheckPendingSockets(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime)
 {
-    // If we have at least one stable link, then select a link that have the
-    // highest priority and silence the rest.
-
-    // Note: If we have one stable link, this is the situation we need.
-    // If we have no stable links at all, there's nothing we can do anyway.
-    // The freshly activated previously idle links don't count because we
-    // just started them and we can't determine their stability. At least if
-    // we have one link that is stable and the freshly activated link is actually
-    // stable too, we'll check this next time.
-    //
-    if (!pending.empty())
+    if (w_sendBackupCtx.countMembersByState(BKUPST_PENDING) == 0)
+        return;
+
+    HLOGC(gslog.Debug, log << "grp/send*: checking pending sockets.");
+
+    // These sockets if they are in pending state, should be added to m_SndEID
+    // at the connecting stage.
+    CEPoll::fmap_t sready;
+
+    if (m_Global.m_EPoll.empty(*m_SndEpolld))
     {
-        HLOGC(gslog.Debug, log << "grp/send*: found pending sockets, polling them.");
+        // Sanity check - weird pending reported.
+        LOGC(gslog.Error, log << "grp/send*: IPE: reported pending sockets, but EID is empty - wiping pending!");
+        return;
+    }
 
-        // These sockets if they are in pending state, they should be added to m_SndEID
-        // at the connecting stage.
-        CEPoll::fmap_t sready;
+    {
+        InvertedLock ug(m_GroupLock);
+        m_Global.m_EPoll.swait(
+            *m_SndEpolld, sready, 0, false /*report by retval*/); // Just check if anything has happened
+    }
 
-        if (m_SndEpolld->watch_empty())
-        {
-            // Sanity check - weird pending reported.
-            LOGC(gslog.Error, log << "grp/send*: IPE: reported pending sockets, but EID is empty - wiping pending!");
-            copy(pending.begin(), pending.end(), back_inserter(w_wipeme));
-        }
-        else
-        {
-            // Some sockets could have been closed in the meantime.
-            if (m_SndEpolld->watch_empty())
-                throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
+    if (m_bClosing)
+    {
+        HLOGC(gslog.Debug, log << "grp/send...: GROUP CLOSED, ABANDONING");
+        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
+    }
 
-            {
-                InvertedLock ug(m_GroupLock);
-                m_pGlobal->m_EPoll.swait(
-                    *m_SndEpolld, sready, 0, false /*report by retval*/); // Just check if anything happened
-            }
+    // Some sockets could have been closed in the meantime.
+    if (m_Global.m_EPoll.empty(*m_SndEpolld))
+        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
-            if (m_bClosing)
-            {
-                HLOGC(gslog.Debug, log << "grp/send...: GROUP CLOSED, ABANDONING");
-                throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-            }
+    HLOGC(gslog.Debug, log << "grp/send*: RDY: " << DisplayEpollResults(sready));
 
-            HLOGC(gslog.Debug, log << "grp/send*: RDY: " << DisplayEpollResults(sready));
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
+    {
+        if (member->state != BKUPST_PENDING)
+            continue;
 
-            // sockets in EX: should be moved to w_wipeme.
-            for (vector<SRTSOCKET>::const_iterator i = pending.begin(); i != pending.end(); ++i)
-            {
-                if (CEPoll::isready(sready, *i, SRT_EPOLL_ERR))
-                {
-                    HLOGC(gslog.Debug, log << "grp/send*: Socket @" << (*i) << " reported FAILURE - moved to wiped.");
-                    // Failed socket. Move d to w_wipeme. Remove from eid.
-                    w_wipeme.push_back(*i);
-                    int no_events = 0;
-                    m_pGlobal->m_EPoll.update_usock(m_SndEID, *i, &no_events);
-                }
-            }
+        const SRTSOCKET sockid = member->pSocketData->id;
+        if (!CEPoll::isready(sready, sockid, SRT_EPOLL_ERR))
+            continue;
 
-            // After that, all sockets that have been reported
-            // as ready to write should be removed from EID. This
-            // will also remove those sockets that have been added
-            // as redundant links at the connecting stage and became
-            // writable (connected) before this function had a chance
-            // to check them.
-            m_pGlobal->m_EPoll.clear_ready_usocks(*m_SndEpolld, SRT_EPOLL_OUT);
+        HLOGC(gslog.Debug, log << "grp/send*: Socket @" << sockid << " reported FAILURE - qualifying as broken.");
+        w_sendBackupCtx.updateMemberState(member->pSocketData, BKUPST_BROKEN);
+        if (member->pSocketData->ps)
+            sendBackup_AssignBackupState(member->pSocketData->ps->core(), BKUPST_BROKEN, currtime);
+
+        const int no_events = 0;
+        m_Global.m_EPoll.update_usock(m_SndEID, sockid, &no_events);
+    }
+
+    // After that, all sockets that have been reported
+    // as ready to write should be removed from EID. This
+    // will also remove those sockets that have been added
+    // as redundant links at the connecting stage and became
+    // writable (connected) before this function had a chance
+    // to check them.
+    m_Global.m_EPoll.clear_ready_usocks(*m_SndEpolld, SRT_EPOLL_OUT);
+}
+
+// [[using locked(this->m_GroupLock)]]
+void CUDTGroup::sendBackup_CheckUnstableSockets(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime)
+{
+    const unsigned num_stable = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_STABLE);
+    if (num_stable == 0)
+        return;
+
+    const unsigned num_unstable = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_UNSTABLE);
+    const unsigned num_wary     = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_UNSTABLE_WARY);
+    if (num_unstable + num_wary == 0)
+        return;
+
+    HLOGC(gslog.Debug, log << "grp/send*: checking unstable sockets.");
+
+    
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
+    {
+        if (member->state != BKUPST_ACTIVE_UNSTABLE && member->state != BKUPST_ACTIVE_UNSTABLE_WARY)
+            continue;
+
+        CUDT& sock = member->pSocketData->ps->core();
+
+        if (is_zero(sock.m_tsUnstableSince))
+        {
+            LOGC(gslog.Error, log << "grp/send* IPE: Socket @" << member->socketID
+                << " is qualified as unstable, but does not have the 'unstable since' timestamp. Still marking for closure.");
         }
+
+        const int unstable_for_ms = (int)count_milliseconds(currtime - sock.m_tsUnstableSince);
+        if (unstable_for_ms < sock.peerIdleTimeout_ms())
+            continue;
+
+        // Requesting this socket to be broken with the next CUDT::checkExpTimer() call.
+        sock.breakAsUnstable();
+
+        LOGC(gslog.Warn, log << "grp/send*: Socket @" << member->socketID << " is unstable for " << unstable_for_ms 
+            << "ms - requesting breakage.");
+
+        //w_sendBackupCtx.updateMemberState(member->pSocketData, BKUPST_BROKEN);
+        //if (member->pSocketData->ps)
+        //    sendBackup_AssignBackupState(member->pSocketData->ps->core(), BKUPST_BROKEN, currtime);
     }
 }
 
@@ -3398,13 +3272,13 @@ void CUDTGroup::send_CloseBrokenSockets(vector<SRTSOCKET>& w_wipeme)
         InvertedLock ug(m_GroupLock);
 
         // With unlocked GroupLock, we can now lock GlobControlLock.
-        // This is needed prevent any of them be deleted from the container
+        // This is needed to prevent any of them deleted from the container
         // at the same time.
-        ScopedLock globlock(CUDT::s_UDTUnited.m_GlobControlLock);
+        ScopedLock globlock(CUDT::uglobal().m_GlobControlLock);
 
         for (vector<SRTSOCKET>::iterator p = w_wipeme.begin(); p != w_wipeme.end(); ++p)
         {
-            CUDTSocket* s = CUDT::s_UDTUnited.locateSocket_LOCKED(*p);
+            CUDTSocket* s = CUDT::uglobal().locateSocket_LOCKED(*p);
 
             // If the socket has been just moved to ClosedSockets, it means that
             // the object still exists, but it will be no longer findable.
@@ -3426,25 +3300,51 @@ void CUDTGroup::send_CloseBrokenSockets(vector<SRTSOCKET>& w_wipeme)
     w_wipeme.clear();
 }
 
-struct FByOldestActive
+// [[using locked(this->m_GroupLock)]]
+void CUDTGroup::sendBackup_CloseBrokenSockets(SendBackupCtx& w_sendBackupCtx)
 {
-    typedef CUDTGroup::gli_t gli_t;
-    bool operator()(gli_t a, gli_t b)
+    if (w_sendBackupCtx.countMembersByState(BKUPST_BROKEN) == 0)
+        return;
+
+    InvertedLock ug(m_GroupLock);
+
+    // With unlocked GroupLock, we can now lock GlobControlLock.
+    // This is needed prevent any of them be deleted from the container
+    // at the same time.
+    ScopedLock globlock(CUDT::uglobal().m_GlobControlLock);
+
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
     {
-        CUDT& x = a->ps->core();
-        CUDT& y = b->ps->core();
+        if (member->state != BKUPST_BROKEN)
+            continue;
+
+        // m_GroupLock is unlocked, therefore member->pSocketData can't be used.
+        const SRTSOCKET sockid = member->socketID;
+        CUDTSocket* s = CUDT::uglobal().locateSocket_LOCKED(sockid);
 
-        return x.m_tsTmpActiveTime < y.m_tsTmpActiveTime;
+        // If the socket has been just moved to ClosedSockets, it means that
+        // the object still exists, but it will be no longer findable.
+        if (!s)
+            continue;
+
+        LOGC(gslog.Debug,
+                log << "grp/send...: BROKEN SOCKET @" << sockid << " - CLOSING, to be removed from group.");
+
+        // As per sending, make it also broken so that scheduled
+        // packets will be also abandoned.
+        s->setBrokenClosed();
     }
-};
+
+    // TODO: all broken members are to be removed from the context now???
+}
 
 // [[using locked(this->m_GroupLock)]]
-void CUDTGroup::sendBackup_CheckParallelLinks(const vector<gli_t>& unstable,
-                                              vector<gli_t>&       w_parallel,
-                                              int&                 w_final_stat,
-                                              bool&                w_none_succeeded,
-                                              SRT_MSGCTRL&         w_mc,
-                                              CUDTException&       w_cx)
+void CUDTGroup::sendBackup_RetryWaitBlocked(SendBackupCtx&       w_sendBackupCtx,
+                                            int&                 w_final_stat,
+                                            bool&                w_none_succeeded,
+                                            SRT_MSGCTRL&         w_mc,
+                                            CUDTException&       w_cx)
 {
     // In contradiction to broadcast sending, backup sending must check
     // the blocking state in total first. We need this information through
@@ -3459,670 +3359,362 @@ void CUDTGroup::sendBackup_CheckParallelLinks(const vector<gli_t>& unstable,
     // unstable links and none other or others just got broken), continue sending
     // anyway.
 
-#if ENABLE_HEAVY_LOGGING
-    // Potential problem to be checked in developer mode
-    for (vector<gli_t>::iterator p = w_parallel.begin(); p != w_parallel.end(); ++p)
-    {
-        if (std::find(unstable.begin(), unstable.end(), *p) != unstable.end())
-        {
-            LOGC(gslog.Debug,
-                    log << "grp/sendBackup: IPE: parallel links enclose unstable link @" << (*p)->ps->m_SocketID);
-        }
-    }
-#endif
 
     // This procedure is for a case when the packet could not be sent
     // over any link (hence "none succeeded"), but there are some unstable
     // links and no parallel links. We need to WAIT for any of the links
     // to become available for sending.
-    if (w_parallel.empty() && !unstable.empty() && w_none_succeeded)
-    {
-        HLOGC(gslog.Debug, log << "grp/sendBackup: no parallel links and "
-                << unstable.size() << " unstable links - checking...");
-
-        // Note: GroupLock is set already, skip locks and checks
-        getGroupData_LOCKED((w_mc.grpdata), (&w_mc.grpdata_size));
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
-
-        if (m_SndEpolld->watch_empty())
-        {
-            // wipeme wiped, pending sockets checked, it can only mean that
-            // all sockets are broken.
-            HLOGC(gslog.Debug, log << "grp/sendBackup: epolld empty - all sockets broken?");
-            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-        }
-
-        if (!m_bSynSending)
-        {
-            HLOGC(gslog.Debug, log << "grp/sendBackup: non-blocking mode - exit with no-write-ready");
-            throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
-        }
-        // Here is the situation that the only links left here are:
-        // - those that failed to send (already closed and wiped out)
-        // - those that got blockade on sending
-
-        // At least, there was so far no socket through which we could
-        // successfully send anything.
-
-        // As a last resort in this situation, try to wait for any links
-        // remaining in the group to become ready to write.
-
-        CEPoll::fmap_t sready;
-        int            brdy;
-
-        // This keeps the number of links that existed at the entry.
-        // Simply notify all dead links, regardless as to whether the number
-        // of group members decreases below. If the number of corpses reaches
-        // this number, consider the group connection broken.
-        size_t nlinks = m_Group.size();
-        size_t ndead  = 0;
-
-RetryWaitBlocked:
-        {
-            // Some sockets could have been closed in the meantime.
-            if (m_SndEpolld->watch_empty())
-            {
-                HLOGC(gslog.Debug, log << "grp/sendBackup: no more sendable sockets - group broken");
-                throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-            }
-
-            InvertedLock ug(m_GroupLock);
-            HLOGC(gslog.Debug,
-                    log << "grp/sendBackup: swait call to get at least one link alive up to " << m_iSndTimeOut << "us");
-            THREAD_PAUSED();
-            brdy = m_pGlobal->m_EPoll.swait(*m_SndEpolld, (sready), m_iSndTimeOut);
-            THREAD_RESUMED();
-
-            if (brdy == 0) // SND timeout exceeded
-            {
-                throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
-            }
-
-            HLOGC(gslog.Debug, log << "grp/sendBackup: swait exited with " << brdy << " ready sockets:");
-
-            // Check if there's anything in the "error" section.
-            // This must be cleared here before the lock on group is set again.
-            // (This loop will not fire neither once if no failed sockets found).
-            for (CEPoll::fmap_t::const_iterator i = sready.begin(); i != sready.end(); ++i)
-            {
-                if (i->second & SRT_EPOLL_ERR)
-                {
-                    SRTSOCKET   id = i->first;
-                    CUDTSocket* s  = m_pGlobal->locateSocket(id, CUDTUnited::ERH_RETURN); // << LOCKS m_GlobControlLock!
-                    if (s)
-                    {
-                        HLOGC(gslog.Debug,
-                                log << "grp/sendBackup: swait/ex on @" << (id)
-                                << " while waiting for any writable socket - CLOSING");
-                        CUDT::s_UDTUnited.close(s); // << LOCKS m_GlobControlLock, then GroupLock!
-                    }
-                    else
-                    {
-                        HLOGC(gslog.Debug, log << "grp/sendBackup: swait/ex on @" << (id) << " - WAS DELETED IN THE MEANTIME");
-                    }
-
-                    ++ndead;
-                }
-            }
-            HLOGC(gslog.Debug, log << "grp/sendBackup: swait/?close done, re-acquiring GroupLock");
-        }
-
-        // GroupLock is locked back
-
-        // Re-check after the waiting lock has been reacquired
-        if (m_bClosing)
-            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-
-        if (brdy == -1 || ndead >= nlinks)
-        {
-            LOGC(gslog.Error,
-                    log << "grp/sendBackup: swait=>" << brdy << " nlinks=" << nlinks << " ndead=" << ndead
-                    << " - looxlike all links broken");
-            m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
-            m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
-            // You can safely throw here - nothing to fill in when all sockets down.
-            // (timeout was reported by exception in the swait call).
-            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
-        }
-
-        // Ok, now check if we have at least one write-ready.
-        // Note that the procedure of activation of a new link in case of
-        // no stable links found embraces also rexmit-sending and status
-        // check as well, including blocked status.
-
-        // Find which one it was. This is so rare case that we can
-        // suffer linear search.
-
-        int nwaiting = 0;
-        int nactivated ATR_UNUSED = 0;
-        int stat     = -1;
-        for (gli_t d = m_Group.begin(); d != m_Group.end(); ++d)
-        {
-            // int erc = 0;
-
-            // Skip if not writable in this run
-            if (!CEPoll::isready(sready, d->id, SRT_EPOLL_OUT))
-            {
-                ++nwaiting;
-                HLOGC(gslog.Debug, log << "grp/sendBackup: @" << d->id << " NOT ready:OUT, added as waiting");
-                continue;
-            }
-
-            if (d->sndstate == SRT_GST_RUNNING)
-            {
-                HLOGC(gslog.Debug,
-                        log << "grp/sendBackup: link @" << d->id << " RUNNING - SKIPPING from activate and resend");
-                continue;
-            }
-
-            try
-            {
-                // Note: this will set the currently required packet
-                // because it has been just freshly added to the sender buffer
-                stat = sendBackupRexmit(d->ps->core(), (w_mc));
-                ++nactivated;
-            }
-            catch (CUDTException& e)
-            {
-                // This will be propagated from internal sendmsg2 call,
-                // but that's ok - we want this sending interrupted even in half.
-                w_cx = e;
-                stat = -1;
-                // erc = e.getErrorCode();
-            }
-
-            d->sndresult  = stat;
-            d->laststatus = d->ps->getStatus();
-
-            if (stat == -1)
-            {
-                // This link is no longer waiting.
-                continue;
-            }
 
-            w_parallel.push_back(d);
-            w_final_stat                      = stat;
-            steady_clock::time_point currtime = steady_clock::now();
-            d->ps->core().m_tsTmpActiveTime   = currtime;
-            d->sndstate                       = SRT_GST_RUNNING;
-            w_none_succeeded                  = false;
-            HLOGC(gslog.Debug, log << "grp/sendBackup: after waiting, ACTIVATED link @" << d->id);
-
-            break;
-        }
-
-        // If we have no links successfully activated, but at least
-        // one link "not ready for writing", continue waiting for at
-        // least one link ready.
-        if (stat == -1 && nwaiting > 0)
-        {
-            HLOGC(gslog.Debug, log << "grp/sendBackup: still have " << nwaiting << " waiting and none succeeded, REPEAT");
-            goto RetryWaitBlocked;
-        }
-
-        HLOGC(gslog.Debug, log << "grp/sendBackup: " << nactivated << " links activated with "
-                << unstable.size() << " unstable");
-    }
-
-    // The most important principle is to keep the data being sent constantly,
-    // even if it means temporarily full redundancy. However, if you are certain
-    // that you have multiple stable links running at the moment, SILENCE all but
-    // the one with highest priority.
-    if (w_parallel.size() > 1)
-    {
-        sort(w_parallel.begin(), w_parallel.end(), FPriorityOrder());
-        steady_clock::time_point currtime = steady_clock::now();
-
-        vector<gli_t>::iterator b = w_parallel.begin();
-
-        // Additional criterion: if you have multiple links with the same weight,
-        // check if you have at least one with m_tsTmpActiveTime == 0. If not,
-        // sort them additionally by this time.
-
-        vector<gli_t>::iterator b1 = b, e = ++b1;
-
-        // Both e and b1 stand on b+1 position.
-        // We have a guarantee that b+1 still points to a valid element.
-        while (e != w_parallel.end())
-        {
-            if ((*e)->weight != (*b)->weight)
-                break;
-            ++e;
-        }
-
-        if (b1 != e)
-        {
-            // More than 1 link with the same weight. Sorting them according
-            // to a different criterion will not change the previous sorting order
-            // because the elements in this range are equal according to the previous
-            // criterion.
-            // Here find the link with least time. The "trap" zero time matches this
-            // requirement, occasionally.
-            sort(b, e, FByOldestActive());
-        }
-
-        // After finding the link to leave active, leave it behind.
-        HLOGC(gslog.Debug, log << "grp/sendBackup: keeping parallel link @" << (*b)->id << " and silencing others:");
-        ++b;
-        for (; b != w_parallel.end(); ++b)
-        {
-            gli_t& d = *b;
-            if (d->sndstate != SRT_GST_RUNNING)
-            {
-                LOGC(gslog.Error,
-                        log << "grp/sendBackup: IPE: parallel link container contains non-running link @" << d->id);
-                continue;
-            }
-            CUDT&                  ce = d->ps->core();
-            steady_clock::duration td(0);
-            if (!is_zero(ce.m_tsTmpActiveTime) &&
-                    count_microseconds(td = currtime - ce.m_tsTmpActiveTime) < ce.m_uOPT_StabilityTimeout)
-            {
-                HLOGC(gslog.Debug,
-                        log << "... not silencing @" << d->id << ": too early: " << FormatDuration(td) << " < "
-                        << ce.m_uOPT_StabilityTimeout << "(stability timeout)");
-                continue;
-            }
-
-            // Clear activation time because the link is no longer active!
-            d->sndstate = SRT_GST_IDLE;
-            HLOGC(gslog.Debug, log << " ... @" << d->id << " ACTIVATED: " << FormatTime(ce.m_tsTmpActiveTime));
-            ce.m_tsTmpActiveTime = steady_clock::time_point();
-        }
-    }
-}
-
-int CUDTGroup::sendBackup(const char* buf, int len, SRT_MSGCTRL& w_mc)
-{
-    // Avoid stupid errors in the beginning.
-    if (len <= 0)
-    {
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-    }
-
-    // Live only - sorry.
-    if (len > SRT_LIVE_MAX_PLSIZE)
-    {
-        LOGC(gslog.Error, log << "grp/send(backup): buffer size=" << len << " exceeds maximum allowed in live mode");
-        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
-    }
-
-    // [[using assert(this->m_pSndBuffer != nullptr)]];
-
-    // NOTE: This is a "vector of list iterators". Every element here
-    // is an iterator to another container.
-    // Note that "list" is THE ONLY container in standard C++ library,
-    // for which NO ITERATORS ARE INVALIDATED after a node at particular
-    // iterator has been removed, except for that iterator itself.
-    vector<SRTSOCKET> wipeme;
-    vector<gli_t> idlers;
-    vector<SRTSOCKET> pending;
-    vector<gli_t> unstable;
-    vector<gli_t> sendable;
+    // Note: A link is added in unstableLinks if sending has failed with SRT_ESYNCSND.
+    const unsigned num_unstable = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_UNSTABLE);
+    const unsigned num_wary     = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_UNSTABLE_WARY);
+    if ((num_unstable + num_wary == 0) || !w_none_succeeded)
+        return;
 
-    int                          stat       = 0;
-    int                          final_stat = -1;
-    SRT_ATR_UNUSED CUDTException cx(MJ_SUCCESS, MN_NONE, 0);
+    HLOGC(gslog.Debug, log << "grp/sendBackup: no successfull sending: "
+        << (num_unstable + num_wary) << " unstable links - waiting to retry sending...");
 
-    // First, acquire GlobControlLock to make sure all member sockets still exist
-    enterCS(m_pGlobal->m_GlobControlLock);
-    ScopedLock guard(m_GroupLock);
+    // Note: GroupLock is set already, skip locks and checks
+    getGroupData_LOCKED((w_mc.grpdata), (&w_mc.grpdata_size));
+    m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+    m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
 
-    if (m_bClosing)
+    if (m_Global.m_EPoll.empty(*m_SndEpolld))
     {
-        leaveCS(m_pGlobal->m_GlobControlLock);
+        // wipeme wiped, pending sockets checked, it can only mean that
+        // all sockets are broken.
+        HLOGC(gslog.Debug, log << "grp/sendBackup: epolld empty - all sockets broken?");
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
-    // Now, still under lock, check if all sockets still can be dispatched
-    send_CheckValidSockets();
-    leaveCS(m_pGlobal->m_GlobControlLock);
-
-    steady_clock::time_point currtime = steady_clock::now();
-
-    sendable.reserve(m_Group.size());
-
-    // First, check status of every link - no matter if idle or active.
-    for (gli_t d = m_Group.begin(); d != m_Group.end(); ++d)
+    if (!m_bSynSending)
     {
-        if (d->sndstate != SRT_GST_BROKEN)
-        {
-            // Check the socket state prematurely in order not to uselessly
-            // send over a socket that is broken.
-            CUDT* const pu = (d->ps)
-                ?  &d->ps->core()
-                :  NULL;
-
-            if (!pu || pu->m_bBroken)
-            {
-                HLOGC(gslog.Debug, log << "grp/sendBackup: socket @" << d->id << " detected +Broken - transit to BROKEN");
-                d->sndstate = SRT_GST_BROKEN;
-                d->rcvstate = SRT_GST_BROKEN;
-            }
-        }
-
-        // Check socket sndstate before sending
-        if (d->sndstate == SRT_GST_BROKEN)
-        {
-            HLOGC(gslog.Debug,
-                  log << "grp/sendBackup: socket in BROKEN state: @" << d->id
-                      << ", sockstatus=" << SockStatusStr(d->ps ? d->ps->getStatus() : SRTS_NONEXIST));
-            wipeme.push_back(d->id);
-            continue;
-        }
+        HLOGC(gslog.Debug, log << "grp/sendBackup: non-blocking mode - exit with no-write-ready");
+        throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
+    }
+    // Here is the situation that the only links left here are:
+    // - those that failed to send (already closed and wiped out)
+    // - those that got blockade on sending
 
-        if (d->sndstate == SRT_GST_IDLE)
-        {
-            if (!send_CheckIdle(d, (wipeme), (pending)))
-                continue;
+    // At least, there was so far no socket through which we could
+    // successfully send anything.
 
-            HLOGC(gslog.Debug,
-                  log << "grp/sendBackup: socket in IDLE state: @" << d->id << " - will activate it IF NEEDED");
-            // This is idle, we'll take care of them next time
-            // Might be that:
-            // - this socket is idle, while some NEXT socket is running
-            // - we need at least one running socket to work BEFORE activating the idle one.
-            // - if ALL SOCKETS ARE IDLE, then we simply activate the first from the list,
-            //   and all others will be activated using the ISN from the first one.
-            idlers.push_back(d);
-            sendBackup_CheckIdleTime(d);
-            continue;
-        }
+    // As a last resort in this situation, try to wait for any links
+    // remaining in the group to become ready to write.
 
-        if (d->sndstate == SRT_GST_RUNNING)
+    CEPoll::fmap_t sready;
+    int            brdy;
+
+    // This keeps the number of links that existed at the entry.
+    // Simply notify all dead links, regardless as to whether the number
+    // of group members decreases below. If the number of corpses reaches
+    // this number, consider the group connection broken.
+    const size_t nlinks = m_Group.size();
+    size_t ndead = 0;
+
+RetryWaitBlocked:
+    {
+        // Some sockets could have been closed in the meantime.
+        if (m_Global.m_EPoll.empty(*m_SndEpolld))
         {
-            if (!sendBackup_CheckRunningStability(d, (currtime)))
-            {
-                insert_uniq((unstable), d);
-            }
-            // Unstable links should still be used for sending.
-            sendable.push_back(d);
-            continue;
+            HLOGC(gslog.Debug, log << "grp/sendBackup: no more sockets available for sending - group broken");
+            throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
         }
 
+        InvertedLock ug(m_GroupLock);
         HLOGC(gslog.Debug,
-              log << "grp/sendBackup: socket @" << d->id << " not ready, state: " << StateStr(d->sndstate) << "("
-                  << int(d->sndstate) << ") - NOT sending, SET AS PENDING");
-
-        pending.push_back(d->id);
-    }
+            log << "grp/sendBackup: swait call to get at least one link alive up to " << m_iSndTimeOut << "us");
+        THREAD_PAUSED();
+        brdy = m_Global.m_EPoll.swait(*m_SndEpolld, (sready), m_iSndTimeOut);
+        THREAD_RESUMED();
 
-    // Sort the idle sockets by priority so the highest priority idle links are checked first.
-    sort(idlers.begin(), idlers.end(), FPriorityOrder());
+        if (brdy == 0) // SND timeout exceeded
+        {
+            throw CUDTException(MJ_AGAIN, MN_WRAVAIL, 0);
+        }
 
-    vector<Sendstate> sendstates;
+        HLOGC(gslog.Debug, log << "grp/sendBackup: swait exited with " << brdy << " ready sockets:");
 
-    // Ok, we've separated the unstable from sendable just to know if:
-    // - we have any STABLE sendable (if not, we must activate a backup link)
-    // - we have multiple stable sendable and we need to stop all but one
+        // Check if there's anything in the "error" section.
+        // This must be cleared here before the lock on group is set again.
+        // (This loop will not fire neither once if no failed sockets found).
+        for (CEPoll::fmap_t::const_iterator i = sready.begin(); i != sready.end(); ++i)
+        {
+            if (i->second & SRT_EPOLL_ERR)
+            {
+                SRTSOCKET   id = i->first;
+                CUDTSocket* s = m_Global.locateSocket(id, CUDTUnited::ERH_RETURN); // << LOCKS m_GlobControlLock!
+                if (s)
+                {
+                    HLOGC(gslog.Debug,
+                        log << "grp/sendBackup: swait/ex on @" << (id)
+                        << " while waiting for any writable socket - CLOSING");
+                    CUDT::uglobal().close(s); // << LOCKS m_GlobControlLock, then GroupLock!
+                }
+                else
+                {
+                    HLOGC(gslog.Debug, log << "grp/sendBackup: swait/ex on @" << (id) << " - WAS DELETED IN THE MEANTIME");
+                }
 
-    // Normally there should be only one link with state == SRT_GST_RUNNING, but there might
-    // be multiple links set as running when a "breaking suspection" is set on a link.
+                ++ndead;
+            }
+        }
+        HLOGC(gslog.Debug, log << "grp/sendBackup: swait/?close done, re-acquiring GroupLock");
+    }
 
-    bool none_succeeded = true; // be pessimistic
+    // GroupLock is locked back
 
-    // This should be added all sockets that are currently stable
-    // and sending was successful. Later, all but the one with highest
-    // priority should remain active.
-    vector<gli_t> parallel;
+    // Re-check after the waiting lock has been reacquired
+    if (m_bClosing)
+        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
-#if ENABLE_HEAVY_LOGGING
+    if (brdy == -1 || ndead >= nlinks)
     {
-        vector<SRTSOCKET> show_running, show_idle;
-        for (vector<gli_t>::iterator i = sendable.begin(); i != sendable.end(); ++i)
-            show_running.push_back((*i)->id);
-
-        for (vector<gli_t>::iterator i = idlers.begin(); i != idlers.end(); ++i)
-            show_idle.push_back((*i)->id);
-
-        LOGC(gslog.Debug,
-             log << "grp/sendBackup: RUNNING: " << PrintableMod(show_running, "@")
-                 << " IDLE: " << PrintableMod(show_idle, "@"));
+        LOGC(gslog.Error,
+            log << "grp/sendBackup: swait=>" << brdy << " nlinks=" << nlinks << " ndead=" << ndead
+            << " - looxlike all links broken");
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
+        // You can safely throw here - nothing to fill in when all sockets down.
+        // (timeout was reported by exception in the swait call).
+        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
-#endif
 
-    int32_t curseq      = SRT_SEQNO_NONE;
-    size_t  nsuccessful = 0;
+    // Ok, now check if we have at least one write-ready.
+    // Note that the procedure of activation of a new link in case of
+    // no stable links found embraces also rexmit-sending and status
+    // check as well, including blocked status.
 
-    // Collect priorities from sendable links, added only after sending is successful.
-    // This will be used to check if any of the idlers have higher priority
-    // and therefore need to be activated.
-    set<uint16_t> sendable_pri;
+    // Find which one it was. This is so rare case that we can
+    // suffer linear search.
 
-    // We believe that we need to send the payload over every sendable link anyway.
-    for (vector<gli_t>::iterator snd = sendable.begin(); snd != sendable.end(); ++snd)
+    int nwaiting = 0;
+    int nactivated SRT_ATR_UNUSED = 0;
+    int stat = -1;
+    for (gli_t d = m_Group.begin(); d != m_Group.end(); ++d)
     {
-        gli_t d   = *snd;
-        int   erc = 0; // success
-        // Remaining sndstate is SRT_GST_RUNNING. Send a payload through it.
-        CUDT&   u       = d->ps->core();
-        int32_t lastseq = u.schedSeqNo();
+        // We are waiting only for active members
+        if (d->sndstate != SRT_GST_RUNNING)
+        {
+            HLOGC(gslog.Debug,
+                log << "grp/sendBackup: member @" << d->id << " state is not RUNNING - SKIPPING from retry/waiting");
+            continue;
+        }
+        // Skip if not writable in this run
+        if (!CEPoll::isready(sready, d->id, SRT_EPOLL_OUT))
+        {
+            ++nwaiting;
+            HLOGC(gslog.Debug, log << "grp/sendBackup: @" << d->id << " NOT ready:OUT, added as waiting");
+            continue;
+        }
+
         try
         {
-            // This must be wrapped in try-catch because on error it throws an exception.
-            // Possible return values are only 0, in case when len was passed 0, or a positive
-            // >0 value that defines the size of the data that it has sent, that is, in case
-            // of Live mode, equal to 'len'.
-            stat = u.sendmsg2(buf, len, (w_mc));
+            // Note: this will set the currently required packet
+            // because it has been just freshly added to the sender buffer
+            stat = sendBackupRexmit(d->ps->core(), (w_mc));
+            ++nactivated;
         }
         catch (CUDTException& e)
         {
-            cx   = e;
+            // This will be propagated from internal sendmsg2 call,
+            // but that's ok - we want this sending interrupted even in half.
+            w_cx = e;
             stat = -1;
-            erc  = e.getErrorCode();
         }
 
-        bool is_unstable = false;
-        none_succeeded &= sendBackup_CheckSendStatus(d,
-                                                     currtime,
-                                                     stat,
-                                                     erc,
-                                                     lastseq,
-                                                     w_mc.pktseq,
-                                                     (u),
-                                                     (curseq),
-                                                     (parallel),
-                                                     (final_stat),
-                                                     (sendable_pri),
-                                                     (nsuccessful),
-                                                     (is_unstable));
-
-        if (is_unstable && is_zero(u.m_tsUnstableSince)) // Add to unstable only if it wasn't unstable already
-            insert_uniq((unstable), d);
-
-        const Sendstate cstate = {d->id, d, stat, erc};
-        sendstates.push_back(cstate);
-        d->sndresult  = stat;
+        d->sndresult = stat;
         d->laststatus = d->ps->getStatus();
-    }
 
-    // Ok, we have attempted to send a payload over all active links
-    // We know that at least one is successful if we have non-default curmsgno
-    // value.
+        if (stat == -1)
+        {
+            // This link is no longer waiting.
+            continue;
+        }
 
-    // Now we need to check the link that is currently defined as
-    // main active because we can have:
-    // - one active link only - we want to check its status
-    // - two active links - one "main active" and one "temporarily
-    //   activated"
+        w_final_stat = stat;
+        d->sndstate = SRT_GST_RUNNING;
+        w_none_succeeded = false;
+        const steady_clock::time_point currtime = steady_clock::now();
+        sendBackup_AssignBackupState(d->ps->core(), BKUPST_ACTIVE_UNSTABLE_WARY, currtime);
+        w_sendBackupCtx.updateMemberState(&(*d), BKUPST_ACTIVE_UNSTABLE_WARY);
+        HLOGC(gslog.Debug, log << "grp/sendBackup: after waiting, ACTIVATED link @" << d->id);
 
-    // Here the only thing we need to decide about is:
-    // 1. if we have at least one active and STABLE link
-    //   - if there are no stable links, activate one idle link
-    // 2. if we have more than one active and stable link
-    //   - select those with highest priority out of them
-    //   - select the first in order from those
-    //   - silence the rest (turn them idle)
+        break;
+    }
 
-    // In Backup group, we have the following possibilities
-    // - only one link active and stable (normal)
-    // - multiple links active (and possibly one of them stable)
-    //
-    // We might have had a situation that sending was not possible
-    // due to have been blocked.
-    //
-    // If you have any link blocked, treat it as unstable, which
-    // means that one link out of the waiting idle must be activated.
-    //
-    // HOWEVER:
-    //
-    // Collect blocked links in order to make an additional check:
-    //
-    // If all links out of the unstable-running links are blocked,
-    // perform epoll wait on them. In this situation we know that
-    // there are no idle blocked links because IDLE LINK CAN'T BE BLOCKED,
-    // no matter what. It's because the link may only be blocked if
-    // the sender buffer of this socket is full, and it can't be
-    // full if it wasn't used so far.
-    //
-    // This means that in case when we have no stable links, we
-    // need to try out any link that can accept the rexmit-load.
-    // We'll check link stability at the next sending attempt.
+    // If we have no links successfully activated, but at least
+    // one link "not ready for writing", continue waiting for at
+    // least one link ready.
+    if (stat == -1 && nwaiting > 0)
+    {
+        HLOGC(gslog.Debug, log << "grp/sendBackup: still have " << nwaiting << " waiting and none succeeded, REPEAT");
+        goto RetryWaitBlocked;
+    }
+}
 
-    // Here we need to activate one IDLE link, if we have
-    // no stable links.
-    // Some portion of logical exclusions:
-    //
-    // - sockets that were broken in the beginning are already wiped out
-    // - broken sockets are checked first, so they can't be simultaneously idle
-    // - idle sockets can't get broken because there's no operation done on them
-    // - running sockets are the only one that could change sndstate here
-    // - running sockets can either remain running or turn to broken
-    // In short: Running and Broken sockets can't become idle,
-    // although Running sockets can become Broken.
+// [[using locked(this->m_GroupLock)]]
+void CUDTGroup::sendBackup_SilenceRedundantLinks(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime)
+{
+    // The most important principle is to keep the data being sent constantly,
+    // even if it means temporarily full redundancy.
+    // A member can be silenced only if there is at least one stable memebr.
+    const unsigned num_stable = w_sendBackupCtx.countMembersByState(BKUPST_ACTIVE_STABLE);
+    if (num_stable == 0)
+        return;
 
-    // There's no certainty here as to whether at least one link was
-    // running and it has successfully performed the operation.
-    // Might have even happened that we had 2 running links that
-    // got broken and 3 other links so far in idle sndstate that just connected
-    // at that very moment (in Backup group: 1 running stable, 1 running
-    // unstable, 3 links keeping connetion being idle).
+    // INPUT NEEDED:
+    // - stable member with maximum weight
 
-    // In this case we have 3 idle links to activate one of,
-    // but there is no message number base. If so, take the number for
-    // the first activated link as a good deal.
-    //
-    // If it has additionally happened that the first link got broken at
-    // that very moment of sending, the second one has a chance to succeed
-    // and therefore take over the leading role in setting the leading message
-    // number. If the second one fails, too, then the only remaining idle link
-    // will simply go with its own original message number.
-    //
-    // Now we can go to the idle links and attempt to send the payload
-    // also over them.
+    uint16_t max_weight_stable = 0;
+    SRTSOCKET stableSocketId = SRT_INVALID_SOCK; // SocketID of a stable link with higher weight
+    
+    w_sendBackupCtx.sortByWeightAndState();
+    //LOGC(gslog.Debug, log << "grp/silenceRedundant: links after sort: " << w_sendBackupCtx.printMembers());
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
+    {
+        if (!isStateActive(member->state))
+            continue;
 
-    sendBackup_Buffering(buf, len, (curseq), (w_mc));
+        const bool haveHigherWeightStable = stableSocketId != SRT_INVALID_SOCK;
+        const uint16_t weight = member->pSocketData->weight;
 
-    // CHECK: no sendable that exceeds unstable
-    // This embraces the case when there are no sendable at all.
-    // Note that unstable links still count as sendable; they
-    // are simply links that were qualified for sending, but:
-    // - have exceeded response timeout
-    // - have hit EASYNCSND error during sending
-    bool   need_activate = sendable.size() <= unstable.size();
-    string activate_reason;
-    IF_HEAVY_LOGGING(activate_reason = "BY NO REASON???");
-    if (need_activate)
-    {
-        HLOGC(gslog.Debug,
-              log << "grp/sendBackup: all " << sendable.size() << " links unstable - will activate an idle link");
-        IF_HEAVY_LOGGING(activate_reason = "no stable links");
-    }
-    else
-    {
-        // Another reason to activate might be if the link with highest priority
-        // among the idlers has a higher priority than any link currently active
-        // (those are collected in 'sendable_pri'). Check if there are any (if
-        // no sendable, a new link needs to be activated anyway), and if the
-        // priority has a lower number.
-        if (sendable_pri.empty() || (!idlers.empty() && FPriorityOrder::check(idlers[0]->weight, *sendable_pri.begin())))
+        if (member->state == BKUPST_ACTIVE_STABLE)
         {
-            need_activate = true;
-#if ENABLE_HEAVY_LOGGING
-            if (sendable_pri.empty())
-            {
-                activate_reason = "no successful links found";
-                LOGC(gslog.Debug,
-                     log << "grp/sendBackup: no active links were successful - will activate an idle link");
-            }
-            else if (idlers.empty())
+            // silence stable link if it is not the first stable
+            if (!haveHigherWeightStable)
             {
-                // This should be impossible.
-                activate_reason = "WEIRD (no idle links!)";
-                LOGC(gslog.Debug,
-                     log << "grp/sendBackup: BY WEIRD AND IMPOSSIBLE REASON (IPE?) - will activate an idle link");
+                max_weight_stable = (int) weight;
+                stableSocketId = member->socketID;
+                continue;
             }
             else
             {
-                // Only now we are granted that both sendable_pri and idlers are nonempty
-                LOGC(gslog.Debug,
-                     log << "grp/sendBackup: found link pri " << idlers[0]->weight << " PREF OVER " << (*sendable_pri.begin())
-                         << " (highest from sendable) - will activate an idle link");
-                activate_reason = "found higher pri link";
+                LOGC(gslog.Note, log << "grp/sendBackup: silencing stable member @" << member->socketID  << " (weight " << weight
+                    << ") in favor of @" << stableSocketId << " (weight " << max_weight_stable << ")");
             }
-#endif
         }
-        else
+        else if (haveHigherWeightStable && weight <= max_weight_stable)
         {
-            HLOGC(gslog.Debug,
-                  log << "grp/sendBackup: sendable_pri (" << sendable_pri.size() << "): " << Printable(sendable_pri)
-                      << " first idle pri: " << (idlers.size() > 0 ? int(idlers[0]->weight) : -1)
-                      << " - will NOT activate an idle link");
+            LOGC(gslog.Note, log << "grp/sendBackup: silencing member @" << member->socketID << " (weight " << weight
+                << " " << stateToStr(member->state)
+                << ") in favor of @" << stableSocketId << " (weight " << max_weight_stable << ")");
         }
-    }
-
-    if (need_activate)
-    {
-        if (idlers.empty())
+        else
         {
-            HLOGP(gslog.Debug, "grp/sendBackup: no idlers to activate, keeping only unstable links");
+            continue;
         }
-        else
+
+        // TODO: Move to a separate function sendBackup_SilenceMember
+        SocketData* d = member->pSocketData;
+        CUDT& u = d->ps->core();
+
+        sendBackup_AssignBackupState(u, BKUPST_STANDBY, currtime);
+        w_sendBackupCtx.updateMemberState(d, BKUPST_STANDBY);
+
+        if (d->sndstate != SRT_GST_RUNNING)
         {
-            size_t n ATR_UNUSED = sendBackup_CheckNeedActivate(idlers,
-                                     buf,
-                                     len,
-                                     (none_succeeded),
-                                     (w_mc),
-                                     (curseq),
-                                     (final_stat),
-                                     (cx),
-                                     (sendstates),
-                                     (parallel),
-                                     (wipeme),
-                                     activate_reason);
-
-            HLOGC(gslog.Debug, log << "grp/sendBackup: activated " << n << " idle links tried");
+            LOGC(gslog.Error,
+                log << "grp/sendBackup: IPE: misidentified a non-running link @" << d->id << " as active");
+            continue;
         }
+
+        d->sndstate = SRT_GST_IDLE;
     }
-    else
+}
+
+int CUDTGroup::sendBackup(const char* buf, int len, SRT_MSGCTRL& w_mc)
+{
+    if (len <= 0)
     {
-        HLOGC(gslog.Debug,
-              log << "grp/sendBackup: have sendable links, stable=" << (sendable.size() - unstable.size())
-                  << " unstable=" << unstable.size());
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    // Only live streaming is supported
+    if (len > SRT_LIVE_MAX_PLSIZE)
+    {
+        LOGC(gslog.Error, log << "grp/send(backup): buffer size=" << len << " exceeds maximum allowed in live mode");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+    }
+
+    // [[using assert(this->m_pSndBuffer != nullptr)]];
+
+    // First, acquire GlobControlLock to make sure all member sockets still exist
+    enterCS(m_Global.m_GlobControlLock);
+    ScopedLock guard(m_GroupLock);
+
+    if (m_bClosing)
+    {
+        leaveCS(m_Global.m_GlobControlLock);
+        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
-    send_CheckPendingSockets(pending, (wipeme));
+    // Now, still under lock, check if all sockets still can be dispatched
+    send_CheckValidSockets();
+    leaveCS(m_Global.m_GlobControlLock);
+
+    steady_clock::time_point currtime = steady_clock::now();
+
+    SendBackupCtx sendBackupCtx; // default initialized as empty
+    // TODO: reserve? sendBackupCtx.memberStates.reserve(m_Group.size());
+
+    sendBackup_QualifyMemberStates((sendBackupCtx), currtime);
+
+    int32_t curseq      = SRT_SEQNO_NONE;
+    size_t  nsuccessful = 0;
+
+    SRT_ATR_UNUSED CUDTException cx(MJ_SUCCESS, MN_NONE, 0); // TODO: Delete then?
+    uint16_t maxActiveWeight = 0; // Maximum weight of active links.
+    // The number of bytes sent or -1 for error will be stored in group_send_result
+    int group_send_result = sendBackup_SendOverActive(buf, len, w_mc, currtime, (curseq), (nsuccessful), (maxActiveWeight), (sendBackupCtx), (cx));
+    bool none_succeeded = (nsuccessful == 0);
+
+    // Save current payload in group's sender buffer.
+    sendBackup_Buffering(buf, len, (curseq), (w_mc));
+
+    sendBackup_TryActivateStandbyIfNeeded(buf, len, (none_succeeded),
+        (w_mc),
+        (curseq),
+        (group_send_result),
+        (sendBackupCtx),
+        (cx), currtime);
+
+    sendBackup_CheckPendingSockets((sendBackupCtx), currtime);
+    sendBackup_CheckUnstableSockets((sendBackupCtx), currtime);
+
+    //LOGC(gslog.Debug, log << "grp/sendBackup: links after all checks: " << sendBackupCtx.printMembers());
 
     // Re-check after the waiting lock has been reacquired
     if (m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
-    send_CloseBrokenSockets((wipeme));
+    sendBackup_CloseBrokenSockets((sendBackupCtx));
 
     // Re-check after the waiting lock has been reacquired
     if (m_bClosing)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
 
-    sendBackup_CheckParallelLinks(unstable, (parallel), (final_stat), (none_succeeded), (w_mc), (cx));
+    // If all links out of the unstable-running links are blocked (SRT_EASYNCSND),
+    // perform epoll wait on them. In this situation we know that
+    // there are no idle blocked links because IDLE LINK CAN'T BE BLOCKED,
+    // no matter what. It's because the link may only be blocked if
+    // the sender buffer of this socket is full, and it can't be
+    // full if it wasn't used so far.
+    //
+    // This means that in case when we have no stable links, we
+    // need to try out any link that can accept the rexmit-load.
+    // We'll check link stability at the next sending attempt.
+    sendBackup_RetryWaitBlocked((sendBackupCtx), (group_send_result), (none_succeeded), (w_mc), (cx));
+
+    sendBackup_SilenceRedundantLinks((sendBackupCtx), currtime);
     // (closing condition checked inside this call)
 
     if (none_succeeded)
     {
         HLOGC(gslog.Debug, log << "grp/sendBackup: all links broken (none succeeded to send a payload)");
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
         // Reparse error code, if set.
         // It might be set, if the last operation was failed.
         // If any operation succeeded, this will not be executed anyway.
@@ -4130,13 +3722,16 @@ int CUDTGroup::sendBackup(const char* buf, int len, SRT_MSGCTRL& w_mc)
         throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);
     }
 
+    // At least one link has succeeded, update sending stats.
+    m_stats.sent.count(len);
+
     // Now fill in the socket table. Check if the size is enough, if not,
     // then set the pointer to NULL and set the correct size.
 
     // Note that list::size() is linear time, however this shouldn't matter,
     // as with the increased number of links in the redundancy group the
     // impossibility of using that many of them grows exponentally.
-    size_t grpsize = m_Group.size();
+    const size_t grpsize = m_Group.size();
 
     if (w_mc.grpdata_size < grpsize)
     {
@@ -4163,19 +3758,19 @@ int CUDTGroup::sendBackup(const char* buf, int len, SRT_MSGCTRL& w_mc)
         // is performed, and this one will result in none-write-ready, this will
         // be fixed just after returning from this function.
 
-        ready_again = ready_again | d->ps->writeReady();
+        ready_again = ready_again || d->ps->writeReady();
     }
     w_mc.grpdata_size = i;
 
     if (!ready_again)
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, false);
     }
 
     HLOGC(gslog.Debug,
-          log << "grp/sendBackup: successfully sent " << final_stat << " bytes, "
+          log << "grp/sendBackup: successfully sent " << group_send_result << " bytes, "
               << (ready_again ? "READY for next" : "NOT READY to send next"));
-    return final_stat;
+    return group_send_result;
 }
 
 // [[using locked(this->m_GroupLock)]]
@@ -4186,6 +3781,7 @@ int32_t CUDTGroup::addMessageToBuffer(const char* buf, size_t len, SRT_MSGCTRL&
         // Very first packet, just set the msgno.
         m_iSndAckedMsgNo  = w_mc.msgno;
         m_iSndOldestMsgNo = w_mc.msgno;
+        HLOGC(gslog.Debug, log << "addMessageToBuffer: initial message no #" << w_mc.msgno);
     }
     else if (m_iSndOldestMsgNo != m_iSndAckedMsgNo)
     {
@@ -4211,6 +3807,8 @@ int32_t CUDTGroup::addMessageToBuffer(const char* buf, size_t len, SRT_MSGCTRL&
 
         // Position at offset is not included
         m_iSndOldestMsgNo = m_iSndAckedMsgNo;
+        HLOGC(gslog.Debug,
+              log << "addMessageToBuffer: ... after: oldest #" << m_iSndOldestMsgNo);
     }
 
     m_SenderBuffer.resize(m_SenderBuffer.size() + 1);
@@ -4224,6 +3822,75 @@ int32_t CUDTGroup::addMessageToBuffer(const char* buf, size_t len, SRT_MSGCTRL&
     return m_SenderBuffer.front().mc.pktseq;
 }
 
+int CUDTGroup::sendBackup_SendOverActive(const char* buf, int len, SRT_MSGCTRL& w_mc, const steady_clock::time_point& currtime, int32_t& w_curseq,
+    size_t& w_nsuccessful, uint16_t& w_maxActiveWeight, SendBackupCtx& w_sendBackupCtx, CUDTException& w_cx)
+{
+    if (w_mc.srctime == 0)
+        w_mc.srctime = count_microseconds(currtime.time_since_epoch());
+
+    SRT_ASSERT(w_nsuccessful == 0);
+    SRT_ASSERT(w_maxActiveWeight == 0);
+
+    int group_send_result = SRT_ERROR;
+
+    // TODO: implement iterator over active links
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t member = w_sendBackupCtx.memberStates().begin(); member != w_sendBackupCtx.memberStates().end(); ++member)
+    {
+        if (!isStateActive(member->state))
+            continue;
+
+        SocketData* d = member->pSocketData;
+        int   erc = SRT_SUCCESS;
+        // Remaining sndstate is SRT_GST_RUNNING. Send a payload through it.
+        CUDT& u = d->ps->core();
+        const int32_t lastseq = u.schedSeqNo();
+        int sndresult = SRT_ERROR;
+        try
+        {
+            // This must be wrapped in try-catch because on error it throws an exception.
+            // Possible return values are only 0, in case when len was passed 0, or a positive
+            // >0 value that defines the size of the data that it has sent, that is, in case
+            // of Live mode, equal to 'len'.
+            sndresult = u.sendmsg2(buf, len, (w_mc));
+        }
+        catch (CUDTException& e)
+        {
+            w_cx = e;
+            erc  = e.getErrorCode();
+            sndresult = SRT_ERROR;
+        }
+
+        const bool send_succeeded = sendBackup_CheckSendStatus(
+            currtime,
+            sndresult,
+            lastseq,
+            w_mc.pktseq,
+            (u),
+            (w_curseq),
+            (group_send_result));
+
+        if (send_succeeded)
+        {
+            ++w_nsuccessful;
+            w_maxActiveWeight = max(w_maxActiveWeight, d->weight);
+
+            if (u.m_pSndBuffer)
+                w_sendBackupCtx.setRateEstimate(u.m_pSndBuffer->getRateEstimator());
+        }
+        else if (erc == SRT_EASYNCSND)
+        {
+            sendBackup_AssignBackupState(u, BKUPST_ACTIVE_UNSTABLE, currtime);
+            w_sendBackupCtx.updateMemberState(d, BKUPST_ACTIVE_UNSTABLE);
+        }
+
+        d->sndresult  = sndresult;
+        d->laststatus = d->ps->getStatus();
+    }
+
+    return group_send_result;
+}
+
 // [[using locked(this->m_GroupLock)]]
 int CUDTGroup::sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc)
 {
@@ -4253,7 +3920,7 @@ int CUDTGroup::sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc)
     size_t  skip_initial = 0;
     if (curseq != core.schedSeqNo())
     {
-        int distance = CSeqNo::seqoff(core.schedSeqNo(), curseq);
+        const int distance = CSeqNo::seqoff(core.schedSeqNo(), curseq);
         if (distance < 0)
         {
             // This may happen in case when the link to be activated is already running.
@@ -4262,8 +3929,8 @@ int CUDTGroup::sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc)
             // packets that are in the past towards the scheduling sequence.
             skip_initial = -distance;
             LOGC(gslog.Warn,
-                 log << "sendBackupRexmit: OVERRIDE attempt to %" << core.schedSeqNo() << " from BACKWARD %" << curseq
-                     << " - DENIED; skip " << skip_initial << " packets");
+                 log << "sendBackupRexmit: OVERRIDE attempt. Link seqno %" << core.schedSeqNo() << ", trying to send from seqno %" << curseq
+                     << " - DENIED; skip " << skip_initial << " pkts, " << m_SenderBuffer.size() << " pkts in buffer");
         }
         else
         {
@@ -4273,26 +3940,30 @@ int CUDTGroup::sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc)
             // sequences already used by the link from which packets were
             // copied to the backup buffer.
             IF_HEAVY_LOGGING(int32_t old = core.schedSeqNo());
-            const bool su ATR_UNUSED = core.overrideSndSeqNo(curseq);
+            const bool su SRT_ATR_UNUSED = core.overrideSndSeqNo(curseq);
             HLOGC(gslog.Debug,
                   log << "sendBackupRexmit: OVERRIDING seq %" << old << " with %" << curseq
                       << (su ? " - succeeded" : " - FAILED!"));
         }
     }
 
-    senderBuffer_t::iterator i = m_SenderBuffer.begin();
 
     if (skip_initial >= m_SenderBuffer.size())
+    {
+        LOGC(gslog.Warn,
+            log << "sendBackupRexmit: All packets were skipped. Nothing to send %" << core.schedSeqNo() << ", trying to send from seqno %" << curseq
+            << " - DENIED; skip " << skip_initial << " packets");
         return 0; // can't return any other state, nothing was sent
-    else if (skip_initial)
-        i += skip_initial;
+    }
+
+    senderBuffer_t::iterator i = m_SenderBuffer.begin() + skip_initial;
 
     // Send everything - including the packet freshly added to the buffer
     for (; i != m_SenderBuffer.end(); ++i)
     {
         // NOTE: an exception from here will interrupt the loop
         // and will be caught in the upper level.
-        stat = core.sendmsg2(i->data, i->size, (i->mc));
+        stat = core.sendmsg2(i->data, (int)i->size, (i->mc));
         if (stat == -1)
         {
             // Stop sending if one sending ended up with error
@@ -4308,6 +3979,7 @@ int CUDTGroup::sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc)
     return stat;
 }
 
+// [[using locked(CUDTGroup::m_GroupLock)]];
 void CUDTGroup::ackMessage(int32_t msgno)
 {
     // The message id could not be identified, skip.
@@ -4342,7 +4014,7 @@ void CUDTGroup::ackMessage(int32_t msgno)
     m_iSndAckedMsgNo = msgno;
 }
 
-void CUDTGroup::handleKeepalive(gli_t gli)
+void CUDTGroup::processKeepalive(CUDTGroup::SocketData* gli)
 {
     // received keepalive for that group member
     // In backup group it means that the link went IDLE.
@@ -4370,7 +4042,7 @@ void CUDTGroup::handleKeepalive(gli_t gli)
         // which may result not only with exceeded stability timeout (which fortunately
         // isn't being measured in this case), but also with receiveing keepalive
         // (therefore we also don't reset the link to IDLE in the temporary activation period).
-        if (gli->sndstate == SRT_GST_RUNNING && is_zero(gli->ps->core().m_tsTmpActiveTime))
+        if (gli->sndstate == SRT_GST_RUNNING && is_zero(gli->ps->core().m_tsFreshActivation))
         {
             gli->sndstate = SRT_GST_IDLE;
             HLOGC(gslog.Debug,
@@ -4379,7 +4051,7 @@ void CUDTGroup::handleKeepalive(gli_t gli)
     }
 }
 
-void CUDTGroup::internalKeepalive(gli_t gli)
+void CUDTGroup::internalKeepalive(SocketData* gli)
 {
     // This is in response to AGENT SENDING keepalive. This means that there's
     // no transmission in either direction, but the KEEPALIVE packet from the
@@ -4390,53 +4062,13 @@ void CUDTGroup::internalKeepalive(gli_t gli)
     {
         gli->rcvstate = SRT_GST_IDLE;
         // Prevent sending KEEPALIVE again in group-sending
-        gli->ps->core().m_tsTmpActiveTime = steady_clock::time_point();
+        gli->ps->core().m_tsFreshActivation = steady_clock::time_point();
         HLOGC(gslog.Debug, log << "GROUP: EXP-requested KEEPALIVE in @" << gli->id << " - link turning IDLE");
     }
 }
 
 CUDTGroup::BufferedMessageStorage CUDTGroup::BufferedMessage::storage(SRT_LIVE_MAX_PLSIZE /*, 1000*/);
 
-int CUDTGroup::configure(const char* str)
-{
-    string config = str;
-    switch (type())
-    {
-        /* TMP review stub case SRT_GTYPE_BALANCING:
-            // config contains the algorithm name
-            if (config == "" || config == "auto")
-            {
-                m_cbSelectLink.set(this, &CUDTGroup::linkSelect_window_fw);
-                HLOGC(gmlog.Debug, log << "group(balancing): WINDOW algorithm selected");
-            }
-            else if (config == "fixed")
-            {
-                m_cbSelectLink.set(this, &CUDTGroup::linkSelect_fixed_fw);
-                HLOGC(gmlog.Debug, log << "group(balancing): FIXED algorithm selected");
-            }
-            else
-            {
-                LOGC(gmlog.Error, log << "group(balancing): unknown selection algorithm '"
-                        << config << "'");
-                return CUDT::APIError(MJ_NOTSUP, MN_INVAL, 0);
-            }
-
-            break;*/
-
-    default:
-        if (config == "")
-        {
-            // You can always call the config with empty string,
-            // it should set defaults or do nothing, if not supported.
-            return 0;
-        }
-        LOGC(gmlog.Error, log << "this group type doesn't support any configuration");
-        return CUDT::APIError(MJ_NOTSUP, MN_INVAL, 0);
-    }
-
-    return 0;
-}
-
 // Forwarder needed due to class definition order
 int32_t CUDTGroup::generateISN()
 {
@@ -4448,7 +4080,7 @@ void CUDTGroup::setGroupConnected()
     if (!m_bConnected)
     {
         // Switch to connected state and give appropriate signal
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_CONNECT, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_CONNECT, true);
         m_bConnected = true;
     }
 }
@@ -4461,25 +4093,25 @@ void CUDTGroup::updateLatestRcv(CUDTSocket* s)
 
     HLOGC(grlog.Debug,
           log << "updateLatestRcv: BACKUP group, updating from active link @" << s->m_SocketID << " with %"
-              << s->m_pUDT->m_iRcvLastSkipAck);
+              << s->core().m_iRcvLastAck);
 
-    CUDT*         source = s->m_pUDT;
+    CUDT*         source = &s->core();
     vector<CUDT*> targets;
 
     UniqueLock lg(m_GroupLock);
     // Sanity check for a case when getting a deleted socket
-    if (!s->m_IncludedGroup)
+    if (!s->m_GroupOf)
         return;
 
     // Under a group lock, we block execution of removal of the socket
-    // from the group, so if m_IncludedGroup is not NULL, we are granted
-    // that m_IncludedIter is valid.
-    gli_t current = s->m_IncludedIter;
+    // from the group, so if m_GroupOf is not NULL, we are granted
+    // that m_GroupMemberData is valid.
+    SocketData* current = s->m_GroupMemberData;
 
     for (gli_t gi = m_Group.begin(); gi != m_Group.end(); ++gi)
     {
         // Skip the socket that has reported packet reception
-        if (gi == current)
+        if (&*gi == current)
         {
             HLOGC(grlog.Debug, log << "grp: NOT updating rcv-seq on self @" << gi->id);
             continue;
@@ -4498,13 +4130,13 @@ void CUDTGroup::updateLatestRcv(CUDTSocket* s)
         }
 
         // Sanity check
-        if (!gi->ps->m_pUDT->m_bConnected)
+        if (!gi->ps->core().m_bConnected)
         {
             HLOGC(grlog.Debug, log << "grp: IPE: NOT updating rcv-seq on @" << gi->id << " - IDLE BUT NOT CONNECTED");
             continue;
         }
 
-        targets.push_back(gi->ps->m_pUDT);
+        targets.push_back(&gi->ps->core());
     }
 
     lg.unlock();
@@ -4525,19 +4157,19 @@ void CUDTGroup::activateUpdateEvent(bool still_have_items)
     // was deleted from the group. This might make the group empty.
     if (!still_have_items) // empty, or removal of unknown socket attempted - set error on group
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
     }
     else
     {
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_UPDATE, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_UPDATE, true);
     }
 }
 
 void CUDTGroup::addEPoll(int eid)
 {
-    enterCS(m_pGlobal->m_EPoll.m_EPollLock);
+    enterCS(m_Global.m_EPoll.m_EPollLock);
     m_sPollID.insert(eid);
-    leaveCS(m_pGlobal->m_EPoll.m_EPollLock);
+    leaveCS(m_Global.m_EPoll.m_EPollLock);
 
     bool any_read    = false;
     bool any_write   = false;
@@ -4575,14 +4207,14 @@ void CUDTGroup::addEPoll(int eid)
     // because we know it is, as we just added it. But it's not performance
     // critical, sockets are not being often added during transmission.
     if (any_read)
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN, true);
 
     if (any_write)
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_OUT, true);
 
     // Set broken if none is non-broken (pending, read-ready or write-ready)
     if (any_broken && !any_pending)
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_ERR, true);
 }
 
 void CUDTGroup::removeEPollEvents(const int eid)
@@ -4591,14 +4223,14 @@ void CUDTGroup::removeEPollEvents(const int eid)
     // since this happens after the epoll ID has been removed, they cannot be set again
     set<int> remove;
     remove.insert(eid);
-    m_pGlobal->m_EPoll.update_events(id(), remove, SRT_EPOLL_IN | SRT_EPOLL_OUT, false);
+    m_Global.m_EPoll.update_events(id(), remove, SRT_EPOLL_IN | SRT_EPOLL_OUT, false);
 }
 
 void CUDTGroup::removeEPollID(const int eid)
 {
-    enterCS(m_pGlobal->m_EPoll.m_EPollLock);
+    enterCS(m_Global.m_EPoll.m_EPollLock);
     m_sPollID.erase(eid);
-    leaveCS(m_pGlobal->m_EPoll.m_EPollLock);
+    leaveCS(m_Global.m_EPoll.m_EPollLock);
 }
 
 void CUDTGroup::updateFailedLink()
@@ -4620,7 +4252,7 @@ void CUDTGroup::updateFailedLink()
     {
         // No healthy links, set ERR on epoll.
         HLOGC(gmlog.Debug, log << "group/updateFailedLink: All sockets broken");
-        m_pGlobal->m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
+        m_Global.m_EPoll.update_events(id(), m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
     }
     else
     {
@@ -4629,7 +4261,7 @@ void CUDTGroup::updateFailedLink()
 }
 
 #if ENABLE_HEAVY_LOGGING
-// [[using maybe_locked(CUDT::s_UDTUnited.m_GlobControlLock)]]
+// [[using maybe_locked(CUDT::uglobal()->m_GlobControlLock)]]
 void CUDTGroup::debugGroup()
 {
     ScopedLock gg(m_GroupLock);
@@ -4645,3 +4277,5 @@ void CUDTGroup::debugGroup()
     }
 }
 #endif
+
+} // namespace srt
diff --git a/srtcore/group.h b/srtcore/group.h
index 75d58eac6..56f1456f8 100644
--- a/srtcore/group.h
+++ b/srtcore/group.h
@@ -19,18 +19,27 @@ Written by
 #include "srt.h"
 #include "common.h"
 #include "packet.h"
+#include "group_common.h"
+#include "group_backup.h"
+
+namespace srt
+{
 
 #if ENABLE_HEAVY_LOGGING
 const char* const srt_log_grp_state[] = {"PENDING", "IDLE", "RUNNING", "BROKEN"};
 #endif
 
+
 class CUDTGroup
 {
     friend class CUDTUnited;
 
-    typedef srt::sync::steady_clock::time_point time_point;
-    typedef srt::sync::steady_clock::duration   duration;
-    typedef srt::sync::steady_clock             steady_clock;
+    typedef sync::steady_clock::time_point time_point;
+    typedef sync::steady_clock::duration   duration;
+    typedef sync::steady_clock             steady_clock;
+    typedef groups::SocketData SocketData;
+    typedef groups::SendBackupCtx SendBackupCtx;
+    typedef groups::BackupMemberState BackupMemberState;
 
 public:
     typedef SRT_MEMBERSTATUS GroupState;
@@ -57,26 +66,6 @@ class CUDTGroup
     static int32_t s_tokenGen;
     static int32_t genToken() { ++s_tokenGen; if (s_tokenGen < 0) s_tokenGen = 0; return s_tokenGen;}
 
-    struct SocketData
-    {
-        SRTSOCKET      id;
-        CUDTSocket*    ps;
-        int            token;
-        SRT_SOCKSTATUS laststatus;
-        GroupState     sndstate;
-        GroupState     rcvstate;
-        int            sndresult;
-        int            rcvresult;
-        sockaddr_any   agent;
-        sockaddr_any   peer;
-        bool           ready_read;
-        bool           ready_write;
-        bool           ready_error;
-
-        // Configuration
-        uint16_t weight;
-    };
-
     struct ConfigItem
     {
         SRT_SOCKOPT                so;
@@ -112,12 +101,12 @@ class CUDTGroup
 
     typedef std::list<SocketData> group_t;
     typedef group_t::iterator     gli_t;
-    typedef std::vector< std::pair<SRTSOCKET, CUDTSocket*> > sendable_t;
+    typedef std::vector< std::pair<SRTSOCKET, srt::CUDTSocket*> > sendable_t;
 
     struct Sendstate
     {
         SRTSOCKET id;
-        gli_t     it;
+        SocketData* mb;
         int   stat;
         int   code;
     };
@@ -125,9 +114,7 @@ class CUDTGroup
     CUDTGroup(SRT_GROUP_TYPE);
     ~CUDTGroup();
 
-    static SocketData prepareData(CUDTSocket* s);
-
-    gli_t add(SocketData data);
+    SocketData* add(SocketData data);
 
     struct HaveID
     {
@@ -139,15 +126,17 @@ class CUDTGroup
         bool operator()(const SocketData& s) { return s.id == id; }
     };
 
-    gli_t find(SRTSOCKET id)
+    bool contains(SRTSOCKET id, SocketData*& w_f)
     {
         srt::sync::ScopedLock g(m_GroupLock);
-        gli_t                 f = std::find_if(m_Group.begin(), m_Group.end(), HaveID(id));
+        gli_t f = std::find_if(m_Group.begin(), m_Group.end(), HaveID(id));
         if (f == m_Group.end())
         {
-            return gli_NULL();
+            w_f = NULL;
+            return false;
         }
-        return f;
+        w_f = &*f;
+        return true;
     }
 
     // NEED LOCKING
@@ -156,7 +145,7 @@ class CUDTGroup
 
     /// Remove the socket from the group container.
     /// REMEMBER: the group spec should be taken from the socket
-    /// (set m_IncludedGroup to NULL and m_IncludedIter to grp->gli_NULL())
+    /// (set m_GroupOf and m_GroupMemberData to NULL
     /// PRIOR TO calling this function.
     /// @param id Socket ID to look for in the container to remove
     /// @return true if the container still contains any sockets after the operation
@@ -166,7 +155,7 @@ class CUDTGroup
         srt::sync::ScopedLock g(m_GroupLock);
 
         bool empty = false;
-        HLOGC(gmlog.Debug, log << "group/remove: going to remove @" << id << " from $" << m_GroupID);
+        LOGC(gmlog.Note, log << "group/remove: removing member @" << id << " from group $" << m_GroupID);
 
         gli_t f = std::find_if(m_Group.begin(), m_Group.end(), HaveID(id));
         if (f != m_Group.end())
@@ -205,9 +194,6 @@ class CUDTGroup
             m_bConnected = false;
         }
 
-        // XXX BUGFIX
-        m_Positions.erase(id);
-
         return !empty;
     }
 
@@ -219,8 +205,6 @@ class CUDTGroup
 
     void setGroupConnected();
 
-    static gli_t gli_NULL() { return GroupContainer::null(); }
-
     int            send(const char* buf, int len, SRT_MSGCTRL& w_mc);
     int            sendBroadcast(const char* buf, int len, SRT_MSGCTRL& w_mc);
     int            sendBackup(const char* buf, int len, SRT_MSGCTRL& w_mc);
@@ -228,49 +212,109 @@ class CUDTGroup
 
 private:
     // For Backup, sending all previous packet
-    int sendBackupRexmit(CUDT& core, SRT_MSGCTRL& w_mc);
+    int sendBackupRexmit(srt::CUDT& core, SRT_MSGCTRL& w_mc);
 
     // Support functions for sendBackup and sendBroadcast
-    bool send_CheckIdle(const gli_t d, std::vector<SRTSOCKET>& w_wipeme, std::vector<SRTSOCKET>& w_pending);
+    /// Check if group member is idle.
+    /// @param d group member
+    /// @param[in,out] w_wipeme array of sockets to remove from group
+    /// @param[in,out] w_pendingLinks array of sockets pending for connection
+    /// @returns true if d is idle (standby), false otherwise
+    bool send_CheckIdle(const gli_t d, std::vector<SRTSOCKET>& w_wipeme, std::vector<SRTSOCKET>& w_pendingLinks);
+
+
+    /// This function checks if the member has just become idle (check if sender buffer is empty) to send a KEEPALIVE immidiatelly.
+    /// @todo Check it is some abandoned logic.
     void sendBackup_CheckIdleTime(gli_t w_d);
-    bool sendBackup_CheckRunningStability(const gli_t d, const time_point currtime);
-    bool sendBackup_CheckSendStatus(const gli_t         d,
-                                    const time_point&   currtime,
-                                    const int           stat,
-                                    const int           erc,
+    
+    /// Qualify states of member links.
+    /// [[using locked(this->m_GroupLock, m_pGlobal->m_GlobControlLock)]]
+    /// @param[out] w_sendBackupCtx  the context will be updated with state qualifications
+    /// @param[in] currtime          current timestamp
+    void sendBackup_QualifyMemberStates(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime);
+
+    void sendBackup_AssignBackupState(srt::CUDT& socket, BackupMemberState state, const steady_clock::time_point& currtime);
+
+    /// Qualify the state of the active link: fresh, stable, unstable, wary.
+    /// @retval active backup member state: fresh, stable, unstable, wary.
+    BackupMemberState sendBackup_QualifyActiveState(const gli_t d, const time_point currtime);
+
+    BackupMemberState sendBackup_QualifyIfStandBy(const gli_t d);
+
+    /// Sends the same payload over all active members.
+    /// @param[in] buf payload
+    /// @param[in] len payload length in bytes
+    /// @param[in,out] w_mc message control
+    /// @param[in] currtime current time
+    /// @param[in] currseq current packet sequence number
+    /// @param[out] w_nsuccessful number of members with successfull sending.
+    /// @param[in,out] maxActiveWeight
+    /// @param[in,out] sendBackupCtx context
+    /// @param[in,out] w_cx error
+    /// @return group send result: -1 if sending over all members has failed; number of bytes sent overwise.
+    int sendBackup_SendOverActive(const char* buf, int len, SRT_MSGCTRL& w_mc, const steady_clock::time_point& currtime, int32_t& w_curseq,
+        size_t& w_nsuccessful, uint16_t& w_maxActiveWeight, SendBackupCtx& w_sendBackupCtx, CUDTException& w_cx);
+    
+    /// Check link sending status
+    /// @param[in]  currtime       Current time (logging only)
+    /// @param[in]  send_status    Result of sending over the socket
+    /// @param[in]  lastseq        Last sent sequence number before the current sending operation
+    /// @param[in]  pktseq         Packet sequence number currently tried to be sent
+    /// @param[out] w_u            CUDT unit of the current member (to allow calling overrideSndSeqNo)
+    /// @param[out] w_curseq       Group's current sequence number (either -1 or the value used already for other links)
+    /// @param[out] w_final_stat   w_final_stat = send_status if sending succeeded.
+    ///
+    /// @returns true if the sending operation result (submitted in stat) is a success, false otherwise.
+    bool sendBackup_CheckSendStatus(const time_point&   currtime,
+                                    const int           send_status,
                                     const int32_t       lastseq,
                                     const int32_t       pktseq,
                                     CUDT&               w_u,
                                     int32_t&            w_curseq,
-                                    std::vector<gli_t>& w_parallel,
-                                    int&                w_final_stat,
-                                    std::set<uint16_t>& w_sendable_pri,
-                                    size_t&             w_nsuccessful,
-                                    bool&               w_is_unstable);
+                                    int&                w_final_stat);
     void sendBackup_Buffering(const char* buf, const int len, int32_t& curseq, SRT_MSGCTRL& w_mc);
-    size_t sendBackup_CheckNeedActivate(const std::vector<gli_t>& idlers,
-                                      const char*               buf,
-                                      const int                 len,
-                                      bool&                     w_none_succeeded,
-                                      SRT_MSGCTRL&              w_mc,
-                                      int32_t&                  w_curseq,
-                                      int32_t&                  w_final_stat,
-                                      CUDTException&            w_cx,
-                                      std::vector<Sendstate>&   w_sendstates,
-                                      std::vector<gli_t>&       w_parallel,
-                                      std::vector<SRTSOCKET>&   w_wipeme,
-                                      const std::string&        activate_reason);
-    void send_CheckPendingSockets(const std::vector<SRTSOCKET>& pending, std::vector<SRTSOCKET>& w_wipeme);
+
+    size_t sendBackup_TryActivateStandbyIfNeeded(
+        const char* buf,
+        const int   len,
+        bool& w_none_succeeded,
+        SRT_MSGCTRL& w_mc,
+        int32_t& w_curseq,
+        int32_t& w_final_stat,
+        SendBackupCtx& w_sendBackupCtx,
+        CUDTException& w_cx,
+        const steady_clock::time_point& currtime);
+
+    /// Check if pending sockets are to be qualified as broken.
+    /// This qualification later results in removing the socket from a group and closing it.
+    /// @param[in,out]  a context with a list of member sockets, some pending might qualified broken
+    void sendBackup_CheckPendingSockets(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime);
+
+    /// Check if unstable sockets are to be qualified as broken.
+    /// The main reason for such qualification is if a socket is unstable for too long.
+    /// This qualification later results in removing the socket from a group and closing it.
+    /// @param[in,out]  a context with a list of member sockets, some pending might qualified broken
+    void sendBackup_CheckUnstableSockets(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime);
+
+    /// @brief Marks broken sockets as closed. Used in broadcast sending.
+    /// @param w_wipeme a list of sockets to close
     void send_CloseBrokenSockets(std::vector<SRTSOCKET>& w_wipeme);
-    void sendBackup_CheckParallelLinks(const std::vector<gli_t>& unstable,
-                                       std::vector<gli_t>&       w_parallel,
-                                       int&                      w_final_stat,
-                                       bool&                     w_none_succeeded,
-                                       SRT_MSGCTRL&              w_mc,
-                                       CUDTException&            w_cx);
+
+    /// @brief Marks broken sockets as closed. Used in backup sending.
+    /// @param w_sendBackupCtx the context with a list of broken sockets
+    void sendBackup_CloseBrokenSockets(SendBackupCtx& w_sendBackupCtx);
+
+    void sendBackup_RetryWaitBlocked(SendBackupCtx& w_sendBackupCtx,
+                                     int&                      w_final_stat,
+                                     bool&                     w_none_succeeded,
+                                     SRT_MSGCTRL&              w_mc,
+                                     CUDTException&            w_cx);
+    void sendBackup_SilenceRedundantLinks(SendBackupCtx& w_sendBackupCtx, const steady_clock::time_point& currtime);
 
     void send_CheckValidSockets();
 
+    SRT_KM_STATE getGroupEncryptionState();
+
 public:
     int recv(char* buf, int len, SRT_MSGCTRL& w_mc);
 
@@ -278,7 +322,7 @@ class CUDTGroup
 
     void setOpt(SRT_SOCKOPT optname, const void* optval, int optlen);
     void getOpt(SRT_SOCKOPT optName, void* optval, int& w_optlen);
-    void deriveSettings(CUDT* source);
+    void deriveSettings(srt::CUDT* source);
     bool applyFlags(uint32_t flags, HandshakeSide);
 
     SRT_SOCKSTATUS getStatus();
@@ -292,14 +336,20 @@ class CUDTGroup
         return m_type == SRT_GTYPE_BROADCAST;
     }
 
-    srt::sync::Mutex* exp_groupLock() { return &m_GroupLock; }
-    void              addEPoll(int eid);
-    void              removeEPollEvents(const int eid);
-    void              removeEPollID(const int eid);
-    void              updateReadState(SRTSOCKET sock, int32_t sequence);
-    void              updateWriteState();
-    void              updateFailedLink();
-    void              activateUpdateEvent(bool still_have_items);
+    sync::Mutex* exp_groupLock() { return &m_GroupLock; }
+    void         addEPoll(int eid);
+    void         removeEPollEvents(const int eid);
+    void         removeEPollID(const int eid);
+
+    /// @brief Update read-ready state.
+    /// @param sock member socket ID (unused)
+    /// @param sequence the latest packet sequence number available for reading.
+    void         updateReadState(SRTSOCKET sock, int32_t sequence);
+
+    void         updateWriteState();
+    void         updateFailedLink();
+    void         activateUpdateEvent(bool still_have_items);
+    int32_t      getRcvBaseSeqNo();
 
     /// Update the in-group array of packet providers per sequence number.
     /// Also basing on the information already provided by possibly other sockets,
@@ -312,19 +362,18 @@ class CUDTGroup
     /// @param provider The core of the socket for which the packet was dispatched
     /// @param time TSBPD time of this packet
     /// @return The bitmap that marks by 'false' packets lost since next to exp_sequence
-    std::vector<bool> providePacket(int32_t exp_sequence, int32_t sequence, CUDT* provider, uint64_t time);
+    std::vector<bool> providePacket(int32_t exp_sequence, int32_t sequence, srt::CUDT* provider, uint64_t time);
 
     /// This is called from the ACK action by particular socket, which
     /// actually signs off the packet for extraction.
     ///
     /// @param core The socket core for which the ACK was sent
     /// @param ack The past-the-last-received ACK sequence number
-    void readyPackets(CUDT* core, int32_t ack);
+    void readyPackets(srt::CUDT* core, int32_t ack);
 
-    void syncWithSocket(const CUDT& core, const HandshakeSide side);
+    void syncWithSocket(const srt::CUDT& core, const HandshakeSide side);
     int  getGroupData(SRT_SOCKGROUPDATA* pdata, size_t* psize);
     int  getGroupData_LOCKED(SRT_SOCKGROUPDATA* pdata, size_t* psize);
-    int  configure(const char* str);
 
     /// Predicted to be called from the reading function to fill
     /// the group data array as requested.
@@ -341,23 +390,24 @@ class CUDTGroup
 #endif
 
     void ackMessage(int32_t msgno);
-    void handleKeepalive(gli_t);
-    void internalKeepalive(gli_t);
+    void processKeepalive(SocketData*);
+    void internalKeepalive(SocketData*);
 
 private:
     // Check if there's at least one connected socket.
     // If so, grab the status of all member sockets.
     void getGroupCount(size_t& w_size, bool& w_still_alive);
 
-    class CUDTUnited* m_pGlobal;
+    srt::CUDTUnited&  m_Global;
     srt::sync::Mutex  m_GroupLock;
 
     SRTSOCKET m_GroupID;
     SRTSOCKET m_PeerGroupID;
     struct GroupContainer
     {
-        std::list<SocketData>        m_List;
-        static std::list<SocketData> s_NoList; // This is to have a predictable "null iterator".
+    private:
+        std::list<SocketData>  m_List;
+        sync::atomic<size_t>   m_SizeCache;
 
         /// This field is used only by some types of groups that need
         /// to keep track as to which link was lately used. Note that
@@ -365,8 +415,11 @@ class CUDTGroup
         /// must be appropriately reset.
         gli_t m_LastActiveLink;
 
+    public:
+
         GroupContainer()
-            : m_LastActiveLink(s_NoList.begin())
+            : m_SizeCache(0)
+            , m_LastActiveLink(m_List.end())
         {
         }
 
@@ -375,24 +428,22 @@ class CUDTGroup
 
         gli_t        begin() { return m_List.begin(); }
         gli_t        end() { return m_List.end(); }
-        static gli_t null() { return s_NoList.begin(); }
         bool         empty() { return m_List.empty(); }
-        void         push_back(const SocketData& data) { m_List.push_back(data); }
+        void         push_back(const SocketData& data) { m_List.push_back(data); ++m_SizeCache; }
         void         clear()
         {
-            m_LastActiveLink = null();
+            m_LastActiveLink = end();
             m_List.clear();
+            m_SizeCache = 0;
         }
-        size_t size() { return m_List.size(); }
+        size_t size() { return m_SizeCache; }
 
         void erase(gli_t it);
     };
     GroupContainer m_Group;
-    bool           m_selfManaged;
-    bool           m_bSyncOnMsgNo;
     SRT_GROUP_TYPE m_type;
     CUDTSocket*    m_listener; // A "group" can only have one listener.
-    int            m_iBusy;
+    srt::sync::atomic<int> m_iBusy;
     CallbackHolder<srt_connect_callback_fn> m_cbConnectHook;
     void installConnectHook(srt_connect_callback_fn* hook, void* opaq)
     {
@@ -454,7 +505,7 @@ class CUDTGroup
 
     bool isStillBusy()
     {
-        srt::sync::ScopedLock glk(m_GroupLock);
+        sync::ScopedLock glk(m_GroupLock);
         return m_iBusy || !m_Group.empty();
     }
 
@@ -562,10 +613,10 @@ class CUDTGroup
 
 private:
     // Fields required for SRT_GTYPE_BACKUP groups.
-    senderBuffer_t   m_SenderBuffer;
-    int32_t          m_iSndOldestMsgNo; // oldest position in the sender buffer
-    volatile int32_t m_iSndAckedMsgNo;
-    uint32_t         m_uOPT_StabilityTimeout;
+    senderBuffer_t        m_SenderBuffer; // This mechanism is to be removed on group-common sndbuf
+    int32_t               m_iSndOldestMsgNo; // oldest position in the sender buffer
+    sync::atomic<int32_t> m_iSndAckedMsgNo;
+    uint32_t              m_uOPT_MinStabilityTimeout_us;
 
     // THIS function must be called only in a function for a group type
     // that does use sender buffer.
@@ -580,9 +631,9 @@ class CUDTGroup
     bool               m_bTLPktDrop;
     int64_t            m_iTsbPdDelay_us;
     int                m_RcvEID;
-    struct CEPollDesc* m_RcvEpolld;
+    class CEPollDesc*  m_RcvEpolld;
     int                m_SndEID;
-    struct CEPollDesc* m_SndEpolld;
+    class CEPollDesc*  m_SndEpolld;
 
     int m_iSndTimeOut; // sending timeout in milliseconds
     int m_iRcvTimeOut; // receiving timeout in milliseconds
@@ -594,24 +645,21 @@ class CUDTGroup
     time_point m_tsStartTime;
     time_point m_tsRcvPeerStartTime;
 
-    struct ReadPos
-    {
-        std::vector<char> packet;
-        SRT_MSGCTRL       mctrl;
-        ReadPos(int32_t s)
-            : mctrl(srt_msgctrl_default)
-        {
-            mctrl.pktseq = s;
-        }
-    };
-    std::map<SRTSOCKET, ReadPos> m_Positions;
+    void recv_CollectAliveAndBroken(std::vector<srt::CUDTSocket*>& w_alive, std::set<srt::CUDTSocket*>& w_broken);
 
-    ReadPos* checkPacketAhead();
+    /// The function polls alive member sockets and retrieves a list of read-ready.
+    /// [acquires lock for CUDT::uglobal()->m_GlobControlLock]
+    /// [[using locked(m_GroupLock)]] temporally unlocks-locks internally
+    ///
+    /// @returns list of read-ready sockets
+    /// @throws CUDTException(MJ_CONNECTION, MN_NOCONN, 0)
+    /// @throws CUDTException(MJ_AGAIN, MN_RDAVAIL, 0)
+    std::vector<srt::CUDTSocket*> recv_WaitForReadReady(const std::vector<srt::CUDTSocket*>& aliveMembers, std::set<srt::CUDTSocket*>& w_broken);
 
     // This is the sequence number of a packet that has been previously
     // delivered. Initially it should be set to SRT_SEQNO_NONE so that the sequence read
     // from the first delivering socket will be taken as a good deal.
-    volatile int32_t m_RcvBaseSeqNo;
+    sync::atomic<int32_t> m_RcvBaseSeqNo;
 
     bool m_bOpened;    // Set to true when at least one link is at least pending
     bool m_bConnected; // Set to true on first link confirmed connected
@@ -625,10 +673,10 @@ class CUDTGroup
 
     // Signal for the blocking user thread that the packet
     // is ready to deliver.
-    srt::sync::Condition m_RcvDataCond;
-    srt::sync::Mutex     m_RcvDataLock;
-    volatile int32_t     m_iLastSchedSeqNo; // represetnts the value of CUDT::m_iSndNextSeqNo for each running socket
-    volatile int32_t     m_iLastSchedMsgNo;
+    sync::Condition       m_RcvDataCond;
+    sync::Mutex           m_RcvDataLock;
+    sync::atomic<int32_t> m_iLastSchedSeqNo; // represetnts the value of CUDT::m_iSndNextSeqNo for each running socket
+    sync::atomic<int32_t> m_iLastSchedMsgNo;
     // Statistics
 
     struct Stats
@@ -637,31 +685,29 @@ class CUDTGroup
         time_point tsActivateTime;   // Time when this group sent or received the first data packet
         time_point tsLastSampleTime; // Time reset when clearing stats
 
-        MetricUsage<PacketMetric> sent; // number of packets sent from the application
-        MetricUsage<PacketMetric> recv; // number of packets delivered from the group to the application
-        MetricUsage<PacketMetric>
-                                  recvDrop; // number of packets dropped by the group receiver (not received from any member)
-        MetricUsage<PacketMetric> recvDiscard; // number of packets discarded as already delivered
+        stats::Metric<stats::BytesPackets> sent; // number of packets sent from the application
+        stats::Metric<stats::BytesPackets> recv; // number of packets delivered from the group to the application
+        stats::Metric<stats::BytesPackets> recvDrop; // number of packets dropped by the group receiver (not received from any member)
+        stats::Metric<stats::BytesPackets> recvDiscard; // number of packets discarded as already delivered
 
         void init()
         {
             tsActivateTime = srt::sync::steady_clock::time_point();
-            sent.Init();
-            recv.Init();
-            recvDrop.Init();
-            recvDiscard.Init();
-
-            reset();
+            tsLastSampleTime = srt::sync::steady_clock::now();
+            sent.reset();
+            recv.reset();
+            recvDrop.reset();
+            recvDiscard.reset();
         }
 
         void reset()
         {
-            sent.Clear();
-            recv.Clear();
-            recvDrop.Clear();
-            recvDiscard.Clear();
-
             tsLastSampleTime = srt::sync::steady_clock::now();
+
+            sent.resetTrace();
+            recv.resetTrace();
+            recvDrop.resetTrace();
+            recvDiscard.resetTrace();
         }
     } m_stats;
 
@@ -741,22 +787,25 @@ class CUDTGroup
     }
 
     // Live state synchronization
-    bool getBufferTimeBase(CUDT* forthesakeof, time_point& w_tb, bool& w_wp, duration& w_dr);
+    bool getBufferTimeBase(srt::CUDT* forthesakeof, time_point& w_tb, bool& w_wp, duration& w_dr);
     bool applyGroupSequences(SRTSOCKET, int32_t& w_snd_isn, int32_t& w_rcv_isn);
-    void synchronizeDrift(CUDT* cu, duration udrift, time_point newtimebase);
 
-    void updateLatestRcv(CUDTSocket*);
+    /// @brief Synchronize TSBPD base time and clock drift among members using the @a srcMember as a reference.
+    /// @param srcMember a reference for synchronization.
+    void synchronizeDrift(const srt::CUDT* srcMember);
+
+    void updateLatestRcv(srt::CUDTSocket*);
 
     // Property accessors
     SRTU_PROPERTY_RW_CHAIN(CUDTGroup, SRTSOCKET, id, m_GroupID);
     SRTU_PROPERTY_RW_CHAIN(CUDTGroup, SRTSOCKET, peerid, m_PeerGroupID);
-    SRTU_PROPERTY_RW_CHAIN(CUDTGroup, bool, managed, m_selfManaged);
     SRTU_PROPERTY_RW_CHAIN(CUDTGroup, SRT_GROUP_TYPE, type, m_type);
     SRTU_PROPERTY_RW_CHAIN(CUDTGroup, int32_t, currentSchedSequence, m_iLastSchedSeqNo);
     SRTU_PROPERTY_RRW(std::set<int>&, epollset, m_sPollID);
-    SRTU_PROPERTY_RW_CHAIN(CUDTGroup, int64_t, latency, m_iTsbPdDelay_us);
-    SRTU_PROPERTY_RO(bool, synconmsgno, m_bSyncOnMsgNo);
+    SRTU_PROPERTY_RW_CHAIN(CUDTGroup, int64_t, latency_us, m_iTsbPdDelay_us);
     SRTU_PROPERTY_RO(bool, closing, m_bClosing);
 };
 
+} // namespace srt
+
 #endif // INC_SRT_GROUP_H
diff --git a/srtcore/group_backup.cpp b/srtcore/group_backup.cpp
new file mode 100644
index 000000000..9adb19607
--- /dev/null
+++ b/srtcore/group_backup.cpp
@@ -0,0 +1,159 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+ /*****************************************************************************
+ Written by
+    Haivision Systems Inc.
+ *****************************************************************************/
+
+#include "platform_sys.h"
+#include <algorithm>
+#include <sstream>
+
+#include "group_backup.h"
+
+
+namespace srt
+{
+namespace groups
+{
+
+using namespace std;
+using namespace srt_logging;
+
+const char* stateToStr(BackupMemberState state)
+{
+    switch (state)
+    {
+    case srt::groups::BKUPST_UNKNOWN:
+        return "UNKNOWN";
+    case srt::groups::BKUPST_PENDING:
+        return "PENDING";
+    case srt::groups::BKUPST_STANDBY:
+        return "STANDBY";
+    case srt::groups::BKUPST_ACTIVE_FRESH:
+        return "ACTIVE_FRESH";
+    case srt::groups::BKUPST_ACTIVE_STABLE:
+        return "ACTIVE_STABLE";
+    case srt::groups::BKUPST_ACTIVE_UNSTABLE:
+        return "ACTIVE_UNSTABLE";
+    case srt::groups::BKUPST_ACTIVE_UNSTABLE_WARY:
+        return "ACTIVE_UNSTABLE_WARY";
+    case srt::groups::BKUPST_BROKEN:
+        return "BROKEN";
+    default:
+        break;
+    }
+
+    return "WRONG_STATE";
+}
+
+/// @brief Compares group members by their weight (higher weight comes first), then state.
+/// Higher weight comes first, same weight: stable, then fresh active.
+struct FCompareByWeight
+{
+    /// @returns true if the first argument is less than (i.e. is ordered before) the second.
+    bool operator()(const BackupMemberStateEntry& a, const BackupMemberStateEntry& b)
+    {
+        if (a.pSocketData != NULL && b.pSocketData != NULL
+            && (a.pSocketData->weight != b.pSocketData->weight))
+            return a.pSocketData->weight > b.pSocketData->weight;
+
+        if (a.state != b.state)
+        {
+            SRT_STATIC_ASSERT(BKUPST_ACTIVE_STABLE > BKUPST_ACTIVE_FRESH, "Wrong ordering");
+            return a.state > b.state;
+        }
+
+        // the order does not matter, but comparator must return a different value for not equal a and b
+        return a.socketID < b.socketID;
+    }
+};
+
+void SendBackupCtx::recordMemberState(SocketData* pSockData, BackupMemberState st)
+{
+    m_memberStates.push_back(BackupMemberStateEntry(pSockData, st));
+    ++m_stateCounter[st];
+
+    if (st == BKUPST_STANDBY)
+    {
+        m_standbyMaxWeight = max(m_standbyMaxWeight, pSockData->weight);
+    }
+    else if (isStateActive(st))
+    {
+        m_activeMaxWeight = max(m_activeMaxWeight, pSockData->weight);
+    }
+}
+
+void SendBackupCtx::updateMemberState(const SocketData* pSockData, BackupMemberState st)
+{
+    typedef vector<BackupMemberStateEntry>::iterator iter_t;
+    for (iter_t i = m_memberStates.begin(); i != m_memberStates.end(); ++i)
+    {
+        if (i->pSocketData == NULL)
+            continue;
+
+        if (i->pSocketData != pSockData)
+            continue;
+
+        if (i->state == st)
+            return;
+
+        --m_stateCounter[i->state];
+        ++m_stateCounter[st];
+        i->state = st;
+
+        return;
+    }
+
+
+    LOGC(gslog.Error,
+        log << "IPE: SendBackupCtx::updateMemberState failed to locate member");
+}
+
+void SendBackupCtx::sortByWeightAndState()
+{
+    sort(m_memberStates.begin(), m_memberStates.end(), FCompareByWeight());
+}
+
+BackupMemberState SendBackupCtx::getMemberState(const SocketData* pSockData) const
+{
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t i = m_memberStates.begin(); i != m_memberStates.end(); ++i)
+    {
+        if (i->pSocketData != pSockData)
+            continue;
+
+        return i->state;
+    }
+
+    // The entry was not found
+    // TODO: Maybe throw an exception here?
+    return BKUPST_UNKNOWN;
+}
+
+unsigned SendBackupCtx::countMembersByState(BackupMemberState st) const
+{
+    return m_stateCounter[st];
+}
+
+std::string SendBackupCtx::printMembers() const
+{
+    stringstream ss;
+    typedef vector<BackupMemberStateEntry>::const_iterator const_iter_t;
+    for (const_iter_t i = m_memberStates.begin(); i != m_memberStates.end(); ++i)
+    {
+        ss << "@" << i->socketID << " w " << i->pSocketData->weight << " state " << stateToStr(i->state) << ", ";
+    }
+    return ss.str();
+}
+
+} // namespace groups
+} // namespace srt
diff --git a/srtcore/group_backup.h b/srtcore/group_backup.h
new file mode 100644
index 000000000..ed2fb29ff
--- /dev/null
+++ b/srtcore/group_backup.h
@@ -0,0 +1,136 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+ /*****************************************************************************
+ Written by
+    Haivision Systems Inc.
+ *****************************************************************************/
+
+#ifndef INC_SRT_GROUP_BACKUP_H
+#define INC_SRT_GROUP_BACKUP_H
+
+#include "srt.h"
+#include "common.h"
+#include "group_common.h"
+
+#include <list>
+
+namespace srt
+{
+namespace groups
+{
+    enum BackupMemberState
+    {
+        BKUPST_UNKNOWN = -1,
+
+        BKUPST_PENDING = 0,
+        BKUPST_STANDBY = 1,
+        BKUPST_BROKEN  = 2,
+
+        BKUPST_ACTIVE_UNSTABLE = 3,
+        BKUPST_ACTIVE_UNSTABLE_WARY = 4,
+        BKUPST_ACTIVE_FRESH = 5,
+        BKUPST_ACTIVE_STABLE = 6,
+
+        BKUPST_E_SIZE = 7
+    };
+
+    const char* stateToStr(BackupMemberState state);
+
+    inline bool isStateActive(BackupMemberState state)
+    {
+        if (state == BKUPST_ACTIVE_FRESH
+            || state == BKUPST_ACTIVE_STABLE
+            || state == BKUPST_ACTIVE_UNSTABLE
+            || state == BKUPST_ACTIVE_UNSTABLE_WARY)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    struct BackupMemberStateEntry
+    {
+        BackupMemberStateEntry(SocketData* psock, BackupMemberState st)
+            : pSocketData(psock)
+            , socketID(psock->id)
+            , state(st)
+        {}
+
+        SocketData* pSocketData; // accessing pSocketDataIt requires m_GroupLock
+        SRTSOCKET socketID;  // therefore socketID is saved separately (needed to close broken sockets)
+        BackupMemberState state;
+    };
+
+    /// @brief A context needed for main/backup sending function.
+    /// @todo Using gli_t here does not allow to safely store the context outside of the sendBackup calls.
+    class SendBackupCtx
+    {
+    public:
+        SendBackupCtx()
+            : m_stateCounter() // default init with zeros
+            , m_activeMaxWeight()
+            , m_standbyMaxWeight()
+            // XXX Setting AF_INET6 is a temporary solution for using rate estimator
+            // that counts a rate based on the current link's IP version. The results
+            // for links using IPv4 could be slightly falsified due to that (16 bytes
+            // more per a packet), but this makes the estimation results the same for
+            // the same data sent over the group, regardless of the IP version used
+            // for the currently active link (which in reality results in different
+            // load for the same stream, if links use different IP version).
+            , m_rateEstimate(AF_INET6)
+        {
+        }
+
+        /// @brief  Adds or updates a record of the member socket state.
+        /// @param pSocketDataIt Iterator to a socket
+        /// @param st State of the memmber socket
+        /// @todo Implement updating member state
+        void recordMemberState(SocketData* pSocketDataIt, BackupMemberState st);
+
+        /// @brief  Updates a record of the member socket state.
+        /// @param pSocketDataIt Iterator to a socket
+        /// @param st State of the memmber socket
+        /// @todo To be replaced by recordMemberState
+        /// @todo Update max weights?
+        void updateMemberState(const SocketData* pSocketDataIt, BackupMemberState st);
+
+        /// @brief sorts members in order
+        /// Higher weight comes first, same weight: stable first, then fresh active.
+        void sortByWeightAndState();
+
+        BackupMemberState getMemberState(const SocketData* pSocketDataIt) const;
+
+        unsigned countMembersByState(BackupMemberState st) const;
+
+        const std::vector<BackupMemberStateEntry>& memberStates() const { return m_memberStates; }
+
+        uint16_t maxStandbyWeight() const { return m_standbyMaxWeight; }
+        uint16_t maxActiveWeight() const { return m_activeMaxWeight; }
+
+        std::string printMembers() const;
+
+        void setRateEstimate(const CRateEstimator& rate) { m_rateEstimate = rate; }
+
+        const CRateEstimator& getRateEstimate() const { return m_rateEstimate; }
+
+    private:
+        std::vector<BackupMemberStateEntry> m_memberStates; // TODO: consider std::map here?
+        unsigned m_stateCounter[BKUPST_E_SIZE];
+        uint16_t m_activeMaxWeight;
+        uint16_t m_standbyMaxWeight;
+        CRateEstimator m_rateEstimate; // The rate estimator state of the active link to copy to a backup on activation.
+    };
+
+} // namespace groups
+} // namespace srt
+
+#endif // INC_SRT_GROUP_BACKUP_H
diff --git a/srtcore/group_common.cpp b/srtcore/group_common.cpp
new file mode 100644
index 000000000..536bdf52c
--- /dev/null
+++ b/srtcore/group_common.cpp
@@ -0,0 +1,63 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Written by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#include "platform_sys.h"
+
+#include "group_common.h"
+#include "api.h"
+
+namespace srt
+{
+namespace groups
+{
+
+SocketData prepareSocketData(CUDTSocket* s)
+{
+    // This uses default SRT_GST_BROKEN because when the group operation is done,
+    // then the SRT_GST_IDLE state automatically turns into SRT_GST_RUNNING. This is
+    // recognized as an initial state of the fresh added socket to the group,
+    // so some "initial configuration" must be done on it, after which it's
+    // turned into SRT_GST_RUNNING, that is, it's treated as all others. When
+    // set to SRT_GST_BROKEN, this socket is disregarded. This socket isn't cleaned
+    // up, however, unless the status is simultaneously SRTS_BROKEN.
+
+    // The order of operations is then:
+    // - add the socket to the group in this "broken" initial state
+    // - connect the socket (or get it extracted from accept)
+    // - update the socket state (should be SRTS_CONNECTED)
+    // - once the connection is established (may take time with connect), set SRT_GST_IDLE
+    // - the next operation of send/recv will automatically turn it into SRT_GST_RUNNING
+    SocketData sd = {
+        s->m_SocketID,
+        s,
+        -1,
+        SRTS_INIT,
+        SRT_GST_BROKEN,
+        SRT_GST_BROKEN,
+        -1,
+        -1,
+        sockaddr_any(),
+        sockaddr_any(),
+        false,
+        false,
+        false,
+        0, // weight
+        0  // pktSndDropTotal
+    };
+    return sd;
+}
+
+} // namespace groups
+} // namespace srt
diff --git a/srtcore/group_common.h b/srtcore/group_common.h
new file mode 100644
index 000000000..d780d0b9a
--- /dev/null
+++ b/srtcore/group_common.h
@@ -0,0 +1,62 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Written by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#ifndef INC_SRT_GROUP_COMMON_H
+#define INC_SRT_GROUP_COMMON_H
+
+#include "srt.h"
+#include "common.h"
+#include "core.h"
+
+#include <list>
+
+namespace srt
+{
+namespace groups
+{
+    typedef SRT_MEMBERSTATUS GroupState;
+
+    struct SocketData
+    {
+        SRTSOCKET      id; // same as ps->m_SocketID
+        CUDTSocket*    ps;
+        int            token;
+        SRT_SOCKSTATUS laststatus;
+        GroupState     sndstate;
+        GroupState     rcvstate;
+        int            sndresult;
+        int            rcvresult;
+        sockaddr_any   agent;
+        sockaddr_any   peer;
+        bool           ready_read;
+        bool           ready_write;
+        bool           ready_error;
+
+        // Configuration
+        uint16_t       weight;
+
+        // Stats
+        int64_t        pktSndDropTotal;
+    };
+
+    SocketData prepareSocketData(CUDTSocket* s);
+
+    typedef std::list<SocketData> group_t;
+    typedef group_t::iterator     gli_t;
+
+} // namespace groups
+} // namespace srt
+
+#endif // INC_SRT_GROUP_COMMON_H
diff --git a/srtcore/handshake.cpp b/srtcore/handshake.cpp
index e3726ea9e..c97b4e2a3 100644
--- a/srtcore/handshake.cpp
+++ b/srtcore/handshake.cpp
@@ -52,29 +52,31 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <algorithm>
 
 #include "udt.h"
+#include "api.h"
 #include "core.h"
 #include "handshake.h"
 #include "utilities.h"
 
 using namespace std;
-
-
-CHandShake::CHandShake():
-m_iVersion(0),
-m_iType(0), // Universal: UDT_UNDEFINED or no flags
-m_iISN(0),
-m_iMSS(0),
-m_iFlightFlagSize(0),
-m_iReqType(URQ_WAVEAHAND),
-m_iID(0),
-m_iCookie(0),
-m_extension(false)
+using namespace srt;
+
+
+srt::CHandShake::CHandShake()
+    : m_iVersion(0)
+    , m_iType(0) // Universal: UDT_UNDEFINED or no flags
+    , m_iISN(0)
+    , m_iMSS(0)
+    , m_iFlightFlagSize(0)
+    , m_iReqType(URQ_WAVEAHAND)
+    , m_iID(0)
+    , m_iCookie(0)
+    , m_extension(false)
 {
    for (int i = 0; i < 4; ++ i)
       m_piPeerIP[i] = 0;
 }
 
-int CHandShake::store_to(char* buf, size_t& w_size)
+int srt::CHandShake::store_to(char* buf, size_t& w_size)
 {
    if (w_size < m_iContentSize)
       return -1;
@@ -96,7 +98,7 @@ int CHandShake::store_to(char* buf, size_t& w_size)
    return 0;
 }
 
-int CHandShake::load_from(const char* buf, size_t size)
+int srt::CHandShake::load_from(const char* buf, size_t size)
 {
    if (size < m_iContentSize)
       return -1;
@@ -119,6 +121,8 @@ int CHandShake::load_from(const char* buf, size_t size)
 
 #ifdef ENABLE_LOGGING
 
+namespace srt
+{
 const char* srt_rejectreason_name [] = {
     "UNKNOWN",
     "SYSTEM",
@@ -135,16 +139,20 @@ const char* srt_rejectreason_name [] = {
     "MESSAGEAPI",
     "CONGESTION",
     "FILTER",
+    "GROUP",
+    "TIMEOUT",
+    "CRYPTO"
 };
+}
 
-std::string RequestTypeStr(UDTRequestType rq)
+std::string srt::RequestTypeStr(UDTRequestType rq)
 {
     if (rq >= URQ_FAILURE_TYPES)
     {
         std::ostringstream rt;
         rt << "ERROR:";
         int id = RejectReasonForURQ(rq);
-        if (id < SRT_REJ_E_SIZE)
+        if (id < (int) Size(srt_rejectreason_name))
             rt << srt_rejectreason_name[id];
         else if (id < SRT_REJC_USERDEFINED)
         {
@@ -170,7 +178,7 @@ std::string RequestTypeStr(UDTRequestType rq)
     }
 }
 
-string CHandShake::RdvStateStr(CHandShake::RendezvousState s)
+string srt::CHandShake::RdvStateStr(CHandShake::RendezvousState s)
 {
     switch (s)
     {
@@ -186,7 +194,18 @@ string CHandShake::RdvStateStr(CHandShake::RendezvousState s)
 }
 #endif
 
-string CHandShake::show()
+bool srt::CHandShake::valid()
+{
+    if (m_iVersion < CUDT::HS_VERSION_UDT4
+            || m_iISN < 0 || m_iISN >= CSeqNo::m_iMaxSeqNo
+            || m_iMSS < 32
+            || m_iFlightFlagSize < 2)
+        return false;
+
+    return true;
+}
+
+string srt::CHandShake::show()
 {
     ostringstream so;
 
@@ -218,7 +237,7 @@ string CHandShake::show()
     return so.str();
 }
 
-string CHandShake::ExtensionFlagStr(int32_t fl)
+string srt::CHandShake::ExtensionFlagStr(int32_t fl)
 {
     std::ostringstream out;
     if ( fl & HS_EXT_HSREQ )
@@ -245,7 +264,7 @@ string CHandShake::ExtensionFlagStr(int32_t fl)
 // XXX This code isn't currently used. Left here because it can
 // be used in future, should any refactoring for the "manual word placement"
 // code be done.
-bool SrtHSRequest::serialize(char* buf, size_t size) const
+bool srt::SrtHSRequest::serialize(char* buf, size_t size) const
 {
     if (size < SRT_HS_SIZE)
         return false;
@@ -260,7 +279,7 @@ bool SrtHSRequest::serialize(char* buf, size_t size) const
 }
 
 
-bool SrtHSRequest::deserialize(const char* buf, size_t size)
+bool srt::SrtHSRequest::deserialize(const char* buf, size_t size)
 {
     m_iSrtVersion = 0; // just to let users recognize if it succeeded or not.
 
@@ -275,3 +294,35 @@ bool SrtHSRequest::deserialize(const char* buf, size_t size)
     m_iSrtReserved = (*p++);
     return true;
 }
+
+std::string srt::SrtFlagString(int32_t flags)
+{
+#define LEN(arr) (sizeof (arr)/(sizeof ((arr)[0])))
+
+    std::string output;
+    static std::string namera[] = { "TSBPD-snd", "TSBPD-rcv", "haicrypt", "TLPktDrop", "NAKReport", "ReXmitFlag", "StreamAPI", "FilterCapable" };
+
+    size_t i = 0;
+    for (; i < LEN(namera); ++i)
+    {
+        if ((flags & 1) == 1)
+        {
+            output += "+" + namera[i] + " ";
+        }
+        else
+        {
+            output += "-" + namera[i] + " ";
+        }
+
+        flags >>= 1;
+    }
+
+#undef LEN
+
+    if (flags != 0)
+    {
+        output += "+unknown";
+    }
+
+    return output;
+}
diff --git a/srtcore/handshake.h b/srtcore/handshake.h
index e674fce33..c6a5731e4 100644
--- a/srtcore/handshake.h
+++ b/srtcore/handshake.h
@@ -51,6 +51,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "crypto.h"
 #include "utilities.h"
 
+namespace srt
+{
+
 typedef Bits<31, 16> HS_CMDSPEC_CMD;
 typedef Bits<15, 0> HS_CMDSPEC_SIZE;
 
@@ -128,7 +131,6 @@ void SrtExtractHandshakeExtensions(const char* bufbegin, size_t size,
         std::vector<SrtHandshakeExtension>& w_output);
 
 
-
 struct SrtHSRequest: public SrtHandshakeExtension
 {
     typedef Bits<31, 16> SRT_HSTYPE_ENCFLAGS;
@@ -285,20 +287,20 @@ inline std::string RequestTypeStr(UDTRequestType) { return ""; }
 class CHandShake
 {
 public:
-   CHandShake();
+    CHandShake();
 
-   int store_to(char* buf, size_t& size);
-   int load_from(const char* buf, size_t size);
+    int store_to(char* buf, size_t& size);
+    int load_from(const char* buf, size_t size);
 
 public:
-   // This is the size of SERIALIZED handshake.
-   // Might be defined as simply sizeof(CHandShake), but the
-   // enum values would have to be forced as int32_t, which is only
-   // available in C++11. Theoretically they are all 32-bit, but
-   // such a statement is not reliable and not portable.
-   static const size_t m_iContentSize = 48;	// Size of hand shake data
+    // This is the size of SERIALIZED handshake.
+    // Might be defined as simply sizeof(CHandShake), but the
+    // enum values would have to be forced as int32_t, which is only
+    // available in C++11. Theoretically they are all 32-bit, but
+    // such a statement is not reliable and not portable.
+    static const size_t m_iContentSize = 48;	// Size of hand shake data
 
-   // Extension flags
+    // Extension flags
 
     static const int32_t HS_EXT_HSREQ = BIT(0);
     static const int32_t HS_EXT_KMREQ = BIT(1);
@@ -309,54 +311,58 @@ class CHandShake
     // Applicable only when m_iVersion == HS_VERSION_SRT1
     int32_t flags() { return m_iType; }
 
+    bool v5orHigher() { return m_iVersion > 4; }
+
 public:
-   int32_t m_iVersion;          // UDT version (HS_VERSION_* symbols)
-   int32_t m_iType;             // UDT4: socket type (only UDT_DGRAM is valid); SRT1: extension flags
-   int32_t m_iISN;              // random initial sequence number
-   int32_t m_iMSS;              // maximum segment size
-   int32_t m_iFlightFlagSize;   // flow control window size
-   UDTRequestType m_iReqType;   // handshake stage
-   int32_t m_iID;		// socket ID
-   int32_t m_iCookie;		// cookie
-   uint32_t m_piPeerIP[4];	// The IP address that the peer's UDP port is bound to
-
-   bool m_extension;
-
-   std::string show();
-
-// The rendezvous state machine used in HSv5 only (in HSv4 everything is happening the old way).
-//
-// The WAVING state is the very initial state of the rendezvous connection and restored after the
-// connection is closed.
-// The ATTENTION and FINE are two alternative states that are transited to from WAVING. The possible
-// situations are:
-// - "serial arrangement": one party transits to ATTENTION and the other party transits to FINE
-// - "parallel arrangement" both parties transit to ATTENTION
-//
-// Parallel arrangement is a "virtually impossible" case, in which both parties must send the first
-// URQ_WAVEAHAND message in a perfect time synchronization, when they are started at exactly the same
-// time, on machines with exactly the same performance and all things preceding the message sending
-// have taken perfectly identical amount of time. This isn't anyhow possible otherwise because if
-// the clients have started at different times, the one who started first sends a message and the
-// system of the receiver buffers this message even before the client binds the port for enough long
-// time so that it outlasts also the possible second, repeated waveahand.
-enum RendezvousState
-{
-    RDV_INVALID,    //< This socket wasn't prepared for rendezvous process. Reject any events.
-    RDV_WAVING,     //< Initial state for rendezvous. No contact seen from the peer.
-    RDV_ATTENTION,  //< When received URQ_WAVEAHAND. [WAVING]:URQ_WAVEAHAND  --> [ATTENTION].
-    RDV_FINE,       //< When received URQ_CONCLUSION. [WAVING]:URQ_CONCLUSION --> [FINE].
-    RDV_INITIATED,  //< When received URQ_CONCLUSION+HSREQ extension in ATTENTION state. 
-    RDV_CONNECTED   //< Final connected state. [ATTENTION]:URQ_CONCLUSION --> [CONNECTED] <-- [FINE]:URQ_AGREEMENT.
-};
+    int32_t m_iVersion;          // UDT version (HS_VERSION_* symbols)
+    int32_t m_iType;             // UDT4: socket type (only UDT_DGRAM is valid); SRT1: extension flags
+    int32_t m_iISN;              // random initial sequence number
+    int32_t m_iMSS;              // maximum segment size
+    int32_t m_iFlightFlagSize;   // flow control window size
+    UDTRequestType m_iReqType;   // handshake stage
+    int32_t m_iID;               // SRT socket ID of HS sender
+    int32_t m_iCookie;		// cookie
+    uint32_t m_piPeerIP[4];	// The IP address that the peer's UDP port is bound to
+
+    bool m_extension;
+
+    bool valid();
+    std::string show();
+
+    // The rendezvous state machine used in HSv5 only (in HSv4 everything is happening the old way).
+    //
+    // The WAVING state is the very initial state of the rendezvous connection and restored after the
+    // connection is closed.
+    // The ATTENTION and FINE are two alternative states that are transited to from WAVING. The possible
+    // situations are:
+    // - "serial arrangement": one party transits to ATTENTION and the other party transits to FINE
+    // - "parallel arrangement" both parties transit to ATTENTION
+    //
+    // Parallel arrangement is a "virtually impossible" case, in which both parties must send the first
+    // URQ_WAVEAHAND message in a perfect time synchronization, when they are started at exactly the same
+    // time, on machines with exactly the same performance and all things preceding the message sending
+    // have taken perfectly identical amount of time. This isn't anyhow possible otherwise because if
+    // the clients have started at different times, the one who started first sends a message and the
+    // system of the receiver buffers this message even before the client binds the port for enough long
+    // time so that it outlasts also the possible second, repeated waveahand.
+    enum RendezvousState
+    {
+        RDV_INVALID,    //< This socket wasn't prepared for rendezvous process. Reject any events.
+        RDV_WAVING,     //< Initial state for rendezvous. No contact seen from the peer.
+        RDV_ATTENTION,  //< When received URQ_WAVEAHAND. [WAVING]:URQ_WAVEAHAND  --> [ATTENTION].
+        RDV_FINE,       //< When received URQ_CONCLUSION. [WAVING]:URQ_CONCLUSION --> [FINE].
+        RDV_INITIATED,  //< When received URQ_CONCLUSION+HSREQ extension in ATTENTION state. 
+        RDV_CONNECTED   //< Final connected state. [ATTENTION]:URQ_CONCLUSION --> [CONNECTED] <-- [FINE]:URQ_AGREEMENT.
+    };
 
 #if ENABLE_LOGGING
-static std::string RdvStateStr(RendezvousState s);
+    static std::string RdvStateStr(RendezvousState s);
 #else
-static std::string RdvStateStr(RendezvousState) { return ""; }
+    static std::string RdvStateStr(RendezvousState) { return ""; }
 #endif
 
 };
 
+} // namespace srt
 
 #endif
diff --git a/srtcore/list.cpp b/srtcore/list.cpp
index 01e7e6016..0fe7d2b4b 100644
--- a/srtcore/list.cpp
+++ b/srtcore/list.cpp
@@ -61,14 +61,16 @@ namespace srt_logging
 {
 extern Logger qrlog;
 extern Logger qslog;
+extern Logger tslog;
 }
 
 using srt_logging::qrlog;
 using srt_logging::qslog;
+using srt_logging::tslog;
 
 using namespace srt::sync;
 
-CSndLossList::CSndLossList(int size)
+srt::CSndLossList::CSndLossList(int size)
     : m_caSeq()
     , m_iHead(-1)
     , m_iLength(0)
@@ -89,29 +91,32 @@ CSndLossList::CSndLossList(int size)
     setupMutex(m_ListLock, "LossList");
 }
 
-CSndLossList::~CSndLossList()
+srt::CSndLossList::~CSndLossList()
 {
     delete[] m_caSeq;
     releaseMutex(m_ListLock);
 }
 
-void CSndLossList::traceState() const
+void srt::CSndLossList::traceState() const
 {
-    int pos = m_iHead;
-    while (pos != SRT_SEQNO_NONE)
-    {
-        ::cout << pos << ":[" << m_caSeq[pos].seqstart;
-        if (m_caSeq[pos].seqend != SRT_SEQNO_NONE)
-            ::cout << ", " << m_caSeq[pos].seqend;
-        ::cout << "], ";
-        pos = m_caSeq[pos].inext;
-    }
-    ::cout << "\n";
+    traceState(std::cout) << "\n";
 }
 
-int CSndLossList::insert(int32_t seqno1, int32_t seqno2)
+int srt::CSndLossList::insert(int32_t seqno1, int32_t seqno2)
 {
-    SRT_ASSERT(CSeqNo::seqlen(seqno1, seqno2) > 0);
+    if (seqno1 < 0 || seqno2 < 0 ) {
+        LOGC(qslog.Error, log << "IPE: Tried to insert negative seqno " << seqno1 << ":" << seqno2
+            << " into sender's loss list. Ignoring.");
+        return 0;
+    }
+
+    const int inserted_range = CSeqNo::seqlen(seqno1, seqno2);
+    if (inserted_range <= 0 || inserted_range >= m_iSize) {
+        LOGC(qslog.Error, log << "IPE: Tried to insert too big range of seqno: " << inserted_range <<  ". Ignoring. "
+                << "seqno " << seqno1 << ":" << seqno2);
+        return 0;
+    }
+
     ScopedLock listguard(m_ListLock);
 
     if (m_iLength == 0)
@@ -123,7 +128,16 @@ int CSndLossList::insert(int32_t seqno1, int32_t seqno2)
     // Find the insert position in the non-empty list
     const int origlen = m_iLength;
     const int offset  = CSeqNo::seqoff(m_caSeq[m_iHead].seqstart, seqno1);
-    int       loc     = (m_iHead + offset + m_iSize) % m_iSize;
+
+    if (offset >= m_iSize)
+    {
+        LOGC(qslog.Error, log << "IPE: New loss record is too far from the first record. Ignoring. "
+                << "First loss seqno " << m_caSeq[m_iHead].seqstart
+                << ", insert seqno " << seqno1 << ":" << seqno2);
+        return 0;
+    }
+
+    int loc = (m_iHead + offset + m_iSize) % m_iSize;
 
     if (loc < 0)
     {
@@ -205,7 +219,7 @@ int CSndLossList::insert(int32_t seqno1, int32_t seqno2)
     return m_iLength - origlen;
 }
 
-void CSndLossList::removeUpTo(int32_t seqno)
+void srt::CSndLossList::removeUpTo(int32_t seqno)
 {
     ScopedLock listguard(m_ListLock);
 
@@ -317,14 +331,14 @@ void CSndLossList::removeUpTo(int32_t seqno)
     }
 }
 
-int CSndLossList::getLossLength() const
+int srt::CSndLossList::getLossLength() const
 {
     ScopedLock listguard(m_ListLock);
 
     return m_iLength;
 }
 
-int32_t CSndLossList::popLostSeq()
+int32_t srt::CSndLossList::popLostSeq()
 {
     ScopedLock listguard(m_ListLock);
 
@@ -368,7 +382,7 @@ int32_t CSndLossList::popLostSeq()
     return seqno;
 }
 
-void CSndLossList::insertHead(int pos, int32_t seqno1, int32_t seqno2)
+void srt::CSndLossList::insertHead(int pos, int32_t seqno1, int32_t seqno2)
 {
     SRT_ASSERT(pos >= 0);
     m_caSeq[pos].seqstart = seqno1;
@@ -384,7 +398,7 @@ void CSndLossList::insertHead(int pos, int32_t seqno1, int32_t seqno2)
     m_iLength += CSeqNo::seqlen(seqno1, seqno2);
 }
 
-void CSndLossList::insertAfter(int pos, int pos_after, int32_t seqno1, int32_t seqno2)
+void srt::CSndLossList::insertAfter(int pos, int pos_after, int32_t seqno1, int32_t seqno2)
 {
     m_caSeq[pos].seqstart = seqno1;
     SRT_ASSERT(m_caSeq[pos].seqend == SRT_SEQNO_NONE);
@@ -398,7 +412,7 @@ void CSndLossList::insertAfter(int pos, int pos_after, int32_t seqno1, int32_t s
     m_iLength += CSeqNo::seqlen(seqno1, seqno2);
 }
 
-void CSndLossList::coalesce(int loc)
+void srt::CSndLossList::coalesce(int loc)
 {
     // coalesce with next node. E.g., [3, 7], ..., [6, 9] becomes [3, 9]
     while ((m_caSeq[loc].inext != -1) && (m_caSeq[loc].seqend != SRT_SEQNO_NONE))
@@ -434,7 +448,7 @@ void CSndLossList::coalesce(int loc)
     }
 }
 
-bool CSndLossList::updateElement(int pos, int32_t seqno1, int32_t seqno2)
+bool srt::CSndLossList::updateElement(int pos, int32_t seqno1, int32_t seqno2)
 {
     m_iLastInsertPos = pos;
 
@@ -460,12 +474,13 @@ bool CSndLossList::updateElement(int pos, int32_t seqno1, int32_t seqno2)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-CRcvLossList::CRcvLossList(int size)
+srt::CRcvLossList::CRcvLossList(int size)
     : m_caSeq()
     , m_iHead(-1)
     , m_iTail(-1)
     , m_iLength(0)
     , m_iSize(size)
+    , m_iLargestSeq(SRT_SEQNO_NONE)
 {
     m_caSeq = new Seq[m_iSize];
 
@@ -477,15 +492,37 @@ CRcvLossList::CRcvLossList(int size)
     }
 }
 
-CRcvLossList::~CRcvLossList()
+srt::CRcvLossList::~CRcvLossList()
 {
     delete[] m_caSeq;
 }
 
-void CRcvLossList::insert(int32_t seqno1, int32_t seqno2)
+int srt::CRcvLossList::insert(int32_t seqno1, int32_t seqno2)
 {
+    SRT_ASSERT(seqno1 != SRT_SEQNO_NONE && seqno2 != SRT_SEQNO_NONE);
+    // Make sure that seqno2 isn't earlier than seqno1.
+    SRT_ASSERT(CSeqNo::seqcmp(seqno1, seqno2) <= 0);
+
     // Data to be inserted must be larger than all those in the list
-    // guaranteed by the UDT receiver
+    if (m_iLargestSeq != SRT_SEQNO_NONE && CSeqNo::seqcmp(seqno1, m_iLargestSeq) <= 0)
+    {
+        if (CSeqNo::seqcmp(seqno2, m_iLargestSeq) > 0)
+        {
+            LOGC(qrlog.Warn,
+                 log << "RCV-LOSS/insert: seqno1=" << seqno1 << " too small, adjust to "
+                     << CSeqNo::incseq(m_iLargestSeq));
+            seqno1 = CSeqNo::incseq(m_iLargestSeq);
+        }
+        else
+        {
+            LOGC(qrlog.Warn,
+                 log << "RCV-LOSS/insert: (" << seqno1 << "," << seqno2
+                     << ") to be inserted is too small: m_iLargestSeq=" << m_iLargestSeq << ", m_iLength=" << m_iLength
+                     << ", m_iHead=" << m_iHead << ", m_iTail=" << m_iTail << " -- REJECTING");
+            return 0;
+        }
+    }
+    m_iLargestSeq = seqno2;
 
     if (0 == m_iLength)
     {
@@ -498,19 +535,19 @@ void CRcvLossList::insert(int32_t seqno1, int32_t seqno2)
 
         m_caSeq[m_iHead].inext  = -1;
         m_caSeq[m_iHead].iprior = -1;
-        m_iLength += CSeqNo::seqlen(seqno1, seqno2);
-
-        return;
+        const int n = CSeqNo::seqlen(seqno1, seqno2);
+        m_iLength += n;
+        return n;
     }
 
     // otherwise searching for the position where the node should be
-    int offset = CSeqNo::seqoff(m_caSeq[m_iHead].seqstart, seqno1);
+    const int offset = CSeqNo::seqoff(m_caSeq[m_iHead].seqstart, seqno1);
     if (offset < 0)
     {
         LOGC(qrlog.Error,
              log << "RCV-LOSS/insert: IPE: new LOSS %(" << seqno1 << "-" << seqno2 << ") PREDATES HEAD %"
                  << m_caSeq[m_iHead].seqstart << " -- REJECTING");
-        return;
+        return -1;
     }
 
     int loc = (m_iHead + offset) % m_iSize;
@@ -535,11 +572,16 @@ void CRcvLossList::insert(int32_t seqno1, int32_t seqno2)
         m_iTail                = loc;
     }
 
-    m_iLength += CSeqNo::seqlen(seqno1, seqno2);
+    const int n = CSeqNo::seqlen(seqno1, seqno2);
+    m_iLength += n;
+    return n;
 }
 
-bool CRcvLossList::remove(int32_t seqno)
+bool srt::CRcvLossList::remove(int32_t seqno)
 {
+    if (m_iLargestSeq == SRT_SEQNO_NONE || CSeqNo::seqcmp(seqno, m_iLargestSeq) > 0)
+        m_iLargestSeq = seqno;
+
     if (0 == m_iLength)
         return false;
 
@@ -562,6 +604,8 @@ bool CRcvLossList::remove(int32_t seqno)
                 m_iHead = m_caSeq[m_iHead].inext;
                 if (-1 != m_iHead)
                     m_caSeq[m_iHead].iprior = -1;
+                else
+                    m_iTail = -1;
             }
             else
             {
@@ -609,6 +653,8 @@ bool CRcvLossList::remove(int32_t seqno)
         }
 
         m_iLength--;
+        if (m_iLength == 0)
+            m_iLargestSeq = SRT_SEQNO_NONE;
 
         return true;
     }
@@ -664,29 +710,54 @@ bool CRcvLossList::remove(int32_t seqno)
     }
 
     m_iLength--;
+    if (m_iLength == 0)
+        m_iLargestSeq = SRT_SEQNO_NONE;
 
     return true;
 }
 
-bool CRcvLossList::remove(int32_t seqno1, int32_t seqno2)
+bool srt::CRcvLossList::remove(int32_t seqno1, int32_t seqno2)
 {
-    if (seqno1 <= seqno2)
+    if (CSeqNo::seqcmp(seqno1, seqno2) > 0)
     {
-        for (int32_t i = seqno1; i <= seqno2; ++i)
-            remove(i);
+        return false;
     }
-    else
+    for (int32_t i = seqno1; CSeqNo::seqcmp(i, seqno2) <= 0; i = CSeqNo::incseq(i))
     {
-        for (int32_t j = seqno1; j < CSeqNo::m_iMaxSeqNo; ++j)
-            remove(j);
-        for (int32_t k = 0; k <= seqno2; ++k)
-            remove(k);
+        remove(i);
     }
-
     return true;
 }
 
-bool CRcvLossList::find(int32_t seqno1, int32_t seqno2) const
+int32_t srt::CRcvLossList::removeUpTo(int32_t seqno_last)
+{
+    int32_t first = getFirstLostSeq();
+    if (first == SRT_SEQNO_NONE)
+    {
+        //HLOGC(tslog.Debug, log << "rcv-loss: DROP to %" << seqno_last << " - empty list");
+        return first; // empty, so nothing to remove
+    }
+
+    if (CSeqNo::seqcmp(seqno_last, first) < 0)
+    {
+        //HLOGC(tslog.Debug, log << "rcv-loss: DROP to %" << seqno_last << " - first %" << first << " is newer, exitting");
+        return first; // seqno_last older than first - nothing to remove
+    }
+
+    HLOGC(tslog.Debug, log << "rcv-loss: DROP to %" << seqno_last << " ...");
+
+    // NOTE: seqno_last is past-the-end here. Removed are only seqs
+    // that are earlier than this.
+    for (int32_t i = first; CSeqNo::seqcmp(i, seqno_last) <= 0; i = CSeqNo::incseq(i))
+    {
+        //HLOGC(tslog.Debug, log << "... removing %" << i);
+        remove(i);
+    }
+
+    return first;
+}
+
+bool srt::CRcvLossList::find(int32_t seqno1, int32_t seqno2) const
 {
     if (0 == m_iLength)
         return false;
@@ -707,12 +778,12 @@ bool CRcvLossList::find(int32_t seqno1, int32_t seqno2) const
     return false;
 }
 
-int CRcvLossList::getLossLength() const
+int srt::CRcvLossList::getLossLength() const
 {
     return m_iLength;
 }
 
-int32_t CRcvLossList::getFirstLostSeq() const
+int32_t srt::CRcvLossList::getFirstLostSeq() const
 {
     if (0 == m_iLength)
         return SRT_SEQNO_NONE;
@@ -720,7 +791,7 @@ int32_t CRcvLossList::getFirstLostSeq() const
     return m_caSeq[m_iHead].seqstart;
 }
 
-void CRcvLossList::getLossArray(int32_t* array, int& len, int limit)
+void srt::CRcvLossList::getLossArray(int32_t* array, int& len, int limit)
 {
     len = 0;
 
@@ -743,7 +814,7 @@ void CRcvLossList::getLossArray(int32_t* array, int& len, int limit)
     }
 }
 
-CRcvFreshLoss::CRcvFreshLoss(int32_t seqlo, int32_t seqhi, int initial_age)
+srt::CRcvFreshLoss::CRcvFreshLoss(int32_t seqlo, int32_t seqhi, int initial_age)
     : ttl(initial_age)
     , timestamp(steady_clock::now())
 {
@@ -751,7 +822,7 @@ CRcvFreshLoss::CRcvFreshLoss(int32_t seqlo, int32_t seqhi, int initial_age)
     seq[1] = seqhi;
 }
 
-CRcvFreshLoss::Emod CRcvFreshLoss::revoke(int32_t sequence)
+srt::CRcvFreshLoss::Emod srt::CRcvFreshLoss::revoke(int32_t sequence)
 {
     int32_t diffbegin = CSeqNo::seqcmp(sequence, seq[0]);
     int32_t diffend   = CSeqNo::seqcmp(sequence, seq[1]);
@@ -782,7 +853,7 @@ CRcvFreshLoss::Emod CRcvFreshLoss::revoke(int32_t sequence)
     return SPLIT;
 }
 
-CRcvFreshLoss::Emod CRcvFreshLoss::revoke(int32_t lo, int32_t hi)
+srt::CRcvFreshLoss::Emod srt::CRcvFreshLoss::revoke(int32_t lo, int32_t hi)
 {
     // This should only if the range lo-hi is anyhow covered by seq[0]-seq[1].
 
@@ -794,8 +865,10 @@ CRcvFreshLoss::Emod CRcvFreshLoss::revoke(int32_t lo, int32_t hi)
     // ITEM:  <lo, hi>                      <--- delete
     // If the sequence range is older than the range to be revoked,
     // delete it anyway.
-    if (CSeqNo::seqcmp(lo, seq[1]) > 0)
+    if (lo != SRT_SEQNO_NONE && CSeqNo::seqcmp(lo, seq[1]) > 0)
         return DELETE;
+    // IF <lo> is NONE, then rely simply on that item.hi <% arg.hi,
+    // which is a condition at the end.
 
     // LOHI:  <lo, hi>
     // ITEM:             <lo, hi>  <-- NOTFOUND
@@ -823,3 +896,53 @@ CRcvFreshLoss::Emod CRcvFreshLoss::revoke(int32_t lo, int32_t hi)
 
     return DELETE;
 }
+
+bool srt::CRcvFreshLoss::removeOne(std::deque<CRcvFreshLoss>& w_container, int32_t sequence, int* pw_had_ttl)
+{
+    for (size_t i = 0; i < w_container.size(); ++i)
+    {
+        const int had_ttl = w_container[i].ttl;
+        Emod wh = w_container[i].revoke(sequence);
+
+        if (wh == NONE)
+            continue;  // Not found. Search again.
+
+        if (wh == DELETE)   //  ... oo ... x ... o ... => ... oo ... o ...
+        {
+            // Removed the only element in the record - remove the record.
+            w_container.erase(w_container.begin() + i);
+        }
+        else if (wh == SPLIT) // ... ooxooo ... => ... oo ... ooo ...
+        {
+            // Create a new element that will hold the upper part of the range,
+            // and the found one modify to be the lower part of the range.
+
+            // Keep the current end-of-sequence value for the second element
+            int32_t next_end = w_container[i].seq[1];
+
+            // seq-1 set to the end of this element
+            w_container[i].seq[1] = CSeqNo::decseq(sequence);
+            // seq+1 set to the begin of the next element
+            int32_t next_begin = CSeqNo::incseq(sequence);
+
+            // Use position of the NEXT element because insertion happens BEFORE pointed element.
+            // Use the same TTL (will stay the same in the other one).
+            w_container.insert(w_container.begin() + i + 1,
+                    CRcvFreshLoss(next_begin, next_end, w_container[i].ttl));
+        }
+        // For STRIPPED:  ... xooo ... => ... ooo ...
+        // i.e. there's nothing to do.
+
+        // Every loss is unique. We're done here.
+        if (pw_had_ttl)
+            *pw_had_ttl = had_ttl;
+
+        return true;
+    }
+
+    if (pw_had_ttl)
+        *pw_had_ttl = 0;
+    return false;
+
+}
+
diff --git a/srtcore/list.h b/srtcore/list.h
index 19b300f30..40b8ee0c9 100644
--- a/srtcore/list.h
+++ b/srtcore/list.h
@@ -53,9 +53,13 @@ modified by
 #ifndef INC_SRT_LIST_H
 #define INC_SRT_LIST_H
 
+#include <deque>
+
 #include "udt.h"
 #include "common.h"
 
+namespace srt {
+
 class CSndLossList
 {
 public:
@@ -80,8 +84,33 @@ class CSndLossList
     /// @return The seq. no. or -1 if the list is empty.
     int32_t popLostSeq();
 
+    template <class Stream>
+    Stream& traceState(Stream& sout) const
+    {
+        int pos = m_iHead;
+        while (pos != SRT_SEQNO_NONE)
+        {
+            sout << "[" << pos << "]:" << m_caSeq[pos].seqstart;
+            if (m_caSeq[pos].seqend != SRT_SEQNO_NONE)
+                sout << ":" << m_caSeq[pos].seqend;
+            if (m_caSeq[pos].inext == -1)
+                sout << "=|";
+            else
+                sout << "->[" << m_caSeq[pos].inext << "]";
+            sout << ", ";
+            pos = m_caSeq[pos].inext;
+        }
+        sout << " {len:" << m_iLength << " head:" << m_iHead << " last:" << m_iLastInsertPos << "}";
+        return sout;
+    }
     void traceState() const;
 
+    // Debug/unittest support.
+
+    int head() const { return m_iHead; }
+    int next(int loc) const { return m_caSeq[loc].inext; }
+    int last() const { return m_iLastInsertPos; }
+
 private:
     struct Seq
     {
@@ -116,6 +145,8 @@ class CSndLossList
     /// @param seqno2  last sequence number in range (SRT_SEQNO_NONE if no range)
     bool updateElement(int pos, int32_t seqno1, int32_t seqno2);
 
+    static const int LOC_NONE = -1;
+
 private:
     CSndLossList(const CSndLossList&);
     CSndLossList& operator=(const CSndLossList&);
@@ -132,8 +163,8 @@ class CRcvLossList
     /// Insert a series of loss seq. no. between "seqno1" and "seqno2" into the receiver's loss list.
     /// @param [in] seqno1 sequence number starts.
     /// @param [in] seqno2 seqeunce number ends.
-
-    void insert(int32_t seqno1, int32_t seqno2);
+    /// @return length of the loss record inserted (seqlen(seqno1, seqno2)), -1 on error.
+    int insert(int32_t seqno1, int32_t seqno2);
 
     /// Remove a loss seq. no. from the receiver's loss list.
     /// @param [in] seqno sequence number.
@@ -148,6 +179,12 @@ class CRcvLossList
 
     bool remove(int32_t seqno1, int32_t seqno2);
 
+
+    /// Remove all numbers that precede the given sequence number.
+    /// @param [in] seqno sequence number.
+    /// @return the first removed sequence number
+    int32_t removeUpTo(int32_t seqno);
+
     /// Find if there is any lost packets whose sequence number falling seqno1 and seqno2.
     /// @param [in] seqno1 start sequence number.
     /// @param [in] seqno2 end sequence number.
@@ -185,6 +222,7 @@ class CRcvLossList
     int m_iTail;   // last node in the list;
     int m_iLength; // loss length
     int m_iSize;   // size of the static array
+    int m_iLargestSeq; // largest seq ever seen
 
 private:
     CRcvLossList(const CRcvLossList&);
@@ -261,6 +299,10 @@ struct CRcvFreshLoss
 
     Emod revoke(int32_t sequence);
     Emod revoke(int32_t lo, int32_t hi);
+
+    static bool removeOne(std::deque<CRcvFreshLoss>& w_container, int32_t sequence, int* had_ttl = NULL);
 };
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/logging.cpp b/srtcore/logging.cpp
new file mode 100644
index 000000000..d0ba3fd4a
--- /dev/null
+++ b/srtcore/logging.cpp
@@ -0,0 +1,149 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+ *****************************************************************************/
+
+
+#include "srt_compat.h"
+#include "logging.h"
+
+using namespace std;
+
+
+namespace srt_logging
+{
+
+
+#if ENABLE_LOGGING
+
+LogDispatcher::Proxy::Proxy(LogDispatcher& guy) : that(guy), that_enabled(that.CheckEnabled())
+{
+    if (that_enabled)
+    {
+        i_file = "";
+        i_line = 0;
+        flags = that.src_config->flags;
+        // Create logger prefix
+        that.CreateLogLinePrefix(os);
+    }
+}
+
+LogDispatcher::Proxy LogDispatcher::operator()()
+{
+    return Proxy(*this);
+}
+
+void LogDispatcher::CreateLogLinePrefix(std::ostringstream& serr)
+{
+    using namespace std;
+    using namespace srt;
+
+    SRT_STATIC_ASSERT(ThreadName::BUFSIZE >= sizeof("hh:mm:ss.") * 2, // multiply 2 for some margin
+                      "ThreadName::BUFSIZE is too small to be used for strftime");
+    char tmp_buf[ThreadName::BUFSIZE];
+    if ( !isset(SRT_LOGF_DISABLE_TIME) )
+    {
+        // Not necessary if sending through the queue.
+        timeval tv;
+        gettimeofday(&tv, NULL);
+        struct tm tm = SysLocalTime((time_t) tv.tv_sec);
+
+        if (strftime(tmp_buf, sizeof(tmp_buf), "%X.", &tm))
+        {
+            serr << tmp_buf << setw(6) << setfill('0') << tv.tv_usec;
+        }
+    }
+
+    string out_prefix;
+    if ( !isset(SRT_LOGF_DISABLE_SEVERITY) )
+    {
+        out_prefix = prefix;
+    }
+
+    // Note: ThreadName::get needs a buffer of size min. ThreadName::BUFSIZE
+    if ( !isset(SRT_LOGF_DISABLE_THREADNAME) && ThreadName::get(tmp_buf) )
+    {
+        serr << "/" << tmp_buf << out_prefix << ": ";
+    }
+    else
+    {
+        serr << out_prefix << ": ";
+    }
+}
+
+std::string LogDispatcher::Proxy::ExtractName(std::string pretty_function)
+{
+    if ( pretty_function == "" )
+        return "";
+    size_t pos = pretty_function.find('(');
+    if ( pos == std::string::npos )
+        return pretty_function; // return unchanged.
+
+    pretty_function = pretty_function.substr(0, pos);
+
+    // There are also template instantiations where the instantiating
+    // parameters are encrypted inside. Therefore, search for the first
+    // open < and if found, search for symmetric >.
+
+    int depth = 1;
+    pos = pretty_function.find('<');
+    if ( pos != std::string::npos )
+    {
+        size_t end = pos+1;
+        for(;;)
+        {
+            ++pos;
+            if ( pos == pretty_function.size() )
+            {
+                --pos;
+                break;
+            }
+            if ( pretty_function[pos] == '<' )
+            {
+                ++depth;
+                continue;
+            }
+
+            if ( pretty_function[pos] == '>' )
+            {
+                --depth;
+                if ( depth <= 0 )
+                    break;
+                continue;
+            }
+        }
+
+        std::string afterpart = pretty_function.substr(pos+1);
+        pretty_function = pretty_function.substr(0, end) + ">" + afterpart;
+    }
+
+    // Now see how many :: can be found in the name.
+    // If this occurs more than once, take the last two.
+    pos = pretty_function.rfind("::");
+
+    if ( pos == std::string::npos || pos < 2 )
+        return pretty_function; // return whatever this is. No scope name.
+
+    // Find the next occurrence of :: - if found, copy up to it. If not,
+    // return whatever is found.
+    pos -= 2;
+    pos = pretty_function.rfind("::", pos);
+    if ( pos == std::string::npos )
+        return pretty_function; // nothing to cut
+
+    return pretty_function.substr(pos+2);
+}
+#endif
+
+} // (end namespace srt_logging)
+
diff --git a/srtcore/logging.h b/srtcore/logging.h
index bfdfb375e..7782245a2 100644
--- a/srtcore/logging.h
+++ b/srtcore/logging.h
@@ -33,7 +33,6 @@ written by
 #include "utilities.h"
 #include "threadname.h"
 #include "logging_api.h"
-#include "srt_compat.h"
 #include "sync.h"
 
 #ifdef __GNUC__
@@ -55,24 +54,27 @@ written by
 { \
     srt_logging::LogDispatcher::Proxy log(logdes); \
     log.setloc(__FILE__, __LINE__, __FUNCTION__); \
-    const srt_logging::LogDispatcher::Proxy& log_prox SRT_ATR_UNUSED = args; \
+    { (void)(const srt_logging::LogDispatcher::Proxy&)(args); } \
 }
 
 // LOGF uses printf-like style formatting.
 // Usage: LOGF(gglog.Debug, "%s: %d", param1.c_str(), int(param2));
+// NOTE: LOGF is deprecated and should not be used
 #define LOGF(logdes, ...) if (logdes.CheckEnabled()) logdes().setloc(__FILE__, __LINE__, __FUNCTION__).form(__VA_ARGS__)
 
 // LOGP is C++11 only OR with only one string argument.
 // Usage: LOGP(gglog.Debug, param1, param2, param3);
 #define LOGP(logdes, ...) if (logdes.CheckEnabled()) logdes.printloc(__FILE__, __LINE__, __FUNCTION__,##__VA_ARGS__)
 
+#define IF_LOGGING(instr) instr
+
 #if ENABLE_HEAVY_LOGGING
 
 #define HLOGC LOGC
 #define HLOGP LOGP
 #define HLOGF LOGF
 
-#define IF_HEAVY_LOGGING(instr) instr
+#define IF_HEAVY_LOGGING(instr,...) instr,##__VA_ARGS__
 
 #else
 
@@ -95,6 +97,7 @@ written by
 #define HLOGP(...)
 
 #define IF_HEAVY_LOGGING(instr) (void)0
+#define IF_LOGGING(instr) (void)0
 
 #endif
 
@@ -109,7 +112,7 @@ struct LogConfig
     std::ostream* log_stream;
     SRT_LOG_HANDLER_FN* loghandler_fn;
     void* loghandler_opaque;
-    srt::sync::Mutex mutex;
+    mutable srt::sync::Mutex mutex;
     int flags;
 
     LogConfig(const fa_bitset_t& efa,
@@ -128,8 +131,11 @@ struct LogConfig
     {
     }
 
-    void lock() { mutex.lock(); }
-    void unlock() { mutex.unlock(); }
+    SRT_ATTR_ACQUIRE(mutex)
+    void lock() const { mutex.lock(); }
+
+    SRT_ATTR_RELEASE(mutex)
+    void unlock() const { mutex.unlock(); }
 };
 
 // The LogDispatcher class represents the object that is responsible for
@@ -141,6 +147,7 @@ struct SRT_API LogDispatcher
     LogLevel::type level;
     static const size_t MAX_PREFIX_SIZE = 32;
     char prefix[MAX_PREFIX_SIZE+1];
+    size_t prefix_len;
     LogConfig* src_config;
 
     bool isset(int flg) { return (src_config->flags & flg) != 0; }
@@ -153,20 +160,30 @@ struct SRT_API LogDispatcher
         level(log_level),
         src_config(&config)
     {
-        // XXX stpcpy desired, but not enough portable
-        // Composing the exact prefix is not critical, so simply
-        // cut the prefix, if the length is exceeded
-
-        // See Logger::Logger; we know this has normally 2 characters,
-        // except !!FATAL!!, which has 9. Still less than 32.
-        strcpy(prefix, your_pfx);
+        const size_t your_pfx_len = your_pfx ? strlen(your_pfx) : 0;
+        const size_t logger_pfx_len = logger_pfx ? strlen(logger_pfx) : 0;
 
-        // If the size of the FA name together with severity exceeds the size,
-        // just skip the former.
-        if (logger_pfx && strlen(prefix) + strlen(logger_pfx) + 1 < MAX_PREFIX_SIZE)
+        if (logger_pfx && your_pfx_len + logger_pfx_len + 1 < MAX_PREFIX_SIZE)
+        {
+            memcpy(prefix, your_pfx, your_pfx_len);
+            prefix[your_pfx_len] = ':';
+            memcpy(prefix + your_pfx_len + 1, logger_pfx, logger_pfx_len);
+            prefix[your_pfx_len + logger_pfx_len + 1] = '\0';
+            prefix_len = your_pfx_len + logger_pfx_len + 1;
+        }
+        else if (your_pfx)
         {
-            strcat(prefix, ":");
-            strcat(prefix, logger_pfx);
+            // Prefix too long, so copy only your_pfx and only
+            // as much as it fits
+            size_t copylen = std::min(+MAX_PREFIX_SIZE, your_pfx_len);
+            memcpy(prefix, your_pfx, copylen);
+            prefix[copylen] = '\0';
+            prefix_len = copylen;
+        }
+        else
+        {
+            prefix[0] = '\0';
+            prefix_len = 0;
         }
     }
 
@@ -187,16 +204,16 @@ struct SRT_API LogDispatcher
     template <class... Args>
     void PrintLogLine(const char* file, int line, const std::string& area, Args&&... args);
 
-    template<class Arg1, class... Args>
-    void operator()(Arg1&& arg1, Args&&... args)
+    template<class... Args>
+    void operator()(Args&&... args)
     {
-        PrintLogLine("UNKNOWN.c++", 0, "UNKNOWN", arg1, args...);
+        PrintLogLine("UNKNOWN.c++", 0, "UNKNOWN", args...);
     }
 
-    template<class Arg1, class... Args>
-    void printloc(const char* file, int line, const std::string& area, Arg1&& arg1, Args&&... args)
+    template<class... Args>
+    void printloc(const char* file, int line, const std::string& area, Args&&... args)
     {
-        PrintLogLine(file, line, area, arg1, args...);
+        PrintLogLine(file, line, area, args...);
     }
 #else
     template <class Arg>
@@ -236,7 +253,14 @@ struct SRT_API LogDispatcher
             return *this;
         }
 
-        DummyProxy& form(const char*, ...)
+        // DEPRECATED: DO NOT use LOGF/HLOGF macros anymore.
+        // Use iostream-style formatting with LOGC or a direct argument with LOGP.
+        SRT_ATR_DEPRECATED_PX DummyProxy& form(const char*, ...) SRT_ATR_DEPRECATED
+        {
+            return *this;
+        }
+
+        DummyProxy& vform(const char*, va_list)
         {
             return *this;
         }
@@ -315,9 +339,9 @@ struct LogDispatcher::Proxy
 
     ~Proxy()
     {
-        if ( that_enabled )
+        if (that_enabled)
         {
-            if ( (flags & SRT_LOGF_DISABLE_EOL) == 0 )
+            if ((flags & SRT_LOGF_DISABLE_EOL) == 0)
                 os << std::endl;
             that.SendLogLine(i_file, i_line, area, os.str());
         }
@@ -345,7 +369,11 @@ struct LogDispatcher::Proxy
     {
         char buf[512];
 
-        vsprintf(buf, fmts, ap);
+#if defined(_MSC_VER) && _MSC_VER < 1900
+        _vsnprintf(buf, sizeof(buf) - 1, fmts, ap);
+#else
+        vsnprintf(buf, sizeof(buf), fmts, ap);
+#endif
         size_t len = strlen(buf);
         if ( buf[len-1] == '\n' )
         {
@@ -354,7 +382,7 @@ struct LogDispatcher::Proxy
             buf[len-1] = '\0';
         }
 
-        os << buf;
+        os.write(buf, len);
         return *this;
     }
 };
@@ -385,7 +413,6 @@ class Logger
         Fatal ( m_fa, LogLevel::fatal, "!!FATAL!!", logger_pfx, m_config )
     {
     }
-
 };
 
 inline bool LogDispatcher::CheckEnabled()
@@ -398,8 +425,10 @@ inline bool LogDispatcher::CheckEnabled()
     // when the enabler check is tested here. Worst case, the log
     // will be printed just a moment after it was turned off.
     const LogConfig* config = src_config; // to enforce using const operator[]
+    config->lock();
     int configured_enabled_fa = config->enabled_fa[fa];
     int configured_maxlevel = config->max_level;
+    config->unlock();
 
     return configured_enabled_fa && level <= configured_maxlevel;
 }
@@ -414,12 +443,12 @@ inline void PrintArgs(std::ostream&) {}
 template <class Arg1, class... Args>
 inline void PrintArgs(std::ostream& serr, Arg1&& arg1, Args&&... args)
 {
-    serr << arg1;
+    serr << std::forward<Arg1>(arg1);
     PrintArgs(serr, args...);
 }
 
 template <class... Args>
-inline void LogDispatcher::PrintLogLine(const char* file ATR_UNUSED, int line ATR_UNUSED, const std::string& area ATR_UNUSED, Args&&... args ATR_UNUSED)
+inline void LogDispatcher::PrintLogLine(const char* file SRT_ATR_UNUSED, int line SRT_ATR_UNUSED, const std::string& area SRT_ATR_UNUSED, Args&&... args SRT_ATR_UNUSED)
 {
 #ifdef ENABLE_LOGGING
     std::ostringstream serr;
@@ -434,10 +463,10 @@ inline void LogDispatcher::PrintLogLine(const char* file ATR_UNUSED, int line AT
 #endif
 }
 
-#else
+#else // !HAVE_CXX11
 
 template <class Arg>
-inline void LogDispatcher::PrintLogLine(const char* file ATR_UNUSED, int line ATR_UNUSED, const std::string& area ATR_UNUSED, const Arg& arg ATR_UNUSED)
+inline void LogDispatcher::PrintLogLine(const char* file SRT_ATR_UNUSED, int line SRT_ATR_UNUSED, const std::string& area SRT_ATR_UNUSED, const Arg& arg SRT_ATR_UNUSED)
 {
 #ifdef ENABLE_LOGGING
     std::ostringstream serr;
@@ -452,7 +481,7 @@ inline void LogDispatcher::PrintLogLine(const char* file ATR_UNUSED, int line AT
 #endif
 }
 
-#endif
+#endif // HAVE_CXX11
 
 // SendLogLine can be compiled normally. It's intermediately used by:
 // - Proxy object, which is replaced by DummyProxy when !ENABLE_LOGGING
@@ -466,7 +495,7 @@ inline void LogDispatcher::SendLogLine(const char* file, int line, const std::st
     }
     else if ( src_config->log_stream )
     {
-        (*src_config->log_stream) << msg;
+        src_config->log_stream->write(msg.data(), msg.size());
         (*src_config->log_stream).flush();
     }
     src_config->unlock();
@@ -474,4 +503,4 @@ inline void LogDispatcher::SendLogLine(const char* file, int line, const std::st
 
 }
 
-#endif
+#endif // INC_SRT_LOGGING_H
diff --git a/srtcore/md5.cpp b/srtcore/md5.cpp
index 9d01025f4..7fd139944 100644
--- a/srtcore/md5.cpp
+++ b/srtcore/md5.cpp
@@ -27,7 +27,7 @@
 
   This code implements the MD5 Algorithm defined in RFC 1321, whose
   text is available at
-	http://www.ietf.org/rfc/rfc1321.txt
+    http://www.ietf.org/rfc/rfc1321.txt
   The code is derived from the text of the RFC, including the test suite
   (section A.5) but excluding the rest of Appendix A.  It does not include
   any code or documentation that is identified in the RFC as being
@@ -38,159 +38,166 @@
   that follows (in reverse chronological order):
 
   2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
-	either statically or dynamically; added missing #include <string.h>
-	in library.
+    either statically or dynamically; added missing #include <string.h>
+    in library.
   2002-03-11 lpd Corrected argument list for main(), and added int return
-	type, in test program and T value program.
+    type, in test program and T value program.
   2002-02-21 lpd Added missing #include <stdio.h> in test program.
   2000-07-03 lpd Patched to eliminate warnings about "constant is
-	unsigned in ANSI C, signed in traditional"; made test program
-	self-checking.
+    unsigned in ANSI C, signed in traditional"; made test program
+    self-checking.
   1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
   1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
   1999-05-03 lpd Original version.
  */
 
 #include "md5.h"
+#include <stdint.h>
 #include <string.h>
 
-#undef BYTE_ORDER	/* 1 = big-endian, -1 = little-endian, 0 = unknown */
+/*
+ * All symbols have been put under the srt namespace
+ * to avoid potential linkage conflicts.
+ */
+namespace srt
+{
+
+#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
 #ifdef ARCH_IS_BIG_ENDIAN
-#  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
 #else
-#  define BYTE_ORDER 0
+#define BYTE_ORDER 0
 #endif
 
 #define T_MASK ((md5_word_t)~0)
 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
-#define T3    0x242070db
+#define T3 0x242070db
 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
-#define T6    0x4787c62a
+#define T6 0x4787c62a
 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
-#define T9    0x698098d8
+#define T9 0x698098d8
 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
-#define T13    0x6b901122
+#define T13 0x6b901122
 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
-#define T16    0x49b40821
+#define T16 0x49b40821
 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
-#define T19    0x265e5a51
+#define T19 0x265e5a51
 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
-#define T22    0x02441453
+#define T22 0x02441453
 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
-#define T25    0x21e1cde6
+#define T25 0x21e1cde6
 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
-#define T28    0x455a14ed
+#define T28 0x455a14ed
 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
-#define T31    0x676f02d9
+#define T31 0x676f02d9
 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
-#define T35    0x6d9d6122
+#define T35 0x6d9d6122
 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
-#define T38    0x4bdecfa9
+#define T38 0x4bdecfa9
 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
-#define T41    0x289b7ec6
+#define T41 0x289b7ec6
 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
-#define T44    0x04881d05
+#define T44 0x04881d05
 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
-#define T47    0x1fa27cf8
+#define T47 0x1fa27cf8
 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
-#define T50    0x432aff97
+#define T50 0x432aff97
 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
-#define T53    0x655b59c3
+#define T53 0x655b59c3
 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
-#define T57    0x6fa87e4f
+#define T57 0x6fa87e4f
 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
-#define T60    0x4e0811a1
+#define T60 0x4e0811a1
 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
-#define T63    0x2ad7d2bb
+#define T63 0x2ad7d2bb
 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
 
-
-static void
-md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/)
 {
-    md5_word_t
-	a = pms->abcd[0], b = pms->abcd[1],
-	c = pms->abcd[2], d = pms->abcd[3];
+    md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3];
     md5_word_t t;
 #if BYTE_ORDER > 0
     /* Define storage only for big-endian CPUs. */
     md5_word_t X[16];
 #else
     /* Define storage for little-endian or both types of CPUs. */
-    md5_word_t xbuf[16];
-    const md5_word_t *X;
+    md5_word_t        xbuf[16];
+    const md5_word_t* X;
 #endif
 
     {
 #if BYTE_ORDER == 0
-	/*
-	 * Determine dynamically whether this is a big-endian or
-	 * little-endian machine, since we can use a more efficient
-	 * algorithm on the latter.
-	 */
-	static const int w = 1;
-
-	if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
+        /*
+         * Determine dynamically whether this is a big-endian or
+         * little-endian machine, since we can use a more efficient
+         * algorithm on the latter.
+         */
+        static const int w = 1;
+
+        if (*((const md5_byte_t*)&w)) /* dynamic little-endian */
 #endif
-#if BYTE_ORDER <= 0		/* little-endian */
-	{
-	    /*
-	     * On little-endian machines, we can process properly aligned
-	     * data without copying it.
-	     */
-	    if (!((data - (const md5_byte_t *)0) & 3)) {
-		/* data are properly aligned */
-		X = (const md5_word_t *)data;
-	    } else {
-		/* not aligned */
-		memcpy((xbuf), data, 64);
-		X = xbuf;
-	    }
-	}
+#if BYTE_ORDER <= 0 /* little-endian */
+        {
+            /*
+             * On little-endian machines, we can process properly aligned
+             * data without copying it.
+             */
+            if (!(uintptr_t(data) & 3))
+            {
+                /* data are properly aligned */
+                X = (const md5_word_t*)data;
+            }
+            else
+            {
+                /* not aligned */
+                memcpy((xbuf), data, 64);
+                X = xbuf;
+            }
+        }
 #endif
 #if BYTE_ORDER == 0
-	else			/* dynamic big-endian */
+        else /* dynamic big-endian */
 #endif
-#if BYTE_ORDER >= 0		/* big-endian */
-	{
-	    /*
-	     * On big-endian machines, we must arrange the bytes in the
-	     * right order.
-	     */
-	    const md5_byte_t *xp = data;
-	    int i;
-
-#  if BYTE_ORDER == 0
-	    X = xbuf;		/* (dynamic only) */
-#  else
-#    define xbuf X		/* (static only) */
-#  endif
-	    for (i = 0; i < 16; ++i, xp += 4)
-		xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
-	}
+#if BYTE_ORDER >= 0 /* big-endian */
+        {
+            /*
+             * On big-endian machines, we must arrange the bytes in the
+             * right order.
+             */
+            const md5_byte_t* xp = data;
+            int               i;
+
+#if BYTE_ORDER == 0
+            X = xbuf; /* (dynamic only) */
+#else
+#define xbuf X /* (static only) */
+#endif
+            for (i = 0; i < 16; ++i, xp += 4)
+                xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+        }
 #endif
     }
 
@@ -200,182 +207,179 @@ md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
     /* Let [abcd k s i] denote the operation
        a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + F(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
+#define SET(a, b, c, d, k, s, Ti)                                                                                      \
+    t = a + F(b, c, d) + X[k] + Ti;                                                                                    \
+    a = ROTATE_LEFT(t, s) + b
     /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  7,  T1);
-    SET(d, a, b, c,  1, 12,  T2);
-    SET(c, d, a, b,  2, 17,  T3);
-    SET(b, c, d, a,  3, 22,  T4);
-    SET(a, b, c, d,  4,  7,  T5);
-    SET(d, a, b, c,  5, 12,  T6);
-    SET(c, d, a, b,  6, 17,  T7);
-    SET(b, c, d, a,  7, 22,  T8);
-    SET(a, b, c, d,  8,  7,  T9);
-    SET(d, a, b, c,  9, 12, T10);
+    SET(a, b, c, d, 0, 7, T1);
+    SET(d, a, b, c, 1, 12, T2);
+    SET(c, d, a, b, 2, 17, T3);
+    SET(b, c, d, a, 3, 22, T4);
+    SET(a, b, c, d, 4, 7, T5);
+    SET(d, a, b, c, 5, 12, T6);
+    SET(c, d, a, b, 6, 17, T7);
+    SET(b, c, d, a, 7, 22, T8);
+    SET(a, b, c, d, 8, 7, T9);
+    SET(d, a, b, c, 9, 12, T10);
     SET(c, d, a, b, 10, 17, T11);
     SET(b, c, d, a, 11, 22, T12);
-    SET(a, b, c, d, 12,  7, T13);
+    SET(a, b, c, d, 12, 7, T13);
     SET(d, a, b, c, 13, 12, T14);
     SET(c, d, a, b, 14, 17, T15);
     SET(b, c, d, a, 15, 22, T16);
 #undef SET
 
-     /* Round 2. */
-     /* Let [abcd k s i] denote the operation
-          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+    /* Round 2. */
+    /* Let [abcd k s i] denote the operation
+         a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + G(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  1,  5, T17);
-    SET(d, a, b, c,  6,  9, T18);
+#define SET(a, b, c, d, k, s, Ti)                                                                                      \
+    t = a + G(b, c, d) + X[k] + Ti;                                                                                    \
+    a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d, 1, 5, T17);
+    SET(d, a, b, c, 6, 9, T18);
     SET(c, d, a, b, 11, 14, T19);
-    SET(b, c, d, a,  0, 20, T20);
-    SET(a, b, c, d,  5,  5, T21);
-    SET(d, a, b, c, 10,  9, T22);
+    SET(b, c, d, a, 0, 20, T20);
+    SET(a, b, c, d, 5, 5, T21);
+    SET(d, a, b, c, 10, 9, T22);
     SET(c, d, a, b, 15, 14, T23);
-    SET(b, c, d, a,  4, 20, T24);
-    SET(a, b, c, d,  9,  5, T25);
-    SET(d, a, b, c, 14,  9, T26);
-    SET(c, d, a, b,  3, 14, T27);
-    SET(b, c, d, a,  8, 20, T28);
-    SET(a, b, c, d, 13,  5, T29);
-    SET(d, a, b, c,  2,  9, T30);
-    SET(c, d, a, b,  7, 14, T31);
+    SET(b, c, d, a, 4, 20, T24);
+    SET(a, b, c, d, 9, 5, T25);
+    SET(d, a, b, c, 14, 9, T26);
+    SET(c, d, a, b, 3, 14, T27);
+    SET(b, c, d, a, 8, 20, T28);
+    SET(a, b, c, d, 13, 5, T29);
+    SET(d, a, b, c, 2, 9, T30);
+    SET(c, d, a, b, 7, 14, T31);
     SET(b, c, d, a, 12, 20, T32);
 #undef SET
 
-     /* Round 3. */
-     /* Let [abcd k s t] denote the operation
-          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+    /* Round 3. */
+    /* Let [abcd k s t] denote the operation
+         a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
 #define H(x, y, z) ((x) ^ (y) ^ (z))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + H(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  5,  4, T33);
-    SET(d, a, b, c,  8, 11, T34);
+#define SET(a, b, c, d, k, s, Ti)                                                                                      \
+    t = a + H(b, c, d) + X[k] + Ti;                                                                                    \
+    a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d, 5, 4, T33);
+    SET(d, a, b, c, 8, 11, T34);
     SET(c, d, a, b, 11, 16, T35);
     SET(b, c, d, a, 14, 23, T36);
-    SET(a, b, c, d,  1,  4, T37);
-    SET(d, a, b, c,  4, 11, T38);
-    SET(c, d, a, b,  7, 16, T39);
+    SET(a, b, c, d, 1, 4, T37);
+    SET(d, a, b, c, 4, 11, T38);
+    SET(c, d, a, b, 7, 16, T39);
     SET(b, c, d, a, 10, 23, T40);
-    SET(a, b, c, d, 13,  4, T41);
-    SET(d, a, b, c,  0, 11, T42);
-    SET(c, d, a, b,  3, 16, T43);
-    SET(b, c, d, a,  6, 23, T44);
-    SET(a, b, c, d,  9,  4, T45);
+    SET(a, b, c, d, 13, 4, T41);
+    SET(d, a, b, c, 0, 11, T42);
+    SET(c, d, a, b, 3, 16, T43);
+    SET(b, c, d, a, 6, 23, T44);
+    SET(a, b, c, d, 9, 4, T45);
     SET(d, a, b, c, 12, 11, T46);
     SET(c, d, a, b, 15, 16, T47);
-    SET(b, c, d, a,  2, 23, T48);
+    SET(b, c, d, a, 2, 23, T48);
 #undef SET
 
-     /* Round 4. */
-     /* Let [abcd k s t] denote the operation
-          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+    /* Round 4. */
+    /* Let [abcd k s t] denote the operation
+         a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + I(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  6, T49);
-    SET(d, a, b, c,  7, 10, T50);
+#define SET(a, b, c, d, k, s, Ti)                                                                                      \
+    t = a + I(b, c, d) + X[k] + Ti;                                                                                    \
+    a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d, 0, 6, T49);
+    SET(d, a, b, c, 7, 10, T50);
     SET(c, d, a, b, 14, 15, T51);
-    SET(b, c, d, a,  5, 21, T52);
-    SET(a, b, c, d, 12,  6, T53);
-    SET(d, a, b, c,  3, 10, T54);
+    SET(b, c, d, a, 5, 21, T52);
+    SET(a, b, c, d, 12, 6, T53);
+    SET(d, a, b, c, 3, 10, T54);
     SET(c, d, a, b, 10, 15, T55);
-    SET(b, c, d, a,  1, 21, T56);
-    SET(a, b, c, d,  8,  6, T57);
+    SET(b, c, d, a, 1, 21, T56);
+    SET(a, b, c, d, 8, 6, T57);
     SET(d, a, b, c, 15, 10, T58);
-    SET(c, d, a, b,  6, 15, T59);
+    SET(c, d, a, b, 6, 15, T59);
     SET(b, c, d, a, 13, 21, T60);
-    SET(a, b, c, d,  4,  6, T61);
+    SET(a, b, c, d, 4, 6, T61);
     SET(d, a, b, c, 11, 10, T62);
-    SET(c, d, a, b,  2, 15, T63);
-    SET(b, c, d, a,  9, 21, T64);
+    SET(c, d, a, b, 2, 15, T63);
+    SET(b, c, d, a, 9, 21, T64);
 #undef SET
 
-     /* Then perform the following additions. (That is increment each
-        of the four registers by the value it had before this block
-        was started.) */
+    /* Then perform the following additions. (That is increment each
+       of the four registers by the value it had before this block
+       was started.) */
     pms->abcd[0] += a;
     pms->abcd[1] += b;
     pms->abcd[2] += c;
     pms->abcd[3] += d;
 }
 
-void
-md5_init(md5_state_t *pms)
+void md5_init(md5_state_t* pms)
 {
     pms->count[0] = pms->count[1] = 0;
-    pms->abcd[0] = 0x67452301;
-    pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
-    pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
-    pms->abcd[3] = 0x10325476;
+    pms->abcd[0]                  = 0x67452301;
+    pms->abcd[1]                  = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+    pms->abcd[2]                  = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+    pms->abcd[3]                  = 0x10325476;
 }
 
-void
-md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+void md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes)
 {
-    const md5_byte_t *p = data;
-    int left = nbytes;
-    int offset = (pms->count[0] >> 3) & 63;
-    md5_word_t nbits = (md5_word_t)(nbytes << 3);
+    const md5_byte_t* p      = data;
+    int               left   = nbytes;
+    int               offset = (pms->count[0] >> 3) & 63;
+    md5_word_t        nbits  = (md5_word_t)(nbytes << 3);
 
     if (nbytes <= 0)
-	return;
+        return;
 
     /* Update the message length. */
     pms->count[1] += nbytes >> 29;
     pms->count[0] += nbits;
     if (pms->count[0] < nbits)
-	pms->count[1]++;
+        pms->count[1]++;
 
     /* Process an initial partial block. */
-    if (offset) {
-	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
-
-	memcpy((pms->buf + offset), p, copy);
-	if (offset + copy < 64)
-	    return;
-	p += copy;
-	left -= copy;
-	md5_process(pms, pms->buf);
+    if (offset)
+    {
+        int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+        memcpy((pms->buf + offset), p, copy);
+        if (offset + copy < 64)
+            return;
+        p += copy;
+        left -= copy;
+        md5_process(pms, pms->buf);
     }
 
     /* Process full blocks. */
     for (; left >= 64; p += 64, left -= 64)
-	md5_process(pms, p);
+        md5_process(pms, p);
 
     /* Process a final partial block. */
     if (left)
-	memcpy((pms->buf), p, left);
+        memcpy((pms->buf), p, left);
 }
 
-void
-md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+void md5_finish(md5_state_t* pms, md5_byte_t digest[16])
 {
-    static const md5_byte_t pad[64] = {
-	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    };
-    md5_byte_t data[8];
-    int i;
+    static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                       0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                       0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    md5_byte_t              data[8];
+    int                     i;
 
     /* Save the length before padding. */
     for (i = 0; i < 8; ++i)
-	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+        data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
     /* Pad to 56 bytes mod 64. */
     md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
     /* Append the length. */
     md5_append(pms, data, 8);
     for (i = 0; i < 16; ++i)
-	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+        digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
 }
+
+} // namespace srt
diff --git a/srtcore/md5.h b/srtcore/md5.h
index f7402e7e2..643981c01 100644
--- a/srtcore/md5.h
+++ b/srtcore/md5.h
@@ -27,7 +27,7 @@
 
   This code implements the MD5 Algorithm defined in RFC 1321, whose
   text is available at
-	http://www.ietf.org/rfc/rfc1321.txt
+    http://www.ietf.org/rfc/rfc1321.txt
   The code is derived from the text of the RFC, including the test suite
   (section A.5) but excluding the rest of Appendix A.  It does not include
   any code or documentation that is identified in the RFC as being
@@ -38,17 +38,24 @@
   that follows (in reverse chronological order):
 
   2002-04-13 lpd Removed support for non-ANSI compilers; removed
-	references to Ghostscript; clarified derivation from RFC 1321;
-	now handles byte order either statically or dynamically.
+    references to Ghostscript; clarified derivation from RFC 1321;
+    now handles byte order either statically or dynamically.
   1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
   1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
-	added conditionalization for C++ compilation from Martin
-	Purschke <purschke@bnl.gov>.
+    added conditionalization for C++ compilation from Martin
+    Purschke <purschke@bnl.gov>.
   1999-05-03 lpd Original version.
  */
 
 #ifndef md5_INCLUDED
-#  define md5_INCLUDED
+#define md5_INCLUDED
+
+/*
+ * All symbols have been put under the srt namespace
+ * to avoid potential linkage conflicts.
+ */
+namespace srt
+{
 
 /*
  * This package supports both compile-time and run-time determination of CPU
@@ -61,31 +68,25 @@
  */
 
 typedef unsigned char md5_byte_t; /* 8-bit byte */
-typedef unsigned int md5_word_t; /* 32-bit word */
+typedef unsigned int  md5_word_t; /* 32-bit word */
 
 /* Define the state of the MD5 Algorithm. */
-typedef struct md5_state_s {
-    md5_word_t count[2];	/* message length in bits, lsw first */
-    md5_word_t abcd[4];		/* digest buffer */
-    md5_byte_t buf[64];		/* accumulate block */
-} md5_state_t;
-
-#ifdef __cplusplus
-extern "C" 
+typedef struct md5_state_s
 {
-#endif
+    md5_word_t count[2]; /* message length in bits, lsw first */
+    md5_word_t abcd[4];  /* digest buffer */
+    md5_byte_t buf[64];  /* accumulate block */
+} md5_state_t;
 
 /* Initialize the algorithm. */
-void md5_init(md5_state_t *pms);
+void md5_init(md5_state_t* pms);
 
 /* Append a string to the message. */
-void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+void md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes);
 
 /* Finish the message and return the digest. */
-void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+void md5_finish(md5_state_t* pms, md5_byte_t digest[16]);
 
-#ifdef __cplusplus
-}  /* end extern "C" */
-#endif
+} // namespace srt
 
 #endif /* md5_INCLUDED */
diff --git a/srtcore/netinet_any.h b/srtcore/netinet_any.h
index 3a17e228f..a38765c08 100644
--- a/srtcore/netinet_any.h
+++ b/srtcore/netinet_any.h
@@ -27,6 +27,9 @@ written by
 // You can use the instances of sockaddr_any in every place where sockaddr is
 // required.
 
+namespace srt
+{
+
 struct sockaddr_any
 {
     union
@@ -418,4 +421,6 @@ inline sockaddr_any::TypeMap<AF_INET>::type& sockaddr_any::get<AF_INET>() { retu
 template <>
 inline sockaddr_any::TypeMap<AF_INET6>::type& sockaddr_any::get<AF_INET6>() { return sin6; }
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/packet.cpp b/srtcore/packet.cpp
index 5b8bada83..180623039 100644
--- a/srtcore/packet.cpp
+++ b/srtcore/packet.cpp
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -50,7 +50,6 @@ modified by
    Haivision Systems Inc.
 *****************************************************************************/
 
-
 //////////////////////////////////////////////////////////////////////////////
 //    0                   1                   2                   3
 //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -137,9 +136,9 @@ modified by
 //              Add. Info:    Error code
 //              Control Info: None
 //      0x7FFF: Explained by bits 16 - 31 (UMSG_EXT)
-//              
+//
 //   bit 16 - 31:
-//      This space is used for future expansion or user defined control packets. 
+//      This space is used for future expansion or user defined control packets.
 //
 //    0                   1                   2                   3
 //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -152,15 +151,15 @@ modified by
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //
 //   Loss List Field Coding:
-//      For any consectutive lost seqeunce numbers that the differnece between
+//      For any consecutive lost seqeunce numbers that the differnece between
 //      the last and first is more than 1, only record the first (a) and the
 //      the last (b) sequence numbers in the loss list field, and modify the
 //      the first bit of a to 1.
-//      For any single loss or consectutive loss less than 2 packets, use
+//      For any single loss or consecutive loss less than 2 packets, use
 //      the original sequence numbers in the field.
 
 #include "platform_sys.h"
-
+#include <cstddef>
 #include <cstring>
 #include "packet.h"
 #include "handshake.h"
@@ -169,19 +168,18 @@ modified by
 
 namespace srt_logging
 {
-    extern Logger inlog;
+extern Logger inlog;
 }
 using namespace srt_logging;
 
+namespace srt {
+
 // Set up the aliases in the constructure
-CPacket::CPacket():
-m_extra_pad(),
-m_data_owned(false),
-m_iSeqNo((int32_t&)(m_nHeader[SRT_PH_SEQNO])),
-m_iMsgNo((int32_t&)(m_nHeader[SRT_PH_MSGNO])),
-m_iTimeStamp((int32_t&)(m_nHeader[SRT_PH_TIMESTAMP])),
-m_iID((int32_t&)(m_nHeader[SRT_PH_ID])),
-m_pcData((char*&)(m_PacketVector[PV_DATA].dataRef()))
+CPacket::CPacket()
+    : m_nHeader() // Silences GCC 12 warning "used uninitialized".
+    , m_extra_pad()
+    , m_data_owned(false)
+    , m_pcData((char*&)(m_PacketVector[PV_DATA].dataRef()))
 {
     m_nHeader.clear();
 
@@ -208,7 +206,7 @@ void CPacket::allocate(size_t alloc_buffer_size)
             return; // already allocated
 
         // Would be nice to reallocate; for now just allocate again.
-        delete [] m_pcData;
+        delete[] m_pcData;
     }
     m_PacketVector[PV_DATA].set(new char[alloc_buffer_size], alloc_buffer_size);
     m_data_owned = true;
@@ -217,8 +215,9 @@ void CPacket::allocate(size_t alloc_buffer_size)
 void CPacket::deallocate()
 {
     if (m_data_owned)
-        delete [] (char*)m_PacketVector[PV_DATA].data();
+        delete[](char*) m_PacketVector[PV_DATA].data();
     m_PacketVector[PV_DATA].set(NULL, 0);
+    m_data_owned = false;
 }
 
 char* CPacket::release()
@@ -227,7 +226,7 @@ char* CPacket::release()
     char* buffer = NULL;
     if (m_data_owned)
     {
-        buffer = getData();
+        buffer       = getData();
         m_data_owned = false;
     }
 
@@ -239,171 +238,229 @@ CPacket::~CPacket()
 {
     // PV_HEADER is always owned, PV_DATA may use a "borrowed" buffer.
     // Delete the internal buffer only if it was declared as owned.
-    if (m_data_owned)
-        delete[](char*)m_PacketVector[PV_DATA].data();
+    deallocate();
 }
 
-
 size_t CPacket::getLength() const
 {
-   return m_PacketVector[PV_DATA].size();
+    return m_PacketVector[PV_DATA].size();
 }
 
 void CPacket::setLength(size_t len)
 {
-   m_PacketVector[PV_DATA].setLength(len);
+    m_PacketVector[PV_DATA].setLength(len);
 }
 
-void CPacket::pack(UDTMessageType pkttype, const int32_t* lparam, void* rparam, int size)
+void CPacket::setLength(size_t len, size_t cap)
 {
-    // Set (bit-0 = 1) and (bit-1~15 = type)
-    setControl(pkttype);
-    HLOGC(inlog.Debug, log << "pack: type=" << MessageTypeStr(pkttype)
-            << " ARG=" << (lparam ? Sprint(*lparam) : std::string("NULL"))
-            << " [ " << (rparam ? Sprint(*(int32_t*)rparam) : std::string()) << " ]");
-
-   // Set additional information and control information field
-   switch (pkttype)
-   {
-   case UMSG_ACK: //0010 - Acknowledgement (ACK)
-      // ACK packet seq. no.
-      if (NULL != lparam)
-         m_nHeader[SRT_PH_MSGNO] = *lparam;
-
-      // data ACK seq. no. 
-      // optional: RTT (microsends), RTT variance (microseconds) advertised flow window size (packets), and estimated link capacity (packets per second)
-      m_PacketVector[PV_DATA].set(rparam, size);
-
-      break;
-
-   case UMSG_ACKACK: //0110 - Acknowledgement of Acknowledgement (ACK-2)
-      // ACK packet seq. no.
-      m_nHeader[SRT_PH_MSGNO] = *lparam;
-
-      // control info field should be none
-      // but "writev" does not allow this
-      m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-
-      break;
-
-   case UMSG_LOSSREPORT: //0011 - Loss Report (NAK)
-      // loss list
-      m_PacketVector[PV_DATA].set(rparam, size);
-
-      break;
-
-   case UMSG_CGWARNING: //0100 - Congestion Warning
-      // control info field should be none
-      // but "writev" does not allow this
-      m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-  
-      break;
-
-   case UMSG_KEEPALIVE: //0001 - Keep-alive
-      if (lparam)
-      {
-          // XXX EXPERIMENTAL. Pass the 32-bit integer here.
-          m_nHeader[SRT_PH_MSGNO] = *lparam;
-      }
-      // control info field should be none
-      // but "writev" does not allow this
-      m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-
-      break;
-
-   case UMSG_HANDSHAKE: //0000 - Handshake
-      // control info filed is handshake info
-      m_PacketVector[PV_DATA].set(rparam, size);
-
-      break;
-
-   case UMSG_SHUTDOWN: //0101 - Shutdown
-      // control info field should be none
-      // but "writev" does not allow this
-      m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-
-      break;
-
-   case UMSG_DROPREQ: //0111 - Message Drop Request
-      // msg id 
-      m_nHeader[SRT_PH_MSGNO] = *lparam;
-
-      //first seq no, last seq no
-      m_PacketVector[PV_DATA].set(rparam, size);
-
-      break;
-
-   case UMSG_PEERERROR: //1000 - Error Signal from the Peer Side
-      // Error type
-      m_nHeader[SRT_PH_MSGNO] = *lparam;
-
-      // control info field should be none
-      // but "writev" does not allow this
-      m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-
-      break;
-
-   case UMSG_EXT: //0x7FFF - Reserved for user defined control packets
-      // for extended control packet
-      // "lparam" contains the extended type information for bit 16 - 31
-      // "rparam" is the control information
-      m_nHeader[SRT_PH_SEQNO] |= *lparam;
-
-      if (NULL != rparam)
-      {
-         m_PacketVector[PV_DATA].set(rparam, size);
-      }
-      else
-      {
-         m_PacketVector[PV_DATA].set((void *)&m_extra_pad, 4);
-      }
-
-      break;
-
-   default:
-      break;
-   }
+   SRT_ASSERT(len <= cap);
+   setLength(len);
+   m_zCapacity = cap;
 }
 
-void CPacket::toNL()
+#if ENABLE_HEAVY_LOGGING
+// Debug only
+static std::string FormatNumbers(UDTMessageType pkttype, const int32_t* lparam, void* rparam, const size_t size)
 {
-    // XXX USE HtoNLA!
-    if (isControl())
+    // This may be changed over time, so use special interpretation
+    // only for certain types, and still display all data, no matter
+    // if it is expected to provide anything or not.
+    std::ostringstream out;
+
+    out << "ARG=";
+    if (lparam)
+        out << *lparam;
+    else
+        out << "none";
+
+    if (size == 0)
+    {
+        out << " [no data]";
+        return out.str();
+    }
+    else if (!rparam)
     {
-        for (ptrdiff_t i = 0, n = getLength() / 4; i < n; ++i)
-            *((uint32_t*)m_pcData + i) = htonl(*((uint32_t*)m_pcData + i));
+        out << " [ {" << size << "} ]";
+        return out.str();
     }
 
-    // convert packet header into network order
-    uint32_t* p = m_nHeader;
-    for (int j = 0; j < 4; ++j)
+    bool interp_as_seq = (pkttype == UMSG_LOSSREPORT || pkttype == UMSG_DROPREQ);
+    bool display_dec = (pkttype == UMSG_ACK || pkttype == UMSG_ACKACK || pkttype == UMSG_DROPREQ);
+
+    out << " [ ";
+
+    // Will be effective only for hex/oct.
+    out << std::showbase;
+
+    const size_t size32 = size/4;
+    for (size_t i = 0; i < size32; ++i)
     {
-        *p = htonl(*p);
-        ++p;
+        int32_t val = ((int32_t*)rparam)[i];
+        if (interp_as_seq)
+        {
+            if (val & LOSSDATA_SEQNO_RANGE_FIRST)
+                out << "<" << (val & (~LOSSDATA_SEQNO_RANGE_FIRST)) << ">";
+            else
+                out << val;
+        }
+        else
+        {
+            if (!display_dec)
+            {
+                out << std::hex;
+                out << val << "/";
+                out << std::dec;
+            }
+            out << val;
+
+        }
+        out << " ";
     }
+
+    out << "]";
+    return out.str();
 }
+#endif
 
-void CPacket::toHL()
+void CPacket::pack(UDTMessageType pkttype, const int32_t* lparam, void* rparam, size_t size)
 {
-    // convert back into local host order
-    uint32_t* p = m_nHeader;
-    for (int k = 0; k < 4; ++k)
+    // Set (bit-0 = 1) and (bit-1~15 = type)
+    setControl(pkttype);
+    HLOGC(inlog.Debug, log << "pack: type=" << MessageTypeStr(pkttype) << " " << FormatNumbers(pkttype, lparam, rparam, size));
+
+    // Set additional information and control information field
+    switch (pkttype)
     {
-        *p = ntohl(*p);
-        ++p;
+    case UMSG_ACK: // 0010 - Acknowledgement (ACK)
+        // ACK packet seq. no.
+        if (NULL != lparam)
+            m_nHeader[SRT_PH_MSGNO] = *lparam;
+
+        // data ACK seq. no.
+        // optional: RTT (microsends), RTT variance (microseconds) advertised flow window size (packets), and estimated
+        // link capacity (packets per second)
+        m_PacketVector[PV_DATA].set(rparam, size);
+
+        break;
+
+    case UMSG_ACKACK: // 0110 - Acknowledgement of Acknowledgement (ACK-2)
+        // ACK packet seq. no.
+        m_nHeader[SRT_PH_MSGNO] = *lparam;
+
+        // control info field should be none
+        // but "writev" does not allow this
+        m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+
+        break;
+
+    case UMSG_LOSSREPORT: // 0011 - Loss Report (NAK)
+        // loss list
+        m_PacketVector[PV_DATA].set(rparam, size);
+
+        break;
+
+    case UMSG_CGWARNING: // 0100 - Congestion Warning
+        // control info field should be none
+        // but "writev" does not allow this
+        m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+
+        break;
+
+    case UMSG_KEEPALIVE: // 0001 - Keep-alive
+        if (lparam)
+        {
+            // XXX EXPERIMENTAL. Pass the 32-bit integer here.
+            m_nHeader[SRT_PH_MSGNO] = *lparam;
+        }
+        // control info field should be none
+        // but "writev" does not allow this
+        m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+
+        break;
+
+    case UMSG_HANDSHAKE: // 0000 - Handshake
+        // control info filed is handshake info
+        m_PacketVector[PV_DATA].set(rparam, size);
+
+        break;
+
+    case UMSG_SHUTDOWN: // 0101 - Shutdown
+        // control info field should be none
+        // but "writev" does not allow this
+        m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+
+        break;
+
+    case UMSG_DROPREQ: // 0111 - Message Drop Request
+        // msg id
+        m_nHeader[SRT_PH_MSGNO] = *lparam;
+
+        // first seq no, last seq no
+        m_PacketVector[PV_DATA].set(rparam, size);
+
+        break;
+
+    case UMSG_PEERERROR: // 1000 - Error Signal from the Peer Side
+        // Error type
+        m_nHeader[SRT_PH_MSGNO] = *lparam;
+
+        // control info field should be none
+        // but "writev" does not allow this
+        m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+
+        break;
+
+    case UMSG_EXT: // 0x7FFF - Reserved for user defined control packets
+        // for extended control packet
+        // "lparam" contains the extended type information for bit 16 - 31
+        // "rparam" is the control information
+        m_nHeader[SRT_PH_SEQNO] |= *lparam;
+
+        if (NULL != rparam)
+        {
+            m_PacketVector[PV_DATA].set(rparam, size);
+        }
+        else
+        {
+            m_PacketVector[PV_DATA].set((void*)&m_extra_pad, 4);
+        }
+
+        break;
+
+    default:
+        break;
     }
+}
 
+void CPacket::toNetworkByteOrder()
+{
+    // The payload of data packet should remain in network byte order.
     if (isControl())
     {
-        for (ptrdiff_t l = 0, n = getLength() / 4; l < n; ++l)
-            *((uint32_t*) m_pcData + l) = ntohl(*((uint32_t*) m_pcData + l));
+        HtoNLA((uint32_t*) m_pcData, (const uint32_t*) m_pcData, getLength() / 4);
     }
+
+    // Convert packet header independent of packet type.
+    uint32_t* p = m_nHeader;
+    HtoNLA(p, p, 4);
 }
 
+void CPacket::toHostByteOrder()
+{
+    // Convert packet header independent of packet type.
+    uint32_t* p = m_nHeader;
+    NtoHLA(p, p, 4);
+
+	// The payload of data packet should remain in network byte order.
+    if (isControl())
+    {
+        NtoHLA((uint32_t*)m_pcData, (const uint32_t*)m_pcData, getLength() / 4);
+    }
+}
 
 IOVector* CPacket::getPacketVector()
 {
-   return m_PacketVector;
+    return m_PacketVector;
 }
 
 UDTMessageType CPacket::getType() const
@@ -418,11 +475,11 @@ int CPacket::getExtendedType() const
 
 int32_t CPacket::getAckSeqNo() const
 {
-   // read additional information field
-   // This field is used only in UMSG_ACK and UMSG_ACKACK,
-   // so 'getAckSeqNo' symbolically defines the only use of it
-   // in case of CONTROL PACKET.
-   return m_nHeader[SRT_PH_MSGNO];
+    // read additional information field
+    // This field is used only in UMSG_ACK and UMSG_ACKACK,
+    // so 'getAckSeqNo' symbolically defines the only use of it
+    // in case of CONTROL PACKET.
+    return m_nHeader[SRT_PH_MSGNO];
 }
 
 uint16_t CPacket::getControlFlags() const
@@ -441,12 +498,12 @@ PacketBoundary CPacket::getMsgBoundary() const
 
 bool CPacket::getMsgOrderFlag() const
 {
-    return 0!=  MSGNO_PACKET_INORDER::unwrap(m_nHeader[SRT_PH_MSGNO]);
+    return 0 != MSGNO_PACKET_INORDER::unwrap(m_nHeader[SRT_PH_MSGNO]);
 }
 
 int32_t CPacket::getMsgSeq(bool has_rexmit) const
 {
-    if ( has_rexmit )
+    if (has_rexmit)
     {
         return MSGNO_SEQ::unwrap(m_nHeader[SRT_PH_MSGNO]);
     }
@@ -458,8 +515,13 @@ int32_t CPacket::getMsgSeq(bool has_rexmit) const
 
 bool CPacket::getRexmitFlag() const
 {
-    // return false; //
-    return 0 !=  MSGNO_REXMIT::unwrap(m_nHeader[SRT_PH_MSGNO]);
+    return 0 != MSGNO_REXMIT::unwrap(m_nHeader[SRT_PH_MSGNO]);
+}
+
+void CPacket::setRexmitFlag(bool bRexmit)
+{
+    const int32_t clr_msgno = m_nHeader[SRT_PH_MSGNO] & ~MSGNO_REXMIT::mask;
+    m_nHeader[SRT_PH_MSGNO] = clr_msgno | MSGNO_REXMIT::wrap(bRexmit? 1 : 0);
 }
 
 EncryptionKeySpec CPacket::getMsgCryptoFlags() const
@@ -472,25 +534,26 @@ EncryptionKeySpec CPacket::getMsgCryptoFlags() const
 // crypto flags after encrypting a packet.
 void CPacket::setMsgCryptoFlags(EncryptionKeySpec spec)
 {
-    int32_t clr_msgno = m_nHeader[SRT_PH_MSGNO] & ~MSGNO_ENCKEYSPEC::mask;
+    int32_t clr_msgno       = m_nHeader[SRT_PH_MSGNO] & ~MSGNO_ENCKEYSPEC::mask;
     m_nHeader[SRT_PH_MSGNO] = clr_msgno | EncryptionKeyBits(spec);
 }
 
 uint32_t CPacket::getMsgTimeStamp() const
 {
-   // SRT_DEBUG_TSBPD_WRAP may enable smaller timestamp for faster wraparoud handling tests
-   return (uint32_t)m_nHeader[SRT_PH_TIMESTAMP] & TIMESTAMP_MASK;
+    // SRT_DEBUG_TSBPD_WRAP used to enable smaller timestamps for faster testing of how wraparounds are handled
+    return (uint32_t)m_nHeader[SRT_PH_TIMESTAMP] & TIMESTAMP_MASK;
 }
 
 CPacket* CPacket::clone() const
 {
-   CPacket* pkt = new CPacket;
-   memcpy((pkt->m_nHeader), m_nHeader, HDR_SIZE);
-   pkt->m_pcData = new char[m_PacketVector[PV_DATA].size()];
-   memcpy((pkt->m_pcData), m_pcData, m_PacketVector[PV_DATA].size());
-   pkt->m_PacketVector[PV_DATA].setLength(m_PacketVector[PV_DATA].size());
-
-   return pkt;
+    CPacket* pkt = new CPacket;
+    memcpy((pkt->m_nHeader), m_nHeader, HDR_SIZE);
+    pkt->allocate(this->getLength());
+    SRT_ASSERT(this->getLength() == pkt->getLength());
+    memcpy((pkt->m_pcData), m_pcData, this->getLength());
+    pkt->m_DestAddr = m_DestAddr;
+
+    return pkt;
 }
 
 // Useful for debugging
@@ -500,10 +563,10 @@ std::string PacketMessageFlagStr(uint32_t msgno_field)
 
     stringstream out;
 
-    static const char* const boundary [] = { "PB_SUBSEQUENT", "PB_LAST", "PB_FIRST", "PB_SOLO" };
-    static const char* const order [] = { "ORD_RELAXED", "ORD_REQUIRED" };
-    static const char* const crypto [] = { "EK_NOENC", "EK_EVEN", "EK_ODD", "EK*ERROR" };
-    static const char* const rexmit [] = { "SN_ORIGINAL", "SN_REXMIT" };
+    static const char* const boundary[] = {"PB_SUBSEQUENT", "PB_LAST", "PB_FIRST", "PB_SOLO"};
+    static const char* const order[]    = {"ORD_RELAXED", "ORD_REQUIRED"};
+    static const char* const crypto[]   = {"EK_NOENC", "EK_EVEN", "EK_ODD", "EK*ERROR"};
+    static const char* const rexmit[]   = {"SN_ORIGINAL", "SN_REXMIT"};
 
     out << boundary[MSGNO_PACKET_BOUNDARY::unwrap(msgno_field)] << " ";
     out << order[MSGNO_PACKET_INORDER::unwrap(msgno_field)] << " ";
@@ -525,7 +588,7 @@ inline void SprintSpecialWord(std::ostream& os, int32_t val)
 std::string CPacket::Info()
 {
     std::ostringstream os;
-    os << "TARGET=@" << m_iID << " ";
+    os << "TARGET=@" << id() << " ";
 
     if (isControl())
     {
@@ -553,8 +616,8 @@ std::string CPacket::Info()
             // display all numbers in the array with the following restrictions:
             // - all data contained in the buffer are considered 32-bit integer
             // - sign flag will be cleared before displaying, with additional mark
-            size_t wordlen = getLength()/4; // drop any remainder if present
-            int32_t* array = (int32_t*)m_pcData;
+            size_t   wordlen = getLength() / 4; // drop any remainder if present
+            int32_t* array   = (int32_t*)m_pcData;
             os << " [ ";
             for (size_t i = 0; i < wordlen; ++i)
             {
@@ -570,12 +633,12 @@ std::string CPacket::Info()
         // This is only a log, nothing crucial, so we can risk displaying incorrect message number.
         // Declaring that the peer supports rexmit flag cuts off the highest bit from
         // the displayed number.
-        os << "DATA: size=" << getLength()
-            << " " << BufferStamp(m_pcData, getLength())
-            << " #" << getMsgSeq(true) << " %" << getSeqNo()
-            << " " << MessageFlagStr();
+        os << "DATA: size=" << getLength() << " " << BufferStamp(m_pcData, getLength()) << " #" << getMsgSeq(true)
+           << " %" << getSeqNo() << " " << MessageFlagStr();
     }
 
     return os.str();
 }
 #endif
+
+} // end namespace srt
diff --git a/srtcore/packet.h b/srtcore/packet.h
index 31dbda411..5a6d6eb15 100644
--- a/srtcore/packet.h
+++ b/srtcore/packet.h
@@ -1,11 +1,11 @@
 /*
- * SRT - Secure, Reliable, Transport
+ * SRT - Secure Reliable Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -59,10 +59,13 @@ modified by
 #include "netinet_any.h"
 #include "packetfilter_api.h"
 
+namespace srt
+{
+
 //////////////////////////////////////////////////////////////////////////////
 // The purpose of the IOVector class is to proide a platform-independet interface
 // to the WSABUF on Windows and iovec on Linux, that can be easilly converted
-// to the native structure for use in WSARecvFrom() and recvmsg(...) functions 
+// to the native structure for use in WSARecvFrom() and recvmsg(...) functions
 class IOVector
 #ifdef _WIN32
     : public WSABUF
@@ -71,15 +74,16 @@ class IOVector
 #endif
 {
 public:
+    IOVector() { set(NULL, 0); }
 
-    inline void set(void  *buffer, size_t length)
+    inline void set(void* buffer, size_t length)
     {
 #ifdef _WIN32
         len = (ULONG)length;
         buf = (CHAR*)buffer;
 #else
         iov_base = (void*)buffer;
-        iov_len = length;
+        iov_len  = length;
 #endif
     }
 
@@ -88,7 +92,7 @@ class IOVector
 #ifdef _WIN32
         return buf;
 #else
-        return (char*&) iov_base;
+        return (char*&)iov_base;
 #endif
     }
 
@@ -104,7 +108,7 @@ class IOVector
     inline size_t size() const
     {
 #ifdef _WIN32
-        return (size_t) len;
+        return (size_t)len;
 #else
         return iov_len;
 #endif
@@ -113,24 +117,20 @@ class IOVector
     inline void setLength(size_t length)
     {
 #ifdef _WIN32
-        len = length;
+        len = (ULONG)length;
 #else
         iov_len = length;
 #endif
     }
 };
 
-
 /// To define packets in order in the buffer. This is public due to being used in buffer.
 enum PacketBoundary
 {
-    PB_SUBSEQUENT = 0, // 00
-///      01: last packet of a message
-    PB_LAST = 1, // 01
-///      10: first packet of a message
-    PB_FIRST = 2, // 10
-///      11: solo message packet
-    PB_SOLO = 3, // 11
+    PB_SUBSEQUENT = 0, // 00: a packet in the middle of a message, neither the first, not the last.
+    PB_LAST       = 1, // 01: last packet of a message
+    PB_FIRST      = 2, // 10: first packet of a message
+    PB_SOLO       = 3, // 11: solo message packet
 };
 
 // Breakdown of the PM_SEQNO field in the header:
@@ -138,7 +138,7 @@ enum PacketBoundary
 typedef Bits<31> SEQNO_CONTROL;
 //  1|T T T T T T T T T T T T T T T|E E...E
 typedef Bits<30, 16> SEQNO_MSGTYPE;
-typedef Bits<15, 0> SEQNO_EXTTYPE;
+typedef Bits<15, 0>  SEQNO_EXTTYPE;
 //  0|S S ... S
 typedef Bits<30, 0> SEQNO_VALUE;
 
@@ -152,7 +152,7 @@ const int32_t LOSSDATA_SEQNO_RANGE_LAST = 0, LOSSDATA_SEQNO_SOLO = 0;
 
 inline int32_t CreateControlSeqNo(UDTMessageType type)
 {
-    return SEQNO_CONTROL::mask | SEQNO_MSGTYPE::wrap(size_t(type));
+    return SEQNO_CONTROL::mask | SEQNO_MSGTYPE::wrap(uint32_t(type));
 }
 
 inline int32_t CreateControlExtSeqNo(int exttype)
@@ -162,11 +162,11 @@ inline int32_t CreateControlExtSeqNo(int exttype)
 
 // MSGNO breakdown: B B|O|K K|R|M M M M M M M M M M...M
 typedef Bits<31, 30> MSGNO_PACKET_BOUNDARY;
-typedef Bits<29> MSGNO_PACKET_INORDER;
+typedef Bits<29>     MSGNO_PACKET_INORDER;
 typedef Bits<28, 27> MSGNO_ENCKEYSPEC;
 #if 1 // can block rexmit flag
 // New bit breakdown - rexmit flag supported.
-typedef Bits<26> MSGNO_REXMIT;
+typedef Bits<26>    MSGNO_REXMIT;
 typedef Bits<25, 0> MSGNO_SEQ;
 // Old bit breakdown - no rexmit flag
 typedef Bits<26, 0> MSGNO_SEQ_OLD;
@@ -174,35 +174,36 @@ typedef Bits<26, 0> MSGNO_SEQ_OLD;
 // The message should be extracted as PMASK_MSGNO_SEQ, if REXMIT is supported, and PMASK_MSGNO_SEQ_OLD otherwise.
 
 const uint32_t PACKET_SND_NORMAL = 0, PACKET_SND_REXMIT = MSGNO_REXMIT::mask;
-const int MSGNO_SEQ_MAX = MSGNO_SEQ::mask;
+const int      MSGNO_SEQ_MAX = MSGNO_SEQ::mask;
 
 #else
 // Old bit breakdown - no rexmit flag
 typedef Bits<26, 0> MSGNO_SEQ;
 #endif
 
-typedef RollNumber<MSGNO_SEQ::size-1, 1> MsgNo;
-
+typedef RollNumber<MSGNO_SEQ::size - 1, 1> MsgNo;
 
 // constexpr in C++11 !
-inline int32_t PacketBoundaryBits(PacketBoundary o) { return MSGNO_PACKET_BOUNDARY::wrap(int32_t(o)); }
-
+inline int32_t PacketBoundaryBits(PacketBoundary o)
+{
+    return MSGNO_PACKET_BOUNDARY::wrap(int32_t(o));
+}
 
 enum EncryptionKeySpec
 {
     EK_NOENC = 0,
-    EK_EVEN = 1,
-    EK_ODD = 2
+    EK_EVEN  = 1,
+    EK_ODD   = 2
 };
 
 enum EncryptionStatus
 {
-    ENCS_CLEAR = 0,
+    ENCS_CLEAR  = 0,
     ENCS_FAILED = -1,
     ENCS_NOTSUP = -2
 };
 
-const int32_t PMASK_MSGNO_ENCKEYSPEC = MSGNO_ENCKEYSPEC::mask;
+const int32_t  PMASK_MSGNO_ENCKEYSPEC = MSGNO_ENCKEYSPEC::mask;
 inline int32_t EncryptionKeyBits(EncryptionKeySpec f)
 {
     return MSGNO_ENCKEYSPEC::wrap(int32_t(f));
@@ -216,218 +217,188 @@ const int32_t PUMASK_SEQNO_PROBE = 0xF;
 
 std::string PacketMessageFlagStr(uint32_t msgno_field);
 
-class CChannel;
-
 class CPacket
 {
-friend class CChannel;
-friend class CSndQueue;
-friend class CRcvQueue;
+    friend class CChannel;
+    friend class CSndQueue;
+    friend class CRcvQueue;
 
 public:
-   CPacket();
-   ~CPacket();
-
-   void allocate(size_t size);
-   void deallocate();
-
-      /// Get the payload or the control information field length.
-      /// @return the payload or the control information field length.
-
-   size_t getLength() const;
-
-      /// Set the payload or the control information field length.
-      /// @param len [in] the payload or the control information field length.
+    CPacket();
+    ~CPacket();
 
-   void setLength(size_t len);
+    void allocate(size_t size);
+    void deallocate();
 
-      /// Pack a Control packet.
-      /// @param pkttype [in] packet type filed.
-      /// @param lparam [in] pointer to the first data structure, explained by the packet type.
-      /// @param rparam [in] pointer to the second data structure, explained by the packet type.
-      /// @param size [in] size of rparam, in number of bytes;
+    /// Get the payload or the control information field length.
+    /// @return the payload or the control information field length.
+    size_t getLength() const;
 
-   void pack(UDTMessageType pkttype, const int32_t* lparam = NULL, void* rparam = NULL, int size = 0);
+    /// Set the payload or the control information field length.
+    /// @param len [in] the payload or the control information field length.
+    void setLength(size_t len);
 
-      /// Read the packet vector.
-      /// @return Pointer to the packet vector.
+    /// Set the payload or the control information field length.
+    /// @param len [in] the payload or the control information field length.
+    /// @param cap [in] capacity (if known).
+    void setLength(size_t len, size_t cap);
 
-   IOVector* getPacketVector();
+    /// Pack a Control packet.
+    /// @param pkttype [in] packet type filed.
+    /// @param lparam [in] pointer to the first data structure, explained by the packet type.
+    /// @param rparam [in] pointer to the second data structure, explained by the packet type.
+    /// @param size [in] size of rparam, in number of bytes;
+    void pack(UDTMessageType pkttype, const int32_t* lparam = NULL, void* rparam = NULL, size_t size = 0);
 
-   uint32_t* getHeader() { return m_nHeader; }
+    /// Read the packet vector.
+    /// @return Pointer to the packet vector.
+    IOVector* getPacketVector();
 
-      /// Read the packet flag.
-      /// @return packet flag (0 or 1).
+    uint32_t* getHeader() { return m_nHeader; }
 
-   // XXX DEPRECATED. Use isControl() instead
-   ATR_DEPRECATED
-   int getFlag() const
-   {
-       return isControl() ? 1 : 0;
-   }
+    /// Read the packet type.
+    /// @return packet type filed (000 ~ 111).
+    UDTMessageType getType() const;
 
-      /// Read the packet type.
-      /// @return packet type filed (000 ~ 111).
+    bool isControl(UDTMessageType type) const { return isControl() && type == getType(); }
 
-   UDTMessageType getType() const;
+    bool isControl() const { return 0 != SEQNO_CONTROL::unwrap(m_nHeader[SRT_PH_SEQNO]); }
 
-   bool isControl(UDTMessageType type) const
-   {
-       return isControl() && type == getType();
-   }
+    void setControl(UDTMessageType type) { m_nHeader[SRT_PH_SEQNO] = SEQNO_CONTROL::mask | SEQNO_MSGTYPE::wrap(type); }
 
-   bool isControl() const
-   {
-       // read bit 0
-       return 0!=  SEQNO_CONTROL::unwrap(m_nHeader[SRT_PH_SEQNO]);
-   }
+    /// Read the extended packet type.
+    /// @return extended packet type filed (0x000 ~ 0xFFF).
+    int getExtendedType() const;
 
-   void setControl(UDTMessageType type)
-   {
-       m_nHeader[SRT_PH_SEQNO] = SEQNO_CONTROL::mask | SEQNO_MSGTYPE::wrap(type);
-   }
+    /// Read the ACK-2 seq. no.
+    /// @return packet header field (bit 16~31).
+    int32_t getAckSeqNo() const;
 
-      /// Read the extended packet type.
-      /// @return extended packet type filed (0x000 ~ 0xFFF).
+    uint16_t getControlFlags() const;
 
-   int getExtendedType() const;
+    // Note: this will return a "singular" value, if the packet
+    // contains the control message
+    int32_t getSeqNo() const { return m_nHeader[SRT_PH_SEQNO]; }
 
-      /// Read the ACK-2 seq. no.
-      /// @return packet header field (bit 16~31).
+    /// Read the message boundary flag bit.
+    /// @return packet header field [1] (bit 0~1).
+    PacketBoundary getMsgBoundary() const;
 
-   int32_t getAckSeqNo() const;
-   uint16_t getControlFlags() const;
+    /// Read the message inorder delivery flag bit.
+    /// @return packet header field [1] (bit 2).
+    bool getMsgOrderFlag() const;
 
-   // Note: this will return a "singular" value, if the packet
-   // contains the control message
-   int32_t getSeqNo() const
-   {
-       return m_nHeader[SRT_PH_SEQNO];
-   }
+    /// Read the rexmit flag (true if the packet was sent due to retransmission).
+    /// If the peer does not support retransmission flag, the current agent cannot use it as well
+    /// (because the peer will understand this bit as a part of MSGNO field).
+    bool getRexmitFlag() const;
 
-      /// Read the message boundary flag bit.
-      /// @return packet header field [1] (bit 0~1).
+    void setRexmitFlag(bool bRexmit);
 
-   PacketBoundary getMsgBoundary() const;
+    /// Read the message sequence number.
+    /// @return packet header field [1]
+    int32_t getMsgSeq(bool has_rexmit = true) const;
 
-      /// Read the message inorder delivery flag bit.
-      /// @return packet header field [1] (bit 2).
+    /// Read the message crypto key bits.
+    /// @return packet header field [1] (bit 3~4).
+    EncryptionKeySpec getMsgCryptoFlags() const;
 
-   bool getMsgOrderFlag() const;
+    void setMsgCryptoFlags(EncryptionKeySpec spec);
 
-   /// Read the rexmit flag (true if the packet was sent due to retransmission).
-   /// If the peer does not support retransmission flag, the current agent cannot use it as well
-   /// (because the peer will understand this bit as a part of MSGNO field).
+    /// Read the message time stamp.
+    /// @return packet header field [2] (bit 0~31, bit 0-26 if SRT_DEBUG_TSBPD_WRAP).
+    uint32_t getMsgTimeStamp() const;
 
-   bool getRexmitFlag() const;
+    sockaddr_any udpDestAddr() const { return m_DestAddr; }
 
-      /// Read the message sequence number.
-      /// @return packet header field [1]
-
-   int32_t getMsgSeq(bool has_rexmit = true) const;
-
-      /// Read the message crypto key bits.
-      /// @return packet header field [1] (bit 3~4).
-
-   EncryptionKeySpec getMsgCryptoFlags() const;
-   void setMsgCryptoFlags(EncryptionKeySpec spec);
-
-      /// Read the message time stamp.
-      /// @return packet header field [2] (bit 0~31, bit 0-26 if SRT_DEBUG_TSBPD_WRAP).
-
-   uint32_t getMsgTimeStamp() const;
-
-#ifdef SRT_DEBUG_TSBPD_WRAP //Receiver
-   static const uint32_t MAX_TIMESTAMP = 0x07FFFFFF; //27 bit fast wraparound for tests (~2m15s)
+#ifdef SRT_DEBUG_TSBPD_WRAP                           // Receiver
+    static const uint32_t MAX_TIMESTAMP = 0x07FFFFFF; // 27 bit fast wraparound for tests (~2m15s)
 #else
-   static const uint32_t MAX_TIMESTAMP = 0xFFFFFFFF; //Full 32 bit (01h11m35s)
+    static const uint32_t MAX_TIMESTAMP = 0xFFFFFFFF; // Full 32 bit (01h11m35s)
 #endif
 
 protected:
-   static const uint32_t TIMESTAMP_MASK = MAX_TIMESTAMP; // this value to be also used as a mask
+    static const uint32_t TIMESTAMP_MASK = MAX_TIMESTAMP; // this value to be also used as a mask
 public:
+    /// Clone this packet.
+    /// @return Pointer to the new packet.
+    CPacket* clone() const;
 
-      /// Clone this packet.
-      /// @return Pointer to the new packet.
-
-   CPacket* clone() const;
-
-   enum PacketVectorFields
-   {
-       PV_HEADER = 0,
-       PV_DATA = 1,
+    enum PacketVectorFields
+    {
+        PV_HEADER = 0,
+        PV_DATA   = 1,
 
-       PV_SIZE = 2
-   };
+        PV_SIZE = 2
+    };
 
 public:
-    void toNL();
-    void toHL();
+    /// @brief Convert the packet inline to a network byte order (Little-endian).
+    void toNetworkByteOrder();
+	/// @brief Convert the packet inline to a host byte order.
+    void toHostByteOrder();
 
 protected:
-   // Length in bytes
-
-   // DynamicStruct is the same as array of given type and size, just it
-   // enforces that you index it using a symbol from symbolic enum type, not by a bare integer.
+    // DynamicStruct is the same as array of given type and size, just it
+    // enforces that you index it using a symbol from symbolic enum type, not by a bare integer.
+    typedef DynamicStruct<uint32_t, SRT_PH_E_SIZE, SrtPktHeaderFields> HEADER_TYPE;
+    HEADER_TYPE                                                        m_nHeader; //< The 128-bit header field
 
-   typedef DynamicStruct<uint32_t, SRT_PH_E_SIZE, SrtPktHeaderFields> HEADER_TYPE;
-   HEADER_TYPE m_nHeader;  //< The 128-bit header field
+    IOVector m_PacketVector[PV_SIZE]; //< The two-dimensional vector of an SRT packet [header, data]
 
-   // XXX NOTE: iovec here is not portable. On Windows there's a different
-   // (although similar) structure defined, which means that this way the
-   // Windows function that is an equivalent of `recvmsg` cannot be used.
-   // For example, something like that:
-   // class IoVector: public iovec { public: size_t size() { return iov_len; } char* data() { return iov_base; } };
-   // class IoVector: public WSAMSG { public: size_t size() { return len; } char* data() { return buf; } };
-   IOVector m_PacketVector[PV_SIZE];             //< The 2-demension vector of UDT packet [header, data]
-
-   int32_t m_extra_pad;
-   bool m_data_owned;
+    int32_t m_extra_pad;
+    bool    m_data_owned;
+    sockaddr_any m_DestAddr;
+    size_t  m_zCapacity;
 
 protected:
-   CPacket& operator=(const CPacket&);
-   CPacket (const CPacket&);
+    CPacket& operator=(const CPacket&);
+    CPacket(const CPacket&);
 
 public:
+    char*&   m_pcData;     // alias: payload (data packet) / control information fields (control packet)
+
+    SRTU_PROPERTY_RO(SRTSOCKET, id, SRTSOCKET(m_nHeader[SRT_PH_ID]));
+    SRTU_PROPERTY_WO_ARG(SRTSOCKET, id, m_nHeader[SRT_PH_ID] = int32_t(arg));
 
-   int32_t& m_iSeqNo;                   // alias: sequence number
-   int32_t& m_iMsgNo;                   // alias: message number
-   int32_t& m_iTimeStamp;               // alias: timestamp
-   int32_t& m_iID;                      // alias: socket ID
-   char*& m_pcData;                     // alias: data/control information
+    SRTU_PROPERTY_RW(int32_t, seqno, m_nHeader[SRT_PH_SEQNO]);
+    SRTU_PROPERTY_RW(int32_t, msgflags, m_nHeader[SRT_PH_MSGNO]);
+    SRTU_PROPERTY_RW(int32_t, timestamp, m_nHeader[SRT_PH_TIMESTAMP]);
 
-   // Experimental: sometimes these references don't work!
-   char* getData();
-   char* release();
+    // Experimental: sometimes these references don't work!
+    char* getData();
+    char* release();
 
-   //static const int m_iPktHdrSize;	// packet header size
-   static const size_t HDR_SIZE = sizeof(HEADER_TYPE); // packet header size = SRT_PH_E_SIZE * sizeof(uint32_t)
+    static const size_t HDR_SIZE = sizeof(HEADER_TYPE); // packet header size = SRT_PH_E_SIZE * sizeof(uint32_t)
 
-   // Used in many computations
-   // Actually this can be also calculated as: sizeof(struct ether_header) + sizeof(struct ip) + sizeof(struct udphdr).
-   static const size_t UDP_HDR_SIZE = 28; // 20 bytes IPv4 + 8 bytes of UDP { u16 sport, dport, len, csum }.
+    // Can also be calculated as: sizeof(struct ether_header) + sizeof(struct ip) + sizeof(struct udphdr).
+    static const size_t UDP_HDR_SIZE = 28; // 20 bytes IPv4 + 8 bytes of UDP { u16 sport, dport, len, csum }.
 
-   static const size_t SRT_DATA_HDR_SIZE = UDP_HDR_SIZE + HDR_SIZE;
+    static const size_t SRT_DATA_HDR_SIZE = UDP_HDR_SIZE + HDR_SIZE;
 
-   // Some well known data
-   static const size_t ETH_MAX_MTU_SIZE = 1500;
+    // Maximum transmission unit size. 1500 in case of Ethernet II (RFC 1191).
+    static const size_t ETH_MAX_MTU_SIZE = 1500;
 
-   // And derived
-   static const size_t SRT_MAX_PAYLOAD_SIZE = ETH_MAX_MTU_SIZE - SRT_DATA_HDR_SIZE;
+    // Maximum payload size of an SRT packet.
+    static const size_t SRT_MAX_PAYLOAD_SIZE = ETH_MAX_MTU_SIZE - SRT_DATA_HDR_SIZE;
 
-   // Packet interface
-   char* data() { return m_pcData; }
-   const char* data() const { return m_pcData; }
-   size_t size() const { return getLength(); }
-   uint32_t header(SrtPktHeaderFields field) const { return m_nHeader[field]; }
+    // Packet interface
+    char*       data() { return m_pcData; }
+    const char* data() const { return m_pcData; }
+    size_t      size() const { return getLength(); }
+    size_t      capacity() const { return m_zCapacity; }
+    void        setCapacity(size_t cap) { m_zCapacity = cap; }
+    uint32_t    header(SrtPktHeaderFields field) const { return m_nHeader[field]; }
 
 #if ENABLE_LOGGING
-   std::string MessageFlagStr() { return PacketMessageFlagStr(m_nHeader[SRT_PH_MSGNO]); }
-   std::string Info();
+    std::string MessageFlagStr() { return PacketMessageFlagStr(m_nHeader[SRT_PH_MSGNO]); }
+    std::string Info();
 #else
-   std::string MessageFlagStr() { return std::string(); }
-   std::string Info() { return std::string(); }
+    std::string           MessageFlagStr() { return std::string(); }
+    std::string           Info() { return std::string(); }
 #endif
 };
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/packetfilter.cpp b/srtcore/packetfilter.cpp
index 993dc806b..dc7e5b422 100644
--- a/srtcore/packetfilter.cpp
+++ b/srtcore/packetfilter.cpp
@@ -26,7 +26,7 @@ using namespace std;
 using namespace srt_logging;
 using namespace srt::sync;
 
-bool ParseFilterConfig(std::string s, SrtFilterConfig& w_config)
+bool srt::ParseFilterConfig(const string& s, SrtFilterConfig& w_config, PacketFilter::Factory** ppf)
 {
     if (!SrtParseConfig(s, (w_config)))
         return false;
@@ -35,24 +35,94 @@ bool ParseFilterConfig(std::string s, SrtFilterConfig& w_config)
     if (!fac)
         return false;
 
+    if (ppf)
+        *ppf = fac;
     // Extract characteristic data
     w_config.extra_size = fac->ExtraSize();
 
     return true;
 }
 
-struct SortBySequence
+bool srt::ParseFilterConfig(const string& s, SrtFilterConfig& w_config)
 {
-    bool operator()(const CUnit* u1, const CUnit* u2)
+    return ParseFilterConfig(s, (w_config), NULL);
+}
+
+// Parameters are passed by value because they need to be potentially modicied inside.
+bool srt::CheckFilterCompat(SrtFilterConfig& w_agent, SrtFilterConfig peer)
+{
+    PacketFilter::Factory* fac = PacketFilter::find(w_agent.type);
+    if (!fac)
+        return false;
+
+    SrtFilterConfig defaults;
+    if (!ParseFilterConfig(fac->defaultConfig(), (defaults)))
+    {
+        return false;
+    }
+
+    set<string> keys;
+    // Extract all keys to identify also unspecified parameters on both sides
+    // Note that theoretically for FEC it could simply check for the "cols" parameter
+    // that is the only mandatory one, but this is a procedure for packet filters in
+    // general and every filter may define its own set of parameters and mandatory rules.
+    for (map<string, string>::iterator x = w_agent.parameters.begin(); x != w_agent.parameters.end(); ++x)
+    {
+        keys.insert(x->first);
+        if (peer.parameters.count(x->first) == 0)
+            peer.parameters[x->first] = x->second;
+    }
+    for (map<string, string>::iterator x = peer.parameters.begin(); x != peer.parameters.end(); ++x)
     {
-        int32_t s1 = u1->m_Packet.getSeqNo();
-        int32_t s2 = u2->m_Packet.getSeqNo();
+        keys.insert(x->first);
+        if (w_agent.parameters.count(x->first) == 0)
+            w_agent.parameters[x->first] = x->second;
+    }
+
+    HLOGC(cnlog.Debug, log << "CheckFilterCompat: re-filled: AGENT:" << Printable(w_agent.parameters)
+            << " PEER:" << Printable(peer.parameters));
 
-        return CSeqNo::seqcmp(s1, s2) < 0;
+    // Complete nonexistent keys with default values
+    for (map<string, string>::iterator x = defaults.parameters.begin(); x != defaults.parameters.end(); ++x)
+    {
+        if (!w_agent.parameters.count(x->first))
+            w_agent.parameters[x->first] = x->second;
+        if (!peer.parameters.count(x->first))
+            peer.parameters[x->first] = x->second;
     }
-};
 
-void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_seqs_t& w_loss_seqs)
+    for (set<string>::iterator x = keys.begin(); x != keys.end(); ++x)
+    {
+        // Note: operator[] will insert an element with default value
+        // if it doesn't exist. This will inject the empty string as value,
+        // which is acceptable.
+        if (w_agent.parameters[*x] != peer.parameters[*x])
+        {
+            LOGC(cnlog.Error, log << "Packet Filter (" << defaults.type << "): collision on '" << (*x)
+                    << "' parameter (agent:" << w_agent.parameters[*x] << " peer:" << (peer.parameters[*x]) << ")");
+            return false;
+        }
+    }
+
+    // Mandatory parameters will be checked when trying to create the filter object.
+
+    return true;
+}
+
+namespace srt {
+    struct SortBySequence
+    {
+        bool operator()(const CUnit* u1, const CUnit* u2)
+        {
+            int32_t s1 = u1->m_Packet.getSeqNo();
+            int32_t s2 = u2->m_Packet.getSeqNo();
+
+            return CSeqNo::seqcmp(s1, s2) < 0;
+        }
+    };
+} // namespace srt
+
+void srt::PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_seqs_t& w_loss_seqs)
 {
     const CPacket& rpkt = unit->m_Packet;
 
@@ -60,7 +130,7 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
     {
         // For the sake of rebuilding MARK THIS UNIT GOOD, otherwise the
         // unit factory will supply it from getNextAvailUnit() as if it were not in use.
-        unit->m_iFlag = CUnit::GOOD;
+        unit->m_bTaken = true;
         HLOGC(pflog.Debug, log << "FILTER: PASSTHRU current packet %" << unit->m_Packet.getSeqNo());
         w_incoming.push_back(unit);
     }
@@ -68,8 +138,7 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
     {
         // Packet not to be passthru, update stats
         ScopedLock lg(m_parent->m_StatsLock);
-        ++m_parent->m_stats.rcvFilterExtra;
-        ++m_parent->m_stats.rcvFilterExtraTotal;
+        m_parent->m_stats.rcvr.recvdFilterExtra.count(1);
     }
 
     // w_loss_seqs enters empty into this function and can be only filled here. XXX ASSERT?
@@ -82,8 +151,7 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
         if (dist > 0)
         {
             ScopedLock lg(m_parent->m_StatsLock);
-            m_parent->m_stats.rcvFilterLoss += dist;
-            m_parent->m_stats.rcvFilterLossTotal += dist;
+            m_parent->m_stats.rcvr.lossFilter.count(dist);
         }
         else
         {
@@ -101,8 +169,7 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
         InsertRebuilt(w_incoming, m_unitq);
 
         ScopedLock lg(m_parent->m_StatsLock);
-        m_parent->m_stats.rcvFilterSupply += nsupply;
-        m_parent->m_stats.rcvFilterSupplyTotal += nsupply;
+        m_parent->m_stats.rcvr.suppliedByFilter.count((uint32_t)nsupply);
     }
 
     // Now that all units have been filled as they should be,
@@ -111,11 +178,11 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
     // Wanted units will be set GOOD flag, unwanted will remain
     // with FREE and therefore will be returned at the next
     // call to getNextAvailUnit().
-    unit->m_iFlag = CUnit::FREE;
+    unit->m_bTaken = false;
     for (vector<CUnit*>::iterator i = w_incoming.begin(); i != w_incoming.end(); ++i)
     {
         CUnit* u = *i;
-        u->m_iFlag = CUnit::FREE;
+        u->m_bTaken = false;
     }
 
     // Packets must be sorted by sequence number, ascending, in order
@@ -138,7 +205,7 @@ void PacketFilter::receive(CUnit* unit, std::vector<CUnit*>& w_incoming, loss_se
 
 }
 
-bool PacketFilter::packControlPacket(int32_t seq, int kflg, CPacket& w_packet)
+bool srt::PacketFilter::packControlPacket(int32_t seq, int kflg, CPacket& w_packet)
 {
     bool have = m_filter->packControlPacket(m_sndctlpkt, seq);
     if (!have)
@@ -159,7 +226,7 @@ bool PacketFilter::packControlPacket(int32_t seq, int kflg, CPacket& w_packet)
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    w_packet.m_iMsgNo = SRT_MSGNO_CONTROL | MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    w_packet.set_msgflags(SRT_MSGNO_CONTROL | MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     w_packet.setMsgCryptoFlags(EncryptionKeySpec(kflg));
@@ -170,7 +237,7 @@ bool PacketFilter::packControlPacket(int32_t seq, int kflg, CPacket& w_packet)
 }
 
 
-void PacketFilter::InsertRebuilt(vector<CUnit*>& incoming, CUnitQueue* uq)
+void srt::PacketFilter::InsertRebuilt(vector<CUnit*>& incoming, CUnitQueue* uq)
 {
     if (m_provided.empty())
         return;
@@ -184,9 +251,9 @@ void PacketFilter::InsertRebuilt(vector<CUnit*>& incoming, CUnitQueue* uq)
             break;
         }
 
-        // LOCK the unit as GOOD because otherwise the next
+        // LOCK the unit as taken because otherwise the next
         // call to getNextAvailUnit will return THE SAME UNIT.
-        u->m_iFlag = CUnit::GOOD;
+        u->m_bTaken = true;
         // After returning from this function, all units will be
         // set back to FREE so that the buffer can decide whether
         // it wants them or not.
@@ -205,19 +272,21 @@ void PacketFilter::InsertRebuilt(vector<CUnit*>& incoming, CUnitQueue* uq)
     m_provided.clear();
 }
 
-bool PacketFilter::IsBuiltin(const string& s)
+bool srt::PacketFilter::IsBuiltin(const string& s)
 {
     return builtin_filters.count(s);
 }
 
+namespace srt {
 std::set<std::string> PacketFilter::builtin_filters;
 PacketFilter::filters_map_t PacketFilter::filters;
+}
 
-PacketFilter::Factory::~Factory()
+srt::PacketFilter::Factory::~Factory()
 {
 }
 
-void PacketFilter::globalInit()
+void srt::PacketFilter::globalInit()
 {
     // Add here builtin packet filters and mark them
     // as builtin. This will disallow users to register
@@ -227,12 +296,12 @@ void PacketFilter::globalInit()
     builtin_filters.insert("fec");
 }
 
-bool PacketFilter::configure(CUDT* parent, CUnitQueue* uq, const std::string& confstr)
+bool srt::PacketFilter::configure(CUDT* parent, CUnitQueue* uq, const std::string& confstr)
 {
     m_parent = parent;
 
     SrtFilterConfig cfg;
-    if (!ParseFilterConfig(confstr, cfg))
+    if (!ParseFilterConfig(confstr, (cfg)))
         return false;
 
     // Extract the "type" key from parameters, or use
@@ -245,8 +314,14 @@ bool PacketFilter::configure(CUDT* parent, CUnitQueue* uq, const std::string& co
     init.socket_id = parent->socketID();
     init.snd_isn = parent->sndSeqNo();
     init.rcv_isn = parent->rcvSeqNo();
-    init.payload_size = parent->OPT_PayloadSize();
 
+    // XXX This is a formula for a full "SRT payload" part that undergoes transmission,
+    // might be nice to have this formula as something more general.
+    init.payload_size = parent->OPT_PayloadSize() + parent->getAuthTagSize();
+    init.rcvbuf_size = parent->m_config.iRcvBufSize;
+
+    HLOGC(pflog.Debug, log << "PFILTER: @" << init.socket_id << " payload size="
+            << init.payload_size << " rcvbuf size=" << init.rcvbuf_size);
 
     // Found a filter, so call the creation function
     m_filter = selector->second->Create(init, m_provided, confstr);
@@ -261,7 +336,7 @@ bool PacketFilter::configure(CUDT* parent, CUnitQueue* uq, const std::string& co
     return true;
 }
 
-bool PacketFilter::correctConfig(const SrtFilterConfig& conf)
+bool srt::PacketFilter::correctConfig(const SrtFilterConfig& conf)
 {
     const string* pname = map_getp(conf.parameters, "type");
 
@@ -278,7 +353,7 @@ bool PacketFilter::correctConfig(const SrtFilterConfig& conf)
     return true;
 }
 
-PacketFilter::~PacketFilter()
+srt::PacketFilter::~PacketFilter()
 {
     delete m_filter;
 }
diff --git a/srtcore/packetfilter.h b/srtcore/packetfilter.h
index 13ec89b78..429e81e79 100644
--- a/srtcore/packetfilter.h
+++ b/srtcore/packetfilter.h
@@ -16,32 +16,42 @@
 #include <string>
 
 #include "packet.h"
-#include "queue.h"
 #include "utilities.h"
 #include "packetfilter_api.h"
 
+namespace srt {
+
+class CUnitQueue;
+struct CUnit;
+class CUDT;
+
 class PacketFilter
 {
     friend class SrtPacketFilterBase;
 
 public:
-
     typedef std::vector< std::pair<int32_t, int32_t> > loss_seqs_t;
 
     typedef SrtPacketFilterBase* filter_create_t(const SrtFilterInitializer& init, std::vector<SrtPacket>&, const std::string& config);
 
-private:
-    friend bool ParseFilterConfig(std::string s, SrtFilterConfig& out);
     class Factory
     {
     public:
         virtual SrtPacketFilterBase* Create(const SrtFilterInitializer& init, std::vector<SrtPacket>& provided, const std::string& confstr) = 0;
 
         // Characteristic data
-        virtual size_t ExtraSize() = 0;
-
+        virtual size_t ExtraSize() const = 0;
+
+        // Represent default parameters. This is for completing and comparing
+        // filter configurations from both parties. Possible values to return:
+        // - an empty string (all parameters are mandatory)
+        // - a form of: "<filter-name>,<param1>:<value1>,..."
+        virtual std::string defaultConfig() const = 0;
+        virtual bool verifyConfig(const SrtFilterConfig& config, std::string& w_errormsg) const = 0;
         virtual ~Factory();
     };
+private:
+    friend bool ParseFilterConfig(const std::string& s, SrtFilterConfig& out, PacketFilter::Factory** ppf);
 
     template <class Target>
     class Creator: public Factory
@@ -52,7 +62,12 @@ class PacketFilter
         { return new Target(init, provided, confstr); }
 
         // Import the extra size data
-        virtual size_t ExtraSize() ATR_OVERRIDE { return Target::EXTRA_SIZE; }
+        virtual size_t ExtraSize() const ATR_OVERRIDE { return Target::EXTRA_SIZE; }
+        virtual std::string defaultConfig() const ATR_OVERRIDE { return Target::defaultConfig; }
+        virtual bool verifyConfig(const SrtFilterConfig& config, std::string& w_errormsg) const ATR_OVERRIDE
+        {
+            return Target::verifyConfig(config, (w_errormsg));
+        }
 
     public:
         Creator() {}
@@ -157,7 +172,7 @@ class PacketFilter
     // Things being done:
     // 1. The filter is individual, so don't copy it. Set NULL.
     // 2. This will be configued anyway basing on possibly a new rule set.
-    PacketFilter(const PacketFilter& source SRT_ATR_UNUSED): m_filter(), m_sndctlpkt(0), m_unitq() {}
+    PacketFilter(const PacketFilter& source SRT_ATR_UNUSED): m_filter(), m_parent(), m_sndctlpkt(0), m_unitq() {}
 
     // This function will be called by the parent CUDT
     // in appropriate time. It should select appropriate
@@ -192,8 +207,13 @@ class PacketFilter
     std::vector<SrtPacket> m_provided;
 };
 
+bool CheckFilterCompat(SrtFilterConfig& w_agent, SrtFilterConfig peer);
 
 inline void PacketFilter::feedSource(CPacket& w_packet) { SRT_ASSERT(m_filter); return m_filter->feedSource((w_packet)); }
 inline SRT_ARQLevel PacketFilter::arqLevel() { SRT_ASSERT(m_filter); return m_filter->arqLevel(); }
 
+bool ParseFilterConfig(const std::string& s, SrtFilterConfig& out, PacketFilter::Factory** ppf);
+
+} // namespace srt
+
 #endif
diff --git a/srtcore/packetfilter_api.h b/srtcore/packetfilter_api.h
index 1f5d7ff23..3bfba7c76 100644
--- a/srtcore/packetfilter_api.h
+++ b/srtcore/packetfilter_api.h
@@ -19,6 +19,8 @@
 #include <vector>
 #include <utility>
 
+namespace srt {
+
 class CPacket;
 
 enum SrtPktHeaderFields
@@ -58,6 +60,7 @@ struct SrtFilterInitializer
     int32_t snd_isn;
     int32_t rcv_isn;
     size_t payload_size;
+    size_t rcvbuf_size;
 };
 
 struct SrtPacket
@@ -78,7 +81,7 @@ struct SrtPacket
 };
 
 
-bool ParseFilterConfig(std::string s, SrtFilterConfig& out);
+bool ParseFilterConfig(const std::string& s, SrtFilterConfig& w_config);
 
 
 class SrtPacketFilterBase
@@ -91,6 +94,7 @@ class SrtPacketFilterBase
     int32_t sndISN() const { return initParams.snd_isn; }
     int32_t rcvISN() const { return initParams.rcv_isn; }
     size_t payloadSize() const { return initParams.payload_size; }
+    size_t rcvBufferSize() const { return initParams.rcvbuf_size; }
 
     friend class PacketFilter;
 
@@ -149,6 +153,6 @@ class SrtPacketFilterBase
     }
 };
 
-
+} // namespace srt
 
 #endif
diff --git a/srtcore/platform_sys.h b/srtcore/platform_sys.h
index ed66e02bf..83763e5ea 100644
--- a/srtcore/platform_sys.h
+++ b/srtcore/platform_sys.h
@@ -21,16 +21,29 @@
 //
 // SRT_IMPORT_TIME   (mach time on Mac, portability gettimeofday on WIN32)
 // SRT_IMPORT_EVENT  (includes kevent on Mac)
+#ifdef _WIN32
+   #ifndef __MINGW32__
+      // Explicitly define 32-bit and 64-bit numbers
+      typedef __int32 int32_t;
+      typedef __int64 int64_t;
+      typedef unsigned __int32 uint32_t;
+      #ifndef LEGACY_WIN32
+         typedef unsigned __int64 uint64_t;
+      #else
+         // VC 6.0 does not support unsigned __int64: may cause potential problems.
+         typedef __int64 uint64_t;
+      #endif
+   #endif
+#endif
 
 
 #ifdef _WIN32
-   #define _CRT_SECURE_NO_WARNINGS 1 // silences windows complaints for sscanf
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <ws2ipdef.h>
    #include <windows.h>
 
-#ifndef __MINGW__
+#ifndef __MINGW32__
    #include <intrin.h>
 #endif
 
@@ -40,12 +53,17 @@
 
    #include <stdint.h>
    #include <inttypes.h>
-   #if defined(_MSC_VER)
-      #pragma warning(disable:4251)
-   #endif
 #else
 
-#if __APPLE__
+#if defined(__APPLE__) && __APPLE__
+// Warning: please keep this test as it is, do not make it
+// "#if __APPLE__" or "#ifdef __APPLE__". In applications with
+// a strict "no warning policy", "#if __APPLE__" triggers an "undef"
+// error. With GCC, an old & never fixed bug prevents muting this
+// warning (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431).
+// Before this fix, the solution was to "#define __APPLE__ 0" before
+// including srt.h. So, don't use "#ifdef __APPLE__" either.
+
 // XXX Check if this condition doesn't require checking of
 // also other macros, like TARGET_OS_IOS etc.
 
diff --git a/srtcore/queue.cpp b/srtcore/queue.cpp
index 46715a539..b2c9d42f6 100644
--- a/srtcore/queue.cpp
+++ b/srtcore/queue.cpp
@@ -65,27 +65,34 @@ using namespace std;
 using namespace srt::sync;
 using namespace srt_logging;
 
-CUnitQueue::CUnitQueue()
-    : m_pQEntry(NULL)
-    , m_pCurrQueue(NULL)
-    , m_pLastQueue(NULL)
-    , m_iSize(0)
-    , m_iCount(0)
-    , m_iMSS()
-    , m_iIPversion()
+srt::CUnitQueue::CUnitQueue(int initNumUnits, int mss)
+    : m_iNumTaken(0)
+    , m_iMSS(mss)
+    , m_iBlockSize(initNumUnits)
 {
+    CQEntry* tempq = allocateEntry(m_iBlockSize, m_iMSS);
+
+    if (tempq == NULL)
+        throw CUDTException(MJ_SYSTEMRES, MN_MEMORY);
+
+    m_pQEntry = m_pCurrQueue = m_pLastQueue = tempq;
+    m_pQEntry->m_pNext = m_pQEntry;
+
+    m_pAvailUnit = m_pCurrQueue->m_pUnit;
+
+    m_iSize = m_iBlockSize;
 }
 
-CUnitQueue::~CUnitQueue()
+srt::CUnitQueue::~CUnitQueue()
 {
-    CQEntry *p = m_pQEntry;
+    CQEntry* p = m_pQEntry;
 
     while (p != NULL)
     {
         delete[] p->m_pUnit;
         delete[] p->m_pBuffer;
 
-        CQEntry *q = p;
+        CQEntry* q = p;
         if (p == m_pLastQueue)
             p = NULL;
         else
@@ -94,17 +101,17 @@ CUnitQueue::~CUnitQueue()
     }
 }
 
-int CUnitQueue::init(int size, int mss, int version)
+srt::CUnitQueue::CQEntry* srt::CUnitQueue::allocateEntry(const int iNumUnits, const int mss)
 {
-    CQEntry *tempq = NULL;
-    CUnit *  tempu = NULL;
-    char *   tempb = NULL;
+    CQEntry* tempq = NULL;
+    CUnit* tempu   = NULL;
+    char* tempb    = NULL;
 
     try
     {
         tempq = new CQEntry;
-        tempu = new CUnit[size];
-        tempb = new char[size * mss];
+        tempu = new CUnit[iNumUnits];
+        tempb = new char[iNumUnits * mss];
     }
     catch (...)
     {
@@ -112,117 +119,60 @@ int CUnitQueue::init(int size, int mss, int version)
         delete[] tempu;
         delete[] tempb;
 
-        return -1;
+        LOGC(rslog.Error, log << "CUnitQueue: failed to allocate " << iNumUnits << " units.");
+        return NULL;
     }
 
-    for (int i = 0; i < size; ++i)
+    for (int i = 0; i < iNumUnits; ++i)
     {
-        tempu[i].m_iFlag           = CUnit::FREE;
+        tempu[i].m_bTaken = false;
         tempu[i].m_Packet.m_pcData = tempb + i * mss;
     }
+
     tempq->m_pUnit   = tempu;
     tempq->m_pBuffer = tempb;
-    tempq->m_iSize   = size;
+    tempq->m_iSize   = iNumUnits;
 
-    m_pQEntry = m_pCurrQueue = m_pLastQueue = tempq;
-    m_pQEntry->m_pNext                      = m_pQEntry;
-
-    m_pAvailUnit = m_pCurrQueue->m_pUnit;
-
-    m_iSize      = size;
-    m_iMSS       = mss;
-    m_iIPversion = version;
-
-    return 0;
+    return tempq;
 }
 
-// XXX Lots of common code with CUnitQueue:init.
-// Consider merging.
-int CUnitQueue::increase()
+int srt::CUnitQueue::increase_()
 {
-    // adjust/correct m_iCount
-    int      real_count = 0;
-    CQEntry *p          = m_pQEntry;
-    while (p != NULL)
-    {
-        CUnit *u = p->m_pUnit;
-        for (CUnit *end = u + p->m_iSize; u != end; ++u)
-            if (u->m_iFlag != CUnit::FREE)
-                ++real_count;
-
-        if (p == m_pLastQueue)
-            p = NULL;
-        else
-            p = p->m_pNext;
-    }
-    m_iCount = real_count;
-    if (double(m_iCount) / m_iSize < 0.9)
-        return -1;
-
-    CQEntry *tempq = NULL;
-    CUnit *  tempu = NULL;
-    char *   tempb = NULL;
-
-    // all queues have the same size
-    const int size = m_pQEntry->m_iSize;
-
-    try
-    {
-        tempq = new CQEntry;
-        tempu = new CUnit[size];
-        tempb = new char[size * m_iMSS];
-    }
-    catch (...)
-    {
-        delete tempq;
-        delete[] tempu;
-        delete[] tempb;
+    const int numUnits = m_iBlockSize;
+    HLOGC(qrlog.Debug, log << "CUnitQueue::increase: Capacity" << capacity() << " + " << numUnits << " new units, " << m_iNumTaken << " in use.");
 
-        LOGC(rslog.Error,
-            log << "CUnitQueue:increase: failed to allocate " << size << " new units."
-                << " Current size=" << m_iSize);
+    CQEntry* tempq = allocateEntry(numUnits, m_iMSS);
+    if (tempq == NULL)
         return -1;
-    }
-
-    for (int i = 0; i < size; ++i)
-    {
-        tempu[i].m_iFlag           = CUnit::FREE;
-        tempu[i].m_Packet.m_pcData = tempb + i * m_iMSS;
-    }
-    tempq->m_pUnit   = tempu;
-    tempq->m_pBuffer = tempb;
-    tempq->m_iSize   = size;
 
     m_pLastQueue->m_pNext = tempq;
     m_pLastQueue          = tempq;
     m_pLastQueue->m_pNext = m_pQEntry;
 
-    m_iSize += size;
+    m_iSize += numUnits;
 
     return 0;
 }
 
-int CUnitQueue::shrink()
+srt::CUnit* srt::CUnitQueue::getNextAvailUnit()
 {
-    // currently queue cannot be shrunk.
-    return -1;
-}
-
-CUnit *CUnitQueue::getNextAvailUnit()
-{
-    if (m_iCount * 10 > m_iSize * 9)
-        increase();
+    const int iNumUnitsTotal = capacity();
+    if (m_iNumTaken * 10 > iNumUnitsTotal * 9) // 90% or more are in use.
+        increase_();
 
-    if (m_iCount >= m_iSize)
+    if (m_iNumTaken >= capacity())
+    {
+        LOGC(qrlog.Error, log << "CUnitQueue: No free units to take. Capacity" << capacity() << ".");
         return NULL;
+    }
 
     int units_checked = 0;
     do
     {
-        const CUnit *end = m_pCurrQueue->m_pUnit + m_pCurrQueue->m_iSize;
+        const CUnit* end = m_pCurrQueue->m_pUnit + m_pCurrQueue->m_iSize;
         for (; m_pAvailUnit != end; ++m_pAvailUnit, ++units_checked)
         {
-            if (m_pAvailUnit->m_iFlag == CUnit::FREE)
+            if (!m_pAvailUnit->m_bTaken)
             {
                 return m_pAvailUnit;
             }
@@ -232,45 +182,45 @@ CUnit *CUnitQueue::getNextAvailUnit()
         m_pAvailUnit = m_pCurrQueue->m_pUnit;
     } while (units_checked < m_iSize);
 
-    increase();
-
     return NULL;
 }
 
-void CUnitQueue::makeUnitFree(CUnit *unit)
+void srt::CUnitQueue::makeUnitFree(CUnit* unit)
 {
     SRT_ASSERT(unit != NULL);
-    SRT_ASSERT(unit->m_iFlag != CUnit::FREE);
-    unit->m_iFlag = CUnit::FREE;
-    --m_iCount;
+    SRT_ASSERT(unit->m_bTaken);
+    unit->m_bTaken.store(false);
+
+    --m_iNumTaken;
 }
 
-void CUnitQueue::makeUnitGood(CUnit *unit)
+void srt::CUnitQueue::makeUnitTaken(CUnit* unit)
 {
+    ++m_iNumTaken;
+
     SRT_ASSERT(unit != NULL);
-    SRT_ASSERT(unit->m_iFlag == CUnit::FREE);
-    unit->m_iFlag = CUnit::GOOD;
-    ++m_iCount;
+    SRT_ASSERT(!unit->m_bTaken);
+    unit->m_bTaken.store(true);
 }
 
-CSndUList::CSndUList()
+srt::CSndUList::CSndUList(sync::CTimer* pTimer)
     : m_pHeap(NULL)
     , m_iArrayLength(512)
     , m_iLastEntry(-1)
     , m_ListLock()
-    , m_pWindowLock(NULL)
-    , m_pWindowCond(NULL)
-    , m_pTimer(NULL)
+    , m_pTimer(pTimer)
 {
-    m_pHeap = new CSNode *[m_iArrayLength];
+    setupCond(m_ListCond, "CSndUListCond");
+    m_pHeap = new CSNode*[m_iArrayLength];
 }
 
-CSndUList::~CSndUList()
+srt::CSndUList::~CSndUList()
 {
+    releaseCond(m_ListCond);
     delete[] m_pHeap;
 }
 
-void CSndUList::update(const CUDT* u, EReschedule reschedule)
+void srt::CSndUList::update(const CUDT* u, EReschedule reschedule, sync::steady_clock::time_point ts)
 {
     ScopedLock listguard(m_ListLock);
 
@@ -278,73 +228,50 @@ void CSndUList::update(const CUDT* u, EReschedule reschedule)
 
     if (n->m_iHeapLoc >= 0)
     {
-        if (!reschedule) // EReschedule to bool conversion, predicted.
+        if (reschedule == DONT_RESCHEDULE)
+            return;
+
+        if (n->m_tsTimeStamp <= ts)
             return;
 
         if (n->m_iHeapLoc == 0)
         {
-            n->m_tsTimeStamp = steady_clock::now();
+            n->m_tsTimeStamp = ts;
             m_pTimer->interrupt();
             return;
         }
 
         remove_(u);
-        insert_norealloc_(steady_clock::now(), u);
+        insert_norealloc_(ts, u);
         return;
     }
 
-    insert_(steady_clock::now(), u);
+    insert_(ts, u);
 }
 
-int CSndUList::pop(sockaddr_any& w_addr, CPacket& w_pkt)
+srt::CUDT* srt::CSndUList::pop()
 {
     ScopedLock listguard(m_ListLock);
 
     if (-1 == m_iLastEntry)
-        return -1;
+        return NULL;
 
-    // no pop until the next schedulled time
+    // no pop until the next scheduled time
     if (m_pHeap[0]->m_tsTimeStamp > steady_clock::now())
-        return -1;
+        return NULL;
 
-    CUDT *u = m_pHeap[0]->m_pUDT;
+    CUDT* u = m_pHeap[0]->m_pUDT;
     remove_(u);
-
-#define UST(field) ((u->m_b##field) ? "+" : "-") << #field << " "
-
-    HLOGC(qslog.Debug,
-          log << "SND:pop: requesting packet from @" << u->socketID() << " STATUS: " << UST(Listening)
-              << UST(Connecting) << UST(Connected) << UST(Closing) << UST(Shutdown) << UST(Broken) << UST(PeerHealth)
-              << UST(Opened));
-#undef UST
-
-    if (!u->m_bConnected || u->m_bBroken)
-        return -1;
-
-    // pack a packet from the socket
-    const std::pair<int, steady_clock::time_point> res_time = u->packData((w_pkt));
-
-    if (res_time.first <= 0)
-        return -1;
-
-    w_addr = u->m_PeerAddr;
-
-    // insert a new entry, ts is the next processing time
-    const steady_clock::time_point send_time = res_time.second;
-    if (!is_zero(send_time))
-        insert_norealloc_(send_time, u);
-
-    return 1;
+    return u;
 }
 
-void CSndUList::remove(const CUDT *u)
+void srt::CSndUList::remove(const CUDT* u)
 {
     ScopedLock listguard(m_ListLock);
-
     remove_(u);
 }
 
-steady_clock::time_point CSndUList::getNextProcTime()
+steady_clock::time_point srt::CSndUList::getNextProcTime()
 {
     ScopedLock listguard(m_ListLock);
 
@@ -354,26 +281,41 @@ steady_clock::time_point CSndUList::getNextProcTime()
     return m_pHeap[0]->m_tsTimeStamp;
 }
 
-void CSndUList::realloc_()
+void srt::CSndUList::waitNonEmpty() const
+{
+    UniqueLock listguard(m_ListLock);
+    if (m_iLastEntry >= 0)
+        return;
+
+    m_ListCond.wait(listguard);
+}
+
+void srt::CSndUList::signalInterrupt() const
+{
+    ScopedLock listguard(m_ListLock);
+    m_ListCond.notify_one();
+}
+
+void srt::CSndUList::realloc_()
 {
-    CSNode **temp = NULL;
+    CSNode** temp = NULL;
 
     try
     {
-        temp = new CSNode *[2 * m_iArrayLength];
+        temp = new CSNode*[2 * m_iArrayLength];
     }
     catch (...)
     {
         throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);
     }
 
-    memcpy((temp), m_pHeap, sizeof(CSNode *) * m_iArrayLength);
+    memcpy((temp), m_pHeap, sizeof(CSNode*) * m_iArrayLength);
     m_iArrayLength *= 2;
     delete[] m_pHeap;
     m_pHeap = temp;
 }
 
-void CSndUList::insert_(const steady_clock::time_point& ts, const CUDT* u)
+void srt::CSndUList::insert_(const steady_clock::time_point& ts, const CUDT* u)
 {
     // increase the heap array size if necessary
     if (m_iLastEntry == m_iArrayLength - 1)
@@ -382,9 +324,9 @@ void CSndUList::insert_(const steady_clock::time_point& ts, const CUDT* u)
     insert_norealloc_(ts, u);
 }
 
-void CSndUList::insert_norealloc_(const steady_clock::time_point& ts, const CUDT* u)
+void srt::CSndUList::insert_norealloc_(const steady_clock::time_point& ts, const CUDT* u)
 {
-    CSNode *n = u->m_pSNode;
+    CSNode* n = u->m_pSNode;
 
     // do not insert repeated node
     if (n->m_iHeapLoc >= 0)
@@ -394,7 +336,7 @@ void CSndUList::insert_norealloc_(const steady_clock::time_point& ts, const CUDT
 
     m_iLastEntry++;
     m_pHeap[m_iLastEntry] = n;
-    n->m_tsTimeStamp = ts;
+    n->m_tsTimeStamp      = ts;
 
     int q = m_iLastEntry;
     int p = q;
@@ -418,20 +360,21 @@ void CSndUList::insert_norealloc_(const steady_clock::time_point& ts, const CUDT
     // first entry, activate the sending queue
     if (0 == m_iLastEntry)
     {
-        CSync::lock_signal(*m_pWindowCond, *m_pWindowLock);
+        // m_ListLock is assumed to be locked.
+        m_ListCond.notify_one();
     }
 }
 
-void CSndUList::remove_(const CUDT* u)
+void srt::CSndUList::remove_(const CUDT* u)
 {
-    CSNode *n = u->m_pSNode;
+    CSNode* n = u->m_pSNode;
 
     if (n->m_iHeapLoc >= 0)
     {
         // remove the node from heap
         m_pHeap[n->m_iHeapLoc] = m_pHeap[m_iLastEntry];
         m_iLastEntry--;
-        m_pHeap[n->m_iHeapLoc]->m_iHeapLoc = n->m_iHeapLoc;
+        m_pHeap[n->m_iHeapLoc]->m_iHeapLoc = n->m_iHeapLoc.load();
 
         int q = n->m_iHeapLoc;
         int p = q * 2 + 1;
@@ -462,17 +405,15 @@ void CSndUList::remove_(const CUDT* u)
 }
 
 //
-CSndQueue::CSndQueue()
+srt::CSndQueue::CSndQueue()
     : m_pSndUList(NULL)
     , m_pChannel(NULL)
     , m_pTimer(NULL)
-    , m_WindowCond()
     , m_bClosing(false)
 {
-    setupCond(m_WindowCond, "Window");
 }
 
-CSndQueue::~CSndQueue()
+srt::CSndQueue::~CSndQueue()
 {
     m_bClosing = true;
 
@@ -481,35 +422,41 @@ CSndQueue::~CSndQueue()
         m_pTimer->interrupt();
     }
 
-    CSync::lock_signal(m_WindowCond, m_WindowLock);
+    // Unblock CSndQueue worker thread if it is waiting.
+    m_pSndUList->signalInterrupt();
 
     if (m_WorkerThread.joinable())
     {
         HLOGC(rslog.Debug, log << "SndQueue: EXIT");
         m_WorkerThread.join();
     }
-    releaseCond(m_WindowCond);
 
     delete m_pSndUList;
 }
 
+int srt::CSndQueue::ioctlQuery(int type) const
+{
+    return m_pChannel->ioctlQuery(type);
+}
+int srt::CSndQueue::sockoptQuery(int level, int type) const
+{
+    return m_pChannel->sockoptQuery(level, type);
+}
+
 #if ENABLE_LOGGING
-    int CSndQueue::m_counter = 0;
+srt::sync::atomic<int> srt::CSndQueue::m_counter(0);
 #endif
 
-void CSndQueue::init(CChannel *c, CTimer *t)
+void srt::CSndQueue::init(CChannel* c, CTimer* t)
 {
-    m_pChannel                 = c;
-    m_pTimer                   = t;
-    m_pSndUList                = new CSndUList;
-    m_pSndUList->m_pWindowLock = &m_WindowLock;
-    m_pSndUList->m_pWindowCond = &m_WindowCond;
-    m_pSndUList->m_pTimer      = m_pTimer;
+    m_pChannel  = c;
+    m_pTimer    = t;
+    m_pSndUList = new CSndUList(t);
 
 #if ENABLE_LOGGING
     ++m_counter;
     const std::string thrname = "SRT:SndQ:w" + Sprint(m_counter);
-    const char* thname = thrname.c_str();
+    const char*       thname  = thrname.c_str();
 #else
     const char* thname = "SRT:SndQ";
 #endif
@@ -517,56 +464,77 @@ void CSndQueue::init(CChannel *c, CTimer *t)
         throw CUDTException(MJ_SYSTEMRES, MN_THREAD);
 }
 
-int CSndQueue::getIpTTL() const { return m_pChannel ? m_pChannel->getIpTTL() : -1; }
+int srt::CSndQueue::getIpTTL() const
+{
+    return m_pChannel ? m_pChannel->getIpTTL() : -1;
+}
 
-int CSndQueue::getIpToS() const { return m_pChannel ? m_pChannel->getIpToS() : -1; }
+int srt::CSndQueue::getIpToS() const
+{
+    return m_pChannel ? m_pChannel->getIpToS() : -1;
+}
 
 #ifdef SRT_ENABLE_BINDTODEVICE
-bool CSndQueue::getBind(char* dst, size_t len) const { return m_pChannel ? m_pChannel->getBind(dst, len) : false; }
+bool srt::CSndQueue::getBind(char* dst, size_t len) const
+{
+    return m_pChannel ? m_pChannel->getBind(dst, len) : false;
+}
 #endif
 
-void *CSndQueue::worker(void *param)
+#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
+static void CSndQueueDebugHighratePrint(const srt::CSndQueue* self, const steady_clock::time_point currtime)
 {
-    CSndQueue *self = (CSndQueue *)param;
-
-#if ENABLE_LOGGING
-    THREAD_STATE_INIT(("SRT:SndQ:w" + Sprint(m_counter)).c_str());
-#else
-    THREAD_STATE_INIT("SRT:SndQ:worker");
+    if (self->m_DbgTime <= currtime)
+    {
+        fprintf(stdout,
+                "SndQueue %lu slt:%lu nrp:%lu snt:%lu nrt:%lu ctw:%lu\n",
+                self->m_WorkerStats.lIteration,
+                self->m_WorkerStats.lSleepTo,
+                self->m_WorkerStats.lNotReadyPop,
+                self->m_WorkerStats.lSendTo,
+                self->m_WorkerStats.lNotReadyTs,
+                self->m_WorkerStats.lCondWait);
+        memset(&self->m_WorkerStats, 0, sizeof(self->m_WorkerStats));
+        self->m_DbgTime = currtime + self->m_DbgPeriod;
+    }
+}
 #endif
 
+void* srt::CSndQueue::worker(void* param)
+{
+    CSndQueue* self = (CSndQueue*)param;
+
+    std::string thname;
+    ThreadName::get(thname);
+    THREAD_STATE_INIT(thname.c_str());
+
 #if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-    CTimer::rdtsc(self->m_ullDbgTime);
-    self->m_ullDbgPeriod = uint64_t(5000000) * CTimer::getCPUFrequency();
-    self->m_ullDbgTime += self->m_ullDbgPeriod;
+#define IF_DEBUG_HIGHRATE(statement) statement
+    self->m_DbgTime = sync::steady_clock::now();
+    self->m_DbgPeriod = sync::microseconds_from(5000000);
+    self->m_DbgTime += self->m_DbgPeriod;
+#else
+#define IF_DEBUG_HIGHRATE(statement) (void)0
 #endif /* SRT_DEBUG_SNDQ_HIGHRATE */
 
     while (!self->m_bClosing)
     {
         const steady_clock::time_point next_time = self->m_pSndUList->getNextProcTime();
 
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-        self->m_WorkerStats.lIteration++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
+        INCREMENT_THREAD_ITERATIONS();
+
+        IF_DEBUG_HIGHRATE(self->m_WorkerStats.lIteration++);
 
         if (is_zero(next_time))
         {
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-            self->m_WorkerStats.lNotReadyTs++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
-
-            UniqueLock windlock (self->m_WindowLock);
-            CSync windsync  (self->m_WindowCond, windlock);
+            IF_DEBUG_HIGHRATE(self->m_WorkerStats.lNotReadyTs++);
 
             // wait here if there is no sockets with data to be sent
             THREAD_PAUSED();
-            if (!self->m_bClosing && (self->m_pSndUList->m_iLastEntry < 0))
+            if (!self->m_bClosing)
             {
-                windsync.wait();
-
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-                self->m_WorkerStats.lCondWait++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
+                self->m_pSndUList->waitNonEmpty();
+                IF_DEBUG_HIGHRATE(self->m_WorkerStats.lCondWait++);
             }
             THREAD_RESUMED();
 
@@ -576,76 +544,92 @@ void *CSndQueue::worker(void *param)
         // wait until next processing time of the first socket on the list
         const steady_clock::time_point currtime = steady_clock::now();
 
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-        if (self->m_ullDbgTime <= currtime)
+        IF_DEBUG_HIGHRATE(CSndQueueDebugHighratePrint(self, currtime));
+        if (currtime < next_time)
         {
-            fprintf(stdout,
-                    "SndQueue %lu slt:%lu nrp:%lu snt:%lu nrt:%lu ctw:%lu\n",
-                    self->m_WorkerStats.lIteration,
-                    self->m_WorkerStats.lSleepTo,
-                    self->m_WorkerStats.lNotReadyPop,
-                    self->m_WorkerStats.lSendTo,
-                    self->m_WorkerStats.lNotReadyTs,
-                    self->m_WorkerStats.lCondWait);
-            memset(&self->m_WorkerStats, 0, sizeof(self->m_WorkerStats));
-            self->m_ullDbgTime = currtime + self->m_ullDbgPeriod;
+            THREAD_PAUSED();
+            self->m_pTimer->sleep_until(next_time);
+            THREAD_RESUMED();
+            IF_DEBUG_HIGHRATE(self->m_WorkerStats.lSleepTo++);
         }
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
 
-        THREAD_PAUSED();
-        if (currtime < next_time)
+        // Get a socket with a send request if any.
+        CUDT* u = self->m_pSndUList->pop();
+        if (u == NULL)
         {
-            self->m_pTimer->sleep_until(next_time);
+            IF_DEBUG_HIGHRATE(self->m_WorkerStats.lNotReadyPop++);
+            continue;
+        }
 
-#if defined(HAI_DEBUG_SNDQ_HIGHRATE)
-            self->m_WorkerStats.lSleepTo++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
+#define UST(field) ((u->m_b##field) ? "+" : "-") << #field << " "
+        HLOGC(qslog.Debug,
+            log << "CSndQueue: requesting packet from @" << u->socketID() << " STATUS: " << UST(Listening)
+                << UST(Connecting) << UST(Connected) << UST(Closing) << UST(Shutdown) << UST(Broken) << UST(PeerHealth)
+                << UST(Opened));
+#undef UST
+
+        if (!u->m_bConnected || u->m_bBroken)
+        {
+            IF_DEBUG_HIGHRATE(self->m_WorkerStats.lNotReadyPop++);
+            continue;
         }
-        THREAD_RESUMED();
 
-        // it is time to send the next pkt
-        sockaddr_any addr;
-        CPacket      pkt;
-        if (self->m_pSndUList->pop((addr), (pkt)) < 0)
+        CUDTUnited::SocketKeeper sk (CUDT::uglobal(), u->id());
+        if (!sk.socket)
         {
+            HLOGC(qslog.Debug, log << "Socket to be processed was deleted in the meantime, not packing");
             continue;
+        }
 
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-            self->m_WorkerStats.lNotReadyPop++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
+        // pack a packet from the socket
+        CPacket pkt;
+        steady_clock::time_point next_send_time;
+        sockaddr_any source_addr;
+        const bool res = u->packData((pkt), (next_send_time), (source_addr));
+
+        // Check if extracted anything to send
+        if (res == false)
+        {
+            IF_DEBUG_HIGHRATE(self->m_WorkerStats.lNotReadyPop++);
+            continue;
         }
 
+        const sockaddr_any addr = u->m_PeerAddr;
+        if (!is_zero(next_send_time))
+            self->m_pSndUList->update(u, CSndUList::DO_RESCHEDULE, next_send_time);
+
         HLOGC(qslog.Debug, log << self->CONID() << "chn:SENDING: " << pkt.Info());
-        self->m_pChannel->sendto(addr, pkt);
+        self->m_pChannel->sendto(addr, pkt, source_addr);
 
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)
-        self->m_WorkerStats.lSendTo++;
-#endif /* SRT_DEBUG_SNDQ_HIGHRATE */
+        IF_DEBUG_HIGHRATE(self->m_WorkerStats.lSendTo++);
     }
 
     THREAD_EXIT();
     return NULL;
 }
 
-int CSndQueue::sendto(const sockaddr_any& w_addr, CPacket& w_packet)
+int srt::CSndQueue::sendto(const sockaddr_any& addr, CPacket& w_packet, const sockaddr_any& src)
 {
     // send out the packet immediately (high priority), this is a control packet
-    m_pChannel->sendto(w_addr, w_packet);
+    // NOTE: w_packet is passed by mutable reference because this function will do
+    // a modification in place and then it will revert it. After returning this object
+    // should look unmodified, hence it is here passed without a reference marker.
+    m_pChannel->sendto(addr, w_packet, src);
     return (int)w_packet.getLength();
 }
 
 //
-CRcvUList::CRcvUList()
+srt::CRcvUList::CRcvUList()
     : m_pUList(NULL)
     , m_pLast(NULL)
 {
 }
 
-CRcvUList::~CRcvUList() {}
+srt::CRcvUList::~CRcvUList() {}
 
-void CRcvUList::insert(const CUDT *u)
+void srt::CRcvUList::insert(const CUDT* u)
 {
-    CRNode *n      = u->m_pRNode;
+    CRNode* n        = u->m_pRNode;
     n->m_tsTimeStamp = steady_clock::now();
 
     if (NULL == m_pUList)
@@ -664,9 +648,9 @@ void CRcvUList::insert(const CUDT *u)
     m_pLast          = n;
 }
 
-void CRcvUList::remove(const CUDT *u)
+void srt::CRcvUList::remove(const CUDT* u)
 {
-    CRNode *n = u->m_pRNode;
+    CRNode* n = u->m_pRNode;
 
     if (!n->m_bOnList)
         return;
@@ -695,9 +679,9 @@ void CRcvUList::remove(const CUDT *u)
     n->m_pNext = n->m_pPrev = NULL;
 }
 
-void CRcvUList::update(const CUDT *u)
+void srt::CRcvUList::update(const CUDT* u)
 {
-    CRNode *n = u->m_pRNode;
+    CRNode* n = u->m_pRNode;
 
     if (!n->m_bOnList)
         return;
@@ -726,20 +710,20 @@ void CRcvUList::update(const CUDT *u)
 }
 
 //
-CHash::CHash()
+srt::CHash::CHash()
     : m_pBucket(NULL)
     , m_iHashSize(0)
 {
 }
 
-CHash::~CHash()
+srt::CHash::~CHash()
 {
     for (int i = 0; i < m_iHashSize; ++i)
     {
-        CBucket *b = m_pBucket[i];
+        CBucket* b = m_pBucket[i];
         while (NULL != b)
         {
-            CBucket *n = b->m_pNext;
+            CBucket* n = b->m_pNext;
             delete b;
             b = n;
         }
@@ -748,9 +732,9 @@ CHash::~CHash()
     delete[] m_pBucket;
 }
 
-void CHash::init(int size)
+void srt::CHash::init(int size)
 {
-    m_pBucket = new CBucket *[size];
+    m_pBucket = new CBucket*[size];
 
     for (int i = 0; i < size; ++i)
         m_pBucket[i] = NULL;
@@ -758,10 +742,10 @@ void CHash::init(int size)
     m_iHashSize = size;
 }
 
-CUDT *CHash::lookup(int32_t id)
+srt::CUDT* srt::CHash::lookup(int32_t id)
 {
     // simple hash function (% hash table size); suitable for socket descriptors
-    CBucket *b = m_pBucket[id % m_iHashSize];
+    CBucket* b = m_pBucket[id % m_iHashSize];
 
     while (NULL != b)
     {
@@ -773,7 +757,7 @@ CUDT *CHash::lookup(int32_t id)
     return NULL;
 }
 
-CUDT* CHash::lookupPeer(int32_t peerid)
+srt::CUDT* srt::CHash::lookupPeer(int32_t peerid)
 {
     // Decode back the socket ID if it has that peer
     int32_t id = map_get(m_RevPeerMap, peerid, -1);
@@ -782,11 +766,11 @@ CUDT* CHash::lookupPeer(int32_t peerid)
     return lookup(id);
 }
 
-void CHash::insert(int32_t id, CUDT *u)
+void srt::CHash::insert(int32_t id, CUDT* u)
 {
-    CBucket *b = m_pBucket[id % m_iHashSize];
+    CBucket* b = m_pBucket[id % m_iHashSize];
 
-    CBucket *n = new CBucket;
+    CBucket* n = new CBucket;
     n->m_iID   = id;
     n->m_iPeerID = u->peerID();
     n->m_pUDT  = u;
@@ -796,10 +780,10 @@ void CHash::insert(int32_t id, CUDT *u)
     m_RevPeerMap[u->peerID()] = id;
 }
 
-void CHash::remove(int32_t id)
+void srt::CHash::remove(int32_t id)
 {
-    CBucket *b = m_pBucket[id % m_iHashSize];
-    CBucket *p = NULL;
+    CBucket* b = m_pBucket[id % m_iHashSize];
+    CBucket* p = NULL;
 
     while (NULL != b)
     {
@@ -822,37 +806,39 @@ void CHash::remove(int32_t id)
 }
 
 //
-CRendezvousQueue::CRendezvousQueue()
+srt::CRendezvousQueue::CRendezvousQueue()
     : m_lRendezvousID()
-    , m_RIDVectorLock()
+    , m_RIDListLock()
 {
 }
 
-CRendezvousQueue::~CRendezvousQueue()
+srt::CRendezvousQueue::~CRendezvousQueue()
 {
     m_lRendezvousID.clear();
 }
 
-void CRendezvousQueue::insert(
-    const SRTSOCKET& id, CUDT* u, const sockaddr_any& addr, const steady_clock::time_point& ttl)
+void srt::CRendezvousQueue::insert(const SRTSOCKET&           id,
+                              CUDT*                           u,
+                              const sockaddr_any&             addr,
+                              const steady_clock::time_point& ttl)
 {
-    ScopedLock vg(m_RIDVectorLock);
+    ScopedLock vg(m_RIDListLock);
 
     CRL r;
-    r.m_iID        = id;
-    r.m_pUDT       = u;
+    r.m_iID      = id;
+    r.m_pUDT     = u;
     r.m_PeerAddr = addr;
-    r.m_tsTTL = ttl;
+    r.m_tsTTL    = ttl;
 
     m_lRendezvousID.push_back(r);
-    HLOGC(cnlog.Debug, log << "RID: adding socket @" << id << " for address: " << addr.str()
-            << " expires: " << FormatTime(ttl)
-            << " (total connectors: " << m_lRendezvousID.size() << ")");
+    HLOGC(cnlog.Debug,
+          log << "RID: adding socket @" << id << " for address: " << addr.str() << " expires: " << FormatTime(ttl)
+              << " (total connectors: " << m_lRendezvousID.size() << ")");
 }
 
-void CRendezvousQueue::remove(const SRTSOCKET &id)
+void srt::CRendezvousQueue::remove(const SRTSOCKET& id)
 {
-    ScopedLock lkv (m_RIDVectorLock);
+    ScopedLock lkv(m_RIDListLock);
 
     for (list<CRL>::iterator i = m_lRendezvousID.begin(); i != m_lRendezvousID.end(); ++i)
     {
@@ -864,203 +850,86 @@ void CRendezvousQueue::remove(const SRTSOCKET &id)
     }
 }
 
-CUDT* CRendezvousQueue::retrieve(const sockaddr_any& addr, SRTSOCKET& w_id)
+srt::CUDT* srt::CRendezvousQueue::retrieve(const sockaddr_any& addr, SRTSOCKET& w_id) const
 {
-    ScopedLock     vg(m_RIDVectorLock);
+    ScopedLock vg(m_RIDListLock);
+
+    IF_HEAVY_LOGGING(const char* const id_type = w_id ? "THIS ID" : "A NEW CONNECTION");
 
     // TODO: optimize search
-    for (list<CRL>::iterator i = m_lRendezvousID.begin(); i != m_lRendezvousID.end(); ++i)
+    for (list<CRL>::const_iterator i = m_lRendezvousID.begin(); i != m_lRendezvousID.end(); ++i)
     {
         if (i->m_PeerAddr == addr && ((w_id == 0) || (w_id == i->m_iID)))
         {
-            HLOGC(cnlog.Debug, log << "RID: found id @" << i->m_iID << " while looking for "
-                    << (w_id ? "THIS ID FROM " : "A NEW CONNECTION FROM ")
-                    << i->m_PeerAddr.str());
+            // This procedure doesn't exactly respond to the original UDT idea.
+            // As the "rendezvous queue" is used for both handling rendezvous and
+            // the caller sockets in the non-blocking mode (for blocking mode the
+            // entire handshake procedure is handled in a loop-style in CUDT::startConnect),
+            // the RID list should give up a socket entity in the following cases:
+            // 1. For THE SAME id as passed in w_id, respond always, as per a caller
+            //    socket that is currently trying to connect and is managed with
+            //    HS roundtrips in an event-style. Same for rendezvous.
+            // 2. For the "connection request" ID=0 the found socket should be given up
+            //    ONLY IF it is rendezvous. Normally ID=0 is only for listener as a
+            //    connection request. But if there was a listener, then this function
+            //    wouldn't even be called, as this case would be handled before trying
+            //    to call this function.
+            //
+            // This means: if an incoming ID is 0, then this search should succeed ONLY
+            // IF THE FOUND SOCKET WAS RENDEZVOUS.
+
+            if (!w_id && !i->m_pUDT->m_config.bRendezvous)
+            {
+                HLOGC(cnlog.Debug,
+                        log << "RID: found id @" << i->m_iID << " while looking for "
+                        << id_type << " FROM " << i->m_PeerAddr.str()
+                        << ", but it's NOT RENDEZVOUS, skipping");
+                continue;
+            }
+
+            HLOGC(cnlog.Debug,
+                    log << "RID: found id @" << i->m_iID << " while looking for "
+                    << id_type << " FROM " << i->m_PeerAddr.str());
             w_id = i->m_iID;
             return i->m_pUDT;
         }
     }
 
 #if ENABLE_HEAVY_LOGGING
-   std::ostringstream spec;
-   if (w_id == 0)
-       spec << "A NEW CONNECTION REQUEST";
-   else
-       spec << " AGENT @" << w_id;
-   HLOGC(cnlog.Debug, log << "RID: NO CONNECTOR FOR ADR:" << addr.str()
-           << " while looking for " << spec.str() << " (" << m_lRendezvousID.size() << " connectors total)");
+    std::ostringstream spec;
+    if (w_id == 0)
+        spec << "A NEW CONNECTION REQUEST";
+    else
+        spec << " AGENT @" << w_id;
+    HLOGC(cnlog.Debug,
+          log << "RID: NO CONNECTOR FOR ADR:" << addr.str() << " while looking for " << spec.str() << " ("
+              << m_lRendezvousID.size() << " connectors total)");
 #endif
 
     return NULL;
 }
 
-struct LinkStatusInfo
-{
-    CUDT* u;
-    SRTSOCKET id;
-    int errorcode;
-    sockaddr_any peeraddr;
-    int token;
-
-    struct HasID
-    {
-        SRTSOCKET id;
-        HasID(SRTSOCKET p): id(p) {}
-        bool operator()(const LinkStatusInfo& i)
-        {
-            return i.id == id;
-        }
-    };
-};
-
-void CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst, const CPacket &response)
+void srt::CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst, CUnit* unit)
 {
-    vector<LinkStatusInfo> ufailed, uprocess;
-
-#if ENABLE_HEAVY_LOGGING
-        int debug_nupd  = 0;
-        int debug_nrun  = 0;
-        int debug_nfail = 0;
-#endif
-
-    {
-        ScopedLock vg(m_RIDVectorLock);
-
-        if (m_lRendezvousID.empty())
-            return;
-
-        HLOGC(cnlog.Debug,
-                log << "updateConnStatus: updating after getting pkt id=" << response.m_iID
-                << " status: " << ConnectStatusStr(cst));
-
-        for (list<CRL>::iterator i = m_lRendezvousID.begin(), i_next = i; i != m_lRendezvousID.end(); i = i_next)
-        {
-            ++i_next;
-            // NOTE: This is a SAFE LOOP.
-            // Incrementation will be done at the end, after the processing did not
-            // REMOVE the currently processed element. When the element was removed,
-            // the iterator value for the next iteration will be taken from erase()'s result.
-
-            // RST_AGAIN happens in case when the last attempt to read a packet from the UDP
-            // socket has read nothing. In this case it would be a repeated update, while
-            // still waiting for a response from the peer. When we have any other state here
-            // (most expectably CONN_CONTINUE or CONN_RENDEZVOUS, which means that a packet has
-            // just arrived in this iteration), do the update immetiately (in SRT this also
-            // involves additional incoming data interpretation, which wasn't the case in UDT).
-
-            // Use "slow" cyclic responding in case when
-            // - RST_AGAIN (no packet was received for whichever socket)
-            // - a packet was received, but not for THIS socket
-            if (rst == RST_AGAIN || i->m_iID != response.m_iID)
-            {
-                // If no packet has been received from the peer,
-                // avoid sending too many requests, at most 1 request per 250ms
-                const steady_clock::time_point then = i->m_pUDT->m_tsLastReqTime;
-                const steady_clock::time_point now = steady_clock::now();
-                const steady_clock::duration timeout_250ms = milliseconds_from(250);
-                const bool now_is_time = (now - then) > timeout_250ms;
-                HLOGC(cnlog.Debug,
-                        log << "RID:@" << i->m_iID << " then=" << FormatTime(then)
-                        << " now=" << FormatTime(now) << " passed=" << count_microseconds(now - then)
-                        << "<=> 250000 -- now's " << (now_is_time ? "" : "NOT ") << "the time");
-
-                if (!now_is_time)
-                    continue;
-            }
-
-            HLOGC(cnlog.Debug, log << "RID:@" << i->m_iID << " cst=" << ConnectStatusStr(cst) << " -- sending update NOW.");
-
-#if ENABLE_HEAVY_LOGGING
-            ++debug_nrun;
-#endif
-
-            // XXX This looks like a loop that rolls in infinity without any sleeps
-            // inside and makes it once per about 50 calls send a hs conclusion
-            // for a randomly sampled rendezvous ID of a socket out of the list.
-            // Ok, probably the rendezvous ID should be just one so not much to
-            // sample from, but if so, why the container?
-            //
-            // This must be somehow fixed!
-            //
-            // Maybe the time should be simply checked once and the whole loop not
-            // done when "it's not the time"?
-            const steady_clock::time_point now = steady_clock::now();
-            if (now >= i->m_tsTTL)
-            {
-                HLOGC(cnlog.Debug, log << "RID: socket @" << i->m_iID
-                        << " removed - EXPIRED ("
-                        // The "enforced on FAILURE" is below when processAsyncConnectRequest failed.
-                        << (is_zero(i->m_tsTTL) ? "enforced on FAILURE" : "passed TTL")
-                        << "). WILL REMOVE from queue");
-
-                // Set appropriate error information, but do not update yet.
-                // Exit the lock first. Collect objects to update them later.
-                int ccerror = SRT_ECONNREJ;
-                if (i->m_pUDT->m_RejectReason == SRT_REJ_UNKNOWN)
-                {
-                    if (!is_zero(i->m_tsTTL))
-                    {
-                        // Timer expired, set TIMEOUT forcefully
-                        i->m_pUDT->m_RejectReason = SRT_REJ_TIMEOUT;
-                        ccerror = SRT_ENOSERVER;
-                    }
-                    else
-                    {
-                        // In case of unknown reason, rejection should at least
-                        // suggest error on the peer
-                        i->m_pUDT->m_RejectReason = SRT_REJ_PEER;
-                    }
-                }
-
-                // The call to completeBrokenConnectionDependencies() cannot happen here
-                // under the lock of m_RIDVectorLock as it risks a deadlock. Collect it
-                // to update later.
-                LinkStatusInfo fi = {i->m_pUDT, i->m_iID, ccerror, i->m_PeerAddr, -1};
-                ufailed.push_back(fi);
-
-                /*
-                 * Setting m_bConnecting to false but keeping socket in rendezvous queue is not a good idea.
-                 * Next CUDT::close will not remove it from rendezvous queue (because !m_bConnecting)
-                 * and may crash here on next pass.
-                 */
-                // i_next was preincremented, but this is guaranteed to point to
-                // the element next to erased one.
-                i_next = m_lRendezvousID.erase(i);
-                continue;
-            }
-            else
-            {
-                HLOGC(cnlog.Debug, log << "RID: socket @" << i->m_iID << " still active (remaining "
-                        << std::fixed << (count_microseconds(i->m_tsTTL - now)/1000000.0) << "s of TTL)...");
-            }
+    vector<LinkStatusInfo> toRemove, toProcess;
 
-            // This queue is used only in case of Async mode (rendezvous or caller-listener).
-            // Synchronous connection requests are handled in startConnect() completely.
-            if (!i->m_pUDT->m_bSynRecving)
-            {
-                IF_HEAVY_LOGGING(++debug_nupd);
-
-                // Collect them so that they can be updated out of m_RIDVectorLock.
-                LinkStatusInfo fi = { i->m_pUDT, i->m_iID, SRT_SUCCESS, i->m_PeerAddr, -1};
-                uprocess.push_back(fi);
-                // NOTE: safe loop, the incrementation was done before the loop body,
-                // so the `i' node can be safely deleted. Just the body must end here.
-                continue;
-            }
-            else
-            {
-                HLOGC(cnlog.Debug, log << "RID: socket @" << i->m_iID << " deemed SYNCHRONOUS, NOT UPDATING");
-            }
-        }
+    const CPacket* pkt = unit ? &unit->m_Packet : NULL;
 
-    }
+    // Need a stub value for a case when there's no unit provided ("storage depleted" case).
+    // It should be normally NOT IN USE because in case of "storage depleted", rst != RST_OK.
+    const SRTSOCKET dest_id = pkt ? pkt->id() : 0;
 
-    // [[using locked()]];
+    // If no socket were qualified for further handling, finish here.
+    // Otherwise toRemove and toProcess contain items to handle.
+    if (!qualifyToHandle(rst, cst, dest_id, (toRemove), (toProcess)))
+        return;
 
-    HLOGC(cnlog.Debug, log << "updateConnStatus: collected " << uprocess.size() << " for processing, "
-            << ufailed.size() << " to close");
+    HLOGC(cnlog.Debug,
+          log << "updateConnStatus: collected " << toProcess.size() << " for processing, " << toRemove.size()
+              << " to close");
 
-    for (vector<LinkStatusInfo>::iterator i = uprocess.begin(); i != uprocess.end(); ++i)
+    // Repeat (resend) connection request.
+    for (vector<LinkStatusInfo>::iterator i = toProcess.begin(); i != toProcess.end(); ++i)
     {
         // IMPORTANT INFORMATION concerning changes towards UDT legacy.
         // In the UDT code there was no attempt to interpret any incoming data.
@@ -1068,7 +937,7 @@ void CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst, con
         // m_ConnRes field, and m_ConnReq field was considered at this time accordingly updated.
         // Therefore this procedure did only one thing: craft a new handshake packet and send it.
         // In SRT this may also interpret extra data (extensions in case when Agent is Responder)
-        // and the `response` packet may sometimes contain no data. Therefore the passed `rst`
+        // and the `pktIn` packet may sometimes contain no data. Therefore the passed `rst`
         // must be checked to distinguish the call by periodic update (RST_AGAIN) from a call
         // due to have received the packet (RST_OK).
         //
@@ -1079,25 +948,50 @@ void CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst, con
         EReadStatus    read_st = rst;
         EConnectStatus conn_st = cst;
 
-        if (i->id != response.m_iID)
+        CUDTUnited::SocketKeeper sk (CUDT::uglobal(), i->id);
+        if (!sk.socket)
         {
-            read_st = RST_AGAIN;
-            conn_st = CONN_AGAIN;
+            // Socket deleted already, so stop this and proceed to the next loop.
+            LOGC(cnlog.Error, log << "updateConnStatus: IPE: socket @" << i->id << " already closed, proceed to only removal from lists");
+            toRemove.push_back(*i);
+            continue;
         }
 
-        HLOGC(cnlog.Debug, log << "updateConnStatus: processing async conn for @" << i->id << " FROM " << i->peeraddr.str());
 
-        if (!i->u->processAsyncConnectRequest(read_st, conn_st, response, i->peeraddr))
+        if (cst != CONN_RENDEZVOUS && dest_id != 0)
+        {
+            if (i->id != dest_id)
+            {
+                HLOGC(cnlog.Debug, log << "updateConnStatus: cst=" << ConnectStatusStr(cst) << " but for RID @" << i->id
+                        << " dest_id=@" << dest_id << " - resetting to AGAIN");
+
+                read_st = RST_AGAIN;
+                conn_st = CONN_AGAIN;
+            }
+            else
+            {
+                HLOGC(cnlog.Debug, log << "updateConnStatus: cst=" << ConnectStatusStr(cst) << " for @"
+                        << i->id);
+            }
+        }
+        else
+        {
+            HLOGC(cnlog.Debug, log << "updateConnStatus: cst=" << ConnectStatusStr(cst) << " and dest_id=@" << dest_id
+                    << " - NOT checking against RID @" << i->id);
+        }
+
+        HLOGC(cnlog.Debug,
+              log << "updateConnStatus: processing async conn for @" << i->id << " FROM " << i->peeraddr.str());
+
+        if (!i->u->processAsyncConnectRequest(read_st, conn_st, pkt, i->peeraddr))
         {
             // cst == CONN_REJECT can only be result of worker_ProcessAddressedPacket and
             // its already set in this case.
             LinkStatusInfo fi = *i;
-            fi.errorcode = SRT_ECONNREJ;
-            ufailed.push_back(fi);
+            fi.errorcode      = SRT_ECONNREJ;
+            toRemove.push_back(fi);
             i->u->sendCtrl(UMSG_SHUTDOWN);
-            IF_HEAVY_LOGGING(++debug_nfail);
         }
-
     }
 
     // NOTE: it is "believed" here that all CUDT objects will not be
@@ -1106,45 +1000,175 @@ void CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst, con
     // they are moved to ClosedSockets and it is believed that this function will
     // not be held on mutexes that long.
 
-    for (vector<LinkStatusInfo>::iterator i = ufailed.begin(); i != ufailed.end(); ++i)
+    for (vector<LinkStatusInfo>::iterator i = toRemove.begin(); i != toRemove.end(); ++i)
     {
         HLOGC(cnlog.Debug, log << "updateConnStatus: COMPLETING dep objects update on failed @" << i->id);
+        remove(i->id);
+
+        CUDTUnited::SocketKeeper sk (CUDT::uglobal(), i->id);
+        if (!sk.socket)
+        {
+            // This actually shall never happen, so it's a kind of paranoid check.
+            LOGC(cnlog.Error, log << "updateConnStatus: IPE: socket @" << i->id << " already closed, NOT ACCESSING its contents");
+            continue;
+        }
+
+        // Setting m_bConnecting to false, and need to remove the socket from the rendezvous queue
+        // because the next CUDT::close will not remove it from the queue when m_bConnecting = false,
+        // and may crash on next pass.
+        //
+        // TODO: maybe lock i->u->m_ConnectionLock?
         i->u->m_bConnecting = false;
-        i->u->updateBrokenConnection();
+
+        // DO NOT close the socket here because in this case it might be
+        // unable to get status from at the right moment. Also only member
+        // sockets should be taken care of internally - single sockets should
+        // be normally closed by the application, after it is done with them.
+
+        // app can call any UDT API to learn the connection_broken error
+        CUDT::uglobal().m_EPoll.update_events(
+            i->u->m_SocketID, i->u->m_sPollID, SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR, true);
+
+        // Make sure that the socket wasn't deleted in the meantime.
+        // Skip this part if it was. Note also that if the socket was
+        // decided to be deleted, it's already moved to m_ClosedSockets
+        // and should have been therefore already processed for deletion.
+
         i->u->completeBrokenConnectionDependencies(i->errorcode);
     }
 
     {
         // Now, additionally for every failed link reset the TTL so that
         // they are set expired right now.
-        ScopedLock vg(m_RIDVectorLock);
+        ScopedLock vg(m_RIDListLock);
         for (list<CRL>::iterator i = m_lRendezvousID.begin(); i != m_lRendezvousID.end(); ++i)
         {
-            if (find_if(ufailed.begin(), ufailed.end(), LinkStatusInfo::HasID(i->m_iID)) != ufailed.end())
+            if (find_if(toRemove.begin(), toRemove.end(), LinkStatusInfo::HasID(i->m_iID)) != toRemove.end())
             {
-                LOGC(cnlog.Error, log << "updateConnStatus: processAsyncConnectRequest FAILED on @" << i->m_iID << ". Setting TTL as EXPIRED.");
-                i->m_tsTTL = steady_clock::time_point(); // Make it expire right now, will be picked up at the next iteration
+                LOGC(cnlog.Error,
+                     log << "updateConnStatus: processAsyncConnectRequest FAILED on @" << i->m_iID
+                         << ". Setting TTL as EXPIRED.");
+                i->m_tsTTL =
+                    steady_clock::time_point(); // Make it expire right now, will be picked up at the next iteration
             }
         }
     }
+}
+
+bool srt::CRendezvousQueue::qualifyToHandle(EReadStatus    rst,
+                                       EConnectStatus cst      SRT_ATR_UNUSED,
+                                       int                     iDstSockID,
+                                       vector<LinkStatusInfo>& toRemove,
+                                       vector<LinkStatusInfo>& toProcess)
+{
+    ScopedLock vg(m_RIDListLock);
+
+    if (m_lRendezvousID.empty())
+        return false; // nothing to process.
 
     HLOGC(cnlog.Debug,
-            log << "updateConnStatus: " << debug_nupd << "/" << debug_nrun << " sockets updated ("
-            << (debug_nrun - debug_nupd) << " useless). REMOVED " << debug_nfail << " sockets.");
+          log << "updateConnStatus: updating after getting pkt with DST socket ID @" << iDstSockID
+              << " status: " << ConnectStatusStr(cst));
+
+    for (list<CRL>::iterator i = m_lRendezvousID.begin(), i_next = i; i != m_lRendezvousID.end(); i = i_next)
+    {
+        // Safe iterator to the next element. If the current element is erased, the iterator is updated again.
+        ++i_next;
+
+        const steady_clock::time_point tsNow = steady_clock::now();
+
+        if (tsNow >= i->m_tsTTL)
+        {
+            HLOGC(cnlog.Debug,
+                  log << "RID: socket @" << i->m_iID
+                      << " removed - EXPIRED ("
+                      // The "enforced on FAILURE" is below when processAsyncConnectRequest failed.
+                      << (is_zero(i->m_tsTTL) ? "enforced on FAILURE" : "passed TTL") << "). WILL REMOVE from queue.");
+
+            // Set appropriate error information, but do not update yet.
+            // Exit the lock first. Collect objects to update them later.
+            int ccerror = SRT_ECONNREJ;
+            if (i->m_pUDT->m_RejectReason == SRT_REJ_UNKNOWN)
+            {
+                if (!is_zero(i->m_tsTTL))
+                {
+                    // Timer expired, set TIMEOUT forcefully
+                    i->m_pUDT->m_RejectReason = SRT_REJ_TIMEOUT;
+                    ccerror                   = SRT_ENOSERVER;
+                }
+                else
+                {
+                    // In case of unknown reason, rejection should at least
+                    // suggest error on the peer
+                    i->m_pUDT->m_RejectReason = SRT_REJ_PEER;
+                }
+            }
+
+            // The call to completeBrokenConnectionDependencies() cannot happen here
+            // under the lock of m_RIDListLock as it risks a deadlock.
+            // Collect in 'toRemove' to update later.
+            LinkStatusInfo fi = {i->m_pUDT, i->m_iID, ccerror, i->m_PeerAddr, -1};
+            toRemove.push_back(fi);
+
+            // i_next was preincremented, but this is guaranteed to point to
+            // the element next to erased one.
+            i_next = m_lRendezvousID.erase(i);
+            continue;
+        }
+        else
+        {
+            HLOGC(cnlog.Debug,
+                  log << "RID: socket @" << i->m_iID << " still active (remaining " << std::fixed
+                      << (count_microseconds(i->m_tsTTL - tsNow) / 1000000.0) << "s of TTL)...");
+        }
+
+        const steady_clock::time_point tsLastReq = i->m_pUDT->m_tsLastReqTime;
+        const steady_clock::time_point tsRepeat =
+            tsLastReq + milliseconds_from(250); // Repeat connection request (send HS).
+
+        // A connection request is repeated every 250 ms if there was no response from the peer:
+        // - RST_AGAIN means no packet was received over UDP.
+        // - a packet was received, but not for THIS socket.
+        if ((rst == RST_AGAIN || i->m_iID != iDstSockID) && tsNow <= tsRepeat)
+        {
+            HLOGC(cnlog.Debug,
+                  log << "RID:@" << i->m_iID << " " << FormatDuration<DUNIT_MS>(tsNow - tsLastReq)
+                      << " passed since last connection request.");
+
+            continue;
+        }
+
+        HLOGC(cnlog.Debug,
+              log << "RID:@" << i->m_iID << " cst=" << ConnectStatusStr(cst) << " -- repeating connection request.");
+
+        // This queue is used only in case of Async mode (rendezvous or caller-listener).
+        // Synchronous connection requests are handled in startConnect() completely.
+        if (!i->m_pUDT->m_config.bSynRecving)
+        {
+            // Collect them so that they can be updated out of m_RIDListLock.
+            LinkStatusInfo fi = {i->m_pUDT, i->m_iID, SRT_SUCCESS, i->m_PeerAddr, -1};
+            toProcess.push_back(fi);
+        }
+        else
+        {
+            HLOGC(cnlog.Debug, log << "RID: socket @" << i->m_iID << " is SYNCHRONOUS, NOT UPDATING");
+        }
+    }
+
+    return !toRemove.empty() || !toProcess.empty();
 }
 
 //
-CRcvQueue::CRcvQueue()
+srt::CRcvQueue::CRcvQueue()
     : m_WorkerThread()
-    , m_UnitQueue()
+    , m_pUnitQueue(NULL)
     , m_pRcvUList(NULL)
     , m_pHash(NULL)
     , m_pChannel(NULL)
     , m_pTimer(NULL)
-    , m_iPayloadSize()
+    , m_iIPversion()
+    , m_szPayloadSize()
     , m_bClosing(false)
-    , m_LSLock()
-    , m_pListener(NULL)
     , m_pRendezvousQueue(NULL)
     , m_vNewEntry()
     , m_IDLock()
@@ -1154,7 +1178,7 @@ CRcvQueue::CRcvQueue()
     setupCond(m_BufferCond, "QueueBuffer");
 }
 
-CRcvQueue::~CRcvQueue()
+srt::CRcvQueue::~CRcvQueue()
 {
     m_bClosing = true;
 
@@ -1165,17 +1189,17 @@ CRcvQueue::~CRcvQueue()
     }
     releaseCond(m_BufferCond);
 
+    delete m_pUnitQueue;
     delete m_pRcvUList;
     delete m_pHash;
     delete m_pRendezvousQueue;
 
     // remove all queued messages
-    for (map<int32_t, std::queue<CPacket *> >::iterator i = m_mBuffer.begin(); i != m_mBuffer.end(); ++i)
+    for (map<int32_t, std::queue<CPacket*> >::iterator i = m_mBuffer.begin(); i != m_mBuffer.end(); ++i)
     {
         while (!i->second.empty())
         {
-            CPacket *pkt = i->second.front();
-            delete[] pkt->m_pcData;
+            CPacket* pkt = i->second.front();
             delete pkt;
             i->second.pop();
         }
@@ -1183,15 +1207,16 @@ CRcvQueue::~CRcvQueue()
 }
 
 #if ENABLE_LOGGING
-    int CRcvQueue::m_counter = 0;
+srt::sync::atomic<int> srt::CRcvQueue::m_counter(0);
 #endif
 
-
-void CRcvQueue::init(int qsize, int payload, int version, int hsize, CChannel *cc, CTimer *t)
+void srt::CRcvQueue::init(int qsize, size_t payload, int version, int hsize, CChannel* cc, CTimer* t)
 {
-    m_iPayloadSize = payload;
+    m_iIPversion    = version;
+    m_szPayloadSize = payload;
 
-    m_UnitQueue.init(qsize, payload, version);
+    SRT_ASSERT(m_pUnitQueue == NULL);
+    m_pUnitQueue = new CUnitQueue(qsize, (int)payload);
 
     m_pHash = new CHash;
     m_pHash->init(hsize);
@@ -1203,8 +1228,8 @@ void CRcvQueue::init(int qsize, int payload, int version, int hsize, CChannel *c
     m_pRendezvousQueue = new CRendezvousQueue;
 
 #if ENABLE_LOGGING
-    ++m_counter;
-    const std::string thrname = "SRT:RcvQ:w" + Sprint(m_counter);
+    const int cnt = ++m_counter;
+    const std::string thrname = "SRT:RcvQ:w" + Sprint(cnt);
 #else
     const std::string thrname = "SRT:RcvQ:w";
 #endif
@@ -1215,24 +1240,24 @@ void CRcvQueue::init(int qsize, int payload, int version, int hsize, CChannel *c
     }
 }
 
-void *CRcvQueue::worker(void *param)
+void* srt::CRcvQueue::worker(void* param)
 {
-    CRcvQueue *  self = (CRcvQueue *)param;
-    sockaddr_any sa(self->m_UnitQueue.getIPversion());
+    CRcvQueue*   self = (CRcvQueue*)param;
+    sockaddr_any sa(self->getIPversion());
     int32_t      id = 0;
 
-#if ENABLE_LOGGING
-    THREAD_STATE_INIT(("SRT:RcvQ:w" + Sprint(m_counter)).c_str());
-#else
-    THREAD_STATE_INIT("SRT:RcvQ:worker");
-#endif
+    std::string thname;
+    ThreadName::get(thname);
+    THREAD_STATE_INIT(thname.c_str());
 
-    CUnit *        unit = 0;
+    CUnit*         unit = 0;
     EConnectStatus cst  = CONN_AGAIN;
     while (!self->m_bClosing)
     {
         bool        have_received = false;
         EReadStatus rst           = self->worker_RetrieveUnit((id), (unit), (sa));
+
+        INCREMENT_THREAD_ITERATIONS();
         if (rst == RST_OK)
         {
             if (id < 0)
@@ -1297,12 +1322,13 @@ void *CRcvQueue::worker(void *param)
         // OTHERWISE: this is an "AGAIN" situation. No data was read, but the process should continue.
 
         // take care of the timing event for all UDT sockets
-        const steady_clock::time_point curtime_minus_syn = steady_clock::now() - microseconds_from(CUDT::COMM_SYN_INTERVAL_US);
+        const steady_clock::time_point curtime_minus_syn =
+            steady_clock::now() - microseconds_from(CUDT::COMM_SYN_INTERVAL_US);
 
-        CRNode *ul = self->m_pRcvUList->m_pUList;
+        CRNode* ul = self->m_pRcvUList->m_pUList;
         while ((NULL != ul) && (ul->m_tsTimeStamp < curtime_minus_syn))
         {
-            CUDT *u = ul->m_pUDT;
+            CUDT* u = ul->m_pUDT;
 
             if (u->m_bConnected && !u->m_bBroken && !u->m_bClosing)
             {
@@ -1335,7 +1361,7 @@ void *CRcvQueue::worker(void *param)
         // worker_TryAsyncRend_OrStore --->
         // CUDT::processAsyncConnectResponse --->
         // CUDT::processConnectResponse
-        self->m_pRendezvousQueue->updateConnStatus(rst, cst, unit->m_Packet);
+        self->m_pRendezvousQueue->updateConnStatus(rst, cst, unit);
 
         // XXX updateConnStatus may have removed the connector from the list,
         // however there's still m_mBuffer in CRcvQueue for that socket to care about.
@@ -1347,7 +1373,7 @@ void *CRcvQueue::worker(void *param)
     return NULL;
 }
 
-EReadStatus CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_unit, sockaddr_any& w_addr)
+srt::EReadStatus srt::CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_unit, sockaddr_any& w_addr)
 {
 #if !USE_BUSY_WAITING
     // This might be not really necessary, and probably
@@ -1358,7 +1384,7 @@ EReadStatus CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_unit, sockad
     // check waiting list, if new socket, insert it to the list
     while (ifNewEntry())
     {
-        CUDT *ne = getNewEntry();
+        CUDT* ne = getNewEntry();
         if (ne)
         {
             HLOGC(qrlog.Debug,
@@ -1369,26 +1395,24 @@ EReadStatus CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_unit, sockad
         }
     }
     // find next available slot for incoming packet
-    w_unit = m_UnitQueue.getNextAvailUnit();
+    w_unit = m_pUnitQueue->getNextAvailUnit();
     if (!w_unit)
     {
         // no space, skip this packet
         CPacket temp;
-        temp.m_pcData = new char[m_iPayloadSize];
-        temp.setLength(m_iPayloadSize);
+        temp.allocate(m_szPayloadSize);
         THREAD_PAUSED();
         EReadStatus rst = m_pChannel->recvfrom((w_addr), (temp));
         THREAD_RESUMED();
         // Note: this will print nothing about the packet details unless heavy logging is on.
         LOGC(qrlog.Error, log << CONID() << "LOCAL STORAGE DEPLETED. Dropping 1 packet: " << temp.Info());
-        delete[] temp.m_pcData;
 
         // Be transparent for RST_ERROR, but ignore the correct
         // data read and fake that the packet was dropped.
         return rst == RST_ERROR ? RST_ERROR : RST_AGAIN;
     }
 
-    w_unit->m_Packet.setLength(m_iPayloadSize);
+    w_unit->m_Packet.setLength(m_szPayloadSize);
 
     // reading next incoming packet, recvfrom returns -1 is nothing has been received
     THREAD_PAUSED();
@@ -1397,32 +1421,32 @@ EReadStatus CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_unit, sockad
 
     if (rst == RST_OK)
     {
-        w_id = w_unit->m_Packet.m_iID;
-        HLOGC(qrlog.Debug, log << "INCOMING PACKET: FROM=" << w_addr.str()
-                << " BOUND=" << m_pChannel->bindAddressAny().str()
-                << " " << w_unit->m_Packet.Info());
+        w_id = w_unit->m_Packet.id();
+        HLOGC(qrlog.Debug,
+              log << "INCOMING PACKET: FROM=" << w_addr.str() << " BOUND=" << m_pChannel->bindAddressAny().str() << " "
+                  << w_unit->m_Packet.Info());
     }
     return rst;
 }
 
-EConnectStatus CRcvQueue::worker_ProcessConnectionRequest(CUnit* unit, const sockaddr_any& addr)
+srt::EConnectStatus srt::CRcvQueue::worker_ProcessConnectionRequest(CUnit* unit, const sockaddr_any& addr)
 {
     HLOGC(cnlog.Debug,
-          log << "Got sockID=0 from " << addr.str()
-              << " - trying to resolve it as a connection request...");
+          log << "Got sockID=0 from " << addr.str() << " - trying to resolve it as a connection request...");
     // Introduced protection because it may potentially happen
     // that another thread could have closed the socket at
     // the same time and inject a bug between checking the
     // pointer for NULL and using it.
-    int listener_ret  = SRT_REJ_UNKNOWN;
-    bool              have_listener = false;
+    int  listener_ret  = SRT_REJ_UNKNOWN;
+    bool have_listener = false;
     {
-        ScopedLock cg(m_LSLock);
-        if (m_pListener)
+        SharedLock shl(m_pListener);
+        CUDT*      pListener = m_pListener.getPtrNoLock();
+
+        if (pListener)
         {
-            LOGC(cnlog.Note,
-                 log << "PASSING request from: " << addr.str() << " to agent:" << m_pListener->socketID());
-            listener_ret = m_pListener->processConnectRequest(addr, unit->m_Packet);
+            LOGC(cnlog.Debug, log << "PASSING request from: " << addr.str() << " to listener:" << pListener->socketID());
+            listener_ret = pListener->processConnectRequest(addr, unit->m_Packet);
 
             // This function does return a code, but it's hard to say as to whether
             // anything can be done about it. In case when it's stated possible, the
@@ -1440,8 +1464,8 @@ EConnectStatus CRcvQueue::worker_ProcessConnectionRequest(CUnit* unit, const soc
 
     if (have_listener) // That is, the above block with m_pListener->processConnectRequest was executed
     {
-        LOGC(cnlog.Note,
-             log << CONID() << "Listener managed the connection request from: " << addr.str()
+        LOGC(cnlog.Debug,
+             log << CONID() << "Listener got the connection request from: " << addr.str()
                  << " result:" << RequestTypeStr(UDTRequestType(listener_ret)));
         return listener_ret == SRT_REJ_UNKNOWN ? CONN_CONTINUE : CONN_REJECT;
     }
@@ -1462,7 +1486,7 @@ EConnectStatus CRcvQueue::worker_ProcessConnectionRequest(CUnit* unit, const soc
     return worker_TryAsyncRend_OrStore(0, unit, addr); // 0 id because the packet came in with that very ID.
 }
 
-bool CRcvQueue::worker_TryAcceptedSocket(CUnit* unit, const sockaddr_any& addr)
+bool srt::CRcvQueue::worker_TryAcceptedSocket(CUnit* unit, const sockaddr_any& addr)
 {
     // We are working with a possibly HS packet... check that.
     CPacket& pkt = unit->m_Packet;
@@ -1509,12 +1533,12 @@ bool CRcvQueue::worker_TryAcceptedSocket(CUnit* unit, const sockaddr_any& addr)
         return false;
     }
 
-    return u->createSendHSResponse(kmdata, kmdatasize, (hs));
+    return u->createSendHSResponse(kmdata, kmdatasize, pkt.udpDestAddr(), (hs));
 }
 
-EConnectStatus CRcvQueue::worker_ProcessAddressedPacket(int32_t id, CUnit* unit, const sockaddr_any& addr)
+srt::EConnectStatus srt::CRcvQueue::worker_ProcessAddressedPacket(int32_t id, CUnit* unit, const sockaddr_any& addr)
 {
-    CUDT *u = m_pHash->lookup(id);
+    CUDT* u = m_pHash->lookup(id);
     if (!u)
     {
         // Pass this to either async rendezvous connection,
@@ -1522,14 +1546,20 @@ EConnectStatus CRcvQueue::worker_ProcessAddressedPacket(int32_t id, CUnit* unit,
         HLOGC(cnlog.Debug, log << "worker_ProcessAddressedPacket: resending to QUEUED socket @" << id);
         return worker_TryAsyncRend_OrStore(id, unit, addr);
     }
+    // Although we don´t have an exclusive passing here,
+    // we can count on that when the socket was once present in the hash,
+    // it will not be deleted for at least one GC cycle. But we still need
+    // to maintain the object existence until it's in use.
+    // Note that here we are out of any locks, so m_GlobControlLock can be locked.
+    CUDTUnited::SocketKeeper sk (CUDT::uglobal(), u->m_parent);
 
     // Found associated CUDT - process this as control or data packet
     // addressed to an associated socket.
     if (addr != u->m_PeerAddr)
     {
         HLOGC(cnlog.Debug,
-              log << CONID() << "Packet for SID=" << id << " asoc with " << u->m_PeerAddr.str()
-                  << " received from " << addr.str() << " (CONSIDERED ATTACK ATTEMPT)");
+              log << CONID() << "Packet for SID=" << id << " asoc with " << u->m_PeerAddr.str() << " received from "
+                  << addr.str() << " (CONSIDERED ATTACK ATTEMPT)");
         // This came not from the address that is the peer associated
         // with the socket. Ignore it.
         return CONN_AGAIN;
@@ -1564,13 +1594,13 @@ EConnectStatus CRcvQueue::worker_ProcessAddressedPacket(int32_t id, CUnit* unit,
 // This function then tries to manage the packet as a rendezvous connection
 // request in ASYNC mode; when this is not applicable, it stores the packet
 // in the "receiving queue" so that it will be picked up in the "main" thread.
-EConnectStatus CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, const sockaddr_any& addr)
+srt::EConnectStatus srt::CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, const sockaddr_any& addr)
 {
     // This 'retrieve' requires that 'id' be either one of those
     // stored in the rendezvous queue (see CRcvQueue::registerConnector)
     // or simply 0, but then at least the address must match one of these.
     // If the id was 0, it will be set to the actual socket ID of the returned CUDT.
-    CUDT *u = m_pRendezvousQueue->retrieve(addr, (id));
+    CUDT* u = m_pRendezvousQueue->retrieve(addr, (id));
     if (!u)
     {
         // this socket is then completely unknown to the system.
@@ -1602,7 +1632,7 @@ EConnectStatus CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, c
 
     // asynchronous connect: call connect here
     // otherwise wait for the UDT socket to retrieve this packet
-    if (!u->m_bSynRecving)
+    if (!u->m_config.bSynRecving)
     {
         HLOGC(cnlog.Debug, log << "AsyncOrRND: packet RESOLVED TO @" << id << " -- continuing as ASYNC CONNECT");
         // This is practically same as processConnectResponse, just this applies
@@ -1614,8 +1644,8 @@ EConnectStatus CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, c
         if (cst == CONN_CONFUSED)
         {
             LOGC(cnlog.Warn, log << "AsyncOrRND: PACKET NOT HANDSHAKE - re-requesting handshake from peer");
-            storePkt(id, unit->m_Packet.clone());
-            if (!u->processAsyncConnectRequest(RST_AGAIN, CONN_CONTINUE, unit->m_Packet, u->m_PeerAddr))
+            storePktClone(id, unit->m_Packet);
+            if (!u->processAsyncConnectRequest(RST_AGAIN, CONN_CONTINUE, &unit->m_Packet, u->m_PeerAddr))
             {
                 // Reuse previous behavior to reject a packet
                 cst = CONN_REJECT;
@@ -1641,7 +1671,7 @@ EConnectStatus CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, c
             // that we KNOW (by the cst == CONN_ACCEPT result) that the socket should be inserted
             // into the pending anteroom.
 
-            CUDT *ne = getNewEntry(); // This function actuall removes the entry and returns it.
+            CUDT* ne = getNewEntry(); // This function actuall removes the entry and returns it.
             // This **should** now always return a non-null value, but check it first
             // because if this accidentally isn't true, the call to worker_ProcessAddressedPacket will
             // result in redirecting it to here and so on until the call stack overflow. In case of
@@ -1689,12 +1719,12 @@ EConnectStatus CRcvQueue::worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, c
           log << "AsyncOrRND: packet RESOLVED TO ID=" << id << " -- continuing through CENTRAL PACKET QUEUE");
     // This is where also the packets for rendezvous connection will be landing,
     // in case of a synchronous connection.
-    storePkt(id, unit->m_Packet.clone());
+    storePktClone(id, unit->m_Packet);
 
     return CONN_CONTINUE;
 }
 
-void CRcvQueue::stopWorker()
+void srt::CRcvQueue::stopWorker()
 {
     // We use the decent way, so we say to the thread "please exit".
     m_bClosing = true;
@@ -1711,12 +1741,11 @@ void CRcvQueue::stopWorker()
     m_WorkerThread.join();
 }
 
-int CRcvQueue::recvfrom(int32_t id, CPacket& w_packet)
+int srt::CRcvQueue::recvfrom(int32_t id, CPacket& w_packet)
 {
-    UniqueLock bufferlock (m_BufferLock);
-    CSync buffercond    (m_BufferCond, bufferlock);
+    CUniqueSync buffercond(m_BufferLock, m_BufferCond);
 
-    map<int32_t, std::queue<CPacket *> >::iterator i = m_mBuffer.find(id);
+    map<int32_t, std::queue<CPacket*> >::iterator i = m_mBuffer.find(id);
 
     if (i == m_mBuffer.end())
     {
@@ -1733,7 +1762,7 @@ int CRcvQueue::recvfrom(int32_t id, CPacket& w_packet)
     }
 
     // retrieve the earliest packet
-    CPacket *newpkt = i->second.front();
+    CPacket* newpkt = i->second.front();
 
     if (w_packet.getLength() < newpkt->getLength())
     {
@@ -1752,8 +1781,8 @@ int CRcvQueue::recvfrom(int32_t id, CPacket& w_packet)
     memcpy((w_packet.m_nHeader), newpkt->m_nHeader, CPacket::HDR_SIZE);
     memcpy((w_packet.m_pcData), newpkt->m_pcData, newpkt->getLength());
     w_packet.setLength(newpkt->getLength());
+    w_packet.m_DestAddr = newpkt->m_DestAddr;
 
-    delete[] newpkt->m_pcData;
     delete newpkt;
 
     // remove this message from queue,
@@ -1765,47 +1794,43 @@ int CRcvQueue::recvfrom(int32_t id, CPacket& w_packet)
     return (int)w_packet.getLength();
 }
 
-int CRcvQueue::setListener(CUDT *u)
+int srt::CRcvQueue::setListener(CUDT* u)
 {
-    ScopedLock lslock(m_LSLock);
-
-    if (NULL != m_pListener)
+    if (!m_pListener.set(u))
         return -1;
 
-    m_pListener = u;
     return 0;
 }
 
-void CRcvQueue::removeListener(const CUDT *u)
+void srt::CRcvQueue::removeListener(const CUDT* u)
 {
-    ScopedLock lslock(m_LSLock);
-
-    if (u == m_pListener)
-        m_pListener = NULL;
+    m_pListener.clearIf(u);
 }
 
-void CRcvQueue::registerConnector(const SRTSOCKET& id, CUDT* u, const sockaddr_any& addr, const steady_clock::time_point& ttl)
+void srt::CRcvQueue::registerConnector(const SRTSOCKET&                id,
+                                  CUDT*                           u,
+                                  const sockaddr_any&             addr,
+                                  const steady_clock::time_point& ttl)
 {
     HLOGC(cnlog.Debug,
           log << "registerConnector: adding @" << id << " addr=" << addr.str() << " TTL=" << FormatTime(ttl));
     m_pRendezvousQueue->insert(id, u, addr, ttl);
 }
 
-void CRcvQueue::removeConnector(const SRTSOCKET &id)
+void srt::CRcvQueue::removeConnector(const SRTSOCKET& id)
 {
     HLOGC(cnlog.Debug, log << "removeConnector: removing @" << id);
     m_pRendezvousQueue->remove(id);
 
     ScopedLock bufferlock(m_BufferLock);
 
-    map<int32_t, std::queue<CPacket *> >::iterator i = m_mBuffer.find(id);
+    map<int32_t, std::queue<CPacket*> >::iterator i = m_mBuffer.find(id);
     if (i != m_mBuffer.end())
     {
         HLOGC(cnlog.Debug,
               log << "removeConnector: ... and its packet queue with " << i->second.size() << " packets collected");
         while (!i->second.empty())
         {
-            delete[] i->second.front()->m_pcData;
             delete i->second.front();
             i->second.pop();
         }
@@ -1813,54 +1838,56 @@ void CRcvQueue::removeConnector(const SRTSOCKET &id)
     }
 }
 
-void CRcvQueue::setNewEntry(CUDT *u)
+void srt::CRcvQueue::setNewEntry(CUDT* u)
 {
     HLOGC(cnlog.Debug, log << CUDTUnited::CONID(u->m_SocketID) << "setting socket PENDING FOR CONNECTION");
     ScopedLock listguard(m_IDLock);
     m_vNewEntry.push_back(u);
 }
 
-bool CRcvQueue::ifNewEntry() { return !(m_vNewEntry.empty()); }
+bool srt::CRcvQueue::ifNewEntry()
+{
+    ScopedLock listguard(m_IDLock);
+    return !(m_vNewEntry.empty());
+}
 
-CUDT *CRcvQueue::getNewEntry()
+srt::CUDT* srt::CRcvQueue::getNewEntry()
 {
     ScopedLock listguard(m_IDLock);
 
     if (m_vNewEntry.empty())
         return NULL;
 
-    CUDT *u = (CUDT *)*(m_vNewEntry.begin());
+    CUDT* u = (CUDT*)*(m_vNewEntry.begin());
     m_vNewEntry.erase(m_vNewEntry.begin());
 
     return u;
 }
 
-void CRcvQueue::storePkt(int32_t id, CPacket *pkt)
+void srt::CRcvQueue::storePktClone(int32_t id, const CPacket& pkt)
 {
-    UniqueLock bufferlock (m_BufferLock);
-    CSync passcond    (m_BufferCond, bufferlock);
+    CUniqueSync passcond(m_BufferLock, m_BufferCond);
 
-    map<int32_t, std::queue<CPacket *> >::iterator i = m_mBuffer.find(id);
+    map<int32_t, std::queue<CPacket*> >::iterator i = m_mBuffer.find(id);
 
     if (i == m_mBuffer.end())
     {
-        m_mBuffer[id].push(pkt);
-        passcond.signal_locked(bufferlock);
+        m_mBuffer[id].push(pkt.clone());
+        passcond.notify_one();
     }
     else
     {
-        // avoid storing too many packets, in case of malfunction or attack
+        // Avoid storing too many packets, in case of malfunction or attack.
         if (i->second.size() > 16)
             return;
 
-        i->second.push(pkt);
+        i->second.push(pkt.clone());
     }
 }
 
-
-void CMultiplexer::destroy()
+void srt::CMultiplexer::destroy()
 {
-    // Reverse order of the assigned 
+    // Reverse order of the assigned.
     delete m_pRcvQueue;
     delete m_pSndQueue;
     delete m_pTimer;
diff --git a/srtcore/queue.h b/srtcore/queue.h
index 0e4409f8a..c5b58a60a 100644
--- a/srtcore/queue.h
+++ b/srtcore/queue.h
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -50,13 +50,12 @@ modified by
    Haivision Systems Inc.
 *****************************************************************************/
 
-
 #ifndef INC_SRT_QUEUE_H
 #define INC_SRT_QUEUE_H
 
-#include "channel.h"
 #include "common.h"
 #include "packet.h"
+#include "socketconfig.h"
 #include "netinet_any.h"
 #include "utilities.h"
 #include <list>
@@ -64,233 +63,223 @@ modified by
 #include <queue>
 #include <vector>
 
+namespace srt
+{
+class CChannel;
 class CUDT;
 
 struct CUnit
 {
-   CPacket m_Packet;		// packet
-   enum Flag { FREE = 0, GOOD = 1, PASSACK = 2, DROPPED = 3 };
-   Flag m_iFlag;			// 0: free, 1: occupied, 2: msg read but not freed (out-of-order), 3: msg dropped
+    CPacket m_Packet; // packet
+    sync::atomic<bool> m_bTaken; // true if the unit is is use (can be stored in the RCV buffer).
 };
 
 class CUnitQueue
 {
-
 public:
-
-   CUnitQueue();
-   ~CUnitQueue();
-
-public:     // Storage size operations
-
-      /// Initialize the unit queue.
-      /// @param [in] size queue size
-      /// @param [in] mss maximum segment size
-      /// @param [in] version IP version
-      /// @return 0: success, -1: failure.
-
-   int init(int size, int mss, int version);
-
-      /// Increase (double) the unit queue size.
-      /// @return 0: success, -1: failure.
-
-   int increase();
-
-      /// Decrease (halve) the unit queue size.
-      /// @return 0: success, -1: failure.
-
-   int shrink();
+    /// @brief Construct a unit queue.
+    /// @param mss Initial number of units to allocate.
+    /// @param mss Maximum segment size meaning the size of each unit.
+    /// @throws CUDTException SRT_ENOBUF.
+    CUnitQueue(int initNumUnits, int mss);
+    ~CUnitQueue();
 
 public:
-   int size() const     { return m_iSize - m_iCount; }
-   int capacity() const { return m_iSize; }
-
-public:     // Operations on units
-
-      /// find an available unit for incoming packet.
-      /// @return Pointer to the available unit, NULL if not found.
-
-   CUnit* getNextAvailUnit();
+    int capacity() const { return m_iSize; }
+    int size() const { return m_iSize - m_iNumTaken; }
 
-   void makeUnitFree(CUnit * unit);
+public:
+    /// @brief Find an available unit for incoming packet. Allocate new units if 90% or more are in use.
+    /// @note This function is not thread-safe. Currently only CRcvQueue::worker thread calls it, thus
+    /// it is not an issue. However, must be protected if used from several threads in the future.
+    /// @return Pointer to the available unit, NULL if not found.
+    CUnit* getNextAvailUnit();
 
-   void makeUnitGood(CUnit * unit);
+    void makeUnitFree(CUnit* unit);
 
-public:
-   inline int getIPversion() const { return m_iIPversion; }
+    void makeUnitTaken(CUnit* unit);
 
 private:
-   struct CQEntry
-   {
-      CUnit* m_pUnit;   // unit queue
-      char* m_pBuffer;  // data buffer
-      int m_iSize;      // size of each queue
+    struct CQEntry
+    {
+        CUnit* m_pUnit;   // unit queue
+        char*  m_pBuffer; // data buffer
+        int    m_iSize;   // size of each queue
 
-      CQEntry* m_pNext;
-   }
-   *m_pQEntry,          // pointer to the first unit queue
-   *m_pCurrQueue,       // pointer to the current available queue
-   *m_pLastQueue;       // pointer to the last unit queue
+        CQEntry* m_pNext;
+    };
 
-   CUnit* m_pAvailUnit; // recent available unit
+    /// Increase the unit queue size (by @a m_iBlockSize units).
+    /// Uses m_mtx to protect access and changes of the queue state.
+    /// @return 0: success, -1: failure.
+    int increase_();
 
-   int m_iSize;         // total size of the unit queue, in number of packets
-   int m_iCount;        // total number of valid (occupied) packets in the queue
+    /// @brief Allocated a CQEntry of iNumUnits with each unit of mss bytes.
+    /// @param iNumUnits a number of units to allocate
+    /// @param mss the size of each unit in bytes.
+    /// @return a pointer to a newly allocated entry on success, NULL otherwise.
+    static CQEntry* allocateEntry(const int iNumUnits, const int mss);
 
-   int m_iMSS;          // unit buffer size
-   int m_iIPversion;    // IP version
+private:
+    CQEntry* m_pQEntry;    // pointer to the first unit queue
+    CQEntry* m_pCurrQueue; // pointer to the current available queue
+    CQEntry* m_pLastQueue; // pointer to the last unit queue
+    CUnit* m_pAvailUnit; // recent available unit
+    int m_iSize;  // total size of the unit queue, in number of packets
+    sync::atomic<int> m_iNumTaken; // total number of valid (occupied) packets in the queue
+    const int m_iMSS; // unit buffer size
+    const int m_iBlockSize; // Number of units in each CQEntry.
 
 private:
-   CUnitQueue(const CUnitQueue&);
-   CUnitQueue& operator=(const CUnitQueue&);
+    CUnitQueue(const CUnitQueue&);
+    CUnitQueue& operator=(const CUnitQueue&);
 };
 
 struct CSNode
 {
-   CUDT* m_pUDT;		// Pointer to the instance of CUDT socket
-   srt::sync::steady_clock::time_point m_tsTimeStamp;
+    CUDT*                          m_pUDT; // Pointer to the instance of CUDT socket
+    sync::steady_clock::time_point m_tsTimeStamp;
 
-   int m_iHeapLoc;		// location on the heap, -1 means not on the heap
+    sync::atomic<int> m_iHeapLoc; // location on the heap, -1 means not on the heap
 };
 
 class CSndUList
 {
-friend class CSndQueue;
-
 public:
-   CSndUList();
-   ~CSndUList();
+    CSndUList(sync::CTimer* pTimer);
+    ~CSndUList();
 
 public:
+    enum EReschedule
+    {
+        DONT_RESCHEDULE = 0,
+        DO_RESCHEDULE   = 1
+    };
 
-   enum EReschedule { DONT_RESCHEDULE = 0, DO_RESCHEDULE = 1 };
-
-   static EReschedule rescheduleIf(bool cond) { return cond ? DO_RESCHEDULE : DONT_RESCHEDULE; }
-
-      /// Update the timestamp of the UDT instance on the list.
-      /// @param [in] u pointer to the UDT instance
-      /// @param [in] reschedule if the timestamp should be rescheduled
-
-   void update(const CUDT* u, EReschedule reschedule);
+    static EReschedule rescheduleIf(bool cond) { return cond ? DO_RESCHEDULE : DONT_RESCHEDULE; }
 
-      /// Retrieve the next packet and peer address from the first entry, and reschedule it in the queue.
-      /// @param [out] addr destination address of the next packet
-      /// @param [out] pkt the next packet to be sent
-      /// @return 1 if successfully retrieved, -1 if no packet found.
+    /// Update the timestamp of the UDT instance on the list.
+    /// @param [in] u pointer to the UDT instance
+    /// @param [in] reschedule if the timestamp should be rescheduled
+    /// @param [in] ts the next time to trigger sending logic on the CUDT
+    void update(const CUDT* u, EReschedule reschedule, sync::steady_clock::time_point ts = sync::steady_clock::now());
 
-   int pop(sockaddr_any& addr, CPacket& pkt);
+    /// Retrieve the next (in time) socket from the heap to process its sending request.
+    /// @return a pointer to CUDT instance to process next.
+    CUDT* pop();
 
-      /// Remove UDT instance from the list.
-      /// @param [in] u pointer to the UDT instance
+    /// Remove UDT instance from the list.
+    /// @param [in] u pointer to the UDT instance
+    void remove(const CUDT* u);// EXCLUDES(m_ListLock);
 
-   void remove(const CUDT* u);
+    /// Retrieve the next scheduled processing time.
+    /// @return Scheduled processing time of the first UDT socket in the list.
+    sync::steady_clock::time_point getNextProcTime();
 
-      /// Retrieve the next scheduled processing time.
-      /// @return Scheduled processing time of the first UDT socket in the list.
+    /// Wait for the list to become non empty.
+    void waitNonEmpty() const;
 
-   srt::sync::steady_clock::time_point getNextProcTime();
+    /// Signal to stop waiting in waitNonEmpty().
+    void signalInterrupt() const;
 
 private:
-
-   /// Doubles the size of the list.
-   ///
-   void realloc_();
-
-   /// Insert a new UDT instance into the list with realloc if required.
-   ///
-   /// @param [in] ts time stamp: next processing time
-   /// @param [in] u pointer to the UDT instance
-   void insert_(const srt::sync::steady_clock::time_point &ts, const CUDT* u);
-
-   /// Insert a new UDT instance into the list without realloc.
-   /// Should be called if there is a gauranteed space for the element.
-   ///
-   /// @param [in] ts time stamp: next processing time
-   /// @param [in] u pointer to the UDT instance
-   void insert_norealloc_(const srt::sync::steady_clock::time_point &ts, const CUDT* u);
-
-   void remove_(const CUDT* u);
+    /// Doubles the size of the list.
+    ///
+    void realloc_();// REQUIRES(m_ListLock);
+
+    /// Insert a new UDT instance into the list with realloc if required.
+    ///
+    /// @param [in] ts time stamp: next processing time
+    /// @param [in] u pointer to the UDT instance
+    void insert_(const sync::steady_clock::time_point& ts, const CUDT* u);
+
+    /// Insert a new UDT instance into the list without realloc.
+    /// Should be called if there is a guaranteed space for the element.
+    ///
+    /// @param [in] ts time stamp: next processing time
+    /// @param [in] u pointer to the UDT instance
+    void insert_norealloc_(const sync::steady_clock::time_point& ts, const CUDT* u);// REQUIRES(m_ListLock);
+
+    /// Removes CUDT entry from the list.
+    /// If the last entry is removed, calls sync::CTimer::interrupt().
+    void remove_(const CUDT* u);
 
 private:
-   CSNode** m_pHeap;			// The heap array
-   int m_iArrayLength;			// physical length of the array
-   int m_iLastEntry;			// position of last entry on the heap array
-
-   srt::sync::Mutex m_ListLock;
+    CSNode** m_pHeap;        // The heap array
+    int      m_iArrayLength; // physical length of the array
+    int      m_iLastEntry;   // position of last entry on the heap array or -1 if empty.
 
-   srt::sync::Mutex* m_pWindowLock;
-   srt::sync::Condition* m_pWindowCond;
+    mutable sync::Mutex     m_ListLock; // Protects the list (m_pHeap, m_iArrayLength, m_iLastEntry).
+    mutable sync::Condition m_ListCond;
 
-   srt::sync::CTimer* m_pTimer;
+    sync::CTimer* const m_pTimer;
 
 private:
-   CSndUList(const CSndUList&);
-   CSndUList& operator=(const CSndUList&);
+    CSndUList(const CSndUList&);
+    CSndUList& operator=(const CSndUList&);
 };
 
 struct CRNode
 {
-   CUDT* m_pUDT;                // Pointer to the instance of CUDT socket
-   srt::sync::steady_clock::time_point m_tsTimeStamp;      // Time Stamp
+    CUDT*                          m_pUDT;        // Pointer to the instance of CUDT socket
+    sync::steady_clock::time_point m_tsTimeStamp; // Time Stamp
 
-   CRNode* m_pPrev;             // previous link
-   CRNode* m_pNext;             // next link
+    CRNode* m_pPrev; // previous link
+    CRNode* m_pNext; // next link
 
-   bool m_bOnList;              // if the node is already on the list
+    sync::atomic<bool> m_bOnList; // if the node is already on the list
 };
 
 class CRcvUList
 {
 public:
-   CRcvUList();
-   ~CRcvUList();
+    CRcvUList();
+    ~CRcvUList();
 
 public:
+    /// Insert a new UDT instance to the list.
+    /// @param [in] u pointer to the UDT instance
 
-      /// Insert a new UDT instance to the list.
-      /// @param [in] u pointer to the UDT instance
+    void insert(const CUDT* u);
 
-   void insert(const CUDT* u);
+    /// Remove the UDT instance from the list.
+    /// @param [in] u pointer to the UDT instance
 
-      /// Remove the UDT instance from the list.
-      /// @param [in] u pointer to the UDT instance
+    void remove(const CUDT* u);
 
-   void remove(const CUDT* u);
+    /// Move the UDT instance to the end of the list, if it already exists; otherwise, do nothing.
+    /// @param [in] u pointer to the UDT instance
 
-      /// Move the UDT instance to the end of the list, if it already exists; otherwise, do nothing.
-      /// @param [in] u pointer to the UDT instance
-
-   void update(const CUDT* u);
+    void update(const CUDT* u);
 
 public:
-   CRNode* m_pUList;		// the head node
+    CRNode* m_pUList; // the head node
 
 private:
-   CRNode* m_pLast;		// the last node
+    CRNode* m_pLast; // the last node
 
 private:
-   CRcvUList(const CRcvUList&);
-   CRcvUList& operator=(const CRcvUList&);
+    CRcvUList(const CRcvUList&);
+    CRcvUList& operator=(const CRcvUList&);
 };
 
 class CHash
 {
 public:
-   CHash();
-   ~CHash();
+    CHash();
+    ~CHash();
 
 public:
+    /// Initialize the hash table.
+    /// @param [in] size hash table size
 
-      /// Initialize the hash table.
-      /// @param [in] size hash table size
-
-   void init(int size);
+    void init(int size);
 
-      /// Look for a UDT instance from the hash table.
-      /// @param [in] id socket ID
-      /// @return Pointer to a UDT instance, or NULL if not found.
+    /// Look for a UDT instance from the hash table.
+    /// @param [in] id socket ID
+    /// @return Pointer to a UDT instance, or NULL if not found.
 
-   CUDT* lookup(int32_t id);
+    CUDT* lookup(int32_t id);
 
      /// Look for a UDT instance from the hash table by source ID
      /// @param [in] peerid socket ID of the peer reported as source ID
@@ -298,280 +287,330 @@ class CHash
 
    CUDT* lookupPeer(int32_t peerid);
 
-      /// Insert an entry to the hash table.
-      /// @param [in] id socket ID
-      /// @param [in] u pointer to the UDT instance
+    /// Insert an entry to the hash table.
+    /// @param [in] id socket ID
+    /// @param [in] u pointer to the UDT instance
 
-   void insert(int32_t id, CUDT* u);
+    void insert(int32_t id, CUDT* u);
 
-      /// Remove an entry from the hash table.
-      /// @param [in] id socket ID
+    /// Remove an entry from the hash table.
+    /// @param [in] id socket ID
 
-   void remove(int32_t id);
+    void remove(int32_t id);
 
 private:
-   struct CBucket
-   {
-      int32_t m_iID;		// Socket ID
-      int32_t m_iPeerID;    // Peer ID
-      CUDT* m_pUDT;		// Socket instance
+    struct CBucket
+    {
+        int32_t m_iID;  // Socket ID
+        int32_t m_iPeerID;    // Peer ID
+        CUDT*   m_pUDT; // Socket instance
 
-      CBucket* m_pNext;		// next bucket
-   } **m_pBucket;		// list of buckets (the hash table)
+        CBucket* m_pNext; // next bucket
+    } * *m_pBucket;       // list of buckets (the hash table)
 
-   int m_iHashSize;		// size of hash table
+    int m_iHashSize; // size of hash table
 
    std::map<int32_t, int32_t> m_RevPeerMap;
 
 private:
-   CHash(const CHash&);
-   CHash& operator=(const CHash&);
+    CHash(const CHash&);
+    CHash& operator=(const CHash&);
 };
 
+/// @brief A queue of sockets pending for connection.
+/// It can be either a caller socket in a non-blocking mode
+/// (the connection has to be handled in background),
+/// or a socket in rendezvous connection mode.
 class CRendezvousQueue
 {
 public:
-   CRendezvousQueue();
-   ~CRendezvousQueue();
+    CRendezvousQueue();
+    ~CRendezvousQueue();
 
 public:
-   void insert(const SRTSOCKET& id, CUDT* u, const sockaddr_any& addr,
-               const srt::sync::steady_clock::time_point &ttl);
-
-   void remove(const SRTSOCKET& id);
-   CUDT* retrieve(const sockaddr_any& addr, SRTSOCKET& id);
+    /// @brief Insert a new socket pending for connection (non-blocking caller or rendezvous).
+    /// @param id socket ID.
+    /// @param u pointer to a corresponding CUDT instance.
+    /// @param addr remote address to connect to.
+    /// @param ttl timepoint for connection attempt to expire.
+    void insert(const SRTSOCKET& id, CUDT* u, const sockaddr_any& addr, const srt::sync::steady_clock::time_point& ttl);
+
+    /// @brief Remove a socket from the connection pending list.
+    /// @param id socket ID.
+    void remove(const SRTSOCKET& id);
+
+    /// @brief Locate a socket in the connection pending queue.
+    /// @param addr source address of the packet received over UDP (peer address).
+    /// @param id socket ID.
+    /// @return a pointer to CUDT instance retrieved, or NULL if nothing was found.
+    CUDT* retrieve(const sockaddr_any& addr, SRTSOCKET& id) const;
+
+    /// @brief Update status of connections in the pending queue.
+    /// Stop connecting if TTL expires. Resend handshake request every 250 ms if no response from the peer.
+    /// @param rst result of reading from a UDP socket: received packet / nothin read / read error.
+    /// @param cst target status for pending connection: reject or proceed.
+    /// @param pktIn packet received from the UDP socket.
+    void updateConnStatus(EReadStatus rst, EConnectStatus cst, CUnit* unit);
 
-   void updateConnStatus(EReadStatus rst, EConnectStatus, const CPacket& response);
+private:
+    struct LinkStatusInfo
+    {
+        CUDT*        u;
+        SRTSOCKET    id;
+        int          errorcode;
+        sockaddr_any peeraddr;
+        int          token;
+
+        struct HasID
+        {
+            SRTSOCKET id;
+            HasID(SRTSOCKET p)
+                : id(p)
+            {
+            }
+            bool operator()(const LinkStatusInfo& i) { return i.id == id; }
+        };
+    };
+
+    /// @brief Qualify pending connections:
+    /// - Sockets with expired TTL go to the 'to_remove' list and removed from the queue straight away.
+    /// - If HS request is to be resent (resend 250 ms if no response from the peer) go to the 'to_process' list.
+    ///
+    /// @param rst result of reading from a UDP socket: received packet / nothin read / read error.
+    /// @param cst target status for pending connection: reject or proceed.
+    /// @param iDstSockID destination socket ID of the received packet.
+    /// @param[in,out] toRemove stores sockets with expired TTL.
+    /// @param[in,out] toProcess stores sockets which should repeat (resend) HS connection request.
+    bool qualifyToHandle(EReadStatus                  rst,
+                         EConnectStatus               cst,
+                         int                          iDstSockID,
+                         std::vector<LinkStatusInfo>& toRemove,
+                         std::vector<LinkStatusInfo>& toProcess);
 
 private:
-   struct CRL
-   {
-      SRTSOCKET m_iID;        // UDT socket ID (self)
-      CUDT* m_pUDT;           // UDT instance
-      sockaddr_any m_PeerAddr;// UDT sonnection peer address
-      srt::sync::steady_clock::time_point m_tsTTL;    // the time that this request expires
-   };
-   std::list<CRL> m_lRendezvousID;    // The sockets currently in rendezvous mode
-
-   srt::sync::Mutex m_RIDVectorLock;
+    struct CRL
+    {
+        SRTSOCKET                      m_iID;      // SRT socket ID (self)
+        CUDT*                          m_pUDT;     // CUDT instance
+        sockaddr_any                   m_PeerAddr; // SRT sonnection peer address
+        sync::steady_clock::time_point m_tsTTL;    // the time that this request expires
+    };
+    std::list<CRL> m_lRendezvousID; // The sockets currently in rendezvous mode
+
+    mutable sync::Mutex m_RIDListLock;
 };
 
 class CSndQueue
 {
-friend class CUDT;
-friend class CUDTUnited;
+    friend class CUDT;
+    friend class CUDTUnited;
 
 public:
-   CSndQueue();
-   ~CSndQueue();
+    CSndQueue();
+    ~CSndQueue();
 
 public:
-
-   // XXX There's currently no way to access the socket ID set for
-   // whatever the queue is currently working for. Required to find
-   // some way to do this, possibly by having a "reverse pointer".
-   // Currently just "unimplemented".
-   std::string CONID() const { return ""; }
-
-      /// Initialize the sending queue.
-      /// @param [in] c UDP channel to be associated to the queue
-      /// @param [in] t Timer
-
-   void init(CChannel* c, srt::sync::CTimer* t);
-
-      /// Send out a packet to a given address.
-      /// @param [in] addr destination address
-      /// @param [in] packet packet to be sent out
-      /// @return Size of data sent out.
-
-   int sendto(const sockaddr_any& addr, CPacket& packet);
-
-      /// Get the IP TTL.
-      /// @param [in] ttl IP Time To Live.
-      /// @return TTL.
-
-   int getIpTTL() const;
-
-      /// Get the IP Type of Service.
-      /// @return ToS.
-
-   int getIpToS() const;
+    // XXX There's currently no way to access the socket ID set for
+    // whatever the queue is currently working for. Required to find
+    // some way to do this, possibly by having a "reverse pointer".
+    // Currently just "unimplemented".
+    std::string CONID() const { return ""; }
+
+    /// Initialize the sending queue.
+    /// @param [in] c UDP channel to be associated to the queue
+    /// @param [in] t Timer
+    void init(CChannel* c, sync::CTimer* t);
+
+    /// Send out a packet to a given address. The @a src parameter is
+    /// blindly passed by the caller down the call with intention to
+    /// be received eventually by CChannel::sendto, and used only if
+    /// appropriate conditions state so.
+    /// @param [in] addr destination address
+    /// @param [in,ref] packet packet to be sent out
+    /// @param [in] src The source IP address (details above)
+    /// @return Size of data sent out.
+    int sendto(const sockaddr_any& addr, CPacket& packet, const sockaddr_any& src);
+
+    /// Get the IP TTL.
+    /// @param [in] ttl IP Time To Live.
+    /// @return TTL.
+    int getIpTTL() const;
+
+    /// Get the IP Type of Service.
+    /// @return ToS.
+    int getIpToS() const;
 
 #ifdef SRT_ENABLE_BINDTODEVICE
-   bool getBind(char* dst, size_t len) const;
+    bool getBind(char* dst, size_t len) const;
 #endif
 
-   int ioctlQuery(int type) const { return m_pChannel->ioctlQuery(type); }
-   int sockoptQuery(int level, int type) const { return m_pChannel->sockoptQuery(level, type); }
+    int ioctlQuery(int type) const;
+    int sockoptQuery(int level, int type) const;
 
-   void setClosing()
-   {
-       m_bClosing = true;
-   }
+    void setClosing() { m_bClosing = true; }
 
 private:
-   static void* worker(void* param);
-   srt::sync::CThread m_WorkerThread;
+    static void*  worker(void* param);
+    sync::CThread m_WorkerThread;
 
 private:
-   CSndUList* m_pSndUList;              // List of UDT instances for data sending
-   CChannel* m_pChannel;                // The UDP channel for data sending
-   srt::sync::CTimer* m_pTimer;         // Timing facility
+    CSndUList*    m_pSndUList; // List of UDT instances for data sending
+    CChannel*     m_pChannel;  // The UDP channel for data sending
+    sync::CTimer* m_pTimer;    // Timing facility
 
-   srt::sync::Mutex m_WindowLock;
-   srt::sync::Condition m_WindowCond;
+    sync::atomic<bool> m_bClosing;            // closing the worker
 
-   volatile bool m_bClosing;            // closing the worker
-
-#if defined(SRT_DEBUG_SNDQ_HIGHRATE)//>>debug high freq worker
-   uint64_t m_ullDbgPeriod;
-   uint64_t m_ullDbgTime;
-   struct {
+public:
+#if defined(SRT_DEBUG_SNDQ_HIGHRATE) //>>debug high freq worker
+    sync::steady_clock::duration m_DbgPeriod;
+    mutable sync::steady_clock::time_point m_DbgTime;
+    struct
+    {
         unsigned long lIteration;   //
-        unsigned long lSleepTo;     //SleepTo
-        unsigned long lNotReadyPop; //Continue
+        unsigned long lSleepTo;     // SleepTo
+        unsigned long lNotReadyPop; // Continue
         unsigned long lSendTo;
-        unsigned long lNotReadyTs;  
-        unsigned long lCondWait;    //block on m_WindowCond
-   } m_WorkerStats;
+        unsigned long lNotReadyTs;
+        unsigned long lCondWait; // block on m_WindowCond
+    } mutable m_WorkerStats;
 #endif /* SRT_DEBUG_SNDQ_HIGHRATE */
 
+private:
+
 #if ENABLE_LOGGING
-   static int m_counter;
+    static srt::sync::atomic<int> m_counter;
 #endif
 
-private:
-   CSndQueue(const CSndQueue&);
-   CSndQueue& operator=(const CSndQueue&);
+    CSndQueue(const CSndQueue&);
+    CSndQueue& operator=(const CSndQueue&);
 };
 
 class CRcvQueue
 {
-friend class CUDT;
-friend class CUDTUnited;
+    friend class CUDT;
+    friend class CUDTUnited;
 
 public:
-   CRcvQueue();
-   ~CRcvQueue();
+    CRcvQueue();
+    ~CRcvQueue();
 
 public:
+    // XXX There's currently no way to access the socket ID set for
+    // whatever the queue is currently working. Required to find
+    // some way to do this, possibly by having a "reverse pointer".
+    // Currently just "unimplemented".
+    std::string CONID() const { return ""; }
 
-   // XXX There's currently no way to access the socket ID set for
-   // whatever the queue is currently working. Required to find
-   // some way to do this, possibly by having a "reverse pointer".
-   // Currently just "unimplemented".
-   std::string CONID() const { return ""; }
-
-      /// Initialize the receiving queue.
-      /// @param [in] size queue size
-      /// @param [in] mss maximum packet size
-      /// @param [in] version IP version
-      /// @param [in] hsize hash table size
-      /// @param [in] c UDP channel to be associated to the queue
-      /// @param [in] t timer
-
-   void init(int size, int payload, int version, int hsize, CChannel* c, srt::sync::CTimer* t);
+    /// Initialize the receiving queue.
+    /// @param [in] size queue size
+    /// @param [in] mss maximum packet size
+    /// @param [in] version IP version
+    /// @param [in] hsize hash table size
+    /// @param [in] c UDP channel to be associated to the queue
+    /// @param [in] t timer
+    void init(int size, size_t payload, int version, int hsize, CChannel* c, sync::CTimer* t);
 
-      /// Read a packet for a specific UDT socket id.
-      /// @param [in] id Socket ID
-      /// @param [out] packet received packet
-      /// @return Data size of the packet
+    /// Read a packet for a specific UDT socket id.
+    /// @param [in] id Socket ID
+    /// @param [out] packet received packet
+    /// @return Data size of the packet
+    int recvfrom(int32_t id, CPacket& to_packet);
 
-   int recvfrom(int32_t id, CPacket& to_packet);
+    void stopWorker();
 
-   void stopWorker();
+    void setClosing() { m_bClosing = true; }
 
-   void setClosing()
-   {
-       m_bClosing = true;
-   }
+    int getIPversion() { return m_iIPversion; }
 
 private:
-   static void* worker(void* param);
-   srt::sync::CThread m_WorkerThread;
-   // Subroutines of worker
-   EReadStatus worker_RetrieveUnit(int32_t& id, CUnit*& unit, sockaddr_any& sa);
-   EConnectStatus worker_ProcessConnectionRequest(CUnit* unit, const sockaddr_any& sa);
-   EConnectStatus worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, const sockaddr_any& sa);
-   EConnectStatus worker_ProcessAddressedPacket(int32_t id, CUnit* unit, const sockaddr_any& sa);
-   bool worker_TryAcceptedSocket(CUnit* unit, const sockaddr_any& addr);
+    static void*  worker(void* param);
+    sync::CThread m_WorkerThread;
+    // Subroutines of worker
+    EReadStatus    worker_RetrieveUnit(int32_t& id, CUnit*& unit, sockaddr_any& sa);
+    EConnectStatus worker_ProcessConnectionRequest(CUnit* unit, const sockaddr_any& sa);
+    EConnectStatus worker_TryAsyncRend_OrStore(int32_t id, CUnit* unit, const sockaddr_any& sa);
+    EConnectStatus worker_ProcessAddressedPacket(int32_t id, CUnit* unit, const sockaddr_any& sa);
+    bool worker_TryAcceptedSocket(CUnit* unit, const sockaddr_any& addr);
 
 private:
-   CUnitQueue m_UnitQueue;      // The received packet queue
-   CRcvUList* m_pRcvUList;      // List of UDT instances that will read packets from the queue
-   CHash* m_pHash;              // Hash table for UDT socket looking up
-   CChannel* m_pChannel;        // UDP channel for receving packets
-   srt::sync::CTimer* m_pTimer; // shared timer with the snd queue
+    CUnitQueue*   m_pUnitQueue; // The received packet queue
+    CRcvUList*    m_pRcvUList;  // List of UDT instances that will read packets from the queue
+    CHash*        m_pHash;      // Hash table for UDT socket looking up
+    CChannel*     m_pChannel;   // UDP channel for receiving packets
+    sync::CTimer* m_pTimer;     // shared timer with the snd queue
 
-   int m_iPayloadSize;          // packet payload size
+    int m_iIPversion;           // IP version
+    size_t m_szPayloadSize;     // packet payload size
 
-   volatile bool m_bClosing;    // closing the worker
+    sync::atomic<bool> m_bClosing; // closing the worker
 #if ENABLE_LOGGING
-   static int m_counter;
+    static srt::sync::atomic<int> m_counter; // A static counter to log RcvQueue worker thread number.
 #endif
 
 private:
-   int setListener(CUDT* u);
-   void removeListener(const CUDT* u);
+    int  setListener(CUDT* u);
+    void removeListener(const CUDT* u);
 
-   void registerConnector(const SRTSOCKET& id, CUDT* u, const sockaddr_any& addr, const srt::sync::steady_clock::time_point& ttl);
-   void removeConnector(const SRTSOCKET& id);
+    void registerConnector(const SRTSOCKET&                      id,
+                           CUDT*                                 u,
+                           const sockaddr_any&                   addr,
+                           const sync::steady_clock::time_point& ttl);
+    void removeConnector(const SRTSOCKET& id);
 
-   void setNewEntry(CUDT* u);
-   bool ifNewEntry();
-   CUDT* getNewEntry();
+    void  setNewEntry(CUDT* u);
+    bool  ifNewEntry();
+    CUDT* getNewEntry();
 
-   void storePkt(int32_t id, CPacket* pkt);
+    void storePktClone(int32_t id, const CPacket& pkt);
 
 private:
-   srt::sync::Mutex m_LSLock;
-   CUDT* m_pListener;                                   // pointer to the (unique, if any) listening UDT entity
-   CRendezvousQueue* m_pRendezvousQueue;                // The list of sockets in rendezvous mode
+    sync::CSharedObjectPtr<CUDT> m_pListener;        // pointer to the (unique, if any) listening UDT entity
+    CRendezvousQueue*            m_pRendezvousQueue; // The list of sockets in rendezvous mode
 
-   std::vector<CUDT*> m_vNewEntry;                      // newly added entries, to be inserted
-   srt::sync::Mutex m_IDLock;
+    std::vector<CUDT*> m_vNewEntry; // newly added entries, to be inserted
+    sync::Mutex        m_IDLock;
 
-   std::map<int32_t, std::queue<CPacket*> > m_mBuffer;	// temporary buffer for rendezvous connection request
-   srt::sync::Mutex m_BufferLock;
-   srt::sync::Condition m_BufferCond;
+    std::map<int32_t, std::queue<CPacket*> > m_mBuffer; // temporary buffer for rendezvous connection request
+    sync::Mutex                              m_BufferLock;
+    sync::Condition                          m_BufferCond;
 
 private:
-   CRcvQueue(const CRcvQueue&);
-   CRcvQueue& operator=(const CRcvQueue&);
+    CRcvQueue(const CRcvQueue&);
+    CRcvQueue& operator=(const CRcvQueue&);
 };
 
 struct CMultiplexer
 {
-   CSndQueue* m_pSndQueue;  // The sending queue
-   CRcvQueue* m_pRcvQueue;  // The receiving queue
-   CChannel* m_pChannel;    // The UDP channel for sending and receiving
-   srt::sync::CTimer* m_pTimer;  // The timer
-
-   int m_iPort;         // The UDP port number of this multiplexer
-   int m_iIPversion;    // Address family (AF_INET or AF_INET6)
-   int m_iIpTTL;
-   int m_iIpToS;
-#ifdef SRT_ENABLE_BINDTODEVICE
-   std::string m_BindToDevice;
-#endif
-   int m_iMSS;          // Maximum Segment Size
-   int m_iRefCount;     // number of UDT instances that are associated with this multiplexer
-   int m_iIpV6Only;     // IPV6_V6ONLY option
-   bool m_bReusable;    // if this one can be shared with others
-
-   int m_iID;           // multiplexer ID
-
-   // Constructor should reset all pointers to NULL
-   // to prevent dangling pointer when checking for memory alloc fails
-   CMultiplexer()
-       : m_pSndQueue(NULL)
-       , m_pRcvQueue(NULL)
-       , m_pChannel(NULL)
-       , m_pTimer(NULL)
+    CSndQueue*    m_pSndQueue; // The sending queue
+    CRcvQueue*    m_pRcvQueue; // The receiving queue
+    CChannel*     m_pChannel;  // The UDP channel for sending and receiving
+    sync::CTimer* m_pTimer;    // The timer
+
+    int m_iPort;      // The UDP port number of this multiplexer
+    int m_iIPversion; // Address family (AF_INET or AF_INET6)
+    int m_iRefCount;  // number of UDT instances that are associated with this multiplexer
+
+    CSrtMuxerConfig m_mcfg;
+
+    int m_iID; // multiplexer ID
+
+    // Constructor should reset all pointers to NULL
+    // to prevent dangling pointer when checking for memory alloc fails
+    CMultiplexer()
+        : m_pSndQueue(NULL)
+        , m_pRcvQueue(NULL)
+        , m_pChannel(NULL)
+        , m_pTimer(NULL)
+        , m_iPort(0)
+        , m_iIPversion(0)
+        , m_iRefCount(1)
+        , m_iID(-1)
     {
     }
 
-   void destroy();
+    void destroy();
 };
 
+} // namespace srt
+
 #endif
diff --git a/srtcore/socketconfig.cpp b/srtcore/socketconfig.cpp
new file mode 100644
index 000000000..1c067d059
--- /dev/null
+++ b/srtcore/socketconfig.cpp
@@ -0,0 +1,1106 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+*****************************************************************************/
+#include <utility>
+
+#include "srt.h"
+#include "socketconfig.h"
+
+namespace srt
+{
+int RcvBufferSizeOptionToValue(int val, int flightflag, int mss)
+{
+    // Mimimum recv buffer size is 32 packets
+    const int mssin_size = mss - CPacket::UDP_HDR_SIZE;
+
+    int bufsize;
+    if (val > mssin_size * CSrtConfig::DEF_MIN_FLIGHT_PKT)
+        bufsize = val / mssin_size;
+    else
+        bufsize = CSrtConfig::DEF_MIN_FLIGHT_PKT;
+
+    // recv buffer MUST not be greater than FC size
+    if (bufsize > flightflag)
+        bufsize = flightflag;
+
+    return bufsize;
+}
+}
+
+using namespace srt;
+extern const int32_t SRT_DEF_VERSION = SrtParseVersion(SRT_VERSION);
+
+namespace {
+typedef void setter_function(CSrtConfig& co, const void* optval, int optlen);
+
+template<SRT_SOCKOPT name>
+struct CSrtConfigSetter
+{
+    static setter_function set;
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_MSS>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int ival = cast_optval<int>(optval, optlen);
+        if (ival < int(CPacket::UDP_HDR_SIZE + CHandShake::m_iContentSize))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iMSS = ival;
+
+        // Packet size cannot be greater than UDP buffer size
+        if (co.iMSS > co.iUDPSndBufSize)
+            co.iMSS = co.iUDPSndBufSize;
+        if (co.iMSS > co.iUDPRcvBufSize)
+            co.iMSS = co.iUDPRcvBufSize;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_FC>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+        const int fc = cast_optval<int>(optval, optlen);
+        if (fc < co.DEF_MIN_FLIGHT_PKT)
+        {
+            LOGC(kmlog.Error, log << "SRTO_FC: minimum allowed value is 32 (provided: " << fc << ")");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL);
+        }
+
+        co.iFlightFlagSize = fc;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_SNDBUF>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        int bs = cast_optval<int>(optval, optlen);
+        if (bs <= 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iSndBufSize = bs / (co.iMSS - CPacket::UDP_HDR_SIZE);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_RCVBUF>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val <= 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iRcvBufSize = srt::RcvBufferSizeOptionToValue(val, co.iFlightFlagSize, co.iMSS);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_LINGER>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.Linger = cast_optval<linger>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_UDP_SNDBUF>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iUDPSndBufSize = std::max(co.iMSS, cast_optval<int>(optval, optlen));
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_UDP_RCVBUF>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iUDPRcvBufSize = std::max(co.iMSS, cast_optval<int>(optval, optlen));
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_RENDEZVOUS>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bRendezvous = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_SNDTIMEO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < -1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iSndTimeOut = val;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_RCVTIMEO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < -1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iRcvTimeOut = val;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_SNDSYN>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bSynSending = cast_optval<bool>(optval, optlen);
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_RCVSYN>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bSynRecving = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_REUSEADDR>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bReuseAddr = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_MAXBW>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int64_t val = cast_optval<int64_t>(optval, optlen);
+        if (val < -1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.llMaxBW = val;
+    }
+};
+
+#ifdef ENABLE_MAXREXMITBW
+template<>
+struct CSrtConfigSetter<SRTO_MAXREXMITBW>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int64_t val = cast_optval<int64_t>(optval, optlen);
+        if (val < -1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.llMaxRexmitBW = val;
+    }
+};
+#endif
+
+template<>
+struct CSrtConfigSetter<SRTO_IPTTL>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        int val = cast_optval<int>(optval, optlen);
+        if (!(val == -1) && !((val >= 1) && (val <= 255)))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        co.iIpTTL = cast_optval<int>(optval);
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_IPTOS>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iIpToS = cast_optval<int>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_BINDTODEVICE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+#ifdef SRT_ENABLE_BINDTODEVICE
+        using namespace std;
+
+        string val;
+
+        val.assign((const char *)optval, optlen);
+        if (val.size() >= IFNAMSIZ)
+        {
+            LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE: device name too long (max: IFNAMSIZ=" << IFNAMSIZ << ")");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        co.sBindToDevice = val;
+#else
+        (void)co; // prevent warning
+        (void)optval;
+        (void)optlen;
+        LOGC(kmlog.Error, log << "SRTO_BINDTODEVICE is not supported on that platform");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+#endif
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_INPUTBW>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int64_t val = cast_optval<int64_t>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        co.llInputBW = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_MININPUTBW>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int64_t val = cast_optval<int64_t>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        co.llMinInputBW = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_OHEADBW>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int32_t val = cast_optval<int32_t>(optval, optlen);
+        if (val < 5 || val > 100)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        co.iOverheadBW = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_SENDER>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bDataSender = cast_optval<bool>(optval, optlen);
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_TSBPDMODE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const bool val = cast_optval<bool>(optval, optlen);
+#ifdef SRT_ENABLE_ENCRYPTION
+        if (val == false && co.iCryptoMode == CSrtConfig::CIPHER_MODE_AES_GCM)
+        {
+            using namespace srt_logging;
+            LOGC(aclog.Error, log << "Can't disable TSBPD as long as AES GCM is enabled.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+#endif
+
+        co.bTSBPD = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_LATENCY>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iRcvLatency  = val;
+        co.iPeerLatency = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_RCVLATENCY>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iRcvLatency = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_PEERLATENCY>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iPeerLatency = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_TLPKTDROP>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bTLPktDrop = cast_optval<bool>(optval, optlen);
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_SNDDROPDELAY>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < -1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iSndDropDelay = val;
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_PASSPHRASE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+#ifdef SRT_ENABLE_ENCRYPTION
+        // Password must be 10-80 characters.
+        // Or it can be empty to clear the password.
+        if ((optlen != 0) && (optlen < 10 || optlen > HAICRYPT_SECRET_MAX_SZ))
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        memset(&co.CryptoSecret, 0, sizeof(co.CryptoSecret));
+        co.CryptoSecret.typ = HAICRYPT_SECTYP_PASSPHRASE;
+        co.CryptoSecret.len = (optlen <= (int)sizeof(co.CryptoSecret.str) ? optlen : (int)sizeof(co.CryptoSecret.str));
+        memcpy((co.CryptoSecret.str), optval, co.CryptoSecret.len);
+#else
+        (void)co; // prevent warning
+        (void)optval;
+        if (optlen == 0)
+            return; // Allow to set empty passphrase if no encryption supported.
+
+        LOGC(aclog.Error, log << "SRTO_PASSPHRASE: encryption not enabled at compile time");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+#endif
+    }
+};
+template<>
+struct CSrtConfigSetter<SRTO_PBKEYLEN>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+#ifdef SRT_ENABLE_ENCRYPTION
+        const int v    = cast_optval<int>(optval, optlen);
+        int const allowed[4] = {
+            0,  // Default value, if this results for initiator, defaults to 16. See below.
+            16, // AES-128
+            24, // AES-192
+            32  // AES-256
+        };
+        const int *const allowed_end = allowed + 4;
+        if (std::find(allowed, allowed_end, v) == allowed_end)
+        {
+            LOGC(aclog.Error,
+                    log << "Invalid value for option SRTO_PBKEYLEN: " << v << "; allowed are: 0, 16, 24, 32");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        // Note: This works a little different in HSv4 and HSv5.
+
+        // HSv4:
+        // The party that is set SRTO_SENDER will send KMREQ, and it will
+        // use default value 16, if SRTO_PBKEYLEN is the default value 0.
+        // The responder that receives KMRSP has nothing to say about
+        // PBKEYLEN anyway and it will take the length of the key from
+        // the initiator (sender) as a good deal.
+        //
+        // HSv5:
+        // The initiator (independently on the sender) will send KMREQ,
+        // and as it should be the sender to decide about the PBKEYLEN.
+        // Your application should do the following then:
+        // 1. The sender should set PBKEYLEN to the required value.
+        // 2. If the sender is initiator, it will create the key using
+        //    its preset PBKEYLEN (or default 16, if not set) and the
+        //    receiver-responder will take it as a good deal.
+        // 3. Leave the PBKEYLEN value on the receiver as default 0.
+        // 4. If sender is responder, it should then advertise the PBKEYLEN
+        //    value in the initial handshake messages (URQ_INDUCTION if
+        //    listener, and both URQ_WAVEAHAND and URQ_CONCLUSION in case
+        //    of rendezvous, as it is the matter of luck who of them will
+        //    eventually become the initiator). This way the receiver
+        //    being an initiator will set iSndCryptoKeyLen before setting
+        //    up KMREQ for sending to the sender-responder.
+        //
+        // Note that in HSv5 if both sides set PBKEYLEN, the responder
+        // wins, unless the initiator is a sender (the effective PBKEYLEN
+        // will be the one advertised by the responder). If none sets,
+        // PBKEYLEN will default to 16.
+
+        co.iSndCryptoKeyLen = v;
+#else
+        (void)co; // prevent warning
+        (void)optval;
+        (void)optlen;
+        LOGC(aclog.Error, log << "SRTO_PBKEYLEN: encryption not enabled at compile time");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+#endif
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_NAKREPORT>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bRcvNakReport = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_CONNTIMEO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        using namespace srt::sync;
+        co.tdConnTimeOut = milliseconds_from(val);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_DRIFTTRACER>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bDriftTracer = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_LOSSMAXTTL>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iMaxReorderTolerance = cast_optval<int>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_MINVERSION>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.uMinimumPeerSrtVersion = cast_optval<uint32_t>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_STREAMID>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        if (size_t(optlen) > CSrtConfig::MAX_SID_LENGTH)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.sStreamName.set((const char*)optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_CONGESTION>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        std::string val;
+        val.assign((const char*)optval, optlen);
+
+        // Translate alias
+        if (val == "vod")
+            val = "file";
+
+        bool res = SrtCongestion::exists(val);
+        if (!res)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.sCongestion.set(val);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_MESSAGEAPI>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bMessageAPI = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_PAYLOADSIZE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+        {
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        if (val > SRT_LIVE_MAX_PLSIZE)
+        {
+            LOGC(aclog.Error, log << "SRTO_PAYLOADSIZE: value exceeds " << SRT_LIVE_MAX_PLSIZE << ", maximum payload per MTU.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        std::string errorlog;
+        if (!co.payloadSizeFits(size_t(val), AF_INET, (errorlog)))
+        {
+            LOGP(aclog.Error, errorlog);
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        co.zExpPayloadSize = val;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_TRANSTYPE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        // XXX Note that here the configuration for SRTT_LIVE
+        // is the same as DEFAULT VALUES for these fields set
+        // in CUDT::CUDT.
+        switch (cast_optval<SRT_TRANSTYPE>(optval, optlen))
+        {
+        case SRTT_LIVE:
+            // Default live options:
+            // - tsbpd: on
+            // - latency: 120ms
+            // - linger: off
+            // - congctl: live
+            // - extraction method: message (reading call extracts one message)
+            co.bTSBPD          = true;
+            co.iRcvLatency     = SRT_LIVE_DEF_LATENCY_MS;
+            co.iPeerLatency    = 0;
+            co.bTLPktDrop      = true;
+            co.iSndDropDelay   = 0;
+            co.bMessageAPI     = true;
+            co.bRcvNakReport   = true;
+            co.iRetransmitAlgo = 1;
+            co.zExpPayloadSize = SRT_LIVE_DEF_PLSIZE;
+            co.Linger.l_onoff  = 0;
+            co.Linger.l_linger = 0;
+            co.sCongestion.set("live", 4);
+            break;
+
+        case SRTT_FILE:
+            // File transfer mode:
+            // - tsbpd: off
+            // - latency: 0
+            // - linger: on
+            // - congctl: file (original UDT congestion control)
+            // - extraction method: stream (reading call extracts as many bytes as available and fits in buffer)
+            co.bTSBPD          = false;
+            co.iRcvLatency     = 0;
+            co.iPeerLatency    = 0;
+            co.bTLPktDrop      = false;
+            co.iSndDropDelay   = -1;
+            co.bMessageAPI     = false;
+            co.bRcvNakReport   = false;
+            co.iRetransmitAlgo = 0;
+            co.zExpPayloadSize = 0; // use maximum
+            co.Linger.l_onoff  = 1;
+            co.Linger.l_linger = CSrtConfig::DEF_LINGER_S;
+            co.sCongestion.set("file", 4);
+            break;
+
+        default:
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+    }
+};
+
+#if ENABLE_BONDING
+template<>
+struct CSrtConfigSetter<SRTO_GROUPCONNECT>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iGroupConnect = cast_optval<int>(optval, optlen);
+    }
+};
+#endif
+
+template<>
+struct CSrtConfigSetter<SRTO_KMREFRESHRATE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+        {
+            LOGC(aclog.Error,
+                 log << "SRTO_KMREFRESHRATE=" << val << " can't be negative");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        // Changing the KMREFRESHRATE sets KMPREANNOUNCE to the maximum allowed value
+        co.uKmRefreshRatePkt = (unsigned) val;
+
+        if (co.uKmPreAnnouncePkt == 0 && co.uKmRefreshRatePkt == 0)
+            return; // Both values are default
+
+        const unsigned km_preanno = co.uKmPreAnnouncePkt == 0 ? HAICRYPT_DEF_KM_PRE_ANNOUNCE : co.uKmPreAnnouncePkt;
+        const unsigned km_refresh = co.uKmRefreshRatePkt == 0 ? HAICRYPT_DEF_KM_REFRESH_RATE : co.uKmRefreshRatePkt;
+
+        if (co.uKmPreAnnouncePkt == 0 || km_preanno > (km_refresh - 1) / 2)
+        {
+            co.uKmPreAnnouncePkt = (km_refresh - 1) / 2;
+            LOGC(aclog.Warn,
+                 log << "SRTO_KMREFRESHRATE=0x" << std::hex << km_refresh << ": setting SRTO_KMPREANNOUNCE=0x"
+                     << std::hex << co.uKmPreAnnouncePkt);
+        }
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_KMPREANNOUNCE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+        {
+            LOGC(aclog.Error,
+                 log << "SRTO_KMPREANNOUNCE=" << val << " can't be negative");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        const unsigned km_preanno = val == 0 ? HAICRYPT_DEF_KM_PRE_ANNOUNCE : val;
+        const unsigned kmref = co.uKmRefreshRatePkt == 0 ? HAICRYPT_DEF_KM_REFRESH_RATE : co.uKmRefreshRatePkt;
+        if (km_preanno > (kmref - 1) / 2)
+        {
+            LOGC(aclog.Error,
+                 log << "SRTO_KMPREANNOUNCE=0x" << std::hex << km_preanno << " exceeds KmRefresh/2, 0x" << ((kmref - 1) / 2)
+                     << " - OPTION REJECTED.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        co.uKmPreAnnouncePkt = val;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_ENFORCEDENCRYPTION>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.bEnforcedEnc = cast_optval<bool>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_PEERIDLETIMEO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iPeerIdleTimeout_ms = val;
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_IPV6ONLY>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        co.iIpV6Only = cast_optval<int>(optval, optlen);
+    }
+};
+
+template<>
+struct CSrtConfigSetter<SRTO_PACKETFILTER>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+        std::string arg((const char*)optval, optlen);
+        // Parse the configuration string prematurely
+        SrtFilterConfig fc;
+        PacketFilter::Factory* fax = 0;
+        if (!ParseFilterConfig(arg, (fc), (&fax)))
+        {
+            LOGC(aclog.Error,
+                 log << "SRTO_PACKETFILTER: Incorrect syntax. Use: FILTERTYPE[,KEY:VALUE...]. "
+                        "FILTERTYPE ("
+                     << fc.type << ") must be installed (or builtin)");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+        std::string error;
+        if (!fax->verifyConfig(fc, (error)))
+        {
+            LOGC(aclog.Error, log << "SRTO_PACKETFILTER: Incorrect config: " << error);
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        size_t efc_max_payload_size = SRT_LIVE_MAX_PLSIZE - fc.extra_size;
+        if (co.zExpPayloadSize > efc_max_payload_size)
+        {
+            LOGC(aclog.Warn,
+                 log << "Due to filter-required extra " << fc.extra_size << " bytes, SRTO_PAYLOADSIZE fixed to "
+                     << efc_max_payload_size << " bytes");
+            co.zExpPayloadSize = efc_max_payload_size;
+        }
+
+        co.sPacketFilterConfig.set(arg);
+    }
+};
+
+#if ENABLE_BONDING
+template<>
+struct CSrtConfigSetter<SRTO_GROUPMINSTABLETIMEO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+        // This option is meaningless for the socket itself.
+        // It's set here just for the sake of setting it on a listener
+        // socket so that it is then applied on the group when a
+        // group connection is configured.
+        const int val_ms = cast_optval<int>(optval, optlen);
+        const int min_timeo_ms = (int) CSrtConfig::COMM_DEF_MIN_STABILITY_TIMEOUT_MS;
+
+        if (val_ms < min_timeo_ms)
+        {
+            LOGC(qmlog.Error,
+                log << "group option: SRTO_GROUPMINSTABLETIMEO min allowed value is "
+                    << min_timeo_ms << " ms.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        const int idletmo_ms = co.iPeerIdleTimeout_ms;
+
+        if (val_ms > idletmo_ms)
+        {
+            LOGC(aclog.Error, log << "group option: SRTO_GROUPMINSTABLETIMEO(" << val_ms
+                                  << ") exceeds SRTO_PEERIDLETIMEO(" << idletmo_ms << ")");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        co.uMinStabilityTimeout_ms = val_ms;
+        LOGC(smlog.Error, log << "SRTO_GROUPMINSTABLETIMEO set " << val_ms);
+    }
+};
+#endif
+
+template<>
+struct CSrtConfigSetter<SRTO_RETRANSMITALGO>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        const int val = cast_optval<int>(optval, optlen);
+        if (val < 0 || val > 1)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        co.iRetransmitAlgo = val;
+    }
+};
+
+#ifdef ENABLE_AEAD_API_PREVIEW
+template<>
+struct CSrtConfigSetter<SRTO_CRYPTOMODE>
+{
+    static void set(CSrtConfig& co, const void* optval, int optlen)
+    {
+        using namespace srt_logging;
+        const int val = cast_optval<int>(optval, optlen);
+#ifdef SRT_ENABLE_ENCRYPTION
+        if (val < CSrtConfig::CIPHER_MODE_AUTO || val > CSrtConfig::CIPHER_MODE_AES_GCM)
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+        if (val == CSrtConfig::CIPHER_MODE_AES_GCM && !HaiCrypt_IsAESGCM_Supported())
+        {
+            LOGC(aclog.Error, log << "AES GCM is not supported by the crypto provider.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        if (val == CSrtConfig::CIPHER_MODE_AES_GCM && !co.bTSBPD)
+        {
+            LOGC(aclog.Error, log << "Enable TSBPD to use AES GCM.");
+            throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+        }
+
+        co.iCryptoMode = val;
+#else
+        LOGC(aclog.Error, log << "SRT was built without crypto module.");
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+#endif
+
+    }
+};
+#endif
+
+int dispatchSet(SRT_SOCKOPT optName, CSrtConfig& co, const void* optval, int optlen)
+{
+    switch (optName)
+    {
+#define DISPATCH(optname) case optname: CSrtConfigSetter<optname>::set(co, optval, optlen); return 0;
+
+        DISPATCH(SRTO_MSS);
+        DISPATCH(SRTO_FC);
+        DISPATCH(SRTO_SNDBUF);
+        DISPATCH(SRTO_RCVBUF);
+        DISPATCH(SRTO_LINGER);
+        DISPATCH(SRTO_UDP_SNDBUF);
+        DISPATCH(SRTO_UDP_RCVBUF);
+        DISPATCH(SRTO_RENDEZVOUS);
+        DISPATCH(SRTO_SNDTIMEO);
+        DISPATCH(SRTO_RCVTIMEO);
+        DISPATCH(SRTO_SNDSYN);
+        DISPATCH(SRTO_RCVSYN);
+        DISPATCH(SRTO_REUSEADDR);
+        DISPATCH(SRTO_MAXBW);
+        DISPATCH(SRTO_IPTTL);
+        DISPATCH(SRTO_IPTOS);
+        DISPATCH(SRTO_BINDTODEVICE);
+        DISPATCH(SRTO_INPUTBW);
+        DISPATCH(SRTO_MININPUTBW);
+        DISPATCH(SRTO_OHEADBW);
+        DISPATCH(SRTO_SENDER);
+        DISPATCH(SRTO_TSBPDMODE);
+        DISPATCH(SRTO_LATENCY);
+        DISPATCH(SRTO_RCVLATENCY);
+        DISPATCH(SRTO_PEERLATENCY);
+        DISPATCH(SRTO_TLPKTDROP);
+        DISPATCH(SRTO_SNDDROPDELAY);
+        DISPATCH(SRTO_PASSPHRASE);
+        DISPATCH(SRTO_PBKEYLEN);
+        DISPATCH(SRTO_NAKREPORT);
+        DISPATCH(SRTO_CONNTIMEO);
+        DISPATCH(SRTO_DRIFTTRACER);
+        DISPATCH(SRTO_LOSSMAXTTL);
+        DISPATCH(SRTO_MINVERSION);
+        DISPATCH(SRTO_STREAMID);
+        DISPATCH(SRTO_CONGESTION);
+        DISPATCH(SRTO_MESSAGEAPI);
+        DISPATCH(SRTO_PAYLOADSIZE);
+        DISPATCH(SRTO_TRANSTYPE);
+#if ENABLE_BONDING
+        DISPATCH(SRTO_GROUPCONNECT);
+        DISPATCH(SRTO_GROUPMINSTABLETIMEO);
+#endif
+        DISPATCH(SRTO_KMREFRESHRATE);
+        DISPATCH(SRTO_KMPREANNOUNCE);
+        DISPATCH(SRTO_ENFORCEDENCRYPTION);
+        DISPATCH(SRTO_PEERIDLETIMEO);
+        DISPATCH(SRTO_IPV6ONLY);
+        DISPATCH(SRTO_PACKETFILTER);
+        DISPATCH(SRTO_RETRANSMITALGO);
+#ifdef ENABLE_AEAD_API_PREVIEW
+        DISPATCH(SRTO_CRYPTOMODE);
+#endif
+#ifdef ENABLE_MAXREXMITBW
+        DISPATCH(SRTO_MAXREXMITBW);
+#endif
+
+#undef DISPATCH
+    default:
+        return -1;
+    }
+}
+
+} // anonymous namespace
+
+int CSrtConfig::set(SRT_SOCKOPT optName, const void* optval, int optlen)
+{
+    return dispatchSet(optName, *this, optval, optlen);
+}
+
+bool CSrtConfig::payloadSizeFits(size_t val, int /*ip_family*/, std::string& w_errmsg) ATR_NOTHROW
+{
+    if (!this->sPacketFilterConfig.empty())
+    {
+        // This means that the filter might have been installed before,
+        // and the fix to the maximum payload size was already applied.
+        // This needs to be checked now.
+        SrtFilterConfig fc;
+        if (!ParseFilterConfig(this->sPacketFilterConfig.str(), fc))
+        {
+            // Break silently. This should not happen
+            w_errmsg = "SRTO_PAYLOADSIZE: IPE: failing filter configuration installed";
+            return false;
+        }
+
+        const size_t efc_max_payload_size = SRT_LIVE_MAX_PLSIZE - fc.extra_size;
+        if (size_t(val) > efc_max_payload_size)
+        {
+            std::ostringstream log;
+            log << "SRTO_PAYLOADSIZE: value exceeds " << SRT_LIVE_MAX_PLSIZE << " bytes decreased by " << fc.extra_size
+                << " required for packet filter header";
+            w_errmsg = log.str();
+            return false;
+        }
+    }
+
+    // Not checking AUTO to allow defaul 1456 bytes.
+    if ((this->iCryptoMode == CSrtConfig::CIPHER_MODE_AES_GCM)
+            && (val > (SRT_LIVE_MAX_PLSIZE - HAICRYPT_AUTHTAG_MAX)))
+    {
+        std::ostringstream log;
+        log << "SRTO_PAYLOADSIZE: value exceeds " << SRT_LIVE_MAX_PLSIZE
+            << " bytes decreased by " << HAICRYPT_AUTHTAG_MAX
+            << " required for AES-GCM.";
+        w_errmsg = log.str();
+        return false;
+    }
+
+    return true;
+}
+
+#if ENABLE_BONDING
+bool SRT_SocketOptionObject::add(SRT_SOCKOPT optname, const void* optval, size_t optlen)
+{
+    // Check first if this option is allowed to be set
+    // as on a member socket.
+
+    switch (optname)
+    {
+    case SRTO_BINDTODEVICE:
+    case SRTO_CONNTIMEO:
+    case SRTO_DRIFTTRACER:
+        //SRTO_FC - not allowed to be different among group members
+    case SRTO_GROUPMINSTABLETIMEO:
+        //SRTO_INPUTBW - per transmission setting
+    case SRTO_IPTOS:
+    case SRTO_IPTTL:
+    case SRTO_KMREFRESHRATE:
+    case SRTO_KMPREANNOUNCE:
+        //SRTO_LATENCY - per transmission setting
+        //SRTO_LINGER - not for managed sockets
+    case SRTO_LOSSMAXTTL:
+        //SRTO_MAXBW - per transmission setting
+        //SRTO_MESSAGEAPI - groups are live mode only
+        //SRTO_MINVERSION - per group connection setting
+    case SRTO_NAKREPORT:
+        //SRTO_OHEADBW - per transmission setting
+        //SRTO_PACKETFILTER - per transmission setting
+        //SRTO_PASSPHRASE - per group connection setting
+        //SRTO_PASSPHRASE - per transmission setting
+        //SRTO_PBKEYLEN - per group connection setting
+    case SRTO_PEERIDLETIMEO:
+    case SRTO_RCVBUF:
+        //SRTO_RCVSYN - must be always false in groups
+        //SRTO_RCVTIMEO - must be always -1 in groups
+    case SRTO_SNDBUF:
+    case SRTO_SNDDROPDELAY:
+        //SRTO_TLPKTDROP - per transmission setting
+        //SRTO_TSBPDMODE - per transmission setting
+    case SRTO_UDP_RCVBUF:
+    case SRTO_UDP_SNDBUF:
+        break;
+
+    default:
+        // Other options are not allowed
+        return false;
+    }
+
+    // Header size will get the size likely aligned, but it won't
+    // hurt if the memory size will be up to 4 bytes more than
+    // needed - and it's better to not risk that alighment rules
+    // will make these calculations result in less space than needed.
+    const size_t headersize = sizeof(SingleOption);
+    const size_t payload = std::min(sizeof(uint32_t), optlen);
+    unsigned char* mem = new unsigned char[headersize + payload];
+    SingleOption* option = reinterpret_cast<SingleOption*>(mem);
+    option->option = optname;
+    option->length = (uint16_t) optlen;
+    memcpy(option->storage, optval, optlen);
+
+    options.push_back(option);
+
+    return true;
+}
+#endif
diff --git a/srtcore/socketconfig.h b/srtcore/socketconfig.h
new file mode 100644
index 000000000..8a78ea21e
--- /dev/null
+++ b/srtcore/socketconfig.h
@@ -0,0 +1,419 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+#ifndef INC_SRT_SOCKETCONFIG_H
+#define INC_SRT_SOCKETCONFIG_H
+
+#include "platform_sys.h"
+#ifdef SRT_ENABLE_BINDTODEVICE
+#include <linux/if.h>
+#endif
+#include <string>
+#include "haicrypt.h"
+#include "congctl.h"
+#include "packet.h"
+#include "handshake.h"
+#include "logger_defs.h"
+#include "packetfilter.h"
+
+// SRT Version constants
+#define SRT_VERSION_UNK     0
+#define SRT_VERSION_MAJ1    0x010000            /* Version 1 major */
+#define SRT_VERSION_MAJ(v) (0xFF0000 & (v))     /* Major number ensuring backward compatibility */
+#define SRT_VERSION_MIN(v) (0x00FF00 & (v))
+#define SRT_VERSION_PCH(v) (0x0000FF & (v))
+
+// NOTE: SRT_VERSION is primarily defined in the build file.
+extern const int32_t SRT_DEF_VERSION;
+
+namespace srt
+{
+
+struct CSrtMuxerConfig
+{
+    static const int DEF_UDP_BUFFER_SIZE = 65536;
+
+    int  iIpTTL;
+    int  iIpToS;
+    int  iIpV6Only;  // IPV6_V6ONLY option (-1 if not set)
+    bool bReuseAddr; // reuse an exiting port or not, for UDP multiplexer
+
+#ifdef SRT_ENABLE_BINDTODEVICE
+    std::string sBindToDevice;
+#endif
+    int iUDPSndBufSize; // UDP sending buffer size
+    int iUDPRcvBufSize; // UDP receiving buffer size
+
+    // NOTE: this operator is not reversable. The syntax must use:
+    //  muxer_entry == socket_entry
+    bool isCompatWith(const CSrtMuxerConfig& other) const
+    {
+#define CEQUAL(field) (field == other.field)
+        return CEQUAL(iIpTTL)
+            && CEQUAL(iIpToS)
+            && CEQUAL(bReuseAddr)
+#ifdef SRT_ENABLE_BINDTODEVICE
+            && CEQUAL(sBindToDevice)
+#endif
+            && CEQUAL(iUDPSndBufSize)
+            && CEQUAL(iUDPRcvBufSize)
+            && (other.iIpV6Only == -1 || CEQUAL(iIpV6Only))
+            // NOTE: iIpV6Only is not regarded because
+            // this matches only in case of IPv6 with "any" address.
+            // And this aspect must be checked separately because here
+            // this procedure has no access to neither the address,
+            // nor the IP version (family).
+#undef CEQUAL
+            && true;
+    }
+
+    CSrtMuxerConfig()
+        : iIpTTL(-1) /* IPv4 TTL or IPv6 HOPs [1..255] (-1:undefined) */
+        , iIpToS(-1) /* IPv4 Type of Service or IPv6 Traffic Class [0x00..0xff] (-1:undefined) */
+        , iIpV6Only(-1)
+        , bReuseAddr(true) // This is default in SRT
+        , iUDPSndBufSize(DEF_UDP_BUFFER_SIZE)
+        , iUDPRcvBufSize(DEF_UDP_BUFFER_SIZE)
+    {
+    }
+};
+
+struct CSrtConfig;
+
+template <size_t SIZE>
+class StringStorage
+{
+    char     stor[SIZE + 1];
+    uint16_t len;
+
+    // NOTE: default copying allowed.
+
+public:
+    StringStorage()
+        : len(0)
+    {
+        memset(stor, 0, sizeof stor);
+    }
+
+    bool set(const char* s, size_t length)
+    {
+        if (length > SIZE)
+            return false;
+
+        memcpy(stor, s, length);
+        stor[length] = 0;
+        len          = (int) length;
+        return true;
+    }
+
+    bool set(const std::string& s)
+    {
+        return set(s.c_str(), s.size());
+    }
+
+    size_t copy(char* s, size_t length) const
+    {
+        if (!s)
+            return 0;
+
+        size_t copy_len = std::min((size_t)len, length);
+        memcpy(s, stor, copy_len);
+        return copy_len;
+    }
+
+    std::string str() const
+    {
+        return len == 0 ? std::string() : std::string(stor, len);
+    }
+
+    const char* c_str() const
+    {
+        return stor;
+    }
+
+    size_t size() const { return size_t(len); }
+    bool   empty() const { return len == 0; }
+};
+
+struct CSrtConfig: CSrtMuxerConfig
+{
+    typedef srt::sync::steady_clock::time_point time_point;
+    typedef srt::sync::steady_clock::duration   duration;
+
+    static const int
+        DEF_MSS = 1500,
+        DEF_FLIGHT_SIZE = 25600,
+        DEF_BUFFER_SIZE = 8192, //Rcv buffer MUST NOT be bigger than Flight Flag size
+        DEF_LINGER_S = 3*60,    // 3 minutes
+        DEF_CONNTIMEO_S = 3;    // 3 seconds
+
+    enum
+    {
+        CIPHER_MODE_AUTO = 0,
+        CIPHER_MODE_AES_CTR = 1,
+        CIPHER_MODE_AES_GCM = 2
+    };
+
+    static const int      COMM_RESPONSE_TIMEOUT_MS      = 5 * 1000; // 5 seconds
+    static const uint32_t COMM_DEF_MIN_STABILITY_TIMEOUT_MS = 60;   // 60 ms
+
+    // Mimimum recv flight flag size is 32 packets
+    static const int    DEF_MIN_FLIGHT_PKT = 32;
+    static const size_t MAX_SID_LENGTH     = 512;
+    static const size_t MAX_PFILTER_LENGTH = 64;
+    static const size_t MAX_CONG_LENGTH    = 16;
+
+    int    iMSS;            // Maximum Segment Size, in bytes
+    size_t zExpPayloadSize; // Expected average payload size (user option)
+
+    // Options
+    bool   bSynSending;     // Sending synchronization mode
+    bool   bSynRecving;     // Receiving synchronization mode
+    int    iFlightFlagSize; // Maximum number of packets in flight from the peer side
+    int    iSndBufSize;     // Maximum UDT sender buffer size
+    int    iRcvBufSize;     // Maximum UDT receiver buffer size
+    linger Linger;          // Linger information on close
+    bool   bRendezvous;     // Rendezvous connection mode
+
+    duration tdConnTimeOut; // connect timeout in milliseconds
+    bool     bDriftTracer;
+    int      iSndTimeOut; // sending timeout in milliseconds
+    int      iRcvTimeOut; // receiving timeout in milliseconds
+    int64_t  llMaxBW;     // maximum data transfer rate (threshold)
+#ifdef ENABLE_MAXREXMITBW
+    int64_t  llMaxRexmitBW; // maximum bandwidth limit for retransmissions (Bytes/s).
+#endif
+
+    // These fields keep the options for encryption
+    // (SRTO_PASSPHRASE, SRTO_PBKEYLEN). Crypto object is
+    // created later and takes values from these.
+    HaiCrypt_Secret CryptoSecret;
+    int             iSndCryptoKeyLen;
+
+    // XXX Consider removing. The bDataSender stays here
+    // in order to maintain the HS side selection in HSv4.
+    bool bDataSender;
+
+    bool     bMessageAPI;
+    bool     bTSBPD;        // Whether AGENT will do TSBPD Rx (whether peer does, is not agent's problem)
+    int      iRcvLatency;   // Agent's Rx latency
+    int      iPeerLatency;  // Peer's Rx latency for the traffic made by Agent's Tx.
+    bool     bTLPktDrop;    // Whether Agent WILL DO TLPKTDROP on Rx.
+    int      iSndDropDelay; // Extra delay when deciding to snd-drop for TLPKTDROP, -1 to off
+    bool     bEnforcedEnc;  // Off by default. When on, any connection other than nopw-nopw & pw1-pw1 is rejected.
+    int      iGroupConnect;    // 1 - allow group connections
+    int      iPeerIdleTimeout_ms; // Timeout for hearing anything from the peer (ms).
+    uint32_t uMinStabilityTimeout_ms;
+    int      iRetransmitAlgo;
+    int      iCryptoMode; // SRTO_CRYPTOMODE
+
+    int64_t llInputBW;         // Input stream rate (bytes/sec). 0: use internally estimated input bandwidth
+    int64_t llMinInputBW;      // Minimum input stream rate estimate (bytes/sec)
+    int  iOverheadBW;          // Percent above input stream rate (applies if llMaxBW == 0)
+    bool bRcvNakReport;        // Enable Receiver Periodic NAK Reports
+    int  iMaxReorderTolerance; //< Maximum allowed value for dynamic reorder tolerance
+
+    // For the use of CCryptoControl
+    // HaiCrypt configuration
+    unsigned int uKmRefreshRatePkt;
+    unsigned int uKmPreAnnouncePkt;
+
+    uint32_t uSrtVersion;
+    uint32_t uMinimumPeerSrtVersion;
+
+    StringStorage<MAX_CONG_LENGTH>    sCongestion;
+    StringStorage<MAX_PFILTER_LENGTH> sPacketFilterConfig;
+    StringStorage<MAX_SID_LENGTH>     sStreamName;
+
+    // Shortcuts and utilities
+    int32_t flightCapacity()
+    {
+        return std::min(iRcvBufSize, iFlightFlagSize);
+    }
+
+    CSrtConfig()
+        : iMSS(DEF_MSS)
+        , zExpPayloadSize(SRT_LIVE_DEF_PLSIZE)
+        , bSynSending(true)
+        , bSynRecving(true)
+        , iFlightFlagSize(DEF_FLIGHT_SIZE)
+        , iSndBufSize(DEF_BUFFER_SIZE)
+        , iRcvBufSize(DEF_BUFFER_SIZE)
+        , bRendezvous(false)
+        , tdConnTimeOut(srt::sync::seconds_from(DEF_CONNTIMEO_S))
+        , bDriftTracer(true)
+        , iSndTimeOut(-1)
+        , iRcvTimeOut(-1)
+        , llMaxBW(-1)
+#ifdef ENABLE_MAXREXMITBW
+        , llMaxRexmitBW(-1)
+#endif
+        , bDataSender(false)
+        , bMessageAPI(true)
+        , bTSBPD(true)
+        , iRcvLatency(SRT_LIVE_DEF_LATENCY_MS)
+        , iPeerLatency(0)
+        , bTLPktDrop(true)
+        , iSndDropDelay(0)
+        , bEnforcedEnc(true)
+        , iGroupConnect(0)
+        , iPeerIdleTimeout_ms(COMM_RESPONSE_TIMEOUT_MS)
+        , uMinStabilityTimeout_ms(COMM_DEF_MIN_STABILITY_TIMEOUT_MS)
+        , iRetransmitAlgo(1)
+        , iCryptoMode(CIPHER_MODE_AUTO)
+        , llInputBW(0)
+        , llMinInputBW(0)
+        , iOverheadBW(25)
+        , bRcvNakReport(true)
+        , iMaxReorderTolerance(0) // Sensible optimal value is 10, 0 preserves old behavior
+        , uKmRefreshRatePkt(0)
+        , uKmPreAnnouncePkt(0)
+        , uSrtVersion(SRT_DEF_VERSION)
+        , uMinimumPeerSrtVersion(SRT_VERSION_MAJ1)
+
+    {
+        // Default UDT configurations
+        iUDPRcvBufSize = iRcvBufSize * iMSS;
+
+        // Linger: LIVE mode defaults, please refer to `SRTO_TRANSTYPE` option
+        // for other modes.
+        Linger.l_onoff   = 0;
+        Linger.l_linger  = 0;
+        CryptoSecret.len = 0;
+        iSndCryptoKeyLen = 0;
+
+        // Default congestion is "live".
+        // Available builtin congestions: "file".
+        // Others can be registerred.
+        sCongestion.set("live", 4);
+    }
+
+    ~CSrtConfig()
+    {
+        // Wipeout critical data
+        memset(&CryptoSecret, 0, sizeof(CryptoSecret));
+    }
+
+    int set(SRT_SOCKOPT optName, const void* val, int size);
+
+    bool payloadSizeFits(size_t val, int ip_family, std::string& w_errmsg) ATR_NOTHROW;
+
+    // This function returns the number of bytes that are allocated
+    // for a single packet in the sender and receiver buffer.
+    int bytesPerPkt() const { return iMSS - int(CPacket::UDP_HDR_SIZE); }
+};
+
+template <typename T>
+inline T cast_optval(const void* optval)
+{
+    return *reinterpret_cast<const T*>(optval);
+}
+
+template <typename T>
+inline T cast_optval(const void* optval, int optlen)
+{
+    if (optlen > 0 && optlen != sizeof(T))
+        throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);
+
+    return cast_optval<T>(optval);
+}
+
+// This function is to make it possible for both C and C++
+// API to accept both bool and int types for boolean options.
+// (it's not that C couldn't use <stdbool.h>, it's that people
+// often forget to use correct type).
+template <>
+inline bool cast_optval(const void* optval, int optlen)
+{
+    if (optlen == sizeof(bool))
+    {
+        return *reinterpret_cast<const bool*>(optval);
+    }
+
+    if (optlen == sizeof(int))
+    {
+        // 0!= is a windows warning-killer int-to-bool conversion
+        return 0 != *reinterpret_cast<const int*>(optval);
+    }
+    return false;
+}
+
+
+int RcvBufferSizeOptionToValue(int optval, int flightflag, int mss);
+
+} // namespace srt
+
+struct SRT_SocketOptionObject
+{
+    struct SingleOption
+    {
+        uint16_t      option;
+        uint16_t      length;
+        unsigned char storage[1]; // NOTE: Variable length object!
+    };
+
+    std::vector<SingleOption*> options;
+
+    SRT_SocketOptionObject() {}
+
+    ~SRT_SocketOptionObject()
+    {
+        for (size_t i = 0; i < options.size(); ++i)
+        {
+            // Convert back
+            unsigned char* mem = reinterpret_cast<unsigned char*>(options[i]);
+            delete[] mem;
+        }
+    }
+
+    bool add(SRT_SOCKOPT optname, const void* optval, size_t optlen);
+};
+
+#endif
diff --git a/srtcore/srt.h b/srtcore/srt.h
index f3a5becdc..614a85aea 100644
--- a/srtcore/srt.h
+++ b/srtcore/srt.h
@@ -16,6 +16,22 @@ written by
 #ifndef INC_SRTC_H
 #define INC_SRTC_H
 
+#ifndef SRT_API
+#ifdef _WIN32
+   #ifdef SRT_DYNAMIC
+      #ifdef SRT_EXPORTS
+         #define SRT_API __declspec(dllexport)
+      #else
+         #define SRT_API __declspec(dllimport)
+      #endif
+   #else // !SRT_DYNAMIC
+      #define SRT_API
+   #endif
+#else
+   #define SRT_API __attribute__ ((visibility("default")))
+#endif
+#endif
+
 #include "version.h"
 
 #include "platform_sys.h"
@@ -33,37 +49,6 @@ written by
 //if compiling with MinGW, it only works on XP or above
 //use -D_WIN32_WINNT=0x0501
 
-
-#ifdef _WIN32
-   #ifndef __MINGW__
-      // Explicitly define 32-bit and 64-bit numbers
-      typedef __int32 int32_t;
-      typedef __int64 int64_t;
-      typedef unsigned __int32 uint32_t;
-      #ifndef LEGACY_WIN32
-         typedef unsigned __int64 uint64_t;
-      #else
-         // VC 6.0 does not support unsigned __int64: may cause potential problems.
-         typedef __int64 uint64_t;
-      #endif
-
-      #ifdef SRT_DYNAMIC
-         #ifdef SRT_EXPORTS
-            #define SRT_API __declspec(dllexport)
-         #else
-            #define SRT_API __declspec(dllimport)
-         #endif
-      #else
-         #define SRT_API
-      #endif
-   #else // __MINGW__
-      #define SRT_API
-   #endif
-#else
-   #define SRT_API __attribute__ ((visibility("default")))
-#endif
-
-
 // For feature tests if you need.
 // You can use these constants with SRTO_MINVERSION option.
 #define SRT_VERSION_FEAT_HSv5 0x010300
@@ -75,7 +60,7 @@ written by
 #endif
 
 
-// Stadnard attributes
+// Standard attributes
 
 // When compiling in C++17 mode, use the standard C++17 attributes
 // (out of these, only [[deprecated]] is supported in C++14, so
@@ -152,15 +137,15 @@ typedef int32_t SRTSOCKET;
 static const int32_t SRTGROUP_MASK = (1 << 30);
 
 #ifdef _WIN32
-   #ifndef __MINGW__
-      typedef SOCKET SYSSOCKET;
-   #else
-      typedef int SYSSOCKET;
-   #endif
+   typedef SOCKET SYSSOCKET;
 #else
    typedef int SYSSOCKET;
 #endif
 
+#ifndef ENABLE_BONDING
+#define ENABLE_BONDING 0
+#endif
+
 typedef SYSSOCKET UDPSOCKET;
 
 
@@ -206,8 +191,8 @@ typedef enum SRT_SOCKOPT {
    SRTO_LATENCY = 23,        // NOT RECOMMENDED. SET: to both SRTO_RCVLATENCY and SRTO_PEERLATENCY. GET: same as SRTO_RCVLATENCY.
    SRTO_INPUTBW = 24,        // Estimated input stream rate.
    SRTO_OHEADBW,             // MaxBW ceiling based on % over input stream rate. Applies when UDT_MAXBW=0 (auto).
-   SRTO_PASSPHRASE = 26,     // Crypto PBKDF2 Passphrase size[0,10..64] 0:disable crypto
-   SRTO_PBKEYLEN,            // Crypto key len in bytes {16,24,32} Default: 16 (128-bit)
+   SRTO_PASSPHRASE = 26,     // Crypto PBKDF2 Passphrase (must be 10..79 characters, or empty to disable encryption)
+   SRTO_PBKEYLEN,            // Crypto key len in bytes {16,24,32} Default: 16 (AES-128)
    SRTO_KMSTATE,             // Key Material exchange status (UDT_SRTKmState)
    SRTO_IPTTL = 29,          // IP Time To Live (passthru for system sockopt IPPROTO_IP/IP_TTL)
    SRTO_IPTOS,               // IP Type of Service (passthru for system sockopt IPPROTO_IP/IP_TOS)
@@ -218,6 +203,7 @@ typedef enum SRT_SOCKOPT {
    SRTO_PEERVERSION,         // Peer SRT Version (from SRT Handshake)
    SRTO_CONNTIMEO = 36,      // Connect timeout in msec. Caller default: 3000, rendezvous (x 10)
    SRTO_DRIFTTRACER = 37,    // Enable or disable drift tracer
+   SRTO_MININPUTBW = 38,     // Minimum estimate of input stream rate.
    // (some space left)
    SRTO_SNDKMSTATE = 40,     // (GET) the current state of the encryption at the peer side
    SRTO_RCVKMSTATE,          // (GET) the current state of the encryption at the agent side
@@ -235,14 +221,20 @@ typedef enum SRT_SOCKOPT {
    SRTO_ENFORCEDENCRYPTION,  // Connection to be rejected or quickly broken when one side encryption set or bad password
    SRTO_IPV6ONLY,            // IPV6_V6ONLY mode
    SRTO_PEERIDLETIMEO,       // Peer-idle timeout (max time of silence heard from peer) in [ms]
-#if ENABLE_EXPERIMENTAL_BONDING
-   SRTO_GROUPCONNECT,        // Set on a listener to allow group connection
-   SRTO_GROUPSTABTIMEO,      // Stability timeout (backup groups) in [us]
-   SRTO_GROUPTYPE,           // Group type to which an accepted socket is about to be added, available in the handshake
-#endif
    SRTO_BINDTODEVICE,        // Forward the SOL_SOCKET/SO_BINDTODEVICE option on socket (pass packets only from that device)
+   SRTO_GROUPCONNECT,        // Set on a listener to allow group connection (ENABLE_BONDING)
+   SRTO_GROUPMINSTABLETIMEO, // Minimum Link Stability timeout (backup mode) in milliseconds (ENABLE_BONDING)
+   SRTO_GROUPTYPE,           // Group type to which an accepted socket is about to be added, available in the handshake (ENABLE_BONDING)
    SRTO_PACKETFILTER = 60,   // Add and configure a packet filter
-   SRTO_RETRANSMITALGO = 61  // An option to select packet retransmission algorithm
+   SRTO_RETRANSMITALGO = 61, // An option to select packet retransmission algorithm
+#ifdef ENABLE_AEAD_API_PREVIEW
+   SRTO_CRYPTOMODE = 62,     // Encryption cipher mode (AES-CTR, AES-GCM, ...).
+#endif
+#ifdef ENABLE_MAXREXMITBW
+   SRTO_MAXREXMITBW = 63,    // Maximum bandwidth limit for retransmision (Bytes/s)
+#endif
+
+   SRTO_E_SIZE // Always last element, not a valid option.
 } SRT_SOCKOPT;
 
 
@@ -466,6 +458,7 @@ enum CodeMinor
     MN_XSIZE           = 12,
     MN_EIDINVAL        = 13,
     MN_EEMPTY          = 14,
+    MN_BUSYPORT        = 15,
     // MJ_AGAIN
     MN_WRAVAIL         =  1,
     MN_RDAVAIL         =  2,
@@ -475,8 +468,8 @@ enum CodeMinor
 
 
 // Stupid, but effective. This will be #undefined, so don't worry.
-#define MJ(major) (1000 * MJ_##major)
-#define MN(major, minor) (1000 * MJ_##major + MN_##minor)
+#define SRT_EMJ(major) (1000 * MJ_##major)
+#define SRT_EMN(major, minor) (1000 * MJ_##major + MN_##minor)
 
 // Some better way to define it, and better for C language.
 typedef enum SRT_ERRNO
@@ -484,56 +477,56 @@ typedef enum SRT_ERRNO
     SRT_EUNKNOWN        = -1,
     SRT_SUCCESS         = MJ_SUCCESS,
 
-    SRT_ECONNSETUP      = MJ(SETUP),
-    SRT_ENOSERVER       = MN(SETUP, TIMEOUT),
-    SRT_ECONNREJ        = MN(SETUP, REJECTED),
-    SRT_ESOCKFAIL       = MN(SETUP, NORES),
-    SRT_ESECFAIL        = MN(SETUP, SECURITY),
-    SRT_ESCLOSED        = MN(SETUP, CLOSED),
-
-    SRT_ECONNFAIL       = MJ(CONNECTION),
-    SRT_ECONNLOST       = MN(CONNECTION, CONNLOST),
-    SRT_ENOCONN         = MN(CONNECTION, NOCONN),
-
-    SRT_ERESOURCE       = MJ(SYSTEMRES),
-    SRT_ETHREAD         = MN(SYSTEMRES, THREAD),
-    SRT_ENOBUF          = MN(SYSTEMRES, MEMORY),
-    SRT_ESYSOBJ         = MN(SYSTEMRES, OBJECT),
-
-    SRT_EFILE           = MJ(FILESYSTEM),
-    SRT_EINVRDOFF       = MN(FILESYSTEM, SEEKGFAIL),
-    SRT_ERDPERM         = MN(FILESYSTEM, READFAIL),
-    SRT_EINVWROFF       = MN(FILESYSTEM, SEEKPFAIL),
-    SRT_EWRPERM         = MN(FILESYSTEM, WRITEFAIL),
-
-    SRT_EINVOP          = MJ(NOTSUP),
-    SRT_EBOUNDSOCK      = MN(NOTSUP, ISBOUND),
-    SRT_ECONNSOCK       = MN(NOTSUP, ISCONNECTED),
-    SRT_EINVPARAM       = MN(NOTSUP, INVAL),
-    SRT_EINVSOCK        = MN(NOTSUP, SIDINVAL),
-    SRT_EUNBOUNDSOCK    = MN(NOTSUP, ISUNBOUND),
-    SRT_ENOLISTEN       = MN(NOTSUP, NOLISTEN),
-    SRT_ERDVNOSERV      = MN(NOTSUP, ISRENDEZVOUS),
-    SRT_ERDVUNBOUND     = MN(NOTSUP, ISRENDUNBOUND),
-    SRT_EINVALMSGAPI    = MN(NOTSUP, INVALMSGAPI),
-    SRT_EINVALBUFFERAPI = MN(NOTSUP, INVALBUFFERAPI),
-    SRT_EDUPLISTEN      = MN(NOTSUP, BUSY),
-    SRT_ELARGEMSG       = MN(NOTSUP, XSIZE),
-    SRT_EINVPOLLID      = MN(NOTSUP, EIDINVAL),
-    SRT_EPOLLEMPTY      = MN(NOTSUP, EEMPTY),
-
-    SRT_EASYNCFAIL      = MJ(AGAIN),
-    SRT_EASYNCSND       = MN(AGAIN, WRAVAIL),
-    SRT_EASYNCRCV       = MN(AGAIN, RDAVAIL),
-    SRT_ETIMEOUT        = MN(AGAIN, XMTIMEOUT),
-    SRT_ECONGEST        = MN(AGAIN, CONGESTION),
-
-    SRT_EPEERERR        = MJ(PEERERROR)
+    SRT_ECONNSETUP      = SRT_EMJ(SETUP),
+    SRT_ENOSERVER       = SRT_EMN(SETUP, TIMEOUT),
+    SRT_ECONNREJ        = SRT_EMN(SETUP, REJECTED),
+    SRT_ESOCKFAIL       = SRT_EMN(SETUP, NORES),
+    SRT_ESECFAIL        = SRT_EMN(SETUP, SECURITY),
+    SRT_ESCLOSED        = SRT_EMN(SETUP, CLOSED),
+
+    SRT_ECONNFAIL       = SRT_EMJ(CONNECTION),
+    SRT_ECONNLOST       = SRT_EMN(CONNECTION, CONNLOST),
+    SRT_ENOCONN         = SRT_EMN(CONNECTION, NOCONN),
+
+    SRT_ERESOURCE       = SRT_EMJ(SYSTEMRES),
+    SRT_ETHREAD         = SRT_EMN(SYSTEMRES, THREAD),
+    SRT_ENOBUF          = SRT_EMN(SYSTEMRES, MEMORY),
+    SRT_ESYSOBJ         = SRT_EMN(SYSTEMRES, OBJECT),
+
+    SRT_EFILE           = SRT_EMJ(FILESYSTEM),
+    SRT_EINVRDOFF       = SRT_EMN(FILESYSTEM, SEEKGFAIL),
+    SRT_ERDPERM         = SRT_EMN(FILESYSTEM, READFAIL),
+    SRT_EINVWROFF       = SRT_EMN(FILESYSTEM, SEEKPFAIL),
+    SRT_EWRPERM         = SRT_EMN(FILESYSTEM, WRITEFAIL),
+
+    SRT_EINVOP          = SRT_EMJ(NOTSUP),
+    SRT_EBOUNDSOCK      = SRT_EMN(NOTSUP, ISBOUND),
+    SRT_ECONNSOCK       = SRT_EMN(NOTSUP, ISCONNECTED),
+    SRT_EINVPARAM       = SRT_EMN(NOTSUP, INVAL),
+    SRT_EINVSOCK        = SRT_EMN(NOTSUP, SIDINVAL),
+    SRT_EUNBOUNDSOCK    = SRT_EMN(NOTSUP, ISUNBOUND),
+    SRT_ENOLISTEN       = SRT_EMN(NOTSUP, NOLISTEN),
+    SRT_ERDVNOSERV      = SRT_EMN(NOTSUP, ISRENDEZVOUS),
+    SRT_ERDVUNBOUND     = SRT_EMN(NOTSUP, ISRENDUNBOUND),
+    SRT_EINVALMSGAPI    = SRT_EMN(NOTSUP, INVALMSGAPI),
+    SRT_EINVALBUFFERAPI = SRT_EMN(NOTSUP, INVALBUFFERAPI),
+    SRT_EDUPLISTEN      = SRT_EMN(NOTSUP, BUSY),
+    SRT_ELARGEMSG       = SRT_EMN(NOTSUP, XSIZE),
+    SRT_EINVPOLLID      = SRT_EMN(NOTSUP, EIDINVAL),
+    SRT_EPOLLEMPTY      = SRT_EMN(NOTSUP, EEMPTY),
+    SRT_EBINDCONFLICT   = SRT_EMN(NOTSUP, BUSYPORT),
+
+    SRT_EASYNCFAIL      = SRT_EMJ(AGAIN),
+    SRT_EASYNCSND       = SRT_EMN(AGAIN, WRAVAIL),
+    SRT_EASYNCRCV       = SRT_EMN(AGAIN, RDAVAIL),
+    SRT_ETIMEOUT        = SRT_EMN(AGAIN, XMTIMEOUT),
+    SRT_ECONGEST        = SRT_EMN(AGAIN, CONGESTION),
+
+    SRT_EPEERERR        = SRT_EMJ(PEERERROR)
 } SRT_ERRNO;
 
-
-#undef MJ
-#undef MN
+#undef SRT_EMJ
+#undef SRT_EMN
 
 enum SRT_REJECT_REASON
 {
@@ -554,6 +547,9 @@ enum SRT_REJECT_REASON
     SRT_REJ_FILTER,      // incompatible packet filter
     SRT_REJ_GROUP,       // incompatible group
     SRT_REJ_TIMEOUT,     // connection timeout
+#ifdef ENABLE_AEAD_API_PREVIEW
+    SRT_REJ_CRYPTO,      // conflicting cryptographic configurations
+#endif
 
     SRT_REJ_E_SIZE,
 };
@@ -635,11 +631,14 @@ enum SRT_REJECT_REASON
 
 enum SRT_KM_STATE
 {
-    SRT_KM_S_UNSECURED = 0,      //No encryption
-    SRT_KM_S_SECURING  = 1,      //Stream encrypted, exchanging Keying Material
-    SRT_KM_S_SECURED   = 2,      //Stream encrypted, keying Material exchanged, decrypting ok.
-    SRT_KM_S_NOSECRET  = 3,      //Stream encrypted and no secret to decrypt Keying Material
-    SRT_KM_S_BADSECRET = 4       //Stream encrypted and wrong secret, cannot decrypt Keying Material
+    SRT_KM_S_UNSECURED     = 0, // No encryption
+    SRT_KM_S_SECURING      = 1, // Stream encrypted, exchanging Keying Material
+    SRT_KM_S_SECURED       = 2, // Stream encrypted, keying Material exchanged, decrypting ok.
+    SRT_KM_S_NOSECRET      = 3, // Stream encrypted and no secret to decrypt Keying Material
+    SRT_KM_S_BADSECRET     = 4 // Stream encrypted and wrong secret is used, cannot decrypt Keying Material
+#ifdef ENABLE_AEAD_API_PREVIEW
+    ,SRT_KM_S_BADCRYPTOMODE = 5  // Stream encrypted but wrong cryptographic mode is used, cannot decrypt. Since v1.5.2.
+#endif
 };
 
 enum SRT_EPOLL_OPT
@@ -754,77 +753,6 @@ SRT_API       int srt_cleanup(void);
 SRT_ATR_DEPRECATED_PX SRT_API SRTSOCKET srt_socket(int, int, int) SRT_ATR_DEPRECATED;
 SRT_API       SRTSOCKET srt_create_socket(void);
 
-// Group management
-
-// Stubs when off
-
-typedef struct SRT_SocketGroupData_ SRT_SOCKGROUPDATA;
-
-#if ENABLE_EXPERIMENTAL_BONDING
-
-typedef enum SRT_GROUP_TYPE
-{
-    SRT_GTYPE_UNDEFINED,
-    SRT_GTYPE_BROADCAST,
-    SRT_GTYPE_BACKUP,
-    SRT_GTYPE_BALANCING,
-    SRT_GTYPE_MULTICAST,
-    // ...
-    SRT_GTYPE_E_END
-} SRT_GROUP_TYPE;
-
-// Free-form flags for groups
-// Flags may be type-specific!
-static const uint32_t SRT_GFLAG_SYNCONMSG = 1;
-
-typedef enum SRT_MemberStatus
-{
-    SRT_GST_PENDING,  // The socket is created correctly, but not yet ready for getting data.
-    SRT_GST_IDLE,     // The socket is ready to be activated
-    SRT_GST_RUNNING,  // The socket was already activated and is in use
-    SRT_GST_BROKEN    // The last operation broke the socket, it should be closed.
-} SRT_MEMBERSTATUS;
-
-struct SRT_SocketGroupData_
-{
-    SRTSOCKET id;
-    struct sockaddr_storage peeraddr; // Don't want to expose sockaddr_any to public API
-    SRT_SOCKSTATUS sockstate;
-    uint16_t weight;
-    SRT_MEMBERSTATUS memberstate;
-    int result;
-    int token;
-};
-
-typedef struct SRT_SocketOptionObject SRT_SOCKOPT_CONFIG;
-
-typedef struct SRT_GroupMemberConfig_
-{
-    SRTSOCKET id;
-    struct sockaddr_storage srcaddr;
-    struct sockaddr_storage peeraddr; // Don't want to expose sockaddr_any to public API
-    uint16_t weight;
-    SRT_SOCKOPT_CONFIG* config;
-    int errorcode;
-    int token;
-} SRT_SOCKGROUPCONFIG;
-
-SRT_API SRTSOCKET srt_create_group (SRT_GROUP_TYPE);
-SRT_API       int srt_include      (SRTSOCKET socket, SRTSOCKET group);
-SRT_API       int srt_exclude      (SRTSOCKET socket);
-SRT_API SRTSOCKET srt_groupof      (SRTSOCKET socket);
-SRT_API       int srt_group_data   (SRTSOCKET socketgroup, SRT_SOCKGROUPDATA* output, size_t* inoutlen);
-SRT_API       int srt_group_configure(SRTSOCKET socketgroup, const char* str);
-
-SRT_API SRT_SOCKOPT_CONFIG* srt_create_config(void);
-SRT_API void srt_delete_config(SRT_SOCKOPT_CONFIG* config /*nullable*/);
-SRT_API int srt_config_add(SRT_SOCKOPT_CONFIG* config, SRT_SOCKOPT option, const void* contents, int len);
-
-SRT_API SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src /*nullable*/, const struct sockaddr* adr, int namelen);
-SRT_API       int srt_connect_group(SRTSOCKET group, SRT_SOCKGROUPCONFIG name [], int arraysize);
-
-#endif // ENABLE_EXPERIMENTAL_BONDING
-
 SRT_API       int srt_bind         (SRTSOCKET u, const struct sockaddr* name, int namelen);
 SRT_API       int srt_bind_acquire (SRTSOCKET u, UDPSOCKET sys_udp_sock);
 // Old name of srt_bind_acquire(), please don't use
@@ -853,10 +781,12 @@ SRT_API       int srt_setsockopt   (SRTSOCKET u, int level /*ignored*/, SRT_SOCK
 SRT_API       int srt_getsockflag  (SRTSOCKET u, SRT_SOCKOPT opt, void* optval, int* optlen);
 SRT_API       int srt_setsockflag  (SRTSOCKET u, SRT_SOCKOPT opt, const void* optval, int optlen);
 
+typedef struct SRT_SocketGroupData_ SRT_SOCKGROUPDATA;
+
 typedef struct SRT_MsgCtrl_
 {
    int flags;            // Left for future
-   int msgttl;           // TTL for a message, default -1 (no TTL limitation)
+   int msgttl;           // TTL for a message (millisec), default -1 (no TTL limitation)
    int inorder;          // Whether a message is allowed to supersede partially lost one. Unused in stream and live mode.
    int boundary;         // 0:mid pkt, 1(01b):end of frame, 2(11b):complete frame, 3(10b): start of frame
    int64_t srctime;      // source time since epoch (usec), 0: use internal time (sender)
@@ -954,7 +884,7 @@ typedef struct SRT_EPOLL_EVENT_STR
     int       events; // SRT_EPOLL_IN | SRT_EPOLL_OUT | SRT_EPOLL_ERR
 #ifdef __cplusplus
     SRT_EPOLL_EVENT_STR(SRTSOCKET s, int ev): fd(s), events(ev) {}
-    SRT_EPOLL_EVENT_STR() {} // NOTE: allows singular values, no init.
+    SRT_EPOLL_EVENT_STR(): fd(-1), events(0) {} // NOTE: allows singular values, no init.
 #endif
 } SRT_EPOLL_EVENT;
 SRT_API int srt_epoll_uwait(int eid, SRT_EPOLL_EVENT* fdsSet, int fdsSize, int64_t msTimeOut);
@@ -979,8 +909,10 @@ SRT_API int srt_getsndbuffer(SRTSOCKET sock, size_t* blocks, size_t* bytes);
 
 SRT_API int srt_getrejectreason(SRTSOCKET sock);
 SRT_API int srt_setrejectreason(SRTSOCKET sock, int value);
-SRT_API extern const char* const srt_rejectreason_msg [];
-const char* srt_rejectreason_str(int id);
+// The srt_rejectreason_msg[] array is deprecated (as unsafe).
+// Planned removal: v1.6.0.
+SRT_API SRT_ATR_DEPRECATED extern const char* const srt_rejectreason_msg [];
+SRT_API const char* srt_rejectreason_str(int id);
 
 SRT_API uint32_t srt_getversion(void);
 
@@ -988,6 +920,76 @@ SRT_API int64_t srt_time_now(void);
 
 SRT_API int64_t srt_connection_time(SRTSOCKET sock);
 
+// Possible internal clock types
+#define SRT_SYNC_CLOCK_STDCXX_STEADY      0 // C++11 std::chrono::steady_clock
+#define SRT_SYNC_CLOCK_GETTIME_MONOTONIC  1 // clock_gettime with CLOCK_MONOTONIC
+#define SRT_SYNC_CLOCK_WINQPC             2
+#define SRT_SYNC_CLOCK_MACH_ABSTIME       3
+#define SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY 4
+#define SRT_SYNC_CLOCK_AMD64_RDTSC        5
+#define SRT_SYNC_CLOCK_IA32_RDTSC         6
+#define SRT_SYNC_CLOCK_IA64_ITC           7
+
+SRT_API int srt_clock_type(void);
+
+// SRT Socket Groups API (ENABLE_BONDING)
+
+typedef enum SRT_GROUP_TYPE
+{
+    SRT_GTYPE_UNDEFINED,
+    SRT_GTYPE_BROADCAST,
+    SRT_GTYPE_BACKUP,
+    // ...
+    SRT_GTYPE_E_END
+} SRT_GROUP_TYPE;
+
+// Free-form flags for groups
+// Flags may be type-specific!
+static const uint32_t SRT_GFLAG_SYNCONMSG = 1;
+
+typedef enum SRT_MemberStatus
+{
+    SRT_GST_PENDING,  // The socket is created correctly, but not yet ready for getting data.
+    SRT_GST_IDLE,     // The socket is ready to be activated
+    SRT_GST_RUNNING,  // The socket was already activated and is in use
+    SRT_GST_BROKEN    // The last operation broke the socket, it should be closed.
+} SRT_MEMBERSTATUS;
+
+struct SRT_SocketGroupData_
+{
+    SRTSOCKET id;
+    struct sockaddr_storage peeraddr; // Don't want to expose sockaddr_any to public API
+    SRT_SOCKSTATUS sockstate;
+    uint16_t weight;
+    SRT_MEMBERSTATUS memberstate;
+    int result;
+    int token;
+};
+
+typedef struct SRT_SocketOptionObject SRT_SOCKOPT_CONFIG;
+
+typedef struct SRT_GroupMemberConfig_
+{
+    SRTSOCKET id;
+    struct sockaddr_storage srcaddr;
+    struct sockaddr_storage peeraddr; // Don't want to expose sockaddr_any to public API
+    uint16_t weight;
+    SRT_SOCKOPT_CONFIG* config;
+    int errorcode;
+    int token;
+} SRT_SOCKGROUPCONFIG;
+
+SRT_API SRTSOCKET srt_create_group(SRT_GROUP_TYPE);
+SRT_API SRTSOCKET srt_groupof(SRTSOCKET socket);
+SRT_API       int srt_group_data(SRTSOCKET socketgroup, SRT_SOCKGROUPDATA* output, size_t* inoutlen);
+
+SRT_API SRT_SOCKOPT_CONFIG* srt_create_config(void);
+SRT_API void srt_delete_config(SRT_SOCKOPT_CONFIG* config /*nullable*/);
+SRT_API int srt_config_add(SRT_SOCKOPT_CONFIG* config, SRT_SOCKOPT option, const void* contents, int len);
+
+SRT_API SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src /*nullable*/, const struct sockaddr* adr, int namelen);
+SRT_API       int srt_connect_group(SRTSOCKET group, SRT_SOCKGROUPCONFIG name[], int arraysize);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/srtcore/srt_attr_defs.h b/srtcore/srt_attr_defs.h
new file mode 100644
index 000000000..726c4a03b
--- /dev/null
+++ b/srtcore/srt_attr_defs.h
@@ -0,0 +1,200 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2019 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v.2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+/*****************************************************************************
+The file contains various planform and compiler dependent attribute definitions
+used by SRT library internally.
+ *****************************************************************************/
+
+#ifndef INC_SRT_ATTR_DEFS_H
+#define INC_SRT_ATTR_DEFS_H
+
+// ATTRIBUTES:
+//
+// SRT_ATR_UNUSED: declare an entity ALLOWED to be unused (prevents warnings)
+// ATR_DEPRECATED: declare an entity deprecated (compiler should warn when used)
+// ATR_NOEXCEPT: The true `noexcept` from C++11, or nothing if compiling in pre-C++11 mode
+// ATR_NOTHROW: In C++11: `noexcept`. In pre-C++11: `throw()`. Required for GNU libstdc++.
+// ATR_CONSTEXPR: In C++11: `constexpr`. Otherwise empty.
+// ATR_OVERRIDE: In C++11: `override`. Otherwise empty.
+// ATR_FINAL: In C++11: `final`. Otherwise empty.
+
+#ifdef __GNUG__
+#define ATR_DEPRECATED __attribute__((deprecated))
+#else
+#define ATR_DEPRECATED
+#endif
+
+#if HAVE_CXX11
+#define SRT_ATR_ALIGNAS(n) alignas(n)
+#elif HAVE_GCC
+#define SRT_ATR_ALIGNAS(n) __attribute__((aligned(n)))
+#else
+#define SRT_ATR_ALIGNAS(n)
+#endif
+
+#if defined(__cplusplus) && __cplusplus > 199711L
+#define HAVE_CXX11 1
+// For gcc 4.7, claim C++11 is supported, as long as experimental C++0x is on,
+// however it's only the "most required C++11 support".
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ == 4 && __GNUC_MINOR__ >= 7 // 4.7 only!
+#define ATR_NOEXCEPT
+#define ATR_NOTHROW throw()
+#define ATR_CONSTEXPR
+#define ATR_OVERRIDE
+#define ATR_FINAL
+#else
+#define HAVE_FULL_CXX11 1
+#define ATR_NOEXCEPT noexcept
+#define ATR_NOTHROW noexcept
+#define ATR_CONSTEXPR constexpr
+#define ATR_OVERRIDE override
+#define ATR_FINAL final
+#endif
+#elif defined(_MSC_VER) && _MSC_VER >= 1800
+// Microsoft Visual Studio supports C++11, but not fully,
+// and still did not change the value of __cplusplus. Treat
+// this special way.
+// _MSC_VER == 1800  means Microsoft Visual Studio 2013.
+#define HAVE_CXX11 1
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
+#define HAVE_FULL_CXX11 1
+#define ATR_NOEXCEPT noexcept
+#define ATR_NOTHROW noexcept
+#define ATR_CONSTEXPR constexpr
+#define ATR_OVERRIDE override
+#define ATR_FINAL final
+#else
+#define ATR_NOEXCEPT
+#define ATR_NOTHROW throw()
+#define ATR_CONSTEXPR
+#define ATR_OVERRIDE
+#define ATR_FINAL
+#endif
+#else
+#define HAVE_CXX11 0
+#define ATR_NOEXCEPT
+#define ATR_NOTHROW throw()
+#define ATR_CONSTEXPR
+#define ATR_OVERRIDE
+#define ATR_FINAL
+#endif // __cplusplus
+
+#if !HAVE_CXX11 && defined(REQUIRE_CXX11) && REQUIRE_CXX11 == 1
+#error "The currently compiled application required C++11, but your compiler doesn't support it."
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Attributes for thread safety analysis
+// - Clang TSA (https://clang.llvm.org/docs/ThreadSafetyAnalysis.html#mutexheader).
+// - MSVC SAL (partially).
+// - Other compilers: none.
+///////////////////////////////////////////////////////////////////////////////
+#if _MSC_VER >= 1920
+// In case of MSVC these attributes have to precede the attributed objects (variable, function).
+// E.g. SRT_ATTR_GUARDED_BY(mtx) int object;
+// It is tricky to annotate e.g. the following function, as clang complaints it does not know 'm'.
+// SRT_ATTR_EXCLUDES(m) SRT_ATTR_ACQUIRE(m)
+// inline void enterCS(Mutex& m) { m.lock(); }
+#define SRT_ATTR_CAPABILITY(expr)
+#define SRT_ATTR_SCOPED_CAPABILITY
+#define SRT_ATTR_GUARDED_BY(expr) _Guarded_by_(expr)
+#define SRT_ATTR_PT_GUARDED_BY(expr)
+#define SRT_ATTR_ACQUIRED_BEFORE(...)
+#define SRT_ATTR_ACQUIRED_AFTER(...)
+#define SRT_ATTR_REQUIRES(expr) _Requires_lock_held_(expr)
+#define SRT_ATTR_REQUIRES2(expr1, expr2) _Requires_lock_held_(expr1) _Requires_lock_held_(expr2)
+#define SRT_ATTR_REQUIRES_SHARED(...)
+#define SRT_ATTR_ACQUIRE(expr) _Acquires_nonreentrant_lock_(expr)
+#define SRT_ATTR_ACQUIRE_SHARED(...)
+#define SRT_ATTR_RELEASE(expr) _Releases_lock_(expr)
+#define SRT_ATTR_RELEASE_SHARED(...)
+#define SRT_ATTR_RELEASE_GENERIC(...)
+#define SRT_ATTR_TRY_ACQUIRE(...) _Acquires_nonreentrant_lock_(expr)
+#define SRT_ATTR_TRY_ACQUIRE_SHARED(...)
+#define SRT_ATTR_EXCLUDES(...) // the caller must not hold the given capabilities
+#define SRT_ATTR_ASSERT_CAPABILITY(expr)
+#define SRT_ATTR_ASSERT_SHARED_CAPABILITY(x)
+#define SRT_ATTR_RETURN_CAPABILITY(x)
+#define SRT_ATTR_NO_THREAD_SAFETY_ANALYSIS
+#else
+
+#if defined(__clang__) && defined(__clang_major__) && (__clang_major__ > 5)
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+#define SRT_ATTR_CAPABILITY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
+
+#define SRT_ATTR_SCOPED_CAPABILITY \
+  THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define SRT_ATTR_GUARDED_BY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+#define SRT_ATTR_PT_GUARDED_BY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define SRT_ATTR_ACQUIRED_BEFORE(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define SRT_ATTR_ACQUIRED_AFTER(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define SRT_ATTR_REQUIRES(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
+
+#define SRT_ATTR_REQUIRES2(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
+
+#define SRT_ATTR_REQUIRES_SHARED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
+
+#define SRT_ATTR_ACQUIRE(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
+
+#define SRT_ATTR_ACQUIRE_SHARED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
+
+#define SRT_ATTR_RELEASE(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
+
+#define SRT_ATTR_RELEASE_SHARED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
+
+#define SRT_ATTR_RELEASE_GENERIC(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(release_generic_capability(__VA_ARGS__))
+
+#define SRT_ATTR_TRY_ACQUIRE(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
+
+#define SRT_ATTR_TRY_ACQUIRE_SHARED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
+
+// The caller must not hold the given capabilities.
+#define SRT_ATTR_EXCLUDES(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define SRT_ATTR_ASSERT_CAPABILITY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
+
+#define SRT_ATTR_ASSERT_SHARED_CAPABILITY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
+
+#define SRT_ATTR_RETURN_CAPABILITY(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define SRT_ATTR_NO_THREAD_SAFETY_ANALYSIS \
+  THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+#endif // not _MSC_VER
+
+#endif // INC_SRT_ATTR_DEFS_H
diff --git a/srtcore/srt_c_api.cpp b/srtcore/srt_c_api.cpp
index 1763198ed..031030cd7 100644
--- a/srtcore/srt_c_api.cpp
+++ b/srtcore/srt_c_api.cpp
@@ -24,6 +24,7 @@ written by
 #include "utilities.h"
 
 using namespace std;
+using namespace srt;
 
 
 extern "C" {
@@ -35,31 +36,20 @@ int srt_cleanup() { return CUDT::cleanup(); }
 SRTSOCKET srt_socket(int , int , int ) { return CUDT::socket(); }
 SRTSOCKET srt_create_socket() { return CUDT::socket(); }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 // Group management.
 SRTSOCKET srt_create_group(SRT_GROUP_TYPE gt) { return CUDT::createGroup(gt); }
-int srt_include(SRTSOCKET socket, SRTSOCKET group) { return CUDT::addSocketToGroup(socket, group); }
-int srt_exclude(SRTSOCKET socket) { return CUDT::removeSocketFromGroup(socket); }
 SRTSOCKET srt_groupof(SRTSOCKET socket) { return CUDT::getGroupOfSocket(socket); }
 int srt_group_data(SRTSOCKET socketgroup, SRT_SOCKGROUPDATA* output, size_t* inoutlen)
 {
     return CUDT::getGroupData(socketgroup, output, inoutlen);
 }
-int srt_group_configure(SRTSOCKET socketgroup, const char* str)
-{
-    return CUDT::configureGroup(socketgroup, str);
-}
 
 SRT_SOCKOPT_CONFIG* srt_create_config()
 {
     return new SRT_SocketOptionObject;
 }
 
-void srt_delete_config(SRT_SOCKOPT_CONFIG* in)
-{
-    delete in;
-}
-
 int srt_config_add(SRT_SOCKOPT_CONFIG* config, SRT_SOCKOPT option, const void* contents, int len)
 {
     if (!config)
@@ -70,30 +60,33 @@ int srt_config_add(SRT_SOCKOPT_CONFIG* config, SRT_SOCKOPT option, const void* c
 
     return 0;
 }
-#endif
 
-// int srt_bind_multicast()
-
-// Binding and connection management
-int srt_bind(SRTSOCKET u, const struct sockaddr * name, int namelen) { return CUDT::bind(u, name, namelen); }
-int srt_bind_acquire(SRTSOCKET u, UDPSOCKET udpsock) { return CUDT::bind(u, udpsock); }
-int srt_listen(SRTSOCKET u, int backlog) { return CUDT::listen(u, backlog); }
-SRTSOCKET srt_accept(SRTSOCKET u, struct sockaddr * addr, int * addrlen) { return CUDT::accept(u, addr, addrlen); }
-SRTSOCKET srt_accept_bond(const SRTSOCKET lsns[], int lsize, int64_t msTimeOut) { return CUDT::accept_bond(lsns, lsize, msTimeOut); }
-int srt_connect(SRTSOCKET u, const struct sockaddr * name, int namelen) { return CUDT::connect(u, name, namelen, SRT_SEQNO_NONE); }
-int srt_connect_debug(SRTSOCKET u, const struct sockaddr * name, int namelen, int forced_isn) { return CUDT::connect(u, name, namelen, forced_isn); }
-int srt_connect_bind(SRTSOCKET u,
-        const struct sockaddr* source,
-        const struct sockaddr* target, int target_len)
+int srt_connect_group(SRTSOCKET group,
+    SRT_SOCKGROUPCONFIG name[], int arraysize)
 {
-    return CUDT::connect(u, source, target, target_len);
+    return CUDT::connectLinks(group, name, arraysize);
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
-SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src, const struct sockaddr* adr, int namelen)
+#else
+
+SRTSOCKET srt_create_group(SRT_GROUP_TYPE) { return SRT_INVALID_SOCK; }
+SRTSOCKET srt_groupof(SRTSOCKET) { return SRT_INVALID_SOCK; }
+int srt_group_data(SRTSOCKET, SRT_SOCKGROUPDATA*, size_t*) { return srt::CUDT::APIError(MJ_NOTSUP, MN_INVAL, 0); }
+SRT_SOCKOPT_CONFIG* srt_create_config() { return NULL; }
+int srt_config_add(SRT_SOCKOPT_CONFIG*, SRT_SOCKOPT, const void*, int) { return srt::CUDT::APIError(MJ_NOTSUP, MN_INVAL, 0); }
+
+int srt_connect_group(SRTSOCKET, SRT_SOCKGROUPCONFIG[], int) { return srt::CUDT::APIError(MJ_NOTSUP, MN_INVAL, 0); }
+
+#endif
+
+SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src, const struct sockaddr* dst, int namelen)
 {
     SRT_SOCKGROUPCONFIG data;
+#if ENABLE_BONDING
     data.errorcode = SRT_SUCCESS;
+#else
+    data.errorcode = SRT_EINVOP;
+#endif
     data.id = -1;
     data.token = -1;
     data.weight = 0;
@@ -104,18 +97,31 @@ SRT_SOCKGROUPCONFIG srt_prepare_endpoint(const struct sockaddr* src, const struc
     {
         memset(&data.srcaddr, 0, sizeof data.srcaddr);
         // Still set the family according to the target address
-        data.srcaddr.ss_family = adr->sa_family;
+        data.srcaddr.ss_family = dst->sa_family;
     }
-    memcpy(&data.peeraddr, adr, namelen);
+    memcpy(&data.peeraddr, dst, namelen);
     return data;
 }
 
-int srt_connect_group(SRTSOCKET group,
-        SRT_SOCKGROUPCONFIG name [], int arraysize)
+void srt_delete_config(SRT_SOCKOPT_CONFIG* in)
 {
-    return CUDT::connectLinks(group, name, arraysize);
+    delete in;
+}
+
+// Binding and connection management
+int srt_bind(SRTSOCKET u, const struct sockaddr * name, int namelen) { return CUDT::bind(u, name, namelen); }
+int srt_bind_acquire(SRTSOCKET u, UDPSOCKET udpsock) { return CUDT::bind(u, udpsock); }
+int srt_listen(SRTSOCKET u, int backlog) { return CUDT::listen(u, backlog); }
+SRTSOCKET srt_accept(SRTSOCKET u, struct sockaddr * addr, int * addrlen) { return CUDT::accept(u, addr, addrlen); }
+SRTSOCKET srt_accept_bond(const SRTSOCKET lsns[], int lsize, int64_t msTimeOut) { return CUDT::accept_bond(lsns, lsize, msTimeOut); }
+int srt_connect(SRTSOCKET u, const struct sockaddr * name, int namelen) { return CUDT::connect(u, name, namelen, SRT_SEQNO_NONE); }
+int srt_connect_debug(SRTSOCKET u, const struct sockaddr * name, int namelen, int forced_isn) { return CUDT::connect(u, name, namelen, forced_isn); }
+int srt_connect_bind(SRTSOCKET u,
+        const struct sockaddr* source,
+        const struct sockaddr* target, int target_len)
+{
+    return CUDT::connect(u, source, target, target_len);
 }
-#endif
 
 int srt_rendezvous(SRTSOCKET u, const struct sockaddr* local_name, int local_namelen,
         const struct sockaddr* remote_name, int remote_namelen)
@@ -244,8 +250,8 @@ int srt_getlasterror(int* loc_errno)
 
 const char* srt_strerror(int code, int err)
 {
-    static CUDTException e;
-    e = CUDTException(CodeMajor(code/1000), CodeMinor(code%1000), err);
+    static srt::CUDTException e;
+    e = srt::CUDTException(CodeMajor(code/1000), CodeMinor(code%1000), err);
     return(e.getErrorMessage());
 }
 
@@ -381,17 +387,11 @@ int srt_setrejectreason(SRTSOCKET sock, int value)
 
 int srt_listen_callback(SRTSOCKET lsn, srt_listen_callback_fn* hook, void* opaq)
 {
-    if (!hook)
-        return CUDT::APIError(MJ_NOTSUP, MN_INVAL);
-
     return CUDT::installAcceptHook(lsn, hook, opaq);
 }
 
 int srt_connect_callback(SRTSOCKET lsn, srt_connect_callback_fn* hook, void* opaq)
 {
-    if (!hook)
-        return CUDT::APIError(MJ_NOTSUP, MN_INVAL);
-
     return CUDT::installConnectHook(lsn, hook, opaq);
 }
 
@@ -410,4 +410,69 @@ int64_t srt_connection_time(SRTSOCKET sock)
     return CUDT::socketStartTime(sock);
 }
 
+int srt_clock_type()
+{
+    return SRT_SYNC_CLOCK;
+}
+
+const char* const srt_rejection_reason_msg [] = {
+    "Unknown or erroneous",
+    "Error in system calls",
+    "Peer rejected connection",
+    "Resource allocation failure",
+    "Rogue peer or incorrect parameters",
+    "Listener's backlog exceeded",
+    "Internal Program Error",
+    "Socket is being closed",
+    "Peer version too old",
+    "Rendezvous-mode cookie collision",
+    "Incorrect passphrase",
+    "Password required or unexpected",
+    "MessageAPI/StreamAPI collision",
+    "Congestion controller type collision",
+    "Packet Filter settings error",
+    "Group settings collision",
+    "Connection timeout"
+#ifdef ENABLE_AEAD_API_PREVIEW
+    ,"Crypto mode"
+#endif
+};
+
+// Deprecated, available in SRT API.
+extern const char* const srt_rejectreason_msg[] = {
+    srt_rejection_reason_msg[0],
+    srt_rejection_reason_msg[1],
+    srt_rejection_reason_msg[2],
+    srt_rejection_reason_msg[3],
+    srt_rejection_reason_msg[4],
+    srt_rejection_reason_msg[5],
+    srt_rejection_reason_msg[6],
+    srt_rejection_reason_msg[7],
+    srt_rejection_reason_msg[8],
+    srt_rejection_reason_msg[9],
+    srt_rejection_reason_msg[10],
+    srt_rejection_reason_msg[11],
+    srt_rejection_reason_msg[12],
+    srt_rejection_reason_msg[13],
+    srt_rejection_reason_msg[14],
+    srt_rejection_reason_msg[15],
+    srt_rejection_reason_msg[16]
+#ifdef ENABLE_AEAD_API_PREVIEW
+    , srt_rejection_reason_msg[17]
+#endif
+};
+
+const char* srt_rejectreason_str(int id)
+{
+    if (id >= SRT_REJC_PREDEFINED)
+    {
+        return "Application-defined rejection reason";
+    }
+
+    static const size_t ra_size = Size(srt_rejection_reason_msg);
+    if (size_t(id) >= ra_size)
+        return srt_rejection_reason_msg[0];
+    return srt_rejection_reason_msg[id];
+}
+
 }
diff --git a/srtcore/srt_compat.c b/srtcore/srt_compat.c
index 32c8dd6fb..bbdf7f795 100644
--- a/srtcore/srt_compat.c
+++ b/srtcore/srt_compat.c
@@ -17,13 +17,12 @@ written by
 // Prevents from misconfiguration through preprocessor.
 
 #include "platform_sys.h"
-
 #include <srt_compat.h>
 
 #include <string.h>
 #include <stdio.h>
 #include <errno.h>
-#if defined(__unix__) && !defined(BSD)
+#if defined(__unix__) && !defined(BSD) && !defined(SUNOS)
 #include <features.h>
 #endif
 
@@ -70,7 +69,7 @@ extern const char * SysStrError(int errnum, char * buf, size_t buflen)
     // your compilation fails when you use wide characters.
     // The problem is that when TCHAR != char, then the buffer written this way
     // would have to be converted to ASCII, not just copied by strncpy.
-    FormatMessage(0
+    FormatMessageA(0
             | FORMAT_MESSAGE_ALLOCATE_BUFFER
             | FORMAT_MESSAGE_FROM_SYSTEM
             | FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -87,8 +86,12 @@ extern const char * SysStrError(int errnum, char * buf, size_t buflen)
 
     if (lpMsgBuf)
     {
+#ifdef _MSC_VER
+        strncpy_s(buf, buflen, lpMsgBuf, _TRUNCATE);
+#else
         strncpy(buf, lpMsgBuf, buflen-1);
         buf[buflen-1] = 0;
+#endif
         LocalFree((HLOCAL)lpMsgBuf);
     }
     else
diff --git a/srtcore/srt_compat.h b/srtcore/srt_compat.h
index f7d072393..d4fd2361e 100644
--- a/srtcore/srt_compat.h
+++ b/srtcore/srt_compat.h
@@ -20,55 +20,12 @@ written by
 #include <stddef.h>
 #include <time.h>
 
-#ifndef SRT_API
-#ifdef _WIN32
-   #ifndef __MINGW__
-      #ifdef SRT_DYNAMIC
-         #ifdef SRT_EXPORTS
-            #define SRT_API __declspec(dllexport)
-         #else
-            #define SRT_API __declspec(dllimport)
-         #endif
-      #else
-         #define SRT_API
-      #endif
-   #else
-      #define SRT_API
-   #endif
-#else
-   #define SRT_API __attribute__ ((visibility("default")))
-#endif
-#endif
-
-#ifdef _WIN32
-   // https://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx
-   // printf() Format for ssize_t
-   #if !defined(PRIzd)
-      #define PRIzd "Id"
-   #endif
-   // printf() Format for size_t
-   #if !defined(PRIzu)
-      #define PRIzu "Iu"
-   #endif
-#else
-   // http://www.gnu.org/software/libc/manual/html_node/Integer-Conversions.html
-   // printf() Format for ssize_t
-   #if !defined(PRIzd)
-      #define PRIzd "zd"
-   #endif
-   // printf() Format for size_t
-   #if !defined(PRIzu)
-      #define PRIzu "zu"
-   #endif
-#endif
-
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* Ensures that we store the error in the buffer and return the bufer. */
-SRT_API const char * SysStrError(int errnum, char * buf, size_t buflen);
+const char * SysStrError(int errnum, char * buf, size_t buflen);
 
 #ifdef __cplusplus
 } // extern C
diff --git a/srtcore/stats.h b/srtcore/stats.h
new file mode 100644
index 000000000..947489eb1
--- /dev/null
+++ b/srtcore/stats.h
@@ -0,0 +1,228 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+#ifndef INC_SRT_STATS_H
+#define INC_SRT_STATS_H
+
+#include "platform_sys.h"
+#include "packet.h"
+
+namespace srt
+{
+namespace stats
+{
+
+class Packets
+{
+public:
+    Packets() : m_count(0) {}
+
+    Packets(uint32_t num) : m_count(num) {}
+
+    void reset()
+    {
+        m_count = 0;
+    }
+
+    Packets& operator+= (const Packets& other)
+    {
+        m_count   += other.m_count;
+        return *this;
+    }
+
+    uint32_t count() const 
+    {
+        return m_count;
+    }
+
+private:
+    uint32_t m_count;
+};
+
+class BytesPackets
+{
+public:
+    BytesPackets()
+        : m_bytes(0)
+        , m_packets(0)
+    {}
+
+    BytesPackets(uint64_t bytes, uint32_t n = 1)
+        : m_bytes(bytes)
+        , m_packets(n)
+    {}
+
+
+    void reset()
+    {
+        m_packets = 0;
+        m_bytes = 0;
+    }
+
+    void count(uint64_t bytes, size_t n = 1)
+    {
+        m_packets += (uint32_t) n;
+        m_bytes += bytes;
+    }
+
+    uint64_t bytes() const 
+    {
+        return m_bytes;
+    }
+
+    uint32_t count() const 
+    {
+        return m_packets;
+    }
+
+    BytesPackets& operator+= (const BytesPackets& other)
+    {
+        m_bytes   += other.m_bytes;
+        m_packets += other.m_packets;
+        return *this;
+    }
+
+    uint64_t bytesWithHdr(size_t hdr_size) const
+    {
+        return m_bytes + m_packets * hdr_size;
+    }
+
+protected:
+    uint64_t m_bytes;
+    uint32_t m_packets;
+};
+
+
+template <class METRIC_TYPE, class BASE_METRIC_TYPE = METRIC_TYPE>
+struct Metric
+{
+    METRIC_TYPE trace;
+    METRIC_TYPE total;
+
+    void count(BASE_METRIC_TYPE val)
+    {
+        trace += val;
+        total += val;
+    }
+
+    void setupHeaderSize(int loc)
+    {
+        trace.setupHeaderSize(loc);
+        total.setupHeaderSize(loc);
+    }
+
+    void reset()
+    {
+        trace.reset();
+        total.reset();
+    }
+
+    void resetTrace()
+    {
+        trace.reset();
+    }
+};
+
+/// Sender-side statistics.
+struct Sender
+{
+    Metric<BytesPackets> sent;
+    Metric<BytesPackets> sentUnique;
+    Metric<BytesPackets> sentRetrans; // The number of data packets retransmitted by the sender.
+    Metric<Packets> lost; // The number of packets reported lost (including repeated reports) to the sender in NAKs.
+    Metric<BytesPackets> dropped; // The number of data packets dropped by the sender.
+
+    Metric<Packets> sentFilterExtra; // The number of packets generate by the packet filter and sent by the sender.
+    
+    Metric<Packets> recvdAck; // The number of ACK packets received by the sender.
+    Metric<Packets> recvdNak; // The number of ACK packets received by the sender.
+
+    void reset()
+    {
+        sent.reset();
+        sentUnique.reset();
+        sentRetrans.reset();
+        lost.reset();
+        dropped.reset();
+        recvdAck.reset();
+        recvdNak.reset();
+        sentFilterExtra.reset();
+    }
+
+    void resetTrace()
+    {
+        sent.resetTrace();
+        sentUnique.resetTrace();
+        sentRetrans.resetTrace();
+        lost.resetTrace();
+        dropped.resetTrace();
+        recvdAck.resetTrace();
+        recvdNak.resetTrace();
+        sentFilterExtra.resetTrace();
+    }
+};
+
+/// Receiver-side statistics.
+struct Receiver
+{
+    Metric<BytesPackets> recvd;
+    Metric<BytesPackets> recvdUnique;
+    Metric<BytesPackets> recvdRetrans; // The number of retransmitted data packets received by the receiver.
+    Metric<BytesPackets> lost; // The number of packets detected by the receiver as lost.
+    Metric<BytesPackets> dropped; // The number of packets dropped by the receiver (as too-late to be delivered).
+    Metric<BytesPackets> recvdBelated; // The number of belated packets received (dropped as too late but eventually received).
+    Metric<BytesPackets> undecrypted; // The number of packets received by the receiver that failed to be decrypted.
+
+    Metric<Packets> recvdFilterExtra; // The number of filter packets (e.g. FEC) received by the receiver.
+    Metric<Packets> suppliedByFilter; // The number of lost packets got from the packet filter at the receiver side (e.g. loss recovered by FEC).
+    Metric<Packets> lossFilter; // The number of lost DATA packets not recovered by the packet filter at the receiver side.
+
+    Metric<Packets> sentAck; // The number of ACK packets sent by the receiver.
+    Metric<Packets> sentNak; // The number of NACK packets sent by the receiver.
+
+    void reset()
+    {
+        recvd.reset();
+        recvdUnique.reset();
+        recvdRetrans.reset();
+        lost.reset();
+        dropped.reset();
+        recvdBelated.reset();
+        undecrypted.reset();
+        recvdFilterExtra.reset();
+        suppliedByFilter.reset();
+        lossFilter.reset();
+        sentAck.reset();
+        sentNak.reset();
+    }
+
+    void resetTrace()
+    {
+        recvd.resetTrace();
+        recvdUnique.resetTrace();
+        recvdRetrans.resetTrace();
+        lost.resetTrace();
+        dropped.resetTrace();
+        recvdBelated.resetTrace();
+        undecrypted.resetTrace();
+        recvdFilterExtra.resetTrace();
+        suppliedByFilter.resetTrace();
+        lossFilter.resetTrace();
+        sentAck.resetTrace();
+        sentNak.resetTrace();
+    }
+};
+
+} // namespace stats
+} // namespace srt
+
+#endif // INC_SRT_STATS_H
+
+
diff --git a/srtcore/strerror_defs.cpp b/srtcore/strerror_defs.cpp
new file mode 100644
index 000000000..e99c8e277
--- /dev/null
+++ b/srtcore/strerror_defs.cpp
@@ -0,0 +1,154 @@
+
+ /*
+  WARNING: Generated from ../scripts/generate-error-types.tcl
+
+  DO NOT MODIFY.
+
+  Copyright applies as per the generator script.
+ */
+
+#include <cstddef>
+
+
+namespace srt
+{
+// MJ_SUCCESS 'Success'
+
+const char* strerror_msgs_success [] = {
+    "Success", // MN_NONE = 0
+    ""
+};
+
+// MJ_SETUP 'Connection setup failure'
+
+const char* strerror_msgs_setup [] = {
+    "Connection setup failure", // MN_NONE = 0
+    "Connection setup failure: connection timed out", // MN_TIMEOUT = 1
+    "Connection setup failure: connection rejected", // MN_REJECTED = 2
+    "Connection setup failure: unable to create/configure SRT socket", // MN_NORES = 3
+    "Connection setup failure: aborted for security reasons", // MN_SECURITY = 4
+    "Connection setup failure: socket closed during operation", // MN_CLOSED = 5
+    ""
+};
+
+// MJ_CONNECTION ''
+
+const char* strerror_msgs_connection [] = {
+    "", // MN_NONE = 0
+    "Connection was broken", // MN_CONNLOST = 1
+    "Connection does not exist", // MN_NOCONN = 2
+    ""
+};
+
+// MJ_SYSTEMRES 'System resource failure'
+
+const char* strerror_msgs_systemres [] = {
+    "System resource failure", // MN_NONE = 0
+    "System resource failure: unable to create new threads", // MN_THREAD = 1
+    "System resource failure: unable to allocate buffers", // MN_MEMORY = 2
+    "System resource failure: unable to allocate a system object", // MN_OBJECT = 3
+    ""
+};
+
+// MJ_FILESYSTEM 'File system failure'
+
+const char* strerror_msgs_filesystem [] = {
+    "File system failure", // MN_NONE = 0
+    "File system failure: cannot seek read position", // MN_SEEKGFAIL = 1
+    "File system failure: failure in read", // MN_READFAIL = 2
+    "File system failure: cannot seek write position", // MN_SEEKPFAIL = 3
+    "File system failure: failure in write", // MN_WRITEFAIL = 4
+    ""
+};
+
+// MJ_NOTSUP 'Operation not supported'
+
+const char* strerror_msgs_notsup [] = {
+    "Operation not supported", // MN_NONE = 0
+    "Operation not supported: Cannot do this operation on a BOUND socket", // MN_ISBOUND = 1
+    "Operation not supported: Cannot do this operation on a CONNECTED socket", // MN_ISCONNECTED = 2
+    "Operation not supported: Bad parameters", // MN_INVAL = 3
+    "Operation not supported: Invalid socket ID", // MN_SIDINVAL = 4
+    "Operation not supported: Cannot do this operation on an UNBOUND socket", // MN_ISUNBOUND = 5
+    "Operation not supported: Socket is not in listening state", // MN_NOLISTEN = 6
+    "Operation not supported: Listen/accept is not supported in rendezvous connection setup", // MN_ISRENDEZVOUS = 7
+    "Operation not supported: Cannot call connect on UNBOUND socket in rendezvous connection setup", // MN_ISRENDUNBOUND = 8
+    "Operation not supported: Incorrect use of Message API (sendmsg/recvmsg)", // MN_INVALMSGAPI = 9
+    "Operation not supported: Incorrect use of Buffer API (send/recv) or File API (sendfile/recvfile)", // MN_INVALBUFFERAPI = 10
+    "Operation not supported: Another socket is already listening on the same port", // MN_BUSY = 11
+    "Operation not supported: Message is too large to send", // MN_XSIZE = 12
+    "Operation not supported: Invalid epoll ID", // MN_EIDINVAL = 13
+    "Operation not supported: All sockets removed from epoll, waiting would deadlock", // MN_EEMPTY = 14
+    "Operation not supported: Another socket is bound to that port and is not reusable for requested settings", // MN_BUSYPORT = 15
+    ""
+};
+
+// MJ_AGAIN 'Non-blocking call failure'
+
+const char* strerror_msgs_again [] = {
+    "Non-blocking call failure", // MN_NONE = 0
+    "Non-blocking call failure: no buffer available for sending", // MN_WRAVAIL = 1
+    "Non-blocking call failure: no data available for reading", // MN_RDAVAIL = 2
+    "Non-blocking call failure: transmission timed out", // MN_XMTIMEOUT = 3
+    "Non-blocking call failure: early congestion notification", // MN_CONGESTION = 4
+    ""
+};
+
+// MJ_PEERERROR 'The peer side has signaled an error'
+
+const char* strerror_msgs_peererror [] = {
+    "The peer side has signaled an error", // MN_NONE = 0
+    ""
+};
+
+
+const char** strerror_array_major [] = {
+    strerror_msgs_success, // MJ_SUCCESS = 0
+    strerror_msgs_setup, // MJ_SETUP = 1
+    strerror_msgs_connection, // MJ_CONNECTION = 2
+    strerror_msgs_systemres, // MJ_SYSTEMRES = 3
+    strerror_msgs_filesystem, // MJ_FILESYSTEM = 4
+    strerror_msgs_notsup, // MJ_NOTSUP = 5
+    strerror_msgs_again, // MJ_AGAIN = 6
+    strerror_msgs_peererror, // MJ_PEERERROR = 7
+    NULL
+};
+
+#define SRT_ARRAY_SIZE(ARR) sizeof(ARR) / sizeof(ARR[0])
+
+const size_t strerror_array_sizes [] = {
+    SRT_ARRAY_SIZE(strerror_msgs_success) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_setup) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_connection) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_systemres) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_filesystem) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_notsup) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_again) - 1,
+    SRT_ARRAY_SIZE(strerror_msgs_peererror) - 1,
+    0
+};
+
+
+const char* strerror_get_message(size_t major, size_t minor)
+{
+    static const char* const undefined = "UNDEFINED ERROR";
+
+    // Extract the major array
+    if (major >= sizeof(strerror_array_major)/sizeof(const char**))
+    {
+        return undefined;
+    }
+
+    const char** array = strerror_array_major[major];
+    const size_t size = strerror_array_sizes[major];
+
+    if (minor >= size)
+    {
+        return undefined;
+    }
+
+    return array[minor];
+}
+
+
+} // namespace srt
diff --git a/srtcore/sync.cpp b/srtcore/sync.cpp
index 8f0c7c1c8..bfe153657 100644
--- a/srtcore/sync.cpp
+++ b/srtcore/sync.cpp
@@ -18,11 +18,18 @@
 #include "logging.h"
 #include "common.h"
 
+// HAVE_CXX11 is defined in utilities.h, included with common.h. 
+// The following conditional inclusion must go after common.h.
+#if HAVE_CXX11 
+#include <random>
+#endif
+
 namespace srt_logging
 {
     extern Logger inlog;
 }
 using namespace srt_logging;
+using namespace std;
 
 namespace srt
 {
@@ -34,26 +41,22 @@ std::string FormatTime(const steady_clock::time_point& timestamp)
     if (is_zero(timestamp))
     {
         // Use special string for 0
-        return "00:00:00.000000";
+        return "00:00:00.000000 [STDY]";
     }
 
-    const uint64_t total_us  = count_microseconds(timestamp.time_since_epoch());
-    const uint64_t us        = total_us % 1000000;
-    const uint64_t total_sec = total_us / 1000000;
-
-    const uint64_t days  = total_sec / (60 * 60 * 24);
+    const int decimals = clockSubsecondPrecision();
+    const uint64_t total_sec = count_seconds(timestamp.time_since_epoch());
+    const uint64_t days = total_sec / (60 * 60 * 24);
     const uint64_t hours = total_sec / (60 * 60) - days * 24;
-
     const uint64_t minutes = total_sec / 60 - (days * 24 * 60) - hours * 60;
     const uint64_t seconds = total_sec - (days * 24 * 60 * 60) - hours * 60 * 60 - minutes * 60;
-
     ostringstream out;
     if (days)
         out << days << "D ";
-    out << setfill('0') << setw(2) << hours << ":" 
-        << setfill('0') << setw(2) << minutes << ":" 
-        << setfill('0') << setw(2) << seconds << "." 
-        << setfill('0') << setw(6) << us << " [STD]";
+    out << setfill('0') << setw(2) << hours << ":"
+        << setfill('0') << setw(2) << minutes << ":"
+        << setfill('0') << setw(2) << seconds << "."
+        << setfill('0') << setw(decimals) << (timestamp - seconds_from(total_sec)).time_since_epoch().count() << " [STDY]";
     return out.str();
 }
 
@@ -63,22 +66,22 @@ std::string FormatTimeSys(const steady_clock::time_point& timestamp)
     const steady_clock::time_point now_timestamp = steady_clock::now();
     const int64_t                  delta_us      = count_microseconds(timestamp - now_timestamp);
     const int64_t                  delta_s =
-        floor((static_cast<int64_t>(count_microseconds(now_timestamp.time_since_epoch()) % 1000000) + delta_us) / 1000000.0);
+        static_cast<int64_t>(floor((static_cast<double>(count_microseconds(now_timestamp.time_since_epoch()) % 1000000) + delta_us) / 1000000.0));
     const time_t tt = now_s + delta_s;
     struct tm    tm = SysLocalTime(tt); // in seconds
     char         tmp_buf[512];
     strftime(tmp_buf, 512, "%X.", &tm);
 
     ostringstream out;
-    out << tmp_buf << setfill('0') << setw(6) << (count_microseconds(timestamp.time_since_epoch()) % 1000000) << " [SYS]";
+    out << tmp_buf << setfill('0') << setw(6) << (count_microseconds(timestamp.time_since_epoch()) % 1000000) << " [SYST]";
     return out.str();
 }
 
 
 #ifdef ENABLE_STDCXX_SYNC
-bool StartThread(CThread& th, ThreadFunc&& f, void* args, const char* name)
+bool StartThread(CThread& th, ThreadFunc&& f, void* args, const string& name)
 #else
-bool StartThread(CThread& th, void* (*f) (void*), void* args, const char* name)
+bool StartThread(CThread& th, void* (*f) (void*), void* args, const string& name)
 #endif
 {
     ThreadName tn(name);
@@ -91,7 +94,11 @@ bool StartThread(CThread& th, void* (*f) (void*), void* args, const char* name)
         th.create_thread(f, args);
 #endif
     }
+#if ENABLE_HEAVY_LOGGING
     catch (const CThreadException& e)
+#else
+    catch (const CThreadException&)
+#endif
     {
         HLOGC(inlog.Debug, log << name << ": failed to start thread. " << e.what());
         return false;
@@ -231,7 +238,7 @@ bool srt::sync::CTimer::sleep_until(TimePoint<steady_clock> tp)
         __asm__ volatile ("nop 0; nop 0; nop 0; nop 0; nop 0;");
 #elif AMD64
         __asm__ volatile ("nop; nop; nop; nop; nop;");
-#elif defined(_WIN32) && !defined(__MINGW__)
+#elif defined(_WIN32) && !defined(__MINGW32__)
         __nop();
         __nop();
         __nop();
@@ -271,3 +278,177 @@ bool srt::sync::CGlobEvent::waitForEvent()
     return g_Sync.lock_wait_for(milliseconds_from(10));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// Random
+//
+////////////////////////////////////////////////////////////////////////////////
+
+namespace srt
+{
+#if HAVE_CXX11
+static std::mt19937& randomGen()
+{
+    static std::random_device s_RandomDevice;
+    static std::mt19937 s_GenMT19937(s_RandomDevice());
+    return s_GenMT19937;
+}
+#elif defined(_WIN32) && defined(__MINGW32__)
+static void initRandSeed()
+{
+    const int64_t seed = sync::steady_clock::now().time_since_epoch().count();
+    srand((unsigned int) seed);
+}
+static pthread_once_t s_InitRandSeedOnce = PTHREAD_ONCE_INIT;
+#else
+
+static unsigned int genRandSeed()
+{
+    // Duration::count() does not depend on any global objects,
+    // therefore it is preferred over count_microseconds(..).
+    const int64_t seed = sync::steady_clock::now().time_since_epoch().count();
+    return (unsigned int) seed;
+}
+
+static unsigned int* getRandSeed()
+{
+    static unsigned int s_uRandSeed = genRandSeed();
+    return &s_uRandSeed;
+}
+
+#endif
+}
+
+int srt::sync::genRandomInt(int minVal, int maxVal)
+{
+    // This Meyers singleton initialization is thread-safe since C++11, but is not thread-safe in C++03.
+    // A mutex to protect simultaneous access to the random device.
+    // Thread-local storage could be used here instead to store the seed / random device.
+    // However the generator is not used often (Initial Socket ID, Initial sequence number, FileCC),
+    // so sharing a single seed among threads should not impact the performance.
+    static sync::Mutex s_mtxRandomDevice;
+    sync::ScopedLock lck(s_mtxRandomDevice);
+#if HAVE_CXX11
+    uniform_int_distribution<> dis(minVal, maxVal); 
+    return dis(randomGen());
+#else
+#if defined(__MINGW32__)
+    // No rand_r(..) for MinGW.
+    pthread_once(&s_InitRandSeedOnce, initRandSeed);
+    // rand() returns a pseudo-random integer in the range 0 to RAND_MAX inclusive
+    // (i.e., the mathematical range [0, RAND_MAX]). 
+    // Therefore, rand_0_1 belongs to [0.0, 1.0].
+    const double rand_0_1 = double(rand()) / RAND_MAX;
+#else // not __MINGW32__
+    // rand_r(..) returns a pseudo-random integer in the range 0 to RAND_MAX inclusive
+    // (i.e., the mathematical range [0, RAND_MAX]). 
+    // Therefore, rand_0_1 belongs to [0.0, 1.0].
+    const double rand_0_1 = double(rand_r(getRandSeed())) / RAND_MAX;
+#endif
+
+    // Map onto [minVal, maxVal].
+    // Note. There is a minuscule probablity to get maxVal+1 as the result.
+    // So we have to use long long to handle cases when maxVal = INT32_MAX.
+    // Also we must check 'res' does not exceed maxVal,
+    // which may happen if rand_0_1 = 1, even though the chances are low.
+    const long long llMaxVal = maxVal;
+    const int res = minVal + static_cast<int>((llMaxVal + 1 - minVal) * rand_0_1);
+    return min(res, maxVal);
+#endif // HAVE_CXX11
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Shared Mutex 
+//
+////////////////////////////////////////////////////////////////////////////////
+
+srt::sync::SharedMutex::SharedMutex()
+    : m_LockWriteCond()
+    , m_LockReadCond()
+    , m_Mutex()
+    , m_iCountRead(0)
+    , m_bWriterLocked(false)
+{
+    setupCond(m_LockReadCond, "SharedMutex::m_pLockReadCond");
+    setupCond(m_LockWriteCond, "SharedMutex::m_pLockWriteCond");
+    setupMutex(m_Mutex, "SharedMutex::m_pMutex");
+}
+
+srt::sync::SharedMutex::~SharedMutex()
+{
+    releaseMutex(m_Mutex);
+    releaseCond(m_LockWriteCond);
+    releaseCond(m_LockReadCond);
+}
+
+void srt::sync::SharedMutex::lock()
+{
+    UniqueLock l1(m_Mutex);
+    while (m_bWriterLocked)
+        m_LockWriteCond.wait(l1);
+
+    m_bWriterLocked = true;
+    
+    while (m_iCountRead)
+        m_LockReadCond.wait(l1);
+}
+
+bool srt::sync::SharedMutex::try_lock()
+{
+    UniqueLock l1(m_Mutex);
+    if (m_bWriterLocked || m_iCountRead > 0)
+        return false;
+    
+    m_bWriterLocked = true;
+    return true;
+}
+
+void srt::sync::SharedMutex::unlock()
+{
+    ScopedLock lk(m_Mutex);
+    m_bWriterLocked = false;
+
+    m_LockWriteCond.notify_all();
+}
+
+void srt::sync::SharedMutex::lock_shared()
+{
+    UniqueLock lk(m_Mutex);
+    while (m_bWriterLocked)
+        m_LockWriteCond.wait(lk);
+
+    m_iCountRead++;
+}
+
+bool srt::sync::SharedMutex::try_lock_shared()
+{
+    UniqueLock lk(m_Mutex);
+    if (m_bWriterLocked)
+        return false;
+
+    m_iCountRead++;
+    return true;
+}
+
+void srt::sync::SharedMutex::unlock_shared()
+{
+    ScopedLock lk(m_Mutex);
+    
+    m_iCountRead--;
+
+    SRT_ASSERT(m_iCountRead >= 0);
+    if (m_iCountRead < 0)
+        m_iCountRead = 0;
+    
+    if (m_bWriterLocked && m_iCountRead == 0)
+        m_LockReadCond.notify_one();
+    
+}
+
+int srt::sync::SharedMutex::getReaderCount() const
+{
+    ScopedLock lk(m_Mutex);
+    return m_iCountRead;
+}
\ No newline at end of file
diff --git a/srtcore/sync.h b/srtcore/sync.h
index 6bda44fae..9d282304c 100644
--- a/srtcore/sync.h
+++ b/srtcore/sync.h
@@ -11,27 +11,59 @@
 #ifndef INC_SRT_SYNC_H
 #define INC_SRT_SYNC_H
 
-//#define ENABLE_STDCXX_SYNC
-//#define ENABLE_CXX17
+#include "platform_sys.h"
 
 #include <cstdlib>
+#include <limits>
 #ifdef ENABLE_STDCXX_SYNC
 #include <chrono>
 #include <thread>
 #include <mutex>
 #include <condition_variable>
+#include <atomic>
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_STDCXX_STEADY
+#define SRT_SYNC_CLOCK_STR "STDCXX_STEADY"
 #else
 #include <pthread.h>
+
+// Defile clock type to use
+#ifdef IA32
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_IA32_RDTSC
+#define SRT_SYNC_CLOCK_STR "IA32_RDTSC"
+#elif defined(IA64)
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_IA64_ITC
+#define SRT_SYNC_CLOCK_STR "IA64_ITC"
+#elif defined(AMD64)
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_AMD64_RDTSC
+#define SRT_SYNC_CLOCK_STR "AMD64_RDTSC"
+#elif defined(_WIN32)
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_WINQPC
+#define SRT_SYNC_CLOCK_STR "WINQPC"
+#elif TARGET_OS_MAC
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_MACH_ABSTIME
+#define SRT_SYNC_CLOCK_STR "MACH_ABSTIME"
+#elif defined(ENABLE_MONOTONIC_CLOCK)
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_GETTIME_MONOTONIC
+#define SRT_SYNC_CLOCK_STR "GETTIME_MONOTONIC"
+#else
+#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY
+#define SRT_SYNC_CLOCK_STR "POSIX_GETTIMEOFDAY"
 #endif
+
+#endif // ENABLE_STDCXX_SYNC
+
+#include "srt.h"
 #include "utilities.h"
+#include "srt_attr_defs.h"
 
-class CUDTException;    // defined in common.h
 
 namespace srt
 {
+
+class CUDTException;    // defined in common.h
+
 namespace sync
 {
-using namespace std;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -42,7 +74,7 @@ using namespace std;
 #if ENABLE_STDCXX_SYNC
 
 template <class Clock>
-using Duration = chrono::duration<Clock>;
+using Duration = std::chrono::duration<Clock>;
 
 #else
 
@@ -101,13 +133,13 @@ class Duration
 
 #if ENABLE_STDCXX_SYNC
 
-using steady_clock = chrono::steady_clock;
+using steady_clock = std::chrono::steady_clock;
 
 template <class Clock, class Duration = typename Clock::duration>
-using time_point = chrono::time_point<Clock, Duration>;
+using time_point = std::chrono::time_point<Clock, Duration>;
 
 template <class Clock>
-using TimePoint = chrono::time_point<Clock>;
+using TimePoint = std::chrono::time_point<Clock>;
 
 template <class Clock, class Duration = typename Clock::duration>
 inline bool is_zero(const time_point<Clock, Duration> &tp)
@@ -154,6 +186,11 @@ class TimePoint
     {
     }
 
+    TimePoint(const Duration<Clock>& duration_since_epoch)
+        : m_timestamp(duration_since_epoch.count())
+    {
+    }
+
     ~TimePoint() {}
 
 public: // Relational operators
@@ -178,21 +215,8 @@ class TimePoint
     inline void operator-=(const Duration<Clock>& rhs) { m_timestamp -= rhs.count(); }
 
 public: //
-#if HAVE_FULL_CXX11
-    static inline ATR_CONSTEXPR TimePoint min() { return TimePoint(numeric_limits<uint64_t>::min()); }
-    static inline ATR_CONSTEXPR TimePoint max() { return TimePoint(numeric_limits<uint64_t>::max()); }
-#else
-#ifndef UINT64_MAX
-#define UNDEF_UINT64_MAX
-#define UINT64_MAX 0xffffffffffffffffULL
-#endif
-    static inline TimePoint min() { return TimePoint(0); }
-    static inline TimePoint max() { return TimePoint(UINT64_MAX); }
-
-#ifdef UNDEF_UINT64_MAX
-#undef UINT64_MAX
-#endif
-#endif
+    static inline ATR_CONSTEXPR TimePoint min() { return TimePoint(std::numeric_limits<uint64_t>::min()); }
+    static inline ATR_CONSTEXPR TimePoint max() { return TimePoint(std::numeric_limits<uint64_t>::max()); }
 
 public:
     Duration<Clock> time_since_epoch() const;
@@ -211,12 +235,23 @@ inline Duration<steady_clock> operator*(const int& lhs, const Duration<steady_cl
 
 #endif // ENABLE_STDCXX_SYNC
 
+// NOTE: Moved the following class definitions to "atomic_clock.h"
+//   template <class Clock>
+//      class AtomicDuration;
+//   template <class Clock>
+//      class AtomicClock;
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Duration and timepoint conversions
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+/// Function return number of decimals in a subsecond precision.
+/// E.g. for a microsecond accuracy of steady_clock the return would be 6.
+/// For a nanosecond accuracy of the steady_clock the return value would be 9.
+int clockSubsecondPrecision();
+
 #if ENABLE_STDCXX_SYNC
 
 inline long long count_microseconds(const steady_clock::duration &t)
@@ -279,14 +314,14 @@ inline bool is_zero(const TimePoint<steady_clock>& t)
 ///////////////////////////////////////////////////////////////////////////////
 
 #if ENABLE_STDCXX_SYNC
-using Mutex = mutex;
-using UniqueLock = unique_lock<mutex>;
-using ScopedLock = lock_guard<mutex>;
+using Mutex = std::mutex;
+using UniqueLock = std::unique_lock<std::mutex>;
+using ScopedLock = std::lock_guard<std::mutex>;
 #else
 /// Mutex is a class wrapper, that should mimic the std::chrono::mutex class.
 /// At the moment the extra function ref() is temporally added to allow calls
 /// to pthread_cond_timedwait(). Will be removed by introducing CEvent.
-class Mutex
+class SRT_ATTR_CAPABILITY("mutex") Mutex
 {
     friend class SyncEvent;
 
@@ -295,11 +330,11 @@ class Mutex
     ~Mutex();
 
 public:
-    int lock();
-    int unlock();
+    int lock() SRT_ATTR_ACQUIRE();
+    int unlock() SRT_ATTR_RELEASE();
 
     /// @return     true if the lock was acquired successfully, otherwise false
-    bool try_lock();
+    bool try_lock() SRT_ATTR_TRY_ACQUIRE(true);
 
     // TODO: To be removed with introduction of the CEvent.
     pthread_mutex_t& ref() { return m_mutex; }
@@ -308,57 +343,72 @@ class Mutex
     pthread_mutex_t m_mutex;
 };
 
-/// A pthread version of std::chrono::scoped_lock<mutex> (or lock_guard for C++11)
-class ScopedLock
+/// A pthread version of std::scoped_lock (or lock_guard for C++11).
+class SRT_ATTR_SCOPED_CAPABILITY ScopedLock
 {
 public:
-    ScopedLock(Mutex& m);
-    ~ScopedLock();
+    SRT_ATTR_ACQUIRE(m)
+    explicit ScopedLock(Mutex& m)
+        : m_mutex(m)
+    {
+        m_mutex.lock();
+    }
+
+    SRT_ATTR_RELEASE()
+    ~ScopedLock() { m_mutex.unlock(); }
 
 private:
     Mutex& m_mutex;
 };
 
 /// A pthread version of std::chrono::unique_lock<mutex>
-class UniqueLock
+class SRT_ATTR_SCOPED_CAPABILITY UniqueLock
 {
     friend class SyncEvent;
+    int m_iLocked;
+    Mutex& m_Mutex;
 
 public:
-    UniqueLock(Mutex &m);
+    SRT_ATTR_ACQUIRE(m)
+    explicit UniqueLock(Mutex &m);
+
+    SRT_ATTR_RELEASE()
     ~UniqueLock();
 
 public:
+    SRT_ATTR_ACQUIRE()
     void lock();
+
+    SRT_ATTR_RELEASE()
     void unlock();
-    Mutex* mutex(); // reflects C++11 unique_lock::mutex()
 
-private:
-    int m_iLocked;
-    Mutex& m_Mutex;
+    SRT_ATTR_RETURN_CAPABILITY(m_Mutex)
+    Mutex* mutex(); // reflects C++11 unique_lock::mutex()
 };
 #endif // ENABLE_STDCXX_SYNC
 
-inline void enterCS(Mutex& m) { m.lock(); }
-inline bool tryEnterCS(Mutex& m) { return m.try_lock(); }
-inline void leaveCS(Mutex& m) { m.unlock(); }
+inline void enterCS(Mutex& m) SRT_ATTR_EXCLUDES(m) SRT_ATTR_ACQUIRE(m) { m.lock(); }
+
+inline bool tryEnterCS(Mutex& m) SRT_ATTR_EXCLUDES(m) SRT_ATTR_TRY_ACQUIRE(true, m) { return m.try_lock(); }
+
+inline void leaveCS(Mutex& m) SRT_ATTR_REQUIRES(m) SRT_ATTR_RELEASE(m) { m.unlock(); }
 
 class InvertedLock
 {
-    Mutex *m_pMutex;
+    Mutex& m_mtx;
 
-  public:
+public:
+    SRT_ATTR_REQUIRES(m) SRT_ATTR_RELEASE(m)
     InvertedLock(Mutex& m)
-        : m_pMutex(&m)
+        : m_mtx(m)
     {
-        leaveCS(*m_pMutex);
+        m_mtx.unlock();
     }
 
+    SRT_ATTR_ACQUIRE(m_mtx)
     ~InvertedLock()
     {
-        if (!m_pMutex)
-            return;
-        enterCS(*m_pMutex);
+        m_mtx.lock();
     }
 };
 
@@ -426,7 +476,7 @@ class Condition
 
 private:
 #if ENABLE_STDCXX_SYNC
-    condition_variable m_cv;
+    std::condition_variable m_cv;
 #else
     pthread_cond_t  m_cv;
 #endif
@@ -435,6 +485,122 @@ class Condition
 inline void setupCond(Condition& cv, const char*) { cv.init(); }
 inline void releaseCond(Condition& cv) { cv.destroy(); }
 
+///////////////////////////////////////////////////////////////////////////////
+//
+// Shared Mutex section
+//
+///////////////////////////////////////////////////////////////////////////////
+
+/// Implementation of a read-write mutex. 
+/// This allows multiple readers at a time, or a single writer.
+/// TODO: The class can be improved if needed to give writer a preference
+/// by adding additional m_iWritersWaiting member variable (counter).
+/// TODO: The m_iCountRead could be made atomic to make unlok_shared() faster and lock-free.
+class SharedMutex
+{
+public:
+    SharedMutex();
+    ~SharedMutex();
+
+public:
+    /// Acquire the lock for writting purposes. Only one thread can acquire this lock at a time
+    /// Once it is locked, no reader can acquire it
+    void lock();
+    bool try_lock();
+    void unlock();
+
+    /// Acquire the lock if no writter already has it. For read purpose only
+    /// Several readers can lock this at the same time.
+    void lock_shared();
+    bool try_lock_shared();
+    void unlock_shared();
+
+    int getReaderCount() const;
+
+protected:
+    Condition m_LockWriteCond;
+    Condition m_LockReadCond;
+
+    mutable Mutex m_Mutex;
+
+    int  m_iCountRead;
+    bool m_bWriterLocked;
+};
+
+/// A version of std::scoped_lock<std::shared_mutex> (or lock_guard for C++11).
+/// We could have used the srt::sync::ScopedLock making it a template-based class.
+/// But in that case all usages would have to be specificed like ScopedLock<Mutex> in C++03.
+class SRT_ATTR_SCOPED_CAPABILITY ExclusiveLock
+{
+public:
+    SRT_ATTR_ACQUIRE(m)
+    explicit ExclusiveLock(SharedMutex& m)
+        : m_mutex(m)
+    {
+        m_mutex.lock();
+    }
+
+    SRT_ATTR_RELEASE(m_mutex)
+    ~ExclusiveLock() { m_mutex.unlock(); }
+
+private:
+    SharedMutex& m_mutex;
+};
+
+/// A reduced implementation of the std::shared_lock functionality (available in C++14).
+class SRT_ATTR_SCOPED_CAPABILITY SharedLock
+{
+public:
+    SRT_ATTR_ACQUIRE_SHARED(m)
+    explicit SharedLock(SharedMutex& m)
+        : m_mtx(m)
+    {
+        m_mtx.lock_shared();
+    }
+
+    SRT_ATTR_RELEASE_SHARED(m_mtx)
+    ~SharedLock() { m_mtx.unlock_shared(); }
+
+private:
+    SharedMutex& m_mtx;
+};
+
+/// A class template for a shared object. It is a wrapper around a pointer to an object
+/// and a shared mutex. It allows multiple readers to access the object at the same time,
+/// but only one writer can access the object at a time.
+template <class T>
+class CSharedObjectPtr : public SharedMutex
+{
+public:
+    CSharedObjectPtr<T>()
+        : m_pObj(NULL)
+    {
+    }
+
+    bool set(T* pObj)
+    {
+        ExclusiveLock lock(*this);
+        if (m_pObj)
+            return false;
+        m_pObj = pObj;
+        return true;
+    }
+
+    bool clearIf(const T* pObj)
+    {
+        ExclusiveLock lock(*this);
+        if (m_pObj != pObj)
+            return false;
+        m_pObj = NULL;
+        return true;
+    }
+
+    T* getPtrNoLock() const { return m_pObj; }
+
+private:
+    T* m_pObj;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Event (CV) section
@@ -445,6 +611,7 @@ inline void releaseCond(Condition& cv) { cv.destroy(); }
 // This should provide a cleaner API around locking with debug-logging inside.
 class CSync
 {
+protected:
     Condition* m_cond;
     UniqueLock* m_locker;
 
@@ -475,63 +642,63 @@ class CSync
     /// Block the call until either @a timestamp time achieved
     /// or the conditional is signaled.
     /// @param [in] delay Maximum time to wait since the moment of the call
-    /// @retval true Resumed due to getting a CV signal
-    /// @retval false Resumed due to being past @a timestamp
+    /// @retval false if the relative timeout specified by rel_time expired,
+    /// @retval true if condition is signaled or spurious wake up.
     bool wait_for(const steady_clock::duration& delay)
     {
         return m_cond->wait_for(*m_locker, delay);
     }
 
-    // Wait until the given time is achieved. This actually
-    // refers to wait_for for the time remaining to achieve
-    // given time.
+    // Wait until the given time is achieved.
+    /// @param [in] exptime The target time to wait until.
+    /// @retval false if the target wait time is reached.
+    /// @retval true if condition is signal or spurious wake up.
     bool wait_until(const steady_clock::time_point& exptime)
     {
-        // This will work regardless as to which clock is in use. The time
-        // should be specified as steady_clock::time_point, so there's no
-        // question of the timer base.
-        steady_clock::time_point now = steady_clock::now();
-        if (now >= exptime)
-            return false; // timeout
-
-        return wait_for(exptime - now);
+        return m_cond->wait_until(*m_locker, exptime);
     }
 
     // Static ad-hoc version
-    static void lock_signal(Condition& cond, Mutex& m)
+    static void lock_notify_one(Condition& cond, Mutex& m)
     {
         ScopedLock lk(m); // XXX with thread logging, don't use ScopedLock directly!
         cond.notify_one();
     }
 
-    static void lock_broadcast(Condition& cond, Mutex& m)
+    static void lock_notify_all(Condition& cond, Mutex& m)
     {
         ScopedLock lk(m); // XXX with thread logging, don't use ScopedLock directly!
         cond.notify_all();
     }
 
-    void signal_locked(UniqueLock& lk ATR_UNUSED)
+    void notify_one_locked(UniqueLock& lk SRT_ATR_UNUSED)
     {
         // EXPECTED: lk.mutex() is LOCKED.
         m_cond->notify_one();
     }
 
-    // The signal_relaxed and broadcast_relaxed functions are to be used in case
-    // when you don't care whether the associated mutex is locked or not (you
-    // accept the case that a mutex isn't locked and the signal gets effectively
-    // missed), or you somehow know that the mutex is locked, but you don't have
-    // access to the associated UniqueLock object. This function, although it does
-    // the same thing as signal_locked() and broadcast_locked(), is here for
-    // the user to declare explicitly that the signal/broadcast is done without
-    // being prematurely certain that the associated mutex is locked.
+    void notify_all_locked(UniqueLock& lk SRT_ATR_UNUSED)
+    {
+        // EXPECTED: lk.mutex() is LOCKED.
+        m_cond->notify_all();
+    }
+
+    // The *_relaxed functions are to be used in case when you don't care
+    // whether the associated mutex is locked or not (you accept the case that
+    // a mutex isn't locked and the condition notification gets effectively
+    // missed), or you somehow know that the mutex is locked, but you don't
+    // have access to the associated UniqueLock object. This function, although
+    // it does the same thing as CSync::notify_one_locked etc. here for the
+    // user to declare explicitly that notifying is done without being
+    // prematurely certain that the associated mutex is locked.
     //
     // It is then expected that whenever these functions are used, an extra
-    // comment is provided to explain, why the use of the relaxed signaling is
-    // correctly used.
+    // comment is provided to explain, why the use of the relaxed notification
+    // is correctly used.
 
-    void signal_relaxed() { signal_relaxed(*m_cond); }
-    static void signal_relaxed(Condition& cond) { cond.notify_one(); }
-    static void broadcast_relaxed(Condition& cond) { cond.notify_all(); }
+    void notify_one_relaxed() { notify_one_relaxed(*m_cond); }
+    static void notify_one_relaxed(Condition& cond) { cond.notify_one(); }
+    static void notify_all_relaxed(Condition& cond) { cond.notify_all(); }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -540,6 +707,9 @@ class CSync
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+// XXX Do not use this class now, there's an unknown issue
+// connected to object management with the use of release* functions.
+// Until this is solved, stay with separate *Cond and *Lock fields.
 class CEvent
 {
 public:
@@ -548,12 +718,13 @@ class CEvent
 
 public:
     Mutex& mutex() { return m_lock; }
+    Condition& cond() { return m_cond; }
 
 public:
     /// Causes the current thread to block until
     /// a specific time is reached.
     ///
-    /// @return true  if condition occured or spuriously woken up
+    /// @return true  if condition occurred or spuriously woken up
     ///         false on timeout
     bool lock_wait_until(const steady_clock::time_point& tp);
 
@@ -564,7 +735,7 @@ class CEvent
     /// It may also be unblocked spuriously.
     /// Uses internal mutex to lock.
     ///
-    /// @return true  if condition occured or spuriously woken up
+    /// @return true  if condition occurred or spuriously woken up
     ///         false on timeout
     bool lock_wait_for(const steady_clock::duration& rel_time);
 
@@ -575,7 +746,7 @@ class CEvent
     /// It may also be unblocked spuriously.
     /// When unblocked, regardless of the reason, lock is reacquiredand wait_for() exits.
     ///
-    /// @return true  if condition occured or spuriously woken up
+    /// @return true  if condition occurred or spuriously woken up
     ///         false on timeout
     bool wait_for(UniqueLock& lk, const steady_clock::duration& rel_time);
 
@@ -587,12 +758,68 @@ class CEvent
 
     void notify_all();
 
+    void lock_notify_one()
+    {
+        ScopedLock lk(m_lock); // XXX with thread logging, don't use ScopedLock directly!
+        m_cond.notify_one();
+    }
+
+    void lock_notify_all()
+    {
+        ScopedLock lk(m_lock); // XXX with thread logging, don't use ScopedLock directly!
+        m_cond.notify_all();
+    }
+
 private:
     Mutex      m_lock;
     Condition  m_cond;
 };
 
 
+// This class binds together the functionality of
+// UniqueLock and CSync. It provides a simple interface of CSync
+// while having already the UniqueLock applied in the scope,
+// so a safe statement can be made about the mutex being locked
+// when signalling or waiting.
+class CUniqueSync: public CSync
+{
+    UniqueLock m_ulock;
+
+public:
+
+    UniqueLock& locker() { return m_ulock; }
+
+    SRT_ATTR_ACQUIRE(this->m_ulock.mutex())
+    CUniqueSync(Mutex& mut, Condition& cnd)
+        : CSync(cnd, m_ulock)
+        , m_ulock(mut)
+    {
+    }
+
+    CUniqueSync(CEvent& event)
+        : CSync(event.cond(), m_ulock)
+        , m_ulock(event.mutex())
+    {
+    }
+
+    SRT_ATTR_RELEASE(this->m_ulock.mutex())
+    ~CUniqueSync() {}
+
+    // These functions can be used safely because
+    // this whole class guarantees that whatever happens
+    // while its object exists is that the mutex is locked.
+
+    void notify_one()
+    {
+        m_cond->notify_one();
+    }
+
+    void notify_all()
+    {
+        m_cond->notify_all();
+    }
+};
+
 class CTimer
 {
 public:
@@ -626,7 +853,7 @@ class CTimer
 
 
 /// Print steady clock timepoint in a human readable way.
-/// days HH:MM::SS.us [STD]
+/// days HH:MM:SS.us [STD]
 /// Example: 1D 02:12:56.123456
 ///
 /// @param [in] steady clock timepoint
@@ -634,7 +861,7 @@ class CTimer
 std::string FormatTime(const steady_clock::time_point& time);
 
 /// Print steady clock timepoint relative to the current system time
-/// Date HH:MM::SS.us [SYS]
+/// Date HH:MM:SS.us [SYS]
 /// @param [in] steady clock timepoint
 /// @returns a string with a formatted time representation
 std::string FormatTimeSys(const steady_clock::time_point& time);
@@ -668,7 +895,7 @@ struct DurationUnitName<DUNIT_S>
 template<eDurationUnit UNIT>
 inline std::string FormatDuration(const steady_clock::duration& dur)
 {
-    return Sprint(DurationUnitName<UNIT>::count(dur)) + DurationUnitName<UNIT>::name();
+    return Sprint(std::fixed, DurationUnitName<UNIT>::count(dur)) + DurationUnitName<UNIT>::name();
 }
 
 inline std::string FormatDuration(const steady_clock::duration& dur)
@@ -703,8 +930,9 @@ class CGlobEvent
 #ifdef ENABLE_STDCXX_SYNC
 typedef std::system_error CThreadException;
 using CThread = std::thread;
+namespace this_thread = std::this_thread;
 #else // pthreads wrapper version
-typedef ::CUDTException CThreadException;
+typedef CUDTException CThreadException;
 
 class CThread
 {
@@ -767,7 +995,7 @@ class CThread
 template <class Stream>
 inline Stream& operator<<(Stream& str, const CThread::id& cid)
 {
-#if defined(_WIN32) && defined(PTW32_VERSION)
+#if defined(_WIN32) && (defined(PTW32_VERSION) || defined (__PTW32_VERSION))
     // This is a version specific for pthread-win32 implementation
     // Here pthread_t type is a structure that is not convertible
     // to a number at all.
@@ -786,7 +1014,7 @@ namespace this_thread
 #if !defined(_WIN32)
         usleep(count_microseconds(t)); // microseconds
 #else
-        Sleep(count_milliseconds(t));
+        Sleep((DWORD) count_milliseconds(t));
 #endif
     }
 }
@@ -804,9 +1032,9 @@ namespace this_thread
 ///
 #ifdef ENABLE_STDCXX_SYNC
 typedef void* (&ThreadFunc) (void*);
-bool StartThread(CThread& th, ThreadFunc&& f, void* args, const char* name);
+bool StartThread(CThread& th, ThreadFunc&& f, void* args, const std::string& name);
 #else
-bool StartThread(CThread& th, void* (*f) (void*), void* args, const char* name);
+bool StartThread(CThread& th, void* (*f) (void*), void* args, const std::string& name);
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -823,7 +1051,21 @@ void SetThreadLocalError(const CUDTException& e);
 /// @returns CUDTException pointer
 CUDTException& GetThreadLocalError();
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// Random distribution functions.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/// Generate a uniform-distributed random integer from [minVal; maxVal].
+/// If HAVE_CXX11, uses std::uniform_distribution(std::random_device).
+/// @param[in] minVal minimum allowed value of the resulting random number.
+/// @param[in] maxVal maximum allowed value of the resulting random number.
+int genRandomInt(int minVal, int maxVal);
+
 } // namespace sync
 } // namespace srt
 
+#include "atomic_clock.h"
+
 #endif // INC_SRT_SYNC_H
diff --git a/srtcore/sync_cxx11.cpp b/srtcore/sync_cxx11.cpp
index 69fffa482..bdfbf9a4e 100644
--- a/srtcore/sync_cxx11.cpp
+++ b/srtcore/sync_cxx11.cpp
@@ -16,6 +16,36 @@
 #include "srt_compat.h"
 #include "common.h"
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// Clock frequency helpers
+//
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+template <int val>
+int pow10();
+
+template <>
+int pow10<10>()
+{
+    return 1;
+}
+
+template <int val>
+int pow10()
+{
+    return 1 + pow10<val / 10>();
+}
+}
+
+int srt::sync::clockSubsecondPrecision()
+{
+    const int64_t ticks_per_sec = (srt::sync::steady_clock::period::den / srt::sync::steady_clock::period::num);
+    const int     decimals      = pow10<ticks_per_sec>();
+    return decimals;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // SyncCond (based on stl chrono C++11)
@@ -38,12 +68,12 @@ void srt::sync::Condition::wait(UniqueLock& lock)
 bool srt::sync::Condition::wait_for(UniqueLock& lock, const steady_clock::duration& rel_time)
 {
     // Another possible implementation is wait_until(steady_clock::now() + timeout);
-    return m_cv.wait_for(lock, rel_time) != cv_status::timeout;
+    return m_cv.wait_for(lock, rel_time) != std::cv_status::timeout;
 }
 
 bool srt::sync::Condition::wait_until(UniqueLock& lock, const steady_clock::time_point& timeout_time)
 {
-    return m_cv.wait_until(lock, timeout_time) != cv_status::timeout;
+    return m_cv.wait_until(lock, timeout_time) != std::cv_status::timeout;
 }
 
 void srt::sync::Condition::notify_one()
@@ -64,14 +94,14 @@ void srt::sync::Condition::notify_all()
 
 // Threal local error will be used by CUDTUnited
 // with a static scope, therefore static thread_local
-static thread_local CUDTException s_thErr;
+static thread_local srt::CUDTException s_thErr;
 
-void srt::sync::SetThreadLocalError(const CUDTException& e)
+void srt::sync::SetThreadLocalError(const srt::CUDTException& e)
 {
     s_thErr = e;
 }
 
-CUDTException& srt::sync::GetThreadLocalError()
+srt::CUDTException& srt::sync::GetThreadLocalError()
 {
     return s_thErr;
 }
diff --git a/srtcore/sync_posix.cpp b/srtcore/sync_posix.cpp
index 01818ae6c..8d7561a19 100644
--- a/srtcore/sync_posix.cpp
+++ b/srtcore/sync_posix.cpp
@@ -21,14 +21,10 @@
 #include "common.h"
 
 #if defined(_WIN32)
-#define TIMING_USE_QPC
 #include "win/wintime.h"
 #include <sys/timeb.h>
 #elif TARGET_OS_MAC
-#define TIMING_USE_MACH_ABS_TIME
 #include <mach/mach_time.h>
-#elif defined(ENABLE_MONOTONIC_CLOCK)
-#define TIMING_USE_CLOCK_GETTIME
 #endif
 
 namespace srt_logging
@@ -42,9 +38,9 @@ namespace srt
 namespace sync
 {
 
-void rdtsc(uint64_t& x)
+static void rdtsc(uint64_t& x)
 {
-#ifdef IA32
+#if SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_IA32_RDTSC
     uint32_t lval, hval;
     // asm volatile ("push %eax; push %ebx; push %ecx; push %edx");
     // asm volatile ("xor %eax, %eax; cpuid");
@@ -52,52 +48,64 @@ void rdtsc(uint64_t& x)
     // asm volatile ("pop %edx; pop %ecx; pop %ebx; pop %eax");
     x = hval;
     x = (x << 32) | lval;
-#elif defined(IA64)
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_IA64_ITC
     asm("mov %0=ar.itc" : "=r"(x)::"memory");
-#elif defined(AMD64)
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_AMD64_RDTSC
     uint32_t lval, hval;
-    asm("rdtsc" : "=a"(lval), "=d"(hval));
+    asm volatile("rdtsc" : "=a"(lval), "=d"(hval));
     x = hval;
     x = (x << 32) | lval;
-#elif defined(TIMING_USE_QPC)
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_WINQPC
     // This function should not fail, because we checked the QPC
     // when calling to QueryPerformanceFrequency. If it failed,
     // the m_bUseMicroSecond was set to true.
     QueryPerformanceCounter((LARGE_INTEGER*)&x);
-#elif defined(TIMING_USE_MACH_ABS_TIME)
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_MACH_ABSTIME
     x = mach_absolute_time();
-#elif defined(TIMING_USE_CLOCK_GETTIME)
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_GETTIME_MONOTONIC
     // get_cpu_frequency() returns 1 us accuracy in this case
     timespec tm;
     clock_gettime(CLOCK_MONOTONIC, &tm);
     x = tm.tv_sec * uint64_t(1000000) + (tm.tv_nsec / 1000);
-#else
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY
     // use system call to read time clock for other archs
     timeval t;
     gettimeofday(&t, 0);
     x = t.tv_sec * uint64_t(1000000) + t.tv_usec;
+#else
+#error Wrong SRT_SYNC_CLOCK
 #endif
 }
 
-int64_t get_cpu_frequency()
+static int64_t get_cpu_frequency()
 {
     int64_t frequency = 1; // 1 tick per microsecond.
 
-#if defined(TIMING_USE_QPC)
+#if SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_WINQPC
     LARGE_INTEGER ccf; // in counts per second
     if (QueryPerformanceFrequency(&ccf))
+    {
         frequency = ccf.QuadPart / 1000000; // counts per microsecond
+        if (frequency == 0)
+        {
+            LOGC(inlog.Warn, log << "Win QPC frequency of " << ccf.QuadPart
+                << " counts/s is below the required 1 us accuracy. Please consider using C++11 timing (-DENABLE_STDCXX_SYNC=ON) instead.");
+            frequency = 1; // set back to 1 to avoid division by zero.
+        }
+    }
+    else
+    {
+        // Can't throw an exception, it won't be handled.
+        LOGC(inlog.Error, log << "IPE: QueryPerformanceFrequency failed with " << GetLastError());
+    }
 
-#elif defined(TIMING_USE_CLOCK_GETTIME)
-    frequency = 1;
-
-#elif defined(TIMING_USE_MACH_ABS_TIME)
-
+#elif SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_MACH_ABSTIME
     mach_timebase_info_data_t info;
     mach_timebase_info(&info);
     frequency = info.denom * int64_t(1000) / info.numer;
 
-#elif defined(IA32) || defined(IA64) || defined(AMD64)
+#elif SRT_SYNC_CLOCK >= SRT_SYNC_CLOCK_AMD64_RDTSC && SRT_SYNC_CLOCK <= SRT_SYNC_CLOCK_IA64_ITC
+    // SRT_SYNC_CLOCK_AMD64_RDTSC or SRT_SYNC_CLOCK_IA32_RDTSC or SRT_SYNC_CLOCK_IA64_ITC
     uint64_t t1, t2;
 
     rdtsc(t1);
@@ -114,8 +122,18 @@ int64_t get_cpu_frequency()
     return frequency;
 }
 
-const int64_t s_cpu_frequency = get_cpu_frequency();
+static int count_subsecond_precision(int64_t ticks_per_us)
+{
+    int signs = 6; // starting from 1 us
+    while (ticks_per_us /= 10) ++signs;
+    return signs;
+}
+
+const int64_t s_clock_ticks_per_us = get_cpu_frequency();
 
+const int s_clock_subsecond_precision = count_subsecond_precision(s_clock_ticks_per_us);
+
+int clockSubsecondPrecision() { return s_clock_subsecond_precision; }
 
 } // namespace sync
 } // namespace srt
@@ -155,32 +173,32 @@ srt::sync::TimePoint<srt::sync::steady_clock> srt::sync::steady_clock::now()
 
 int64_t srt::sync::count_microseconds(const steady_clock::duration& t)
 {
-    return t.count() / s_cpu_frequency;
+    return t.count() / s_clock_ticks_per_us;
 }
 
 int64_t srt::sync::count_milliseconds(const steady_clock::duration& t)
 {
-    return t.count() / s_cpu_frequency / 1000;
+    return t.count() / s_clock_ticks_per_us / 1000;
 }
 
 int64_t srt::sync::count_seconds(const steady_clock::duration& t)
 {
-    return t.count() / s_cpu_frequency / 1000000;
+    return t.count() / s_clock_ticks_per_us / 1000000;
 }
 
 srt::sync::steady_clock::duration srt::sync::microseconds_from(int64_t t_us)
 {
-    return steady_clock::duration(t_us * s_cpu_frequency);
+    return steady_clock::duration(t_us * s_clock_ticks_per_us);
 }
 
 srt::sync::steady_clock::duration srt::sync::milliseconds_from(int64_t t_ms)
 {
-    return steady_clock::duration((1000 * t_ms) * s_cpu_frequency);
+    return steady_clock::duration((1000 * t_ms) * s_clock_ticks_per_us);
 }
 
 srt::sync::steady_clock::duration srt::sync::seconds_from(int64_t t_s)
 {
-    return steady_clock::duration((1000000 * t_s) * s_cpu_frequency);
+    return steady_clock::duration((1000000 * t_s) * s_clock_ticks_per_us);
 }
 
 srt::sync::Mutex::Mutex()
@@ -212,18 +230,6 @@ bool srt::sync::Mutex::try_lock()
     return (pthread_mutex_trylock(&m_mutex) == 0);
 }
 
-srt::sync::ScopedLock::ScopedLock(Mutex& m)
-    : m_mutex(m)
-{
-    m_mutex.lock();
-}
-
-srt::sync::ScopedLock::~ScopedLock()
-{
-    m_mutex.unlock();
-}
-
-
 srt::sync::UniqueLock::UniqueLock(Mutex& m)
     : m_Mutex(m)
 {
@@ -232,22 +238,27 @@ srt::sync::UniqueLock::UniqueLock(Mutex& m)
 
 srt::sync::UniqueLock::~UniqueLock()
 {
-    unlock();
+    if (m_iLocked == 0)
+    {
+        unlock();
+    }
 }
 
 void srt::sync::UniqueLock::lock()
 {
-    if (m_iLocked == -1)
-        m_iLocked = m_Mutex.lock();
+    if (m_iLocked != -1)
+        throw CThreadException(MJ_SYSTEMRES, MN_THREAD, 0);
+
+    m_iLocked = m_Mutex.lock();
 }
 
 void srt::sync::UniqueLock::unlock()
 {
-    if (m_iLocked == 0)
-    {
-        m_Mutex.unlock();
-        m_iLocked = -1;
-    }
+    if (m_iLocked != 0)
+        throw CThreadException(MJ_SYSTEMRES, MN_THREAD, 0);
+
+    m_Mutex.unlock();
+    m_iLocked = -1;
 }
 
 srt::sync::Mutex* srt::sync::UniqueLock::mutex()
@@ -277,7 +288,7 @@ Condition::~Condition() {}
 void Condition::init()
 {
     pthread_condattr_t* attr = NULL;
-#if ENABLE_MONOTONIC_CLOCK
+#if SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_GETTIME_MONOTONIC
     pthread_condattr_t  CondAttribs;
     pthread_condattr_init(&CondAttribs);
     pthread_condattr_setclock(&CondAttribs, CLOCK_MONOTONIC);
@@ -301,7 +312,7 @@ void Condition::wait(UniqueLock& lock)
 bool Condition::wait_for(UniqueLock& lock, const steady_clock::duration& rel_time)
 {
     timespec timeout;
-#if ENABLE_MONOTONIC_CLOCK
+#if SRT_SYNC_CLOCK == SRT_SYNC_CLOCK_GETTIME_MONOTONIC
     clock_gettime(CLOCK_MONOTONIC, &timeout);
     const uint64_t now_us = timeout.tv_sec * uint64_t(1000000) + (timeout.tv_nsec / 1000);
 #else
@@ -412,7 +423,7 @@ void srt::sync::CThread::join()
 #ifdef HEAVY_LOGGING
     else
     {
-        LOGC(inlog.Debug, log << "pthread_join SUCCEEDED");
+        HLOGC(inlog.Debug, log << "pthread_join SUCCEEDED");
     }
 #endif
     // After joining, joinable should be false
@@ -444,45 +455,84 @@ class CThreadError
 public:
     CThreadError()
     {
-        pthread_key_create(&m_TLSError, TLSDestroy);
+        pthread_key_create(&m_ThreadSpecKey, ThreadSpecKeyDestroy);
+
+        // This is a global object and as such it should be called in the
+        // main application thread or at worst in the thread that has first
+        // run `srt_startup()` function and so requested the SRT library to
+        // be dynamically linked. Most probably in this very thread the API
+        // errors will be reported, so preallocate the ThreadLocalSpecific
+        // object for this error description.
+
+        // This allows std::bac_alloc to crash the program during
+        // the initialization of the SRT library (likely it would be
+        // during the DL constructor, still way before any chance of
+        // doing any operations here). This will prevent SRT from running
+        // into trouble while trying to operate.
+        CUDTException* ne = new CUDTException();
+        pthread_setspecific(m_ThreadSpecKey, ne);
     }
 
     ~CThreadError()
     {
-        delete (CUDTException*)pthread_getspecific(m_TLSError);
-        pthread_key_delete(m_TLSError);
+        // Likely all objects should be deleted in all
+        // threads that have exited, but std::this_thread didn't exit
+        // yet :).
+        ThreadSpecKeyDestroy(pthread_getspecific(m_ThreadSpecKey));
+        pthread_key_delete(m_ThreadSpecKey);
     }
 
-public:
     void set(const CUDTException& e)
     {
         CUDTException* cur = get();
-        SRT_ASSERT(cur != NULL);
+        // If this returns NULL, it means that there was an unexpected
+        // memory allocation error. Simply ignore this request if so
+        // happened, and then when trying to get the error description
+        // the application will always get the memory allocation error.
+
+        // There's no point in doing anything else here; lack of memory
+        // must be prepared for prematurely, and that was already done.
+        if (!cur)
+            return;
+
         *cur = e;
     }
 
-    CUDTException* get()
+    /*[[nullable]]*/ CUDTException* get()
     {
-        if (!pthread_getspecific(m_TLSError))
+        if (!pthread_getspecific(m_ThreadSpecKey))
         {
-            CUDTException* ne = new CUDTException();
-            pthread_setspecific(m_TLSError, ne);
+            // This time if this can't be done due to memory allocation
+            // problems, just allow this value to be NULL, which during
+            // getting the error description will redirect to a memory
+            // allocation error.
+
+            // It would be nice to somehow ensure that this object is
+            // created in every thread of the application using SRT, but
+            // POSIX thread API doesn't contain any possibility to have
+            // a creation callback that would apply to every thread in
+            // the application (as it is for C++11 thread_local storage).
+            CUDTException* ne = new(std::nothrow) CUDTException();
+            pthread_setspecific(m_ThreadSpecKey, ne);
             return ne;
         }
-        return (CUDTException*)pthread_getspecific(m_TLSError);
+        return (CUDTException*)pthread_getspecific(m_ThreadSpecKey);
     }
 
-    static void TLSDestroy(void* e)
+    static void ThreadSpecKeyDestroy(void* e)
     {
         delete (CUDTException*)e;
     }
 
 private:
-    pthread_key_t m_TLSError;
+    pthread_key_t m_ThreadSpecKey;
 };
 
 // Threal local error will be used by CUDTUnited
 // that has a static scope
+
+// This static makes this object file-private access so that
+// the access is granted only for the accessor functions.
 static CThreadError s_thErr;
 
 void SetThreadLocalError(const CUDTException& e)
@@ -492,7 +542,17 @@ void SetThreadLocalError(const CUDTException& e)
 
 CUDTException& GetThreadLocalError()
 {
-    return *s_thErr.get();
+    // In POSIX version we take into account the possibility
+    // of having an allocation error here. Therefore we need to
+    // allow thie value to return NULL and have some fallback
+    // for that case. The dynamic memory allocation failure should
+    // be the only case as to why it is unable to get the pointer
+    // to the error description.
+    static CUDTException resident_alloc_error (MJ_SYSTEMRES, MN_MEMORY);
+    CUDTException* curx = s_thErr.get();
+    if (!curx)
+        return resident_alloc_error;
+    return *curx;
 }
 
 } // namespace sync
diff --git a/srtcore/threadname.h b/srtcore/threadname.h
index 38fea471b..6233e36fc 100644
--- a/srtcore/threadname.h
+++ b/srtcore/threadname.h
@@ -1,11 +1,11 @@
 /*
  * SRT - Secure, Reliable, Transport
  * Copyright (c) 2018 Haivision Systems Inc.
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- * 
+ *
  */
 
 /*****************************************************************************
@@ -16,85 +16,211 @@ written by
 #ifndef INC_SRT_THREADNAME_H
 #define INC_SRT_THREADNAME_H
 
-#ifdef __linux__
+// NOTE:
+//    HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H
+//    HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H
+//    HAVE_PTHREAD_GETNAME_NP
+//    HAVE_PTHREAD_GETNAME_NP
+//    Are detected and set in ../CMakeLists.txt.
+//    OS Availability of pthread_getname_np(..) and pthread_setname_np(..)::
+//       MacOS(10.6)
+//       iOS(3.2)
+//       AIX(7.1)
+//       FreeBSD(version?), OpenBSD(Version?)
+//       Linux-GLIBC(GLIBC-2.12).
+//       Linux-MUSL(MUSL-1.1.20 Partial Implementation. See below).
+//       MINGW-W64(4.0.6)
+
+#if defined(HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H) \
+   || defined(HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H)
+   #include <pthread_np.h>
+   #if defined(HAVE_PTHREAD_GETNAME_NP_IN_PTHREAD_NP_H) \
+      && !defined(HAVE_PTHREAD_GETNAME_NP)
+      #define HAVE_PTHREAD_GETNAME_NP 1
+   #endif
+   #if defined(HAVE_PTHREAD_SETNAME_NP_IN_PTHREAD_NP_H) \
+      && !defined(HAVE_PTHREAD_SETNAME_NP)
+      #define HAVE_PTHREAD_SETNAME_NP 1
+   #endif
+#endif
+
+#if (defined(HAVE_PTHREAD_GETNAME_NP) && defined(HAVE_PTHREAD_GETNAME_NP)) \
+   || defined(__linux__)
+   // NOTE:
+   //    Linux pthread_getname_np() and pthread_setname_np() became available
+   //       in GLIBC-2.12 and later.
+   //    Some Linux runtimes do not have pthread_getname_np(), but have
+   //       pthread_setname_np(), for instance MUSL at least as of v1.1.20.
+   //    So using the prctl() for Linux is more portable.
+   #if defined(__linux__)
+      #include <sys/prctl.h>
+   #endif
+   #include <pthread.h>
+#endif
 
-#include <sys/prctl.h>
 #include <cstdio>
+#include <cstring>
+#include <string>
+
+#include "common.h"
+#include "sync.h"
+
+namespace srt {
 
 class ThreadName
 {
-    char old_name[128];
-    char new_name[128];
-    bool good;
 
-public:
-    static const size_t BUFSIZE = 128;
+#if (defined(HAVE_PTHREAD_GETNAME_NP) && defined(HAVE_PTHREAD_GETNAME_NP)) \
+   || defined(__linux__)
 
-    static bool get(char* namebuf)
+    class ThreadNameImpl
     {
-        return prctl(PR_GET_NAME, (unsigned long)namebuf, 0, 0) != -1;
-    }
+    public:
+        static const size_t BUFSIZE    = 64;
+        static const bool   DUMMY_IMPL = false;
 
-    static bool set(const char* name)
-    {
-        return prctl(PR_SET_NAME, (unsigned long)name, 0, 0) != -1;
-    }
+        static bool get(char* namebuf)
+        {
+#if defined(__linux__)
+            // since Linux 2.6.11. The buffer should allow space for up to 16
+            // bytes; the returned string will be null-terminated.
+            return prctl(PR_GET_NAME, (unsigned long)namebuf, 0, 0) != -1;
+#elif defined(HAVE_PTHREAD_GETNAME_NP)
+            return pthread_getname_np(pthread_self(), namebuf, BUFSIZE) == 0;
+#else
+#error "unsupported platform"
+#endif
+        }
 
+        static bool set(const char* name)
+        {
+            SRT_ASSERT(name != NULL);
+#if defined(__linux__)
+            // The name can be up to 16 bytes long, including the terminating
+            // null byte. (If the length of the string, including the terminating
+            // null byte, exceeds 16 bytes, the string is silently truncated.)
+            return prctl(PR_SET_NAME, (unsigned long)name, 0, 0) != -1;
+#elif defined(HAVE_PTHREAD_SETNAME_NP)
+    #if defined(__APPLE__)
+            return pthread_setname_np(name) == 0;
+    #elif defined(__NetBSD__)
+            return pthread_setname_np(pthread_self(), "%s", name) == 0;
+    #else
+            return pthread_setname_np(pthread_self(), name) == 0;
+    #endif
+#else
+#error "unsupported platform"
+#endif
+        }
 
-    ThreadName(const char* name)
-    {
-        if ( (good = get(old_name)) )
+        explicit ThreadNameImpl(const std::string& name)
+            : reset(false)
         {
-            snprintf(new_name, 127, "%s", name);
-            new_name[127] = 0;
-            prctl(PR_SET_NAME, (unsigned long)new_name, 0, 0);
+            tid   = pthread_self();
+
+            if (!get(old_name))
+                return;
+
+            reset = set(name.c_str());
+            if (reset)
+                return;
+
+            // Try with a shorter name. 15 is the upper limit supported by Linux,
+            // other platforms should support a larger value. So 15 should works
+            // on all platforms.
+            const size_t max_len = 15;
+            if (name.size() > max_len)
+                reset = set(name.substr(0, max_len).c_str());
         }
-    }
 
-    ~ThreadName()
-    {
-        if ( good )
-            prctl(PR_SET_NAME, (unsigned long)old_name, 0, 0);
-    }
-};
+        ~ThreadNameImpl()
+        {
+            if (!reset)
+                return;
+
+            // ensure it's called on the right thread
+            if (tid == pthread_self())
+                set(old_name);
+        }
+    
+    private:
+        ThreadNameImpl(ThreadNameImpl& other);
+        ThreadNameImpl& operator=(const ThreadNameImpl& other);
+
+    private:
+        bool      reset;
+        pthread_t tid;
+        char      old_name[BUFSIZE];
+    };
 
 #else
 
-#include "sync.h"
+    class ThreadNameImpl
+    {
+    public:
+        static const bool   DUMMY_IMPL = true;
+        static const size_t BUFSIZE    = 64;
 
-// Fallback version, which simply reports the thread name as
-// T<numeric-id>, and custom names used with `set` are ignored.
-// If you know how to implement this for other systems than
-// Linux, you can make another conditional. This one is now
-// the "ultimate fallback".
+        static bool get(char* output)
+        {
+            // The default implementation will simply try to get the thread ID
+            std::ostringstream bs;
+            bs << "T" << sync::this_thread::get_id();
+            size_t s  = bs.str().copy(output, BUFSIZE - 1);
+            output[s] = '\0';
+            return true;
+        }
 
-class ThreadName
-{
-public:
-    static const size_t BUFSIZE = 128;
+        static bool set(const char*) { return false; }
 
-    static bool get(char* output)
-    {
-        // The default implementation will simply try to get the thread ID
-        std::ostringstream bs;
-        bs << "T" << srt::sync::this_thread::get_id();
-        size_t s = bs.str().copy(output, BUFSIZE-1);
-        output[s] = '\0';
-        return true;
+        ThreadNameImpl(const std::string&) {}
+
+        ~ThreadNameImpl() // just to make it "non-trivially-destructible" for compatibility with normal version
+        {
+        }
+    };
+
+#endif // platform dependent impl
+
+    // Why delegate to impl:
+    // 1. to make sure implementation on different platforms have the same interface.
+    // 2. it's simple to add some wrappers like get(const std::string &).
+    ThreadNameImpl impl;
+
+public:
+    static const bool   DUMMY_IMPL = ThreadNameImpl::DUMMY_IMPL;
+    static const size_t BUFSIZE    = ThreadNameImpl::BUFSIZE;
+
+    /// @brief Print thread ID to the provided buffer.
+    /// The size of the destination buffer is assumed to be at least ThreadName::BUFSIZE.
+    /// @param [out] output destination buffer to get thread name
+    /// @return true on success, false on failure
+    static bool get(char* output) {
+        return ThreadNameImpl::get(output);
     }
-    static bool set(const char*) { return false; }
 
-    ThreadName(const char*)
+    static bool get(std::string& name)
     {
+        char buf[BUFSIZE];
+        bool ret = get(buf);
+        if (ret)
+            name = buf;
+        return ret;
     }
 
-    ~ThreadName() // just to make it "non-trivially-destructible" for compatibility with normal version
+    static bool set(const std::string& name) { return ThreadNameImpl::set(name.c_str()); }
+
+    explicit ThreadName(const std::string& name)
+        : impl(name)
     {
     }
 
+private:
+    ThreadName(const ThreadName&);
+    ThreadName(const char*);
+    ThreadName& operator=(const ThreadName& other);
 };
 
+} // namespace srt
 
-
-#endif
 #endif
diff --git a/srtcore/tsbpd_time.cpp b/srtcore/tsbpd_time.cpp
new file mode 100644
index 000000000..162fc7ac7
--- /dev/null
+++ b/srtcore/tsbpd_time.cpp
@@ -0,0 +1,276 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+#include "tsbpd_time.h"
+
+#include "logging.h"
+#include "logger_defs.h"
+#include "packet.h"
+
+using namespace srt_logging;
+using namespace srt::sync;
+
+namespace srt
+{
+
+#if SRT_DEBUG_TRACE_DRIFT
+class drift_logger
+{
+    typedef srt::sync::steady_clock steady_clock;
+
+public:
+    drift_logger() {}
+
+    ~drift_logger()
+    {
+        ScopedLock lck(m_mtx);
+        m_fout.close();
+    }
+
+    void trace(unsigned                                   ackack_timestamp,
+               int                                        rtt_us,
+               int64_t                                    drift_sample,
+               int64_t                                    drift,
+               int64_t                                    overdrift,
+               const srt::sync::steady_clock::time_point& pkt_base,
+               const srt::sync::steady_clock::time_point& tsbpd_base)
+    {
+        using namespace srt::sync;
+        ScopedLock lck(m_mtx);
+        create_file();
+
+        // std::string str_tnow = srt::sync::FormatTime(steady_clock::now());
+        // str_tnow.resize(str_tnow.size() - 7); // remove trailing ' [STDY]' part
+
+        std::string str_tbase = srt::sync::FormatTime(tsbpd_base);
+        str_tbase.resize(str_tbase.size() - 7); // remove trailing ' [STDY]' part
+
+        std::string str_pkt_base = srt::sync::FormatTime(pkt_base);
+        str_pkt_base.resize(str_pkt_base.size() - 7); // remove trailing ' [STDY]' part
+
+        // m_fout << str_tnow << ",";
+        m_fout << count_microseconds(steady_clock::now() - m_start_time) << ",";
+        m_fout << ackack_timestamp << ",";
+        m_fout << rtt_us << ",";
+        m_fout << drift_sample << ",";
+        m_fout << drift << ",";
+        m_fout << overdrift << ",";
+        m_fout << str_pkt_base << ",";
+        m_fout << str_tbase << "\n";
+        m_fout.flush();
+    }
+
+private:
+    void print_header()
+    {
+        m_fout << "usElapsedStd,usAckAckTimestampStd,";
+        m_fout << "usRTTStd,usDriftSampleStd,usDriftStd,usOverdriftStd,tsPktBase,TSBPDBase\n";
+    }
+
+    void create_file()
+    {
+        if (m_fout.is_open())
+            return;
+
+        m_start_time         = srt::sync::steady_clock::now();
+        std::string str_tnow = srt::sync::FormatTimeSys(m_start_time);
+        str_tnow.resize(str_tnow.size() - 7); // remove trailing ' [SYST]' part
+        while (str_tnow.find(':') != std::string::npos)
+        {
+            str_tnow.replace(str_tnow.find(':'), 1, 1, '_');
+        }
+        const std::string fname = "drift_trace_" + str_tnow + ".csv";
+        m_fout.open(fname, std::ofstream::out);
+        if (!m_fout)
+            std::cerr << "IPE: Failed to open " << fname << "!!!\n";
+
+        print_header();
+    }
+
+private:
+    srt::sync::Mutex                    m_mtx;
+    std::ofstream                       m_fout;
+    srt::sync::steady_clock::time_point m_start_time;
+};
+
+drift_logger g_drift_logger;
+
+#endif // SRT_DEBUG_TRACE_DRIFT
+
+bool CTsbpdTime::addDriftSample(uint32_t usPktTimestamp, const time_point& tsPktArrival, int usRTTSample)
+{
+    if (!m_bTsbPdMode)
+        return false;
+
+    ScopedLock lck(m_mtxRW);
+
+    // Remember the first RTT sample measured. Ideally we need RTT0 - the one from the handshaking phase,
+    // because TSBPD base is initialized there. But HS-based RTT is not yet implemented.
+    // Take the first one assuming it is close to RTT0.
+    if (m_iFirstRTT == -1)
+    {
+        m_iFirstRTT = usRTTSample;
+    }
+
+    // A change in network delay has to be taken into account. The only way to get some estimation of it
+    // is to estimate RTT change and assume that the change of the one way network delay is
+    // approximated by the half of the RTT change.
+    const duration               tdRTTDelta    = usRTTSample >= 0 ? microseconds_from((usRTTSample - m_iFirstRTT) / 2) : duration(0);
+    const time_point             tsPktBaseTime = getPktTsbPdBaseTime(usPktTimestamp);
+    const steady_clock::duration tdDrift       = tsPktArrival - tsPktBaseTime - tdRTTDelta;
+
+    const bool updated = m_DriftTracer.update(count_microseconds(tdDrift));
+
+    if (updated)
+    {
+        IF_HEAVY_LOGGING(const steady_clock::time_point oldbase = m_tsTsbPdTimeBase);
+        steady_clock::duration overdrift = microseconds_from(m_DriftTracer.overdrift());
+        m_tsTsbPdTimeBase += overdrift;
+
+        HLOGC(brlog.Debug,
+              log << "DRIFT=" << FormatDuration(tdDrift) << " AVG=" << (m_DriftTracer.drift() / 1000.0)
+                  << "ms, TB: " << FormatTime(oldbase) << " EXCESS: " << FormatDuration(overdrift)
+                  << " UPDATED TO: " << FormatTime(m_tsTsbPdTimeBase));
+    }
+    else
+    {
+        HLOGC(brlog.Debug,
+              log << "DRIFT=" << FormatDuration(tdDrift) << " TB REMAINS: " << FormatTime(m_tsTsbPdTimeBase));
+    }
+
+#if SRT_DEBUG_TRACE_DRIFT
+    g_drift_logger.trace(usPktTimestamp,
+                         usRTTSample,
+                         count_microseconds(tdDrift),
+                         m_DriftTracer.drift(),
+                         m_DriftTracer.overdrift(),
+                         tsPktBaseTime,
+                         m_tsTsbPdTimeBase);
+#endif
+    return updated;
+}
+
+void CTsbpdTime::setTsbPdMode(const steady_clock::time_point& timebase, bool wrap, duration delay)
+{
+    m_bTsbPdMode      = true;
+    m_bTsbPdWrapCheck = wrap;
+
+    // Timebase passed here comes is calculated as:
+    // Tnow - hspkt.m_iTimeStamp
+    // where hspkt is the packet with SRT_CMD_HSREQ message.
+    //
+    // This function is called in the HSREQ reception handler only.
+    m_tsTsbPdTimeBase = timebase;
+    m_tdTsbPdDelay    = delay;
+}
+
+void CTsbpdTime::applyGroupTime(const steady_clock::time_point& timebase,
+                                bool                            wrp,
+                                uint32_t                        delay,
+                                const steady_clock::duration&   udrift)
+{
+    // Same as setTsbPdMode, but predicted to be used for group members.
+    // This synchronizes the time from the INTERNAL TIMEBASE of an existing
+    // socket's internal timebase. This is required because the initial time
+    // base stays always the same, whereas the internal timebase undergoes
+    // adjustment as the 32-bit timestamps in the sockets wrap. The socket
+    // newly added to the group must get EXACTLY the same internal timebase
+    // or otherwise the TsbPd time calculation will ship different results
+    // on different member sockets.
+
+    m_bTsbPdMode = true;
+
+    m_tsTsbPdTimeBase = timebase;
+    m_bTsbPdWrapCheck = wrp;
+    m_tdTsbPdDelay    = microseconds_from(delay);
+    m_DriftTracer.forceDrift(count_microseconds(udrift));
+}
+
+void CTsbpdTime::applyGroupDrift(const steady_clock::time_point& timebase,
+                                 bool                            wrp,
+                                 const steady_clock::duration&   udrift)
+{
+    // This is only when a drift was updated on one of the group members.
+    HLOGC(brlog.Debug,
+          log << "rcv-buffer: group synch uDRIFT: " << m_DriftTracer.drift() << " -> " << FormatDuration(udrift)
+              << " TB: " << FormatTime(m_tsTsbPdTimeBase) << " -> " << FormatTime(timebase));
+
+    m_tsTsbPdTimeBase = timebase;
+    m_bTsbPdWrapCheck = wrp;
+
+    m_DriftTracer.forceDrift(count_microseconds(udrift));
+}
+
+CTsbpdTime::time_point CTsbpdTime::getTsbPdTimeBase(uint32_t timestamp_us) const
+{
+    // A data packet within [TSBPD_WRAP_PERIOD; 2 * TSBPD_WRAP_PERIOD] would end TSBPD wrap-aware state.
+    // Some incoming control packets may not update the TSBPD base (calling updateTsbPdTimeBase(..)),
+    // but may come before a data packet with a timestamp in this range. Therefore the whole range should be tracked.
+    const int64_t carryover_us =
+        (m_bTsbPdWrapCheck && timestamp_us <= 2 * TSBPD_WRAP_PERIOD) ? int64_t(CPacket::MAX_TIMESTAMP) + 1 : 0;
+
+    return (m_tsTsbPdTimeBase + microseconds_from(carryover_us));
+}
+
+CTsbpdTime::time_point CTsbpdTime::getPktTsbPdTime(uint32_t usPktTimestamp) const
+{
+    time_point value = getPktTsbPdBaseTime(usPktTimestamp) + m_tdTsbPdDelay + microseconds_from(m_DriftTracer.drift());
+
+    /*
+    HLOGC(brlog.Debug, log << "getPktTsbPdTime:"
+            << " BASE=" << FormatTime(m_tsTsbPdTimeBase)
+            << " TS=" << usPktTimestamp << "us, lat=" << FormatDuration<DUNIT_US>(m_tdTsbPdDelay)
+            << " DRF=" << m_DriftTracer.drift() << "us = " << FormatTime(value));
+            */
+
+    return value;
+}
+
+CTsbpdTime::time_point CTsbpdTime::getPktTsbPdBaseTime(uint32_t usPktTimestamp) const
+{
+    return getTsbPdTimeBase(usPktTimestamp) + microseconds_from(usPktTimestamp);
+}
+
+void CTsbpdTime::updateTsbPdTimeBase(uint32_t usPktTimestamp)
+{
+    if (m_bTsbPdWrapCheck)
+    {
+        // Wrap check period.
+        if ((usPktTimestamp >= TSBPD_WRAP_PERIOD) && (usPktTimestamp <= (TSBPD_WRAP_PERIOD * 2)))
+        {
+            /* Exiting wrap check period (if for packet delivery head) */
+            m_bTsbPdWrapCheck = false;
+            m_tsTsbPdTimeBase += microseconds_from(int64_t(CPacket::MAX_TIMESTAMP) + 1);
+            LOGC(tslog.Debug,
+                 log << "tsbpd wrap period ends with ts=" << usPktTimestamp << " - NEW TIME BASE: "
+                     << FormatTime(m_tsTsbPdTimeBase) << " drift: " << m_DriftTracer.drift() << "us");
+        }
+        return;
+    }
+
+    // Check if timestamp is within the TSBPD_WRAP_PERIOD before reaching the MAX_TIMESTAMP.
+    if (usPktTimestamp > (CPacket::MAX_TIMESTAMP - TSBPD_WRAP_PERIOD))
+    {
+        // Approching wrap around point, start wrap check period (if for packet delivery head)
+        m_bTsbPdWrapCheck = true;
+        LOGC(tslog.Debug,
+             log << "tsbpd wrap period begins with ts=" << usPktTimestamp
+                 << " TIME BASE: " << FormatTime(m_tsTsbPdTimeBase) << " drift: " << m_DriftTracer.drift() << "us.");
+    }
+}
+
+void CTsbpdTime::getInternalTimeBase(time_point& w_tb, bool& w_wrp, duration& w_udrift) const
+{
+    ScopedLock lck(m_mtxRW);
+    w_tb     = m_tsTsbPdTimeBase;
+    w_udrift = microseconds_from(m_DriftTracer.drift());
+    w_wrp    = m_bTsbPdWrapCheck;
+}
+
+} // namespace srt
diff --git a/srtcore/tsbpd_time.h b/srtcore/tsbpd_time.h
new file mode 100644
index 000000000..3483c197f
--- /dev/null
+++ b/srtcore/tsbpd_time.h
@@ -0,0 +1,163 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2021 Haivision Systems Inc.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+#ifndef INC_SRT_TSBPD_TIME_H
+#define INC_SRT_TSBPD_TIME_H
+
+#include "platform_sys.h"
+#include "sync.h"
+#include "utilities.h"
+
+namespace srt
+{
+
+/// @brief TimeStamp-Based Packet Delivery Mode (TSBPD) time conversion logic.
+/// Used by the receiver to calculate delivery time of data packets.
+/// See SRT Internet Draft Section "Timestamp-Based Packet Delivery".
+class CTsbpdTime
+{
+    typedef srt::sync::steady_clock  steady_clock;
+    typedef steady_clock::time_point time_point;
+    typedef steady_clock::duration   duration;
+    typedef srt::sync::Mutex         Mutex;
+
+public:
+    CTsbpdTime()
+        : m_iFirstRTT(-1)
+        , m_bTsbPdMode(false)
+        , m_tdTsbPdDelay(0)
+        , m_bTsbPdWrapCheck(false)
+    {
+    }
+
+    /// Set TimeStamp-Based Packet Delivery Mode (receiver).
+    /// @param [in] timebase local time base (uSec) of packet time stamps including buffering delay.
+    /// @param [in] wrap wrapping period.
+    /// @param [in] delay negotiated TsbPD delay (buffering latency).
+    void setTsbPdMode(const time_point& timebase, bool wrap, duration delay);
+
+    /// @brief Check if TSBPD logic is enabled.
+    /// @return true if TSBPD is enabled.
+    bool isEnabled() const { return m_bTsbPdMode; }
+
+    /// @brief Apply new state derived from other members of a socket group.
+    /// @param timebase TSBPD base time.
+    /// @param wrp wrap period (enabled or not).
+    /// @param delay TSBPD delay.
+    /// @param udrift clock drift.
+    void applyGroupTime(const time_point& timebase, bool wrp, uint32_t delay, const duration& udrift);
+
+    /// @brief Apply new clock state (TSBPD base and drift) derived from other members of a socket group.
+    /// @param timebase TSBPD base time.
+    /// @param wrp state of the wrapping period (enabled or disabled).
+    /// @param udrift clock drift.
+    void applyGroupDrift(const time_point& timebase, bool wrp, const duration& udrift);
+
+    /// @brief Add new drift sample from an ACK-ACKACK pair.
+    /// ACKACK packets are sent immediately (except for UDP buffering).
+    /// Therefore their timestamp roughly corresponds to the time of sending
+    /// and can be used to estimate clock drift.
+    /// 
+    /// @param [in] pktTimestamp Timestamp of the arrived ACKACK packet.
+    /// @param [in] tsPktArrival packet arrival time.
+    /// @param [in] usRTTSample RTT sample from an ACK-ACKACK pair. If no sample, pass '-1'.
+    /// 
+    /// @return true if TSBPD base time has changed, false otherwise.
+    bool addDriftSample(uint32_t pktTimestamp, const time_point& tsPktArrival, int usRTTSample);
+
+    /// @brief Handle timestamp of data packet when 32-bit integer carryover is about to happen.
+    /// When packet timestamp approaches CPacket::MAX_TIMESTAMP, the TSBPD base time should be
+    /// shifted accordingly to correctly handle new packets with timestamps starting from zero.
+    /// @param usPktTimestamp timestamp field value of a data packet.
+    void updateTsbPdTimeBase(uint32_t usPktTimestamp);
+
+    /// @brief Get TSBPD base time adjusted for carryover, which occurs when
+    /// a packet's timestamp exceeds the UINT32_MAX and continues from zero.
+    /// @param [in] usPktTimestamp 32-bit value of packet timestamp field (microseconds).
+    ///
+    /// @return TSBPD base time for a provided packet timestamp.
+    time_point getTsbPdTimeBase(uint32_t usPktTimestamp) const;
+
+    /// @brief Get packet TSBPD time without buffering delay and clock drift, which is
+    /// the target time for delivering the packet to an upstream application.
+    /// Essentially: getTsbPdTimeBase(usPktTimestamp) + usPktTimestamp
+    /// @param [in] usPktTimestamp 32-bit value of packet timestamp field (microseconds).
+    ///
+    /// @return Packet TSBPD base time without buffering delay.
+    time_point getPktTsbPdBaseTime(uint32_t usPktTimestamp) const;
+
+    /// @brief Get packet TSBPD time with buffering delay and clock drift, which is
+    /// the target time for delivering the packet to an upstream application
+    /// (including drift and carryover effects, if any).
+    /// Essentially: getPktTsbPdBaseTime(usPktTimestamp) + m_tdTsbPdDelay + drift()
+    /// @param [in] usPktTimestamp 32-bit value of packet timestamp field (microseconds).
+    ///
+    /// @return Packet TSBPD time with buffering delay.
+    time_point getPktTsbPdTime(uint32_t usPktTimestamp) const;
+
+    /// @brief Get current drift value.
+    /// @return current drift value.
+    int64_t    drift() const { return m_DriftTracer.drift(); }
+
+    /// @brief Get current overdrift value.
+    /// @return current overdrift value.
+    int64_t    overdrift() const { return m_DriftTracer.overdrift(); }
+
+    /// @brief Get internal state to apply to another member of a socket group.
+    /// @param w_tb TsbPd base time.
+    /// @param w_udrift drift value.
+    /// @param w_wrp wrap check.
+    void getInternalTimeBase(time_point& w_tb, bool& w_wrp, duration& w_udrift) const;
+
+private:
+    int        m_iFirstRTT;       // First measured RTT sample.
+    bool       m_bTsbPdMode;      // Receiver buffering and TSBPD is active when true.
+    duration   m_tdTsbPdDelay;    // Negotiated buffering delay.
+
+    /// @brief Local time base for TsbPd.
+    /// @note m_tsTsbPdTimeBase is changed in the following cases:
+    /// 1. Initialized upon SRT_CMD_HSREQ packet as the difference with the current time:
+    ///    = (NOW - PACKET_TIMESTAMP), at the time of HSREQ reception.
+    /// 2. Shifted forward on timestamp overflow (@see CTsbpdTime::updateTsbPdTimeBase), when overflow
+    ///    of the timestamp field value of a data packet is detected.
+    ///    += CPacket::MAX_TIMESTAMP + 1
+    /// 3. Clock drift (@see CTsbpdTime::addDriftSample, executed exclusively
+    ///    from ACKACK handler). This is updated with (positive or negative) TSBPD_DRIFT_MAX_VALUE
+    ///    once the value of average drift exceeds this value in either direction.
+    ///    += (+/-)TSBPD_DRIFT_MAX_VALUE
+    ///
+    /// @note The TSBPD base time is expected to hold the following condition:
+    /// (PACKET_TIMESTAMP + m_tsTsbPdTimeBase + drift) == NOW.
+    /// Then it can be used to estimate the origin time of a data packet, and calculate its delivery time
+    /// with buffering delay applied.
+    time_point m_tsTsbPdTimeBase;
+
+    /// @note Packet timestamps wrap around every 01h11m35s (32-bit in usec).
+    /// A wrap check period starts 30 seconds (TSBPD_WRAP_PERIOD) before the wrap point.
+    /// During the wrap check period, packet timestamps smaller than 30 seconds
+    /// are considered to have been wrapped around.
+    /// The wrap check period ends 30 seconds after the wrap point,
+    /// after which the TSBPD base time is adjusted.
+    bool                  m_bTsbPdWrapCheck;                  // true: check packet time stamp wraparound (overflow).
+    static const uint32_t TSBPD_WRAP_PERIOD = (30 * 1000000); // 30 seconds (in usec) for timestamp wrapping period.
+
+    /// Maximum clock drift (microseconds) above which TsbPD base time is already adjusted.
+    static const int TSBPD_DRIFT_MAX_VALUE = 5000;
+    /// Number of samples (ACKACK packets) on which to perform drift calculation and compensation.
+    static const int TSBPD_DRIFT_MAX_SAMPLES = 1000;
+    DriftTracer<TSBPD_DRIFT_MAX_SAMPLES, TSBPD_DRIFT_MAX_VALUE> m_DriftTracer;
+
+    /// Protect simultaneous change of state (read/write).
+    mutable Mutex m_mtxRW;
+};
+
+} // namespace srt
+
+#endif // INC_SRT_TSBPD_TIME_H
diff --git a/srtcore/udt.h b/srtcore/udt.h
index 1bcc889ca..ee4c02f4d 100644
--- a/srtcore/udt.h
+++ b/srtcore/udt.h
@@ -70,10 +70,10 @@ modified by
 #include "srt.h"
 
 /*
-* SRT_ENABLE_THREADCHECK (THIS IS SET IN MAKEFILE NOT HERE)
+* SRT_ENABLE_THREADCHECK IS SET IN MAKEFILE, NOT HERE
 */
 #if defined(SRT_ENABLE_THREADCHECK)
-#include <threadcheck.h>
+#include "threadcheck.h"
 #else
 #define THREAD_STATE_INIT(name)
 #define THREAD_EXIT()
@@ -82,13 +82,6 @@ modified by
 #define INCREMENT_THREAD_ITERATIONS()
 #endif
 
-/* Obsolete way to define MINGW */
-#ifndef __MINGW__
-#if defined(__MINGW32__) || defined(__MINGW64__)
-#define __MINGW__ 1
-#endif
-#endif
-
 #ifdef __cplusplus
 #include <fstream>
 #include <set>
@@ -96,7 +89,6 @@ modified by
 #include <vector>
 #endif
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 //if compiling on VC6.0 or pre-WindowsXP systems
@@ -156,12 +148,12 @@ typedef SRTSOCKET UDTSOCKET; //legacy alias
 
 #ifdef __cplusplus
 
-class CUDTException;
+namespace srt { class CUDTException; }
 
 namespace UDT
 {
 
-typedef CUDTException ERRORINFO;
+typedef srt::CUDTException ERRORINFO;
 typedef CPerfMon TRACEINFO;
 
 // This facility is used only for select() function.
@@ -257,7 +249,7 @@ namespace logging {
     using namespace srt_logging;
 }
 
-}
+} // namespace srt
 
 // Planned deprecated removal: rel1.6.0
 // There's also no portable way possible to enforce a deprecation
diff --git a/srtcore/utilities.h b/srtcore/utilities.h
index c81e5ba45..ca8c365a3 100644
--- a/srtcore/utilities.h
+++ b/srtcore/utilities.h
@@ -16,84 +16,11 @@ written by
 #ifndef INC_SRT_UTILITIES_H
 #define INC_SRT_UTILITIES_H
 
-// ATTRIBUTES:
-//
-// ATR_UNUSED: declare an entity ALLOWED to be unused (prevents warnings)
-// ATR_DEPRECATED: declare an entity deprecated (compiler should warn when used)
-// ATR_NOEXCEPT: The true `noexcept` from C++11, or nothing if compiling in pre-C++11 mode
-// ATR_NOTHROW: In C++11: `noexcept`. In pre-C++11: `throw()`. Required for GNU libstdc++.
-// ATR_CONSTEXPR: In C++11: `constexpr`. Otherwise empty.
-// ATR_OVERRIDE: In C++11: `override`. Otherwise empty.
-// ATR_FINAL: In C++11: `final`. Otherwise empty.
-
-
-#ifdef __GNUG__
-#define ATR_UNUSED __attribute__((unused))
-#define ATR_DEPRECATED __attribute__((deprecated))
-#else
-#define ATR_UNUSED
-#define ATR_DEPRECATED
-#endif
-
-#if defined(__cplusplus) && __cplusplus > 199711L
-#define HAVE_CXX11 1
-
-// For gcc 4.7, claim C++11 is supported, as long as experimental C++0x is on,
-// however it's only the "most required C++11 support".
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ == 4 && __GNUC_MINOR__ >= 7 // 4.7 only!
-#define ATR_NOEXCEPT
-#define ATR_NOTHROW throw()
-#define ATR_CONSTEXPR
-#define ATR_OVERRIDE
-#define ATR_FINAL
-#else
-#define HAVE_FULL_CXX11 1
-#define ATR_NOEXCEPT noexcept
-#define ATR_NOTHROW noexcept
-#define ATR_CONSTEXPR constexpr
-#define ATR_OVERRIDE override
-#define ATR_FINAL final
-#endif
-
-// Microsoft Visual Studio supports C++11, but not fully,
-// and still did not change the value of __cplusplus. Treat
-// this special way.
-// _MSC_VER == 1800  means Microsoft Visual Studio 2013.
-#elif defined(_MSC_VER) && _MSC_VER >= 1800
-#define HAVE_CXX11 1
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
-#define HAVE_FULL_CXX11 1
-#define ATR_NOEXCEPT noexcept
-#define ATR_NOTHROW noexcept
-#define ATR_CONSTEXPR constexpr
-#define ATR_OVERRIDE override
-#define ATR_FINAL final
-#else
-#define ATR_NOEXCEPT
-#define ATR_NOTHROW throw()
-#define ATR_CONSTEXPR
-#define ATR_OVERRIDE
-#define ATR_FINAL
-#endif
-#else
-#define HAVE_CXX11 0
-#define ATR_NOEXCEPT
-#define ATR_NOTHROW throw()
-#define ATR_CONSTEXPR
-#define ATR_OVERRIDE
-#define ATR_FINAL
-
-#endif
-
-#if !HAVE_CXX11 && defined(REQUIRE_CXX11) && REQUIRE_CXX11 == 1
-#error "The currently compiled application required C++11, but your compiler doesn't support it."
-#endif
-
-
 // Windows warning disabler
 #define _CRT_SECURE_NO_WARNINGS 1
 
 #include "platform_sys.h"
+#include "srt_attr_defs.h" // defines HAVE_CXX11
 
 // Happens that these are defined, undefine them in advance
 #undef min
@@ -108,7 +35,7 @@ written by
 #include <memory>
 #include <iomanip>
 #include <sstream>
-#include <iomanip>
+#include <utility>
 
 #if HAVE_CXX11
 #include <type_traits>
@@ -117,6 +44,7 @@ written by
 #include <cstdlib>
 #include <cerrno>
 #include <cstring>
+#include <stdexcept>
 
 // -------------- UTILITIES ------------------------
 
@@ -130,7 +58,7 @@ written by
 
 #endif
 
-#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__)
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__)
 
 #	include <endian.h>
 
@@ -188,7 +116,7 @@ written by
 
 #	include <sys/endian.h>
 
-#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 
 #	include <sys/endian.h>
 
@@ -213,6 +141,46 @@ written by
 #	define le64toh(x) letoh64(x)
 #endif
 
+#elif defined(SUNOS)
+
+   // SunOS/Solaris
+
+   #include <sys/byteorder.h>
+   #include <sys/isa_defs.h>
+
+   #define __LITTLE_ENDIAN 1234
+   #define __BIG_ENDIAN 4321
+
+   # if defined(_BIG_ENDIAN)
+   #define __BYTE_ORDER __BIG_ENDIAN
+   #define be64toh(x) (x)
+   #define be32toh(x) (x)
+   #define be16toh(x) (x)
+   #define le16toh(x) ((uint16_t)BSWAP_16(x))
+   #define le32toh(x) BSWAP_32(x)
+   #define le64toh(x) BSWAP_64(x)
+   #define htobe16(x) (x)
+   #define htole16(x) ((uint16_t)BSWAP_16(x))
+   #define htobe32(x) (x)
+   #define htole32(x) BSWAP_32(x)
+   #define htobe64(x) (x)
+   #define htole64(x) BSWAP_64(x)
+   # else
+   #define __BYTE_ORDER __LITTLE_ENDIAN
+   #define be64toh(x) BSWAP_64(x)
+   #define be32toh(x) ntohl(x)
+   #define be16toh(x) ntohs(x)
+   #define le16toh(x) (x)
+   #define le32toh(x) (x)
+   #define le64toh(x) (x)
+   #define htobe16(x) htons(x)
+   #define htole16(x) (x)
+   #define htobe32(x) htonl(x)
+   #define htole32(x) (x)
+   #define htobe64(x) BSWAP_64(x)
+   #define htole64(x) (x)
+   # endif
+
 #elif defined(__WINDOWS__)
 
 #	include <winsock2.h>
@@ -269,17 +237,20 @@ written by
 
 #endif
 
-// Hardware <--> Network (big endian) convention
+/// Hardware --> Network (big-endian) byte order conversion
+/// @param size source length in four octets
 inline void HtoNLA(uint32_t* dst, const uint32_t* src, size_t size)
 {
     for (size_t i = 0; i < size; ++ i)
-        dst[i] = htonl(src[i]);
+        dst[i] = htobe32(src[i]);
 }
 
+/// Network (big-endian) --> Hardware byte order conversion
+/// @param size source length in four octets
 inline void NtoHLA(uint32_t* dst, const uint32_t* src, size_t size)
 {
     for (size_t i = 0; i < size; ++ i)
-        dst[i] = ntohl(src[i]);
+        dst[i] = be32toh(src[i]);
 }
 
 // Hardware <--> Intel (little endian) convention
@@ -334,7 +305,7 @@ template<size_t R>
 struct BitsetMask<R, R, true>
 {
     static const bool correct = true;
-    static const uint32_t value = 1 << R;
+    static const uint32_t value = 1u << R;
 };
 
 // This is a trap for a case that BitsetMask::correct in the master template definition
@@ -443,6 +414,88 @@ struct DynamicStruct
 };
 
 
+/// Fixed-size array template class.
+namespace srt {
+
+template <class T>
+class FixedArray
+{
+public:
+    FixedArray(size_t size)
+        : m_size(size)
+        , m_entries(new T[size])
+    {
+    }
+
+    ~FixedArray()
+    {
+        delete [] m_entries;
+    }
+
+public:
+    const T& operator[](size_t index) const
+    {
+        if (index >= m_size)
+            throw_invalid_index(index);
+
+        return m_entries[index];
+    }
+
+    T& operator[](size_t index)
+    {
+        if (index >= m_size)
+            throw_invalid_index(index);
+
+        return m_entries[index];
+    }
+
+    const T& operator[](int index) const
+    {
+        if (index < 0 || static_cast<size_t>(index) >= m_size)
+            throw_invalid_index(index);
+
+        return m_entries[index];
+    }
+
+    T& operator[](int index)
+    {
+        if (index < 0 || static_cast<size_t>(index) >= m_size)
+            throw_invalid_index(index);
+
+        return m_entries[index];
+    }
+
+    size_t size() const { return m_size; }
+
+    typedef T* iterator;
+    typedef const T* const_iterator;
+
+    iterator begin() { return m_entries; }
+    iterator end() { return m_entries + m_size; }
+
+    const_iterator cbegin() const { return m_entries; }
+    const_iterator cend() const { return m_entries + m_size; }
+
+    T* data() { return m_entries; }
+
+private:
+    FixedArray(const FixedArray<T>& );
+    FixedArray<T>& operator=(const FixedArray<T>&);
+
+    void throw_invalid_index(int i) const
+    {
+        std::stringstream ss;
+        ss << "Index " << i << "out of range";
+        throw std::runtime_error(ss.str());
+    }
+
+private:
+    size_t      m_size;
+    T* const    m_entries;
+};
+
+} // namespace srt
+
 // ------------------------------------------------------------
 
 
@@ -485,6 +538,34 @@ namespace srt_pair_op
     }
 }
 
+namespace any_op
+{
+    template <class T>
+    struct AnyProxy
+    {
+        const T& value;
+        bool result;
+
+        AnyProxy(const T& x, bool res): value(x), result(res) {}
+
+        AnyProxy<T>& operator,(const T& val)
+        {
+            if (result)
+                return *this;
+            result = value == val;
+            return *this;
+        }
+
+        operator bool() { return result; }
+    };
+
+    template <class T> inline
+    AnyProxy<T> EqualAny(const T& checked_val)
+    {
+        return AnyProxy<T>(checked_val, false);
+    }
+}
+
 #if HAVE_CXX11
 
 template <class In>
@@ -498,7 +579,7 @@ inline Stream& Print(Stream& in) { return in;}
 template <class Stream, class Arg1, class... Args>
 inline Stream& Print(Stream& sout, Arg1&& arg1, Args&&... args)
 {
-    sout << arg1;
+    sout << std::forward<Arg1>(arg1);
     return Print(sout, args...);
 }
 
@@ -605,7 +686,7 @@ class UniquePtr: public std::auto_ptr<T>
     bool operator==(const element_type* two) const { return get() == two; }
     bool operator!=(const element_type* two) const { return get() != two; }
 
-    operator bool () { return 0!= get(); }
+    operator bool () const { return 0!= get(); }
 };
 
 // A primitive one-argument versions of Sprint and Printable
@@ -617,6 +698,15 @@ inline std::string Sprint(const Arg1& arg)
     return sout.str();
 }
 
+// Ok, let it be 2-arg, in case when a manipulator is needed
+template <class Arg1, class Arg2>
+inline std::string Sprint(const Arg1& arg1, const Arg2& arg2)
+{
+    std::ostringstream sout;
+    sout << arg1 << arg2;
+    return sout.str();
+}
+
 template <class Container> inline
 std::string Printable(const Container& in)
 {
@@ -699,6 +789,32 @@ inline void insert_uniq(std::vector<Value>& v, const ArgValue& val)
     v.push_back(val);
 }
 
+template <class Type1, class Type2>
+inline std::pair<Type1&, Type2&> Tie(Type1& var1, Type2& var2)
+{
+    return std::pair<Type1&, Type2&>(var1, var2);
+}
+
+// This can be used in conjunction with Tie to simplify the code
+// in loops around a whole container:
+// list<string>::const_iterator it, end;
+// Tie(it, end) = All(list_container);
+template<class Container>
+std::pair<typename Container::iterator, typename Container::iterator>
+inline All(Container& c) { return std::make_pair(c.begin(), c.end()); }
+
+template<class Container>
+std::pair<typename Container::const_iterator, typename Container::const_iterator>
+inline All(const Container& c) { return std::make_pair(c.begin(), c.end()); }
+
+
+template <class Container, class Value>
+inline void FringeValues(const Container& from, std::map<Value, size_t>& out)
+{
+    for (typename Container::const_iterator i = from.begin(); i != from.end(); ++i)
+        ++out[*i];
+}
+
 template <class Signature>
 struct CallbackHolder
 {
@@ -720,7 +836,8 @@ struct CallbackHolder
         // Casting function-to-function, however, should not. Unfortunately
         // newer compilers disallow that, too (when a signature differs), but
         // then they should better use the C++11 way, much more reliable and safer.
-        void* (*testfn)(void*) ATR_UNUSED = (void*(*)(void*))f;
+        void* (*testfn)(void*) = (void*(*)(void*))f;
+        (void)(testfn);
 #endif
         opaque = o;
         fn = f;
@@ -730,36 +847,147 @@ struct CallbackHolder
 };
 
 #define CALLBACK_CALL(holder,...) (*holder.fn)(holder.opaque, __VA_ARGS__)
+// The version of std::tie from C++11, but for pairs only.
+template <class T1, class T2>
+struct PairProxy
+{
+    T1& v1;
+    T2& v2;
+
+    PairProxy(T1& c1, T2& c2): v1(c1), v2(c2) {}
+
+    void operator=(const std::pair<T1, T2>& p)
+    {
+        v1 = p.first;
+        v2 = p.second;
+    }
+};
+
+template <class T1, class T2> inline
+PairProxy<T1, T2> Tie2(T1& v1, T2& v2)
+{
+    return PairProxy<T1, T2>(v1, v2);
+}
+
+template<class T>
+struct PassFilter
+{
+    T lower, median, upper;
+
+    bool encloses(const T& value)
+    {
+        // Throw away those that don't fit in the filter
+        return value > lower && value < upper;
+    }
+};
+
+// This utility is used in window.cpp where it is required to calculate
+// the median value basing on the value in the very middle and filtered
+// out values exceeding its range of 1/8 and 8 times. Returned is a structure
+// that shows the median and also the lower and upper value used for filtering.
+inline PassFilter<int> GetPeakRange(const int* window, int* replica, size_t size)
+{
+    // This calculation does more-less the following:
+    //
+    // 1. Having example window:
+    //  - 50, 51, 100, 55, 80, 1000, 600, 1500, 1200, 10, 90
+    // 2. This window is now sorted, but we only know the value in the middle:
+    //  - 10, 50, 51, 55, 80, [[90]], 100, 600, 1000, 1200, 1500
+    // 3. Now calculate:
+    //   - lower: 90/8 = 11.25
+    //   - upper: 90*8 = 720
+    // 4. Now calculate the arithmetic median from all these values,
+    //    but drop those from outside the <lower, upper> range:
+    //  - 10, (11<) [ 50, 51, 55, 80, 90, 100, 600, ] (>720) 1000, 1200, 1500
+    // 5. Calculate the median from the extracted range,
+    //    NOTE: the median is actually repeated once, so size is +1.
+    //
+    //    values = { 50, 51, 55, 80, 90, 100, 600 };
+    //    sum = 90 + accumulate(values); ==> 1026
+    //    median = sum/(1 + values.size()); ==> 147
+    //
+    // For comparison: the overall arithmetic median from this window == 430
+    //
+    // 6. Returned value = 1M/median
+
+    // get median value, but cannot change the original value order in the window
+    std::copy(window, window + size, replica);
+    std::nth_element(replica, replica + (size / 2), replica + size);
+    //std::sort(replica, replica + psize); <--- was used for debug, just leave it as a mark
+
+    PassFilter<int> filter;
+    filter.median = replica[size / 2];
+    filter.upper = filter.median << 3; // median*8
+    filter.lower = filter.median >> 3; // median/8
+
+    return filter;
+}
+
+// This function sums up all values in the array (from p to end),
+// except those that don't fit in the low- and high-pass filter.
+// Returned is the sum and the number of elements taken into account.
+inline std::pair<int, int> AccumulatePassFilter(const int* p, size_t size, PassFilter<int> filter)
+{
+    int count = 0;
+    int sum = 0;
+    const int* const end = p + size;
+    for (; p != end; ++p)
+    {
+        // Throw away those that don't fit in the filter
+        if (!filter.encloses(*p))
+            continue;
+
+        sum += *p;
+        ++count;
+    }
+
+    return std::make_pair(sum, count);
+}
+
+// This function sums up all values in the array (from p to end)
+// and simultaneously elements from `para`, stated it points to
+// an array of the same size. The first array is used as a driver
+// for which elements to include and which to skip, and this is done
+// for both arrays at particular index position. Returner is the sum
+// of the elements passed from the first array and from the `para`
+// array, as well as the number of included elements.
+template <class IntCount, class IntParaCount>
+inline void AccumulatePassFilterParallel(const int* p, size_t size, PassFilter<int> filter,
+        const int* para,
+        int& w_sum, IntCount& w_count, IntParaCount& w_paracount)
+{
+    IntCount count = 0;
+    int sum = 0;
+    IntParaCount parasum = 0;
+    const int* const end = p + size;
+    for (; p != end; ++p, ++para)
+    {
+        // Throw away those that don't fit in the filter
+        if (!filter.encloses(*p))
+            continue;
+
+        sum += *p;
+        parasum += *para;
+        ++count;
+    }
+    w_count = count;
+    w_sum = sum;
+    w_paracount = parasum;
+}
+
 
 inline std::string FormatBinaryString(const uint8_t* bytes, size_t size)
 {
     if ( size == 0 )
         return "";
 
-    //char buf[256];
     using namespace std;
 
     ostringstream os;
+    os << setfill('0') << setw(2) << hex << uppercase;
 
-    // I know, it's funny to use sprintf and ostringstream simultaneously,
-    // but " %02X" in iostream is: << " " << hex << uppercase << setw(2) << setfill('0') << VALUE << setw(1)
-    // Too noisy. OTOH ostringstream solves the problem of memory allocation
-    // for a string of unpredictable size.
-    //sprintf(buf, "%02X", int(bytes[0]));
-
-    os.fill('0');
-    os.width(2);
-    os.setf(ios::basefield, ios::hex);
-    os.setf(ios::uppercase);
-
-    //os << buf;
-    os << int(bytes[0]);
-
-
-    for (size_t i = 1; i < size; ++i)
+    for (size_t i = 0; i < size; ++i)
     {
-        //sprintf(buf, " %02X", int(bytes[i]));
-        //os << buf;
         os << int(bytes[i]);
     }
     return os.str();
@@ -791,11 +1019,13 @@ class DriftTracer
         m_qDriftSum += driftval;
         ++m_uDriftSpan;
 
+        // I moved it here to calculate accumulated overdrift.
+        if (CLEAR_ON_UPDATE)
+            m_qOverdrift = 0;
+
         if (m_uDriftSpan < MAX_SPAN)
             return false;
 
-        if (CLEAR_ON_UPDATE)
-            m_qOverdrift = 0;
 
         // Calculate the median of all drift values.
         // In most cases, the divisor should be == MAX_SPAN.
@@ -899,14 +1129,14 @@ struct MapProxy
     }
 };
 
+/// Print some hash-based stamp of the first 16 bytes in the buffer
 inline std::string BufferStamp(const char* mem, size_t size)
 {
     using namespace std;
     char spread[16];
 
-    int n = 16-size;
-    if (n > 0)
-        memset((spread + 16 - n), 0, n);
+    if (size < 16)
+        memset((spread + size), 0, 16 - size);
     memcpy((spread), mem, min(size_t(16), size));
 
     // Now prepare 4 cells for uint32_t.
@@ -924,9 +1154,7 @@ inline std::string BufferStamp(const char* mem, size_t size)
         }
 
     // Convert to hex string
-
     ostringstream os;
-
     os << hex << uppercase << setfill('0') << setw(8) << sum;
 
     return os.str();
@@ -1008,11 +1236,11 @@ inline ValueType avg_iir_w(ValueType old_value, ValueType new_value, size_t new_
 // This relies only on a convention, which is the following:
 //
 // V x = object.prop(); <-- get the property's value
-// object.prop(x); <-- set the property a value
+// object.set_prop(x); <-- set the property a value
 //
 // Properties might be also chained when setting:
 //
-// object.prop1(v1).prop2(v2).prop3(v3);
+// object.set_prop1(v1).set_prop2(v2).set_prop3(v3);
 //
 // Properties may be defined various even very complicated
 // ways, which is simply providing a method with body. In order
@@ -1039,6 +1267,7 @@ inline ValueType avg_iir_w(ValueType old_value, ValueType new_value, size_t new_
 #define SRTU_PROPERTY_RR(type, name, field) type name() { return field; }
 #define SRTU_PROPERTY_RO(type, name, field) type name() const { return field; }
 #define SRTU_PROPERTY_WO(type, name, field) void set_##name(type arg) { field = arg; }
+#define SRTU_PROPERTY_WO_ARG(type, name, expr) void set_##name(type arg) { expr; }
 #define SRTU_PROPERTY_WO_CHAIN(otype, type, name, field) otype& set_##name(type arg) { field = arg; return *this; }
 #define SRTU_PROPERTY_RW(type, name, field) SRTU_PROPERTY_RO(type, name, field); SRTU_PROPERTY_WO(type, name, field)
 #define SRTU_PROPERTY_RRW(type, name, field) SRTU_PROPERTY_RR(type, name, field); SRTU_PROPERTY_WO(type, name, field)
diff --git a/srtcore/version.h.in b/srtcore/version.h.in
index 72ce89bcb..c32ac1226 100644
--- a/srtcore/version.h.in
+++ b/srtcore/version.h.in
@@ -24,7 +24,7 @@ written by
 #define SRT_VERSION_MAJOR @SRT_VERSION_MAJOR@
 #define SRT_VERSION_MINOR @SRT_VERSION_MINOR@
 #define SRT_VERSION_PATCH @SRT_VERSION_PATCH@
-#cmakedefine SRT_VERSION_BUILD @APPVEYOR_BUILD_NUMBER_STRING@
+#cmakedefine SRT_VERSION_BUILD @CI_BUILD_NUMBER_STRING@
 
 #define SRT_VERSION_STRING "@SRT_VERSION@"
 #define SRT_VERSION_VALUE \
diff --git a/srtcore/window.cpp b/srtcore/window.cpp
index 6e03b5d0b..1950f7e16 100644
--- a/srtcore/window.cpp
+++ b/srtcore/window.cpp
@@ -61,6 +61,8 @@ modified by
 using namespace std;
 using namespace srt::sync;
 
+namespace srt
+{
 namespace ACKWindowTools
 {
 
@@ -77,22 +79,21 @@ void store(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t s
       r_iTail = (r_iTail + 1) % size;
 }
 
-int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t seq, int32_t& r_ack)
+int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t seq, int32_t& r_ack, const steady_clock::time_point& currtime)
 {
+   // Head has not exceeded the physical boundary of the window
    if (r_iHead >= r_iTail)
    {
-      // Head has not exceeded the physical boundary of the window
-
       for (int i = r_iTail, n = r_iHead; i < n; ++ i)
       {
-         // looking for indentical ACK Seq. No.
+         // Looking for an identical ACK Seq. No.
          if (seq == r_aSeq[i].iACKSeqNo)
          {
-            // return the Data ACK it carried
+            // Return the Data ACK it carried
             r_ack = r_aSeq[i].iACK;
 
-            // calculate RTT
-            const int rtt = count_microseconds(steady_clock::now() - r_aSeq[i].tsTimeStamp);
+            // Calculate RTT estimate
+            const int rtt = (int)count_microseconds(currtime - r_aSeq[i].tsTimeStamp);
 
             if (i + 1 == r_iHead)
             {
@@ -106,22 +107,22 @@ int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int3
          }
       }
 
-      // Bad input, the ACK node has been overwritten
+      // The record about ACK is not found in the buffer, RTT can not be calculated
       return -1;
    }
 
    // Head has exceeded the physical window boundary, so it is behind tail
-   for (int j = r_iTail, n = r_iHead + size; j < n; ++ j)
+   for (int j = r_iTail, n = r_iHead + (int)size; j < n; ++ j)
    {
-      // looking for indentical ACK seq. no.
+      // Looking for an identical ACK Seq. No.
       if (seq == r_aSeq[j % size].iACKSeqNo)
       {
-         // return Data ACK
+         // Return the Data ACK it carried
          j %= size;
          r_ack = r_aSeq[j].iACK;
 
-         // calculate RTT
-         const int rtt = count_microseconds(steady_clock::now() - r_aSeq[j].tsTimeStamp);
+         // Calculate RTT estimate
+         const int rtt = (int)count_microseconds(currtime - r_aSeq[j].tsTimeStamp);
 
          if (j == r_iHead)
          {
@@ -135,14 +136,16 @@ int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int3
       }
    }
 
-   // bad input, the ACK node has been overwritten
+   // The record about ACK is not found in the buffer, RTT can not be calculated
    return -1;
 }
-}
+
+} // namespace AckTools
+} // namespace srt
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void CPktTimeWindowTools::initializeWindowArrays(int* r_pktWindow, int* r_probeWindow, int* r_bytesWindow, size_t asize, size_t psize)
+void srt::CPktTimeWindowTools::initializeWindowArrays(int* r_pktWindow, int* r_probeWindow, int* r_bytesWindow, size_t asize, size_t psize, size_t max_payload_size)
 {
    for (size_t i = 0; i < asize; ++ i)
       r_pktWindow[i] = 1000000;   //1 sec -> 1 pkt/sec
@@ -151,103 +154,50 @@ void CPktTimeWindowTools::initializeWindowArrays(int* r_pktWindow, int* r_probeW
       r_probeWindow[k] = 1000;    //1 msec -> 1000 pkts/sec
 
    for (size_t i = 0; i < asize; ++ i)
-      r_bytesWindow[i] = CPacket::SRT_MAX_PAYLOAD_SIZE; //based on 1 pkt/sec set in r_pktWindow[i]
+      r_bytesWindow[i] = max_payload_size; //based on 1 pkt/sec set in r_pktWindow[i]
 }
 
-
-int CPktTimeWindowTools::getPktRcvSpeed_in(const int* window, int* replica, const int* abytes, size_t asize, int& bytesps)
+int srt::CPktTimeWindowTools::ceilPerMega(double value, double count)
 {
-   // get median value, but cannot change the original value order in the window
-   std::copy(window, window + asize, replica);
-   std::nth_element(replica, replica + (asize / 2), replica + asize);
-   //std::sort(replica, replica + asize);
-   int median = replica[asize / 2];
-
-   unsigned count = 0;
-   int sum = 0;
-   int upper = median << 3;
-   int lower = median >> 3;
-
-   bytesps = 0;
-   unsigned long bytes = 0;
-   const int* bp = abytes;
-   // median filtering
-   const int* p = window;
-   for (int i = 0, n = asize; i < n; ++ i)
-   {
-      if ((*p < upper) && (*p > lower))
-      {
-         ++ count;  //packet counter
-         sum += *p; //usec counter
-         bytes += (unsigned long)*bp;   //byte counter
-      }
-      ++ p;     //advance packet pointer
-      ++ bp;    //advance bytes pointer
-   }
+    static const double MEGA = 1000.0 * 1000.0;
+    return ::ceil(MEGA / (value / count));
+}
 
-   // claculate speed, or return 0 if not enough valid value
-   if (count > (asize >> 1))
-   {
-      bytes += (CPacket::SRT_DATA_HDR_SIZE * count); //Add protocol headers to bytes received
-      bytesps = (unsigned long)ceil(1000000.0 / (double(sum) / double(bytes)));
-      return (int)ceil(1000000.0 / (sum / count));
-   }
-   else
-   {
-      bytesps = 0;
-      return 0;
-   }
+int srt::CPktTimeWindowTools::getPktRcvSpeed_in(const int* window, int* replica, const int* abytes, size_t asize, size_t hdr_size, int& w_bytesps)
+{
+    PassFilter<int> filter = GetPeakRange(window, replica, asize);
+
+    unsigned count = 0;
+    int sum = 0;
+
+    w_bytesps = 0;
+    unsigned long bytes = 0;
+    // // (explicit specialization due to problems on MSVC 2013 and 2015)
+    AccumulatePassFilterParallel<unsigned, unsigned long>(window, asize, filter, abytes,
+            (sum), (count), (bytes));
+
+    // claculate speed, or return 0 if not enough valid value
+    if (count <= (asize/2))
+    {
+        w_bytesps = 0;
+        return 0;
+    }
+
+    bytes += (hdr_size * count); //Add protocol headers to bytes received
+    w_bytesps = ceilPerMega(sum, bytes);
+    return ceilPerMega(sum, count);
 }
 
-int CPktTimeWindowTools::getBandwidth_in(const int* window, int* replica, size_t psize)
+int srt::CPktTimeWindowTools::getBandwidth_in(const int* window, int* replica, size_t psize)
 {
-    // This calculation does more-less the following:
-    //
-    // 1. Having example window:
-    //  - 50, 51, 100, 55, 80, 1000, 600, 1500, 1200, 10, 90
-    // 2. This window is now sorted, but we only know the value in the middle:
-    //  - 10, 50, 51, 55, 80, [[90]], 100, 600, 1000, 1200, 1500
-    // 3. Now calculate:
-    //   - lower: 90/8 = 11.25
-    //   - upper: 90*8 = 720
-    // 4. Now calculate the arithmetic median from all these values,
-    //    but drop those from outside the <lower, upper> range:
-    //  - 10, (11<) [ 50, 51, 55, 80, 90, 100, 600, ] (>720) 1000, 1200, 1500
-    // 5. Calculate the median from the extracted range,
-    //    NOTE: the median is actually repeated once, so size is +1.
-    //
-    //    values = { 50, 51, 55, 80, 90, 100, 600 };
-    //    sum = 90 + accumulate(values); ==> 1026
-    //    median = sum/(1 + values.size()); ==> 147
-    //
-    // For comparison: the overall arithmetic median from this window == 430
-    //
-    // 6. Returned value = 1M/median
-
-   // get median value, but cannot change the original value order in the window
-   std::copy(window, window + psize - 1, replica);
-   std::nth_element(replica, replica + (psize / 2), replica + psize - 1);
-   //std::sort(replica, replica + psize); <--- was used for debug, just leave it as a mark
-   int median = replica[psize / 2];
-
-   int count = 1;
-   int sum = median;
-   int upper = median << 3; // median*8
-   int lower = median >> 3; // median/8
-
-   // median filtering
-   const int* p = window;
-   for (int i = 0, n = psize; i < n; ++ i)
-   {
-      if ((*p < upper) && (*p > lower))
-      {
-         ++ count;
-         sum += *p;
-      }
-      ++ p;
-   }
+    PassFilter<int> filter = GetPeakRange(window, replica, psize);
+
+    int sum, count;
+    Tie2(sum, count) = AccumulatePassFilter(window, psize, filter);
+    sum   += filter.median;
+    count += 1;
 
-   return (int)ceil(1000000.0 / (double(sum) / double(count)));
+    return ceilPerMega(sum, count);
 }
 
 
diff --git a/srtcore/window.h b/srtcore/window.h
index 20b2374dc..dbe4b7179 100644
--- a/srtcore/window.h
+++ b/srtcore/window.h
@@ -58,20 +58,23 @@ modified by
    #include <sys/time.h>
    #include <time.h>
 #endif
-#include "udt.h"
 #include "packet.h"
+#include "udt.h"
+
+namespace srt
+{
 
 namespace ACKWindowTools
 {
    struct Seq
    {
-       int32_t iACKSeqNo;       // Seq. No. for the ACK packet
-       int32_t iACK;            // Data Seq. No. carried by the ACK packet
-       srt::sync::steady_clock::time_point tsTimeStamp;      // The timestamp when the ACK was sent
+       int32_t iACKSeqNo;                                   // Seq. No. of the ACK packet
+       int32_t iACK;                                        // Data packet Seq. No. carried by the ACK packet
+       sync::steady_clock::time_point tsTimeStamp;     // The timestamp when the ACK was sent
    };
 
    void store(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t seq, int32_t ack);
-   int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t seq, int32_t& r_ack);
+   int acknowledge(Seq* r_aSeq, const size_t size, int& r_iHead, int& r_iTail, int32_t seq, int32_t& r_ack, const sync::steady_clock::time_point& currtime);
 }
 
 template <size_t SIZE>
@@ -89,22 +92,24 @@ class CACKWindow
    ~CACKWindow() {}
 
       /// Write an ACK record into the window.
-      /// @param [in] seq ACK seq. no.
-      /// @param [in] ack DATA ACK no.
+      /// @param [in] seq Seq. No. of the ACK packet
+      /// @param [in] ack Data packet Seq. No. carried by the ACK packet
 
    void store(int32_t seq, int32_t ack)
    {
        return ACKWindowTools::store(m_aSeq, SIZE, m_iHead, m_iTail, seq, ack);
    }
 
-      /// Search the ACK-2 "seq" in the window, find out the DATA "ack" and caluclate RTT .
-      /// @param [in] seq ACK-2 seq. no.
-      /// @param [out] ack the DATA ACK no. that matches the ACK-2 no.
-      /// @return RTT.
+      /// Search the ACKACK "seq" in the window, find out the data packet "ack"
+      /// and calculate RTT estimate based on the ACK/ACKACK pair
+      /// @param [in] seq Seq. No. of the ACK packet carried within ACKACK
+      /// @param [out] ack Acknowledged data packet Seq. No. from the ACK packet that matches the ACKACK
+      /// @param [in] currtime The timestamp of ACKACK packet reception by the receiver
+      /// @return RTT
 
-   int acknowledge(int32_t seq, int32_t& r_ack)
+   int acknowledge(int32_t seq, int32_t& r_ack, const sync::steady_clock::time_point& currtime)
    {
-       return ACKWindowTools::acknowledge(m_aSeq, SIZE, m_iHead, m_iTail, seq, r_ack);
+       return ACKWindowTools::acknowledge(m_aSeq, SIZE, m_iHead, m_iTail, seq, r_ack, currtime);
    }
 
 private:
@@ -112,7 +117,7 @@ class CACKWindow
    typedef ACKWindowTools::Seq Seq;
 
    Seq m_aSeq[SIZE];
-   int m_iHead;                 // Pointer to the lastest ACK record
+   int m_iHead;                 // Pointer to the latest ACK record
    int m_iTail;                 // Pointer to the oldest ACK record
 
 private:
@@ -125,10 +130,12 @@ class CACKWindow
 class CPktTimeWindowTools
 {
 public:
-   static int getPktRcvSpeed_in(const int* window, int* replica, const int* bytes, size_t asize, int& bytesps);
+   static int getPktRcvSpeed_in(const int* window, int* replica, const int* bytes, size_t asize, size_t hsize, int& bytesps);
    static int getBandwidth_in(const int* window, int* replica, size_t psize);
 
-   static void initializeWindowArrays(int* r_pktWindow, int* r_probeWindow, int* r_bytesWindow, size_t asize, size_t psize);
+   static void initializeWindowArrays(int* r_pktWindow, int* r_probeWindow, int* r_bytesWindow, size_t asize, size_t psize, size_t max_payload_size);
+
+   static int ceilPerMega(double value, double count);
 };
 
 template <size_t ASIZE = 16, size_t PSIZE = 16>
@@ -143,15 +150,16 @@ class CPktTimeWindow: CPktTimeWindowTools
         m_iProbeWindowPtr(0),
         m_iLastSentTime(0),
         m_iMinPktSndInt(1000000),
-        m_tsLastArrTime(srt::sync::steady_clock::now()),
+        m_tsLastArrTime(sync::steady_clock::now()),
         m_tsCurrArrTime(),
         m_tsProbeTime(),
-        m_Probe1Sequence(SRT_SEQNO_NONE)
+        m_Probe1Sequence(SRT_SEQNO_NONE),
+        m_zPayloadSize(0),
+        m_zHeaderSize(0)
     {
         // Exception: up to CUDT ctor
-        srt::sync::setupMutex(m_lockPktWindow, "PktWindow");
-        srt::sync::setupMutex(m_lockProbeWindow, "ProbeWindow");
-        CPktTimeWindowTools::initializeWindowArrays(m_aPktWindow, m_aProbeWindow, m_aBytesWindow, ASIZE, PSIZE);
+        sync::setupMutex(m_lockPktWindow, "PktWindow");
+        sync::setupMutex(m_lockProbeWindow, "ProbeWindow");
     }
 
    ~CPktTimeWindow()
@@ -169,11 +177,12 @@ class CPktTimeWindow: CPktTimeWindowTools
 
    int getPktRcvSpeed(int& w_bytesps) const
    {
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
        // Lock access to the packet Window
-       srt::sync::ScopedLock cg(m_lockPktWindow);
+       sync::ScopedLock cg(m_lockPktWindow);
 
        int pktReplica[ASIZE];          // packet information window (inter-packet time)
-       return getPktRcvSpeed_in(m_aPktWindow, pktReplica, m_aBytesWindow, ASIZE, (w_bytesps));
+       return getPktRcvSpeed_in(m_aPktWindow, pktReplica, m_aBytesWindow, ASIZE, m_zHeaderSize, (w_bytesps));
    }
 
    int getPktRcvSpeed() const
@@ -187,8 +196,9 @@ class CPktTimeWindow: CPktTimeWindowTools
 
    int getBandwidth() const
    {
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
        // Lock access to the packet Window
-       srt::sync::ScopedLock cg(m_lockProbeWindow);
+       sync::ScopedLock cg(m_lockProbeWindow);
 
        int probeReplica[PSIZE];
        return getBandwidth_in(m_aProbeWindow, probeReplica, PSIZE);
@@ -199,6 +209,7 @@ class CPktTimeWindow: CPktTimeWindowTools
 
    void onPktSent(int currtime)
    {
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
        int interval = currtime - m_iLastSentTime;
 
        if ((interval < m_iMinPktSndInt) && (interval > 0))
@@ -211,12 +222,13 @@ class CPktTimeWindow: CPktTimeWindowTools
 
    void onPktArrival(int pktsz = 0)
    {
-       srt::sync::ScopedLock cg(m_lockPktWindow);
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
+       sync::ScopedLock cg(m_lockPktWindow);
 
-       m_tsCurrArrTime = srt::sync::steady_clock::now();
+       m_tsCurrArrTime = sync::steady_clock::now();
 
        // record the packet interval between the current and the last one
-       m_aPktWindow[m_iPktWindowPtr] = srt::sync::count_microseconds(m_tsCurrArrTime - m_tsLastArrTime);
+       m_aPktWindow[m_iPktWindowPtr] = (int) sync::count_microseconds(m_tsCurrArrTime - m_tsLastArrTime);
        m_aBytesWindow[m_iPktWindowPtr] = pktsz;
 
        // the window is logically circular
@@ -231,7 +243,8 @@ class CPktTimeWindow: CPktTimeWindowTools
    /// Shortcut to test a packet for possible probe 1 or 2
    void probeArrival(const CPacket& pkt, bool unordered)
    {
-       const int inorder16 = pkt.m_iSeqNo & PUMASK_SEQNO_PROBE;
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
+       const int inorder16 = pkt.seqno() & PUMASK_SEQNO_PROBE;
 
        // for probe1, we want 16th packet
        if (inorder16 == 0)
@@ -252,7 +265,8 @@ class CPktTimeWindow: CPktTimeWindowTools
    /// Record the arrival time of the first probing packet.
    void probe1Arrival(const CPacket& pkt, bool unordered)
    {
-       if (unordered && pkt.m_iSeqNo == m_Probe1Sequence)
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
+       if (unordered && pkt.seqno() == m_Probe1Sequence)
        {
            // Reset the starting probe into "undefined", when
            // a packet has come as retransmitted before the
@@ -261,14 +275,15 @@ class CPktTimeWindow: CPktTimeWindowTools
            return;
        }
 
-       m_tsProbeTime = srt::sync::steady_clock::now();
-       m_Probe1Sequence = pkt.m_iSeqNo; // Record the sequence where 16th packet probe was taken
+       m_tsProbeTime = sync::steady_clock::now();
+       m_Probe1Sequence = pkt.seqno(); // Record the sequence where 16th packet probe was taken
    }
 
    /// Record the arrival time of the second probing packet and the interval between packet pairs.
 
    void probe2Arrival(const CPacket& pkt)
    {
+       SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
        // Reject probes that don't refer to the very next packet
        // towards the one that was lately notified by probe1Arrival.
        // Otherwise the result can be stupid.
@@ -277,16 +292,16 @@ class CPktTimeWindow: CPktTimeWindowTools
        // expected packet pair, behave as if the 17th packet was lost.
 
        // no start point yet (or was reset) OR not very next packet
-       if (m_Probe1Sequence == SRT_SEQNO_NONE || CSeqNo::incseq(m_Probe1Sequence) != pkt.m_iSeqNo)
+       if (m_Probe1Sequence == SRT_SEQNO_NONE || CSeqNo::incseq(m_Probe1Sequence) != pkt.seqno())
            return;
 
        // Grab the current time before trying to acquire
        // a mutex. This might add extra delay and therefore
        // screw up the measurement.
-       const srt::sync::steady_clock::time_point now = srt::sync::steady_clock::now();
+       const sync::steady_clock::time_point now = sync::steady_clock::now();
 
        // Lock access to the packet Window
-       srt::sync::ScopedLock cg(m_lockProbeWindow);
+       sync::ScopedLock cg(m_lockProbeWindow);
 
        m_tsCurrArrTime = now;
 
@@ -296,8 +311,8 @@ class CPktTimeWindow: CPktTimeWindowTools
 
        // record the probing packets interval
        // Adjust the time for what a complete packet would have take
-       const int64_t timediff = srt::sync::count_microseconds(m_tsCurrArrTime - m_tsProbeTime);
-       const int64_t timediff_times_pl_size = timediff * CPacket::SRT_MAX_PAYLOAD_SIZE;
+       const int64_t timediff = sync::count_microseconds(m_tsCurrArrTime - m_tsProbeTime);
+       const int64_t timediff_times_pl_size = timediff * m_zPayloadSize;
 
        // Let's take it simpler than it is coded here:
        // (stating that a packet has never zero size)
@@ -310,7 +325,7 @@ class CPktTimeWindow: CPktTimeWindowTools
        // the ETH+IP+UDP+SRT header part elliminates the constant packet delivery time influence.
        //
        const size_t pktsz = pkt.getLength();
-       m_aProbeWindow[m_iProbeWindowPtr] = pktsz ? timediff_times_pl_size / pktsz : int(timediff);
+       m_aProbeWindow[m_iProbeWindowPtr] = pktsz ? int(timediff_times_pl_size / pktsz) : int(timediff);
 
        // OLD CODE BEFORE BSTATS:
        // record the probing packets interval
@@ -322,28 +337,40 @@ class CPktTimeWindow: CPktTimeWindowTools
            m_iProbeWindowPtr = 0;
    }
 
+   // Late initialization because these sizes aren't known at construction time of the parent CUDT class.
+   void initialize(size_t h, size_t s)
+   {
+       m_zHeaderSize = h;
+       m_zPayloadSize = s;
+       CPktTimeWindowTools::initializeWindowArrays(m_aPktWindow, m_aProbeWindow, m_aBytesWindow, ASIZE, PSIZE, s);
+   }
+
 private:
-   int m_aPktWindow[ASIZE];          // packet information window (inter-packet time)
-   int m_aBytesWindow[ASIZE];        // 
-   int m_iPktWindowPtr;         // position pointer of the packet info. window.
-   mutable srt::sync::Mutex m_lockPktWindow; // used to synchronize access to the packet window
+   int m_aPktWindow[ASIZE];                            // Packet information window (inter-packet time)
+   int m_aBytesWindow[ASIZE];
+   int m_iPktWindowPtr;                                // Position pointer of the packet info. window
+   mutable sync::Mutex m_lockPktWindow;                // Used to synchronize access to the packet window
+
+   int m_aProbeWindow[PSIZE];                          // Record inter-packet time for probing packet pairs
+   int m_iProbeWindowPtr;                              // Position pointer to the probing window
+   mutable sync::Mutex m_lockProbeWindow;              // Used to synchronize access to the probe window
 
-   int m_aProbeWindow[PSIZE];        // record inter-packet time for probing packet pairs
-   int m_iProbeWindowPtr;       // position pointer to the probing window
-   mutable srt::sync::Mutex m_lockProbeWindow; // used to synchronize access to the probe window
+   int m_iLastSentTime;                                // Last packet sending time
+   int m_iMinPktSndInt;                                // Minimum packet sending interval
 
-   int m_iLastSentTime;         // last packet sending time
-   int m_iMinPktSndInt;         // Minimum packet sending interval
+   sync::steady_clock::time_point m_tsLastArrTime;     // Last packet arrival time
+   sync::steady_clock::time_point m_tsCurrArrTime;     // Current packet arrival time
+   sync::steady_clock::time_point m_tsProbeTime;       // Arrival time of the first probing packet
+   int32_t m_Probe1Sequence;                           // Sequence number for which the arrival time was notified
 
-   srt::sync::steady_clock::time_point m_tsLastArrTime;      // last packet arrival time
-   srt::sync::steady_clock::time_point m_tsCurrArrTime;      // current packet arrival time
-   srt::sync::steady_clock::time_point m_tsProbeTime;        // arrival time of the first probing packet
-   int32_t m_Probe1Sequence;    // sequence number for which the arrival time was notified
+   size_t m_zPayloadSize;
+   size_t m_zHeaderSize;
 
 private:
    CPktTimeWindow(const CPktTimeWindow&);
    CPktTimeWindow &operator=(const CPktTimeWindow&);
 };
 
+} // namespace srt
 
 #endif
diff --git a/test/TESTS_HOWTO.md b/test/TESTS_HOWTO.md
new file mode 100644
index 000000000..e12d91d6e
--- /dev/null
+++ b/test/TESTS_HOWTO.md
@@ -0,0 +1,107 @@
+# Rules for writing tests for SRT
+
+## 1. Use automatic startup/cleanup management
+
+Note that most of the test require SRT library to be initialized for the
+time of running the test. There are two methods how you can do it:
+
+* In a free test (`TEST` macro), declare this in the beginning:
+`srt::TestInit srtinit;`
+
+* In a fixture (`TEST_F` macro), draw your class off `srt::Test`
+(instead of `testing::Test`)
+
+In the fixture case you should also use names `setup/teardown` instead of
+`SetUp/TearDown`. Both these things will properly initialize and destroy the
+library resources.
+
+## 2. Do not misuse ASSERT macros
+
+**Be careful** where you are using `ASSERT_*` macros. In distinction to
+`EXPECT_*` macros, they interrupt the testing procedure by throwing an exception.
+This means that if this fires, nothing will be executed up to the end of the
+current testing procedure, unless it's a destructor of some object constructed
+inside the procedure.
+
+This means, however, that if you have any resource deallocation procedures, which
+must be placed there for completion regardless of the test result, the call to
+`ASSERT_*` macro will skip them, which may often lead to misexecution of the
+remaining tests and have them falsely failed. If this interruption is necessary,
+there are the following methods you can use to prevent skipping resource cleanup:
+
+* Do not cleanup anything in the testing procedure. Use the fixture's teardown
+method for any cleaning. Remember also that it is not allowed to use `ASSERT_*`
+macros in the teardown procedure, should you need to test additionally to the
+cleanup.
+
+* You can also use a local class with a destructor so that cleanups will execute
+no matter what happened inside the procedure
+
+* Last resort, keep the code that might use `ASSERT_*` macro in the try-catch
+block and free the resources in the `catch` clause, then rethrow the exception.
+A disadvantage of this solution is that you'll have to repeat the cleanup
+procedure outside the try-catch block.
+
+* Use `EXPECT_` macros, but still check the condition again and skip required
+parts of the test that could not be done without this resource.
+
+# Useful SRT test features
+
+## Test command line parameters
+
+The SRT tests support command-line parameters. They are available in test
+procedures, startups, and through this you can control some execution
+aspects. The gtest-specific options are being removed from the command
+line by the gtest library itself; all other parameters are available for
+the user. The main API access function for this is `srt::TestEnv`. This
+is a fixed singleton object accessed through `srt::TestEnv::me` pointer.
+These arguments are accessible through two fields:
+
+* `TestEnv::args`: a plain vector with all the command line arguments
+* `TestEnv::argmap`: a map of arguments parsed according to the option syntax
+
+The option syntax is the following:
+
+* `-option` : single option without argument; can be tested for presence
+* `-option param1 param2 param3` : multiple parameters assigned to an option
+
+Special markers:
+
+* `--`: end of options
+* `-/`: end of parameters for the current option
+
+To specify free parameters after an option (and possibly its own parameters),
+end the parameter list with the `-/` phrase. The `--` phrase means that the
+rest of command line parameters are arguments for the last specified option,
+even if they start with a dash. Note that a single dash has no special meaning.
+
+The `TestEnv::argmap` is using option names (except the initial dash) as keys
+and the value is a vector of the parameters specified after the option. Free
+parameters are collected under an empty string key. For convenience you can
+also use two `TestEnv` helper methods:
+
+* `OptionPresent(name)`: returns true if the option of `name` is present in the
+map (note that options without parameters have simply an empty vector assigned)
+
+* `OptionValue(name)`: returns a string that contains all parameters for that
+option separated by a space (note that the value type in the map is a vector
+of strings)
+
+## Test environment feature checks
+
+The macro `SRTST_REQUIRE` can be used to check if particular feature of the
+test environment is available. This binds to the `TestEnv::Available_FEATURE`
+option if used as `SRTST_REQUIRE(FEATURE)`. This macro makes the test function
+exit immediately with success. The checking function should take care of
+printing appropriate information about that the test was forcefully passed.
+
+To add more environment availability features, add more `TestEnv::Available_*`
+methods. Methods must return `bool`, but may have parameters, which are passed
+next to the first argument in the macro transparently. Availability can be
+tested internally, or taken as a good deal basing on options, as it is
+currently done with the IPv6 feature - it is declared as not available when the
+test application gets the `-disable-ipv6` option.
+
+It is unknown what future tests could require particular system features,
+so this solution is open for further extensions.
+
diff --git a/test/any.hpp b/test/any.hpp
new file mode 100644
index 000000000..9ecb96cc5
--- /dev/null
+++ b/test/any.hpp
@@ -0,0 +1,504 @@
+//
+// Implementation of N4562 std::experimental::any (merged into C++17) for C++11 compilers.
+//
+// See also:
+//   + http://en.cppreference.com/w/cpp/any
+//   + http://en.cppreference.com/w/cpp/experimental/any
+//   + http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4562.html#any
+//   + https://cplusplus.github.io/LWG/lwg-active.html#2509
+//
+//
+// Copyright (c) 2016 Denilson das Mercês Amorim
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef LINB_ANY_HPP
+#define LINB_ANY_HPP
+#pragma once
+#include <typeinfo>
+#include <type_traits>
+#include <stdexcept>
+
+
+#if defined(PARTICLE)
+#if !defined(__cpp_exceptions) && !defined(ANY_IMPL_NO_EXCEPTIONS) && !defined(ANY_IMPL_EXCEPTIONS)
+#   define ANY_IMPL_NO_EXCEPTIONS
+# endif
+#else
+// you can opt-out of exceptions by defining ANY_IMPL_NO_EXCEPTIONS,
+// but you must ensure not to cast badly when passing an `any' object to any_cast<T>(any)
+#endif
+
+#if defined(PARTICLE)
+#if !defined(__cpp_rtti) && !defined(ANY_IMPL_NO_RTTI) && !defined(ANY_IMPL_RTTI)
+#   define ANY_IMPL_NO_RTTI
+# endif
+#else
+// you can opt-out of RTTI by defining ANY_IMPL_NO_RTTI,
+// in order to disable functions working with the typeid of a type
+#endif
+
+
+namespace linb
+{
+
+class bad_any_cast : public std::bad_cast
+{
+public:
+    const char* what() const noexcept override
+    {
+        return "bad any cast";
+    }
+};
+
+class any final
+{
+public:
+    /// Constructs an object of type any with an empty state.
+    any() :
+        vtable(nullptr)
+    {
+    }
+
+    /// Constructs an object of type any with an equivalent state as other.
+    any(const any& rhs) :
+        vtable(rhs.vtable)
+    {
+        if(!rhs.empty())
+        {
+            rhs.vtable->copy(rhs.storage, this->storage);
+        }
+    }
+
+    /// Constructs an object of type any with a state equivalent to the original state of other.
+    /// rhs is left in a valid but otherwise unspecified state.
+    any(any&& rhs) noexcept :
+        vtable(rhs.vtable)
+    {
+        if(!rhs.empty())
+        {
+            rhs.vtable->move(rhs.storage, this->storage);
+            rhs.vtable = nullptr;
+        }
+    }
+
+    /// Same effect as this->clear().
+    ~any()
+    {
+        this->clear();
+    }
+
+    /// Constructs an object of type any that contains an object of type T direct-initialized with std::forward<ValueType>(value).
+    ///
+    /// T shall satisfy the CopyConstructible requirements, otherwise the program is ill-formed.
+    /// This is because an `any` may be copy constructed into another `any` at any time, so a copy should always be allowed.
+    template<typename ValueType, typename = typename std::enable_if<!std::is_same<typename std::decay<ValueType>::type, any>::value>::type>
+    any(ValueType&& value)
+    {
+        static_assert(std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
+            "T shall satisfy the CopyConstructible requirements.");
+        this->construct(std::forward<ValueType>(value));
+    }
+
+    /// Has the same effect as any(rhs).swap(*this). No effects if an exception is thrown.
+    any& operator=(const any& rhs)
+    {
+        any(rhs).swap(*this);
+        return *this;
+    }
+
+    /// Has the same effect as any(std::move(rhs)).swap(*this).
+    ///
+    /// The state of *this is equivalent to the original state of rhs and rhs is left in a valid
+    /// but otherwise unspecified state.
+    any& operator=(any&& rhs) noexcept
+    {
+        any(std::move(rhs)).swap(*this);
+        return *this;
+    }
+
+    /// Has the same effect as any(std::forward<ValueType>(value)).swap(*this). No effect if a exception is thrown.
+    ///
+    /// T shall satisfy the CopyConstructible requirements, otherwise the program is ill-formed.
+    /// This is because an `any` may be copy constructed into another `any` at any time, so a copy should always be allowed.
+    template<typename ValueType, typename = typename std::enable_if<!std::is_same<typename std::decay<ValueType>::type, any>::value>::type>
+    any& operator=(ValueType&& value)
+    {
+        static_assert(std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
+            "T shall satisfy the CopyConstructible requirements.");
+        any(std::forward<ValueType>(value)).swap(*this);
+        return *this;
+    }
+
+    /// If not empty, destroys the contained object.
+    void clear() noexcept
+    {
+        if(!empty())
+        {
+            this->vtable->destroy(storage);
+            this->vtable = nullptr;
+        }
+    }
+
+    /// Returns true if *this has no contained object, otherwise false.
+    bool empty() const noexcept
+    {
+        return this->vtable == nullptr;
+    }
+
+#ifndef ANY_IMPL_NO_RTTI
+    /// If *this has a contained object of type T, typeid(T); otherwise typeid(void).
+    const std::type_info& type() const noexcept
+    {
+        return empty()? typeid(void) : this->vtable->type();
+    }
+#endif
+
+    /// Exchange the states of *this and rhs.
+    void swap(any& rhs) noexcept
+    {
+        if(this->vtable != rhs.vtable)
+        {
+            any tmp(std::move(rhs));
+
+            // move from *this to rhs.
+            rhs.vtable = this->vtable;
+            if(this->vtable != nullptr)
+            {
+                this->vtable->move(this->storage, rhs.storage);
+                //this->vtable = nullptr; -- unneeded, see below
+            }
+
+            // move from tmp (previously rhs) to *this.
+            this->vtable = tmp.vtable;
+            if(tmp.vtable != nullptr)
+            {
+                tmp.vtable->move(tmp.storage, this->storage);
+                tmp.vtable = nullptr;
+            }
+        }
+        else // same types
+        {
+            if(this->vtable != nullptr)
+                this->vtable->swap(this->storage, rhs.storage);
+        }
+    }
+
+private: // Storage and Virtual Method Table
+    union storage_union
+    {
+        using stack_storage_t = typename std::aligned_storage<2 * sizeof(void*), std::alignment_of<void*>::value>::type;
+
+        void*               dynamic;
+        stack_storage_t     stack;      // 2 words for e.g. shared_ptr
+    };
+
+    /// Base VTable specification.
+    struct vtable_type
+    {
+        // Note: The caller is responssible for doing .vtable = nullptr after destructful operations
+        // such as destroy() and/or move().
+
+#ifndef ANY_IMPL_NO_RTTI
+        /// The type of the object this vtable is for.
+        const std::type_info& (*type)() noexcept;
+#endif
+
+        /// Destroys the object in the union.
+        /// The state of the union after this call is unspecified, caller must ensure not to use src anymore.
+        void(*destroy)(storage_union&) noexcept;
+
+        /// Copies the **inner** content of the src union into the yet unitialized dest union.
+        /// As such, both inner objects will have the same state, but on separate memory locations.
+        void(*copy)(const storage_union& src, storage_union& dest);
+
+        /// Moves the storage from src to the yet unitialized dest union.
+        /// The state of src after this call is unspecified, caller must ensure not to use src anymore.
+        void(*move)(storage_union& src, storage_union& dest) noexcept;
+
+        /// Exchanges the storage between lhs and rhs.
+        void(*swap)(storage_union& lhs, storage_union& rhs) noexcept;
+    };
+
+    /// VTable for dynamically allocated storage.
+    template<typename T>
+    struct vtable_dynamic
+    {
+#ifndef ANY_IMPL_NO_RTTI
+        static const std::type_info& type() noexcept
+        {
+            return typeid(T);
+        }
+#endif
+
+        static void destroy(storage_union& storage) noexcept
+        {
+            //assert(reinterpret_cast<T*>(storage.dynamic));
+            delete reinterpret_cast<T*>(storage.dynamic);
+        }
+
+        static void copy(const storage_union& src, storage_union& dest)
+        {
+            dest.dynamic = new T(*reinterpret_cast<const T*>(src.dynamic));
+        }
+
+        static void move(storage_union& src, storage_union& dest) noexcept
+        {
+            dest.dynamic = src.dynamic;
+            src.dynamic = nullptr;
+        }
+
+        static void swap(storage_union& lhs, storage_union& rhs) noexcept
+        {
+            // just exchage the storage pointers.
+            std::swap(lhs.dynamic, rhs.dynamic);
+        }
+    };
+
+    /// VTable for stack allocated storage.
+    template<typename T>
+    struct vtable_stack
+    {
+#ifndef ANY_IMPL_NO_RTTI
+        static const std::type_info& type() noexcept
+        {
+            return typeid(T);
+        }
+#endif
+
+        static void destroy(storage_union& storage) noexcept
+        {
+            reinterpret_cast<T*>(&storage.stack)->~T();
+        }
+
+        static void copy(const storage_union& src, storage_union& dest)
+        {
+            new (&dest.stack) T(reinterpret_cast<const T&>(src.stack));
+        }
+
+        static void move(storage_union& src, storage_union& dest) noexcept
+        {
+            // one of the conditions for using vtable_stack is a nothrow move constructor,
+            // so this move constructor will never throw a exception.
+            new (&dest.stack) T(std::move(reinterpret_cast<T&>(src.stack)));
+            destroy(src);
+        }
+
+        static void swap(storage_union& lhs, storage_union& rhs) noexcept
+        {
+            storage_union tmp_storage;
+            move(rhs, tmp_storage);
+            move(lhs, rhs);
+            move(tmp_storage, lhs);
+        }
+    };
+
+    /// Whether the type T must be dynamically allocated or can be stored on the stack.
+    template<typename T>
+    struct requires_allocation :
+        std::integral_constant<bool,
+                !(std::is_nothrow_move_constructible<T>::value      // N4562 §6.3/3 [any.class]
+                  && sizeof(T) <= sizeof(storage_union::stack)
+                  && std::alignment_of<T>::value <= std::alignment_of<storage_union::stack_storage_t>::value)>
+    {};
+
+    /// Returns the pointer to the vtable of the type T.
+    template<typename T>
+    static vtable_type* vtable_for_type()
+    {
+        using VTableType = typename std::conditional<requires_allocation<T>::value, vtable_dynamic<T>, vtable_stack<T>>::type;
+        static vtable_type table = {
+#ifndef ANY_IMPL_NO_RTTI
+            VTableType::type,
+#endif
+            VTableType::destroy,
+            VTableType::copy, VTableType::move,
+            VTableType::swap,
+        };
+        return &table;
+    }
+
+protected:
+    template<typename T>
+    friend const T* any_cast(const any* operand) noexcept;
+    template<typename T>
+    friend T* any_cast(any* operand) noexcept;
+
+#ifndef ANY_IMPL_NO_RTTI
+    /// Same effect as is_same(this->type(), t);
+    bool is_typed(const std::type_info& t) const
+    {
+        return is_same(this->type(), t);
+    }
+#endif
+
+#ifndef ANY_IMPL_NO_RTTI
+    /// Checks if two type infos are the same.
+    ///
+    /// If ANY_IMPL_FAST_TYPE_INFO_COMPARE is defined, checks only the address of the
+    /// type infos, otherwise does an actual comparison. Checking addresses is
+    /// only a valid approach when there's no interaction with outside sources
+    /// (other shared libraries and such).
+    static bool is_same(const std::type_info& a, const std::type_info& b)
+    {
+#ifdef ANY_IMPL_FAST_TYPE_INFO_COMPARE
+        return &a == &b;
+#else
+        return a == b;
+#endif
+    }
+#endif
+
+    /// Casts (with no type_info checks) the storage pointer as const T*.
+    template<typename T>
+    const T* cast() const noexcept
+    {
+        return requires_allocation<typename std::decay<T>::type>::value?
+            reinterpret_cast<const T*>(storage.dynamic) :
+            reinterpret_cast<const T*>(&storage.stack);
+    }
+
+    /// Casts (with no type_info checks) the storage pointer as T*.
+    template<typename T>
+    T* cast() noexcept
+    {
+        return requires_allocation<typename std::decay<T>::type>::value?
+            reinterpret_cast<T*>(storage.dynamic) :
+            reinterpret_cast<T*>(&storage.stack);
+    }
+
+private:
+    storage_union storage; // on offset(0) so no padding for align
+    vtable_type*  vtable;
+
+    template<typename ValueType, typename T>
+    typename std::enable_if<requires_allocation<T>::value>::type
+    do_construct(ValueType&& value)
+    {
+        storage.dynamic = new T(std::forward<ValueType>(value));
+    }
+
+    template<typename ValueType, typename T>
+    typename std::enable_if<!requires_allocation<T>::value>::type
+    do_construct(ValueType&& value)
+    {
+        new (&storage.stack) T(std::forward<ValueType>(value));
+    }
+
+    /// Chooses between stack and dynamic allocation for the type decay_t<ValueType>,
+    /// assigns the correct vtable, and constructs the object on our storage.
+    template<typename ValueType>
+    void construct(ValueType&& value)
+    {
+        using T = typename std::decay<ValueType>::type;
+
+        this->vtable = vtable_for_type<T>();
+
+        do_construct<ValueType,T>(std::forward<ValueType>(value));
+    }
+};
+
+
+
+namespace detail
+{
+    template<typename ValueType>
+    inline ValueType any_cast_move_if_true(typename std::remove_reference<ValueType>::type* p, std::true_type)
+    {
+        return std::move(*p);
+    }
+
+    template<typename ValueType>
+    inline ValueType any_cast_move_if_true(typename std::remove_reference<ValueType>::type* p, std::false_type)
+    {
+        return *p;
+    }
+}
+
+/// Performs *any_cast<add_const_t<remove_reference_t<ValueType>>>(&operand), or throws bad_any_cast on failure.
+template<typename ValueType>
+inline ValueType any_cast(const any& operand)
+{
+    auto p = any_cast<typename std::add_const<typename std::remove_reference<ValueType>::type>::type>(&operand);
+#ifndef ANY_IMPL_NO_EXCEPTIONS
+    if(p == nullptr) throw bad_any_cast();
+#endif
+    return *p;
+}
+
+/// Performs *any_cast<remove_reference_t<ValueType>>(&operand), or throws bad_any_cast on failure.
+template<typename ValueType>
+inline ValueType any_cast(any& operand)
+{
+    auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
+#ifndef ANY_IMPL_NO_EXCEPTIONS
+    if(p == nullptr) throw bad_any_cast();
+#endif
+    return *p;
+}
+
+///
+/// If ValueType is MoveConstructible and isn't a lvalue reference, performs
+/// std::move(*any_cast<remove_reference_t<ValueType>>(&operand)), otherwise
+/// *any_cast<remove_reference_t<ValueType>>(&operand). Throws bad_any_cast on failure.
+///
+template<typename ValueType>
+inline ValueType any_cast(any&& operand)
+{
+    using can_move = std::integral_constant<bool,
+        std::is_move_constructible<ValueType>::value
+        && !std::is_lvalue_reference<ValueType>::value>;
+
+    auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
+#ifndef ANY_IMPL_NO_EXCEPTIONS
+    if(p == nullptr) throw bad_any_cast();
+#endif
+    return detail::any_cast_move_if_true<ValueType>(p, can_move());
+}
+
+/// If operand != nullptr && operand->type() == typeid(ValueType), a pointer to the object
+/// contained by operand, otherwise nullptr.
+template<typename ValueType>
+inline const ValueType* any_cast(const any* operand) noexcept
+{
+    using T = typename std::decay<ValueType>::type;
+
+#ifndef ANY_IMPL_NO_RTTI
+    if (operand && operand->is_typed(typeid(T)))
+#else
+    if (operand && operand->vtable == any::vtable_for_type<T>())
+#endif
+        return operand->cast<ValueType>();
+    else
+        return nullptr;
+}
+
+/// If operand != nullptr && operand->type() == typeid(ValueType), a pointer to the object
+/// contained by operand, otherwise nullptr.
+template<typename ValueType>
+inline ValueType* any_cast(any* operand) noexcept
+{
+    using T = typename std::decay<ValueType>::type;
+
+#ifndef ANY_IMPL_NO_RTTI
+    if (operand && operand->is_typed(typeid(T)))
+#else
+    if (operand && operand->vtable == any::vtable_for_type<T>())
+#endif
+        return operand->cast<ValueType>();
+    else
+        return nullptr;
+}
+
+}
+
+namespace std
+{
+    inline void swap(linb::any& lhs, linb::any& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+}
+
+#endif
diff --git a/test/filelist.maf b/test/filelist.maf
index 431373a46..7ae5693b1 100644
--- a/test/filelist.maf
+++ b/test/filelist.maf
@@ -1,26 +1,36 @@
+HEADERS
+any.hpp
+test_env.h
 
 SOURCES
-test_buffer.cpp
-test_bonding.cpp
+test_main.cpp
+test_buffer_rcv.cpp
 test_common.cpp
 test_connection_timeout.cpp
-test_many_connections.cpp
+test_crypto.cpp
 test_cryspr.cpp
 test_enforced_encryption.cpp
 test_epoll.cpp
 test_fec_rebuilding.cpp
 test_file_transmission.cpp
-test_list.cpp
+test_ipv6.cpp
 test_listen_callback.cpp
+test_losslist_rcv.cpp
+test_losslist_snd.cpp
+test_many_connections.cpp
 test_muxer.cpp
 test_seqno.cpp
 test_socket_options.cpp
 test_sync.cpp
+test_threadname.cpp
 test_timer.cpp
 test_unitqueue.cpp
 test_utilities.cpp
+test_reuseaddr.cpp
+test_socketdata.cpp
+test_snd_rate_estimator.cpp
 
 # Tests for bonding only - put here!
 
-SOURCES - ENABLE_EXPERIMENTAL_BONDING
-
+SOURCES - ENABLE_BONDING
+test_bonding.cpp
diff --git a/test/test_bonding.cpp b/test/test_bonding.cpp
index 5172fc756..0e48c8a04 100644
--- a/test/test_bonding.cpp
+++ b/test/test_bonding.cpp
@@ -1,30 +1,20 @@
-
-#include <stdio.h>
-#include <stdlib.h>
 #include <future>
 #include <thread>
 #include <chrono>
 #include <vector>
 #include <functional>
-#ifdef _WIN32
-#define usleep(x) Sleep(x / 1000)
-#else
-#include <unistd.h>
-#endif
-
-#if ENABLE_EXPERIMENTAL_BONDING
 
 #include "gtest/gtest.h"
+#include "test_env.h"
 
 #include "srt.h"
 #include "netinet_any.h"
 
 TEST(Bonding, SRTConnectGroup)
 {
+    srt::TestInit srtinit;
     struct sockaddr_in sa;
 
-    srt_startup();
-
     const int ss = srt_create_group(SRT_GTYPE_BROADCAST);
     ASSERT_NE(ss, SRT_ERROR);
 
@@ -39,30 +29,34 @@ TEST(Bonding, SRTConnectGroup)
         targets.push_back(gd);
     }
 
-    std::future<void> closing_promise = std::async(std::launch::async, [](int ss) {
+    std::future<void> closing_promise = std::async(std::launch::async, [](int s) {
         std::this_thread::sleep_for(std::chrono::seconds(2));
         std::cerr << "Closing group" << std::endl;
-        srt_close(ss);
+        srt_close(s);
     }, ss);
 
     std::cout << "srt_connect_group calling " << std::endl;
-    const int st = srt_connect_group(ss, targets.data(), targets.size());
-    std::cout << "srt_connect_group returned " << st << std::endl;
+    const int st = srt_connect_group(ss, targets.data(), (int) targets.size());
+    std::cout << "srt_connect_group returned " << st << ", waiting for srt_close() to finish" << std::endl;
 
     closing_promise.wait();
+
+    std::cout << "TEST: closing future has exit. Deleting all other resources\n";
+
     // Delete config objects before prospective exception
     for (auto& gd: targets)
         srt_delete_config(gd.config);
 
     int res = srt_close(ss);
+
+    std::cout << "TEST: closing ss has exit. Cleaning up\n";
     if (res == SRT_ERROR)
     {
         std::cerr << "srt_close: " << srt_getlasterror_str() << std::endl;
     }
-
-    srt_cleanup();
 }
 
+#define ASSERT_SRT_SUCCESS(callform) ASSERT_NE(callform, -1) << "SRT ERROR: " << srt_getlasterror_str()
 
 void listening_thread(bool should_read)
 {
@@ -73,33 +67,33 @@ void listening_thread(bool should_read)
     ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &bind_sa.sin_addr), 1);
     bind_sa.sin_port = htons(4200);
 
-    ASSERT_NE(srt_bind(server_sock, (sockaddr*)&bind_sa, sizeof bind_sa), -1);
+    ASSERT_SRT_SUCCESS(srt_bind(server_sock, (sockaddr*)&bind_sa, sizeof bind_sa));
     const int yes = 1;
-    srt_setsockflag(server_sock, SRTO_GROUPCONNECT, &yes, sizeof yes);
+    ASSERT_SRT_SUCCESS(srt_setsockflag(server_sock, SRTO_GROUPCONNECT, &yes, sizeof yes));
 
     const int no = 1;
-    srt_setsockflag(server_sock, SRTO_RCVSYN, &no, sizeof no);
+    ASSERT_SRT_SUCCESS(srt_setsockflag(server_sock, SRTO_RCVSYN, &no, sizeof no));
 
     const int eid = srt_epoll_create();
     const int listen_event = SRT_EPOLL_IN | SRT_EPOLL_ERR;
-    srt_epoll_add_usock(eid, server_sock, &listen_event);
+    ASSERT_SRT_SUCCESS(srt_epoll_add_usock(eid, server_sock, &listen_event));
 
-    ASSERT_NE(srt_listen(server_sock, 5), -1);
+    ASSERT_SRT_SUCCESS(srt_listen(server_sock, 5));
     std::cout << "Listen: wait for acceptability\n";
     int fds[2];
     int fds_len = 2;
     int ers[2];
     int ers_len = 2;
-    int wr = srt_epoll_wait(eid, fds, &fds_len, ers, &ers_len, 5000,
-            0, 0, 0, 0);
+    ASSERT_SRT_SUCCESS(srt_epoll_wait(eid, fds, &fds_len, ers, &ers_len, 5000,
+            0, 0, 0, 0));
 
-    ASSERT_NE(wr, -1);
     std::cout << "Listen: reported " << fds_len << " acceptable and " << ers_len << " errors\n";
     ASSERT_GT(fds_len, 0);
     ASSERT_EQ(fds[0], server_sock);
 
-    sockaddr_any scl;
+    srt::sockaddr_any scl;
     int acp = srt_accept(server_sock, (scl.get()), (&scl.len));
+    ASSERT_SRT_SUCCESS(acp);
     ASSERT_NE(acp & SRTGROUP_MASK, 0);
 
     if (should_read)
@@ -121,6 +115,7 @@ void listening_thread(bool should_read)
     }
 
     srt_close(acp);
+    srt_close(server_sock);
 
     std::cout << "Listen: wait 7 seconds\n";
     std::this_thread::sleep_for(std::chrono::seconds(7));
@@ -136,8 +131,8 @@ void ConnectCallback(void* /*opaq*/, SRTSOCKET sock, int error, const sockaddr*
 
 TEST(Bonding, NonBlockingGroupConnect)
 {
-    srt_startup();
-    
+    srt::TestInit srtinit;
+
     const int ss = srt_create_group(SRT_GTYPE_BROADCAST);
     ASSERT_NE(ss, SRT_ERROR);
     std::cout << "Created group socket: " << ss << '\n';
@@ -210,8 +205,6 @@ TEST(Bonding, NonBlockingGroupConnect)
     listen_promise.wait();
 
     EXPECT_EQ(srt_close(ss), 0) << "srt_close: %s\n" << srt_getlasterror_str();
-
-    srt_cleanup();
 }
 
 void ConnectCallback_Close(void* /*opaq*/, SRTSOCKET sock, int error, const sockaddr* /*peer*/, int token)
@@ -229,8 +222,8 @@ void ConnectCallback_Close(void* /*opaq*/, SRTSOCKET sock, int error, const sock
 
 TEST(Bonding, CloseGroupAndSocket)
 {
-    srt_startup();
-    
+    srt::TestInit srtinit;
+
     const int ss = srt_create_group(SRT_GTYPE_BROADCAST);
     ASSERT_NE(ss, SRT_ERROR);
     std::cout << "Created group socket: " << ss << '\n';
@@ -264,15 +257,15 @@ TEST(Bonding, CloseGroupAndSocket)
     }
     std::cout << "Returned from connecting two sockets " << std::endl;
 
-    const int default_len = 3;
-    int rlen = default_len;
-    SRTSOCKET read[default_len];
-
-    int wlen = default_len;
-    SRTSOCKET write[default_len];
-
     for (int j = 0; j < 2; ++j)
     {
+        const int default_len = 3;
+        int rlen = default_len;
+        SRTSOCKET read[default_len];
+
+        int wlen = default_len;
+        SRTSOCKET write[default_len];
+
         const int epoll_res = srt_epoll_wait(poll_id, read, &rlen,
             write, &wlen,
             5000, /* timeout */
@@ -280,6 +273,9 @@ TEST(Bonding, CloseGroupAndSocket)
 
         std::cout << "Epoll result: " << epoll_res << '\n';
         std::cout << "Epoll rlen: " << rlen << ", wlen: " << wlen << '\n';
+        if (epoll_res < 0)
+            continue;
+
         for (int i = 0; i < rlen; ++i)
         {
             std::cout << "Epoll read[" << i << "]: " << read[i] << '\n';
@@ -291,6 +287,20 @@ TEST(Bonding, CloseGroupAndSocket)
         }
     }
 
+    // Some basic checks for group stats
+    SRT_TRACEBSTATS stats;
+    EXPECT_EQ(srt_bstats(ss, &stats, true), SRT_SUCCESS);
+    EXPECT_EQ(stats.pktSent, 0);
+    EXPECT_EQ(stats.pktSentTotal, 0);
+    EXPECT_EQ(stats.pktSentUnique, 0);
+    EXPECT_EQ(stats.pktSentUniqueTotal, 0);
+    EXPECT_EQ(stats.pktRecv, 0);
+    EXPECT_EQ(stats.pktRecvTotal, 0);
+    EXPECT_EQ(stats.pktRecvUnique, 0);
+    EXPECT_EQ(stats.pktRecvUniqueTotal, 0);
+    EXPECT_EQ(stats.pktRcvDrop, 0);
+    EXPECT_EQ(stats.pktRcvDropTotal, 0);
+
     std::cout << "Starting thread for sending:\n";
     std::thread sender([ss] {
         char buf[1316];
@@ -318,8 +328,239 @@ TEST(Bonding, CloseGroupAndSocket)
     std::cout << "CLOSED GROUP. Now waiting for sender to exit...\n";
     sender.join();
     listen_promise.wait();
+}
+
+TEST(Bonding, Options)
+{
+    using namespace std;
+    using namespace srt;
+
+    TestInit srtinit;
+
+    // Create a group
+    const SRTSOCKET grp = srt_create_group(SRT_GTYPE_BROADCAST);
+
+    // rendezvous shall not be allowed to be set on the group
+    // XXX actually it is possible, but no one tested it. POSTPONE.
+    //int yes = 1;
+    //EXPECT_EQ(srt_setsockflag(grp, SRTO_RENDEZVOUS, &yes, sizeof yes), SRT_ERROR);
+
+#ifdef SRT_ENABLE_ENCRYPTION
+    string pass = "longenoughpassword";
+    // passphrase should be ok.
+    EXPECT_NE(srt_setsockflag(grp, SRTO_PASSPHRASE, pass.c_str(), pass.size()), SRT_ERROR);
+
+    uint32_t val = 16;
+    EXPECT_NE(srt_setsockflag(grp, SRTO_PBKEYLEN, &val, sizeof val), SRT_ERROR);
+
+#ifdef ENABLE_AEAD_API_PREVIEW
+    val = 1;
+    EXPECT_NE(srt_setsockflag(grp, SRTO_CRYPTOMODE, &val, sizeof val), SRT_ERROR);
+#endif
+#endif
+
+    int lat = 500;
+    EXPECT_NE(srt_setsockflag(grp, SRTO_RCVLATENCY, &lat, sizeof lat), SRT_ERROR);
+
+    mutex mx;
+    condition_variable latch;
+    atomic<bool> started {false};
+
+    thread accept_and_close { [&]() {
+
+        unique_lock<mutex> ux(mx);
+
+        SRTSOCKET lsn = srt_create_socket();
+#ifdef SRT_ENABLE_ENCRYPTION
+        EXPECT_NE(srt_setsockflag(lsn, SRTO_PASSPHRASE, pass.c_str(), pass.size()), SRT_ERROR);
+#endif
+        int allow = 1;
+        ASSERT_NE(srt_setsockflag(lsn, SRTO_GROUPCONNECT, &allow, sizeof allow), SRT_ERROR);
+        sockaddr_any sa = CreateAddr("127.0.0.1", 5555, AF_INET);
+        ASSERT_NE(srt_bind(lsn, sa.get(), sa.size()), SRT_ERROR);
+        ASSERT_NE(srt_listen(lsn, 1), SRT_ERROR);
+        started = true;
+
+        // First wait - until it's let go with accepting
+        latch.wait(ux);
+
+        sockaddr_any revsa;
+        SRTSOCKET gs = srt_accept(lsn, revsa.get(), &revsa.len);
+        ASSERT_NE(gs, SRT_ERROR);
+
+        // Connected, wait to close
+        latch.wait(ux);
+
+        srt_close(gs);
+        srt_close(lsn);
+    }};
+
+    // Give the thread a chance to start
+    this_thread::yield();
+
+    while (!started)
+    {
+        // In case of a bad luck, just wait for the thread to
+        // acquire the mutex before you do
+        this_thread::sleep_for(chrono::milliseconds(10));
+    }
+
+    // Wait for the possibility to connect
+    {
+        // Make sure that the thread reached the wait() call.
+        unique_lock<mutex> ux(mx);
+        latch.notify_all();
+    }
+
+    // Now the thread is accepting, so we call the connect.
+    sockaddr_any sa = CreateAddr("127.0.0.1", 5555, AF_INET);
+    SRTSOCKET member = srt_connect(grp, sa.get(), sa.size());
+
+    // We've released the mutex and signaled the CV, so accept should proceed now.
+    // Exit from srt_connect() means also exit from srt_accept().
+
+    EXPECT_NE(member, SRT_INVALID_SOCK);
+
+    // conenct_res should be a socket
+    EXPECT_NE(member, 0); // XXX Change to SRT_SOCKID_CONNREQ
+
+    // Now get the option value from the group
+
+    int revlat = -1;
+    int optsize = sizeof revlat;
+    EXPECT_NE(srt_getsockflag(grp, SRTO_RCVLATENCY, &revlat, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, (int) sizeof revlat);
+    EXPECT_EQ(revlat, 500);
+
+    revlat = -1;
+    optsize = sizeof revlat;
+    // Expect the same value set on the member socket
+    EXPECT_NE(srt_getsockflag(member, SRTO_RCVLATENCY, &revlat, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, (int) sizeof revlat);
+    EXPECT_EQ(revlat, 500);
+
+    // Individual socket option modified on group
+    int ohead = 12;
+    optsize = sizeof ohead;
+    EXPECT_NE(srt_setsockflag(grp, SRTO_OHEADBW, &ohead, optsize), SRT_ERROR);
+
+    // Modifyting a post-option should be possible on a socket
+    ohead = 11;
+    optsize = sizeof ohead;
+    EXPECT_NE(srt_setsockflag(member, SRTO_OHEADBW, &ohead, optsize), SRT_ERROR);
+
+    // But getting the option value should be equal to the group setting
+    EXPECT_NE(srt_getsockflag(grp, SRTO_OHEADBW, &ohead, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, (int) sizeof ohead);
+    EXPECT_EQ(ohead, 12);
+
+#if SRT_ENABLE_ENCRYPTION
+
+    uint32_t kms = -1;
+
+    EXPECT_NE(srt_getsockflag(grp, SRTO_KMSTATE, &kms, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, (int) sizeof kms);
+    EXPECT_EQ(kms, int(SRT_KM_S_SECURED));
+
+    EXPECT_NE(srt_getsockflag(grp, SRTO_PBKEYLEN, &kms, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, (int) sizeof kms);
+    EXPECT_EQ(kms, 16);
+
+#ifdef ENABLE_AEAD_API_PREVIEW
+    EXPECT_NE(srt_getsockflag(grp, SRTO_CRYPTOMODE, &kms, &optsize), SRT_ERROR);
+    EXPECT_EQ(optsize, sizeof kms);
+    EXPECT_EQ(kms, 1);
+#endif
+#endif
+
+    // We're done, the thread can close connection and exit
+    {
+        // Make sure that the thread reached the wait() call.
+        std::unique_lock<std::mutex> ux(mx);
+        latch.notify_all();
+    }
+
+    accept_and_close.join();
+    srt_close(grp);
+}
+
+inline SRT_SOCKGROUPCONFIG PrepareEndpoint(const std::string& host, int port)
+{
+    srt::sockaddr_any sa = srt::CreateAddr(host, port, AF_INET);
+    return srt_prepare_endpoint(NULL, sa.get(), sa.size());
+}
+
+// This test will create a listener and then the group that should
+// connect members, where the first one fail, and two next should
+// succeed. Then sends a single packet over that link and makes sure
+// it's properly received, then the second packet isn't read.
+TEST(Bonding, InitialFailure)
+{
+    using namespace std;
+    using namespace srt;
+
+    TestInit srtinit;
+    MAKE_UNIQUE_SOCK(lsn, "Listener", srt_create_socket());
+    MAKE_UNIQUE_SOCK(grp, "GrpCaller", srt_create_group(SRT_GTYPE_BROADCAST));
+
+    // Create the listener on port 5555.
+    int allow = 1;
+    ASSERT_NE(srt_setsockflag(lsn, SRTO_GROUPCONNECT, &allow, sizeof allow), SRT_ERROR);
+
+    sockaddr_any sa = CreateAddr("127.0.0.1", 5555, AF_INET);
+    ASSERT_NE(srt_bind(lsn, sa.get(), sa.size()), SRT_ERROR);
+    ASSERT_NE(srt_listen(lsn, 5), SRT_ERROR);
+
+    // Create a group
+    // Connect 3 members in the group.
+    std::vector<SRT_SOCKGROUPCONFIG> targets;
+    targets.push_back(PrepareEndpoint("127.0.0.1", 5556)); // NOTE: NONEXISTENT LISTENER
+    targets.push_back(PrepareEndpoint("127.0.0.1", 5555));
+    targets.push_back(PrepareEndpoint("127.0.0.1", 5555));
+
+    // This should block until the connection is established, but
+    // accepted socket should be spawned and just wait for extraction.
+    const SRTSOCKET conn = srt_connect_group(grp, targets.data(), (int)targets.size());
+    EXPECT_NE(conn, SRT_INVALID_SOCK);
+
+    // Now check if the accept is ready
+    sockaddr_any revsa;
+    const SRTSOCKET gs = srt_accept(lsn, revsa.get(), &revsa.len);
+    EXPECT_NE(gs, SRT_INVALID_SOCK);
+
+    // Make sure that it was the group accepted
+    EXPECT_EQ(gs & SRTGROUP_MASK, SRTGROUP_MASK);
+
+    // Set 1s reading timeout on the socket so that reading won't wait forever,
+    // as it should fail at the second reading.
+    int read_timeout = 500; // 0.5s
+    EXPECT_NE(srt_setsockflag(gs, SRTO_RCVTIMEO, &read_timeout, sizeof (read_timeout)), SRT_ERROR);
+
+    int lsn_isn = -1, lsn_isn_size = sizeof (int);
+    EXPECT_NE(srt_getsockflag(gs, SRTO_ISN, &lsn_isn, &lsn_isn_size), SRT_ERROR);
+
+    // Now send a packet
+
+    string packet_data = "PREDEFINED PACKET DATA";
+    EXPECT_NE(srt_send(grp, packet_data.data(), packet_data.size()), SRT_ERROR);
+
+    char outbuf[1316];
+    SRT_MSGCTRL mc = srt_msgctrl_default;
+    int recvlen = srt_recvmsg2(gs, outbuf, 1316, &mc);
+    EXPECT_EQ(recvlen, int(packet_data.size()));
+
+    if (recvlen > 0)
+    {
+        outbuf[recvlen] = 0;
+        EXPECT_EQ(outbuf, packet_data);
+    }
+    EXPECT_EQ(mc.pktseq, lsn_isn);
+
+    recvlen = srt_recv(gs, outbuf, 80);
+    EXPECT_EQ(recvlen, int(SRT_ERROR));
 
-    srt_cleanup();
+    srt_close(gs);
+    srt_close(grp);
+    srt_close(lsn);
 }
 
-#endif // ENABLE_EXPERIMENTAL_BONDING
diff --git a/test/test_buffer.cpp b/test/test_buffer.cpp
deleted file mode 100644
index 795a6d52f..000000000
--- a/test/test_buffer.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include <array>
-#include "gtest/gtest.h"
-#include "buffer.h"
-
-
-TEST(CRcvBuffer, Create)
-{
-    const int buffer_size_pkts = 128;
-    CUnitQueue unit_queue;
-    CRcvBuffer rcv_buffer(&unit_queue, buffer_size_pkts);
-
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);   // logic
-}
-
-
-TEST(CRcvBuffer, FullBuffer)
-{
-    const int buffer_size_pkts = 16;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
-    CRcvBuffer rcv_buffer(&unit_queue, buffer_size_pkts);
-
-    const size_t payload_size = 1456;
-    // Add a number of units (packets) to the buffer
-    // equal to the buffer size in packets
-    for (int i = 0; i < rcv_buffer.getAvailBufSize(); ++i)
-    {
-        CUnit* unit = unit_queue.getNextAvailUnit();
-        EXPECT_NE(unit, nullptr);
-        unit->m_Packet.setLength(payload_size);
-        EXPECT_EQ(rcv_buffer.addData(unit, i), 0);
-    }
-
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);   // logic
-
-    rcv_buffer.ackData(buffer_size_pkts - 1);
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), 0);
-
-    // Try to add more data than the available size of the buffer
-    CUnit* unit = unit_queue.getNextAvailUnit();
-    EXPECT_NE(unit, nullptr);
-    EXPECT_EQ(rcv_buffer.addData(unit, 1), -1);
-
-    std::array<char, payload_size> buff;
-    for (int i = 0; i < buffer_size_pkts - 1; ++i)
-    {
-        const int res = rcv_buffer.readBuffer(buff.data(), buff.size());
-        EXPECT_EQ(res, payload_size);
-    }
-}
-
-
-// In this test case a packet is added to receiver buffer with offset 1,
-// thus leaving offset 0 with an empty pointer.
-// The buffer sais it is not empty, and the data is available
-// to be read, but reading should cause error.
-TEST(CRcvBuffer, ReadDataIPE)
-{
-    const int buffer_size_pkts = 16;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
-    CRcvBuffer rcv_buffer(&unit_queue, buffer_size_pkts);
-
-    const size_t payload_size = 1456;
-    // Add a number of units (packets) to the buffer
-    // equal to the buffer size in packets
-    CUnit* unit = unit_queue.getNextAvailUnit();
-    EXPECT_NE(unit, nullptr);
-    unit->m_Packet.setLength(payload_size);
-    EXPECT_EQ(rcv_buffer.addData(unit, 1), 0);
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);
-
-    EXPECT_FALSE(rcv_buffer.isRcvDataAvailable());
-    rcv_buffer.ackData(1);
-    EXPECT_TRUE(rcv_buffer.isRcvDataAvailable());
-
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 2);
-
-    std::cerr << "Expecting IPE message: \n";
-    std::array<char, payload_size> buff;
-    const int res = rcv_buffer.readBuffer(buff.data(), buff.size());
-    EXPECT_EQ(res, -1);
-}
-
-
-TEST(CRcvBuffer, ReadData)
-{
-    const int buffer_size_pkts = 16;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
-    CRcvBuffer rcv_buffer(&unit_queue, buffer_size_pkts);
-
-    const size_t payload_size = 1456;
-    // Add a number of units (packets) to the buffer
-    // equal to the buffer size in packets
-    CUnit* unit = unit_queue.getNextAvailUnit();
-    EXPECT_NE(unit, nullptr);
-    unit->m_Packet.setLength(payload_size);
-    EXPECT_EQ(rcv_buffer.addData(unit, 0), 0);
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);
-
-    EXPECT_FALSE(rcv_buffer.isRcvDataAvailable());
-    rcv_buffer.ackData(1);
-    EXPECT_TRUE(rcv_buffer.isRcvDataAvailable());
-
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 2);
-
-    std::array<char, payload_size> buff;
-    const int res = rcv_buffer.readBuffer(buff.data(), buff.size());
-    EXPECT_EQ(res, payload_size);
-}
-
-
-TEST(CRcvBuffer, AddData)
-{
-    const int buffer_size_pkts = 16;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
-    CRcvBuffer rcv_buffer(&unit_queue, buffer_size_pkts);
-
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);   // logic
-
-    const size_t payload_size = 1456;
-    // Add 10 units (packets) to the buffer
-    for (int i = 0; i < 10; ++i)
-    {
-        CUnit* unit = unit_queue.getNextAvailUnit();
-        EXPECT_NE(unit, nullptr);
-        unit->m_Packet.setLength(payload_size);
-        EXPECT_EQ(rcv_buffer.addData(unit, i), 0);
-    }
-
-    // The available buffer size remains the same
-    // The value is reported by SRT receiver like this:
-    // data[ACKD_BUFFERLEFT] = m_pRcvBuffer->getAvailBufSize();
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1);
-    EXPECT_FALSE(rcv_buffer.isRcvDataAvailable());
-
-    // Now acknowledge two packets
-    const int ack_pkts = 2;
-    rcv_buffer.ackData(2);
-    EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - 1 - ack_pkts);
-    EXPECT_TRUE(rcv_buffer.isRcvDataAvailable());
-
-    std::array<char, payload_size> buff;
-    for (int i = 0; i < ack_pkts; ++i)
-    {
-        const int res = rcv_buffer.readBuffer(buff.data(), buff.size());
-        EXPECT_EQ(res, payload_size);
-        EXPECT_EQ(rcv_buffer.getAvailBufSize(), buffer_size_pkts - ack_pkts + i);
-    }
-
-    // Add packet to the same position
-    CUnit* unit = unit_queue.getNextAvailUnit();
-    EXPECT_NE(unit, nullptr);
-    unit->m_Packet.setLength(payload_size);
-    EXPECT_EQ(rcv_buffer.addData(unit, 1), -1);
-}
-
-
diff --git a/test/test_buffer_rcv.cpp b/test/test_buffer_rcv.cpp
new file mode 100644
index 000000000..511c2dcb1
--- /dev/null
+++ b/test/test_buffer_rcv.cpp
@@ -0,0 +1,882 @@
+#include <array>
+#include <numeric>
+#include "gtest/gtest.h"
+#include "buffer_rcv.h"
+
+using namespace srt;
+using namespace std;
+
+class CRcvBufferReadMsg
+    : public ::testing::Test
+{
+protected:
+    CRcvBufferReadMsg(bool message_api = true)
+        : m_use_message_api(message_api)
+    {
+        // initialization code here
+    }
+
+    virtual ~CRcvBufferReadMsg()
+    {
+        // cleanup any pending stuff, but no exceptions allowed
+    }
+
+protected:
+    // SetUp() is run immediately before a test starts.
+    void SetUp() override
+    {
+        // make_unique is unfortunatelly C++14
+        m_unit_queue.reset(new CUnitQueue(m_buff_size_pkts, 1500));
+        ASSERT_NE(m_unit_queue.get(), nullptr);
+
+        const bool enable_msg_api = m_use_message_api;
+        const bool enable_peer_rexmit = true;
+        m_rcv_buffer.reset(new CRcvBuffer(m_init_seqno, m_buff_size_pkts, m_unit_queue.get(), enable_msg_api));
+        m_rcv_buffer->setPeerRexmitFlag(enable_peer_rexmit);
+        ASSERT_NE(m_rcv_buffer.get(), nullptr);
+    }
+
+    void TearDown() override
+    {
+        // Code here will be called just after the test completes.
+        // OK to throw exceptions from here if needed.
+        m_rcv_buffer.reset();
+        m_unit_queue.reset();
+    }
+
+public:
+    /// Generate and add one packet to the receiver buffer.
+    ///
+    /// @returns the result of rcv_buffer::insert(..)
+    int addPacket(int seqno, int msgno, bool pb_first = true, bool pb_last = true, bool out_of_order = false, int ts = 0)
+    {
+        CUnit* unit = m_unit_queue->getNextAvailUnit();
+        EXPECT_NE(unit, nullptr);
+
+        CPacket& packet = unit->m_Packet;
+        packet.set_seqno(seqno);
+        packet.set_timestamp(ts);
+
+        packet.setLength(m_payload_sz);
+        generatePayload(packet.data(), packet.getLength(), packet.seqno());
+
+        int32_t pktMsgFlags = msgno;
+        pktMsgFlags |= PacketBoundaryBits(PB_SUBSEQUENT);
+        if (pb_first)
+            pktMsgFlags |= PacketBoundaryBits(PB_FIRST);
+        if (pb_last)
+            pktMsgFlags |= PacketBoundaryBits(PB_LAST);
+
+        if (!out_of_order)
+            pktMsgFlags |= MSGNO_PACKET_INORDER::wrap(1);
+        packet.set_msgflags(pktMsgFlags);
+
+        if (!out_of_order)
+        {
+            EXPECT_TRUE(packet.getMsgOrderFlag());
+        }
+
+        return m_rcv_buffer->insert(unit);
+    }
+
+    /// @returns 0 on success, the result of rcv_buffer::insert(..) once it failed
+    int addMessage(size_t msg_len_pkts, int msgno, int start_seqno, bool out_of_order = false, int ts = 0)
+    {
+        for (size_t i = 0; i < msg_len_pkts; ++i)
+        {
+            const bool pb_first = (i == 0);
+            const bool pb_last = (i == (msg_len_pkts - 1));
+            const int res = addPacket(start_seqno + int(i), msgno, pb_first, pb_last, out_of_order, ts);
+
+            if (res != 0)
+                return res;
+        }
+        return 0;
+    }
+
+    void generatePayload(char* dst, size_t len, int seqno) { std::iota(dst, dst + len, (char)seqno); }
+
+    bool verifyPayload(char* dst, size_t len, int seqno)
+    {
+        // Note. A more consistent way would be to use generatePayload function,
+        // but I don't want to create another buffer for the data.
+        for (size_t i = 0; i < len; ++i)
+        {
+            if (dst[i] != static_cast<char>(seqno + i))
+                return false;
+        }
+        return true;
+    }
+
+    int ackPackets(int num_pkts)
+    {
+        m_first_unack_seqno = CSeqNo::incseq(m_first_unack_seqno, num_pkts);
+        return 0;
+    }
+
+    int getAvailBufferSize()
+    {
+        return int(m_rcv_buffer->getAvailSize(m_first_unack_seqno));
+    }
+
+    int readMessage(char* data, size_t len)
+    {
+        return m_rcv_buffer->readMessage(data, len);
+    }
+
+    bool hasAvailablePackets()
+    {
+        return m_rcv_buffer->hasAvailablePackets();
+    }
+
+protected:
+    unique_ptr<CUnitQueue> m_unit_queue;
+    unique_ptr<CRcvBuffer> m_rcv_buffer;
+    const int m_buff_size_pkts = 16;
+    const int m_init_seqno = 1000;
+    int m_first_unack_seqno = m_init_seqno;
+    static const size_t m_payload_sz = 1456;
+    const bool m_use_message_api;
+
+    const sync::steady_clock::time_point m_tsbpd_base = sync::steady_clock::now(); // now() - HS.timestamp, microseconds
+    const sync::steady_clock::duration m_delay = sync::milliseconds_from(200);
+};
+
+// Check the available size of the receiver buffer.
+TEST_F(CRcvBufferReadMsg, Create)
+{
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+}
+
+// Check that destroying the buffer also frees memory units.
+TEST_F(CRcvBufferReadMsg, Destroy)
+{
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    // Add a number of units (packets) to the buffer
+    // equal to the buffer size in packets
+    for (int i = 0; i < getAvailBufferSize(); ++i)
+        EXPECT_EQ(addMessage(1, i + 1, CSeqNo::incseq(m_init_seqno, i)), 0);
+
+    m_rcv_buffer.reset();
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Fill the buffer full, and check adding more data results in an error.
+TEST_F(CRcvBufferReadMsg, FullBuffer)
+{
+    auto& rcv_buffer = *m_rcv_buffer.get();
+    // Add a number of units (packets) to the buffer
+    // equal to the buffer size in packets
+    for (int i = 0; i < getAvailBufferSize(); ++i)
+    {
+        EXPECT_EQ(addMessage(1, i + 1, CSeqNo::incseq(m_init_seqno, i)), 0);
+    }
+
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);   // logic
+
+    ackPackets(m_buff_size_pkts - 1);
+    EXPECT_EQ(getAvailBufferSize(), 0);
+
+    // Try to add more data than the available size of the buffer
+    EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, getAvailBufferSize()), 1), -1);
+
+    array<char, m_payload_sz> buff;
+    for (int i = 0; i < m_buff_size_pkts - 1; ++i)
+    {
+        const int res = rcv_buffer.readBuffer(buff.data(), int(buff.size()));
+        EXPECT_TRUE(size_t(res) == m_payload_sz);
+        EXPECT_TRUE(verifyPayload(buff.data(), res, CSeqNo::incseq(m_init_seqno, i)));
+    }
+
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// BUG in the old RCV buffer!!!
+// In this test case a packet is added to receiver buffer with offset 1,
+// thus leaving offset 0 with an empty pointer.
+// The buffer says it is not empty, and the data is available
+// to be read, but reading is not possible.
+TEST_F(CRcvBufferReadMsg, OnePacketGap)
+{
+    // Add one packet message to to the buffer
+    // with a gap of one packet.
+    EXPECT_EQ(addMessage(1, 1, CSeqNo::incseq(m_init_seqno)), 0);
+
+    auto& rcv_buffer = *m_rcv_buffer.get();
+    // Before ACK the available buffer size stays the same.
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    // Not available for reading as not yet acknowledged.
+    EXPECT_FALSE(hasAvailablePackets());
+    // Confirm reading zero bytes.
+    array<char, m_payload_sz> buff;
+    int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, 0);
+
+    // BUG. Acknowledging an empty position must not result in a read-readiness.
+    // TODO: Actually we should not acknowledge, but must drop instead.
+    ackPackets(1);
+    EXPECT_FALSE(hasAvailablePackets());
+    EXPECT_FALSE(rcv_buffer.isRcvDataReady());
+
+    const auto next_packet = m_rcv_buffer->getFirstValidPacketInfo();
+    EXPECT_EQ(next_packet.seqno, m_init_seqno + 1);
+
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 2);
+    // The buffer will return 0 as reading is not available.
+    res = rcv_buffer.readBuffer(buff.data(), int(buff.size()));
+    EXPECT_EQ(res, 0);
+
+    res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, 0);
+
+    // Add a missing packet (can't add before an acknowledged position in the old buffer).
+    EXPECT_EQ(addMessage(1, 1, m_init_seqno), 0);
+
+    for (int pktno = 0; pktno < 2; ++pktno)
+    {
+        const size_t msg_bytelen = m_payload_sz;
+        EXPECT_TRUE(rcv_buffer.isRcvDataReady());
+        EXPECT_EQ(readMessage(buff.data(), buff.size()), (int) msg_bytelen);
+        EXPECT_TRUE(verifyPayload(buff.data(), msg_bytelen, CSeqNo::incseq(m_init_seqno, pktno)));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+
+    // Further read is not possible
+    EXPECT_FALSE(rcv_buffer.isRcvDataReady());
+}
+
+/// One packet is added to the buffer after 1-packet gap. Should be read only after ACK.
+/// 1. insert (1)
+///       |
+/// +---+---+  ---+---+---+---+   +---+
+/// | 0 | 1 |   0 | 0 | 0 | 0 |...| 0 | m_pUnit[]
+/// +---+---+  ---+---+---+---+   +---+
+/// 2. drop (0)
+/// 2. read (1)
+///
+TEST_F(CRcvBufferReadMsg, OnePacketGapDrop)
+{
+    // Add one packet message to to the buffer
+    // with a gap of one packet.
+    EXPECT_EQ(addMessage(1, 1, CSeqNo::incseq(m_init_seqno)), 0);
+    auto& rcv_buffer = *m_rcv_buffer.get();
+    EXPECT_FALSE(hasAvailablePackets());
+    EXPECT_FALSE(rcv_buffer.isRcvDataReady());
+    rcv_buffer.dropUpTo(CSeqNo::incseq(m_init_seqno));
+
+    EXPECT_TRUE(hasAvailablePackets());
+    EXPECT_TRUE(rcv_buffer.isRcvDataReady());
+    array<char, m_payload_sz> buff;
+    EXPECT_TRUE(readMessage(buff.data(), buff.size()) == m_payload_sz);
+    EXPECT_TRUE(verifyPayload(buff.data(), m_payload_sz, CSeqNo::incseq(m_init_seqno)));
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+TEST_F(CRcvBufferReadMsg, PacketDropBySeqNo)
+{
+    // Add two packets.
+    EXPECT_EQ(addMessage(1, 1, m_init_seqno), 0);
+    EXPECT_EQ(addMessage(1, 2, CSeqNo::incseq(m_init_seqno)), 0);
+
+    auto& rcv_buffer = *m_rcv_buffer.get();
+    EXPECT_TRUE(hasAvailablePackets());
+    EXPECT_TRUE(rcv_buffer.isRcvDataReady());
+
+    EXPECT_EQ(rcv_buffer.dropMessage(m_init_seqno, m_init_seqno, SRT_MSGNO_NONE, CRcvBuffer::KEEP_EXISTING), 0);
+    EXPECT_TRUE(hasAvailablePackets());
+    EXPECT_TRUE(rcv_buffer.isRcvDataReady());
+
+    EXPECT_EQ(rcv_buffer.dropMessage(m_init_seqno, m_init_seqno, SRT_MSGNO_NONE, CRcvBuffer::DROP_EXISTING), 1);
+    EXPECT_TRUE(hasAvailablePackets());
+    EXPECT_TRUE(rcv_buffer.isRcvDataReady());
+
+    array<char, m_payload_sz> buff;
+    EXPECT_TRUE(readMessage(buff.data(), buff.size()) == m_payload_sz);
+    EXPECT_TRUE(verifyPayload(buff.data(), m_payload_sz, CSeqNo::incseq(m_init_seqno)));
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Test dropping a message by message number and sequence number.
+TEST_F(CRcvBufferReadMsg, PacketDropByMsgNoSeqNo)
+{
+    const size_t msg_len_pkts = 5;
+    const int msgno = 1;
+    for (size_t i = 0; i < msg_len_pkts; ++i)
+    {
+        if (i == 1 || i == msg_len_pkts - 1)
+            continue; // make a gap in the message
+
+        const bool pb_first = (i == 0);
+        const bool pb_last = false; // Do not put the whole message in the buffer.
+        EXPECT_EQ(addPacket(m_init_seqno + int(i), msgno, pb_first, pb_last, false), 0);
+    }
+
+    auto& rcv_buffer = *m_rcv_buffer.get();
+    EXPECT_FALSE(hasAvailablePackets()) << "The message in the buffer is not complete";
+    EXPECT_FALSE(rcv_buffer.isRcvDataReady()); // The buffer does not have the whole message.
+
+    // Let's say SND does not have the very first packet of the message,
+    // therefore seqnolo of the msg drop request starts with the second packet of the message.
+    EXPECT_EQ(rcv_buffer.dropMessage(CSeqNo::incseq(m_init_seqno), CSeqNo::incseq(m_init_seqno, msg_len_pkts - 1), msgno, CRcvBuffer::KEEP_EXISTING), (int) msg_len_pkts);
+    EXPECT_FALSE(hasAvailablePackets());
+    EXPECT_FALSE(rcv_buffer.isRcvDataReady());
+
+    EXPECT_EQ(rcv_buffer.getStartSeqNo(), CSeqNo::incseq(m_init_seqno, msg_len_pkts));
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Add one packet to the buffer and read it once it is acknowledged.
+// Confirm the data read is valid.
+// Don't allow to add packet with the same sequence number.
+TEST_F(CRcvBufferReadMsg, OnePacket)
+{
+    const size_t msg_pkts = 1;
+    // Adding one message  without acknowledging
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, false), 0);
+    // Adding a packet into the same position must return an error.
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, false), -1);
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+
+    // The receiver buffer allows reading without ACK.
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const int res2 = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res2, (int) msg_bytelen);
+    EXPECT_TRUE(verifyPayload(buff.data(), res2, m_init_seqno));
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Add ten packets to the buffer, acknowledge and read some of them.
+// Then try to add packets to the position of existing packets.
+// We can't check adding to the position of those packets already read,
+// because a negative offset is not checked by the receiver buffer,
+// but must be handled by the CUDT socket.
+TEST_F(CRcvBufferReadMsg, AddData)
+{
+    const int num_pkts = 10;
+    ASSERT_LT(num_pkts, m_buff_size_pkts);
+    for (int i = 0; i < num_pkts; ++i)
+    {
+        EXPECT_EQ(addMessage(1, i + 1, CSeqNo::incseq(m_init_seqno, i)), 0);
+    }
+
+    // The available buffer size remains the same
+    // The value is reported by SRT receiver like this:
+    // data[ACKD_BUFFERLEFT] = m_pRcvBuffer->getAvailBufSize();
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    // The receiver buffer does not need ACK to allow reading.
+    EXPECT_TRUE(hasAvailablePackets());
+
+    // Now acknowledge two packets
+    const int ack_pkts = 2;
+    ackPackets(2);
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1 - ack_pkts);
+    EXPECT_TRUE(hasAvailablePackets());
+
+    std::array<char, m_payload_sz> buff;
+    for (int i = 0; i < ack_pkts; ++i)
+    {
+        const int res = readMessage(buff.data(), buff.size());
+        EXPECT_TRUE(size_t(res) == m_payload_sz);
+        EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - ack_pkts + i);
+        EXPECT_TRUE(verifyPayload(buff.data(), res, CSeqNo::incseq(m_init_seqno, i)));
+    }
+
+    // Add packet to the position of oackets already read.
+    EXPECT_EQ(addPacket(m_init_seqno, num_pkts + 1), -2);
+
+    // Add packet to a non-empty position.
+    EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, ack_pkts), num_pkts + 1), -1);
+
+    const int num_pkts_left = num_pkts - ack_pkts;
+    ackPackets(num_pkts_left);
+    for (int i = 0; i < num_pkts_left; ++i)
+    {
+        const int res = readMessage(buff.data(), buff.size());
+        EXPECT_TRUE(size_t(res) == m_payload_sz);
+        EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - num_pkts_left + i);
+        EXPECT_TRUE(verifyPayload(buff.data(), res, CSeqNo::incseq(m_init_seqno, ack_pkts + i)));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Check reading the whole message (consisting of several packets) from the buffer.
+TEST_F(CRcvBufferReadMsg, MsgAcked)
+{
+    const size_t msg_pkts = 4;
+    // Adding one message  without acknowledging
+    addMessage(msg_pkts, 1, m_init_seqno, false);
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+
+    // Acknowledge all packets of the message.
+    ackPackets(msg_pkts);
+    // Now the whole message can be read.
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const ptrdiff_t offset = i * m_payload_sz;
+        EXPECT_TRUE(verifyPayload(buff.data() + offset, m_payload_sz, CSeqNo::incseq(m_init_seqno, int(i))));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Check reading the whole message (consisting of several packets) into
+// a buffer of an insufficient size.
+TEST_F(CRcvBufferReadMsg, SmallReadBuffer)
+{
+    const size_t msg_pkts = 4;
+    // Adding one message  without acknowledging
+    addMessage(msg_pkts, 1, m_init_seqno, false);
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+
+    // Acknowledge all packets of the message.
+    ackPackets(msg_pkts);
+    // Now the whole message can be read.
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    // Check reading into an insufficient size buffer.
+    // The old buffer extracts the whole message, but copies only
+    // the number of bytes provided in the 'len' argument.
+    const int res = readMessage(buff.data(), m_payload_sz);
+    EXPECT_EQ(res, 1456);
+
+    // No more messages to read
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_FALSE(hasAvailablePackets());
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// BUG!!!
+// Checks signaling of read-readiness of a half-acknowledged message.
+// The RCV buffer implementation has an issue here: when only half of the message is
+// acknowledged, the RCV buffer signals read-readiness, even though
+// the message can't be read, and reading returns 0.
+TEST_F(CRcvBufferReadMsg, MsgHalfAck)
+{
+    const size_t msg_pkts = 4;
+    // Adding one message  without acknowledging
+    addMessage(msg_pkts, 1, m_init_seqno, false);
+    
+    // Nothing to read (0 for zero bytes read).
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+
+    // The receiver buffer does not care about ACK.
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const ptrdiff_t offset = i * m_payload_sz;
+        EXPECT_TRUE(verifyPayload(buff.data() + offset, m_payload_sz, CSeqNo::incseq(m_init_seqno, int(i))));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// BUG!!!
+// Adding a message with the out-of-order flag set.
+// RCV buffer does not signal read-readiness, but actually the packet can be read.
+TEST_F(CRcvBufferReadMsg, OutOfOrderMsgNoACK)
+{
+    const size_t msg_pkts = 4;
+    // Adding one message with the Out-Of-Order flag set, but without acknowledging.
+    addMessage(msg_pkts, 1, m_init_seqno, true);
+
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+    const int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const ptrdiff_t offset = i * m_payload_sz;
+        EXPECT_TRUE(verifyPayload(buff.data() + offset, m_payload_sz, CSeqNo::incseq(m_init_seqno, int(i))));
+    }
+
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_FALSE(hasAvailablePackets());
+
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// Adding a message with the out-of-order flag set.
+// The message can be read.
+TEST_F(CRcvBufferReadMsg, OutOfOrderMsgGap)
+{
+    const size_t msg_pkts = 4;
+    // Adding one message with the Out-Of-Order flag set, but without acknowledging.
+    addMessage(msg_pkts, 2, CSeqNo::incseq(m_init_seqno, 1), true);
+
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+    const int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const ptrdiff_t offset = i * m_payload_sz;
+        EXPECT_TRUE(verifyPayload(buff.data() + offset, m_payload_sz, CSeqNo::incseq(m_init_seqno, int(i)+1)));
+    }
+
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_FALSE(hasAvailablePackets());
+    // Adding one message with the Out-Of-Order flag set, but without acknowledging.
+    //int seqno, bool pb_first = true, bool pb_last = true, bool out_of_order = false, int ts = 0)
+    const int res2 = addPacket(CSeqNo::incseq(m_init_seqno, 2), 1);
+    EXPECT_EQ(res2, -1); // already exists
+
+    EXPECT_EQ(addPacket(m_init_seqno, 1), 0);
+    ackPackets(msg_pkts + 1);
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const int res3 = readMessage(buff.data(), buff.size());
+    EXPECT_TRUE(res3 == m_payload_sz);
+    EXPECT_TRUE(verifyPayload(buff.data(), m_payload_sz, m_init_seqno));
+
+    // Only "passack" or EntryState_Read packets remain in the buffer.
+    // They are falsely signalled as read-ready.
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_FALSE(hasAvailablePackets());
+
+    // Adding a packet right after the EntryState_Read packets.
+    const int seqno = CSeqNo::incseq(m_init_seqno, msg_pkts + 1);
+    EXPECT_EQ(addPacket(seqno, 3), 0);
+    ackPackets(1);
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+    EXPECT_TRUE(readMessage(buff.data(), buff.size()) == m_payload_sz);
+    EXPECT_TRUE(verifyPayload(buff.data(), m_payload_sz, seqno));
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_FALSE(hasAvailablePackets());
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// One message (4 packets) are added to the buffer.
+// Check if reading is only possible once the whole message is present in the buffer.
+TEST_F(CRcvBufferReadMsg, LongMsgReadReady)
+{
+    const size_t msg_pkts = 4;
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const int msgno = 1;
+        // int addPacket(int seqno, bool pb_first = true, bool pb_last = true, bool out_of_order = false, int ts = 0)
+        const bool pb_first = (i == 0);
+        const bool pb_last  = (i == (msg_pkts - 1));
+        EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, int(i)), msgno, pb_first, pb_last), 0);
+        ackPackets(1);
+        if (!pb_last)
+        {
+            EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+            EXPECT_FALSE(hasAvailablePackets());
+            EXPECT_EQ(readMessage(buff.data(), buff.size()), 0);
+        }
+    }
+
+    // Read the whole message.
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const int res = readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        const ptrdiff_t offset = i * m_payload_sz;
+        EXPECT_TRUE(verifyPayload(buff.data() + offset, m_payload_sz, CSeqNo::incseq(m_init_seqno, int(i))));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// One message (4 packets) is added to the buffer. Can be read out of order.
+// Reading should be possible even before the missing packet is dropped.
+TEST_F(CRcvBufferReadMsg, MsgOutOfOrderDrop)
+{
+    const size_t msg_pkts = 4;
+    // 1. Add one message (4 packets) without acknowledging
+    const int msg_seqno = m_init_seqno + 1; // seqno of the first packet in the message
+    EXPECT_EQ(addMessage(msg_pkts, 2, msg_seqno, true), 0);
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+
+    // 2. Read full message after gap.
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+    int res = m_rcv_buffer->readMessage(buff.data(), buff.size());
+    EXPECT_EQ(res, (int) msg_bytelen);
+    for (size_t i = 0; i < msg_pkts; ++i)
+    {
+        EXPECT_TRUE(verifyPayload(buff.data() + i * m_payload_sz, m_payload_sz, msg_seqno + int(i)));
+    }
+
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+
+    // Can't add to the same message
+    EXPECT_EQ(addMessage(msg_pkts, 2, msg_seqno, true), -1);
+
+    const auto pkt_info = m_rcv_buffer->getFirstValidPacketInfo();
+    EXPECT_EQ(pkt_info.seqno, -1); // Nothing to read
+    EXPECT_TRUE(srt::sync::is_zero(pkt_info.tsbpd_time));
+
+    // Drop missing packet
+    m_rcv_buffer->dropUpTo(msg_seqno);
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+    // All memory units are expected to be freed.
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+// One message (4 packets) is added to the buffer after a message with "in order" flag.
+// Read in order
+TEST_F(CRcvBufferReadMsg, MsgOutOfOrderAfterInOrder)
+{
+    const size_t msg_pkts = 4;
+    // 1. Add one packet with inOrder=true and one message (4 packets) with inOrder=false
+    EXPECT_EQ(addMessage(msg_pkts, 3, m_init_seqno + 2 * msg_pkts, true), 0);
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, false), 0);
+    EXPECT_EQ(addMessage(msg_pkts, 2, m_init_seqno + msg_pkts, true), 0);
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+
+    // 2. Read messages in order
+    const size_t                      msg_bytelen = msg_pkts * m_payload_sz;
+    std::array<char, 2 * msg_bytelen> buff;
+    for (int msg_i = 0; msg_i < 3; ++msg_i)
+    {
+        EXPECT_TRUE(m_rcv_buffer->isRcvDataReady());
+        EXPECT_EQ(m_rcv_buffer->readMessage(buff.data(), buff.size()), (int) msg_bytelen);
+        for (size_t i = 0; i < msg_pkts; ++i)
+        {
+            EXPECT_TRUE(verifyPayload(buff.data() + i * m_payload_sz, m_payload_sz, int(m_init_seqno + msg_i * msg_pkts + i)));
+        }
+    }
+
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady());
+}
+
+/// One packet is added to the buffer. Can be read on TSBPD-readiness.
+///
+/// 1. insert
+///   | 
+/// +---+  ---+---+---+---+---+   +---+
+/// | 1 |   0 | 0 | 0 | 0 | 0 |...| 0 | m_pUnit[]
+/// +---+  ---+---+---+---+---+   +---+
+///   |
+/// 2. read
+///
+TEST_F(CRcvBufferReadMsg, OnePacketTSBPD)
+{
+    const size_t msg_pkts = 1;
+
+    m_rcv_buffer->setTsbPdMode(m_tsbpd_base, false, m_delay);
+
+    const int packet_ts = 0;
+    // Adding one message. Note that all packets have the out of order flag
+    // set to false by default in TSBPD mode, but this flag is ignored.
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, true, packet_ts), 0);
+
+    const size_t msg_bytelen = msg_pkts * m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+
+    // Confirm adding to the same location returns an error.
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, true, packet_ts), -1);
+
+    // There is one packet in the buffer, but not ready to read after delay/2
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + (m_delay / 2)));
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + m_delay - sync::microseconds_from(1)));
+    // There is one packet in the buffer ready to read after delay
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + m_delay));
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + m_delay + sync::microseconds_from(1)));
+
+    // Read out the first message
+    const int read_len = m_rcv_buffer->readMessage(buff.data(), buff.size());
+    EXPECT_EQ(read_len, (int) msg_bytelen);
+    EXPECT_TRUE(verifyPayload(buff.data(), read_len, m_init_seqno));
+
+    // Check the state after a packet was read
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + m_delay));
+    EXPECT_EQ(addMessage(msg_pkts, 1, m_init_seqno, false), -2);
+
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady(m_tsbpd_base + m_delay));
+}
+
+/// TSBPD = ON, a ready-to-play packet is preceded by a missing packet.
+/// The read-rediness must be signalled, and a packet must be read after the missing
+/// one is dropped.
+/// The TSBPD delay is set to 200 ms. This means, that the packet can be played
+/// not earlier than after 200200 microseconds from the peer start time.
+/// The peer start time is set to 100000 us.
+///
+/// 
+/// |<m_iMaxPosInc>|
+/// |          /
+/// |        /
+/// |       |
+/// +---+---+---+---+---+---+   +---+
+/// | 0 | 1 | 0 | 0 | 0 | 0 |...| 0 | m_pUnit[]
+/// +---+---+---+---+---+---+   +---+
+/// |       |
+/// |       \__last pkt received
+/// |
+/// \___ m_iStartPos: first message to read
+///  \___ m_iLastAckPos: last ack sent
+///
+/// m_pUnit[i]->m_iFlag: 0:free, 1:good, 2:passack, 3:dropped
+///
+TEST_F(CRcvBufferReadMsg, TSBPDGapBeforeValid)
+{
+    m_rcv_buffer->setTsbPdMode(m_tsbpd_base, false, m_delay);
+    // Add a solo packet to position m_init_seqno + 1 with timestamp 200 us
+    const int seqno = m_init_seqno + 1;
+    const int32_t pkt_ts = 200;
+    EXPECT_EQ(addMessage(1, 2, seqno, false, pkt_ts), 0);
+
+    const auto readready_timestamp = m_tsbpd_base + sync::microseconds_from(pkt_ts) + m_delay;
+    // Check that getFirstValidPacketInfo() returns first valid packet.
+    const auto pkt_info = m_rcv_buffer->getFirstValidPacketInfo();
+    EXPECT_EQ(pkt_info.tsbpd_time, readready_timestamp);
+    EXPECT_EQ(pkt_info.seqno, seqno);
+    EXPECT_TRUE(pkt_info.seq_gap);
+
+    // The packet can't be read because there is a missing packet preceding.
+    EXPECT_FALSE(m_rcv_buffer->isRcvDataReady(readready_timestamp));
+
+    const int seq_gap_len = CSeqNo::seqoff(m_rcv_buffer->getStartSeqNo(), pkt_info.seqno);
+    EXPECT_GT(seq_gap_len, 0);
+    if (seq_gap_len > 0)
+    {
+        m_rcv_buffer->dropUpTo(pkt_info.seqno);
+    }
+
+    EXPECT_TRUE(m_rcv_buffer->isRcvDataReady(readready_timestamp));
+
+    const size_t msg_bytelen = m_payload_sz;
+    array<char, 2 * msg_bytelen> buff;
+    EXPECT_EQ(readMessage(buff.data(), buff.size()), (int) msg_bytelen);
+    EXPECT_TRUE(verifyPayload(buff.data(), m_payload_sz, seqno));
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+
+class CRcvBufferReadStream
+    : public CRcvBufferReadMsg
+{
+protected:
+    CRcvBufferReadStream()
+        : CRcvBufferReadMsg(false)
+    {}
+
+    virtual ~CRcvBufferReadStream() { }
+};
+
+
+// Add ten packets to the buffer in stream mode, read some of them.
+// Try to add packets to occupied positions.
+TEST_F(CRcvBufferReadStream, ReadSinglePackets)
+{
+    const int num_pkts = 10;
+    ASSERT_LT(num_pkts, m_buff_size_pkts);
+    for (int i = 0; i < num_pkts; ++i)
+    {
+        EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, i), 0, false, false), 0);
+    }
+
+    // The available buffer size remains the same
+    // The value is reported by SRT receiver like this:
+    // data[ACKD_BUFFERLEFT] = m_pRcvBuffer->getAvailBufSize();
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_TRUE(hasAvailablePackets());
+
+    // Now acknowledge two packets
+    const int ack_pkts = 2;
+    ackPackets(2);
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1 - ack_pkts);
+    EXPECT_TRUE(hasAvailablePackets());
+
+    std::array<char, m_payload_sz> buff;
+    for (int i = 0; i < ack_pkts; ++i)
+    {
+        const size_t res = m_rcv_buffer->readBuffer(buff.data(), int(buff.size()));
+        EXPECT_TRUE(size_t(res) == m_payload_sz);
+        EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - ack_pkts + i);
+        EXPECT_TRUE(verifyPayload(buff.data(), res, CSeqNo::incseq(m_init_seqno, i)));
+    }
+
+    // Add packet to the position of oackets already read.
+    // Can't check the old buffer, as it does not handle a negative offset.
+    EXPECT_EQ(addPacket(m_init_seqno, 0), -2);
+
+    // Add packet to a non-empty position.
+    EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, ack_pkts), 0), -1);
+
+    const int num_pkts_left = num_pkts - ack_pkts;
+    ackPackets(num_pkts_left);
+    for (int i = 0; i < num_pkts_left; ++i)
+    {
+        const int res = m_rcv_buffer->readBuffer(buff.data(), int(buff.size()));
+        EXPECT_TRUE(size_t(res) == m_payload_sz);
+        EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - num_pkts_left + i);
+        EXPECT_TRUE(verifyPayload(buff.data(), res, CSeqNo::incseq(m_init_seqno, ack_pkts + i)));
+    }
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
+
+
+// Add packets to the buffer in stream mode. Read fractional number of packets
+// to confirm a partially read packet stays in the buffer and is read properly afterwards.
+TEST_F(CRcvBufferReadStream, ReadFractional)
+{
+    const int num_pkts = 10;
+    ASSERT_LT(num_pkts, m_buff_size_pkts);
+    for (int i = 0; i < num_pkts; ++i)
+    {
+        EXPECT_EQ(addPacket(CSeqNo::incseq(m_init_seqno, i), 0, false, false), 0);
+    }
+
+    // The available buffer size remains the same
+    // The value is reported by SRT receiver like this:
+    // data[ACKD_BUFFERLEFT] = m_pRcvBuffer->getAvailBufSize();
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_TRUE(hasAvailablePackets());
+
+    array<char, m_payload_sz * num_pkts> buff;
+
+    const size_t nfull_pkts = 2;
+    const size_t num_bytes1 = nfull_pkts * m_payload_sz + m_payload_sz / 2;
+    const int res1 = m_rcv_buffer->readBuffer(buff.data(), num_bytes1);
+    EXPECT_TRUE(size_t(res1) == num_bytes1);
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_TRUE(hasAvailablePackets());
+
+    const size_t num_bytes2 = m_payload_sz * (num_pkts - nfull_pkts - 1) + m_payload_sz / 2;
+
+    const int res2 = m_rcv_buffer->readBuffer(buff.data() + num_bytes1, int(buff.size() - num_bytes1));
+    EXPECT_TRUE(size_t(res2) == num_bytes2);
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_FALSE(hasAvailablePackets());
+    ackPackets(num_pkts); // Move the reference ACK position.
+    EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+
+    for (int i = 0; i < num_pkts; ++i)
+    {
+        EXPECT_TRUE(verifyPayload(buff.data() + i * m_payload_sz, m_payload_sz, CSeqNo::incseq(m_init_seqno, i))) << "i = " << i;
+    }
+
+    EXPECT_EQ(m_unit_queue->size(), m_unit_queue->capacity());
+}
diff --git a/test/test_common.cpp b/test/test_common.cpp
index a4b8c033a..1a8cca061 100644
--- a/test/test_common.cpp
+++ b/test/test_common.cpp
@@ -2,9 +2,12 @@
 #include <stdlib.h>
 
 #include "gtest/gtest.h"
+#include "test_env.h"
 #include "utilities.h"
 #include "common.h"
 
+using namespace srt;
+
 void test_cipaddress_pton(const char* peer_ip, int family, const uint32_t (&ip)[4])
 {
     const int port = 4200;
@@ -34,13 +37,14 @@ void test_cipaddress_pton(const char* peer_ip, int family, const uint32_t (&ip)[
     sockaddr_any host(family);
     host.hport(port);
 
-    CIPAddress::pton(host, ip, peer);
+    srt::CIPAddress::pton(host, ip, peer);
     EXPECT_EQ(peer, host) << "Peer " << peer.str() << " host " << host.str();
 }
 
 // Example IPv4 address: 192.168.0.1
 TEST(CIPAddress, IPv4_pton)
 {
+    srt::TestInit srtinit;
     const char*    peer_ip = "192.168.0.1";
     const uint32_t ip[4]   = {htobe32(0xC0A80001), 0, 0, 0};
     test_cipaddress_pton(peer_ip, AF_INET, ip);
@@ -49,6 +53,7 @@ TEST(CIPAddress, IPv4_pton)
 // Example IPv6 address: 2001:db8:85a3:8d3:1319:8a2e:370:7348
 TEST(CIPAddress, IPv6_pton)
 {
+    srt::TestInit srtinit;
     const char*    peer_ip = "2001:db8:85a3:8d3:1319:8a2e:370:7348";
     const uint32_t ip[4]   = {htobe32(0x20010db8), htobe32(0x85a308d3), htobe32(0x13198a2e), htobe32(0x03707348)};
 
@@ -57,9 +62,10 @@ TEST(CIPAddress, IPv6_pton)
 
 // Example IPv4 address: 192.168.0.1
 // Maps to IPv6 address: 0:0:0:0:0:FFFF:192.168.0.1
-// Simplified: 	                 ::FFFF:192.168.0.1
+// Simplified:                   ::FFFF:192.168.0.1
 TEST(CIPAddress, IPv4_in_IPv6_pton)
 {
+    srt::TestInit srtinit;
     const char*    peer_ip = "::ffff:192.168.0.1";
     const uint32_t ip[4]   = {0, 0, htobe32(0x0000FFFF), htobe32(0xC0A80001)};
 
diff --git a/test/test_connection_timeout.cpp b/test/test_connection_timeout.cpp
index bbd87e145..ec52d9dd8 100644
--- a/test/test_connection_timeout.cpp
+++ b/test/test_connection_timeout.cpp
@@ -1,5 +1,7 @@
-#include <gtest/gtest.h>
 #include <chrono>
+#include <thread>
+#include <gtest/gtest.h>
+#include "test_env.h"
 
 #ifdef _WIN32
 #define INC_SRT_WIN_WINTIME // exclude gettimeofday from srt headers
@@ -11,12 +13,13 @@ typedef int SOCKET;
 
 #include"platform_sys.h"
 #include "srt.h"
+#include "netinet_any.h"
 
 using namespace std;
 
 
 class TestConnectionTimeout
-    : public ::testing::Test
+    : public ::srt::Test
 {
 protected:
     TestConnectionTimeout()
@@ -32,10 +35,8 @@ class TestConnectionTimeout
 protected:
 
     // SetUp() is run immediately before a test starts.
-    void SetUp() override
+    void setup() override
     {
-        ASSERT_EQ(srt_startup(), 0);
-
         m_sa.sin_family = AF_INET;
         m_sa.sin_addr.s_addr = INADDR_ANY;
         m_udp_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
@@ -60,12 +61,11 @@ class TestConnectionTimeout
         ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &m_sa.sin_addr), 1);
     }
 
-    void TearDown() override
+    void teardown() override
     {
         // Code here will be called just after the test completes.
         // OK to throw exceptions from here if needed.
-        ASSERT_NE(closesocket(m_udp_sock), -1);
-        srt_cleanup();
+        EXPECT_NE(closesocket(m_udp_sock), -1);
     }
 
 protected:
@@ -100,7 +100,7 @@ TEST_F(TestConnectionTimeout, Nonblocking) {
     EXPECT_EQ(conn_timeout, 3000);
 
     // Set connection timeout to 500 ms to reduce the test execution time
-    const int connection_timeout_ms = 500;
+    const int connection_timeout_ms = 300;
     EXPECT_EQ(srt_setsockopt(client_sock, 0, SRTO_CONNTIMEO, &connection_timeout_ms, sizeof connection_timeout_ms), SRT_SUCCESS);
 
     const int yes = 1;
@@ -126,7 +126,6 @@ TEST_F(TestConnectionTimeout, Nonblocking) {
         int wlen = 2;
         SRTSOCKET write[2];
 
-        using namespace std;
         const chrono::steady_clock::time_point chrono_ts_start = chrono::steady_clock::now();
 
         // Here we check the connection timeout.
@@ -143,9 +142,8 @@ TEST_F(TestConnectionTimeout, Nonblocking) {
         const chrono::steady_clock::time_point chrono_ts_end = chrono::steady_clock::now();
         const auto delta_ms = chrono::duration_cast<chrono::milliseconds>(chrono_ts_end - chrono_ts_start).count();
         // Confidence interval border : +/-80 ms
-        EXPECT_LE(delta_ms, connection_timeout_ms + 80);
-        EXPECT_GE(delta_ms, connection_timeout_ms - 80);
-        cerr << "Timeout was: " << delta_ms << "\n";
+        EXPECT_LE(delta_ms, connection_timeout_ms + 80) << "Timeout was: " << delta_ms;
+        EXPECT_GE(delta_ms, connection_timeout_ms - 80) << "Timeout was: " << delta_ms;
 
         EXPECT_EQ(rlen, 1);
         EXPECT_EQ(read[0], client_sock);
@@ -186,8 +184,14 @@ TEST_F(TestConnectionTimeout, BlockingLoop)
     const sockaddr* psa = reinterpret_cast<const sockaddr*>(&m_sa);
     for (int i = 0; i < 10; ++i)
     {
+        const chrono::steady_clock::time_point chrono_ts_start = chrono::steady_clock::now();
         EXPECT_EQ(srt_connect(client_sock, psa, sizeof m_sa), SRT_ERROR);
 
+        const auto delta_ms = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - chrono_ts_start).count();
+        // Confidence interval border : +/-200 ms
+        EXPECT_LE(delta_ms, connection_timeout_ms + 200) << "Timeout was: " << delta_ms;
+        EXPECT_GE(delta_ms, connection_timeout_ms - 200) << "Timeout was: " << delta_ms;
+
         const int error_code = srt_getlasterror(nullptr);
         EXPECT_EQ(error_code, SRT_ENOSERVER);
         if (error_code != SRT_ENOSERVER)
@@ -202,3 +206,68 @@ TEST_F(TestConnectionTimeout, BlockingLoop)
 }
 
 
+TEST(TestConnectionAPI, Accept)
+{
+    using namespace std::chrono;
+    using namespace srt;
+
+    srt_startup();
+
+    const SRTSOCKET caller_sock = srt_create_socket();
+    const SRTSOCKET listener_sock = srt_create_socket();
+
+    const int eidl = srt_epoll_create();
+    const int eidc = srt_epoll_create();
+    const int ev_conn = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
+    srt_epoll_add_usock(eidc, caller_sock, &ev_conn);
+    const int ev_acp = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+    srt_epoll_add_usock(eidl, listener_sock, &ev_acp);
+
+    sockaddr_any sa = srt::CreateAddr("localhost", 5555, AF_INET);
+
+    ASSERT_NE(srt_bind(listener_sock, sa.get(), sa.size()), -1);
+    ASSERT_NE(srt_listen(listener_sock, 1), -1);
+
+    // Set non-blocking mode so that you can wait for readiness
+    bool no = false;
+    srt_setsockflag(caller_sock, SRTO_RCVSYN, &no, sizeof no);
+    srt_setsockflag(listener_sock, SRTO_RCVSYN, &no, sizeof no);
+
+    srt_connect(caller_sock, sa.get(), sa.size());
+
+    SRT_EPOLL_EVENT ready[2];
+    int nready = srt_epoll_uwait(eidl, ready, 2, 1000); // Wait 1s
+    EXPECT_EQ(nready, 1);
+    EXPECT_EQ(ready[0].fd, listener_sock);
+    // EXPECT_EQ(ready[0].events, SRT_EPOLL_IN);
+
+    // Now call the accept function incorrectly
+    int size = 0;
+    sockaddr_storage saf;
+
+    EXPECT_EQ(srt_accept(listener_sock, (sockaddr*)&saf, &size), SRT_ERROR);
+
+    std::this_thread::sleep_for(seconds(1));
+
+    // Set correctly
+    size = sizeof (sockaddr_in6);
+    EXPECT_NE(srt_accept(listener_sock, (sockaddr*)&saf, &size), SRT_ERROR);
+
+    // Ended up with error, but now you should also expect error on the caller side.
+
+    // Wait 5s until you get a connection broken.
+    nready = srt_epoll_uwait(eidc, ready, 2, 5000);
+    EXPECT_EQ(nready, 1);
+    if (nready == 1)
+    {
+        // Do extra checks only if you know that this was returned.
+        EXPECT_EQ(ready[0].fd, caller_sock);
+        EXPECT_EQ(ready[0].events & SRT_EPOLL_ERR, 0u);
+    }
+    srt_close(caller_sock);
+    srt_close(listener_sock);
+
+    srt_cleanup();
+}
+
+
diff --git a/test/test_crypto.cpp b/test/test_crypto.cpp
new file mode 100644
index 000000000..47b18dd1a
--- /dev/null
+++ b/test/test_crypto.cpp
@@ -0,0 +1,110 @@
+#include <array>
+#include <numeric>
+
+#include "gtest/gtest.h"
+
+#if defined(SRT_ENABLE_ENCRYPTION) && defined(ENABLE_AEAD_API_PREVIEW)
+#include "crypto.h"
+#include "hcrypt.h" // Imports the CRYSPR_HAS_AESGCM definition.
+#include "socketconfig.h"
+
+namespace srt
+{
+
+    class Crypto
+        : public ::testing::Test
+    {
+    protected:
+        Crypto()
+            : m_crypt(0)
+        {
+            // initialization code here
+        }
+
+        virtual ~Crypto()
+        {
+            // cleanup any pending stuff, but no exceptions allowed
+        }
+
+    protected:
+        // SetUp() is run immediately before a test starts.
+        void SetUp() override
+        {
+            CSrtConfig cfg;
+
+            memset(&cfg.CryptoSecret, 0, sizeof(cfg.CryptoSecret));
+            cfg.CryptoSecret.typ = HAICRYPT_SECTYP_PASSPHRASE;
+            cfg.CryptoSecret.len = (m_pwd.size() <= (int)sizeof(cfg.CryptoSecret.str) ? m_pwd.size() : (int)sizeof(cfg.CryptoSecret.str));
+            memcpy((cfg.CryptoSecret.str), m_pwd.c_str(), m_pwd.size());
+
+            m_crypt.setCryptoSecret(cfg.CryptoSecret);
+
+            // 2 = 128, 3 = 192, 4 = 256
+            cfg.iSndCryptoKeyLen = SrtHSRequest::SRT_PBKEYLEN_BITS::wrap(4);
+            m_crypt.setCryptoKeylen(cfg.iSndCryptoKeyLen);
+
+            cfg.iCryptoMode = CSrtConfig::CIPHER_MODE_AES_GCM;
+            EXPECT_TRUE(m_crypt.init(HSD_INITIATOR, cfg, true, HaiCrypt_IsAESGCM_Supported()));
+
+            const unsigned char* kmmsg = m_crypt.getKmMsg_data(0);
+            const size_t km_len = m_crypt.getKmMsg_size(0);
+            uint32_t kmout[72];
+            size_t kmout_len = 72;
+
+            std::array<uint32_t, 72> km_nworder;
+            NtoHLA(km_nworder.data(), reinterpret_cast<const uint32_t*>(kmmsg), km_len);
+            m_crypt.processSrtMsg_KMREQ(km_nworder.data(), km_len, 5, SrtVersion(1, 5, 3), kmout, kmout_len);
+        }
+
+        void TearDown() override
+        {
+        }
+
+    protected:
+
+        srt::CCryptoControl m_crypt;
+        const std::string m_pwd = "abcdefghijk";
+    };
+
+
+    // Check that destroying the buffer also frees memory units.
+    TEST_F(Crypto, GCM)
+    {
+        if (HaiCrypt_IsAESGCM_Supported() == 0)
+            GTEST_SKIP() << "The crypto service provider does not support AES GCM.";
+
+        const size_t mtu_size = 1500;
+        const size_t pld_size = 1316;
+        const size_t tag_len  = 16;
+
+        CPacket pkt;
+        pkt.allocate(mtu_size);
+
+        const int seqno = 1;
+        const int msgno = 1;
+        const int inorder = 1;
+        const int kflg = m_crypt.getSndCryptoFlags();
+
+        pkt.set_seqno(seqno);
+        pkt.set_msgflags(msgno | inorder | PacketBoundaryBits(PB_SOLO) | MSGNO_ENCKEYSPEC::wrap(kflg));
+        pkt.set_timestamp(356);
+
+        std::iota(pkt.data(), pkt.data() + pld_size, '0');
+        pkt.setLength(pld_size);
+
+        EXPECT_EQ(m_crypt.encrypt(pkt), ENCS_CLEAR);
+        EXPECT_EQ(pkt.getLength(), pld_size + tag_len);
+
+        auto pkt_enc = std::unique_ptr<CPacket>(pkt.clone());
+
+        EXPECT_EQ(m_crypt.decrypt(pkt), ENCS_CLEAR);
+        EXPECT_EQ(pkt.getLength(), pld_size);
+
+        // Modify the payload and expect auth to fail.
+        pkt_enc->data()[10] = '5';
+        EXPECT_EQ(m_crypt.decrypt(*pkt_enc.get()), ENCS_FAILED);
+    }
+
+} // namespace srt
+
+#endif //SRT_ENABLE_ENCRYPTION && ENABLE_AEAD_API_PREVIEW
diff --git a/test/test_cryspr.cpp b/test/test_cryspr.cpp
index 3a54aaf4f..d4499bf9f 100644
--- a/test/test_cryspr.cpp
+++ b/test/test_cryspr.cpp
@@ -16,7 +16,7 @@
 
 const void *nullPtr = NULL;
 
-/* TestCRYSPRmethods: Test presense of required cryspr methods */
+/* TestCRYSPRmethods: Test presence of required cryspr methods */
 
 class TestCRYSPRmethods
     : public ::testing::Test
@@ -139,11 +139,11 @@ TEST_F(TestCRYSPRmethods, SHA1)
 
 
 /* CRYSPR control block test */
-class TestCRYSPRcypto
+class TestCRYSPRcrypto
     : public ::testing::Test
 {
 protected:
-    TestCRYSPRcypto()
+    TestCRYSPRcrypto()
     {
         // initialization code here
         cryspr_m = NULL;
@@ -151,7 +151,7 @@ class TestCRYSPRcypto
         cryspr_cb = NULL;
     }
 
-    ~TestCRYSPRcypto()
+    ~TestCRYSPRcrypto()
     {
         // cleanup any pending stuff, but no exceptions allowed
     }
@@ -192,7 +192,7 @@ class TestCRYSPRcypto
     CRYSPR_cb *cryspr_cb;       /* Control block */
 };
 
-TEST_F(TestCRYSPRcypto, CtrlBlock)
+TEST_F(TestCRYSPRcrypto, CtrlBlock)
 {
     EXPECT_EQ(cryspr_m, cryspr_cb->cryspr); //methods set in control block
 }
@@ -306,37 +306,37 @@ void test_pbkdf2(
 }
 
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv1_k128)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv1_k128)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 0);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv1_k192)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv1_k192)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 1);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv1_k256)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv1_k256)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 2);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv2_i1)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv2_i1)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 3);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv2_i20)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv2_i20)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 4);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv2_i4096)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv2_i4096)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 5);
 }
 
-TEST_F(TestCRYSPRcypto, PBKDF2_tv3_0)
+TEST_F(TestCRYSPRcrypto, PBKDF2_tv3_0)
 {
     test_pbkdf2(cryspr_m, cryspr_cb, 6);
 }
@@ -411,7 +411,7 @@ void test_kmwrap(
                 cryspr_cb,
                 wrap,
                 tv->sek,
-                tv->seklen);
+                uint32_t(tv->seklen));
 
             ASSERT_EQ(rc1, 0);
             ASSERT_EQ(rc2, 0);
@@ -447,7 +447,7 @@ void test_kmunwrap(
                 cryspr_cb,
                 sek,
                 tv->wrap,
-                wraplen);
+                uint32_t(wraplen));
 
             ASSERT_EQ(rc1, 0);
             ASSERT_EQ(rc2, 0);
@@ -457,28 +457,28 @@ void test_kmunwrap(
 }
 
 
-TEST_F(TestCRYSPRcypto, KMWRAP_tv1_k128)
+TEST_F(TestCRYSPRcrypto, KMWRAP_tv1_k128)
 {
     test_kmwrap(cryspr_m, cryspr_cb, 0);
 }
-TEST_F(TestCRYSPRcypto, KMWRAP_tv1_k192)
+TEST_F(TestCRYSPRcrypto, KMWRAP_tv1_k192)
 {
     test_kmwrap(cryspr_m, cryspr_cb, 1);
 }
-TEST_F(TestCRYSPRcypto, KMWRAP_tv1_k256)
+TEST_F(TestCRYSPRcrypto, KMWRAP_tv1_k256)
 {
     test_kmwrap(cryspr_m, cryspr_cb, 2);
 }
 
-TEST_F(TestCRYSPRcypto, KMUNWRAP_tv1_k128)
+TEST_F(TestCRYSPRcrypto, KMUNWRAP_tv1_k128)
 {
     test_kmunwrap(cryspr_m, cryspr_cb, 0);
 }
-TEST_F(TestCRYSPRcypto, KMUNWRAP_tv1_k192)
+TEST_F(TestCRYSPRcrypto, KMUNWRAP_tv1_k192)
 {
     test_kmunwrap(cryspr_m, cryspr_cb, 1);
 }
-TEST_F(TestCRYSPRcypto, KMUNWRAP_tv1_k256)
+TEST_F(TestCRYSPRcrypto, KMUNWRAP_tv1_k256)
 {
     test_kmunwrap(cryspr_m, cryspr_cb, 2);
 }
@@ -574,14 +574,11 @@ void test_AESecb(
         ASSERT_NE(cryspr_m->aes_ecb_cipher, nullPtr);
 
         rc1 = cryspr_m->aes_set_key(
+            HCRYPT_CTX_MODE_AESECB,
             bEncrypt,
             tv->sek,    /* Stream encrypting Key */
             tv->seklen,
-#if WITH_FIPSMODE
-            cryspr_cb->aes_sek[0]);
-#else
-            &cryspr_cb->aes_sek[0]);
-#endif
+            CRYSPR_GETSEK(cryspr_cb, 0));
         if(bEncrypt) {
             intxt=(unsigned char *)tv->cleartxt;
             outtxt=(unsigned char *)tv->ciphertxt;
@@ -592,11 +589,7 @@ void test_AESecb(
 
         rc2 = cryspr_m->aes_ecb_cipher(
             bEncrypt,                   /* true:encrypt, false:decrypt */
-#if WITH_FIPSMODE
-            cryspr_cb->aes_sek[0],      /* CRYpto Service PRovider AES Key context */
-#else
-            &cryspr_cb->aes_sek[0],      /* CRYpto Service PRovider AES Key context */
-#endif
+            CRYSPR_GETSEK(cryspr_cb, 0),/* CRYpto Service PRovider AES Key context */
             intxt,                      /* src */
             txtlen,                     /* length */
             result,                     /* dest */
@@ -613,51 +606,51 @@ void test_AESecb(
 #define ENCRYPT true
 #define DECRYPT false
 
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv1_128)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv1_128)
 {
     test_AESecb(cryspr_m, cryspr_cb, 0, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv1_192)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv1_192)
 {
     test_AESecb(cryspr_m, cryspr_cb, 1, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv1_256)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv1_256)
 {
     test_AESecb(cryspr_m, cryspr_cb, 2, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv2_128)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv2_128)
 {
     test_AESecb(cryspr_m, cryspr_cb, 3, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv2_192)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv2_192)
 {
     test_AESecb(cryspr_m, cryspr_cb, 4, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESecb_tv2_256)
+TEST_F(TestCRYSPRcrypto, EncryptAESecb_tv2_256)
 {
     test_AESecb(cryspr_m, cryspr_cb, 5, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv1_128)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv1_128)
 {
     test_AESecb(cryspr_m, cryspr_cb, 0, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv1_192)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv1_192)
 {
     test_AESecb(cryspr_m, cryspr_cb, 1, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv1_256)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv1_256)
 {
     test_AESecb(cryspr_m, cryspr_cb, 2, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv2_128)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv2_128)
 {
     test_AESecb(cryspr_m, cryspr_cb, 3, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv2_192)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv2_192)
 {
     test_AESecb(cryspr_m, cryspr_cb, 4, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESecb_tv2_256)
+TEST_F(TestCRYSPRcrypto, DecryptAESecb_tv2_256)
 {
     test_AESecb(cryspr_m, cryspr_cb, 5, DECRYPT);
 }
@@ -729,14 +722,11 @@ void test_AESctr(
         ASSERT_NE(cryspr_m->aes_ctr_cipher, nullPtr);
 
         rc1 = cryspr_m->aes_set_key(
+            HCRYPT_CTX_MODE_AESCTR,
             true,       //For CTR, Encrypt key is used for both encryption and decryption
             tv->sek,    /* Stream encrypting Key */
             tv->seklen,
-#if WITH_FIPSMODE
-            cryspr_cb->aes_sek[0]);
-#else
-            &cryspr_cb->aes_sek[0]);
-#endif
+            CRYSPR_GETSEK(cryspr_cb, 0));
         if(bEncrypt) {
             intxt=(unsigned char *)tv->cleartxt;
             outtxt=(unsigned char *)tv->ciphertxt;
@@ -748,11 +738,7 @@ void test_AESctr(
         memcpy(ivec, tv->iv, sizeof(ivec)); //cipher ivec not const
         rc2 = cryspr_m->aes_ctr_cipher(
             bEncrypt,                   /* true:encrypt, false:decrypt */
-#if WITH_FIPSMODE
-            cryspr_cb->aes_sek[0],      /* CRYpto Service PRovider AES Key context */
-#else
-            &cryspr_cb->aes_sek[0],      /* CRYpto Service PRovider AES Key context */
-#endif
+            CRYSPR_GETSEK(cryspr_cb, 0),/* CRYpto Service PRovider AES Key context */
             ivec,                       /* iv */
             intxt,                      /* src */
             txtlen,                     /* length */
@@ -768,27 +754,27 @@ void test_AESctr(
 #define ENCRYPT true
 #define DECRYPT false
 
-TEST_F(TestCRYSPRcypto, EncryptAESctr_tv1_128)
+TEST_F(TestCRYSPRcrypto, EncryptAESctr_tv1_128)
 {
     test_AESctr(cryspr_m, cryspr_cb, 0, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESctr_tv1_192)
+TEST_F(TestCRYSPRcrypto, EncryptAESctr_tv1_192)
 {
     test_AESctr(cryspr_m, cryspr_cb, 1, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, EncryptAESctr_tv1_256)
+TEST_F(TestCRYSPRcrypto, EncryptAESctr_tv1_256)
 {
     test_AESctr(cryspr_m, cryspr_cb, 2, ENCRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESctr_tv1_128)
+TEST_F(TestCRYSPRcrypto, DecryptAESctr_tv1_128)
 {
     test_AESctr(cryspr_m, cryspr_cb, 0, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESctr_tv1_192)
+TEST_F(TestCRYSPRcrypto, DecryptAESctr_tv1_192)
 {
     test_AESctr(cryspr_m, cryspr_cb, 1, DECRYPT);
 }
-TEST_F(TestCRYSPRcypto, DecryptAESctr_tv1_256)
+TEST_F(TestCRYSPRcrypto, DecryptAESctr_tv1_256)
 {
     test_AESctr(cryspr_m, cryspr_cb, 2, DECRYPT);
 }
diff --git a/test/test_enforced_encryption.cpp b/test/test_enforced_encryption.cpp
index eeddfb922..717b4549c 100644
--- a/test/test_enforced_encryption.cpp
+++ b/test/test_enforced_encryption.cpp
@@ -10,10 +10,11 @@
  *             Haivision Systems Inc.
  */
 
-#include <gtest/gtest.h>
 #include <thread>
 #include <condition_variable> 
 #include <mutex>
+#include <gtest/gtest.h>
+#include "test_env.h"
 
 #include "srt.h"
 #include "sync.h"
@@ -214,7 +215,7 @@ const TestCaseBlocking g_test_matrix_blocking[] =
 
 
 class TestEnforcedEncryption
-    : public ::testing::Test
+    : public srt::Test
 {
 protected:
     TestEnforcedEncryption()
@@ -230,10 +231,8 @@ class TestEnforcedEncryption
 protected:
 
     // SetUp() is run immediately before a test starts.
-    void SetUp()
+    void setup() override
     {
-        ASSERT_EQ(srt_startup(), 0);
-
         m_pollid = srt_epoll_create();
         ASSERT_GE(m_pollid, 0);
 
@@ -254,13 +253,20 @@ class TestEnforcedEncryption
         ASSERT_NE(srt_epoll_add_usock(m_pollid, m_listener_socket, &epoll_out), SRT_ERROR);
     }
 
-    void TearDown()
+    void teardown() override
     {
         // Code here will be called just after the test completes.
         // OK to throw exceptions from here if needed.
-        ASSERT_NE(srt_close(m_caller_socket),   SRT_ERROR);
-        ASSERT_NE(srt_close(m_listener_socket), SRT_ERROR);
-        srt_cleanup();
+
+        if (m_caller_socket != SRT_INVALID_SOCK)
+        {
+            EXPECT_NE(srt_close(m_caller_socket),   SRT_ERROR) << srt_getlasterror_str();
+        }
+
+        if (m_listener_socket != SRT_INVALID_SOCK)
+        {
+            EXPECT_NE(srt_close(m_listener_socket), SRT_ERROR) << srt_getlasterror_str();
+        }
     }
 
 
@@ -277,10 +283,10 @@ class TestEnforcedEncryption
     bool GetEnforcedEncryption(PEER_TYPE peer_type)
     {
         const SRTSOCKET socket = peer_type == PEER_CALLER ? m_caller_socket : m_listener_socket;
-        int value = -1;
-        int value_len = sizeof value;
-        EXPECT_EQ(srt_getsockopt(socket, 0, SRTO_ENFORCEDENCRYPTION, (void*)&value, &value_len), SRT_SUCCESS);
-        return value ? true : false;
+        bool optval;
+        int  optlen = sizeof optval;
+        EXPECT_EQ(srt_getsockopt(socket, 0, SRTO_ENFORCEDENCRYPTION, (void*)&optval, &optlen), SRT_SUCCESS);
+        return optval ? true : false;
     }
 
 
@@ -345,10 +351,15 @@ class TestEnforcedEncryption
         ASSERT_EQ(SetPassword(PEER_CALLER, test.password[PEER_CALLER]), SRT_SUCCESS);
         ASSERT_EQ(SetPassword(PEER_LISTENER, test.password[PEER_LISTENER]), SRT_SUCCESS);
 
+        // Determine the subcase for the KLUDGE (check the behavior of the decryption failure)
+        const bool case_pw_failure = test.password[PEER_CALLER] != test.password[PEER_LISTENER];
+        const bool case_both_relaxed = !test.enforcedenc[PEER_LISTENER] && !test.enforcedenc[PEER_CALLER];
+        const bool case_sender_enc = test.password[PEER_CALLER] != "";
+
         const TResult &expect = test.expected_result;
 
         // Start testing
-        volatile bool caller_done = false;
+        srt::sync::atomic<bool> caller_done;
         sockaddr_in sa;
         memset(&sa, 0, sizeof sa);
         sa.sin_family = AF_INET;
@@ -358,6 +369,8 @@ class TestEnforcedEncryption
         ASSERT_NE(srt_bind(m_listener_socket, psa, sizeof sa), SRT_ERROR);
         ASSERT_NE(srt_listen(m_listener_socket, 4), SRT_ERROR);
 
+        SRTSOCKET accepted_socket = -1;
+
         auto accepting_thread = std::thread([&] {
             const int epoll_event = WaitOnEpoll(expect);
 
@@ -366,7 +379,6 @@ class TestEnforcedEncryption
             // otherwise SRT_INVALID_SOCKET after the listening socket is closed.
             sockaddr_in client_address;
             int length = sizeof(sockaddr_in);
-            SRTSOCKET accepted_socket = -1;
             if (epoll_event == SRT_EPOLL_IN)
             {
                 accepted_socket = srt_accept(m_listener_socket, (sockaddr*)&client_address, &length);
@@ -407,7 +419,7 @@ class TestEnforcedEncryption
                     std::cerr << "SND KM State accepted:     " << m_km_state[GetSocetkOption(accepted_socket, SRTO_SNDKMSTATE)] << '\n';
                 }
 
-                // We have to wait some time for the socket to be able to process the HS responce from the caller.
+                // We have to wait some time for the socket to be able to process the HS response from the caller.
                 // In test cases B2 - B4 the socket is expected to change its state from CONNECTED to BROKEN
                 // due to KM mismatches
                 do
@@ -415,22 +427,25 @@ class TestEnforcedEncryption
                     std::this_thread::sleep_for(std::chrono::milliseconds(50));
                 } while (!caller_done);
 
-                const SRT_SOCKSTATUS status = srt_getsockstate(accepted_socket);
-                if (m_is_tracing)
-                {
-                    std::cerr << "LATE Socket state accepted: " << m_socket_state[status]
-                        << " (expected: " << m_socket_state[expect.socket_state[CHECK_SOCKET_ACCEPTED]] << ")\n";
-                }
+                // Special case when the expected state is "broken": if so, tolerate every possible
+                // socket state, just NOT LESS than SRTS_BROKEN, and also don't read any flags on that socket.
 
                 if (expect.socket_state[CHECK_SOCKET_ACCEPTED] == SRTS_BROKEN)
                 {
-                    EXPECT_TRUE(accepted_socket == -1 || status == SRTS_BROKEN || status == SRTS_CLOSED);
+                    EXPECT_GE(srt_getsockstate(accepted_socket), SRTS_BROKEN);
                 }
                 else
                 {
-                    EXPECT_EQ(status, expect.socket_state[CHECK_SOCKET_ACCEPTED]);
+                    EXPECT_EQ(srt_getsockstate(accepted_socket), expect.socket_state[CHECK_SOCKET_ACCEPTED]);
                     EXPECT_EQ(GetSocetkOption(accepted_socket, SRTO_SNDKMSTATE), expect.km_state[CHECK_SOCKET_ACCEPTED]);
                 }
+
+                if (m_is_tracing)
+                {
+                    const SRT_SOCKSTATUS status = srt_getsockstate(accepted_socket);
+                    std::cerr << "LATE Socket state accepted: " << m_socket_state[status]
+                        << " (expected: " << m_socket_state[expect.socket_state[CHECK_SOCKET_ACCEPTED]] << ")\n";
+                }
             }
         });
 
@@ -481,12 +496,60 @@ class TestEnforcedEncryption
         EXPECT_EQ(srt_getsockstate(m_listener_socket), SRTS_LISTENING);
         EXPECT_EQ(GetKMState(m_listener_socket), SRT_KM_S_UNSECURED);
 
+        if (!is_blocking && case_both_relaxed && case_pw_failure && case_sender_enc)
+        {
+            // Additionally check decryption failure does not trigger read-readiness (see issue #2503).
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            EXPECT_FALSE(accepting_thread.joinable());
+
+            int const epollRead = srt_epoll_create();
+            int events = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+            srt_epoll_add_usock(epollRead, accepted_socket, &events);
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+            {
+                int const epollWrite = srt_epoll_create();
+                events = SRT_EPOLL_OUT | SRT_EPOLL_ERR;
+                srt_epoll_add_usock(epollWrite, m_caller_socket, &events);
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+                SRTSOCKET   srtSocket  = SRT_INVALID_SOCK;
+                int         socketNum  = 1;
+                const int epoll_res_w = srt_epoll_wait(epollWrite,
+                        nullptr, nullptr, // read
+                        &srtSocket, &socketNum, // write
+                        500,
+                        nullptr, nullptr, nullptr, nullptr); // R/W system sockets
+                std::cout << "W: " << epoll_res_w << std::endl;
+
+                char buffer[1316] = {1, 2, 3, 4};
+                ASSERT_NE(srt_sendmsg2(m_caller_socket, buffer, sizeof buffer, nullptr), SRT_ERROR);
+                std::this_thread::sleep_for(std::chrono::seconds(1));
+            }
+
+            SRTSOCKET   srtSocket  = SRT_INVALID_SOCK;
+            int         socketNum  = 1;
+            int epoll_res_r = srt_epoll_wait(epollRead, &srtSocket, &socketNum, nullptr, nullptr, 500, nullptr, nullptr, nullptr, nullptr);
+            std::cout << "R: " << epoll_res_r << std::endl;
+            EXPECT_LE(epoll_res_r, 0) << "It's wrongly reported, so let's take a look...";
+            char buffer[1316] = {};
+            EXPECT_EQ(srt_recvmsg2(accepted_socket, buffer, sizeof buffer, nullptr), -1);
+
+            epoll_res_r = srt_epoll_wait(epollRead, &srtSocket, &socketNum, nullptr, nullptr, 500, nullptr, nullptr, nullptr, nullptr);
+            EXPECT_LE(epoll_res_r, 0) << "Another?!";
+            //// ! /KLUDGE !
+
+            srt_epoll_release(epollRead);
+        }
+
         if (is_blocking)
         {
             // srt_accept() has no timeout, so we have to close the socket and wait for the thread to exit.
             // Just give it some time and close the socket.
             std::this_thread::sleep_for(std::chrono::milliseconds(50));
             ASSERT_NE(srt_close(m_listener_socket), SRT_ERROR);
+            m_listener_socket = SRT_INVALID_SOCK; // mark closed already
             accepting_thread.join();
         }
     }
@@ -500,8 +563,8 @@ class TestEnforcedEncryption
 
     int       m_pollid          = 0;
 
-    const int s_yes = 1;
-    const int s_no  = 0;
+    const bool s_yes = true;
+    const bool s_no  = false;
 
     const bool          m_is_tracing = false;
     static const char*  m_km_state[];
@@ -527,7 +590,7 @@ static std::ostream& PrintEpollEvent(std::ostream& os, int events, int et_events
         make_pair(SRT_EPOLL_UPDATE, "U")
     };
 
-    int N = Size(namemap);
+    const int N = (int)Size(namemap);
 
     for (int i = 0; i < N; ++i)
     {
@@ -626,7 +689,7 @@ static const char* const socket_state_array[] = {
 const char* const* TestEnforcedEncryption::m_socket_state = socket_state_array+1;
 
 /** 
- * @fn TEST_F(TestEnforcedEncryption, PasswordLength)
+ * @fn TestEnforcedEncryption.PasswordLength
  * @brief The password length should belong to the interval of [10; 80]
  */
 TEST_F(TestEnforcedEncryption, PasswordLength)
@@ -661,7 +724,7 @@ TEST_F(TestEnforcedEncryption, PasswordLength)
 
 
 /**
- * @fn TEST_F(TestEnforcedEncryption, SetGetDefault)
+ * @fn TestEnforcedEncryption.SetGetDefault
  * @brief The default value for the enforced encryption should be ON
  */
 TEST_F(TestEnforcedEncryption, SetGetDefault)
diff --git a/test/test_env.h b/test/test_env.h
new file mode 100644
index 000000000..b425fa808
--- /dev/null
+++ b/test/test_env.h
@@ -0,0 +1,136 @@
+#ifndef INC_SRT_TESTENV_H
+#define INC_SRT_TESTENV_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <stdexcept>
+#include "gtest/gtest.h"
+
+
+namespace srt
+{
+class TestEnv: public testing::Environment
+{
+public:
+    static TestEnv* me;
+    std::vector<std::string> args;
+    std::map<std::string, std::vector<std::string>> argmap;
+
+    explicit TestEnv(int argc, char** argv)
+        : args(argv+1, argv+argc)
+    {
+        if (me)
+            throw std::invalid_argument("singleton");
+
+        me = this;
+        FillArgMap();
+    }
+
+    void FillArgMap();
+
+    bool OptionPresent(const std::string& key)
+    {
+        return argmap.count(key) > 0;
+    }
+
+    std::string OptionValue(const std::string& key);
+
+    // Specific test environment options
+    // All must be static, return bool. Arguments allowed.
+    // The name must start with Allowed_.
+    static bool Allowed_IPv6();
+};
+
+#define SRTST_REQUIRES(feature,...) if (!srt::TestEnv::Allowed_##feature(__VA_ARGS__)) { return; }
+
+
+class TestInit
+{
+public:
+    int ninst;
+
+    static void start(int& w_retstatus);
+    static void stop();
+
+    TestInit()
+    {
+        start((ninst));
+        HandlePerTestOptions();
+    }
+    ~TestInit() { stop(); }
+
+    void HandlePerTestOptions();
+
+};
+
+class UniqueSocket
+{
+    int32_t sock;
+    std::string lab, f;
+    int l;
+
+public:
+    UniqueSocket(int32_t s, const char* label, const char* file, int line): sock(s)
+    {
+        if (s == -1)
+            throw std::invalid_argument("Invalid socket");
+        lab = label;
+        f = file;
+        l = line;
+    }
+
+#define MAKE_UNIQUE_SOCK(name, label, expr) srt::UniqueSocket name (expr, label, __FILE__, __LINE__)
+
+    UniqueSocket(): sock(-1), l(0)
+    {
+    }
+
+    void close();
+    ~UniqueSocket();
+
+    operator int32_t() const
+    {
+        return sock;
+    }
+
+    int32_t& ref() { return sock; }
+
+    /*
+       IF NEEDED, MOVE to test_main.cpp
+    UniqueSocket& operator=(int32_t s)
+    {
+        if (sock == s)
+            return;
+        srt_close(sock);
+        sock = s;
+    }
+    */
+};
+
+class Test: public testing::Test
+{
+    std::unique_ptr<TestInit> init_holder;
+public:
+
+    virtual void setup() = 0;
+    virtual void teardown() = 0;
+
+    void SetUp() override final
+    {
+        init_holder.reset(new TestInit);
+        setup();
+    }
+
+    void TearDown() override final
+    {
+        teardown();
+        init_holder.reset();
+    }
+};
+
+struct sockaddr_any CreateAddr(const std::string& name, unsigned short port, int pref_family);
+
+} //namespace
+
+#endif
diff --git a/test/test_epoll.cpp b/test/test_epoll.cpp
index ebeb0d73a..a8a88aa7a 100644
--- a/test/test_epoll.cpp
+++ b/test/test_epoll.cpp
@@ -4,17 +4,18 @@
 #include <thread>
 #include <condition_variable>
 #include "gtest/gtest.h"
+#include "test_env.h"
 #include "api.h"
 #include "epoll.h"
 
 
 using namespace std;
+using namespace srt;
 
 
 TEST(CEPoll, InfiniteWait)
 {
-    ASSERT_EQ(srt_startup(), 0);
-
+    srt::TestInit srtinit;
     const int epoll_id = srt_epoll_create();
     ASSERT_GE(epoll_id, 0);
 
@@ -24,13 +25,11 @@ TEST(CEPoll, InfiniteWait)
         0, 0, 0, 0), SRT_ERROR);
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
-
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WaitNoSocketsInEpoll)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
     const int epoll_id = srt_epoll_create();
     ASSERT_GE(epoll_id, 0);
@@ -46,12 +45,11 @@ TEST(CEPoll, WaitNoSocketsInEpoll)
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WaitNoSocketsInEpoll2)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
     const int epoll_id = srt_epoll_create();
     ASSERT_GE(epoll_id, 0);
@@ -62,14 +60,13 @@ TEST(CEPoll, WaitNoSocketsInEpoll2)
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WaitEmptyCall)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int no = 0;
@@ -86,14 +83,13 @@ TEST(CEPoll, WaitEmptyCall)
                 -1, 0, 0, 0, 0), SRT_ERROR);
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, UWaitEmptyCall)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int no = 0;
@@ -110,14 +106,13 @@ TEST(CEPoll, UWaitEmptyCall)
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WaitAllSocketsInEpollReleased)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int yes = 1;
@@ -145,14 +140,13 @@ TEST(CEPoll, WaitAllSocketsInEpollReleased)
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WaitAllSocketsInEpollReleased2)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int yes = 1;
@@ -174,15 +168,13 @@ TEST(CEPoll, WaitAllSocketsInEpollReleased2)
     ASSERT_EQ(srt_epoll_uwait(epoll_id, events, 2, -1), SRT_ERROR);
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
-
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, WrongEpoll_idOnAddUSock)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int no  = 0;
@@ -198,15 +190,14 @@ TEST(CEPoll, WrongEpoll_idOnAddUSock)
 
     EXPECT_EQ(srt_epoll_release(epoll_id), 0);
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 
 TEST(CEPoll, HandleEpollEvent)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     EXPECT_NE(client_sock, SRT_ERROR);
 
     const int yes = 1;
@@ -255,7 +246,6 @@ TEST(CEPoll, HandleEpollEvent)
         throw;
     }
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 
@@ -265,10 +255,10 @@ TEST(CEPoll, HandleEpollEvent)
 // be notified about connection break via polling the accepted socket.
 TEST(CEPoll, NotifyConnectionBreak)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
     // 1. Prepare client
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     ASSERT_NE(client_sock, SRT_ERROR);
 
     const int yes SRT_ATR_UNUSED = 1;
@@ -290,7 +280,7 @@ TEST(CEPoll, NotifyConnectionBreak)
     ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa_client.sin_addr), 1);
 
     // 2. Prepare server
-    SRTSOCKET server_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(server_sock, "server_sock", srt_create_socket());
     ASSERT_NE(server_sock, SRT_ERROR);
 
     ASSERT_NE(srt_setsockopt(server_sock, 0, SRTO_RCVSYN, &no, sizeof no), SRT_ERROR); // for async connect
@@ -348,9 +338,9 @@ TEST(CEPoll, NotifyConnectionBreak)
 
     // The caller will close connection after 1 second
     auto close_res = std::async(std::launch::async, [&client_sock]() {
-        cout << "TEST(async call): WILL CLOSE client connection in 3s\n";
+        cout << "(async call): WILL CLOSE client connection in 3s\n";
         this_thread::sleep_for(chrono::seconds(1));
-        cout << "TEST(async call): Closing client connection\n";
+        cout << "(async call): Closing client connection\n";
         return srt_close(client_sock);
         });
 
@@ -367,7 +357,7 @@ TEST(CEPoll, NotifyConnectionBreak)
     EXPECT_EQ(ready[0], sock);
 
     // Wait for the caller to close connection
-    // There should be no wait, as epoll should wait untill connection is closed.
+    // There should be no wait, as epoll should wait until connection is closed.
     EXPECT_EQ(close_res.get(), SRT_SUCCESS);
     const SRT_SOCKSTATUS state = srt_getsockstate(sock);
     const bool state_valid = state == SRTS_BROKEN || state == SRTS_CLOSING || state == SRTS_CLOSED;
@@ -375,15 +365,14 @@ TEST(CEPoll, NotifyConnectionBreak)
     if (!state_valid)
         cerr << "socket state: " << state << endl;
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 
 TEST(CEPoll, HandleEpollEvent2)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     EXPECT_NE(client_sock, SRT_ERROR);
 
     const int yes = 1;
@@ -408,7 +397,7 @@ TEST(CEPoll, HandleEpollEvent2)
 
     int result = epoll.uwait(epoll_id, fds, 1024, -1);
     ASSERT_EQ(result, 1); 
-    ASSERT_EQ(fds[0].events, SRT_EPOLL_ERR);
+    ASSERT_EQ(fds[0].events, int(SRT_EPOLL_ERR));
 
     // Edge-triggered means that after one wait call was done, the next
     // call to this event should no longer report it. Now use timeout 0
@@ -437,15 +426,14 @@ TEST(CEPoll, HandleEpollEvent2)
         throw;
     }
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 
 TEST(CEPoll, HandleEpollNoEvent)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     EXPECT_NE(client_sock, SRT_ERROR);
 
     const int yes = 1;
@@ -489,14 +477,13 @@ TEST(CEPoll, HandleEpollNoEvent)
         throw;
     }
 
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 TEST(CEPoll, ThreadedUpdate)
 {
-    ASSERT_EQ(srt_startup(), 0);
+    srt::TestInit srtinit;
 
-    SRTSOCKET client_sock = srt_create_socket();
+    MAKE_UNIQUE_SOCK(client_sock, "client", srt_create_socket());
     EXPECT_NE(client_sock, SRT_ERROR);
 
     const int no  = 0;
@@ -529,7 +516,7 @@ TEST(CEPoll, ThreadedUpdate)
     int result = epoll.uwait(epoll_id, fds, 1024, -1);
     cerr << "Exit no longer infinite-wait by uwait, result=" << result << "\n";
     ASSERT_EQ(result, 1); 
-    ASSERT_EQ(fds[0].events, SRT_EPOLL_ERR);
+    ASSERT_EQ(fds[0].events, int(SRT_EPOLL_ERR));
 
     cerr << "THREAD JOIN...\n";
     td.join();
@@ -555,13 +542,10 @@ TEST(CEPoll, ThreadedUpdate)
         cerr << ex.getErrorMessage() << endl;
         throw;
     }
-
-
-    EXPECT_EQ(srt_cleanup(), 0);
 }
 
 
-class TestEPoll: public testing::Test
+class TestEPoll: public srt::Test
 {
 protected:
 
@@ -691,7 +675,7 @@ class TestEPoll: public testing::Test
 
             ASSERT_EQ(rlen, 1); // get exactly one read event without writes
             ASSERT_EQ(wlen, 0); // get exactly one read event without writes
-            ASSERT_EQ(read[0], servsock); // read event is for bind socket    	
+            ASSERT_EQ(read[0], servsock); // read event is for bind socket
         }
 
         sockaddr_in scl;
@@ -718,7 +702,7 @@ class TestEPoll: public testing::Test
 
             ASSERT_EQ(rlen, 1); // get exactly one read event without writes
             ASSERT_EQ(wlen, 0); // get exactly one read event without writes
-            ASSERT_EQ(read[0], acpsock); // read event is for bind socket        
+            ASSERT_EQ(read[0], acpsock); // read event is for bind socket
         }
 
         char buffer[1316];
@@ -749,10 +733,8 @@ class TestEPoll: public testing::Test
         srt_close(servsock);
     }
 
-    void SetUp() override
+    void setup() override
     {
-        ASSERT_EQ(srt_startup(), 0);
-
         m_client_pollid = srt_epoll_create();
         ASSERT_NE(SRT_ERROR, m_client_pollid);
 
@@ -761,19 +743,18 @@ class TestEPoll: public testing::Test
 
     }
 
-    void TearDown() override
+    void teardown() override
     {
         (void)srt_epoll_release(m_client_pollid);
         (void)srt_epoll_release(m_server_pollid);
-        srt_cleanup();
     }
 };
 
 
 TEST_F(TestEPoll, SimpleAsync)
 {
-    SRTSOCKET ss = SRT_INVALID_SOCK;
-    createServerSocket( (ss) );
+    srt::UniqueSocket ss;
+    createServerSocket( (ss.ref()) );
 
     std::thread client([this] { clientSocket(); });
 
diff --git a/test/test_fec_rebuilding.cpp b/test/test_fec_rebuilding.cpp
index 8651a341e..ac57e5265 100644
--- a/test/test_fec_rebuilding.cpp
+++ b/test/test_fec_rebuilding.cpp
@@ -1,14 +1,22 @@
 #include <vector>
+#include <algorithm>
+#include <future>
 
 #include "gtest/gtest.h"
+#include "test_env.h"
 #include "packet.h"
 #include "fec.h"
+#include "core.h"
 #include "packetfilter.h"
 #include "packetfilter_api.h"
 
+// For direct imp access
+#include "api.h"
+
 using namespace std;
+using namespace srt;
 
-class TestFECRebuilding: public testing::Test
+class TestFECRebuilding: public srt::Test
 {
 protected:
     FECFilterBuiltin* fec = nullptr;
@@ -24,7 +32,7 @@ class TestFECRebuilding: public testing::Test
         PacketFilter::globalInit();
     }
 
-    void SetUp() override
+    void setup() override
     {
         int timestamp = 10;
 
@@ -32,7 +40,8 @@ class TestFECRebuilding: public testing::Test
             sockid,
             isn - 1, // It's passed in this form to PacketFilter constructor, it should increase it
             isn - 1, // XXX Probably this better be changed.
-            plsize
+            plsize,
+            CSrtConfig::DEF_BUFFER_SIZE
         };
 
 
@@ -64,7 +73,7 @@ class TestFECRebuilding: public testing::Test
             // Randomly chose the size
 
             int minsize = 732;
-            int divergence = plsize - minsize - 1;
+            int divergence = int(plsize) - minsize - 1;
             size_t length = minsize + rand() % divergence;
 
             p.setLength(length);
@@ -78,12 +87,678 @@ class TestFECRebuilding: public testing::Test
         }
     }
 
-    void TearDown() override
+    void teardown() override
     {
         delete fec;
     }
 };
 
+namespace srt {
+    class TestMockCUDT
+    {
+    public:
+        CUDT* core;
+
+        bool checkApplyFilterConfig(const string& s)
+        {
+            return core->checkApplyFilterConfig(s);
+        }
+    };
+}
+
+// The expected whole procedure of connection using FEC is
+// expected to:
+//
+// 1. Successfully set the FEC option for correct filter type.
+//    - STOP ON FAILURE: unknown filter type (the table below, case D)
+// 2. Perform the connection and integrate configurations.
+//    - STOP on failed integration (the table below, cases A and B)
+// 3. Deliver on both sides identical configurations consisting
+//    of combined configurations and completed with default values.
+//    - Not possible if stopped before.
+//
+// Test coverage for the above cases:
+//
+// Success cases in all of the above: ConfigExchange, Connection, ConnectionReorder
+// Failure cases:
+// 1. ConfigExchangeFaux - setting unknown filter type
+// 2. ConfigExchangeFaux, RejectionConflict, RejectionIncomplete, RejectionIncompleteEmpty
+//
+// For config exchange we have several possibilities here:
+//
+// - any same parameters with different values are rejected (Case A)
+// - resulting configuiration should have the `cols` value set (Cases B)
+//
+// The configuration API rules that control correctness:
+//
+// 1. The first word defines an existing filter type.
+// 2. Parameters are defined in whatever order.
+// 3. Some parameters are optional and have default values. Others are mandatory.
+// 4. A parameter provided twice remains with the last specification.
+// 5. A parameter with empty value is like not provided parameter.
+// 6. Only parameters handled by given filter type are allowed.
+// 7. Every parameter may have limitations on the provided value:
+//    a. Numeric values in appropriate range
+//    b. String-enumeration with only certain values allowed
+//
+// Additionally there are rules for configuration integration:
+//
+// 8. Configuration consists of parameters provided in both sides.
+// 9. Parameters lacking after integration are set to default values.
+// 10. Parameters specified on both sides (including type) must be equal.
+// 11. Empty configuration blindly accepts the configuration from the peer.
+// 12. The final configuration must provide mandatory parameters
+//
+// Restrictive rules type are: 1, 6, 7, 10
+//
+// Case description:
+// A: Conflicting values on the same parameter (rejection, rule 10 failure)
+// B: Missing a mandatory parameter (rejection, rule 12 failure)
+// C: Successful setting and combining parameters
+//    1: rules (positive): 1, 3, 6, 7(part), 8, 9, 12
+//    2: rules (positive): 1, 2, 3, 6, 7(part), 9, 10, 12
+//    3,4: rules (positive): 1, 2, 3(all), 6, 7(all), 8, 10, 12
+//    5: rules (positive): 1, 3, 4, 5, 6, 7, 8, 9, 12
+//    6: rules (positive): 1, 3, 6, 7, 8, 11, 12
+// D: Unknown filter type (failed option, rule 1)
+// E: Incorrect values of the parameters (failed option, rule 7)
+// F: Unknown excessive parameters (failed option, rule 6)
+//
+// Case |Party A                 |  Party B           | Situation           | Test coverage
+//------|------------------------|--------------------|---------------------|---------------
+//  A   |fec,cols:10             | fec,cols:20        | Conflict            | ConfigExchangeFaux, RejectionConflict
+//  B1  |fec,rows:10             | fec,arq:never      | Missing `cols`      | RejectionIncomplete
+//  B2  |fec,rows:10             |                    | Missing `cols`      | RejectionIncompleteEmpty
+//  C1  |fec,cols:10,rows:10     | fec                | OK                  | ConfigExchange, Connection
+//  C2  |fec,cols:10,rows:10     | fec,rows:10,cols:10| OK                  | ConnectionReorder
+//  C3  |FULL 1 (see below)      | FULL 2 (see below) | OK                  | ConnectionFull1
+//  C4  |FULL 3 (see below)      | FULL 4 (see below) | OK                  | ConnectionFull2
+//  C5  |fec,cols:,cols:10       | fec,cols:,rows:10  | OK                  | ConnectionMess
+//  C6  |fec,rows:20,cols:20     |                    | OK                  | ConnectionForced
+//  D   |FEC,Cols:10             | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  E1  |fec,cols:-10            | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  E2  |fec,cols:10,rows:0      | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  E3  |fec,cols:10,rows:-1     | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  E4  |fec,cols:10,layout:x (*)| (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  E5  |fec,cols:10,arq:x (*)   | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//  F   |fec,cols:10,weight:2    | (unimportant)      | Option rejected     | ConfigExchangeFaux
+//
+// (*) Here is just an example of a longer string that surely is wrong for this parameter.
+//
+// The configurations for FULL (cases C3 and C4) are longer and use all possible
+// values in different order:
+// 1. fec,cols:10,rows:20,arq:never,layout:even
+// 1. fec,layout:even,rows:20,cols:10,arq:never
+// 1. fec,cols:10,rows:20,arq:always,layout:even
+// 1. fec,layout:even,rows:20,cols:10,arq:always
+
+
+bool filterConfigSame(const string& config1, const string& config2)
+{
+    vector<string> config1_vector;
+    Split(config1, ',', back_inserter(config1_vector));
+    sort(config1_vector.begin(), config1_vector.end());
+
+    vector<string> config2_vector;
+    Split(config2, ',', back_inserter(config2_vector));
+    sort(config2_vector.begin(), config2_vector.end());
+
+    return config1_vector == config2_vector;
+}
+
+TEST(TestFEC, ConfigExchange)
+{
+    srt::TestInit srtinit;
+
+    CUDTSocket* s1;
+
+    SRTSOCKET sid1 = CUDT::uglobal().newSocket(&s1);
+
+    TestMockCUDT m1;
+    m1.core = &s1->core();
+
+    // Can't access the configuration storage without
+    // accessing the private fields, so let's use the official API
+
+    char fec_config1 [] = "fec,cols:10,rows:10";
+
+    srt_setsockflag(sid1, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1);
+
+    EXPECT_TRUE(m1.checkApplyFilterConfig("fec,cols:10,arq:never"));
+
+    char fec_configback[200];
+    int fec_configback_size = 200;
+    srt_getsockflag(sid1, SRTO_PACKETFILTER, fec_configback, &fec_configback_size);
+
+    // Order of parameters may differ, so store everything in a vector and sort it.
+
+    string exp_config = "fec,cols:10,rows:10,arq:never,layout:staircase";
+
+    EXPECT_TRUE(filterConfigSame(fec_configback, exp_config));
+    srt_close(sid1);
+}
+
+TEST(TestFEC, ConfigExchangeFaux)
+{
+    srt::TestInit srtinit;
+
+    CUDTSocket* s1;
+
+    SRTSOCKET sid1 = CUDT::uglobal().newSocket(&s1);
+
+    const char* fec_config_wrong [] = {
+        "FEC,Cols:20", // D: unknown filter
+        "fec,cols:-10", // E1: invalid value for cols
+        "fec,cols:10,rows:0", // E2: invalid value for rows
+        "fec,cols:10,rows:-1", // E3: invalid value for rows
+        "fec,cols:10,layout:stairwars", // E4: invalid value for layout
+        "fec,cols:10,arq:sometimes", // E5: invalid value for arq
+        "fec,cols:10,weight:2" // F: invalid parameter name
+    };
+
+    for (auto badconfig: fec_config_wrong)
+    {
+        ASSERT_EQ(srt_setsockflag(sid1, SRTO_PACKETFILTER, badconfig, (int)strlen(badconfig)), -1);
+    }
+
+    TestMockCUDT m1;
+    m1.core = &s1->core();
+
+    // Can't access the configuration storage without
+    // accessing the private fields, so let's use the official API
+
+    char fec_config1 [] = "fec,cols:20,rows:10";
+
+    EXPECT_NE(srt_setsockflag(sid1, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+
+    cout << "(NOTE: expecting a failure message)\n";
+    EXPECT_FALSE(m1.checkApplyFilterConfig("fec,cols:10,arq:never"));
+
+    srt_close(sid1);
+}
+
+TEST(TestFEC, Connection)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:10,rows:10";
+    const char fec_config2 [] = "fec,cols:10,arq:never";
+    const char fec_config_final [] = "fec,cols:10,rows:10,arq:never,layout:staircase";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+    ASSERT_NE(srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    // Given 2s timeout for accepting as it has occasionally happened with Travis
+    // that 1s might not be enough.
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR);
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    EXPECT_NE(srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size), -1);
+    EXPECT_NE(srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size), -1);
+
+    string caller_config = result_config1;
+    string accept_config = result_config2;
+    EXPECT_EQ(caller_config, accept_config);
+
+    EXPECT_TRUE(filterConfigSame(caller_config, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(accept_config, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, ConnectionReorder)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:10,rows:10";
+    const char fec_config2 [] = "fec,rows:10,cols:10";
+    const char fec_config_final [] = "fec,cols:10,rows:10,arq:onreq,layout:staircase";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+    ASSERT_NE(srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR);
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size);
+    srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size);
+
+    string caller_config = result_config1;
+    string accept_config = result_config2;
+    EXPECT_EQ(caller_config, accept_config);
+
+    EXPECT_TRUE(filterConfigSame(caller_config, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(accept_config, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, ConnectionFull1)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:10,rows:20,arq:never,layout:even";
+    const char fec_config2 [] = "fec,layout:even,rows:20,cols:10,arq:never";
+    const char fec_config_final [] = "fec,cols:10,rows:20,arq:never,layout:even";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+    ASSERT_NE(srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR);
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size);
+    srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size);
+
+    string caller_config = result_config1;
+    string accept_config = result_config2;
+    EXPECT_EQ(caller_config, accept_config);
+
+    EXPECT_TRUE(filterConfigSame(caller_config, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(accept_config, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, ConnectionFull2)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:10,rows:20,arq:always,layout:even";
+    const char fec_config2 [] = "fec,layout:even,rows:20,cols:10,arq:always";
+    const char fec_config_final [] = "fec,cols:10,rows:20,arq:always,layout:even";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+    ASSERT_NE(srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR);
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size);
+    srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size);
+
+    string caller_config = result_config1;
+    string accept_config = result_config2;
+    EXPECT_EQ(caller_config, accept_config);
+
+    EXPECT_TRUE(filterConfigSame(caller_config, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(accept_config, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, ConnectionMess)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:,cols:10";
+    const char fec_config2 [] = "fec,cols:,rows:10";
+    const char fec_config_final [] = "fec,cols:10,rows:10,arq:onreq,layout:staircase";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+    ASSERT_NE(srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR) << srt_getlasterror_str();
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size);
+    srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size);
+
+    string caller_config = result_config1;
+    string accept_config = result_config2;
+    EXPECT_EQ(caller_config, accept_config);
+
+    EXPECT_TRUE(filterConfigSame(caller_config, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(accept_config, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, ConnectionForced)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,rows:20,cols:20";
+    const char fec_config_final [] = "fec,cols:20,rows:20";
+
+    ASSERT_NE(srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1), -1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    SRTSOCKET la[] = { l };
+    SRTSOCKET a = srt_accept_bond(la, 1, 2000);
+    ASSERT_NE(a, SRT_ERROR);
+    EXPECT_EQ(connect_res.get(), SRT_SUCCESS);
+
+    // Now that the connection is established, check negotiated config
+
+    char result_config1[200] = "";
+    int result_config1_size = 200;
+    char result_config2[200] = "";
+    int result_config2_size = 200;
+
+    srt_getsockflag(s, SRTO_PACKETFILTER, result_config1, &result_config1_size);
+    srt_getsockflag(a, SRTO_PACKETFILTER, result_config2, &result_config2_size);
+
+    EXPECT_TRUE(filterConfigSame(result_config1, fec_config_final));
+    EXPECT_TRUE(filterConfigSame(result_config2, fec_config_final));
+
+    srt_close(a);
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, RejectionConflict)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,cols:10,rows:10";
+    const char fec_config2 [] = "fec,cols:20,arq:never";
+
+    srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1);
+    srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    EXPECT_EQ(connect_res.get(), SRT_ERROR);
+    EXPECT_EQ(srt_getrejectreason(s), SRT_REJ_FILTER);
+
+    bool no = false;
+    // Set non-blocking so that srt_accept can return
+    // immediately with failure. Just to make sure that
+    // the connection is not about to be established,
+    // also on the listener side.
+    srt_setsockflag(l, SRTO_RCVSYN, &no, sizeof no);
+    sockaddr_in scl;
+    int sclen = sizeof scl;
+    EXPECT_EQ(srt_accept(l, (sockaddr*)& scl, &sclen), SRT_ERROR);
+
+    srt_close(s);
+    srt_close(l);
+}
+
+TEST(TestFEC, RejectionIncompleteEmpty)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,rows:10";
+    srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    EXPECT_EQ(connect_res.get(), SRT_ERROR);
+    EXPECT_EQ(srt_getrejectreason(s), SRT_REJ_FILTER);
+
+    bool no = false;
+    // Set non-blocking so that srt_accept can return
+    // immediately with failure. Just to make sure that
+    // the connection is not about to be established,
+    // also on the listener side.
+    srt_setsockflag(l, SRTO_RCVSYN, &no, sizeof no);
+    sockaddr_in scl;
+    int sclen = sizeof scl;
+    EXPECT_EQ(srt_accept(l, (sockaddr*)& scl, &sclen), SRT_ERROR);
+
+    srt_close(s);
+    srt_close(l);
+}
+
+
+TEST(TestFEC, RejectionIncomplete)
+{
+    srt::TestInit srtinit;
+
+    SRTSOCKET s = srt_create_socket();
+    SRTSOCKET l = srt_create_socket();
+
+    sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(5555);
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+
+    srt_bind(l, (sockaddr*)& sa, sizeof(sa));
+
+    const char fec_config1 [] = "fec,rows:10";
+    const char fec_config2 [] = "fec,arq:never";
+
+    srt_setsockflag(s, SRTO_PACKETFILTER, fec_config1, (sizeof fec_config1)-1);
+    srt_setsockflag(l, SRTO_PACKETFILTER, fec_config2, (sizeof fec_config2)-1);
+
+    srt_listen(l, 1);
+
+    auto connect_res = std::async(std::launch::async, [&s, &sa]() {
+        return srt_connect(s, (sockaddr*)& sa, sizeof(sa));
+        });
+
+    // Make sure that the async call to srt_connect() is already kicked.
+    std::this_thread::yield();
+
+    EXPECT_EQ(connect_res.get(), SRT_ERROR);
+    EXPECT_EQ(srt_getrejectreason(s), SRT_REJ_FILTER);
+
+    bool no = false;
+    // Set non-blocking so that srt_accept can return
+    // immediately with failure. Just to make sure that
+    // the connection is not about to be established,
+    // also on the listener side.
+    srt_setsockflag(l, SRTO_RCVSYN, &no, sizeof no);
+    sockaddr_in scl;
+    int sclen = sizeof scl;
+    EXPECT_EQ(srt_accept(l, (sockaddr*)& scl, &sclen), SRT_ERROR);
+
+    srt_close(s);
+    srt_close(l);
+}
 
 TEST_F(TestFECRebuilding, Prepare)
 {
@@ -122,7 +797,7 @@ TEST_F(TestFECRebuilding, NoRebuild)
     SrtPacket fec_ctl(SRT_LIVE_MAX_PLSIZE);
 
     // Use the sequence number of the last packet, as usual.
-    bool have_fec_ctl = fec->packControlPacket(fec_ctl, seq);
+    const bool have_fec_ctl = fec->packControlPacket(fec_ctl, seq);
 
     ASSERT_EQ(have_fec_ctl, true);
     // By having all packets and FEC CTL packet, now stuff in
@@ -161,7 +836,7 @@ TEST_F(TestFECRebuilding, NoRebuild)
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    fecpkt->m_iMsgNo = MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    fecpkt->set_msgflags(MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     fecpkt->setMsgCryptoFlags(EncryptionKeySpec(0));
@@ -170,7 +845,7 @@ TEST_F(TestFECRebuilding, NoRebuild)
 
     bool want_passthru_fec = fec->receive(*fecpkt, loss);
     EXPECT_EQ(want_passthru_fec, false); // Confirm that it's been eaten up
-    EXPECT_EQ(provided.size(), 0); // Confirm that nothing was rebuilt
+    EXPECT_EQ(provided.size(), 0U); // Confirm that nothing was rebuilt
 
     /*
     // XXX With such a short sequence, losses will not be reported.
@@ -199,7 +874,7 @@ TEST_F(TestFECRebuilding, Rebuild)
     SrtPacket fec_ctl(SRT_LIVE_MAX_PLSIZE);
 
     // Use the sequence number of the last packet, as usual.
-    bool have_fec_ctl = fec->packControlPacket(fec_ctl, seq);
+    const bool have_fec_ctl = fec->packControlPacket(fec_ctl, seq);
 
     ASSERT_EQ(have_fec_ctl, true);
     // By having all packets and FEC CTL packet, now stuff in
@@ -238,25 +913,25 @@ TEST_F(TestFECRebuilding, Rebuild)
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    fecpkt->m_iMsgNo = MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    fecpkt->set_msgflags(MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     fecpkt->setMsgCryptoFlags(EncryptionKeySpec(0));
 
     // And now receive the FEC control packet
 
-    bool want_passthru_fec = fec->receive(*fecpkt, loss);
+    const bool want_passthru_fec = fec->receive(*fecpkt, loss);
     EXPECT_EQ(want_passthru_fec, false); // Confirm that it's been eaten up
 
-    EXPECT_EQ(loss.size(), 0);
-    ASSERT_EQ(provided.size(), 1);
+    EXPECT_EQ(loss.size(), 0U);
+    ASSERT_EQ(provided.size(), 1U);
 
     SrtPacket& rebuilt = provided[0];
     CPacket& skipped = *source[4];
 
     // Set artificially the SN_REXMIT flag in the skipped source packet
     // because the rebuilt packet shall have REXMIT flag set.
-    skipped.m_iMsgNo |= MSGNO_REXMIT::wrap(true);
+    skipped.set_msgflags(skipped.msgflags() | MSGNO_REXMIT::wrap(true));
 
     // Compare the header
     EXPECT_EQ(skipped.getHeader()[SRT_PH_SEQNO], rebuilt.hdr[SRT_PH_SEQNO]);
diff --git a/test/test_file_transmission.cpp b/test/test_file_transmission.cpp
index 790555eb7..bfd668ac7 100644
--- a/test/test_file_transmission.cpp
+++ b/test/test_file_transmission.cpp
@@ -11,6 +11,7 @@
  */
 
 #include <gtest/gtest.h>
+#include "test_env.h"
 
 #ifdef _WIN32
 #define INC_SRT_WIN_WINTIME // exclude gettimeofday from srt headers
@@ -18,16 +19,20 @@
 
 #include "srt.h"
 
+#include <array>
 #include <thread>
 #include <fstream>
 #include <ctime>
+#include <random>
 #include <vector>
+#include <atomic>
 
 //#pragma comment (lib, "ws2_32.lib")
 
 TEST(Transmission, FileUpload)
 {
-    srt_startup();
+    srt::TestInit srtinit;
+    srtinit.HandlePerTestOptions();
 
     // Generate the source file
     // We need a file that will contain more data
@@ -35,7 +40,7 @@ TEST(Transmission, FileUpload)
 
     SRTSOCKET sock_lsn = srt_create_socket(), sock_clr = srt_create_socket();
 
-    int tt = SRTT_FILE;
+    const int tt = SRTT_FILE;
     srt_setsockflag(sock_lsn, SRTO_TRANSTYPE, &tt, sizeof tt);
     srt_setsockflag(sock_clr, SRTO_TRANSTYPE, &tt, sizeof tt);
 
@@ -45,23 +50,43 @@ TEST(Transmission, FileUpload)
     sa_lsn.sin_addr.s_addr = INADDR_ANY;
     sa_lsn.sin_port = htons(5555);
 
+    // Find unused a port not used by any other service.    
+    // Otherwise srt_connect may actually connect.
+    int bind_res = -1;
+    for (int port = 5000; port <= 5555; ++port)
+    {
+        sa_lsn.sin_port = htons(port);
+        bind_res = srt_bind(sock_lsn, (sockaddr*)&sa_lsn, sizeof sa_lsn);
+        if (bind_res == 0)
+        {
+            std::cout << "Running test on port " << port << "\n";
+            break;
+        }
+
+        ASSERT_TRUE(bind_res == SRT_EINVOP) << "Bind failed not due to an occupied port. Result " << bind_res;
+    }
+
+    ASSERT_GE(bind_res, 0);
+
     srt_bind(sock_lsn, (sockaddr*)&sa_lsn, sizeof sa_lsn);
 
     int optval = 0;
     int optlen = sizeof optval;
     ASSERT_EQ(srt_getsockflag(sock_lsn, SRTO_SNDBUF, &optval, &optlen), 0);
-    size_t filesize = 7 * optval;
+    const size_t filesize = 7 * optval;
 
     {
         std::cout << "WILL CREATE source file with size=" << filesize << " (= 7 * " << optval << "[sndbuf])\n";
         std::ofstream outfile("file.source", std::ios::out | std::ios::binary);
-        ASSERT_EQ(!!outfile, true);
+        ASSERT_EQ(!!outfile, true) << srt_getlasterror_str();
 
-        srand(time(0));
+        std::random_device rd;
+        std::mt19937 mtrd(rd());
+        std::uniform_int_distribution<short> dis(0, UINT8_MAX);
 
         for (size_t i = 0; i < filesize; ++i)
         {
-            char outbyte = rand() % 255;
+            char outbyte = dis(mtrd);
             outfile.write(&outbyte, 1);
         }
     }
@@ -70,7 +95,7 @@ TEST(Transmission, FileUpload)
 
     // Start listener-receiver thread
 
-    bool thread_exit = false;
+    std::atomic<bool> thread_exit { false };
 
     auto client = std::thread([&]
     {
@@ -93,9 +118,15 @@ TEST(Transmission, FileUpload)
         for (;;)
         {
             int n = srt_recv(accepted_sock, buf.data(), 1456);
-            ASSERT_NE(n, SRT_ERROR);
+            EXPECT_NE(n, SRT_ERROR) << srt_getlasterror_str();
             if (n == 0)
             {
+                std::cerr << "Received 0 bytes, breaking.\n";
+                break;
+            }
+            else if (n == -1)
+            {
+                std::cerr << "READ FAILED, breaking anyway\n";
                 break;
             }
 
@@ -110,7 +141,7 @@ TEST(Transmission, FileUpload)
 
     sockaddr_in sa = sockaddr_in();
     sa.sin_family = AF_INET;
-    sa.sin_port = htons(5555);
+    sa.sin_port = sa_lsn.sin_port;
     ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
 
     srt_connect(sock_clr, (sockaddr*)&sa, sizeof(sa));
@@ -126,8 +157,8 @@ TEST(Transmission, FileUpload)
         size_t shift = 0;
         while (n > 0)
         {
-            int st = srt_send(sock_clr, buf.data()+shift, n);
-            ASSERT_GT(st, 0);
+            const int st = srt_send(sock_clr, buf.data()+shift, int(n));
+            ASSERT_GT(st, 0) << srt_getlasterror_str();
 
             n -= st;
             shift += st;
@@ -149,7 +180,7 @@ TEST(Transmission, FileUpload)
     std::cout << "Sockets closed, joining receiver thread\n";
     client.join();
 
-    std::ifstream tarfile("file.target");
+    std::ifstream tarfile("file.target", std::ios::in | std::ios::binary);
     EXPECT_EQ(!!tarfile, true);
 
     tarfile.seekg(0, std::ios::end);
@@ -158,8 +189,14 @@ TEST(Transmission, FileUpload)
 
     std::cout << "Comparing files\n";
     // Compare files
-    tarfile.seekg(0, std::ios::end);
-    ifile.seekg(0, std::ios::beg);
+
+    // Theoretically it should work if you just rewind to 0, but
+    // on Windows this somehow doesn't work. 
+    tarfile.close();
+    tarfile.open("file.target", std::ios::in | std::ios::binary);
+
+    ifile.close();
+    ifile.open("file.source", std::ios::in | std::ios::binary);
 
     for (size_t i = 0; i < tar_size; ++i)
     {
@@ -172,5 +209,4 @@ TEST(Transmission, FileUpload)
     remove("file.source");
     remove("file.target");
 
-    (void)srt_cleanup();
 }
diff --git a/test/test_ipv6.cpp b/test/test_ipv6.cpp
new file mode 100644
index 000000000..ee11292b0
--- /dev/null
+++ b/test/test_ipv6.cpp
@@ -0,0 +1,199 @@
+#include <thread>
+#include <string>
+#include "gtest/gtest.h"
+#include "test_env.h"
+
+#include "srt.h"
+#include "netinet_any.h"
+
+using srt::sockaddr_any;
+
+class TestIPv6
+    : public srt::Test
+{
+protected:
+    int yes = 1;
+    int no = 0;
+
+    TestIPv6()
+    {
+        // initialization code here
+    }
+
+    ~TestIPv6()
+    {
+        // cleanup any pending stuff, but no exceptions allowed
+    }
+
+protected:
+    // SetUp() is run immediately before a test starts.
+    void setup() override
+    {
+        m_caller_sock = srt_create_socket();
+        ASSERT_NE(m_caller_sock, SRT_ERROR);
+        // IPv6 calling IPv4 would otherwise fail if the system-default net.ipv6.bindv6only=1.
+        ASSERT_NE(srt_setsockflag(m_caller_sock, SRTO_IPV6ONLY, &no, sizeof no), SRT_ERROR);
+
+        m_listener_sock = srt_create_socket();
+        ASSERT_NE(m_listener_sock, SRT_ERROR);
+    }
+
+    void teardown() override
+    {
+        // Code here will be called just after the test completes.
+        // OK to throw exceptions from here if needed.
+        srt_close(m_listener_sock);
+        srt_close(m_caller_sock);
+    }
+
+public:
+    void ClientThread(int family, const std::string& address)
+    {
+        sockaddr_any sa (family);
+        sa.hport(m_listen_port);
+        EXPECT_EQ(inet_pton(family, address.c_str(), sa.get_addr()), 1);
+
+        std::cout << "Calling: " << address << "(" << fam[family] << ")\n";
+
+        const int connect_res = srt_connect(m_caller_sock, (sockaddr*)&sa, sizeof sa);
+        EXPECT_NE(connect_res, SRT_ERROR) << "srt_connect() failed with: " << srt_getlasterror_str();
+        if (connect_res == SRT_ERROR)
+            srt_close(m_listener_sock);
+
+        PrintAddresses(m_caller_sock, "CALLER");
+    }
+
+    std::map<int, std::string> fam = { {AF_INET, "IPv4"}, {AF_INET6, "IPv6"} };
+
+    void ShowAddress(std::string src, const sockaddr_any& w)
+    {
+        EXPECT_NE(fam.count(w.family()), 0U) << "INVALID FAMILY";
+        std::cout << src << ": " << w.str() << " (" << fam[w.family()] << ")" << std::endl;
+    }
+
+    sockaddr_any DoAccept()
+    {
+        sockaddr_any sc1;
+
+        SRTSOCKET accepted_sock = srt_accept(m_listener_sock, sc1.get(), &sc1.len);
+        EXPECT_NE(accepted_sock, SRT_INVALID_SOCK) << "accept() failed with: " << srt_getlasterror_str();
+        if (accepted_sock == SRT_INVALID_SOCK) {
+            return sockaddr_any();
+        }
+
+        PrintAddresses(accepted_sock, "ACCEPTED");
+
+        sockaddr_any sn;
+        EXPECT_NE(srt_getsockname(accepted_sock, sn.get(), &sn.len), SRT_ERROR);
+        EXPECT_NE(sn.get_addr(), nullptr);
+
+        if (sn.get_addr() != nullptr)
+        {
+            const int32_t ipv6_zero[] = { 0, 0, 0, 0 };
+            EXPECT_NE(memcmp(ipv6_zero, sn.get_addr(), sizeof ipv6_zero), 0)
+                << "EMPTY address in srt_getsockname";
+        }
+
+        srt_close(accepted_sock);
+        return sn;
+    }
+
+private:
+    void PrintAddresses(SRTSOCKET sock, const char* who)
+    {
+        sockaddr_any sa;
+        int sa_len = (int) sa.storage_size();
+        srt_getsockname(sock, sa.get(), &sa_len);
+        ShowAddress(std::string(who) + " Sock name: ", sa);
+        //std::cout << who << " Sock name: " << << sa.str() << std::endl;
+
+        sa_len = (int) sa.storage_size();
+        srt_getpeername(sock, sa.get(), &sa_len);
+        //std::cout << who << " Peer name: " << << sa.str() << std::endl;
+        ShowAddress(std::string(who) + " Peer name: ", sa);
+    }
+
+protected:
+    SRTSOCKET m_caller_sock;
+    SRTSOCKET m_listener_sock;
+    const int m_listen_port = 4200;
+};
+
+
+TEST_F(TestIPv6, v4_calls_v6_mapped)
+{
+    sockaddr_any sa (AF_INET6);
+    sa.hport(m_listen_port);
+
+    ASSERT_EQ(srt_setsockflag(m_listener_sock, SRTO_IPV6ONLY, &no, sizeof no), 0);
+    ASSERT_NE(srt_bind(m_listener_sock, sa.get(), sa.size()), SRT_ERROR);
+    ASSERT_NE(srt_listen(m_listener_sock, SOMAXCONN), SRT_ERROR);
+
+    std::thread client(&TestIPv6::ClientThread, this, AF_INET, "127.0.0.1");
+
+    const sockaddr_any sa_accepted = DoAccept();
+    EXPECT_EQ(sa_accepted.str(), "::ffff:127.0.0.1:4200");
+
+    client.join();
+}
+
+TEST_F(TestIPv6, v6_calls_v6_mapped)
+{
+    SRTST_REQUIRES(IPv6);
+
+    sockaddr_any sa (AF_INET6);
+    sa.hport(m_listen_port);
+
+    ASSERT_EQ(srt_setsockflag(m_listener_sock, SRTO_IPV6ONLY, &no, sizeof no), 0);
+    ASSERT_NE(srt_bind(m_listener_sock, sa.get(), sa.size()), SRT_ERROR);
+    ASSERT_NE(srt_listen(m_listener_sock, SOMAXCONN), SRT_ERROR);
+
+    std::thread client(&TestIPv6::ClientThread, this, AF_INET6, "::1");
+
+    const sockaddr_any sa_accepted = DoAccept();
+    EXPECT_EQ(sa_accepted.str(), "::1:4200");
+
+    client.join();
+}
+
+TEST_F(TestIPv6, v6_calls_v6)
+{
+    SRTST_REQUIRES(IPv6);
+
+    sockaddr_any sa (AF_INET6);
+    sa.hport(m_listen_port);
+
+    // This time bind the socket exclusively to IPv6.
+    ASSERT_EQ(srt_setsockflag(m_listener_sock, SRTO_IPV6ONLY, &yes, sizeof yes), 0);
+    ASSERT_EQ(inet_pton(AF_INET6, "::1", sa.get_addr()), 1);
+
+    ASSERT_NE(srt_bind(m_listener_sock, sa.get(), sa.size()), SRT_ERROR);
+    ASSERT_NE(srt_listen(m_listener_sock, SOMAXCONN), SRT_ERROR);
+
+    std::thread client(&TestIPv6::ClientThread, this, AF_INET6, "::1");
+
+    const sockaddr_any sa_accepted = DoAccept();
+    EXPECT_EQ(sa_accepted.str(), "::1:4200");
+
+    client.join();
+}
+
+TEST_F(TestIPv6, v6_calls_v4)
+{
+    sockaddr_any sa (AF_INET);
+    sa.hport(m_listen_port);
+
+    // This time bind the socket exclusively to IPv4.
+    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", sa.get_addr()), 1);
+
+    ASSERT_NE(srt_bind(m_listener_sock, sa.get(), sa.size()), SRT_ERROR);
+    ASSERT_NE(srt_listen(m_listener_sock, SOMAXCONN), SRT_ERROR);
+
+    std::thread client(&TestIPv6::ClientThread, this, AF_INET6, "0::FFFF:127.0.0.1");
+
+    const sockaddr_any sa_accepted = DoAccept();
+    EXPECT_EQ(sa_accepted.str(), "127.0.0.1:4200");
+
+    client.join();
+}
+
diff --git a/test/test_listen_callback.cpp b/test/test_listen_callback.cpp
index 680ac6911..33753c213 100644
--- a/test/test_listen_callback.cpp
+++ b/test/test_listen_callback.cpp
@@ -1,116 +1,148 @@
-#include <gtest/gtest.h>
+#include <thread>
 #include <chrono>
 #include <string>
 #include <map>
+#include <gtest/gtest.h>
+#include "test_env.h"
 
 #ifdef _WIN32
 #define INC_SRT_WIN_WINTIME // exclude gettimeofday from srt headers
 #endif
 
 #include "srt.h"
+#include "access_control.h"
 #include "utilities.h"
 
-
 srt_listen_callback_fn SrtTestListenCallback;
 
-/**
- * This test makes a service and a client connecting to it.
- * The service sets up a callback function on the listener.
- * The listener sets up different passwords depending on the user.
- * The test tests:
- *  - correct connection with correct password
- *  - rejected connection with wrong password
- *  - rejected connection on nonexistent user
-*/
-TEST(Core, ListenCallback) {
-
-    using namespace std;
-
-    ASSERT_EQ(srt_startup(), 0);
-
-    // Create server on 127.0.0.1:5555
-
-    const SRTSOCKET server_sock = srt_create_socket();
-    ASSERT_GT(server_sock, 0);    // socket_id should be > 0
-
-    sockaddr_in bind_sa;
-    memset(&bind_sa, 0, sizeof bind_sa);
-    bind_sa.sin_family = AF_INET;
-    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &bind_sa.sin_addr), 1);
-    bind_sa.sin_port = htons(5555);
+class ListenerCallback
+    : public srt::Test
+{
+protected:
+    ListenerCallback()
+    {
+        // initialization code here
+    }
 
-    ASSERT_NE(srt_bind(server_sock, (sockaddr*)&bind_sa, sizeof bind_sa), -1);
-    ASSERT_NE(srt_listen(server_sock, 5), -1);
-    (void)srt_listen_callback(server_sock, &SrtTestListenCallback, NULL);
+    ~ListenerCallback()
+    {
+        // cleanup any pending stuff, but no exceptions allowed
+    }
+public:
 
-    // Create client to connect to the above server
-    SRTSOCKET client_sock;
+    SRTSOCKET server_sock, client_sock;
+    std::thread accept_thread;
     sockaddr_in sa;
-    memset(&sa, 0, sizeof sa);
-    sa.sin_family = AF_INET;
-    sa.sin_port = htons(5555);
-    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
-    sockaddr* psa = (sockaddr*)&sa;
+    sockaddr* psa;
 
+    void setup()
+    {
+        // Create server on 127.0.0.1:5555
 
-    cerr << "TEST 1: Connect to an encrypted socket correctly (should succeed)\n";
+        server_sock = srt_create_socket();
+        ASSERT_GT(server_sock, 0);    // socket_id should be > 0
 
-    client_sock = srt_create_socket();
-    ASSERT_GT(client_sock, 0);    // socket_id should be > 0
+        sockaddr_in bind_sa;
+        memset(&bind_sa, 0, sizeof bind_sa);
+        bind_sa.sin_family = AF_INET;
+        ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &bind_sa.sin_addr), 1);
+        bind_sa.sin_port = htons(5555);
 
-    string username_spec = "#!::u=admin";
-    string password = "thelocalmanager";
+        // NOTE: listener callback must be set BEFORE LISTENING,
+        // otherwise it may potentially change the procedure in the middle of processing
+        // of an incoming connection.
+        ASSERT_NE(srt_listen_callback(server_sock, &SrtTestListenCallback, NULL), -1);
+        ASSERT_NE(srt_bind(server_sock, (sockaddr*)&bind_sa, sizeof bind_sa), -1);
+        ASSERT_NE(srt_listen(server_sock, 5), -1);
 
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), username_spec.size()), -1);
-#if SRT_ENABLE_ENCRYPTION
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), password.size()), -1);
-#endif
+        // Check also changing the listener callback AFTER listening - this is expected to fail.
+        ASSERT_EQ(srt_listen_callback(server_sock, &SrtTestListenCallback, NULL), -1);
 
-    // EXPECTED RESULT: connected successfully
-    EXPECT_NE(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+        accept_thread = std::thread([this] { this->AcceptLoop(); });
 
-    // Close the socket
-    EXPECT_EQ(srt_close(client_sock), SRT_SUCCESS);
+        // Prepare client socket
 
+        client_sock = srt_create_socket();
+        memset(&sa, 0, sizeof sa);
+        sa.sin_family = AF_INET;
+        sa.sin_port = htons(5555);
+        ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
+        psa = (sockaddr*)&sa;
 
-    cerr << "TEST 2: Connect with a wrong password (should reject the handshake)\n";
-#if SRT_ENABLE_ENCRYPTION
-    client_sock = srt_create_socket();
-    ASSERT_GT(client_sock, 0);    // socket_id should be > 0
+        ASSERT_GT(client_sock, 0);    // socket_id should be > 0
 
-    password = "thelokalmanager"; // (typo :D)
+        auto awhile = std::chrono::milliseconds(20);
+        std::this_thread::sleep_for(awhile);
+    }
 
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), username_spec.size()), -1);
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), password.size()), -1);
+    void AcceptLoop()
+    {
+        // Setup EID in order to pick up either readiness or error.
+        // THis is only to make a formal response side, nothing here is to be tested.
 
-    // EXPECTED RESULT: connection rejected
-    EXPECT_EQ(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+        int eid = srt_epoll_create();
 
-    // Close the socket
-    EXPECT_EQ(srt_close(client_sock), SRT_SUCCESS);
-#endif
+        // Subscribe to R | E
 
+        int re = SRT_EPOLL_IN | SRT_EPOLL_ERR;
+        srt_epoll_add_usock(eid, server_sock, &re);
 
-    cerr << "TEST 3: Connect with wrong username (should exit on exception)\n";
-    client_sock = srt_create_socket();
-    ASSERT_GT(client_sock, 0);    // socket_id should be > 0
+        SRT_EPOLL_EVENT results[2];
 
-    username_spec = "#!::u=haivision";
-    password = "thelocalmanager"; // (typo :D)
+        for (;;)
+        {
+            auto state = srt_getsockstate(server_sock);
+            if (int(state) > int(SRTS_CONNECTED))
+            {
+                std::cout << "[T] Listener socket closed, exitting\n";
+                break;
+            }
 
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), username_spec.size()), -1);
-#if SRT_ENABLE_ENCRYPTION
-    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), password.size()), -1);
-#endif
+            std::cout << "[T] Waiting for epoll to accept\n";
+            int res = srt_epoll_uwait(eid, results, 2, 1000);
+            if (res == 1)
+            {
+                if (results[0].events == SRT_EPOLL_IN)
+                {
+                    SRTSOCKET acp = srt_accept(server_sock, NULL, NULL);
+                    if (acp == SRT_INVALID_SOCK)
+                    {
+                        std::cout << "[T] Accept failed, so exitting\n";
+                        break;
+                    }
+                    srt_close(acp);
+                    continue;
+                }
+
+                // Then it can only be SRT_EPOLL_ERR, which
+                // can be done by having the socket closed
+                break;
+            }
 
-    // EXPECTED RESULT: connection rejected
-    EXPECT_EQ(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+            if (res == 0) // probably timeout, just repeat
+            {
+                std::cout << "[T] (NOTE: epoll timeout, still waiting)\n";
+                continue;
+            }
+        }
 
-    // Close the socket
-    EXPECT_EQ(srt_close(client_sock), SRT_SUCCESS);
+        srt_epoll_release(eid);
+    }
 
-    (void)srt_cleanup();
-}
+    void teardown()
+    {
+        std::cout << "TeadDown: closing all sockets\n";
+        // Close the socket
+        EXPECT_EQ(srt_close(client_sock), SRT_SUCCESS);
+        EXPECT_EQ(srt_close(server_sock), SRT_SUCCESS);
+
+        // After that, the thread should exit
+        std::cout << "teardown: joining accept thread\n";
+        accept_thread.join();
+        std::cout << "teardown: SRT exit\n";
+    }
+
+};
 
 int SrtTestListenCallback(void* opaq, SRTSOCKET ns, int hsversion, const struct sockaddr* peeraddr, const char* streamid)
 {
@@ -164,6 +196,7 @@ int SrtTestListenCallback(void* opaq, SRTSOCKET ns, int hsversion, const struct
 
         if (!found)
         {
+            srt_setrejectreason(ns, SRT_REJX_UNAUTHORIZED);
             cerr << "TEST: USER NOT FOUND, returning false.\n";
             return -1;
         }
@@ -183,9 +216,91 @@ int SrtTestListenCallback(void* opaq, SRTSOCKET ns, int hsversion, const struct
 
 #if SRT_ENABLE_ENCRYPTION
     cerr << "TEST: Setting password '" << exp_pw << "' as per user '" << username << "'\n";
-    srt_setsockflag(ns, SRTO_PASSPHRASE, exp_pw.c_str(), exp_pw.size());
+    EXPECT_EQ(srt_setsockflag(ns, SRTO_PASSPHRASE, exp_pw.c_str(), (int)exp_pw.size()), SRT_SUCCESS);
 #endif
+
+    // Checking that SRTO_RCVLATENCY (PRE option) can be altered in the listener callback.
+    int optval = 200;
+    EXPECT_EQ(srt_setsockflag(ns, SRTO_RCVLATENCY, &optval, sizeof optval), SRT_SUCCESS);
     return 0;
 }
 
 
+/**
+ * This test makes a service and a client connecting to it.
+ * The service sets up a callback function on the listener.
+ * The listener sets up different passwords depending on the user.
+ * The test tests:
+ *  - correct connection with correct password (SecureSuccess)
+ *  - rejected connection with wrong password (FauxPass)
+ *  - rejected connection on nonexistent user (FauxUser)
+*/
+
+using namespace std;
+
+
+TEST_F(ListenerCallback, SecureSuccess)
+{
+    string username_spec = "#!::u=admin";
+    string password = "thelocalmanager";
+
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), (int)username_spec.size()), -1);
+#if SRT_ENABLE_ENCRYPTION
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), (int)password.size()), -1);
+#endif
+
+    // EXPECTED RESULT: connected successfully
+    EXPECT_NE(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+
+    EXPECT_EQ(srt_getrejectreason(client_sock), SRT_REJ_UNKNOWN);
+}
+
+#if SRT_ENABLE_ENCRYPTION
+TEST_F(ListenerCallback, FauxPass)
+{
+    string username_spec = "#!::u=admin";
+    string password = "thelokalmanager"; // (typo :D)
+
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), (int)username_spec.size()), -1);
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), (int)password.size()), -1);
+
+    // EXPECTED RESULT: connection rejected
+    EXPECT_EQ(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+
+    EXPECT_EQ(srt_getrejectreason(client_sock), SRT_REJ_BADSECRET);
+}
+#endif
+
+TEST_F(ListenerCallback, FauxUser)
+{
+    string username_spec = "#!::u=haivision";
+    string password = "thelocalmanager"; // (typo :D)
+
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), (int)username_spec.size()), -1);
+#if SRT_ENABLE_ENCRYPTION
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), (int)password.size()), -1);
+#endif
+
+    // EXPECTED RESULT: connection rejected
+    EXPECT_EQ(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+
+    EXPECT_EQ(srt_getrejectreason(client_sock), SRT_REJX_FALLBACK);
+}
+
+TEST_F(ListenerCallback, FauxSyntax)
+{
+    string username_spec = "#!::r=mystream,t=publish"; // No 'u' key specified
+    string password = "thelocalmanager";
+
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_STREAMID, username_spec.c_str(), (int)username_spec.size()), -1);
+#if SRT_ENABLE_ENCRYPTION
+    ASSERT_NE(srt_setsockflag(client_sock, SRTO_PASSPHRASE, password.c_str(), (int)password.size()), -1);
+#endif
+
+    // EXPECTED RESULT: connection rejected
+    EXPECT_EQ(srt_connect(client_sock, psa, sizeof sa), SRT_ERROR);
+
+    EXPECT_EQ(srt_getrejectreason(client_sock), SRT_REJX_UNAUTHORIZED);
+}
+
+
diff --git a/test/test_losslist_rcv.cpp b/test/test_losslist_rcv.cpp
new file mode 100644
index 000000000..94fea6ceb
--- /dev/null
+++ b/test/test_losslist_rcv.cpp
@@ -0,0 +1,139 @@
+#include <iostream>
+#include "gtest/gtest.h"
+#include "test_env.h"
+#include "common.h"
+#include "list.h"
+
+using namespace std;
+using namespace srt;
+
+class CRcvLossListTest
+    : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        m_lossList = new CRcvLossList(CRcvLossListTest::SIZE);
+    }
+
+    void TearDown() override
+    {
+        delete m_lossList;
+    }
+
+    void CheckEmptyArray()
+    {
+        EXPECT_EQ(m_lossList->getLossLength(), 0);
+        EXPECT_EQ(m_lossList->getFirstLostSeq(), SRT_SEQNO_NONE);
+    }
+
+    void CleanUpList()
+    {
+        //while (m_lossList->popLostSeq() != -1);
+    }
+
+    CRcvLossList* m_lossList;
+
+public:
+    const int SIZE = 256;
+};
+
+/// Check the state of the freshly created list.
+/// Capacity, loss length and pop().
+TEST_F(CRcvLossListTest, Create)
+{
+    CheckEmptyArray();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// The first group of tests checks insert and pop()
+///
+///////////////////////////////////////////////////////////////////////////////
+
+/// Insert and remove one element from the list.
+TEST_F(CRcvLossListTest, InsertRemoveOneElem)
+{
+    EXPECT_EQ(m_lossList->insert(1, 1), 1);
+
+    EXPECT_EQ(m_lossList->getLossLength(), 1);
+    EXPECT_TRUE(m_lossList->remove(1, 1));
+    CheckEmptyArray();
+}
+
+
+/// Insert and pop one element from the list.
+TEST_F(CRcvLossListTest, InsertTwoElemsEdge)
+{
+    EXPECT_EQ(m_lossList->insert(CSeqNo::m_iMaxSeqNo, 1), 3);
+    EXPECT_EQ(m_lossList->getLossLength(), 3);
+    EXPECT_TRUE(m_lossList->remove(CSeqNo::m_iMaxSeqNo, 1));
+    CheckEmptyArray();
+}
+
+TEST(CRcvFreshLossListTest, CheckFreshLossList)
+{
+    srt::TestInit srtinit;
+    std::deque<CRcvFreshLoss> floss {
+        CRcvFreshLoss (10, 15, 5),
+        CRcvFreshLoss (25, 29, 10),
+        CRcvFreshLoss (30, 30, 3),
+        CRcvFreshLoss (45, 80, 100)
+    };
+
+    EXPECT_EQ(floss.size(), 4u);
+
+    // Ok, now let's do element removal
+
+    int had_ttl = 0;
+    bool rm = CRcvFreshLoss::removeOne((floss), 26, &had_ttl);
+
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 10);
+    EXPECT_EQ(floss.size(), 5u);
+
+    // Now we expect to have [10-15] [25-25] [27-35]...
+    // After revoking 25 it should have removed it.
+
+    // SPLIT
+    rm = CRcvFreshLoss::removeOne((floss), 27, &had_ttl);
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 10);
+    EXPECT_EQ(floss.size(), 5u);
+
+    // STRIP
+    rm = CRcvFreshLoss::removeOne((floss), 28, &had_ttl);
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 10);
+    EXPECT_EQ(floss.size(), 5u);
+
+    // DELETE
+    rm = CRcvFreshLoss::removeOne((floss), 25, &had_ttl);
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 10);
+    EXPECT_EQ(floss.size(), 4u);
+
+    // SPLIT
+    rm = CRcvFreshLoss::removeOne((floss), 50, &had_ttl);
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 100);
+    EXPECT_EQ(floss.size(), 5u);
+
+    // DELETE
+    rm = CRcvFreshLoss::removeOne((floss), 30, &had_ttl);
+    EXPECT_EQ(rm, true);
+    EXPECT_EQ(had_ttl, 3);
+    EXPECT_EQ(floss.size(), 4u);
+
+    // Remove nonexistent sequence, but existing before.
+    rm = CRcvFreshLoss::removeOne((floss), 25, NULL);
+    EXPECT_EQ(rm, false);
+    EXPECT_EQ(floss.size(), 4u);
+
+    // Remove nonexistent sequence that didn't exist before.
+    rm = CRcvFreshLoss::removeOne((floss), 31, &had_ttl);
+    EXPECT_EQ(rm, false);
+    EXPECT_EQ(had_ttl, 0);
+    EXPECT_EQ(floss.size(), 4u);
+
+}
diff --git a/test/test_list.cpp b/test/test_losslist_snd.cpp
similarity index 90%
rename from test/test_list.cpp
rename to test/test_losslist_snd.cpp
index 72164a5e5..5ff3e7744 100644
--- a/test/test_list.cpp
+++ b/test/test_losslist_snd.cpp
@@ -1,9 +1,10 @@
 #include <iostream>
 #include "gtest/gtest.h"
 #include "common.h"
+#include "list.h"
 
 using namespace std;
-#include "list.h"
+using namespace srt;
 
 class CSndLossListTest
     : public ::testing::Test
@@ -22,12 +23,12 @@ class CSndLossListTest
     void CheckEmptyArray()
     {
         EXPECT_EQ(m_lossList->getLossLength(), 0);
-        EXPECT_EQ(m_lossList->popLostSeq(), -1);
+        EXPECT_EQ(m_lossList->popLostSeq(), SRT_SEQNO_NONE);
     }
 
     void CleanUpList()
     {
-        while (m_lossList->popLostSeq() != -1);
+        while (m_lossList->popLostSeq() != SRT_SEQNO_NONE);
     }
 
     CSndLossList* m_lossList;
@@ -59,6 +60,16 @@ TEST_F(CSndLossListTest, InsertPopOneElem)
     CheckEmptyArray();
 }
 
+TEST_F(CSndLossListTest, InsertNegativeSeqno)
+{
+    cerr << "Expecting IPE message:" << endl;
+    EXPECT_EQ(m_lossList->insert(1, SRT_SEQNO_NONE), 0);
+    EXPECT_EQ(m_lossList->insert(SRT_SEQNO_NONE, SRT_SEQNO_NONE), 0);
+    EXPECT_EQ(m_lossList->insert(SRT_SEQNO_NONE, 1), 0);
+    
+    CheckEmptyArray();
+}
+
 /// Insert two elements at once and pop one by one
 TEST_F(CSndLossListTest, InsertPopTwoElemsRange)
 {
@@ -505,13 +516,14 @@ TEST_F(CSndLossListTest, InsertFullListCoalesce)
         EXPECT_EQ(m_lossList->insert(i, i), 1);
     EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE);
     // Inserting additional element: 1 item more than list size.
-    // But given all elements coalesce into one entry, list size should still increase.
-    EXPECT_EQ(m_lossList->insert(CSndLossListTest::SIZE + 1, CSndLossListTest::SIZE + 1), 1);
-    EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE + 1);
-    for (int i = 1; i <= CSndLossListTest::SIZE + 1; i++)
+    // Given all elements coalesce into one entry, there is a place to insert it,
+    // but sequence span now exceeds list size.
+    EXPECT_EQ(m_lossList->insert(CSndLossListTest::SIZE + 1, CSndLossListTest::SIZE + 1), 0);
+    EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE);
+    for (int i = 1; i <= CSndLossListTest::SIZE; i++)
     {
         EXPECT_EQ(m_lossList->popLostSeq(), i);
-        EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE + 1 - i);
+        EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE - i);
     }
     EXPECT_EQ(m_lossList->popLostSeq(), -1);
     EXPECT_EQ(m_lossList->getLossLength(), 0);
@@ -519,7 +531,7 @@ TEST_F(CSndLossListTest, InsertFullListCoalesce)
     CheckEmptyArray();
 }
 
-TEST_F(CSndLossListTest, DISABLED_InsertFullListNoCoalesce)
+TEST_F(CSndLossListTest, InsertFullListNoCoalesce)
 {
     // We will insert each element with a gap of one elements.
     // This should lead to having space for only [i; SIZE] sequence numbers.
@@ -530,30 +542,29 @@ TEST_F(CSndLossListTest, DISABLED_InsertFullListNoCoalesce)
     // [0]:taken, [1]: empty, [2]: taken, [3]: empty, ...
     EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE / 2);
 
-    // Inserting additional element: 1 item more than list size.
-    // There should be one free place for it at list[SIZE-1]
-    // right after previously inserted element.
+    // Inserting additional element out of the list span must fail.
     const int seqno1 = CSndLossListTest::SIZE + 2;
-    EXPECT_EQ(m_lossList->insert(seqno1, seqno1), 1);
+    EXPECT_EQ(m_lossList->insert(seqno1, seqno1), 0);
 
-    // Inserting one more element into a full list.
-    // There should be no place for it.
-    const int seqno2 = CSndLossListTest::SIZE + 4;
-    EXPECT_EQ(m_lossList->insert(seqno2, seqno2), 0);
+    // There should however be a place for one element right after the last inserted one.
+    const int seqno_last = CSndLossListTest::SIZE + 1;
+    EXPECT_EQ(m_lossList->insert(seqno_last, seqno_last), 1);
 
-    EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE + 1);
-    for (int i = 1; i <= CSndLossListTest::SIZE + 1; i++)
+    const int initial_length = m_lossList->getLossLength();
+    EXPECT_EQ(initial_length, CSndLossListTest::SIZE / 2 + 1);
+    for (int i = 1; i <= CSndLossListTest::SIZE / 2; i++)
     {
         EXPECT_EQ(m_lossList->popLostSeq(), 2 * i);
-        EXPECT_EQ(m_lossList->getLossLength(), CSndLossListTest::SIZE  - i);
+        EXPECT_EQ(m_lossList->getLossLength(), initial_length - i);
     }
+    EXPECT_EQ(m_lossList->popLostSeq(), seqno_last);
     EXPECT_EQ(m_lossList->popLostSeq(), -1);
     EXPECT_EQ(m_lossList->getLossLength(), 0);
 
     CheckEmptyArray();
 }
 
-TEST_F(CSndLossListTest, DISABLED_InsertFullListNegativeOffset)
+TEST_F(CSndLossListTest, InsertFullListNegativeOffset)
 {
     for (int i = 10000000; i < 10000000 + CSndLossListTest::SIZE; i++)
         m_lossList->insert(i, i);
@@ -571,6 +582,23 @@ TEST_F(CSndLossListTest, DISABLED_InsertFullListNegativeOffset)
     CheckEmptyArray();
 }
 
+TEST_F(CSndLossListTest, InsertPositiveOffsetTooFar)
+{
+    const int32_t head_seqno = 1000;
+    EXPECT_EQ(m_lossList->insert(head_seqno, head_seqno), 1);
+    EXPECT_EQ(m_lossList->getLossLength(), 1);
+
+    // The offset of the sequence number being added does not fit
+    // into the size of the loss list, it must be ignored.
+    // Normally this situation should not happen.
+
+    const int32_t outofbound_seqno = head_seqno + CSndLossListTest::SIZE;
+    m_lossList->insert(outofbound_seqno, outofbound_seqno);
+
+    const int32_t outofbound_seqno2 = head_seqno + 2 * CSndLossListTest::SIZE;
+    m_lossList->insert(outofbound_seqno2, outofbound_seqno2);
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
 TEST_F(CSndLossListTest, InsertNoUpdateElement01)
diff --git a/test/test_main.cpp b/test/test_main.cpp
new file mode 100644
index 000000000..e2243a306
--- /dev/null
+++ b/test/test_main.cpp
@@ -0,0 +1,215 @@
+#include <string>
+#include <iterator>
+#include <vector>
+#include <sstream>
+
+#include "gtest/gtest.h"
+#include "test_env.h"
+
+#include "srt.h"
+#include "netinet_any.h"
+
+using namespace std;
+
+int main(int argc, char **argv)
+{
+    string command_line_arg(argc == 2 ? argv[1] : "");
+    testing::InitGoogleTest(&argc, argv);
+    testing::AddGlobalTestEnvironment(new srt::TestEnv(argc, argv));
+    return RUN_ALL_TESTS();
+}
+
+namespace srt
+{
+
+TestEnv* TestEnv::me = 0;
+
+void TestEnv::FillArgMap()
+{
+    // The rule is:
+    // - first arguments go to an empty string key
+    // - if an argument has - in the beginning, name the key
+    // - key followed by args collected in a list
+    // - double dash prevents interpreting further args as option keys
+
+    string key;
+    bool expectkey = true;
+
+    argmap[""];
+
+    for (auto& a: args)
+    {
+        if (a.size() > 1)
+        {
+            if (expectkey && a[0] == '-')
+            {
+                if (a[1] == '-')
+                    expectkey = false;
+                else if (a[1] == '/')
+                    key = "";
+                else
+                {
+                    key = a.substr(1);
+                    argmap[key]; // Make sure it exists even empty
+                }
+
+                continue;
+            }
+        }
+        argmap[key].push_back(a);
+    }
+
+    return;
+}
+
+std::string TestEnv::OptionValue(const std::string& key)
+{
+    std::ostringstream out;
+
+    auto it = argmap.find(key);
+    if (it != argmap.end() && !it->second.empty())
+    {
+        auto iv = it->second.begin();
+        out << (*iv);
+        while (++iv != it->second.end())
+        {
+            out << " " << (*iv);
+        }
+    }
+
+    return out.str();
+}
+
+// Specific functions
+bool TestEnv::Allowed_IPv6()
+{
+    if (TestEnv::me->OptionPresent("disable-ipv6"))
+    {
+        std::cout << "TEST: IPv6 testing disabled, FORCED PASS\n";
+        return false;
+    }
+    return true;
+}
+
+
+void TestInit::start(int& w_retstatus)
+{
+    ASSERT_GE(w_retstatus = srt_startup(), 0);
+}
+
+void TestInit::stop()
+{
+    EXPECT_NE(srt_cleanup(), -1);
+}
+
+// This function finds some interesting options among command
+// line arguments and does specific things.
+void TestInit::HandlePerTestOptions()
+{
+    // As a short example:
+    // use '-logdebug' option to turn on debug logging.
+
+    if (TestEnv::me->OptionPresent("logdebug"))
+    {
+        srt_setloglevel(LOG_DEBUG);
+    }
+
+    if (TestEnv::me->OptionPresent("lognote"))
+    {
+        srt_setloglevel(LOG_NOTICE);
+    }
+}
+
+// Copied from ../apps/apputil.cpp, can't really link this file here.
+sockaddr_any CreateAddr(const std::string& name, unsigned short port, int pref_family)
+{
+    using namespace std;
+
+    // Handle empty name.
+    // If family is specified, empty string resolves to ANY of that family.
+    // If not, it resolves to IPv4 ANY (to specify IPv6 any, use [::]).
+    if (name == "")
+    {
+        sockaddr_any result(pref_family == AF_INET6 ? pref_family : AF_INET);
+        result.hport(port);
+        return result;
+    }
+
+    bool first6 = pref_family != AF_INET;
+    int families[2] = {AF_INET6, AF_INET};
+    if (!first6)
+    {
+        families[0] = AF_INET;
+        families[1] = AF_INET6;
+    }
+
+    for (int i = 0; i < 2; ++i)
+    {
+        int family = families[i];
+        sockaddr_any result (family);
+
+        // Try to resolve the name by pton first
+        if (inet_pton(family, name.c_str(), result.get_addr()) == 1)
+        {
+            result.hport(port); // same addr location in ipv4 and ipv6
+            return result;
+        }
+    }
+
+    // If not, try to resolve by getaddrinfo
+    // This time, use the exact value of pref_family
+
+    sockaddr_any result;
+    addrinfo fo = {
+        0,
+        pref_family,
+        0, 0,
+        0, 0,
+        NULL, NULL
+    };
+
+    addrinfo* val = nullptr;
+    int erc = getaddrinfo(name.c_str(), nullptr, &fo, &val);
+    if (erc == 0)
+    {
+        result.set(val->ai_addr);
+        result.len = result.size();
+        result.hport(port); // same addr location in ipv4 and ipv6
+    }
+    freeaddrinfo(val);
+
+    return result;
+}
+
+UniqueSocket::~UniqueSocket()
+{
+    // Could be closed explicitly
+    if (sock != -1)
+        close();
+}
+
+void UniqueSocket::close()
+{
+    int close_result = srt_close(sock);
+    int close_error = srt_getlasterror(nullptr);
+
+    // XXX SRT_EINVSOCK is reported when the socket
+    // has been already wiped out, which may happen to a broken socket.
+    // This isn't exactly intended, although trying to close a nonexistent
+    // socket is not a problem, as long as it happens before the id value rollover
+    // (that is, when it's closed immediately after getting broken).
+    // This solution is still slick though and should be fixed.
+    //
+    // Restore this, when fixed
+    // EXPECT_NE(srt_close(sock), SRT_ERROR) << lab << " CREATED: "<< f << ":" << l;
+    if (close_result == SRT_ERROR)
+    {
+        EXPECT_NE(close_error, SRT_EINVSOCK) << lab << " CREATED: "<< f << ":" << l;
+    }
+    else
+    {
+        EXPECT_EQ(close_result, 0) << lab << " CREATED: "<< f << ":" << l;
+    }
+}
+
+}
diff --git a/test/test_many_connections.cpp b/test/test_many_connections.cpp
index cca42ecf0..29cd6bdd2 100644
--- a/test/test_many_connections.cpp
+++ b/test/test_many_connections.cpp
@@ -1,8 +1,11 @@
 #define _CRT_RAND_S // For Windows, rand_s 
 
-#include <gtest/gtest.h>
+#include <array>
 #include <chrono>
 #include <future>
+#include <random>
+#include <gtest/gtest.h>
+#include "test_env.h"
 
 #ifdef _WIN32
 #include <stdlib.h>
@@ -20,10 +23,11 @@ typedef int SOCKET;
 #include "api.h"
 
 using namespace std;
+using srt::sockaddr_any;
 
 
 class TestConnection
-    : public ::testing::Test
+    : public ::srt::Test
 {
 protected:
     TestConnection()
@@ -42,58 +46,47 @@ class TestConnection
     static const size_t NSOCK = 60;
 
 protected:
-    // SetUp() is run immediately before a test starts.
-    void SetUp() override
+    void setup() override
     {
-        ASSERT_EQ(srt_startup(), 0);
-
         m_sa.sin_family = AF_INET;
         m_sa.sin_addr.s_addr = INADDR_ANY;
-        m_udp_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-        ASSERT_NE(m_udp_sock, -1);
 
-        // Find unused a port not used by any other service.
-        // Otherwise srt_connect may actually connect.
-        int bind_res = -1;
+        m_server_sock = srt_create_socket();
+        ASSERT_NE(m_server_sock, SRT_INVALID_SOCK);
+
+        // Find a port not used by another service.
+        int bind_res = 0;
         const sockaddr* psa = reinterpret_cast<const sockaddr*>(&m_sa);
-        for (int port = 5000; port <= 5555; ++port)
+        for (int port = 5000; port <= 5100; ++port)
         {
             m_sa.sin_port = htons(port);
-            bind_res = ::bind(m_udp_sock, psa, sizeof m_sa);
-            if (bind_res >= 0)
+
+            bind_res = srt_bind(m_server_sock, psa, sizeof m_sa);
+            if (bind_res == 0)
             {
                 cerr << "Running test on port " << port << "\n";
                 break;
             }
         }
 
-        // Close the socket to free the port.
-        ASSERT_NE(closesocket(m_udp_sock), -1);
-        ASSERT_GE(bind_res, 0);
+        ASSERT_GE(bind_res, 0) << "srt_bind returned " << bind_res << ": " << srt_getlasterror_str();
         ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &m_sa.sin_addr), 1);
 
         // Fill the buffer with random data
-        time_t now;
-        time(&now);
-        unsigned int randseed = now % 255;
-        srand(randseed);
-        for (int i = 0; i < SRT_LIVE_DEF_PLSIZE; ++i)
-            buf[i] = rand_r(&randseed) % 255;
-
-        m_server_sock = srt_create_socket();
+        std::random_device rnd_device;
+        std::mt19937 gen(rnd_device());
+        std::uniform_int_distribution<short> dis(-128, 127);
+        std::generate(m_buf.begin(), m_buf.end(), [dis, gen]() mutable { return (char)dis(gen); });
 
-        ASSERT_NE(srt_bind(m_server_sock, psa, sizeof m_sa), -1);
         ASSERT_NE(srt_listen(m_server_sock, NSOCK), -1);
     }
 
-    void TearDown() override
+    void teardown() override
     {
-        srt_cleanup();
     }
 
     void AcceptLoop()
     {
-        //cerr << "[T] Accepting connections\n";
         for (;;)
         {
             sockaddr_any addr;
@@ -102,18 +95,16 @@ class TestConnection
             if (acp == -1)
             {
                 cerr << "[T] Accept error at " << m_accepted.size()
-                    << "/" << NSOCK << ": " << srt_getlasterror_str() << endl;
+                     << "/" << NSOCK << ": " << srt_getlasterror_str() << endl;
                 break;
             }
-            //cerr << "[T] Got new acp @" << acp << endl;
             m_accepted.push_back(acp);
         }
 
-        m_accept_exit = true;
-
         cerr << "[T] Closing those accepted ones\n";
+        m_accept_exit = true;
 
-        for (auto s: m_accepted)
+        for (const auto s : m_accepted)
         {
             srt_close(s);
         }
@@ -122,69 +113,80 @@ class TestConnection
     }
 
 protected:
-    SOCKET m_udp_sock = INVALID_SOCKET;
     sockaddr_in m_sa = sockaddr_in();
     SRTSOCKET m_server_sock = SRT_INVALID_SOCK;
     vector<SRTSOCKET> m_accepted;
-    char buf[SRT_LIVE_DEF_PLSIZE];
-    SRTSOCKET srt_socket_list[NSOCK];
+    std::array<char, SRT_LIVE_DEF_PLSIZE> m_buf;
+    SRTSOCKET m_connections[NSOCK];
     volatile bool m_accept_exit = false;
 };
 
 
-
+// This test establishes multiple connections to a single SRT listener on a localhost port.
+// Packets are submitted for sending to all those connections in a non-blocking mode.
+// Then all connections are closed. Some sockets may potentially still have undelivered packets.
+// This test tries to reproduce the issue described in #1182, and fixed by #1315.
 TEST_F(TestConnection, Multiple)
 {
-    size_t size = SRT_LIVE_DEF_PLSIZE;
-
-    sockaddr_in lsa = m_sa;
-
+    const sockaddr_in lsa = m_sa;
     const sockaddr* psa = reinterpret_cast<const sockaddr*>(&lsa);
 
-    auto ex = std::async([this] { return AcceptLoop(); });
+    auto ex = std::async(std::launch::async, [this] { return AcceptLoop(); });
+
+    cerr << "Opening " << NSOCK << " connections\n";
 
-    cout << "Opening " << NSOCK << " connections\n";
+    bool overall_test = true;
 
     for (size_t i = 0; i < NSOCK; i++)
     {
-        srt_socket_list[i] = srt_create_socket();
+        m_connections[i] = srt_create_socket();
+        EXPECT_NE(m_connections[i], SRT_INVALID_SOCK);
 
         // Give it 60s timeout, many platforms fail to process
         // so many connections in a short time.
         int conntimeo = 60;
-        srt_setsockflag(srt_socket_list[i], SRTO_CONNTIMEO, &conntimeo, sizeof conntimeo);
+        srt_setsockflag(m_connections[i], SRTO_CONNTIMEO, &conntimeo, sizeof conntimeo);
+
+        SRTSOCKET connres = SRT_INVALID_SOCK;
 
         //cerr << "Connecting #" << i << " to " << sockaddr_any(psa).str() << "...\n";
         //cerr << "Connecting to: " << sockaddr_any(psa).str() << endl;
-        ASSERT_NE(srt_connect(srt_socket_list[i], psa, sizeof lsa), SRT_ERROR);
+        connres = srt_connect(m_connections[i], psa, sizeof lsa);
+        EXPECT_NE(connres, SRT_INVALID_SOCK) << "conn #" << i << ": " << srt_getlasterror_str();
+        if (connres == SRT_INVALID_SOCK)
+            overall_test = false;
 
         // Set now async sending so that sending isn't blocked
         int no = 0;
-        ASSERT_NE(srt_setsockflag(srt_socket_list[i], SRTO_SNDSYN, &no, sizeof no), -1);
+        EXPECT_NE(srt_setsockflag(m_connections[i], SRTO_SNDSYN, &no, sizeof no), -1);
     }
 
     for (size_t j = 1; j <= 100; j++)
     {
         for (size_t i = 0; i < NSOCK; i++)
         {
-            EXPECT_GT(srt_send(srt_socket_list[i], buf, size), 0);
+            EXPECT_GT(srt_send(m_connections[i], m_buf.data(), (int) m_buf.size()), 0);
         }
     }
-    cout << "Sending finished, closing caller sockets\n";
+    cerr << "Sending finished, closing caller sockets\n";
 
     for (size_t i = 0; i < NSOCK; i++)
     {
-        EXPECT_EQ(srt_close(srt_socket_list[i]), SRT_SUCCESS);
+        EXPECT_EQ(srt_close(m_connections[i]), SRT_SUCCESS);
     }
-    // Up to this moment the server sock should survive
-    cout << "Closing server socket\n";
 
-    EXPECT_EQ(m_accept_exit, false);
+    EXPECT_FALSE(m_accept_exit) << "AcceptLoop already broken for some reason!";
+    // Up to this moment the server sock should survive
 
+    cerr << "Closing server socket\n";
     // Close server socket to break the accept loop
     EXPECT_EQ(srt_close(m_server_sock), 0);
 
+    cerr << "Synchronize with the accepting thread\n";
     ex.wait();
+    cerr << "Synchronization done\n";
+
+    ASSERT_TRUE(overall_test);
 }
 
 
diff --git a/test/test_muxer.cpp b/test/test_muxer.cpp
index f7efc8517..e85a12118 100644
--- a/test/test_muxer.cpp
+++ b/test/test_muxer.cpp
@@ -1,9 +1,11 @@
 #include "gtest/gtest.h"
+#include "test_env.h"
+
 #include <thread>
 #include "srt.h"
 
 class TestMuxer
-    : public ::testing::Test
+    : public srt::Test
 {
 protected:
     TestMuxer()
@@ -18,10 +20,8 @@ class TestMuxer
 
 protected:
     // SetUp() is run immediately before a test starts.
-    void SetUp()
+    void setup() override
     {
-        ASSERT_GE(srt_startup(), 0);
-        
         m_caller_sock = srt_create_socket();
         ASSERT_NE(m_caller_sock, SRT_ERROR);
 
@@ -41,7 +41,7 @@ class TestMuxer
         srt_epoll_add_usock(m_client_pollid, m_caller_sock, &epoll_out);
     }
 
-    void TearDown()
+    void teardown() override
     {
         // Code here will be called just after the test completes.
         // OK to throw exceptions from here if needed.
@@ -49,7 +49,6 @@ class TestMuxer
         srt_epoll_release(m_server_pollid);
         srt_close(m_listener_sock_ipv4);
         srt_close(m_listener_sock_ipv6);
-        srt_cleanup();
     }
 
 public:
@@ -100,6 +99,8 @@ class TestMuxer
 
 TEST_F(TestMuxer, IPv4_and_IPv6)
 {
+    SRTST_REQUIRES(IPv6);
+
     int yes = 1;
     int no = 0;
 
diff --git a/test/test_reuseaddr.cpp b/test/test_reuseaddr.cpp
new file mode 100644
index 000000000..df4aec487
--- /dev/null
+++ b/test/test_reuseaddr.cpp
@@ -0,0 +1,681 @@
+#include <thread>
+#include <future>
+#include <sstream>
+#ifndef _WIN32
+#include <ifaddrs.h>
+#endif
+#include "gtest/gtest.h"
+#include "test_env.h"
+
+#include "common.h"
+#include "srt.h"
+#include "udt.h"
+
+using srt::sockaddr_any;
+
+template<typename Future>
+struct AtReturnJoin
+{
+    Future& which_future;
+
+    ~AtReturnJoin()
+    {
+        if (which_future.valid())
+            which_future.wait();
+    }
+};
+
+#ifdef _WIN32
+
+// On Windows there's a function for it, but it requires an extra
+// iphlp library to be attached to the executable, which is kinda
+// problematic. Temporarily block tests using this function on Windows.
+
+static std::string GetLocalIP(int af = AF_UNSPEC)
+{
+    std::cout << "!!!WARNING!!!: GetLocalIP not supported, test FORCEFULLY passed\n";
+    return "";
+}
+#else
+struct IfAddr
+{
+    ifaddrs* handle;
+    IfAddr()
+    {
+        getifaddrs(&handle);
+    }
+
+    ~IfAddr()
+    {
+        freeifaddrs(handle);
+    }
+};
+
+static std::string GetLocalIP(int af = AF_UNSPEC)
+{
+    struct ifaddrs * ifa=NULL;
+    void * tmpAddrPtr=NULL;
+
+    IfAddr ifAddr;
+
+    for (ifa = ifAddr.handle; ifa != NULL; ifa = ifa->ifa_next)
+    {
+        if (!ifa->ifa_addr)
+        {
+            continue;
+        }
+
+        if (ifa->ifa_addr->sa_family == AF_INET)
+        {
+            // Ignore IPv4 address if not wanted.
+            if (af == AF_INET6)
+                continue;
+
+            // is a valid IP4 Address
+            sockaddr_in* psin = (struct sockaddr_in *)ifa->ifa_addr;
+            tmpAddrPtr=&psin->sin_addr;
+
+            if (ntohl(psin->sin_addr.s_addr) == 0x7f000001) // Skip 127.0.0.1
+                continue;
+
+            char addressBuffer[INET_ADDRSTRLEN] = "";
+            inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
+            return addressBuffer;
+            printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer); 
+        }
+        else if (ifa->ifa_addr->sa_family == AF_INET6)
+        { // check it is IP6
+
+            // Ignore IPv6 address if not wanted.
+            if (af == AF_INET)
+                continue;
+
+            // is a valid IP6 Address
+            tmpAddrPtr=&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
+            char addressBuffer[INET6_ADDRSTRLEN] = "";
+            inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
+            return addressBuffer;
+        }
+    }
+
+    return "";
+}
+#endif
+
+class ReuseAddr : public srt::Test
+{
+protected:
+
+    std::string showEpollContents(const char* label, int* array, int length)
+    {
+        std::ostringstream out;
+        out << label << ":[";
+        if (length)
+        {
+            // Now is at least 1
+            out << "@" << array[0];
+
+            for (int i = 1; i < length; ++i)
+                out << " @" << array[i];
+        }
+        out << "]";
+        return out.str();
+    }
+
+    struct UniquePollid
+    {
+        int pollid = SRT_ERROR;
+        UniquePollid()
+        {
+            pollid = srt_epoll_create();
+        }
+
+        ~UniquePollid()
+        {
+            srt_epoll_release(pollid);
+        }
+
+        operator int() const
+        {
+            return pollid;
+        }
+    };
+
+    void clientSocket(SRTSOCKET client_sock, std::string ip, int port, bool expect_success)
+    {
+        using namespace std;
+
+        int yes = 1;
+        int no = 0;
+
+        int family = AF_INET;
+        string famname = "IPv4";
+        if (ip.substr(0, 2) == "6.")
+        {
+            family = AF_INET6;
+            ip = ip.substr(2);
+            famname = "IPv6";
+        }
+
+        cout << "[T/C] Setting up client socket\n";
+        ASSERT_NE(client_sock, SRT_INVALID_SOCK);
+        ASSERT_EQ(srt_getsockstate(client_sock), SRTS_INIT);
+
+        EXPECT_NE(srt_setsockflag(client_sock, SRTO_SNDSYN, &no, sizeof no), SRT_ERROR); // for async connect
+        EXPECT_NE(srt_setsockflag(client_sock, SRTO_SENDER, &yes, sizeof yes), SRT_ERROR);
+        EXPECT_NE(srt_setsockflag(client_sock, SRTO_TSBPDMODE, &yes, sizeof yes), SRT_ERROR);
+
+        UniquePollid client_pollid;
+        ASSERT_NE(int(client_pollid), SRT_ERROR);
+
+        int epoll_out = SRT_EPOLL_OUT;
+        srt_epoll_add_usock(client_pollid, client_sock, &epoll_out);
+
+        sockaddr_any sa = srt::CreateAddr(ip, port, family);
+
+        cout << "[T/C] Connecting to: " << sa.str() << " (" << famname << ")" << endl;
+
+        int connect_res = srt_connect(client_sock, sa.get(), sa.size());
+
+        if (connect_res == -1)
+        {
+            cout << "srt_connect: " << srt_getlasterror_str() << endl;
+        }
+
+        if (expect_success)
+        {
+            EXPECT_NE(connect_res, -1);
+            if (connect_res == -1)
+                return;
+
+            // Socket readiness for connection is checked by polling on WRITE allowed sockets.
+
+            if (connect_res != -1)
+            {
+                int rlen = 2;
+                SRTSOCKET read[2];
+
+                int wlen = 2;
+                SRTSOCKET write[2];
+
+                cout << "[T/C] Waiting for connection readiness...\n";
+
+                EXPECT_NE(srt_epoll_wait(client_pollid, read, &rlen,
+                            write, &wlen,
+                            -1, // -1 is set for debuging purpose.
+                            // in case of production we need to set appropriate value
+                            0, 0, 0, 0), SRT_ERROR) << srt_getlasterror_str();
+
+                EXPECT_EQ(rlen, 0) << showEpollContents("[T/C] R", read, rlen); // get exactly one write event without reads
+                EXPECT_EQ(wlen, 1) << showEpollContents("[T/C] W", write, wlen); // get exactly one write event without reads
+                EXPECT_EQ(write[0], client_sock); // for our client socket
+
+                char buffer[1316] = {1, 2, 3, 4};
+                EXPECT_NE(srt_sendmsg(client_sock, buffer, sizeof buffer,
+                            -1, // infinit ttl
+                            true // in order must be set to true
+                            ),
+                        SRT_ERROR);
+            }
+            else
+            {
+                cout << "[T/C] (NOT TESTING TRANSMISSION - CONNECTION FAILED ALREADY)\n";
+            }
+        }
+        else
+        {
+            EXPECT_EQ(connect_res, -1);
+        }
+
+        cout << "[T/C] Client exit\n";
+    }
+
+    SRTSOCKET prepareServerSocket()
+    {
+        SRTSOCKET bindsock = srt_create_socket();
+        EXPECT_NE(bindsock, SRT_ERROR);
+
+        int yes = 1;
+        int no = 0;
+
+        EXPECT_NE(srt_setsockopt(bindsock, 0, SRTO_RCVSYN, &no, sizeof no), SRT_ERROR); // for async connect
+        EXPECT_NE(srt_setsockopt(bindsock, 0, SRTO_TSBPDMODE, &yes, sizeof yes), SRT_ERROR);
+
+        return bindsock;
+    }
+
+    bool bindSocket(SRTSOCKET bindsock, std::string ip, int port, bool expect_success)
+    {
+        sockaddr_any sa = srt::CreateAddr(ip, port, AF_INET);
+
+        std::string fam = (sa.family() == AF_INET) ? "IPv4" : "IPv6";
+
+        std::cout << "[T/S] Bind @" << bindsock << " to: " << sa.str() << " (" << fam << ")" << std::endl;
+
+        int bind_res = srt_bind(bindsock, sa.get(), sa.size());
+
+        std::cout << "[T/S] ... result " << bind_res << " (expected to "
+            << (expect_success ? "succeed" : "fail") << ")\n";
+
+        if (!expect_success)
+        {
+            std::cout << "[T/S] Binding should fail: " << srt_getlasterror_str() << std::endl;
+            EXPECT_EQ(bind_res, SRT_ERROR);
+            return false;
+        }
+
+        EXPECT_NE(bind_res, SRT_ERROR);
+        return true;
+    }
+
+    bool bindListener(SRTSOCKET bindsock, std::string ip, int port, bool expect_success)
+    {
+        if (!bindSocket(bindsock, ip, port, expect_success))
+            return false;
+
+        EXPECT_NE(srt_listen(bindsock, SOMAXCONN), SRT_ERROR);
+
+        return true;
+    }
+
+    SRTSOCKET createListener(std::string ip, int port, bool expect_success)
+    {
+        std::cout << "[T/S] serverSocket: creating listener socket\n";
+
+        SRTSOCKET bindsock = prepareServerSocket();
+
+        if (!bindListener(bindsock, ip, port, expect_success))
+            return SRT_INVALID_SOCK;
+
+        return bindsock;
+    }
+
+    SRTSOCKET createBinder(std::string ip, int port, bool expect_success)
+    {
+        std::cout << "[T/S] serverSocket: creating binder socket\n";
+
+        SRTSOCKET bindsock = prepareServerSocket();
+
+        if (!bindSocket(bindsock, ip, port, expect_success))
+        {
+            srt_close(bindsock);
+            return SRT_INVALID_SOCK;
+        }
+
+        return bindsock;
+    }
+
+    void testAccept(SRTSOCKET bindsock, std::string ip, int port, bool expect_success)
+    {
+        MAKE_UNIQUE_SOCK(client_sock, "[T/S]connect", srt_create_socket());
+
+        auto run = [this, &client_sock, ip, port, expect_success]() { clientSocket(client_sock, ip, port, expect_success); };
+
+        auto launched = std::async(std::launch::async, run);
+
+        AtReturnJoin<decltype(launched)> atreturn_join {launched};
+
+        int server_pollid = srt_epoll_create();
+        int epoll_in = SRT_EPOLL_IN;
+        std::cout << "[T/S] Listener/binder sock @" << bindsock << " added to server_pollid\n";
+        srt_epoll_add_usock(server_pollid, bindsock, &epoll_in);
+
+        { // wait for connection from client
+            int rlen = 2;
+            SRTSOCKET read[2];
+
+            int wlen = 2;
+            SRTSOCKET write[2];
+
+            std::cout << "[T/S] Wait 10s on E" << server_pollid << " for acceptance on @" << bindsock << " ...\n";
+
+            EXPECT_NE(srt_epoll_wait(server_pollid,
+                        read,  &rlen,
+                        write, &wlen,
+                        10000, // -1 is set for debuging purpose.
+                        // in case of production we need to set appropriate value
+                        0, 0, 0, 0), SRT_ERROR) << srt_getlasterror_str();
+
+
+            EXPECT_EQ(rlen, 1) << showEpollContents("[T/S] R", read, rlen);  // get exactly one read event without writes
+            EXPECT_EQ(wlen, 0) << showEpollContents("[T/S] W", write, wlen);  // get exactly one read event without writes
+            ASSERT_EQ(read[0], bindsock); // read event is for bind socket
+        }
+
+        {
+            sockaddr_any scl;
+            MAKE_UNIQUE_SOCK(accepted_sock, "[T/S]accept", srt_accept(bindsock, scl.get(), &scl.len));
+
+            if (accepted_sock == -1)
+            {
+                std::cout << "srt_accept: " << srt_getlasterror_str() << std::endl;
+            }
+            EXPECT_NE(accepted_sock.ref(), SRT_INVALID_SOCK);
+
+            sockaddr_any showacp = (sockaddr*)&scl;
+            std::cout << "[T/S] Accepted from: " << showacp.str() << std::endl;
+
+            epoll_in = SRT_EPOLL_IN;
+            srt_epoll_add_usock(server_pollid, accepted_sock, &epoll_in); // wait for input
+
+            char buffer[1316];
+            { // wait for 1316 packet from client
+                int rlen = 2;
+                SRTSOCKET read[2];
+
+                int wlen = 2;
+                SRTSOCKET write[2];
+
+                std::cout << "[T/S] Wait for data reception...\n";
+
+                EXPECT_NE(srt_epoll_wait(server_pollid,
+                            read,  &rlen,
+                            write, &wlen,
+                            -1, // -1 is set for debuging purpose.
+                            // in case of production we need to set appropriate value
+                            0, 0, 0, 0), SRT_ERROR) << srt_getlasterror_str();
+
+
+                EXPECT_EQ(rlen, 1) << showEpollContents("[T/S] R", read, rlen);   // get exactly one read event without writes
+                EXPECT_EQ(wlen, 0) << showEpollContents("[T/S] W", write, wlen);  // get exactly one read event without writes
+                EXPECT_EQ(read[0], accepted_sock.ref()); // read event is for bind socket        
+            }
+
+            char pattern[4] = {1, 2, 3, 4};
+
+            EXPECT_EQ(srt_recvmsg(accepted_sock, buffer, sizeof buffer),
+                    1316);
+
+            EXPECT_EQ(memcmp(pattern, buffer, sizeof pattern), 0);
+
+            // XXX There is a possibility that a broken socket can be closed automatically,
+            // just the srt_close() call would simply return error in case of nonexistent
+            // socket. Therefore close them both at once; this problem needs to be fixed
+            // separately.
+            //
+            // The test only intends to send one portion of data from the client, so once
+            // received, the client has nothing more to do and should exit.
+            std::cout << "[T/S] closing client socket\n";
+            client_sock.close();
+            std::cout << "[T/S] closing sockets: ACP:@" << accepted_sock << "...\n";
+        }
+        srt_epoll_release(server_pollid);
+
+        // client_sock closed through UniqueSocket.
+        // cannot close client_sock after srt_sendmsg because of issue in api.c:2346 
+
+        std::cout << "[T/S] joining client async \n";
+        launched.get();
+    }
+
+    static void shutdownListener(SRTSOCKET bindsock)
+    {
+        // Silently ignore. Usually it should have been checked earlier,
+        // and an invalid sock might be expected in particular tests.
+        if (bindsock == SRT_INVALID_SOCK)
+            return;
+
+        int yes = 1;
+        EXPECT_NE(srt_setsockopt(bindsock, 0, SRTO_RCVSYN, &yes, sizeof yes), SRT_ERROR); // for async connect
+        EXPECT_NE(srt_close(bindsock), SRT_ERROR);
+
+        std::chrono::milliseconds check_period (100);
+        int credit = 400; // 10 seconds
+        auto then = std::chrono::steady_clock::now();
+
+        std::cout << "[T/S] waiting for cleanup of @" << bindsock << " up to 10s" << std::endl;
+        while (srt_getsockstate(bindsock) != SRTS_NONEXIST)
+        {
+            std::this_thread::sleep_for(check_period);
+            --credit;
+            if (!credit)
+                break;
+        }
+        auto now = std::chrono::steady_clock::now();
+        auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(now - then);
+
+        // Keep as single string because this tends to be mixed from 2 threads.
+        std::ostringstream sout;
+        sout << "[T/S] @" << bindsock << " dissolved after "
+            << (dur.count() / 1000.0) << "s" << std::endl;
+        std::cout << sout.str() << std::flush;
+
+        EXPECT_NE(credit, 0);
+    }
+
+private:
+
+    void setup()
+    {
+    }
+
+    void teardown()
+    {
+    }
+};
+
+TEST_F(ReuseAddr, SameAddr1)
+{
+
+    SRTSOCKET bindsock_1 = createBinder("127.0.0.1", 5000, true);
+    SRTSOCKET bindsock_2 = createListener("127.0.0.1", 5000, true);
+
+    testAccept(bindsock_2, "127.0.0.1", 5000, true);
+
+    std::thread s1(shutdownListener, bindsock_1);
+    std::thread s2(shutdownListener, bindsock_2);
+
+    s1.join();
+    s2.join();
+
+}
+
+TEST_F(ReuseAddr, SameAddr2)
+{
+    std::string localip = GetLocalIP(AF_INET);
+    if (localip == "")
+        return; // DISABLE TEST if this doesn't work.
+
+    SRTSOCKET bindsock_1 = createBinder(localip, 5000, true);
+    SRTSOCKET bindsock_2 = createListener(localip, 5000, true);
+
+    testAccept(bindsock_2, localip, 5000, true);
+
+    shutdownListener(bindsock_1);
+
+    // Test simple close and reuse the multiplexer
+    ASSERT_NE(srt_close(bindsock_2), SRT_ERROR);
+
+    SRTSOCKET bindsock_3 = createListener(localip, 5000, true);
+    testAccept(bindsock_3, localip, 5000, true);
+
+    shutdownListener(bindsock_3);
+}
+
+TEST_F(ReuseAddr, SameAddrV6)
+{
+    SRTST_REQUIRES(IPv6);
+
+    SRTSOCKET bindsock_1 = createBinder("::1", 5000, true);
+    SRTSOCKET bindsock_2 = createListener("::1", 5000, true);
+
+    testAccept(bindsock_2, "::1", 5000, true);
+
+    shutdownListener(bindsock_1);
+
+    // Test simple close and reuse the multiplexer
+    ASSERT_NE(srt_close(bindsock_2), SRT_ERROR);
+
+    SRTSOCKET bindsock_3 = createListener("::1", 5000, true);
+    testAccept(bindsock_3, "::1", 5000, true);
+
+    shutdownListener(bindsock_3);
+}
+
+
+TEST_F(ReuseAddr, DiffAddr)
+{
+    std::string localip = GetLocalIP(AF_INET);
+    if (localip == "")
+        return; // DISABLE TEST if this doesn't work.
+
+    SRTSOCKET bindsock_1 = createBinder("127.0.0.1", 5000, true);
+    SRTSOCKET bindsock_2 = createListener(localip, 5000, true);
+
+    //std::thread server_1(testAccept, bindsock_1, "127.0.0.1", 5000, true);
+    //server_1.join();
+
+    testAccept(bindsock_2, localip, 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+}
+
+TEST_F(ReuseAddr, Wildcard)
+{
+#if defined(_WIN32) || defined(CYGWIN)
+    std::cout << "!!!WARNING!!!: On Windows connection to localhost this way isn't possible.\n"
+        "Forcing test to pass, PLEASE FIX.\n";
+    return;
+#endif
+
+    // This time exceptionally require IPv4 because we'll be
+    // checking it against 0.0.0.0 
+    std::string localip = GetLocalIP(AF_INET);
+    if (localip == "")
+        return; // DISABLE TEST if this doesn't work.
+    SRTSOCKET bindsock_1 = createListener("0.0.0.0", 5000, true);
+
+    // Binding a certain address when wildcard is already bound should fail.
+    SRTSOCKET bindsock_2 = createBinder(localip, 5000, false);
+
+    testAccept(bindsock_1, "127.0.0.1", 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+}
+
+TEST_F(ReuseAddr, Wildcard6)
+{
+    SRTST_REQUIRES(IPv6);
+#if defined(_WIN32) || defined(CYGWIN)
+    std::cout << "!!!WARNING!!!: On Windows connection to localhost this way isn't possible.\n"
+        "Forcing test to pass, PLEASE FIX.\n";
+    return;
+#endif
+
+    // This time exceptionally require IPv6 because we'll be
+    // checking it against ::
+    std::string localip = GetLocalIP(AF_INET6);
+    if (localip == "")
+        return; // DISABLE TEST if this doesn't work.
+
+    // This "should work", but there can also be platforms
+    // that do not have IPv4, in which case this test can't be
+    // performed there.
+    std::string localip_v4 = GetLocalIP(AF_INET);
+
+    // This must be obligatory set before binding a socket to "::"
+    int strict_ipv6 = 1;
+
+    SRTSOCKET bindsock_1 = prepareServerSocket();
+    srt_setsockflag(bindsock_1, SRTO_IPV6ONLY, &strict_ipv6, sizeof strict_ipv6);
+    bindListener(bindsock_1, "::", 5000, true);
+
+    // Binding a certain address when wildcard is already bound should fail.
+    SRTSOCKET bindsock_2 = createBinder(localip, 5000, false);
+
+    SRTSOCKET bindsock_3 = SRT_INVALID_SOCK;
+    if (localip_v4 != "")
+    {
+        // V6ONLY = 1, which means that binding to IPv4 should be possible.
+        bindsock_3 = createBinder(localip_v4, 5000, true);
+    }
+
+    testAccept(bindsock_1, "::1", 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+    shutdownListener(bindsock_3);
+
+    // Now the same thing, except that we bind to both IPv4 and IPv6.
+
+    strict_ipv6 = 0;
+
+    bindsock_1 = prepareServerSocket();
+    srt_setsockflag(bindsock_1, SRTO_IPV6ONLY, &strict_ipv6, sizeof strict_ipv6);
+    bindListener(bindsock_1, "::", 5000, true);
+
+    // Binding a certain address when wildcard is already bound should fail.
+    bindsock_2 = createBinder(localip, 5000, false);
+    bindsock_3 = SRT_INVALID_SOCK;
+
+    if (localip_v4 != "")
+    {
+        // V6ONLY = 0, which means that binding to IPv4 should not be possible.
+        bindsock_3 = createBinder(localip_v4, 5000, false);
+    }
+
+    testAccept(bindsock_1, "::1", 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+    shutdownListener(bindsock_3);
+}
+
+TEST_F(ReuseAddr, ProtocolVersion6)
+{
+    SRTST_REQUIRES(IPv6);
+
+#if defined(_WIN32) || defined(CYGWIN)
+    std::cout << "!!!WARNING!!!: On Windows connection to localhost this way isn't possible.\n"
+        "Forcing test to pass, PLEASE FIX.\n";
+    return;
+#endif
+
+    SRTSOCKET bindsock_1 = createListener("0.0.0.0", 5000, true);
+
+    // We need a small interception in this one.
+    // createListener = prepareServerSocket | bindListener
+    SRTSOCKET bindsock_2 = prepareServerSocket();
+    {
+        int yes = 1;
+
+        ASSERT_NE(srt_setsockflag(bindsock_2, SRTO_IPV6ONLY, &yes, sizeof yes), SRT_ERROR);
+        ASSERT_TRUE(bindListener(bindsock_2, "::", 5000, true));
+    }
+
+    testAccept(bindsock_1, "127.0.0.1", 5000, true);
+    testAccept(bindsock_2, "::1", 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+}
+
+TEST_F(ReuseAddr, ProtocolVersionFaux6)
+{
+    SRTST_REQUIRES(IPv6);
+
+#if defined(_WIN32) || defined(CYGWIN)
+    std::cout << "!!!WARNING!!!: On Windows connection to localhost this way isn't possible.\n"
+        "Forcing test to pass, PLEASE FIX.\n";
+    return;
+#endif
+
+    SRTSOCKET bindsock_1 = createListener("0.0.0.0", 5000, true);
+
+    // We need a small interception in this one.
+    // createListener = prepareServerSocket | bindListener
+    SRTSOCKET bindsock_2 = prepareServerSocket();
+    {
+        int no = 0;
+
+        ASSERT_NE(srt_setsockflag(bindsock_2, SRTO_IPV6ONLY, &no, sizeof no), SRT_ERROR);
+        ASSERT_FALSE(bindListener(bindsock_2, "::", 5000, false));
+    }
+
+    testAccept(bindsock_1, "127.0.0.1", 5000, true);
+
+    shutdownListener(bindsock_1);
+    shutdownListener(bindsock_2);
+}
diff --git a/test/test_seqno.cpp b/test/test_seqno.cpp
index df2ecca53..f2e374f76 100644
--- a/test/test_seqno.cpp
+++ b/test/test_seqno.cpp
@@ -2,6 +2,8 @@
 #include "common.h"
 #include "core.h"
 
+using namespace srt;
+
 
 const int32_t CSeqNo::m_iSeqNoTH;
 const int32_t CSeqNo::m_iMaxSeqNo;
@@ -14,7 +16,6 @@ TEST(CSeqNo, constants)
     EXPECT_EQ(CSeqNo::m_iSeqNoTH,  0x3FFFFFFF);
 }
 
-
 TEST(CSeqNo, seqcmp)
 {
     // Compare two seq#, considering the wraping.
@@ -25,11 +26,10 @@ TEST(CSeqNo, seqcmp)
     EXPECT_EQ(CSeqNo::seqcmp(1, 128), -127);
 
     // abs(seq1 - seq2) >= 0x3FFFFFFF : seq2 - seq1
-    EXPECT_EQ(CSeqNo::seqcmp(0x7FFFFFFF, 1), 0x80000002);   // -2147483646
+    EXPECT_EQ(CSeqNo::seqcmp(0x7FFFFFFF, 1), int(0x80000002));   // -2147483646
     EXPECT_EQ(CSeqNo::seqcmp(1, 0x7FFFFFFF), 0x7FFFFFFE);   //  2147483646
 }
 
-
 TEST(CSeqNo, seqoff)
 {
     // seqoff: offset from the 2nd to the 1st seq#
@@ -46,6 +46,9 @@ TEST(CSeqNo, seqlen)
 {
     EXPECT_EQ(CSeqNo::seqlen(125, 125), 1);
     EXPECT_EQ(CSeqNo::seqlen(125, 126), 2);
+
+    EXPECT_EQ(CSeqNo::seqlen(2147483647, 0), 2);
+    EXPECT_EQ(CSeqNo::seqlen(0, 2147483647), -2147483648);
 }
 
 TEST(CUDT, getFlightSpan)
@@ -72,7 +75,6 @@ TEST(CSeqNo, incseq)
     EXPECT_EQ(CSeqNo::incseq(0x3FFFFFFF), 0x40000000);
 }
 
-
 TEST(CSeqNo, decseq)
 {
     // decseq: decrease the seq# by 1
@@ -82,7 +84,6 @@ TEST(CSeqNo, decseq)
     EXPECT_EQ(CSeqNo::decseq(0x40000000), 0x3FFFFFFF);
 }
 
-
 TEST(CSeqNo, incseqint)
 {
     // incseq: increase the seq# by 1
@@ -96,7 +97,6 @@ TEST(CSeqNo, incseqint)
     EXPECT_EQ(CSeqNo::incseq(0x3FFFFFFF, 0x40000001), 0x00000000);
 }
 
-
 TEST(CSeqNo, decseqint)
 {
     // decseq: decrease the seq# by 1
@@ -105,4 +105,3 @@ TEST(CSeqNo, decseqint)
     EXPECT_EQ(CSeqNo::decseq(0, 1),          0x7FFFFFFF);
     EXPECT_EQ(CSeqNo::decseq(0x40000000, 1), 0x3FFFFFFF);
 }
-
diff --git a/test/test_snd_rate_estimator.cpp b/test/test_snd_rate_estimator.cpp
new file mode 100644
index 000000000..c658c659c
--- /dev/null
+++ b/test/test_snd_rate_estimator.cpp
@@ -0,0 +1,117 @@
+#include <array>
+#include <numeric>
+#include "gtest/gtest.h"
+#include "buffer_tools.h"
+#include "sync.h"
+#include "packet.h"
+
+using namespace srt;
+using namespace std;
+
+#ifdef ENABLE_MAXREXMITBW
+
+class CSndRateEstFixture
+    : public ::testing::Test
+{
+protected:
+    CSndRateEstFixture()
+        : m_tsStart(sync::steady_clock::now())
+        , m_rateEst(m_tsStart)
+    {
+        // initialization code here
+    }
+
+    virtual ~CSndRateEstFixture()
+    {
+        // cleanup any pending stuff, but no exceptions allowed
+    }
+
+protected:
+    // SetUp() is run immediately before a test starts.
+    void SetUp() override
+    {
+        // make_unique is unfortunatelly C++14
+
+    }
+
+    void TearDown() override
+    {
+        // Code here will be called just after the test completes.
+        // OK to throw exceptions from here if needed.
+    }
+
+    const sync::steady_clock::time_point m_tsStart;
+    CSndRateEstimator m_rateEst;
+};
+
+// Check the available size of the receiver buffer.
+TEST_F(CSndRateEstFixture, Empty)
+{
+    //EXPECT_EQ(getAvailBufferSize(), m_buff_size_pkts - 1);
+    EXPECT_EQ(m_rateEst.getRate(), 0);
+}
+
+
+TEST_F(CSndRateEstFixture, CBRSending)
+{
+    const size_t hdrBytes = srt::CPacket::HDR_SIZE;
+    // Generate CBR sending for 2.1 seconds to wrap the buffer around.
+    for (int i = 0; i < 2100; ++i)
+    {
+        const auto t = m_tsStart + sync::milliseconds_from(i);
+        m_rateEst.addSample(t, 1, 1316);
+        
+        const auto rate = m_rateEst.getRate();
+        if (i >= 100)
+            EXPECT_EQ(rate, 1316000 + 1000 * hdrBytes) << "i=" << i;
+        else
+            EXPECT_EQ(rate, 0) << "i=" << i;
+    }
+
+}
+
+// Make a 1 second long pause and check that the rate is 0 again
+// only for one sampling period.
+TEST_F(CSndRateEstFixture, CBRSendingAfterPause)
+{
+    const size_t hdrBytes = srt::CPacket::HDR_SIZE;
+    // Send 100 packets with 1000 bytes each
+    for (int i = 0; i < 3100; ++i)
+    {
+        if (i >= 1000 && i < 2000)
+            continue;
+        const auto t = m_tsStart + sync::milliseconds_from(i);
+        m_rateEst.addSample(t, 1, 1316);
+
+        const auto rate = m_rateEst.getRate();
+        if (i >= 100 && !(i >= 2000 && i < 2100))
+            EXPECT_EQ(rate, 1316000 + 1000 * hdrBytes) << "i=" << i;
+        else
+            EXPECT_EQ(rate, 0) << "i=" << i;
+    }
+}
+
+// Make a short 0.5 second pause and check the bitrate goes down, but not to 0.
+// Those empty samples should be included in bitrate estimation.
+TEST_F(CSndRateEstFixture, CBRSendingShortPause)
+{
+    const size_t hdrBytes = srt::CPacket::HDR_SIZE;
+    // Send 100 packets with 1000 bytes each
+    for (int i = 0; i < 3100; ++i)
+    {
+        if (i >= 1000 && i < 1500)
+            continue;
+        const auto t = m_tsStart + sync::milliseconds_from(i);
+        m_rateEst.addSample(t, 1, 1316);
+
+        const auto rate = m_rateEst.getRate();
+        if (i >= 1500 && i < 2000)
+            EXPECT_EQ(rate, 658000 + 500 * hdrBytes) << "i=" << i;
+        else if (i >= 100)
+            EXPECT_EQ(rate, 1316000 + 1000 * hdrBytes) << "i=" << i;
+        else
+            EXPECT_EQ(rate, 0) << "i=" << i;
+    }
+}
+
+#endif // ENABLE_MAXREXMITBW
diff --git a/test/test_socket_options.cpp b/test/test_socket_options.cpp
index 705db5a09..a4c90af37 100644
--- a/test/test_socket_options.cpp
+++ b/test/test_socket_options.cpp
@@ -10,17 +10,23 @@
  *             Haivision Systems Inc.
  */
 
-#include <gtest/gtest.h>
 #include <future>
 #include <thread>
+#include <string>
+#include <gtest/gtest.h>
+#include "test_env.h"
 
+// SRT includes
+#include "any.hpp"
+#include "socketconfig.h"
 #include "srt.h"
 
 using namespace std;
+using namespace srt;
 
 
 class TestSocketOptions
-    : public ::testing::Test
+    : public ::srt::Test
 {
 protected:
     TestSocketOptions()
@@ -33,13 +39,60 @@ class TestSocketOptions
         // cleanup any pending stuff, but no exceptions allowed
     }
 
+public:
+    void BindListener()
+    {
+        // Specify address of the listener
+        sockaddr* psa = (sockaddr*)&m_sa;
+        ASSERT_NE(srt_bind(m_listen_sock, psa, sizeof m_sa), SRT_ERROR);
+    }
+
+    void StartListener()
+    {
+        BindListener();
+
+        srt_listen(m_listen_sock, 1);
+    }
+
+    int Connect()
+    {
+        sockaddr* psa = (sockaddr*)&m_sa;
+        return srt_connect(m_caller_sock, psa, sizeof m_sa);
+    }
+
+    SRTSOCKET EstablishConnection()
+    {
+        auto accept_async = [](SRTSOCKET listen_sock) {
+            sockaddr_in client_address;
+            int length = sizeof(sockaddr_in);
+            const SRTSOCKET accepted_socket = srt_accept(listen_sock, (sockaddr*)&client_address, &length);
+            return accepted_socket;
+        };
+        auto accept_res = async(launch::async, accept_async, m_listen_sock);
+
+        // Make sure the thread was kicked
+        this_thread::yield();
+
+        const int connect_res = Connect();
+        EXPECT_EQ(connect_res, SRT_SUCCESS);
+
+        const SRTSOCKET accepted_sock = accept_res.get();
+        EXPECT_NE(accepted_sock, SRT_INVALID_SOCK);
+
+        return accepted_sock;
+    }
+
 protected:
-    // SetUp() is run immediately before a test starts.
-    void SetUp()
+    // setup() is run immediately before a test starts.
+    void setup()
     {
-        ASSERT_GE(srt_startup(), 0);
         const int yes = 1;
 
+        memset(&m_sa, 0, sizeof m_sa);
+        m_sa.sin_family = AF_INET;
+        m_sa.sin_port = htons(5200);
+        ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &m_sa.sin_addr), 1);
+
         m_caller_sock = srt_create_socket();
         ASSERT_NE(m_caller_sock, SRT_INVALID_SOCK);
         ASSERT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_RCVSYN, &yes, sizeof yes), SRT_SUCCESS); // for async connect
@@ -51,18 +104,16 @@ class TestSocketOptions
         ASSERT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_SNDSYN, &yes, sizeof yes), SRT_SUCCESS); // for async connect
     }
 
-    void TearDown()
+    void teardown()
     {
         // Code here will be called just after the test completes.
         // OK to throw exceptions from here if needed.
-        ASSERT_NE(srt_close(m_caller_sock), SRT_ERROR);
-        ASSERT_NE(srt_close(m_listen_sock), SRT_ERROR);
-        srt_cleanup();
+        EXPECT_NE(srt_close(m_caller_sock), SRT_ERROR);
+        EXPECT_NE(srt_close(m_listen_sock), SRT_ERROR);
     }
 
 protected:
-    // put in any custom data members that you need
-
+    sockaddr_in m_sa;
     SRTSOCKET m_caller_sock = SRT_INVALID_SOCK;
     SRTSOCKET m_listen_sock = SRT_INVALID_SOCK;
 
@@ -70,6 +121,591 @@ class TestSocketOptions
 };
 
 
+enum class RestrictionType
+{
+    PREBIND = 0,
+    PRE     = 1,
+    POST    = 2
+};
+
+const char* RestrictionTypeStr(RestrictionType val)
+{
+    switch (val)
+    {
+    case RestrictionType::PREBIND:
+        return "PREBIND";
+        break;
+    case RestrictionType::PRE:
+        return "PRE";
+        break;
+    case RestrictionType::POST:
+        return "POST";
+        break;
+    default:
+        break;
+    }
+    return "INVALID";
+}
+
+struct OptionTestEntry
+{
+    SRT_SOCKOPT optid;
+    const char* optname;            // TODO: move to a separate array, function or std::map.
+    RestrictionType restriction;    // TODO: consider using SRTO_R_PREBIND, etc. from core.cpp 
+    size_t  opt_len;
+    linb::any min_val;
+    linb::any max_val;
+    linb::any dflt_val;
+    linb::any ndflt_val; 
+    vector<linb::any> invalid_vals;
+};
+
+static const size_t UDP_HDR_SIZE = 28;   // 20 bytes IPv4 + 8 bytes of UDP { u16 sport, dport, len, csum }.
+static const size_t DFT_MTU_SIZE = 1500; // Default MTU size
+static const size_t SRT_PKT_SIZE = DFT_MTU_SIZE - UDP_HDR_SIZE; // MTU without UDP header
+
+const OptionTestEntry g_test_matrix_options[] =
+{
+    // Option ID,                Option Name |          Restriction |         optlen |             min |       max |  default | nondefault |  invalid vals |
+    //SRTO_BINDTODEVICE
+    //{ SRTO_CONGESTION,      "SRTO_CONGESTION",  RestrictionType::PRE,               4,           "live",     "file",   "live",       "file",   {"liv", ""} },
+    { SRTO_CONNTIMEO,        "SRTO_CONNTIMEO",  RestrictionType::PRE,     sizeof(int),                0,  INT32_MAX,     3000,          250,   {-1} },
+    { SRTO_DRIFTTRACER,    "SRTO_DRIFTTRACER",  RestrictionType::POST,   sizeof(bool),            false,       true,     true,        false,     {} },
+    { SRTO_ENFORCEDENCRYPTION, "SRTO_ENFORCEDENCRYPTION", RestrictionType::PRE, sizeof(bool),     false,       true,     true,        false,     {} },
+    //SRTO_EVENT
+    { SRTO_FC,                      "SRTO_FC",  RestrictionType::PRE,     sizeof(int),               32,  INT32_MAX,    25600,        10000,   {-1, 31} },
+    //SRTO_GROUPCONNECT
+#if ENABLE_BONDING
+    // Max value can't exceed SRTO_PEERIDLETIMEO
+    { SRTO_GROUPMINSTABLETIMEO, "SRTO_GROUPMINSTABLETIMEO", RestrictionType::PRE, sizeof(int),       60,       5000,       60,           70,     {0, -1, 50, 5001} },
+#endif
+    //SRTO_GROUPTYPE
+    //SRTO_INPUTBW
+    //SRTO_IPTOS
+    //SRTO_IPTTL
+    //SRTO_IPV6ONLY
+    //SRTO_ISN
+    { SRTO_KMPREANNOUNCE, "SRTO_KMPREANNOUNCE", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX,        0,         1024,   {-1} },
+    { SRTO_KMREFRESHRATE, "SRTO_KMREFRESHRATE", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX,        0,         1024,   {-1} },
+    //SRTO_KMSTATE
+    { SRTO_LATENCY,             "SRTO_LATENCY", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX,      120,          200,  {-1} },
+    //SRTO_LINGER
+    { SRTO_LOSSMAXTTL,       "SRTO_LOSSMAXTTL", RestrictionType::POST,    sizeof(int),                 0, INT32_MAX,        0,           10,   {} },
+    { SRTO_MAXBW,                 "SRTO_MAXBW", RestrictionType::POST, sizeof(int64_t),      int64_t(-1),  INT64_MAX, int64_t(-1), int64_t(200000),  {int64_t(-2)}},
+#ifdef ENABLE_MAXREXMITBW
+    { SRTO_MAXREXMITBW,      "SRTO_MAXREXMITBW", RestrictionType::POST, sizeof(int64_t),     int64_t(-1), INT64_MAX,  int64_t(-1), int64_t(200000),  {int64_t(-2)}},
+#endif
+    { SRTO_MESSAGEAPI,       "SRTO_MESSAGEAPI", RestrictionType::PRE,    sizeof(bool),             false,      true,     true,        false,     {} },
+    { SRTO_MININPUTBW,       "SRTO_MININPUTBW", RestrictionType::POST, sizeof(int64_t),       int64_t(0),  INT64_MAX,  int64_t(0), int64_t(200000),  {int64_t(-1)}},
+    { SRTO_MINVERSION,       "SRTO_MINVERSION", RestrictionType::PRE,     sizeof(int),                 0,  INT32_MAX, 0x010000,    0x010300,    {} },
+    { SRTO_MSS,                     "SRTO_MSS", RestrictionType::PREBIND, sizeof(int),                76,     65536,     1500,        1400,    {-1, 0, 75} },
+    { SRTO_NAKREPORT,         "SRTO_NAKREPORT", RestrictionType::PRE,    sizeof(bool),             false,      true,     true,        false,     {} },
+    { SRTO_OHEADBW,             "SRTO_OHEADBW", RestrictionType::POST,    sizeof(int),                 5,        100,       25,          20, {-1, 0, 4, 101} },
+    //SRTO_PACKETFILTER
+    //SRTO_PASSPHRASE
+    { SRTO_PAYLOADSIZE,     "SRTO_PAYLOADSIZE", RestrictionType::PRE,     sizeof(int),                 0,      1456,      1316,        1400,   {-1, 1500} },
+    //SRTO_PBKEYLEN
+    //SRTO_PEERIDLETIMEO
+    { SRTO_PEERIDLETIMEO, "SRTO_PEERIDLETIMEO", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX,      5000,        4500,    {-1} },
+    { SRTO_PEERLATENCY,     "SRTO_PEERLATENCY", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX,         0,        180,    {-1} },
+    //SRTO_PEERVERSION
+    { SRTO_RCVBUF,              "SRTO_RCVBUF",  RestrictionType::PREBIND, sizeof(int), (int)(32 * SRT_PKT_SIZE), 2147483256, (int)(8192 * SRT_PKT_SIZE), 1000000, {-1} },
+    //SRTO_RCVDATA
+    //SRTO_RCVKMSTATE
+    { SRTO_RCVLATENCY,       "SRTO_RCVLATENCY", RestrictionType::PRE,     sizeof(int),                 0, INT32_MAX, 120, 1100, {-1} },
+    //SRTO_RCVSYN
+    { SRTO_RCVTIMEO,           "SRTO_RCVTIMEO", RestrictionType::POST,    sizeof(int),                -1, INT32_MAX,  -1, 2000, {-2} },
+    //SRTO_RENDEZVOUS
+    { SRTO_RETRANSMITALGO, "SRTO_RETRANSMITALGO", RestrictionType::PRE,   sizeof(int),                 0,         1,   1,    0, {-1, 2} },
+    //SRTO_REUSEADDR
+    //SRTO_SENDER
+    { SRTO_SNDBUF,              "SRTO_SNDBUF",  RestrictionType::PREBIND, sizeof(int), (int)(32 * SRT_PKT_SIZE), 2147483256, (int)(8192 * SRT_PKT_SIZE), 1000000, {-1} },
+    //SRTO_SNDDATA
+    { SRTO_SNDDROPDELAY,  "SRTO_SNDDROPDELAY", RestrictionType::POST,     sizeof(int),                -1, INT32_MAX, 0, 1500, {-2} },
+    //SRTO_SNDKMSTATE
+    //SRTO_SNDSYN
+    { SRTO_SNDTIMEO,          "SRTO_SNDTIMEO", RestrictionType::POST,     sizeof(int),                -1, INT32_MAX, -1, 1400, {-2} },
+    //SRTO_STATE
+    //SRTO_STREAMID
+    { SRTO_TLPKTDROP,        "SRTO_TLPKTDROP",  RestrictionType::PRE,    sizeof(bool),             false,      true,     true, false, {} },
+    //SRTO_TRANSTYPE
+    //SRTO_TSBPDMODE
+    //SRTO_UDP_RCVBUF
+    //SRTO_UDP_SNDBUF
+    //SRTO_VERSION
+};
+
+
+template<class ValueType>
+void CheckGetSockOpt(const OptionTestEntry& entry, SRTSOCKET sock, const ValueType& value, const char* desc)
+{
+    ValueType opt_val;
+    int opt_len = (int) entry.opt_len;
+    EXPECT_EQ(srt_getsockopt(sock, 0, entry.optid, &opt_val, &opt_len), SRT_SUCCESS)
+        << "Getting " << entry.optname << " returned error: " << srt_getlasterror_str();
+
+    EXPECT_EQ(opt_val, value) << desc << ": Wrong " << entry.optname << " value " << opt_val;
+    EXPECT_EQ(opt_len, (int) entry.opt_len) << desc << "Wrong " << entry.optname << " value length";
+}
+
+typedef char const* strptr;
+template<>
+void CheckGetSockOpt<strptr>(const OptionTestEntry& entry, SRTSOCKET sock, const strptr& value, const char* desc)
+{
+    char opt_val[16];
+    int opt_len = 0;
+    EXPECT_EQ(srt_getsockopt(sock, 0, entry.optid, &opt_val, &opt_len), SRT_SUCCESS)
+        << "Getting " << entry.optname << " returned error: " << srt_getlasterror_str();
+
+    EXPECT_EQ(strncmp(opt_val, value, min(opt_len, (int)entry.opt_len)), 0) << desc << ": Wrong " << entry.optname << " value " << opt_val;
+    EXPECT_EQ(opt_len, (int) entry.opt_len) << desc << "Wrong " << entry.optname << " value length";
+}
+
+template<class ValueType>
+void CheckSetSockOpt(const OptionTestEntry& entry, SRTSOCKET sock, const ValueType& value, int expect_return, const char* desc)
+{
+    ValueType opt_val = value;
+    int opt_len = (int)entry.opt_len;
+    EXPECT_EQ(srt_setsockopt(sock, 0, entry.optid, &opt_val, opt_len), expect_return)
+        << "Setting " << entry.optname << " to " << opt_val << " must " << (expect_return == SRT_SUCCESS ? "succeed" : "fail");
+
+    if (expect_return == SRT_SUCCESS)
+    {
+        CheckGetSockOpt<ValueType>(entry, sock, value, desc);
+    }
+    // TODO: else check the previous value is in force
+}
+
+template<class ValueType>
+bool CheckDefaultValue(const OptionTestEntry& entry, SRTSOCKET sock, const char* desc)
+{
+    try {
+        const ValueType dflt_val = linb::any_cast<ValueType>(entry.dflt_val);
+        CheckGetSockOpt<ValueType>(entry, sock, dflt_val, desc);
+    }
+    catch (const linb::bad_any_cast&)
+    {
+        std::cerr << entry.optname << " default value type: " << entry.dflt_val.type().name() << "\n";
+        return false;
+    }
+
+    return true;
+}
+
+template<class ValueType>
+bool CheckSetNonDefaultValue(const OptionTestEntry& entry, SRTSOCKET sock, int expected_return, const char* desc)
+{
+    try {
+        /*const ValueType dflt_val = linb::any_cast<ValueType>(entry.dflt_val);
+        const ValueType min_val  = linb::any_cast<ValueType>(entry.min_val);
+        const ValueType max_val  = linb::any_cast<ValueType>(entry.max_val);*/
+        //const ValueType ndflt_val = (min_val != dflt_val) ? min_val : max_val;
+
+        const ValueType ndflt_val = linb::any_cast<ValueType>(entry.ndflt_val);;
+
+        CheckSetSockOpt<ValueType>(entry, sock, ndflt_val, expected_return, desc);
+    }
+    catch (const linb::bad_any_cast&)
+    {
+        std::cerr << entry.optname << " non-default value type: " << entry.ndflt_val.type().name() << "\n";
+        return false;
+    }
+
+    return true;
+}
+
+template<class ValueType>
+bool CheckMinValue(const OptionTestEntry& entry, SRTSOCKET sock, const char* desc)
+{
+    try {
+        const ValueType min_val = linb::any_cast<ValueType>(entry.min_val);
+        CheckSetSockOpt<ValueType>(entry, sock, min_val, SRT_SUCCESS, desc);
+
+        const ValueType dflt_val = linb::any_cast<ValueType>(entry.dflt_val);
+        CheckSetSockOpt<ValueType>(entry, sock, dflt_val, SRT_SUCCESS, desc);
+    }
+    catch (const linb::bad_any_cast&)
+    {
+        std::cerr << entry.optname << " min value type: " << entry.min_val.type().name() << "\n";
+        return false;
+    }
+
+    return true;
+}
+
+template<class ValueType>
+bool CheckMaxValue(const OptionTestEntry& entry, SRTSOCKET sock, const char* desc)
+{
+    try {
+        const ValueType max_val = linb::any_cast<ValueType>(entry.max_val);
+        CheckSetSockOpt<ValueType>(entry, sock, max_val, SRT_SUCCESS, desc);
+    }
+    catch (const linb::bad_any_cast&)
+    {
+        std::cerr << entry.optname << " max value type: " << entry.max_val.type().name() << "\n";
+        return false;
+    }
+
+    return true;
+}
+
+template<class ValueType>
+bool CheckInvalidValues(const OptionTestEntry& entry, SRTSOCKET sock, const char* sock_name)
+{
+    for (const auto& inval : entry.invalid_vals)
+    {
+        try {
+            const ValueType val = linb::any_cast<ValueType>(inval);
+            CheckSetSockOpt<ValueType>(entry, sock, val, SRT_ERROR, sock_name);
+        }
+        catch (const linb::bad_any_cast&)
+        {
+            std::cerr << entry.optname << " value type: " << inval.type().name() << "\n";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+TEST_F(TestSocketOptions, DefaultVals)
+{
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const char* test_desc = "[Caller, default]";
+        if (entry.dflt_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckDefaultValue<bool>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.dflt_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckDefaultValue<int>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.dflt_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckDefaultValue<int64_t>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.dflt_val.type() == typeid(const char*))
+        {
+            EXPECT_TRUE(CheckDefaultValue<const char*>(entry, m_caller_sock, test_desc));
+        }
+        else
+        {
+            FAIL() << entry.optname << ": Unexpected type " << entry.dflt_val.type().name();
+        }
+    }
+}
+
+TEST_F(TestSocketOptions, MaxVals)
+{
+    // Note: Changing SRTO_FC changes SRTO_RCVBUF limitation
+    for (const auto& entry : g_test_matrix_options)
+    {
+        if (entry.optid == SRTO_KMPREANNOUNCE || entry.optid == SRTO_KMREFRESHRATE)
+        {
+            cerr << "Skipping " << entry.optname << "\n";
+            continue;
+        }
+
+        const char* test_desc = "[Caller, max value]";
+        if (entry.max_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckMaxValue<bool>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.max_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckMaxValue<int>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.max_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckMaxValue<int64_t>(entry, m_caller_sock, test_desc));
+        }
+        else
+        {
+            FAIL() << "Unexpected type " << entry.max_val.type().name();
+        }
+
+        // TODO: back to default ?
+    }
+}
+
+TEST_F(TestSocketOptions, MinVals)
+{
+    // Note: Changing SRTO_FC changes SRTO_RCVBUF limitation
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const char* test_desc = "[Caller, min val]";
+        if (entry.min_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckMinValue<bool>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.min_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckMinValue<int>(entry, m_caller_sock, test_desc));
+        }
+        else if (entry.min_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckMinValue<int64_t>(entry, m_caller_sock, test_desc));
+        }
+        else
+        {
+            FAIL() << entry.optname << ": Unexpected type " << entry.min_val.type().name();
+        }
+
+        // TODO: back to default
+    }
+}
+
+TEST_F(TestSocketOptions, InvalidVals)
+{
+    // Note: Changing SRTO_FC changes SRTO_RCVBUF limitation
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const char* desc = "[Caller, invalid val]";
+        if (entry.dflt_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckInvalidValues<bool>(entry, m_caller_sock, desc));
+        }
+        else if (entry.dflt_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckInvalidValues<int>(entry, m_caller_sock, desc));
+        }
+        else if (entry.dflt_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckInvalidValues<int64_t>(entry, m_caller_sock, desc));
+        }
+        else
+        {
+            FAIL() << "Unexpected type " << entry.dflt_val.type().name();
+        }
+
+        // TODO: expect default is still in force?
+    }
+}
+
+
+
+// TODO: taken from test_enforced_encryption
+static const char* const socket_state_array[] = {
+    "IGNORE_SRTS",
+    "SRTS_INVALID",
+    "SRTS_INIT",
+    "SRTS_OPENED",
+    "SRTS_LISTENING",
+    "SRTS_CONNECTING",
+    "SRTS_CONNECTED",
+    "SRTS_BROKEN",
+    "SRTS_CLOSING",
+    "SRTS_CLOSED",
+    "SRTS_NONEXIST"
+};
+
+// A trick that allows the array to be indexed by -1
+const char* const* g_socket_state = socket_state_array + 1;
+
+#if 0
+// No socket option can be set in blocking mode because m_ConnectionLock is required by both srt_setsockopt and srt_connect
+// TODO: Use non-blocking mode
+TEST_F(TestSocketOptions, RestrictionCallerConnecting)
+{
+    // The default SRTO_CONNTIMEO is 3 seconds. It is assumed all socket options could be checked.
+    auto connect_async = [this]() {
+        return Connect();
+    };
+    auto connect_res = async(launch::async, connect_async);
+
+    for (int i = 0; i < 100; ++i)
+    {
+        if (srt_getsockstate(m_caller_sock) == SRTS_CONNECTING)
+            break;
+
+        this_thread::sleep_for(chrono::microseconds(100));
+    }
+
+    cout << "Running test\n";
+
+    for (const auto& entry : g_test_matrix_options)
+    {
+        if (entry.restriction != RestrictionType::PRE)
+            continue;
+
+        // Setting a valid minimum value
+        EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, entry.optid, &entry.min_val, entry.opt_len), SRT_ERROR)
+            << "Setting " << entry.optname << " (PRE) must not succeed while connecting. Sock state: " << g_socket_state[srt_getsockstate(m_caller_sock)];
+    }
+
+    connect_res.get();
+}
+#endif
+
+TEST_F(TestSocketOptions, RestrictionBind)
+{
+    BindListener();
+
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const char* test_desc = "[Caller, after bind]";
+        const int expected_res = (entry.restriction == RestrictionType::PREBIND) ? SRT_ERROR : SRT_SUCCESS;
+
+        if (entry.dflt_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<bool>(entry, m_listen_sock, expected_res, test_desc))
+                << "Sock state : " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else if (entry.dflt_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<int>(entry, m_listen_sock, expected_res, test_desc))
+                << "Sock state : " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else if (entry.dflt_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<int64_t>(entry, m_listen_sock, expected_res, test_desc))
+                << "Sock state : " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else
+        {
+            FAIL() << "Unexpected type " << entry.dflt_val.type().name();
+        }
+    }
+}
+
+// Check that only socket option with POST binding can be set on a listener socket in "listening" state.
+TEST_F(TestSocketOptions, RestrictionListening)
+{
+    StartListener();
+
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const int expected_res = (entry.restriction != RestrictionType::POST) ? SRT_ERROR : SRT_SUCCESS;
+
+        // Setting a valid minimum value
+        const char* test_desc ="[Listener, listening]";
+
+        if (entry.dflt_val.type() == typeid(bool))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<bool>(entry, m_listen_sock, expected_res, test_desc))
+                << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else if (entry.dflt_val.type() == typeid(int))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<int>(entry, m_listen_sock, expected_res, test_desc))
+                << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else if (entry.dflt_val.type() == typeid(int64_t))
+        {
+            EXPECT_TRUE(CheckSetNonDefaultValue<int64_t>(entry, m_listen_sock, expected_res, test_desc))
+                << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(m_listen_sock)];
+        }
+        else
+        {
+            FAIL() << "Unexpected type " << entry.dflt_val.type().name();
+        }
+    }
+}
+
+// Check that only socket option with POST binding can be set on a connected socket (caller and accepted).
+TEST_F(TestSocketOptions, RestrictionConnected)
+{
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    for (const auto& entry : g_test_matrix_options)
+    {
+        const int expected_res = (entry.restriction != RestrictionType::POST) ? SRT_ERROR : SRT_SUCCESS;
+
+        // Setting a valid minimum value
+        for (SRTSOCKET sock : { m_caller_sock, accepted_sock })
+        {
+            const char* test_desc = sock == m_caller_sock ? "[Caller, connected]" : "[Accepted, connected]";
+
+            if (entry.dflt_val.type() == typeid(bool))
+            {
+                EXPECT_TRUE(CheckSetNonDefaultValue<bool>(entry, sock, expected_res, test_desc))
+                    << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(sock)];
+            }
+            else if (entry.dflt_val.type() == typeid(int))
+            {
+                EXPECT_TRUE(CheckSetNonDefaultValue<int>(entry, sock, expected_res, test_desc))
+                    << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(sock)];
+            }
+            else if (entry.dflt_val.type() == typeid(int64_t))
+            {
+                EXPECT_TRUE(CheckSetNonDefaultValue<int64_t>(entry, sock, expected_res, test_desc))
+                    << test_desc << entry.optname << " Sock state: " << g_socket_state[srt_getsockstate(sock)];
+            }
+            else
+            {
+                FAIL() << "Unexpected type " << entry.dflt_val.type().name();
+            }
+        }
+    }
+}
+
+// TODO: TEST_F(TestSocketOptions, CheckInheritedAfterConnection)
+// Check that accepted socket has correct socket option values.
+// Check setting and getting SRT_MININPUTBW
+TEST_F(TestSocketOptions, TLPktDropInherits)
+{
+    const bool tlpktdrop_dflt = true;
+    const bool tlpktdrop_new  = false;
+    
+    bool optval = tlpktdrop_dflt;
+    int optlen  = (int)(sizeof optval);
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_TLPKTDROP, &tlpktdrop_new, sizeof tlpktdrop_new), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_TLPKTDROP, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, tlpktdrop_new);
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (SRTSOCKET sock : { m_listen_sock, accepted_sock })
+    {
+        optval = tlpktdrop_dflt;
+        optlen = (int)(sizeof optval);
+        EXPECT_EQ(srt_getsockopt(sock, 0, SRTO_TLPKTDROP, &optval, &optlen), SRT_SUCCESS);
+        EXPECT_EQ(optlen, (int)(sizeof optval));
+        EXPECT_EQ(optval, tlpktdrop_new);
+    }
+
+    this_thread::sleep_for(chrono::seconds(2));
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+TEST_F(TestSocketOptions, Latency)
+{
+    const int latency_a    = 140;
+    const int latency_b    = 100;
+    const int latency_dflt = 120;
+
+    int optval;
+    int optlen = (int)(sizeof optval);
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_RCVLATENCY,  &latency_a, sizeof latency_a), SRT_SUCCESS);
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_PEERLATENCY, &latency_b, sizeof latency_b), SRT_SUCCESS);
+
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_RCVLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_a);
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_PEERLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_b);
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check caller socket
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_RCVLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_dflt);
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_PEERLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_a);
+
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_RCVLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_a);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_PEERLATENCY, &optval, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optval, latency_dflt);
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
 /// A regression test for issue #735, fixed by PR #843.
 /// Checks propagation of listener's socket option SRTO_LOSSMAXTTL
 /// on SRT sockets being accepted.
@@ -78,36 +714,14 @@ TEST_F(TestSocketOptions, LossMaxTTL)
     const int loss_max_ttl = 5;
     ASSERT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_LOSSMAXTTL, &loss_max_ttl, sizeof loss_max_ttl), SRT_SUCCESS);
 
-    // Specify address
-    sockaddr_in sa;
-    memset(&sa, 0, sizeof sa);
-    sa.sin_family = AF_INET;
-    sa.sin_port = htons(5200);
-    ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sa.sin_addr), 1);
-    sockaddr* psa = (sockaddr*)&sa;
-    ASSERT_NE(srt_bind(m_listen_sock, psa, sizeof sa), SRT_ERROR);
-
-    srt_listen(m_listen_sock, 1);
-
-    auto accept_async = [](SRTSOCKET listen_sock) {
-        sockaddr_in client_address;
-        int length = sizeof(sockaddr_in);
-        const SRTSOCKET accepted_socket = srt_accept(listen_sock, (sockaddr*)&client_address, &length);
-        return accepted_socket;
-    };
-    auto accept_res = async(launch::async, accept_async, m_listen_sock);
-
-    const int connect_res = srt_connect(m_caller_sock, psa, sizeof sa);
-    EXPECT_EQ(connect_res, SRT_SUCCESS);
-
-    const SRTSOCKET accepted_sock = accept_res.get();
-    ASSERT_NE(accepted_sock, SRT_INVALID_SOCK);
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
 
     int opt_val = 0;
     int opt_len = 0;
     ASSERT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_LOSSMAXTTL, &opt_val, &opt_len), SRT_SUCCESS);
     EXPECT_EQ(opt_val, loss_max_ttl) << "Wrong SRTO_LOSSMAXTTL value on the accepted socket";
-    EXPECT_EQ(opt_len, sizeof opt_len) << "Wrong SRTO_LOSSMAXTTL value length on the accepted socket";
+    EXPECT_EQ(size_t(opt_len), sizeof opt_len) << "Wrong SRTO_LOSSMAXTTL value length on the accepted socket";
 
     SRT_TRACEBSTATS stats;
     EXPECT_EQ(srt_bstats(accepted_sock, &stats, 0), SRT_SUCCESS);
@@ -115,9 +729,314 @@ TEST_F(TestSocketOptions, LossMaxTTL)
 
     ASSERT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_LOSSMAXTTL, &opt_val, &opt_len), SRT_SUCCESS);
     EXPECT_EQ(opt_val, loss_max_ttl) << "Wrong SRTO_LOSSMAXTTL value on the listener socket";
-    EXPECT_EQ(opt_len, sizeof opt_len) << "Wrong SRTO_LOSSMAXTTL value length on the listener socket";
+    EXPECT_EQ(size_t(opt_len), sizeof opt_len) << "Wrong SRTO_LOSSMAXTTL value length on the listener socket";
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+
+// Try to set/get SRTO_MININPUTBW with wrong optlen
+TEST_F(TestSocketOptions, MinInputBWWrongLen)
+{
+    int64_t mininputbw = 0;
+    int optlen = (int)(sizeof mininputbw) - 1;
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &mininputbw, &optlen), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+    optlen += 2;
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &mininputbw, &optlen), SRT_SUCCESS) << "Bigger storage is allowed";
+    EXPECT_EQ(optlen, (int)(sizeof mininputbw));
+
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &mininputbw, sizeof mininputbw - 1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &mininputbw, sizeof mininputbw + 1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+}
+
+// Check the default SRTO_MININPUTBW is SRT_PACING_MAXBW_DEFAULT
+TEST_F(TestSocketOptions, MinInputBWDefault)
+{
+    const int mininputbw_expected = 0;
+    int64_t mininputbw = 1;
+    int optlen = (int)(sizeof mininputbw);
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &mininputbw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(optlen, (int)(sizeof mininputbw));
+    EXPECT_EQ(mininputbw, mininputbw_expected);
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check both listener and accepted socket have default values
+    for (SRTSOCKET sock : { m_listen_sock, accepted_sock })
+    {
+        optlen = (int)(sizeof mininputbw);
+        EXPECT_EQ(srt_getsockopt(sock, 0, SRTO_MININPUTBW, &mininputbw, &optlen), SRT_SUCCESS);
+        EXPECT_EQ(optlen, (int)(sizeof mininputbw));
+        EXPECT_EQ(mininputbw, mininputbw_expected);
+    }
 
     ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
 }
 
+// Check setting and getting SRT_MININPUTBW
+TEST_F(TestSocketOptions, MinInputBWSet)
+{
+    const int64_t mininputbw_dflt = 0;
+    const int64_t mininputbw = 50000000;
+    int optlen = (int)(sizeof mininputbw);
+
+    int64_t bw = -100;
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &bw, sizeof bw), SRT_ERROR) << "Has to be a non-negative number";
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, mininputbw_dflt);
+
+    bw = mininputbw;
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &bw, sizeof bw), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, mininputbw);
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (SRTSOCKET sock : { m_listen_sock, accepted_sock })
+    {
+        optlen = (int)(sizeof bw);
+        EXPECT_EQ(srt_getsockopt(sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+        EXPECT_EQ(optlen, (int)(sizeof bw));
+        EXPECT_EQ(bw, mininputbw);
+    }
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+// Check setting and getting SRTO_MININPUTBW in runtime
+TEST_F(TestSocketOptions, MinInputBWRuntime)
+{
+    const int64_t mininputbw = 50000000;
+
+    // Establish a connection
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Test a connected socket
+    int64_t bw = mininputbw;
+    int optlen = (int)(sizeof bw);
+    EXPECT_EQ(srt_setsockopt(accepted_sock, 0, SRTO_MININPUTBW, &bw, sizeof bw), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, mininputbw);
+
+    bw = 0;
+    EXPECT_EQ(srt_setsockopt(accepted_sock, 0, SRTO_INPUTBW, &bw, sizeof bw), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_INPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, 0);
 
+    EXPECT_EQ(srt_setsockopt(accepted_sock, 0, SRTO_MAXBW, &bw, sizeof bw), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_MAXBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, 0);
+
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, mininputbw);
+
+    const int64_t new_mininputbw = 20000000;
+    bw = new_mininputbw;
+    EXPECT_EQ(srt_setsockopt(accepted_sock, 0, SRTO_MININPUTBW, &bw, sizeof bw), SRT_SUCCESS);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_MININPUTBW, &bw, &optlen), SRT_SUCCESS);
+    EXPECT_EQ(bw, new_mininputbw);
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+TEST_F(TestSocketOptions, StreamIDWrongLen)
+{
+    char buffer[CSrtConfig::MAX_SID_LENGTH + 135];
+    for (size_t i = 0; i < sizeof buffer; ++i)
+        buffer[i] = 'a' + i % 25;
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, buffer, CSrtConfig::MAX_SID_LENGTH+1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+}
+
+//Check if setting -1 as optlen returns an error 
+TEST_F(TestSocketOptions, StringOptLenInvalid)
+{
+    const string test_string = "test1234567";
+    const string srto_congestion_string ="live";
+    const string fec_config = "fec,cols:10,rows:10";
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, test_string.c_str(), -1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_BINDTODEVICE, test_string.c_str(), -1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_CONGESTION, srto_congestion_string.c_str(), -1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_PACKETFILTER, fec_config.c_str(), -1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_PASSPHRASE, test_string.c_str(), -1), SRT_ERROR);
+    EXPECT_EQ(srt_getlasterror(NULL), SRT_EINVPARAM);
+}
+
+// Try to set/get a 13-character string in SRTO_STREAMID.
+// This tests checks that the StreamID is set to the correct size
+// while it is transmitted as 16 characters in the Stream ID HS extension.
+TEST_F(TestSocketOptions, StreamIDOdd)
+{
+    // 13 characters, that is, 3*4+1
+    string sid_odd = "something1234";
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, sid_odd.c_str(), (int)sid_odd.size()), SRT_SUCCESS);
+
+    char buffer[CSrtConfig::MAX_SID_LENGTH + 135];
+    int buffer_len = sizeof buffer;
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(std::string(buffer), sid_odd);
+    EXPECT_EQ(size_t(buffer_len), sid_odd.size());
+    EXPECT_EQ(strlen(buffer), sid_odd.size());
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (size_t i = 0; i < sizeof buffer; ++i)
+        buffer[i] = 'a';
+    buffer_len = (int)(sizeof buffer);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(size_t(buffer_len), sid_odd.size());
+    EXPECT_EQ(strlen(buffer), sid_odd.size());
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+
+TEST_F(TestSocketOptions, StreamIDEven)
+{
+    // 12 characters = 4*3, that is, aligned to 4
+    string sid_even = "123412341234";
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, sid_even.c_str(), (int)sid_even.size()), SRT_SUCCESS);
+
+    char buffer[CSrtConfig::MAX_SID_LENGTH + 135];
+    int buffer_len = sizeof buffer;
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(std::string(buffer), sid_even);
+    EXPECT_EQ(size_t(buffer_len), sid_even.size());
+    EXPECT_EQ(strlen(buffer), sid_even.size());
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (size_t i = 0; i < sizeof buffer; ++i)
+        buffer[i] = 'a';
+    buffer_len = (int)(sizeof buffer);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(size_t(buffer_len), sid_even.size());
+    EXPECT_EQ(strlen(buffer), sid_even.size());
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+
+TEST_F(TestSocketOptions, StreamIDAlmostFull)
+{
+    // 12 characters = 4*3, that is, aligned to 4
+    string sid_amost_full;
+    for (size_t i = 0; i < CSrtConfig::MAX_SID_LENGTH-2; ++i)
+        sid_amost_full += 'x';
+
+    // Just to manipulate the last ones.
+    size_t size = sid_amost_full.size();
+    sid_amost_full[size-2] = 'y';
+    sid_amost_full[size-1] = 'z';
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, sid_amost_full.c_str(), (int)sid_amost_full.size()), SRT_SUCCESS);
+
+    char buffer[CSrtConfig::MAX_SID_LENGTH + 135];
+    int buffer_len = sizeof buffer;
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(std::string(buffer), sid_amost_full);
+    EXPECT_EQ(size_t(buffer_len), sid_amost_full.size());
+    EXPECT_EQ(strlen(buffer), sid_amost_full.size());
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (size_t i = 0; i < sizeof buffer; ++i)
+        buffer[i] = 'a';
+    buffer_len = (int)(sizeof buffer);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(size_t(buffer_len), sid_amost_full.size());
+    EXPECT_EQ(strlen(buffer), sid_amost_full.size());
+    EXPECT_EQ(buffer[sid_amost_full.size()-1], 'z');
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+TEST_F(TestSocketOptions, StreamIDFull)
+{
+    // 12 characters = 4*3, that is, aligned to 4
+    string sid_full;
+    for (size_t i = 0; i < CSrtConfig::MAX_SID_LENGTH; ++i)
+        sid_full += 'x';
+
+    // Just to manipulate the last ones.
+    size_t size = sid_full.size();
+    sid_full[size-2] = 'y';
+    sid_full[size-1] = 'z';
+
+    EXPECT_EQ(srt_setsockopt(m_caller_sock, 0, SRTO_STREAMID, sid_full.c_str(), (int)sid_full.size()), SRT_SUCCESS);
+
+    char buffer[CSrtConfig::MAX_SID_LENGTH + 135];
+    int buffer_len = sizeof buffer;
+    EXPECT_EQ(srt_getsockopt(m_caller_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(std::string(buffer), sid_full);
+    EXPECT_EQ(size_t(buffer_len), sid_full.size());
+    EXPECT_EQ(strlen(buffer), sid_full.size());
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted socket inherits values
+    for (size_t i = 0; i < sizeof buffer; ++i)
+        buffer[i] = 'a';
+    buffer_len = (int)(sizeof buffer);
+    EXPECT_EQ(srt_getsockopt(accepted_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(size_t(buffer_len), sid_full.size());
+    EXPECT_EQ(strlen(buffer), sid_full.size());
+    EXPECT_EQ(buffer[sid_full.size()-1], 'z');
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
+
+// Check that StreamID assigned to a listener socket is not inherited by accepted sockets,
+// and is not derived by a caller socket.
+TEST_F(TestSocketOptions, StreamIDLenListener)
+{
+    string stream_id_13 = "something1234";
+
+    EXPECT_EQ(srt_setsockopt(m_listen_sock, 0, SRTO_STREAMID, stream_id_13.c_str(), (int)stream_id_13.size()), SRT_SUCCESS);
+
+    char buffer[648];
+    int buffer_len = sizeof buffer;
+    EXPECT_EQ(srt_getsockopt(m_listen_sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+    EXPECT_EQ(string(buffer), stream_id_13);
+    EXPECT_EQ(size_t(buffer_len), stream_id_13.size());
+
+    StartListener();
+    const SRTSOCKET accepted_sock = EstablishConnection();
+
+    // Check accepted and caller sockets do not inherit StreamID.
+    for (SRTSOCKET sock : { m_caller_sock, accepted_sock })
+    {
+        buffer_len = (int)(sizeof buffer);
+        fill_n(buffer, buffer_len, 'a');
+        EXPECT_EQ(srt_getsockopt(sock, 0, SRTO_STREAMID, &buffer, &buffer_len), SRT_SUCCESS);
+        EXPECT_EQ(buffer_len, 0) << (sock == accepted_sock ? "ACCEPTED" : "CALLER");
+    }
+
+    ASSERT_NE(srt_close(accepted_sock), SRT_ERROR);
+}
diff --git a/test/test_socketdata.cpp b/test/test_socketdata.cpp
new file mode 100644
index 000000000..547a2ebc9
--- /dev/null
+++ b/test/test_socketdata.cpp
@@ -0,0 +1,69 @@
+
+#include <chrono>
+#include <thread>
+#include <iostream>
+
+#include "gtest/gtest.h"
+#include "test_env.h"
+
+#include "srt.h"
+#include "netinet_any.h"
+
+using namespace std;
+using namespace std::chrono;
+using namespace srt;
+
+TEST(SocketData, PeerName)
+{
+    srt::TestInit srtinit;
+
+    // Single-threaded one-app connect/accept action
+
+    int csock = srt_create_socket();
+    int lsock = srt_create_socket();
+
+    bool rd_nonblocking = false;
+
+    srt_setsockflag(csock, SRTO_RCVSYN, &rd_nonblocking, sizeof (rd_nonblocking));
+    //srt_setsockflag(lsock, SRTO_RCVSYN, &rd_nonblocking, sizeof (rd_nonblocking));
+
+    sockaddr_any addr = srt::CreateAddr("127.0.0.1", 5000, AF_INET);
+
+    ASSERT_NE(srt_bind(lsock, addr.get(), addr.size()), -1);
+
+    ASSERT_NE(srt_listen(lsock, 5), -1);
+
+    ASSERT_NE(srt_connect(csock, addr.get(), addr.size()), -1);
+
+    sockaddr_any rev_addr;
+    int accepted_sock = srt_accept(lsock, rev_addr.get(), &rev_addr.len);
+
+    // Wait to make sure that the socket is connected.
+
+    int retry = 10;
+    while (srt_getsockstate(csock) != SRTS_CONNECTED && retry)
+    {
+        this_thread::sleep_for(milliseconds(500));
+        --retry;
+    }
+
+    ASSERT_NE(retry, 0);
+
+    // Now checkups
+    sockaddr_any peer_addr;
+    ASSERT_NE(srt_getpeername(csock, peer_addr.get(), &peer_addr.len), -1);
+    sockaddr_any my_addr;
+    ASSERT_NE(srt_getsockname(csock, my_addr.get(), &my_addr.len), -1);
+
+    cout << "Connect address: " << addr.str() << endl;
+    cout << "Peer address: " << peer_addr.str() << endl;
+    cout << "Accept address: " << rev_addr.str() << endl;
+    cout << "Caller address: " << my_addr.str() << endl;
+
+    EXPECT_EQ(peer_addr, addr);
+    EXPECT_EQ(my_addr, rev_addr);
+
+    srt_close(csock);
+    srt_close(accepted_sock);
+    srt_close(lsock);
+}
diff --git a/test/test_sync.cpp b/test/test_sync.cpp
index 2a69c1980..d06b5e5f5 100644
--- a/test/test_sync.cpp
+++ b/test/test_sync.cpp
@@ -1,8 +1,8 @@
 #include "gtest/gtest.h"
+#include <array>
 #include <chrono>
 #include <thread>
 #include <future>
-#include <array>
 #include <numeric> // std::accumulate
 #include <regex>   // Used in FormatTime test
 #include "sync.h"
@@ -15,14 +15,6 @@
 using namespace std;
 using namespace srt::sync;
 
-// GNUC supports C++14 starting from version 5
-//#if defined(__GNUC__) && (__GNUC__ < 5)
-////namespace srt
-// constexpr chrono::milliseconds operator"" ms(
-//    unsigned long long _Val) { // return integral milliseconds
-//    return chrono::milliseconds(_Val);
-//}
-//#endif
 
 TEST(SyncDuration, BasicChecks)
 {
@@ -157,6 +149,49 @@ TEST(SyncDuration, OperatorMultIntEq)
     EXPECT_EQ(count_milliseconds(a), 7000);
 }
 
+TEST(SyncRandom, GenRandomInt)
+{
+    array<size_t, 64> mn = {};
+
+    // Check generated values are in the specified range.
+    const size_t n = 2048;
+    for (size_t i = 0; i < n; ++i)
+    {
+        const int rand_val = genRandomInt(0, int(mn.size()) - 1);
+        ASSERT_GE(rand_val, 0);
+        ASSERT_LT(rand_val, (int) mn.size());
+        ++mn[rand_val];
+    }
+
+    // Check the distribution is more or less uniform.
+    // 100% uniform if each value is generated (n / (2 * mn.size())) times.
+    // We expect at least half of that value for a random uniform distribution.
+    ASSERT_GT(n / (2 * mn.size()), 4u);
+    const size_t min_value = n / (2 * mn.size()) - 4u; // Subtracting 4 to tolerate possible deviations.
+    for (size_t i = 0; i < mn.size(); ++i)
+    {
+        EXPECT_GE(mn[i], min_value) << "i=" << i << ". Ok-ish if the count is non-zero.";
+    }
+
+    // Uncomment to see the distribution.
+    //cout << "min value: " << min_value << endl;
+    //for (size_t i = 0; i < mn.size(); ++i)
+    //{
+    //    cout << i << '\t';
+    //    for (int j=0; j<mn[i]; ++j) cout << '*';
+    //    cout << '\n';
+    //}
+
+    // Check INT32_MAX
+    for (size_t i = 0; i < n; ++i)
+    {
+        const int rand_val = genRandomInt(INT32_MAX - 1, INT32_MAX);
+
+        EXPECT_GE(rand_val, INT32_MAX - 1);
+        EXPECT_LE(rand_val, INT32_MAX);
+    }
+}
+
 /*****************************************************************************/
 /*
  * TimePoint tests
@@ -314,7 +349,8 @@ TEST(SyncEvent, WaitFor)
         // - SyncEvent::wait_for( 50us) took 6us
         // - SyncEvent::wait_for(100us) took 4us
         if (on_timeout) {
-            EXPECT_GE(waittime_us, timeout_us);
+            const int tolerance = timeout_us/1000;
+            EXPECT_GE(waittime_us, timeout_us - tolerance);
         }
 #endif
         if (on_timeout) {
@@ -349,9 +385,9 @@ TEST(SyncEvent, WaitForNotifyOne)
 
     const steady_clock::duration timeout = seconds_from(5);
 
-    auto wait_async = [](Condition* cond, Mutex* mutex, const steady_clock::duration& timeout) {
-        UniqueLock lock(*mutex);
-        return cond->wait_for(lock, timeout);
+    auto wait_async = [](Condition* cv, Mutex* m, const steady_clock::duration& tmo) {
+        CUniqueSync cc (*m, *cv);
+        return cc.wait_for(tmo);
     };
     auto wait_async_res = async(launch::async, wait_async, &cond, &mutex, timeout);
 
@@ -370,9 +406,9 @@ TEST(SyncEvent, WaitNotifyOne)
     Condition cond;
     cond.init();
 
-    auto wait_async = [](Condition* cond, Mutex* mutex) {
-        UniqueLock lock(*mutex);
-        return cond->wait(lock);
+    auto wait_async = [](Condition* cv, Mutex* m) {
+        UniqueLock lock(*m);
+        return cv->wait(lock);
     };
     auto wait_async_res = async(launch::async, wait_async, &cond, &mutex);
 
@@ -394,11 +430,11 @@ TEST(SyncEvent, WaitForTwoNotifyOne)
     const int VAL_SIGNAL = 42;
     const int VAL_NO_SIGNAL = 0;
 
-    volatile bool resource_ready = true;
+    srt::sync::atomic<bool> resource_ready(true);
 
-    auto wait_async = [&](Condition* cond, Mutex* mutex, const steady_clock::duration& timeout, int id) {
-        UniqueLock lock(*mutex);
-        if (cond->wait_for(lock, timeout) && resource_ready)
+    auto wait_async = [&](Condition* cv, Mutex* m, const steady_clock::duration& tmo, int id) {
+        UniqueLock lock(*m);
+        if (cv->wait_for(lock, tmo) && resource_ready)
         {
             notified_clients.push_back(id);
             resource_ready = false;
@@ -409,7 +445,7 @@ TEST(SyncEvent, WaitForTwoNotifyOne)
 
     using future_t = decltype(async(launch::async, wait_async, &cond, &mutex, timeout, 0));
 
-    future_t future_result[2] = {
+    std::array<future_t, 2> future_result = {
         async(launch::async, wait_async, &cond, &mutex, timeout, 0),
         async(launch::async, wait_async, &cond, &mutex, timeout, 1)
     };
@@ -426,9 +462,9 @@ TEST(SyncEvent, WaitForTwoNotifyOne)
 
     using wait_t = decltype(future_t().wait_for(chrono::microseconds(0)));
 
-    wait_t wait_state[2] = {
-        move(future_result[0].wait_for(chrono::microseconds(100))),
-        move(future_result[1].wait_for(chrono::microseconds(100)))
+    std::array<wait_t, 2> wait_state = {
+        future_result[0].wait_for(chrono::microseconds(500)),
+        future_result[1].wait_for(chrono::microseconds(500))
     };
 
     cerr << "SyncEvent::WaitForTwoNotifyOne: NOTIFICATION came from " << notified_clients.size()
@@ -439,7 +475,7 @@ TEST(SyncEvent, WaitForTwoNotifyOne)
 
     // Now exactly one waiting thread should become ready
     // Error if: 0 (none ready) or 2 (both ready, while notify_one was used)
-    ASSERT_EQ(notified_clients.size(), 1);
+    ASSERT_EQ(notified_clients.size(), 1U);
 
     const int ready = notified_clients[0];
     const int not_ready = (ready + 1) % 2;
@@ -500,9 +536,9 @@ TEST(SyncEvent, WaitForTwoNotifyAll)
     cond.init();
     const steady_clock::duration timeout = seconds_from(3);
 
-    auto wait_async = [](Condition* cond, Mutex* mutex, const steady_clock::duration& timeout) {
-        UniqueLock lock(*mutex);
-        return cond->wait_for(lock, timeout);
+    auto wait_async = [](Condition* cv, Mutex* m, const steady_clock::duration& tmo) {
+        UniqueLock lock(*m);
+        return cv->wait_for(lock, tmo);
     };
     auto wait_async1_res = async(launch::async, wait_async, &cond, &mutex, timeout);
     auto wait_async2_res = async(launch::async, wait_async, &cond, &mutex, timeout);
@@ -529,9 +565,9 @@ TEST(SyncEvent, WaitForNotifyAll)
     cond.init();
     const steady_clock::duration timeout = seconds_from(5);
 
-    auto wait_async = [](Condition* cond, Mutex* mutex, const steady_clock::duration& timeout) {
-        UniqueLock lock(*mutex);
-        return cond->wait_for(lock, timeout);
+    auto wait_async = [](Condition* cv, Mutex* m, const steady_clock::duration& tmo) {
+        UniqueLock lock(*m);
+        return cv->wait_for(lock, tmo);
     };
     auto wait_async_res = async(launch::async, wait_async, &cond, &mutex, timeout);
 
@@ -551,14 +587,15 @@ TEST(SyncEvent, WaitForNotifyAll)
  /*****************************************************************************/
 void* dummythread(void* param)
 {
-    *(bool*)(param) = true;
+    auto& thread_finished = *(srt::sync::atomic<bool>*)param;
+    thread_finished = true;
     return nullptr;
 }
 
 TEST(SyncThread, Joinable)
 {
     CThread foo;
-    volatile bool thread_finished = false;
+    srt::sync::atomic<bool> thread_finished;
 
     StartThread(foo, dummythread, (void*)&thread_finished, "DumyThread");
 
@@ -572,6 +609,91 @@ TEST(SyncThread, Joinable)
     EXPECT_FALSE(foo.joinable());
 }
 
+/*****************************************************************************/
+/*
+ * SharedMutex
+ */
+ /*****************************************************************************/
+TEST(SharedMutex, LockWriteRead)
+{
+    SharedMutex mut;
+        
+    mut.lock();
+    EXPECT_FALSE(mut.try_lock_shared());
+
+}
+
+TEST(SharedMutex, LockReadWrite)
+{
+    SharedMutex mut;
+
+    mut.lock_shared();
+    EXPECT_FALSE(mut.try_lock());
+
+}
+
+TEST(SharedMutex, LockReadTwice)
+{
+    SharedMutex mut;
+
+    mut.lock_shared();
+    mut.lock_shared();
+    EXPECT_TRUE(mut.try_lock_shared());
+}
+
+TEST(SharedMutex, LockWriteTwice)
+{
+    SharedMutex mut;
+
+    mut.lock();
+    EXPECT_FALSE(mut.try_lock());
+}
+
+TEST(SharedMutex, LockUnlockWrite)
+{
+    SharedMutex mut;
+    mut.lock();
+    EXPECT_FALSE(mut.try_lock());
+    mut.unlock();
+    EXPECT_TRUE(mut.try_lock());
+}
+
+TEST(SharedMutex, LockUnlockRead)
+{
+    SharedMutex mut;
+
+    mut.lock_shared();
+    EXPECT_FALSE(mut.try_lock());
+
+    mut.unlock_shared();
+    EXPECT_TRUE(mut.try_lock());
+}
+
+TEST(SharedMutex, LockedReadCount)
+{
+    SharedMutex mut;
+    int count = 0;
+
+    mut.lock_shared();
+    count++;
+    ASSERT_EQ(mut.getReaderCount(), count);
+
+    mut.lock_shared();
+    count++;
+    ASSERT_EQ(mut.getReaderCount(), count);
+
+    mut.unlock_shared();
+    count--;
+    ASSERT_EQ(mut.getReaderCount(), count);
+
+    mut.unlock_shared();
+    count--;
+    ASSERT_EQ(mut.getReaderCount(), count);
+
+    EXPECT_TRUE(mut.try_lock());
+}
+
+
 /*****************************************************************************/
 /*
  * FormatTime
@@ -586,19 +708,19 @@ TEST(Sync, FormatTime)
 {
     auto parse_time = [](const string& timestr) -> long long {
         // Example string: 1D 02:10:55.972651 [STD]
-        const regex rex("([[:digit:]]+D )?([[:digit:]]{2}):([[:digit:]]{2}):([[:digit:]]{2}).([[:digit:]]{6}) \\[STD\\]");
+        const regex rex("([[:digit:]]+D )?([[:digit:]]{2}):([[:digit:]]{2}):([[:digit:]]{2}).([[:digit:]]{6,}) \\[STDY\\]");
         std::smatch sm;
         EXPECT_TRUE(regex_match(timestr, sm, rex));
-        EXPECT_LE(sm.size(), 6);
+        EXPECT_LE(sm.size(), 6U);
         if (sm.size() != 6 && sm.size() != 5)
             return 0;
 
         // Day may be missing if zero
         const long long d = sm[1].matched ? std::stoi(sm[1]) : 0;
-        const long long h = std::stoi(sm[2]);
-        const long long m = std::stoi(sm[3]);
-        const long long s = std::stoi(sm[4]);
-        const long long u = std::stoi(sm[5]);
+        const long long h = std::stoll(sm[2]);
+        const long long m = std::stoll(sm[3]);
+        const long long s = std::stoll(sm[4]);
+        const long long u = std::stoll(sm[5]);
 
         return u + s * 1000000 + m * 60000000 + h * 60 * 60 * 1000000 + d * 24 * 60 * 60 * 1000000;
     };
@@ -630,10 +752,10 @@ TEST(Sync, FormatTime)
 TEST(Sync, FormatTimeSys)
 {
     auto parse_time = [](const string& timestr) -> long long {
-        const regex rex("([[:digit:]]{2}):([[:digit:]]{2}):([[:digit:]]{2}).([[:digit:]]{6}) \\[SYS\\]");
+        const regex rex("([[:digit:]]{2}):([[:digit:]]{2}):([[:digit:]]{2}).([[:digit:]]{6}) \\[SYST\\]");
         std::smatch sm;
         EXPECT_TRUE(regex_match(timestr, sm, rex));
-        EXPECT_EQ(sm.size(), 5);
+        EXPECT_EQ(sm.size(), 5U);
         if (sm.size() != 5)
             return 0;
 
diff --git a/test/test_threadname.cpp b/test/test_threadname.cpp
new file mode 100644
index 000000000..0b03686a4
--- /dev/null
+++ b/test/test_threadname.cpp
@@ -0,0 +1,63 @@
+#include <algorithm>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "threadname.h"
+
+using namespace srt;
+
+TEST(ThreadName, GetSet)
+{
+    std::string name("getset");
+    char        buf[ThreadName::BUFSIZE * 2];
+
+    memset(buf, 'a', sizeof(buf));
+    ASSERT_EQ(ThreadName::get(buf), true);
+    // ensure doesn't write out-of-range
+    size_t max = ThreadName::BUFSIZE - 1;
+    ASSERT_LE(strlen(buf), max);
+
+    if (ThreadName::DUMMY_IMPL)
+        return;
+
+    ASSERT_EQ(ThreadName::set(name), true);
+    memset(buf, 'a', sizeof(buf));
+    ASSERT_EQ(ThreadName::get(buf), true);
+    ASSERT_EQ(buf, name);
+}
+
+TEST(ThreadName, AutoReset)
+{
+    const std::string old_name("old");
+    std::string new_name("new-name");
+    if (ThreadName::DUMMY_IMPL)
+    {
+        // just make sure the API is correct
+        ThreadName t(std::string("test"));
+        return;
+    }
+
+    ASSERT_EQ(ThreadName::set(old_name), true);
+    std::string name;
+    ASSERT_EQ(ThreadName::get(name), true);
+    ASSERT_EQ(name, old_name);
+
+    {
+        ThreadName threadName(new_name);
+        ASSERT_EQ(ThreadName::get(name), true);
+        ASSERT_EQ(name, new_name);
+    }
+
+    ASSERT_EQ(ThreadName::get(name), true);
+    ASSERT_EQ(name, old_name);
+
+    {
+        new_name.resize(std::max<size_t>(512, ThreadName::BUFSIZE * 2), 'z');
+        ThreadName threadName(new_name);
+        ASSERT_EQ(ThreadName::get(name), true);
+        ASSERT_EQ(new_name.compare(0, name.size(), name), 0);
+    }
+
+    ASSERT_EQ(ThreadName::get(name), true);
+    ASSERT_EQ(name, old_name);
+}
diff --git a/test/test_unitqueue.cpp b/test/test_unitqueue.cpp
index f9010b9e7..c58242727 100644
--- a/test/test_unitqueue.cpp
+++ b/test/test_unitqueue.cpp
@@ -1,11 +1,11 @@
 #include <array>
 #include <vector>
 #include "gtest/gtest.h"
+#include "test_env.h"
 #include "queue.h"
 
-
 using namespace std;
-
+using namespace srt;
 
 /// Create CUnitQueue with queue size of 4 units.
 /// The size of 4 is chosen on purpose, because 
@@ -16,16 +16,16 @@ using namespace std;
 /// the very last element of the queue (it was skipped).
 TEST(CUnitQueue, Increase)
 {
+    srt::TestInit srtinit;
     const int buffer_size_pkts = 4;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
+    CUnitQueue unit_queue(buffer_size_pkts, 1500);
 
     vector<CUnit*> taken_units;
     for (int i = 0; i < 5 * buffer_size_pkts; ++i)
     {
         CUnit* unit = unit_queue.getNextAvailUnit();
         ASSERT_NE(unit, nullptr);
-        unit_queue.makeUnitGood(unit);
+        unit_queue.makeUnitTaken(unit);
         taken_units.push_back(unit);
     }
 }
@@ -37,16 +37,16 @@ TEST(CUnitQueue, Increase)
 /// beginning of the same queue.
 TEST(CUnitQueue, IncreaseAndFree)
 {
+    srt::TestInit srtinit;
     const int buffer_size_pkts = 4;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
+    CUnitQueue unit_queue(buffer_size_pkts, 1500);
 
     CUnit* taken_unit = nullptr;
     for (int i = 0; i < 5 * buffer_size_pkts; ++i)
     {
         CUnit* unit = unit_queue.getNextAvailUnit();
         ASSERT_NE(unit, nullptr);
-        unit_queue.makeUnitGood(unit);
+        unit_queue.makeUnitTaken(unit);
 
         if (taken_unit)
             unit_queue.makeUnitFree(taken_unit);
@@ -62,16 +62,16 @@ TEST(CUnitQueue, IncreaseAndFree)
 /// Thus the test checks if 
 TEST(CUnitQueue, IncreaseAndFreeGrouped)
 {
+    srt::TestInit srtinit;
     const int buffer_size_pkts = 4;
-    CUnitQueue unit_queue;
-    unit_queue.init(buffer_size_pkts, 1500, AF_INET);
+    CUnitQueue unit_queue(buffer_size_pkts, 1500);
 
     vector<CUnit*> taken_units;
     for (int i = 0; i < 5 * buffer_size_pkts; ++i)
     {
         CUnit* unit = unit_queue.getNextAvailUnit();
         ASSERT_NE(unit, nullptr);
-        unit_queue.makeUnitGood(unit);
+        unit_queue.makeUnitTaken(unit);
 
         if (taken_units.size() >= buffer_size_pkts)
         {
diff --git a/test/test_utilities.cpp b/test/test_utilities.cpp
index 42c761d63..28c14044e 100644
--- a/test/test_utilities.cpp
+++ b/test/test_utilities.cpp
@@ -9,6 +9,7 @@
 #include "common.h"
 
 using namespace std;
+using namespace srt;
 
 
 // To test CircularBuffer
@@ -159,11 +160,11 @@ TEST(CircularBuffer, Overall)
     ASSERT_EQ(output.d, 22.1);
 
     IF_HEAVY_LOGGING(cerr << "Pushing 1 aslong there is capacity:\n");
-    int i = 0;
+    IF_HEAVY_LOGGING(int i = 0);
     while (buf.push(1) != -1)
     {
         IF_HEAVY_LOGGING(cerr << "Pushed, begin=" << buf.m_xBegin << " end=" << buf.m_xEnd << endl);
-        ++i;
+        IF_HEAVY_LOGGING(++i);
     }
     IF_HEAVY_LOGGING(cerr << "Done " << i << " operations, buffer:\n");
     IF_HEAVY_LOGGING(ShowCircularBuffer(buf));
@@ -177,7 +178,7 @@ TEST(CircularBuffer, Overall)
     int offset = 9;
     IF_HEAVY_LOGGING(cerr << "Forced adding at position 9 with dropping (capacity: " << buf.capacity() << "):\n");
     // State we already know it has failed. Calculate drop size.
-    int dropshift = offset - (buf.capacity() - 1); // buf.capacity()-1 is the latest position
+    int dropshift = offset - int(buf.capacity() - 1); // buf.capacity()-1 is the latest position
     offset -= dropshift;
     IF_HEAVY_LOGGING(cerr << "Need to drop: " << dropshift << " New offset:" << offset << endl);
     ASSERT_GE(dropshift, 0);
@@ -211,3 +212,63 @@ TEST(CircularBuffer, Overall)
     IF_HEAVY_LOGGING(cerr << "DONE.\n");
 }
 
+TEST(ConfigString, Setting)
+{
+    using namespace std;
+
+    static const auto STRSIZE = 20;
+    StringStorage<STRSIZE> s;
+
+    EXPECT_TRUE(s.empty());
+    EXPECT_EQ(s.size(), 0U);
+    EXPECT_EQ(s.str(), std::string());
+
+    char example_ac1[] = "example_long";
+    char example_ac2[] = "short";
+    char example_ac3[] = "example_longer";
+    char example_acx[] = "example_long_excessively";
+    char example_ace[] = "";
+
+    // According to the standard, this array gets automatically
+    // the number of characters + 1 for terminating 0. Get sizeof()-1
+    // to get the number of characters.
+
+    EXPECT_TRUE(s.set(example_ac1, sizeof (example_ac1)-1));
+    EXPECT_EQ(s.size(), sizeof (example_ac1)-1);
+    EXPECT_FALSE(s.empty());
+
+    EXPECT_TRUE(s.set(example_ac2, sizeof (example_ac2)-1));
+    EXPECT_EQ(s.size(), sizeof (example_ac2)-1);
+
+    EXPECT_TRUE(s.set(example_ac3, sizeof (example_ac3)-1));
+    EXPECT_EQ(s.size(), sizeof (example_ac3)-1);
+
+    EXPECT_FALSE(s.set(example_acx, sizeof (example_acx)-1));
+    EXPECT_EQ(s.size(), sizeof (example_ac3)-1);
+
+    EXPECT_TRUE(s.set(example_ace, sizeof (example_ace)-1));
+    EXPECT_EQ(s.size(), 0U);
+
+    string example_s1 = "example_long";
+    string example_s2 = "short";
+    string example_s3 = "example_longer";
+    string example_sx = "example_long_excessively";
+    string example_se = "";
+
+    EXPECT_TRUE(s.set(example_s1));
+    EXPECT_EQ(s.size(), example_s1.size());
+    EXPECT_FALSE(s.empty());
+
+    EXPECT_TRUE(s.set(example_s2));
+    EXPECT_EQ(s.size(), example_s2.size());
+
+    EXPECT_TRUE(s.set(example_s3));
+    EXPECT_EQ(s.size(), example_s3.size());
+
+    EXPECT_FALSE(s.set(example_sx));
+    EXPECT_EQ(s.size(), example_s3.size());
+
+    EXPECT_TRUE(s.set(example_se));
+    EXPECT_EQ(s.size(), 0U);
+    EXPECT_TRUE(s.empty());
+}
diff --git a/testing/srt-test-file.cpp b/testing/srt-test-file.cpp
index aafeef4b2..3dd8fe998 100644
--- a/testing/srt-test-file.cpp
+++ b/testing/srt-test-file.cpp
@@ -259,7 +259,7 @@ bool DoUpload(UriParser& ut, string path, string filename)
         size_t shift = 0;
         while (n > 0)
         {
-            int st = srt_send(ss, buf.data()+shift, n);
+            int st = srt_send(ss, buf.data()+shift, int(n));
             Verb() << "Upload: " << n << " --> " << st << (!shift ? string() : "+" + Sprint(shift));
             if (st == SRT_ERROR)
             {
@@ -357,7 +357,7 @@ bool DoDownload(UriParser& us, string directory, string filename)
 
     for (;;)
     {
-        int n = srt_recv(ss, buf.data(), ::g_buffer_size);
+        int n = srt_recv(ss, buf.data(), int(::g_buffer_size));
         if (n == SRT_ERROR)
         {
             cerr << "Download: SRT error: " << srt_getlasterror_str() << endl;
diff --git a/testing/srt-test-live.cpp b/testing/srt-test-live.cpp
index daa3efc29..12478e461 100644
--- a/testing/srt-test-live.cpp
+++ b/testing/srt-test-live.cpp
@@ -64,11 +64,11 @@
 #include <chrono>
 #include <thread>
 
+#include "srt_compat.h"
 #include "apputil.hpp"
 #include "uriparser.hpp"  // UriParser
 #include "socketoptions.hpp"
 #include "logsupport.hpp"
-#include "testmedia.hpp"
 #include "testmedia.hpp" // requires access to SRT-dependent globals
 #include "verbose.hpp"
 
@@ -101,14 +101,11 @@ struct AlarmExit: public std::runtime_error
     }
 };
 
-volatile bool int_state = false;
-volatile bool timer_state = false;
+srt::sync::atomic<bool> timer_state;
 void OnINT_ForceExit(int)
 {
     cerr << "\n-------- REQUESTED INTERRUPT!\n";
-    int_state = true;
-    if ( transmit_throw_on_interrupt )
-        throw ForcedExit("Requested exception interrupt");
+    transmit_int_state = true;
 }
 
 std::string g_interrupt_reason;
@@ -116,7 +113,7 @@ std::string g_interrupt_reason;
 void OnAlarm_Interrupt(int)
 {
     cerr << "\n---------- INTERRUPT ON TIMEOUT: hang on " << g_interrupt_reason << "!\n";
-    int_state = false; // JIC
+    transmit_int_state = true; // JIC
     timer_state = true;
     throw AlarmExit("Watchdog bites hangup");
 }
@@ -271,7 +268,7 @@ bool CheckMediaSpec(const string& prefix, const vector<string>& spec, string& w_
     for (string& a: adrs)
         w_outspec += a + ",";
 
-    Verb() << "NOTE: " << prefix << " specification set as: " << (w_outspec);
+    Verb("NOTE: ", prefix, " specification set as: ", (w_outspec));
 
     return true;
 }
@@ -283,7 +280,7 @@ namespace srt_logging
     extern Logger glog;
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 extern "C" int SrtCheckGroupHook(void* , SRTSOCKET acpsock, int , const sockaddr*, const char* )
 {
     static string gtypes[] = {
@@ -297,20 +294,20 @@ extern "C" int SrtCheckGroupHook(void* , SRTSOCKET acpsock, int , const sockaddr
     int type;
     int size = sizeof type;
     srt_getsockflag(acpsock, SRTO_GROUPCONNECT, &type, &size);
-    Verb() << "listener: @" << acpsock << " - accepting " << (type ? "GROUP" : "SINGLE") << VerbNoEOL;
+    Verb("listener: @", acpsock, " - accepting ", (type ? "GROUP" : "SINGLE"), VerbNoEOL);
     if (type != 0)
     {
         SRT_GROUP_TYPE gt;
         size = sizeof gt;
         if (-1 != srt_getsockflag(acpsock, SRTO_GROUPTYPE, &gt, &size))
         {
-            if (gt < Size(gtypes))
-                Verb() << " type=" << gtypes[gt] << VerbNoEOL;
+            if (size_t(gt) < Size(gtypes))
+                Verb(" type=", gtypes[gt], VerbNoEOL);
             else
-                Verb() << " type=" << int(gt) << VerbNoEOL;
+                Verb(" type=", int(gt), VerbNoEOL);
         }
     }
-    Verb() << " connection";
+    Verb(" connection");
 
     return 0;
 }
@@ -320,7 +317,7 @@ extern "C" int SrtUserPasswordHook(void* , SRTSOCKET acpsock, int hsv, const soc
 {
     if (hsv < 5)
     {
-        Verb() << "SrtUserPasswordHook: HS version 4 doesn't support extended handshake";
+        Verb("SrtUserPasswordHook: HS version 4 doesn't support extended handshake");
         return -1;
     }
 
@@ -360,7 +357,7 @@ extern "C" int SrtUserPasswordHook(void* , SRTSOCKET acpsock, int hsv, const soc
 
     string exp_pw = passwd.at(username);
 
-    srt_setsockflag(acpsock, SRTO_PASSPHRASE, exp_pw.c_str(), exp_pw.size());
+    srt_setsockflag(acpsock, SRTO_PASSPHRASE, exp_pw.c_str(), int(exp_pw.size()));
 
     return 0;
 }
@@ -381,37 +378,6 @@ extern "C" int SrtRejectByCodeHook(void* op, SRTSOCKET acpsock, int , const sock
     return -1;
 }
 
-void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
-{
-    std::ostringstream son, soff;
-
-    for (auto& s: speclist)
-    {
-        string name;
-        bool on = true;
-        if (s[0] == '+')
-            name = s.substr(1);
-        else if (s[0] == '~')
-        {
-            name = s.substr(1);
-            on = false;
-        }
-        else
-            name = s;
-
-        if (on)
-            son << "," << name;
-        else
-            soff << "," << name;
-    }
-
-    const string& sons = son.str();
-    const string& soffs = soff.str();
-
-    w_on = sons.empty() ? string() : sons.substr(1);
-    w_off = soffs.empty() ? string() : soffs.substr(1);
-}
-
 int main( int argc, char** argv )
 {
     // This is mainly required on Windows to initialize the network system,
@@ -419,6 +385,8 @@ int main( int argc, char** argv )
     if ( !SysInitializeNetwork() )
         throw std::runtime_error("Can't initialize network!");
 
+    srt_startup();
+
     // Symmetrically, this does a cleanup; put into a local destructor to ensure that
     // it's called regardless of how this function returns.
     struct NetworkCleanup
@@ -426,6 +394,7 @@ int main( int argc, char** argv )
         ~NetworkCleanup()
         {
             SysCleanupNetwork();
+            srt_cleanup();
         }
     } cleanupobj;
 
@@ -447,7 +416,7 @@ int main( int argc, char** argv )
         o_skipflush ((optargs), " Do not wait safely 5 seconds at the end to flush buffers", "sf",  "skipflush"),
         o_stoptime  ((optargs), "<time[s]=0[no timeout]> Time after which the application gets interrupted", "d", "stoptime"),
         o_hook      ((optargs), "<hookspec> Use listener callback of given specification (internally coded)", "hook"),
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         o_group     ((optargs), "<URIs...> Using multiple SRT connections as redundancy group", "g"),
 #endif
         o_stime     ((optargs), " Pass source time explicitly to SRT output", "st", "srctime", "sourcetime"),
@@ -462,7 +431,7 @@ int main( int argc, char** argv )
     vector<string> args = params[""];
 
     string source_spec, target_spec;
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     vector<string> groupspec = Option<OutList>(params, vector<string>{}, o_group);
 #endif
     vector<string> source_items, target_items;
@@ -471,7 +440,7 @@ int main( int argc, char** argv )
     {
         // You may still need help.
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         if ( !groupspec.empty() )
         {
             // Check if you have something before -g and after -g.
@@ -678,7 +647,7 @@ int main( int argc, char** argv )
             transmit_accept_hook_op = (void*)&g_reject_data;
             transmit_accept_hook_fn = &SrtRejectByCodeHook;
         }
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         else if (hargs[0] == "groupcheck")
         {
             transmit_accept_hook_fn = &SrtCheckGroupHook;
@@ -687,13 +656,26 @@ int main( int argc, char** argv )
 #endif
     }
 
-    SrtStatsPrintFormat statspf = ParsePrintFormat(Option<OutString>(params, "default", o_statspf));
+    string pfextra;
+    SrtStatsPrintFormat statspf = ParsePrintFormat(Option<OutString>(params, "default", o_statspf), (pfextra));
     if (statspf == SRTSTATS_PROFMAT_INVALID)
     {
         cerr << "Invalid stats print format\n";
         return 1;
     }
     transmit_stats_writer = SrtStatsWriterFactory(statspf);
+    if (pfextra != "")
+    {
+        vector<string> options;
+        Split(pfextra, ',', back_inserter(options));
+        for (auto& i: options)
+        {
+            vector<string> klv;
+            Split(i, '=', back_inserter(klv));
+            klv.resize(2);
+            transmit_stats_writer->Option(klv[0], klv[1]);
+        }
+    }
 
     // Options that require integer conversion
     size_t stoptime = Option<OutNumber>(params, "0", o_stoptime);
@@ -822,7 +804,7 @@ int main( int argc, char** argv )
     }
     catch(std::exception& x)
     {
-        if (::int_state)
+        if (::transmit_int_state)
         {
             // The application was terminated by SIGINT or SIGTERM.
             // Don't print anything, just exit gently like ffmpeg.
@@ -836,7 +818,7 @@ int main( int argc, char** argv )
             return 0;
         }
 
-        Verb() << "MEDIA CREATION FAILED: " << x.what() << " - exiting.";
+        Verb("MEDIA CREATION FAILED: ", x.what(), " - exiting.");
 
         // Don't speak anything when no -v option.
         // (the "requested interrupt" will be printed anyway)
@@ -865,10 +847,10 @@ int main( int argc, char** argv )
 
     if (transmit_use_sourcetime && src->uri.type() != UriParser::SRT)
     {
-        Verb() << "WARNING: -st option is effective only if the target type is SRT";
+        Verb("WARNING: -st option is effective only if the target type is SRT");
     }
 
-    Verb() << "STARTING TRANSMISSION: '" << source_spec << "' --> '" << target_spec << "'";
+    Verb("STARTING TRANSMISSION: '", source_spec, "' --> '", target_spec, "'");
 
     // After the time has been spent in the creation
     // (including waiting for connection)
@@ -876,7 +858,7 @@ int main( int argc, char** argv )
     if (stoptime != 0)
     {
         int elapsed = end_time - start_time;
-        int remain = stoptime - elapsed;
+        int remain = int(stoptime) - elapsed;
 
         if (remain <= final_delay)
         {
@@ -894,41 +876,41 @@ int main( int argc, char** argv )
         {
             if (stoptime == 0 && timeout != -1 )
             {
-                Verb() << "[." << VerbNoEOL;
+                Verb("[.", VerbNoEOL);
                 alarm(timeout);
             }
             else
             {
                 alarm(0);
             }
-            Verb() << " << ... " << VerbNoEOL;
+            Verb(", ... ", VerbNoEOL);
             g_interrupt_reason = "reading";
             const MediaPacket& data = src->Read(chunk);
-            Verb() << " << " << data.payload.size() << "  ->  " << VerbNoEOL;
+            Verb(", ", data.payload.size(), "  ->  ", VerbNoEOL);
             if ( data.payload.empty() && src->End() )
             {
-                Verb() << "EOS";
+                Verb("EOS");
                 break;
             }
             g_interrupt_reason = "writing";
             tar->Write(data);
             if (stoptime == 0 && timeout != -1 )
             {
-                Verb() << ".] " << VerbNoEOL;
+                Verb(".] ", VerbNoEOL);
                 alarm(0);
             }
 
             if ( tar->Broken() )
             {
-                Verb() << " OUTPUT broken";
+                Verb(" OUTPUT broken");
                 break;
             }
 
-            Verb() << "sent";
+            Verb("sent");
 
-            if ( int_state )
+            if (::transmit_int_state)
             {
-                Verror() << "\n (interrupted on request)";
+                Verror("\n (interrupted on request)");
                 break;
             }
 
@@ -937,10 +919,10 @@ int main( int argc, char** argv )
             if (stoptime != 0)
             {
                 int elapsed = time(0) - end_time;
-                int remain = stoptime - final_delay - elapsed;
+                int remain = int(stoptime - final_delay - elapsed);
                 if (remain < 0)
                 {
-                    Verror() << "\n (interrupted on timeout: elapsed " << elapsed << "s) - waiting " << final_delay << "s for cleanup";
+                    Verror("\n (interrupted on timeout: elapsed ", elapsed, "s) - waiting ", final_delay, "s for cleanup");
                     this_thread::sleep_for(chrono::seconds(final_delay));
                     break;
                 }
@@ -952,17 +934,17 @@ int main( int argc, char** argv )
 
         if (!skip_flushing)
         {
-            Verror() << "(DEBUG) EOF when reading file. Looping until the sending bufer depletes.\n";
+            Verror("(DEBUG) EOF when reading file. Looping until the sending bufer depletes.\n");
             for (;;)
             {
                 size_t still = tar->Still();
                 if (still == 0)
                 {
-                    Verror() << "(DEBUG) DEPLETED. Done.\n";
+                    Verror("(DEBUG) DEPLETED. Done.\n");
                     break;
                 }
 
-                Verror() << "(DEBUG)... still " << still << " bytes (sleep 1s)\n";
+                Verror("(DEBUG)... still ", still, " bytes (sleep 1s)\n");
                 this_thread::sleep_for(chrono::seconds(1));
             }
         }
@@ -970,16 +952,16 @@ int main( int argc, char** argv )
 
         if (stoptime != 0 && ::timer_state)
         {
-            Verror() << "Exit on timeout.";
+            Verror("Exit on timeout.");
         }
-        else if (::int_state)
+        else if (::transmit_int_state)
         {
-            Verror() << "Exit on interrupt.";
+            Verror("Exit on interrupt.");
             // Do nothing.
         }
         else
         {
-            Verror() << "STD EXCEPTION: " << x.what();
+            Verror("STD EXCEPTION: ", x.what());
         }
 
         if ( crashonx )
@@ -987,7 +969,7 @@ int main( int argc, char** argv )
 
         if (final_delay > 0)
         {
-            Verror() << "Waiting " << final_delay << "s for possible cleanup...";
+            Verror("Waiting ", final_delay, "s for possible cleanup...");
             this_thread::sleep_for(chrono::seconds(final_delay));
         }
         if (stoptime != 0 && ::timer_state)
@@ -997,7 +979,7 @@ int main( int argc, char** argv )
 
     } catch (...) {
 
-        Verror() << "UNKNOWN type of EXCEPTION";
+        Verror("UNKNOWN type of EXCEPTION");
         if ( crashonx )
             throw;
 
@@ -1013,8 +995,14 @@ int main( int argc, char** argv )
 void TestLogHandler(void* opaque, int level, const char* file, int line, const char* area, const char* message)
 {
     char prefix[100] = "";
-    if ( opaque )
-        strncpy(prefix, (char*)opaque, 99);
+    if ( opaque ) {
+#ifdef _MSC_VER
+        strncpy_s(prefix, sizeof(prefix), (char*)opaque, _TRUNCATE);
+#else
+        strncpy(prefix, (char*)opaque, sizeof(prefix) - 1);
+        prefix[sizeof(prefix) - 1] = '\0';
+#endif
+    }
     time_t now;
     time(&now);
     char buf[1024];
diff --git a/testing/srt-test-live.maf b/testing/srt-test-live.maf
index 17368a660..e80d79ec7 100644
--- a/testing/srt-test-live.maf
+++ b/testing/srt-test-live.maf
@@ -4,6 +4,7 @@ SOURCES
 srt-test-live.cpp
 testmedia.cpp
 ../apps/apputil.cpp
+../apps/statswriter.cpp
 ../apps/verbose.cpp
 ../apps/socketoptions.cpp
 ../apps/uriparser.cpp
diff --git a/testing/srt-test-mpbond.cpp b/testing/srt-test-mpbond.cpp
index 3295d401a..157fa9728 100644
--- a/testing/srt-test-mpbond.cpp
+++ b/testing/srt-test-mpbond.cpp
@@ -42,6 +42,10 @@
 
 srt_logging::Logger applog(SRT_LOGFA_APP, srt_logger_config, "srt-mpbond");
 
+using namespace srt;
+using namespace std;
+
+
 volatile bool mpbond_int_state = false;
 void OnINT_SetIntState(int)
 {
@@ -49,9 +53,6 @@ void OnINT_SetIntState(int)
     mpbond_int_state = true;
 }
 
-
-
-
 int main( int argc, char** argv )
 {
     // This is mainly required on Windows to initialize the network system,
@@ -188,10 +189,7 @@ int main( int argc, char** argv )
 
         SRTSOCKET s = srt_create_socket();
 
-        //SRT_GROUPCONNTYPE gcon = SRTGC_GROUPONLY;
-        int gcon = 1;
-        srt_setsockflag(s, SRTO_GROUPCONNECT, &gcon, sizeof gcon);
-
+        srt::setopt(s)[SRTO_GROUPCONNECT] = 1;
         srt_bind(s, sa.get(), sizeof sa);
         srt_listen(s, 5);
 
@@ -201,14 +199,13 @@ int main( int argc, char** argv )
 
     Verb() << "] accept...";
 
-    SRTSOCKET conngrp = srt_accept_bond(listeners.data(), listeners.size(), -1);
+    SRTSOCKET conngrp = srt_accept_bond(listeners.data(), int(listeners.size()), -1);
     if (conngrp == SRT_INVALID_SOCK)
     {
         cerr << "ERROR: srt_accept_bond: " << srt_getlasterror_str() << endl;
         return 1;
     }
 
-    auto s = new SrtSource;
     unique_ptr<Source> src;
     unique_ptr<Target> tar;
 
@@ -221,6 +218,7 @@ int main( int argc, char** argv )
             Verb() << "SRT -> " << outspec;
             tar = Target::Create(outspec);
 
+            auto s = new SrtSource;
             s->Acquire(conngrp);
             src.reset(s);
         }
diff --git a/testing/srt-test-multiplex.cpp b/testing/srt-test-multiplex.cpp
index 2b6b2b2af..857557a5c 100644
--- a/testing/srt-test-multiplex.cpp
+++ b/testing/srt-test-multiplex.cpp
@@ -76,7 +76,7 @@ struct MediumPair
     bytevector initial_portion;
     string name;
 
-    MediumPair(unique_ptr<Source> s, unique_ptr<Target> t): src(move(s)), tar(move(t)) {}
+    MediumPair(unique_ptr<Source> s, unique_ptr<Target> t): src(std::move(s)), tar(std::move(t)) {}
 
     void Stop()
     {
@@ -154,14 +154,14 @@ struct MediumPair
                 applog.Note() << sout.str();
             }
         }
-        catch (Source::ReadEOF& x)
+        catch (const Source::ReadEOF&)
         {
             applog.Note() << "EOS - closing media for loop: " << name;
             src->Close();
             tar->Close();
             applog.Note() << "CLOSED: " << name;
         }
-        catch (std::runtime_error& x)
+        catch (const std::runtime_error& x)
         {
             applog.Note() << "INTERRUPTED: " << x.what();
             src->Close();
@@ -190,13 +190,13 @@ class MediaBase
     ///        are still meant to be delivered to @c tar
     MediumPair& Link(std::unique_ptr<Source> src, std::unique_ptr<Target> tar, bytevector&& initial_portion, string name, string thread_name)
     {
-        media.emplace_back(move(src), move(tar));
+        media.emplace_back(std::move(src), std::move(tar));
         MediumPair& med = media.back();
-        med.initial_portion = move(initial_portion);
+        med.initial_portion = std::move(initial_portion);
         med.name = name;
 
         // Ok, got this, so we can start transmission.
-        ThreadName tn(thread_name.c_str());
+        srt::ThreadName tn(thread_name);
 
         med.runner = thread( [&med]() { med.TransmissionLoop(); });
         return med;
@@ -313,7 +313,7 @@ bool PrepareStreamNames(const map<string,vector<string>>& params, bool mode_outp
     return true;
 }
 
-bool SelectAndLink(SrtModel& m, string id, bool mode_output)
+bool SelectAndLink(SrtModel& m, string id, bool mode_output, string& w_msg)
 {
     // So, we have made a connection that is now contained in m.
     // For that connection we need to select appropriate stream
@@ -331,6 +331,7 @@ bool SelectAndLink(SrtModel& m, string id, bool mode_output)
     {
         // No medium available for that stream, ignore it.
         m.Close();
+        w_msg = "No medium available for that stream";
         return false;
     }
 
@@ -345,13 +346,19 @@ bool SelectAndLink(SrtModel& m, string id, bool mode_output)
 
     if ( mode_output )
     {
+        target = Target::Create(medium);
+        if (!target)
+        {
+            m.Close();
+            w_msg = "Unable to create target medium: " + medium;
+            return false;
+        }
+
         // Create Source out of SrtModel and Target from the given medium
         auto s = new SrtSource();
         s->StealFrom(m);
         source.reset(s);
 
-        target = Target::Create(medium);
-
         os << m.m_host << ":" << m.m_port << "[" << id << "]%" << sock << "  ->  " << medium;
         thread_name = "TL>" + medium;
     }
@@ -359,6 +366,13 @@ bool SelectAndLink(SrtModel& m, string id, bool mode_output)
     {
         // Create Source of given medium and Target of SrtModel.
         source = Source::Create(medium);
+        if (!source)
+        {
+            m.Close();
+            w_msg = "Unable to create source medium: " + medium;
+            return false;
+        }
+
         auto t = new SrtTarget();
         t->StealFrom(m);
         target.reset(t);
@@ -368,7 +382,7 @@ bool SelectAndLink(SrtModel& m, string id, bool mode_output)
     }
 
     bytevector dummy_initial_portion;
-    g_media_base.Link(move(source), move(target), move(dummy_initial_portion), os.str(), thread_name);
+    g_media_base.Link(std::move(source), std::move(target), std::move(dummy_initial_portion), os.str(), thread_name);
 
     return true;
 }
@@ -389,7 +403,7 @@ void Stall()
             ++i_next;
             if (i->has_quit)
             {
-                Verb() << "Found QUIT mediumpair: " << i->name << " - removing from base";
+                Verb("Found QUIT mediumpair: ", i->name, " - removing from base");
                 i->Stop();
                 g_media_base.media.erase(i);
             }
@@ -397,7 +411,7 @@ void Stall()
 
         if (g_media_base.media.empty())
         {
-            Verb() << "All media have quit. Marking exit.";
+            Verb("All media have quit. Marking exit.");
             break;
         }
     }
@@ -464,11 +478,15 @@ int main( int argc, char** argv )
         }
     } cleanupobj;
 
-    // Check options
+    const OptionName
+        o_loglevel = { "ll", "loglevel" },
+        o_input    = { "i" },
+        o_output   = { "o" };
+
     vector<OptionScheme> optargs = {
-        { {"ll", "loglevel"}, OptionScheme::ARG_ONE },
-        { {"i"}, OptionScheme::ARG_VAR },
-        { {"o"}, OptionScheme::ARG_VAR }
+        { o_loglevel, OptionScheme::ARG_ONE },
+        { o_input,    OptionScheme::ARG_VAR },
+        { o_output,   OptionScheme::ARG_VAR }
     };
 
     map<string, vector<string>> params = ProcessOptions(argv, argc, optargs);
@@ -573,7 +591,7 @@ int main( int argc, char** argv )
 
     SrtModel m(up.host(), iport, up.parameters());
 
-    ThreadName::set("main");
+    srt::ThreadName::set("main");
 
     // Note: for input, there must be an exactly defined
     // number of sources. The loop rolls up to all these sources.
@@ -603,15 +621,20 @@ int main( int argc, char** argv )
             // the local resource of this id, and if this failed, simply
             // close the stream and ignore it.
 
+            string msg;
             // Select medium from parameters.
-            if (SelectAndLink(m, id, mode_output))
+            if (SelectAndLink((m), id, mode_output, (msg)))
             {
                 ids.erase(id);
                 if (ids.empty())
                     break;
             }
+            else
+            {
+                applog.Error() << "Unable to select a link for id=" << id << ": " << msg;
+            }
 
-            ThreadName::set("main");
+            srt::ThreadName::set("main");
         }
 
         applog.Note() << "All local stream definitions covered. Waiting for interrupt/broken all connections.";
diff --git a/testing/srt-test-relay.cpp b/testing/srt-test-relay.cpp
index 141bb8e83..912af555e 100755
--- a/testing/srt-test-relay.cpp
+++ b/testing/srt-test-relay.cpp
@@ -15,6 +15,7 @@ written by
 
 #include "platform_sys.h"
 
+#include <atomic>
 #include <iostream>
 #include <iterator>
 #include <vector>
@@ -32,6 +33,8 @@ written by
 #include <srt.h>
 #include <udt.h>
 
+#include "testactivemedia.hpp"
+
 #include "apputil.hpp"
 #include "uriparser.hpp"
 #include "logsupport.hpp"
@@ -41,13 +44,16 @@ written by
 #include "testmedia.hpp"
 #include "threadname.h"
 
+
+using namespace std;
+
+
 bool Upload(UriParser& srt, UriParser& file);
 bool Download(UriParser& srt, UriParser& file);
 
 srt_logging::Logger applog(SRT_LOGFA_APP, srt_logger_config, "srt-relay");
 
-volatile bool g_program_interrupted = false;
-volatile bool g_program_established = false;
+std::atomic<bool> g_program_established {false};
 
 SrtModel* g_pending_model = nullptr;
 
@@ -56,7 +62,7 @@ thread::id g_root_thread = std::this_thread::get_id();
 static void OnINT_SetInterrupted(int)
 {
     Verb() << VerbLock << "SIGINT: Setting interrupt state.";
-    ::g_program_interrupted = true;
+    ::transmit_int_state = true;
 
     // Just for a case, forcefully close all active SRT sockets.
     SrtModel* pm = ::g_pending_model;
@@ -83,168 +89,10 @@ static void OnINT_SetInterrupted(int)
 
 using namespace std;
 
-template <class VarType, class ValType>
-struct OnReturnSetter
-{
-    VarType& var;
-    ValType value;
-
-    OnReturnSetter(VarType& target, ValType v): var(target), value(v) {}
-    ~OnReturnSetter() { var = value; }
-};
-
-template <class VarType, class ValType>
-OnReturnSetter<VarType, ValType> OnReturnSet(VarType& target, ValType v)
-{ return OnReturnSetter<VarType, ValType>(target, v); }
-
-template<class MediumDir>
-struct Medium
-{
-    class SrtMainLoop* master = nullptr;
-    MediumDir* med = nullptr;
-    unique_ptr<MediumDir> pinned_med;
-    list<MediaPacket> buffer;
-    mutex buffer_lock;
-    thread thr;
-    condition_variable ready;
-    volatile bool running = false;
-    std::exception_ptr xp; // To catch exception thrown by a thread
-
-    virtual void Runner() = 0;
-
-    void RunnerBase()
-    {
-        try
-        {
-            Runner();
-        }
-        catch (...)
-        {
-            xp = std::current_exception();
-        }
-
-        //Verb() << "Medium: " << this << ": thread exit";
-        unique_lock<mutex> g(buffer_lock);
-        running = false;
-        ready.notify_all();
-        //Verb() << VerbLock << "Medium: EXIT NOTIFIED";
-    }
-
-    void run()
-    {
-        running = true;
-        std::ostringstream tns;
-        tns << typeid(*this).name() << ":" << this;
-        ThreadName tn(tns.str().c_str());
-        thr = thread( [this] { RunnerBase(); } );
-    }
-
-    void quit()
-    {
-        if (!med)
-            return;
-
-        applog.Debug() << "Medium(" << typeid(*med).name() << ") quit. Buffer contains " << buffer.size() << " blocks";
-
-        string name;
-        if (Verbose::on)
-            name = typeid(*med).name();
-
-        med->Close();
-        if (thr.joinable())
-        {
-            applog.Debug() << "Medium::quit: Joining medium thread (" << name << ") ...";
-            thr.join();
-            applog.Debug() << "... done";
-        }
-
-        if (xp)
-        {
-            try {
-                std::rethrow_exception(xp);
-            } catch (TransmissionError& e) {
-                if (Verbose::on)
-                    Verb() << VerbLock << "Medium " << this << " exited with Transmission Error:\n\t" << e.what();
-                else
-                    cerr << "Transmission Error: " << e.what() << endl;
-            } catch (...) {
-                if (Verbose::on)
-                    Verb() << VerbLock << "Medium " << this << " exited with UNKNOWN EXCEPTION:";
-                else
-                    cerr << "UNKNOWN EXCEPTION on medium\n";
-            }
-        }
-
-        // Prevent further quits from running
-        med = nullptr;
-    }
-
-    void Setup(SrtMainLoop* mst, MediumDir* t)
-    {
-        med = t;
-        master = mst;
-        // Leave pinned_med as 0
-    }
-
-    void Setup(SrtMainLoop* mst, unique_ptr<MediumDir>&& medbase)
-    {
-        pinned_med = move(medbase);
-        med = pinned_med.get();
-        master = mst;
-    }
-
-    virtual ~Medium()
-    {
-        //Verb() << "Medium: " << this << " DESTROYED. Threads quit.";
-        quit();
-    }
-};
-
 size_t g_chunksize = 0;
 size_t g_default_live_chunksize = 1316;
 size_t g_default_file_chunksize = 1456;
 
-struct SourceMedium: Medium<Source>
-{
-    // Source Runner: read payloads and put on the buffer
-    void Runner() override;
-
-    // External user: call this to get the buffer.
-    MediaPacket Extract();
-};
-
-struct TargetMedium: Medium<Target>
-{
-    void Runner() override;
-
-    bool Schedule(const MediaPacket& data)
-    {
-        lock_guard<mutex> lg(buffer_lock);
-        if (!running || ::g_program_interrupted)
-            return false;
-
-        applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): [" << data.payload.size() << "] CLIENT -> BUFFER";
-        buffer.push_back(data);
-        ready.notify_one();
-        return true;
-    }
-
-    void Interrupt()
-    {
-        lock_guard<mutex> lg(buffer_lock);
-        running = false;
-        ready.notify_one();
-    }
-
-    ~TargetMedium()
-    {
-        //Verb() << "TargetMedium: DESTROYING";
-        Interrupt();
-        // ~Medium will do quit() additionally, which joins the thread
-    }
-
-};
-
 class SrtMainLoop
 {
     UriParser m_srtspec;
@@ -258,7 +106,7 @@ class SrtMainLoop
     std::exception_ptr m_input_xp;
 
     void InputRunner();
-    volatile bool m_input_running = false;
+    srt::sync::atomic<bool> m_input_running;
 
 public:
     SrtMainLoop(const string& srt_uri, bool input_echoback, const string& input_spec, const vector<string>& output_spec);
@@ -275,140 +123,6 @@ class SrtMainLoop
     }
 };
 
-
-void SourceMedium::Runner()
-{
-    ThreadName::set("SourceRN");
-    if (!master)
-    {
-        cerr << "IPE: incorrect setup, master empty\n";
-        return;
-    }
-
-    /* Don't stop me now...
-    struct OnReturn
-    {
-        SrtMainLoop* m;
-        OnReturn(SrtMainLoop* mst): m(mst) {}
-        ~OnReturn()
-        {
-            m->MakeStop();
-        }
-    } on_return(master);
-    */
-
-    Verb() << VerbLock << "Starting SourceMedium: " << this;
-    for (;;)
-    {
-        auto input = med->Read(g_chunksize);
-        if (input.payload.empty() && med->End())
-        {
-            Verb() << VerbLock << "Exiting SourceMedium: " << this;
-            return;
-        }
-        applog.Debug() << "SourceMedium(" << typeid(*med).name() << "): [" << input.payload.size() << "] MEDIUM -> BUFFER. signal(" << &ready << ")";
-
-        lock_guard<mutex> g(buffer_lock);
-        buffer.push_back(input);
-        ready.notify_one();
-    }
-}
-
-MediaPacket SourceMedium::Extract()
-{
-    if (!master)
-        return {};
-
-    unique_lock<mutex> g(buffer_lock);
-    for (;;)
-    {
-        if (!buffer.empty())
-        {
-            MediaPacket top;
-            swap(top, *buffer.begin());
-            buffer.pop_front();
-            applog.Debug() << "SourceMedium(" << typeid(*med).name() << "): [" << top.payload.size() << "] BUFFER -> CLIENT";
-            return top;
-        }
-        else
-        {
-            // Don't worry about the media status as long as you have somthing in the buffer.
-            // Purge the buffer first, then worry about the other things.
-            if (!running || ::g_program_interrupted)
-            {
-                applog.Debug() << "Extract(" << typeid(*med).name() << "): INTERRUPTED READING ("
-                                                                                << (!running ? "local" : (!master->IsRunning() ? "master" : "unknown")) << ")";
-                //Verb() << "SourceMedium " << this << " not running";
-                return {};
-            }
-
-        }
-
-        // Block until ready
-        applog.Debug() << "Extract(" << typeid(*med).name() << "): " << this << " wait(" << &ready << ") -->";
-        ready.wait_for(g, chrono::seconds(1), [this] { return running && master->IsRunning() && !buffer.empty(); });
-        applog.Debug() << "Extract(" << typeid(*med).name() << "): " << this << " <-- notified (running:"
-            << boolalpha << running << " master:" << master->IsRunning() << " buffer:" << buffer.size() << ")";
-    }
-}
-
-void TargetMedium::Runner()
-{
-    ThreadName::set("TargetRN");
-    auto on_return_set = OnReturnSet(running, false);
-    Verb() << VerbLock << "Starting TargetMedium: " << this;
-    for (;;)
-    {
-        MediaPacket val;
-        {
-            unique_lock<mutex> lg(buffer_lock);
-            if (buffer.empty())
-            {
-                if (!running)
-                {
-                    applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): buffer empty, medium stopped, exiting.";
-                    return;
-                }
-
-                bool gotsomething = ready.wait_for(lg, chrono::seconds(1), [this] { return !running || !buffer.empty(); } );
-                applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): [" << val.payload.size() << "] BUFFER update (timeout:"
-                                << boolalpha << gotsomething << " running: " << running << ")";
-                if (::g_program_interrupted || !running || !med || med->Broken())
-                {
-                    applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): buffer empty, medium "
-                                   << (!::g_program_interrupted ?
-                                           (running ?
-                                                (med ?
-                                                    (med->Broken() ? "broken" : "UNKNOWN")
-                                                : "deleted")
-                                           : "stopped")
-                                      : "killed");
-                    return;
-                }
-                if (!gotsomething) // exit on timeout
-                    continue;
-            }
-            swap(val, *buffer.begin());
-            applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): [" << val.payload.size() << "] BUFFER extraction";
-
-            buffer.pop_front();
-        }
-
-        // Check before writing
-        if (med->Broken())
-        {
-            applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): [" << val.payload.size() << "] BUFFER -> DISCARDED (medium broken)";
-            running = false;
-            return;
-        }
-
-        applog.Debug() << "TargetMedium(" << typeid(*med).name() << "): [" << val.payload.size() << "] BUFFER -> MEDIUM";
-        // You get the data to send, send them.
-        med->Write(val);
-    }
-}
-
-
 int main( int argc, char** argv )
 {
     OptionName
@@ -605,8 +319,8 @@ SrtMainLoop::SrtMainLoop(const string& srt_uri, bool input_echoback, const strin
     {
         Verb() << "Setting up output: " << spec;
         unique_ptr<TargetMedium> m { new TargetMedium };
-        m->Setup(this, Target::Create(spec));
-        m_output_media.push_back(move(m));
+        m->Setup(Target::Create(spec));
+        m_output_media.push_back(std::move(m));
     }
 
 
@@ -631,14 +345,7 @@ SrtMainLoop::SrtMainLoop(const string& srt_uri, bool input_echoback, const strin
     Verb() << "... Established. configuring other pipes:";
 
     // Once it's ready, use it to initialize the medium.
-
-    m_srt_relay.reset(new SrtRelay);
-    m_srt_relay->StealFrom(m);
-
-    m_srt_source.Setup(this, m_srt_relay.get());
-
     bool file_mode = (transtype == "file");
-
     if (g_chunksize == 0)
     {
         if (file_mode)
@@ -649,15 +356,20 @@ SrtMainLoop::SrtMainLoop(const string& srt_uri, bool input_echoback, const strin
         Verb() << "DEFAULT CHUNKSIZE used: " << g_chunksize;
     }
 
+    m_srt_relay.reset(new SrtRelay);
+    m_srt_relay->StealFrom(m);
+
+    m_srt_source.Setup(m_srt_relay.get(), g_chunksize);
+
     // Now check the input medium
     if (input_echoback)
     {
         Verb() << "SRT set up as input source and the first output target";
 
         // Add SRT medium to output targets, and keep input medium empty.
-        unique_ptr<TargetMedium> m { new TargetMedium };
-        m->Setup(this, m_srt_relay.get());
-        m_output_media.push_back(move(m));
+        unique_ptr<TargetMedium> med { new TargetMedium };
+        med->Setup(m_srt_relay.get());
+        m_output_media.push_back(std::move(med));
     }
     else
     {
@@ -665,7 +377,7 @@ SrtMainLoop::SrtMainLoop(const string& srt_uri, bool input_echoback, const strin
         // to the output list, as this will be fed directly
         // by the data from this input medium in a spearate engine.
         Verb() << "Setting up input: " << input_spec;
-        m_input_medium.Setup(this, Source::Create(input_spec));
+        m_input_medium.Setup(Source::Create(input_spec), g_chunksize);
 
         if (!file_mode)
         {
@@ -681,7 +393,7 @@ SrtMainLoop::SrtMainLoop(const string& srt_uri, bool input_echoback, const strin
 
 void SrtMainLoop::InputRunner()
 {
-    ThreadName::set("InputRN");
+    srt::ThreadName::set("InputRN");
     // An extra thread with a loop that reads from the external input
     // and writes into the SRT medium. When echoback mode is used,
     // this thread isn't started at all and instead the SRT reading
@@ -727,7 +439,7 @@ void SrtMainLoop::run()
 
         std::ostringstream tns;
         tns << "Input:" << this;
-        ThreadName tn(tns.str().c_str());
+        srt::ThreadName tn(tns.str());
         m_input_thr = thread([this] {
                 try {
                     InputRunner();
@@ -796,6 +508,11 @@ void SrtMainLoop::run()
     }
 
     Verb() << "MEDIA LOOP EXIT";
+    for (auto& m : m_output_media)
+    {
+        m->quit();
+    }
+    m_input_medium.quit();
     m_srt_source.quit();
 
     if (m_input_xp)
diff --git a/testing/srt-test-relay.maf b/testing/srt-test-relay.maf
index b1b22afb2..33cba8173 100644
--- a/testing/srt-test-relay.maf
+++ b/testing/srt-test-relay.maf
@@ -3,6 +3,7 @@
 SOURCES
 srt-test-relay.cpp
 testmedia.cpp
+testactivemedia.cpp
 ../apps/apputil.cpp
 ../apps/verbose.cpp
 ../apps/socketoptions.cpp
diff --git a/testing/testactivemedia.cpp b/testing/testactivemedia.cpp
new file mode 100644
index 000000000..dd0393ea6
--- /dev/null
+++ b/testing/testactivemedia.cpp
@@ -0,0 +1,139 @@
+
+#include "testactivemedia.hpp"
+
+using namespace std;
+
+
+void SourceMedium::Runner()
+{
+    srt::ThreadName::set("SourceRN");
+
+    Verb() << VerbLock << "Starting SourceMedium: " << this;
+    for (;;)
+    {
+        auto input = med->Read(chunksize_);
+        if (input.payload.empty() && med->End())
+        {
+            Verb() << VerbLock << "Exiting SourceMedium: " << this;
+            return;
+        }
+        LOGP(applog.Debug, "SourceMedium(", typeid(*med).name(), "): [", input.payload.size(), "] MEDIUM -> BUFFER. signal(", &ready, ")");
+
+        lock_guard<std::mutex> g(buffer_lock);
+        buffer.push_back(input);
+        ready.notify_one();
+    }
+}
+
+MediaPacket SourceMedium::Extract()
+{
+    unique_lock<std::mutex> g(buffer_lock);
+    for (;;)
+    {
+        if (::transmit_int_state)
+            running = false;
+
+        if (!buffer.empty())
+        {
+            MediaPacket top;
+            swap(top, *buffer.begin());
+            buffer.pop_front();
+            LOGP(applog.Debug, "SourceMedium(", typeid(*med).name(), "): [", top.payload.size(), "] BUFFER -> CLIENT");
+            return top;
+        }
+        else
+        {
+            // Don't worry about the media status as long as you have somthing in the buffer.
+            // Purge the buffer first, then worry about the other things.
+            if (!running)
+            {
+                //LOGP(applog.Debug, "Extract(", typeid(*med).name(), "): INTERRUPTED READING");
+                //Verb() << "SourceMedium " << this << " not running";
+                return {};
+            }
+
+        }
+
+        // Block until ready
+        //LOGP(applog.Debug, "Extract(", typeid(*med).name(), "): ", this, " wait(", &ready, ") -->");
+
+        ready.wait_for(g, chrono::seconds(1), [this] { return running && !buffer.empty(); });
+
+        // LOGP(applog.Debug, "Extract(", typeid(*med).name(), "): ", this, " <-- notified (running:"
+        //     << boolalpha << running << " buffer:" << buffer.size() << ")");
+    }
+}
+
+void TargetMedium::Runner()
+{
+    srt::ThreadName::set("TargetRN");
+    auto on_return_set = OnReturnSet(running, false);
+    Verb() << VerbLock << "Starting TargetMedium: " << this;
+    for (;;)
+    {
+        MediaPacket val;
+        {
+            unique_lock<std::mutex> lg(buffer_lock);
+            if (buffer.empty())
+            {
+                if (!running)
+                {
+                    //LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): buffer empty, medium stopped, exiting.");
+                    return;
+                }
+
+                bool gotsomething = ready.wait_for(lg, chrono::seconds(1), [this] { return !running || !buffer.empty(); } );
+                LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): [", val.payload.size(), "] BUFFER update (timeout:",
+                        boolalpha, gotsomething, " running: ", running, ")");
+                if (::transmit_int_state || !running || !med || med->Broken())
+                {
+                    LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): buffer empty, medium ",
+                                   (!::transmit_int_state ?
+                                           (running ?
+                                                (med ?
+                                                    (med->Broken() ? "broken" : "UNKNOWN")
+                                                : "deleted")
+                                           : "stopped")
+                                      : "killed"));
+                    return;
+                }
+                if (!gotsomething) // exit on timeout
+                    continue;
+            }
+            swap(val, *buffer.begin());
+            LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): [", val.payload.size(), "] BUFFER extraction");
+
+            buffer.pop_front();
+        }
+
+        // Check before writing
+        if (med->Broken())
+        {
+            LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): [", val.payload.size(), "] BUFFER -> DISCARDED (medium broken)");
+            running = false;
+            return;
+        }
+
+        LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): [", val.payload.size(), "] BUFFER -> MEDIUM");
+        // You get the data to send, send them.
+        med->Write(val);
+    }
+}
+
+bool TargetMedium::Schedule(const MediaPacket& data)
+{
+    LOGP(applog.Debug, "TargetMedium::Schedule LOCK ... ");
+    std::lock_guard<std::mutex> lg(buffer_lock);
+    LOGP(applog.Debug, "TargetMedium::Schedule LOCKED - checking: running=", running, " interrupt=", ::transmit_int_state);
+    if (!running || ::transmit_int_state)
+    {
+        LOGP(applog.Debug, "TargetMedium::Schedule: not running, discarding packet");
+        return false;
+    }
+
+    LOGP(applog.Debug, "TargetMedium(", typeid(*med).name(), "): Schedule: [", data.payload.size(), "] CLIENT -> BUFFER");
+    buffer.push_back(data);
+    ready.notify_one();
+    return true;
+}
+
diff --git a/testing/testactivemedia.hpp b/testing/testactivemedia.hpp
new file mode 100644
index 000000000..e92abbe0c
--- /dev/null
+++ b/testing/testactivemedia.hpp
@@ -0,0 +1,172 @@
+#include <string>
+#include <sstream>
+#include <vector>
+#include <list>
+#include <memory>
+#include <exception>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
+#include "testmedia.hpp"
+#include "logsupport.hpp"
+
+#define SRT_ENABLE_VERBOSE_LOCK 1
+#include "verbose.hpp"
+
+#include "logging.h"
+#include "threadname.h"
+
+extern srt_logging::Logger applog;
+
+template<class MediumDir>
+struct Medium
+{
+    MediumDir* med = nullptr;
+    std::unique_ptr<MediumDir> pinned_med;
+    std::list<MediaPacket> buffer;
+    std::mutex buffer_lock;
+    std::thread thr;
+    std::condition_variable ready;
+    srt::sync::atomic<bool> running {false};
+    std::exception_ptr xp; // To catch exception thrown by a thread
+
+    virtual void Runner() = 0;
+
+    void RunnerBase()
+    {
+        try
+        {
+            running = true;
+            Runner();
+        }
+        catch (...)
+        {
+            xp = std::current_exception();
+        }
+
+        //Verb() << "Medium: " << this << ": thread exit";
+        std::unique_lock<std::mutex> g(buffer_lock);
+        running = false;
+        ready.notify_all();
+        //Verb() << VerbLock << "Medium: EXIT NOTIFIED";
+    }
+
+    void run()
+    {
+        running = true;
+        std::ostringstream tns;
+        tns << typeid(*this).name() << ":" << this;
+        srt::ThreadName tn(tns.str());
+        thr = std::thread( [this] { RunnerBase(); } );
+    }
+
+    void quit()
+    {
+        if (!med)
+            return;
+
+        LOGP(applog.Debug, "Medium(", typeid(*med).name(), ") quit. Buffer contains ", buffer.size(), " blocks");
+
+        std::string name;
+        if (Verbose::on)
+            name = typeid(*med).name();
+
+        med->Close();
+        if (thr.joinable())
+        {
+            LOGP(applog.Debug, "Medium::quit: Joining medium thread (", name, ") ...");
+            thr.join();
+            LOGP(applog.Debug, "... done");
+        }
+
+        if (xp)
+        {
+            try {
+                std::rethrow_exception(xp);
+            } catch (TransmissionError& e) {
+                if (Verbose::on)
+                    Verb() << VerbLock << "Medium " << this << " exited with Transmission Error:\n\t" << e.what();
+                else
+                    std::cerr << "Transmission Error: " << e.what() << std::endl;
+            } catch (...) {
+                if (Verbose::on)
+                    Verb() << VerbLock << "Medium " << this << " exited with UNKNOWN EXCEPTION:";
+                else
+                    std::cerr << "UNKNOWN EXCEPTION on medium\n";
+            }
+        }
+
+        // Prevent further quits from running
+        med = nullptr;
+    }
+
+    void Setup(MediumDir* t)
+    {
+        med = t;
+        // Leave pinned_med as 0
+    }
+
+    void Setup(std::unique_ptr<MediumDir>&& medbase)
+    {
+        pinned_med = std::move(medbase);
+        med = pinned_med.get();
+    }
+
+    virtual ~Medium()
+    {
+        //Verb() << "Medium: " << this << " DESTROYED. Threads quit.";
+        quit();
+    }
+
+    virtual void Start() { run(); }
+    virtual void Stop() { quit(); }
+};
+
+struct SourceMedium: Medium<Source>
+{
+    size_t chunksize_ = 0;
+    typedef Medium<Source> Base;
+
+    // Source Runner: read payloads and put on the buffer
+    void Runner() override;
+
+    // External user: call this to get the buffer.
+    MediaPacket Extract();
+
+    template<class Arg>
+    void Setup(Arg&& medium, size_t chunksize)
+    {
+        chunksize_ = chunksize;
+        return Base::Setup(std::move(medium));
+    }
+};
+
+struct TargetMedium: Medium<Target>
+{
+    void Runner() override;
+
+    bool Schedule(const MediaPacket& data);
+
+    void Clear()
+    {
+        std::lock_guard<std::mutex> lg(buffer_lock);
+        buffer.clear();
+    }
+
+    void Interrupt()
+    {
+        std::lock_guard<std::mutex> lg(buffer_lock);
+        running = false;
+        ready.notify_one();
+    }
+
+    ~TargetMedium()
+    {
+        //Verb() << "TargetMedium: DESTROYING";
+        Interrupt();
+        // ~Medium will do quit() additionally, which joins the thread
+    }
+};
+
+
diff --git a/testing/testmedia.cpp b/testing/testmedia.cpp
index 03584d414..a7eb0541c 100755
--- a/testing/testmedia.cpp
+++ b/testing/testmedia.cpp
@@ -41,14 +41,16 @@
 #include "verbose.hpp"
 
 using namespace std;
+using namespace srt;
 
 using srt_logging::KmStateStr;
 using srt_logging::SockStatusStr;
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 using srt_logging::MemberStatusStr;
 #endif
 
-volatile bool transmit_throw_on_interrupt = false;
+srt::sync::atomic<bool> transmit_throw_on_interrupt {false};
+srt::sync::atomic<bool> transmit_int_state {false};
 int transmit_bw_report = 0;
 unsigned transmit_stats_report = 0;
 size_t transmit_chunk_size = SRT_LIVE_DEF_PLSIZE;
@@ -130,10 +132,6 @@ class FileSource: public virtual Source
     //~FileSource() { ifile.close(); }
 };
 
-#ifdef PLEASE_LOG
-#include "logging.h"
-#endif
-
 class FileTarget: public virtual Target
 {
     ofstream ofile;
@@ -145,7 +143,7 @@ class FileTarget: public virtual Target
     {
         ofile.write(data.payload.data(), data.payload.size());
 #ifdef PLEASE_LOG
-        applog.Debug() << "FileTarget::Write: " << data.size() << " written to a file";
+        applog.Debug() << "FileTarget::Write: " << data.payload.size() << " written to a file";
 #endif
     }
 
@@ -221,7 +219,7 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
 
         path = path.substr(2);
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         if (path == "group")
         {
             // Group specified, check type.
@@ -349,7 +347,7 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
                 }
 
                 cc.token = token++;
-                m_group_nodes.push_back(move(cc));
+                m_group_nodes.push_back(std::move(cc));
             }
 
             par.erase("type");
@@ -364,6 +362,24 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
 #endif
     }
 
+    if (par.count("bind"))
+    {
+        string bindspec = par.at("bind");
+        UriParser u (bindspec, UriParser::EXPECT_HOST);
+        if ( u.scheme() != ""
+                || u.path() != ""
+                || !u.parameters().empty()
+                || u.portno() == 0)
+        {
+            Error("Invalid syntax in 'bind' option");
+        }
+
+        if (u.host() != "")
+            par["adapter"] = u.host();
+        par["port"] = u.port();
+        par.erase("bind");
+    }
+
     string adapter;
     if (par.count("adapter"))
     {
@@ -454,7 +470,7 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
         string v = par["minversion"];
         if (v.find('.') != string::npos)
         {
-            int version = SrtParseVersion(v.c_str());
+            int version = srt::SrtParseVersion(v.c_str());
             if (version == 0)
             {
                 throw std::runtime_error(Sprint("Value for 'minversion' doesn't specify a valid version: ", v));
@@ -530,8 +546,15 @@ void SrtCommon::AcceptNewClient()
 
         int len = 2;
         SRTSOCKET ready[2];
-        if (srt_epoll_wait(srt_conn_epoll, 0, 0, ready, &len, -1, 0, 0, 0, 0) == -1)
+        while (srt_epoll_wait(srt_conn_epoll, 0, 0, ready, &len, 1000, 0, 0, 0, 0) == -1)
+        {
+            if (::transmit_int_state)
+                Error("srt_epoll_wait for srt_accept: interrupt");
+
+            if (srt_getlasterror(NULL) == SRT_ETIMEOUT)
+                continue;
             Error("srt_epoll_wait(srt_conn_epoll)");
+        }
 
         Verb() << "[EPOLL: " << len << " sockets] " << VerbNoEOL;
     }
@@ -545,21 +568,14 @@ void SrtCommon::AcceptNewClient()
         Error("srt_accept");
     }
 
-    /// TESTING
-    //srt_close(m_bindsock);
-
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     if (m_sock & SRTGROUP_MASK)
     {
         m_listener_group = true;
         if (m_group_config != "")
         {
-            int stat = srt_group_configure(m_sock, m_group_config.c_str());
-            if (stat == SRT_ERROR)
-            {
-                // Don't break the connection basing on this, just ignore.
-                Verb() << " (error setting config: '" << m_group_config << "') " << VerbNoEOL;
-            }
+            // Don't break the connection basing on this, just ignore.
+            Verb() << " (ignoring setting group config: '" << m_group_config << "') " << VerbNoEOL;
         }
         // There might be added a poller, remove it.
         // We need it work different way.
@@ -622,7 +638,7 @@ static string PrintEpollEvent(int events, int et_events)
     };
 
     ostringstream os;
-    int N = Size(namemap);
+    int N = (int)Size(namemap);
 
     for (int i = 0; i < N; ++i)
     {
@@ -663,7 +679,7 @@ void SrtCommon::Init(string host, int port, string path, map<string,string> par,
             {
                 OpenClient(host, port);
             }
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
             else
             {
                 OpenGroupClient(); // Source data are in the fields already.
@@ -714,16 +730,19 @@ void SrtCommon::Init(string host, int port, string path, map<string,string> par,
         bool blocking_snd = false, blocking_rcv = false;
         int dropdelay = 0;
         int size_int = sizeof (int), size_int64 = sizeof (int64_t), size_bool = sizeof (bool);
+        char packetfilter[100] = "";
+        int packetfilter_size = 100;
 
         srt_getsockflag(m_sock, SRTO_MAXBW, &bandwidth, &size_int64);
         srt_getsockflag(m_sock, SRTO_RCVLATENCY, &latency, &size_int);
         srt_getsockflag(m_sock, SRTO_RCVSYN, &blocking_rcv, &size_bool);
         srt_getsockflag(m_sock, SRTO_SNDSYN, &blocking_snd, &size_bool);
         srt_getsockflag(m_sock, SRTO_SNDDROPDELAY, &dropdelay, &size_int);
+        srt_getsockflag(m_sock, SRTO_PACKETFILTER, (packetfilter), (&packetfilter_size));
 
         Verb() << "OPTIONS: maxbw=" << bandwidth << " rcvlatency=" << latency << boolalpha
             << " blocking{rcv=" << blocking_rcv << " snd=" << blocking_snd
-            << "} snddropdelay=" << dropdelay;
+            << "} snddropdelay=" << dropdelay << " packetfilter=" << packetfilter;
     }
 
     if (!m_blocking_mode)
@@ -788,6 +807,11 @@ int SrtCommon::ConfigurePost(SRTSOCKET sock)
 
         if (m_timeout)
             result = srt_setsockopt(sock, 0, SRTO_RCVTIMEO, &m_timeout, sizeof m_timeout);
+        else
+        {
+            int timeout = 1000;
+            result = srt_setsockopt(sock, 0, SRTO_RCVTIMEO, &timeout, sizeof timeout);
+        }
         if (result == -1)
             return result;
     }
@@ -857,6 +881,7 @@ int SrtCommon::ConfigurePre(SRTSOCKET sock)
 
 void SrtCommon::SetupAdapter(const string& host, int port)
 {
+    Verb() << "Binding the caller socket to " << host << ":" << port << " ...";
     auto lsa = CreateAddr(host, port);
     int stat = srt_bind(m_sock, lsa.get(), sizeof lsa);
     if (stat == SRT_ERROR)
@@ -867,9 +892,9 @@ void SrtCommon::OpenClient(string host, int port)
 {
     PrepareClient();
 
-    if (m_outgoing_port)
+    if (m_outgoing_port || m_adapter != "")
     {
-        SetupAdapter("", m_outgoing_port);
+        SetupAdapter(m_adapter, m_outgoing_port);
     }
 
     ConnectClient(host, port);
@@ -892,7 +917,7 @@ void SrtCommon::PrepareClient()
 
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 void TransmitGroupSocketConnect(void* srtcommon, SRTSOCKET sock, int error, const sockaddr* /*peer*/, int token)
 {
     SrtCommon* that = (SrtCommon*)srtcommon;
@@ -937,18 +962,36 @@ void TransmitGroupSocketConnect(void* srtcommon, SRTSOCKET sock, int error, cons
     Verb() << " IPE: LINK NOT FOUND???]";
 }
 
+SRT_GROUP_TYPE ResolveGroupType(const string& name)
+{
+    static struct
+    {
+        string name;
+        SRT_GROUP_TYPE type;
+    } table [] {
+#define E(n) {#n, SRT_GTYPE_##n}
+        E(BROADCAST),
+        E(BACKUP)
+
+#undef E
+    };
+
+    typedef int charxform(int c);
+
+    string uname;
+    transform(name.begin(), name.end(), back_inserter(uname), (charxform*)(&toupper));
+
+    for (auto& x: table)
+        if (x.name == uname)
+            return x.type;
+
+    return SRT_GTYPE_UNDEFINED;
+}
+
 void SrtCommon::OpenGroupClient()
 {
-    SRT_GROUP_TYPE type = SRT_GTYPE_UNDEFINED;
-
-    // Resolve group type.
-    if (m_group_type == "broadcast")
-        type = SRT_GTYPE_BROADCAST;
-    else if (m_group_type == "backup")
-        type = SRT_GTYPE_BACKUP;
-    else if (m_group_type == "balancing")
-        type = SRT_GTYPE_BALANCING;
-    else
+    SRT_GROUP_TYPE type = ResolveGroupType(m_group_type);
+    if (type == SRT_GTYPE_UNDEFINED)
     {
         Error("With //group, type='" + m_group_type + "' undefined");
     }
@@ -962,9 +1005,7 @@ void SrtCommon::OpenGroupClient()
     int stat = -1;
     if (m_group_config != "")
     {
-        stat = srt_group_configure(m_sock, m_group_config.c_str());
-        if (stat == SRT_ERROR)
-            Error("srt_group_configure");
+        Verb() << "Ignoring setting group config: '" << m_group_config;
     }
 
     stat = ConfigurePre(m_sock);
@@ -1017,8 +1058,8 @@ void SrtCommon::OpenGroupClient()
         if (!extras.empty())
         {
             Verb() << "?" << extras[0] << VerbNoEOL;
-            for (size_t i = 1; i < extras.size(); ++i)
-                Verb() << "&" << extras[i] << VerbNoEOL;
+            for (size_t ii = 1; ii < extras.size(); ++ii)
+                Verb() << "&" << extras[ii] << VerbNoEOL;
         }
 
         Verb();
@@ -1037,7 +1078,7 @@ void SrtCommon::OpenGroupClient()
 Connect_Again:
         Verb() << "Waiting for group connection... " << VerbNoEOL;
 
-        int fisock = srt_connect_group(m_sock, targets.data(), targets.size());
+        int fisock = srt_connect_group(m_sock, targets.data(), int(targets.size()));
 
         if (fisock == SRT_ERROR)
         {
@@ -1088,15 +1129,15 @@ void SrtCommon::OpenGroupClient()
     // spread the setting on all sockets.
     ConfigurePost(m_sock);
 
-    for (size_t i = 0; i < targets.size(); ++i)
+    for (size_t j = 0; j < targets.size(); ++j)
     {
         // As m_group_nodes is simply transformed into 'targets',
         // one index can be used to index them all. You don't
         // have to check if they have equal addresses because they
         // are equal by definition.
-        if (targets[i].id != -1 && targets[i].errorcode == SRT_SUCCESS)
+        if (targets[j].id != -1 && targets[j].errorcode == SRT_SUCCESS)
         {
-            m_group_nodes[i].socket = targets[i].id;
+            m_group_nodes[j].socket = targets[j].id;
         }
     }
 
@@ -1117,9 +1158,9 @@ void SrtCommon::OpenGroupClient()
     }
     m_group_data.resize(size);
 
-    for (size_t i = 0; i < m_group_nodes.size(); ++i)
+    for (size_t j = 0; j < m_group_nodes.size(); ++j)
     {
-        SRTSOCKET insock = m_group_nodes[i].socket;
+        SRTSOCKET insock = m_group_nodes[j].socket;
         if (insock == -1)
         {
             Verb() << "TARGET '" << sockaddr_any(targets[i].peeraddr).str() << "' connection failed.";
@@ -1152,11 +1193,11 @@ void SrtCommon::OpenGroupClient()
                     NULL, NULL) != -1)
         {
             Verb() << "[C]" << VerbNoEOL;
-            for (int i = 0; i < len1; ++i)
-                Verb() << " " << ready_conn[i] << VerbNoEOL;
+            for (int ii = 0; ii < len1; ++ii)
+                Verb() << " " << ready_conn[ii] << VerbNoEOL;
             Verb() << "[E]" << VerbNoEOL;
-            for (int i = 0; i < len2; ++i)
-                Verb() << " " << ready_err[i] << VerbNoEOL;
+            for (int ii = 0; ii < len2; ++ii)
+                Verb() << " " << ready_err[ii] << VerbNoEOL;
 
             Verb() << "";
 
@@ -1294,7 +1335,8 @@ void SrtCommon::ConnectClient(string host, int port)
         {
             int reason = srt_getrejectreason(m_sock);
 #if PLEASE_LOG
-            LOGP(applog.Error, "ERROR reported by srt_connect - closing socket @", m_sock);
+            LOGP(applog.Error, "ERROR reported by srt_connect - closing socket @", m_sock,
+                    " reject reason: ", reason, ": ", srt_rejectreason_str(reason));
 #endif
             if (transmit_retry_connect && (transmit_retry_always || reason == SRT_REJ_TIMEOUT))
             {
@@ -1464,7 +1506,7 @@ SrtCommon::~SrtCommon()
     Close();
 }
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
 void SrtCommon::UpdateGroupStatus(const SRT_SOCKGROUPDATA* grpdata, size_t grpdata_size)
 {
     if (!grpdata)
@@ -1786,7 +1828,7 @@ bytevector SrtSource::GroupRead(size_t chunk)
         // Don't skip packets that are ahead because if we have a situation
         // that all links are either "elephants" (do not report read readiness)
         // and "kangaroos" (have already delivered an ahead packet) then
-        // omiting kangaroos will result in only elephants to be polled for
+        // omitting kangaroos will result in only elephants to be polled for
         // reading. Elephants, due to the strict timing requirements and
         // ensurance that TSBPD on every link will result in exactly the same
         // delivery time for a packet of given sequence, having an elephant
@@ -2095,7 +2137,7 @@ bytevector SrtSource::GroupRead(size_t chunk)
 
     // In this position all links are either:
     // - updated to the current position
-    // - updated to the newest possible possition available
+    // - updated to the newest possible position available
     // - not yet ready for extraction (not present in the group)
 
     // If we haven't extracted the very next sequence position,
@@ -2246,7 +2288,7 @@ MediaPacket SrtSource::Read(size_t chunk)
 {
     static size_t counter = 1;
 
-    bool have_group ATR_UNUSED = !m_group_nodes.empty();
+    bool have_group SRT_ATR_UNUSED = !m_group_nodes.empty();
 
     bytevector data(chunk);
     // EXPERIMENTAL
@@ -2269,7 +2311,7 @@ MediaPacket SrtSource::Read(size_t chunk)
 
     do
     {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         if (have_group || m_listener_group)
         {
             mctrl.grpdata = m_group_data.data();
@@ -2277,15 +2319,25 @@ MediaPacket SrtSource::Read(size_t chunk)
         }
 #endif
 
+        if (::transmit_int_state)
+            Error("srt_recvmsg2: interrupted");
+
         ::transmit_throw_on_interrupt = true;
-        stat = srt_recvmsg2(m_sock, data.data(), chunk, &mctrl);
+        stat = srt_recvmsg2(m_sock, data.data(), int(chunk), &mctrl);
         ::transmit_throw_on_interrupt = false;
-        if (stat == SRT_ERROR)
+        if (stat != SRT_ERROR)
         {
+            ready = true;
+        }
+        else
+        {
+            int syserr = 0;
+            int err = srt_getlasterror(&syserr);
+
             if (!m_blocking_mode)
             {
                 // EAGAIN for SRT READING
-                if (srt_getlasterror(NULL) == SRT_EASYNCRCV)
+                if (err == SRT_EASYNCRCV)
                 {
 Epoll_again:
                     Verb() << "AGAIN: - waiting for data by epoll(" << srt_epoll << ")...";
@@ -2327,6 +2379,16 @@ MediaPacket SrtSource::Read(size_t chunk)
                     // If was -1, then passthru.
                 }
             }
+            else
+            {
+                // In blocking mode it uses a minimum of 1s timeout,
+                // and continues only if interrupt not requested.
+                if (!::transmit_int_state && (err == SRT_EASYNCRCV || err == SRT_ETIMEOUT))
+                {
+                    ready = false;
+                    continue;
+                }
+            }
             Error("srt_recvmsg2");
         }
 
@@ -2337,7 +2399,7 @@ MediaPacket SrtSource::Read(size_t chunk)
 #if PLEASE_LOG
         extern srt_logging::Logger applog;
         LOGC(applog.Debug, log << "recv: #" << mctrl.msgno << " %" << mctrl.pktseq << "  "
-                << BufferStamp(data.data(), stat) << " BELATED: " << ((CTimer::getTime()-mctrl.srctime)/1000.0) << "ms");
+                << BufferStamp(data.data(), stat) << " BELATED: " << ((srt_time_now()-mctrl.srctime)/1000.0) << "ms");
 #endif
 
         Verb() << "(#" << mctrl.msgno << " %" << mctrl.pktseq << "  " << BufferStamp(data.data(), stat) << ") " << VerbNoEOL;
@@ -2351,7 +2413,7 @@ MediaPacket SrtSource::Read(size_t chunk)
     const bool need_bw_report    = transmit_bw_report    && int(counter % transmit_bw_report) == transmit_bw_report - 1;
     const bool need_stats_report = transmit_stats_report && counter % transmit_stats_report == transmit_stats_report - 1;
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     if (have_group) // Means, group with caller mode
     {
         UpdateGroupStatus(mctrl.grpdata, mctrl.grpdata_size);
@@ -2443,7 +2505,7 @@ void SrtTarget::Write(const MediaPacket& data)
     }
 
     SRT_MSGCTRL mctrl = srt_msgctrl_default;
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     bool have_group = !m_group_nodes.empty();
     if (have_group || m_listener_group)
     {
@@ -2457,7 +2519,7 @@ void SrtTarget::Write(const MediaPacket& data)
         mctrl.srctime = data.time;
     }
 
-    int stat = srt_sendmsg2(m_sock, data.payload.data(), data.payload.size(), &mctrl);
+    int stat = srt_sendmsg2(m_sock, data.payload.data(), int(data.payload.size()), &mctrl);
 
     // For a socket group, the error is reported only
     // if ALL links from the group have failed to perform
@@ -2470,7 +2532,7 @@ void SrtTarget::Write(const MediaPacket& data)
     const bool need_bw_report    = transmit_bw_report    && int(counter % transmit_bw_report) == transmit_bw_report - 1;
     const bool need_stats_report = transmit_stats_report && counter % transmit_stats_report == transmit_stats_report - 1;
 
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
     if (have_group)
     {
         // For listener group this is not necessary. The group information
@@ -2546,10 +2608,10 @@ void SrtModel::Establish(std::string& w_name)
             Verb() << "NO STREAM ID for SRT connection";
         }
 
-        if (m_outgoing_port)
+        if (m_outgoing_port || m_adapter != "")
         {
-            Verb() << "Setting outgoing port: " << m_outgoing_port;
-            SetupAdapter("", m_outgoing_port);
+            Verb() << "Setting outgoing port: " << m_outgoing_port << " adapter:" << m_adapter;
+            SetupAdapter(m_adapter, m_outgoing_port);
         }
 
         ConnectClient(m_host, m_port);
@@ -2682,264 +2744,242 @@ static inline bool IsMulticast(in_addr adr)
     return c >= 224 && c <= 239;
 }
 
-
-class UdpCommon
+void UdpCommon::Setup(string host, int port, map<string,string> attr)
 {
-protected:
-    int m_sock = -1;
-    sockaddr_any sadr;
-    string adapter;
-    map<string, string> m_options;
+    m_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (m_sock == -1)
+        Error(SysError(), "UdpCommon::Setup: socket");
 
-    void Setup(string host, int port, map<string,string> attr)
-    {
-        m_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-        if (m_sock == -1)
-            Error(SysError(), "UdpCommon::Setup: socket");
+    int yes = 1;
+    ::setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof yes);
 
-        int yes = 1;
-        ::setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof yes);
+    sadr = CreateAddr(host, port);
 
-        sadr = CreateAddr(host, port);
+    bool is_multicast = false;
+    if (sadr.family() == AF_INET)
+    {
+        if (attr.count("multicast"))
+        {
+            if (!IsMulticast(sadr.sin.sin_addr))
+            {
+                throw std::runtime_error("UdpCommon: requested multicast for a non-multicast-type IP address");
+            }
+            is_multicast = true;
+        }
+        else if (IsMulticast(sadr.sin.sin_addr))
+        {
+            is_multicast = true;
+        }
 
-        bool is_multicast = false;
-        if (sadr.family() == AF_INET)
+        if (is_multicast)
         {
-            if (attr.count("multicast"))
+            ip_mreq mreq;
+            sockaddr_any maddr (AF_INET);
+            int opt_name;
+            void* mreq_arg_ptr;
+            socklen_t mreq_arg_size;
+
+            adapter = attr.count("adapter") ? attr.at("adapter") : string();
+            if (adapter == "")
             {
-                if (!IsMulticast(sadr.sin.sin_addr))
-                {
-                    throw std::runtime_error("UdpCommon: requested multicast for a non-multicast-type IP address");
-                }
-                is_multicast = true;
+                Verb() << "Multicast: home address: INADDR_ANY:" << port;
+                maddr.sin.sin_family = AF_INET;
+                maddr.sin.sin_addr.s_addr = htonl(INADDR_ANY);
+                maddr.sin.sin_port = htons(port); // necessary for temporary use
             }
-            else if (IsMulticast(sadr.sin.sin_addr))
+            else
             {
-                is_multicast = true;
+                Verb() << "Multicast: home address: " << adapter << ":" << port;
+                maddr = CreateAddr(adapter, port);
             }
 
-            if (is_multicast)
+            if (attr.count("source"))
             {
+#ifdef IP_ADD_SOURCE_MEMBERSHIP
                 ip_mreq_source mreq_ssm;
-                ip_mreq mreq;
-                sockaddr_any maddr;
-                int opt_name;
-                void* mreq_arg_ptr;
-                socklen_t mreq_arg_size;
-
-                adapter = attr.count("adapter") ? attr.at("adapter") : string();
-                if (adapter == "")
-                {
-                    Verb() << "Multicast: home address: INADDR_ANY:" << port;
-                    maddr.sin.sin_family = AF_INET;
-                    maddr.sin.sin_addr.s_addr = htonl(INADDR_ANY);
-                    maddr.sin.sin_port = htons(port); // necessary for temporary use
-                }
-                else
-                {
-                    Verb() << "Multicast: home address: " << adapter << ":" << port;
-                    maddr = CreateAddr(adapter, port);
-                }
-
-                if (attr.count("source"))
-                {
-                    /* this is an ssm.  we need to use the right struct and opt */
-                    opt_name = IP_ADD_SOURCE_MEMBERSHIP;
-                    mreq_ssm.imr_multiaddr.s_addr = sadr.sin.sin_addr.s_addr;
-                    mreq_ssm.imr_interface.s_addr = maddr.sin.sin_addr.s_addr;
-                    inet_pton(AF_INET, attr.at("source").c_str(), &mreq_ssm.imr_sourceaddr);
-                    mreq_arg_size = sizeof(mreq_ssm);
-                    mreq_arg_ptr = &mreq_ssm;
-                }
-                else
-                {
-                    opt_name = IP_ADD_MEMBERSHIP;
-                    mreq.imr_multiaddr.s_addr = sadr.sin.sin_addr.s_addr;
-                    mreq.imr_interface.s_addr = maddr.sin.sin_addr.s_addr;
-                    mreq_arg_size = sizeof(mreq);
-                    mreq_arg_ptr = &mreq;
-                }
+                /* this is an ssm.  we need to use the right struct and opt */
+                opt_name = IP_ADD_SOURCE_MEMBERSHIP;
+                mreq_ssm.imr_multiaddr.s_addr = sadr.sin.sin_addr.s_addr;
+                mreq_ssm.imr_interface.s_addr = maddr.sin.sin_addr.s_addr;
+                inet_pton(AF_INET, attr.at("source").c_str(), &mreq_ssm.imr_sourceaddr);
+                mreq_arg_size = sizeof(mreq_ssm);
+                mreq_arg_ptr = &mreq_ssm;
+#else
+                throw std::runtime_error("UdpCommon: source-filter multicast not supported by OS");
+#endif
+            }
+            else
+            {
+                opt_name = IP_ADD_MEMBERSHIP;
+                mreq.imr_multiaddr.s_addr = sadr.sin.sin_addr.s_addr;
+                mreq.imr_interface.s_addr = maddr.sin.sin_addr.s_addr;
+                mreq_arg_size = sizeof(mreq);
+                mreq_arg_ptr = &mreq;
+            }
 
 #ifdef _WIN32
-                const char* mreq_arg = (const char*)mreq_arg_ptr;
-                const auto status_error = SOCKET_ERROR;
+            const char* mreq_arg = (const char*)mreq_arg_ptr;
+            const auto status_error = SOCKET_ERROR;
 #else
-                const void* mreq_arg = mreq_arg_ptr;
-                const auto status_error = -1;
+            const void* mreq_arg = mreq_arg_ptr;
+            const auto status_error = -1;
 #endif
 
 #if defined(_WIN32) || defined(__CYGWIN__)
-                // On Windows it somehow doesn't work when bind()
-                // is called with multicast address. Write the address
-                // that designates the network device here.
-                // Also, sets port sharing when working with multicast
-                sadr = maddr;
-                int reuse = 1;
-                int shareAddrRes = setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&reuse), sizeof(reuse));
-                if (shareAddrRes == status_error)
-                {
-                    throw runtime_error("marking socket for shared use failed");
-                }
-                Verb() << "Multicast(Windows): will bind to home address";
+            // On Windows it somehow doesn't work when bind()
+            // is called with multicast address. Write the address
+            // that designates the network device here.
+            // Also, sets port sharing when working with multicast
+            sadr = maddr;
+            int reuse = 1;
+            int shareAddrRes = setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&reuse), sizeof(reuse));
+            if (shareAddrRes == status_error)
+            {
+                throw runtime_error("marking socket for shared use failed");
+            }
+            Verb() << "Multicast(Windows): will bind to home address";
 #else
-                Verb() << "Multicast(POSIX): will bind to IGMP address: " << host;
+            Verb() << "Multicast(POSIX): will bind to IGMP address: " << host;
 #endif
-                int res = setsockopt(m_sock, IPPROTO_IP, opt_name, mreq_arg, mreq_arg_size);
-
-                if (res == status_error)
-                {
-                    Error(errno, "adding to multicast membership failed");
-                }
+            int res = setsockopt(m_sock, IPPROTO_IP, opt_name, mreq_arg, mreq_arg_size);
 
-                attr.erase("multicast");
-                attr.erase("adapter");
+            if (res == status_error)
+            {
+                Error(errno, "adding to multicast membership failed");
             }
+
+            attr.erase("multicast");
+            attr.erase("adapter");
         }
+    }
 
-        // The "ttl" options is handled separately, it maps to both IP_TTL
-        // and IP_MULTICAST_TTL so that TTL setting works for both uni- and multicast.
-        if (attr.count("ttl"))
-        {
-            int ttl = stoi(attr.at("ttl"));
-            int res = setsockopt(m_sock, IPPROTO_IP, IP_TTL, (const char*)&ttl, sizeof ttl);
-            if (res == -1)
-                Verb() << "WARNING: failed to set 'ttl' (IP_TTL) to " << ttl;
-            res = setsockopt(m_sock, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&ttl, sizeof ttl);
-            if (res == -1)
-                Verb() << "WARNING: failed to set 'ttl' (IP_MULTICAST_TTL) to " << ttl;
+    // The "ttl" options is handled separately, it maps to both IP_TTL
+    // and IP_MULTICAST_TTL so that TTL setting works for both uni- and multicast.
+    if (attr.count("ttl"))
+    {
+        int ttl = stoi(attr.at("ttl"));
+        int res = setsockopt(m_sock, IPPROTO_IP, IP_TTL, (const char*)&ttl, sizeof ttl);
+        if (res == -1)
+            Verb() << "WARNING: failed to set 'ttl' (IP_TTL) to " << ttl;
+        res = setsockopt(m_sock, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&ttl, sizeof ttl);
+        if (res == -1)
+            Verb() << "WARNING: failed to set 'ttl' (IP_MULTICAST_TTL) to " << ttl;
 
-            attr.erase("ttl");
-        }
+        attr.erase("ttl");
+    }
 
-        m_options = attr;
+    m_options = attr;
 
-        for (auto o: udp_options)
+    for (auto o: udp_options)
+    {
+        // Ignore "binding" - for UDP there are no post options.
+        if (m_options.count(o.name))
         {
-            // Ignore "binding" - for UDP there are no post options.
-            if (m_options.count(o.name))
-            {
-                string value = m_options.at(o.name);
-                bool ok = o.apply<SocketOption::SYSTEM>(m_sock, value);
-                if (!ok)
-                    Verb() << "WARNING: failed to set '" << o.name << "' to " << value;
-            }
+            string value = m_options.at(o.name);
+            bool ok = o.apply<SocketOption::SYSTEM>(m_sock, value);
+            if (!ok)
+                Verb() << "WARNING: failed to set '" << o.name << "' to " << value;
         }
     }
+}
 
-    void Error(int err, string src)
-    {
-        char buf[512];
-        string message = SysStrError(err, buf, 512u);
+void UdpCommon::Error(int err, string src)
+{
+    char buf[512];
+    string message = SysStrError(err, buf, 512u);
 
-        if (Verbose::on)
-            Verb() << "FAILURE\n" << src << ": [" << err << "] " << message;
-        else
-            cerr << "\nERROR #" << err << ": " << message << endl;
+    if (Verbose::on)
+        Verb() << "FAILURE\n" << src << ": [" << err << "] " << message;
+    else
+        cerr << "\nERROR #" << err << ": " << message << endl;
 
-        throw TransmissionError("error: " + src + ": " + message);
-    }
+    throw TransmissionError("error: " + src + ": " + message);
+}
 
-    ~UdpCommon()
-    {
+UdpCommon::~UdpCommon()
+{
 #ifdef _WIN32
-        if (m_sock != -1)
-        {
-            shutdown(m_sock, SD_BOTH);
-            closesocket(m_sock);
-            m_sock = -1;
-        }
+    if (m_sock != -1)
+    {
+        shutdown(m_sock, SD_BOTH);
+        closesocket(m_sock);
+        m_sock = -1;
+    }
 #else
-        close(m_sock);
+    close(m_sock);
 #endif
-    }
-};
-
+}
 
-class UdpSource: public virtual Source, public virtual UdpCommon
+UdpSource::UdpSource(string host, int port, const map<string,string>& attr)
 {
-    bool eof = true;
-public:
+    Setup(host, port, attr);
+    int stat = ::bind(m_sock, sadr.get(), sadr.size());
+    if (stat == -1)
+        Error(SysError(), "Binding address for UDP");
+    eof = false;
+    struct timeval tv;
+    tv.tv_sec = 1;
+    tv.tv_usec = 0;
+    if (::setsockopt(m_sock, SOL_SOCKET, SO_RCVTIMEO, (const char*) &tv, sizeof(tv)) < 0)
+        Error(SysError(), "Setting timeout for UDP");
+}
 
-    UdpSource(string host, int port, const map<string,string>& attr)
+MediaPacket UdpSource::Read(size_t chunk)
+{
+    bytevector data(chunk);
+    sockaddr_any sa(sadr.family());
+    int64_t srctime = 0;
+AGAIN:
+    int stat = recvfrom(m_sock, data.data(), (int) chunk, 0, sa.get(), &sa.syslen());
+    int err = SysError();
+    if (transmit_use_sourcetime)
     {
-        Setup(host, port, attr);
-        int stat = ::bind(m_sock, sadr.get(), sadr.size());
-        if (stat == -1)
-            Error(SysError(), "Binding address for UDP");
-        eof = false;
+        srctime = srt_time_now();
     }
-
-    MediaPacket Read(size_t chunk) override
+    if (stat == -1)
     {
-        bytevector data(chunk);
-        sockaddr_any sa(sadr.family());
-        int64_t srctime = 0;
-        int stat = recvfrom(m_sock, data.data(), (int) chunk, 0, sa.get(), &sa.syslen());
-        if (transmit_use_sourcetime)
-        {
-            srctime = srt_time_now();
-        }
-        if (stat == -1)
-            Error(SysError(), "UDP Read/recvfrom");
-
-        if (stat < 1)
-        {
-            eof = true;
-            return bytevector();
-        }
+        if (!::transmit_int_state && err == SysAGAIN)
+            goto AGAIN;
 
-        chunk = size_t(stat);
-        if (chunk < data.size())
-            data.resize(chunk);
+        Error(SysError(), "UDP Read/recvfrom");
+    }
 
-        return MediaPacket(data, srctime);
+    if (stat < 1)
+    {
+        eof = true;
+        return bytevector();
     }
 
-    bool IsOpen() override { return m_sock != -1; }
-    bool End() override { return eof; }
-};
+    chunk = size_t(stat);
+    if (chunk < data.size())
+        data.resize(chunk);
 
-class UdpTarget: public virtual Target, public virtual UdpCommon
+    return MediaPacket(data, srctime);
+}
+
+UdpTarget::UdpTarget(string host, int port, const map<string,string>& attr)
 {
-public:
-    UdpTarget(string host, int port, const map<string,string>& attr )
+    Setup(host, port, attr);
+    if (adapter != "")
     {
-        Setup(host, port, attr);
-        if (adapter != "")
-        {
-            auto maddr = CreateAddr(adapter, 0);
-            in_addr addr = maddr.sin.sin_addr;
+        auto maddr = CreateAddr(adapter, 0);
+        in_addr addr = maddr.sin.sin_addr;
 
-            int res = setsockopt(m_sock, IPPROTO_IP, IP_MULTICAST_IF, reinterpret_cast<const char*>(&addr), sizeof(addr));
-            if (res == -1)
-            {
-                Error(SysError(), "setsockopt/IP_MULTICAST_IF: " + adapter);
-            }
+        int res = setsockopt(m_sock, IPPROTO_IP, IP_MULTICAST_IF, reinterpret_cast<const char*>(&addr), sizeof(addr));
+        if (res == -1)
+        {
+            Error(SysError(), "setsockopt/IP_MULTICAST_IF: " + adapter);
         }
     }
+}
 
-    void Write(const MediaPacket& data) override
-    {
-        int stat = sendto(m_sock, data.payload.data(), data.payload.size(), 0, (sockaddr*)&sadr, sizeof sadr);
-        if (stat == -1)
-            Error(SysError(), "UDP Write/sendto");
-    }
-
-    bool IsOpen() override { return m_sock != -1; }
-    bool Broken() override { return false; }
-};
-
-class UdpRelay: public Relay, public UdpSource, public UdpTarget
+void UdpTarget::Write(const MediaPacket& data)
 {
-public:
-    UdpRelay(string host, int port, const map<string,string>& attr):
-        UdpSource(host, port, attr),
-        UdpTarget(host, port, attr)
-    {
-    }
+    int stat = sendto(m_sock, data.payload.data(), int(data.payload.size()), 0, (sockaddr*)&sadr, int(sizeof sadr));
+    if (stat == -1)
+        Error(SysError(), "UDP Write/sendto");
+}
 
-    bool IsOpen() override { return m_sock != -1; }
-};
 
 template <class Iface> struct Udp;
 template <> struct Udp<Source> { typedef UdpSource type; };
@@ -3001,7 +3041,7 @@ extern unique_ptr<Base> CreateMedium(const string& uri)
     }
 
     if (ptr)
-        ptr->uri = move(u);
+        ptr->uri = std::move(u);
     return ptr;
 }
 
diff --git a/testing/testmedia.hpp b/testing/testmedia.hpp
index ad70f6967..470e825ef 100644
--- a/testing/testmedia.hpp
+++ b/testing/testmedia.hpp
@@ -16,17 +16,20 @@
 #include <stdexcept>
 #include <deque>
 
+#include <sync.h> // use srt::sync::atomic instead of std::atomic for the sake of logging
+
+#include "apputil.hpp"
+#include "statswriter.hpp"
 #include "testmediabase.hpp"
 #include <udt.h> // Needs access to CUDTException
 #include <netinet_any.h>
 
 extern srt_listen_callback_fn* transmit_accept_hook_fn;
 extern void* transmit_accept_hook_op;
+extern srt::sync::atomic<bool> transmit_int_state;
 
 extern std::shared_ptr<SrtStatsWriter> transmit_stats_writer;
 
-using namespace std;
-
 const srt_logging::LogFA SRT_LOGFA_APP = 10;
 extern srt_logging::Logger applog;
 
@@ -53,29 +56,29 @@ class SrtCommon
 
     struct ConnectionBase
     {
-        string host;
+        std::string host;
         int port;
         int weight = 0;
         SRTSOCKET socket = SRT_INVALID_SOCK;
-        sockaddr_any source;
-        sockaddr_any target;
+        srt::sockaddr_any source;
+        srt::sockaddr_any target;
         int token = -1;
 
-        ConnectionBase(string h, int p): host(h), port(p), source(AF_INET) {}
+        ConnectionBase(std::string h, int p): host(h), port(p), source(AF_INET) {}
     };
 
     struct Connection: ConnectionBase
     {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
         SRT_SOCKOPT_CONFIG* options = nullptr;
 #endif
         int error = SRT_SUCCESS;
         int reason = SRT_REJ_UNKNOWN;
 
-        Connection(string h, int p): ConnectionBase(h, p) {}
+        Connection(std::string h, int p): ConnectionBase(h, p) {}
         Connection(Connection&& old): ConnectionBase(old)
         {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
             if (old.options)
             {
                 options = old.options;
@@ -85,7 +88,7 @@ class SrtCommon
         }
         ~Connection()
         {
-#if ENABLE_EXPERIMENTAL_BONDING
+#if ENABLE_BONDING
             srt_delete_config(options);
 #endif
         }
@@ -97,14 +100,14 @@ class SrtCommon
     int m_timeout = 0; //< enforces using SRTO_SNDTIMEO or SRTO_RCVTIMEO, depending on @a m_direction
     bool m_tsbpdmode = true;
     int m_outgoing_port = 0;
-    string m_mode;
-    string m_adapter;
-    map<string, string> m_options; // All other options, as provided in the URI
-    vector<Connection> m_group_nodes;
-    string m_group_type;
-    string m_group_config;
-#if ENABLE_EXPERIMENTAL_BONDING
-    vector<SRT_SOCKGROUPDATA> m_group_data;
+    std::string m_mode;
+    std::string m_adapter;
+    std::map<std::string, std::string> m_options; // All other options, as provided in the URI
+    std::vector<Connection> m_group_nodes;
+    std::string m_group_type;
+    std::string m_group_config;
+#if ENABLE_BONDING
+    std::vector<SRT_SOCKGROUPDATA> m_group_data;
 #ifdef SRT_OLD_APP_READER
     int32_t m_group_seqno = -1;
 
@@ -113,7 +116,7 @@ class SrtCommon
         int32_t sequence;
         bytevector packet;
     };
-    map<SRTSOCKET, ReadPos> m_group_positions;
+    std::map<SRTSOCKET, ReadPos> m_group_positions;
     SRTSOCKET m_group_active; // The link from which the last packet was delivered
 #endif
 #endif
@@ -127,8 +130,8 @@ class SrtCommon
     void UpdateGroupStatus(const SRT_SOCKGROUPDATA* grpdata, size_t grpdata_size);
 
 public:
-    void InitParameters(string host, string path, map<string,string> par);
-    void PrepareListener(string host, int port, int backlog);
+    void InitParameters(std::string host, std::string path, std::map<std::string,std::string> par);
+    void PrepareListener(std::string host, int port, int backlog);
     void StealFrom(SrtCommon& src);
     void AcceptNewClient();
 
@@ -146,22 +149,22 @@ class SrtCommon
 
 protected:
 
-    void Error(string src, int reason = SRT_REJ_UNKNOWN, int force_result = 0);
-    void Init(string host, int port, string path, map<string,string> par, SRT_EPOLL_OPT dir);
+    void Error(std::string src, int reason = SRT_REJ_UNKNOWN, int force_result = 0);
+    void Init(std::string host, int port, std::string path, std::map<std::string,std::string> par, SRT_EPOLL_OPT dir);
     int AddPoller(SRTSOCKET socket, int modes);
     virtual int ConfigurePost(SRTSOCKET sock);
     virtual int ConfigurePre(SRTSOCKET sock);
 
-    void OpenClient(string host, int port);
-#if ENABLE_EXPERIMENTAL_BONDING
+    void OpenClient(std::string host, int port);
+#if ENABLE_BONDING
     void OpenGroupClient();
 #endif
     void PrepareClient();
     void SetupAdapter(const std::string& host, int port);
-    void ConnectClient(string host, int port);
-    void SetupRendezvous(string adapter, string host, int port);
+    void ConnectClient(std::string host, int port);
+    void SetupRendezvous(std::string adapter, std::string host, int port);
 
-    void OpenServer(string host, int port, int backlog = 1)
+    void OpenServer(std::string host, int port, int backlog = 1)
     {
         PrepareListener(host, port, backlog);
         if (transmit_accept_hook_fn)
@@ -171,7 +174,7 @@ class SrtCommon
         AcceptNewClient();
     }
 
-    void OpenRendezvous(string adapter, string host, int port)
+    void OpenRendezvous(std::string adapter, std::string host, int port)
     {
         PrepareClient();
         SetupRendezvous(adapter, host, port);
@@ -280,11 +283,11 @@ class SrtModel: public SrtCommon
 public:
     bool is_caller = false;
     bool is_rend = false;
-    string m_host;
+    std::string m_host;
     int m_port = 0;
 
 
-    SrtModel(string host, int port, map<string,string> par);
+    SrtModel(std::string host, int port, std::map<std::string,std::string> par);
     void Establish(std::string& w_name);
 
     void Close()
@@ -297,6 +300,55 @@ class SrtModel: public SrtCommon
     }
 };
 
+class UdpCommon
+{
+protected:
+    int m_sock = -1;
+    srt::sockaddr_any sadr;
+    std::string adapter;
+    std::map<std::string, std::string> m_options;
+    void Setup(std::string host, int port, std::map<std::string,std::string> attr);
+    void Error(int err, std::string src);
+
+    ~UdpCommon();
+};
+
+
+class UdpSource: public virtual Source, public virtual UdpCommon
+{
+    bool eof = true;
+public:
+
+    UdpSource(std::string host, int port, const std::map<std::string,std::string>& attr);
+
+    MediaPacket Read(size_t chunk) override;
+
+    bool IsOpen() override { return m_sock != -1; }
+    bool End() override { return eof; }
+};
+
+class UdpTarget: public virtual Target, public virtual UdpCommon
+{
+public:
+    UdpTarget(std::string host, int port, const std::map<std::string,std::string>& attr);
+
+    void Write(const MediaPacket& data) override;
+    bool IsOpen() override { return m_sock != -1; }
+    bool Broken() override { return false; }
+};
+
+class UdpRelay: public Relay, public UdpSource, public UdpTarget
+{
+public:
+    UdpRelay(std::string host, int port, const std::map<std::string,std::string>& attr):
+        UdpSource(host, port, attr),
+        UdpTarget(host, port, attr)
+    {
+    }
+
+    bool IsOpen() override { return m_sock != -1; }
+};
+
 
 
 #endif
diff --git a/testing/testmediabase.hpp b/testing/testmediabase.hpp
index a04803e04..686198787 100644
--- a/testing/testmediabase.hpp
+++ b/testing/testmediabase.hpp
@@ -17,8 +17,11 @@
 #include <iostream>
 #include <stdexcept>
 
+#include "sync.h"
+#include "uriparser.hpp"
+
 typedef std::vector<char> bytevector;
-extern volatile bool transmit_throw_on_interrupt;
+extern srt::sync::atomic<bool> transmit_throw_on_interrupt;
 extern int transmit_bw_report;
 extern unsigned transmit_stats_report;
 extern size_t transmit_chunk_size;
diff --git a/testing/utility-test.cpp b/testing/utility-test.cpp
index 69d696255..535b3f5b9 100644
--- a/testing/utility-test.cpp
+++ b/testing/utility-test.cpp
@@ -18,6 +18,8 @@
 #include <crypto.h>
 #include <common.h>
 
+using namespace srt;
+
 void ShowDistance(int32_t s1, int32_t s2)
 {
     using namespace std;