cmake: Bump version to 0.9.1

Signed-off-by: Andreas Schneider <asn@cryptomilk.org> Reviewed-by: Jakub Jelen <jjelen@redhat.com>
cmake: Bump library version
2026-02-04 20:30:38 +09:00 · 2019-10-25 16:11:17 +02:00 · 2019-10-25 16:11:17 +02:00 · 2019-10-25 16:11:17 +02:00 · 2019-10-25 16:11:17 +02:00 · 2019-10-25 16:11:17 +02:00
271 changed files with 8665 additions and 27101 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,18 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-max_line_length = 80
-end_of_line = lf
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.{c,h}]
-indent_style = space
-indent_size = 4
-tab_width = 4
-
-[{CMakeLists.txt,*.cmake}]
-indent_style = space
-indent_size = 4
-tab_width = 4
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@
 *~$
 cscope.*
 compile_commands.json
-/.cache
 /.clangd
 tags
 /build
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,528 +1,536 @@
---
 variables:
  BUILD_IMAGES_PROJECT: libssh/build-images
-  CENTOS7_BUILD: buildenv-centos7
-  CENTOS9_BUILD: buildenv-c9s
-  COVERITY_BUILD: buildenv-coverity
  FEDORA_BUILD: buildenv-fedora
-  MINGW_BUILD: buildenv-mingw
+  CENTOS7_BUILD: buildenv-centos7
  TUMBLEWEED_BUILD: buildenv-tumbleweed
-  UBUNTU_BUILD: buildenv-ubuntu
-  ALPINE_BUILD: buildenv-alpine
+  MINGW_BUILD: buildenv-mingw
+  DEBIAN_CROSS_BUILD: buildenv-debian-cross

-stages:
-  - build
-  - test
-  - analysis
-
-.build:
-  stage: build
-  variables:
-    CMAKE_DEFAULT_OPTIONS: "-DCMAKE_BUILD_TYPE=RelWithDebInfo -DPICKY_DEVELOPER=ON"
-    CMAKE_BUILD_OPTIONS: "-DWITH_BLOWFISH_CIPHER=ON -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON -DWITH_DEBUG_CRYPTO=ON -DWITH_DEBUG_PACKET=ON -DWITH_DEBUG_CALLTRACE=ON -DWITH_DSA=ON"
-    CMAKE_TEST_OPTIONS: "-DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON -DWITH_BENCHMARKS=ON"
-    CMAKE_OPTIONS: $CMAKE_DEFAULT_OPTIONS $CMAKE_BUILD_OPTIONS $CMAKE_TEST_OPTIONS
-  before_script: &build
-    - uname -a
-    - cat /etc/os-release
-    - mount
-    - df -h
-    - cat /proc/swaps
-    - free -h
-    - mkdir -p obj && cd obj
+# pkd tests fail on CentOS7 docker images, so we don't use -DSERVER_TESTING=ON
+centos7/openssl_1.0.x/x86_64:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$CENTOS7_BUILD
  script:
-    - cmake $CMAKE_OPTIONS $CMAKE_ADDITIONAL_OPTIONS .. &&
-      make -j$(nproc) &&
-      make -j$(nproc) install
-  # Do not use after_script as it does not make the targets fail
+  - mkdir -p obj && cd obj && cmake3
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
  tags:
-    - shared
+  - shared
  except:
-    - tags
+  - tags
  artifacts:
    expire_in: 1 week
    when: on_failure
    paths:
      - obj/

-.tests:
-  extends: .build
-  stage: test
-  # This is needed to prevent passing artifacts from previous stages
-  dependencies: []
-  script:
-    - cmake $CMAKE_OPTIONS $CMAKE_ADDITIONAL_OPTIONS .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-    # Do not use after_script as it does not make the targets fail
-
-.fedora:
-  extends: .tests
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: -DWITH_PKCS11_URI=ON
-
-.tumbleweed:
-  extends: .tests
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
-
-
-###############################################################################
-#                               CentOS builds                                 #
-###############################################################################
-# pkd tests fail on CentOS7 docker images, so we don't use -DSERVER_TESTING=ON
-centos7/openssl_1.0.x/x86_64:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$CENTOS7_BUILD
-  extends: .tests
-  script:
-    - cmake3 $CMAKE_OPTIONS .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-centos9s/openssl_3.0.x/x86_64:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$CENTOS9_BUILD
-  extends: .tests
-  script:
-    - export OPENSSL_ENABLE_SHA1_SIGNATURES=1
-    - cmake3 $CMAKE_OPTIONS .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-
-###############################################################################
-#                               Fedora builds                                 #
-###############################################################################
-fedora/build:
-  extends: .build
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
-
-fedora/docs:
-  extends: .build
+fedora/openssl_1.1.x/x86_64:
  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - cmake .. && make docs
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_BLOWFISH_CIPHER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DWITH_DEBUG_CRYPTO=ON
+    -DWITH_DEBUG_PACKET=ON -DWITH_DEBUG_CALLTRACE=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

-fedora/ninja:
-  extends: .fedora
+fedora/openssl_1.1.x/x86_64/fips:
  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - cmake -G Ninja $CMAKE_OPTIONS ../ && ninja && ninja test
+  - echo 1 > /etc/system-fips
+  - update-crypto-policies --set FIPS
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_BLOWFISH_CIPHER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DWITH_DEBUG_CRYPTO=ON -DWITH_DEBUG_PACKET=ON -DWITH_DEBUG_CALLTRACE=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && OPENSSL_FORCE_FIPS_MODE=1 ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

-fedora/openssl_3.0.x/x86_64:
-  extends: .fedora
-
-fedora/openssl_3.0.x/x86_64/fips:
-  extends: .fedora
-  before_script:
-    - echo "# userspace fips" > /etc/system-fips
-    # We do not need the kernel part, but in case we ever do:
-    # mkdir -p /var/tmp/userspace-fips
-    # echo 1 > /var/tmp/userspace-fips/fips_enabled
-    # mount --bind /var/tmp/userspace-fips/fips_enabled \
-    # /proc/sys/crypto/fips_enabled
-    - update-crypto-policies --show
-    - update-crypto-policies --set FIPS
-    - update-crypto-policies --show
-    - mkdir -p obj && cd obj && cmake
-      -DCMAKE_BUILD_TYPE=RelWithDebInfo
-      -DPICKY_DEVELOPER=ON
-      -DWITH_BLOWFISH_CIPHER=ON
-      -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
-      -DWITH_DEBUG_CRYPTO=ON -DWITH_DEBUG_PACKET=ON -DWITH_DEBUG_CALLTRACE=ON
-      -DWITH_DSA=ON
-      -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON ..
+fedora/openssl_1.1.x/x86_64/minimal:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - cmake $CMAKE_OPTIONS .. &&
-      make -j$(nproc) &&
-      OPENSSL_FORCE_FIPS_MODE=1 ctest --output-on-failure
-
-fedora/openssl_3.0.x/x86_64/minimal:
-  extends: .fedora
-  variables:
-  script:
-    - cmake $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=OFF
-      -DWITH_SERVER=OFF
-      -DWITH_ZLIB=OFF
-      -DWITH_PCAP=OFF
-      -DWITH_DSA=OFF
-      -DUNIT_TESTING=ON
-      -DCLIENT_TESTING=ON
-      -DWITH_GEX=OFF .. &&
-      make -j$(nproc)
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=OFF -DWITH_SERVER=OFF -DWITH_ZLIB=OFF -DWITH_PCAP=OFF
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DWITH_GEX=OFF .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

 # Address sanitizer doesn't mix well with LD_PRELOAD used in the testsuite
 # so, this is only enabled for unit tests right now.
 # TODO: add -DCLIENT_TESTING=ON -DSERVER_TESTING=ON
 fedora/address-sanitizer:
-  extends: .fedora
-  stage: analysis
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - cmake
-      -DCMAKE_BUILD_TYPE=AddressSanitizer
-      -DCMAKE_C_COMPILER=clang
-      -DCMAKE_CXX_COMPILER=clang++
-      -DPICKY_DEVELOPER=ON
-      $CMAKE_BUILD_OPTIONS
-      -DUNIT_TESTING=ON
-      -DFUZZ_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=AddressSanitizer
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

 # This is disabled as it report OpenSSL issues
-# It also has the same issues with cwrap as AddressSanitizer
+# It also has ethe same issues with cwrap as AddressSanitizer
 .fedora/memory-sanitizer:
-  extends: .fedora
-  stage: analysis
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - cmake
-      -DCMAKE_BUILD_TYPE=MemorySanitizer
-      -DCMAKE_C_COMPILER=clang
-      -DCMAKE_CXX_COMPILER=clang++
-      -DPICKY_DEVELOPER=ON
-      $CMAKE_BUILD_OPTIONS
-      -DUNIT_TESTING=ON
-      -DFUZZ_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=MemorySanitizer
+    -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON ..
+    && make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

 fedora/undefined-sanitizer:
-  extends: .fedora
-  stage: analysis
-  script:
-    - cmake
-      -DCMAKE_BUILD_TYPE=UndefinedSanitizer
-      -DCMAKE_C_COMPILER=clang
-      -DCMAKE_CXX_COMPILER=clang++
-      -DPICKY_DEVELOPER=ON
-      $CMAKE_BUILD_OPTIONS
-      -DUNIT_TESTING=ON
-      -DFUZZ_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-fedora/libgcrypt/x86_64:
-  extends: .fedora
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: "-DWITH_GCRYPT=ON -DWITH_DEBUG_CRYPTO=ON"
-
-fedora/mbedtls/x86_64:
-  extends: .fedora
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: "-DWITH_MBEDTLS=ON -DWITH_DEBUG_CRYPTO=ON -DWITH_DSA=OFF"
-
-# Unit testing only, no client and pkd testing, because cwrap is not available
-# for MinGW
-fedora/mingw64:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$MINGW_BUILD
-  extends: .tests
-  script:
-    - export WINEPATH=/usr/x86_64-w64-mingw32/sys-root/mingw/bin
-    - export WINEDEBUG=-all
-    - mingw64-cmake $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON
-      -DWITH_SERVER=ON
-      -DWITH_ZLIB=ON
-      -DWITH_PCAP=ON
-      -DUNIT_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-# Unit testing only, no client and pkd testing, because cwrap is not available
-# for MinGW
-fedora/mingw32:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$MINGW_BUILD
-  extends: .tests
-  script:
-    - export WINEPATH=/usr/i686-w64-mingw32/sys-root/mingw/bin
-    - export WINEDEBUG=-all
-    - mingw32-cmake $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON
-      -DWITH_SERVER=ON
-      -DWITH_ZLIB=ON
-      -DWITH_PCAP=ON
-      -DUNIT_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-
-###############################################################################
-#                               Fedora csbuild                                #
-###############################################################################
-.csbuild:
-  stage: analysis
-  variables:
-    GIT_DEPTH: "100"
  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
-  before_script:
-    - |
-      if [[ -z "$CI_COMMIT_BEFORE_SHA" ]]; then
-          export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
-      fi
-
-      # Check if the commit exists in this branch
-      # This is not the case for a force push
-      git branch --contains $CI_COMMIT_BEFORE_SHA 2>/dev/null || export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
-
-      export CI_COMMIT_RANGE="$CI_COMMIT_BEFORE_SHA..$CI_COMMIT_SHA"
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=UndefinedSanitizer
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON ..
+    && make -j$(nproc) && ctest --output-on-failure
  tags:
-    - shared
+  - shared
  except:
-    - tags
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+fedora/csbuild:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
+  script:
+  - |
+    if [[ -z "$CI_COMMIT_BEFORE_SHA" ]]; then
+        export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
+    fi
+
+    # Check if the commit exists in this branch
+    # This is not the case for a force push
+    git branch --contains $CI_COMMIT_BEFORE_SHA 2>/dev/null || export CI_COMMIT_BEFORE_SHA=$(git rev-parse "${CI_COMMIT_SHA}~20")
+
+    export CI_COMMIT_RANGE="$CI_COMMIT_BEFORE_SHA..$CI_COMMIT_SHA"
+
+  - csbuild
+    --build-dir=obj-csbuild
+    --build-cmd "rm -rf CMakeFiles CMakeCache.txt && cmake -DCMAKE_BUILD_TYPE=Debug -DPICKY_DEVELOPER=ON -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON -DFUZZ_TESTING=ON @SRCDIR@ && make clean && make -j$(nproc)"
+    --git-commit-range $CI_COMMIT_RANGE
+    --color
+    --print-current --print-fixed
+  tags:
+  - shared
+  except:
+  - tags
  artifacts:
    expire_in: 1 week
    when: on_failure
    paths:
      - obj-csbuild/

-fedora/csbuild/openssl_3.0.x:
-  extends: .csbuild
+# That is a specific runner that we cannot enable universally.
+# We restrict it to builds under the $BUILD_IMAGES_PROJECT project.
+freebsd/x86_64:
+  image:
  script:
-    - csbuild
-      --build-dir=obj-csbuild
-      --build-cmd "rm -rf CMakeFiles CMakeCache.txt && cmake -DCMAKE_BUILD_TYPE=Debug -DPICKY_DEVELOPER=ON -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON -DFUZZ_TESTING=ON -DWITH_DSA=ON @SRCDIR@ && make clean && make -j$(nproc)"
-      --git-commit-range $CI_COMMIT_RANGE
-      --color
-      --print-current --print-fixed
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make && ctest --output-on-failure
+  tags:
+  - freebsd
+  except:
+  - tags
+  only:
+  - branches@libssh/libssh-mirror
+  - branches@cryptomilk/libssh-mirror
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

-fedora/csbuild/libgcrypt:
-  extends: .csbuild
+fedora/libgcrypt/x86_64:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - csbuild
-      --build-dir=obj-csbuild
-      --build-cmd "rm -rf CMakeFiles CMakeCache.txt && cmake -DCMAKE_BUILD_TYPE=Debug -DPICKY_DEVELOPER=ON -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON -DFUZZ_TESTING=ON -DWITH_GCRYPT=ON -DWITH_DSA=ON @SRCDIR@ && make clean && make -j$(nproc)"
-      --git-commit-range $CI_COMMIT_RANGE
-      --color
-      --print-current --print-fixed
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON
+    -DWITH_GCRYPT=ON -DWITH_DEBUG_CRYPTO=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

-fedora/csbuild/mbedtls:
-  extends: .csbuild
+fedora/mbedtls/x86_64:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$FEDORA_BUILD
  script:
-    - csbuild
-      --build-dir=obj-csbuild
-      --build-cmd "rm -rf CMakeFiles CMakeCache.txt && cmake -DCMAKE_BUILD_TYPE=Debug -DPICKY_DEVELOPER=ON -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON -DFUZZ_TESTING=ON -DWITH_MBEDTLS=ON @SRCDIR@ && make clean && make -j$(nproc)"
-      --git-commit-range $CI_COMMIT_RANGE
-      --color
-      --print-current --print-fixed
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON
+    -DWITH_MBEDTLS=ON -DWITH_DEBUG_CRYPTO=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

-
-###############################################################################
-#                               Ubuntu builds                                 #
-###############################################################################
-ubuntu/openssl_1.1.x/x86_64:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$UBUNTU_BUILD
-  extends: .tests
-
-
-###############################################################################
-#                               Alpine builds                                 #
-###############################################################################
-alpine/musl:
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$ALPINE_BUILD
-  extends: .tests
+# Unit testing only, no client and pkd testing, because cwrap is not available
+# for MinGW
+fedora/mingw64:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$MINGW_BUILD
  script:
-    - cmake $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON
-      -DWITH_SERVER=ON
-      -DWITH_ZLIB=ON
-      -DWITH_PCAP=ON
-      -DUNIT_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
+  - export WINEPATH=/usr/x86_64-w64-mingw32/sys-root/mingw/bin
+  - export WINEDEBUG=-all
+  - mkdir -p obj && cd obj && mingw64-cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make -j$(nproc) &&
+    ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/

+# Unit testing only, no client and pkd testing, because cwrap is not available
+# for MinGW
+fedora/mingw32:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$MINGW_BUILD
+  script:
+  - export WINEPATH=/usr/i686-w64-mingw32/sys-root/mingw/bin
+  - export WINEDEBUG=-all
+  - mkdir -p obj && cd obj && mingw32-cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make -j$(nproc) &&
+    ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+.Debian.cross.template: &Debian_cross_template
+  stage: test
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$DEBIAN_CROSS_BUILD
+  script:
+  - build=$(dpkg-architecture -qDEB_HOST_GNU_TYPE)
+  - host="${CI_JOB_NAME#*.cross.}"
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_C_COMPILER="$(which $host-gcc)"
+    -DCMAKE_CXX_COMPILER="$(which $host-g++)"
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DUNIT_TESTING=ON -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON
+    -DWITH_PCAP=ON .. &&
+    make -j$(nproc) &&
+    ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+.Debian.cross.mips-linux-gnu:
+  <<: *Debian_cross_template

-###############################################################################
-#                             Tumbleweed builds                               #
-###############################################################################
 tumbleweed/openssl_1.1.x/x86_64/gcc:
-  extends: .tumbleweed
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: "-DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config"
-
-tumbleweed/openssl_1.1.x/x86/gcc:
-  extends: .tumbleweed
-  script:
-    - cmake
-      -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-cross-m32.cmake
-      $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON
-      -DWITH_SERVER=ON
-      -DWITH_ZLIB=ON
-      -DWITH_PCAP=ON
-      -DWITH_DSA=ON
-      -DUNIT_TESTING=ON ..
-
-tumbleweed/openssl_1.1.x/x86_64/gcc7:
-  extends: .tumbleweed
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: "-DCMAKE_C_COMPILER=gcc-7 -DCMAKE_CXX_COMPILER=g++-7 -DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config"
-
-tumbleweed/openssl_1.1.x/x86/gcc7:
-  extends: .tumbleweed
-  script:
-    - cmake
-      -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-cross-m32.cmake
-      -DCMAKE_C_COMPILER=gcc-7 -DCMAKE_CXX_COMPILER=g++-7
-      $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
-      -DWITH_DSA=ON
-      -DUNIT_TESTING=ON .. &&
-      make -j$(nproc) &&
-      ctest --output-on-failure
-
-tumbleweed/openssl_1.1.x/x86_64/clang:
-  extends: .tumbleweed
-  variables:
-    CMAKE_ADDITIONAL_OPTIONS: "-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config"
-
-tumbleweed/static-analysis:
-  extends: .tests
-  stage: analysis
  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
  script:
-    - export CCC_CC=clang
-    - export CCC_CXX=clang++
-    - scan-build cmake
-      -DCMAKE_BUILD_TYPE=Debug
-      -DCMAKE_C_COMPILER=clang
-      -DCMAKE_CXX_COMPILER=clang++
-      -DPICKY_DEVELOPER=ON
-      $CMAKE_BUILD_OPTIONS
-      $CMAKE_TEST_OPTIONS .. &&
-      scan-build --status-bugs -o scan make -j$(nproc)
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/openssl_1.1.x/x86/gcc:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-cross-m32.cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/openssl_1.1.x/x86_64/gcc7:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_C_COMPILER=gcc-7 -DCMAKE_CXX_COMPILER=g++-7
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/openssl_1.1.x/x86/gcc7:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-cross-m32.cmake
+    -DCMAKE_C_COMPILER=gcc-7 -DCMAKE_CXX_COMPILER=g++-7
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/openssl_1.1.x/x86_64/clang:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DKRB5_CONFIG=/usr/lib/mit/bin/krb5-config
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/docs:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake .. && make docs
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/undefined-sanitizer:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - mkdir -p obj && cd obj && cmake
+    -DCMAKE_BUILD_TYPE=UndefinedSanitizer
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    make -j$(nproc) && ctest --output-on-failure
+  tags:
+  - shared
+  except:
+  - tags
+  artifacts:
+    expire_in: 1 week
+    when: on_failure
+    paths:
+      - obj/
+
+tumbleweed/static-analysis:
+  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$TUMBLEWEED_BUILD
+  script:
+  - export CCC_CC=clang
+  - export CCC_CXX=clang++
+  - mkdir -p obj && cd obj && scan-build cmake
+    -DCMAKE_BUILD_TYPE=Debug
+    -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+    -DPICKY_DEVELOPER=ON
+    -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+    -DUNIT_TESTING=ON -DCLIENT_TESTING=ON -DSERVER_TESTING=ON .. &&
+    scan-build --status-bugs -o scan make -j$(nproc)
+  tags:
+  - shared
+  except:
+  - tags
  artifacts:
    expire_in: 1 week
    when: on_failure
    paths:
      - obj/scan

-
-###############################################################################
-#                               FreeBSD builds                                #
-###############################################################################
-# That is a specific runner that we cannot enable universally.
-# We restrict it to builds under the $BUILD_IMAGES_PROJECT project.
-freebsd/x86_64:
-  image:
-  extends: .tests
-  before_script:
-    - mkdir -p obj && cd obj && cmake
-      -DCMAKE_BUILD_TYPE=RelWithDebInfo
+visualstudio/x86_64:
+  script:
+  - $env:VCPKG_DEFAULT_TRIPLET="x64-windows"
+  - cd obj
+  - cmake
+      -A x64
+      -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_TOOLCHAIN_FILE"
      -DPICKY_DEVELOPER=ON
      -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
      -DUNIT_TESTING=ON ..
-  script:
-    - cmake $CMAKE_DEFAULT_OPTIONS
-      -DWITH_SFTP=ON
-      -DWITH_SERVER=ON
-      -DWITH_ZLIB=ON
-      -DWITH_PCAP=ON
-      -DUNIT_TESTING=ON .. &&
-      make &&
-      ctest --output-on-failure
+  - cmake --build .
+  - ctest --output-on-failure
  tags:
-    - private
-    - freebsd
-  only:
-    - branches@libssh/libssh-mirror
-    - branches@cryptomilk/libssh-mirror
-    - branches@jjelen/libssh-mirror
-    - branches@marco.fortina/libssh-mirror
-
-
-###############################################################################
-#                           Visual Studio builds                              #
-###############################################################################
-.vs:
-  stage: test
-  cache:
-    key: vcpkg.${CI_JOB_NAME}
-    paths:
-      - .vcpkg
-  variables:
-    ErrorActionPreference: STOP
-  script:
-    - cmake --build .
-    - ctest --output-on-failure
-  tags:
-    - windows
-    - shared-windows
+  - vs2017
+  - windows
  except:
-    - tags
+  - tags
+  only:
+  - branches@libssh/libssh-mirror
+  - branches@ansasaki/libssh-mirror
+  - branches@cryptomilk/libssh-mirror
+  - branches@jjelen/libssh-mirror
  artifacts:
    expire_in: 1 week
    when: on_failure
    paths:
      - obj/
-  before_script:
-    - choco install --no-progress -y cmake
-    - $env:Path += ';C:\Program Files\CMake\bin'
-    - If (!(test-path .vcpkg\archives)) { mkdir -p .vcpkg\archives }
-    - $env:VCPKG_DEFAULT_BINARY_CACHE="$PWD\.vcpkg\archives"
-    - echo $env:VCPKG_DEFAULT_BINARY_CACHE
-    - $env:VCPKG_DEFAULT_TRIPLET="$TRIPLET-windows"
-    - vcpkg install cmocka
-    - vcpkg install openssl
-    - vcpkg install zlib
-    - vcpkg integrate install
-    - mkdir -p obj; if ($?) {cd obj}; if (! $?) {exit 1}
-    - cmake
-        -A $PLATFORM
-        -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake
-        -DPICKY_DEVELOPER=ON
-        -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
-        -DUNIT_TESTING=ON ..
-
-visualstudio/x86_64:
-  extends: .vs
-  variables:
-    PLATFORM: "x64"
-    TRIPLET: "x64"

 visualstudio/x86:
-  extends: .vs
-  variables:
-    PLATFORM: "win32"
-    TRIPLET: "x86"
-
-###############################################################################
-#                                 Coverity                                    #
-###############################################################################
-#
-# git push -o ci.variable="COVERITY_SCAN_TOKEN=XXXXXX" \
-#          -o ci.variable="COVERITY_SCAN_PROJECT_NAME=XXXXXX" \
-#          -o ci.variable="COVERITY_SCAN_EMAIL=XXXXXX" \
-#          -f gitlab
-
-coverity:
-  stage: analysis
-  image: $CI_REGISTRY/$BUILD_IMAGES_PROJECT:$COVERITY_BUILD
  script:
-    - mkdir obj && cd obj
-    - wget https://scan.coverity.com/download/linux64 --post-data "token=$COVERITY_SCAN_TOKEN&project=$COVERITY_SCAN_PROJECT_NAME" -O /tmp/coverity_tool.tgz
-    - tar xf /tmp/coverity_tool.tgz
-    - cmake -DCMAKE_BUILD_TYPE=Debug $CMAKE_BUILD_OPTIONS $CMAKE_TEST_OPTIONS ..
-    - cov-analysis-linux64-*/bin/cov-build --dir cov-int make -j$(nproc)
-    - tar czf cov-int.tar.gz cov-int
-    - curl
-      --form token=$COVERITY_SCAN_TOKEN
-      --form email=$COVERITY_SCAN_EMAIL
-      --form file=@cov-int.tar.gz
-      --form version="`git describe --tags`"
-      --form description="CI build"
-      https://scan.coverity.com/builds?project=$COVERITY_SCAN_PROJECT_NAME
+  - $env:VCPKG_DEFAULT_TRIPLET="x86-windows"
+  - cd obj
+  - cmake
+      -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_TOOLCHAIN_FILE"
+      -DPICKY_DEVELOPER=ON
+      -DWITH_SFTP=ON -DWITH_SERVER=ON -DWITH_ZLIB=ON -DWITH_PCAP=ON
+      -DUNIT_TESTING=ON ..
+  - cmake --build .
+  - ctest --output-on-failure
  tags:
-    - shared
+  - vs2017
+  - windows
+  except:
+  - tags
  only:
-    refs:
-      - master
-      - schedules
-    variables:
-      - $COVERITY_SCAN_TOKEN != null
-      - $COVERITY_SCAN_PROJECT_NAME != null
-      - $COVERITY_SCAN_EMAIL != null
+  - branches@libssh/libssh-mirror
+  - branches@ansasaki/libssh-mirror
+  - branches@cryptomilk/libssh-mirror
+  - branches@jjelen/libssh-mirror
  artifacts:
    expire_in: 1 week
    when: on_failure
    paths:
-      - obj/cov-int/*.txt
+      - obj/
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.3.0)
 cmake_policy(SET CMP0048 NEW)

-# Specify search path for CMake modules to be loaded by include()
+# Specify search path for CMake modules to be loaded by include() 
 # and find_package()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")

@@ -10,7 +10,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
 include(DefineCMakeDefaults)
 include(DefineCompilerFlags)

-project(libssh VERSION 0.10.4 LANGUAGES C)
+project(libssh VERSION 0.9.1 LANGUAGES C)

 # global needed variable
 set(APPLICATION_NAME ${PROJECT_NAME})
@@ -22,7 +22,7 @@ set(APPLICATION_NAME ${PROJECT_NAME})
 #     Increment AGE. Set REVISION to 0
 #   If the source code was changed, but there were no interface changes:
 #     Increment REVISION.
-set(LIBRARY_VERSION "4.9.4")
+set(LIBRARY_VERSION "4.8.2")
 set(LIBRARY_SOVERSION "4")

 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
@@ -58,14 +58,8 @@ elseif(WITH_MBEDTLS)
      message(FATAL_ERROR "Could not find mbedTLS")
    endif (NOT MBEDTLS_FOUND)
 else (WITH_GCRYPT)
-  find_package(OpenSSL 1.0.1)
-  if (OPENSSL_FOUND)
-    # On CMake < 3.16, OPENSSL_CRYPTO_LIBRARIES is usually a synonym for OPENSSL_CRYPTO_LIBRARY, but is not defined
-    # when building on Windows outside of Cygwin. We provide the synonym here, if FindOpenSSL didn't define it already.
-    if (NOT DEFINED OPENSSL_CRYPTO_LIBRARIES)
-      set(OPENSSL_CRYPTO_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
-    endif (NOT DEFINED OPENSSL_CRYPTO_LIBRARIES)
-  else (OPENSSL_FOUND)
+  find_package(OpenSSL)
+  if (NOT OPENSSL_FOUND)
    find_package(GCrypt)
    if (NOT GCRYPT_FOUND)
      find_package(MbedTLS)
@@ -73,7 +67,7 @@ else (WITH_GCRYPT)
        message(FATAL_ERROR "Could not find OpenSSL, GCrypt or mbedTLS")
      endif (NOT MBEDTLS_FOUND)
    endif (NOT GCRYPT_FOUND)
-  endif (OPENSSL_FOUND)
+  endif (NOT OPENSSL_FOUND)
 endif(WITH_GCRYPT)

 if (UNIT_TESTING)
@@ -89,13 +83,6 @@ if (WITH_GSSAPI)
    find_package(GSSAPI)
 endif (WITH_GSSAPI)

-if (WITH_PKCS11_URI)
-    find_package(softhsm)
-    if (NOT SOFTHSM_FOUND)
-        message(SEND_ERROR "Could not find softhsm module!")
-     endif (NOT SOFTHSM_FOUND)
-endif (WITH_PKCS11_URI)
-
 if (WITH_NACL)
    find_package(NaCl)
    if (NOT NACL_FOUND)
@@ -103,9 +90,9 @@ if (WITH_NACL)
    endif (NOT NACL_FOUND)
 endif (WITH_NACL)

-if (BSD OR SOLARIS OR OSX OR CYGWIN)
+if (BSD OR SOLARIS OR OSX)
    find_package(Argp)
-endif (BSD OR SOLARIS OR OSX OR CYGWIN)
+endif (BSD OR SOLARIS OR OSX)

 # Disable symbol versioning in non UNIX platforms
 if (UNIX)
@@ -124,7 +111,7 @@ add_subdirectory(include)
 add_subdirectory(src)

 # pkg-config file
-if (UNIX OR MINGW)
+if (UNIX)
 configure_file(libssh.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libssh.pc)
 install(
  FILES
@@ -134,7 +121,7 @@ install(
  COMPONENT
    pkgconfig
 )
-endif (UNIX OR MINGW)
+endif (UNIX)

 # CMake config files
 include(CMakePackageConfigHelpers)
@@ -216,10 +203,10 @@ if (WITH_SYMBOL_VERSIONING AND ABIMAP_FOUND)
    endif(UPDATE_ABI)
 endif (WITH_SYMBOL_VERSIONING AND ABIMAP_FOUND)

-add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source DEPENDS ${_SYMBOL_TARGET} VERBATIM)
+add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source DEPENDS ${_SYMBOL_TARGET})

 # Link compile database for clangd
-execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
+execute_process(COMMAND cmake -E create_symlink
                "${CMAKE_BINARY_DIR}/compile_commands.json"
                "${CMAKE_SOURCE_DIR}/compile_commands.json")

@@ -234,14 +221,11 @@ message(STATUS "SFTP support: ${WITH_SFTP}")
 message(STATUS "Server support : ${WITH_SERVER}")
 message(STATUS "GSSAPI support : ${WITH_GSSAPI}")
 message(STATUS "GEX support : ${WITH_GEX}")
-message(STATUS "Support insecure none cipher and MAC : ${WITH_INSECURE_NONE}")
 message(STATUS "Pcap debugging support : ${WITH_PCAP}")
-message(STATUS "Build shared library: ${BUILD_SHARED_LIBS}")
+message(STATUS "With static library: ${WITH_STATIC_LIB}")
 message(STATUS "Unit testing: ${UNIT_TESTING}")
 message(STATUS "Client code testing: ${CLIENT_TESTING}")
 message(STATUS "Blowfish cipher support: ${WITH_BLOWFISH_CIPHER}")
-message(STATUS "PKCS #11 URI support: ${WITH_PKCS11_URI}")
-message(STATUS "DSA support: ${WITH_DSA}")
 set(_SERVER_TESTING OFF)
 if (WITH_SERVER)
    set(_SERVER_TESTING ${SERVER_TESTING})
--- a/CPackConfig.cmake
+++ b/CPackConfig.cmake
@@ -10,7 +10,7 @@ set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})

 # SOURCE GENERATOR
 set(CPACK_SOURCE_GENERATOR "TXZ")
-set(CPACK_SOURCE_IGNORE_FILES "~$;[.]swp$;/[.]git/;/[.]clangd/;/[.]cache/;.gitignore;/build*;/obj*;tags;cscope.*;compile_commands.json;.*\.patch")
+set(CPACK_SOURCE_IGNORE_FILES "~$;[.]swp$;/[.]git/;.gitignore;/build*;/obj*;tags;cscope.*")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")

 ### NSIS INSTALLER
@@ -23,7 +23,7 @@ if (WIN32)
        set(CPACK_GENERATOR "${CPACK_GENERATOR};NSIS")
        set(CPACK_NSIS_DISPLAY_NAME "The SSH Library")
        set(CPACK_NSIS_COMPRESSOR "/SOLID zlib")
-        set(CPACK_NSIS_MENU_LINKS "https://www.libssh.org/" "libssh homepage")
+        set(CPACK_NSIS_MENU_LINKS "http://www.libssh.org/" "libssh homepage")
    endif (NSIS_MAKE)
 endif (WIN32)

--- a/177
+++ b/177
@@ -1,101 +1,5 @@
-CHANGELOG
-=========
-
-version 0.10.4 (released 2022-09-07)
-  * Fixed issues with KDF on big endian
-
-version 0.10.3 (released 2022-09-05)
-  * Fixed possible infinite loop in known hosts checking
-
-version 0.10.2 (released 2022-09-02)
-  * Fixed tilde expansion when handling include directives
-  * Fixed building the shared torture library
-  * Made rekey test more robust (fixes running on i586 build systems e.g koji)
-
-version 0.10.1 (released 2022-08-30)
-  * Fixed proxycommand support
-  * Fixed musl libc support
-
-version 0.10.0 (released 2022-08-26)
-  * Added support for OpenSSL 3.0
-  * Added support for mbedTLS 3
-  * Added support for Smart Cards  (through openssl pkcs11 engine)
-  * Added support for chacha20-poly1305@openssh.com with libgcrypt
-  * Added support ed25519 keys in PEM files
-  * Added support for sk-ecdsa and sk-ed25519 (server side)
-  * Added support for limiting RSA key sizes and not accepting small one by
-    default
-  * Added support for ssh-agent on Windows
-  * Added ssh_userauth_publickey_auto_get_current_identity() API
-  * Added ssh_vlog() API
-  * Added ssh_send_issue_banner() API
-  * Added ssh_session_set_disconnect_message() API
-  * Added new configuration options:
-    + IdentityAgent
-    + ModuliFile
-  * Provided X11 client example
-  * Disabled DSA support at build time by default (will be removed in the next
-    release)
-  * Deprecated the SCP API!
-  * Deprecated old pubkey, privatekey API
-  * Avoided some needless large stack buffers to minimize memory footprint
-  * Removed support for OpenSSL < 1.0.1
-  * Fixed parsing username@host in login name
-  * Free global init mutex in the destructor on Windows
-  * Fixed PEM parsing in mbedtls to support both legacy and new PKCS8 formats
-
-version 0.9.6 (released 2021-08-26)
-  * CVE-2021-3634: Fix possible heap-buffer overflow when rekeying with
-    different key exchange mechanism
-  * Fix several memory leaks on error paths
-  * Reset pending_call_state on disconnect
-  * Fix handshake bug with AEAD ciphers and no HMAC overlap
-  * Use OPENSSL_CRYPTO_LIBRARIES in CMake
-  * Ignore request success and failure message if they are not expected
-  * Support more identity files in configuration
-  * Avoid setting compiler flags directly in CMake
-  * Support build directories with special characters
-  * Include stdlib.h to avoid crash in Windows
-  * Fix sftp_new_channel constructs an invalid object
-  * Fix Ninja multiple rules error
-  * Several tests fixes
-
-version 0.9.5 (released 2020-09-10)
-  * CVE-2020-16135: Avoid null pointer dereference in sftpserver (T232)
-  * Improve handling of library initialization (T222)
-  * Fix parsing of subsecond times in SFTP (T219)
-  * Make the documentation reproducible
-  * Remove deprecated API usage in OpenSSL
-  * Fix regression of ssh_channel_poll_timeout() returning SSH_AGAIN
-  * Define version in one place (T226)
-  * Prevent invalid free when using different C runtimes than OpenSSL (T229)
-  * Compatibility improvements to testsuite
-
-version 0.9.4 (released 2020-04-09)
-  * Fixed CVE-2020-1730 - Possible DoS in client and server when handling
-    AES-CTR keys with OpenSSL
-  * Added diffie-hellman-group14-sha256
-  * Fixed serveral possible memory leaks
-
-version 0.9.3 (released 2019-12-10)
-  * Fixed CVE-2019-14889 - SCP: Unsanitized location leads to command execution
-  * SSH-01-003 Client: Missing NULL check leads to crash in erroneous state
-  * SSH-01-006 General: Various unchecked Null-derefs cause DOS
-  * SSH-01-007 PKI Gcrypt: Potential UAF/double free with RSA pubkeys
-  * SSH-01-010 SSH: Deprecated hash function in fingerprinting
-  * SSH-01-013 Conf-Parsing: Recursive wildcards in hostnames lead to DOS
-  * SSH-01-014 Conf-Parsing: Integer underflow leads to OOB array access
-  * SSH-01-001 State Machine: Initial machine states should be set explicitly
-  * SSH-01-002 Kex: Differently bound macros used to iterate same array
-  * SSH-01-005 Code-Quality: Integer sign confusion during assignments
-  * SSH-01-008 SCP: Protocol Injection via unescaped File Names
-  * SSH-01-009 SSH: Update documentation which RFCs are implemented
-  * SSH-01-012 PKI: Information leak via uninitialized stack buffer
-
-version 0.9.2 (released 2019-11-07)
-  * Fixed libssh-config.cmake
-  * Fixed issues with rsa algorithm negotiation (T191)
-  * Fixed detection of OpenSSL ed25519 support (T197)
+ChangeLog
+==========

 version 0.9.1 (released 2019-10-25)
  * Added support for Ed25519 via OpenSSL
@@ -111,7 +15,7 @@ version 0.9.1 (released 2019-10-25)
  * Fixed deprecation issues (T165)
  * Fixed known_hosts directory creation (T166)

-version 0.9.0 (released 2019-02-xx)
+version 0.9.0 (released 2019-06-28)
  * Added support for AES-GCM
  * Added improved rekeying support
  * Added performance improvements
@@ -126,6 +30,71 @@ version 0.9.0 (released 2019-02-xx)
  * Improved documentation
  * Improved OpenSSL API usage for KEX, DH, and signatures

+version 0.8.7 (released 2019-02-25)
+  * Fixed handling extension flags in the server implementation
+  * Fixed exporting ed25519 private keys
+  * Fixed corner cases for rsa-sha2 signatures
+  * Fixed some issues with connector
+
+version 0.8.6 (released 2018-12-24)
+  * Fixed compilation issues with different OpenSSL versions
+  * Fixed StrictHostKeyChecking in new knownhosts API
+  * Fixed ssh_send_keepalive() with packet filter
+  * Fixed possible crash with knownhosts options
+  * Fixed issus with rekeying
+  * Fixed strong ECDSA keys
+  * Fixed some issues with rsa-sha2 extentions
+  * Fixed access violation in ssh_init() (static linking)
+  * Fixed ssh_channel_close() handling
+
+version 0.8.5 (released 2018-10-29)
+  * Added support to get known_hosts locations with ssh_options_get()
+  * Fixed preferred algorithm for known hosts negotiations
+  * Fixed KEX with some server implementations (e.g. Cisco)
+  * Fixed issues with MSVC
+  * Fixed keyboard-interactive auth in server mode
+    (regression from CVE-2018-10933)
+  * Fixed gssapi auth in server mode (regression from CVE-2018-10933)
+  * Fixed socket fd handling with proxy command
+  * Fixed a memory leak with OpenSSL
+
+version 0.8.4 (released 2018-10-16)
+  * Fixed CVE-2018-10933
+  * Fixed building without globbing support
+  * Fixed possible memory leaks
+  * Avoid SIGPIPE on sockets
+
+version 0.8.3 (released 2018-09-21)
+  * Added support for rsa-sha2
+  * Added support to parse private keys in openssh container format
+    (other than ed25519)
+  * Added support for diffie-hellman-group18-sha512 and
+    diffie-hellman-group16-sha512
+  * Added ssh_get_fingerprint_hash()
+  * Added ssh_pki_export_privkey_base64()
+  * Added support for Match keyword in config file
+  * Improved performance and reduced memory footprint for sftp
+  * Fixed ecdsa publickey auth
+  * Fixed reading a closed channel
+  * Added support to announce posix-rename@openssh.com and
+    hardlink@openssh.com in the sftp server
+
+version 0.8.2 (released 2018-08-30)
+  * Added sha256 fingerprints for pubkeys
+  * Improved compiler flag detection
+  * Fixed race condition in reading sftp messages
+  * Fixed doxygen generation and added modern style
+  * Fixed library initialization on Windows
+  * Fixed __bounded__ attribute detection
+  * Fixed a bug in the options parser
+  * Fixed documentation for new knwon_hosts API
+
+version 0.8.1 (released 2018-08-13)
+  * Fixed version number in the header
+  * Fixed version number in pkg-config and cmake config
+  * Fixed library initialization
+  * Fixed attribute detection
+
 version 0.8.0 (released 2018-08-10)
  * Removed support for deprecated SSHv1 protocol
  * Added new connector API for clients
@@ -460,6 +429,14 @@ version 0.3.2 (released 2009-08-05)
  * Fixed compilation on Solaris.
  * Fixed SSHv1 compilation.

+version 0.3.1 (released 2009-07-14)
+  * Added return code SSH_SERVER_FILE_NOT_FOUND.
+  * Fixed compilation of SSHv1.
+  * Fixed several memory leaks.
+  * Fixed possible infinite loops.
+  * Fixed a possible crash bug.
+  * Fixed build warnings.
+  * Fixed cmake on BSD.
 version 0.3.1 (released 2009-07-14)
  * Added return code SSH_SERVER_FILE_NOT_FOUND.
  * Fixed compilation of SSHv1.
@@ -509,7 +486,7 @@ version 0.2 (released 2007-11-29)
 version 0.11-dev
  * Server implementation development.
  * Small bug corrected when connecting to sun ssh servers.
-  * Channel weirdness corrected (writing huge data packets)
+  * Channel wierdness corrected (writing huge data packets)
  * Channel_read_nonblocking added
  * Channel bug where stderr wasn't correctly read fixed.
  * Added sftp_file_set_nonblocking(), which is nonblocking SFTP IO
--- a/CompilerChecks.cmake
+++ b/CompilerChecks.cmake
@@ -42,7 +42,6 @@ if (UNIX)
    add_c_compiler_flag("-Wstrict-overflow=2" SUPPORTED_COMPILER_FLAGS)
    add_c_compiler_flag("-Wno-format-zero-length" SUPPORTED_COMPILER_FLAGS)
    add_c_compiler_flag("-Wmissing-field-initializers" SUPPORTED_COMPILER_FLAGS)
-    add_c_compiler_flag("-Wsign-compare" SUPPORTED_COMPILER_FLAGS)

    check_c_compiler_flag("-Wformat" REQUIRED_FLAGS_WFORMAT)
    if (REQUIRED_FLAGS_WFORMAT)
@@ -85,11 +84,9 @@ if (UNIX)
        endif()
    endif (WITH_STACK_PROTECTOR_STRONG)

-    if (NOT WINDOWS AND NOT CYGWIN)
-        check_c_compiler_flag_ssp("-fstack-clash-protection" WITH_STACK_CLASH_PROTECTION)
-        if (WITH_STACK_CLASH_PROTECTION)
-            list(APPEND SUPPORTED_COMPILER_FLAGS "-fstack-clash-protection")
-        endif()
+    check_c_compiler_flag_ssp("-fstack-clash-protection" WITH_STACK_CLASH_PROTECTION)
+    if (WITH_STACK_CLASH_PROTECTION)
+        list(APPEND SUPPORTED_COMPILER_FLAGS "-fstack-clash-protection")
    endif()

    if (PICKY_DEVELOPER)
--- a/ConfigureChecks.cmake
+++ b/ConfigureChecks.cmake
@@ -101,50 +101,57 @@ if (OPENSSL_FOUND)
    check_include_file(openssl/ecdsa.h HAVE_OPENSSL_ECDSA_H)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(EVP_aes_128_ctr HAVE_OPENSSL_EVP_AES_CTR)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(EVP_aes_128_cbc HAVE_OPENSSL_EVP_AES_CBC)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(EVP_aes_128_gcm HAVE_OPENSSL_EVP_AES_GCM)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(CRYPTO_THREADID_set_callback HAVE_OPENSSL_CRYPTO_THREADID_SET_CALLBACK)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(CRYPTO_ctr128_encrypt HAVE_OPENSSL_CRYPTO_CTR128_ENCRYPT)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_function_exists(EVP_CIPHER_CTX_new HAVE_OPENSSL_EVP_CIPHER_CTX_NEW)
+
+    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_function_exists(EVP_KDF_CTX_new_id HAVE_OPENSSL_EVP_KDF_CTX_NEW_ID)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
-    check_function_exists(EVP_KDF_CTX_new HAVE_OPENSSL_EVP_KDF_CTX_NEW)
-
-    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_function_exists(FIPS_mode HAVE_OPENSSL_FIPS_MODE)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_function_exists(RAND_priv_bytes HAVE_OPENSSL_RAND_PRIV_BYTES)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_function_exists(EVP_DigestSign HAVE_OPENSSL_EVP_DIGESTSIGN)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_function_exists(EVP_DigestVerify HAVE_OPENSSL_EVP_DIGESTVERIFY)

    check_function_exists(OPENSSL_ia32cap_loc HAVE_OPENSSL_IA32CAP_LOC)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
-    check_symbol_exists(EVP_PKEY_ED25519 "openssl/evp.h" FOUND_OPENSSL_ED25519)
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+    check_symbol_exists(EVP_PKEY_ED25519 "openssl/evp.h" HAVE_OPENSSL_ED25519)

    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
-    check_function_exists(EVP_chacha20 HAVE_OPENSSL_EVP_CHACHA20)
-
-    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
-    check_symbol_exists(EVP_PKEY_POLY1305 "openssl/evp.h" HAVE_OPENSSL_EVP_POLY1305)
-
-    if (HAVE_OPENSSL_EVP_DIGESTSIGN AND HAVE_OPENSSL_EVP_DIGESTVERIFY AND
-        FOUND_OPENSSL_ED25519)
-        set(HAVE_OPENSSL_ED25519 1)
-    endif()
-
-    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
    check_symbol_exists(EVP_PKEY_X25519 "openssl/evp.h" HAVE_OPENSSL_X25519)

    unset(CMAKE_REQUIRED_INCLUDES)
@@ -163,18 +170,11 @@ if (NOT WITH_GCRYPT AND NOT WITH_MBEDTLS)
    if (HAVE_OPENSSL_ECC)
        set(HAVE_ECC 1)
    endif (HAVE_OPENSSL_ECC)
-
-    if (HAVE_OPENSSL_EVP_KDF_CTX_NEW_ID OR HAVE_OPENSSL_EVP_KDF_CTX_NEW)
-        set(HAVE_OPENSSL_EVP_KDF_CTX 1)
-    endif (HAVE_OPENSSL_EVP_KDF_CTX_NEW_ID OR HAVE_OPENSSL_EVP_KDF_CTX_NEW)
-
 endif ()

-if (WITH_DSA)
-    if (NOT WITH_MBEDTLS)
-        set(HAVE_DSA 1)
-    endif (NOT WITH_MBEDTLS)
-endif()
+if (NOT WITH_MBEDTLS)
+    set(HAVE_DSA 1)
+endif (NOT WITH_MBEDTLS)

 # FUNCTIONS

@@ -273,20 +273,11 @@ if (GCRYPT_FOUND)
        set(HAVE_GCRYPT_ECC 1)
        set(HAVE_ECC 1)
    endif (GCRYPT_VERSION VERSION_GREATER "1.4.6")
-    if (NOT GCRYPT_VERSION VERSION_LESS "1.7.0")
-        set(HAVE_GCRYPT_CHACHA_POLY 1)
-    endif (NOT GCRYPT_VERSION VERSION_LESS "1.7.0")
 endif (GCRYPT_FOUND)

 if (MBEDTLS_FOUND)
    set(HAVE_LIBMBEDCRYPTO 1)
    set(HAVE_ECC 1)
-
-    set(CMAKE_REQUIRED_INCLUDES "${MBEDTLS_INCLUDE_DIR}/mbedtls")
-    check_include_file(chacha20.h HAVE_MBEDTLS_CHACHA20_H)
-    check_include_file(poly1305.h HAVE_MBEDTLS_POLY1305_H)
-    unset(CMAKE_REQUIRED_INCLUDES)
-
 endif (MBEDTLS_FOUND)

 if (CMAKE_USE_PTHREADS_INIT)
@@ -375,23 +366,6 @@ int main(void) {
    return 0;
 }" HAVE_FALLTHROUGH_ATTRIBUTE)

-check_c_source_compiles("
-#define WEAK __attribute__((weak))
-
-WEAK int sum(int a, int b)
-{
-    return a + b;
-}
-
-int main(void)
-{
-    int i = sum(2, 2);
-
-    (void)i;
-
-    return 0;
-}" HAVE_WEAK_ATTRIBUTE)
-
 if (NOT WIN32)
    check_c_source_compiles("
    #define __unused __attribute__((unused))
@@ -485,28 +459,6 @@ if (WITH_GSSAPI AND NOT GSSAPI_FOUND)
    set(WITH_GSSAPI 0)
 endif (WITH_GSSAPI AND NOT GSSAPI_FOUND)

-if (WITH_PKCS11_URI)
-    if (WITH_GCRYPT)
-        message(FATAL_ERROR "PKCS #11 is not supported for gcrypt.")
-        set(WITH_PKCS11_URI 0)
-    endif()
-    if (WITH_MBEDTLS)
-        message(FATAL_ERROR "PKCS #11 is not supported for mbedcrypto")
-        set(WITH_PKCS11_URI 0)
-    endif()
-    if (HAVE_OPENSSL AND NOT OPENSSL_VERSION VERSION_GREATER_EQUAL "1.1.1")
-        message(FATAL_ERROR "PKCS #11 requires at least OpenSSL 1.1.1")
-        set(WITH_PKCS11_URI 0)
-    endif()
-endif()
-
-if (WITH_MBEDTLS)
-    if (WITH_DSA)
-        message(FATAL_ERROR "DSA is not supported with mbedTLS crypto")
-        set(HAVE_DSA 0)
-    endif()
-endif()
-
 # ENDIAN
 if (NOT WIN32)
    test_big_endian(WORDS_BIGENDIAN)
--- a/DefineOptions.cmake
+++ b/DefineOptions.cmake
@@ -2,17 +2,15 @@ option(WITH_GSSAPI "Build with GSSAPI support" ON)
 option(WITH_ZLIB "Build with ZLIB support" ON)
 option(WITH_SFTP "Build with SFTP support" ON)
 option(WITH_SERVER "Build with SSH server support" ON)
+option(WITH_STATIC_LIB "Build with a static library" OFF)
 option(WITH_DEBUG_CRYPTO "Build with cryto debug output" OFF)
 option(WITH_DEBUG_PACKET "Build with packet debug output" OFF)
 option(WITH_DEBUG_CALLTRACE "Build with calltrace debug output" ON)
-option(WITH_DSA "Build with DSA" OFF)
 option(WITH_GCRYPT "Compile against libgcrypt" OFF)
 option(WITH_MBEDTLS "Compile against libmbedtls" OFF)
 option(WITH_BLOWFISH_CIPHER "Compile with blowfish support" OFF)
 option(WITH_PCAP "Compile with Pcap generation support" ON)
 option(WITH_INTERNAL_DOC "Compile doxygen internal documentation" OFF)
-option(BUILD_SHARED_LIBS "Build shared libraries" ON)
-option(WITH_PKCS11_URI "Build with PKCS#11 URI support" OFF)
 option(UNIT_TESTING "Build with unit tests" OFF)
 option(CLIENT_TESTING "Build with client tests; requires openssh" OFF)
 option(SERVER_TESTING "Build with server tests; requires openssh and dropbear" OFF)
@@ -22,8 +20,7 @@ option(WITH_NACL "Build with libnacl (curve25519)" ON)
 option(WITH_SYMBOL_VERSIONING "Build with symbol versioning" ON)
 option(WITH_ABI_BREAK "Allow ABI break" OFF)
 option(WITH_GEX "Enable DH Group exchange mechanisms" ON)
-option(WITH_INSECURE_NONE "Enable insecure none cipher and MAC algorithms (not suitable for production!)" OFF)
-option(FUZZ_TESTING "Build with fuzzer for the server and client (automatically enables none cipher!)" OFF)
+option(FUZZ_TESTING "Build with fuzzer for the server" OFF)
 option(PICKY_DEVELOPER "Build with picky developer flags" OFF)

 if (WITH_ZLIB)
@@ -37,9 +34,13 @@ if (WITH_BENCHMARKS)
  set(CLIENT_TESTING ON)
 endif()

-if (UNIT_TESTING OR CLIENT_TESTING OR SERVER_TESTING)
+if (WITH_STATIC_LIB)
+    set(BUILD_STATIC_LIB ON)
+endif (WITH_STATIC_LIB)
+
+if (UNIT_TESTING)
  set(BUILD_STATIC_LIB ON)
-endif()
+endif (UNIT_TESTING)

 if (WITH_NACL)
  set(WITH_NACL ON)
@@ -56,7 +57,3 @@ endif (NOT GLOBAL_BIND_CONFIG)
 if (NOT GLOBAL_CLIENT_CONFIG)
  set(GLOBAL_CLIENT_CONFIG "/etc/ssh/ssh_config")
 endif (NOT GLOBAL_CLIENT_CONFIG)
-
-if (FUZZ_TESTING)
-  set(WITH_INSECURE_NONE ON)
-endif (FUZZ_TESTING)
--- a/10
+++ b/10
@@ -7,11 +7,11 @@
 In order to build libssh, you need to install several components:

 - A C compiler
- [CMake](https://www.cmake.org) >= 3.3.0
- [openssl](https://www.openssl.org) >= 1.0.1
+- [CMake](http://www.cmake.org) >= 2.6.0.
+- [openssl](http://www.openssl.org) >= 0.9.8
 or
- [gcrypt](https://www.gnu.org/directory/Security/libgcrypt.html) >= 1.4
- [libz](https://www.zlib.net) >= 1.2
+- [gcrypt](http://www.gnu.org/directory/Security/libgcrypt.html) >= 1.4
+- [libz](http://www.zlib.net) >= 1.2

 optional:
 - [cmocka](https://cmocka.org/) >= 1.1.0
@@ -117,4 +117,4 @@ This document is written using [Markdown][] syntax, making it possible to
 provide usable information in both plain text and HTML format. Whenever
 modifying this document please use [Markdown][] syntax.

-[markdown]: https://www.daringfireball.net/projects/markdown
+[markdown]: http://www.daringfireball.net/projects/markdown
--- a/4
+++ b/4
@@ -31,12 +31,12 @@ If you ask yourself how to compile libssh, please read INSTALL before anything.
 3* Where ?
 -_-_-_-_-_-_

-https://www.libssh.org
+http://www.libssh.org

 4* Contributing
 -_-_-_-_-_-_-_-_-_

-Please read the file 'CONTRIBUTING.md' next to this README file. It explains
+Please read the file 'SubmittingPatches' next to this README file. It explains
 our copyright policy and how you should send patches for upstream inclusion.

 Have fun and happy libssh hacking!
--- a/README.CodingStyle
+++ b/README.CodingStyle
@@ -1,126 +1,9 @@
-# How to contribute a patch to libssh
+Coding conventions in the libssh tree
+======================================

-Please checkout the libssh source code using git.
-
-For contributions we prefer Merge Requests on Gitlab:
-
-https://gitlab.com/libssh/libssh-mirror/
-
-This way you get continuous integration which runs the complete libssh
-testsuite for you.
-
-For larger code changes, breaking the changes up into a set of simple
-patches, each of which does a single thing, are much easier to review.
-Patch sets like that will most likely have an easier time being merged
-into the libssh code than large single patches that make lots of
-changes in one large diff.
-
-Also bugfixes and new features should be covered by tests. We use the cmocka
-and cwrap framework for our testing and you can simply run it locally by
-calling `make test`.
-
-## Ownership of the contributed code
-
-libssh is a project with distributed copyright ownership, which means
-we prefer the copyright on parts of libssh to be held by individuals
-rather than corporations if possible. There are historical legal
-reasons for this, but one of the best ways to explain it is that it's
-much easier to work with individuals who have ownership than corporate
-legal departments if we ever need to make reasonable compromises with
-people using and working with libssh.
-
-We track the ownership of every part of libssh via https://git.libssh.org,
-our source code control system, so we know the provenance of every piece
-of code that is committed to libssh.
-
-So if possible, if you're doing libssh changes on behalf of a company
-who normally owns all the work you do please get them to assign
-personal copyright ownership of your changes to you as an individual,
-that makes things very easy for us to work with and avoids bringing
-corporate legal departments into the picture.
-
-If you can't do this we can still accept patches from you owned by
-your employer under a standard employment contract with corporate
-copyright ownership. It just requires a simple set-up process first.
-
-We use a process very similar to the way things are done in the Linux
-Kernel community, so it should be very easy to get a sign off from
-your corporate legal department. The only changes we've made are to
-accommodate the license we use, which is LGPLv2 (or later) whereas the
-Linux kernel uses GPLv2.
-
-The process is called signing.
-
-## How to sign your work
-
-Once you have permission to contribute to libssh from your employer, simply
-email a copy of the following text from your corporate email address to:
-
-contributing@libssh.org
-
-
-```
-libssh Developer's Certificate of Origin. Version 1.0
-
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the appropriate
-    version of the GNU General Public License; or
-
-(b) The contribution is based upon previous work that, to the best of
-    my knowledge, is covered under an appropriate open source license
-    and I have the right under that license to submit that work with
-    modifications, whether created in whole or in part by me, under
-    the GNU General Public License, in the appropriate version; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a) or (b) and I have not modified it.
-
-(d) I understand and agree that this project and the contribution are
-    public and that a record of the contribution (including all
-    metadata and personal information I submit with it, including my
-    sign-off) is maintained indefinitely and may be redistributed
-    consistent with the libssh Team's policies and the requirements of
-    the GNU GPL where they are relevant.
-
-(e) I am granting this work to this project 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 the option of the project) any later version.
-
-    https://www.gnu.org/licenses/lgpl-2.1.html
-```
-
-We will maintain a copy of that email as a record that you have the
-rights to contribute code to libssh under the required licenses whilst
-working for the company where the email came from.
-
-Then when sending in a patch via the normal mechanisms described
-above, add a line that states:
-
-    Signed-off-by: Random J Developer <random@developer.example.org>
-
-using your real name and the email address you sent the original email
-you used to send the libssh Developer's Certificate of Origin to us
-(sorry, no pseudonyms or anonymous contributions.)
-
-That's it! Such code can then quite happily contain changes that have
-copyright messages such as:
-
-    (c) Example Corporation.
-
-and can be merged into the libssh codebase in the same way as patches
-from any other individual. You don't need to send in a copy of the
-libssh Developer's Certificate of Origin for each patch, or inside each
-patch. Just the sign-off message is all that is required once we've
-received the initial email.
-
-
-# Coding conventions in the libssh tree
-
-## Quick Start
+===========
+Quick Start
+===========

 Coding style guidelines are about reducing the number of unnecessary
 reformatting patches and making things easier for developers to work together.
@@ -153,28 +36,31 @@ are the highlights.
  have a copy of "The C Programming Language" anyways right?


-## Editor Hints
-
-### Emacs
+=============
+Editor Hints
+=============

+Emacs
+------
 Add the follow to your $HOME/.emacs file:

-    (add-hook 'c-mode-hook
-      (lambda ()
-          (c-set-style "linux")
-          (c-toggle-auto-state)))
+  (add-hook 'c-mode-hook
+    (lambda ()
+        (c-set-style "linux")
+        (c-toggle-auto-state)))


-## Neovim/VIM
+Vim
+----

 For the basic vi editor included with all variants of \*nix, add the
-following to ~/.config/nvim/init.rc or ~/.vimrc:
+following to $HOME/.vimrc:

    set ts=4 sw=4 et cindent

 You can use the Vim gitmodline plugin to store this in the git config:

-https://git.cryptomilk.org/projects/vim-gitmodeline.git/
+    http://git.cryptomilk.org/projects/vim-gitmodeline.git/

 For Vim, the following settings in $HOME/.vimrc will also deal with
 displaying trailing whitespace:
@@ -195,9 +81,12 @@ displaying trailing whitespace:
    autocmd BufNewFile,BufRead *.c,*.h exec 'match Todo /\%>' . &textwidth . 'v.\+/'


-## FAQ & Statement Reference
+==========================
+FAQ & Statement Reference
+==========================

-### Comments
+Comments
+---------

 Comments should always use the standard C syntax.  C++ style comments are not
 currently allowed.
@@ -274,7 +163,8 @@ This is bad:
     * This is a multi line comment,
     * with some more words...*/

-### Indention & Whitespace & 80 columns
+Indention & Whitespace & 80 columns
+------------------------------------

 To avoid confusion, indentations have to be 4 spaces. Do not use tabs!.  When
 wrapping parameters for function calls, align the parameter list with the first
@@ -290,7 +180,8 @@ splitting.  Never split a line before columns 70 - 79 unless you
 have a really good reason.  Be smart about formatting.


-### If, switch, & Code blocks
+If, switch, & Code blocks
+--------------------------

 Always follow an 'if' keyword with a space but don't include additional
 spaces following or preceding the parentheses in the conditional.
@@ -316,7 +207,7 @@ invoking functions.
 Braces for code blocks used by for, if, switch, while, do..while, etc.  should
 begin on the same line as the statement keyword and end on a line of their own.
 You should always include braces, even if the block only contains one
-statement.  **NOTE**: Functions are different and the beginning left brace should
+statement.  NOTE: Functions are different and the beginning left brace should
 be located in the first column on the next line.

 If the beginning statement has to be broken across lines due to length, the
@@ -363,7 +254,8 @@ Bad examples:
        print("I should be in braces.\n");


-### Goto
+Goto
+-----

 While many people have been academically taught that "goto"s are fundamentally
 evil, they can greatly enhance readability and reduce memory leaks when used as
@@ -395,13 +287,14 @@ Good Examples:
        return rc;
    }

-### Initialize pointers
+Initialize pointers
+-------------------

-All pointer variables **MUST** be initialized to `NULL`. History has
+All pointer variables MUST be initialized to NULL. History has
 demonstrated that uninitialized pointer variables have lead to various
 bugs and security issues.

-Pointers **MUST** be initialized even if the assignment directly follows
+Pointers MUST be initialized even if the assignment directly follows
 the declaration, like pointer2 in the example below, because the
 instructions sequence may change over time.

@@ -416,13 +309,15 @@ Good Example:

    pointer1 = some_func1();

-### Typedefs
+Typedefs
+---------

-libssh tries to avoid `typedef struct { .. } x_t;` so we do always try to use
-`struct x { .. };`. We know there are still such typedefs in the code, but for
+libssh tries to avoid "typedef struct { .. } x_t;" so we do always try to use
+"struct x { .. };". We know there are still such typedefs in the code, but for
 new code, please don't do that anymore.

-### Make use of helper variables
+Make use of helper variables
+-----------------------------

 Please try to avoid passing function calls as function parameters in new code.
 This makes the code much easier to read and it's also easier to use the "step"
@@ -472,13 +367,9 @@ an iterator style:
 But in general, please try to avoid this pattern.


-### Control-Flow changing macros
+Control-Flow changing macros
+-----------------------------

-Macros like `STATUS_NOT_OK_RETURN` that change control flow (return/goto/etc)
+Macros like STATUS_NOT_OK_RETURN that change control flow (return/goto/etc)
 from within the macro are considered bad, because they look like function calls
 that never change control flow. Please do not introduce them.
-
-
-Have fun and happy libssh hacking!
-
-The libssh Team
--- a/README.md
+++ b/README.md
@@ -1,5 +1,4 @@
 [![pipeline status](https://gitlab.com/libssh/libssh-mirror/badges/master/pipeline.svg)](https://gitlab.com/libssh/libssh-mirror/commits/master)
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/libssh.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:libssh)

 ```
  _   _   _                          _
@@ -37,7 +36,7 @@ https://www.libssh.org

 # Contributing

-Please read the file 'CONTRIBUTING.md' next to this README file. It explains
+Please read the file 'SubmittingPatches' next to this README file. It explains
 our copyright policy and how you should send patches for upstream inclusion.

 Have fun and happy libssh hacking!
--- a/118
+++ b/118
@@ -0,0 +1,118 @@
+How to contribute a patch to libssh
+====================================
+
+Please checkout the libssh source code using git. Change the code and then
+use  "git format-patch" to create a patch. The patch should be signed (see
+below) and send it to libssh@libssh.org, or attach it to a bug report at
+https://red.libssh.org/
+
+For larger code changes, breaking the changes up into a set of simple
+patches, each of which does a single thing, are much easier to review.
+Patch sets like that will most likely have an easier time being merged
+into the libssh code than large single patches that make lots of
+changes in one large diff.
+
+Ownership of the contributed code
+==================================
+
+libssh is a project with distributed copyright ownership, which means
+we prefer the copyright on parts of libssh to be held by individuals
+rather than corporations if possible. There are historical legal
+reasons for this, but one of the best ways to explain it is that it's
+much easier to work with individuals who have ownership than corporate
+legal departments if we ever need to make reasonable compromises with
+people using and working with libssh.
+
+We track the ownership of every part of libssh via http://git.libssh.org,
+our source code control system, so we know the provenance of every piece
+of code that is committed to libssh.
+
+So if possible, if you're doing libssh changes on behalf of a company
+who normally owns all the work you do please get them to assign
+personal copyright ownership of your changes to you as an individual,
+that makes things very easy for us to work with and avoids bringing
+corporate legal departments into the picture.
+
+If you can't do this we can still accept patches from you owned by
+your employer under a standard employment contract with corporate
+copyright ownership. It just requires a simple set-up process first.
+
+We use a process very similar to the way things are done in the Linux
+Kernel community, so it should be very easy to get a sign off from
+your corporate legal department. The only changes we've made are to
+accommodate the license we use, which is LGPLv2 (or later) whereas the
+Linux kernel uses GPLv2.
+
+The process is called signing.
+
+How to sign your work
+----------------------
+
+Once you have permission to contribute to libssh from your employer, simply
+email a copy of the following text from your corporate email address to:
+
+contributing@libssh.org
+
+
+
+libssh Developer's Certificate of Origin. Version 1.0
+
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the appropriate
+    version of the GNU General Public License; or
+
+(b) The contribution is based upon previous work that, to the best of
+    my knowledge, is covered under an appropriate open source license
+    and I have the right under that license to submit that work with
+    modifications, whether created in whole or in part by me, under
+    the GNU General Public License, in the appropriate version; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a) or (b) and I have not modified it.
+
+(d) I understand and agree that this project and the contribution are
+    public and that a record of the contribution (including all
+    metadata and personal information I submit with it, including my
+    sign-off) is maintained indefinitely and may be redistributed
+    consistent with the libssh Team's policies and the requirements of
+    the GNU GPL where they are relevant.
+
+(e) I am granting this work to this project 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 the option of the project) any later version.
+
+    http://www.gnu.org/licenses/lgpl-2.1.html
+
+
+We will maintain a copy of that email as a record that you have the
+rights to contribute code to libssh under the required licenses whilst
+working for the company where the email came from.
+
+Then when sending in a patch via the normal mechanisms described
+above, add a line that states:
+
+   Signed-off-by: Random J Developer <random@developer.example.org>
+
+using your real name and the email address you sent the original email
+you used to send the libssh Developer's Certificate of Origin to us
+(sorry, no pseudonyms or anonymous contributions.)
+
+That's it! Such code can then quite happily contain changes that have
+copyright messages such as:
+
+   (c) Example Corporation.
+
+and can be merged into the libssh codebase in the same way as patches
+from any other individual. You don't need to send in a copy of the
+libssh Developer's Certificate of Origin for each patch, or inside each
+patch. Just the sign-off message is all that is required once we've
+received the initial email.
+
+Have fun and happy libssh hacking !
+
+The libssh Team
+
--- a/cmake/Modules/DefineCompilerFlags.cmake
+++ b/cmake/Modules/DefineCompilerFlags.cmake
@@ -36,9 +36,9 @@ if (UNIX AND NOT WIN32)
        CACHE STRING "Flags used by the linker during MEMORYSANITIZER builds.")

    # Activate with: -DCMAKE_BUILD_TYPE=UndefinedSanitizer
-    set(CMAKE_C_FLAGS_UNDEFINEDSANITIZER "-g -O1 -fsanitize=undefined -fsanitize=null -fsanitize=alignment -fno-sanitize-recover=undefined,integer"
+    set(CMAKE_C_FLAGS_UNDEFINEDSANITIZER "-g -O1 -fsanitize=undefined -fsanitize=null -fsanitize=alignment -fno-sanitize-recover"
        CACHE STRING "Flags used by the C compiler during UNDEFINEDSANITIZER builds.")
-    set(CMAKE_CXX_FLAGS_UNDEFINEDSANITIZER "-g -O1 -fsanitize=undefined -fsanitize=null -fsanitize=alignment -fno-sanitize-recover=undefined,integer"
+    set(CMAKE_CXX_FLAGS_UNDEFINEDSANITIZER "-g -O1 -fsanitize=undefined -fsanitize=null -fsanitize=alignment -fno-sanitize-recover"
        CACHE STRING "Flags used by the CXX compiler during UNDEFINEDSANITIZER builds.")
    set(CMAKE_SHARED_LINKER_FLAGS_UNDEFINEDSANITIZER "-fsanitize=undefined"
        CACHE STRING "Flags used by the linker during the creation of shared libraries during UNDEFINEDSANITIZER builds.")
--- a/cmake/Modules/FindABIMap.cmake
+++ b/cmake/Modules/FindABIMap.cmake
@@ -302,13 +302,12 @@ function(get_file_list _TARGET_NAME)
    add_custom_target(
        ${_TARGET_NAME}_int ALL
        COMMAND ${CMAKE_COMMAND}
-          -DOUTPUT_PATH=${_get_files_list_OUTPUT_PATH}
-          -DDIRECTORIES=${_get_files_list_DIRECTORIES}
-          -DFILES_PATTERNS=${_get_files_list_FILES_PATTERNS}
+          -DOUTPUT_PATH="${_get_files_list_OUTPUT_PATH}"
+          -DDIRECTORIES="${_get_files_list_DIRECTORIES}"
+          -DFILES_PATTERNS="${_get_files_list_FILES_PATTERNS}"
          -P ${_GET_FILES_LIST_SCRIPT}
        COMMENT
          "Searching for files"
-        VERBATIM
    )

    if (DEFINED _get_files_list_COPY_TO)
@@ -319,7 +318,6 @@ function(get_file_list _TARGET_NAME)
              ${_FILES_LIST_OUTPUT_PATH} ${_get_files_list_COPY_TO}
            DEPENDS ${_TARGET_NAME}_int
            COMMENT "Copying ${_TARGET_NAME} to ${_get_files_list_COPY_TO}"
-            VERBATIM
        )
    else()
        add_custom_target(${_TARGET_NAME} ALL
@@ -371,13 +369,12 @@ function(extract_symbols _TARGET_NAME)
    add_custom_target(
        ${_TARGET_NAME}_int ALL
        COMMAND ${CMAKE_COMMAND}
-          -DOUTPUT_PATH=${_SYMBOLS_OUTPUT_PATH}
-          -DHEADERS_LIST_FILE=${_HEADERS_LIST_FILE}
+          -DOUTPUT_PATH="${_SYMBOLS_OUTPUT_PATH}"
+          -DHEADERS_LIST_FILE="${_HEADERS_LIST_FILE}"
          -DFILTER_PATTERN=${_extract_symbols_FILTER_PATTERN}
          -P ${_EXTRACT_SYMBOLS_SCRIPT}
        DEPENDS ${_extract_symbols_HEADERS_LIST}
        COMMENT "Extracting symbols from headers"
-        VERBATIM
    )

    if (DEFINED _extract_symbols_COPY_TO)
@@ -388,7 +385,6 @@ function(extract_symbols _TARGET_NAME)
              ${_SYMBOLS_OUTPUT_PATH} ${_extract_symbols_COPY_TO}
            DEPENDS ${_TARGET_NAME}_int
            COMMENT "Copying ${_TARGET_NAME} to ${_extract_symbols_COPY_TO}"
-            VERBATIM
        )
    else()
        add_custom_target(${_TARGET_NAME} ALL
@@ -453,37 +449,35 @@ function(generate_map_file _TARGET_NAME)
        ${_TARGET_NAME}_int ALL
        COMMAND ${CMAKE_COMMAND}
          -DABIMAP_EXECUTABLE=${ABIMAP_EXECUTABLE}
-          -DSYMBOLS=${_SYMBOLS_FILE}
+          -DSYMBOLS="${_SYMBOLS_FILE}"
          -DCURRENT_MAP=${_generate_map_file_CURRENT_MAP}
-          -DOUTPUT_PATH=${_MAP_OUTPUT_PATH}
+          -DOUTPUT_PATH="${_MAP_OUTPUT_PATH}"
          -DFINAL=${_generate_map_file_FINAL}
          -DBREAK_ABI=${_generate_map_file_BREAK_ABI}
          -DRELEASE_NAME_VERSION=${_generate_map_file_RELEASE_NAME_VERSION}
          -P ${_GENERATE_MAP_SCRIPT}
        DEPENDS ${_generate_map_file_SYMBOLS}
        COMMENT "Generating the map ${_TARGET_NAME}"
-        VERBATIM
    )

    # Add a custom command setting the map as OUTPUT to allow it to be added as
    # a generated source
    add_custom_command(
        OUTPUT ${_MAP_OUTPUT_PATH}
-        DEPENDS ${_TARGET_NAME}_copy
+        DEPENDS ${_TARGET_NAME}
    )

    if (DEFINED _generate_map_file_COPY_TO)
        # Copy the generated map back to the COPY_TO
-        add_custom_target(${_TARGET_NAME}_copy ALL
+        add_custom_target(${_TARGET_NAME} ALL
            COMMAND
              ${CMAKE_COMMAND} -E copy_if_different ${_MAP_OUTPUT_PATH}
              ${_generate_map_file_COPY_TO}
            DEPENDS ${_TARGET_NAME}_int
            COMMENT "Copying ${_MAP_OUTPUT_PATH} to ${_generate_map_file_COPY_TO}"
-            VERBATIM
        )
    else()
-        add_custom_target(${_TARGET_NAME}_copy ALL
+        add_custom_target(${_TARGET_NAME} ALL
            DEPENDS ${_TARGET_NAME}_int
        )
    endif()
--- a/cmake/Modules/Findsofthsm.cmake
+++ b/cmake/Modules/Findsofthsm.cmake
@@ -1,36 +0,0 @@
-# - Try to find softhsm
-# Once done this will define
-#
-#  SOFTHSM_FOUND - system has softhsm
-#  SOFTHSM_LIBRARIES - Link these to use softhsm
-#
-#=============================================================================
-#  Copyright (c) 2019 Sahana Prasad <sahana@redhat.com>
-#
-#  Distributed under the OSI-approved BSD License (the "License");
-#  see accompanying file Copyright.txt for details.
-#
-#  This software is distributed WITHOUT ANY WARRANTY; without even the
-#  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-#  See the License for more information.
-#=============================================================================
-#
-
-
-find_library(SOFTHSM2_LIBRARY
-    NAMES
-        softhsm2
-)
-
-if (SOFTHSM2_LIBRARY)
-    set(SOFTHSM_LIBRARIES
-        ${SOFTHSM_LIBRARIES}
-        ${SOFTHSM2_LIBRARY}
-    )
-endif (SOFTHSM2_LIBRARY)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(softhsm DEFAULT_MSG SOFTHSM_LIBRARIES)
-
-# show the SOFTHSM_INCLUDE_DIR and SOFTHSM_LIBRARIES variables only in the advanced view
-mark_as_advanced(SOFTHSM_LIBRARIES)
--- a/config.h.cmake
+++ b/config.h.cmake
@@ -103,19 +103,28 @@
 /* Define to 1 if you have OpenSSL with X25519 support */
 #cmakedefine HAVE_OPENSSL_X25519 1

-/* Define to 1 if you have OpenSSL with Poly1305 support */
-#cmakedefine HAVE_OPENSSL_EVP_POLY1305 1
-
-/* Define to 1 if you have gcrypt with ChaCha20/Poly1305 support */
-#cmakedefine HAVE_GCRYPT_CHACHA_POLY 1
-
 /*************************** FUNCTIONS ***************************/

-/* Define to 1 if you have the `EVP_chacha20' function. */
-#cmakedefine HAVE_OPENSSL_EVP_CHACHA20 1
+/* Define to 1 if you have the `EVP_aes128_ctr' function. */
+#cmakedefine HAVE_OPENSSL_EVP_AES_CTR 1

-/* Define to 1 if you have the `EVP_KDF_CTX_new_id' or `EVP_KDF_CTX_new` function. */
-#cmakedefine HAVE_OPENSSL_EVP_KDF_CTX 1
+/* Define to 1 if you have the `EVP_aes128_cbc' function. */
+#cmakedefine HAVE_OPENSSL_EVP_AES_CBC 1
+
+/* Define to 1 if you have the `EVP_aes128_gcm' function. */
+#cmakedefine HAVE_OPENSSL_EVP_AES_GCM 1
+
+/* Define to 1 if you have the `CRYPTO_THREADID_set_callback' function. */
+#cmakedefine HAVE_OPENSSL_CRYPTO_THREADID_SET_CALLBACK 1
+
+/* Define to 1 if you have the `CRYPTO_ctr128_encrypt' function. */
+#cmakedefine HAVE_OPENSSL_CRYPTO_CTR128_ENCRYPT 1
+
+/* Define to 1 if you have the `EVP_CIPHER_CTX_new' function. */
+#cmakedefine HAVE_OPENSSL_EVP_CIPHER_CTX_NEW 1
+
+/* Define to 1 if you have the `EVP_KDF_CTX_new_id' function. */
+#cmakedefine HAVE_OPENSSL_EVP_KDF_CTX_NEW_ID 1

 /* Define to 1 if you have the `FIPS_mode' function. */
 #cmakedefine HAVE_OPENSSL_FIPS_MODE 1
@@ -225,7 +234,6 @@

 #cmakedefine HAVE_FALLTHROUGH_ATTRIBUTE 1
 #cmakedefine HAVE_UNUSED_ATTRIBUTE 1
-#cmakedefine HAVE_WEAK_ATTRIBUTE 1

 #cmakedefine HAVE_CONSTRUCTOR_ATTRIBUTE 1
 #cmakedefine HAVE_DESTRUCTOR_ATTRIBUTE 1
@@ -252,9 +260,6 @@
 /* Define to 1 if you want to enable DH group exchange algorithms */
 #cmakedefine WITH_GEX 1

-/* Define to 1 if you want to enable none cipher and MAC */
-#cmakedefine WITH_INSECURE_NONE 1
-
 /* Define to 1 if you want to enable blowfish cipher support */
 #cmakedefine WITH_BLOWFISH_CIPHER 1

@@ -273,9 +278,6 @@
 /* Define to 1 if you want to enable NaCl support */
 #cmakedefine WITH_NACL 1

-/* Define to 1 if you want to enable PKCS #11 URI support */
-#cmakedefine WITH_PKCS11_URI 1
-
 /*************************** ENDIAN *****************************/

 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -13,11 +13,8 @@ if (DOXYGEN_FOUND)
    set(DOXYGEN_TAB_SIZE 4)
    set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C YES)
    set(DOXYGEN_MARKDOWN_SUPPORT YES)
-    set(DOXYGEN_FULL_PATH_NAMES NO)

    set(DOXYGEN_PREDEFINED DOXYGEN
-                           WITH_SERVER
-                           WITH_SFTP
                           PRINTF_ATTRIBUTE(x,y))

    set(DOXYGEN_EXCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/that_style)
--- a/doc/README.gitlab.freebsd.md
+++ b/doc/README.gitlab.freebsd.md
@@ -1,101 +0,0 @@
-# Install a FreeBSD CI instance
-
-Install the following packages:
-
-```
-pkg install -y bash git gmake cmake cmocka openssl wget pkgconf ccache bash
-```
-
-Create gitlab-runner user:
-
-```
-pw group add -n gitlab-runner
-pw user add -n gitlab-runner -g gitlab-runner -s /usr/local/bin/bash
-mkdir /home/gitlab-runner
-chown gitlab-runner:gitlab-runner /home/gitlab-runner
-```
-
-Get the gitlab-runner binary for freebsd:
-
-```
-wget -O /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-freebsd-amd64
-chmod +x /usr/local/bin/gitlab-runner
-```
-
-Create a log file and allow access:
-
-```
-touch /var/log/gitlab_runner.log && chown gitlab-runner:gitlab-runner /var/log/gitlab_runner.log
-```
-
-We need a start script to run it on boot:
-
-```
-mkdir -p /usr/local/etc/rc.d
-cat > /usr/local/etc/rc.d/gitlab_runner << EOF
-#!/usr/local/bin/bash
-# PROVIDE: gitlab_runner
-# REQUIRE: DAEMON NETWORKING
-# BEFORE:
-# KEYWORD:
-
-. /etc/rc.subr
-
-name="gitlab_runner"
-rcvar="gitlab_runner_enable"
-
-load_rc_config $name
-
-user="gitlab-runner"
-user_home="/home/gitlab-runner"
-command="/usr/local/bin/gitlab-runner run"
-pidfile="/var/run/${name}.pid"
-
-start_cmd="gitlab_runner_start"
-stop_cmd="gitlab_runner_stop"
-status_cmd="gitlab_runner_status"
-
-gitlab_runner_start()
-{
-    export USER=${user}
-    export HOME=${user_home}
-
-    if checkyesno ${rcvar}; then
-        cd ${user_home}
-        /usr/sbin/daemon -u ${user} -p ${pidfile} ${command} > /var/log/gitlab_runner.log 2>&1
-    fi
-}
-
-gitlab_runner_stop()
-{
-    if [ -f ${pidfile} ]; then
-        kill `cat ${pidfile}`
-    fi
-}
-
-gitlab_runner_status()
-{
-    if [ ! -f ${pidfile} ] || kill -0 `cat ${pidfile}`; then
-        echo "Service ${name} is not running."
-    else
-        echo "${name} appears to be running."
-    fi
-}
-
-run_rc_command $1
-EOF
-chmod +x /usr/local/etc/rc.d/gitlab_runner
-```
-
-Register your gitlab-runner with your gitlab project
-
-```
-su gitlab-runner -c 'gitlab-runner register'
-```
-
-Start the gitlab runner service:
-
-```
-sysrc -f /etc/rc.conf "gitlab_runner_enable=YES"
-service gitlab_runner start
-```
--- a/doc/authentication.dox
+++ b/doc/authentication.dox
@@ -33,9 +33,6 @@ The process of authenticating by public key to a server is the following:
   used to authenticate the user).
 - then, you retrieve the private key for this key and send a message
   proving that you know that private key.
- - when several identity files are specified, then the order of processing of
-   these files is from the last-mentioned to the first one
-   (if specified in the ~/.ssh/config, then starting from the bottom to the top).

 The function ssh_userauth_autopubkey() does this using the available keys in
 "~/.ssh/".  The return values are the following:
--- a/doc/curve25519-sha256@libssh.org.txt
+++ b/doc/curve25519-sha256@libssh.org.txt
@@ -112,8 +112,8 @@ This number is calculated using the following procedure:
     This conversion follows the network byte order. This step differs from 
     RFC5656.

-[RFC5656]    https://tools.ietf.org/html/rfc5656
+[RFC5656]    http://tools.ietf.org/html/rfc5656
 [SCHNEIER]   https://www.schneier.com/blog/archives/2013/09/the_nsa_is_brea.html#c1675929
-[DJB]        https://cr.yp.to/talks/2013.05.31/slides-dan+tanja-20130531-4x3.pdf
+[DJB]        http://cr.yp.to/talks/2013.05.31/slides-dan+tanja-20130531-4x3.pdf
 [Curve25519] "Curve25519: new Diffie-Hellman speed records."
-             https://cr.yp.to/ecdh/curve25519-20060209.pdf
+             http://cr.yp.to/ecdh/curve25519-20060209.pdf
--- a/doc/forwarding.dox
+++ b/doc/forwarding.dox
@@ -101,7 +101,7 @@ used to retrieve google's home page from the remote SSH server.
 int direct_forwarding(ssh_session session)
 {
  ssh_channel forwarding_channel;
-  int rc = SSH_ERROR;
+  int rc;
  char *http_get = "GET / HTTP/1.1\nHost: www.google.com\n\n";
  int nbytes, nwritten;

@@ -165,8 +165,6 @@ int web_server(ssh_session session)
  char buffer[256];
  int nbytes, nwritten;
  int port = 0;
-  char *peer_address = NULL;
-  int peer_port = 0;
  char *helloworld = ""
 "HTTP/1.1 200 OK\n"
 "Content-Type: text/html\n"
@@ -189,8 +187,7 @@ int web_server(ssh_session session)
    return rc;
  }

-  channel = ssh_channel_open_forward_port(session, 60000, &port,
-                                        &peer_address, &peer_port);
+  channel = ssh_channel_accept_forward(session, 60000, &port);
  if (channel == NULL)
  {
    fprintf(stderr, "Error waiting for incoming connection: %s\n",
@@ -207,7 +204,6 @@ int web_server(ssh_session session)
              ssh_get_error(session));
      ssh_channel_send_eof(channel);
      ssh_channel_free(channel);
-      ssh_string_free_char(peer_address);
      return SSH_ERROR;
    }
    if (strncmp(buffer, "GET /", 5)) continue;
@@ -220,15 +216,13 @@ int web_server(ssh_session session)
              ssh_get_error(session));
      ssh_channel_send_eof(channel);
      ssh_channel_free(channel);
-      ssh_string_free_char(peer_address);
      return SSH_ERROR;
    }
-    printf("Sent answer to %s:%d\n", peer_address, peer_port);
+    printf("Sent answer\n");
  }

  ssh_channel_send_eof(channel);
  ssh_channel_free(channel);
-  ssh_string_free_char(peer_address);
  return SSH_OK;
 }
@endcode
--- a/doc/linking.dox
+++ b/doc/linking.dox
@@ -28,6 +28,6 @@ the dllimport attribute.
@endcode

 If you're are statically linking with OpenSSL, read the "Linking your
-application" section in the NOTES.[OS] in the OpenSSL source tree!
+application" section in the NOTES.<OS> in the OpenSSL source tree!

 */
--- a/doc/mainpage.dox
+++ b/doc/mainpage.dox
@@ -21,9 +21,9 @@ The libssh library provides:

 - <strong>Key Exchange Methods</strong>: <i>curve25519-sha256, curve25519-sha256@libssh.org, ecdh-sha2-nistp256, ecdh-sha2-nistp384, ecdh-sha2-nistp521</i>, diffie-hellman-group1-sha1, diffie-hellman-group14-sha1
 - <strong>Public Key Algorithms</strong>: ssh-ed25519, ecdsa-sha2-nistp256, ecdsa-sha2-nistp384, ecdsa-sha2-nistp521, ssh-rsa, rsa-sha2-512, rsa-sha2-256,ssh-dss
- - <strong>Ciphers</strong>: <i>aes256-ctr, aes192-ctr, aes128-ctr</i>, aes256-cbc (rijndael-cbc@lysator.liu.se), aes192-cbc, aes128-cbc, 3des-cbc, blowfish-cbc
+ - <strong>Ciphers</strong>: <i>aes256-ctr, aes192-ctr, aes128-ctr</i>, aes256-cbc (rijndael-cbc@lysator.liu.se), aes192-cbc, aes128-cbc, 3des-cbc, blowfish-cbc, none
 - <strong>Compression Schemes</strong>: zlib, <i>zlib@openssh.com</i>, none
- - <strong>MAC hashes</strong>: hmac-sha1, hmac-sha2-256, hmac-sha2-512, hmac-md5
+ - <strong>MAC hashes</strong>: hmac-sha1, hmac-sha2-256, hmac-sha2-512, hmac-md5, none
 - <strong>Authentication</strong>: none, password, public-key, keyboard-interactive, <i>gssapi-with-mic</i>
 - <strong>Channels</strong>: shell, exec (incl. SCP wrapper), direct-tcpip, subsystem, <i>auth-agent-req@openssh.com</i>
 - <strong>Global Requests</strong>: tcpip-forward, forwarded-tcpip
@@ -38,9 +38,9 @@ The libssh library provides:
@section main-additional-features Additional Features

 - Client <b>and</b> server support
- - SSHv2 protocol support
- - Supports <a href="https://test.libssh.org/" target="_blank">Linux, UNIX, BSD, Solaris, OS/2 and Windows</a>
- - Automated test cases with nightly <a href="https://test.libssh.org/" target="_blank">tests</a>
+ - SSHv2 and SSHv1 protocol support
+ - Supports <a href="http://test.libssh.org/" target="_blank">Linux, UNIX, BSD, Solaris, OS/2 and Windows</a>
+ - Automated test cases with nightly <a href="http://test.libssh.org/" target="_blank">tests</a>
 - Event model based on poll(2), or a poll(2)-emulation.

@section main-copyright Copyright Policy
@@ -111,7 +111,7 @@ By making a contribution to this project, I certify that:
    Free Software Foundation; either version 2.1 of
    the License, or (at the option of the project) any later version.

-https://www.gnu.org/licenses/lgpl-2.1.html
+http://www.gnu.org/licenses/lgpl-2.1.html
@endverbatim

 We will maintain a copy of that email as a record that you have the rights to
@@ -151,81 +151,47 @@ The libssh Team

 The following RFC documents described SSH-2 protcol as an Internet standard.

- - <a href="https://tools.ietf.org/html/rfc4250" target="_blank">RFC 4250</a>,
+ - <a href="http://tools.ietf.org/html/rfc4250" target="_blank">RFC 4250</a>,
    The Secure Shell (SSH) Protocol Assigned Numbers
- - <a href="https://tools.ietf.org/html/rfc4251" target="_blank">RFC 4251</a>,
+ - <a href="http://tools.ietf.org/html/rfc4251" target="_blank">RFC 4251</a>,
    The Secure Shell (SSH) Protocol Architecture
- - <a href="https://tools.ietf.org/html/rfc4252" target="_blank">RFC 4252</a>,
+ - <a href="http://tools.ietf.org/html/rfc4252" target="_blank">RFC 4252</a>,
    The Secure Shell (SSH) Authentication Protocol
- - <a href="https://tools.ietf.org/html/rfc4253" target="_blank">RFC 4253</a>,
+ - <a href="http://tools.ietf.org/html/rfc4253" target="_blank">RFC 4253</a>,
    The Secure Shell (SSH) Transport Layer Protocol
- - <a href="https://tools.ietf.org/html/rfc4254" target="_blank">RFC 4254</a>,
+ - <a href="http://tools.ietf.org/html/rfc4254" target="_blank">RFC 4254</a>,
    The Secure Shell (SSH) Connection Protocol
- - <a href="https://tools.ietf.org/html/rfc4255" target="_blank">RFC 4255</a>,
+ - <a href="http://tools.ietf.org/html/rfc4255" target="_blank">RFC 4255</a>,
    Using DNS to Securely Publish Secure Shell (SSH) Key Fingerprints
-    (not implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc4256" target="_blank">RFC 4256</a>,
+ - <a href="http://tools.ietf.org/html/rfc4256" target="_blank">RFC 4256</a>,
    Generic Message Exchange Authentication for the Secure Shell Protocol (SSH)
- - <a href="https://tools.ietf.org/html/rfc4335" target="_blank">RFC 4335</a>,
+ - <a href="http://tools.ietf.org/html/rfc4335" target="_blank">RFC 4335</a>,
    The Secure Shell (SSH) Session Channel Break Extension
- - <a href="https://tools.ietf.org/html/rfc4344" target="_blank">RFC 4344</a>,
+ - <a href="http://tools.ietf.org/html/rfc4344" target="_blank">RFC 4344</a>,
    The Secure Shell (SSH) Transport Layer Encryption Modes
- - <a href="https://tools.ietf.org/html/rfc4345" target="_blank">RFC 4345</a>,
+ - <a href="http://tools.ietf.org/html/rfc4345" target="_blank">RFC 4345</a>,
    Improved Arcfour Modes for the Secure Shell (SSH) Transport Layer Protocol

 It was later modified and expanded by the following RFCs.

- - <a href="https://tools.ietf.org/html/rfc4419" target="_blank">RFC 4419</a>,
+ - <a href="http://tools.ietf.org/html/rfc4419" target="_blank">RFC 4419</a>,
    Diffie-Hellman Group Exchange for the Secure Shell (SSH) Transport Layer
    Protocol
- - <a href="https://tools.ietf.org/html/rfc4432" target="_blank">RFC 4432</a>,
+ - <a href="http://tools.ietf.org/html/rfc4432" target="_blank">RFC 4432</a>,
    RSA Key Exchange for the Secure Shell (SSH) Transport Layer Protocol
-    (not implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc4462" target="_blank">RFC 4462</a>,
+ - <a href="http://tools.ietf.org/html/rfc4462" target="_blank">RFC 4462</a>,
    Generic Security Service Application Program Interface (GSS-API)
    Authentication and Key Exchange for the Secure Shell (SSH) Protocol
-    (only the authentication implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc4716" target="_blank">RFC 4716</a>,
+ - <a href="http://tools.ietf.org/html/rfc4716" target="_blank">RFC 4716</a>,
    The Secure Shell (SSH) Public Key File Format
-    (not implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc5647" target="_blank">RFC 5647</a>,
+ - <a href="http://tools.ietf.org/html/rfc5647" target="_blank">RFC 5647</a>,
    AES Galois Counter Mode for the Secure Shell Transport Layer Protocol
-    (the algorithm negotiation implemented according to openssh.com)
- - <a href="https://tools.ietf.org/html/rfc5656" target="_blank">RFC 5656</a>,
+ - <a href="http://tools.ietf.org/html/rfc5656" target="_blank">RFC 5656</a>,
    Elliptic Curve Algorithm Integration in the Secure Shell Transport Layer
- - <a href="https://tools.ietf.org/html/rfc6594" target="_blank">RFC 6594</a>,
-    Use of the SHA-256 Algorithm with RSA, DSA, and ECDSA in SSHFP Resource Records
-    (not implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc6668" target="_blank">RFC 6668</a>,
-    SHA-2 Data Integrity Verification for the Secure Shell (SSH) Transport Layer Protocol
- - <a href="https://tools.ietf.org/html/rfc7479" target="_blank">RFC 7479</a>,
-    Using Ed25519 in SSHFP Resource Records
-    (not implemented in libssh)
- - <a href="https://tools.ietf.org/html/rfc8160" target="_blank">RFC 8160</a>,
-    IUTF8 Terminal Mode in Secure Shell (SSH)
-    (not handled in libssh)
- - <a href="https://tools.ietf.org/html/rfc8270" target="_blank">RFC 8270</a>,
-    Increase the Secure Shell Minimum Recommended Diffie-Hellman Modulus Size to 2048 Bits
- - <a href="https://tools.ietf.org/html/rfc8308" target="_blank">RFC 8308</a>,
-    Extension Negotiation in the Secure Shell (SSH) Protocol
-    (only the "server-sig-algs" extension implemented)
- - <a href="https://tools.ietf.org/html/rfc8332" target="_blank">RFC 8332</a>,
-    Use of RSA Keys with SHA-256 and SHA-512 in the Secure Shell (SSH) Protocol
- - <a href="https://tools.ietf.org/html/rfc8709" target="_blank">RFC 8709</a>,
-    Ed25519 and Ed448 Public Key Algorithms for the Secure Shell (SSH) Protocol
-
-There are also drafts that are being currently developed and followed.
-
- - <a href="https://tools.ietf.org/html/draft-ietf-curdle-ssh-kex-sha2-10" target="_blank">draft-ietf-curdle-ssh-kex-sha2-10</a>
-    Key Exchange (KEX) Method Updates and Recommendations for Secure Shell (SSH)
- - <a href="https://tools.ietf.org/html/draft-miller-ssh-agent-03" target="_blank">draft-miller-ssh-agent-03</a>
-    SSH Agent Protocol
- - <a href="https://tools.ietf.org/html/draft-ietf-curdle-ssh-curves-12" target="_blank">draft-ietf-curdle-ssh-curves-12</a>
-    Secure Shell (SSH) Key Exchange Method using Curve25519 and Curve448

 Interesting cryptography documents:

- - <a href="https://www.cryptsoft.com/pkcs11doc/" target="_blank">PKCS #11</a>, PKCS #11 reference documents, describing interface with smartcards.
+ - <a href="http://www.cryptsoft.com/pkcs11doc/" target="_blank">PKCS #11</a>, PKCS #11 reference documents, describing interface with smartcards.

@subsection main-rfc-sftp Secure Shell File Transfer Protocol (SFTP)

@@ -233,22 +199,26 @@ The protocol is not an Internet standard but it is still widely implemented.
 OpenSSH and most other implementation implement Version 3 of the protocol. We
 do the same in libssh.

- - <a href="https://tools.ietf.org/html/draft-ietf-secsh-filexfer-02" target="_blank">
+ - <a href="http://tools.ietf.org/html/draft-ietf-secsh-filexfer-02" target="_blank">
   draft-ietf-secsh-filexfer-02.txt</a>,
   SSH File Transfer Protocol

@subsection main-rfc-extensions Secure Shell Extensions

+The libssh project has an extension to support Curve25519 which is also supported by
+the OpenSSH project.
+
+ - <a href="http://git.libssh.org/projects/libssh.git/tree/doc/curve25519-sha256@libssh.org.txt" target="_blank">curve25519-sha256@libssh.org</a>,
+   Curve25519-SHA256 for ECDH KEX
+
 The OpenSSH project has defined some extensions to the protocol. We support some of
 them like the statvfs calls in SFTP or the ssh-agent.

- - <a href="https://api.libssh.org/rfc/PROTOCOL" target="_blank">
+ - <a href="http://api.libssh.org/rfc/PROTOCOL" target="_blank">
    OpenSSH's deviations and extensions</a>
- - <a href="https://api.libssh.org/rfc/PROTOCOL.certkeys" target="_blank">
+ - <a href="http://api.libssh.org/rfc/PROTOCOL.agent" target="_blank">
+    OpenSSH's ssh-agent</a>
+ - <a href="http://api.libssh.org/rfc/PROTOCOL.certkeys" target="_blank">
    OpenSSH's pubkey certificate authentication</a>
- - <a href="https://api.libssh.org/rfc/PROTOCOL.chacha20poly1305" target="_blank">
-    chacha20-poly1305@openssh.com authenticated encryption mode</a>
- - <a href="https://api.libssh.org/rfc/PROTOCOL.key" target="_blank">
-    OpenSSH private key format (openssh-key-v1)</a>

 */
--- a/doc/pkcs11.dox
+++ b/doc/pkcs11.dox
@@ -1,67 +0,0 @@
-/**
-@page libssh_tutor_pkcs11 Chapter 9: Authentication using PKCS #11 URIs
-@section how_to How to use PKCS #11 URIs in libssh?
-
-PKCS #11 is a Cryptographic Token Interface Standard that provides an API
-to devices like smart cards that store cryptographic private information.
-Such cryptographic devices are referenced as tokens. A mechanism through which
-objects stored on the tokens can be uniquely identified is called PKCS #11 URI
-(Uniform Resource Identifier) and is defined in RFC 7512
-(https://tools.ietf.org/html/rfc7512).
-
-Pre-requisites:
-
-OpenSSL defines an abstract layer called the "engine" to achieve cryptographic
-acceleration. The engine_pkcs11 module acts like an interface between the PKCS #11
-modules and the OpenSSL engine.
-
-To build and use libssh with PKCS #11 support:
-1. Enable the cmake option: $ cmake -DWITH_PKCS11_URI=ON
-2. Build with OpenSSL.
-3. Install and configure engine_pkcs11 (https://github.com/OpenSC/libp11).
-4. Plug in a working smart card or configure softhsm (https://www.opendnssec.org/softhsm).
-
-The functions  ssh_pki_import_pubkey_file() and ssh_pki_import_privkey_file() that
-import the public and private keys from files respectively are now modified to support
-PKCS #11 URIs. These functions automatically detect if the provided filename is a file path
-or a PKCS #11 URI (when it begins with "pkcs11:"). If a PKCS #11 URI is detected,
-the engine is loaded and initialized. Through the engine, the private/public key
-corresponding to the PKCS #11 URI are loaded from the PKCS #11 device.
-
-If you wish to authenticate using public keys on your own, follow the steps mentioned under
-"Authentication with public keys" in Chapter 2 - A deeper insight into authentication.
-
-The function pki_uri_import() is used to populate the public/private ssh_key from the 
-engine with PKCS #11 URIs as the look up.
-
-Here is a minimalistic example of public key authentication using PKCS #11 URIs:
-
-@code
-int authenticate_pkcs11_URI(ssh_session session)
-{
-  int rc;
-  char priv_uri[1042] = "pkcs11:token=my-token;object=my-object;type=private?pin-value=1234";
-
-  rc = ssh_options_set(session, SSH_OPTIONS_IDENTITY, priv_uri);
-  assert_int_equal(rc, SSH_OK)
-
-  rc = ssh_userauth_publickey_auto(session, NULL, NULL);
-
-  if (rc == SSH_AUTH_ERROR)
-  {
-     fprintf(stderr, "Authentication with PKCS #11 URIs failed: %s\n",
-       ssh_get_error(session));
-     return SSH_AUTH_ERROR;
-  }
-
-  return rc;
-}
-@endcode
-
-@subsection Caveats
-
-We recommend the users to provide a specific PKCS #11 URI so that it matches only a single slot in the engine.
-If the engine discovers multiple slots that could potentially contain the private keys referenced
-by the provided PKCS #11 URI, the engine will not try to authenticate.
-
-*/
--- a/doc/shell.dox
+++ b/doc/shell.dox
@@ -320,36 +320,18 @@ int interactive_shell_session(ssh_session session, ssh_channel channel)
 If your remote application is graphical, you can forward the X11 protocol to
 your local computer.

-To do that, you first declare a callback to manage channel_open_request_x11_function.
-Then you create the forwarding tunnel for the X11 protocol with ssh_channel_request_x11().
+To do that, you first declare that you accept X11 connections with
+ssh_channel_accept_x11(). Then you create the forwarding tunnel for
+the X11 protocol with ssh_channel_request_x11().

 The following code performs channel initialization and shell session
 opening, and handles a parallel X11 connection:

@code
-#include <libssh/callbacks.h>
-
-ssh_channel x11channel = NULL;
-
-ssh_channel x11_open_request_callback(ssh_session session, const char *shost, int sport, void *userdata)
-{
-  x11channel = ssh_channel_new(session);
-  return x11channel;
-}
-
 int interactive_shell_session(ssh_channel channel)
 {
  int rc;
-
-  struct ssh_callbacks_struct cb =
-  {
-    .channel_open_request_x11_function = x11_open_request_callback,
-    .userdata = NULL
-  };
-
-  ssh_callbacks_init(&cb);
-  rc = ssh_set_callbacks(session, &cb);
-  if (rc != SSH_OK) return rc;
+  ssh_channel x11channel;

  rc = ssh_channel_request_pty(channel);
  if (rc != SSH_OK) return rc;
@@ -368,15 +350,12 @@ int interactive_shell_session(ssh_channel channel)
 }
@endcode

-Don't forget to check the $DISPLAY environment variable on the remote
+Don't forget to set the $DISPLAY environment variable on the remote
 side, or the remote applications won't try using the X11 tunnel:

@code
-$ echo $DISPLAY
-localhost:10.0
+$ export DISPLAY=:0
 $ xclock &
@endcode

-See an implementation example at https://gitlab.com/libssh/libssh-mirror/-/tree/master/examples/ssh_X11_client.c for details.
-
 */
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -6,7 +6,10 @@ set(examples_SRCS
  connect_ssh.c
 )

-include_directories(${libssh_BINARY_DIR}/include ${libssh_BINARY_DIR})
+include_directories(
+  ${LIBSSH_PUBLIC_INCLUDE_DIRS}
+  ${CMAKE_BINARY_DIR}
+)

 if (ARGP_INCLUDE_DIR)
    include_directories(${ARGP_INCLUDE_DIR})
@@ -15,85 +18,68 @@ endif()
 if (UNIX AND NOT WIN32)
    add_executable(libssh_scp libssh_scp.c ${examples_SRCS})
    target_compile_options(libssh_scp PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(libssh_scp ssh::ssh)
+    target_link_libraries(libssh_scp ${LIBSSH_SHARED_LIBRARY})

    add_executable(scp_download scp_download.c ${examples_SRCS})
    target_compile_options(scp_download PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(scp_download ssh::ssh)
+    target_link_libraries(scp_download ${LIBSSH_SHARED_LIBRARY})

    add_executable(sshnetcat sshnetcat.c ${examples_SRCS})
    target_compile_options(sshnetcat PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(sshnetcat ssh::ssh)
+    target_link_libraries(sshnetcat ${LIBSSH_SHARED_LIBRARY})

    if (WITH_SFTP)
        add_executable(samplesftp samplesftp.c ${examples_SRCS})
        target_compile_options(samplesftp PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-        target_link_libraries(samplesftp ssh::ssh)
+        target_link_libraries(samplesftp ${LIBSSH_SHARED_LIBRARY})
    endif (WITH_SFTP)

    add_executable(ssh-client ssh_client.c ${examples_SRCS})
    target_compile_options(ssh-client PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(ssh-client ssh::ssh)
-
-    add_executable(ssh-X11-client ssh_X11_client.c ${examples_SRCS})
-    target_compile_options(ssh-X11-client PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(ssh-X11-client ssh::ssh)
+    target_link_libraries(ssh-client ${LIBSSH_SHARED_LIBRARY})

    if (WITH_SERVER AND (ARGP_LIBRARY OR HAVE_ARGP_H))
        if (HAVE_LIBUTIL)
-            add_executable(ssh_server_fork ssh_server.c)
-            target_compile_options(ssh_server_fork PRIVATE ${DEFAULT_C_COMPILE_FLAGS} -DWITH_FORK)
-            target_link_libraries(ssh_server_fork ssh::ssh ${ARGP_LIBRARY} util)
-
-            add_executable(ssh_server_pthread ssh_server.c)
-            target_compile_options(ssh_server_pthread PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-            target_link_libraries(ssh_server_pthread ssh::ssh ${ARGP_LIBRARY} pthread util)
+            add_executable(ssh_server_fork ssh_server_fork.c)
+            target_compile_options(ssh_server_fork PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
+            target_link_libraries(ssh_server_fork ${LIBSSH_SHARED_LIBRARY} ${ARGP_LIBRARY} util)
        endif (HAVE_LIBUTIL)

        if (WITH_GSSAPI AND GSSAPI_FOUND)
+            add_executable(samplesshd-cb samplesshd-cb.c)
+            target_compile_options(samplesshd-cb PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
+            target_link_libraries(samplesshd-cb ${LIBSSH_SHARED_LIBRARY} ${ARGP_LIBRARY})
+
            add_executable(proxy proxy.c)
            target_compile_options(proxy PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-            target_link_libraries(proxy ssh::ssh ${ARGP_LIBRARY})
+            target_link_libraries(proxy ${LIBSSH_SHARED_LIBRARY} ${ARGP_LIBRARY})

            add_executable(sshd_direct-tcpip sshd_direct-tcpip.c)
            target_compile_options(sshd_direct-tcpip PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-            target_link_libraries(sshd_direct-tcpip ssh::ssh ${ARGP_LIBRARY})
+            target_link_libraries(sshd_direct-tcpip ${LIBSSH_SHARED_LIBRARY} ${ARGP_LIBRARY})
        endif (WITH_GSSAPI AND GSSAPI_FOUND)

        add_executable(samplesshd-kbdint samplesshd-kbdint.c)
        target_compile_options(samplesshd-kbdint PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-        target_link_libraries(samplesshd-kbdint ssh::ssh ${ARGP_LIBRARY})
-
-        add_executable(keygen2 keygen2.c ${examples_SRCS})
-        target_compile_options(keygen2 PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-        target_link_libraries(keygen2 ssh::ssh ${ARGP_LIBRARY})
+        target_link_libraries(samplesshd-kbdint ${LIBSSH_SHARED_LIBRARY} ${ARGP_LIBRARY})

    endif()
 endif (UNIX AND NOT WIN32)

-if (WITH_SERVER)
-    add_executable(samplesshd-cb samplesshd-cb.c)
-    target_compile_options(samplesshd-cb PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-    target_link_libraries(samplesshd-cb ssh::ssh)
-    if (ARGP_LIBRARY OR HAVE_ARGP_H)
-        target_link_libraries(samplesshd-cb ${ARGP_LIBRARY})
-    endif(ARGP_LIBRARY OR HAVE_ARGP_H)
-endif()
-
 add_executable(exec exec.c ${examples_SRCS})
 target_compile_options(exec PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-target_link_libraries(exec ssh::ssh)
+target_link_libraries(exec ${LIBSSH_SHARED_LIBRARY})

 add_executable(senddata senddata.c ${examples_SRCS})
 target_compile_options(senddata PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-target_link_libraries(senddata ssh::ssh)
+target_link_libraries(senddata ${LIBSSH_SHARED_LIBRARY})

 add_executable(keygen keygen.c)
 target_compile_options(keygen PRIVATE ${DEFAULT_C_COMPILE_FLAGS})
-target_link_libraries(keygen ssh::ssh)
+target_link_libraries(keygen ${LIBSSH_SHARED_LIBRARY})

 add_executable(libsshpp libsshpp.cpp)
-target_link_libraries(libsshpp ssh::ssh)
+target_link_libraries(libsshpp ${LIBSSH_SHARED_LIBRARY})

 add_executable(libsshpp_noexcept libsshpp_noexcept.cpp)
-target_link_libraries(libsshpp_noexcept ssh::ssh)
+target_link_libraries(libsshpp_noexcept ${LIBSSH_SHARED_LIBRARY})
--- a/examples/authentication.c
+++ b/examples/authentication.c
@@ -234,7 +234,7 @@ int authenticate_console(ssh_session session)
    banner = ssh_get_issue_banner(session);
    if (banner) {
        printf("%s\n",banner);
-        SSH_STRING_FREE_CHAR(banner);
+        ssh_string_free_char(banner);
    }

    return rc;
--- a/examples/exec.c
+++ b/examples/exec.c
@@ -8,7 +8,7 @@ int main(void) {
    ssh_session session;
    ssh_channel channel;
    char buffer[256];
-    int rbytes, wbytes, total = 0;
+    int nbytes;
    int rc;

    session = connect_ssh("localhost", NULL, 0);
@@ -17,7 +17,7 @@ int main(void) {
        return 1;
    }

-    channel = ssh_channel_new(session);
+    channel = ssh_channel_new(session);;
    if (channel == NULL) {
        ssh_disconnect(session);
        ssh_free(session);
@@ -35,30 +35,15 @@ int main(void) {
        goto failed;
    }

-    rbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
-    if (rbytes <= 0) {
-        goto failed;
-    }
-
-    do {
-        wbytes = fwrite(buffer + total, 1, rbytes, stdout);
-        if (wbytes <= 0) {
+    nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
+    while (nbytes > 0) {
+        if (fwrite(buffer, 1, nbytes, stdout) != (unsigned int) nbytes) {
            goto failed;
        }
+        nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
+    }

-        total += wbytes;
-
-        /* When it was not possible to write the whole buffer to stdout */
-        if (wbytes < rbytes) {
-            rbytes -= wbytes;
-            continue;
-        }
-
-        rbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
-        total = 0;
-    } while (rbytes > 0);
-
-    if (rbytes < 0) {
+    if (nbytes < 0) {
        goto failed;
    }

--- a/examples/keygen2.c
+++ b/examples/keygen2.c
@@ -1,505 +0,0 @@
-/*
- * keygen2.c - Generate SSH keys using libssh
- * Author: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
- */
-
-/*
- * Copyright (c) 2019 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- */
-
-#include "config.h"
-
-#include <libssh/libssh.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <argp.h>
-#include <errno.h>
-#include <string.h>
-#include <ctype.h>
-#include <fcntl.h>
-
-#include <sys/stat.h>
-
-struct arguments_st {
-    enum ssh_keytypes_e type;
-    unsigned long bits;
-    char *file;
-    char *passphrase;
-    int action_list;
-};
-
-static struct argp_option options[] = {
-    {
-        .name  = "bits",
-        .key   = 'b',
-        .arg   = "BITS",
-        .flags = 0,
-        .doc   = "The size of the key to be generated. "
-                 "If omitted, a default value is used depending on the TYPE. "
-                 "Accepted values are: "
-                 "1024, 2048, 3072 (default), 4096, and 8192 for TYPE=\"rsa\"; "
-                 "256 (default), 384, and 521 for TYPE=\"ecdsa\"; "
-                 "1024 (default) and 2048 for TYPE=\"dsa\"; "
-                 "can be omitted for TYPE=\"ed25519\" "
-                 "(it will be ignored if provided).\n",
-        .group = 0
-    },
-    {
-        .name  = "file",
-        .key   = 'f',
-        .arg   = "FILE",
-        .flags = 0,
-        .doc   = "The output file. "
-                 "If not provided, the used file name will be generated "
-                 "according to the key type as \"id_TYPE\" "
-                 "(e.g. \"id_rsa\" for type \"rsa\"). "
-                 "The public key file name is generated from the private key "
-                 "file name by appending \".pub\".\n",
-        .group = 0
-    },
-    {
-        .name  = "passphrase",
-        .key   = 'p',
-        .arg   = "PASSPHRASE",
-        .flags = 0,
-        .doc   = "The passphrase used to encrypt the private key. "
-                 "If omitted the file will not be encrypted.\n",
-        .group = 0
-    },
-    {
-        .name  = "type",
-        .key   = 't',
-        .arg   = "TYPE",
-        .flags = 0,
-        .doc   = "The type of the key to be generated. "
-                 "Accepted values are: "
-                 "\"rsa\", \"ecdsa\", \"ed25519\", and \"dsa\".\n",
-        .group = 0
-    },
-    {
-        .name  = "list",
-        .key   = 'l',
-        .arg   = NULL,
-        .flags = 0,
-        .doc   = "List the Fingerprint of the given key\n",
-        .group = 0
-    },
-    {
-        /* End of the options */
-        0
-    },
-};
-
-/* Parse a single option. */
-static error_t parse_opt (int key, char *arg, struct argp_state *state)
-{
-    /* Get the input argument from argp_parse, which we
-     * know is a pointer to our arguments structure.
-     */
-    struct arguments_st *arguments = NULL;
-    error_t rc = 0;
-
-    if (state == NULL) {
-        return EINVAL;
-    }
-
-    arguments = state->input;
-    if (arguments == NULL) {
-        fprintf(stderr, "Error: NULL pointer to arguments structure "
-                "provided\n");
-        rc = EINVAL;
-        goto end;
-    }
-
-    switch (key) {
-        case 'b':
-            errno = 0;
-            arguments->bits = strtoul(arg, NULL, 10);
-            if (errno != 0) {
-                rc = errno;
-                goto end;
-            }
-            break;
-        case 'f':
-            arguments->file = strdup(arg);
-            if (arguments->file == NULL) {
-                fprintf(stderr, "Error: Out of memory\n");
-                rc = ENOMEM;
-                goto end;
-            }
-            break;
-        case 'p':
-            arguments->passphrase = strdup(arg);
-            if (arguments->passphrase == NULL) {
-                fprintf(stderr, "Error: Out of memory\n");
-                rc = ENOMEM;
-                goto end;
-            }
-            break;
-        case 't':
-            if (!strcmp(arg, "rsa")) {
-                arguments->type = SSH_KEYTYPE_RSA;
-            }
-            else if (!strcmp(arg, "dsa")) {
-                arguments->type = SSH_KEYTYPE_DSS;
-            }
-            else if (!strcmp(arg, "ecdsa")) {
-                arguments->type = SSH_KEYTYPE_ECDSA;
-            }
-            else if (!strcmp(arg, "ed25519")) {
-                arguments->type = SSH_KEYTYPE_ED25519;
-            }
-            else {
-                fprintf(stderr, "Error: Invalid key type\n");
-                argp_usage(state);
-                rc = EINVAL;
-                goto end;
-            }
-            break;
-        case 'l':
-            arguments->action_list = 1;
-            break;
-        case ARGP_KEY_ARG:
-            if (state->arg_num > 0) {
-                /* Too many arguments. */
-                printf("Error: Too many arguments\n");
-                argp_usage(state);
-            }
-            break;
-        case ARGP_KEY_END:
-            break;
-        default:
-            return ARGP_ERR_UNKNOWN;
-    }
-
-end:
-    return rc;
-}
-
-static int validate_args(struct arguments_st *args)
-{
-    int rc = 0;
-
-    if (args == NULL) {
-        return EINVAL;
-    }
-
-    /* no other arguments needed for listing key fingerprints */
-    if (args->action_list) {
-        return 0;
-    }
-
-    switch (args->type) {
-    case SSH_KEYTYPE_RSA:
-        switch (args->bits) {
-        case 0:
-            /* If not provided, use default value */
-            args->bits = 3072;
-            break;
-        case 1024:
-        case 2048:
-        case 3072:
-        case 4096:
-        case 8192:
-            break;
-        default:
-            fprintf(stderr, "Error: Invalid bits parameter provided\n");
-            rc = EINVAL;
-            break;
-        }
-
-        if (args->file == NULL) {
-            args->file = strdup("id_rsa");
-            if (args->file == NULL) {
-                rc = ENOMEM;
-                break;
-            }
-        }
-
-        break;
-    case SSH_KEYTYPE_ECDSA:
-        switch (args->bits) {
-        case 0:
-            /* If not provided, use default value */
-            args->bits = 256;
-            break;
-        case 256:
-        case 384:
-        case 521:
-            break;
-        default:
-            fprintf(stderr, "Error: Invalid bits parameter provided\n");
-            rc = EINVAL;
-            break;
-        }
-        if (args->file == NULL) {
-            args->file = strdup("id_ecdsa");
-            if (args->file == NULL) {
-                rc = ENOMEM;
-                break;
-            }
-        }
-
-        break;
-    case SSH_KEYTYPE_DSS:
-        switch (args->bits) {
-        case 0:
-            /* If not provided, use default value */
-            args->bits = 1024;
-            break;
-        case 1024:
-        case 2048:
-            break;
-        default:
-            fprintf(stderr, "Error: Invalid bits parameter provided\n");
-            rc = EINVAL;
-            break;
-        }
-        if (args->file == NULL) {
-            args->file = strdup("id_dsa");
-            if (args->file == NULL) {
-                rc = ENOMEM;
-                break;
-            }
-        }
-
-        break;
-    case SSH_KEYTYPE_ED25519:
-        /* Ignore value and overwrite with a zero */
-        args->bits = 0;
-
-        if (args->file == NULL) {
-            args->file = strdup("id_ed25519");
-            if (args->file == NULL) {
-                rc = ENOMEM;
-                break;
-            }
-        }
-
-        break;
-    default:
-        fprintf(stderr, "Error: unknown key type\n");
-        rc = EINVAL;
-        break;
-    }
-
-    return rc;
-}
-
-/* Program documentation. */
-static char doc[] = "Generate an SSH key pair. "
-                    "The \"--type\" (short: \"-t\") option is required.";
-
-/* Our argp parser */
-static struct argp argp = {options, parse_opt, NULL, doc, NULL, NULL, NULL};
-
-static void
-list_fingerprint(char *file)
-{
-    ssh_key key = NULL;
-    unsigned char *hash = NULL;
-    size_t hlen = 0;
-    int rc;
-
-    rc = ssh_pki_import_privkey_file(file, NULL, NULL, NULL, &key);
-    if (rc != SSH_OK) {
-        fprintf(stderr, "Failed to import private key %s\n", file);
-        return;
-    }
-
-    rc = ssh_get_publickey_hash(key, SSH_PUBLICKEY_HASH_SHA256, &hash, &hlen);
-    if (rc != SSH_OK) {
-        fprintf(stderr, "Failed to get key fingerprint\n");
-        return;
-    }
-    ssh_print_hash(SSH_PUBLICKEY_HASH_SHA256, hash, hlen);
-
-    ssh_clean_pubkey_hash(&hash);
-    ssh_key_free(key);
-}
-
-int main(int argc, char *argv[])
-{
-    ssh_key key = NULL;
-    int rc = 0;
-    char overwrite[1024] = "";
-
-    char *pubkey_file = NULL;
-
-    struct arguments_st arguments = {
-        .type = SSH_KEYTYPE_UNKNOWN,
-        .bits = 0,
-        .file = NULL,
-        .passphrase = NULL,
-        .action_list = 0,
-    };
-
-    if (argc < 2) {
-        argp_help(&argp, stdout, ARGP_HELP_DOC | ARGP_HELP_USAGE, argv[0]);
-        goto end;
-    }
-
-    rc = argp_parse(&argp, argc, argv, 0, 0, &arguments);
-    if (rc != 0) {
-        goto end;
-    }
-
-    rc = validate_args(&arguments);
-    if (rc != 0) {
-        goto end;
-    }
-
-    if (arguments.action_list && arguments.file) {
-        list_fingerprint(arguments.file);
-        goto end;
-    }
-
-    errno = 0;
-    rc = open(arguments.file, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR);
-    if (rc < 0) {
-        if (errno == EEXIST) {
-            printf("File \"%s\" exists. Overwrite it? (y|n) ", arguments.file);
-            rc = scanf("%1023s", overwrite);
-            if (rc > 0 && tolower(overwrite[0]) == 'y') {
-                rc = open(arguments.file, O_WRONLY);
-                if (rc > 0) {
-                    close(rc);
-                    errno = 0;
-                    rc = chmod(arguments.file, S_IRUSR | S_IWUSR);
-                    if (rc != 0) {
-                        fprintf(stderr,
-                                "Error(%d): Could not set file permissions\n",
-                                errno);
-                        goto end;
-                    }
-                } else {
-                    fprintf(stderr,
-                            "Error: Could not create private key file\n");
-                    goto end;
-                }
-            } else {
-                goto end;
-            }
-        } else {
-            fprintf(stderr, "Error opening \"%s\" file\n", arguments.file);
-            goto end;
-        }
-    } else {
-        close(rc);
-    }
-
-    /* Generate a new private key */
-    rc = ssh_pki_generate(arguments.type, arguments.bits, &key);
-    if (rc != SSH_OK) {
-        fprintf(stderr, "Error: Failed to generate keys");
-        goto end;
-    }
-
-    /* Write the private key */
-    rc = ssh_pki_export_privkey_file(key, arguments.passphrase, NULL, NULL,
-                                     arguments.file);
-    if (rc != SSH_OK) {
-        fprintf(stderr, "Error: Failed to write private key file");
-        goto end;
-    }
-
-    /* If a passphrase was provided, overwrite and free it as it is not needed
-     * anymore */
-    if (arguments.passphrase != NULL) {
-#ifdef HAVE_EXPLICIT_BZERO
-        explicit_bzero(arguments.passphrase, strlen(arguments.passphrase));
-#else
-        bzero(arguments.passphrase, strlen(arguments.passphrase));
-#endif
-        free(arguments.passphrase);
-        arguments.passphrase = NULL;
-    }
-
-    pubkey_file = (char *)malloc(strlen(arguments.file) + 5);
-    if (pubkey_file == NULL) {
-        rc = ENOMEM;
-        goto end;
-    }
-
-    sprintf(pubkey_file, "%s.pub", arguments.file);
-
-    errno = 0;
-    rc = open(pubkey_file,
-              O_CREAT | O_EXCL | O_WRONLY,
-              S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-    if (rc < 0) {
-        if (errno == EEXIST) {
-            printf("File \"%s\" exists. Overwrite it? (y|n) ", pubkey_file);
-            rc = scanf("%1023s", overwrite);
-            if (rc > 0 && tolower(overwrite[0]) == 'y') {
-                rc = open(pubkey_file, O_WRONLY);
-                if (rc > 0) {
-                    close(rc);
-                    errno = 0;
-                    rc = chmod(pubkey_file,
-                               S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-                    if (rc != 0) {
-                        fprintf(stderr,
-                                "Error(%d): Could not set file permissions\n",
-                                errno);
-                        goto end;
-                    }
-                } else {
-                    fprintf(stderr,
-                            "Error: Could not create public key file\n");
-                    goto end;
-                }
-            } else {
-                goto end;
-            }
-        } else {
-            fprintf(stderr, "Error opening \"%s\" file\n", pubkey_file);
-            goto end;
-        }
-    } else {
-        close(rc);
-    }
-
-    /* Write the public key */
-    rc = ssh_pki_export_pubkey_file(key, pubkey_file);
-    if (rc != SSH_OK) {
-        fprintf(stderr, "Error: Failed to write public key file");
-        goto end;
-    }
-
-end:
-    if (key != NULL) {
-        ssh_key_free(key);
-    }
-
-    if (arguments.file != NULL) {
-        free(arguments.file);
-    }
-
-    if (arguments.passphrase != NULL) {
-#ifdef HAVE_EXPLICIT_BZERO
-        explicit_bzero(arguments.passphrase, strlen(arguments.passphrase));
-#else
-        bzero(arguments.passphrase, strlen(arguments.passphrase));
-#endif
-        free(arguments.passphrase);
-    }
-
-    if (pubkey_file != NULL) {
-        free(pubkey_file);
-    }
-    return rc;
-}
--- a/examples/libssh_scp.c
+++ b/examples/libssh_scp.c
@@ -22,10 +22,6 @@ program.
 #include <libssh/libssh.h>
 #include "examples_common.h"

-#ifndef BUF_SIZE
-#define BUF_SIZE 16384
-#endif
-
 static char **sources;
 static int nsources;
 static char *destination;
@@ -109,6 +105,10 @@ static void location_free(struct location *loc)
                free(loc->user);
            }
            loc->user = NULL;
+            if (loc->host) {
+                free(loc->host);
+            }
+            loc->host = NULL;
        }
        free(loc);
    }
@@ -233,7 +233,7 @@ static int open_location(struct location *loc, int flag) {
        loc->file = fopen(loc->path, flag == READ ? "r":"w");
        if (!loc->file) {
            if (errno == EISDIR) {
-                if (loc->path != NULL && chdir(loc->path)) {
+                if (chdir(loc->path)) {
                    fprintf(stderr,
                            "Error changing directory to %s: %s\n",
                            loc->path, strerror(errno));
@@ -257,15 +257,14 @@ static int open_location(struct location *loc, int flag) {
 * @param recursive Copy also directories
 */
 static int do_copy(struct location *src, struct location *dest, int recursive) {
-    size_t size;
+    int size;
    socket_t fd;
    struct stat s;
    int w, r;
-    char buffer[BUF_SIZE];
-    size_t total = 0;
-    mode_t mode;
+    char buffer[16384];
+    int total = 0;
+    int mode;
    char *filename = NULL;
-
    /* recursive mode doesn't work yet */
    (void)recursive;
    /* Get the file name and size*/
@@ -303,7 +302,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                fprintf(stderr,
                        "Error: %s\n",
                        ssh_get_error(src->session));
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }
        } while(r != SSH_SCP_REQUEST_NEWFILE);
@@ -316,7 +315,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
            fprintf(stderr,
                    "error: %s\n",
                    ssh_get_error(dest->session));
-            SSH_STRING_FREE_CHAR(filename);
+            ssh_string_free_char(filename);
            ssh_scp_free(dest->scp);
            dest->scp = NULL;
            return -1;
@@ -331,7 +330,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                if (src->is_ssh) {
                    ssh_scp_deny_request(src->scp, "Cannot open local file");
                }
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }
        }
@@ -347,7 +346,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                fprintf(stderr,
                        "Error reading scp: %s\n",
                        ssh_get_error(src->session));
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }

@@ -364,7 +363,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                fprintf(stderr,
                        "Error reading file: %s\n",
                        strerror(errno));
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }
        }
@@ -377,7 +376,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                        ssh_get_error(dest->session));
                ssh_scp_free(dest->scp);
                dest->scp = NULL;
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }
        } else {
@@ -386,7 +385,7 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {
                fprintf(stderr,
                        "Error writing in local file: %s\n",
                        strerror(errno));
-                SSH_STRING_FREE_CHAR(filename);
+                ssh_string_free_char(filename);
                return -1;
            }
        }
@@ -394,8 +393,8 @@ static int do_copy(struct location *src, struct location *dest, int recursive) {

    } while(total < size);

-    SSH_STRING_FREE_CHAR(filename);
-    printf("wrote %zu bytes\n", total);
+    ssh_string_free_char(filename);
+    printf("wrote %d bytes\n", total);
    return 0;
 }

@@ -404,11 +403,10 @@ int main(int argc, char **argv) {
    int i;
    int r;
    if (opts(argc, argv) < 0) {
-        return EXIT_FAILURE;
+        r = EXIT_FAILURE;
+        goto end;
    }

-    ssh_init();
-
    dest = parse_location(destination);
    if (dest == NULL) {
        r = EXIT_FAILURE;
@@ -450,7 +448,5 @@ close_dest:
    close_location(dest);
    location_free(dest);
 end:
-    ssh_finalize();
-    free(sources);
    return r;
 }
--- a/examples/proxy.c
+++ b/examples/proxy.c
@@ -25,10 +25,6 @@ clients must be made or how a client should react.
 #include <string.h>
 #include <stdio.h>

-#ifndef BUF_SIZE
-#define BUF_SIZE 2048
-#endif
-
 #define USER "myuser"
 #define PASSWORD "mypassword"

@@ -229,7 +225,7 @@ int main(int argc, char **argv){
        .channel_open_request_session_function = new_session_channel
    };

-    char buf[BUF_SIZE];
+    char buf[2048];
    char host[128]="";
    char *ptr;
    int i,r, rc;
@@ -295,7 +291,7 @@ int main(int argc, char **argv){
    snprintf(buf,sizeof(buf), "Hello %s, welcome to the Sample SSH proxy.\r\nPlease select your destination: ", username);
    ssh_channel_write(chan, buf, strlen(buf));
    do{
-        i=ssh_channel_read(chan,buf, sizeof(buf), 0);
+        i=ssh_channel_read(chan,buf, 2048, 0);
        if(i>0) {
            ssh_channel_write(chan, buf, i);
            if(strlen(host) + i < sizeof(host)){
--- a/examples/samplesftp.c
+++ b/examples/samplesftp.c
@@ -29,13 +29,11 @@ clients must be made or how a client should react.
 #include "examples_common.h"
 #ifdef WITH_SFTP

-#ifndef BUF_SIZE
-#define BUF_SIZE 65536
-#endif
-
 static int verbosity;
 static char *destination;

+#define DATALEN 65536
+
 static void do_sftp(ssh_session session) {
    sftp_session sftp = sftp_new(session);
    sftp_dir dir;
@@ -46,7 +44,7 @@ static void do_sftp(ssh_session session) {
    sftp_file to;
    int len = 1;
    unsigned int i;
-    char data[BUF_SIZE] = {0};
+    char data[DATALEN] = {0};
    char *lnk;

    unsigned int count;
@@ -225,9 +223,9 @@ static void do_sftp(ssh_session session) {
    to = sftp_open(sftp, "/tmp/grosfichier", O_WRONLY|O_CREAT, 0644);

    for (i = 0; i < 1000; ++i) {
-        len = sftp_write(to, data, sizeof(data));
+        len = sftp_write(to, data, DATALEN);
        printf("wrote %d bytes\n", len);
-        if (len != sizeof(data)) {
+        if (len != DATALEN) {
            printf("chunk %d : %d (%s)\n", i, len, ssh_get_error(session));
        }
    }
--- a/examples/samplesshd-cb.c
+++ b/examples/samplesshd-cb.c
@@ -25,14 +25,6 @@ clients must be made or how a client should react.
 #include <string.h>
 #include <stdio.h>

-#ifdef _WIN32
-#include <io.h>
-#endif
-
-#ifndef BUF_SIZE
-#define BUF_SIZE 2049
-#endif
-
 #ifndef KEYS_FOLDER
 #ifdef _WIN32
 #define KEYS_FOLDER
@@ -49,27 +41,6 @@ static int tries = 0;
 static int error = 0;
 static ssh_channel chan=NULL;

-static int auth_none(ssh_session session,
-                     const char *user,
-                     void *userdata)
-{
-    ssh_string banner = NULL;
-
-    (void)user; /* unused */
-    (void)userdata; /* unused */
-
-    ssh_set_auth_methods(session,
-                         SSH_AUTH_METHOD_PASSWORD | SSH_AUTH_METHOD_GSSAPI_MIC);
-
-    banner = ssh_string_from_char("Banner Example\n");
-    if (banner != NULL) {
-        ssh_send_issue_banner(session, banner);
-    }
-    ssh_string_free(banner);
-
-    return SSH_AUTH_DENIED;
-}
-
 static int auth_password(ssh_session session, const char *user,
        const char *password, void *userdata){
    (void)userdata;
@@ -89,7 +60,6 @@ static int auth_password(ssh_session session, const char *user,
    return SSH_AUTH_DENIED;
 }

-#ifdef WITH_GSSAPI
 static int auth_gssapi_mic(ssh_session session, const char *user, const char *principal, void *userdata){
    ssh_gssapi_creds creds = ssh_gssapi_get_creds(session);
    (void)userdata;
@@ -102,7 +72,6 @@ static int auth_gssapi_mic(ssh_session session, const char *user, const char *pr
    authenticated = 1;
    return SSH_AUTH_SUCCESS;
 }
-#endif

 static int pty_request(ssh_session session, ssh_channel channel, const char *term,
        int x,int y, int px, int py, void *userdata){
@@ -196,14 +165,6 @@ static struct argp_option options[] = {
        .doc   = "Get verbose output.",
        .group = 0
    },
-    {
-        .name  = "config",
-        .key   = 'f',
-        .arg   = "FILE",
-        .flags = 0,
-        .doc   = "Configuration file to use.",
-        .group = 0
-    },
    {NULL, 0, NULL, 0, NULL, 0}
 };

@@ -230,9 +191,6 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
        case 'v':
            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR, "3");
            break;
-        case 'f':
-            ssh_bind_options_parse_config(sshbind, arg);
-            break;
        case ARGP_KEY_ARG:
            if (state->arg_num >= 1) {
                /* Too many arguments. */
@@ -263,15 +221,12 @@ int main(int argc, char **argv){
    ssh_event mainloop;
    struct ssh_server_callbacks_struct cb = {
        .userdata = NULL,
-        .auth_none_function = auth_none,
        .auth_password_function = auth_password,
-#ifdef WITH_GSSAPI
        .auth_gssapi_mic_function = auth_gssapi_mic,
-#endif
        .channel_open_request_session_function = new_session_channel
    };

-    char buf[BUF_SIZE];
+    char buf[2048];
    int i;
    int r;

@@ -327,24 +282,19 @@ int main(int argc, char **argv){
    } else
        printf("Authenticated and got a channel\n");
    do{
-        i=ssh_channel_read(chan, buf, sizeof(buf) - 1, 0);
+        i=ssh_channel_read(chan,buf, 2048, 0);
        if(i>0) {
-            if (ssh_channel_write(chan, buf, i) == SSH_ERROR) {
-                printf("error writing to channel\n");
+            ssh_channel_write(chan, buf, i);
+            if (write(1,buf,i) < 0) {
+                printf("error writing to buffer\n");
                return 1;
            }
-
-            buf[i] = '\0';
-            printf("%s", buf);
-            fflush(stdout);
-
            if (buf[0] == '\x0d') {
-                if (ssh_channel_write(chan, "\n", 1) == SSH_ERROR) {
-                    printf("error writing to channel\n");
+                if (write(1, "\n", 1) < 0) {
+                    printf("error writing to buffer\n");
                    return 1;
                }
-
-                printf("\n");
+                ssh_channel_write(chan, "\n", 1);
            }
        }
    } while (i>0);
--- a/examples/samplesshd-kbdint.c
+++ b/examples/samplesshd-kbdint.c
@@ -25,10 +25,6 @@ clients must be made or how a client should react.
 #include <stdio.h>
 #include <stdbool.h>

-#ifndef BUF_SIZE
-#define BUF_SIZE 2048
-#endif
-
 #define SSHD_USER "libssh"
 #define SSHD_PASSWORD "libssh"

@@ -297,7 +293,7 @@ int main(int argc, char **argv){
    ssh_bind sshbind;
    ssh_message message;
    ssh_channel chan=0;
-    char buf[BUF_SIZE];
+    char buf[2048];
    int auth=0;
    int shell=0;
    int i;
@@ -403,7 +399,7 @@ int main(int argc, char **argv){

    printf("it works !\n");
    do{
-        i=ssh_channel_read(chan,buf, sizeof(buf), 0);
+        i=ssh_channel_read(chan,buf, 2048, 0);
        if(i>0) {
            if(*buf == '' || *buf == '')
                    break;
--- a/examples/scp_download.c
+++ b/examples/scp_download.c
@@ -22,10 +22,6 @@ program.
 #include <libssh/libssh.h>
 #include "examples_common.h"

-#ifndef BUF_SIZE
-#define BUF_SIZE 16384
-#endif
-
 static int verbosity = 0;
 static const char *createcommand =
    "rm -fr /tmp/libssh_tests && mkdir /tmp/libssh_tests && "
@@ -106,7 +102,7 @@ static void create_files(ssh_session session){

 static int fetch_files(ssh_session session){
  int size;
-  char buffer[BUF_SIZE];
+  char buffer[16384];
  int mode;
  char *filename;
  int r;
--- a/examples/senddata.c
+++ b/examples/senddata.c
@@ -17,7 +17,7 @@ int main(void) {
    return 1;
  }

-  channel = ssh_channel_new(session);
+  channel = ssh_channel_new(session);;
  if (channel == NULL) {
    ssh_disconnect(session);
    return 1;
--- a/examples/ssh_X11_client.c
+++ b/examples/ssh_X11_client.c
@@ -1,866 +0,0 @@
-/*
- * ssh.c - Simple example of SSH X11 client using libssh
- *
- * Copyright (C) 2022 Marco Fortina
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA  02110-1301, USA.
- *
- *  In addition, as a special exception, the copyright holders give
- *  permission to link the code of portions of this program with the
- *  OpenSSL library under certain conditions as described in each
- *  individual source file, and distribute linked combinations
- *  including the two.
- *  You must obey the GNU General Public License in all respects
- *  for all of the code used other than OpenSSL. *  If you modify
- *  file(s) with this exception, you may extend this exception to your
- *  version of the file(s), but you are not obligated to do so. *  If you
- *  do not wish to do so, delete this exception statement from your
- *  version. *  If you delete this exception statement from all source
- *  files in the program, then also delete it here.
- *
- *
- *
- * ssh_X11_client
- * ==============
- *
- * AUTHOR URL
- * https://gitlab.com/marco.fortina/libssh-x11-client/
- *
- * This is a simple example of SSH X11 client using libssh.
- *
- * Features:
- *
- * - support local display (e.g. :0)
- * - support remote display (e.g. localhost:10.0)
- * - using callbacks and event polling to significantly reduce CPU utilization
- * - use X11 forwarding with authentication spoofing (like openssh)
- *
- * Note:
- *
- * - part of this code was inspired by openssh's one.
- *
- * Dependencies:
- *
- * - gcc >= 7.5.0
- * - libssh >= 0.8.0
- * - libssh-dev >= 0.8.0
- *
- * To Build:
- * gcc -o ssh_X11_client ssh_X11_client.c -lssh -g
- *
- * Donations:
- *
- * If you liked this work and wish to support the developer please donate to:
- * Bitcoin: 1N2rQimKbeUQA8N2LU5vGopYQJmZsBM2d6
- *
-*/
-
-#include <errno.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <pthread.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <termios.h>
-#include <time.h>
-
-#include <libssh/libssh.h>
-#include <libssh/callbacks.h>
-
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-
-#include <sys/un.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-/*
- * Data Structures and Macros
-*/
-
-#define _PATH_UNIX_X 	"/tmp/.X11-unix/X%d"
-#define _XAUTH_CMD	"/usr/bin/xauth list %s 2>/dev/null"
-
-typedef struct item {
-	ssh_channel channel;
-	int fd_in;
-	int fd_out;
-	int protected;
-	struct item *next;
-} node_t;
-
-node_t *node = NULL;
-
-
-/*
- * Mutex
-*/
-
-pthread_mutex_t mutex;
-
-
-/*
- * Function declarations
-*/
-
-/* Linked nodes to manage channel/fd tuples */
-static void insert_item(ssh_channel channel, int fd_in, int fd_out, int protected);
-static void delete_item(ssh_channel channel);
-static node_t * search_item(ssh_channel channel);
-
-/* X11 Display */
-const char * ssh_gai_strerror(int gaierr);
-static int x11_get_proto(const char *display, char **_proto, char **_data);
-static void set_nodelay(int fd);
-static int connect_local_xsocket_path(const char *pathname);
-static int connect_local_xsocket(int display_number);
-static int x11_connect_display(void);
-
-/* Send data to channel */
-static int copy_fd_to_channel_callback(int fd, int revents, void *userdata);
-
-/* Read data from channel */
-static int copy_channel_to_fd_callback(ssh_session session, ssh_channel channel, void *data, uint32_t len, int is_stderr, void *userdata);
-
-/* EOF&Close channel */
-static void channel_close_callback(ssh_session session, ssh_channel channel, void *userdata);
-
-/* X11 Request */
-static ssh_channel x11_open_request_callback(ssh_session session, const char *shost, int sport, void *userdata);
-
-/* Main loop */
-static int main_loop(ssh_channel channel);
-
-/* Internals */
-int64_t _current_timestamp(void);
-
-/* Global variables */
-const char *hostname = NULL;
-int enableX11 = 1;
-
-/*
- * Callbacks Data Structures
-*/
-
-/* SSH Channel Callbacks */
-struct ssh_channel_callbacks_struct channel_cb =
-{
-	.channel_data_function = copy_channel_to_fd_callback,
-	.channel_eof_function = channel_close_callback,
-	.channel_close_function = channel_close_callback,
-	.userdata = NULL
-};
-
-/* SSH Callbacks */
-struct ssh_callbacks_struct cb =
-{
-	.channel_open_request_x11_function = x11_open_request_callback,
-	.userdata = NULL
-};
-
-
-/*
- * SSH Event Context
-*/
-
-short events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
-ssh_event event;
-
-
-/*
- * Internal data structures
-*/
-
-struct termios _saved_tio;
-
-
-/*
- * Internal functions
-*/
-
-int64_t
-_current_timestamp(void) {
-	struct timeval tv;
-	int64_t milliseconds;
-
-	gettimeofday(&tv, NULL);
-	milliseconds = (int64_t)(tv.tv_sec) * 1000 + (tv.tv_usec / 1000);
-
-	return milliseconds;
-}
-
-static void
-_logging_callback(int priority, const char *function, const char *buffer, void *userdata)
-{
-	FILE *fp = NULL;
-	char buf[100];
-	int64_t milliseconds;
-
-	time_t now = time (0);
-
-	(void)userdata;
-
-	strftime(buf, 100, "%Y-%m-%d %H:%M:%S", localtime (&now));
-
-	fp = fopen("debug.log","a");
-	if(fp == NULL)
-	{
-		printf("Error!");
-		exit(-11);
-	}
-
-	milliseconds = _current_timestamp();
-
-	fprintf(fp, "[%s.%jd, %d] %s: %s\n", buf, milliseconds, priority, function, buffer);
-	fclose(fp);
-}
-
-static int
-_enter_term_raw_mode(void)
-{
-	struct termios tio;
-	int ret = tcgetattr(fileno(stdin), &tio);
-	if (ret != -1) {
-		_saved_tio = tio;
-		tio.c_iflag |= IGNPAR;
-		tio.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
-#ifdef IUCLC
-		tio.c_iflag &= ~IUCLC;
-#endif
-		tio.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL);
-#ifdef IEXTEN
-		tio.c_lflag &= ~IEXTEN;
-#endif
-		tio.c_oflag &= ~OPOST;
-		tio.c_cc[VMIN] = 1;
-		tio.c_cc[VTIME] = 0;
-		ret = tcsetattr(fileno(stdin), TCSADRAIN, &tio);
-	}
-	return ret;
-}
-
-static int
-_leave_term_raw_mode(void)
-{
-	int ret = tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio);
-	return ret;
-}
-
-
-/*
- * Functions
-*/
-
-static void
-insert_item(ssh_channel channel, int fd_in, int fd_out, int protected)
-{
-	node_t *node_iterator = NULL, *new = NULL;
-
-	pthread_mutex_lock(&mutex);
-
-	if (node == NULL) {
-		/* Calloc ensure that node is full of 0 */
-		node = (node_t *) calloc(1, sizeof(node_t));
-		node->channel = channel;
-		node->fd_in = fd_in;
-		node->fd_out = fd_out;
-		node->protected = protected;
-		node->next = NULL;
-	} else {
-		node_iterator = node;
-		while (node_iterator->next != NULL)
-			node_iterator = node_iterator->next;
-		/* Create the new node */
-		new = (node_t *) malloc(sizeof(node_t));
-		new->channel = channel;
-		new->fd_in = fd_in;
-		new->fd_out = fd_out;
-		new->protected = protected;
-		new->next = NULL;
-		node_iterator->next = new;
-
-	}
-
-	pthread_mutex_unlock(&mutex);
-}
-
-
-static void
-delete_item(ssh_channel channel)
-{
-	node_t *current = NULL, *previous = NULL;
-
-	pthread_mutex_lock(&mutex);
-
-	for (current = node; current; previous = current, current = current->next) {
-		if (current->channel != channel)
-			continue;
-
-		if (previous == NULL)
-			node = current->next;
-		else
-			previous->next = current->next;
-
-		free(current);
-		pthread_mutex_unlock(&mutex);
-		return;
-	}
-
-	pthread_mutex_unlock(&mutex);
-}
-
-
-static node_t *
-search_item(ssh_channel channel)
-{
-	node_t *current = node;
-
-	pthread_mutex_lock(&mutex);
-
-	while (current != NULL) {
-		if (current->channel == channel) {
-			pthread_mutex_unlock(&mutex);
-			return current;
-		} else {
-			current = current->next;
-		}
-	}
-
-	pthread_mutex_unlock(&mutex);
-
-	return NULL;
-}
-
-
-
-static void
-set_nodelay(int fd)
-{
-	int opt;
-	socklen_t optlen;
-
-	optlen = sizeof(opt);
-	if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen) == -1) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "getsockopt TCP_NODELAY: %.100s", strerror(errno));
-		return;
-	}
-	if (opt == 1) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "fd %d is TCP_NODELAY", fd);
-		return;
-	}
-	opt = 1;
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "fd %d setting TCP_NODELAY", fd);
-	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) == -1)
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "setsockopt TCP_NODELAY: %.100s", strerror(errno));
-}
-
-
-const char *
-ssh_gai_strerror(int gaierr)
-{
-	if (gaierr == EAI_SYSTEM && errno != 0)
-		return strerror(errno);
-	return gai_strerror(gaierr);
-}
-
-
-
-static int
-x11_get_proto(const char *display, char **_proto, char **_cookie)
-{
-	char cmd[1024], line[512], xdisplay[512];
-	static char proto[512], cookie[512];
-	FILE *f = NULL;
-	int ret = 0;
-
-	*_proto = proto;
-	*_cookie = cookie;
-
-	proto[0] = cookie[0] = '\0';
-
-	if (strncmp(display, "localhost:", 10) == 0) {
-		if ((ret = snprintf(xdisplay, sizeof(xdisplay), "unix:%s", display + 10)) < 0 || (size_t)ret >= sizeof(xdisplay)) {
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "display name too long. display: %s", display);
-			return -1;
-		}
-		display = xdisplay;
-	}
-
-	snprintf(cmd, sizeof(cmd), _XAUTH_CMD, display);
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "xauth cmd: %s", cmd);
-
-	f = popen(cmd, "r");
-	if (f && fgets(line, sizeof(line), f) && sscanf(line, "%*s %511s %511s", proto, cookie) == 2) {
-		ret = 0;
-	} else {
-		ret = 1;
-	}
-
-	if (f) pclose(f);
-
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "proto: %s - cookie: %s - ret: %d", proto, cookie, ret);
-
-	return ret;
-}
-
-static int
-connect_local_xsocket_path(const char *pathname)
-{
-	int sock;
-	struct sockaddr_un addr;
-
-	sock = socket(AF_UNIX, SOCK_STREAM, 0);
-	if (sock == -1) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "socket: %.100s", strerror(errno));
-		return -1;
-	}
-
-	memset(&addr, 0, sizeof(addr));
-	addr.sun_family = AF_UNIX;
-	addr.sun_path[0] = '\0';
-	/* pathname is guaranteed to be initialized and larger than addr.sun_path[108] */
-	memcpy(addr.sun_path + 1, pathname, sizeof(addr.sun_path) - 1);
-	if (connect(sock, (struct sockaddr *)&addr, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(pathname)) == 0)
-		return sock;
-	close(sock);
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "connect %.100s: %.100s", addr.sun_path, strerror(errno));
-	return -1;
-}
-
-
-static int
-connect_local_xsocket(int display_number)
-{
-	char buf[1024] = {0};
-	snprintf(buf, sizeof(buf), _PATH_UNIX_X, display_number);
-	return connect_local_xsocket_path(buf);
-}
-
-
-static int
-x11_connect_display()
-{
-	int display_number;
-	const char *display = NULL;
-	char buf[1024], *cp = NULL;
-	struct addrinfo hints, *ai = NULL, *aitop = NULL;
-	char strport[NI_MAXSERV];
-	int gaierr = 0, sock = 0;
-
-	/* Try to open a socket for the local X server. */
-	display = getenv("DISPLAY");
-
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "display: %s", display);
-
-	if (!display) {
-		return -1;
-	}
-
-	/* Check if it is a unix domain socket. */
-	if (strncmp(display, "unix:", 5) == 0 || display[0] == ':') {
-		/* Connect to the unix domain socket. */
-		if (sscanf(strrchr(display, ':') + 1, "%d", &display_number) != 1) {
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "Could not parse display number from DISPLAY: %.100s", display);
-			return -1;
-		}
-
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "display_number: %d", display_number);
-
-		/* Create a socket. */
-		sock = connect_local_xsocket(display_number);
-
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "socket: %d", sock);
-
-		if (sock < 0)
-			return -1;
-
-		/* OK, we now have a connection to the display. */
-		return sock;
-	}
-
-	/* Connect to an inet socket. */
-	strncpy(buf, display, sizeof(buf) - 1);
-	cp = strchr(buf, ':');
-	if (!cp) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "Could not find ':' in DISPLAY: %.100s", display);
-		return -1;
-	}
-	*cp = 0;
-	if (sscanf(cp + 1, "%d", &display_number) != 1) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "Could not parse display number from DISPLAY: %.100s", display);
-		return -1;
-	}
-
-	/* Look up the host address */
-	memset(&hints, 0, sizeof(hints));
-	hints.ai_family = AF_INET;
-	hints.ai_socktype = SOCK_STREAM;
-	snprintf(strport, sizeof(strport), "%u", 6000 + display_number);
-	if ((gaierr = getaddrinfo(buf, strport, &hints, &aitop)) != 0) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "%.100s: unknown host. (%s)", buf, ssh_gai_strerror(gaierr));
-		return -1;
-	}
-	for (ai = aitop; ai; ai = ai->ai_next) {
-		/* Create a socket. */
-		sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
-		if (sock == -1) {
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "socket: %.100s", strerror(errno));
-			continue;
-		}
-		/* Connect it to the display. */
-		if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "connect %.100s port %u: %.100s", buf, 6000 + display_number, strerror(errno));
-			close(sock);
-			continue;
-		}
-		/* Success */
-		break;
-	}
-	freeaddrinfo(aitop);
-	if (!ai) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "connect %.100s port %u: %.100s", buf, 6000 + display_number, strerror(errno));
-		return -1;
-	}
-	set_nodelay(sock);
-	return sock;
-}
-
-
-
-static int
-copy_fd_to_channel_callback(int fd, int revents, void *userdata)
-{
-	ssh_channel channel = (ssh_channel)userdata;
-	char buf[2097152];
-	int sz = 0, ret = 0;
-
-	node_t *temp_node = search_item(channel);
-
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "event: %d - fd: %d", revents, fd);
-
-	if (!channel) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "channel does not exist.");
-		if (temp_node->protected == 0) {
-			close(fd);
-		}
-		return -1;
-	}
-
-	if (fcntl(fd, F_GETFD) == -1) {
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "fcntl error. fd: %d", fd);
-		ssh_channel_close(channel);
-		return -1;
-	}
-
-	if ((revents & POLLIN) || (revents & POLLPRI)) {
-		sz = read(fd, buf, sizeof(buf));
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "sz: %d", sz);
-		if (sz > 0) {
-			ret = ssh_channel_write(channel, buf, sz);
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "channel_write ret: %d", ret);
-		} else if (sz < 0) {
-			ssh_channel_close(channel);
-			return -1;
-		} else {
-			/* sz = 0. Why the hell I'm here? */
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "Why the hell am I here?: sz: %d", sz);
-			if (temp_node->protected == 0) {
-				close(fd);
-			}
-			return -1;
-		}
-	}
-
-	if ((revents & POLLHUP) || (revents & POLLNVAL) || (revents & POLLERR)) {
-		ssh_channel_close(channel);
-		return -1;
-	}
-
-	return sz;
-}
-
-
-static int
-copy_channel_to_fd_callback(ssh_session session, ssh_channel channel, void *data, uint32_t len, int is_stderr, void *userdata)
-{
-	node_t *temp_node = NULL;
-	int fd, sz;
-
-	(void)session;
-	(void)is_stderr;
-	(void)userdata;
-
-	temp_node = search_item(channel);
-
-	fd = temp_node->fd_out;
-
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "len: %d - fd: %d - is_stderr: %d", len, fd, is_stderr);
-
-	sz = write(fd, data, len);
-
-	return sz;
-}
-
-
-static void
-channel_close_callback(ssh_session session, ssh_channel channel, void *userdata)
-{
-	node_t *temp_node = NULL;
-
-	(void)session;
-	(void)userdata;
-
-	temp_node = search_item(channel);
-
-	if (temp_node != NULL) {
-		int fd = temp_node->fd_in;
-
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "fd: %d", fd);
-
-		delete_item(channel);
-		ssh_event_remove_fd(event, fd);
-
-		if (temp_node->protected == 0) {
-			close(fd);
-		}
-	}
-}
-
-
-static ssh_channel
-x11_open_request_callback(ssh_session session, const char *shost, int sport, void *userdata)
-{
-	ssh_channel channel = NULL;
-	int sock;
-
-	(void)shost;
-	(void)sport;
-	(void)userdata;
-
-	channel	= ssh_channel_new(session);
-
-	sock = x11_connect_display();
-
-	_ssh_log(SSH_LOG_FUNCTIONS, __func__, "sock: %d", sock);
-
-	insert_item(channel, sock, sock, 0);
-
-	ssh_event_add_fd(event, sock, events, copy_fd_to_channel_callback, channel);
-	ssh_event_add_session(event, session);
-
-	ssh_add_channel_callbacks(channel, &channel_cb);
-
-	return channel;
-}
-
-
-
-/*
- * MAIN LOOP
-*/
-
-static int
-main_loop(ssh_channel channel)
-{
-	ssh_session session = ssh_channel_get_session(channel);
-
-	insert_item(channel, fileno(stdin), fileno(stdout), 1);
-
-	ssh_callbacks_init(&channel_cb);
-	ssh_set_channel_callbacks(channel, &channel_cb);
-
-	event = ssh_event_new();
-	if (event == NULL) {
-		printf("Couldn't get a event\n");
-		return -1;
-	}
-
-	if (ssh_event_add_fd(event, fileno(stdin), events, copy_fd_to_channel_callback, channel) != SSH_OK) {
-		printf("Couldn't add an fd to the event\n");
-		return -1;
-	}
-
-	if(ssh_event_add_session(event, session) != SSH_OK) {
-		printf("Couldn't add the session to the event\n");
-		return -1;
-	}
-
-	do {
-		if (ssh_event_dopoll(event, 1000) == SSH_ERROR) {
-			printf("Error : %s\n", ssh_get_error(session));
-			/* fall through */
-		}
-	} while (!ssh_channel_is_closed(channel));
-
-	delete_item(channel);
-	ssh_event_remove_fd(event, fileno(stdin));
-	ssh_event_remove_session(event, session);
-	ssh_event_free(event);
-
-	return 0;
-}
-
-
-/*
- * USAGE
- */
-
-static void
-usage(void)
-{
-	fprintf(stderr,
-		"Usage : ssh-X11-client [options] [login@]hostname\n"
-		"sample X11 client - libssh-%s\n"
-		"Options :\n"
-		"  -l user : Specifies the user to log in as on the remote machine.\n"
-		"  -p port : Port to connect to on the remote host.\n"
-		"  -v      : Verbose mode. Multiple -v options increase the verbosity. The maximum is 5.\n"
-		"  -C      : Requests compression of all data.\n"
-		"  -x      : Disables X11 forwarding.\n"
-		"\n",
-		ssh_version(0));
-
-	exit(0);
-}
-
-static int opts(int argc, char **argv)
-{
-	int i;
-
-	while ((i = getopt(argc,argv,"x")) != -1) {
-		switch(i) {
-		case 'x':
-			enableX11 = 0;
-			break;
-		default:
-			fprintf(stderr, "Unknown option %c\n", optopt);
-			return -1;
-		}
-	}
-
-	if (optind < argc) {
-		hostname = argv[optind++];
-	}
-
-	if (hostname == NULL) {
-		return -1;
-	}
-
-	return 0;
-}
-
-/*
- * MAIN
-*/
-
-int
-main(int argc, char **argv)
-{
-	char *password = NULL;
-
-	ssh_session session = NULL;
-	ssh_channel channel = NULL;
-
-	int ret;
-
-	const char *display = NULL;
-	char *proto = NULL, *cookie = NULL;
-
-	ssh_set_log_callback(_logging_callback);
-	ret = ssh_init();
-	if (ret != SSH_OK) return ret;
-
-	session = ssh_new();
-	if (session == NULL) exit(-1);
-
-	if (ssh_options_getopt(session, &argc, argv) || opts(argc, argv)) {
-		fprintf(stderr, "Error parsing command line: %s\n", ssh_get_error(session));
-		ssh_free(session);
-		ssh_finalize();
-		usage();
-	}
-
-	if (ssh_options_set(session, SSH_OPTIONS_HOST, hostname) < 0) {
-		return -1;
-	}
-
-	ret = ssh_connect(session);
-	if (ret != SSH_OK) {
-		fprintf(stderr, "Connection failed : %s\n", ssh_get_error(session));
-		exit(-1);
-	}
-
-	password = getpass("Password: ");
-	ret = ssh_userauth_password(session, NULL, password);
-	if (ret != SSH_AUTH_SUCCESS) {
-		fprintf(stderr, "Error authenticating with password: %s\n", ssh_get_error(session));
-		exit(-1);
-	}
-
-	channel = ssh_channel_new(session);
-	if (channel == NULL) return SSH_ERROR;
-
-	ret = ssh_channel_open_session(channel);
-	if (ret != SSH_OK) return ret;
-
-	ret = ssh_channel_request_pty(channel);
-	if (ret != SSH_OK) return ret;
-
-	ret = ssh_channel_change_pty_size(channel, 80, 24);
-	if (ret != SSH_OK) return ret;
-
-	if (enableX11 == 1) {
-		display = getenv("DISPLAY");
-
-		_ssh_log(SSH_LOG_FUNCTIONS, __func__, "display: %s", display);
-
-		if (display) {
-			ssh_callbacks_init(&cb);
-			ret = ssh_set_callbacks(session, &cb);
-			if (ret != SSH_OK) return ret;
-
-			if (x11_get_proto(display, &proto, &cookie) != 0) {
-				_ssh_log(SSH_LOG_FUNCTIONS, __func__, "Using fake authentication data for X11 forwarding");
-				proto = NULL;
-				cookie = NULL;
-			}
-
-			_ssh_log(SSH_LOG_FUNCTIONS, __func__, "proto: %s - cookie: %s", proto, cookie);
-			/* See https://gitlab.com/libssh/libssh-mirror/-/blob/master/src/channels.c#L2062 for details. */
-			ret = ssh_channel_request_x11(channel, 0, proto, cookie, 0);
-			if (ret != SSH_OK) return ret;
-		}
-	}
-
-	ret = _enter_term_raw_mode();
-	if (ret != 0) exit(-1);
-
-	ret = ssh_channel_request_shell(channel);
-	if (ret != SSH_OK) return ret;
-
-	ret = main_loop(channel);
-	if (ret != SSH_OK) return ret;
-
-	_leave_term_raw_mode();
-
-	ssh_channel_close(channel);
-	ssh_channel_free(channel);
-	ssh_disconnect(session);
-	ssh_free(session);
-	ssh_finalize();
-}
--- a/examples/ssh_client.c
+++ b/examples/ssh_client.c
@@ -17,7 +17,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <limits.h>

 #include <sys/select.h>
 #include <sys/time.h>
@@ -45,10 +44,9 @@
 #include "examples_common.h"
 #define MAXCMD 10

-static char *host = NULL;
-static char *user = NULL;
+static char *host;
+static char *user;
 static char *cmds[MAXCMD];
-static char *config_file = NULL;
 static struct termios terminal;

 static char *pcap_file = NULL;
@@ -83,7 +81,7 @@ static void add_cmd(char *cmd)
        return;
    }

-    cmds[n] = cmd;
+    cmds[n] = strdup(cmd);
 }

 static void usage(void)
@@ -96,7 +94,6 @@ static void usage(void)
            "  -p port : connect to port\n"
            "  -d : use DSS to verify host public key\n"
            "  -r : use RSA to verify host public key\n"
-            "  -F file : parse configuration file instead of default one\n"
 #ifdef WITH_PCAP
            "  -P file : create a pcap debugging file\n"
 #endif
@@ -113,14 +110,11 @@ static int opts(int argc, char **argv)
 {
    int i;

-    while((i = getopt(argc,argv,"T:P:F:")) != -1) {
+    while((i = getopt(argc,argv,"T:P:")) != -1) {
        switch(i){
        case 'P':
            pcap_file = optarg;
            break;
-        case 'F':
-            config_file = optarg;
-            break;
 #ifndef _WIN32
        case 'T':
            proxycommand = optarg;
@@ -128,7 +122,7 @@ static int opts(int argc, char **argv)
 #endif
        default:
            fprintf(stderr, "Unknown option %c\n", optopt);
-            return -1;
+            usage();
        }
    }
    if (optind < argc) {
@@ -140,7 +134,7 @@ static int opts(int argc, char **argv)
    }

    if (host == NULL) {
-        return -1;
+        usage();
    }

    return 0;
@@ -175,25 +169,22 @@ static void do_exit(int i)
    exit(0);
 }

+static ssh_channel chan;
 static int signal_delayed = 0;

-#ifdef SIGWINCH
 static void sigwindowchanged(int i)
 {
    (void) i;
    signal_delayed = 1;
 }
-#endif

 static void setsignal(void)
 {
-#ifdef SIGWINCH
    signal(SIGWINCH, sigwindowchanged);
-#endif
    signal_delayed = 0;
 }

-static void sizechanged(ssh_channel chan)
+static void sizechanged(void)
 {
    struct winsize win = {
        .ws_row = 0,
@@ -231,7 +222,7 @@ static void select_loop(ssh_session session,ssh_channel channel)

    while (ssh_channel_is_open(channel)) {
        if (signal_delayed) {
-            sizechanged(channel);
+            sizechanged();
        }
        rc = ssh_event_dopoll(event, 60000);
        if (rc == SSH_ERROR) {
@@ -271,9 +262,10 @@ static void shell(ssh_session session)
        ssh_channel_free(channel);
        return;
    }
+    chan = channel;
    if (interactive) {
        ssh_channel_request_pty(channel);
-        sizechanged(channel);
+        sizechanged();
    }

    if (ssh_channel_request_shell(channel)) {
@@ -298,12 +290,14 @@ static void shell(ssh_session session)
 static void batch_shell(ssh_session session)
 {
    ssh_channel channel;
-    char buffer[PATH_MAX];
+    char buffer[1024];
    size_t i;
    int s = 0;

    for (i = 0; i < MAXCMD && cmds[i]; ++i) {
        s += snprintf(buffer + s, sizeof(buffer) - s, "%s ", cmds[i]);
+        free(cmds[i]);
+        cmds[i] = NULL;
    }

    channel = ssh_channel_new(session);
@@ -332,7 +326,7 @@ static int client(ssh_session session)
            return -1;
        }
    }
-    if (ssh_options_set(session, SSH_OPTIONS_HOST, host) < 0) {
+    if (ssh_options_set(session, SSH_OPTIONS_HOST ,host) < 0) {
        return -1;
    }
    if (proxycommand != NULL) {
@@ -340,13 +334,7 @@ static int client(ssh_session session)
            return -1;
        }
    }
-    /* Parse configuration file if specified: The command-line options will
-     * overwrite items loaded from configuration file */
-    if (config_file != NULL) {
-        ssh_options_parse_config(session, config_file);
-    } else {
-        ssh_options_parse_config(session, NULL);
-    }
+    ssh_options_parse_config(session, NULL);

    if (ssh_connect(session)) {
        fprintf(stderr, "Connection failed : %s\n", ssh_get_error(session));
@@ -410,20 +398,18 @@ int main(int argc, char **argv)
 {
    ssh_session session;

-    ssh_init();
    session = ssh_new();

    ssh_callbacks_init(&cb);
    ssh_set_callbacks(session,&cb);

-    if (ssh_options_getopt(session, &argc, argv) || opts(argc, argv)) {
+    if (ssh_options_getopt(session, &argc, argv)) {
        fprintf(stderr,
                "Error parsing command line: %s\n",
                ssh_get_error(session));
-        ssh_free(session);
-        ssh_finalize();
        usage();
    }
+    opts(argc, argv);
    signal(SIGTERM, do_exit);

    set_pcap(session);
--- a/examples/ssh_server_fork.c
+++ b/examples/ssh_server_fork.c
@@ -24,7 +24,6 @@ The goal is to show the API in action.
 #ifdef HAVE_LIBUTIL_H
 #include <libutil.h>
 #endif
-#include <pthread.h>
 #ifdef HAVE_PTY_H
 #include <pty.h>
 #endif
@@ -41,10 +40,6 @@ The goal is to show the API in action.
 #include <sys/stat.h>
 #include <stdio.h>

-#ifndef BUF_SIZE
-#define BUF_SIZE 1048576
-#endif
-
 #ifndef KEYS_FOLDER
 #ifdef _WIN32
 #define KEYS_FOLDER
@@ -53,6 +48,9 @@ The goal is to show the API in action.
 #endif
 #endif

+#define USER "myuser"
+#define PASS "mypassword"
+#define BUF_SIZE 1048576
 #define SESSION_END (SSH_CLOSED | SSH_CLOSED_ERROR)
 #define SFTP_SERVER_PATH "/usr/lib/sftp-server"

@@ -77,8 +75,6 @@ static void set_default_keys(ssh_bind sshbind,
 }
 #define DEF_STR_SIZE 1024
 char authorizedkeys[DEF_STR_SIZE] = {0};
-char username[128] = "myuser";
-char password[128] = "mypassword";
 #ifdef HAVE_ARGP_H
 const char *argp_program_version = "libssh server example "
 SSH_STRINGIFY(LIBSSH_VERSION);
@@ -141,22 +137,6 @@ static struct argp_option options[] = {
        .doc   = "Set the authorized keys file.",
        .group = 0
    },
-    {
-        .name  = "user",
-        .key   = 'u',
-        .arg   = "USERNAME",
-        .flags = 0,
-        .doc   = "Set expected username.",
-        .group = 0
-    },
-    {
-        .name  = "pass",
-        .key   = 'P',
-        .arg   = "PASSWORD",
-        .flags = 0,
-        .doc   = "Set expected password.",
-        .group = 0
-    },
    {
        .name  = "no-default-keys",
        .key   = 'n',
@@ -213,12 +193,6 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
        case 'a':
            strncpy(authorizedkeys, arg, DEF_STR_SIZE-1);
            break;
-        case 'u':
-            strncpy(username, arg, sizeof(username) - 1);
-            break;
-        case 'P':
-            strncpy(password, arg, sizeof(password) - 1);
-            break;
        case 'v':
            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR,
                                 "3");
@@ -252,89 +226,6 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {

 /* Our argp parser. */
 static struct argp argp = {options, parse_opt, args_doc, doc, NULL, NULL, NULL};
-#else
-static int parse_opt(int argc, char **argv, ssh_bind sshbind) {
-    int no_default_keys = 0;
-    int rsa_already_set = 0;
-    int dsa_already_set = 0;
-    int ecdsa_already_set = 0;
-    int key;
-
-    while((key = getopt(argc, argv, "a:d:e:k:np:P:r:u:v")) != -1) {
-        if (key == 'n') {
-            no_default_keys = 1;
-        } else if (key == 'p') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDPORT_STR, optarg);
-        } else if (key == 'd') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY, optarg);
-            dsa_already_set = 1;
-        } else if (key == 'k') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_HOSTKEY, optarg);
-            /* We can't track the types of keys being added with this
-            option, so let's ensure we keep the keys we're adding
-            by just not setting the default keys */
-            no_default_keys = 1;
-        } else if (key == 'r') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY, optarg);
-            rsa_already_set = 1;
-        } else if (key == 'e') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_ECDSAKEY, optarg);
-            ecdsa_already_set = 1;
-        } else if (key == 'a') {
-            strncpy(authorizedkeys, optarg, DEF_STR_SIZE-1);
-        } else if (key == 'u') {
-            strncpy(username, optarg, sizeof(username) - 1);
-        } else if (key == 'P') {
-            strncpy(password, optarg, sizeof(password) - 1);
-        } else if (key == 'v') {
-            ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR,
-                                 "3");
-        } else {
-            break;
-        }
-    }
-
-    if (key != -1) {
-        printf("Usage: %s [OPTION...] BINDADDR\n"
-               "libssh %s -- a Secure Shell protocol implementation\n"
-               "\n"
-               "  -a, --authorizedkeys=FILE  Set the authorized keys file.\n"
-               "  -d, --dsakey=FILE          Set the dsa key.\n"
-               "  -e, --ecdsakey=FILE        Set the ecdsa key.\n"
-               "  -k, --hostkey=FILE         Set a host key.  Can be used multiple times.\n"
-               "                             Implies no default keys.\n"
-               "  -n, --no-default-keys      Do not set default key locations.\n"
-               "  -p, --port=PORT            Set the port to bind.\n"
-               "  -P, --pass=PASSWORD        Set expected password.\n"
-               "  -r, --rsakey=FILE          Set the rsa key.\n"
-               "  -u, --user=USERNAME        Set expected username.\n"
-               "  -v, --verbose              Get verbose output.\n"
-               "  -?, --help                 Give this help list\n"
-               "\n"
-               "Mandatory or optional arguments to long options are also mandatory or optional\n"
-               "for any corresponding short options.\n"
-               "\n"
-               "Report bugs to <libssh@libssh.org>.\n",
-               argv[0], SSH_STRINGIFY(LIBSSH_VERSION));
-        return -1;
-    }
-
-    if (optind != argc - 1) {
-        printf("Usage: %s [OPTION...] BINDADDR\n", argv[0]);
-        return -1;
-    }
-
-    ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDADDR, argv[optind]);
-
-    if (!no_default_keys) {
-        set_default_keys(sshbind,
-                         rsa_already_set,
-                         dsa_already_set,
-                         ecdsa_already_set);
-    }
-
-    return 0;
-}
 #endif /* HAVE_ARGP_H */

 /* A userdata struct for channel. */
@@ -549,7 +440,7 @@ static int auth_password(ssh_session session, const char *user,

    (void) session;

-    if (strcmp(user, username) == 0 && strcmp(pass, password) == 0) {
+    if (strcmp(user, USER) == 0 && strcmp(pass, PASS) == 0) {
        sdata->authenticated = 1;
        return SSH_AUTH_SUCCESS;
    }
@@ -787,38 +678,18 @@ static void handle_session(ssh_event event, ssh_session session) {
    }
 }

-#ifdef WITH_FORK
 /* SIGCHLD handler for cleaning up dead children. */
 static void sigchld_handler(int signo) {
    (void) signo;
    while (waitpid(-1, NULL, WNOHANG) > 0);
 }
-#else
-static void *session_thread(void *arg) {
-    ssh_session session = arg;
-    ssh_event event;
-
-    event = ssh_event_new();
-    if (event != NULL) {
-        /* Blocks until the SSH session ends by either
-         * child thread exiting, or client disconnecting. */
-        handle_session(event, session);
-        ssh_event_free(event);
-    } else {
-        fprintf(stderr, "Could not create polling context\n");
-    }
-    ssh_disconnect(session);
-    ssh_free(session);
-    return NULL;
-}
-#endif

 int main(int argc, char **argv) {
    ssh_bind sshbind;
    ssh_session session;
-    int rc;
-#ifdef WITH_FORK
+    ssh_event event;
    struct sigaction sa;
+    int rc;

    /* Set up SIGCHLD handler. */
    sa.sa_handler = sigchld_handler;
@@ -828,7 +699,6 @@ int main(int argc, char **argv) {
        fprintf(stderr, "Failed to register SIGCHLD handler\n");
        return 1;
    }
-#endif

    rc = ssh_init();
    if (rc < 0) {
@@ -839,24 +709,20 @@ int main(int argc, char **argv) {
    sshbind = ssh_bind_new();
    if (sshbind == NULL) {
        fprintf(stderr, "ssh_bind_new failed\n");
-        ssh_finalize();
        return 1;
    }

 #ifdef HAVE_ARGP_H
    argp_parse(&argp, argc, argv, 0, 0, sshbind);
 #else
-    if (parse_opt(argc, argv, sshbind) < 0) {
-        ssh_bind_free(sshbind);
-        ssh_finalize();
-        return 1;
-    }
+    (void) argc;
+    (void) argv;
+
+    set_default_keys(sshbind, 0, 0, 0);
 #endif /* HAVE_ARGP_H */

    if(ssh_bind_listen(sshbind) < 0) {
        fprintf(stderr, "%s\n", ssh_get_error(sshbind));
-        ssh_bind_free(sshbind);
-        ssh_finalize();
        return 1;
    }

@@ -869,9 +735,6 @@ int main(int argc, char **argv) {

        /* Blocks until there is a new incoming connection. */
        if(ssh_bind_accept(sshbind, session) != SSH_ERROR) {
-#ifdef WITH_FORK
-            ssh_event event;
-
            switch(fork()) {
                case 0:
                    /* Remove the SIGCHLD handler inherited from parent. */
@@ -897,16 +760,6 @@ int main(int argc, char **argv) {
                case -1:
                    fprintf(stderr, "Failed to fork\n");
            }
-#else
-            pthread_t tid;
-
-            rc = pthread_create(&tid, NULL, session_thread, session);
-            if (rc == 0) {
-                pthread_detach(tid);
-                continue;
-            }
-            fprintf(stderr, "Failed to pthread_create\n");
-#endif
        } else {
            fprintf(stderr, "%s\n", ssh_get_error(sshbind));
        }
--- a/examples/sshd_direct-tcpip.c
+++ b/examples/sshd_direct-tcpip.c
@@ -23,36 +23,17 @@ clients must be made or how a client should react.
 #include <libssh/libssh.h>
 #include <libssh/server.h>
 #include <libssh/callbacks.h>
+#include <libssh/channels.h>

 #ifdef HAVE_ARGP_H
 #include <argp.h>
 #endif
-#include <sys/types.h>
-#include <sys/socket.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <poll.h>

-#ifndef BUF_SIZE
-#define BUF_SIZE 16384
-#endif
-
-#define SAFE_FREE(x) do { if ((x) != NULL) {free(x); x=NULL;} } while(0)
-
-#ifndef __unused__
-# ifdef HAVE_UNUSED_ATTRIBUTE
-#  define __unused__ __attribute__((unused))
-# else /* HAVE_UNUSED_ATTRIBUTE */
-#  define __unused__
-# endif /* HAVE_UNUSED_ATTRIBUTE */
-#endif /* __unused__ */
-
-#ifndef UNUSED_PARAM
-#define UNUSED_PARAM(param) param __unused__
-#endif /* UNUSED_PARAM */
-
 #ifndef KEYS_FOLDER
 #ifdef _WIN32
 #define KEYS_FOLDER
@@ -85,18 +66,11 @@ static struct cleanup_node_struct *cleanup_stack = NULL;

 static void _close_socket(struct event_fd_data_struct event_fd_data);

-static void
-cleanup_push(struct cleanup_node_struct** head_ref,
-             struct event_fd_data_struct *new_data)
-{
+static void cleanup_push(struct cleanup_node_struct** head_ref, struct event_fd_data_struct *new_data) {
    // Allocate memory for node
    struct cleanup_node_struct *new_node = malloc(sizeof *new_node);

-    if (*head_ref != NULL) {
-        new_node->next = *head_ref;
-    } else {
-        new_node->next = NULL;
-    }
+    new_node->next = (*head_ref);

    // Copy new_data
    new_node->data = new_data;
@@ -105,9 +79,7 @@ cleanup_push(struct cleanup_node_struct** head_ref,
    (*head_ref) = new_node;
 }

-static void
-do_cleanup(struct cleanup_node_struct **head_ref)
-{
+static void do_cleanup(struct cleanup_node_struct **head_ref) {
    struct cleanup_node_struct *current = (*head_ref);
    struct cleanup_node_struct *previous = NULL, *gone = NULL;

@@ -146,22 +118,16 @@ do_cleanup(struct cleanup_node_struct **head_ref)
    }
 }

-static int
-auth_password(ssh_session session,
-              const char *user,
-              const char *password,
-              UNUSED_PARAM(void *userdata))
-{
-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== auth_password", "Authenticating user %s pwd %s",
-             user,
-             password);
-    if (strcmp(user, USER) == 0 && strcmp(password, PASSWORD) == 0) {
+static int auth_password(ssh_session session, const char *user,
+            const char *password, void *userdata) {
+    (void)userdata;
+    _ssh_log(SSH_LOG_PROTOCOL, "=== auth_password", "Authenticating user %s pwd %s",user, password);
+    if (strcmp(user,USER) == 0 && strcmp(password, PASSWORD) == 0){
        authenticated = true;
        printf("Authenticated\n");
        return SSH_AUTH_SUCCESS;
    }
-    if (tries >= 3) {
+    if (tries >= 3){
        printf("Too many authentication tries\n");
        ssh_disconnect(session);
        error_set = true;
@@ -171,34 +137,25 @@ auth_password(ssh_session session,
    return SSH_AUTH_DENIED;
 }

-static int
-auth_gssapi_mic(ssh_session session,
-                const char *user,
-                const char *principal,
-                UNUSED_PARAM(void *userdata))
-{
+static int auth_gssapi_mic(ssh_session session, const char *user, const char *principal, void *userdata) {
    ssh_gssapi_creds creds = ssh_gssapi_get_creds(session);
-    printf("Authenticating user %s with gssapi principal %s\n",
-           user, principal);
-    if (creds != NULL) {
+    (void)userdata;
+    printf("Authenticating user %s with gssapi principal %s\n", user, principal);
+    if (creds != NULL)
        printf("Received some gssapi credentials\n");
-    } else {
+    else
        printf("Not received any forwardable creds\n");
-    }
    printf("authenticated\n");
    authenticated = true;
    return SSH_AUTH_SUCCESS;
 }

-static int
-subsystem_request(UNUSED_PARAM(ssh_session session),
-                  UNUSED_PARAM(ssh_channel channel),
-                  const char *subsystem,
-                  UNUSED_PARAM(void *userdata))
-{
-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== subsystem_request", "Channel subsystem reqeuest: %s",
-             subsystem);
+static int subsystem_request(ssh_session session, ssh_channel channel, const char *subsystem, void *userdata) {
+    (void)session;
+    (void)channel;
+    //(void)subsystem;
+    (void)userdata;
+    _ssh_log(SSH_LOG_PROTOCOL, "=== subsystem_request", "Channel subsystem reqeuest: %s", subsystem);
    return 0;
 }

@@ -206,10 +163,9 @@ struct ssh_channel_callbacks_struct channel_cb = {
    .channel_subsystem_request_function = subsystem_request
 };

-static ssh_channel
-new_session_channel(UNUSED_PARAM(ssh_session session),
-                    UNUSED_PARAM(void *userdata))
-{
+static ssh_channel new_session_channel(ssh_session session, void *userdata) {
+    (void)session;
+    (void)userdata;
    _ssh_log(SSH_LOG_PROTOCOL, "=== subsystem_request", "Session channel request");
    /* For TCP forward only there seems to be no need for a session channel */
    /*if(chan != NULL)
@@ -222,25 +178,18 @@ new_session_channel(UNUSED_PARAM(ssh_session session),
    return NULL;
 }

-static void
-stack_socket_close(UNUSED_PARAM(ssh_session session),
-                   struct event_fd_data_struct *event_fd_data)
+static void stack_socket_close(UNUSED_PARAM(ssh_session session),
+                               struct event_fd_data_struct *event_fd_data)
 {
    if (event_fd_data->stacked != 1) {
-        _ssh_log(SSH_LOG_FUNCTIONS, "=== stack_socket_close",
-                 "Closing fd = %d sockets_cnt = %d", *event_fd_data->p_fd,
-                 sockets_cnt);
+        _ssh_log(SSH_LOG_FUNCTIONS, "=== stack_socket_close", "Closing fd = %d sockets_cnt = %d", *event_fd_data->p_fd, sockets_cnt);
        event_fd_data->stacked = 1;
        cleanup_push(&cleanup_stack, event_fd_data);
    }
 }

-static void
-_close_socket(struct event_fd_data_struct event_fd_data)
-{
-    _ssh_log(SSH_LOG_FUNCTIONS, "=== close_socket",
-             "Closing fd = %d sockets_cnt = %d", *event_fd_data.p_fd,
-             sockets_cnt);
+static void _close_socket(struct event_fd_data_struct event_fd_data) {
+    _ssh_log(SSH_LOG_FUNCTIONS, "=== close_socket", "Closing fd = %d sockets_cnt = %d", *event_fd_data.p_fd, sockets_cnt);
    ssh_event_remove_fd(mainloop, *event_fd_data.p_fd);
    sockets_cnt--;
 #ifdef _WIN32
@@ -251,75 +200,51 @@ _close_socket(struct event_fd_data_struct event_fd_data)
    (*event_fd_data.p_fd) = SSH_INVALID_SOCKET;
 }

-static int
-service_request(UNUSED_PARAM(ssh_session session),
-                const char *service,
-                UNUSED_PARAM(void *userdata))
-{
+static int service_request(ssh_session session, const char *service, void *userdata) {
+    (void)session;
+    //(void)service;
+    (void)userdata;
    _ssh_log(SSH_LOG_PROTOCOL, "=== service_request", "Service request: %s", service);
    return 0;
 }

-static void
-global_request(UNUSED_PARAM(ssh_session session),
-               ssh_message message,
-               UNUSED_PARAM(void *userdata))
-{
-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== global_request", "Global request, message type: %d",
-             ssh_message_type(message));
+static void global_request(ssh_session session, ssh_message message, void *userdata) {
+    (void)session;
+    (void)userdata;
+    _ssh_log(SSH_LOG_PROTOCOL, "=== global_request", "Global request, message type: %d", ssh_message_type(message));
 }

-static void
-my_channel_close_function(ssh_session session,
-                          UNUSED_PARAM(ssh_channel channel),
-                          void *userdata)
-{
+static void my_channel_close_function(ssh_session session, ssh_channel channel, void *userdata) {
    struct event_fd_data_struct *event_fd_data = (struct event_fd_data_struct *)userdata;
+    (void)session;

-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== my_channel_close_function",
-             "Channel closed by remote.");
+    _ssh_log(SSH_LOG_PROTOCOL, "=== my_channel_close_function", "Channel %d:%d closed by remote. State=%d", channel->local_channel, channel->remote_channel, channel->state);

    stack_socket_close(session, event_fd_data);
 }

-static void
-my_channel_eof_function(ssh_session session,
-                        UNUSED_PARAM(ssh_channel channel),
-                        void *userdata)
-{
+static void my_channel_eof_function(ssh_session session, ssh_channel channel, void *userdata) {
    struct event_fd_data_struct *event_fd_data = (struct event_fd_data_struct *)userdata;
+    (void)session;

-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== my_channel_eof_function",
-             "Got EOF on channel. Shuting down write on socket (fd = %d).",
-             *event_fd_data->p_fd);
+    _ssh_log(SSH_LOG_PROTOCOL, "=== my_channel_eof_function", "Got EOF on channel %d:%d. Shuting down write on socket (fd = %d).", channel->local_channel, channel->remote_channel, *event_fd_data->p_fd);

    stack_socket_close(session, event_fd_data);
 }

-static void
-my_channel_exit_status_function(UNUSED_PARAM(ssh_session session),
-                                UNUSED_PARAM(ssh_channel channel),
-                                int exit_status,
-                                void *userdata)
-{
+static void my_channel_exit_status_function(ssh_session session, ssh_channel channel, int exit_status, void *userdata) {
    struct event_fd_data_struct *event_fd_data = (struct event_fd_data_struct *)userdata;
+    (void)session;

-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== my_channel_exit_status_function",
-             "Got exit status %d on channel fd = %d.",
-             exit_status, *event_fd_data->p_fd);
+    _ssh_log(SSH_LOG_PROTOCOL, "=== my_channel_exit_status_function", "Got exit status %d on channel %d:%d fd = %d.", exit_status, channel->local_channel, channel->remote_channel, *event_fd_data->p_fd);
 }

-static int
-my_channel_data_function(ssh_session session,
-                         UNUSED_PARAM(ssh_channel channel),
-                         void *data,
-                         uint32_t len,
-                         UNUSED_PARAM(int is_stderr),
-                         void *userdata)
+static int my_channel_data_function(ssh_session session,
+                                    ssh_channel channel,
+                                    void *data,
+                                    uint32_t len,
+                                    UNUSED_PARAM(int is_stderr),
+                                    void *userdata)
 {
    int i = 0;
    struct event_fd_data_struct *event_fd_data = (struct event_fd_data_struct *)userdata;
@@ -328,18 +253,12 @@ my_channel_data_function(ssh_session session,
        fprintf(stderr, "Why we're here? Stacked = %d\n", event_fd_data->stacked);
    }

-    _ssh_log(SSH_LOG_PROTOCOL,
-             "=== my_channel_data_function",
-             "%d bytes waiting on channel for reading. Fd = %d",
-             len,
-             *event_fd_data->p_fd);
+    _ssh_log(SSH_LOG_PROTOCOL, "=== my_channel_data_function", "%d bytes waiting on channel %d:%d for reading. Fd = %d",len, channel->local_channel, channel->remote_channel, *event_fd_data->p_fd);
    if (len > 0) {
        i = send(*event_fd_data->p_fd, data, len, 0);
    }
    if (i < 0) {
-        _ssh_log(SSH_LOG_WARNING, "=== my_channel_data_function",
-                 "Writing to tcp socket %d: %s", *event_fd_data->p_fd,
-                 strerror(errno));
+        _ssh_log(SSH_LOG_WARNING, "=== my_channel_data_function", "Writing to tcp socket %d: %s", *event_fd_data->p_fd, strerror(errno));
        stack_socket_close(session, event_fd_data);
    }
    else {
@@ -348,16 +267,15 @@ my_channel_data_function(ssh_session session,
    return i;
 }

-static int
-my_fd_data_function(UNUSED_PARAM(socket_t fd),
-                    int revents,
-                    void *userdata)
+static int my_fd_data_function(UNUSED_PARAM(socket_t fd),
+                               int revents,
+                               void *userdata)
 {
    struct event_fd_data_struct *event_fd_data = (struct event_fd_data_struct *)userdata;
    ssh_channel channel = event_fd_data->channel;
    ssh_session session;
    int len, i, wr;
-    char buf[BUF_SIZE];
+    char buf[16384];
    int blocking;

    if (channel == NULL) {
@@ -395,10 +313,8 @@ my_fd_data_function(UNUSED_PARAM(socket_t fd),
    blocking = ssh_is_blocking(session);
    ssh_set_blocking(session, 0);

-    _ssh_log(SSH_LOG_FUNCTIONS,
-             "=== my_fd_data_function",
-             "Trying to read from tcp socket fd = %d",
-             *event_fd_data->p_fd);
+    _ssh_log(SSH_LOG_FUNCTIONS, "=== my_fd_data_function", "Trying to read from tcp socket fd = %d... (Channel %d:%d state=%d)",
+                        *event_fd_data->p_fd, channel->local_channel, channel->remote_channel, channel->state);
 #ifdef _WIN32
    struct sockaddr from;
    int fromlen = sizeof(from);
@@ -422,7 +338,7 @@ my_fd_data_function(UNUSED_PARAM(socket_t fd),
                    break;
                }
                wr += i;
-                _ssh_log(SSH_LOG_FUNCTIONS, "=== my_fd_data_function", "ssh_channel_write (%d from %d)", wr, len);
+                _ssh_log(SSH_LOG_FUNCTIONS, "=== my_fd_data_function", "channel_write (%d from %d)", wr, len);
            } while (i > 0 && wr < len);
        }
        else {
@@ -444,9 +360,7 @@ my_fd_data_function(UNUSED_PARAM(socket_t fd),
    return len;
 }

-static int
-open_tcp_socket(ssh_message msg)
-{
+static int open_tcp_socket(ssh_message msg) {
    struct sockaddr_in sin;
    int forwardsock = -1;
    struct hostent *host;
@@ -487,20 +401,17 @@ open_tcp_socket(ssh_message msg)
    return forwardsock;
 }

-static int
-message_callback(UNUSED_PARAM(ssh_session session),
-                 ssh_message message,
-                 UNUSED_PARAM(void *userdata))
-{
+static int message_callback(ssh_session session, ssh_message message, void *userdata) {
    ssh_channel channel;
    int socket_fd, *pFd;
    struct ssh_channel_callbacks_struct *cb_chan;
    struct event_fd_data_struct *event_fd_data;
+    (void)session;
+    (void)message;
+    (void)userdata;

-    _ssh_log(SSH_LOG_PACKET, "=== message_callback", "Message type: %d",
-             ssh_message_type(message));
-    _ssh_log(SSH_LOG_PACKET, "=== message_callback", "Message Subtype: %d",
-             ssh_message_subtype(message));
+    _ssh_log(SSH_LOG_PACKET, "=== message_callback", "Message type: %d", ssh_message_type(message));
+    _ssh_log(SSH_LOG_PACKET, "=== message_callback", "Message Subtype: %d", ssh_message_subtype(message));
    if (ssh_message_type(message) == SSH_REQUEST_CHANNEL_OPEN) {
        _ssh_log(SSH_LOG_PROTOCOL, "=== message_callback", "channel_request_open");

@@ -522,13 +433,6 @@ message_callback(UNUSED_PARAM(ssh_session session),
                pFd = malloc(sizeof *pFd);
                cb_chan = malloc(sizeof *cb_chan);
                event_fd_data = malloc(sizeof *event_fd_data);
-                if (pFd == NULL || cb_chan == NULL || event_fd_data == NULL) {
-                    SAFE_FREE(pFd);
-                    SAFE_FREE(cb_chan);
-                    SAFE_FREE(event_fd_data);
-                    close(socket_fd);
-                    return 1;
-                }

                (*pFd) = socket_fd;
                event_fd_data->channel = channel;
@@ -611,9 +515,7 @@ static struct argp_option options[] = {
 };

 /* Parse a single option. */
-static error_t
-parse_opt (int key, char *arg, struct argp_state *state)
-{
+static error_t parse_opt (int key, char *arg, struct argp_state *state) {
    /* Get the input argument from argp_parse, which we
     * know is a pointer to our arguments structure.
     */
@@ -659,9 +561,7 @@ parse_opt (int key, char *arg, struct argp_state *state)
 static struct argp argp = {options, parse_opt, args_doc, doc, NULL, NULL, NULL};
 #endif /* HAVE_ARGP_H */

-int
-main(int argc, char **argv)
-{
+int main(int argc, char **argv){
    ssh_session session;
    ssh_bind sshbind;
    struct ssh_server_callbacks_struct cb = {
--- a/examples/sshnetcat.c
+++ b/examples/sshnetcat.c
@@ -34,11 +34,6 @@ clients must be made or how a client should react.
 #include <fcntl.h>

 #include "examples_common.h"
-
-#ifndef BUF_SIZE
-#define BUF_SIZE 4096
-#endif
-
 char *host;
 const char *desthost="localhost";
 const char *port="22";
@@ -82,7 +77,7 @@ static int opts(int argc, char **argv){
 static void select_loop(ssh_session session,ssh_channel channel){
 	fd_set fds;
 	struct timeval timeout;
-	char buffer[BUF_SIZE];
+	char buffer[4096];
 	/* channels will be set to the channels to poll.
 	 * outchannels will contain the result of the poll
 	 */
--- a/include/libssh/CMakeLists.txt
+++ b/include/libssh/CMakeLists.txt
@@ -31,9 +31,3 @@ install(
    headers
 )

-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libssh_version.h.cmake
-               ${libssh_BINARY_DIR}/include/libssh/libssh_version.h
-               @ONLY)
-install(FILES ${libssh_BINARY_DIR}/include/libssh/libssh_version.h
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${APPLICATION_NAME}
-        COMPONENT headers)
--- a/include/libssh/agent.h
+++ b/include/libssh/agent.h
@@ -77,6 +77,7 @@ struct ssh_agent_struct {
  ssh_channel channel;
 };

+#ifndef _WIN32
 /* agent.c */
 /**
 * @brief Create a new ssh agent structure.
@@ -103,7 +104,7 @@ void ssh_agent_free(struct ssh_agent_struct *agent);
 */
 int ssh_agent_is_running(struct ssh_session_struct *session);

-uint32_t ssh_agent_get_ident_count(struct ssh_session_struct *session);
+int ssh_agent_get_ident_count(struct ssh_session_struct *session);

 ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
                                 char **comment);
@@ -114,5 +115,6 @@ ssh_key ssh_agent_get_first_ident(struct ssh_session_struct *session,
 ssh_string ssh_agent_sign_data(ssh_session session,
                               const ssh_key pubkey,
                               struct ssh_buffer_struct *data);
+#endif

 #endif /* __AGENT_H */
--- a/include/libssh/bind.h
+++ b/include/libssh/bind.h
@@ -22,7 +22,6 @@
 #define BIND_H_

 #include "libssh/priv.h"
-#include "libssh/kex.h"
 #include "libssh/session.h"

 struct ssh_bind_struct {
@@ -32,7 +31,7 @@ struct ssh_bind_struct {

  struct ssh_poll_handle_struct *poll;
  /* options */
-  char *wanted_methods[SSH_KEX_METHODS];
+  char *wanted_methods[10];
  char *banner;
  char *ecdsakey;
  char *dsakey;
@@ -50,8 +49,6 @@ struct ssh_bind_struct {
  bool config_processed;
  char *config_dir;
  char *pubkey_accepted_key_types;
-  char* moduli_file;
-  int rsa_min_size;
 };

 struct ssh_poll_handle_struct *ssh_bind_get_poll(struct ssh_bind_struct
--- a/include/libssh/bind_config.h
+++ b/include/libssh/bind_config.h
@@ -61,14 +61,4 @@ enum ssh_bind_config_opcode_e {
 */
 int ssh_bind_config_parse_file(ssh_bind sshbind, const char *filename);

-/* @brief Parse configuration string and set the options to the given bind session
- *
- * @params[in] bind      The ssh bind session
- * @params[in] input     Null terminated string containing the configuration
- *
- * @returns    SSH_OK on successful parsing the configuration string,
- *             SSH_ERROR on error
- */
-int ssh_bind_config_parse_string(ssh_bind bind, const char *input);
-
 #endif /* BIND_CONFIG_H_ */
--- a/include/libssh/buffer.h
+++ b/include/libssh/buffer.h
@@ -63,9 +63,9 @@ int ssh_buffer_prepend_data(ssh_buffer buffer, const void *data, uint32_t len);
 int ssh_buffer_add_buffer(ssh_buffer buffer, ssh_buffer source);

 /* buffer_read_*() returns the number of bytes read, except for ssh strings */
-uint32_t ssh_buffer_get_u8(ssh_buffer buffer, uint8_t *data);
-uint32_t ssh_buffer_get_u32(ssh_buffer buffer, uint32_t *data);
-uint32_t ssh_buffer_get_u64(ssh_buffer buffer, uint64_t *data);
+int ssh_buffer_get_u8(ssh_buffer buffer, uint8_t *data);
+int ssh_buffer_get_u32(ssh_buffer buffer, uint32_t *data);
+int ssh_buffer_get_u64(ssh_buffer buffer, uint64_t *data);

 /* ssh_buffer_get_ssh_string() is an exception. if the String read is too large or invalid, it will answer NULL. */
 ssh_string ssh_buffer_get_ssh_string(ssh_buffer buffer);
--- a/include/libssh/callbacks.h
+++ b/include/libssh/callbacks.h
@@ -56,7 +56,7 @@ typedef void (*ssh_callback_int) (int code, void *user);
 * @returns number of bytes processed by the callee. The remaining bytes will
 * be sent in the next callback message, when more data is available.
 */
-typedef size_t (*ssh_callback_data) (const void *data, size_t len, void *user);
+typedef int (*ssh_callback_data) (const void *data, size_t len, void *user);

 typedef void (*ssh_callback_int_int) (int code, int errno_code, void *user);

@@ -221,8 +221,8 @@ typedef int (*ssh_auth_gssapi_mic_callback) (ssh_session session, const char *us
 * @param user User that wants to authenticate
 * @param pubkey public key used for authentication
 * @param signature_state SSH_PUBLICKEY_STATE_NONE if the key is not signed (simple public key probe),
- *							SSH_PUBLICKEY_STATE_VALID if the signature is valid. Others values should be
- *							replied with a SSH_AUTH_DENIED.
+ * 							SSH_PUBLICKEY_STATE_VALID if the signature is valid. Others values should be
+ * 							replied with a SSH_AUTH_DENIED.
 * @param userdata Userdata to be passed to the callback function.
 * @returns SSH_AUTH_SUCCESS Authentication is accepted.
 * @returns SSH_AUTH_PARTIAL Partial authentication, more authentication means are needed.
@@ -272,7 +272,7 @@ typedef ssh_string (*ssh_gssapi_select_oid_callback) (ssh_session session, const
 * @param session current session handler
 * @param[in] input_token input token provided by client
 * @param[out] output_token output of the gssapi accept_sec_context method,
- *				NULL after completion.
+ * 				NULL after completion.
 * @returns SSH_OK if the token was generated correctly or accept_sec_context
 * returned GSS_S_COMPLETE
 * @returns SSH_ERROR in case of error
@@ -354,9 +354,6 @@ typedef struct ssh_server_callbacks_struct *ssh_server_callbacks;
 * This functions sets the callback structure to use your own callback
 * functions for user authentication, new channels and requests.
 *
- * Note, that the structure is not copied to the session structure so it needs
- * to be valid for the whole session lifetime.
- *
 * @code
 * struct ssh_server_callbacks_struct cb = {
 *   .userdata = data,
@@ -551,9 +548,6 @@ typedef struct ssh_packet_callbacks_struct *ssh_packet_callbacks;
 * This functions sets the callback structure to use your own callback
 * functions for auth, logging and status.
 *
- * Note, that the callback structure is not copied into the session so it needs
- * to be valid for the whole session lifetime.
- *
 * @code
 * struct ssh_callbacks_struct cb = {
 *   .userdata = data,
@@ -777,7 +771,7 @@ typedef int (*ssh_channel_subsystem_request_callback) (ssh_session session,
 */
 typedef int (*ssh_channel_write_wontblock_callback) (ssh_session session,
                                                     ssh_channel channel,
-                                                     uint32_t bytes,
+                                                     size_t bytes,
                                                     void *userdata);

 struct ssh_channel_callbacks_struct {
@@ -855,11 +849,7 @@ typedef struct ssh_channel_callbacks_struct *ssh_channel_callbacks;
 * @brief Set the channel callback functions.
 *
 * This functions sets the callback structure to use your own callback
- * functions for channel data and exceptions.
- *
- * Note, that the structure is not copied to the channel structure so it needs
- * to be valid as for the whole life of the channel or until it is removed with
- * ssh_remove_channel_callbacks().
+ * functions for channel data and exceptions
 *
 * @code
 * struct ssh_channel_callbacks_struct cb = {
--- a/include/libssh/chacha.h
+++ b/include/libssh/chacha.h
@@ -17,6 +17,7 @@ struct chacha_ctx {
 #define CHACHA_NONCELEN   8
 #define CHACHA_CTRLEN     8
 #define CHACHA_STATELEN   (CHACHA_NONCELEN+CHACHA_CTRLEN)
+#define CHACHA_BLOCKLEN   64

 void chacha_keysetup(struct chacha_ctx *x, const uint8_t *k, uint32_t kbits)
 #ifdef HAVE_GCC_BOUNDED_ATTRIBUTE
--- a/include/libssh/chacha20-poly1305-common.h
+++ b/include/libssh/chacha20-poly1305-common.h
@@ -1,54 +0,0 @@
-/*
- * This file is part of the SSH Library
- *
- * Copyright (c) 2020 Red Hat, Inc.
- *
- * Author: Jakub Jelen <jjelen@redhat.com>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/*
- * chacha20-poly1305.h file
- * This file includes definitions needed for Chacha20-poly1305 AEAD cipher
- * using different crypto backends.
- */
-
-#ifndef CHACHA20_POLY1305_H
-#define CHACHA20_POLY1305_H
-
-#define CHACHA20_BLOCKSIZE 64
-#define CHACHA20_KEYLEN 32
-
-#define POLY1305_TAGLEN 16
-/* size of the keys k1 and k2 as defined in specs */
-#define POLY1305_KEYLEN 32
-
-#ifdef _MSC_VER
-#pragma pack(push, 1)
-#endif
-struct ssh_packet_header {
-    uint32_t length;
-    uint8_t payload[];
-}
-#if defined(__GNUC__)
-__attribute__ ((packed))
-#endif
-#ifdef _MSC_VER
-#pragma pack(pop)
-#endif
-;
-
-#endif /* CHACHA20_POLY1305_H */
--- a/include/libssh/channels.h
+++ b/include/libssh/channels.h
@@ -97,9 +97,8 @@ SSH_PACKET_CALLBACK(channel_rcv_close);
 SSH_PACKET_CALLBACK(channel_rcv_request);
 SSH_PACKET_CALLBACK(channel_rcv_data);

-int channel_default_bufferize(ssh_channel channel,
-                              void *data, uint32_t len,
-                              bool is_stderr);
+int channel_default_bufferize(ssh_channel channel, void *data, int len,
+        int is_stderr);
 int ssh_channel_flush(ssh_channel channel);
 uint32_t ssh_channel_new_id(ssh_session session);
 ssh_channel ssh_channel_from_local(ssh_session session, uint32_t id);
--- a/include/libssh/config.h
+++ b/include/libssh/config.h
@@ -42,6 +42,7 @@ enum ssh_config_opcode_e {
    SOC_MACS,
    SOC_COMPRESSION,
    SOC_TIMEOUT,
+    SOC_PROTOCOL,
    SOC_STRICTHOSTKEYCHECK,
    SOC_KNOWNHOSTS,
    SOC_PROXYCOMMAND,
@@ -59,9 +60,8 @@ enum ssh_config_opcode_e {
    SOC_KBDINTERACTIVEAUTHENTICATION,
    SOC_PASSWORDAUTHENTICATION,
    SOC_PUBKEYAUTHENTICATION,
-    SOC_PUBKEYACCEPTEDKEYTYPES,
+    SOC_PUBKEYACCEPTEDTYPES,
    SOC_REKEYLIMIT,
-    SOC_IDENTITYAGENT,

    SOC_MAX /* Keep this one last in the list */
 };
--- a/include/libssh/crypto.h
+++ b/include/libssh/crypto.h
@@ -80,8 +80,6 @@ enum ssh_key_exchange_e {
  SSH_KEX_DH_GROUP16_SHA512,
  /* diffie-hellman-group18-sha512 */
  SSH_KEX_DH_GROUP18_SHA512,
-  /* diffie-hellman-group14-sha256 */
-  SSH_KEX_DH_GROUP14_SHA256,
 };

 enum ssh_cipher_e {
@@ -107,19 +105,11 @@ struct ssh_crypto_struct {
    bignum shared_secret;
    struct dh_ctx *dh_ctx;
 #ifdef WITH_GEX
-    size_t dh_pmin; size_t dh_pn; size_t dh_pmax; /* preferred group parameters */
+    size_t dh_pmin; int dh_pn; int dh_pmax; /* preferred group parameters */
 #endif /* WITH_GEX */
 #ifdef HAVE_ECDH
 #ifdef HAVE_OPENSSL_ECC
-/* TODO Change to new API when the OpenSSL will support export of uncompressed EC keys
- * https://github.com/openssl/openssl/pull/16624
- * #if OPENSSL_VERSION_NUMBER < 0x30000000L
- */
-#if 1
    EC_KEY *ecdh_privkey;
-#else
-    EVP_PKEY *ecdh_privkey;
-#endif /* OPENSSL_VERSION_NUMBER */
 #elif defined HAVE_GCRYPT_ECC
    gcry_sexp_t ecdh_privkey;
 #elif defined HAVE_LIBMBEDCRYPTO
@@ -134,9 +124,8 @@ struct ssh_crypto_struct {
    ssh_curve25519_pubkey curve25519_server_pubkey;
 #endif
    ssh_string dh_server_signature; /* information used by dh_handshake. */
-    size_t session_id_len;
+    size_t digest_len; /* len of the two fields below */
    unsigned char *session_id;
-    size_t digest_len; /* len of the secret hash */
    unsigned char *secret_hash; /* Secret hash is same as session id until re-kex */
    unsigned char *encryptIV;
    unsigned char *decryptIV;
@@ -219,12 +208,7 @@ struct ssh_cipher_struct {
 const struct ssh_cipher_struct *ssh_get_chacha20poly1305_cipher(void);
 int sshkdf_derive_key(struct ssh_crypto_struct *crypto,
                      unsigned char *key, size_t key_len,
-                      uint8_t key_type, unsigned char *output,
+                      int key_type, unsigned char *output,
                      size_t requested_len);

-int secure_memcmp(const void *s1, const void *s2, size_t n);
-#ifdef HAVE_LIBCRYPTO
-ENGINE *pki_get_engine(void);
-#endif /* HAVE_LIBCRYPTO */
-
 #endif /* _CRYPTO_H_ */
--- a/include/libssh/dh.h
+++ b/include/libssh/dh.h
@@ -34,24 +34,14 @@ struct dh_ctx;
 int ssh_dh_init_common(struct ssh_crypto_struct *crypto);
 void ssh_dh_cleanup(struct ssh_crypto_struct *crypto);

-#if !defined(HAVE_LIBCRYPTO) || OPENSSL_VERSION_NUMBER < 0x30000000L
 int ssh_dh_get_parameters(struct dh_ctx *ctx,
                          const_bignum *modulus, const_bignum *generator);
-#else
-int ssh_dh_get_parameters(struct dh_ctx *ctx,
-                          bignum *modulus, bignum *generator);
-#endif /* OPENSSL_VERSION_NUMBER */
 int ssh_dh_set_parameters(struct dh_ctx *ctx,
                          const bignum modulus, const bignum generator);

 int ssh_dh_keypair_gen_keys(struct dh_ctx *ctx, int peer);
-#if !defined(HAVE_LIBCRYPTO) || OPENSSL_VERSION_NUMBER < 0x30000000L
 int ssh_dh_keypair_get_keys(struct dh_ctx *ctx, int peer,
                            const_bignum *priv, const_bignum *pub);
-#else
-int ssh_dh_keypair_get_keys(struct dh_ctx *ctx, int peer,
-                            bignum *priv, bignum *pub);
-#endif /* OPENSSL_VERSION_NUMBER */
 int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
                            const bignum priv, const bignum pub);

--- a/include/libssh/fe25519.h
+++ b/include/libssh/fe25519.h
@@ -39,7 +39,7 @@ void fe25519_unpack(fe25519 *r, const unsigned char x[32]);

 void fe25519_pack(unsigned char r[32], const fe25519 *x);

-uint32_t fe25519_iszero(const fe25519 *x);
+int fe25519_iszero(const fe25519 *x);

 int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y);

--- a/include/libssh/keys.h
+++ b/include/libssh/keys.h
@@ -28,17 +28,13 @@
 struct ssh_public_key_struct {
    int type;
    const char *type_c; /* Don't free it ! it is static */
-#if defined(HAVE_LIBGCRYPT)
+#ifdef HAVE_LIBGCRYPT
    gcry_sexp_t dsa_pub;
    gcry_sexp_t rsa_pub;
-#elif defined(HAVE_LIBCRYPTO)
-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+#elif HAVE_LIBCRYPTO
    DSA *dsa_pub;
    RSA *rsa_pub;
-#else /* OPENSSL_VERSION_NUMBER */
-    EVP_PKEY *key_pub;
-#endif
-#elif defined(HAVE_LIBMBEDCRYPTO)
+#elif HAVE_LIBMBEDCRYPTO
    mbedtls_pk_context *rsa_pub;
    void *dsa_pub;
 #endif
@@ -46,17 +42,13 @@ struct ssh_public_key_struct {

 struct ssh_private_key_struct {
    int type;
-#if defined(HAVE_LIBGCRYPT)
+#ifdef HAVE_LIBGCRYPT
    gcry_sexp_t dsa_priv;
    gcry_sexp_t rsa_priv;
-#elif defined(HAVE_LIBCRYPTO)
-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+#elif defined HAVE_LIBCRYPTO
    DSA *dsa_priv;
    RSA *rsa_priv;
-#else
-    EVP_PKEY *key_priv;
-#endif /* OPENSSL_VERSION_NUMBER */
-#elif defined(HAVE_LIBMBEDCRYPTO)
+#elif HAVE_LIBMBEDCRYPTO
    mbedtls_pk_context *rsa_priv;
    void *dsa_priv;
 #endif
--- a/include/libssh/legacy.h
+++ b/include/libssh/legacy.h
@@ -88,19 +88,19 @@ SSH_DEPRECATED LIBSSH_API int channel_select(ssh_channel *readchans, ssh_channel
 SSH_DEPRECATED LIBSSH_API void channel_set_blocking(ssh_channel channel, int blocking);
 SSH_DEPRECATED LIBSSH_API int channel_write(ssh_channel channel, const void *data, uint32_t len);

-SSH_DEPRECATED LIBSSH_API void privatekey_free(ssh_private_key prv);
-SSH_DEPRECATED LIBSSH_API ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
+LIBSSH_API void privatekey_free(ssh_private_key prv);
+LIBSSH_API ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
    int type, const char *passphrase);
-SSH_DEPRECATED LIBSSH_API void publickey_free(ssh_public_key key);
-SSH_DEPRECATED LIBSSH_API int ssh_publickey_to_file(ssh_session session, const char *file,
+LIBSSH_API void publickey_free(ssh_public_key key);
+LIBSSH_API int ssh_publickey_to_file(ssh_session session, const char *file,
    ssh_string pubkey, int type);
-SSH_DEPRECATED LIBSSH_API ssh_string publickey_from_file(ssh_session session, const char *filename,
+LIBSSH_API ssh_string publickey_from_file(ssh_session session, const char *filename,
    int *type);
-SSH_DEPRECATED LIBSSH_API ssh_public_key publickey_from_privatekey(ssh_private_key prv);
-SSH_DEPRECATED LIBSSH_API ssh_string publickey_to_string(ssh_public_key key);
-SSH_DEPRECATED LIBSSH_API int ssh_try_publickey_from_file(ssh_session session, const char *keyfile,
+LIBSSH_API ssh_public_key publickey_from_privatekey(ssh_private_key prv);
+LIBSSH_API ssh_string publickey_to_string(ssh_public_key key);
+LIBSSH_API int ssh_try_publickey_from_file(ssh_session session, const char *keyfile,
    ssh_string *publickey, int *type);
-SSH_DEPRECATED LIBSSH_API enum ssh_keytypes_e ssh_privatekey_type(ssh_private_key privatekey);
+LIBSSH_API enum ssh_keytypes_e ssh_privatekey_type(ssh_private_key privatekey);

 LIBSSH_API ssh_string ssh_get_pubkey(ssh_session session);

--- a/include/libssh/libcrypto.h
+++ b/include/libssh/libcrypto.h
@@ -38,7 +38,7 @@ typedef EVP_MD_CTX* SHA256CTX;
 typedef EVP_MD_CTX* SHA384CTX;
 typedef EVP_MD_CTX* SHA512CTX;
 typedef EVP_MD_CTX* MD5CTX;
-typedef EVP_MD_CTX* HMACCTX;
+typedef HMAC_CTX* HMACCTX;
 #ifdef HAVE_ECC
 typedef EVP_MD_CTX *EVPCTX;
 #else
@@ -60,6 +60,10 @@ typedef void *EVPCTX;

 #include <openssl/bn.h>
 #include <openssl/opensslv.h>
+#define OPENSSL_0_9_7b 0x0090702fL
+#if (OPENSSL_VERSION_NUMBER <= OPENSSL_0_9_7b)
+#define BROKEN_AES_CTR
+#endif
 typedef BIGNUM*  bignum;
 typedef const BIGNUM* const_bignum;
 typedef BN_CTX* bignum_CTX;
@@ -92,9 +96,9 @@ typedef BN_CTX* bignum_CTX;
 #define bignum_add(dest, a, b) BN_add(dest, a, b)
 #define bignum_sub(dest, a, b) BN_sub(dest, a, b)
 #define bignum_mod(dest, a, b, ctx) BN_mod(dest, a, b, ctx)
-#define bignum_num_bytes(num) (size_t)BN_num_bytes(num)
-#define bignum_num_bits(num) (size_t)BN_num_bits(num)
-#define bignum_is_bit_set(num,bit) BN_is_bit_set(num, (int)bit)
+#define bignum_num_bytes(num) BN_num_bytes(num)
+#define bignum_num_bits(num) BN_num_bits(num)
+#define bignum_is_bit_set(num,bit) BN_is_bit_set(num,bit)
 #define bignum_bn2bin(num,len, ptr) BN_bn2bin(num, ptr)
 #define bignum_cmp(num1,num2) BN_cmp(num1,num2)
 #define bignum_rshift1(dest, src) BN_rshift1(dest, src)
@@ -110,8 +114,6 @@ typedef BN_CTX* bignum_CTX;
 /* Returns true if the OpenSSL is operating in FIPS mode */
 #ifdef HAVE_OPENSSL_FIPS_MODE
 #define ssh_fips_mode() (FIPS_mode() != 0)
-#elif OPENSSL_VERSION_NUMBER >= 0x30000000L
-#define ssh_fips_mode() EVP_default_properties_is_fips_enabled(NULL)
 #else
 #define ssh_fips_mode() false
 #endif
--- a/include/libssh/libssh.h
+++ b/include/libssh/libssh.h
@@ -1,7 +1,7 @@
 /*
 * This file is part of the SSH Library
 *
- * Copyright (c) 2003-2022 by Aris Adamantiadis and the libssh team
+ * Copyright (c) 2003-2009 by Aris Adamantiadis
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -21,8 +21,6 @@
 #ifndef _LIBSSH_H
 #define _LIBSSH_H

-#include <libssh/libssh_version.h>
-
 #if defined _WIN32 || defined __CYGWIN__
  #ifdef LIBSSH_STATIC
    #define LIBSSH_API
@@ -49,8 +47,6 @@
  #endif
 #endif

-#include <stdarg.h>
-
 #ifdef _MSC_VER
  /* Visual Studio hasn't inttypes.h so it doesn't know uint32_t */
  typedef int int32_t;
@@ -75,6 +71,23 @@
 #define SSH_STRINGIFY(s) SSH_TOSTRING(s)
 #define SSH_TOSTRING(s) #s

+/* libssh version macros */
+#define SSH_VERSION_INT(a, b, c) ((a) << 16 | (b) << 8 | (c))
+#define SSH_VERSION_DOT(a, b, c) a ##.## b ##.## c
+#define SSH_VERSION(a, b, c) SSH_VERSION_DOT(a, b, c)
+
+/* libssh version */
+#define LIBSSH_VERSION_MAJOR  0
+#define LIBSSH_VERSION_MINOR  9
+#define LIBSSH_VERSION_MICRO  1
+
+#define LIBSSH_VERSION_INT SSH_VERSION_INT(LIBSSH_VERSION_MAJOR, \
+                                           LIBSSH_VERSION_MINOR, \
+                                           LIBSSH_VERSION_MICRO)
+#define LIBSSH_VERSION     SSH_VERSION(LIBSSH_VERSION_MAJOR, \
+                                       LIBSSH_VERSION_MINOR, \
+                                       LIBSSH_VERSION_MICRO)
+
 /* GCC have printf type attribute check.  */
 #ifdef __GNUC__
 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
@@ -155,13 +168,13 @@ enum ssh_auth_e {
 };

 /* auth flags */
-#define SSH_AUTH_METHOD_UNKNOWN     0x0000u
-#define SSH_AUTH_METHOD_NONE        0x0001u
-#define SSH_AUTH_METHOD_PASSWORD    0x0002u
-#define SSH_AUTH_METHOD_PUBLICKEY   0x0004u
-#define SSH_AUTH_METHOD_HOSTBASED   0x0008u
-#define SSH_AUTH_METHOD_INTERACTIVE 0x0010u
-#define SSH_AUTH_METHOD_GSSAPI_MIC  0x0020u
+#define SSH_AUTH_METHOD_UNKNOWN 0
+#define SSH_AUTH_METHOD_NONE 0x0001
+#define SSH_AUTH_METHOD_PASSWORD 0x0002
+#define SSH_AUTH_METHOD_PUBLICKEY 0x0004
+#define SSH_AUTH_METHOD_HOSTBASED 0x0008
+#define SSH_AUTH_METHOD_INTERACTIVE 0x0010
+#define SSH_AUTH_METHOD_GSSAPI_MIC 0x0020

 /* messages */
 enum ssh_requests_e {
@@ -291,10 +304,6 @@ enum ssh_keytypes_e{
  SSH_KEYTYPE_ECDSA_P384_CERT01,
  SSH_KEYTYPE_ECDSA_P521_CERT01,
  SSH_KEYTYPE_ED25519_CERT01,
-  SSH_KEYTYPE_SK_ECDSA,
-  SSH_KEYTYPE_SK_ECDSA_CERT01,
-  SSH_KEYTYPE_SK_ED25519,
-  SSH_KEYTYPE_SK_ED25519_CERT01,
 };

 enum ssh_keycmp_e {
@@ -406,8 +415,6 @@ enum ssh_options_e {
  SSH_OPTIONS_PROCESS_CONFIG,
  SSH_OPTIONS_REKEY_DATA,
  SSH_OPTIONS_REKEY_TIME,
-  SSH_OPTIONS_RSA_MIN_SIZE,
-  SSH_OPTIONS_IDENTITY_AGENT,
 };

 enum {
@@ -479,6 +486,8 @@ LIBSSH_API int ssh_channel_request_x11(ssh_channel channel, int single_connectio
    const char *cookie, int screen_number);
 LIBSSH_API int ssh_channel_request_auth_agent(ssh_channel channel);
 LIBSSH_API int ssh_channel_send_eof(ssh_channel channel);
+LIBSSH_API int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
+        timeval * timeout);
 LIBSSH_API void ssh_channel_set_blocking(ssh_channel channel, int blocking);
 LIBSSH_API void ssh_channel_set_counter(ssh_channel channel,
                                        ssh_counter counter);
@@ -509,12 +518,7 @@ LIBSSH_API char *ssh_dirname (const char *path);
 LIBSSH_API int ssh_finalize(void);

 /* REVERSE PORT FORWARDING */
-LIBSSH_API ssh_channel ssh_channel_open_forward_port(ssh_session session,
-                                                   int timeout_ms,
-                                                   int *destination_port,
-                                                   char **originator,
-                                                   int *originator_port);
-SSH_DEPRECATED LIBSSH_API ssh_channel ssh_channel_accept_forward(ssh_session session,
+LIBSSH_API ssh_channel ssh_channel_accept_forward(ssh_session session,
                                                  int timeout_ms,
                                                  int *destination_port);
 LIBSSH_API int ssh_channel_cancel_forward(ssh_session session,
@@ -556,27 +560,7 @@ SSH_DEPRECATED LIBSSH_API int ssh_write_knownhost(ssh_session session);
 SSH_DEPRECATED LIBSSH_API char *ssh_dump_knownhost(ssh_session session);
 SSH_DEPRECATED LIBSSH_API int ssh_is_server_known(ssh_session session);
 SSH_DEPRECATED LIBSSH_API void ssh_print_hexa(const char *descr, const unsigned char *what, size_t len);
-SSH_DEPRECATED LIBSSH_API int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
-        timeval * timeout);

-SSH_DEPRECATED LIBSSH_API int ssh_scp_accept_request(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_close(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_deny_request(ssh_scp scp, const char *reason);
-SSH_DEPRECATED LIBSSH_API void ssh_scp_free(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_init(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_leave_directory(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API ssh_scp ssh_scp_new(ssh_session session, int mode, const char *location);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_pull_request(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_push_file(ssh_scp scp, const char *filename, size_t size, int perms);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_push_file64(ssh_scp scp, const char *filename, uint64_t size, int perms);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_read(ssh_scp scp, void *buffer, size_t size);
-SSH_DEPRECATED LIBSSH_API const char *ssh_scp_request_get_filename(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_request_get_permissions(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API size_t ssh_scp_request_get_size(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API uint64_t ssh_scp_request_get_size64(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API const char *ssh_scp_request_get_warning(ssh_scp scp);
-SSH_DEPRECATED LIBSSH_API int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len);


 LIBSSH_API int ssh_get_random(void *where,int len,int strong);
@@ -614,10 +598,6 @@ LIBSSH_API int ssh_set_log_level(int level);
 LIBSSH_API int ssh_get_log_level(void);
 LIBSSH_API void *ssh_get_log_userdata(void);
 LIBSSH_API int ssh_set_log_userdata(void *data);
-LIBSSH_API void ssh_vlog(int verbosity,
-                         const char *function,
-                         const char *format,
-                         va_list *va) PRINTF_ATTRIBUTE(3, 0);
 LIBSSH_API void _ssh_log(int verbosity,
                         const char *function,
                         const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
@@ -653,13 +633,7 @@ LIBSSH_API ssh_pcap_file ssh_pcap_file_new(void);
 LIBSSH_API int ssh_pcap_file_open(ssh_pcap_file pcap, const char *filename);

 /**
- * @addtogroup libssh_auth
- *
- * @{
- */
-
-/**
- * @brief SSH authentication callback for password and publickey auth.
+ * @brief SSH authentication callback.
 *
 * @param prompt        Prompt to be displayed.
 * @param buf           Buffer to save the password. You should null-terminate it.
@@ -674,8 +648,6 @@ LIBSSH_API int ssh_pcap_file_open(ssh_pcap_file pcap, const char *filename);
 typedef int (*ssh_auth_callback) (const char *prompt, char *buf, size_t len,
    int echo, int verify, void *userdata);

-/** @} */
-
 LIBSSH_API ssh_key ssh_key_new(void);
 #define SSH_KEY_FREE(x) \
    do { if ((x) != NULL) { ssh_key_free(x); x = NULL; } } while(0)
@@ -688,7 +660,6 @@ LIBSSH_API int ssh_key_is_private(const ssh_key k);
 LIBSSH_API int ssh_key_cmp(const ssh_key k1,
                           const ssh_key k2,
                           enum ssh_keycmp_e what);
-LIBSSH_API ssh_key ssh_key_dup(const ssh_key key);

 LIBSSH_API int ssh_pki_generate(enum ssh_keytypes_e type, int parameter,
        ssh_key *pkey);
@@ -744,6 +715,24 @@ LIBSSH_API void ssh_print_hash(enum ssh_publickey_hash_type type, unsigned char
 LIBSSH_API int ssh_send_ignore (ssh_session session, const char *data);
 LIBSSH_API int ssh_send_debug (ssh_session session, const char *message, int always_display);
 LIBSSH_API void ssh_gssapi_set_creds(ssh_session session, const ssh_gssapi_creds creds);
+LIBSSH_API int ssh_scp_accept_request(ssh_scp scp);
+LIBSSH_API int ssh_scp_close(ssh_scp scp);
+LIBSSH_API int ssh_scp_deny_request(ssh_scp scp, const char *reason);
+LIBSSH_API void ssh_scp_free(ssh_scp scp);
+LIBSSH_API int ssh_scp_init(ssh_scp scp);
+LIBSSH_API int ssh_scp_leave_directory(ssh_scp scp);
+LIBSSH_API ssh_scp ssh_scp_new(ssh_session session, int mode, const char *location);
+LIBSSH_API int ssh_scp_pull_request(ssh_scp scp);
+LIBSSH_API int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode);
+LIBSSH_API int ssh_scp_push_file(ssh_scp scp, const char *filename, size_t size, int perms);
+LIBSSH_API int ssh_scp_push_file64(ssh_scp scp, const char *filename, uint64_t size, int perms);
+LIBSSH_API int ssh_scp_read(ssh_scp scp, void *buffer, size_t size);
+LIBSSH_API const char *ssh_scp_request_get_filename(ssh_scp scp);
+LIBSSH_API int ssh_scp_request_get_permissions(ssh_scp scp);
+LIBSSH_API size_t ssh_scp_request_get_size(ssh_scp scp);
+LIBSSH_API uint64_t ssh_scp_request_get_size64(ssh_scp scp);
+LIBSSH_API const char *ssh_scp_request_get_warning(ssh_scp scp);
+LIBSSH_API int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len);
 LIBSSH_API int ssh_select(ssh_channel *channels, ssh_channel *outchannels, socket_t maxfd,
    fd_set *readfds, struct timeval *timeout);
 LIBSSH_API int ssh_service_request(ssh_session session, const char *service);
@@ -771,8 +760,6 @@ LIBSSH_API int ssh_userauth_publickey(ssh_session session,
 LIBSSH_API int ssh_userauth_agent(ssh_session session,
                                  const char *username);
 #endif
-LIBSSH_API int ssh_userauth_publickey_auto_get_current_identity(ssh_session session,
-                                                                char** value);
 LIBSSH_API int ssh_userauth_publickey_auto(ssh_session session,
                                           const char *username,
                                           const char *passphrase);
@@ -841,7 +828,6 @@ LIBSSH_API int ssh_buffer_add_data(ssh_buffer buffer, const void *data, uint32_t
 LIBSSH_API uint32_t ssh_buffer_get_data(ssh_buffer buffer, void *data, uint32_t requestedlen);
 LIBSSH_API void *ssh_buffer_get(ssh_buffer buffer);
 LIBSSH_API uint32_t ssh_buffer_get_len(ssh_buffer buffer);
-LIBSSH_API int ssh_session_set_disconnect_message(ssh_session session, const char *message);

 #ifndef LIBSSH_LEGACY_0_4
 #include "libssh/legacy.h"
--- a/include/libssh/libssh_version.h.cmake
+++ b/include/libssh/libssh_version.h.cmake
@@ -1,41 +0,0 @@
-/*
- * This file is part of the SSH Library
- *
- * Copyright (c) 2020 by Heiko Thiery
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef _LIBSSH_VERSION_H
-#define _LIBSSH_VERSION_H
-
-/* libssh version macros */
-#define SSH_VERSION_INT(a, b, c) ((a) << 16 | (b) << 8 | (c))
-#define SSH_VERSION_DOT(a, b, c) a ##.## b ##.## c
-#define SSH_VERSION(a, b, c) SSH_VERSION_DOT(a, b, c)
-
-/* libssh version */
-#define LIBSSH_VERSION_MAJOR  @libssh_VERSION_MAJOR@
-#define LIBSSH_VERSION_MINOR  @libssh_VERSION_MINOR@
-#define LIBSSH_VERSION_MICRO  @libssh_VERSION_PATCH@
-
-#define LIBSSH_VERSION_INT SSH_VERSION_INT(LIBSSH_VERSION_MAJOR, \
-                                           LIBSSH_VERSION_MINOR, \
-                                           LIBSSH_VERSION_MICRO)
-#define LIBSSH_VERSION     SSH_VERSION(LIBSSH_VERSION_MAJOR, \
-                                       LIBSSH_VERSION_MINOR, \
-                                       LIBSSH_VERSION_MICRO)
-
-#endif /* _LIBSSH_VERSION_H */
--- a/include/libssh/libsshpp.hpp
+++ b/include/libssh/libsshpp.hpp
@@ -369,11 +369,13 @@ public:
    return state;
  }
  void log(int priority, const char *format, ...){
+    char buffer[1024];
    va_list va;

    va_start(va, format);
-    ssh_vlog(priority, "libsshpp", format, &va);
+    vsnprintf(buffer, sizeof(buffer), format, va);
    va_end(va);
+    _ssh_log(priority, "libsshpp", "%s", buffer);
  }

  /** @brief copies options from a session to another
@@ -523,7 +525,7 @@ public:
    return ssh_channel_is_open(channel) != 0;
  }
  int openForward(const char *remotehost, int remoteport,
-      const char *sourcehost, int localport=0){
+      const char *sourcehost=NULL, int localport=0){
    int err=ssh_channel_open_forward(channel,remotehost,remoteport,
        sourcehost, localport);
    ssh_throw(err);
@@ -630,8 +632,8 @@ public:
   * @param is_stderr write should be done on the stderr channel (server only)
   * @returns number of bytes written
   * @throws SshException in case of error
-   * @see ssh_channel_write
-   * @see ssh_channel_write_stderr
+   * @see channel_write
+   * @see channel_write_stderr
   */
  int write(const void *data, size_t len, bool is_stderr=false){
    int ret;
@@ -669,7 +671,7 @@ private:

 inline Channel *Session::acceptForward(int timeout_ms){
    ssh_channel forward =
-        ssh_channel_open_forward_port(c_session, timeout_ms, NULL, NULL, NULL);
+        ssh_channel_accept_forward(c_session, timeout_ms, NULL);
    ssh_throw_null(c_session,forward);
    Channel *newchan = new Channel(*this,forward);
    return newchan;
--- a/include/libssh/messages.h
+++ b/include/libssh/messages.h
@@ -28,8 +28,7 @@ struct ssh_auth_request {
    int method;
    char *password;
    struct ssh_key_struct *pubkey;
-    char *sigtype;
-    enum ssh_publickey_state_e signature_state;
+    char signature_state;
    char kbdint_response;
 };

--- a/include/libssh/misc.h
+++ b/include/libssh/misc.h
@@ -51,12 +51,6 @@ struct ssh_timestamp {
  long useconds;
 };

-enum ssh_quote_state_e {
-    NO_QUOTE,
-    SINGLE_QUOTE,
-    DOUBLE_QUOTE
-};
-
 struct ssh_list *ssh_list_new(void);
 void ssh_list_free(struct ssh_list *list);
 struct ssh_iterator *ssh_list_get_iterator(const struct ssh_list *list);
@@ -81,7 +75,7 @@ const void *_ssh_list_pop_head(struct ssh_list *list);
 #define ssh_list_pop_head(type, ssh_list)\
  ((type)_ssh_list_pop_head(ssh_list))

-int ssh_make_milliseconds(unsigned long sec, unsigned long usec);
+int ssh_make_milliseconds(long sec, long usec);
 void ssh_timestamp_init(struct ssh_timestamp *ts);
 int ssh_timeout_elapsed(struct ssh_timestamp *ts, int timeout);
 int ssh_timeout_update(struct ssh_timestamp *ts, int timeout);
@@ -94,9 +88,4 @@ void ssh_log_hexdump(const char *descr, const unsigned char *what, size_t len);

 int ssh_mkdirs(const char *pathname, mode_t mode);

-int ssh_quote_file_name(const char *file_name, char *buf, size_t buf_len);
-int ssh_newline_vis(const char *string, char *buf, size_t buf_len);
-int ssh_tmpname(char *template);
-
-char *ssh_strreplace(const char *src, const char *pattern, const char *repl);
 #endif /* MISC_H_ */
--- a/include/libssh/options.h
+++ b/include/libssh/options.h
@@ -22,7 +22,6 @@
 #define _OPTIONS_H

 int ssh_config_parse_file(ssh_session session, const char *filename);
-int ssh_config_parse_string(ssh_session session, const char *input);
 int ssh_options_set_algo(ssh_session session,
                         enum ssh_kex_types_e algo,
                         const char *list);
--- a/include/libssh/packet.h
+++ b/include/libssh/packet.h
@@ -67,7 +67,7 @@ int ssh_packet_send_unimplemented(ssh_session session, uint32_t seqnum);
 int ssh_packet_parse_type(ssh_session session);
 //int packet_flush(ssh_session session, int enforce_blocking);

-size_t ssh_packet_socket_callback(const void *data, size_t len, void *user);
+int ssh_packet_socket_callback(const void *data, size_t len, void *user);
 void ssh_packet_register_socket_callback(ssh_session session, struct ssh_socket_struct *s);
 void ssh_packet_set_callbacks(ssh_session session, ssh_packet_callbacks callbacks);
 void ssh_packet_remove_callbacks(ssh_session session, ssh_packet_callbacks callbacks);
@@ -80,7 +80,7 @@ int ssh_packet_decrypt(ssh_session session, uint8_t *destination, uint8_t *sourc
        size_t start, size_t encrypted_size);
 unsigned char *ssh_packet_encrypt(ssh_session session,
                                  void *packet,
-                                  size_t len);
+                                  unsigned int len);
 int ssh_packet_hmac_verify(ssh_session session, const void *data, size_t len,
                           unsigned char *mac, enum ssh_hmac_e type);
 int ssh_packet_set_newkeys(ssh_session session,
--- a/include/libssh/pki.h
+++ b/include/libssh/pki.h
@@ -21,7 +21,6 @@
 #ifndef PKI_H_
 #define PKI_H_

-#include <stdint.h>
 #include "libssh/priv.h"
 #ifdef HAVE_OPENSSL_EC_H
 #include <openssl/ec.h>
@@ -29,11 +28,9 @@
 #ifdef HAVE_OPENSSL_ECDSA_H
 #include <openssl/ecdsa.h>
 #endif
-#ifdef HAVE_LIBCRYPTO
-#include <openssl/evp.h>
-#endif
+
 #include "libssh/crypto.h"
-#if defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_ED25519)
+#ifdef HAVE_OPENSSL_ED25519
 /* If using OpenSSL implementation, define the signature lenght which would be
 * defined in libssh/ed25519.h otherwise */
 #define ED25519_SIG_LEN 64
@@ -49,7 +46,6 @@
 #define SSH_KEY_FLAG_EMPTY   0x0
 #define SSH_KEY_FLAG_PUBLIC  0x0001
 #define SSH_KEY_FLAG_PRIVATE 0x0002
-#define SSH_KEY_FLAG_PKCS11_URI 0x0004

 struct ssh_key_struct {
    enum ssh_keytypes_e type;
@@ -65,31 +61,21 @@ struct ssh_key_struct {
    mbedtls_ecdsa_context *ecdsa;
    void *dsa;
 #elif defined(HAVE_LIBCRYPTO)
-#if OPENSSL_VERSION_NUMBER < 0x30000000L
    DSA *dsa;
    RSA *rsa;
-#endif /* OPENSSL_VERSION_NUMBER */
-/* TODO Change to new API when the OpenSSL will support export of uncompressed EC keys
- * https://github.com/openssl/openssl/pull/16624
- * Move into the #if above
- */
 # if defined(HAVE_OPENSSL_ECC)
    EC_KEY *ecdsa;
 # else
    void *ecdsa;
 # endif /* HAVE_OPENSSL_EC_H */
-    /* This holds either ENGINE key for PKCS#11 support or just key in
-     * high-level format required by OpenSSL 3.0 */
-    EVP_PKEY *key;
 #endif /* HAVE_LIBGCRYPT */
-#if defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_ED25519)
+#ifdef HAVE_OPENSSL_ED25519
    uint8_t *ed25519_pubkey;
    uint8_t *ed25519_privkey;
 #else
    ed25519_pubkey *ed25519_pubkey;
    ed25519_privkey *ed25519_privkey;
 #endif
-    ssh_string sk_application;
    void *cert;
    enum ssh_keytypes_e cert_type;
 };
@@ -106,19 +92,16 @@ struct ssh_signature_struct {
    ssh_string rsa_sig;
    struct mbedtls_ecdsa_sig ecdsa_sig;
 #endif /* HAVE_LIBGCRYPT */
-#if !defined(HAVE_LIBCRYPTO) || !defined(HAVE_OPENSSL_ED25519)
+#ifndef HAVE_OPENSSL_ED25519
    ed25519_signature *ed25519_sig;
 #endif
    ssh_string raw_sig;
-
-    /* Security Key specific additions */
-    uint8_t sk_flags;
-    uint32_t sk_counter;
 };

 typedef struct ssh_signature_struct *ssh_signature;

 /* SSH Key Functions */
+ssh_key ssh_key_dup(const ssh_key key);
 void ssh_key_clean (ssh_key key);

 const char *
@@ -128,7 +111,6 @@ enum ssh_keytypes_e ssh_key_type_from_signature_name(const char *name);
 enum ssh_keytypes_e ssh_key_type_plain(enum ssh_keytypes_e type);
 enum ssh_digest_e ssh_key_type_to_hash(ssh_session session,
                                       enum ssh_keytypes_e type);
-enum ssh_digest_e ssh_key_hash_from_name(const char *name);

 #define is_ecdsa_key_type(t) \
    ((t) >= SSH_KEYTYPE_ECDSA_P256 && (t) <= SSH_KEYTYPE_ECDSA_P521)
@@ -136,16 +118,12 @@ enum ssh_digest_e ssh_key_hash_from_name(const char *name);
 #define is_cert_type(kt)\
      ((kt) == SSH_KEYTYPE_DSS_CERT01 ||\
       (kt) == SSH_KEYTYPE_RSA_CERT01 ||\
-       (kt) == SSH_KEYTYPE_SK_ECDSA_CERT01 ||\
-       (kt) == SSH_KEYTYPE_SK_ED25519_CERT01 ||\
      ((kt) >= SSH_KEYTYPE_ECDSA_P256_CERT01 &&\
       (kt) <= SSH_KEYTYPE_ED25519_CERT01))

 /* SSH Signature Functions */
 ssh_signature ssh_signature_new(void);
 void ssh_signature_free(ssh_signature sign);
-#define SSH_SIGNATURE_FREE(x) \
-    do { ssh_signature_free(x); x = NULL; } while(0)

 int ssh_pki_export_signature_blob(const ssh_signature sign,
                                  ssh_string *sign_blob);
@@ -175,21 +153,11 @@ ssh_string ssh_pki_do_sign_agent(ssh_session session,
                                 struct ssh_buffer_struct *buf,
                                 const ssh_key pubkey);
 ssh_string ssh_srv_pki_do_sign_sessionid(ssh_session session,
-                                         const ssh_key privkey,
-                                         const enum ssh_digest_e digest);
+                                         const ssh_key privkey);

 /* Temporary functions, to be removed after migration to ssh_key */
 ssh_public_key ssh_pki_convert_key_to_publickey(const ssh_key key);
 ssh_private_key ssh_pki_convert_key_to_privatekey(const ssh_key key);

 int ssh_key_algorithm_allowed(ssh_session session, const char *type);
-bool ssh_key_size_allowed(ssh_session session, ssh_key key);
-
-/* Return the key size in bits */
-int ssh_key_size(ssh_key key);
-
-/* PKCS11 URI function to check if filename is a path or a PKCS11 URI */
-bool ssh_pki_is_uri(const char *filename);
-char *ssh_pki_export_pub_uri_from_priv_uri(const char *priv_uri);
-
 #endif /* PKI_H_ */
--- a/include/libssh/pki_priv.h
+++ b/include/libssh/pki_priv.h
@@ -43,14 +43,6 @@ int bcrypt_pbkdf(const char *pass,
 /* Magic defined in OpenSSH/PROTOCOL.key */
 #define OPENSSH_AUTH_MAGIC      "openssh-key-v1"

-/* Determine type of ssh key. */
-enum ssh_key_e {
-  SSH_KEY_PUBLIC = 0,
-  SSH_KEY_PRIVATE
-};
-
-void pki_key_clean(ssh_key key);
-
 int pki_key_ecdsa_nid_from_name(const char *name);
 const char *pki_key_ecdsa_nid_to_name(int nid);
 const char *ssh_key_signature_to_char(enum ssh_keytypes_e type,
@@ -164,8 +156,4 @@ ssh_key ssh_pki_openssh_privkey_import(const char *text_key,
 ssh_string ssh_pki_openssh_privkey_export(const ssh_key privkey,
        const char *passphrase, ssh_auth_callback auth_fn, void *auth_data);

-/* URI Function */
-int pki_uri_import(const char *uri_name, ssh_key *key, enum ssh_key_e key_type);
-
-bool ssh_key_size_allowed_rsa(int min_size, ssh_key key);
 #endif /* PKI_PRIV_H_ */
--- a/include/libssh/poly1305.h
+++ b/include/libssh/poly1305.h
@@ -5,7 +5,9 @@

 #ifndef POLY1305_H
 #define POLY1305_H
-#include "libssh/chacha20-poly1305-common.h"
+
+#define POLY1305_KEYLEN    32
+#define POLY1305_TAGLEN    16

 void poly1305_auth(uint8_t out[POLY1305_TAGLEN], const uint8_t *m, size_t inlen,
    const uint8_t key[POLY1305_KEYLEN])
--- a/include/libssh/priv.h
+++ b/include/libssh/priv.h
@@ -29,11 +29,9 @@
 #ifndef _LIBSSH_PRIV_H
 #define _LIBSSH_PRIV_H

-#include <limits.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdbool.h>

 #if !defined(HAVE_STRTOULL)
 # if defined(HAVE___STRTOULL)
@@ -67,6 +65,11 @@ char *strndup(const char *s, size_t n);

 #ifdef _WIN32

+/* Imitate define of inttypes.h */
+# ifndef PRIdS
+#  define PRIdS "Id"
+# endif
+
 # ifndef PRIu64
 #  if __WORDSIZE == 64
 #   define PRIu64 "lu"
@@ -152,15 +155,14 @@ char *strndup(const char *s, size_t n);
 # endif /* _MSC_VER */

 struct timeval;
-int ssh_gettimeofday(struct timeval *__p, void *__t);
-
-#define gettimeofday ssh_gettimeofday
+int gettimeofday(struct timeval *__p, void *__t);

 #define _XCLOSESOCKET closesocket

 #else /* _WIN32 */

 #include <unistd.h>
+#define PRIdS "zd"

 #define _XCLOSESOCKET close

@@ -170,15 +172,7 @@ int ssh_gettimeofday(struct timeval *__p, void *__t);
 #include "libssh/callbacks.h"

 /* some constants */
-#ifndef PATH_MAX
-#ifdef MAX_PATH
-#define PATH_MAX MAX_PATH
-#else
-#define PATH_MAX 4096
-#endif
-#endif
-
-#ifndef MAX_PACKET_LEN
+#ifndef MAX_PACKAT_LEN
 #define MAX_PACKET_LEN 262144
 #endif
 #ifndef ERROR_BUFFERLEN
@@ -227,17 +221,7 @@ int ssh_gettimeofday(struct timeval *__p, void *__t);
 struct ssh_common_struct;
 struct ssh_kex_struct;

-enum ssh_digest_e {
-    SSH_DIGEST_AUTO=0,
-    SSH_DIGEST_SHA1=1,
-    SSH_DIGEST_SHA256,
-    SSH_DIGEST_SHA384,
-    SSH_DIGEST_SHA512,
-};
-
-int ssh_get_key_params(ssh_session session,
-                       ssh_key *privkey,
-                       enum ssh_digest_e *digest);
+int ssh_get_key_params(ssh_session session, ssh_key *privkey);

 /* LOGGING */
 void ssh_log_function(int verbosity,
@@ -293,7 +277,7 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,

 /* in base64.c */
 ssh_buffer base64_to_bin(const char *source);
-uint8_t *bin_to_base64(const uint8_t *source, size_t len);
+unsigned char *bin_to_base64(const unsigned char *source, int len);

 /* gzip.c */
 int compress_buffer(ssh_session session,ssh_buffer buf);
@@ -301,7 +285,7 @@ int decompress_buffer(ssh_session session,ssh_buffer buf, size_t maxlen);

 /* match.c */
 int match_pattern_list(const char *string, const char *pattern,
-    size_t len, int dolower);
+    unsigned int len, int dolower);
 int match_hostname(const char *host, const char *pattern, unsigned int len);

 /* connector.c */
@@ -352,7 +336,7 @@ void explicit_bzero(void *s, size_t n);
 #define discard_const_p(type, ptr) ((type *)discard_const(ptr))

 /**
- * Get the argument count of variadic arguments
+ * Get the argument cound of variadic arguments
 */
 /*
 * Since MSVC 2010 there is a bug in passing __VA_ARGS__ to subsequent
@@ -411,27 +395,22 @@ void explicit_bzero(void *s, size_t n);
 # endif /* HAVE_FALLTHROUGH_ATTRIBUTE */
 #endif /* FALL_THROUGH */

-#ifndef __attr_unused__
+#ifndef __unused__
 # ifdef HAVE_UNUSED_ATTRIBUTE
-#  define __attr_unused__ __attribute__((unused))
+#  define __unused__ __attribute__((unused))
 # else /* HAVE_UNUSED_ATTRIBUTE */
-#  define __attr_unused__
+#  define __unused__
 # endif /* HAVE_UNUSED_ATTRIBUTE */
-#endif /* __attr_unused__ */
+#endif /* __unused__ */

 #ifndef UNUSED_PARAM
-#define UNUSED_PARAM(param) param __attr_unused__
+#define UNUSED_PARAM(param) param __unused__
 #endif /* UNUSED_PARAM */

 #ifndef UNUSED_VAR
-#define UNUSED_VAR(var) __attr_unused__ var
+#define UNUSED_VAR(var) __unused__ var
 #endif /* UNUSED_VAR */

 void ssh_agent_state_free(void *data);

-bool is_ssh_initialized(void);
-
-#define SSH_ERRNO_MSG_MAX   1024
-char *ssh_strerror(int err_num, char *buf, size_t buflen);
-
 #endif /* _LIBSSH_PRIV_H */
--- a/include/libssh/server.h
+++ b/include/libssh/server.h
@@ -56,8 +56,6 @@ enum ssh_bind_options_e {
  SSH_BIND_OPTIONS_PUBKEY_ACCEPTED_KEY_TYPES,
  SSH_BIND_OPTIONS_HOSTKEY_ALGORITHMS,
  SSH_BIND_OPTIONS_PROCESS_CONFIG,
-  SSH_BIND_OPTIONS_MODULI,
-  SSH_BIND_OPTIONS_RSA_MIN_SIZE,
 };

 typedef struct ssh_bind_struct* ssh_bind;
@@ -245,18 +243,6 @@ LIBSSH_API void ssh_bind_free(ssh_bind ssh_bind_o);
 */
 LIBSSH_API void ssh_set_auth_methods(ssh_session session, int auth_methods);

-/**
- * @brief Send the server's issue-banner to client.
- *
- *
- * @param[in]  session      The server session.
- *
- * @param[in]  banner       The server's banner.
- *
- * @return                  SSH_OK on success, SSH_ERROR on error.
- */
-LIBSSH_API int ssh_send_issue_banner(ssh_session session, const ssh_string banner);
-
 /**********************************************************
 * SERVER MESSAGING
 **********************************************************/
@@ -296,10 +282,8 @@ LIBSSH_API const char *ssh_message_auth_user(ssh_message msg);
 *
 * @see ssh_message_get()
 * @see ssh_message_type()
- * @warning This function should not be used anymore as there is a
- * callback based server implementation now auth_password_function.
 */
-SSH_DEPRECATED LIBSSH_API const char *ssh_message_auth_password(ssh_message msg);
+LIBSSH_API const char *ssh_message_auth_password(ssh_message msg);

 /**
 * @brief Get the publickey of the authenticated user.
@@ -314,16 +298,11 @@ SSH_DEPRECATED LIBSSH_API const char *ssh_message_auth_password(ssh_message msg)
 * @see ssh_key_cmp()
 * @see ssh_message_get()
 * @see ssh_message_type()
- * @warning This function should not be used anymore as there is a
- * callback based server implementation auth_pubkey_function.
 */
-SSH_DEPRECATED LIBSSH_API ssh_key ssh_message_auth_pubkey(ssh_message msg);
+LIBSSH_API ssh_key ssh_message_auth_pubkey(ssh_message msg);

 LIBSSH_API int ssh_message_auth_kbdint_is_response(ssh_message msg);
-
-/* Replaced by callback based server implementation auth_pubkey_function */
-SSH_DEPRECATED LIBSSH_API enum ssh_publickey_state_e ssh_message_auth_publickey_state(ssh_message msg);
-
+LIBSSH_API enum ssh_publickey_state_e ssh_message_auth_publickey_state(ssh_message msg);
 LIBSSH_API int ssh_message_auth_reply_success(ssh_message msg,int partial);
 LIBSSH_API int ssh_message_auth_reply_pk_ok(ssh_message msg, ssh_string algo, ssh_string pubkey);
 LIBSSH_API int ssh_message_auth_reply_pk_ok_simple(ssh_message msg);
@@ -352,12 +331,11 @@ LIBSSH_API int ssh_message_channel_request_open_destination_port(ssh_message msg

 LIBSSH_API ssh_channel ssh_message_channel_request_channel(ssh_message msg);

-/* Replaced by callback based server implementation function channel_pty_request_function*/
-SSH_DEPRECATED LIBSSH_API const char *ssh_message_channel_request_pty_term(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_pty_width(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_pty_height(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_pty_pxwidth(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_pty_pxheight(ssh_message msg);
+LIBSSH_API const char *ssh_message_channel_request_pty_term(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_pty_width(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_pty_height(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_pty_pxwidth(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_pty_pxheight(ssh_message msg);

 LIBSSH_API const char *ssh_message_channel_request_env_name(ssh_message msg);
 LIBSSH_API const char *ssh_message_channel_request_env_value(ssh_message msg);
@@ -366,18 +344,17 @@ LIBSSH_API const char *ssh_message_channel_request_command(ssh_message msg);

 LIBSSH_API const char *ssh_message_channel_request_subsystem(ssh_message msg);

-/* Replaced by callback based server implementation function channel_open_request_x11_function*/
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_x11_single_connection(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API const char *ssh_message_channel_request_x11_auth_protocol(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API const char *ssh_message_channel_request_x11_auth_cookie(ssh_message msg);
-SSH_DEPRECATED LIBSSH_API int ssh_message_channel_request_x11_screen_number(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_x11_single_connection(ssh_message msg);
+LIBSSH_API const char *ssh_message_channel_request_x11_auth_protocol(ssh_message msg);
+LIBSSH_API const char *ssh_message_channel_request_x11_auth_cookie(ssh_message msg);
+LIBSSH_API int ssh_message_channel_request_x11_screen_number(ssh_message msg);

 LIBSSH_API const char *ssh_message_global_request_address(ssh_message msg);
 LIBSSH_API int ssh_message_global_request_port(ssh_message msg);

 LIBSSH_API int ssh_channel_open_reverse_forward(ssh_channel channel, const char *remotehost,
    int remoteport, const char *sourcehost, int localport);
-LIBSSH_API int ssh_channel_open_x11(ssh_channel channel,
+LIBSSH_API int ssh_channel_open_x11(ssh_channel channel, 
                                        const char *orig_addr, int orig_port);

 LIBSSH_API int ssh_channel_request_send_exit_status(ssh_channel channel,
--- a/include/libssh/session.h
+++ b/include/libssh/session.h
@@ -23,7 +23,6 @@
 #include <stdbool.h>

 #include "libssh/priv.h"
-#include "libssh/callbacks.h"
 #include "libssh/kex.h"
 #include "libssh/packet.h"
 #include "libssh/pcap.h"
@@ -136,7 +135,6 @@ struct ssh_session_struct {
                       the server */
    char *discon_msg; /* disconnect message from
                         the remote host */
-    char *disconnect_message; /* disconnect message to be set */
    ssh_buffer in_buffer;
    PACKET in_packet;
    ssh_buffer out_buffer;
@@ -147,7 +145,7 @@ struct ssh_session_struct {
    /* where it was before being interrupted */
    enum ssh_pending_call_e pending_call_state;
    enum ssh_session_state_e session_state;
-    enum ssh_packet_state_e packet_state;
+    int packet_state;
    enum ssh_dh_state_e dh_handshake_state;
    enum ssh_channel_request_state_e global_req_state;
    struct ssh_agent_state_struct *agent_state;
@@ -175,7 +173,7 @@ struct ssh_session_struct {
    struct ssh_crypto_struct *next_crypto;  /* next_crypto is going to be used after a SSH2_MSG_NEWKEYS */

    struct ssh_list *channels; /* linked list of channels */
-    uint32_t maxchannel;
+    int maxchannel;
    ssh_agent agent; /* ssh agent */

 /* keyb interactive data */
@@ -190,7 +188,6 @@ struct ssh_session_struct {
        ssh_key ed25519_key;
        /* The type of host key wanted by client */
        enum ssh_keytypes_e hostkey;
-        enum ssh_digest_e hostkey_digest;
    } srv;

    /* auths accepted by server */
@@ -215,15 +212,13 @@ struct ssh_session_struct {
        char *sshdir;
        char *knownhosts;
        char *global_knownhosts;
-        char *wanted_methods[SSH_KEX_METHODS];
+        char *wanted_methods[10];
        char *pubkey_accepted_types;
        char *ProxyCommand;
        char *custombanner;
-        char *moduli_file;
-        char *agent_socket;
        unsigned long timeout; /* seconds */
        unsigned long timeout_usec;
-        uint16_t port;
+        unsigned int port;
        socket_t fd;
        int StrictHostKeyChecking;
        char compressionlevel;
@@ -236,7 +231,6 @@ struct ssh_session_struct {
        uint8_t options_seen[SOC_MAX];
        uint64_t rekey_data;
        uint32_t rekey_time;
-        int rsa_min_size;
    } opts;
    /* counters */
    ssh_counter socket_counter;
@@ -251,7 +245,7 @@ struct ssh_session_struct {
 typedef int (*ssh_termination_function)(void *user);
 int ssh_handle_packets(ssh_session session, int timeout);
 int ssh_handle_packets_termination(ssh_session session,
-                                   int timeout,
+                                   long timeout,
                                   ssh_termination_function fct,
                                   void *user);
 void ssh_socket_exception_callback(int code, int errno_code, void *user);
--- a/include/libssh/sftp.h
+++ b/include/libssh/sftp.h
@@ -258,7 +258,7 @@ LIBSSH_API int sftp_init(sftp_session sftp);
 * @param sftp          The sftp session where the error is saved.
 *
 * @return              The saved error (see server responses), < 0 if an error
- *                      in the function occurred.
+ *                      in the function occured.
 *
 * @see Server responses
 */
@@ -413,7 +413,7 @@ LIBSSH_API void sftp_attributes_free(sftp_attributes file);
 *
 * @param dir           The sftp directory handle to close.
 *
- * @return              Returns SSH_NO_ERROR or SSH_ERROR if an error occurred.
+ * @return              Returns SSH_NO_ERROR or SSH_ERROR if an error occured.
 */
 LIBSSH_API int sftp_closedir(sftp_dir dir);

@@ -422,7 +422,7 @@ LIBSSH_API int sftp_closedir(sftp_dir dir);
 *
 * @param file          The open sftp file handle to close.
 *
- * @return              Returns SSH_NO_ERROR or SSH_ERROR if an error occurred.
+ * @return              Returns SSH_NO_ERROR or SSH_ERROR if an error occured.
 *
 * @see                 sftp_open()
 */
@@ -478,7 +478,7 @@ LIBSSH_API void sftp_file_set_blocking(sftp_file handle);
 *
 * @param file          The opened sftp file handle to be read from.
 *
- * @param buf           Pointer to buffer to receive read data.
+ * @param buf           Pointer to buffer to recieve read data.
 *
 * @param count         Size of the buffer in bytes.
 *
@@ -527,7 +527,7 @@ LIBSSH_API int sftp_async_read_begin(sftp_file file, uint32_t len);
 *
 * @param file          The opened sftp file handle to be read from.
 *
- * @param data          Pointer to buffer to receive read data.
+ * @param data          Pointer to buffer to recieve read data.
 *
 * @param len           Size of the buffer in bytes. It should be bigger or
 *                      equal to the length parameter of the
@@ -537,7 +537,7 @@ LIBSSH_API int sftp_async_read_begin(sftp_file file, uint32_t len);
 *                      function.
 *
 * @return              Number of bytes read, 0 on EOF, SSH_ERROR if an error
- *                      occurred, SSH_AGAIN if the file is opened in nonblocking
+ *                      occured, SSH_AGAIN if the file is opened in nonblocking
 *                      mode and the request hasn't been executed yet.
 *
 * @warning             A call to this function with an invalid identifier
@@ -632,7 +632,7 @@ LIBSSH_API void sftp_rewind(sftp_file file);
 LIBSSH_API int sftp_unlink(sftp_session sftp, const char *file);

 /**
- * @brief Remove a directory.
+ * @brief Remove a directoy.
 *
 * @param sftp          The sftp session handle.
 *
@@ -806,7 +806,7 @@ LIBSSH_API void sftp_statvfs_free(sftp_statvfs_t statvfs_o);
 /**
 * @brief Synchronize a file's in-core state with storage device
 *
- * This calls the "fsync@openssh.com" extension. You should check if the
+ * This calls the "fsync@openssh.com" extention. You should check if the
 * extensions is supported using:
 *
 * @code
@@ -854,7 +854,7 @@ LIBSSH_API int sftp_server_version(sftp_session sftp);
 LIBSSH_API sftp_session sftp_server_new(ssh_session session, ssh_channel chan);

 /**
- * @brief Initialize the sftp server.
+ * @brief Intialize the sftp server.
 *
 * @param sftp         The sftp session to init.
 *
@@ -870,6 +870,13 @@ LIBSSH_API int sftp_server_init(sftp_session sftp);
 LIBSSH_API void sftp_server_free(sftp_session sftp);
 #endif  /* WITH_SERVER */

+/* this is not a public interface */
+#define SFTP_HANDLES 256
+sftp_packet sftp_packet_read(sftp_session sftp);
+int sftp_packet_write(sftp_session sftp,uint8_t type, ssh_buffer payload);
+void sftp_packet_free(sftp_packet packet);
+int buffer_add_attributes(ssh_buffer buffer, sftp_attributes attr);
+sftp_attributes sftp_parse_attr(sftp_session session, ssh_buffer buf,int expectname);
 /* sftpserver.c */

 LIBSSH_API sftp_client_message sftp_get_client_message(sftp_session sftp);
--- a/include/libssh/sftp_priv.h
+++ b/include/libssh/sftp_priv.h
@@ -1,32 +0,0 @@
-/*
- * This file is part of the SSH Library
- *
- * Copyright (c) 2003-2008 by Aris Adamantiadis
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef SFTP_PRIV_H
-#define SFTP_PRIV_H
-
-sftp_packet sftp_packet_read(sftp_session sftp);
-int sftp_packet_write(sftp_session sftp, uint8_t type, ssh_buffer payload);
-void sftp_packet_free(sftp_packet packet);
-int buffer_add_attributes(ssh_buffer buffer, sftp_attributes attr);
-sftp_attributes sftp_parse_attr(sftp_session session,
-                                ssh_buffer buf,
-                                int expectname);
-
-#endif /* SFTP_PRIV_H */
--- a/include/libssh/socket.h
+++ b/include/libssh/socket.h
@@ -35,13 +35,13 @@ void ssh_socket_reset(ssh_socket s);
 void ssh_socket_free(ssh_socket s);
 void ssh_socket_set_fd(ssh_socket s, socket_t fd);
 socket_t ssh_socket_get_fd(ssh_socket s);
+#ifndef _WIN32
 int ssh_socket_unix(ssh_socket s, const char *path);
 void ssh_execute_command(const char *command, socket_t in, socket_t out);
-#ifndef _WIN32
 int ssh_socket_connect_proxycommand(ssh_socket s, const char *command);
 #endif
 void ssh_socket_close(ssh_socket s);
-int ssh_socket_write(ssh_socket s,const void *buffer, uint32_t len);
+int ssh_socket_write(ssh_socket s,const void *buffer, int len);
 int ssh_socket_is_open(ssh_socket s);
 int ssh_socket_fd_isset(ssh_socket s, fd_set *set);
 void ssh_socket_fd_set(ssh_socket s, fd_set *set, socket_t *max_fd);
@@ -63,9 +63,6 @@ void ssh_socket_set_callbacks(ssh_socket s, ssh_socket_callbacks callbacks);
 int ssh_socket_pollcallback(struct ssh_poll_handle_struct *p, socket_t fd, int revents, void *v_s);
 struct ssh_poll_handle_struct * ssh_socket_get_poll_handle(ssh_socket s);

-int ssh_socket_connect(ssh_socket s,
-                       const char *host,
-                       uint16_t port,
-                       const char *bind_addr);
+int ssh_socket_connect(ssh_socket s, const char *host, int port, const char *bind_addr);

 #endif /* SOCKET_H_ */
--- a/include/libssh/wrapper.h
+++ b/include/libssh/wrapper.h
@@ -29,6 +29,14 @@
 #include "libssh/libgcrypt.h"
 #include "libssh/libmbedcrypto.h"

+enum ssh_digest_e {
+    SSH_DIGEST_AUTO=0,
+    SSH_DIGEST_SHA1=1,
+    SSH_DIGEST_SHA256,
+    SSH_DIGEST_SHA384,
+    SSH_DIGEST_SHA512,
+};
+
 enum ssh_kdf_digest {
    SSH_KDF_SHA1=1,
    SSH_KDF_SHA256,
@@ -42,8 +50,7 @@ enum ssh_hmac_e {
  SSH_HMAC_SHA512,
  SSH_HMAC_MD5,
  SSH_HMAC_AEAD_POLY1305,
-  SSH_HMAC_AEAD_GCM,
-  SSH_HMAC_NONE,
+  SSH_HMAC_AEAD_GCM
 };

 enum ssh_des_e {
@@ -68,42 +75,42 @@ struct ssh_crypto_struct;

 typedef struct ssh_mac_ctx_struct *ssh_mac_ctx;
 MD5CTX md5_init(void);
-void md5_update(MD5CTX c, const void *data, size_t len);
+void md5_update(MD5CTX c, const void *data, unsigned long len);
 void md5_final(unsigned char *md,MD5CTX c);

 SHACTX sha1_init(void);
-void sha1_update(SHACTX c, const void *data, size_t len);
+void sha1_update(SHACTX c, const void *data, unsigned long len);
 void sha1_final(unsigned char *md,SHACTX c);
-void sha1(const unsigned char *digest,size_t len,unsigned char *hash);
+void sha1(const unsigned char *digest,int len,unsigned char *hash);

 SHA256CTX sha256_init(void);
-void sha256_update(SHA256CTX c, const void *data, size_t len);
+void sha256_update(SHA256CTX c, const void *data, unsigned long len);
 void sha256_final(unsigned char *md,SHA256CTX c);
-void sha256(const unsigned char *digest, size_t len, unsigned char *hash);
+void sha256(const unsigned char *digest, int len, unsigned char *hash);

 SHA384CTX sha384_init(void);
-void sha384_update(SHA384CTX c, const void *data, size_t len);
+void sha384_update(SHA384CTX c, const void *data, unsigned long len);
 void sha384_final(unsigned char *md,SHA384CTX c);
-void sha384(const unsigned char *digest, size_t len, unsigned char *hash);
+void sha384(const unsigned char *digest, int len, unsigned char *hash);

 SHA512CTX sha512_init(void);
-void sha512_update(SHA512CTX c, const void *data, size_t len);
+void sha512_update(SHA512CTX c, const void *data, unsigned long len);
 void sha512_final(unsigned char *md,SHA512CTX c);
-void sha512(const unsigned char *digest, size_t len, unsigned char *hash);
+void sha512(const unsigned char *digest, int len, unsigned char *hash);

-void evp(int nid, unsigned char *digest, size_t len, unsigned char *hash, unsigned int *hlen);
+void evp(int nid, unsigned char *digest, int len, unsigned char *hash, unsigned int *hlen);
 EVPCTX evp_init(int nid);
-void evp_update(EVPCTX ctx, const void *data, size_t len);
+void evp_update(EVPCTX ctx, const void *data, unsigned long len);
 void evp_final(EVPCTX ctx, unsigned char *md, unsigned int *mdlen);

-HMACCTX hmac_init(const void *key,size_t len, enum ssh_hmac_e type);
-int hmac_update(HMACCTX c, const void *data, size_t len);
-int hmac_final(HMACCTX ctx, unsigned char *hashmacbuf, size_t *len);
+HMACCTX hmac_init(const void *key,int len, enum ssh_hmac_e type);
+void hmac_update(HMACCTX c, const void *data, unsigned long len);
+void hmac_final(HMACCTX ctx,unsigned char *hashmacbuf,unsigned int *len);
 size_t hmac_digest_len(enum ssh_hmac_e type);

 int ssh_kdf(struct ssh_crypto_struct *crypto,
            unsigned char *key, size_t key_len,
-            uint8_t key_type, unsigned char *output,
+            int key_type, unsigned char *output,
            size_t requested_len);

 int crypt_set_algorithms_client(ssh_session session);
@@ -120,11 +127,4 @@ struct ssh_hmac_struct *ssh_get_hmactab(void);
 struct ssh_cipher_struct *ssh_get_ciphertab(void);
 const char *ssh_hmac_type_to_string(enum ssh_hmac_e hmac_type, bool etm);

-#if defined(HAVE_LIBCRYPTO) && OPENSSL_VERSION_NUMBER >= 0x30000000L
-int evp_build_pkey(const char* name, OSSL_PARAM_BLD *param_bld, EVP_PKEY **pkey, int selection);
-int evp_dup_dsa_pkey(const ssh_key key, ssh_key new, int demote);
-int evp_dup_rsa_pkey(const ssh_key key, ssh_key new, int demote);
-int evp_dup_ecdsa_pkey(const ssh_key key, ssh_key new, int demote);
-#endif /* HAVE_LIBCRYPTO && OPENSSL_VERSION_NUMBER */
-
 #endif /* WRAPPER_H_ */
--- a/obj/build_make.sh
+++ b/obj/build_make.sh
@@ -0,0 +1,200 @@
+#!/bin/bash
+#
+# Last Change: 2008-06-18 14:13:46
+#
+# Script to build libssh on UNIX.
+#
+# Copyright (c) 2006-2007 Andreas Schneider <asn@cryptomilk.org>
+#
+
+SOURCE_DIR=".."
+
+LANG=C
+export LANG
+
+SCRIPT="$0"
+COUNT=0
+while [ -L "${SCRIPT}" ]
+do
+	SCRIPT=$(readlink ${SCRIPT})
+	COUNT=$(expr ${COUNT} + 1)
+	if [ ${COUNT} -gt 100 ]; then
+		echo "Too many symbolic links"
+		exit 1
+	fi
+done
+BUILDDIR=$(dirname ${SCRIPT})
+
+cleanup_and_exit () {
+	if test "$1" = 0 -o -z "$1" ; then
+		exit 0
+	else
+		exit $1
+	fi
+}
+
+function configure() {
+	if [ -n "${CMAKEDIR}" ]; then
+		${CMAKEDIR}/bin/cmake "$@" ${SOURCE_DIR} || cleanup_and_exit $?
+	else
+		cmake "$@" ${SOURCE_DIR} || cleanup_and_exit $?
+	fi
+}
+
+function compile() {
+	if [ -f /proc/cpuinfo ]; then
+		CPUCOUNT=$(grep -c processor /proc/cpuinfo)
+	elif test `uname` = "SunOS" ; then
+		CPUCOUNT=$(psrinfo -p)
+	else
+		CPUCOUNT="1"
+	fi
+
+	if [ "${CPUCOUNT}" -gt "1" ]; then
+		${MAKE} -j${CPUCOUNT} $1 || cleanup_and_exit $?
+	else
+		${MAKE} $1 || exit $?
+	fi
+}
+
+function clean_build_dir() {
+	find ! -path "*.svn*" ! -name "*.bat" ! -name "*.sh" ! -name "." -print0 | xargs -0 rm -rf
+}
+
+function usage () {
+echo "Usage: `basename $0` [--prefix /install_prefix|--build [debug|final]|--clean|--verbose|--libsuffix (32|64)|--help|--clang|--cmakedir /directory|--make
+(gmake|make)|--ccompiler(gcc|cc)|--withstaticlib|--unittesting|--clientunittesting|--withserver|--withoutsymbolversioning]"
+    cleanup_and_exit
+}
+
+cd ${BUILDDIR}
+
+# the default CMake options:
+OPTIONS="--graphviz=${BUILDDIR}/libssh.dot"
+
+# the default 'make' utility:
+MAKE="make"
+
+while test -n "$1"; do
+	PARAM="$1"
+	ARG="$2"
+	shift
+	case ${PARAM} in
+		*-*=*)
+		ARG=${PARAM#*=}
+		PARAM=${PARAM%%=*}
+		set -- "----noarg=${PARAM}" "$@"
+	esac
+	case ${PARAM} in
+		*-help|-h)
+			#echo_help
+			usage
+			cleanup_and_exit
+		;;
+		*-build)
+			DOMAKE="1"
+			BUILD_TYPE="${ARG}"
+			test -n "${BUILD_TYPE}" && shift
+		;;
+		*-clean)
+			clean_build_dir
+			cleanup_and_exit
+		;;
+		*-clang)
+			OPTIONS="${OPTIONS} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++"
+		;;
+		*-verbose)
+			DOVERBOSE="1"
+		;;
+		*-memtest)
+			OPTIONS="${OPTIONS} -DMEM_NULL_TESTS=ON"
+		;;
+		*-libsuffix)
+			OPTIONS="${OPTIONS} -DLIB_SUFFIX=${ARG}"
+			shift
+		;;
+		*-prefix)
+			OPTIONS="${OPTIONS} -DCMAKE_INSTALL_PREFIX=${ARG}"
+			shift
+		;;
+		*-sysconfdir)
+			OPTIONS="${OPTIONS} -DSYSCONF_INSTALL_DIR=${ARG}"
+			shift
+		;;
+		*-cmakedir)
+			CMAKEDIR="${ARG}"
+			shift
+		;;
+		*-make)
+			MAKE="${ARG}"
+			shift
+		;;
+		*-ccompiler)
+			OPTIONS="${OPTIONS} -DCMAKE_C_COMPILER=${ARG}"
+			shift
+		;;
+		*-withstaticlib)
+			OPTIONS="${OPTIONS} -DWITH_STATIC_LIB=ON"
+		;;
+		*-unittesting)
+			OPTIONS="${OPTIONS} -DUNIT_TESTING=ON"
+		;;
+		*-clientunittesting)
+			OPTIONS="${OPTIONS} -DCLIENT_TESTING=ON"
+		;;
+		*-withserver)
+			OPTIONS="${OPTIONS} -DWITH_SERVER=ON"
+		;;
+		*-withoutsymbolversioning)
+			OPTIONS="${OPTIONS} -DWITH_SYMBOL_VERSIONING=OFF"
+		;;
+		*-finalrelease)
+			OPTIONS="${OPTIONS} -DWITH_FINAL=ON"
+		;;
+		----noarg)
+			echo "$ARG does not take an argument"
+			cleanup_and_exit
+		;;
+		-*)
+			echo Unknown Option "$PARAM". Exit.
+			cleanup_and_exit 1
+		;;
+		*)
+			usage
+		;;
+	esac
+done
+
+if [ "${DOMAKE}" == "1" ]; then
+	OPTIONS="${OPTIONS} -DCMAKE_BUILD_TYPE=${BUILD_TYPE}"
+fi
+
+if [ -n "${DOVERBOSE}" ]; then
+	OPTIONS="${OPTIONS} -DCMAKE_VERBOSE_MAKEFILE=1"
+else
+	OPTIONS="${OPTIONS} -DCMAKE_VERBOSE_MAKEFILE=0"
+fi
+
+test -f "${BUILDDIR}/.build.log" && rm -f ${BUILDDIR}/.build.log
+touch ${BUILDDIR}/.build.log
+# log everything from here to .build.log
+exec 1> >(exec -a 'build logging tee' tee -a ${BUILDDIR}/.build.log) 2>&1
+echo "${HOST} started build at $(date)."
+echo
+
+configure ${OPTIONS} "$@"
+
+if [ -n "${DOMAKE}" ]; then
+	test -n "${DOVERBOSE}" && compile VERBOSE=1 || compile
+fi
+
+DOT=$(which dot 2>/dev/null)
+if [ -n "${DOT}" ]; then
+	${DOT} -Tpng -o${BUILDDIR}/libssh.png ${BUILDDIR}/libssh.dot
+	${DOT} -Tsvg -o${BUILDDIR}/libssh.svg ${BUILDDIR}/libssh.dot
+fi
+
+exec >&0 2>&0		# so that the logging tee finishes
+sleep 1			# wait till tee terminates
+
+cleanup_and_exit 0
--- a/src/ABI/current
+++ b/src/ABI/current
@@ -1 +1 @@
-4.9.4
+4.8.2
--- a/src/ABI/libssh-4.8.2.symbols
+++ b/src/ABI/libssh-4.8.2.symbols
@@ -149,7 +149,6 @@ ssh_channel_listen_forward
 ssh_channel_new
 ssh_channel_open_auth_agent
 ssh_channel_open_forward
-ssh_channel_open_forward_port
 ssh_channel_open_forward_unix
 ssh_channel_open_reverse_forward
 ssh_channel_open_session
@@ -242,7 +241,6 @@ ssh_is_blocking
 ssh_is_connected
 ssh_is_server_known
 ssh_key_cmp
-ssh_key_dup
 ssh_key_free
 ssh_key_is_private
 ssh_key_is_public
@@ -348,7 +346,6 @@ ssh_scp_write
 ssh_select
 ssh_send_debug
 ssh_send_ignore
-ssh_send_issue_banner
 ssh_send_keepalive
 ssh_server_init_kex
 ssh_service_request
@@ -356,7 +353,6 @@ ssh_session_export_known_hosts_entry
 ssh_session_get_known_hosts_entry
 ssh_session_has_known_hosts_entry
 ssh_session_is_known_server
-ssh_session_set_disconnect_message
 ssh_session_update_known_hosts
 ssh_set_agent_channel
 ssh_set_agent_socket
@@ -411,10 +407,8 @@ ssh_userauth_privatekey_file
 ssh_userauth_pubkey
 ssh_userauth_publickey
 ssh_userauth_publickey_auto
-ssh_userauth_publickey_auto_get_current_identity
 ssh_userauth_try_publickey
 ssh_version
-ssh_vlog
 ssh_write_knownhost
 string_burn
 string_copy
--- a/src/ABI/libssh-4.9.0.symbols
+++ b/src/ABI/libssh-4.9.0.symbols
@@ -1,427 +0,0 @@
-_ssh_log
-buffer_free
-buffer_get
-buffer_get_len
-buffer_new
-channel_accept_x11
-channel_change_pty_size
-channel_close
-channel_forward_accept
-channel_forward_cancel
-channel_forward_listen
-channel_free
-channel_get_exit_status
-channel_get_session
-channel_is_closed
-channel_is_eof
-channel_is_open
-channel_new
-channel_open_forward
-channel_open_session
-channel_poll
-channel_read
-channel_read_buffer
-channel_read_nonblocking
-channel_request_env
-channel_request_exec
-channel_request_pty
-channel_request_pty_size
-channel_request_send_signal
-channel_request_sftp
-channel_request_shell
-channel_request_subsystem
-channel_request_x11
-channel_select
-channel_send_eof
-channel_set_blocking
-channel_write
-channel_write_stderr
-privatekey_free
-privatekey_from_file
-publickey_free
-publickey_from_file
-publickey_from_privatekey
-publickey_to_string
-sftp_async_read
-sftp_async_read_begin
-sftp_attributes_free
-sftp_canonicalize_path
-sftp_chmod
-sftp_chown
-sftp_client_message_free
-sftp_client_message_get_data
-sftp_client_message_get_filename
-sftp_client_message_get_flags
-sftp_client_message_get_submessage
-sftp_client_message_get_type
-sftp_client_message_set_filename
-sftp_close
-sftp_closedir
-sftp_dir_eof
-sftp_extension_supported
-sftp_extensions_get_count
-sftp_extensions_get_data
-sftp_extensions_get_name
-sftp_file_set_blocking
-sftp_file_set_nonblocking
-sftp_free
-sftp_fstat
-sftp_fstatvfs
-sftp_fsync
-sftp_get_client_message
-sftp_get_error
-sftp_handle
-sftp_handle_alloc
-sftp_handle_remove
-sftp_init
-sftp_lstat
-sftp_mkdir
-sftp_new
-sftp_new_channel
-sftp_open
-sftp_opendir
-sftp_read
-sftp_readdir
-sftp_readlink
-sftp_rename
-sftp_reply_attr
-sftp_reply_data
-sftp_reply_handle
-sftp_reply_name
-sftp_reply_names
-sftp_reply_names_add
-sftp_reply_status
-sftp_rewind
-sftp_rmdir
-sftp_seek
-sftp_seek64
-sftp_send_client_message
-sftp_server_free
-sftp_server_init
-sftp_server_new
-sftp_server_version
-sftp_setstat
-sftp_stat
-sftp_statvfs
-sftp_statvfs_free
-sftp_symlink
-sftp_tell
-sftp_tell64
-sftp_unlink
-sftp_utimes
-sftp_write
-ssh_accept
-ssh_add_channel_callbacks
-ssh_auth_list
-ssh_basename
-ssh_bind_accept
-ssh_bind_accept_fd
-ssh_bind_fd_toaccept
-ssh_bind_free
-ssh_bind_get_fd
-ssh_bind_listen
-ssh_bind_new
-ssh_bind_options_parse_config
-ssh_bind_options_set
-ssh_bind_set_blocking
-ssh_bind_set_callbacks
-ssh_bind_set_fd
-ssh_blocking_flush
-ssh_buffer_add_data
-ssh_buffer_free
-ssh_buffer_get
-ssh_buffer_get_data
-ssh_buffer_get_len
-ssh_buffer_new
-ssh_buffer_reinit
-ssh_channel_accept_forward
-ssh_channel_accept_x11
-ssh_channel_cancel_forward
-ssh_channel_change_pty_size
-ssh_channel_close
-ssh_channel_free
-ssh_channel_get_exit_status
-ssh_channel_get_session
-ssh_channel_is_closed
-ssh_channel_is_eof
-ssh_channel_is_open
-ssh_channel_listen_forward
-ssh_channel_new
-ssh_channel_open_auth_agent
-ssh_channel_open_forward
-ssh_channel_open_forward_port
-ssh_channel_open_forward_unix
-ssh_channel_open_reverse_forward
-ssh_channel_open_session
-ssh_channel_open_x11
-ssh_channel_poll
-ssh_channel_poll_timeout
-ssh_channel_read
-ssh_channel_read_nonblocking
-ssh_channel_read_timeout
-ssh_channel_request_auth_agent
-ssh_channel_request_env
-ssh_channel_request_exec
-ssh_channel_request_pty
-ssh_channel_request_pty_size
-ssh_channel_request_send_break
-ssh_channel_request_send_exit_signal
-ssh_channel_request_send_exit_status
-ssh_channel_request_send_signal
-ssh_channel_request_sftp
-ssh_channel_request_shell
-ssh_channel_request_subsystem
-ssh_channel_request_x11
-ssh_channel_select
-ssh_channel_send_eof
-ssh_channel_set_blocking
-ssh_channel_set_counter
-ssh_channel_window_size
-ssh_channel_write
-ssh_channel_write_stderr
-ssh_clean_pubkey_hash
-ssh_connect
-ssh_connector_free
-ssh_connector_new
-ssh_connector_set_in_channel
-ssh_connector_set_in_fd
-ssh_connector_set_out_channel
-ssh_connector_set_out_fd
-ssh_copyright
-ssh_dirname
-ssh_disconnect
-ssh_dump_knownhost
-ssh_event_add_connector
-ssh_event_add_fd
-ssh_event_add_session
-ssh_event_dopoll
-ssh_event_free
-ssh_event_new
-ssh_event_remove_connector
-ssh_event_remove_fd
-ssh_event_remove_session
-ssh_execute_message_callbacks
-ssh_finalize
-ssh_forward_accept
-ssh_forward_cancel
-ssh_forward_listen
-ssh_free
-ssh_get_cipher_in
-ssh_get_cipher_out
-ssh_get_clientbanner
-ssh_get_disconnect_message
-ssh_get_error
-ssh_get_error_code
-ssh_get_fd
-ssh_get_fingerprint_hash
-ssh_get_hexa
-ssh_get_hmac_in
-ssh_get_hmac_out
-ssh_get_issue_banner
-ssh_get_kex_algo
-ssh_get_log_callback
-ssh_get_log_level
-ssh_get_log_userdata
-ssh_get_openssh_version
-ssh_get_poll_flags
-ssh_get_pubkey
-ssh_get_pubkey_hash
-ssh_get_publickey
-ssh_get_publickey_hash
-ssh_get_random
-ssh_get_server_publickey
-ssh_get_serverbanner
-ssh_get_status
-ssh_get_version
-ssh_getpass
-ssh_gssapi_get_creds
-ssh_gssapi_set_creds
-ssh_handle_key_exchange
-ssh_init
-ssh_is_blocking
-ssh_is_connected
-ssh_is_server_known
-ssh_key_cmp
-ssh_key_dup
-ssh_key_free
-ssh_key_is_private
-ssh_key_is_public
-ssh_key_new
-ssh_key_type
-ssh_key_type_from_name
-ssh_key_type_to_char
-ssh_known_hosts_parse_line
-ssh_knownhosts_entry_free
-ssh_log
-ssh_message_auth_interactive_request
-ssh_message_auth_kbdint_is_response
-ssh_message_auth_password
-ssh_message_auth_pubkey
-ssh_message_auth_publickey
-ssh_message_auth_publickey_state
-ssh_message_auth_reply_pk_ok
-ssh_message_auth_reply_pk_ok_simple
-ssh_message_auth_reply_success
-ssh_message_auth_set_methods
-ssh_message_auth_user
-ssh_message_channel_request_channel
-ssh_message_channel_request_command
-ssh_message_channel_request_env_name
-ssh_message_channel_request_env_value
-ssh_message_channel_request_open_destination
-ssh_message_channel_request_open_destination_port
-ssh_message_channel_request_open_originator
-ssh_message_channel_request_open_originator_port
-ssh_message_channel_request_open_reply_accept
-ssh_message_channel_request_open_reply_accept_channel
-ssh_message_channel_request_pty_height
-ssh_message_channel_request_pty_pxheight
-ssh_message_channel_request_pty_pxwidth
-ssh_message_channel_request_pty_term
-ssh_message_channel_request_pty_width
-ssh_message_channel_request_reply_success
-ssh_message_channel_request_subsystem
-ssh_message_channel_request_x11_auth_cookie
-ssh_message_channel_request_x11_auth_protocol
-ssh_message_channel_request_x11_screen_number
-ssh_message_channel_request_x11_single_connection
-ssh_message_free
-ssh_message_get
-ssh_message_global_request_address
-ssh_message_global_request_port
-ssh_message_global_request_reply_success
-ssh_message_reply_default
-ssh_message_retrieve
-ssh_message_service_reply_success
-ssh_message_service_service
-ssh_message_subtype
-ssh_message_type
-ssh_mkdir
-ssh_new
-ssh_options_copy
-ssh_options_get
-ssh_options_get_port
-ssh_options_getopt
-ssh_options_parse_config
-ssh_options_set
-ssh_pcap_file_close
-ssh_pcap_file_free
-ssh_pcap_file_new
-ssh_pcap_file_open
-ssh_pki_copy_cert_to_privkey
-ssh_pki_export_privkey_base64
-ssh_pki_export_privkey_file
-ssh_pki_export_privkey_to_pubkey
-ssh_pki_export_pubkey_base64
-ssh_pki_export_pubkey_file
-ssh_pki_generate
-ssh_pki_import_cert_base64
-ssh_pki_import_cert_file
-ssh_pki_import_privkey_base64
-ssh_pki_import_privkey_file
-ssh_pki_import_pubkey_base64
-ssh_pki_import_pubkey_file
-ssh_pki_key_ecdsa_name
-ssh_print_hash
-ssh_print_hexa
-ssh_privatekey_type
-ssh_publickey_to_file
-ssh_remove_channel_callbacks
-ssh_scp_accept_request
-ssh_scp_close
-ssh_scp_deny_request
-ssh_scp_free
-ssh_scp_init
-ssh_scp_leave_directory
-ssh_scp_new
-ssh_scp_pull_request
-ssh_scp_push_directory
-ssh_scp_push_file
-ssh_scp_push_file64
-ssh_scp_read
-ssh_scp_request_get_filename
-ssh_scp_request_get_permissions
-ssh_scp_request_get_size
-ssh_scp_request_get_size64
-ssh_scp_request_get_warning
-ssh_scp_write
-ssh_select
-ssh_send_debug
-ssh_send_ignore
-ssh_send_issue_banner
-ssh_send_keepalive
-ssh_server_init_kex
-ssh_service_request
-ssh_session_export_known_hosts_entry
-ssh_session_get_known_hosts_entry
-ssh_session_has_known_hosts_entry
-ssh_session_is_known_server
-ssh_session_set_disconnect_message
-ssh_session_update_known_hosts
-ssh_set_agent_channel
-ssh_set_agent_socket
-ssh_set_auth_methods
-ssh_set_blocking
-ssh_set_callbacks
-ssh_set_channel_callbacks
-ssh_set_counters
-ssh_set_fd_except
-ssh_set_fd_toread
-ssh_set_fd_towrite
-ssh_set_log_callback
-ssh_set_log_level
-ssh_set_log_userdata
-ssh_set_message_callback
-ssh_set_pcap_file
-ssh_set_server_callbacks
-ssh_silent_disconnect
-ssh_string_burn
-ssh_string_copy
-ssh_string_data
-ssh_string_fill
-ssh_string_free
-ssh_string_free_char
-ssh_string_from_char
-ssh_string_get_char
-ssh_string_len
-ssh_string_new
-ssh_string_to_char
-ssh_threads_get_default
-ssh_threads_get_noop
-ssh_threads_get_pthread
-ssh_threads_set_callbacks
-ssh_try_publickey_from_file
-ssh_userauth_agent
-ssh_userauth_agent_pubkey
-ssh_userauth_autopubkey
-ssh_userauth_gssapi
-ssh_userauth_kbdint
-ssh_userauth_kbdint_getanswer
-ssh_userauth_kbdint_getinstruction
-ssh_userauth_kbdint_getname
-ssh_userauth_kbdint_getnanswers
-ssh_userauth_kbdint_getnprompts
-ssh_userauth_kbdint_getprompt
-ssh_userauth_kbdint_setanswer
-ssh_userauth_list
-ssh_userauth_none
-ssh_userauth_offer_pubkey
-ssh_userauth_password
-ssh_userauth_privatekey_file
-ssh_userauth_pubkey
-ssh_userauth_publickey
-ssh_userauth_publickey_auto
-ssh_userauth_publickey_auto_get_current_identity
-ssh_userauth_try_publickey
-ssh_version
-ssh_vlog
-ssh_write_knownhost
-string_burn
-string_copy
-string_data
-string_fill
-string_free
-string_from_char
-string_len
-string_new
-string_to_char
--- a/src/ABI/libssh-4.9.1.symbols
+++ b/src/ABI/libssh-4.9.1.symbols
@@ -1,427 +0,0 @@
-_ssh_log
-buffer_free
-buffer_get
-buffer_get_len
-buffer_new
-channel_accept_x11
-channel_change_pty_size
-channel_close
-channel_forward_accept
-channel_forward_cancel
-channel_forward_listen
-channel_free
-channel_get_exit_status
-channel_get_session
-channel_is_closed
-channel_is_eof
-channel_is_open
-channel_new
-channel_open_forward
-channel_open_session
-channel_poll
-channel_read
-channel_read_buffer
-channel_read_nonblocking
-channel_request_env
-channel_request_exec
-channel_request_pty
-channel_request_pty_size
-channel_request_send_signal
-channel_request_sftp
-channel_request_shell
-channel_request_subsystem
-channel_request_x11
-channel_select
-channel_send_eof
-channel_set_blocking
-channel_write
-channel_write_stderr
-privatekey_free
-privatekey_from_file
-publickey_free
-publickey_from_file
-publickey_from_privatekey
-publickey_to_string
-sftp_async_read
-sftp_async_read_begin
-sftp_attributes_free
-sftp_canonicalize_path
-sftp_chmod
-sftp_chown
-sftp_client_message_free
-sftp_client_message_get_data
-sftp_client_message_get_filename
-sftp_client_message_get_flags
-sftp_client_message_get_submessage
-sftp_client_message_get_type
-sftp_client_message_set_filename
-sftp_close
-sftp_closedir
-sftp_dir_eof
-sftp_extension_supported
-sftp_extensions_get_count
-sftp_extensions_get_data
-sftp_extensions_get_name
-sftp_file_set_blocking
-sftp_file_set_nonblocking
-sftp_free
-sftp_fstat
-sftp_fstatvfs
-sftp_fsync
-sftp_get_client_message
-sftp_get_error
-sftp_handle
-sftp_handle_alloc
-sftp_handle_remove
-sftp_init
-sftp_lstat
-sftp_mkdir
-sftp_new
-sftp_new_channel
-sftp_open
-sftp_opendir
-sftp_read
-sftp_readdir
-sftp_readlink
-sftp_rename
-sftp_reply_attr
-sftp_reply_data
-sftp_reply_handle
-sftp_reply_name
-sftp_reply_names
-sftp_reply_names_add
-sftp_reply_status
-sftp_rewind
-sftp_rmdir
-sftp_seek
-sftp_seek64
-sftp_send_client_message
-sftp_server_free
-sftp_server_init
-sftp_server_new
-sftp_server_version
-sftp_setstat
-sftp_stat
-sftp_statvfs
-sftp_statvfs_free
-sftp_symlink
-sftp_tell
-sftp_tell64
-sftp_unlink
-sftp_utimes
-sftp_write
-ssh_accept
-ssh_add_channel_callbacks
-ssh_auth_list
-ssh_basename
-ssh_bind_accept
-ssh_bind_accept_fd
-ssh_bind_fd_toaccept
-ssh_bind_free
-ssh_bind_get_fd
-ssh_bind_listen
-ssh_bind_new
-ssh_bind_options_parse_config
-ssh_bind_options_set
-ssh_bind_set_blocking
-ssh_bind_set_callbacks
-ssh_bind_set_fd
-ssh_blocking_flush
-ssh_buffer_add_data
-ssh_buffer_free
-ssh_buffer_get
-ssh_buffer_get_data
-ssh_buffer_get_len
-ssh_buffer_new
-ssh_buffer_reinit
-ssh_channel_accept_forward
-ssh_channel_accept_x11
-ssh_channel_cancel_forward
-ssh_channel_change_pty_size
-ssh_channel_close
-ssh_channel_free
-ssh_channel_get_exit_status
-ssh_channel_get_session
-ssh_channel_is_closed
-ssh_channel_is_eof
-ssh_channel_is_open
-ssh_channel_listen_forward
-ssh_channel_new
-ssh_channel_open_auth_agent
-ssh_channel_open_forward
-ssh_channel_open_forward_port
-ssh_channel_open_forward_unix
-ssh_channel_open_reverse_forward
-ssh_channel_open_session
-ssh_channel_open_x11
-ssh_channel_poll
-ssh_channel_poll_timeout
-ssh_channel_read
-ssh_channel_read_nonblocking
-ssh_channel_read_timeout
-ssh_channel_request_auth_agent
-ssh_channel_request_env
-ssh_channel_request_exec
-ssh_channel_request_pty
-ssh_channel_request_pty_size
-ssh_channel_request_send_break
-ssh_channel_request_send_exit_signal
-ssh_channel_request_send_exit_status
-ssh_channel_request_send_signal
-ssh_channel_request_sftp
-ssh_channel_request_shell
-ssh_channel_request_subsystem
-ssh_channel_request_x11
-ssh_channel_select
-ssh_channel_send_eof
-ssh_channel_set_blocking
-ssh_channel_set_counter
-ssh_channel_window_size
-ssh_channel_write
-ssh_channel_write_stderr
-ssh_clean_pubkey_hash
-ssh_connect
-ssh_connector_free
-ssh_connector_new
-ssh_connector_set_in_channel
-ssh_connector_set_in_fd
-ssh_connector_set_out_channel
-ssh_connector_set_out_fd
-ssh_copyright
-ssh_dirname
-ssh_disconnect
-ssh_dump_knownhost
-ssh_event_add_connector
-ssh_event_add_fd
-ssh_event_add_session
-ssh_event_dopoll
-ssh_event_free
-ssh_event_new
-ssh_event_remove_connector
-ssh_event_remove_fd
-ssh_event_remove_session
-ssh_execute_message_callbacks
-ssh_finalize
-ssh_forward_accept
-ssh_forward_cancel
-ssh_forward_listen
-ssh_free
-ssh_get_cipher_in
-ssh_get_cipher_out
-ssh_get_clientbanner
-ssh_get_disconnect_message
-ssh_get_error
-ssh_get_error_code
-ssh_get_fd
-ssh_get_fingerprint_hash
-ssh_get_hexa
-ssh_get_hmac_in
-ssh_get_hmac_out
-ssh_get_issue_banner
-ssh_get_kex_algo
-ssh_get_log_callback
-ssh_get_log_level
-ssh_get_log_userdata
-ssh_get_openssh_version
-ssh_get_poll_flags
-ssh_get_pubkey
-ssh_get_pubkey_hash
-ssh_get_publickey
-ssh_get_publickey_hash
-ssh_get_random
-ssh_get_server_publickey
-ssh_get_serverbanner
-ssh_get_status
-ssh_get_version
-ssh_getpass
-ssh_gssapi_get_creds
-ssh_gssapi_set_creds
-ssh_handle_key_exchange
-ssh_init
-ssh_is_blocking
-ssh_is_connected
-ssh_is_server_known
-ssh_key_cmp
-ssh_key_dup
-ssh_key_free
-ssh_key_is_private
-ssh_key_is_public
-ssh_key_new
-ssh_key_type
-ssh_key_type_from_name
-ssh_key_type_to_char
-ssh_known_hosts_parse_line
-ssh_knownhosts_entry_free
-ssh_log
-ssh_message_auth_interactive_request
-ssh_message_auth_kbdint_is_response
-ssh_message_auth_password
-ssh_message_auth_pubkey
-ssh_message_auth_publickey
-ssh_message_auth_publickey_state
-ssh_message_auth_reply_pk_ok
-ssh_message_auth_reply_pk_ok_simple
-ssh_message_auth_reply_success
-ssh_message_auth_set_methods
-ssh_message_auth_user
-ssh_message_channel_request_channel
-ssh_message_channel_request_command
-ssh_message_channel_request_env_name
-ssh_message_channel_request_env_value
-ssh_message_channel_request_open_destination
-ssh_message_channel_request_open_destination_port
-ssh_message_channel_request_open_originator
-ssh_message_channel_request_open_originator_port
-ssh_message_channel_request_open_reply_accept
-ssh_message_channel_request_open_reply_accept_channel
-ssh_message_channel_request_pty_height
-ssh_message_channel_request_pty_pxheight
-ssh_message_channel_request_pty_pxwidth
-ssh_message_channel_request_pty_term
-ssh_message_channel_request_pty_width
-ssh_message_channel_request_reply_success
-ssh_message_channel_request_subsystem
-ssh_message_channel_request_x11_auth_cookie
-ssh_message_channel_request_x11_auth_protocol
-ssh_message_channel_request_x11_screen_number
-ssh_message_channel_request_x11_single_connection
-ssh_message_free
-ssh_message_get
-ssh_message_global_request_address
-ssh_message_global_request_port
-ssh_message_global_request_reply_success
-ssh_message_reply_default
-ssh_message_retrieve
-ssh_message_service_reply_success
-ssh_message_service_service
-ssh_message_subtype
-ssh_message_type
-ssh_mkdir
-ssh_new
-ssh_options_copy
-ssh_options_get
-ssh_options_get_port
-ssh_options_getopt
-ssh_options_parse_config
-ssh_options_set
-ssh_pcap_file_close
-ssh_pcap_file_free
-ssh_pcap_file_new
-ssh_pcap_file_open
-ssh_pki_copy_cert_to_privkey
-ssh_pki_export_privkey_base64
-ssh_pki_export_privkey_file
-ssh_pki_export_privkey_to_pubkey
-ssh_pki_export_pubkey_base64
-ssh_pki_export_pubkey_file
-ssh_pki_generate
-ssh_pki_import_cert_base64
-ssh_pki_import_cert_file
-ssh_pki_import_privkey_base64
-ssh_pki_import_privkey_file
-ssh_pki_import_pubkey_base64
-ssh_pki_import_pubkey_file
-ssh_pki_key_ecdsa_name
-ssh_print_hash
-ssh_print_hexa
-ssh_privatekey_type
-ssh_publickey_to_file
-ssh_remove_channel_callbacks
-ssh_scp_accept_request
-ssh_scp_close
-ssh_scp_deny_request
-ssh_scp_free
-ssh_scp_init
-ssh_scp_leave_directory
-ssh_scp_new
-ssh_scp_pull_request
-ssh_scp_push_directory
-ssh_scp_push_file
-ssh_scp_push_file64
-ssh_scp_read
-ssh_scp_request_get_filename
-ssh_scp_request_get_permissions
-ssh_scp_request_get_size
-ssh_scp_request_get_size64
-ssh_scp_request_get_warning
-ssh_scp_write
-ssh_select
-ssh_send_debug
-ssh_send_ignore
-ssh_send_issue_banner
-ssh_send_keepalive
-ssh_server_init_kex
-ssh_service_request
-ssh_session_export_known_hosts_entry
-ssh_session_get_known_hosts_entry
-ssh_session_has_known_hosts_entry
-ssh_session_is_known_server
-ssh_session_set_disconnect_message
-ssh_session_update_known_hosts
-ssh_set_agent_channel
-ssh_set_agent_socket
-ssh_set_auth_methods
-ssh_set_blocking
-ssh_set_callbacks
-ssh_set_channel_callbacks
-ssh_set_counters
-ssh_set_fd_except
-ssh_set_fd_toread
-ssh_set_fd_towrite
-ssh_set_log_callback
-ssh_set_log_level
-ssh_set_log_userdata
-ssh_set_message_callback
-ssh_set_pcap_file
-ssh_set_server_callbacks
-ssh_silent_disconnect
-ssh_string_burn
-ssh_string_copy
-ssh_string_data
-ssh_string_fill
-ssh_string_free
-ssh_string_free_char
-ssh_string_from_char
-ssh_string_get_char
-ssh_string_len
-ssh_string_new
-ssh_string_to_char
-ssh_threads_get_default
-ssh_threads_get_noop
-ssh_threads_get_pthread
-ssh_threads_set_callbacks
-ssh_try_publickey_from_file
-ssh_userauth_agent
-ssh_userauth_agent_pubkey
-ssh_userauth_autopubkey
-ssh_userauth_gssapi
-ssh_userauth_kbdint
-ssh_userauth_kbdint_getanswer
-ssh_userauth_kbdint_getinstruction
-ssh_userauth_kbdint_getname
-ssh_userauth_kbdint_getnanswers
-ssh_userauth_kbdint_getnprompts
-ssh_userauth_kbdint_getprompt
-ssh_userauth_kbdint_setanswer
-ssh_userauth_list
-ssh_userauth_none
-ssh_userauth_offer_pubkey
-ssh_userauth_password
-ssh_userauth_privatekey_file
-ssh_userauth_pubkey
-ssh_userauth_publickey
-ssh_userauth_publickey_auto
-ssh_userauth_publickey_auto_get_current_identity
-ssh_userauth_try_publickey
-ssh_version
-ssh_vlog
-ssh_write_knownhost
-string_burn
-string_copy
-string_data
-string_fill
-string_free
-string_from_char
-string_len
-string_new
-string_to_char
--- a/src/ABI/libssh-4.9.3.symbols
+++ b/src/ABI/libssh-4.9.3.symbols
@@ -1,427 +0,0 @@
-_ssh_log
-buffer_free
-buffer_get
-buffer_get_len
-buffer_new
-channel_accept_x11
-channel_change_pty_size
-channel_close
-channel_forward_accept
-channel_forward_cancel
-channel_forward_listen
-channel_free
-channel_get_exit_status
-channel_get_session
-channel_is_closed
-channel_is_eof
-channel_is_open
-channel_new
-channel_open_forward
-channel_open_session
-channel_poll
-channel_read
-channel_read_buffer
-channel_read_nonblocking
-channel_request_env
-channel_request_exec
-channel_request_pty
-channel_request_pty_size
-channel_request_send_signal
-channel_request_sftp
-channel_request_shell
-channel_request_subsystem
-channel_request_x11
-channel_select
-channel_send_eof
-channel_set_blocking
-channel_write
-channel_write_stderr
-privatekey_free
-privatekey_from_file
-publickey_free
-publickey_from_file
-publickey_from_privatekey
-publickey_to_string
-sftp_async_read
-sftp_async_read_begin
-sftp_attributes_free
-sftp_canonicalize_path
-sftp_chmod
-sftp_chown
-sftp_client_message_free
-sftp_client_message_get_data
-sftp_client_message_get_filename
-sftp_client_message_get_flags
-sftp_client_message_get_submessage
-sftp_client_message_get_type
-sftp_client_message_set_filename
-sftp_close
-sftp_closedir
-sftp_dir_eof
-sftp_extension_supported
-sftp_extensions_get_count
-sftp_extensions_get_data
-sftp_extensions_get_name
-sftp_file_set_blocking
-sftp_file_set_nonblocking
-sftp_free
-sftp_fstat
-sftp_fstatvfs
-sftp_fsync
-sftp_get_client_message
-sftp_get_error
-sftp_handle
-sftp_handle_alloc
-sftp_handle_remove
-sftp_init
-sftp_lstat
-sftp_mkdir
-sftp_new
-sftp_new_channel
-sftp_open
-sftp_opendir
-sftp_read
-sftp_readdir
-sftp_readlink
-sftp_rename
-sftp_reply_attr
-sftp_reply_data
-sftp_reply_handle
-sftp_reply_name
-sftp_reply_names
-sftp_reply_names_add
-sftp_reply_status
-sftp_rewind
-sftp_rmdir
-sftp_seek
-sftp_seek64
-sftp_send_client_message
-sftp_server_free
-sftp_server_init
-sftp_server_new
-sftp_server_version
-sftp_setstat
-sftp_stat
-sftp_statvfs
-sftp_statvfs_free
-sftp_symlink
-sftp_tell
-sftp_tell64
-sftp_unlink
-sftp_utimes
-sftp_write
-ssh_accept
-ssh_add_channel_callbacks
-ssh_auth_list
-ssh_basename
-ssh_bind_accept
-ssh_bind_accept_fd
-ssh_bind_fd_toaccept
-ssh_bind_free
-ssh_bind_get_fd
-ssh_bind_listen
-ssh_bind_new
-ssh_bind_options_parse_config
-ssh_bind_options_set
-ssh_bind_set_blocking
-ssh_bind_set_callbacks
-ssh_bind_set_fd
-ssh_blocking_flush
-ssh_buffer_add_data
-ssh_buffer_free
-ssh_buffer_get
-ssh_buffer_get_data
-ssh_buffer_get_len
-ssh_buffer_new
-ssh_buffer_reinit
-ssh_channel_accept_forward
-ssh_channel_accept_x11
-ssh_channel_cancel_forward
-ssh_channel_change_pty_size
-ssh_channel_close
-ssh_channel_free
-ssh_channel_get_exit_status
-ssh_channel_get_session
-ssh_channel_is_closed
-ssh_channel_is_eof
-ssh_channel_is_open
-ssh_channel_listen_forward
-ssh_channel_new
-ssh_channel_open_auth_agent
-ssh_channel_open_forward
-ssh_channel_open_forward_port
-ssh_channel_open_forward_unix
-ssh_channel_open_reverse_forward
-ssh_channel_open_session
-ssh_channel_open_x11
-ssh_channel_poll
-ssh_channel_poll_timeout
-ssh_channel_read
-ssh_channel_read_nonblocking
-ssh_channel_read_timeout
-ssh_channel_request_auth_agent
-ssh_channel_request_env
-ssh_channel_request_exec
-ssh_channel_request_pty
-ssh_channel_request_pty_size
-ssh_channel_request_send_break
-ssh_channel_request_send_exit_signal
-ssh_channel_request_send_exit_status
-ssh_channel_request_send_signal
-ssh_channel_request_sftp
-ssh_channel_request_shell
-ssh_channel_request_subsystem
-ssh_channel_request_x11
-ssh_channel_select
-ssh_channel_send_eof
-ssh_channel_set_blocking
-ssh_channel_set_counter
-ssh_channel_window_size
-ssh_channel_write
-ssh_channel_write_stderr
-ssh_clean_pubkey_hash
-ssh_connect
-ssh_connector_free
-ssh_connector_new
-ssh_connector_set_in_channel
-ssh_connector_set_in_fd
-ssh_connector_set_out_channel
-ssh_connector_set_out_fd
-ssh_copyright
-ssh_dirname
-ssh_disconnect
-ssh_dump_knownhost
-ssh_event_add_connector
-ssh_event_add_fd
-ssh_event_add_session
-ssh_event_dopoll
-ssh_event_free
-ssh_event_new
-ssh_event_remove_connector
-ssh_event_remove_fd
-ssh_event_remove_session
-ssh_execute_message_callbacks
-ssh_finalize
-ssh_forward_accept
-ssh_forward_cancel
-ssh_forward_listen
-ssh_free
-ssh_get_cipher_in
-ssh_get_cipher_out
-ssh_get_clientbanner
-ssh_get_disconnect_message
-ssh_get_error
-ssh_get_error_code
-ssh_get_fd
-ssh_get_fingerprint_hash
-ssh_get_hexa
-ssh_get_hmac_in
-ssh_get_hmac_out
-ssh_get_issue_banner
-ssh_get_kex_algo
-ssh_get_log_callback
-ssh_get_log_level
-ssh_get_log_userdata
-ssh_get_openssh_version
-ssh_get_poll_flags
-ssh_get_pubkey
-ssh_get_pubkey_hash
-ssh_get_publickey
-ssh_get_publickey_hash
-ssh_get_random
-ssh_get_server_publickey
-ssh_get_serverbanner
-ssh_get_status
-ssh_get_version
-ssh_getpass
-ssh_gssapi_get_creds
-ssh_gssapi_set_creds
-ssh_handle_key_exchange
-ssh_init
-ssh_is_blocking
-ssh_is_connected
-ssh_is_server_known
-ssh_key_cmp
-ssh_key_dup
-ssh_key_free
-ssh_key_is_private
-ssh_key_is_public
-ssh_key_new
-ssh_key_type
-ssh_key_type_from_name
-ssh_key_type_to_char
-ssh_known_hosts_parse_line
-ssh_knownhosts_entry_free
-ssh_log
-ssh_message_auth_interactive_request
-ssh_message_auth_kbdint_is_response
-ssh_message_auth_password
-ssh_message_auth_pubkey
-ssh_message_auth_publickey
-ssh_message_auth_publickey_state
-ssh_message_auth_reply_pk_ok
-ssh_message_auth_reply_pk_ok_simple
-ssh_message_auth_reply_success
-ssh_message_auth_set_methods
-ssh_message_auth_user
-ssh_message_channel_request_channel
-ssh_message_channel_request_command
-ssh_message_channel_request_env_name
-ssh_message_channel_request_env_value
-ssh_message_channel_request_open_destination
-ssh_message_channel_request_open_destination_port
-ssh_message_channel_request_open_originator
-ssh_message_channel_request_open_originator_port
-ssh_message_channel_request_open_reply_accept
-ssh_message_channel_request_open_reply_accept_channel
-ssh_message_channel_request_pty_height
-ssh_message_channel_request_pty_pxheight
-ssh_message_channel_request_pty_pxwidth
-ssh_message_channel_request_pty_term
-ssh_message_channel_request_pty_width
-ssh_message_channel_request_reply_success
-ssh_message_channel_request_subsystem
-ssh_message_channel_request_x11_auth_cookie
-ssh_message_channel_request_x11_auth_protocol
-ssh_message_channel_request_x11_screen_number
-ssh_message_channel_request_x11_single_connection
-ssh_message_free
-ssh_message_get
-ssh_message_global_request_address
-ssh_message_global_request_port
-ssh_message_global_request_reply_success
-ssh_message_reply_default
-ssh_message_retrieve
-ssh_message_service_reply_success
-ssh_message_service_service
-ssh_message_subtype
-ssh_message_type
-ssh_mkdir
-ssh_new
-ssh_options_copy
-ssh_options_get
-ssh_options_get_port
-ssh_options_getopt
-ssh_options_parse_config
-ssh_options_set
-ssh_pcap_file_close
-ssh_pcap_file_free
-ssh_pcap_file_new
-ssh_pcap_file_open
-ssh_pki_copy_cert_to_privkey
-ssh_pki_export_privkey_base64
-ssh_pki_export_privkey_file
-ssh_pki_export_privkey_to_pubkey
-ssh_pki_export_pubkey_base64
-ssh_pki_export_pubkey_file
-ssh_pki_generate
-ssh_pki_import_cert_base64
-ssh_pki_import_cert_file
-ssh_pki_import_privkey_base64
-ssh_pki_import_privkey_file
-ssh_pki_import_pubkey_base64
-ssh_pki_import_pubkey_file
-ssh_pki_key_ecdsa_name
-ssh_print_hash
-ssh_print_hexa
-ssh_privatekey_type
-ssh_publickey_to_file
-ssh_remove_channel_callbacks
-ssh_scp_accept_request
-ssh_scp_close
-ssh_scp_deny_request
-ssh_scp_free
-ssh_scp_init
-ssh_scp_leave_directory
-ssh_scp_new
-ssh_scp_pull_request
-ssh_scp_push_directory
-ssh_scp_push_file
-ssh_scp_push_file64
-ssh_scp_read
-ssh_scp_request_get_filename
-ssh_scp_request_get_permissions
-ssh_scp_request_get_size
-ssh_scp_request_get_size64
-ssh_scp_request_get_warning
-ssh_scp_write
-ssh_select
-ssh_send_debug
-ssh_send_ignore
-ssh_send_issue_banner
-ssh_send_keepalive
-ssh_server_init_kex
-ssh_service_request
-ssh_session_export_known_hosts_entry
-ssh_session_get_known_hosts_entry
-ssh_session_has_known_hosts_entry
-ssh_session_is_known_server
-ssh_session_set_disconnect_message
-ssh_session_update_known_hosts
-ssh_set_agent_channel
-ssh_set_agent_socket
-ssh_set_auth_methods
-ssh_set_blocking
-ssh_set_callbacks
-ssh_set_channel_callbacks
-ssh_set_counters
-ssh_set_fd_except
-ssh_set_fd_toread
-ssh_set_fd_towrite
-ssh_set_log_callback
-ssh_set_log_level
-ssh_set_log_userdata
-ssh_set_message_callback
-ssh_set_pcap_file
-ssh_set_server_callbacks
-ssh_silent_disconnect
-ssh_string_burn
-ssh_string_copy
-ssh_string_data
-ssh_string_fill
-ssh_string_free
-ssh_string_free_char
-ssh_string_from_char
-ssh_string_get_char
-ssh_string_len
-ssh_string_new
-ssh_string_to_char
-ssh_threads_get_default
-ssh_threads_get_noop
-ssh_threads_get_pthread
-ssh_threads_set_callbacks
-ssh_try_publickey_from_file
-ssh_userauth_agent
-ssh_userauth_agent_pubkey
-ssh_userauth_autopubkey
-ssh_userauth_gssapi
-ssh_userauth_kbdint
-ssh_userauth_kbdint_getanswer
-ssh_userauth_kbdint_getinstruction
-ssh_userauth_kbdint_getname
-ssh_userauth_kbdint_getnanswers
-ssh_userauth_kbdint_getnprompts
-ssh_userauth_kbdint_getprompt
-ssh_userauth_kbdint_setanswer
-ssh_userauth_list
-ssh_userauth_none
-ssh_userauth_offer_pubkey
-ssh_userauth_password
-ssh_userauth_privatekey_file
-ssh_userauth_pubkey
-ssh_userauth_publickey
-ssh_userauth_publickey_auto
-ssh_userauth_publickey_auto_get_current_identity
-ssh_userauth_try_publickey
-ssh_version
-ssh_vlog
-ssh_write_knownhost
-string_burn
-string_copy
-string_data
-string_fill
-string_free
-string_from_char
-string_len
-string_new
-string_to_char
--- a/src/ABI/libssh-4.9.4.symbols
+++ b/src/ABI/libssh-4.9.4.symbols
@@ -1,427 +0,0 @@
-_ssh_log
-buffer_free
-buffer_get
-buffer_get_len
-buffer_new
-channel_accept_x11
-channel_change_pty_size
-channel_close
-channel_forward_accept
-channel_forward_cancel
-channel_forward_listen
-channel_free
-channel_get_exit_status
-channel_get_session
-channel_is_closed
-channel_is_eof
-channel_is_open
-channel_new
-channel_open_forward
-channel_open_session
-channel_poll
-channel_read
-channel_read_buffer
-channel_read_nonblocking
-channel_request_env
-channel_request_exec
-channel_request_pty
-channel_request_pty_size
-channel_request_send_signal
-channel_request_sftp
-channel_request_shell
-channel_request_subsystem
-channel_request_x11
-channel_select
-channel_send_eof
-channel_set_blocking
-channel_write
-channel_write_stderr
-privatekey_free
-privatekey_from_file
-publickey_free
-publickey_from_file
-publickey_from_privatekey
-publickey_to_string
-sftp_async_read
-sftp_async_read_begin
-sftp_attributes_free
-sftp_canonicalize_path
-sftp_chmod
-sftp_chown
-sftp_client_message_free
-sftp_client_message_get_data
-sftp_client_message_get_filename
-sftp_client_message_get_flags
-sftp_client_message_get_submessage
-sftp_client_message_get_type
-sftp_client_message_set_filename
-sftp_close
-sftp_closedir
-sftp_dir_eof
-sftp_extension_supported
-sftp_extensions_get_count
-sftp_extensions_get_data
-sftp_extensions_get_name
-sftp_file_set_blocking
-sftp_file_set_nonblocking
-sftp_free
-sftp_fstat
-sftp_fstatvfs
-sftp_fsync
-sftp_get_client_message
-sftp_get_error
-sftp_handle
-sftp_handle_alloc
-sftp_handle_remove
-sftp_init
-sftp_lstat
-sftp_mkdir
-sftp_new
-sftp_new_channel
-sftp_open
-sftp_opendir
-sftp_read
-sftp_readdir
-sftp_readlink
-sftp_rename
-sftp_reply_attr
-sftp_reply_data
-sftp_reply_handle
-sftp_reply_name
-sftp_reply_names
-sftp_reply_names_add
-sftp_reply_status
-sftp_rewind
-sftp_rmdir
-sftp_seek
-sftp_seek64
-sftp_send_client_message
-sftp_server_free
-sftp_server_init
-sftp_server_new
-sftp_server_version
-sftp_setstat
-sftp_stat
-sftp_statvfs
-sftp_statvfs_free
-sftp_symlink
-sftp_tell
-sftp_tell64
-sftp_unlink
-sftp_utimes
-sftp_write
-ssh_accept
-ssh_add_channel_callbacks
-ssh_auth_list
-ssh_basename
-ssh_bind_accept
-ssh_bind_accept_fd
-ssh_bind_fd_toaccept
-ssh_bind_free
-ssh_bind_get_fd
-ssh_bind_listen
-ssh_bind_new
-ssh_bind_options_parse_config
-ssh_bind_options_set
-ssh_bind_set_blocking
-ssh_bind_set_callbacks
-ssh_bind_set_fd
-ssh_blocking_flush
-ssh_buffer_add_data
-ssh_buffer_free
-ssh_buffer_get
-ssh_buffer_get_data
-ssh_buffer_get_len
-ssh_buffer_new
-ssh_buffer_reinit
-ssh_channel_accept_forward
-ssh_channel_accept_x11
-ssh_channel_cancel_forward
-ssh_channel_change_pty_size
-ssh_channel_close
-ssh_channel_free
-ssh_channel_get_exit_status
-ssh_channel_get_session
-ssh_channel_is_closed
-ssh_channel_is_eof
-ssh_channel_is_open
-ssh_channel_listen_forward
-ssh_channel_new
-ssh_channel_open_auth_agent
-ssh_channel_open_forward
-ssh_channel_open_forward_port
-ssh_channel_open_forward_unix
-ssh_channel_open_reverse_forward
-ssh_channel_open_session
-ssh_channel_open_x11
-ssh_channel_poll
-ssh_channel_poll_timeout
-ssh_channel_read
-ssh_channel_read_nonblocking
-ssh_channel_read_timeout
-ssh_channel_request_auth_agent
-ssh_channel_request_env
-ssh_channel_request_exec
-ssh_channel_request_pty
-ssh_channel_request_pty_size
-ssh_channel_request_send_break
-ssh_channel_request_send_exit_signal
-ssh_channel_request_send_exit_status
-ssh_channel_request_send_signal
-ssh_channel_request_sftp
-ssh_channel_request_shell
-ssh_channel_request_subsystem
-ssh_channel_request_x11
-ssh_channel_select
-ssh_channel_send_eof
-ssh_channel_set_blocking
-ssh_channel_set_counter
-ssh_channel_window_size
-ssh_channel_write
-ssh_channel_write_stderr
-ssh_clean_pubkey_hash
-ssh_connect
-ssh_connector_free
-ssh_connector_new
-ssh_connector_set_in_channel
-ssh_connector_set_in_fd
-ssh_connector_set_out_channel
-ssh_connector_set_out_fd
-ssh_copyright
-ssh_dirname
-ssh_disconnect
-ssh_dump_knownhost
-ssh_event_add_connector
-ssh_event_add_fd
-ssh_event_add_session
-ssh_event_dopoll
-ssh_event_free
-ssh_event_new
-ssh_event_remove_connector
-ssh_event_remove_fd
-ssh_event_remove_session
-ssh_execute_message_callbacks
-ssh_finalize
-ssh_forward_accept
-ssh_forward_cancel
-ssh_forward_listen
-ssh_free
-ssh_get_cipher_in
-ssh_get_cipher_out
-ssh_get_clientbanner
-ssh_get_disconnect_message
-ssh_get_error
-ssh_get_error_code
-ssh_get_fd
-ssh_get_fingerprint_hash
-ssh_get_hexa
-ssh_get_hmac_in
-ssh_get_hmac_out
-ssh_get_issue_banner
-ssh_get_kex_algo
-ssh_get_log_callback
-ssh_get_log_level
-ssh_get_log_userdata
-ssh_get_openssh_version
-ssh_get_poll_flags
-ssh_get_pubkey
-ssh_get_pubkey_hash
-ssh_get_publickey
-ssh_get_publickey_hash
-ssh_get_random
-ssh_get_server_publickey
-ssh_get_serverbanner
-ssh_get_status
-ssh_get_version
-ssh_getpass
-ssh_gssapi_get_creds
-ssh_gssapi_set_creds
-ssh_handle_key_exchange
-ssh_init
-ssh_is_blocking
-ssh_is_connected
-ssh_is_server_known
-ssh_key_cmp
-ssh_key_dup
-ssh_key_free
-ssh_key_is_private
-ssh_key_is_public
-ssh_key_new
-ssh_key_type
-ssh_key_type_from_name
-ssh_key_type_to_char
-ssh_known_hosts_parse_line
-ssh_knownhosts_entry_free
-ssh_log
-ssh_message_auth_interactive_request
-ssh_message_auth_kbdint_is_response
-ssh_message_auth_password
-ssh_message_auth_pubkey
-ssh_message_auth_publickey
-ssh_message_auth_publickey_state
-ssh_message_auth_reply_pk_ok
-ssh_message_auth_reply_pk_ok_simple
-ssh_message_auth_reply_success
-ssh_message_auth_set_methods
-ssh_message_auth_user
-ssh_message_channel_request_channel
-ssh_message_channel_request_command
-ssh_message_channel_request_env_name
-ssh_message_channel_request_env_value
-ssh_message_channel_request_open_destination
-ssh_message_channel_request_open_destination_port
-ssh_message_channel_request_open_originator
-ssh_message_channel_request_open_originator_port
-ssh_message_channel_request_open_reply_accept
-ssh_message_channel_request_open_reply_accept_channel
-ssh_message_channel_request_pty_height
-ssh_message_channel_request_pty_pxheight
-ssh_message_channel_request_pty_pxwidth
-ssh_message_channel_request_pty_term
-ssh_message_channel_request_pty_width
-ssh_message_channel_request_reply_success
-ssh_message_channel_request_subsystem
-ssh_message_channel_request_x11_auth_cookie
-ssh_message_channel_request_x11_auth_protocol
-ssh_message_channel_request_x11_screen_number
-ssh_message_channel_request_x11_single_connection
-ssh_message_free
-ssh_message_get
-ssh_message_global_request_address
-ssh_message_global_request_port
-ssh_message_global_request_reply_success
-ssh_message_reply_default
-ssh_message_retrieve
-ssh_message_service_reply_success
-ssh_message_service_service
-ssh_message_subtype
-ssh_message_type
-ssh_mkdir
-ssh_new
-ssh_options_copy
-ssh_options_get
-ssh_options_get_port
-ssh_options_getopt
-ssh_options_parse_config
-ssh_options_set
-ssh_pcap_file_close
-ssh_pcap_file_free
-ssh_pcap_file_new
-ssh_pcap_file_open
-ssh_pki_copy_cert_to_privkey
-ssh_pki_export_privkey_base64
-ssh_pki_export_privkey_file
-ssh_pki_export_privkey_to_pubkey
-ssh_pki_export_pubkey_base64
-ssh_pki_export_pubkey_file
-ssh_pki_generate
-ssh_pki_import_cert_base64
-ssh_pki_import_cert_file
-ssh_pki_import_privkey_base64
-ssh_pki_import_privkey_file
-ssh_pki_import_pubkey_base64
-ssh_pki_import_pubkey_file
-ssh_pki_key_ecdsa_name
-ssh_print_hash
-ssh_print_hexa
-ssh_privatekey_type
-ssh_publickey_to_file
-ssh_remove_channel_callbacks
-ssh_scp_accept_request
-ssh_scp_close
-ssh_scp_deny_request
-ssh_scp_free
-ssh_scp_init
-ssh_scp_leave_directory
-ssh_scp_new
-ssh_scp_pull_request
-ssh_scp_push_directory
-ssh_scp_push_file
-ssh_scp_push_file64
-ssh_scp_read
-ssh_scp_request_get_filename
-ssh_scp_request_get_permissions
-ssh_scp_request_get_size
-ssh_scp_request_get_size64
-ssh_scp_request_get_warning
-ssh_scp_write
-ssh_select
-ssh_send_debug
-ssh_send_ignore
-ssh_send_issue_banner
-ssh_send_keepalive
-ssh_server_init_kex
-ssh_service_request
-ssh_session_export_known_hosts_entry
-ssh_session_get_known_hosts_entry
-ssh_session_has_known_hosts_entry
-ssh_session_is_known_server
-ssh_session_set_disconnect_message
-ssh_session_update_known_hosts
-ssh_set_agent_channel
-ssh_set_agent_socket
-ssh_set_auth_methods
-ssh_set_blocking
-ssh_set_callbacks
-ssh_set_channel_callbacks
-ssh_set_counters
-ssh_set_fd_except
-ssh_set_fd_toread
-ssh_set_fd_towrite
-ssh_set_log_callback
-ssh_set_log_level
-ssh_set_log_userdata
-ssh_set_message_callback
-ssh_set_pcap_file
-ssh_set_server_callbacks
-ssh_silent_disconnect
-ssh_string_burn
-ssh_string_copy
-ssh_string_data
-ssh_string_fill
-ssh_string_free
-ssh_string_free_char
-ssh_string_from_char
-ssh_string_get_char
-ssh_string_len
-ssh_string_new
-ssh_string_to_char
-ssh_threads_get_default
-ssh_threads_get_noop
-ssh_threads_get_pthread
-ssh_threads_set_callbacks
-ssh_try_publickey_from_file
-ssh_userauth_agent
-ssh_userauth_agent_pubkey
-ssh_userauth_autopubkey
-ssh_userauth_gssapi
-ssh_userauth_kbdint
-ssh_userauth_kbdint_getanswer
-ssh_userauth_kbdint_getinstruction
-ssh_userauth_kbdint_getname
-ssh_userauth_kbdint_getnanswers
-ssh_userauth_kbdint_getnprompts
-ssh_userauth_kbdint_getprompt
-ssh_userauth_kbdint_setanswer
-ssh_userauth_list
-ssh_userauth_none
-ssh_userauth_offer_pubkey
-ssh_userauth_password
-ssh_userauth_privatekey_file
-ssh_userauth_pubkey
-ssh_userauth_publickey
-ssh_userauth_publickey_auto
-ssh_userauth_publickey_auto_get_current_identity
-ssh_userauth_try_publickey
-ssh_version
-ssh_vlog
-ssh_write_knownhost
-string_burn
-string_copy
-string_data
-string_fill
-string_free
-string_from_char
-string_len
-string_new
-string_to_char
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,7 +1,9 @@
-set(LIBSSH_PUBLIC_INCLUDE_DIRS ${libssh_SOURCE_DIR}/include)
+set(LIBSSH_PUBLIC_INCLUDE_DIRS
+  ${libssh_SOURCE_DIR}/include
+  CACHE INTERNAL "libssh public include directories"
+)

 set(LIBSSH_PRIVATE_INCLUDE_DIRS
-  ${libssh_BINARY_DIR}/include
  ${libssh_BINARY_DIR}
 )

@@ -9,7 +11,21 @@ set(LIBSSH_LINK_LIBRARIES
  ${LIBSSH_REQUIRED_LIBRARIES}
 )

-if (OPENSSL_CRYPTO_LIBRARIES)
+if (WIN32)
+  set(LIBSSH_LINK_LIBRARIES
+    ${LIBSSH_LINK_LIBRARIES}
+    ws2_32
+  )
+endif (WIN32)
+
+if (HAVE_LIBSOCKET)
+  set(LIBSSH_LINK_LIBRARIES
+    ${LIBSSH_LINK_LIBRARIES}
+    socket
+  )
+endif (HAVE_LIBSOCKET)
+
+if (OPENSSL_CRYPTO_LIBRARY)
  set(LIBSSH_PRIVATE_INCLUDE_DIRS
    ${LIBSSH_PRIVATE_INCLUDE_DIRS}
    ${OPENSSL_INCLUDE_DIR}
@@ -17,9 +33,9 @@ if (OPENSSL_CRYPTO_LIBRARIES)

  set(LIBSSH_LINK_LIBRARIES
    ${LIBSSH_LINK_LIBRARIES}
-    ${OPENSSL_CRYPTO_LIBRARIES}
+    ${OPENSSL_CRYPTO_LIBRARY}
  )
-endif (OPENSSL_CRYPTO_LIBRARIES)
+endif (OPENSSL_CRYPTO_LIBRARY)

 if (MBEDTLS_CRYPTO_LIBRARY)
    set(LIBSSH_PRIVATE_INCLUDE_DIRS
@@ -79,21 +95,15 @@ if (WITH_NACL AND NACL_FOUND)
  )
 endif (WITH_NACL AND NACL_FOUND)

-if (MINGW AND Threads_FOUND)
-  set(LIBSSH_LINK_LIBRARIES
-    ${LIBSSH_LINK_LIBRARIES}
-    Threads::Threads
-  )
-endif()
+set(LIBSSH_LINK_LIBRARIES
+  ${LIBSSH_LINK_LIBRARIES}
+  CACHE INTERNAL "libssh link libraries"
+)

-# This needs to be last for mingw to build
-# https://gitlab.com/libssh/libssh-mirror/-/issues/84
-if (WIN32)
-  set(LIBSSH_LINK_LIBRARIES
-    ${LIBSSH_LINK_LIBRARIES}
-    ws2_32
-  )
-endif (WIN32)
+set(LIBSSH_SHARED_LIBRARY
+  ssh_shared
+  CACHE INTERNAL "libssh shared library"
+)

 if (BUILD_STATIC_LIB)
  set(LIBSSH_STATIC_LIBRARY
@@ -114,7 +124,6 @@ set(libssh_SRCS
  config.c
  connect.c
  connector.c
-  crypto_common.c
  curve25519.c
  dh.c
  ecdh.c
@@ -146,6 +155,9 @@ set(libssh_SRCS
  wrapper.c
  external/bcrypt_pbkdf.c
  external/blowfish.c
+  external/chacha.c
+  external/poly1305.c
+  chachapoly.c
  config_parser.c
  token.c
  pki_ed25519_common.c
@@ -184,8 +196,6 @@ if (WITH_GCRYPT)
        gcrypt_missing.c
        pki_gcrypt.c
        ecdh_gcrypt.c
-        getrandom_gcrypt.c
-        md_gcrypt.c
        dh_key.c
        pki_ed25519.c
        external/ed25519.c
@@ -193,14 +203,6 @@ if (WITH_GCRYPT)
        external/ge25519.c
        external/sc25519.c
       )
-    if (NOT HAVE_GCRYPT_CHACHA_POLY)
-        set(libssh_SRCS
-            ${libssh_SRCS}
-            external/chacha.c
-            external/poly1305.c
-            chachapoly.c
-        )
-    endif (NOT HAVE_GCRYPT_CHACHA_POLY)
 elseif (WITH_MBEDTLS)
    set(libssh_SRCS
        ${libssh_SRCS}
@@ -209,8 +211,6 @@ elseif (WITH_MBEDTLS)
        mbedcrypto_missing.c
        pki_mbedcrypto.c
        ecdh_mbedcrypto.c
-        getrandom_mbedcrypto.c
-        md_mbedcrypto.c
        dh_key.c
        pki_ed25519.c
        external/ed25519.c
@@ -218,23 +218,12 @@ elseif (WITH_MBEDTLS)
        external/ge25519.c
        external/sc25519.c
       )
-    if (NOT (HAVE_MBEDTLS_CHACHA20_H AND HAVE_MBEDTLS_POLY1305_H))
-        set(libssh_SRCS
-            ${libssh_SRCS}
-            external/chacha.c
-            external/poly1305.c
-            chachapoly.c
-           )
-    endif()
-
 else (WITH_GCRYPT)
    set(libssh_SRCS
        ${libssh_SRCS}
        threads/libcrypto.c
        pki_crypto.c
        ecdh_crypto.c
-        getrandom_crypto.c
-        md_crypto.c
        libcrypto.c
        dh_crypto.c
       )
@@ -248,14 +237,6 @@ else (WITH_GCRYPT)
            external/sc25519.c
           )
    endif (NOT HAVE_OPENSSL_ED25519)
-    if (NOT (HAVE_OPENSSL_EVP_CHACHA20 AND HAVE_OPENSSL_EVP_POLY1305))
-        set(libssh_SRCS
-            ${libssh_SRCS}
-            external/chacha.c
-            external/poly1305.c
-            chachapoly.c
-        )
-    endif (NOT (HAVE_OPENSSL_EVP_CHACHA20 AND HAVE_OPENSSL_EVP_POLY1305))
    if(OPENSSL_VERSION VERSION_LESS "1.1.0")
        set(libssh_SRCS ${libssh_SRCS} libcrypto-compat.c)
    endif()
@@ -306,14 +287,19 @@ if (WITH_GSSAPI AND GSSAPI_FOUND)
 endif (WITH_GSSAPI AND GSSAPI_FOUND)

 if (NOT WITH_NACL)
-    if (NOT HAVE_LIBCRYPTO OR NOT HAVE_OPENSSL_ED25519)
+    if (NOT HAVE_OPENSSL_ED25519)
        set(libssh_SRCS
            ${libssh_SRCS}
            external/curve25519_ref.c
           )
-    endif()
+    endif (NOT HAVE_OPENSSL_ED25519)
 endif (NOT WITH_NACL)

+include_directories(
+  ${LIBSSH_PUBLIC_INCLUDE_DIRS}
+  ${LIBSSH_PRIVATE_INCLUDE_DIRS}
+)
+
 # Set the path to the default map file
 set(MAP_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.map")

@@ -345,54 +331,49 @@ if (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT AND ABIMAP_FOUND)
    )
 endif (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT AND ABIMAP_FOUND)

-# This gets built as a static library, if -DBUILD_SHARED_LIBS=OFF is passed to
-# cmake.
-add_library(ssh ${libssh_SRCS})
-target_include_directories(ssh
-                           PUBLIC
-                               $<BUILD_INTERFACE:${libssh_SOURCE_DIR}/include>
-                               $<INSTALL_INTERFACE:include>
-                           PRIVATE ${LIBSSH_PRIVATE_INCLUDE_DIRS})
+add_library(${LIBSSH_SHARED_LIBRARY} SHARED ${libssh_SRCS})
+target_compile_options(${LIBSSH_SHARED_LIBRARY}
+                       PRIVATE
+                           ${DEFAULT_C_COMPILE_FLAGS}
+                           -D_GNU_SOURCE)

-target_link_libraries(ssh
+target_link_libraries(${LIBSSH_SHARED_LIBRARY}
                      PRIVATE ${LIBSSH_LINK_LIBRARIES})

-if (WIN32 AND NOT BUILD_SHARED_LIBS)
-    target_compile_definitions(ssh PUBLIC "LIBSSH_STATIC")
-endif ()
-
-add_library(ssh::ssh ALIAS ssh)
-
 if (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT)
    if (ABIMAP_FOUND)
        # Change path to devel map file
        set(MAP_PATH "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}_dev.map")
    endif (ABIMAP_FOUND)

-    target_link_libraries(ssh PRIVATE "-Wl,--version-script,\"${MAP_PATH}\"")
+    set_target_properties(${LIBSSH_SHARED_LIBRARY}
+                          PROPERTIES LINK_FLAGS
+                          "-Wl,--version-script,\"${MAP_PATH}\"")
 endif (WITH_SYMBOL_VERSIONING AND HAVE_LD_VERSION_SCRIPT)

-set_target_properties(ssh
+set_target_properties(
+  ${LIBSSH_SHARED_LIBRARY}
    PROPERTIES
      VERSION
        ${LIBRARY_VERSION}
      SOVERSION
        ${LIBRARY_SOVERSION}
+      OUTPUT_NAME
+        ssh
      DEFINE_SYMBOL
        LIBSSH_EXPORTS
 )

 if (WITH_VISIBILITY_HIDDEN)
-    set_target_properties(ssh PROPERTIES C_VISIBILITY_PRESET hidden)
+  set_target_properties(${LIBSSH_SHARED_LIBRARY} PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
 endif (WITH_VISIBILITY_HIDDEN)

 if (MINGW)
-    target_link_libraries(ssh PRIVATE "-Wl,--enable-stdcall-fixup")
-    target_compile_definitions(ssh PRIVATE "_POSIX_SOURCE")
+    set_target_properties(${LIBSSH_SHARED_LIBRARY} PROPERTIES LINK_FLAGS "-Wl,--enable-stdcall-fixup")
 endif ()


-install(TARGETS ssh
+install(TARGETS ${LIBSSH_SHARED_LIBRARY}
        EXPORT libssh-config
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -403,16 +384,14 @@ install(EXPORT libssh-config
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})

 if (BUILD_STATIC_LIB)
-  add_library(ssh-static STATIC ${libssh_SRCS})
+  add_library(${LIBSSH_STATIC_LIBRARY} STATIC ${libssh_SRCS})
+  target_compile_options(${LIBSSH_STATIC_LIBRARY}
+                         PRIVATE
+                            ${DEFAULT_C_COMPILE_FLAGS}
+                            -D_GNU_SOURCE)

-  target_include_directories(ssh-static
-                             PUBLIC
-                                 $<BUILD_INTERFACE:${libssh_SOURCE_DIR}/include>
-                                 $<INSTALL_INTERFACE:include>
-                             PRIVATE ${LIBSSH_PRIVATE_INCLUDE_DIRS})
-  target_link_libraries(ssh-static
+  target_link_libraries(${LIBSSH_STATIC_LIBRARY}
                        PUBLIC ${LIBSSH_LINK_LIBRARIES})
-  add_library(ssh::static ALIAS ssh-static)

  if (MSVC)
    set(OUTPUT_SUFFIX static)
@@ -420,7 +399,7 @@ if (BUILD_STATIC_LIB)
    set(OUTPUT_SUFFIX )
  endif (MSVC)
  set_target_properties(
-    ssh-static
+    ${LIBSSH_STATIC_LIBRARY}
      PROPERTIES
        VERSION
          ${LIBRARY_VERSION}
@@ -433,8 +412,22 @@ if (BUILD_STATIC_LIB)
  )

  if (WIN32)
-    target_compile_definitions(ssh-static PUBLIC "LIBSSH_STATIC")
+    set_target_properties(
+      ${LIBSSH_STATIC_LIBRARY}
+        PROPERTIES
+          COMPILE_FLAGS
+            "-DLIBSSH_STATIC"
+    )
  endif (WIN32)
+
+    if (WITH_STATIC_LIB)
+      install(TARGETS
+                ${LIBSSH_STATIC_LIBRARY}
+              DESTINATION
+                  ${CMAKE_INSTALL_LIBDIR}/${OUTPUT_SUFFIX}
+              COMPONENT
+                libraries)
+    endif (WITH_STATIC_LIB)
 endif (BUILD_STATIC_LIB)

 message(STATUS "Threads_FOUND=${Threads_FOUND}")
--- a/src/agent.c
+++ b/src/agent.c
@@ -33,6 +33,8 @@
 *    the agent returns the signed data
 */

+#ifndef _WIN32
+
 #include "config.h"

 #include <stdlib.h>
@@ -44,14 +46,8 @@
 #include <unistd.h>
 #endif

-#ifndef _WIN32
 #include <netinet/in.h>
 #include <arpa/inet.h>
-#include <sys/socket.h>
-#else
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#endif

 #include "libssh/agent.h"
 #include "libssh/priv.h"
@@ -67,9 +63,9 @@
  (((x) == SSH_AGENT_FAILURE) || ((x) == SSH_COM_AGENT2_FAILURE) || \
   ((x) == SSH2_AGENT_FAILURE))

-static uint32_t atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n, int do_read) {
+static size_t atomicio(struct ssh_agent_struct *agent, void *buf, size_t n, int do_read) {
  char *b = buf;
-  uint32_t pos = 0;
+  size_t pos = 0;
  ssize_t res;
  ssh_pollfd_t pfd;
  ssh_channel channel = agent->channel;
@@ -83,9 +79,9 @@ static uint32_t atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n,

    while (n > pos) {
      if (do_read) {
-        res = recv(fd, b + pos, n - pos, 0);
+        res = read(fd, b + pos, n - pos);
      } else {
-        res = send(fd, b + pos, n - pos, 0);
+        res = write(fd, b + pos, n - pos);
      }
      switch (res) {
      case -1:
@@ -106,7 +102,7 @@ static uint32_t atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n,
        errno = do_read ? 0 : EPIPE;
        return pos;
      default:
-        pos += (uint32_t) res;
+        pos += (size_t) res;
        }
      }
      return pos;
@@ -121,7 +117,7 @@ static uint32_t atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n,
          continue;
        if (res == SSH_ERROR)
          return 0;
-        pos += (uint32_t)res;
+        pos += (size_t)res;
      }
      return pos;
    }
@@ -200,7 +196,7 @@ void ssh_agent_close(struct ssh_agent_struct *agent) {
 void ssh_agent_free(ssh_agent agent) {
  if (agent) {
    if (agent->ident) {
-      SSH_BUFFER_FREE(agent->ident);
+      ssh_buffer_free(agent->ident);
    }
    if (agent->sock) {
      ssh_agent_close(agent);
@@ -220,8 +216,7 @@ static int agent_connect(ssh_session session) {
  if (session->agent->channel != NULL)
    return 0;

-  auth_sock = session->opts.agent_socket ?
-    session->opts.agent_socket : getenv("SSH_AUTH_SOCK");
+  auth_sock = getenv("SSH_AUTH_SOCK");

  if (auth_sock && *auth_sock) {
    if (ssh_socket_unix(session->agent->sock, auth_sock) < 0) {
@@ -256,9 +251,7 @@ static int agent_decode_reply(struct ssh_session_struct *session, int type) {
 static int agent_talk(struct ssh_session_struct *session,
    struct ssh_buffer_struct *request, struct ssh_buffer_struct *reply) {
  uint32_t len = 0;
-  uint8_t tmpbuf[4];
-  uint8_t *payload = tmpbuf;
-  char err_msg[SSH_ERRNO_MSG_MAX] = {0};
+  uint8_t payload[1024] = {0};

  len = ssh_buffer_get_len(request);
  SSH_LOG(SSH_LOG_TRACE, "Request length: %u", len);
@@ -269,20 +262,20 @@ static int agent_talk(struct ssh_session_struct *session,
    if (atomicio(session->agent, ssh_buffer_get(request), len, 0)
        != len) {
      SSH_LOG(SSH_LOG_WARN, "atomicio sending request failed: %s",
-          ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+          strerror(errno));
      return -1;
    }
  } else {
    SSH_LOG(SSH_LOG_WARN,
        "atomicio sending request length failed: %s",
-        ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+        strerror(errno));
    return -1;
  }

  /* wait for response, read the length of the response packet */
  if (atomicio(session->agent, payload, 4, 1) != 4) {
    SSH_LOG(SSH_LOG_WARN, "atomicio read response length failed: %s",
-        ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+        strerror(errno));
    return -1;
  }

@@ -294,111 +287,113 @@ static int agent_talk(struct ssh_session_struct *session,
  }
  SSH_LOG(SSH_LOG_TRACE, "Response length: %u", len);

-  payload = ssh_buffer_allocate(reply, len);
-  if (payload == NULL) {
-    SSH_LOG(SSH_LOG_WARN, "Not enough space");
-    return -1;
-  }
-
-  if (atomicio(session->agent, payload, len, 1) != len) {
-    SSH_LOG(SSH_LOG_WARN,
-        "Error reading response from authentication socket.");
-    /* Rollback the unused space */
-    ssh_buffer_pass_bytes_end(reply, len);
-    return -1;
+  while (len > 0) {
+    size_t n = len;
+    if (n > sizeof(payload)) {
+      n = sizeof(payload);
+    }
+    if (atomicio(session->agent, payload, n, 1) != n) {
+      SSH_LOG(SSH_LOG_WARN,
+          "Error reading response from authentication socket.");
+      return -1;
+    }
+    if (ssh_buffer_add_data(reply, payload, n) < 0) {
+      SSH_LOG(SSH_LOG_WARN, "Not enough space");
+      return -1;
+    }
+    len -= n;
  }

  return 0;
 }

-uint32_t ssh_agent_get_ident_count(struct ssh_session_struct *session)
-{
-    ssh_buffer request = NULL;
-    ssh_buffer reply = NULL;
-    unsigned int type = 0;
-    uint32_t count = 0;
-    uint32_t rc;
+int ssh_agent_get_ident_count(struct ssh_session_struct *session) {
+  ssh_buffer request = NULL;
+  ssh_buffer reply = NULL;
+  unsigned int type = 0;
+  uint32_t count = 0;
+  int rc;

-    /* send message to the agent requesting the list of identities */
-    request = ssh_buffer_new();
-    if (request == NULL) {
-        ssh_set_error_oom(session);
-        return 0;
-    }
-    if (ssh_buffer_add_u8(request, SSH2_AGENTC_REQUEST_IDENTITIES) < 0) {
-        ssh_set_error_oom(session);
-        SSH_BUFFER_FREE(request);
-        return 0;
-    }
+  /* send message to the agent requesting the list of identities */
+  request = ssh_buffer_new();
+  if (request == NULL) {
+      ssh_set_error_oom(session);
+      return -1;
+  }
+  if (ssh_buffer_add_u8(request, SSH2_AGENTC_REQUEST_IDENTITIES) < 0) {
+      ssh_set_error_oom(session);
+      ssh_buffer_free(request);
+      return -1;
+  }

-    reply = ssh_buffer_new();
-    if (reply == NULL) {
-        SSH_BUFFER_FREE(request);
-        ssh_set_error(session, SSH_FATAL, "Not enough space");
-        return 0;
-    }
+  reply = ssh_buffer_new();
+  if (reply == NULL) {
+    ssh_buffer_free(request);
+    ssh_set_error(session, SSH_FATAL, "Not enough space");
+    return -1;
+  }

-    if (agent_talk(session, request, reply) < 0) {
-        SSH_BUFFER_FREE(request);
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    }
-    SSH_BUFFER_FREE(request);
+  if (agent_talk(session, request, reply) < 0) {
+    ssh_buffer_free(request);
+    ssh_buffer_free(reply);
+    return 0;
+  }
+  ssh_buffer_free(request);

-    /* get message type and verify the answer */
-    rc = ssh_buffer_get_u8(reply, (uint8_t *) &type);
-    if (rc != sizeof(uint8_t)) {
-        ssh_set_error(session, SSH_FATAL,
-                "Bad authentication reply size: %d", rc);
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    }
+  /* get message type and verify the answer */
+  rc = ssh_buffer_get_u8(reply, (uint8_t *) &type);
+  if (rc != sizeof(uint8_t)) {
+    ssh_set_error(session, SSH_FATAL,
+        "Bad authentication reply size: %d", rc);
+    ssh_buffer_free(reply);
+    return -1;
+  }
 #ifdef WORDS_BIGENDIAN
-    type = bswap_32(type);
+  type = bswap_32(type);
 #endif

-    SSH_LOG(SSH_LOG_WARN,
-            "Answer type: %d, expected answer: %d",
-            type, SSH2_AGENT_IDENTITIES_ANSWER);
+  SSH_LOG(SSH_LOG_WARN,
+      "Answer type: %d, expected answer: %d",
+      type, SSH2_AGENT_IDENTITIES_ANSWER);

-    if (agent_failed(type)) {
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    } else if (type != SSH2_AGENT_IDENTITIES_ANSWER) {
-        ssh_set_error(session, SSH_FATAL,
-                "Bad authentication reply message type: %u", type);
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    }
+  if (agent_failed(type)) {
+      ssh_buffer_free(reply);
+      return 0;
+  } else if (type != SSH2_AGENT_IDENTITIES_ANSWER) {
+      ssh_set_error(session, SSH_FATAL,
+          "Bad authentication reply message type: %u", type);
+      ssh_buffer_free(reply);
+      return -1;
+  }

-    rc = ssh_buffer_get_u32(reply, &count);
-    if (rc != 4) {
-        ssh_set_error(session,
-                SSH_FATAL,
-                "Failed to read count");
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    }
-    session->agent->count = ntohl(count);
-    SSH_LOG(SSH_LOG_DEBUG, "Agent count: %d",
-            session->agent->count);
-    if (session->agent->count > 1024) {
-        ssh_set_error(session, SSH_FATAL,
-                "Too many identities in authentication reply: %d",
-                session->agent->count);
-        SSH_BUFFER_FREE(reply);
-        return 0;
-    }
+  rc = ssh_buffer_get_u32(reply, &count);
+  if (rc != 4) {
+      ssh_set_error(session,
+                    SSH_FATAL,
+                    "Failed to read count");
+      ssh_buffer_free(reply);
+      return -1;
+  }
+  session->agent->count = ntohl(count);
+  SSH_LOG(SSH_LOG_DEBUG, "Agent count: %d",
+      session->agent->count);
+  if (session->agent->count > 1024) {
+    ssh_set_error(session, SSH_FATAL,
+        "Too many identities in authentication reply: %d",
+        session->agent->count);
+    ssh_buffer_free(reply);
+    return -1;
+  }

-    if (session->agent->ident) {
-        ssh_buffer_reinit(session->agent->ident);
-    }
-    session->agent->ident = reply;
+  if (session->agent->ident) {
+    ssh_buffer_reinit(session->agent->ident);
+  }
+  session->agent->ident = reply;

-    return session->agent->count;
+  return session->agent->count;
 }

-/* caller has to free comment */
+/* caller has to free commment */
 ssh_key ssh_agent_get_first_ident(struct ssh_session_struct *session,
                              char **comment) {
    if (ssh_agent_get_ident_count(session) > 0) {
@@ -408,7 +403,7 @@ ssh_key ssh_agent_get_first_ident(struct ssh_session_struct *session,
    return NULL;
 }

-/* caller has to free comment */
+/* caller has to free commment */
 ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
    char **comment) {
    struct ssh_key_struct *key;
@@ -429,7 +424,7 @@ ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
    /* get the comment */
    tmp = ssh_buffer_get_ssh_string(session->agent->ident);
    if (tmp == NULL) {
-        SSH_STRING_FREE(blob);
+        ssh_string_free(blob);

        return NULL;
    }
@@ -437,12 +432,12 @@ ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
    if (comment) {
        *comment = ssh_string_to_char(tmp);
    } else {
-        SSH_STRING_FREE(blob);
-        SSH_STRING_FREE(tmp);
+        ssh_string_free(blob);
+        ssh_string_free(tmp);

        return NULL;
    }
-    SSH_STRING_FREE(tmp);
+    ssh_string_free(tmp);

    /* get key from blob */
    rc = ssh_pki_import_pubkey_blob(blob, &key);
@@ -450,7 +445,7 @@ ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
        /* Try again as a cert. */
        rc = ssh_pki_import_cert_blob(blob, &key);
    }
-    SSH_STRING_FREE(blob);
+    ssh_string_free(blob);
    if (rc == SSH_ERROR) {
        return NULL;
    }
@@ -496,13 +491,13 @@ ssh_string ssh_agent_sign_data(ssh_session session,

    /* create request */
    if (ssh_buffer_add_u8(request, SSH2_AGENTC_SIGN_REQUEST) < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

    rc = ssh_pki_export_pubkey_blob(pubkey, &key_blob);
    if (rc < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

@@ -517,26 +512,26 @@ ssh_string ssh_agent_sign_data(ssh_session session,
                                  sizeof(uint32_t) * 2 +
                                  ssh_string_len(key_blob));
    if (rc < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

    /* adds len + blob */
    rc = ssh_buffer_add_ssh_string(request, key_blob);
-    SSH_STRING_FREE(key_blob);
+    ssh_string_free(key_blob);
    if (rc < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

    /* Add data */
    dlen = ssh_buffer_get_len(data);
    if (ssh_buffer_add_u32(request, htonl(dlen)) < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }
    if (ssh_buffer_add_data(request, ssh_buffer_get(data), dlen) < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

@@ -549,27 +544,27 @@ ssh_string ssh_agent_sign_data(ssh_session session,
        }
    }
    if (ssh_buffer_add_u32(request, htonl(flags)) < 0) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

    reply = ssh_buffer_new();
    if (reply == NULL) {
-        SSH_BUFFER_FREE(request);
+        ssh_buffer_free(request);
        return NULL;
    }

    /* send the request */
    if (agent_talk(session, request, reply) < 0) {
-        SSH_BUFFER_FREE(request);
-        SSH_BUFFER_FREE(reply);
+        ssh_buffer_free(request);
+        ssh_buffer_free(reply);
        return NULL;
    }
-    SSH_BUFFER_FREE(request);
+    ssh_buffer_free(request);

    /* check if reply is valid */
    if (ssh_buffer_get_u8(reply, (uint8_t *) &type) != sizeof(uint8_t)) {
-        SSH_BUFFER_FREE(reply);
+        ssh_buffer_free(reply);
        return NULL;
    }
 #ifdef WORDS_BIGENDIAN
@@ -578,19 +573,21 @@ ssh_string ssh_agent_sign_data(ssh_session session,

    if (agent_failed(type)) {
        SSH_LOG(SSH_LOG_WARN, "Agent reports failure in signing the key");
-        SSH_BUFFER_FREE(reply);
+        ssh_buffer_free(reply);
        return NULL;
    } else if (type != SSH2_AGENT_SIGN_RESPONSE) {
        ssh_set_error(session,
                      SSH_FATAL,
                      "Bad authentication response: %u",
                      type);
-        SSH_BUFFER_FREE(reply);
+        ssh_buffer_free(reply);
        return NULL;
    }

    sig_blob = ssh_buffer_get_ssh_string(reply);
-    SSH_BUFFER_FREE(reply);
+    ssh_buffer_free(reply);

    return sig_blob;
 }
+
+#endif /* _WIN32 */
--- a/src/auth.c
+++ b/src/auth.c
@@ -25,7 +25,6 @@
 #include "config.h"

 #include <stdio.h>
-#include <string.h>

 #ifndef _WIN32
 #include <netinet/in.h>
@@ -58,7 +57,7 @@
 /**
 * @internal
 *
- * @brief Ask for access to the ssh-userauth service.
+ * @brief Ask access to the ssh-userauth service.
 *
 * @param[in] session   The SSH session handle.
 *
@@ -66,8 +65,7 @@
 * @returns SSH_AGAIN on nonblocking mode, if calling that function
 * again is necessary
 */
-static int ssh_userauth_request_service(ssh_session session)
-{
+static int ssh_userauth_request_service(ssh_session session) {
    int rc;

    rc = ssh_service_request(session, "ssh-userauth");
@@ -79,8 +77,7 @@ static int ssh_userauth_request_service(ssh_session session)
    return rc;
 }

-static int ssh_auth_response_termination(void *user)
-{
+static int ssh_auth_response_termination(void *user) {
    ssh_session session = (ssh_session)user;
    switch (session->auth.state) {
        case SSH_AUTH_STATE_NONE:
@@ -141,8 +138,7 @@ static const char *ssh_auth_get_current_method(ssh_session session)
 *          SSH_AUTH_AGAIN   In nonblocking mode, call has to be made again
 *          SSH_AUTH_ERROR   Error during the process.
 */
-static int ssh_userauth_get_response(ssh_session session)
-{
+static int ssh_userauth_get_response(ssh_session session) {
    int rc = SSH_AUTH_ERROR;

    rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_USER,
@@ -208,7 +204,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_banner) {
        SSH_LOG(SSH_LOG_DEBUG,
                "Received SSH_USERAUTH_BANNER packet");
        if (session->banner != NULL)
-            SSH_STRING_FREE(session->banner);
+            ssh_string_free(session->banner);
        session->banner = banner;
    }

@@ -367,7 +363,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_pk_ok) {
 *
 * @param[in] username  Deprecated, set to NULL.
 *
- * @returns             A bitfield of the following values:
+ * @returns             A bitfield of the fllowing values:
 *                      - SSH_AUTH_METHOD_PASSWORD
 *                      - SSH_AUTH_METHOD_PUBLICKEY
 *                      - SSH_AUTH_METHOD_HOSTBASED
@@ -406,11 +402,10 @@ int ssh_userauth_list(ssh_session session, const char *username)
 * authentication. The username should only be set with ssh_options_set() only
 * before you connect to the server.
 */
-int ssh_userauth_none(ssh_session session, const char *username)
-{
+int ssh_userauth_none(ssh_session session, const char *username) {
    int rc;

-    switch (session->pending_call_state) {
+    switch(session->pending_call_state) {
        case SSH_PENDING_CALL_NONE:
            break;
        case SSH_PENDING_CALL_AUTH_NONE:
@@ -496,7 +491,6 @@ int ssh_userauth_try_publickey(ssh_session session,
 {
    ssh_string pubkey_s = NULL;
    const char *sig_type_c = NULL;
-    bool allowed;
    int rc;

    if (session == NULL) {
@@ -518,7 +512,7 @@ int ssh_userauth_try_publickey(ssh_session session,
                          SSH_FATAL,
                          "Wrong state (%d) during pending SSH call",
                          session->pending_call_state);
-            return SSH_AUTH_ERROR;
+            return SSH_ERROR;
    }

    /* Check if the given public key algorithm is allowed */
@@ -528,21 +522,13 @@ int ssh_userauth_try_publickey(ssh_session session,
                      "Invalid key type (unknown)");
        return SSH_AUTH_DENIED;
    }
-    rc = ssh_key_algorithm_allowed(session, sig_type_c);
-    if (!rc) {
+    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {
        ssh_set_error(session, SSH_REQUEST_DENIED,
                      "The key algorithm '%s' is not allowed to be used by"
                      " PUBLICKEY_ACCEPTED_TYPES configuration option",
                      sig_type_c);
        return SSH_AUTH_DENIED;
    }
-    allowed = ssh_key_size_allowed(session, pubkey);
-    if (!allowed) {
-        ssh_set_error(session, SSH_REQUEST_DENIED,
-                      "The '%s' key type of size %d is not allowed by "
-                      "RSA_MIN_SIZE", sig_type_c, ssh_key_size(pubkey));
-        return SSH_AUTH_DENIED;
-    }

    rc = ssh_userauth_request_service(session);
    if (rc == SSH_AGAIN) {
@@ -571,7 +557,7 @@ int ssh_userauth_try_publickey(ssh_session session,
        goto fail;
    }

-    SSH_STRING_FREE(pubkey_s);
+    ssh_string_free(pubkey_s);

    session->auth.current_method = SSH_AUTH_METHOD_PUBLICKEY;
    session->auth.state = SSH_AUTH_STATE_PUBKEY_OFFER_SENT;
@@ -589,7 +575,7 @@ pending:

    return rc;
 fail:
-    SSH_STRING_FREE(pubkey_s);
+    ssh_string_free(pubkey_s);
    ssh_set_error_oom(session);
    ssh_buffer_reinit(session->out_buffer);

@@ -624,7 +610,6 @@ int ssh_userauth_publickey(ssh_session session,
                           const ssh_key privkey)
 {
    ssh_string str = NULL;
-    bool allowed;
    int rc;
    const char *sig_type_c = NULL;
    enum ssh_keytypes_e key_type;
@@ -661,21 +646,13 @@ int ssh_userauth_publickey(ssh_session session,
                      "Invalid key type (unknown)");
        return SSH_AUTH_DENIED;
    }
-    rc = ssh_key_algorithm_allowed(session, sig_type_c);
-    if (!rc) {
+    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {
        ssh_set_error(session, SSH_REQUEST_DENIED,
                      "The key algorithm '%s' is not allowed to be used by"
                      " PUBLICKEY_ACCEPTED_TYPES configuration option",
                      sig_type_c);
        return SSH_AUTH_DENIED;
    }
-    allowed = ssh_key_size_allowed(session, privkey);
-    if (!allowed) {
-        ssh_set_error(session, SSH_REQUEST_DENIED,
-                      "The '%s' key type of size %d is not allowed by "
-                      "RSA_MIN_SIZE", sig_type_c, ssh_key_size(privkey));
-        return SSH_AUTH_DENIED;
-    }

    rc = ssh_userauth_request_service(session);
    if (rc == SSH_AGAIN) {
@@ -703,7 +680,7 @@ int ssh_userauth_publickey(ssh_session session,
    if (rc < 0) {
        goto fail;
    }
-    SSH_STRING_FREE(str);
+    ssh_string_free(str);

    /* Get the hash type to be used in the signature based on the key type */
    hash_type = ssh_key_type_to_hash(session, privkey->type);
@@ -715,7 +692,7 @@ int ssh_userauth_publickey(ssh_session session,
    }

    rc = ssh_buffer_add_ssh_string(session->out_buffer, str);
-    SSH_STRING_FREE(str);
+    ssh_string_free(str);
    str = NULL;
    if (rc < 0) {
        goto fail;
@@ -737,13 +714,14 @@ pending:

    return rc;
 fail:
-    SSH_STRING_FREE(str);
+    ssh_string_free(str);
    ssh_set_error_oom(session);
    ssh_buffer_reinit(session->out_buffer);

    return SSH_AUTH_ERROR;
 }

+#ifndef _WIN32
 static int ssh_userauth_agent_publickey(ssh_session session,
                                        const char *username,
                                        ssh_key pubkey)
@@ -751,7 +729,6 @@ static int ssh_userauth_agent_publickey(ssh_session session,
    ssh_string pubkey_s = NULL;
    ssh_string sig_blob = NULL;
    const char *sig_type_c = NULL;
-    bool allowed;
    int rc;

    switch(session->pending_call_state) {
@@ -787,8 +764,7 @@ static int ssh_userauth_agent_publickey(ssh_session session,
        SSH_STRING_FREE(pubkey_s);
        return SSH_AUTH_DENIED;
    }
-    rc = ssh_key_algorithm_allowed(session, sig_type_c);
-    if (!rc) {
+    if (!ssh_key_algorithm_allowed(session, sig_type_c)) {
        ssh_set_error(session, SSH_REQUEST_DENIED,
                      "The key algorithm '%s' is not allowed to be used by"
                      " PUBLICKEY_ACCEPTED_TYPES configuration option",
@@ -796,14 +772,6 @@ static int ssh_userauth_agent_publickey(ssh_session session,
        SSH_STRING_FREE(pubkey_s);
        return SSH_AUTH_DENIED;
    }
-    allowed = ssh_key_size_allowed(session, pubkey);
-    if (!allowed) {
-        ssh_set_error(session, SSH_REQUEST_DENIED,
-                      "The '%s' key type of size %d is not allowed by "
-                      "RSA_MIN_SIZE", sig_type_c, ssh_key_size(pubkey));
-        SSH_STRING_FREE(pubkey_s);
-        return SSH_AUTH_DENIED;
-    }

    /* request */
    rc = ssh_buffer_pack(session->out_buffer, "bsssbsS",
@@ -868,12 +836,11 @@ struct ssh_agent_state_struct {
 };

 /* Internal function */
-void ssh_agent_state_free(void *data)
-{
+void ssh_agent_state_free(void *data) {
    struct ssh_agent_state_struct *state = data;

    if (state) {
-        SSH_STRING_FREE_CHAR(state->comment);
+        ssh_string_free_char(state->comment);
        ssh_key_free(state->pubkey);
        free (state);
    }
@@ -902,8 +869,7 @@ void ssh_agent_state_free(void *data)
 * before you connect to the server.
 */
 int ssh_userauth_agent(ssh_session session,
-                       const char *username)
-{
+                       const char *username) {
    int rc = SSH_AUTH_ERROR;
    struct ssh_agent_state_struct *state;

@@ -952,7 +918,7 @@ int ssh_userauth_agent(ssh_session session,
            } else if (rc != SSH_AUTH_SUCCESS) {
                SSH_LOG(SSH_LOG_DEBUG,
                        "Public key of %s refused by server", state->comment);
-                SSH_STRING_FREE_CHAR(state->comment);
+                ssh_string_free_char(state->comment);
                state->comment = NULL;
                ssh_key_free(state->pubkey);
                state->pubkey = ssh_agent_get_next_ident(session, &state->comment);
@@ -968,7 +934,7 @@ int ssh_userauth_agent(ssh_session session,
            rc = ssh_userauth_agent_publickey(session, username, state->pubkey);
            if (rc == SSH_AUTH_AGAIN)
                return rc;
-            SSH_STRING_FREE_CHAR(state->comment);
+            ssh_string_free_char(state->comment);
            state->comment = NULL;
            if (rc == SSH_AUTH_ERROR || rc == SSH_AUTH_PARTIAL) {
                ssh_agent_state_free (session->agent_state);
@@ -992,6 +958,7 @@ int ssh_userauth_agent(ssh_session session,
    session->agent_state = NULL;
    return rc;
 }
+#endif

 enum ssh_auth_auto_state_e {
    SSH_AUTH_AUTO_STATE_NONE = 0,
@@ -1007,55 +974,6 @@ struct ssh_auth_auto_state_struct {
    ssh_key pubkey;
 };

-/**
- * @brief Get the identity that is currently being processed by
- * ssh_userauth_publickey_auto()
- *
- * This is meant to be used by a callback that happens as part of the
- * execution of ssh_userauth_publickey_auto().  The auth_function
- * callback might want to know which key a passphrase is needed for,
- * for example.
- *
- * @param[in]  session     The SSH session.
- *
- * @param[out] value       The value to get into. As a char**, space will be
- *                         allocated by the function for the value, it is
- *                         your responsibility to free the memory using
- *                         ssh_string_free_char().
- *
- * @return  SSH_OK on success, SSH_ERROR on error.
- */
-int ssh_userauth_publickey_auto_get_current_identity(ssh_session session,
-                                                     char** value)
-{
-    const char *id = NULL;
-
-    if (session == NULL) {
-        return SSH_ERROR;
-    }
-
-    if (value == NULL) {
-        ssh_set_error_invalid(session);
-        return SSH_ERROR;
-    }
-
-    if (session->auth.auto_state != NULL && session->auth.auto_state->it != NULL) {
-        id = session->auth.auto_state->it->data;
-    }
-
-    if (id == NULL) {
-        return SSH_ERROR;
-    }
-
-    *value = strdup(id);
-    if (*value == NULL) {
-        ssh_set_error_oom(session);
-        return SSH_ERROR;
-    }
-
-    return SSH_OK;
-}
-
 /**
 * @brief Tries to automatically authenticate with public key and "none"
 *
@@ -1076,7 +994,8 @@ int ssh_userauth_publickey_auto_get_current_identity(ssh_session session,
 *                            method.\n
 *          SSH_AUTH_PARTIAL: You've been partially authenticated, you still
 *                            have to use another method.\n
- *          SSH_AUTH_SUCCESS: Authentication success\n
+ *          SSH_AUTH_SUCCESS: The public key is accepted, you want now to use
+ *                            ssh_userauth_publickey().\n
 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again
 *                            later.
 *
@@ -1111,12 +1030,10 @@ int ssh_userauth_publickey_auto(ssh_session session,
            ssh_set_error_oom(session);
            return SSH_AUTH_ERROR;
        }
-
-        /* Set state explicitly */
-        session->auth.auto_state->state = SSH_AUTH_AUTO_STATE_NONE;
    }
    state = session->auth.auto_state;
    if (state->state == SSH_AUTH_AUTO_STATE_NONE) {
+#ifndef _WIN32
        /* Try authentication with ssh-agent first */
        rc = ssh_userauth_agent(session, username);
        if (rc == SSH_AUTH_SUCCESS ||
@@ -1124,6 +1041,7 @@ int ssh_userauth_publickey_auto(ssh_session session,
            rc == SSH_AUTH_AGAIN ) {
            return rc;
        }
+#endif
        state->state = SSH_AUTH_AUTO_STATE_PUBKEY;
    }
    if (state->it == NULL) {
@@ -1132,29 +1050,13 @@ int ssh_userauth_publickey_auto(ssh_session session,

    while (state->it != NULL) {
        const char *privkey_file = state->it->data;
-        char pubkey_file[PATH_MAX] = {0};
-
+        char pubkey_file[1024] = {0};
        if (state->state == SSH_AUTH_AUTO_STATE_PUBKEY) {
            SSH_LOG(SSH_LOG_DEBUG,
                    "Trying to authenticate with %s", privkey_file);
            state->privkey = NULL;
            state->pubkey = NULL;
-
-            if (ssh_pki_is_uri(privkey_file)) {
-                char *pub_uri_from_priv = NULL;
-                SSH_LOG(SSH_LOG_INFO,
-                        "Authenticating with PKCS #11 URI.");
-                pub_uri_from_priv = ssh_pki_export_pub_uri_from_priv_uri(privkey_file);
-                if (pub_uri_from_priv == NULL) {
-                    return SSH_ERROR;
-                } else {
-                    snprintf(pubkey_file, sizeof(pubkey_file), "%s",
-                             pub_uri_from_priv);
-                    SAFE_FREE(pub_uri_from_priv);
-                }
-            } else {
-                snprintf(pubkey_file, sizeof(pubkey_file), "%s.pub", privkey_file);
-            }
+            snprintf(pubkey_file, sizeof(pubkey_file), "%s.pub", privkey_file);

            rc = ssh_pki_import_pubkey_file(pubkey_file, &state->pubkey);
            if (rc == SSH_ERROR) {
@@ -1210,9 +1112,7 @@ int ssh_userauth_publickey_auto(ssh_session session,
                        "Public key authentication error for %s",
                        privkey_file);
                ssh_key_free(state->privkey);
-                state->privkey = NULL;
                ssh_key_free(state->pubkey);
-                state->pubkey = NULL;
                SAFE_FREE(session->auth.auto_state);
                return rc;
            } else if (rc == SSH_AUTH_AGAIN) {
@@ -1278,9 +1178,6 @@ int ssh_userauth_publickey_auto(ssh_session session,
                return rc;
            }

-            ssh_key_free(state->privkey);
-            ssh_key_free(state->pubkey);
-
            SSH_LOG(SSH_LOG_WARN,
                    "The server accepted the public key but refused the signature");
            state->it = state->it->next;
@@ -1328,11 +1225,10 @@ int ssh_userauth_publickey_auto(ssh_session session,
 */
 int ssh_userauth_password(ssh_session session,
                          const char *username,
-                          const char *password)
-{
+                          const char *password) {
    int rc;

-    switch (session->pending_call_state) {
+    switch(session->pending_call_state) {
        case SSH_PENDING_CALL_NONE:
            break;
        case SSH_PENDING_CALL_AUTH_PASSWORD:
@@ -1390,6 +1286,7 @@ fail:
    return SSH_AUTH_ERROR;
 }

+#ifndef _WIN32
 /* LEGACY */
 int ssh_userauth_agent_pubkey(ssh_session session,
                              const char *username,
@@ -1406,28 +1303,20 @@ int ssh_userauth_agent_pubkey(ssh_session session,
    key->type = publickey->type;
    key->type_c = ssh_key_type_to_char(key->type);
    key->flags = SSH_KEY_FLAG_PUBLIC;
-#if !defined(HAVE_LIBCRYPTO) || OPENSSL_VERSION_NUMBER < 0x30000000L
    key->dsa = publickey->dsa_pub;
    key->rsa = publickey->rsa_pub;
-#else
-    key->key = publickey->key_pub;
-#endif /* OPENSSL_VERSION_NUMBER */

    rc = ssh_userauth_agent_publickey(session, username, key);

-#if !defined(HAVE_LIBCRYPTO) || OPENSSL_VERSION_NUMBER < 0x30000000L
    key->dsa = NULL;
    key->rsa = NULL;
-#else
-    key->key = NULL;
-#endif /* OPENSSL_VERSION_NUMBER */
    ssh_key_free(key);

    return rc;
 }
+#endif /* _WIN32 */

-ssh_kbdint ssh_kbdint_new(void)
-{
+ssh_kbdint ssh_kbdint_new(void) {
    ssh_kbdint kbd;

    kbd = calloc(1, sizeof(struct ssh_kbdint_struct));
@@ -1439,9 +1328,8 @@ ssh_kbdint ssh_kbdint_new(void)
 }


-void ssh_kbdint_free(ssh_kbdint kbd)
-{
-    size_t i, n;
+void ssh_kbdint_free(ssh_kbdint kbd) {
+    int i, n;

    if (kbd == NULL) {
        return;
@@ -1476,9 +1364,8 @@ void ssh_kbdint_free(ssh_kbdint kbd)
    SAFE_FREE(kbd);
 }

-void ssh_kbdint_clean(ssh_kbdint kbd)
-{
-    size_t i, n;
+void ssh_kbdint_clean(ssh_kbdint kbd) {
+    int i, n;

    if (kbd == NULL) {
        return;
@@ -1667,7 +1554,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_info_request) {
            );

    /* We don't care about tmp */
-    SSH_STRING_FREE(tmp);
+    ssh_string_free(tmp);

    if (rc != SSH_OK) {
        ssh_set_error(session, SSH_FATAL, "Invalid USERAUTH_INFO_REQUEST msg");
@@ -1755,8 +1642,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_info_request) {
 * @see ssh_userauth_kbdint_setanswer()
 */
 int ssh_userauth_kbdint(ssh_session session, const char *user,
-                        const char *submethods)
-{
+    const char *submethods) {
    int rc = SSH_AUTH_ERROR;

    if (session == NULL) {
@@ -1798,8 +1684,7 @@ int ssh_userauth_kbdint(ssh_session session, const char *user,
 *
 * @returns             The number of prompts.
 */
-int ssh_userauth_kbdint_getnprompts(ssh_session session)
-{
+int ssh_userauth_kbdint_getnprompts(ssh_session session) {
    if (session == NULL) {
        return SSH_ERROR;
    }
@@ -1821,8 +1706,7 @@ int ssh_userauth_kbdint_getnprompts(ssh_session session)
 *
 * @returns             The name of the message block. Do not free it.
 */
-const char *ssh_userauth_kbdint_getname(ssh_session session)
-{
+const char *ssh_userauth_kbdint_getname(ssh_session session) {
    if (session == NULL) {
        return NULL;
    }
@@ -1845,8 +1729,7 @@ const char *ssh_userauth_kbdint_getname(ssh_session session)
 * @returns             The instruction of the message block.
 */

-const char *ssh_userauth_kbdint_getinstruction(ssh_session session)
-{
+const char *ssh_userauth_kbdint_getinstruction(ssh_session session) {
    if (session == NULL)
        return NULL;
    if (session->kbdint == NULL) {
@@ -1881,9 +1764,8 @@ const char *ssh_userauth_kbdint_getinstruction(ssh_session session)
 *   if (echo) ...
 * @endcode
 */
-const char *
-ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i, char *echo)
-{
+const char *ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i,
+    char *echo) {
    if (session == NULL)
        return NULL;
    if (session->kbdint == NULL) {
@@ -1896,7 +1778,7 @@ ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i, char *echo)
    }

    if (echo) {
-        *echo = (char)session->kbdint->echo[i];
+        *echo = session->kbdint->echo[i];
    }

    return session->kbdint->prompts[i];
@@ -1910,8 +1792,7 @@ ssh_userauth_kbdint_getprompt(ssh_session session, unsigned int i, char *echo)
 *
 * @returns             The number of answers.
 */
-int ssh_userauth_kbdint_getnanswers(ssh_session session)
-{
+int ssh_userauth_kbdint_getnanswers(ssh_session session) {
    if (session == NULL || session->kbdint == NULL) {
        return SSH_ERROR;
    }
@@ -1919,7 +1800,7 @@ int ssh_userauth_kbdint_getnanswers(ssh_session session)
 }

 /**
- * @brief Get the answer to a question from a message block.
+ * @brief Get the answer for a question from a message block.
 *
 * @param[in]  session  The ssh session to use.
 *
@@ -1927,8 +1808,7 @@ int ssh_userauth_kbdint_getnanswers(ssh_session session)
 *
 * @return              0 on success, < 0 on error.
 */
-const char *ssh_userauth_kbdint_getanswer(ssh_session session, unsigned int i)
-{
+const char *ssh_userauth_kbdint_getanswer(ssh_session session, unsigned int i) {
    if (session == NULL || session->kbdint == NULL
            || session->kbdint->answers == NULL) {
        return NULL;
@@ -1959,10 +1839,8 @@ const char *ssh_userauth_kbdint_getanswer(ssh_session session, unsigned int i)
 *
 * @return              0 on success, < 0 on error.
 */
-int
-ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i,
-                              const char *answer)
-{
+int ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i,
+    const char *answer) {
    if (session == NULL) {
        return -1;
    }
@@ -2008,8 +1886,7 @@ ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i,
 *          SSH_AUTH_AGAIN:   In nonblocking mode, you've got to call this again
 *                            later.
 */
-int ssh_userauth_gssapi(ssh_session session)
-{
+int ssh_userauth_gssapi(ssh_session session) {
    int rc = SSH_AUTH_DENIED;
 #ifdef WITH_GSSAPI
    switch(session->pending_call_state) {
--- a/src/base64.c
+++ b/src/base64.c
@@ -29,8 +29,7 @@
 #include "libssh/priv.h"
 #include "libssh/buffer.h"

-static
-const uint8_t alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+static char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                         "abcdefghijklmnopqrstuvwxyz"
                         "0123456789+/";

@@ -168,19 +167,19 @@ ssh_buffer base64_to_bin(const char *source) {

 error:
  SAFE_FREE(base64);
-  SSH_BUFFER_FREE(buffer);
+  ssh_buffer_free(buffer);
  return NULL;
 }

-#define BLOCK(letter, n) do {ptr = strchr((const char *)alphabet, source[n]); \
+#define BLOCK(letter, n) do {ptr = strchr(alphabet, source[n]); \
                             if(!ptr) return -1; \
-                             i = ptr - (const char *)alphabet; \
+                             i = ptr - alphabet; \
                             SET_##letter(*block, i); \
                         } while(0)

 /* Returns 0 if ok, -1 if not (ie invalid char into the stuff) */
 static int to_block4(unsigned long *block, const char *source, int num) {
-  const char *ptr = NULL;
+  char *ptr;
  unsigned int i;

  *block = 0;
@@ -235,32 +234,29 @@ static int get_equals(char *string) {
 }

 /* thanks sysk for debugging my mess :) */
-static void _bin_to_base64(uint8_t *dest,
-                           const uint8_t source[3],
-                           size_t len)
-{
 #define BITS(n) ((1 << (n)) - 1)
-    switch (len) {
-        case 1:
-            dest[0] = alphabet[(source[0] >> 2)];
-            dest[1] = alphabet[((source[0] & BITS(2)) << 4)];
-            dest[2] = '=';
-            dest[3] = '=';
-            break;
-        case 2:
-            dest[0] = alphabet[source[0] >> 2];
-            dest[1] = alphabet[(source[1] >> 4) | ((source[0] & BITS(2)) << 4)];
-            dest[2] = alphabet[(source[1] & BITS(4)) << 2];
-            dest[3] = '=';
-            break;
-        case 3:
-            dest[0] = alphabet[(source[0] >> 2)];
-            dest[1] = alphabet[(source[1] >> 4) | ((source[0] & BITS(2)) << 4)];
-            dest[2] = alphabet[(source[2] >> 6) | (source[1] & BITS(4)) << 2];
-            dest[3] = alphabet[source[2] & BITS(6)];
-            break;
-    }
-#undef BITS
+static void _bin_to_base64(unsigned char *dest, const unsigned char source[3],
+    int len) {
+  switch (len) {
+    case 1:
+      dest[0] = alphabet[(source[0] >> 2)];
+      dest[1] = alphabet[((source[0] & BITS(2)) << 4)];
+      dest[2] = '=';
+      dest[3] = '=';
+      break;
+    case 2:
+      dest[0] = alphabet[source[0] >> 2];
+      dest[1] = alphabet[(source[1] >> 4) | ((source[0] & BITS(2)) << 4)];
+      dest[2] = alphabet[(source[1] & BITS(4)) << 2];
+      dest[3] = '=';
+      break;
+    case 3:
+      dest[0] = alphabet[(source[0] >> 2)];
+      dest[1] = alphabet[(source[1] >> 4) | ((source[0] & BITS(2)) << 4)];
+      dest[2] = alphabet[ (source[2] >> 6) | (source[1] & BITS(4)) << 2];
+      dest[3] = alphabet[source[2] & BITS(6)];
+      break;
+  }
 }

 /**
@@ -270,29 +266,25 @@ static void _bin_to_base64(uint8_t *dest,
 *
 * @returns the converted string
 */
-uint8_t *bin_to_base64(const uint8_t *source, size_t len)
-{
-    uint8_t *base64 = NULL;
-    uint8_t *ptr = NULL;
-    size_t flen = len + (3 - (len % 3)); /* round to upper 3 multiple */
-    flen = (4 * flen) / 3 + 1;
+unsigned char *bin_to_base64(const unsigned char *source, int len) {
+  unsigned char *base64;
+  unsigned char *ptr;
+  int flen = len + (3 - (len % 3)); /* round to upper 3 multiple */
+  flen = (4 * flen) / 3 + 1;

-    base64 = malloc(flen);
-    if (base64 == NULL) {
-        return NULL;
-    }
-    ptr = base64;
+  base64 = malloc(flen);
+  if (base64 == NULL) {
+    return NULL;
+  }
+  ptr = base64;

-    while(len > 0){
-        _bin_to_base64(ptr, source, len > 3 ? 3 : len);
-        ptr += 4;
-        if (len < 3) {
-            break;
-        }
-        source += 3;
-        len -= 3;
-    }
-    ptr[0] = '\0';
+  while(len > 0){
+    _bin_to_base64(ptr, source, len > 3 ? 3 : len);
+    ptr += 4;
+    source += 3;
+    len -= 3;
+  }
+  ptr[0] = '\0';

-    return base64;
+  return base64;
 }
--- a/src/bignum.c
+++ b/src/bignum.c
@@ -29,9 +29,9 @@

 ssh_string ssh_make_bignum_string(bignum num) {
  ssh_string ptr = NULL;
-  size_t pad = 0;
-  size_t len = bignum_num_bytes(num);
-  size_t bits = bignum_num_bits(num);
+  int pad = 0;
+  unsigned int len = bignum_num_bytes(num);
+  unsigned int bits = bignum_num_bits(num);

  if (len == 0) {
      return NULL;
@@ -43,9 +43,7 @@ ssh_string ssh_make_bignum_string(bignum num) {
  }

 #ifdef DEBUG_CRYPTO
-  SSH_LOG(SSH_LOG_TRACE,
-          "%zu bits, %zu bytes, %zu padding\n",
-          bits, len, pad);
+  fprintf(stderr, "%d bits, %d bytes, %d padding\n", bits, len, pad);
 #endif /* DEBUG_CRYPTO */

  ptr = ssh_string_new(len + pad);
@@ -69,8 +67,7 @@ bignum ssh_make_string_bn(ssh_string string)
    size_t len = ssh_string_len(string);

 #ifdef DEBUG_CRYPTO
-    SSH_LOG(SSH_LOG_TRACE,
-            "Importing a %zu bits, %zu bytes object ...\n",
+    fprintf(stderr, "Importing a %zu bits, %zu bytes object ...\n",
            len * 8, len);
 #endif /* DEBUG_CRYPTO */

@@ -86,7 +83,7 @@ void ssh_print_bignum(const char *name, const_bignum num)
    if (num != NULL) {
        bignum_bn2hex(num, &hex);
    }
-    SSH_LOG(SSH_LOG_DEBUG, "%s value: %s\n", name, (hex == NULL) ? "(null)" : (char *) hex);
+    fprintf(stderr, "%s value: %s\n", name, (hex == NULL) ? "(null)" : (char *) hex);
 #ifdef HAVE_LIBGCRYPT
    SAFE_FREE(hex);
 #elif defined HAVE_LIBCRYPTO
--- a/src/bind.c
+++ b/src/bind.c
@@ -79,7 +79,6 @@ static socket_t bind_socket(ssh_bind sshbind, const char *hostname,
    int opt = 1;
    socket_t s;
    int rc;
-    char err_msg[SSH_ERRNO_MSG_MAX] = {0};

    ZERO_STRUCT(hints);

@@ -99,8 +98,7 @@ static socket_t bind_socket(ssh_bind sshbind, const char *hostname,
                           ai->ai_socktype,
                           ai->ai_protocol);
    if (s == SSH_INVALID_SOCKET) {
-        ssh_set_error(sshbind, SSH_FATAL, "%s",
-                      ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+        ssh_set_error(sshbind, SSH_FATAL, "%s", strerror(errno));
        freeaddrinfo (ai);
        return -1;
    }
@@ -110,7 +108,7 @@ static socket_t bind_socket(ssh_bind sshbind, const char *hostname,
        ssh_set_error(sshbind,
                      SSH_FATAL,
                      "Setting socket options failed: %s",
-                      ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                      strerror(errno));
        freeaddrinfo (ai);
        CLOSE_SOCKET(s);
        return -1;
@@ -122,7 +120,7 @@ static socket_t bind_socket(ssh_bind sshbind, const char *hostname,
                      "Binding to %s:%d: %s",
                      hostname,
                      port,
-                      ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                      strerror(errno));
        freeaddrinfo (ai);
        CLOSE_SOCKET(s);
        return -1;
@@ -282,10 +280,9 @@ int ssh_bind_listen(ssh_bind sshbind) {
      }

      if (listen(fd, 10) < 0) {
-        char err_msg[SSH_ERRNO_MSG_MAX] = {0};
          ssh_set_error(sshbind, SSH_FATAL,
                  "Listening to socket %d: %s",
-                  fd, ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                  fd, strerror(errno));
          CLOSE_SOCKET(fd);
          ssh_key_free(sshbind->dsa);
          sshbind->dsa = NULL;
@@ -342,7 +339,7 @@ static int ssh_bind_poll_callback(ssh_poll_handle sshpoll,
 }

 /** @internal
- * @brief returns the current poll handle, or creates it
+ * @brief returns the current poll handle, or create it
 * @param sshbind the ssh_bind object
 * @returns a ssh_poll handle suitable for operation
 */
@@ -396,7 +393,6 @@ void ssh_bind_free(ssh_bind sshbind){

  /* options */
  SAFE_FREE(sshbind->banner);
-  SAFE_FREE(sshbind->moduli_file);
  SAFE_FREE(sshbind->bindaddr);
  SAFE_FREE(sshbind->config_dir);
  SAFE_FREE(sshbind->pubkey_accepted_key_types);
@@ -415,7 +411,7 @@ void ssh_bind_free(ssh_bind sshbind){
  ssh_key_free(sshbind->ed25519);
  sshbind->ed25519 = NULL;

-  for (i = 0; i < SSH_KEX_METHODS; i++) {
+  for (i = 0; i < 10; i++) {
    if (sshbind->wanted_methods[i]) {
      SAFE_FREE(sshbind->wanted_methods[i]);
    }
@@ -446,7 +442,7 @@ int ssh_bind_accept_fd(ssh_bind sshbind, ssh_session session, socket_t fd){
    session->server = 1;

    /* Copy options from bind to session */
-    for (i = 0; i < SSH_KEX_METHODS; i++) {
+    for (i = 0; i < 10; i++) {
      if (sshbind->wanted_methods[i]) {
        session->opts.wanted_methods[i] = strdup(sshbind->wanted_methods[i]);
        if (session->opts.wanted_methods[i] == NULL) {
@@ -489,25 +485,8 @@ int ssh_bind_accept_fd(ssh_bind sshbind, ssh_session session, socket_t fd){
    }

    session->common.log_verbosity = sshbind->common.log_verbosity;
-
-    if (sshbind->banner != NULL) {
-        session->opts.custombanner = strdup(sshbind->banner);
-        if (session->opts.custombanner == NULL) {
-            ssh_set_error_oom(sshbind);
-            return SSH_ERROR;
-        }
-    }
-
-    if (sshbind->moduli_file != NULL) {
-        session->opts.moduli_file = strdup(sshbind->moduli_file);
-        if (session->opts.moduli_file == NULL) {
-            ssh_set_error_oom(sshbind);
-            return SSH_ERROR;
-        }
-    }
-
-    session->opts.rsa_min_size = sshbind->rsa_min_size;
-
+    if(sshbind->banner != NULL)
+    	session->opts.custombanner = strdup(sshbind->banner);
    ssh_socket_free(session->socket);
    session->socket = ssh_socket_new(session);
    if (session->socket == NULL) {
@@ -571,44 +550,34 @@ int ssh_bind_accept_fd(ssh_bind sshbind, ssh_session session, socket_t fd){
    return SSH_OK;
 }

-int ssh_bind_accept(ssh_bind sshbind, ssh_session session)
-{
-    socket_t fd = SSH_INVALID_SOCKET;
-    int rc;
+int ssh_bind_accept(ssh_bind sshbind, ssh_session session) {
+  socket_t fd = SSH_INVALID_SOCKET;
+  int rc;
+  if (sshbind->bindfd == SSH_INVALID_SOCKET) {
+    ssh_set_error(sshbind, SSH_FATAL,
+        "Can't accept new clients on a not bound socket.");
+    return SSH_ERROR;
+  }

-    if (sshbind->bindfd == SSH_INVALID_SOCKET) {
-        ssh_set_error(sshbind, SSH_FATAL,
-                      "Can't accept new clients on a not bound socket.");
-        return SSH_ERROR;
-    }
+  if (session == NULL){
+      ssh_set_error(sshbind, SSH_FATAL,"session is null");
+      return SSH_ERROR;
+  }

-    if (session == NULL) {
-        ssh_set_error(sshbind, SSH_FATAL, "session is null");
-        return SSH_ERROR;
-    }
+  fd = accept(sshbind->bindfd, NULL, NULL);
+  if (fd == SSH_INVALID_SOCKET) {
+    ssh_set_error(sshbind, SSH_FATAL,
+        "Accepting a new connection: %s",
+        strerror(errno));
+    return SSH_ERROR;
+  }
+  rc = ssh_bind_accept_fd(sshbind, session, fd);

-    fd = accept(sshbind->bindfd, NULL, NULL);
-    if (fd == SSH_INVALID_SOCKET) {
-        char err_msg[SSH_ERRNO_MSG_MAX] = {0};
-        if (errno == EINTR) {
-            ssh_set_error(sshbind, SSH_EINTR,
-                          "Accepting a new connection (child signal error): %s",
-                          ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-        } else {
-            ssh_set_error(sshbind, SSH_FATAL,
-                          "Accepting a new connection: %s",
-                          ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-        }
-        return SSH_ERROR;
-    }
-    rc = ssh_bind_accept_fd(sshbind, session, fd);
-
-    if (rc == SSH_ERROR) {
-        CLOSE_SOCKET(fd);
-        ssh_socket_free(session->socket);
-    }
-
-    return rc;
+  if(rc == SSH_ERROR){
+      CLOSE_SOCKET(fd);
+      ssh_socket_free(session->socket);
+  }
+  return rc;
 }


--- a/src/bind_config.c
+++ b/src/bind_config.c
@@ -40,9 +40,7 @@
 #include "libssh/server.h"
 #include "libssh/options.h"

-#ifndef MAX_LINE_SIZE
 #define MAX_LINE_SIZE 1024
-#endif

 /* Flags used for the parser state */
 #define PARSING     1
@@ -189,29 +187,18 @@ ssh_bind_config_parse_line(ssh_bind bind,
                           const char *line,
                           unsigned int count,
                           uint32_t *parser_flags,
-                           uint8_t *seen,
-                           unsigned int depth);
+                           uint8_t *seen);

-#define LIBSSH_BIND_CONF_MAX_DEPTH 16
-static void
-local_parse_file(ssh_bind bind,
-                 const char *filename,
-                 uint32_t *parser_flags,
-                 uint8_t *seen,
-                 unsigned int depth)
+static void local_parse_file(ssh_bind bind,
+                             const char *filename,
+                             uint32_t *parser_flags,
+                             uint8_t *seen)
 {
    FILE *f;
    char line[MAX_LINE_SIZE] = {0};
    unsigned int count = 0;
    int rv;

-    if (depth > LIBSSH_BIND_CONF_MAX_DEPTH) {
-        ssh_set_error(bind, SSH_FATAL,
-                      "ERROR - Too many levels of configuration includes "
-                      "when processing file '%s'", filename);
-        return;
-    }
-
    f = fopen(filename, "r");
    if (f == NULL) {
        SSH_LOG(SSH_LOG_RARE, "Cannot find file %s to load",
@@ -224,7 +211,7 @@ local_parse_file(ssh_bind bind,

    while (fgets(line, sizeof(line), f)) {
        count++;
-        rv = ssh_bind_config_parse_line(bind, line, count, parser_flags, seen, depth);
+        rv = ssh_bind_config_parse_line(bind, line, count, parser_flags, seen);
        if (rv < 0) {
            fclose(f);
            return;
@@ -239,8 +226,7 @@ local_parse_file(ssh_bind bind,
 static void local_parse_glob(ssh_bind bind,
                             const char *fileglob,
                             uint32_t *parser_flags,
-                             uint8_t *seen,
-                             unsigned int depth)
+                             uint8_t *seen)
 {
    glob_t globbuf = {
        .gl_flags = 0,
@@ -260,7 +246,7 @@ static void local_parse_glob(ssh_bind bind,
    }

    for (i = 0; i < globbuf.gl_pathc; i++) {
-        local_parse_file(bind, globbuf.gl_pathv[i], parser_flags, seen, depth);
+        local_parse_file(bind, globbuf.gl_pathv[i], parser_flags, seen);
    }

    globfree(&globbuf);
@@ -286,8 +272,7 @@ ssh_bind_config_parse_line(ssh_bind bind,
                           const char *line,
                           unsigned int count,
                           uint32_t *parser_flags,
-                           uint8_t *seen,
-                           unsigned int depth)
+                           uint8_t *seen)
 {
    enum ssh_bind_config_opcode_e opcode;
    const char *p = NULL;
@@ -301,12 +286,7 @@ ssh_bind_config_parse_line(ssh_bind bind,
        return -1;
    }

-    /* Ignore empty lines */
-    if (line == NULL || *line == '\0') {
-        return 0;
-    }
-
-    if (parser_flags == NULL) {
+    if ((line == NULL) || (parser_flags == NULL)) {
        ssh_set_error_invalid(bind);
        return -1;
    }
@@ -351,9 +331,9 @@ ssh_bind_config_parse_line(ssh_bind bind,
        p = ssh_config_get_str_tok(&s, NULL);
        if (p && (*parser_flags & PARSING)) {
 #if defined(HAVE_GLOB) && defined(HAVE_GLOB_GL_FLAGS_MEMBER)
-            local_parse_glob(bind, p, parser_flags, seen, depth + 1);
+            local_parse_glob(bind, p, parser_flags, seen);
 #else
-            local_parse_file(bind, p, parser_flags, seen, depth + 1);
+            local_parse_file(bind, p, parser_flags, seen);
 #endif /* HAVE_GLOB */
        }
        break;
@@ -646,7 +626,7 @@ int ssh_bind_config_parse_file(ssh_bind bind, const char *filename)
    parser_flags = PARSING;
    while (fgets(line, sizeof(line), f)) {
        count++;
-        rv = ssh_bind_config_parse_line(bind, line, count, &parser_flags, seen, 0);
+        rv = ssh_bind_config_parse_line(bind, line, count, &parser_flags, seen);
        if (rv) {
            fclose(f);
            return -1;
@@ -656,64 +636,3 @@ int ssh_bind_config_parse_file(ssh_bind bind, const char *filename)
    fclose(f);
    return 0;
 }
-
-/* @brief Parse configuration string and set the options to the given bind session
- *
- * @params[in] bind      The ssh bind session
- * @params[in] input     Null terminated string containing the configuration
- *
- * @returns    SSH_OK on successful parsing the configuration string,
- *             SSH_ERROR on error
- */
-int ssh_bind_config_parse_string(ssh_bind bind, const char *input)
-{
-    char line[MAX_LINE_SIZE] = {0};
-    const char *c = input, *line_start = input;
-    unsigned int line_num = 0, line_len;
-    uint32_t parser_flags;
-    int rv;
-
-    /* This local table is used during the parsing of the current file (and
-     * files included recursively in this file) to prevent an option to be
-     * redefined, i.e. the first value set is kept. But this DO NOT prevent the
-     * option to be redefined later by another file. */
-    uint8_t seen[BIND_CFG_MAX] = {0};
-
-    SSH_LOG(SSH_LOG_DEBUG, "Reading bind configuration data from string:");
-    SSH_LOG(SSH_LOG_DEBUG, "START\n%s\nEND", input);
-
-    parser_flags = PARSING;
-    while (1) {
-        line_num++;
-        line_start = c;
-        c = strchr(line_start, '\n');
-        if (c == NULL) {
-            /* if there is no newline at the end of the string */
-            c = strchr(line_start, '\0');
-        }
-        if (c == NULL) {
-            /* should not happen, would mean a string without trailing '\0' */
-            SSH_LOG(SSH_LOG_WARN, "No trailing '\\0' in config string");
-            return SSH_ERROR;
-        }
-        line_len = c - line_start;
-        if (line_len > MAX_LINE_SIZE - 1) {
-            SSH_LOG(SSH_LOG_WARN, "Line %u too long: %u characters",
-                    line_num, line_len);
-            return SSH_ERROR;
-        }
-        memcpy(line, line_start, line_len);
-        line[line_len] = '\0';
-        SSH_LOG(SSH_LOG_DEBUG, "Line %u: %s", line_num, line);
-        rv = ssh_bind_config_parse_line(bind, line, line_num, &parser_flags, seen, 0);
-        if (rv < 0) {
-            return SSH_ERROR;
-        }
-        if (*c == '\0') {
-            break;
-        }
-        c++;
-    }
-
-    return SSH_OK;
-}
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -46,9 +46,9 @@
 */
 struct ssh_buffer_struct {
    bool secure;
-    uint32_t used;
-    uint32_t allocated;
-    uint32_t pos;
+    size_t used;
+    size_t allocated;
+    size_t pos;
    uint8_t *data;
 };

@@ -83,21 +83,21 @@ static void buffer_verify(ssh_buffer buf)

    if (buf->used > buf->allocated) {
        fprintf(stderr,
-                "BUFFER ERROR: allocated %u, used %u\n",
+                "BUFFER ERROR: allocated %zu, used %zu\n",
                buf->allocated,
                buf->used);
        do_abort = true;
    }
    if (buf->pos > buf->used) {
        fprintf(stderr,
-                "BUFFER ERROR: position %u, used %u\n",
+                "BUFFER ERROR: position %zu, used %zu\n",
                buf->pos,
                buf->used);
        do_abort = true;
    }
    if (buf->pos > buf->allocated) {
        fprintf(stderr,
-                "BUFFER ERROR: position %u, allocated %u\n",
+                "BUFFER ERROR: position %zu, allocated %zu\n",
                buf->pos,
                buf->allocated);
        do_abort = true;
@@ -129,7 +129,7 @@ struct ssh_buffer_struct *ssh_buffer_new(void)
    /*
     * Always preallocate 64 bytes.
     *
-     * -1 for realloc_buffer magic.
+     * -1 for ralloc_buffer magic.
     */
    rc = ssh_buffer_allocate_size(buf, 64 - 1);
    if (rc != 0) {
@@ -178,9 +178,9 @@ void ssh_buffer_set_secure(ssh_buffer buffer)
    buffer->secure = true;
 }

-static int realloc_buffer(struct ssh_buffer_struct *buffer, uint32_t needed)
+static int realloc_buffer(struct ssh_buffer_struct *buffer, size_t needed)
 {
-    uint32_t smallest = 1;
+    size_t smallest = 1;
    uint8_t *new = NULL;

    buffer_verify(buffer);
@@ -299,33 +299,28 @@ int ssh_buffer_reinit(struct ssh_buffer_struct *buffer)
 */
 int ssh_buffer_add_data(struct ssh_buffer_struct *buffer, const void *data, uint32_t len)
 {
-    if (buffer == NULL) {
-        return -1;
+  buffer_verify(buffer);
+
+  if (data == NULL) {
+      return -1;
+  }
+
+  if (buffer->used + len < len) {
+    return -1;
+  }
+
+  if (buffer->allocated < (buffer->used + len)) {
+    if(buffer->pos > 0)
+      buffer_shift(buffer);
+    if (realloc_buffer(buffer, buffer->used + len) < 0) {
+      return -1;
    }
+  }

-    buffer_verify(buffer);
-
-    if (data == NULL) {
-        return -1;
-    }
-
-    if (buffer->used + len < len) {
-        return -1;
-    }
-
-    if (buffer->allocated < (buffer->used + len)) {
-        if (buffer->pos > 0) {
-            buffer_shift(buffer);
-        }
-        if (realloc_buffer(buffer, buffer->used + len) < 0) {
-            return -1;
-        }
-    }
-
-    memcpy(buffer->data + buffer->used, data, len);
-    buffer->used += len;
-    buffer_verify(buffer);
-    return 0;
+  memcpy(buffer->data+buffer->used, data, len);
+  buffer->used+=len;
+  buffer_verify(buffer);
+  return 0;
 }

 /**
@@ -693,7 +688,7 @@ uint32_t ssh_buffer_get_data(struct ssh_buffer_struct *buffer, void *data, uint3
 /**
 * @internal
 *
- * @brief Get a 8 bits unsigned int out of the buffer and adjust the read
+ * @brief Get a 8 bits unsigned int out of the buffer and adjusts the read
 * pointer.
 *
 * @param[in]  buffer   The buffer to read.
@@ -702,7 +697,7 @@ uint32_t ssh_buffer_get_data(struct ssh_buffer_struct *buffer, void *data, uint3
 *
 * @returns             0 if there is not enough data in buffer, 1 otherwise.
 */
-uint32_t ssh_buffer_get_u8(struct ssh_buffer_struct *buffer, uint8_t *data){
+int ssh_buffer_get_u8(struct ssh_buffer_struct *buffer, uint8_t *data){
    return ssh_buffer_get_data(buffer,data,sizeof(uint8_t));
 }

@@ -717,7 +712,7 @@ uint32_t ssh_buffer_get_u8(struct ssh_buffer_struct *buffer, uint8_t *data){
 *
 * @returns             0 if there is not enough data in buffer, 4 otherwise.
 */
-uint32_t ssh_buffer_get_u32(struct ssh_buffer_struct *buffer, uint32_t *data){
+int ssh_buffer_get_u32(struct ssh_buffer_struct *buffer, uint32_t *data){
    return ssh_buffer_get_data(buffer,data,sizeof(uint32_t));
 }
 /**
@@ -732,12 +727,12 @@ uint32_t ssh_buffer_get_u32(struct ssh_buffer_struct *buffer, uint32_t *data){
 *
 * @returns             0 if there is not enough data in buffer, 8 otherwise.
 */
-uint32_t ssh_buffer_get_u64(struct ssh_buffer_struct *buffer, uint64_t *data){
+int ssh_buffer_get_u64(struct ssh_buffer_struct *buffer, uint64_t *data){
    return ssh_buffer_get_data(buffer,data,sizeof(uint64_t));
 }

 /**
- * @brief Validates that the given length can be obtained from the buffer.
+ * @brief Valdiates that the given length can be obtained from the buffer.
 *
 * @param[in]  buffer  The buffer to read from.
 *
@@ -757,7 +752,7 @@ int ssh_buffer_validate_length(struct ssh_buffer_struct *buffer, size_t len)
 /**
 * @internal
 *
- * @brief Get an SSH String out of the buffer and adjust the read pointer.
+ * @brief Get a SSH String out of the buffer and adjusts the read pointer.
 *
 * @param[in]  buffer   The buffer to read.
 *
@@ -868,7 +863,7 @@ static int ssh_buffer_pack_allocate_va(struct ssh_buffer_struct *buffer,
            va_arg(ap, bignum);
            /*
             * Use a fixed size for a bignum
-             * (they should normally be around 32)
+             * (they should normaly be around 32)
             */
            needed_size += 64;
            break;
@@ -900,7 +895,7 @@ static int ssh_buffer_pack_allocate_va(struct ssh_buffer_struct *buffer,
        }
    }

-    rc = ssh_buffer_allocate_size(buffer, (uint32_t)needed_size);
+    rc = ssh_buffer_allocate_size(buffer, needed_size);
    if (rc != 0) {
        return SSH_ERROR;
    }
@@ -1102,8 +1097,7 @@ int ssh_buffer_unpack_va(struct ssh_buffer_struct *buffer,
        bignum *bignum;
        void **data;
    } o;
-    size_t len;
-    uint32_t rlen, max_len;
+    size_t len, rlen, max_len;
    ssh_string tmp_string = NULL;
    va_list ap_copy;
    size_t count;
--- a/src/chachapoly.c
+++ b/src/chachapoly.c
@@ -26,8 +26,9 @@
 #include "libssh/chacha.h"
 #include "libssh/poly1305.h"
 #include "libssh/misc.h"
-#include "libssh/chacha20-poly1305-common.h"

+/* size of the keys k1 and k2 as defined in specs */
+#define CHACHA20_KEYLEN 32
 struct chacha20_poly1305_keysched {
    /* key used for encrypting the length field*/
    struct chacha_ctx k1;
@@ -35,6 +36,13 @@ struct chacha20_poly1305_keysched {
    struct chacha_ctx k2;
 };

+#pragma pack(push, 1)
+struct ssh_packet_header {
+    uint32_t length;
+    uint8_t payload[];
+};
+#pragma pack(pop)
+
 static const uint8_t zero_block_counter[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 static const uint8_t payload_block_counter[8] = {1, 0, 0, 0, 0, 0, 0, 0};

@@ -65,7 +73,7 @@ static int chacha20_set_encrypt_key(struct ssh_cipher_struct *cipher,
 /**
 * @internal
 *
- * @brief encrypts an outgoing packet with chacha20 and authenticates it
+ * @brief encrypts an outgoing packet with chacha20 and authenticate it
 * with poly1305.
 */
 static void chacha20_poly1305_aead_encrypt(struct ssh_cipher_struct *cipher,
@@ -164,7 +172,7 @@ static int chacha20_poly1305_aead_decrypt(struct ssh_cipher_struct *cipher,
    ssh_log_hexdump("received tag", mac, POLY1305_TAGLEN);
 #endif

-    cmp = secure_memcmp(tag, mac, POLY1305_TAGLEN);
+    cmp = memcmp(tag, mac, POLY1305_TAGLEN);
    if(cmp != 0) {
        /* mac error */
        SSH_LOG(SSH_LOG_PACKET,"poly1305 verify error");
--- a/src/channels.c
+++ b/src/channels.c
--- a/src/client.c
+++ b/src/client.c
@@ -60,8 +60,7 @@
 * @param code one of SSH_SOCKET_CONNECTED_OK or SSH_SOCKET_CONNECTED_ERROR
 * @param user is a pointer to session
 */
-static void socket_callback_connected(int code, int errno_code, void *user)
-{
+static void socket_callback_connected(int code, int errno_code, void *user){
 	ssh_session session=(ssh_session)user;

 	if (session->session_state != SSH_SESSION_STATE_CONNECTING &&
@@ -77,10 +76,8 @@ static void socket_callback_connected(int code, int errno_code, void *user)
 	if(code == SSH_SOCKET_CONNECTED_OK)
 		session->session_state=SSH_SESSION_STATE_SOCKET_CONNECTED;
 	else {
-        char err_msg[SSH_ERRNO_MSG_MAX] = {0};
 		session->session_state=SSH_SESSION_STATE_ERROR;
-		ssh_set_error(session,SSH_FATAL,"%s",
-                      ssh_strerror(errno_code, err_msg, SSH_ERRNO_MSG_MAX));
+		ssh_set_error(session,SSH_FATAL,"%s",strerror(errno_code));
 	}
 	session->ssh_connection_callback(session);
 }
@@ -96,12 +93,12 @@ static void socket_callback_connected(int code, int errno_code, void *user)
 * @param  user is a pointer to session
 * @returns Number of bytes processed, or zero if the banner is not complete.
 */
-static size_t callback_receive_banner(const void *data, size_t len, void *user)
+static int callback_receive_banner(const void *data, size_t len, void *user)
 {
    char *buffer = (char *)data;
-    ssh_session session = (ssh_session) user;
+    ssh_session session=(ssh_session) user;
    char *str = NULL;
-    uint32_t i;
+    size_t i;
    int ret=0;

    if (session->session_state != SSH_SESSION_STATE_SOCKET_CONNECTED) {
@@ -109,7 +106,7 @@ static size_t callback_receive_banner(const void *data, size_t len, void *user)
                      "Wrong state in callback_receive_banner : %d",
                      session->session_state);

-        return 0;
+        return SSH_ERROR;
    }
    for (i = 0; i < len; ++i) {
 #ifdef WITH_PCAP
@@ -246,8 +243,8 @@ end:
 * @warning this function returning is no proof that DH handshake is
 * completed
 */
-static int dh_handshake(ssh_session session)
-{
+static int dh_handshake(ssh_session session) {
+
  int rc = SSH_AGAIN;

  switch (session->dh_handshake_state) {
@@ -255,7 +252,6 @@ static int dh_handshake(ssh_session session)
      switch(session->next_crypto->kex_type){
        case SSH_KEX_DH_GROUP1_SHA1:
        case SSH_KEX_DH_GROUP14_SHA1:
-        case SSH_KEX_DH_GROUP14_SHA256:
        case SSH_KEX_DH_GROUP16_SHA512:
        case SSH_KEX_DH_GROUP18_SHA512:
          rc = ssh_client_dh_init(session);
@@ -302,15 +298,13 @@ static int dh_handshake(ssh_session session)
  return rc;
 }

-static int ssh_service_request_termination(void *s)
-{
-    ssh_session session = (ssh_session)s;
-
-    if (session->session_state == SSH_SESSION_STATE_ERROR ||
-        session->auth.service_state != SSH_AUTH_SERVICE_SENT)
-        return 1;
-    else
-        return 0;
+static int ssh_service_request_termination(void *s){
+  ssh_session session = (ssh_session)s;
+  if(session->session_state == SSH_SESSION_STATE_ERROR ||
+      session->auth.service_state != SSH_AUTH_SERVICE_SENT)
+    return 1;
+  else
+    return 0;
 }

 /**
@@ -328,9 +322,8 @@ static int ssh_service_request_termination(void *s)
 * @return SSH_AGAIN No response received yet
 * @bug actually only works with ssh-userauth
 */
-int ssh_service_request(ssh_session session, const char *service)
-{
-  int rc = SSH_ERROR;
+int ssh_service_request(ssh_session session, const char *service) {
+  int rc=SSH_ERROR;

  if(session->auth.service_state != SSH_AUTH_SERVICE_NONE)
    goto pending;
@@ -457,7 +450,7 @@ static void ssh_client_connection_callback(ssh_session session)
            if (dh_handshake(session) == SSH_ERROR) {
                goto error;
            }
-            FALL_THROUGH;
+            /* FALL THROUGH */
        case SSH_SESSION_STATE_DH:
            if(session->dh_handshake_state==DH_STATE_FINISHED){
                set_status(session,1.0f);
@@ -487,18 +480,16 @@ error:
 /** @internal
 * @brief describe under which conditions the ssh_connect function may stop
 */
-static int ssh_connect_termination(void *user)
-{
-    ssh_session session = (ssh_session)user;
-
-    switch (session->session_state) {
+static int ssh_connect_termination(void *user){
+  ssh_session session = (ssh_session)user;
+  switch(session->session_state){
    case SSH_SESSION_STATE_ERROR:
    case SSH_SESSION_STATE_AUTHENTICATING:
    case SSH_SESSION_STATE_DISCONNECTED:
-        return 1;
+      return 1;
    default:
-        return 0;
-    }
+      return 0;
+  }
 }

 /**
@@ -513,138 +504,119 @@ static int ssh_connect_termination(void *user)
 * @see ssh_new()
 * @see ssh_disconnect()
 */
-int ssh_connect(ssh_session session)
-{
-    int ret;
+int ssh_connect(ssh_session session) {
+  int ret;

-    if (!is_ssh_initialized()) {
-        ssh_set_error(session, SSH_FATAL,
-                      "Library not initialized.");
+  if (session == NULL) {
+    return SSH_ERROR;
+  }

-        return SSH_ERROR;
+  switch(session->pending_call_state){
+  case SSH_PENDING_CALL_NONE:
+  	break;
+  case SSH_PENDING_CALL_CONNECT:
+  	goto pending;
+  default:
+  	ssh_set_error(session,SSH_FATAL,"Bad call during pending SSH call in ssh_connect");
+
+  	return SSH_ERROR;
+  }
+  session->alive = 0;
+  session->client = 1;
+
+  if (session->opts.fd == SSH_INVALID_SOCKET &&
+      session->opts.host == NULL &&
+      session->opts.ProxyCommand == NULL) {
+    ssh_set_error(session, SSH_FATAL, "Hostname required");
+    return SSH_ERROR;
+  }
+
+  /* If the system configuration files were not yet processed, do it now */
+  if (!session->opts.config_processed) {
+    ret = ssh_options_parse_config(session, NULL);
+    if (ret != 0) {
+      ssh_set_error(session, SSH_FATAL,
+                    "Failed to process system configuration files");
+      return SSH_ERROR;
    }
+  }

-    if (session == NULL) {
-        return SSH_ERROR;
-    }
+  ret = ssh_options_apply(session);
+  if (ret < 0) {
+      ssh_set_error(session, SSH_FATAL, "Couldn't apply options");
+      return SSH_ERROR;
+  }

-    switch(session->pending_call_state) {
-    case SSH_PENDING_CALL_NONE:
-        break;
-    case SSH_PENDING_CALL_CONNECT:
-        goto pending;
-    default:
-        ssh_set_error(session, SSH_FATAL,
-                      "Bad call during pending SSH call in ssh_connect");
+  SSH_LOG(SSH_LOG_PROTOCOL,
+          "libssh %s, using threading %s",
+          ssh_copyright(),
+          ssh_threads_get_type());

-        return SSH_ERROR;
-    }
-    session->alive = 0;
-    session->client = 1;
-
-    if (session->opts.fd == SSH_INVALID_SOCKET &&
-        session->opts.host == NULL &&
-        session->opts.ProxyCommand == NULL)
-    {
-        ssh_set_error(session, SSH_FATAL, "Hostname required");
-        return SSH_ERROR;
-    }
-
-    /* If the system configuration files were not yet processed, do it now */
-    if (!session->opts.config_processed) {
-        ret = ssh_options_parse_config(session, NULL);
-        if (ret != 0) {
-            ssh_set_error(session, SSH_FATAL,
-                          "Failed to process system configuration files");
-            return SSH_ERROR;
-        }
-    }
-
-    ret = ssh_options_apply(session);
-    if (ret < 0) {
-        ssh_set_error(session, SSH_FATAL, "Couldn't apply options");
-        return SSH_ERROR;
-    }
-
-    SSH_LOG(SSH_LOG_PROTOCOL,
-            "libssh %s, using threading %s",
-            ssh_copyright(),
-            ssh_threads_get_type());
-
-    session->ssh_connection_callback = ssh_client_connection_callback;
-    session->session_state = SSH_SESSION_STATE_CONNECTING;
-    ssh_socket_set_callbacks(session->socket, &session->socket_callbacks);
-    session->socket_callbacks.connected = socket_callback_connected;
-    session->socket_callbacks.data = callback_receive_banner;
-    session->socket_callbacks.exception = ssh_socket_exception_callback;
-    session->socket_callbacks.userdata = session;
-
-    if (session->opts.fd != SSH_INVALID_SOCKET) {
-        session->session_state = SSH_SESSION_STATE_SOCKET_CONNECTED;
-        ssh_socket_set_fd(session->socket, session->opts.fd);
-        ret = SSH_OK;
+  session->ssh_connection_callback = ssh_client_connection_callback;
+  session->session_state=SSH_SESSION_STATE_CONNECTING;
+  ssh_socket_set_callbacks(session->socket,&session->socket_callbacks);
+  session->socket_callbacks.connected=socket_callback_connected;
+  session->socket_callbacks.data=callback_receive_banner;
+  session->socket_callbacks.exception=ssh_socket_exception_callback;
+  session->socket_callbacks.userdata=session;
+  if (session->opts.fd != SSH_INVALID_SOCKET) {
+    session->session_state=SSH_SESSION_STATE_SOCKET_CONNECTED;
+    ssh_socket_set_fd(session->socket, session->opts.fd);
+    ret=SSH_OK;
 #ifndef _WIN32
-    } else if (session->opts.ProxyCommand != NULL) {
-        ret = ssh_socket_connect_proxycommand(session->socket,
-                session->opts.ProxyCommand);
+  } else if (session->opts.ProxyCommand != NULL){
+    ret = ssh_socket_connect_proxycommand(session->socket,
+                                          session->opts.ProxyCommand);
 #endif
-    } else {
-        ret = ssh_socket_connect(session->socket,
-                                 session->opts.host,
-                                 session->opts.port > 0 ? session->opts.port : 22,
-                                 session->opts.bindaddr);
-    }
-    if (ret == SSH_ERROR) {
-        return SSH_ERROR;
-    }
+  } else {
+    ret=ssh_socket_connect(session->socket,
+                           session->opts.host,
+                           session->opts.port > 0 ? session->opts.port : 22,
+                           session->opts.bindaddr);
+  }
+  if (ret == SSH_ERROR) {
+    return SSH_ERROR;
+  }

-    set_status(session, 0.2f);
-
-    session->alive = 1;
-    SSH_LOG(SSH_LOG_PROTOCOL,
-            "Socket connecting, now waiting for the callbacks to work");
+  set_status(session, 0.2f);

+  session->alive = 1;
+  SSH_LOG(SSH_LOG_PROTOCOL,"Socket connecting, now waiting for the callbacks to work");
 pending:
-    session->pending_call_state = SSH_PENDING_CALL_CONNECT;
-    if(ssh_is_blocking(session)) {
-        int timeout = (session->opts.timeout * 1000) +
-            (session->opts.timeout_usec / 1000);
-        if (timeout == 0) {
-            timeout = 10 * 1000;
-        }
-        SSH_LOG(SSH_LOG_PACKET, "Actual timeout : %d", timeout);
-        ret = ssh_handle_packets_termination(session, timeout,
-                                             ssh_connect_termination, session);
-        if (session->session_state != SSH_SESSION_STATE_ERROR &&
-            (ret == SSH_ERROR || !ssh_connect_termination(session)))
-        {
-            ssh_set_error(session, SSH_FATAL,
-                          "Timeout connecting to %s", session->opts.host);
-            session->session_state = SSH_SESSION_STATE_ERROR;
-        }
-    } else {
-        ret = ssh_handle_packets_termination(session,
-                                             SSH_TIMEOUT_NONBLOCKING,
-                                             ssh_connect_termination,
-                                             session);
-        if (ret == SSH_ERROR) {
-            session->session_state = SSH_SESSION_STATE_ERROR;
-        }
-    }
+  session->pending_call_state=SSH_PENDING_CALL_CONNECT;
+  if(ssh_is_blocking(session)) {
+      int timeout = (session->opts.timeout * 1000) +
+                    (session->opts.timeout_usec / 1000);
+      if (timeout == 0) {
+          timeout = 10 * 1000;
+      }
+      SSH_LOG(SSH_LOG_PACKET,"Actual timeout : %d", timeout);
+      ret = ssh_handle_packets_termination(session, timeout, ssh_connect_termination, session);
+      if (session->session_state != SSH_SESSION_STATE_ERROR &&
+          (ret == SSH_ERROR || !ssh_connect_termination(session))) {
+          ssh_set_error(session, SSH_FATAL,
+                        "Timeout connecting to %s", session->opts.host);
+          session->session_state = SSH_SESSION_STATE_ERROR;
+      }
+  }
+  else {
+      ret = ssh_handle_packets_termination(session,
+                                           SSH_TIMEOUT_NONBLOCKING,
+                                           ssh_connect_termination,
+                                           session);
+      if (ret == SSH_ERROR) {
+          session->session_state = SSH_SESSION_STATE_ERROR;
+      }
+  }
+  SSH_LOG(SSH_LOG_PACKET,"current state : %d",session->session_state);
+  if(!ssh_is_blocking(session) && !ssh_connect_termination(session)){
+    return SSH_AGAIN;
+  }

-    SSH_LOG(SSH_LOG_PACKET, "current state : %d", session->session_state);
-    if (!ssh_is_blocking(session) && !ssh_connect_termination(session)) {
-        return SSH_AGAIN;
-    }
-
-    session->pending_call_state = SSH_PENDING_CALL_NONE;
-    if (session->session_state == SSH_SESSION_STATE_ERROR ||
-        session->session_state == SSH_SESSION_STATE_DISCONNECTED)
-    {
-        return SSH_ERROR;
-    }
-
-    return SSH_OK;
+  session->pending_call_state=SSH_PENDING_CALL_NONE;
+  if(session->session_state == SSH_SESSION_STATE_ERROR || session->session_state == SSH_SESSION_STATE_DISCONNECTED)
+  	return SSH_ERROR;
+  return SSH_OK;
 }

 /**
@@ -657,13 +629,12 @@ pending:
 *
 * @return A newly allocated string with the banner, NULL on error.
 */
-char *ssh_get_issue_banner(ssh_session session)
-{
-    if (session == NULL || session->banner == NULL) {
-        return NULL;
-    }
+char *ssh_get_issue_banner(ssh_session session) {
+  if (session == NULL || session->banner == NULL) {
+    return NULL;
+  }

-    return ssh_string_to_char(session->banner);
+  return ssh_string_to_char(session->banner);
 }

 /**
@@ -684,159 +655,102 @@ char *ssh_get_issue_banner(ssh_session session)
 * }
 * @endcode
 */
-int ssh_get_openssh_version(ssh_session session)
-{
-    if (session == NULL) {
-        return 0;
-    }
+int ssh_get_openssh_version(ssh_session session) {
+  if (session == NULL) {
+    return 0;
+  }

-    return session->openssh;
+  return session->openssh;
 }
-/**
- * @brief Add disconnect message when ssh_session is disconnected
- * To add a disconnect message to give peer a better hint.
- * @param  session      The SSH session to use.
- * @param  message      The message to send after the session is disconnected.
- *                      If no message is passed then a default message i.e
- *                      "Bye Bye" will be sent.
- */
-int
-ssh_session_set_disconnect_message(ssh_session session, const char *message)
-{
-    if (session == NULL) {
-        return SSH_ERROR;
-    }
-
-    if (message == NULL || strlen(message) == 0) {
-        SAFE_FREE(session->disconnect_message);  //To free any message set earlier.
-        session->disconnect_message = strdup("Bye Bye") ;
-        if (session->disconnect_message == NULL) {
-            ssh_set_error_oom(session);
-            return SSH_ERROR;
-        }
-        return SSH_OK;
-    }
-    SAFE_FREE(session->disconnect_message);  //To free any message set earlier.
-    session->disconnect_message = strdup(message);
-    if (session->disconnect_message == NULL) {
-        ssh_set_error_oom(session);
-        return SSH_ERROR;
-    }
-    return SSH_OK;
-}
-

 /**
 * @brief Disconnect from a session (client or server).
- *
 * The session can then be reused to open a new session.
 *
- * @note Note that this function wont close the socket if it was set with
- * @ssh_options_set and SSH_OPTIONS_FD. You're responsible for closing the
- * socket. This is new behavior in libssh 0.10.
- *
 * @param[in]  session  The SSH session to use.
 */
-void
-ssh_disconnect(ssh_session session)
-{
-    struct ssh_iterator *it;
-    int rc;
+void ssh_disconnect(ssh_session session) {
+  struct ssh_iterator *it;
+  int rc;

-    if (session == NULL) {
-        return;
-    }
-
-    if (session->disconnect_message == NULL) {
-        session->disconnect_message = strdup("Bye Bye") ;
-        if (session->disconnect_message == NULL) {
-            ssh_set_error_oom(session);
-            goto error;
-        }
-    }
-
-    if (session->socket != NULL && ssh_socket_is_open(session->socket)) {
-        rc = ssh_buffer_pack(session->out_buffer,
-                             "bdss",
-                             SSH2_MSG_DISCONNECT,
-                             SSH2_DISCONNECT_BY_APPLICATION,
-                             session->disconnect_message,
-                             ""); /* language tag */
-        if (rc != SSH_OK) {
-            ssh_set_error_oom(session);
-            goto error;
-        }
-
-        ssh_packet_send(session);
-        /* Do not close the socket, if the fd was set via options. */
-        if (session->opts.fd == SSH_INVALID_SOCKET) {
-            ssh_socket_close(session->socket);
-        }
+  if (session == NULL) {
+    return;
+  }
+
+  if (session->socket != NULL && ssh_socket_is_open(session->socket)) {
+    rc = ssh_buffer_pack(session->out_buffer,
+                         "bdss",
+                         SSH2_MSG_DISCONNECT,
+                         SSH2_DISCONNECT_BY_APPLICATION,
+                         "Bye Bye",
+                         ""); /* language tag */
+    if (rc != SSH_OK){
+      ssh_set_error_oom(session);
+      goto error;
    }

+    ssh_packet_send(session);
+    ssh_socket_close(session->socket);
+  }
 error:
-    session->recv_seq = 0;
-    session->send_seq = 0;
-    session->alive = 0;
-    if (session->socket != NULL){
-        ssh_socket_reset(session->socket);
-    }
-    session->opts.fd = SSH_INVALID_SOCKET;
-    session->session_state = SSH_SESSION_STATE_DISCONNECTED;
-    session->pending_call_state = SSH_PENDING_CALL_NONE;
+  session->recv_seq = 0;
+  session->send_seq = 0;
+  session->alive = 0;
+  if (session->socket != NULL){
+    ssh_socket_reset(session->socket);
+  }
+  session->opts.fd = SSH_INVALID_SOCKET;
+  session->session_state=SSH_SESSION_STATE_DISCONNECTED;

-    while ((it = ssh_list_get_iterator(session->channels)) != NULL) {
-        ssh_channel_do_free(ssh_iterator_value(ssh_channel, it));
-        ssh_list_remove(session->channels, it);
+  while ((it=ssh_list_get_iterator(session->channels)) != NULL) {
+    ssh_channel_do_free(ssh_iterator_value(ssh_channel,it));
+    ssh_list_remove(session->channels, it);
+  }
+  if(session->current_crypto){
+    crypto_free(session->current_crypto);
+    session->current_crypto=NULL;
+  }
+  if (session->next_crypto) {
+    crypto_free(session->next_crypto);
+    session->next_crypto = crypto_new();
+    if (session->next_crypto == NULL) {
+      ssh_set_error_oom(session);
    }
-    if (session->current_crypto) {
-      crypto_free(session->current_crypto);
-      session->current_crypto = NULL;
-    }
-    if (session->next_crypto) {
-        crypto_free(session->next_crypto);
-        session->next_crypto = crypto_new();
-        if (session->next_crypto == NULL) {
-            ssh_set_error_oom(session);
-        }
-    }
-    if (session->in_buffer) {
-        ssh_buffer_reinit(session->in_buffer);
-    }
-    if (session->out_buffer) {
-        ssh_buffer_reinit(session->out_buffer);
-    }
-    if (session->in_hashbuf) {
-        ssh_buffer_reinit(session->in_hashbuf);
-    }
-    if (session->out_hashbuf) {
-        ssh_buffer_reinit(session->out_hashbuf);
-    }
-    session->auth.supported_methods = 0;
-    SAFE_FREE(session->serverbanner);
-    SAFE_FREE(session->clientbanner);
-    SAFE_FREE(session->disconnect_message);
+  }
+  if (session->in_buffer) {
+    ssh_buffer_reinit(session->in_buffer);
+  }
+  if (session->out_buffer) {
+    ssh_buffer_reinit(session->out_buffer);
+  }
+  if (session->in_hashbuf) {
+    ssh_buffer_reinit(session->in_hashbuf);
+  }
+  if (session->out_hashbuf) {
+    ssh_buffer_reinit(session->out_hashbuf);
+  }
+  session->auth.supported_methods = 0;
+  SAFE_FREE(session->serverbanner);
+  SAFE_FREE(session->clientbanner);

-    if (session->ssh_message_list) {
-        ssh_message msg = NULL;
-
-        while ((msg = ssh_list_pop_head(ssh_message,
-                                        session->ssh_message_list)) != NULL) {
-              ssh_message_free(msg);
-        }
-        ssh_list_free(session->ssh_message_list);
-        session->ssh_message_list = NULL;
+  if(session->ssh_message_list){
+    ssh_message msg;
+    while((msg=ssh_list_pop_head(ssh_message ,session->ssh_message_list))
+        != NULL){
+      ssh_message_free(msg);
    }
+    ssh_list_free(session->ssh_message_list);
+    session->ssh_message_list=NULL;
+  }

-    if (session->packet_callbacks) {
-        ssh_list_free(session->packet_callbacks);
-        session->packet_callbacks = NULL;
-    }
+  if (session->packet_callbacks){
+    ssh_list_free(session->packet_callbacks);
+    session->packet_callbacks=NULL;
+  }
 }

-const char *ssh_copyright(void)
-{
-    return SSH_STRINGIFY(LIBSSH_VERSION) " (c) 2003-2022 "
+const char *ssh_copyright(void) {
+    return SSH_STRINGIFY(LIBSSH_VERSION) " (c) 2003-2019 "
           "Aris Adamantiadis, Andreas Schneider "
           "and libssh contributors. "
           "Distributed under the LGPL, please refer to COPYING "
--- a/src/config.c
+++ b/src/config.c
@@ -32,14 +32,6 @@
 #endif
 #include <stdbool.h>
 #include <limits.h>
-#ifndef _WIN32
-# include <sys/types.h>
-# include <sys/stat.h>
-# include <fcntl.h>
-# include <errno.h>
-# include <signal.h>
-# include <sys/wait.h>
-#endif

 #include "libssh/config_parser.h"
 #include "libssh/config.h"
@@ -48,9 +40,7 @@
 #include "libssh/misc.h"
 #include "libssh/options.h"

-#ifndef MAX_LINE_SIZE
 #define MAX_LINE_SIZE 1024
-#endif

 struct ssh_config_keyword_table_s {
  const char *name;
@@ -68,6 +58,7 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "macs", SOC_MACS },
  { "compression", SOC_COMPRESSION },
  { "connecttimeout", SOC_TIMEOUT },
+  { "protocol", SOC_PROTOCOL },
  { "stricthostkeychecking", SOC_STRICTHOSTKEYCHECK },
  { "userknownhostsfile", SOC_KNOWNHOSTS },
  { "proxycommand", SOC_PROXYCOMMAND },
@@ -80,6 +71,7 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "loglevel", SOC_LOGLEVEL},
  { "hostkeyalgorithms", SOC_HOSTKEYALGORITHMS},
  { "kexalgorithms", SOC_KEXALGORITHMS},
+  { "mac", SOC_UNSUPPORTED}, /* SSHv1 */
  { "gssapiauthentication", SOC_GSSAPIAUTHENTICATION},
  { "kbdinteractiveauthentication", SOC_KBDINTERACTIVEAUTHENTICATION},
  { "passwordauthentication", SOC_PASSWORDAUTHENTICATION},
@@ -93,18 +85,23 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "canonicalizemaxdots", SOC_UNSUPPORTED},
  { "canonicalizepermittedcnames", SOC_UNSUPPORTED},
  { "certificatefile", SOC_UNSUPPORTED},
-  { "kbdinteractiveauthentication", SOC_UNSUPPORTED},
+  { "challengeresponseauthentication", SOC_UNSUPPORTED},
  { "checkhostip", SOC_UNSUPPORTED},
+  { "cipher", SOC_UNSUPPORTED}, /* SSHv1 */
+  { "compressionlevel", SOC_UNSUPPORTED}, /* SSHv1 */
  { "connectionattempts", SOC_UNSUPPORTED},
  { "enablesshkeysign", SOC_UNSUPPORTED},
  { "fingerprinthash", SOC_UNSUPPORTED},
  { "forwardagent", SOC_UNSUPPORTED},
+  { "gssapikeyexchange", SOC_UNSUPPORTED},
+  { "gssapirenewalforcesrekey", SOC_UNSUPPORTED},
+  { "gssapitrustdns", SOC_UNSUPPORTED},
  { "hashknownhosts", SOC_UNSUPPORTED},
  { "hostbasedauthentication", SOC_UNSUPPORTED},
-  { "hostbasedacceptedalgorithms", SOC_UNSUPPORTED},
+  { "hostbasedkeytypes", SOC_UNSUPPORTED},
  { "hostkeyalias", SOC_UNSUPPORTED},
  { "identitiesonly", SOC_UNSUPPORTED},
-  { "identityagent", SOC_IDENTITYAGENT},
+  { "identityagent", SOC_UNSUPPORTED},
  { "ipqos", SOC_UNSUPPORTED},
  { "kbdinteractivedevices", SOC_UNSUPPORTED},
  { "nohostauthenticationforlocalhost", SOC_UNSUPPORTED},
@@ -113,10 +110,12 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "preferredauthentications", SOC_UNSUPPORTED},
  { "proxyjump", SOC_PROXYJUMP},
  { "proxyusefdpass", SOC_UNSUPPORTED},
-  { "pubkeyacceptedalgorithms", SOC_PUBKEYACCEPTEDKEYTYPES},
+  { "pubkeyacceptedtypes", SOC_PUBKEYACCEPTEDTYPES},
  { "rekeylimit", SOC_REKEYLIMIT},
  { "remotecommand", SOC_UNSUPPORTED},
  { "revokedhostkeys", SOC_UNSUPPORTED},
+  { "rhostsrsaauthentication", SOC_UNSUPPORTED},
+  { "rsaauthentication", SOC_UNSUPPORTED}, /* SSHv1 */
  { "serveralivecountmax", SOC_UNSUPPORTED},
  { "serveraliveinterval", SOC_UNSUPPORTED},
  { "streamlocalbindmask", SOC_UNSUPPORTED},
@@ -124,6 +123,7 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "syslogfacility", SOC_UNSUPPORTED},
  { "tcpkeepalive", SOC_UNSUPPORTED},
  { "updatehostkeys", SOC_UNSUPPORTED},
+  { "useprivilegedport", SOC_UNSUPPORTED},
  { "verifyhostkeydns", SOC_UNSUPPORTED},
  { "visualhostkey", SOC_UNSUPPORTED},
  { "clearallforwardings", SOC_NA},
@@ -147,7 +147,7 @@ static struct ssh_config_keyword_table_s ssh_config_keyword_table[] = {
  { "tunnel", SOC_NA},
  { "tunneldevice", SOC_NA},
  { "xauthlocation", SOC_NA},
-  { "pubkeyacceptedkeytypes", SOC_PUBKEYACCEPTEDKEYTYPES},
+  { "pubkeyacceptedkeytypes", SOC_PUBKEYACCEPTEDTYPES},
  { NULL, SOC_UNKNOWN }
 };

@@ -181,7 +181,7 @@ static struct ssh_config_match_keyword_table_s ssh_config_match_keyword_table[]
 };

 static int ssh_config_parse_line(ssh_session session, const char *line,
-    unsigned int count, int *parsing, unsigned int depth, bool global);
+    unsigned int count, int *parsing);

 static enum ssh_config_opcode_e ssh_config_get_opcode(char *keyword) {
  int i;
@@ -195,26 +195,16 @@ static enum ssh_config_opcode_e ssh_config_get_opcode(char *keyword) {
  return SOC_UNKNOWN;
 }

-#define LIBSSH_CONF_MAX_DEPTH 16
 static void
 local_parse_file(ssh_session session,
                 const char *filename,
-                 int *parsing,
-                 unsigned int depth,
-                 bool global)
+                 int *parsing)
 {
    FILE *f;
    char line[MAX_LINE_SIZE] = {0};
    unsigned int count = 0;
    int rv;

-    if (depth > LIBSSH_CONF_MAX_DEPTH) {
-        ssh_set_error(session, SSH_FATAL,
-                      "ERROR - Too many levels of configuration includes "
-                      "when processing file '%s'", filename);
-        return;
-    }
-
    f = fopen(filename, "r");
    if (f == NULL) {
        SSH_LOG(SSH_LOG_RARE, "Cannot find file %s to load",
@@ -225,7 +215,7 @@ local_parse_file(ssh_session session,
    SSH_LOG(SSH_LOG_PACKET, "Reading additional configuration data from %s", filename);
    while (fgets(line, sizeof(line), f)) {
        count++;
-        rv = ssh_config_parse_line(session, line, count, parsing, depth, global);
+        rv = ssh_config_parse_line(session, line, count, parsing);
        if (rv < 0) {
            fclose(f);
            return;
@@ -239,9 +229,7 @@ local_parse_file(ssh_session session,
 #if defined(HAVE_GLOB) && defined(HAVE_GLOB_GL_FLAGS_MEMBER)
 static void local_parse_glob(ssh_session session,
                             const char *fileglob,
-                             int *parsing,
-                             unsigned int depth,
-                             bool global)
+                             int *parsing)
 {
    glob_t globbuf = {
        .gl_flags = 0,
@@ -261,7 +249,7 @@ static void local_parse_glob(ssh_session session,
    }

    for (i = 0; i < globbuf.gl_pathc; i++) {
-        local_parse_file(session, globbuf.gl_pathv[i], parsing, depth, global);
+        local_parse_file(session, globbuf.gl_pathv[i], parsing);
    }

    globfree(&globbuf);
@@ -299,134 +287,6 @@ ssh_config_match(char *value, const char *pattern, bool negate)
    return result;
 }

-#ifdef _WIN32
-static int
-ssh_match_exec(ssh_session session, const char *command, bool negate)
-{
-    (void) session;
-    (void) command;
-    (void) negate;
-
-    SSH_LOG(SSH_LOG_TRACE, "Unsupported 'exec' command on Windows '%s'",
-            command);
-    return 0;
-}
-#else /* _WIN32 */
-
-static int
-ssh_exec_shell(char *cmd)
-{
-    char *shell = NULL;
-    pid_t pid;
-    int status, devnull, rc;
-    char err_msg[SSH_ERRNO_MSG_MAX] = {0};
-
-    shell = getenv("SHELL");
-    if (shell == NULL || shell[0] == '\0') {
-        shell = (char *)"/bin/sh";
-    }
-
-    rc = access(shell, X_OK);
-    if (rc != 0) {
-        SSH_LOG(SSH_LOG_WARN, "The shell '%s' is not executable", shell);
-        return -1;
-    }
-
-    /* Need this to redirect subprocess stdin/out */
-    devnull = open("/dev/null", O_RDWR);
-    if (devnull == -1) {
-        SSH_LOG(SSH_LOG_WARN, "Failed to open(/dev/null): %s",
-                ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-        return -1;
-    }
-
-    SSH_LOG(SSH_LOG_DEBUG, "Running command '%s'", cmd);
-    pid = fork();
-    if (pid == 0) { /* Child */
-        char *argv[4];
-
-        /* Redirect child stdin and stdout. Leave stderr */
-        rc = dup2(devnull, STDIN_FILENO);
-        if (rc == -1) {
-            SSH_LOG(SSH_LOG_WARN, "dup2: %s",
-                    ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-            exit(1);
-        }
-        rc = dup2(devnull, STDOUT_FILENO);
-        if (rc == -1) {
-            SSH_LOG(SSH_LOG_WARN, "dup2: %s",
-                    ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-	    exit(1);
-        }
-        if (devnull > STDERR_FILENO) {
-            close(devnull);
-        }
-
-        argv[0] = shell;
-        argv[1] = (char *) "-c";
-        argv[2] = strdup(cmd);
-        argv[3] = NULL;
-
-        rc = execv(argv[0], argv);
-        if (rc == -1) {
-            SSH_LOG(SSH_LOG_WARN, "Failed to execute command '%s': %s", cmd,
-                    ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-            /* Die with signal to make this error apparent to parent. */
-            signal(SIGTERM, SIG_DFL);
-            kill(getpid(), SIGTERM);
-            _exit(1);
-        }
-    }
-
-    /* Parent */
-    close(devnull);
-    if (pid == -1) { /* Error */
-        SSH_LOG(SSH_LOG_WARN, "Failed to fork child: %s",
-                ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-        return -1;
-
-    }
-
-    while (waitpid(pid, &status, 0) == -1) {
-        if (errno != EINTR) {
-            SSH_LOG(SSH_LOG_WARN, "waitpid failed: %s",
-                    ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
-            return -1;
-        }
-    }
-    if (!WIFEXITED(status)) {
-        SSH_LOG(SSH_LOG_WARN, "Command %s exitted abnormally", cmd);
-        return -1;
-    }
-    SSH_LOG(SSH_LOG_TRACE, "Command '%s' returned %d", cmd, WEXITSTATUS(status));
-    return WEXITSTATUS(status);
-}
-
-static int
-ssh_match_exec(ssh_session session, const char *command, bool negate)
-{
-    int rv, result = 0;
-    char *cmd = NULL;
-
-    /* TODO There should be more supported expansions */
-    cmd = ssh_path_expand_escape(session, command);
-    if (cmd == NULL) {
-        return 0;
-    }
-    rv = ssh_exec_shell(cmd);
-    if (rv > 0 && negate == true) {
-        result = 1;
-    } else if (rv == 0 && negate == false) {
-        result = 1;
-    }
-    SSH_LOG(SSH_LOG_TRACE, "%s 'exec' command '%s'%s (rv=%d)",
-            result == 1 ? "Matched" : "Not matched", cmd,
-            negate == true ? " (negated)" : "", rv);
-    free(cmd);
-    return result;
-}
-#endif  /* _WIN32 */
-
 /* @brief: Parse the ProxyJump configuration line and if parsing,
 * stores the result in the configuration option
 */
@@ -517,68 +377,11 @@ out:
    return rv;
 }

-static char *
-ssh_config_make_absolute(ssh_session session,
-                         const char *path,
-                         bool global)
-{
-    size_t outlen = 0;
-    char *out = NULL;
-    int rv;
-
-    /* Looks like absolute path */
-    if (path[0] == '/') {
-        return strdup(path);
-    }
-
-    /* relative path */
-    if (global) {
-        /* Parsing global config */
-        outlen = strlen(path) + strlen("/etc/ssh/") + 1;
-        out = malloc(outlen);
-        if (out == NULL) {
-            ssh_set_error_oom(session);
-            return NULL;
-        }
-        rv = snprintf(out, outlen, "/etc/ssh/%s", path);
-        if (rv < 1) {
-            free(out);
-            return NULL;
-        }
-        return out;
-    }
-
-    /* paths starting with tilde are already absolute */
-    if (path[0] == '~') {
-        return ssh_path_expand_tilde(path);
-    }
-
-    /* Parsing user config relative to home directory (generally ~/.ssh) */
-    if (session->opts.sshdir == NULL) {
-        ssh_set_error_invalid(session);
-        return NULL;
-    }
-    outlen = strlen(path) + strlen(session->opts.sshdir) + 1 + 1;
-    out = malloc(outlen);
-    if (out == NULL) {
-        ssh_set_error_oom(session);
-        return NULL;
-    }
-    rv = snprintf(out, outlen, "%s/%s", session->opts.sshdir, path);
-    if (rv < 1) {
-        free(out);
-        return NULL;
-    }
-    return out;
-}
-
 static int
 ssh_config_parse_line(ssh_session session,
                      const char *line,
                      unsigned int count,
-                      int *parsing,
-                      unsigned int depth,
-                      bool global)
+                      int *parsing)
 {
  enum ssh_config_opcode_e opcode;
  const char *p = NULL, *p2 = NULL;
@@ -591,11 +394,6 @@ ssh_config_parse_line(ssh_session session,
  long l;
  int64_t ll;

-  /* Ignore empty lines */
-  if (line == NULL || *line == '\0') {
-    return 0;
-  }
-
  x = s = strdup(line);
  if (s == NULL) {
    ssh_set_error_oom(session);
@@ -622,7 +420,6 @@ ssh_config_parse_line(ssh_session session,
      opcode != SOC_HOST &&
      opcode != SOC_MATCH &&
      opcode != SOC_INCLUDE &&
-      opcode != SOC_IDENTITY &&
      opcode > SOC_UNSUPPORTED) { /* Ignore all unknown types here */
      /* Skip all the options that were already applied */
      if (seen[opcode] != 0) {
@@ -637,19 +434,11 @@ ssh_config_parse_line(ssh_session session,

      p = ssh_config_get_str_tok(&s, NULL);
      if (p && *parsing) {
-        char *path = ssh_config_make_absolute(session, p, global);
-        if (path == NULL) {
-          SSH_LOG(SSH_LOG_WARN, "line %d: Failed to allocate memory "
-                  "for the include path expansion", count);
-          SAFE_FREE(x);
-          return -1;
-        }
 #if defined(HAVE_GLOB) && defined(HAVE_GLOB_GL_FLAGS_MEMBER)
-        local_parse_glob(session, path, parsing, depth + 1, global);
+        local_parse_glob(session, p, parsing);
 #else
-        local_parse_file(session, path, parsing, depth + 1, global);
+        local_parse_file(session, p, parsing);
 #endif /* HAVE_GLOB */
-        free(path);
      }
      break;

@@ -699,7 +488,7 @@ ssh_config_parse_line(ssh_session session,

            case MATCH_FINAL:
            case MATCH_CANONICAL:
-                SSH_LOG(SSH_LOG_INFO,
+                SSH_LOG(SSH_LOG_WARN,
                        "line %d: Unsupported Match keyword '%s', skipping",
                        count,
                        p);
@@ -708,22 +497,20 @@ ssh_config_parse_line(ssh_session session,
                break;

            case MATCH_EXEC:
-                /* Skip one argument (including in quotes) */
-                p = ssh_config_get_token(&s);
+                /* Skip to the end of line as unsupported */
+                p = ssh_config_get_cmd(&s);
                if (p == NULL || p[0] == '\0') {
                    SSH_LOG(SSH_LOG_WARN, "line %d: Match keyword "
                            "'%s' requires argument", count, p2);
                    SAFE_FREE(x);
                    return -1;
                }
-                if (result != 1) {
-                    SSH_LOG(SSH_LOG_INFO, "line %d: Skipped match exec "
-                            "'%s' as previous conditions already failed.",
-                            count, p2);
-                    continue;
-                }
-                result &= ssh_match_exec(session, p, negate);
                args++;
+                SSH_LOG(SSH_LOG_WARN,
+                        "line %d: Unsupported Match keyword '%s', ignoring",
+                        count,
+                        p2);
+                result = 0;
                break;

            case MATCH_LOCALUSER:
@@ -758,7 +545,7 @@ ssh_config_parse_line(ssh_session session,
                    return -1;
                }
                args++;
-                SSH_LOG(SSH_LOG_INFO,
+                SSH_LOG(SSH_LOG_WARN,
                        "line %d: Unsupported Match keyword '%s', ignoring",
                        count,
                        p2);
@@ -888,6 +675,34 @@ ssh_config_parse_line(ssh_session session,
        }
      }
      break;
+    case SOC_PROTOCOL:
+      p = ssh_config_get_str_tok(&s, NULL);
+      if (p && *parsing) {
+        char *a, *b;
+        b = strdup(p);
+        if (b == NULL) {
+          SAFE_FREE(x);
+          ssh_set_error_oom(session);
+          return -1;
+        }
+        i = 0;
+        ssh_options_set(session, SSH_OPTIONS_SSH2, &i);
+
+        for (a = strtok(b, ","); a; a = strtok(NULL, ",")) {
+          switch (atoi(a)) {
+            case 1:
+              break;
+            case 2:
+              i = 1;
+              ssh_options_set(session, SSH_OPTIONS_SSH2, &i);
+              break;
+            default:
+              break;
+          }
+        }
+        SAFE_FREE(b);
+      }
+      break;
    case SOC_TIMEOUT:
      l = ssh_config_get_long(&s, -1);
      if (l >= 0 && *parsing) {
@@ -988,7 +803,7 @@ ssh_config_parse_line(ssh_session session,
            ssh_options_set(session, SSH_OPTIONS_HOSTKEYS, p);
        }
        break;
-    case SOC_PUBKEYACCEPTEDKEYTYPES:
+    case SOC_PUBKEYACCEPTEDTYPES:
        p = ssh_config_get_str_tok(&s, NULL);
        if (p && *parsing) {
            ssh_options_set(session, SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES, p);
@@ -1165,19 +980,13 @@ ssh_config_parse_line(ssh_session session,
              keyword, count);
      break;
    case SOC_UNSUPPORTED:
-      SSH_LOG(SSH_LOG_INFO, "Unsupported option: %s, line: %d",
+      SSH_LOG(SSH_LOG_RARE, "Unsupported option: %s, line: %d",
              keyword, count);
      break;
    case SOC_UNKNOWN:
-      SSH_LOG(SSH_LOG_INFO, "Unknown option: %s, line: %d",
+      SSH_LOG(SSH_LOG_WARN, "Unknown option: %s, line: %d",
              keyword, count);
      break;
-    case SOC_IDENTITYAGENT:
-      p = ssh_config_get_str_tok(&s, NULL);
-      if (p && *parsing) {
-          ssh_options_set(session, SSH_OPTIONS_IDENTITY_AGENT, p);
-      }
-      break;
    default:
      ssh_set_error(session, SSH_FATAL, "ERROR - unimplemented opcode: %d",
              opcode);
@@ -1203,24 +1012,18 @@ int ssh_config_parse_file(ssh_session session, const char *filename)
    unsigned int count = 0;
    FILE *f;
    int parsing, rv;
-    bool global = 0;

    f = fopen(filename, "r");
    if (f == NULL) {
        return 0;
    }

-    rv = strcmp(filename, GLOBAL_CLIENT_CONFIG);
-    if (rv == 0) {
-        global = true;
-    }
-
    SSH_LOG(SSH_LOG_PACKET, "Reading configuration data from %s", filename);

    parsing = 1;
    while (fgets(line, sizeof(line), f)) {
        count++;
-        rv = ssh_config_parse_line(session, line, count, &parsing, 0, global);
+        rv = ssh_config_parse_line(session, line, count, &parsing);
        if (rv < 0) {
            fclose(f);
            return -1;
@@ -1230,57 +1033,3 @@ int ssh_config_parse_file(ssh_session session, const char *filename)
    fclose(f);
    return 0;
 }
-
-/* @brief Parse configuration string and set the options to the given session
- *
- * @params[in] session   The ssh session
- * @params[in] input     Null terminated string containing the configuration
- *
- * @returns    SSH_OK on successful parsing the configuration string,
- *             SSH_ERROR on error
- */
-int ssh_config_parse_string(ssh_session session, const char *input)
-{
-    char line[MAX_LINE_SIZE] = {0};
-    const char *c = input, *line_start = input;
-    unsigned int line_num = 0, line_len;
-    int parsing, rv;
-
-    SSH_LOG(SSH_LOG_DEBUG, "Reading configuration data from string:");
-    SSH_LOG(SSH_LOG_DEBUG, "START\n%s\nEND", input);
-
-    parsing = 1;
-    while (1) {
-        line_num++;
-        line_start = c;
-        c = strchr(line_start, '\n');
-        if (c == NULL) {
-            /* if there is no newline at the end of the string */
-            c = strchr(line_start, '\0');
-        }
-        if (c == NULL) {
-            /* should not happen, would mean a string without trailing '\0' */
-            SSH_LOG(SSH_LOG_WARN, "No trailing '\\0' in config string");
-            return SSH_ERROR;
-        }
-        line_len = c - line_start;
-        if (line_len > MAX_LINE_SIZE - 1) {
-            SSH_LOG(SSH_LOG_WARN, "Line %u too long: %u characters",
-                    line_num, line_len);
-            return SSH_ERROR;
-        }
-        memcpy(line, line_start, line_len);
-        line[line_len] = '\0';
-        SSH_LOG(SSH_LOG_DEBUG, "Line %u: %s", line_num, line);
-        rv = ssh_config_parse_line(session, line, line_num, &parsing, 0, false);
-        if (rv < 0) {
-            return SSH_ERROR;
-        }
-        if (*c == '\0') {
-            break;
-        }
-        c++;
-    }
-
-    return SSH_OK;
-}
--- a/src/config_parser.c
+++ b/src/config_parser.c
@@ -31,11 +31,6 @@
 #include "libssh/config_parser.h"
 #include "libssh/priv.h"

-/* Returns the original string after skipping the leading whitespace
- * and optional quotes.
- * This is useful in case we need to get the rest of the line (for example
- * external command).
- */
 char *ssh_config_get_cmd(char **str)
 {
    register char *c;
@@ -70,55 +65,23 @@ out:
    return r;
 }

-/* Returns the next token delimited by whitespace or equal sign (=)
- * respecting the quotes creating separate token (including whitespaces).
- */
 char *ssh_config_get_token(char **str)
 {
    register char *c;
-    bool had_equal = false;
-    char *r = NULL;
+    char *r;

-    /* Ignore leading spaces */
-    for (c = *str; *c; c++) {
-        if (! isblank(*c)) {
-            break;
+    c = ssh_config_get_cmd(str);
+
+    for (r = c; *c; c++) {
+        if (isblank(*c) || *c == '=') {
+            *c = '\0';
+            goto out;
        }
    }

-    /* If we start with quote, return the whole quoted block */
-    if (*c == '\"') {
-        for (r = ++c; *c; c++) {
-            if (*c == '\"' || *c == '\n') {
-                *c = '\0';
-                c++;
-                break;
-            }
-            /* XXX Unmatched quotes extend to the end of line */
-        }
-    } else {
-        /* Otherwise terminate on space, equal or newline */
-        for (r = c; *c; c++) {
-            if (*c == '\0') {
-                goto out;
-            } else if (isblank(*c) || *c == '=' || *c == '\n') {
-                had_equal = (*c == '=');
-                *c = '\0';
-                c++;
-                break;
-            }
-        }
-    }
-
-    /* Skip any other remaining whitespace */
-    while (isblank(*c) || *c == '\n' || (!had_equal && *c == '=')) {
-        if (*c == '=') {
-            had_equal = true;
-        }
-        c++;
-    }
 out:
-    *str = c;
+    *str = c + 1;
+
    return r;
 }

--- a/src/connect.c
+++ b/src/connect.c
@@ -25,13 +25,9 @@

 #include <errno.h>
 #include <fcntl.h>
-#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif /* HAVE_SYS_TIME_H */

 #include "libssh/libssh.h"
 #include "libssh/misc.h"
@@ -183,13 +179,11 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
    }

    for (itr = ai; itr != NULL; itr = itr->ai_next) {
-        char err_msg[SSH_ERRNO_MSG_MAX] = {0};
        /* create socket */
        s = socket(itr->ai_family, itr->ai_socktype, itr->ai_protocol);
        if (s < 0) {
            ssh_set_error(session, SSH_FATAL,
-                          "Socket create failed: %s",
-                          ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                          "Socket create failed: %s", strerror(errno));
            continue;
        }

@@ -216,8 +210,7 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
            {
                if (bind(s, bind_itr->ai_addr, bind_itr->ai_addrlen) < 0) {
                    ssh_set_error(session, SSH_FATAL,
-                                  "Binding local address: %s",
-                                  ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                                  "Binding local address: %s", strerror(errno));
                    continue;
                } else {
                    break;
@@ -249,7 +242,7 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
            if (rc < 0) {
                ssh_set_error(session, SSH_FATAL,
                              "Failed to set TCP_NODELAY on socket: %s",
-                              ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                              strerror(errno));
                ssh_connect_socket_close(s);
                s = -1;
                continue;
@@ -260,8 +253,7 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
        rc = connect(s, itr->ai_addr, itr->ai_addrlen);
        if (rc == -1 && (errno != 0) && (errno != EINPROGRESS)) {
            ssh_set_error(session, SSH_FATAL,
-                          "Failed to connect: %s",
-                          ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
+                          "Failed to connect: %s", strerror(errno));
            ssh_connect_socket_close(s);
            s = -1;
            continue;
@@ -293,14 +285,14 @@ static int ssh_select_cb (socket_t fd, int revents, void *userdata)
 /**
 * @brief A wrapper for the select syscall
 *
- * This function acts more or less like the select(2) syscall.\n
+ * This functions acts more or less like the select(2) syscall.\n
 * There is no support for writing or exceptions.\n
 *
 * @param[in]  channels Arrays of channels pointers terminated by a NULL.
 *                      It is never rewritten.
 *
- * @param[out] outchannels Arrays of the same size as "channels", there is no
- *                         need to initialize it.
+ * @param[out] outchannels Arrays of same size that "channels", there is no need
+ *                         to initialize it.
 *
 * @param[in]  maxfd    Maximum +1 file descriptor from readfds.
 *
--- a/src/connector.c
+++ b/src/connector.c
@@ -30,9 +30,7 @@
 #include <stdbool.h>
 #include <sys/stat.h>

-#ifndef CHUNKSIZE
 #define CHUNKSIZE 4096
-#endif

 #ifdef _WIN32
 # ifdef HAVE_IO_H
@@ -85,7 +83,7 @@ static int ssh_connector_channel_data_cb(ssh_session session,
                                         void *userdata);
 static int ssh_connector_channel_write_wontblock_cb(ssh_session session,
                                                    ssh_channel channel,
-                                                    uint32_t bytes,
+                                                    size_t bytes,
                                                    void *userdata);
 static ssize_t ssh_connector_fd_read(ssh_connector connector,
                                     void *buffer,
@@ -216,7 +214,7 @@ static void ssh_connector_except_channel(ssh_connector connector,
 /**
 * @internal
 *
- * @brief Reset the poll events to be followed for each file descriptor.
+ * @brief Reset the poll events to be followed for each file descriptors.
 */
 static void ssh_connector_reset_pollevents(ssh_connector connector)
 {
@@ -248,14 +246,14 @@ static void ssh_connector_fd_in_cb(ssh_connector connector)
    uint32_t toread = CHUNKSIZE;
    ssize_t r;
    ssize_t w;
-    ssize_t total = 0;
+    int total = 0;
    int rc;

    SSH_LOG(SSH_LOG_TRACE, "connector POLLIN event for fd %d", connector->in_fd);

    if (connector->out_wontblock) {
        if (connector->out_channel != NULL) {
-            uint32_t size = ssh_channel_window_size(connector->out_channel);
+            size_t size = ssh_channel_window_size(connector->out_channel);

            /* Don't attempt reading more than the window */
            toread = MIN(size, CHUNKSIZE);
@@ -328,9 +326,9 @@ static void ssh_connector_fd_in_cb(ssh_connector connector)
 */
 static void ssh_connector_fd_out_cb(ssh_connector connector){
    unsigned char buffer[CHUNKSIZE];
-    ssize_t r;
-    ssize_t w;
-    ssize_t total = 0;
+    int r;
+    int w;
+    int total = 0;
    SSH_LOG(SSH_LOG_TRACE, "connector POLLOUT event for fd %d", connector->out_fd);

    if(connector->in_available){
@@ -432,7 +430,7 @@ static int ssh_connector_channel_data_cb(ssh_session session,
 {
    ssh_connector connector = userdata;
    int w;
-    uint32_t window;
+    size_t window;

    (void) session;
    (void) channel;
@@ -446,14 +444,11 @@ static int ssh_connector_channel_data_cb(ssh_session session,
    } else if (!is_stderr && !(connector->in_flags & SSH_CONNECTOR_STDOUT)) {
        /* ignore stdout */
        return 0;
-    } else if (len == 0) {
-        /* ignore empty data */
-        return 0;
    }

    if (connector->out_wontblock) {
        if (connector->out_channel != NULL) {
-            uint32_t window_len;
+            int window_len;

            window = ssh_channel_window_size(connector->out_channel);
            window_len = MIN(window, len);
@@ -517,7 +512,7 @@ static int ssh_connector_channel_data_cb(ssh_session session,
 */
 static int ssh_connector_channel_write_wontblock_cb(ssh_session session,
                                                    ssh_channel channel,
-                                                    uint32_t bytes,
+                                                    size_t bytes,
                                                    void *userdata)
 {
    ssh_connector connector = userdata;
@@ -529,7 +524,7 @@ static int ssh_connector_channel_write_wontblock_cb(ssh_session session,
    SSH_LOG(SSH_LOG_TRACE, "Channel write won't block");
    if (connector->in_available) {
        if (connector->in_channel != NULL) {
-            uint32_t len = MIN(CHUNKSIZE, bytes);
+            size_t len = MIN(CHUNKSIZE, bytes);

            r = ssh_channel_read_nonblocking(connector->in_channel,
                                             buffer,
--- a/src/crypto_common.c
+++ b/src/crypto_common.c
@@ -1,36 +0,0 @@
-/*
- * This file is part of the SSH Library
- *
- * Copyright (c) 2020 by Anderson Toshiyuki Sasaki - Red Hat, 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, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include "config.h"
-#include "libssh/crypto.h"
-
-int secure_memcmp(const void *s1, const void *s2, size_t n)
-{
-    size_t i;
-    uint8_t status = 0;
-    const uint8_t *p1 = s1;
-    const uint8_t *p2 = s2;
-
-    for (i = 0; i < n; i++) {
-        status |= (p1[i] ^ p2[i]);
-    }
-
-    return (status != 0);
-}
--- a/src/curve25519.c
+++ b/src/curve25519.c
@@ -39,7 +39,7 @@
 #include "libssh/pki.h"
 #include "libssh/bignum.h"

-#if defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_X25519)
+#ifdef HAVE_OPENSSL_X25519
 #include <openssl/err.h>
 #endif

@@ -59,7 +59,7 @@ static struct ssh_packet_callbacks_struct ssh_curve25519_client_callbacks = {
 static int ssh_curve25519_init(ssh_session session)
 {
    int rc;
-#if defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_X25519)
+#ifdef HAVE_OPENSSL_X25519
    EVP_PKEY_CTX *pctx = NULL;
    EVP_PKEY *pkey = NULL;
    size_t pubkey_len = CURVE25519_PUBKEY_SIZE;
@@ -136,7 +136,7 @@ static int ssh_curve25519_init(ssh_session session)
        crypto_scalarmult_base(session->next_crypto->curve25519_client_pubkey,
                               session->next_crypto->curve25519_privkey);
    }
-#endif /* defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_X25519) */
+#endif /* HAVE_OPENSSL_X25519 */

    return SSH_OK;
 }
@@ -176,11 +176,11 @@ static int ssh_curve25519_build_k(ssh_session session)
 {
    ssh_curve25519_pubkey k;

-#if defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_X25519)
+#ifdef HAVE_OPENSSL_X25519
    EVP_PKEY_CTX *pctx = NULL;
    EVP_PKEY *pkey = NULL, *pubkey = NULL;
-    size_t shared_key_len = sizeof(k);
-    int rc, ret = SSH_ERROR;
+    size_t shared_key_len;
+    int rc;

    pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_X25519, NULL,
                                        session->next_crypto->curve25519_privkey,
@@ -197,7 +197,8 @@ static int ssh_curve25519_build_k(ssh_session session)
        SSH_LOG(SSH_LOG_TRACE,
                "Failed to initialize X25519 context: %s",
                ERR_error_string(ERR_get_error(), NULL));
-        goto out;
+        EVP_PKEY_free(pkey);
+        return SSH_ERROR;
    }

    rc = EVP_PKEY_derive_init(pctx);
@@ -205,7 +206,9 @@ static int ssh_curve25519_build_k(ssh_session session)
        SSH_LOG(SSH_LOG_TRACE,
                "Failed to initialize X25519 key derivation: %s",
                ERR_error_string(ERR_get_error(), NULL));
-        goto out;
+        EVP_PKEY_free(pkey);
+        EVP_PKEY_CTX_free(pctx);
+        return SSH_ERROR;
    }

    if (session->server) {
@@ -221,7 +224,9 @@ static int ssh_curve25519_build_k(ssh_session session)
        SSH_LOG(SSH_LOG_TRACE,
                "Failed to create X25519 public key EVP_PKEY: %s",
                ERR_error_string(ERR_get_error(), NULL));
-        goto out;
+        EVP_PKEY_free(pkey);
+        EVP_PKEY_CTX_free(pctx);
+        return SSH_ERROR;
    }

    rc = EVP_PKEY_derive_set_peer(pctx, pubkey);
@@ -229,23 +234,23 @@ static int ssh_curve25519_build_k(ssh_session session)
        SSH_LOG(SSH_LOG_TRACE,
                "Failed to set peer X25519 public key: %s",
                ERR_error_string(ERR_get_error(), NULL));
-        goto out;
+        EVP_PKEY_free(pkey);
+        EVP_PKEY_free(pubkey);
+        EVP_PKEY_CTX_free(pctx);
+        return SSH_ERROR;
    }

-    rc = EVP_PKEY_derive(pctx, k, &shared_key_len);
+    rc = EVP_PKEY_derive(pctx,
+                         k,
+                         &shared_key_len);
    if (rc != 1) {
        SSH_LOG(SSH_LOG_TRACE,
                "Failed to derive X25519 shared secret: %s",
                ERR_error_string(ERR_get_error(), NULL));
-        goto out;
-    }
-    ret = SSH_OK;
-out:
-    EVP_PKEY_free(pkey);
-    EVP_PKEY_free(pubkey);
-    EVP_PKEY_CTX_free(pctx);
-    if (ret == SSH_ERROR) {
-        return ret;
+        EVP_PKEY_free(pkey);
+        EVP_PKEY_free(pubkey);
+        EVP_PKEY_CTX_free(pctx);
+        return SSH_ERROR;
    }
 #else
    if (session->server) {
@@ -255,7 +260,7 @@ out:
        crypto_scalarmult(k, session->next_crypto->curve25519_privkey,
                          session->next_crypto->curve25519_server_pubkey);
    }
-#endif /* defined(HAVE_LIBCRYPTO) && defined(HAVE_OPENSSL_X25519) */
+#endif /* HAVE_OPENSSL_X25519 */

    bignum_bin2bn(k, CURVE25519_PUBKEY_SIZE, &session->next_crypto->shared_secret);
    if (session->next_crypto->shared_secret == NULL) {
@@ -294,7 +299,7 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_curve25519_reply){
  }

  rc = ssh_dh_import_next_pubkey_blob(session, pubkey_blob);
-  SSH_STRING_FREE(pubkey_blob);
+  ssh_string_free(pubkey_blob);
  if (rc != 0) {
      ssh_set_error(session,
                    SSH_FATAL,
@@ -310,11 +315,11 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_curve25519_reply){
  if (ssh_string_len(q_s_string) != CURVE25519_PUBKEY_SIZE){
 	  ssh_set_error(session, SSH_FATAL, "Incorrect size for server Curve25519 public key: %d",
 			  (int)ssh_string_len(q_s_string));
-	  SSH_STRING_FREE(q_s_string);
+	  ssh_string_free(q_s_string);
 	  goto error;
  }
  memcpy(session->next_crypto->curve25519_server_pubkey, ssh_string_data(q_s_string), CURVE25519_PUBKEY_SIZE);
-  SSH_STRING_FREE(q_s_string);
+  ssh_string_free(q_s_string);

  signature = ssh_buffer_get_ssh_string(packet);
  if (signature == NULL) {
@@ -377,13 +382,12 @@ void ssh_server_curve25519_init(ssh_session session){
 */
 static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
    /* ECDH keys */
-    ssh_string q_c_string = NULL;
-    ssh_string q_s_string = NULL;
+    ssh_string q_c_string;
+    ssh_string q_s_string;
    ssh_string server_pubkey_blob = NULL;

    /* SSH host keys (rsa,dsa,ecdsa) */
-    ssh_key privkey = NULL;
-    enum ssh_digest_e digest = SSH_DIGEST_AUTO;
+    ssh_key privkey;
    ssh_string sig_blob = NULL;
    int rc;
    (void)type;
@@ -402,12 +406,13 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
                      SSH_FATAL,
                      "Incorrect size for server Curve25519 public key: %zu",
                      ssh_string_len(q_c_string));
+        ssh_string_free(q_c_string);
        goto error;
    }

    memcpy(session->next_crypto->curve25519_client_pubkey,
           ssh_string_data(q_c_string), CURVE25519_PUBKEY_SIZE);
-    SSH_STRING_FREE(q_c_string);
+    ssh_string_free(q_c_string);
    /* Build server's keypair */

    rc = ssh_curve25519_init(session);
@@ -430,7 +435,7 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
    }

    /* privkey is not allocated */
-    rc = ssh_get_key_params(session, &privkey, &digest);
+    rc = ssh_get_key_params(session, &privkey);
    if (rc == SSH_ERROR) {
        goto error;
    }
@@ -450,7 +455,7 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
    /* add host's public key */
    rc = ssh_buffer_add_ssh_string(session->out_buffer,
                                   server_pubkey_blob);
-    SSH_STRING_FREE(server_pubkey_blob);
+    ssh_string_free(server_pubkey_blob);
    if (rc < 0) {
        ssh_set_error_oom(session);
        goto error;
@@ -459,33 +464,28 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
    /* add ecdh public key */
    q_s_string = ssh_string_new(CURVE25519_PUBKEY_SIZE);
    if (q_s_string == NULL) {
-        ssh_set_error_oom(session);
        goto error;
    }

-    rc = ssh_string_fill(q_s_string,
-                         session->next_crypto->curve25519_server_pubkey,
-                         CURVE25519_PUBKEY_SIZE);
-    if (rc < 0) {
-        ssh_set_error(session, SSH_FATAL, "Could not copy public key");
-        goto error;
-    }
+    ssh_string_fill(q_s_string,
+                    session->next_crypto->curve25519_server_pubkey,
+                    CURVE25519_PUBKEY_SIZE);

    rc = ssh_buffer_add_ssh_string(session->out_buffer, q_s_string);
-    SSH_STRING_FREE(q_s_string);
+    ssh_string_free(q_s_string);
    if (rc < 0) {
        ssh_set_error_oom(session);
        goto error;
    }
    /* add signature blob */
-    sig_blob = ssh_srv_pki_do_sign_sessionid(session, privkey, digest);
+    sig_blob = ssh_srv_pki_do_sign_sessionid(session, privkey);
    if (sig_blob == NULL) {
        ssh_set_error(session, SSH_FATAL, "Could not sign the session id");
        goto error;
    }

    rc = ssh_buffer_add_ssh_string(session->out_buffer, sig_blob);
-    SSH_STRING_FREE(sig_blob);
+    ssh_string_free(sig_blob);
    if (rc < 0) {
        ssh_set_error_oom(session);
        goto error;
@@ -512,8 +512,6 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){

    return SSH_PACKET_USED;
 error:
-    SSH_STRING_FREE(q_c_string);
-    SSH_STRING_FREE(q_s_string);
    ssh_buffer_reinit(session->out_buffer);
    session->session_state=SSH_SESSION_STATE_ERROR;
    return SSH_PACKET_USED;
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .9.4
 .8.2