bump version to 0.1.3

See https://cloudlinux.zendesk.com/hc/en-us/articles/12225072530204-yum-update-error-Error-GPG-check-FAILED

.github/workflows/build-macos.yml

@@ -2,9 +2,9 @@ name: build on macOS
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
 
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
@@ -30,7 +30,7 @@ jobs:
       run: echo "HOMEBREW_PREFIX=$(brew --prefix)" >> $GITHUB_OUTPUT
 
     - name: patch to libssh
-      run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+      run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
     - name: Configure CMake
       # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.

.github/workflows/build-ubuntu.yml

@@ -2,9 +2,9 @@ name: build on ubuntu
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
 
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
@@ -23,10 +23,12 @@ jobs:
         submodules: true
 
     - name: install build dependency
-      run: sudo ./scripts/install-build-deps.sh
+      run: |
+        sudo apt-get update
+        sudo ./scripts/install-build-deps.sh
 
     - name: patch to libssh
-      run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+      run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
     - name: Configure CMake
       # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.

.github/workflows/codeql.yml

@@ -13,10 +13,10 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   schedule:
     - cron: '35 11 * * 5'
 
@@ -43,10 +43,12 @@ jobs:
         submodules: true
 
     - name: install build dependency
-      run: sudo ./scripts/install-build-deps.sh
+      run: |
+        sudo apt-get update
+        sudo ./scripts/install-build-deps.sh
 
     - name: patch to libssh
-      run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+      run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
           submodules: true
 
       - name: patch to libssh
-        run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+        run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
       # TODO: just building docker does not require packages. fix CMakeLists
       - name: install build dependency
@@ -45,8 +45,8 @@ jobs:
           files: |
             ${{github.workspace}}/build/mscp_ubuntu-20.04-x86_64.deb
             ${{github.workspace}}/build/mscp_ubuntu-22.04-x86_64.deb
-            ${{github.workspace}}/build/mscp_centos-8-x86_64.rpm
-            ${{github.workspace}}/build/mscp_rocky-8.6-x86_64.rpm
+            ${{github.workspace}}/build/mscp_rocky-8.8-x86_64.rpm
+            ${{github.workspace}}/build/mscp_almalinux-8.8-x86_64.rpm
             ${{github.workspace}}/build/mscp_alpine-3.17-x86_64.static
             ${{github.workspace}}/build/mscp.linux.x86.static
 
@@ -58,7 +58,7 @@ jobs:
           submodules: true
 
       - name: patch to libssh
-        run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+        run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
       - name: Set variables
         run: |

.github/workflows/test.yml

@@ -2,9 +2,9 @@ name: test
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
 
 env:
   BUILD_TYPE: Release
@@ -18,11 +18,13 @@ jobs:
         submodules: true
 
     - name: patch to libssh
-      run: patch -d libssh -p1 < patch/libssh-0.10.4.patch
+      run: patch -d libssh -p1 < patch/libssh-0.10.6-2-g6f1b1e76.patch
 
     # TODO: just building docker does not require libssh. fix CMakeLists
     - name: install build dependency
-      run: sudo ./scripts/install-build-deps.sh
+      run: |
+        sudo apt-get update
+        sudo ./scripts/install-build-deps.sh
 
     - name: configure CMake
       run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}

.gitignore

@@ -4,6 +4,8 @@ compile_commands.json
 CMakeUserPresets.json
 .*.swp
 
+include/mscp_version.h
+
 dist
 *.egg-info
 __pycache__

CMakeLists.txt

@@ -6,6 +6,26 @@ project(mscp
 	VERSION ${MSCP_VERSION}
 	LANGUAGES C)
 
+
+find_package(Git)
+if (Git_FOUND)
+	# based on https://github.com/nocnokneo/cmake-git-versioning-example
+	execute_process(
+		COMMAND	${GIT_EXECUTABLE} describe --tags --dirty --match "v*"
+		OUTPUT_VARIABLE	GIT_DESCRIBE_VERSION
+		RESULT_VARIABLE	GIT_DESCRIBE_ERROR_CODE
+		OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if(NOT GIT_DESCRIBE_ERROR_CODE)
+		set(MSCP_BUILD_VERSION ${GIT_DESCRIBE_VERSION})
+	endif()
+endif()
+
+if (NOT MSCP_BUILD_VERSION)
+	message(STATUS "Failed to determine version via Git. Use VERSION file instead.")
+	set(MSCP_BUILD_VERSION v${MSCP_VERSION})
+endif()
+
+
 include(GNUInstallDirs)
 
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
@@ -32,6 +52,8 @@ if (BUILD_STATIC)
 endif()
 
 
+option(INSTALL_EXECUTABLE_ONLY OFF) # do not install libmscp
+
 
 # add libssh static library
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
@@ -62,9 +84,16 @@ if(BUILD_CONAN)
 	list(APPEND MSCP_LINK_LIBS OpenSSL::Crypto)
 endif()
 
-set(LIBMSCP_SRC src/mscp.c src/ssh.c src/path.c src/platform.c src/message.c)
+
+# generate version header file
+configure_file(
+	${mscp_SOURCE_DIR}/include/mscp_version.h.in
+	${mscp_SOURCE_DIR}/include/mscp_version.h)
+
 
 # libmscp.so
+set(LIBMSCP_SRC
+	src/mscp.c src/ssh.c src/fileops.c src/path.c src/platform.c src/message.c)
 add_library(mscp-shared SHARED ${LIBMSCP_SRC})
 target_include_directories(mscp-shared
 	PUBLIC	$<BUILD_INTERFACE:${mscp_SOURCE_DIR}/include>
@@ -77,7 +106,9 @@ set_target_properties(mscp-shared
 	OUTPUT_NAME	mscp
 	PUBLIC_HEADER	${mscp_SOURCE_DIR}/include/mscp.h)
 
-install(TARGETS mscp-shared)
+if(!INSTALL_EXECUTABLE_ONLY)
+	install(TARGETS mscp-shared)
+endif()
 
 
 # libmscp.a
@@ -90,7 +121,9 @@ set_target_properties(mscp-static
 	PROPERTIES
 	OUTPUT_NAME	mscp)
 
-install(TARGETS mscp-static)
+if(!INSTALL_EXECUTABLE_ONLY)
+	install(TARGETS mscp-static)
+endif()
 
 
 # mscp executable
@@ -104,12 +137,26 @@ if (BUILD_STATIC)
 	target_link_options(mscp PRIVATE -static)
 endif()
 target_compile_options(mscp PRIVATE ${MSCP_COMPILE_OPTS})
-target_compile_definitions(mscp PUBLIC _VERSION="${PROJECT_VERSION}")
 
 
 install(TARGETS mscp RUNTIME DESTINATION bin)
 
 
+# mscp manpage and document
+configure_file(
+	${mscp_SOURCE_DIR}/doc/mscp.1.in
+	${PROJECT_BINARY_DIR}/mscp.1)
+
+add_custom_target(update-mscp-rst
+	COMMENT "Update doc/mscp.rst from mscp.1.in"
+	WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+	COMMAND
+	pandoc -s -f man mscp.1 -t rst -o ${PROJECT_SOURCE_DIR}/doc/mscp.rst)
+
+install(FILES ${PROJECT_BINARY_DIR}/mscp.1
+	DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+
+
 # Test
 add_test(NAME	pytest
 	COMMAND	python3 -m pytest -v
@@ -121,9 +168,8 @@ enable_testing()
 
 
 # CPACK Rules
-set(CPACK_SET_DESTDIR		true)
-set(CPACK_PROJECT_NAME		${PROJECT_NAME})
-set(CPACK_PROJECT_VERSION	${PROJECT_VERSION})
+#set(CPACK_SET_DESTDIR		true)
+set(CPACK_PACKAGE_NAME		${PROJECT_NAME})
 set(CPACK_PACKAGE_CONTACT	"Ryo Nakamura <upa@haeena.net>")
 set(CPACK_PACKAGE_DESCRIPTION
 	"mscp, copy files over multiple ssh connections")
@@ -153,6 +199,7 @@ if(UNIX AND NOT APPLE) # on linux
 	set(CPACK_RPM_PACKAGE_REQUIRES		${DIST_DEP})
 	set(CPACK_RPM_PACKAGE_HOMEPAGE		"https://github.com/upa/mscp")
 	set(CPACK_RPM_PACKAGE_DESCRIPTION	${CPACK_PACKAGE_DESCRIPTION})
+	set(CPACK_RPM_PACKAGE_LICENSE		"GPLv3")
 endif() # on linux
 
 include(CPack)
@@ -162,9 +209,9 @@ include(CPack)
 # Custom targets to build and test mscp in docker containers.
 # foreach(IN ZIP_LISTS) (cmake >= 3.17) can shorten the following lists.
 # However, ubuntu 20.04 has cmake 3.16.3. So this is a roundabout trick.
-list(APPEND DIST_NAMES	ubuntu	ubuntu	centos	rocky	alpine)
-list(APPEND DIST_VERS	20.04	22.04	8	8.6	3.17)
-list(APPEND DIST_PKGS	deb	deb	rpm	rpm	static)
+list(APPEND DIST_NAMES	ubuntu	ubuntu	rocky	almalinux	alpine)
+list(APPEND DIST_VERS	20.04	22.04	8.8	8.8		3.17)
+list(APPEND DIST_PKGS	deb	deb	rpm	rpm		static)
 
 list(LENGTH DIST_NAMES _DIST_LISTLEN)
 math(EXPR DIST_LISTLEN "${_DIST_LISTLEN} - 1")
@@ -185,11 +232,18 @@ foreach(x RANGE ${DIST_LISTLEN})
 		COMMAND
 		docker build -t ${DOCKER_IMAGE} -f docker/${DOCKER_INDEX}.Dockerfile .)
 
+	add_custom_target(docker-build-${DOCKER_INDEX}-no-cache
+		COMMENT "Build mscp in ${DOCKER_IMAGE} container"
+		WORKING_DIRECTORY ${mscp_SOURCE_DIR}
+		COMMAND
+		docker build --no-cache -t ${DOCKER_IMAGE} -f docker/${DOCKER_INDEX}.Dockerfile .)
+
 	add_custom_target(docker-test-${DOCKER_INDEX}
 		COMMENT "Test mscp in ${DOCKER_IMAGE} container"
 		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
 		COMMAND
-		docker run --init --rm ${DOCKER_IMAGE} /mscp/scripts/test-in-container.sh)
+		docker run --init --rm --sysctl net.ipv6.conf.all.disable_ipv6=0
+		${DOCKER_IMAGE} /mscp/scripts/test-in-container.sh)
 
 	add_custom_target(docker-pkg-${DOCKER_INDEX}
 		COMMENT "Retrieve mscp package from ${DOCKER_IMAGE} container"
@@ -198,11 +252,13 @@ foreach(x RANGE ${DIST_LISTLEN})
 		docker run --rm -v ${CMAKE_BINARY_DIR}:/out ${DOCKER_IMAGE}
 		cp /mscp/build/${PKG_FILE_NAME} /out/)
 
-	list(APPEND DOCKER_BUILDS	docker-build-${DOCKER_INDEX})
-	list(APPEND DOCKER_TESTS	docker-test-${DOCKER_INDEX})
-	list(APPEND DOCKER_PKGS		docker-pkg-${DOCKER_INDEX})
+	list(APPEND DOCKER_BUILDS		docker-build-${DOCKER_INDEX})
+	list(APPEND DOCKER_BUILDS_NO_CACHE	docker-build-${DOCKER_INDEX}-no-cache)
+	list(APPEND DOCKER_TESTS		docker-test-${DOCKER_INDEX})
+	list(APPEND DOCKER_PKGS			docker-pkg-${DOCKER_INDEX})
 endforeach()
 
-add_custom_target(docker-build-all	DEPENDS ${DOCKER_BUILDS})
-add_custom_target(docker-test-all	DEPENDS ${DOCKER_TESTS})
-add_custom_target(docker-pkg-all	DEPENDS ${DOCKER_PKGS})
+add_custom_target(docker-build-all		DEPENDS ${DOCKER_BUILDS})
+add_custom_target(docker-build-all-no-cache	DEPENDS ${DOCKER_BUILDS_NO_CACHE})
+add_custom_target(docker-test-all		DEPENDS ${DOCKER_TESTS})
+add_custom_target(docker-pkg-all		DEPENDS ${DOCKER_PKGS})

README.md

@@ -3,30 +3,34 @@
 [![build on ubuntu](https://github.com/upa/mscp/actions/workflows/build-ubuntu.yml/badge.svg)](https://github.com/upa/mscp/actions/workflows/build-ubuntu.yml) [![build on macOS](https://github.com/upa/mscp/actions/workflows/build-macos.yml/badge.svg)](https://github.com/upa/mscp/actions/workflows/build-macos.yml) [![test](https://github.com/upa/mscp/actions/workflows/test.yml/badge.svg)](https://github.com/upa/mscp/actions/workflows/test.yml)
 
 
-`mscp`, a variant of `scp`, copies files over multiple ssh (SFTP)
-connections. Multiple threads and connections in mscp transfer (1)
-multiple files simultaneously and (2) a large file in parallel. It
-would shorten the waiting time for transferring a lot of/large files
-over networks.
+`mscp`, a variant of `scp`, copies files over multiple SSH (SFTP)
+connections by multiple threads. It enables transferring (1) multiple
+files simultaneously and (2) a large file in parallel, reducing the
+transfer time for a lot of/large files over networks.
 
-You can use `mscp` like `scp`, for example, `mscp
-user@example.com:srcfile /tmp/dstfile`. Remote hosts only need to run
-standard `sshd` supporting the SFTP subsystem (e.g. openssh-server),
-and you need to be able to ssh to the hosts as usual. `mscp` does not
-require anything else.
+You can use `mscp` like `scp`, for example:
 
-https://user-images.githubusercontent.com/184632/206889149-7cc6178a-6f0f-41e6-855c-d25e15a9abc5.mp4
+```shell-session
+$ mscp user@example.com:srcfile /tmp/dstfile
+```
+
+Remote hosts only need to run standard `sshd` supporting the SFTP
+subsystem (e.g. openssh-server), and you need to be able to ssh to the
+hosts as usual. `mscp` does not require anything else.
+
+
+https://github.com/upa/mscp/assets/184632/19230f57-be7f-4ef0-98dd-cb4c460f570d
 
 --------------------------------------------------------------------
 
 Differences from `scp` on usage:
 
-- remote glob on remote shell expansion is not supported.
-- remote to remote copy is not supported.
+- Remote-to-remote copy is not supported.
 - `-r` option is not needed to transfer directories.
 - and any other differences I have not implemented and noticed.
 
-
+Paper:
+- Ryo Nakamura and Yohei Kuga. 2023. Multi-threaded scp: Easy and Fast File Transfer over SSH. In Practice and Experience in Advanced Research Computing (PEARC '23). Association for Computing Machinery, New York, NY, USA, 320–323. https://doi.org/10.1145/3569951.3597582
 
 ## Install
 
@@ -36,24 +40,23 @@ Differences from `scp` on usage:
 brew install upa/tap/mscp
 ```
 
-- Ubuntu 22.04
+- Ubuntu
 ```console
-wget https://github.com/upa/mscp/releases/latest/download/mscp_ubuntu-22.04-x86_64.deb
-apt-get install -f ./mscp_ubuntu-22.04-x86_64.deb
+sudo add-apt-repository ppa:upaa/mscp
+sudo apt-get install mscp
 ```
 
-- Ubuntu 20.04
+- Rocky 8.8
 ```console
-wget https://github.com/upa/mscp/releases/latest/download/mscp_ubuntu-20.04-x86_64.deb
-apt-get install -f ./mscp_ubuntu-20.04-x86_64.deb
+yum install https://github.com/upa/mscp/releases/latest/download/mscp_rocky-8.8-x86_64.rpm
 ```
 
-- Rocky 8.6
+- Alma 8.8
 ```console
-yum install https://github.com/upa/mscp/releases/latest/download/mscp_rocky-8.6-x86_64.rpm
+yum install https://github.com/upa/mscp/releases/latest/download/mscp_almalinux-8.8-x86_64.rpm
 ```
 
-- Linux with single binary `mscp` (x86_64 only)
+- Linux with single binary `mscp` (x86_64 only, and not optimal performance)
 ```console
 wget https://github.com/upa/mscp/releases/latest/download/mscp.linux.x86.static -O /usr/local/bin/mscp
 chmod 755 /usr/local/bin/mscp
@@ -62,12 +65,12 @@ chmod 755 /usr/local/bin/mscp
 
 ## Build
 
-mscp depends on a patched [libssh](https://www.libssh.org/).  The
+mscp depends on a patched [libssh](https://www.libssh.org/). The
 patch introduces asynchronous SFTP Write, which is derived from
 https://github.com/limes-datentechnik-gmbh/libssh (see [Re: SFTP Write
 async](https://archive.libssh.org/libssh/2020-06/0000004.html)).
 
-Currently macOS and Linux (Ubuntu, CentOS, Rocky) are supported.
+Currently macOS and Linux (Ubuntu, Rocky and Alma) are supported.
 
 ```console
 # clone this repository
@@ -76,7 +79,7 @@ cd mscp
 
 # prepare patched libssh
 git submodule update --init
-patch -d libssh -p1 < patch/libssh-0.10.4.patch
+patch -d libssh -p1 < patch/$(git --git-dir=./libssh/.git describe).patch
 
 # install build dependency
 bash ./scripts/install-build-deps.sh
@@ -94,104 +97,12 @@ make
 # install the mscp binary to CMAKE_INSTALL_PREFIX/bin (usually /usr/local/bin)
 make install
 ```
+
 Source tar balls (`mscp-X.X.X.tar.gz`, not `Source code`) in
 [Releases page](https://github.com/upa/mscp/releases) contains the patched version
 of libssh. So you can start from cmake with it.
 
-## Run
 
-- Usage
+## Documentation
 
-```console
-$ mscp
-mscp v0.0.8: copy files over multiple ssh connections
-
-Usage: mscp [vqDHdNh] [-n nr_conns] [-m coremask] [-u max_startups]
-            [-s min_chunk_sz] [-S max_chunk_sz] [-a nr_ahead] [-b buf_sz]
-            [-l login_name] [-p port] [-i identity_file]
-            [-c cipher_spec] [-M hmac_spec] [-C compress] source ... target
-```
-
-- Example: copy a 15GB file on memory over a 100Gbps link
-  - Two Intel Xeon Gold 6130 machines directly connected with Intel E810 100Gbps NICs.
-  - Default `openssh-server` runs on the remote host.
-
-```console
-$ mscp /var/ram/test.img 10.0.0.1:/var/ram/
-[======================================] 100%   15GB/15GB    1.7GB/s  00:00 ETA
-```
-
-```console
-# with some optimizations. top speed reaches 3.0GB/s.
-$ mscp -n 5 -m 0x1f -c aes128-gcm@openssh.com /var/ram/test.img 10.0.0.1:/var/ram/
-[======================================] 100%   15GB/15GB    2.4GB/s  00:00 ETA
-```
-
-- `-v` option increments verbose output level.
-
-```console
-$ mscp test 10.0.0.1:
-[=======================================] 100%   49B /49B   198.8B/s   00:00 ETA
-```
-
-```console
-$ mscp -vv test 10.0.0.1:
-file: test/test1 -> ./test/test1
-file: test/testdir/asdf -> ./test/testdir/asdf
-file: test/testdir/qwer -> ./test/testdir/qwer
-file: test/test2 -> ./test/test2
-we have only 4 chunk(s). set number of connections to 4
-connecting to localhost for a copy thread...
-connecting to localhost for a copy thread...
-connecting to localhost for a copy thread...
-copy start: test/test1
-copy start: test/test2
-copy start: test/testdir/asdf
-copy start: test/testdir/qwer
-copy done: test/test1
-copy done: test/test2
-copy done: test/testdir/qwer
-copy done: test/testdir/asdf
-[=======================================] 100%   49B /49B   198.1B/s   00:00 ETA
-```
-
-- Full usage
-
-```console
-$ mscp -h
-mscp v0.0.8: copy files over multiple ssh connections
-
-Usage: mscp [vqDHdNh] [-n nr_conns] [-m coremask] [-u max_startups]
-            [-s min_chunk_sz] [-S max_chunk_sz] [-a nr_ahead] [-b buf_sz]
-            [-l login_name] [-p port] [-i identity_file]
-            [-c cipher_spec] [-M hmac_spec] [-C compress] source ... target
-
-    -n NR_CONNECTIONS  number of connections (default: floor(log(cores)*2)+1)
-    -m COREMASK        hex value to specify cores where threads pinned
-    -u MAX_STARTUPS    number of concurrent outgoing connections (default: 8)
-    -s MIN_CHUNK_SIZE  min chunk size (default: 64MB)
-    -S MAX_CHUNK_SIZE  max chunk size (default: filesize/nr_conn)
-
-    -a NR_AHEAD        number of inflight SFTP commands (default: 32)
-    -b BUF_SZ          buffer size for i/o and transfer
-
-    -v                 increment verbose output level
-    -q                 disable output
-    -D                 dry run. check copy destinations with -vvv
-    -r                 no effect
-
-    -l LOGIN_NAME      login name
-    -p PORT            port number
-    -i IDENTITY        identity file for public key authentication
-    -c CIPHER          cipher spec
-    -M HMAC            hmac spec
-    -C COMPRESS        enable compression: yes, no, zlib, zlib@openssh.com
-    -H                 disable hostkey check
-    -d                 increment ssh debug output level
-    -N                 enable Nagle's algorithm (default disabled)
-    -h                 print this help
-```
-
-
-Note: mscp is still under development, and the author is not
-responsible for any accidents due to mscp.
+[manpage](/doc/mscp.rst) is available.

VERSION

@@ -1 +1 @@
-0.0.8
+0.1.3

debian/.gitignore

@@ -0,0 +1,11 @@
+
+/.debhelper/
+/*/
+!/tests/
+!/source
+
+/*.log
+/*.substvars
+/*.debhelper
+/files
+/mscp

debian/changelog

@@ -0,0 +1,18 @@
+mscp (0.1.3) UNRELEASED; urgency=medium
+
+  * add -I option for inserting intervals between SSH attempts (issue #7)
+  * add -P option, equivalent to -p (just for compatibility)
+  * update libssh to 0.10.6-2-g6f1b1e76 for security fixes
+  * cleanup warning messages when scanning source files fails
+  * fix wrong destination paths for source paths under '/' (issue #8)
+  * reduce memory footprint for coping many (e.g., over 100k) files (issue #8)
+  * add SPDX-License-Identifer to the source files
+  * add manpage
+
+ -- Ryo Nakamura <upa@haeena.net>  Fri, 12 Jan 2024 22:20:24 +0900
+
+mscp (0.1.2) unstable; urgency=medium
+
+  * Initial release for debian packaging
+
+ -- Ryo Nakamura <upa@haeena.net>  Sun, 10 Dec 2023 21:51:49 +0900

debian/compat

@@ -0,0 +1 @@
+10

debian/control

@@ -0,0 +1,17 @@
+Source: mscp
+Section: net
+Priority: optional
+Maintainer: Ryo Nakamura <upa@haeena.net>
+Build-Depends: debhelper (>= 10~), cmake, zlib1g-dev, libssl-dev, libkrb5-dev
+Homepage: https://github.com/upa/mscp
+Standards-Version: 4.5.0.3
+
+
+Package: mscp
+Architecture: linux-any
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Description: mscp, fast file transfer over multiple SSH connections
+ mscp transfers files over multiple SSH connections. Multiple threads
+ and connections in mscp transfer (1) multiple files simultaneously
+ and (2) a large file in parallel. It would shorten the waiting time
+ for transferring a lot of/large files over networks.

debian/copyright

@@ -0,0 +1,12 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Source: https://github.com/upa/mscp
+Upstream-Name: mscp
+Upstream-Contact: Ryo Nakamura <upa@haeena.net>
+
+Files: *
+Copyright: Ryo Nakamura
+License: GPL-3
+
+Files: src/list.h
+Copyright: kazutomo@mcs.anl.gov
+License: GPL

debian/rules

@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+
+%:
+	dh $@
+
+
+override_dh_auto_configure:
+	dh_auto_configure -- \
+		-DINSTALL_EXECUTABLE_ONLY=ON
+
+override_dh_auto_test:
+
+

debian/source/format

@@ -0,0 +1 @@
+3.0 (native)

doc/README.md

@@ -0,0 +1,11 @@
+
+# Document
+
+The base file of documents is `mscp.1.in`. The manpage of mscp and
+`doc/mscp.rst` are generated from `mscp.1.in`.
+
+When `mscp.1.in` is changed, update `doc/mscp.rst` by:
+
+1. `cd build`
+2. `cmake ..`
+3. `make update-mscp-rst`

doc/mscp.1.in

@@ -0,0 +1,316 @@
+.TH MSCP 1 "@MSCP_BUILD_VERSION@" "mscp" "User Commands"
+
+.SH NAME
+mscp \- copy files over multiple SSH connections
+
+.SH SYNOPSIS
+
+.B mscp
+.RB [ \-vqDHdNh ]
+[\c
+.BI \-n \ NR_CONNECTIONS\c
+]
+[\c
+.BI \-m \ COREMASK\c
+]
+[\c
+.BI \-u \ MAX_STARTUPS\c
+]
+[\c
+.BI \-I \ INTERVAL\c
+]
+[\c
+.BI \-s \ MIN_CHUNK_SIZE\c
+]
+[\c
+.BI \-S \ MAX_CHUNK_SIZE\c
+]
+[\c
+.BI \-a \ NR_AHEAD\c
+]
+[\c
+.BI \-b \ BUF_SIZE\c
+]
+[\c
+.BI \-l \ LOGIN_NAME\c
+]
+[\c
+.BR \-p |\c
+.BI \-P \ PORT\c
+]
+[\c
+.BI \-F \ CONFIG\c
+]
+[\c
+.BI \-i \ IDENTITY\c
+]
+[\c
+.BI \-c \ CIPHER\c
+]
+[\c
+.BI \-M \ HMAC\c
+]
+[\c
+.BI \-C \ COMPRESS\c
+]
+.I source ... target
+
+.SH DESCRIPTION
+
+.PP
+.B mscp
+copies files over multiple SSH (SFTP) connections by multiple
+threads. It enables transferring (1) multiple files simultaneously and
+(2) a large file in parallel, reducing the transfer time for a lot
+of/large files over networks.
+
+.PP
+The usage of
+.B mscp
+imitates the
+.B scp
+command of
+.I OpenSSH,
+for example:
+
+.nf
+    $ mscp srcfile user@example.com:dstfile
+.fi
+
+Remote hosts only need to run standard
+.B sshd
+supporting the SFTP subsystem, and users need to be able to
+.B ssh
+to the hosts as usual.
+.B mscp
+does not require anything else.
+
+.PP
+.B mscp
+uses
+.UR https://\:www\:.libssh\:.org
+libssh
+.UE
+as its SSH implementation. Thus, supported SSH features, for example,
+authentication, encryption, and various options in ssh_config, follow
+what
+.I libssh
+supports.
+
+.SH OPTIONS
+.TP
+.B \-n \fINR_CONNECTIONS\fR
+Specifies the number of SSH connections. The default value is
+calculated from the number of CPU cores on the host with the following
+formula: floor(log(nr_cores)*2)+1.
+
+.TP
+.B \-m \fICOREMASK\fR
+Configures CPU cores to be used by the hexadecimal bitmask.  All CPU
+cores are used by default.
+
+.TP
+.B \-u \fIMAX_STARTUPS\fR
+Specifies the number of concurrent outgoing SSH connections.
+.B sshd
+limits the number of simultaneous SSH connection attempts by
+.I MaxStartups
+in
+.I sshd_config.
+The default
+.I MaxStartups
+is 10; thus, we set the default MAX_STARTUPS 8.
+
+.TP
+.B \-I \fIINTERVAL\fR
+Specifies the interval (in seconds) between SSH connection
+attempts. Some firewall products treat SSH connection attempts from a
+single source IP address for a short period as a brute force attack.
+This option inserts intervals between the attempts to avoid being
+determined as an attack. The default value is 0.
+
+.TP
+.B \-s \fIMIN_CHUNK_SIZE\fR
+Specifies the minimum chunk size.
+.B mscp
+divides a file into chunks and copies the chunks in parallel.
+
+.TP
+.B \-S \fIMAX_CHUNK_SIZE\fR
+Specifies the maximum chunk size. The default is file size divided by
+the number of connections.
+
+.TP
+.B \-a \fINR_AHEAD\fR
+Specifies the number of inflight SFTP commands. The default value is
+32.
+
+.TP
+.B \-b \fIBUF_SIZE\fR
+Specifies the buffer size for I/O and transfer over SFTP. The default
+value is 16384. Note that the SSH specification restricts buffer size
+delivered over SSH. Changing this value is not recommended at present.
+
+.TP
+.B \-v
+Increments the verbose output level.
+
+.TP
+.B \-q
+Quiet mode: turns off all outputs.
+
+.TP
+.B \-D
+Dry-run mode: it scans source files to be copied, calculates chunks,
+and resolves destination file paths. Dry-run mode with
+.B -vv
+option enables confirming files to be copied and their destination
+paths.
+
+.TP
+.B \-r
+No effect.
+.B mscp
+copies recursively if a source path is a directory. This option exists
+for just compatibility.
+
+.TP
+.B \-l \fILOGIN_NAME\fR
+Specifies the username to log in on the remote machine as with
+.I ssh(1).
+
+.TP
+.B \-p,\-P \fIPORT\fR
+Specifies the port number to connect to on the remote machine as with
+ssh(1) and scp(1).
+
+.TP
+.B \-F \fICONFIG\fR
+Specifies an alternative per-user ssh configuration file. Note that
+acceptable options in the configuration file are what
+.I libssh
+supports.
+
+.TP
+.B \-i \fIIDENTITY\fR
+Specifies the identity file for public key authentication.
+
+.TP
+.B \-c \fICIPHER\fR
+Selects the cipher to use for encrypting the data transfer. See
+.UR https://\:www\:.libssh\:.org/\:features/
+libssh features
+.UE .
+
+.TP
+.B \-M \fIHMAC\fR
+Specifies MAC hash algorithms. See
+.UR https://\:www\:.libssh\:.org/\:features/
+libssh features
+.UE .
+
+.TP
+.B \-C \fICOMPRESS\fR
+Enables compression: yes, no, zlib, zlib@openssh.com. The default is
+none. See
+.UR https://\:www\:.libssh\:.org/\:features/
+libssh features
+.UE .
+
+.TP
+.B \-H
+Disables hostkey checking.
+
+.TP
+.B \-d
+Increments the ssh debug output level.
+
+.TP
+.B \-N
+Enables Nagle's algorithm. It is disabled by default.
+
+.TP
+.B \-h
+Prints help.
+
+.SH EXIT STATUS
+Exit status is 0 on success,  and >0 if an error occurs.
+
+.SH NOTES
+
+.PP
+.B mscp
+uses glob(3) for globbing pathnames, including matching patterns for
+local and remote paths. However, globbing on the
+.I remote
+side does not work with musl libc (used in Alpine Linux and the
+single-binary version of mscp) because musl libc does not support
+GLOB_ALTDIRFUNC.
+
+.PP
+.B mscp
+does not support remote-to-remote copy, which
+.B scp
+supports.
+
+.SH EXAMPLES
+
+.PP
+Copy a local file to a remote host with different name:
+
+.nf
+    $ mscp ~/src-file 10.0.0.1:copied-file
+.fi
+
+.PP
+Copy a local file and a directory to /tmp at a remote host:
+
+.nf
+    $ mscp ~/src-file dir1 10.0.0.1:/tmp
+.fi
+
+.PP
+In a long fat network, following options might improve performance:
+
+.nf
+    $ mscp -n 64 -m 0xffff -a 64 -c aes128-gcm@openssh.com src 10.0.0.1:
+.fi
+
+.B -n
+increases the number of SSH connections than default,
+.B -m
+pins threads to specific CPU cores,
+.B -a
+increases asynchronous inflight SFTP WRITE/READ commands, and
+.B -c aes128-gcm@openssh.com
+will be faster than the default chacha20-poly1305 cipher, particularly
+on hosts that support AES-NI.
+
+
+
+.SH "SEE ALSO"
+.BR scp (1),
+.BR ssh (1),
+.BR sshd (8).
+
+.SH "PAPER REFERENCE"
+
+
+Ryo Nakamura and Yohei Kuga. 2023. Multi-threaded scp: Easy and Fast
+File Transfer over SSH. In Practice and Experience in Advanced
+Research Computing (PEARC '23). Association for Computing Machinery,
+New York, NY, USA, 320–323.
+.UR https://\:doi\:.org/\:10.1145/\:3569951.3597582
+DOI
+.UE .
+
+
+.SH CONTACT INFROMATION
+.PP
+For pathces, bug reports, or feature requests, please open an issue on
+.UR https://\:github\:.com/\:upa/\:mscp
+GitHub
+.UE .
+
+.SH AUTHORS
+Ryo Nakamura <upa@haeena.net>

doc/mscp.rst

@@ -0,0 +1,210 @@
+====
+MSCP
+====
+
+:Date:   v0.1.2-14-g24617d2
+
+NAME
+====
+
+mscp - copy files over multiple SSH connections
+
+SYNOPSIS
+========
+
+**mscp** [**-vqDHdNh**] [ **-n**\ *NR_CONNECTIONS* ] [
+**-m**\ *COREMASK* ] [ **-u**\ *MAX_STARTUPS* ] [ **-I**\ *INTERVAL* ] [
+**-s**\ *MIN_CHUNK_SIZE* ] [ **-S**\ *MAX_CHUNK_SIZE* ] [
+**-a**\ *NR_AHEAD* ] [ **-b**\ *BUF_SIZE* ] [ **-l**\ *LOGIN_NAME* ] [
+**-p**\ \| **-P**\ *PORT* ] [ **-F**\ *CONFIG* ] [ **-i**\ *IDENTITY* ]
+[ **-c**\ *CIPHER* ] [ **-M**\ *HMAC* ] [ **-C**\ *COMPRESS* ] *source
+... target*
+
+DESCRIPTION
+===========
+
+**mscp** copies files over multiple SSH (SFTP) connections by multiple
+threads. It enables transferring (1) multiple files simultaneously and
+(2) a large file in parallel, reducing the transfer time for a lot
+of/large files over networks.
+
+The usage of **mscp** imitates the **scp** command of *OpenSSH,* for
+example:
+
+::
+
+       $ mscp srcfile user@example.com:dstfile
+
+Remote hosts only need to run standard **sshd** supporting the SFTP
+subsystem, and users need to be able to **ssh** to the hosts as usual.
+**mscp** does not require anything else.
+
+**mscp** uses `libssh <https://www.libssh.org>`__ as its SSH
+implementation. Thus, supported SSH features, for example,
+authentication, encryption, and various options in ssh_config, follow
+what *libssh* supports.
+
+OPTIONS
+=======
+
+**-n NR_CONNECTIONS**
+   Specifies the number of SSH connections. The default value is
+   calculated from the number of CPU cores on the host with the
+   following formula: floor(log(nr_cores)*2)+1.
+
+**-m COREMASK**
+   Configures CPU cores to be used by the hexadecimal bitmask. All CPU
+   cores are used by default.
+
+**-u MAX_STARTUPS**
+   Specifies the number of concurrent outgoing SSH connections. **sshd**
+   limits the number of simultaneous SSH connection attempts by
+   *MaxStartups* in *sshd_config.* The default *MaxStartups* is 10;
+   thus, we set the default MAX_STARTUPS 8.
+
+**-I INTERVAL**
+   Specifies the interval (in seconds) between SSH connection attempts.
+   Some firewall products treat SSH connection attempts from a single
+   source IP address for a short period as a brute force attack. This
+   option inserts intervals between the attempts to avoid being
+   determined as an attack. The default value is 0.
+
+**-s MIN_CHUNK_SIZE**
+   Specifies the minimum chunk size. **mscp** divides a file into chunks
+   and copies the chunks in parallel.
+
+**-S MAX_CHUNK_SIZE**
+   Specifies the maximum chunk size. The default is file size divided by
+   the number of connections.
+
+**-a NR_AHEAD**
+   Specifies the number of inflight SFTP commands. The default value is
+   32.
+
+**-b BUF_SIZE**
+   Specifies the buffer size for I/O and transfer over SFTP. The default
+   value is 16384. Note that the SSH specification restricts buffer size
+   delivered over SSH. Changing this value is not recommended at
+   present.
+
+**-v**
+   Increments the verbose output level.
+
+**-q**
+   Quiet mode: turns off all outputs.
+
+**-D**
+   Dry-run mode: it scans source files to be copied, calculates chunks,
+   and resolves destination file paths. Dry-run mode with **-vv** option
+   enables confirming files to be copied and their destination paths.
+
+**-r**
+   No effect. **mscp** copies recursively if a source path is a
+   directory. This option exists for just compatibility.
+
+**-l LOGIN_NAME**
+   Specifies the username to log in on the remote machine as with
+   *ssh(1).*
+
+**-p,-P PORT**
+   Specifies the port number to connect to on the remote machine as with
+   ssh(1) and scp(1).
+
+**-F CONFIG**
+   Specifies an alternative per-user ssh configuration file. Note that
+   acceptable options in the configuration file are what *libssh*
+   supports.
+
+**-i IDENTITY**
+   Specifies the identity file for public key authentication.
+
+**-c CIPHER**
+   Selects the cipher to use for encrypting the data transfer. See
+   `libssh features <https://www.libssh.org/features/>`__.
+
+**-M HMAC**
+   Specifies MAC hash algorithms. See `libssh
+   features <https://www.libssh.org/features/>`__.
+
+**-C COMPRESS**
+   Enables compression: yes, no, zlib, zlib@openssh.com. The default is
+   none. See `libssh features <https://www.libssh.org/features/>`__.
+
+**-H**
+   Disables hostkey checking.
+
+**-d**
+   Increments the ssh debug output level.
+
+**-N**
+   Enables Nagle's algorithm. It is disabled by default.
+
+**-h**
+   Prints help.
+
+EXIT STATUS
+===========
+
+Exit status is 0 on success, and >0 if an error occurs.
+
+NOTES
+=====
+
+**mscp** uses glob(3) for globbing pathnames, including matching
+patterns for local and remote paths. However, globbing on the *remote*
+side does not work with musl libc (used in Alpine Linux and the
+single-binary version of mscp) because musl libc does not support
+GLOB_ALTDIRFUNC.
+
+**mscp** does not support remote-to-remote copy, which **scp** supports.
+
+EXAMPLES
+========
+
+Copy a local file to a remote host with different name:
+
+::
+
+       $ mscp ~/src-file 10.0.0.1:copied-file
+
+Copy a local file and a directory to /tmp at a remote host:
+
+::
+
+       $ mscp ~/src-file dir1 10.0.0.1:/tmp
+
+In a long fat network, following options might improve performance:
+
+::
+
+       $ mscp -n 64 -m 0xffff -a 64 -c aes128-gcm@openssh.com src 10.0.0.1:
+
+**-n** increases the number of SSH connections than default, **-m** pins
+threads to specific CPU cores, **-a** increases asynchronous inflight
+SFTP WRITE/READ commands, and **-c aes128-gcm@openssh.com** will be
+faster than the default chacha20-poly1305 cipher, particularly on hosts
+that support AES-NI.
+
+SEE ALSO
+========
+
+**scp**\ (1), **ssh**\ (1), **sshd**\ (8).
+
+PAPER REFERENCE
+===============
+
+Ryo Nakamura and Yohei Kuga. 2023. Multi-threaded scp: Easy and Fast
+File Transfer over SSH. In Practice and Experience in Advanced Research
+Computing (PEARC '23). Association for Computing Machinery, New York,
+NY, USA, 320–323. `DOI <https://doi.org/10.1145/3569951.3597582>`__.
+
+CONTACT INFROMATION
+===================
+
+For pathces, bug reports, or feature requests, please open an issue on
+`GitHub <https://github.com/upa/mscp>`__.
+
+AUTHORS
+=======
+
+Ryo Nakamura <upa@haeena.net>

docker/README.md

@@ -8,9 +8,7 @@ docker build -t mscp-ubuntu:20.04 -f docker/ubuntu-20.04.Dockerfile .
 
 docker build -t mscp-ubuntu:22.04 -f docker/ubuntu-22.04.Dockerfile .
 
-docker build -t mscp-centos:8 -f docker/centos-8.Dockerfile .
-
-docker build -t mscp-rocky:8.6 -f docker/rocky-8.6.Dockerfile .
+docker build -t mscp-rocky:8.8 -f docker/rocky-8.Dockerfile .
 ```
 
 Test `mscp` in the containers.
@@ -20,25 +18,20 @@ docker run --init --rm mscp-ubuntu:20.04 /mscp/scripts/test-in-container.sh
 
 docker run --init --rm mscp-ubuntu:22.04 /mscp/scripts/test-in-container.sh
 
-docker run --init --rm mscp-centos:8 /mscp/scripts/test-in-container.sh
-
-docker run --init --rm mscp-rocky:8.6 /mscp/scripts/test-in-container.sh
+docker run --init --rm mscp-rocky:8.9 /mscp/scripts/test-in-container.sh
 ```
 
 Retrieve deb/rpm packages.
 
 ```console
 docker run --rm -v (pwd):/out mscp-ubuntu:20.04 \
-       cp /mscp/build/mscp_0.0.0-ubuntu-20.04-x86_64.deb /out/
+       cp /mscp/build/mscp_ubuntu-20.04-x86_64.deb /out/
 
 docker run --rm -v (pwd):/out mscp-ubuntu:22.04 \
-       cp /mscp/build/mscp_0.0.0-ubuntu-22.04-x86_64.deb /out/
+       cp /mscp/build/mscp_ubuntu-22.04-x86_64.deb /out/
 
-docker run --rm -v (pwd):/out mscp-centos:8 \
-       cp /mscp/build/mscp_0.0.0-centos-8-x86_64.rpm /out/
-
-docker run --rm -v (pwd):/out mscp-rocky:8.6 \
-       cp /mscp/build/mscp_0.0.0-rocky-8.6-x86_64.rpm /out/
+docker run --rm -v (pwd):/out mscp-rocky:8.8 \
+       cp /mscp/build/mscp_rocky-8.8-x86_64.rpm /out/
 ```
 
 I don't know whether these are good way.

docker/almalinux-8.8.Dockerfile

@@ -1,16 +1,9 @@
-FROM centos:8
-
-ARG mscpdir="/mscp"
-
-COPY . ${mscpdir}
-
-# from https://stackoverflow.com/questions/70963985/error-failed-to-download-metadata-for-repo-appstream-cannot-prepare-internal
-RUN cd /etc/yum.repos.d/
-RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
-RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+FROM almalinux:8.8
 
 # install pytest, sshd for test, and rpm-build
-RUN set -ex && yum -y update && yum -y install \
+RUN set -ex && \
+	rpm --import https://repo.almalinux.org/almalinux/RPM-GPG-KEY-AlmaLinux && \
+	yum -y install \
 	python3 python3-pip python3-devel openssh openssh-server openssh-clients rpm-build
 
 RUN python3 -m pip install pytest
@@ -22,13 +15,18 @@ RUN  mkdir /var/run/sshd        \
         && ssh-keygen -f /root/.ssh/id_rsa -N ""                \
         && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
 
+
+ARG mscpdir="/mscp"
+
+COPY . ${mscpdir}
+
 # install build dependency
 RUN ${mscpdir}/scripts/install-build-deps.sh
 
 # build
 RUN cd ${mscpdir}			\
         && rm -rf build			\
-        && cmake -B build 		\
+        && cmake -B build		\
         && cd ${mscpdir}/build          \
 	&& make				\
 	&& cpack -G RPM CPackConfig.cmake \
@@ -36,4 +34,6 @@ RUN cd ${mscpdir}			\
 
 # install mscp python module
 RUN cd ${mscpdir}	\
-	&& python3 setup.py install --user
+	&& python3 pysetup.py install --user \
+	&& ldconfig
+

docker/alpine-3.17.Dockerfile

@@ -2,18 +2,26 @@ FROM alpine:3.17
 
 # Build mscp with conan to create single binary mscp
 
-ARG mscpdir="/mscp"
-
-COPY . ${mscpdir}
-
 RUN apk add --no-cache \
 	gcc make cmake python3 py3-pip perl linux-headers libc-dev	\
 	openssh bash python3-dev g++
 
 RUN pip3 install conan pytest
 
+# preparation for sshd
+RUN ssh-keygen -A
+RUN  mkdir /var/run/sshd        \
+        && ssh-keygen -f /root/.ssh/id_rsa -N ""                \
+        && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
+
+
 # Build mscp as a single binary
 RUN conan profile detect --force
+
+ARG mscpdir="/mscp"
+
+COPY . ${mscpdir}
+
 RUN cd ${mscpdir}							\
 	&& rm -rf build							\
 	&& conan install . --output-folder=build --build=missing	\
@@ -25,20 +33,8 @@ RUN cd ${mscpdir}							\
 	&& make								\
 	&& cp mscp /usr/bin/						\
 	&& cp mscp /mscp/build/mscp_alpine-3.17-x86_64.static
-
 # copy mscp to PKG FILE NAME because this build doesn't use CPACK
 
-# preparation for sshd
-RUN ssh-keygen -A
-RUN  mkdir /var/run/sshd        \
-        && ssh-keygen -f /root/.ssh/id_rsa -N ""                \
-        && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
-
 # install mscp python module
 RUN cd ${mscpdir}	\
-	&& python3 setup.py install --user
-
-# Need Fix: A trick putting libmscp.so to python mscp module dir does not work on alpine,
-# so install libmscp.
-RUN cd ${mscpdir}/build	\
-	&& make install
+	&& python3 pysetup.py install --user

docker/rocky-8.8.Dockerfile

@@ -1,8 +1,4 @@
-FROM rockylinux:8.6
-
-ARG mscpdir="/mscp"
-
-COPY . ${mscpdir}
+FROM rockylinux:8.8
 
 # install pytest, sshd for test, and rpm-build
 RUN set -ex && yum -y install \
@@ -17,6 +13,10 @@ RUN  mkdir /var/run/sshd        \
         && ssh-keygen -f /root/.ssh/id_rsa -N ""                \
         && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
 
+ARG mscpdir="/mscp"
+
+COPY . ${mscpdir}
+
 # install build dependency
 RUN ${mscpdir}/scripts/install-build-deps.sh
 
@@ -31,5 +31,6 @@ RUN cd ${mscpdir}			\
 
 # install mscp python module
 RUN cd ${mscpdir}	\
-	&& python3 setup.py install --user
+	&& python3 pysetup.py install --user \
+	&& ldconfig
 

docker/ubuntu-20.04.Dockerfile

@@ -1,10 +1,6 @@
 FROM ubuntu:20.04
 
 ARG DEBIAN_FRONTEND=noninteractive
-ARG mscpdir="/mscp"
-
-COPY . ${mscpdir}
-
 RUN set -ex && apt-get update && apt-get install -y --no-install-recommends \
 	ca-certificates
 
@@ -21,6 +17,10 @@ RUN  mkdir /var/run/sshd        \
         && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
 
 
+ARG mscpdir="/mscp"
+
+COPY . ${mscpdir}
+
 # install build dependency
 RUN ${mscpdir}/scripts/install-build-deps.sh
 
@@ -36,4 +36,5 @@ RUN cd ${mscpdir}			\
 
 # install mscp python module
 RUN cd ${mscpdir}       \
-        && python3 setup.py install --user
+	&& python3 pysetup.py install --user \
+	&& ldconfig

docker/ubuntu-22.04.Dockerfile

@@ -1,10 +1,6 @@
 FROM ubuntu:22.04
 
 ARG DEBIAN_FRONTEND=noninteractive
-ARG mscpdir="/mscp"
-
-COPY . ${mscpdir}
-
 RUN set -ex && apt-get update && apt-get install -y --no-install-recommends \
 	ca-certificates
 
@@ -20,6 +16,9 @@ RUN  mkdir /var/run/sshd        \
         && ssh-keygen -f /root/.ssh/id_rsa -N ""                \
         && mv /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys
 
+ARG mscpdir="/mscp"
+
+COPY . ${mscpdir}
 
 # install build dependency
 RUN ${mscpdir}/scripts/install-build-deps.sh
@@ -36,5 +35,6 @@ RUN cd ${mscpdir}			\
 
 # install mscp python module
 RUN cd ${mscpdir}	\
-	&& python3 setup.py install --user
+	&& python3 pysetup.py install --user \
+	&& ldconfig
 

examples/.gitignore

@@ -0,0 +1,3 @@
+simple-copy-dest
+*.img
+.ipynb_checkpoints

examples/mscp-example.ipynb

@@ -0,0 +1,226 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ccda9e3a-35de-43fc-9b6e-02475c763f6b",
+   "metadata": {},
+   "source": [
+    "# mscp python binding example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "df04d655-a082-47eb-9a1e-154ebc2a5655",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "import time\n",
+    "import os\n",
+    "\n",
+    "import mscp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "e9ed4519-c3fd-4639-89a5-1c1cdffd9519",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "this_dir = os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fee75bf8-df40-45f4-81d1-113069c34f13",
+   "metadata": {},
+   "source": [
+    "## Simple copy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "2b06e6d3-30cc-47be-bd4f-af27eb141c8c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['../src/ssh.c',\n",
+       " '../src/mscp.c',\n",
+       " '../src/platform.c',\n",
+       " '../src/pymscp.c',\n",
+       " '../src/main.c',\n",
+       " '../src/path.c',\n",
+       " '../src/message.c',\n",
+       " '../src/fileops.c']"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# preparing files to be transferred\n",
+    "c_sources = glob.glob(\"../src/*.c\")\n",
+    "c_sources"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "89bb4558-9472-4d26-9af3-24f426b15edc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# copy files using mscp\n",
+    "dst_dir = this_dir + \"/simple-copy-dest\"\n",
+    "m = mscp.mscp(\"localhost\", mscp.LOCAL2REMOTE)\n",
+    "m.copy(c_sources, dst_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "6daf2c98-8905-4039-b82a-a593df3107fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ssh.c',\n",
+       " 'mscp.c',\n",
+       " 'platform.c',\n",
+       " 'pymscp.c',\n",
+       " 'main.c',\n",
+       " 'path.c',\n",
+       " 'message.c',\n",
+       " 'fileops.c']"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.listdir(\"simple-copy-dest\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4a3869a-878e-43b0-9758-a049eaf8b5bd",
+   "metadata": {},
+   "source": [
+    "## Simple Copy with Python Rich ProgressBar"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "e7cb7cd6-b845-4d26-93ed-aee8ed3983ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# make a 256MB file\n",
+    "src = \"example-256MB-src.img\"\n",
+    "with open(src, \"wb\") as f:\n",
+    "    f.seek(128 * 1024 * 1024 -1, 0)\n",
+    "    f.write(b'1')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "878607ed-5c06-4b15-81ac-9845dad0c9c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b700e9fc00464969a22a26300404dc35",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# copy the 256MB file while ploting progress bar using python rich\n",
+    "dst = this_dir + \"/example-256MB-dst.img\"\n",
+    "\n",
+    "kw = {\"nr_threads\": 1, \"nr_ahead\": 1} # slow mscp to watch the progress bar\n",
+    "\n",
+    "m = mscp.mscp(\"localhost\", mscp.LOCAL2REMOTE, **kw)\n",
+    "m.copy(src, dst, nonblock = True)\n",
+    "\n",
+    "# m.stats() returns total bytes to be transferred, bytes transferred (done), and finished (bool).\n",
+    "total, done, finished = m.stats()\n",
+    "with Progress() as progress:\n",
+    "\n",
+    "    task = progress.add_task(f\"[green]Copying {src}\", total = total)\n",
+    "\n",
+    "    while not progress.finished:\n",
+    "        total, done, finished = m.stats()\n",
+    "        progress.update(task, completed = done)\n",
+    "        time.sleep(0.5)\n",
+    "\n",
+    "m.join()\n",
+    "m.cleanup()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/mscp-python.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""mscp.py
+
+An example python script running mscp
+"""
+
+import argparse
+import time
+import sys
+
+from rich.progress import Progress
+
+import mscp
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-f", "--from", dest = "fr",
+                        metavar = "REMOTE", default = None,
+                        help = "copy a file from this remote host")
+    parser.add_argument("-t", "--to", metavar = "REMOTE", default = None,
+                        help = "copy a file to this remote host")
+    parser.add_argument("source", help = "path to source file to be copied")
+    parser.add_argument("destination", help = "path of copy destination")
+
+    args = parser.parse_args()
+
+    if args.fr and args.to:
+        print("-f and -t are exclusive", file = sys.stderr)
+        sys.exit(1)
+    elif args.fr:
+        d = mscp.REMOTE2LOCAL
+        remote = args.fr
+    elif args.to:
+        d = mscp.LOCAL2REMOTE
+        remote = args.to
+    else:
+        print("-f or -t must be specified", file = sys.stderr)
+        sys.exit(1)
+
+
+    m = mscp.mscp(remote, d)
+    m.connect()
+    m.add_src_path(args.source)
+    m.set_dst_path(args.destination)
+    m.scan()
+    m.start()
+
+    total, done, finished = m.stats()
+    with Progress() as progress:
+
+        task = progress.add_task("[green]Copying...", total = total)
+
+        while not progress.finished:
+            total, done, finished = m.stats()
+            progress.update(task, completed = done)
+            time.sleep(0.5)
+
+    m.join()
+    m.cleanup()
+
+
+if __name__ == "__main__":
+    main()

include/mscp.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _MSCP_H_
 #define _MSCP_H_
 
@@ -43,7 +44,8 @@ struct mscp_opts {
 	size_t	max_chunk_sz;	/** maximum chunk size (default file size/nr_threads) */
 	size_t	buf_sz;		/** buffer size, default 16k. */
 	char	coremask[MSCP_MAX_COREMASK_STR]; /** hex to specifiy usable cpu cores */
-	int	max_startups;	/* sshd MaxStartups concurrent connections */
+	int	max_startups;	/** sshd MaxStartups concurrent connections */
+	int     interval;	/** interval between SSH connection attempts */
 
 	int	severity; 	/** messaging severity. set MSCP_SERVERITY_* */
 	int	msg_fd;		/** fd to output message. default STDOUT (0),
@@ -56,6 +58,7 @@ struct mscp_opts {
 #define MSCP_SSH_MAX_CIPHER_STR		32
 #define MSCP_SSH_MAX_HMAC_STR		32
 #define MSCP_SSH_MAX_COMP_STR		32 /* yes, no, zlib, zlib@openssh.com, none */
+#define MSCP_SSH_MAX_CCALGO_STR		16
 #define MSCP_SSH_MAX_PASSWORD		128
 #define MSCP_SSH_MAX_PASSPHRASE		128
 
@@ -67,10 +70,12 @@ struct mscp_ssh_opts {
 	/* ssh options */
 	char	login_name[MSCP_SSH_MAX_LOGIN_NAME];	/** ssh username */
 	char	port[MSCP_SSH_MAX_PORT_STR];		/** ssh port */
+	char	config[PATH_MAX];	/** path to ssh_config, default ~/.ssh/config*/
 	char	identity[MSCP_SSH_MAX_IDENTITY_PATH];	/** path to private key */
 	char	cipher[MSCP_SSH_MAX_CIPHER_STR];	/** cipher spec */
 	char	hmac[MSCP_SSH_MAX_HMAC_STR];		/** hmacp spec */
 	char	compress[MSCP_SSH_MAX_COMP_STR];	/** yes, no, zlib@openssh.com */
+	char	ccalgo[MSCP_SSH_MAX_CCALGO_STR];	/** TCP cc algorithm */
 
 	char	password[MSCP_SSH_MAX_PASSWORD];	/** password auth passowrd */
 	char	passphrase[MSCP_SSH_MAX_PASSPHRASE];	/** passphrase for private key */
@@ -184,7 +189,7 @@ int mscp_scan_join(struct mscp *m);
  *
  * @param m	mscp instance.
  *
- * @return 	0 on success, < 0 if an error occured.
+ * @return 	number of threads on success, < 0 if an error occured.
  *              mscp_get_error() can be used to retrieve error message.
  *
  * @see		mscp_join()

include/mscp_version.h.in

@@ -0,0 +1,8 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
+#ifndef _MSCP_VERSION_H_
+#define _MSCP_VERSION_H_
+
+#define MSCP_VERSION		"@MSCP_VERSION@"
+#define MSCP_BUILD_VERSION	"@MSCP_BUILD_VERSION@"
+
+#endif /* _MSCP_VERSION_H_ */

mscp/mscp.py

@@ -37,7 +37,7 @@ SEVERITY_DEBUG  = pymscp.SEVERITY_DEBUG
 
 STATE_INIT      = 0
 STATE_CONNECTED = 1
-STATE_SCANNED  = 2
+STATE_SCANNED   = 2
 STATE_RUNNING   = 3
 STATE_STOPPED   = 4
 STATE_JOINED    = 5
@@ -47,7 +47,7 @@ STATE_RELEASED  = 7
 _state_str = {
     STATE_INIT:      "init",
     STATE_CONNECTED: "connected",
-    STATE_SCANNED:  "scanned",
+    STATE_SCANNED:   "scanned",
     STATE_RUNNING:   "running",
     STATE_STOPPED:   "stopped",
     STATE_JOINED:    "joined",
@@ -115,6 +115,8 @@ class mscp:
         pymscp.mscp_set_dst_path(m = self.m, dst_path = dst_path);
 
     def scan(self):
+        if self.state == STATE_SCANNED:
+            return
         if self.state != STATE_CONNECTED:
             raise RuntimeError("invalid mscp state: {}".format(self.__state2str()))
         if not self.src_paths:
@@ -139,6 +141,8 @@ class mscp:
         self.state = STATE_STOPPED
 
     def join(self):
+        if self.state == STATE_JOINED:
+            return
         if not (self.state == STATE_RUNNING or self.state == STATE_STOPPED):
             raise RuntimeError("invalid mscp state: {}".format(self.__state2str()))
         pymscp.mscp_join(m = self.m)

patch/README.md

@@ -1,13 +1,5 @@
 
-Patch(es) in this directory introduces `sftp_async_write()` and
+Patches in this directory introduces `sftp_async_write()` and
 `sftp_async_write_end()` to libssh. Those implementations are derived
 from https://github.com/limes-datentechnik-gmbh/libssh. See [Re: SFTP
 Write async](https://archive.libssh.org/libssh/2020-06/0000004.html).
-
-```console
-git clone https://git.libssh.org/projects/libssh.git/ --depth=1 -b libssh-0.10.4
-cd libssh
-git apply ../pathc/libssh-0.10.4.patch
-
-# then build libssh
-```

patch/libssh-0.10.4.patch

@@ -1,3 +1,28 @@
+diff --git a/ConfigureChecks.cmake b/ConfigureChecks.cmake
+index 7103f303..c64eb39d 100644
+--- a/ConfigureChecks.cmake
++++ b/ConfigureChecks.cmake
+@@ -258,6 +258,7 @@ if (UNIX)
+     check_library_exists(util forkpty "" HAVE_LIBUTIL)
+     check_function_exists(cfmakeraw HAVE_CFMAKERAW)
+     check_function_exists(__strtoull HAVE___STRTOULL)
++    check_symbol_exists(TCP_CONGESTION "netinet/tcp.h" HAVE_TCP_CONGESTION)
+ endif (UNIX)
+ 
+ set(LIBSSH_REQUIRED_LIBRARIES ${_REQUIRED_LIBRARIES} CACHE INTERNAL "libssh required system libraries")
+diff --git a/config.h.cmake b/config.h.cmake
+index 1357615b..1e915ead 100644
+--- a/config.h.cmake
++++ b/config.h.cmake
+@@ -237,6 +237,8 @@
+ 
+ #cmakedefine HAVE_GCC_BOUNDED_ATTRIBUTE 1
+ 
++#cmakedefine HAVE_TCP_CONGESTION 1
++
+ /* Define to 1 if you want to enable GSSAPI */
+ #cmakedefine WITH_GSSAPI 1
+ 
 diff --git a/include/libssh/buffer.h b/include/libssh/buffer.h
 index a55a1b40..e34e075c 100644
 --- a/include/libssh/buffer.h
@@ -12,10 +37,18 @@ index a55a1b40..e34e075c 100644
  int ssh_buffer_validate_length(struct ssh_buffer_struct *buffer, size_t len);
  
 diff --git a/include/libssh/libssh.h b/include/libssh/libssh.h
-index 7857a77b..3eef7a16 100644
+index 7857a77b..6b4d481c 100644
 --- a/include/libssh/libssh.h
 +++ b/include/libssh/libssh.h
-@@ -833,6 +833,7 @@ LIBSSH_API const char* ssh_get_hmac_in(ssh_session session);
+@@ -402,6 +402,7 @@ enum ssh_options_e {
+   SSH_OPTIONS_GSSAPI_AUTH,
+   SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
+   SSH_OPTIONS_NODELAY,
++  SSH_OPTIONS_CCALGO,
+   SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES,
+   SSH_OPTIONS_PROCESS_CONFIG,
+   SSH_OPTIONS_REKEY_DATA,
+@@ -833,6 +834,7 @@ LIBSSH_API const char* ssh_get_hmac_in(ssh_session session);
  LIBSSH_API const char* ssh_get_hmac_out(ssh_session session);
  
  LIBSSH_API ssh_buffer ssh_buffer_new(void);
@@ -23,7 +56,7 @@ index 7857a77b..3eef7a16 100644
  LIBSSH_API void ssh_buffer_free(ssh_buffer buffer);
  #define SSH_BUFFER_FREE(x) \
      do { if ((x) != NULL) { ssh_buffer_free(x); x = NULL; } } while(0)
-@@ -843,6 +844,8 @@ LIBSSH_API void *ssh_buffer_get(ssh_buffer buffer);
+@@ -843,6 +845,8 @@ 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);
  
@@ -32,6 +65,18 @@ index 7857a77b..3eef7a16 100644
  #ifndef LIBSSH_LEGACY_0_4
  #include "libssh/legacy.h"
  #endif
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index d3e5787c..15183d1b 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -232,6 +232,7 @@ struct ssh_session_struct {
+         int gss_delegate_creds;
+         int flags;
+         int nodelay;
++        char *ccalgo;
+         bool config_processed;
+         uint8_t options_seen[SOC_MAX];
+         uint64_t rekey_data;
 diff --git a/include/libssh/sftp.h b/include/libssh/sftp.h
 index c855df8a..0fcdb9b8 100644
 --- a/include/libssh/sftp.h
@@ -158,6 +203,106 @@ index e0068015..cc0caf35 100644
  /**
   * @brief Ensure the buffer has at least a certain preallocated size.
   *
+diff --git a/src/connect.c b/src/connect.c
+index 57e37e63..c02397d5 100644
+--- a/src/connect.c
++++ b/src/connect.c
+@@ -156,6 +156,20 @@ static int set_tcp_nodelay(socket_t socket)
+                       sizeof(opt));
+ }
+ 
++static int set_tcp_ccalgo(socket_t socket, const char *ccalgo)
++{
++#ifdef HAVE_TCP_CONGESTION
++	return setsockopt(socket,
++			  IPPROTO_TCP,
++			  TCP_CONGESTION,
++			  (void *)ccalgo,
++			  strlen(ccalgo));
++#else
++	errno = ENOTSUP;
++	return -1;
++#endif
++}
++
+ /**
+  * @internal
+  *
+@@ -256,6 +270,18 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
+             }
+         }
+ 
++        if (session->opts.ccalgo) {
++	     rc = set_tcp_ccalgo(s, session->opts.ccalgo);
++	     if (rc < 0) {
++		 ssh_set_error(session, SSH_FATAL,
++			       "Failed to set TCP_CONGESTION on socket: %s",
++			       ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
++		 ssh_connect_socket_close(s);
++		 s = -1;
++		 continue;
++	     }
++	}
++
+         errno = 0;
+         rc = connect(s, itr->ai_addr, itr->ai_addrlen);
+         if (rc == -1 && (errno != 0) && (errno != EINPROGRESS)) {
+diff --git a/src/options.c b/src/options.c
+index 49aaefa2..9f7360c3 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -210,6 +210,7 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+     new->opts.gss_delegate_creds    = src->opts.gss_delegate_creds;
+     new->opts.flags                 = src->opts.flags;
+     new->opts.nodelay               = src->opts.nodelay;
++    new->opts.ccalgo                = src->opts.ccalgo;
+     new->opts.config_processed      = src->opts.config_processed;
+     new->common.log_verbosity       = src->common.log_verbosity;
+     new->common.callbacks           = src->common.callbacks;
+@@ -450,6 +451,10 @@ int ssh_options_set_algo(ssh_session session,
+  *                Set it to disable Nagle's Algorithm (TCP_NODELAY) on the
+  *                session socket. (int, 0=false)
+  *
++ *              - SSH_OPTIONS_CCALGO
++ *                Set it to specify TCP congestion control algorithm on the
++ *                session socket (Linux only). (int, 0=false)
++ *
+  *              - SSH_OPTIONS_PROCESS_CONFIG
+  *                Set it to false to disable automatic processing of per-user
+  *                and system-wide OpenSSH configuration files. LibSSH
+@@ -1013,6 +1018,20 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                 session->opts.nodelay = (*x & 0xff) > 0 ? 1 : 0;
+             }
+             break;
++	case SSH_OPTIONS_CCALGO:
++            v = value;
++            if (v == NULL || v[0] == '\0') {
++                ssh_set_error_invalid(session);
++                return -1;
++            } else {
++                SAFE_FREE(session->opts.ccalgo);
++                session->opts.ccalgo = strdup(v);
++                if (session->opts.ccalgo == NULL) {
++                    ssh_set_error_oom(session);
++                    return -1;
++                }
++            }
++            break;
+         case SSH_OPTIONS_PROCESS_CONFIG:
+             if (value == NULL) {
+                 ssh_set_error_invalid(session);
+diff --git a/src/session.c b/src/session.c
+index 6025c133..6b197526 100644
+--- a/src/session.c
++++ b/src/session.c
+@@ -108,6 +108,7 @@ ssh_session ssh_new(void)
+     session->opts.fd = -1;
+     session->opts.compressionlevel = 7;
+     session->opts.nodelay = 0;
++    session->opts.ccalgo = NULL;
+ 
+     session->opts.flags = SSH_OPT_FLAG_PASSWORD_AUTH |
+                           SSH_OPT_FLAG_PUBKEY_AUTH |
 diff --git a/src/sftp.c b/src/sftp.c
 index e01012a8..702623a0 100644
 --- a/src/sftp.c

patch/libssh-0.10.6-2-g6f1b1e76.patch

@@ -0,0 +1,442 @@
+diff --git a/ConfigureChecks.cmake b/ConfigureChecks.cmake
+index 9de10225..0f3d20ed 100644
+--- a/ConfigureChecks.cmake
++++ b/ConfigureChecks.cmake
+@@ -258,6 +258,7 @@ if (UNIX)
+     check_library_exists(util forkpty "" HAVE_LIBUTIL)
+     check_function_exists(cfmakeraw HAVE_CFMAKERAW)
+     check_function_exists(__strtoull HAVE___STRTOULL)
++    check_symbol_exists(TCP_CONGESTION "netinet/tcp.h" HAVE_TCP_CONGESTION)
+ endif (UNIX)
+ 
+ set(LIBSSH_REQUIRED_LIBRARIES ${_REQUIRED_LIBRARIES} CACHE INTERNAL "libssh required system libraries")
+diff --git a/config.h.cmake b/config.h.cmake
+index cc83734d..f74cd03b 100644
+--- a/config.h.cmake
++++ b/config.h.cmake
+@@ -237,6 +237,8 @@
+ 
+ #cmakedefine HAVE_GCC_BOUNDED_ATTRIBUTE 1
+ 
++#cmakedefine HAVE_TCP_CONGESTION 1
++
+ /* Define to 1 if you want to enable GSSAPI */
+ #cmakedefine WITH_GSSAPI 1
+ 
+diff --git a/include/libssh/buffer.h b/include/libssh/buffer.h
+index 1fce7b76..b64d1455 100644
+--- a/include/libssh/buffer.h
++++ b/include/libssh/buffer.h
+@@ -37,6 +37,8 @@ int ssh_buffer_add_u8(ssh_buffer buffer, uint8_t data);
+ int ssh_buffer_add_u16(ssh_buffer buffer, uint16_t data);
+ int ssh_buffer_add_u32(ssh_buffer buffer, uint32_t data);
+ int ssh_buffer_add_u64(ssh_buffer buffer, uint64_t data);
++ssize_t ssh_buffer_add_func(ssh_buffer buffer, ssh_add_func f, size_t max_bytes,
++			    void *userdata);
+ 
+ int ssh_buffer_validate_length(struct ssh_buffer_struct *buffer, size_t len);
+ 
+diff --git a/include/libssh/libssh.h b/include/libssh/libssh.h
+index 669a0a96..b6a93ac7 100644
+--- a/include/libssh/libssh.h
++++ b/include/libssh/libssh.h
+@@ -402,6 +402,7 @@ enum ssh_options_e {
+   SSH_OPTIONS_GSSAPI_AUTH,
+   SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
+   SSH_OPTIONS_NODELAY,
++  SSH_OPTIONS_CCALGO,
+   SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES,
+   SSH_OPTIONS_PROCESS_CONFIG,
+   SSH_OPTIONS_REKEY_DATA,
+@@ -833,6 +834,7 @@ LIBSSH_API const char* ssh_get_hmac_in(ssh_session session);
+ LIBSSH_API const char* ssh_get_hmac_out(ssh_session session);
+ 
+ LIBSSH_API ssh_buffer ssh_buffer_new(void);
++LIBSSH_API ssh_buffer ssh_buffer_new_size(uint32_t size, uint32_t headroom);
+ LIBSSH_API void ssh_buffer_free(ssh_buffer buffer);
+ #define SSH_BUFFER_FREE(x) \
+     do { if ((x) != NULL) { ssh_buffer_free(x); x = NULL; } } while(0)
+@@ -843,6 +845,8 @@ 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);
+ 
++typedef ssize_t (*ssh_add_func) (void *ptr, size_t max_bytes, void *userdata);
++
+ #ifndef LIBSSH_LEGACY_0_4
+ #include "libssh/legacy.h"
+ #endif
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index 97936195..e4a7f80c 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -258,6 +258,7 @@ struct ssh_session_struct {
+         int flags;
+         int exp_flags;
+         int nodelay;
++        char *ccalgo;
+         bool config_processed;
+         uint8_t options_seen[SOC_MAX];
+         uint64_t rekey_data;
+diff --git a/include/libssh/sftp.h b/include/libssh/sftp.h
+index c713466e..e27fe326 100644
+--- a/include/libssh/sftp.h
++++ b/include/libssh/sftp.h
+@@ -565,6 +565,10 @@ LIBSSH_API int sftp_async_read(sftp_file file, void *data, uint32_t len, uint32_
+  */
+ LIBSSH_API ssize_t sftp_write(sftp_file file, const void *buf, size_t count);
+ 
++LIBSSH_API ssize_t sftp_async_write(sftp_file file, ssh_add_func f, size_t count,
++				    void *userdata, uint32_t* id);
++LIBSSH_API int sftp_async_write_end(sftp_file file, uint32_t id, int blocking);
++
+ /**
+  * @brief Seek to a specific location in a file.
+  *
+diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
+index 807313b5..86487087 100644
+--- a/src/CMakeLists.txt
++++ b/src/CMakeLists.txt
+@@ -448,6 +448,11 @@ if (BUILD_STATIC_LIB)
+   if (WIN32)
+     target_compile_definitions(ssh-static PUBLIC "LIBSSH_STATIC")
+   endif (WIN32)
++
++  install(TARGETS ssh-static
++	  EXPORT libssh-config
++	  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
++	  COMPONENT libraries)
+ endif (BUILD_STATIC_LIB)
+ 
+ message(STATUS "Threads_FOUND=${Threads_FOUND}")
+diff --git a/src/buffer.c b/src/buffer.c
+index 8991e006..e0414801 100644
+--- a/src/buffer.c
++++ b/src/buffer.c
+@@ -142,6 +142,40 @@ struct ssh_buffer_struct *ssh_buffer_new(void)
+     return buf;
+ }
+ 
++/**
++ * @brief Create a new SSH buffer with a specified size and headroom.
++ *
++ * @param[in] len       length for newly initialized SSH buffer.
++ * @param[in] headroom  length for headroom
++ * @return A newly initialized SSH buffer, NULL on error.
++ */
++struct ssh_buffer_struct *ssh_buffer_new_size(uint32_t len, uint32_t headroom)
++{
++    struct ssh_buffer_struct *buf = NULL;
++    int rc;
++
++    if (len < headroom)
++	    return NULL;
++
++    buf = calloc(1, sizeof(struct ssh_buffer_struct));
++    if (buf == NULL) {
++        return NULL;
++    }
++
++    rc = ssh_buffer_allocate_size(buf, len);
++    if (rc != 0) {
++        SAFE_FREE(buf);
++        return NULL;
++    }
++
++    buf->pos += headroom;
++    buf->used += headroom;
++
++    buffer_verify(buf);
++
++    return buf;
++}
++
+ /**
+  * @brief Deallocate a SSH buffer.
+  *
+@@ -329,6 +363,49 @@ int ssh_buffer_add_data(struct ssh_buffer_struct *buffer, const void *data, uint
+     return 0;
+ }
+ 
++/**
++ * @brief Add data at the tail of a buffer by an external function
++ *
++ * @param[in]  buffer    The buffer to add data.
++ *
++ * @param[in]  f         function that adds data to the buffer.
++ *
++ * @param[in]  max_bytes The maximum length of the data to add.
++ *
++ * @return               actual bytes added on success, < 0 on error.
++ */
++ssize_t ssh_buffer_add_func(struct ssh_buffer_struct *buffer, ssh_add_func f,
++			    size_t max_bytes, void *userdata)
++{
++    ssize_t actual;
++
++    if (buffer == NULL) {
++        return -1;
++    }
++
++    buffer_verify(buffer);
++
++    if (buffer->used + max_bytes < max_bytes) {
++        return -1;
++    }
++
++    if (buffer->allocated < (buffer->used + max_bytes)) {
++        if (buffer->pos > 0) {
++            buffer_shift(buffer);
++        }
++        if (realloc_buffer(buffer, buffer->used + max_bytes) < 0) {
++            return -1;
++        }
++    }
++
++    if ((actual = f(buffer->data + buffer->used, max_bytes, userdata)) < 0)
++      return -1;
++
++    buffer->used += actual;
++    buffer_verify(buffer);
++    return actual;
++}
++
+ /**
+  * @brief Ensure the buffer has at least a certain preallocated size.
+  *
+diff --git a/src/connect.c b/src/connect.c
+index 15cae644..e7520f40 100644
+--- a/src/connect.c
++++ b/src/connect.c
+@@ -156,6 +156,20 @@ static int set_tcp_nodelay(socket_t socket)
+                       sizeof(opt));
+ }
+ 
++static int set_tcp_ccalgo(socket_t socket, const char *ccalgo)
++{
++#ifdef HAVE_TCP_CONGESTION
++	return setsockopt(socket,
++			  IPPROTO_TCP,
++			  TCP_CONGESTION,
++			  (void *)ccalgo,
++			  strlen(ccalgo));
++#else
++	errno = ENOTSUP;
++	return -1;
++#endif
++}
++
+ /**
+  * @internal
+  *
+@@ -256,6 +270,18 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
+             }
+         }
+ 
++        if (session->opts.ccalgo) {
++	     rc = set_tcp_ccalgo(s, session->opts.ccalgo);
++	     if (rc < 0) {
++		 ssh_set_error(session, SSH_FATAL,
++			       "Failed to set TCP_CONGESTION on socket: %s",
++			       ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
++		 ssh_connect_socket_close(s);
++		 s = -1;
++		 continue;
++	     }
++	}
++
+         errno = 0;
+         rc = connect(s, itr->ai_addr, itr->ai_addrlen);
+         if (rc == -1 && (errno != 0) && (errno != EINPROGRESS)) {
+diff --git a/src/options.c b/src/options.c
+index b3ecffe1..fb966fa1 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -217,6 +217,7 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+     new->opts.gss_delegate_creds    = src->opts.gss_delegate_creds;
+     new->opts.flags                 = src->opts.flags;
+     new->opts.nodelay               = src->opts.nodelay;
++    new->opts.ccalgo                = src->opts.ccalgo;
+     new->opts.config_processed      = src->opts.config_processed;
+     new->common.log_verbosity       = src->common.log_verbosity;
+     new->common.callbacks           = src->common.callbacks;
+@@ -458,6 +459,10 @@ int ssh_options_set_algo(ssh_session session,
+  *                Set it to disable Nagle's Algorithm (TCP_NODELAY) on the
+  *                session socket. (int, 0=false)
+  *
++ *              - SSH_OPTIONS_CCALGO
++ *                Set it to specify TCP congestion control algorithm on the
++ *                session socket (Linux only). (int, 0=false)
++ *
+  *              - SSH_OPTIONS_PROCESS_CONFIG
+  *                Set it to false to disable automatic processing of per-user
+  *                and system-wide OpenSSH configuration files. LibSSH
+@@ -1017,6 +1022,20 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                 session->opts.nodelay = (*x & 0xff) > 0 ? 1 : 0;
+             }
+             break;
++	case SSH_OPTIONS_CCALGO:
++            v = value;
++            if (v == NULL || v[0] == '\0') {
++                ssh_set_error_invalid(session);
++                return -1;
++            } else {
++                SAFE_FREE(session->opts.ccalgo);
++                session->opts.ccalgo = strdup(v);
++                if (session->opts.ccalgo == NULL) {
++                    ssh_set_error_oom(session);
++                    return -1;
++                }
++            }
++            break;
+         case SSH_OPTIONS_PROCESS_CONFIG:
+             if (value == NULL) {
+                 ssh_set_error_invalid(session);
+diff --git a/src/session.c b/src/session.c
+index 8c509699..88602b6a 100644
+--- a/src/session.c
++++ b/src/session.c
+@@ -108,6 +108,7 @@ ssh_session ssh_new(void)
+     session->opts.fd = -1;
+     session->opts.compressionlevel = 7;
+     session->opts.nodelay = 0;
++    session->opts.ccalgo = NULL;
+ 
+     session->opts.flags = SSH_OPT_FLAG_PASSWORD_AUTH |
+                           SSH_OPT_FLAG_PUBKEY_AUTH |
+diff --git a/src/sftp.c b/src/sftp.c
+index e01012a8..702623a0 100644
+--- a/src/sftp.c
++++ b/src/sftp.c
+@@ -2228,6 +2228,132 @@ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
+   return -1; /* not reached */
+ }
+ 
++/*
++ * sftp_async_write is based on and sftp_async_write_end is copied from
++ * https://github.com/limes-datentechnik-gmbh/libssh
++ *
++ * sftp_async_write has some optimizations:
++ * - use ssh_buffer_new_size() to reduce realoc_buffer.
++ * - use ssh_buffer_add_func() to avoid memcpy from read buffer to ssh buffer.
++ */
++ssize_t sftp_async_write(sftp_file file, ssh_add_func f, size_t count, void *userdata,
++			 uint32_t* id) {
++  sftp_session sftp = file->sftp;
++  ssh_buffer buffer;
++  uint32_t buf_sz;
++  ssize_t actual;
++  int len;
++  int packetlen;
++  int rc;
++
++#define HEADROOM 16
++  /* sftp_packet_write() prepends a 5-bytes (uint32_t length and
++   * 1-byte type) header to the head of the payload by
++   * ssh_buffer_prepend_data(). Inserting headroom by
++   * ssh_buffer_new_size() eliminates memcpy for prepending the
++   * header.
++   */
++
++  buf_sz = (HEADROOM + /* for header */
++	    sizeof(uint32_t) + /* id */
++	    ssh_string_len(file->handle) + 4 + /* file->handle */
++	    sizeof(uint64_t) + /* file->offset */
++	    sizeof(uint32_t) + /* count */
++	    count); /* datastring */
++
++  buffer = ssh_buffer_new_size(buf_sz, HEADROOM);
++  if (buffer == NULL) {
++    ssh_set_error_oom(sftp->session);
++    return -1;
++  }
++
++  *id = sftp_get_new_id(file->sftp);
++
++  rc = ssh_buffer_pack(buffer,
++                       "dSqd",
++                       *id,
++                       file->handle,
++                       file->offset,
++                       count); /* len of datastring */
++
++  if (rc != SSH_OK){
++    ssh_set_error_oom(sftp->session);
++    ssh_buffer_free(buffer);
++    return SSH_ERROR;
++  }
++
++  actual = ssh_buffer_add_func(buffer, f, count, userdata);
++  if (actual < 0){
++    ssh_set_error_oom(sftp->session);
++    ssh_buffer_free(buffer);
++    return SSH_ERROR;
++  }
++
++  packetlen=ssh_buffer_get_len(buffer)+5;
++  len = sftp_packet_write(file->sftp, SSH_FXP_WRITE, buffer);
++  ssh_buffer_free(buffer);
++  if (len < 0) {
++    return SSH_ERROR;
++  } else  if (len != packetlen) {
++    ssh_set_error(sftp->session, SSH_FATAL,
++      "Could only send %d of %d bytes to remote host!", len, packetlen);
++    SSH_LOG(SSH_LOG_PACKET,
++        "Could not write as much data as expected");
++    return SSH_ERROR;
++  }
++
++  file->offset += actual;
++
++  return actual;
++}
++
++int sftp_async_write_end(sftp_file file, uint32_t id, int blocking) {
++  sftp_session sftp = file->sftp;
++  sftp_message msg = NULL;
++  sftp_status_message status;
++
++  msg = sftp_dequeue(sftp, id);
++  while (msg == NULL) {
++    if (!blocking && ssh_channel_poll(sftp->channel, 0) == 0) {
++      /* we cannot block */
++      return SSH_AGAIN;
++    }
++    if (sftp_read_and_dispatch(sftp) < 0) {
++      /* something nasty has happened */
++      return SSH_ERROR;
++    }
++    msg = sftp_dequeue(sftp, id);
++  }
++
++  switch (msg->packet_type) {
++    case SSH_FXP_STATUS:
++      status = parse_status_msg(msg);
++      sftp_message_free(msg);
++      if (status == NULL) {
++        return SSH_ERROR;
++      }
++      sftp_set_error(sftp, status->status);
++      switch (status->status) {
++        case SSH_FX_OK:
++          status_msg_free(status);
++          return SSH_OK;
++        default:
++          break;
++      }
++      ssh_set_error(sftp->session, SSH_REQUEST_DENIED,
++          "SFTP server: %s", status->errormsg);
++      status_msg_free(status);
++      return SSH_ERROR;
++    default:
++      ssh_set_error(sftp->session, SSH_FATAL,
++          "Received message %d during write!", msg->packet_type);
++      sftp_message_free(msg);
++      return SSH_ERROR;
++  }
++
++  return SSH_ERROR; /* not reached */
++}
++
+ /* Seek to a specific location in a file. */
+ int sftp_seek(sftp_file file, uint32_t new_offset) {
+   if (file == NULL) {

patch/libssh-0.10.6.patch

@@ -0,0 +1,442 @@
+diff --git a/ConfigureChecks.cmake b/ConfigureChecks.cmake
+index 9de10225..0f3d20ed 100644
+--- a/ConfigureChecks.cmake
++++ b/ConfigureChecks.cmake
+@@ -258,6 +258,7 @@ if (UNIX)
+     check_library_exists(util forkpty "" HAVE_LIBUTIL)
+     check_function_exists(cfmakeraw HAVE_CFMAKERAW)
+     check_function_exists(__strtoull HAVE___STRTOULL)
++    check_symbol_exists(TCP_CONGESTION "netinet/tcp.h" HAVE_TCP_CONGESTION)
+ endif (UNIX)
+ 
+ set(LIBSSH_REQUIRED_LIBRARIES ${_REQUIRED_LIBRARIES} CACHE INTERNAL "libssh required system libraries")
+diff --git a/config.h.cmake b/config.h.cmake
+index cc83734d..f74cd03b 100644
+--- a/config.h.cmake
++++ b/config.h.cmake
+@@ -237,6 +237,8 @@
+ 
+ #cmakedefine HAVE_GCC_BOUNDED_ATTRIBUTE 1
+ 
++#cmakedefine HAVE_TCP_CONGESTION 1
++
+ /* Define to 1 if you want to enable GSSAPI */
+ #cmakedefine WITH_GSSAPI 1
+ 
+diff --git a/include/libssh/buffer.h b/include/libssh/buffer.h
+index 1fce7b76..b64d1455 100644
+--- a/include/libssh/buffer.h
++++ b/include/libssh/buffer.h
+@@ -37,6 +37,8 @@ int ssh_buffer_add_u8(ssh_buffer buffer, uint8_t data);
+ int ssh_buffer_add_u16(ssh_buffer buffer, uint16_t data);
+ int ssh_buffer_add_u32(ssh_buffer buffer, uint32_t data);
+ int ssh_buffer_add_u64(ssh_buffer buffer, uint64_t data);
++ssize_t ssh_buffer_add_func(ssh_buffer buffer, ssh_add_func f, size_t max_bytes,
++			    void *userdata);
+ 
+ int ssh_buffer_validate_length(struct ssh_buffer_struct *buffer, size_t len);
+ 
+diff --git a/include/libssh/libssh.h b/include/libssh/libssh.h
+index 669a0a96..b6a93ac7 100644
+--- a/include/libssh/libssh.h
++++ b/include/libssh/libssh.h
+@@ -402,6 +402,7 @@ enum ssh_options_e {
+   SSH_OPTIONS_GSSAPI_AUTH,
+   SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
+   SSH_OPTIONS_NODELAY,
++  SSH_OPTIONS_CCALGO,
+   SSH_OPTIONS_PUBLICKEY_ACCEPTED_TYPES,
+   SSH_OPTIONS_PROCESS_CONFIG,
+   SSH_OPTIONS_REKEY_DATA,
+@@ -833,6 +834,7 @@ LIBSSH_API const char* ssh_get_hmac_in(ssh_session session);
+ LIBSSH_API const char* ssh_get_hmac_out(ssh_session session);
+ 
+ LIBSSH_API ssh_buffer ssh_buffer_new(void);
++LIBSSH_API ssh_buffer ssh_buffer_new_size(uint32_t size, uint32_t headroom);
+ LIBSSH_API void ssh_buffer_free(ssh_buffer buffer);
+ #define SSH_BUFFER_FREE(x) \
+     do { if ((x) != NULL) { ssh_buffer_free(x); x = NULL; } } while(0)
+@@ -843,6 +845,8 @@ 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);
+ 
++typedef ssize_t (*ssh_add_func) (void *ptr, size_t max_bytes, void *userdata);
++
+ #ifndef LIBSSH_LEGACY_0_4
+ #include "libssh/legacy.h"
+ #endif
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index 97936195..e4a7f80c 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -258,6 +258,7 @@ struct ssh_session_struct {
+         int flags;
+         int exp_flags;
+         int nodelay;
++        char *ccalgo;
+         bool config_processed;
+         uint8_t options_seen[SOC_MAX];
+         uint64_t rekey_data;
+diff --git a/include/libssh/sftp.h b/include/libssh/sftp.h
+index c713466e..e27fe326 100644
+--- a/include/libssh/sftp.h
++++ b/include/libssh/sftp.h
+@@ -565,6 +565,10 @@ LIBSSH_API int sftp_async_read(sftp_file file, void *data, uint32_t len, uint32_
+  */
+ LIBSSH_API ssize_t sftp_write(sftp_file file, const void *buf, size_t count);
+ 
++LIBSSH_API ssize_t sftp_async_write(sftp_file file, ssh_add_func f, size_t count,
++				    void *userdata, uint32_t* id);
++LIBSSH_API int sftp_async_write_end(sftp_file file, uint32_t id, int blocking);
++
+ /**
+  * @brief Seek to a specific location in a file.
+  *
+diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
+index 807313b5..86487087 100644
+--- a/src/CMakeLists.txt
++++ b/src/CMakeLists.txt
+@@ -448,6 +448,11 @@ if (BUILD_STATIC_LIB)
+   if (WIN32)
+     target_compile_definitions(ssh-static PUBLIC "LIBSSH_STATIC")
+   endif (WIN32)
++
++  install(TARGETS ssh-static
++	  EXPORT libssh-config
++	  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
++	  COMPONENT libraries)
+ endif (BUILD_STATIC_LIB)
+ 
+ message(STATUS "Threads_FOUND=${Threads_FOUND}")
+diff --git a/src/buffer.c b/src/buffer.c
+index 8991e006..e0414801 100644
+--- a/src/buffer.c
++++ b/src/buffer.c
+@@ -142,6 +142,40 @@ struct ssh_buffer_struct *ssh_buffer_new(void)
+     return buf;
+ }
+ 
++/**
++ * @brief Create a new SSH buffer with a specified size and headroom.
++ *
++ * @param[in] len       length for newly initialized SSH buffer.
++ * @param[in] headroom  length for headroom
++ * @return A newly initialized SSH buffer, NULL on error.
++ */
++struct ssh_buffer_struct *ssh_buffer_new_size(uint32_t len, uint32_t headroom)
++{
++    struct ssh_buffer_struct *buf = NULL;
++    int rc;
++
++    if (len < headroom)
++	    return NULL;
++
++    buf = calloc(1, sizeof(struct ssh_buffer_struct));
++    if (buf == NULL) {
++        return NULL;
++    }
++
++    rc = ssh_buffer_allocate_size(buf, len);
++    if (rc != 0) {
++        SAFE_FREE(buf);
++        return NULL;
++    }
++
++    buf->pos += headroom;
++    buf->used += headroom;
++
++    buffer_verify(buf);
++
++    return buf;
++}
++
+ /**
+  * @brief Deallocate a SSH buffer.
+  *
+@@ -329,6 +363,49 @@ int ssh_buffer_add_data(struct ssh_buffer_struct *buffer, const void *data, uint
+     return 0;
+ }
+ 
++/**
++ * @brief Add data at the tail of a buffer by an external function
++ *
++ * @param[in]  buffer    The buffer to add data.
++ *
++ * @param[in]  f         function that adds data to the buffer.
++ *
++ * @param[in]  max_bytes The maximum length of the data to add.
++ *
++ * @return               actual bytes added on success, < 0 on error.
++ */
++ssize_t ssh_buffer_add_func(struct ssh_buffer_struct *buffer, ssh_add_func f,
++			    size_t max_bytes, void *userdata)
++{
++    ssize_t actual;
++
++    if (buffer == NULL) {
++        return -1;
++    }
++
++    buffer_verify(buffer);
++
++    if (buffer->used + max_bytes < max_bytes) {
++        return -1;
++    }
++
++    if (buffer->allocated < (buffer->used + max_bytes)) {
++        if (buffer->pos > 0) {
++            buffer_shift(buffer);
++        }
++        if (realloc_buffer(buffer, buffer->used + max_bytes) < 0) {
++            return -1;
++        }
++    }
++
++    if ((actual = f(buffer->data + buffer->used, max_bytes, userdata)) < 0)
++      return -1;
++
++    buffer->used += actual;
++    buffer_verify(buffer);
++    return actual;
++}
++
+ /**
+  * @brief Ensure the buffer has at least a certain preallocated size.
+  *
+diff --git a/src/connect.c b/src/connect.c
+index 15cae644..e7520f40 100644
+--- a/src/connect.c
++++ b/src/connect.c
+@@ -156,6 +156,20 @@ static int set_tcp_nodelay(socket_t socket)
+                       sizeof(opt));
+ }
+ 
++static int set_tcp_ccalgo(socket_t socket, const char *ccalgo)
++{
++#ifdef HAVE_TCP_CONGESTION
++	return setsockopt(socket,
++			  IPPROTO_TCP,
++			  TCP_CONGESTION,
++			  (void *)ccalgo,
++			  strlen(ccalgo));
++#else
++	errno = ENOTSUP;
++	return -1;
++#endif
++}
++
+ /**
+  * @internal
+  *
+@@ -256,6 +270,18 @@ socket_t ssh_connect_host_nonblocking(ssh_session session, const char *host,
+             }
+         }
+ 
++        if (session->opts.ccalgo) {
++	     rc = set_tcp_ccalgo(s, session->opts.ccalgo);
++	     if (rc < 0) {
++		 ssh_set_error(session, SSH_FATAL,
++			       "Failed to set TCP_CONGESTION on socket: %s",
++			       ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
++		 ssh_connect_socket_close(s);
++		 s = -1;
++		 continue;
++	     }
++	}
++
+         errno = 0;
+         rc = connect(s, itr->ai_addr, itr->ai_addrlen);
+         if (rc == -1 && (errno != 0) && (errno != EINPROGRESS)) {
+diff --git a/src/options.c b/src/options.c
+index 38511455..a183605d 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -217,6 +217,7 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+     new->opts.gss_delegate_creds    = src->opts.gss_delegate_creds;
+     new->opts.flags                 = src->opts.flags;
+     new->opts.nodelay               = src->opts.nodelay;
++    new->opts.ccalgo                = src->opts.ccalgo;
+     new->opts.config_processed      = src->opts.config_processed;
+     new->common.log_verbosity       = src->common.log_verbosity;
+     new->common.callbacks           = src->common.callbacks;
+@@ -458,6 +459,10 @@ int ssh_options_set_algo(ssh_session session,
+  *                Set it to disable Nagle's Algorithm (TCP_NODELAY) on the
+  *                session socket. (int, 0=false)
+  *
++ *              - SSH_OPTIONS_CCALGO
++ *                Set it to specify TCP congestion control algorithm on the
++ *                session socket (Linux only). (int, 0=false)
++ *
+  *              - SSH_OPTIONS_PROCESS_CONFIG
+  *                Set it to false to disable automatic processing of per-user
+  *                and system-wide OpenSSH configuration files. LibSSH
+@@ -1023,6 +1028,20 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                 session->opts.nodelay = (*x & 0xff) > 0 ? 1 : 0;
+             }
+             break;
++	case SSH_OPTIONS_CCALGO:
++            v = value;
++            if (v == NULL || v[0] == '\0') {
++                ssh_set_error_invalid(session);
++                return -1;
++            } else {
++                SAFE_FREE(session->opts.ccalgo);
++                session->opts.ccalgo = strdup(v);
++                if (session->opts.ccalgo == NULL) {
++                    ssh_set_error_oom(session);
++                    return -1;
++                }
++            }
++            break;
+         case SSH_OPTIONS_PROCESS_CONFIG:
+             if (value == NULL) {
+                 ssh_set_error_invalid(session);
+diff --git a/src/session.c b/src/session.c
+index 8c509699..88602b6a 100644
+--- a/src/session.c
++++ b/src/session.c
+@@ -108,6 +108,7 @@ ssh_session ssh_new(void)
+     session->opts.fd = -1;
+     session->opts.compressionlevel = 7;
+     session->opts.nodelay = 0;
++    session->opts.ccalgo = NULL;
+ 
+     session->opts.flags = SSH_OPT_FLAG_PASSWORD_AUTH |
+                           SSH_OPT_FLAG_PUBKEY_AUTH |
+diff --git a/src/sftp.c b/src/sftp.c
+index e01012a8..702623a0 100644
+--- a/src/sftp.c
++++ b/src/sftp.c
+@@ -2228,6 +2228,132 @@ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
+   return -1; /* not reached */
+ }
+ 
++/*
++ * sftp_async_write is based on and sftp_async_write_end is copied from
++ * https://github.com/limes-datentechnik-gmbh/libssh
++ *
++ * sftp_async_write has some optimizations:
++ * - use ssh_buffer_new_size() to reduce realoc_buffer.
++ * - use ssh_buffer_add_func() to avoid memcpy from read buffer to ssh buffer.
++ */
++ssize_t sftp_async_write(sftp_file file, ssh_add_func f, size_t count, void *userdata,
++			 uint32_t* id) {
++  sftp_session sftp = file->sftp;
++  ssh_buffer buffer;
++  uint32_t buf_sz;
++  ssize_t actual;
++  int len;
++  int packetlen;
++  int rc;
++
++#define HEADROOM 16
++  /* sftp_packet_write() prepends a 5-bytes (uint32_t length and
++   * 1-byte type) header to the head of the payload by
++   * ssh_buffer_prepend_data(). Inserting headroom by
++   * ssh_buffer_new_size() eliminates memcpy for prepending the
++   * header.
++   */
++
++  buf_sz = (HEADROOM + /* for header */
++	    sizeof(uint32_t) + /* id */
++	    ssh_string_len(file->handle) + 4 + /* file->handle */
++	    sizeof(uint64_t) + /* file->offset */
++	    sizeof(uint32_t) + /* count */
++	    count); /* datastring */
++
++  buffer = ssh_buffer_new_size(buf_sz, HEADROOM);
++  if (buffer == NULL) {
++    ssh_set_error_oom(sftp->session);
++    return -1;
++  }
++
++  *id = sftp_get_new_id(file->sftp);
++
++  rc = ssh_buffer_pack(buffer,
++                       "dSqd",
++                       *id,
++                       file->handle,
++                       file->offset,
++                       count); /* len of datastring */
++
++  if (rc != SSH_OK){
++    ssh_set_error_oom(sftp->session);
++    ssh_buffer_free(buffer);
++    return SSH_ERROR;
++  }
++
++  actual = ssh_buffer_add_func(buffer, f, count, userdata);
++  if (actual < 0){
++    ssh_set_error_oom(sftp->session);
++    ssh_buffer_free(buffer);
++    return SSH_ERROR;
++  }
++
++  packetlen=ssh_buffer_get_len(buffer)+5;
++  len = sftp_packet_write(file->sftp, SSH_FXP_WRITE, buffer);
++  ssh_buffer_free(buffer);
++  if (len < 0) {
++    return SSH_ERROR;
++  } else  if (len != packetlen) {
++    ssh_set_error(sftp->session, SSH_FATAL,
++      "Could only send %d of %d bytes to remote host!", len, packetlen);
++    SSH_LOG(SSH_LOG_PACKET,
++        "Could not write as much data as expected");
++    return SSH_ERROR;
++  }
++
++  file->offset += actual;
++
++  return actual;
++}
++
++int sftp_async_write_end(sftp_file file, uint32_t id, int blocking) {
++  sftp_session sftp = file->sftp;
++  sftp_message msg = NULL;
++  sftp_status_message status;
++
++  msg = sftp_dequeue(sftp, id);
++  while (msg == NULL) {
++    if (!blocking && ssh_channel_poll(sftp->channel, 0) == 0) {
++      /* we cannot block */
++      return SSH_AGAIN;
++    }
++    if (sftp_read_and_dispatch(sftp) < 0) {
++      /* something nasty has happened */
++      return SSH_ERROR;
++    }
++    msg = sftp_dequeue(sftp, id);
++  }
++
++  switch (msg->packet_type) {
++    case SSH_FXP_STATUS:
++      status = parse_status_msg(msg);
++      sftp_message_free(msg);
++      if (status == NULL) {
++        return SSH_ERROR;
++      }
++      sftp_set_error(sftp, status->status);
++      switch (status->status) {
++        case SSH_FX_OK:
++          status_msg_free(status);
++          return SSH_OK;
++        default:
++          break;
++      }
++      ssh_set_error(sftp->session, SSH_REQUEST_DENIED,
++          "SFTP server: %s", status->errormsg);
++      status_msg_free(status);
++      return SSH_ERROR;
++    default:
++      ssh_set_error(sftp->session, SSH_FATAL,
++          "Received message %d during write!", msg->packet_type);
++      sftp_message_free(msg);
++      return SSH_ERROR;
++  }
++
++  return SSH_ERROR; /* not reached */
++}
++
+ /* Seek to a specific location in a file. */
+ int sftp_seek(sftp_file file, uint32_t new_offset) {
+   if (file == NULL) {

pysetup.py

@@ -11,6 +11,9 @@ if sys.platform == "linux":
 elif sys.platform == "darwin":
     libmscp = "libmscp.dylib"
 
+data_dir = sys.prefix + "/lib"
+libmscp = "build/" + libmscp
+
 setup(
     name='mscp',
     version = version,
@@ -20,7 +23,7 @@ setup(
     url = "https://github.com/upa/mscp",
     packages = find_packages("mscp"),
     package_dir = {"": "mscp"},
-    data_files = [ ("", ["build/" + libmscp])],
+    data_files = [ (data_dir, [libmscp])],
     py_modules = [ "mscp" ],
     ext_modules = [
         Extension(

scripts/install-build-deps.sh

@@ -19,7 +19,7 @@ case $platform in
 		apt-get install -y \
 			gcc make cmake zlib1g-dev libssl-dev libkrb5-dev
 		;;
-	Linux-centos* | Linux-rhel* | Linux-rocky*)
+	Linux-centos* | Linux-rhel* | Linux-rocky* | Linux-almalinux)
 		yum install -y \
 			gcc make cmake zlib-devel openssl-devel rpm-build
 		;;

scripts/print-install-deps.sh

@@ -14,10 +14,10 @@ case $release in
 	ubuntu-22.04*)
 		echo "libc6 (>= 2.33), libgssapi-krb5-2 (>= 1.17), libssl3 (>= 3.0.0~~alpha1), zlib1g (>= 1:1.1.4)"
 		;;
-	centos* | rhel* | rocky*)
+	centos* | rhel* | rocky* | almalinux*)
 		echo "glibc crypto-policies krb5-libs openssl-libs libcom_err"
 		;;
 	*)
-		echo "unsupported install dependency: $release"
+		echo "$(basename $0): unsupported install dependency: $release"
 		exit 1
 esac

scripts/test-in-container.sh

@@ -11,6 +11,7 @@ set -x
 # Run sshd
 if [ ! -e /var/run/sshd.pid ]; then
 	/usr/sbin/sshd
+	sleep 1
 fi
 
 ssh-keyscan localhost >> ${HOME}/.ssh/known_hosts

src/atomic.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _ATOMIC_H_
 #define _ATOMIC_H_
 
@@ -20,6 +21,8 @@ static inline refcnt refcnt_dec(refcnt *cnt)
 }
 
 
+/* mutex */
+
 typedef pthread_mutex_t lock;
 
 static inline void lock_init(lock *l)
@@ -44,12 +47,58 @@ static inline void lock_release_via_cleanup(void *l)
 	lock_release(l);
 }
 
-#define LOCK_ACQUIRE_THREAD(l)				\
-		lock_acquire(l);			\
-		pthread_cleanup_push(lock_release_via_cleanup, l)
+#define LOCK_ACQUIRE(l)						\
+	lock_acquire(l);					\
+	pthread_cleanup_push(lock_release_via_cleanup, l)
 
-
-#define LOCK_RELEASE_THREAD() \
+#define LOCK_RELEASE()				\
 	pthread_cleanup_pop(1)
 
+
+
+/* read/write lock */
+typedef pthread_rwlock_t rwlock;
+
+static inline void rwlock_init(rwlock *rw)
+{
+	pthread_rwlock_init(rw, NULL);
+}
+
+static inline void rwlock_read_acquire(rwlock *rw)
+{
+	int ret = pthread_rwlock_rdlock(rw);
+	assert(ret == 0);
+}
+
+static inline void rwlock_write_acquire(rwlock *rw)
+{
+	int ret = pthread_rwlock_wrlock(rw);
+	assert(ret == 0);
+}
+
+static inline void rwlock_release(rwlock *rw)
+{
+	int ret = pthread_rwlock_unlock(rw);
+	assert(ret == 0);
+}
+
+static inline void rwlock_release_via_cleanup(void *rw)
+{
+	rwlock_release(rw);
+}
+
+#define RWLOCK_READ_ACQUIRE(rw)						\
+	rwlock_read_acquire(rw);					\
+	pthread_cleanup_push(rwlock_release_via_cleanup, rw)
+
+#define RWLOCK_WRITE_ACQUIRE(rw)					\
+	rwlock_write_acquire(rw);					\
+	pthread_cleanup_push(rwlock_release_via_cleanup, rw)
+
+
+#define RWLOCK_RELEASE()			\
+	pthread_cleanup_pop(1)
+
+
+
 #endif /* _ATOMIC_H_ */

src/fileops.c

@@ -0,0 +1,367 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include <fileops.h>
+#include <ssh.h>
+#include <message.h>
+
+
+sftp_session __thread tls_sftp;
+/* tls_sftp is used *_wrapped() functions */
+
+void set_tls_sftp_session(sftp_session sftp)
+{
+	tls_sftp = sftp;
+}
+
+static void sftp_err_to_errno(sftp_session sftp)
+{
+	int sftperr = sftp_get_error(sftp);
+
+	switch (sftperr){
+	case SSH_FX_OK:
+	case SSH_FX_EOF:
+		errno = 0;
+		break;
+	case SSH_FX_NO_SUCH_FILE:
+	case SSH_FX_NO_SUCH_PATH:
+		errno = ENOENT;
+		break;
+	case SSH_FX_PERMISSION_DENIED:
+		errno = EACCES;
+		break;
+	case SSH_FX_FAILURE:
+		errno = EINVAL;
+	case SSH_FX_BAD_MESSAGE:
+		errno = EBADMSG;
+	case SSH_FX_NO_CONNECTION:
+		errno = ENOTCONN;
+		break;
+	case SSH_FX_CONNECTION_LOST:
+		errno = ENETRESET;
+		break;
+	case SSH_FX_OP_UNSUPPORTED:
+		errno = EOPNOTSUPP;
+		break;
+	case SSH_FX_INVALID_HANDLE:
+		errno = EBADF;
+		break;
+	case SSH_FX_FILE_ALREADY_EXISTS:
+		errno = EEXIST;
+		break;
+	case SSH_FX_WRITE_PROTECT:
+		errno = EPERM;
+		break;
+	case SSH_FX_NO_MEDIA:
+		errno = ENODEV;
+		break;
+	default:
+		mpr_warn(stderr, "unkown SSH_FX response %d", sftperr);
+	}
+}
+
+
+MDIR *mscp_opendir(const char *path, sftp_session sftp)
+{
+	MDIR *md;
+
+	if (!(md = malloc(sizeof(*md))))
+		return NULL;
+	memset(md, 0, sizeof(*md));
+
+	if (sftp) {
+		md->remote = sftp_opendir(sftp, path);
+		sftp_err_to_errno(sftp);
+		if (!md->remote) {
+			goto free_out;
+		}
+	} else {
+		md->local = opendir(path);
+		if (!md->local) {
+			goto free_out;
+		}
+	}
+
+	return md;
+
+free_out:
+	free(md);
+	return NULL;
+}
+
+MDIR *mscp_opendir_wrapped(const char *path)
+{
+	return mscp_opendir(path, tls_sftp);
+}
+
+void mscp_closedir(MDIR *md)
+{
+	int ret;
+	if (md->remote)
+		sftp_closedir(md->remote);
+	else
+		closedir(md->local);
+
+	free(md);
+}
+
+
+struct dirent __thread tls_dirent;
+/* tls_dirent contains dirent converted from sftp_attributes returned
+ * from sftp_readdir(). This trick is derived from openssh's
+ * fudge_readdir() */
+
+struct dirent *mscp_readdir(MDIR *md)
+{
+	sftp_attributes attr;
+	struct dirent *ret = NULL;
+	static int inum = 1;
+
+	if (md->remote) {
+		attr = sftp_readdir(md->remote->sftp, md->remote);
+		if (!attr) {
+			sftp_err_to_errno(md->remote->sftp);
+			return NULL;
+		}
+
+		memset(&tls_dirent, 0, sizeof(tls_dirent));
+		strncpy(tls_dirent.d_name, attr->name, sizeof(tls_dirent.d_name) - 1);
+		tls_dirent.d_ino = inum++;
+		if (!inum)
+			inum = 1;
+		ret = &tls_dirent;
+		sftp_attributes_free(attr);
+	} else
+		ret = readdir(md->local);
+
+	return ret;
+}
+
+int mscp_mkdir(const char *path, mode_t mode, sftp_session sftp)
+{
+	int ret;
+
+	if (sftp) {
+		ret = sftp_mkdir(sftp, path, mode);
+		sftp_err_to_errno(sftp);
+	} else
+		ret = mkdir(path, mode);
+
+	if (ret < 0 && errno == EEXIST) {
+		ret = 0;
+	}
+
+	return ret;
+}
+
+
+static void sftp_attr_to_stat(sftp_attributes attr, struct stat *st)
+{
+        memset(st, 0, sizeof(*st));
+	st->st_size	= attr->size;
+	st->st_uid	= attr->uid;
+	st->st_gid	= attr->gid;
+	st->st_mode	= attr->permissions;
+
+	switch (attr->type) {
+	case SSH_FILEXFER_TYPE_REGULAR:
+		st->st_mode |= S_IFREG;
+		break;
+	case SSH_FILEXFER_TYPE_DIRECTORY:
+		st->st_mode |= S_IFDIR;
+		break;
+	case SSH_FILEXFER_TYPE_SYMLINK:
+		st->st_mode |= S_IFLNK;
+		break;
+	case SSH_FILEXFER_TYPE_SPECIAL:
+		st->st_mode |= S_IFCHR; /* or block? */
+		break;
+	case SSH_FILEXFER_TYPE_UNKNOWN:
+		st->st_mode |= S_IFIFO; /* really? */
+		break;
+	default:
+		mpr_warn(stderr, "unkown SSH_FILEXFER_TYPE %d", attr->type);
+	}
+
+	/* ToDo: convert atime, ctime, and mtime */
+}
+
+
+int mscp_stat(const char *path, struct stat *st, sftp_session sftp)
+{
+	sftp_attributes attr;
+	int ret = 0;
+
+	if (sftp) {
+		attr = sftp_stat(sftp, path);
+		sftp_err_to_errno(sftp);
+		if (!attr)
+			return -1;
+
+		sftp_attr_to_stat(attr, st);
+		sftp_attributes_free(attr);
+		ret = 0;
+	} else
+		ret = stat(path, st);
+
+	return ret;
+}
+
+int mscp_stat_wrapped(const char *path, struct stat *st)
+{
+	return mscp_stat(path, st, tls_sftp);
+}
+
+int mscp_lstat(const char *path, struct stat *st, sftp_session sftp)
+{
+	sftp_attributes attr;
+	int ret = 0;
+
+	if (sftp) {
+		attr = sftp_lstat(sftp, path);
+		sftp_err_to_errno(sftp);
+		if (!attr)
+			return -1;
+
+		sftp_attr_to_stat(attr, st);
+		sftp_attributes_free(attr);
+		ret = 0;
+	} else
+		ret = lstat(path, st);
+
+	return ret;
+}
+
+int mscp_lstat_wrapped(const char *path, struct stat *st)
+{
+	return mscp_lstat(path, st, tls_sftp);
+}
+
+
+mf *mscp_open(const char *path, int flags, mode_t mode, sftp_session sftp)
+{
+	mf *f;
+
+	f = malloc(sizeof(*f));
+	if (!f)
+		return NULL;
+	memset(f, 0, sizeof(*f));
+
+	if (sftp) {
+		f->remote = sftp_open(sftp, path, flags, mode);
+		if (!f->remote) {
+			sftp_err_to_errno(sftp);
+			goto free_out;
+		}
+	} else {
+		f->local = open(path, flags, mode);
+		if (f->local < 0)
+			goto free_out;
+	}
+
+	return f;
+
+free_out:
+	free(f);
+	return NULL;
+}
+
+void mscp_close(mf *f)
+{
+	if (f->remote)
+		sftp_close(f->remote);
+	if (f->local > 0)
+		close(f->local);
+	free(f);
+}
+
+off_t mscp_lseek(mf *f, off_t off)
+{
+	off_t ret;
+
+	if (f->remote) {
+		ret = sftp_seek64(f->remote, off);
+		sftp_err_to_errno(f->remote->sftp);
+	} else
+		ret = lseek(f->local, off, SEEK_SET);
+
+	return ret;
+}
+
+int mscp_setstat(const char *path, mode_t mode, size_t size, sftp_session sftp)
+{
+	int ret;
+
+	if (sftp) {
+		struct sftp_attributes_struct attr;
+		memset(&attr, 0, sizeof(attr));
+		attr.permissions = mode;
+		attr.size = size;
+		attr.flags = (SSH_FILEXFER_ATTR_PERMISSIONS|SSH_FILEXFER_ATTR_SIZE);
+		ret = sftp_setstat(sftp, path, &attr);
+		sftp_err_to_errno(sftp);
+	} else {
+		if ((ret = chmod(path, mode)) < 0)
+			return ret;
+		if ((ret = truncate(path, size)) < 0)
+			return ret;
+	}
+
+	return ret;
+}
+
+int mscp_glob(const char *pattern, int flags, glob_t *pglob, sftp_session sftp)
+{
+	int ret;
+	if (sftp) {
+#ifndef GLOB_ALTDIRFUNC
+#define GLOB_NOALTDIRMAGIC INT_MAX
+		/* musl does not implement GLOB_ALTDIRFUNC */
+		pglob->gl_pathc = 1;
+		pglob->gl_pathv = malloc(sizeof(char *));
+		pglob->gl_pathv[0] = strdup(pattern);
+		pglob->gl_offs = GLOB_NOALTDIRMAGIC;
+		return 0;
+#else
+		flags |= GLOB_ALTDIRFUNC;
+		set_tls_sftp_session(sftp);
+#ifdef __APPLE__
+		pglob->gl_opendir = (void *(*)(const char *))mscp_opendir_wrapped;
+		pglob->gl_readdir = (struct dirent *(*)(void *))mscp_readdir;
+		pglob->gl_closedir = (void (*)(void *))mscp_closedir;
+		pglob->gl_lstat = mscp_lstat_wrapped;
+		pglob->gl_stat = mscp_stat_wrapped;
+#elif linux
+		pglob->gl_opendir = (void *(*)(const char *))mscp_opendir_wrapped;
+		pglob->gl_readdir = (void *(*)(void *))mscp_readdir;
+		pglob->gl_closedir = (void (*)(void *))mscp_closedir;
+		pglob->gl_lstat = (int (*)(const char *, void *))mscp_lstat_wrapped;
+		pglob->gl_stat = (int (*)(const char *, void *))mscp_stat_wrapped;
+#else
+#error unsupported platform
+#endif
+#endif
+	}
+
+	ret = glob(pattern, flags, NULL, pglob);
+
+	if (sftp)
+		set_tls_sftp_session(NULL);
+	return ret;
+}
+
+void mscp_globfree(glob_t *pglob)
+{
+#ifndef GLOB_ALTDIRFUNC
+	if (pglob->gl_offs == GLOB_NOALTDIRMAGIC) {
+		free(pglob->gl_pathv[0]);
+		free(pglob->gl_pathv);
+		return;
+	}
+#endif
+	globfree(pglob);
+}

src/fileops.h

@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
+#include <dirent.h>
+#include <sys/stat.h>
+#include <glob.h>
+
+#include <ssh.h>
+
+void set_tls_sftp_session(sftp_session sftp);
+/* sftp_session set by set_tls_sftp_session is sued in
+ mscp_open_wrapped(), mscp_stat_wrapped(), and
+ mscp_lstat_wrapped(). This _wrapped() functions exist for
+ sftp_glob() */
+
+/* directory operations */
+
+struct mdir_struct {
+	DIR *local;
+	sftp_dir remote;
+};
+typedef struct mdir_struct MDIR;
+
+
+MDIR *mscp_opendir(const char *path, sftp_session sftp);
+MDIR *mscp_opendir_wrapped(const char *path);
+void mscp_closedir(MDIR *md);
+struct dirent *mscp_readdir(MDIR *md);
+
+int mscp_mkdir(const char *path, mode_t mode, sftp_session sftp);
+
+/* stat operations */
+int mscp_stat(const char *path, struct stat *st, sftp_session sftp);
+int mscp_stat_wrapped(const char *path, struct stat *st);
+
+int mscp_lstat(const char *path, struct stat *st, sftp_session sftp);
+int mscp_lstat_wrapped(const char *path, struct stat *st);
+
+
+/* file operations */
+
+struct mf_struct {
+	sftp_file remote;
+	int local;
+};
+typedef struct mf_struct mf;
+
+mf *mscp_open(const char *path, int flags, mode_t mode, sftp_session sftp);
+void mscp_close(mf *f);
+off_t mscp_lseek(mf *f, off_t off);
+
+/* mscp_setstat() involves chmod and truncate. It executes both at
+ * once via a single SFTP command (sftp_setstat()).
+ */
+int mscp_setstat(const char *path, mode_t mode, size_t size, sftp_session sftp);
+
+/* remote glob */
+int mscp_glob(const char *pattern, int flags, glob_t *pglob, sftp_session sftp);
+void mscp_globfree(glob_t *pglob);

src/main.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -11,23 +12,19 @@
 #include <pthread.h>
 
 #include <mscp.h>
+#include <mscp_version.h>
 #include <util.h>
 
 
-#ifndef _VERSION /* passed through cmake */
-#define VERSION "(unknown)"
-#else
-#define VERSION _VERSION
-#endif
-
-
 void usage(bool print_help) {
-	printf("mscp v" VERSION ": copy files over multiple ssh connections\n"
+	printf("mscp " MSCP_BUILD_VERSION ": copy files over multiple ssh connections\n"
 	       "\n"
-	       "Usage: mscp [vqDHdNh] [-n nr_conns] [-m coremask] [-u max_startups]\n"
+	       "Usage: mscp [vqDHdNh] [-n nr_conns] [-m coremask]\n"
+	       "            [-u max_startups] [-I interval]\n"
 	       "            [-s min_chunk_sz] [-S max_chunk_sz] [-a nr_ahead] [-b buf_sz]\n"
-	       "            [-l login_name] [-p port] [-i identity_file]\n"
-	       "            [-c cipher_spec] [-M hmac_spec] [-C compress] source ... target\n"
+	       "            [-l login_name] [-p port] [-F ssh_config] [-i identity_file]\n"
+	       "            [-c cipher_spec] [-M hmac_spec] [-C compress] [-g congestion]\n"
+	       "            source ... target\n"
 	       "\n");
 
 	if (!print_help)
@@ -36,11 +33,12 @@ void usage(bool print_help) {
 	printf("    -n NR_CONNECTIONS  number of connections "
 	       "(default: floor(log(cores)*2)+1)\n"
 	       "    -m COREMASK        hex value to specify cores where threads pinned\n"
-	       "    -u MAX_STARTUPS    number of concurrent outgoing connections "
+	       "    -u MAX_STARTUPS    number of concurrent SSH connection attempts "
 	       "(default: 8)\n"
+	       "    -I INTERVAL        interval between SSH connection attempts (default: 0)\n"
+	       "\n"
 	       "    -s MIN_CHUNK_SIZE  min chunk size (default: 64MB)\n"
 	       "    -S MAX_CHUNK_SIZE  max chunk size (default: filesize/nr_conn)\n"
-	       "\n"
 	       "    -a NR_AHEAD        number of inflight SFTP commands (default: 32)\n"
 	       "    -b BUF_SZ          buffer size for i/o and transfer\n"
 	       "\n"
@@ -50,12 +48,14 @@ void usage(bool print_help) {
 	       "    -r                 no effect\n"
 	       "\n"
 	       "    -l LOGIN_NAME      login name\n"
-	       "    -p PORT            port number\n"
+	       "    -p/-P PORT         port number\n"
+	       "    -F CONFIG          path to user ssh config (default ~/.ssh/config)\n"
 	       "    -i IDENTITY        identity file for public key authentication\n"
 	       "    -c CIPHER          cipher spec\n"
 	       "    -M HMAC            hmac spec\n"
 	       "    -C COMPRESS        enable compression: "
 	       "yes, no, zlib, zlib@openssh.com\n"
+	       "    -g CONGESTION      specify TCP congestion control algorithm\n"
 	       "    -H                 disable hostkey check\n"
 	       "    -d                 increment ssh debug output level\n"
 	       "    -N                 enable Nagle's algorithm (default disabled)\n"
@@ -63,58 +63,113 @@ void usage(bool print_help) {
 	       "\n");
 }
 
-char *split_remote_and_path(const char *string, char **remote, char **path)
+char *strip_brackets(char *s)
 {
-	char *s, *p;
-
-	/* split user@host:path into user@host, and path.
-	 * return value is strdup()ed memory (for free()).
-	 */
-
-	if (!(s = strdup(string))) {
-		fprintf(stderr, "strdup: %s\n", strerror(errno));
-		return NULL;
+	if (s[0] == '[' && s[strlen(s) - 1] == ']') {
+		s[strlen(s) - 1] = '\0';
+		return s + 1;
 	}
-
-	if ((p = strchr(s, ':'))) {
-		if (p == s || ((p > s) && *(p - 1) == '\\')) {
-			/* first byte is colon, or escaped colon. no user@host here  */
-			goto no_remote;
-		} else {
-			/* we found ':', so this is remote:path notation. split it */
-			*p = '\0';
-			*remote = s;
-			*path = p + 1;
-			return s;
-		}
-	}
-
-no_remote:
-	*remote = NULL;
-	*path = s;
 	return s;
 }
 
+char *split_user_host_path(const char *s, char **userp, char **hostp, char **pathp)
+{
+	char *tmp, *cp, *user = NULL, *host = NULL, *path = NULL;
+	bool inbrackets = false;
+
+	if (!(tmp = strdup(s))) {
+		fprintf(stderr, "stdrup: %s\n", strerror(errno));
+		return NULL;
+	}
+
+	user = NULL;
+	host = NULL;
+	path = tmp;
+	for (cp = tmp; *cp; cp++) {
+		if (*cp == '@' && (cp > tmp) && *(cp - 1) != '\\' && user == NULL) {
+			/* cp is non-escaped '@', so this '@' is the
+			 * delimitater between username and host. */
+			*cp = '\0';
+			user = tmp;
+			host = cp + 1;
+		}
+		if (*cp == '[')
+			inbrackets = true;
+		if (*cp == ']')
+			inbrackets = false;
+		if (*cp == ':' && (cp > tmp) && *(cp - 1) != '\\') {
+			if (!inbrackets) {
+				/* cp is non-escaped ':' and not in
+				 * brackets for IPv6 address
+				 * notation. So, this ':' is the
+				 * delimitater between host and
+				 * path. */
+				*cp = '\0';
+				host = host == NULL ? tmp : host;
+				path = cp + 1;
+				break;
+			}
+		}
+	}
+	*userp = user;
+	*hostp = host ? strip_brackets(host) : NULL;
+	*pathp = path;
+	return tmp;
+}
+
 struct target {
-	char *remote;
+	char *copy;
+	char *user;
+	char *host;
 	char *path;
 };
 
+int compare_remote(struct target *a, struct target *b)
+{
+	/* return 0 if a and b have the identical user@host, otherwise 1 */
+	int alen, blen;
+
+	if (a->user) {
+		if (!b->user)
+			return 1;
+		alen = strlen(a->user);
+		blen = strlen(b->user);
+		if (alen != blen)
+			return 1;
+		if (strncmp(a->user, b->user, alen) != 0)
+			return 1;
+	} else if (b->user)
+		return 1;
+
+	if (a->host) {
+		if (!b->host)
+			return 1;
+		alen = strlen(a->host);
+		blen = strlen(b->host);
+		if (alen != blen)
+			return 1;
+		if (strncmp(a->host, b->host, alen) != 0)
+			return 1;
+	} else if (b->host)
+		return 1;
+
+	return 0;
+}
+
 struct target *validate_targets(char **arg, int len)
 {
 	/* arg is array of source ... destination.
 	 * There are two cases:
 	 *
-	 * 1. remote:path remote:path ... path, remote to local copy
-	 * 2. path path ... remote:path, local to remote copy.
+	 * 1. user@host:path host:path ... path, remote to local copy
+	 * 2. path path ... host:path, local to remote copy.
 	 *
-	 * This function split (remote:)path args into struct target,
+	 * This function split user@remote:path args into struct target,
 	 * and validate all remotes are identical (mscp does not support
 	 * remote to remote copy).
 	 */
 
-	struct target *t;
-	char *r;
+	struct target *t, *t0;
 	int n;
 
 	if ((t = calloc(len, sizeof(struct target))) == NULL) {
@@ -125,33 +180,28 @@ struct target *validate_targets(char **arg, int len)
 
 	/* split remote:path into remote and path */
 	for (n = 0; n < len; n++) {
-		if (split_remote_and_path(arg[n], &t[n].remote, &t[n].path) == NULL)
+		t[n].copy = split_user_host_path(arg[n], &t[n].user,
+					      &t[n].host, &t[n].path);
+		if (!t[n].copy)
 			goto free_target_out;
 	}
 
-	/* check all remote are identical. t[len - 1] is destination,
+	/* check all user@host are identical. t[len - 1] is destination,
 	 * so we need to check t[0] to t[len - 2] having the identical
-	 * remote */
-	r = t[0].remote;
+	 * remote notation */
+	t0 = &t[0];
 	for (n = 1; n < len - 1; n++) {
-		if (!r && t[n].remote) {
+		if (compare_remote(t0, &t[n]) != 0)
 			goto invalid_remotes;
-		}
-		if (r) {
-			if (!t[n].remote ||
-			    strlen(r) != strlen(t[n].remote) ||
-			    strcmp(r, t[n].remote) != 0)
-				goto invalid_remotes;
-		}
 	}
 
 	/* check inconsistent remote position in args */
-	if (t[0].remote == NULL && t[len - 1].remote == NULL) {
+	if (t[0].host == NULL && t[len - 1].host == NULL) {
 		fprintf(stderr, "no remote host given\n");
 		goto free_split_out;
 	}
 
-	if (t[0].remote != NULL && t[len - 1].remote != NULL) {
+	if (t[0].host != NULL && t[len - 1].host != NULL) {
 		fprintf(stderr, "no local path given\n");
 		goto free_split_out;
 	}
@@ -159,11 +209,11 @@ struct target *validate_targets(char **arg, int len)
 	return t;
 
 invalid_remotes:
-	fprintf(stderr, "specified remote host invalid\n");
+	fprintf(stderr, "invalid remote host notation\n");
 
 free_split_out:
 	for (n = 0; n < len; n++)
-		t[n].remote ? free(t[n].remote) : free(t[n].path);
+		if (t[n].copy) free(t[n].copy);
 
 free_target_out:
 	free(t);
@@ -176,8 +226,6 @@ pthread_t tid_stat = 0;
 
 void sigint_handler(int sig)
 {
-	if (tid_stat)
-		pthread_cancel(tid_stat);
 	mscp_stop(m);
 }
 
@@ -207,7 +255,8 @@ int main(int argc, char **argv)
 	memset(&o, 0, sizeof(o));
 	o.severity = MSCP_SEVERITY_WARN;
 
-	while ((ch = getopt(argc, argv, "n:m:u:s:S:a:b:vqDrl:p:i:c:M:C:HdNh")) != -1) {
+	while ((ch = getopt(argc, argv,
+			    "n:m:u:I:s:S:a:b:vqDrl:P:p:i:F:c:M:C:g:HdNh")) != -1) {
 		switch (ch) {
 		case 'n':
 			o.nr_threads = atoi(optarg);
@@ -223,6 +272,9 @@ int main(int argc, char **argv)
 		case 'u':
 			o.max_startups = atoi(optarg);
 			break;
+		case 'I':
+			o.interval = atoi(optarg);
+			break;
 		case 's':
 			o.min_chunk_sz = atoi(optarg);
 			break;
@@ -254,6 +306,8 @@ int main(int argc, char **argv)
 			}
 			strncpy(s.login_name, optarg, MSCP_SSH_MAX_LOGIN_NAME - 1);
 			break;
+		case 'P':
+			/* fallthough for compatibility with scp */
 		case 'p':
 			if (strlen(optarg) > MSCP_SSH_MAX_PORT_STR - 1) {
 				fprintf(stderr, "long port string: %s\n", optarg);
@@ -261,6 +315,9 @@ int main(int argc, char **argv)
 			}
 			strncpy(s.port, optarg, MSCP_SSH_MAX_PORT_STR);
 			break;
+		case 'F':
+			strncpy(s.config, optarg, PATH_MAX - 1);
+			break;
 		case 'i':
 			if (strlen(optarg) > MSCP_SSH_MAX_IDENTITY_PATH - 1) {
 				fprintf(stderr, "long identity path: %s\n", optarg);
@@ -289,6 +346,13 @@ int main(int argc, char **argv)
 			}
 			strncpy(s.compress, optarg, MSCP_SSH_MAX_COMP_STR);
 			break;
+		case 'g':
+			if (strlen(optarg) > MSCP_SSH_MAX_CCALGO_STR - 1) {
+				fprintf(stderr, "long ccalgo string: %s\n", optarg);
+				return -1;
+			}
+			strncpy(s.ccalgo, optarg, MSCP_SSH_MAX_CCALGO_STR);
+			break;
 		case 'H':
 			s.no_hostkey_check = true;
 			break;
@@ -317,14 +381,19 @@ int main(int argc, char **argv)
 	if ((t = validate_targets(argv + optind, i)) == NULL)
 		return -1;
 
-	if (t[0].remote) {
+	if (t[0].host) {
 		/* copy remote to local */
 		direction = MSCP_DIRECTION_R2L;
-		remote = t[0].remote;
+		remote = t[0].host;
+		if (t[0].user != NULL && s.login_name[0] == '\0')
+			strncpy(s.login_name, t[0].user, MSCP_SSH_MAX_LOGIN_NAME - 1);
 	} else {
 		/* copy local to remote */
 		direction = MSCP_DIRECTION_L2R;
-		remote = t[i - 1].remote;
+		remote = t[i - 1].host;
+		if (t[i - 1].user != NULL && s.login_name[0] == '\0')
+			strncpy(s.login_name, t[i - 1].user,
+				MSCP_SSH_MAX_LOGIN_NAME - 1);
 	}
 
 	if (!dryrun) {
@@ -380,11 +449,11 @@ int main(int argc, char **argv)
 
 	ret = mscp_start(m);
 	if (ret < 0)
-		fprintf(stderr, "%s\n", mscp_get_error());
+		fprintf(stderr, "mscp_start: %s\n", mscp_get_error());
 
 	ret = mscp_join(m);
 	if (ret != 0)
-		fprintf(stderr, "%s\n", mscp_get_error());
+		fprintf(stderr, "mscp_join: %s\n", mscp_get_error());
 
 	pthread_cancel(tid_stat);
 	pthread_join(tid_stat, NULL);
@@ -421,19 +490,43 @@ double calculate_bps(size_t diff, struct timeval *b, struct timeval *a)
         return (double)diff / calculate_timedelta(b, a);
 }
 
-char *calculate_eta(size_t remain, size_t diff, struct timeval *b, struct timeval *a)
+
+char *calculate_eta(size_t remain, size_t diff, struct timeval *b, struct timeval *a,
+		    bool final)
 {
         static char buf[16];
-        double elapsed = calculate_timedelta(b, a);
-        double eta;
 
-        if (diff == 0)
+#define bps_window_size 16
+	static double bps_window[bps_window_size];
+	static size_t sum, idx, count;
+        double elapsed = calculate_timedelta(b, a);
+	double bps = diff / elapsed;
+	double avg, eta;
+
+	/* early return when diff == 0 (stalled) or final output */
+        if (diff == 0) {
                 snprintf(buf, sizeof(buf), "--:-- ETA");
-        else {
-                eta = remain / (diff / elapsed);
-                snprintf(buf, sizeof(buf), "%02d:%02d ETA",
-                         (int)floor(eta / 60), (int)round(eta) % 60);
-        }
+		return buf;
+	}
+	if (final) {
+		snprintf(buf, sizeof(buf), "%02d:%02d    ",
+			 (int)(floor(elapsed / 60)), (int)round(elapsed) % 60);
+		return buf;
+	}
+
+	/* drop the old bps value and add the recent one */
+	sum -= bps_window[idx];
+	bps_window[idx] = bps;
+	sum += bps_window[idx];
+	idx = (idx + 1) % bps_window_size;
+	count++;
+
+	/* calcuate ETA from avg of recent bps values */
+	avg = sum / min(count, bps_window_size);
+	eta = remain / avg;
+	snprintf(buf, sizeof(buf), "%02d:%02d ETA",
+		 (int)floor(eta / 60), (int)round(eta) % 60);
+
         return buf;
 }
 
@@ -474,13 +567,13 @@ void print_progress_bar(double percent, char *suffix)
 }
 
 void print_progress(struct timeval *b, struct timeval *a,
-		    size_t total, size_t last, size_t done)
+		    size_t total, size_t last, size_t done, bool final)
 {
         char *bps_units[] = { "B/s ", "KB/s", "MB/s", "GB/s" };
         char *byte_units[] = { "B ", "KB", "MB", "GB", "TB", "PB" };
         char suffix[128];
         int bps_u, byte_tu, byte_du;
-        size_t total_round, done_round;
+        double total_round, done_round;
         int percent;
         double bps;
 
@@ -503,13 +596,14 @@ void print_progress(struct timeval *b, struct timeval *a,
         percent = floor(((double)(done) / (double)total) * 100);
 
         done_round = done;
-        for (byte_du = 0; done_round > 1000 && byte_du < array_size(byte_units) - 1;
+        for (byte_du = 0; done_round > 1024 && byte_du < array_size(byte_units) - 1;
              byte_du++)
                 done_round /= 1024;
 
-        snprintf(suffix, sizeof(suffix), "%4lu%s/%lu%s %6.1f%s  %s",
+        snprintf(suffix, sizeof(suffix), "%4.1lf%s/%.1lf%s %6.1f%s  %s",
                  done_round, byte_units[byte_du], total_round, byte_units[byte_tu],
-                 bps, bps_units[bps_u], calculate_eta(total - done, done - last, b, a));
+                 bps, bps_units[bps_u],
+		 calculate_eta(total - done, done - last, b, a, final));
 
         print_progress_bar(percent, suffix);
 }
@@ -523,17 +617,42 @@ struct xfer_stat {
 };
 struct xfer_stat x;
 
-void print_stat_thread_cleanup(void *arg)
+void print_stat(bool final)
 {
+	struct pollfd pfd = { .fd = msg_fd, .events = POLLIN };
 	struct mscp_stats s;
+	char buf[8192];
+	int timeout;
+
+	if (poll(&pfd, 1, !final ? 100 : 0) < 0) {
+		fprintf(stderr, "poll: %s\n", strerror(errno));
+		return;
+	}
+
+	if (pfd.revents & POLLIN) {
+		memset(buf, 0, sizeof(buf));
+		if (read(msg_fd, buf, sizeof(buf)) < 0) {
+			fprintf(stderr, "read: %s\n", strerror(errno));
+			return;
+		}
+		print_cli("\r\033[K" "%s", buf);
+	}
 
 	gettimeofday(&x.after, NULL);
-	mscp_get_stats(m, &s);
-	x.total = s.total;
-	x.done = s.done;
+	if (calculate_timedelta(&x.before, &x.after) > 1 || final) {
+		mscp_get_stats(m, &s);
+		x.total = s.total;
+		x.done = s.done;
+		print_progress(!final ? &x.before : &x.start, &x.after,
+			       x.total, !final ? x.last : 0, x.done, final);
+		x.before = x.after;
+		x.last = x.done;
+	}
+}
 
-	/* print progress from the beginning */
-	print_progress(&x.start, &x.after, x.total, 0, x.done);
+void print_stat_thread_cleanup(void *arg)
+{
+	print_stat(true);
 	print_cli("\n"); /* final output */
 }
 
@@ -552,30 +671,7 @@ void *print_stat_thread(void *arg)
         pthread_cleanup_push(print_stat_thread_cleanup, NULL);
 
 	while (true) {
-		if (poll(&pfd, 1, 100) < 0) {
-			fprintf(stderr, "poll: %s\n", strerror(errno));
-			return NULL;
-		}
-
-		if (pfd.revents & POLLIN) {
-			memset(buf, 0, sizeof(buf));
-			if (read(msg_fd, buf, sizeof(buf)) < 0) {
-				fprintf(stderr, "read: %s\n", strerror(errno));
-				return NULL;
-			}
-			print_cli("\r\033[K" "%s", buf);
-		}
-
-		gettimeofday(&x.after, NULL);
-		if (calculate_timedelta(&x.before, &x.after) > 1) {
-			mscp_get_stats(m, &s);
-			x.total = s.total;
-			x.done = s.done;
-
-			print_progress(&x.before, &x.after, x.total, x.last, x.done);
-			x.before = x.after;
-			x.last = x.done;
-		}
+		print_stat(false);
 	}
 
 	pthread_cleanup_pop(1);

src/message.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>

src/message.h

@@ -1,7 +1,9 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _MESSAGE_H_
 #define _MESSAGE_H_
 
 #include <libgen.h>
+#include <stdio.h>
 
 #include <mscp.h>
 

src/mscp.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #include <stdbool.h>
 #include <unistd.h>
 #include <math.h>
@@ -9,6 +10,7 @@
 #include <util.h>       
 #include <ssh.h>                
 #include <path.h>
+#include <fileops.h>
 #include <atomic.h>             
 #include <platform.h>
 #include <message.h>
@@ -40,11 +42,15 @@ struct mscp {
 	int			ret_scan;	/* return code from scan thread */
 
 	size_t			total_bytes;	/* total bytes to be transferred */
-	struct mscp_thread	*threads;
+
+	struct list_head	thread_list;
+	rwlock			thread_rwlock;
 };
 
 
 struct mscp_thread {
+	struct list_head	list;	/* mscp->thread_list */
+
 	struct mscp	*m;
 	int		id;
 	sftp_session	sftp;
@@ -56,7 +62,7 @@ struct mscp_thread {
 };
 
 struct src {
-	struct list_head list;
+	struct list_head list;	/* mscp->src_list */
 	char *path;
 };
 
@@ -75,8 +81,6 @@ struct src {
 #define non_null_string(s) (s[0] != '\0')
 
 
-
-
 static int expand_coremask(const char *coremask, int **cores, int *nr_cores)
 {
         int n, *core_list, core_list_len = 0, nr_usable, nr_all;
@@ -198,6 +202,11 @@ static int validate_and_set_defaut_params(struct mscp_opts *o)
 		return -1;
 	}
 
+	if (o->interval > 0) {
+		/* when the interval is set, establish SSH connections sequentially. */
+		o->max_startups = 1;
+	}
+
 	if (o->msg_fd == 0)
 		o->msg_fd = STDOUT_FILENO;
 
@@ -211,7 +220,7 @@ struct mscp *mscp_init(const char *remote_host, int direction,
 	int n;
 
 	if (!remote_host) {
-		mscp_set_error("empty remote host\n");
+		mscp_set_error("empty remote host");
 		return NULL;
 	}
 
@@ -238,6 +247,9 @@ struct mscp *mscp_init(const char *remote_host, int direction,
 	INIT_LIST_HEAD(&m->path_list);
 	chunk_pool_init(&m->cp);
 
+	INIT_LIST_HEAD(&m->thread_list);
+	rwlock_init(&m->thread_rwlock);
+
 	if ((m->sem = sem_create(o->max_startups)) == NULL) {
 		mscp_set_error("sem_create: %s", strerrno());
 		goto free_out;
@@ -339,11 +351,14 @@ static int get_page_mask(void)
 
 static void mscp_stop_copy_thread(struct mscp *m)
 {
-	int n;
-        for (n = 0; n < m->opts->nr_threads; n++) {
-                if (m->threads[n].tid && !m->threads[n].finished)
-                        pthread_cancel(m->threads[n].tid);
-        }
+	struct mscp_thread *t;
+
+	RWLOCK_READ_ACQUIRE(&m->thread_rwlock);
+	list_for_each_entry(t, &m->thread_list, list) {
+		if (!t->finished)
+			pthread_cancel(t->tid);
+	}
+	RWLOCK_RELEASE();
 }
 
 static void mscp_stop_scan_thread(struct mscp *m)
@@ -366,7 +381,9 @@ void *mscp_scan_thread(void *arg)
 	struct list_head tmp;
 	struct path *p;
 	struct src *s;
-	mstat ss, ds;
+	struct stat ss, ds;
+	glob_t pglob;
+	int n;
 	
 	m->ret_scan = 0;
 
@@ -393,9 +410,8 @@ void *mscp_scan_thread(void *arg)
 		a.dst_path_should_dir = true;
 
 	if (mscp_stat(m->dst_path, &ds, dst_sftp) == 0) {
-		if (mstat_is_dir(ds))
+		if (S_ISDIR(ds.st_mode))
 			a.dst_path_is_dir = true;
-		mscp_stat_free(ds);
 	}
 
 	a.cp = &m->cp;
@@ -408,35 +424,43 @@ void *mscp_scan_thread(void *arg)
 
 	/* walk a src_path recusively, and resolve path->dst_path for each src */
 	list_for_each_entry(s, &m->src_list, list) {
-		if (mscp_stat(s->path, &ss, src_sftp) < 0) {
-			mscp_set_error("stat: %s", mscp_strerror(src_sftp));
-			mscp_stat_free(ss);
+		memset(&pglob, 0, sizeof(pglob));
+		if (mscp_glob(s->path, GLOB_NOCHECK, &pglob, src_sftp) < 0) {
+			mscp_set_error("mscp_glob: %s", strerrno());
 			goto err_out;
 		}
 
-		/* set path specific args */
-		a.src_path = s->path;
-		a.dst_path = m->dst_path;
-		a.src_path_is_dir = mstat_is_dir(ss);
-		mscp_stat_free(ss);
+		for (n = 0; n < pglob.gl_pathc; n++) {
+			if (mscp_stat(pglob.gl_pathv[n], &ss, src_sftp) < 0) {
+				mscp_set_error("stat: %s %s", s->path, strerrno());
+				goto err_out;
+			}
 
-		INIT_LIST_HEAD(&tmp);
-		if (walk_src_path(src_sftp, s->path, &tmp, &a) < 0)
-			goto err_out;
+			if (!a.dst_path_should_dir && pglob.gl_pathc > 1)
+				a.dst_path_should_dir = true; /* we have over 1 src */
 
-		list_splice_tail(&tmp, m->path_list.prev);
+			/* set path specific args */
+			a.src_path = pglob.gl_pathv[n];
+			a.dst_path = m->dst_path;
+			a.src_path_is_dir = S_ISDIR(ss.st_mode);
+
+			INIT_LIST_HEAD(&tmp);
+			if (walk_src_path(src_sftp, pglob.gl_pathv[n], &tmp, &a) < 0)
+				goto err_out;
+
+			list_splice_tail(&tmp, m->path_list.prev);
+		}
+		mscp_globfree(&pglob);
 	}
 
-	chunk_pool_set_filled(&m->cp);
-
 	mpr_info(m->msg_fp, "walk source path(s) done\n");
-
+	chunk_pool_set_filled(&m->cp);
 	m->ret_scan = 0;
 	return NULL;
 
 err_out:
+	chunk_pool_set_filled(&m->cp);
 	m->ret_scan = -1;
-	mscp_stop_copy_thread(m);
 	return NULL;
 }
 
@@ -450,10 +474,10 @@ int mscp_scan(struct mscp *m)
 		return -1;
 	}
 
-	/* need scan finished or over nr_threads chunks to determine
-	 * actual number of threads (and connections). If the number
-	 * of chunks are smaller than nr_threads, we adjust nr_threads
-	 * to the number of chunks.
+	/* We wait for there are over nr_threads chunks to determine
+	 * actual number of threads (and connections), or scan
+	 * finished. If the number of chunks are smaller than
+	 * nr_threads, we adjust nr_threads to the number of chunks.
 	 */
 	while (!chunk_pool_is_filled(&m->cp) &&
 	       chunk_pool_size(&m->cp) < m->opts->nr_threads)
@@ -476,9 +500,40 @@ int mscp_scan_join(struct mscp *m)
 
 static void *mscp_copy_thread(void *arg);
 
+static struct mscp_thread *mscp_copy_thread_spawn(struct mscp *m, int id)
+{
+	struct mscp_thread *t;
+	int ret;
+
+	t = malloc(sizeof(*t));
+	if (!t){
+		mscp_set_error("malloc: %s,", strerrno());
+		return NULL;
+	}
+
+	memset(t, 0, sizeof(*t));
+	t->m = m;
+	t->id = id;
+	if (m->cores == NULL)
+		t->cpu = -1;	/* not pinned to cpu */
+	else
+		t->cpu = m->cores[id % m->nr_cores];
+
+	ret = pthread_create(&t->tid, NULL, mscp_copy_thread, t);
+	if (ret < 0) {
+		mscp_set_error("pthread_create error: %d", ret);
+		free(t);
+		return NULL;
+	}
+
+	return t;
+}
+
+
 int mscp_start(struct mscp *m)
 {
-	int n, ret;
+	struct mscp_thread *t;
+	int n, ret = 0;
 
 	if ((n = chunk_pool_size(&m->cp)) < m->opts->nr_threads) {
 		mpr_notice(m->msg_fp, "we have only %d chunk(s). "
@@ -486,67 +541,79 @@ int mscp_start(struct mscp *m)
 		m->opts->nr_threads = n;
 	}
 
-	/* scan thread instances */
-	m->threads = calloc(m->opts->nr_threads, sizeof(struct mscp_thread));
-	memset(m->threads, 0, m->opts->nr_threads * sizeof(struct mscp_thread));
 	for (n = 0; n < m->opts->nr_threads; n++) {
-		struct mscp_thread *t = &m->threads[n];
-		t->m = m;
-		t->id = n;
-		if (!m->cores)
-			t->cpu = -1;
-		else
-			t->cpu = m->cores[n % m->nr_cores];
-
-                ret = pthread_create(&t->tid, NULL, mscp_copy_thread, t);
-                if (ret < 0) {
-                        mscp_set_error("pthread_create error: %d", ret);
-                        mscp_stop(m);
-			return -1;
-                }
+		t = mscp_copy_thread_spawn(m, n);
+		if (!t) {
+			mpr_err(m->msg_fp, "failed to spawn copy thread\n");
+			break;
+		}
+		RWLOCK_WRITE_ACQUIRE(&m->thread_rwlock);
+		list_add_tail(&t->list, &m->thread_list);
+		RWLOCK_RELEASE();
         }
 
-	return 0;
+	return n;
 }
 
 int mscp_join(struct mscp *m)
 {
+	struct mscp_thread *t;
+	struct path *p;
+	size_t done = 0, nr_copied = 0, nr_tobe_copied = 0;
 	int n, ret = 0;
 
 	/* waiting for scan thread joins... */
 	ret = mscp_scan_join(m);
 
         /* waiting for copy threads join... */
-        for (n = 0; n < m->opts->nr_threads; n++) {
-                if (m->threads[n].tid) {
-                        pthread_join(m->threads[n].tid, NULL);
-                        if (m->threads[n].ret < 0)
-                                ret = m->threads[n].ret;
-                }
-        }
+	RWLOCK_READ_ACQUIRE(&m->thread_rwlock);
+	list_for_each_entry(t, &m->thread_list, list) {
+		pthread_join(t->tid, NULL);
+		done += t->done;
+		if (t->ret < 0)
+			ret = t->ret;
+		if (t->sftp) {
+			ssh_sftp_close(t->sftp);
+			t->sftp = NULL;
+		}
+	}
+	RWLOCK_RELEASE();
 
         if (m->first) {
                 ssh_sftp_close(m->first);
 		m->first = NULL;
 	}
 
-        if (m->threads) {
-                for (n = 0; n < m->opts->nr_threads; n++) {
-                        struct mscp_thread *t = &m->threads[n];
-			if (t->ret != 0)
-				ret = ret;
+	/* count up number of transferred files */
+	list_for_each_entry(p, &m->path_list, list) {
+		nr_tobe_copied++;
+		if (p->state == FILE_STATE_DONE) {
+			nr_copied++;
+		}
+	}
 
-                        if (t->sftp) {
-                                ssh_sftp_close(t->sftp);
-				t->sftp = NULL;
-			}
-                }
-        }
+	mpr_notice(m->msg_fp, "%lu/%lu bytes copied for %lu/%lu files\n",
+		   done, m->total_bytes, nr_copied, nr_tobe_copied);
 
 	return ret;
 }
 
-/* copy thread related functions */
+/* copy thread-related functions */
+
+static void wait_for_interval(int interval)
+{
+	_Atomic static long next;
+	struct timeval t;
+	long now;
+
+	gettimeofday(&t, NULL);
+	now = t.tv_sec * 1000000 + t.tv_usec;
+
+	if (next - now > 0)
+		usleep(next - now);
+
+	next = now + interval * 1000000;
+}
 
 static void mscp_copy_thread_cleanup(void *arg)
 {
@@ -556,36 +623,45 @@ static void mscp_copy_thread_cleanup(void *arg)
 
 void *mscp_copy_thread(void *arg)
 {
-        sftp_session src_sftp, dst_sftp;
-        struct mscp_thread *t = arg;
+	sftp_session src_sftp, dst_sftp;
+	struct mscp_thread *t = arg;
 	struct mscp *m = t->m;
-        struct chunk *c;
+	struct chunk *c;
+	bool nomore;
+
+        pthread_cleanup_push(mscp_copy_thread_cleanup, t);
 
         if (t->cpu > -1) {
-                if (set_thread_affinity(pthread_self(), t->cpu) < 0) {
-			t->ret = -1;
-                        return NULL;
-		}
+                if (set_thread_affinity(pthread_self(), t->cpu) < 0)
+			goto err_out;
         }
 
 	if (sem_wait(m->sem) < 0) {
-		mscp_set_error("sem_wait: %s\n", strerrno());
+		mscp_set_error("sem_wait: %s", strerrno());
 		mpr_err(m->msg_fp, "%s", mscp_get_error());
 		goto err_out;
 	}
 
-	mpr_notice(m->msg_fp, "connecting to %s for a copy thread[%d]...\n",
-		   m->remote, t->id);
-	t->sftp = ssh_init_sftp_session(m->remote, m->ssh_opts);
+	if (!(nomore = chunk_pool_is_empty(&m->cp))) {
+		if (m->opts->interval > 0)
+			wait_for_interval(m->opts->interval);
+		mpr_notice(m->msg_fp, "thread:%d connecting to %s\n", t->id, m->remote);
+		t->sftp = ssh_init_sftp_session(m->remote, m->ssh_opts);
+	}
 
 	if (sem_post(m->sem) < 0) {
-		mscp_set_error("sem_post: %s\n", strerrno());
+		mscp_set_error("sem_post: %s", strerrno());
 		mpr_err(m->msg_fp, "%s", mscp_get_error());
 		goto err_out;
 	}
 
+	if (nomore) {
+		mpr_notice(m->msg_fp, "thread:%d no more connections needed\n", t->id);
+		goto out;
+	}
+
 	if (!t->sftp) {
-		mpr_err(m->msg_fp, "copy thread[%d]: %s\n", t->id, mscp_get_error());
+		mpr_err(m->msg_fp, "thread:%d: %s\n", t->id, mscp_get_error());
 		goto err_out;
 	}
 
@@ -602,10 +678,6 @@ void *mscp_copy_thread(void *arg)
                 return NULL; /* not reached */
         }
 
-        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
-        pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
-        pthread_cleanup_push(mscp_copy_thread_cleanup, t);
-
         while (1) {
                 c = chunk_pool_pop(&m->cp);
 		if (c == CHUNK_POP_WAIT) {
@@ -625,20 +697,25 @@ void *mscp_copy_thread(void *arg)
         pthread_cleanup_pop(1);
 
         if (t->ret < 0)
-                mscp_set_error("copy failed: chunk %s 0x%010lx-0x%010lx",
-			       c->p->path, c->off, c->off + c->len);
+		mpr_err(m->msg_fp, "thread:%d copy failed: %s 0x%010lx-0x%010lx\n",
+			t->id, c->p->path, c->off, c->off + c->len);
 
         return NULL;
 
 err_out:
+	t->finished = true;
 	t->ret = -1;
 	return NULL;
+out:
+	t->finished = true;
+	t->ret = 0;
+	return NULL;
 }
 
 
-/* cleanup related functions */
+/* cleanup-related functions */
 
-static void free_src(struct list_head *list)
+static void list_free_src(struct list_head *list)
 {
 	struct src *s;
 	s = list_entry(list, typeof(*s), list);
@@ -646,18 +723,18 @@ static void free_src(struct list_head *list)
 	free(s);
 }
 
-static void free_path(struct list_head *list)
+static void list_free_path(struct list_head *list)
 {
 	struct path *p;
 	p = list_entry(list, typeof(*p), list);
-	free(p);
+	free_path(p);
 }
 
-static void free_chunk(struct list_head *list)
+static void list_free_thread(struct list_head *list)
 {
-	struct chunk *c;
-	c = list_entry(list, typeof(*c), list);
-	free(c);
+	struct mscp_thread *t;
+	t = list_entry(list, typeof(*t), list);
+	free(t);
 }
 
 void mscp_cleanup(struct mscp *m)
@@ -667,19 +744,18 @@ void mscp_cleanup(struct mscp *m)
 		m->first = NULL;
 	}
 
-	list_free_f(&m->src_list, free_src);
+	list_free_f(&m->src_list, list_free_src);
 	INIT_LIST_HEAD(&m->src_list);
 
-	list_free_f(&m->path_list, free_path);
+	list_free_f(&m->path_list, list_free_path);
 	INIT_LIST_HEAD(&m->path_list);
 
 	chunk_pool_release(&m->cp);
 	chunk_pool_init(&m->cp);
 
-	if (m->threads) {
-		free(m->threads);
-		m->threads = NULL;
-	}
+	RWLOCK_WRITE_ACQUIRE(&m->thread_rwlock);
+	list_free_f(&m->thread_list, list_free_thread);
+	RWLOCK_RELEASE();
 }
 
 void mscp_free(struct mscp *m)
@@ -696,16 +772,20 @@ void mscp_free(struct mscp *m)
 
 void mscp_get_stats(struct mscp *m, struct mscp_stats *s)
 {
-	bool finished = true;
-	int n;
+	int nr_finished = 0, nr_threads = 0;
+	struct mscp_thread *t;
 
 	s->total = m->total_bytes;
-	for (s->done = 0, n = 0; n < m->opts->nr_threads; n++) {
-		s->done += m->threads[n].done;
+	s->done = 0;
 
-		if (!m->threads[n].done)
-			finished = false;
+	RWLOCK_READ_ACQUIRE(&m->thread_rwlock);
+	list_for_each_entry(t, &m->thread_list, list) {
+		nr_threads++;
+		s->done += t->done;
+		if (t->finished)
+			nr_finished++;
 	}
+	RWLOCK_RELEASE();
 
-	s->finished = finished;
+	s->finished = nr_threads > 0 ? (nr_finished == nr_threads) : false;
 }

src/path.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #include <string.h>
 #include <unistd.h>
 #include <dirent.h>
@@ -7,12 +8,12 @@
 
 #include <ssh.h>
 #include <util.h>
+#include <fileops.h>
 #include <list.h>
 #include <atomic.h>
 #include <path.h>
 #include <message.h>
 
-
 /* chunk pool operations */
 #define CHUNK_POOL_STATE_FILLING	0
 #define CHUNK_POOL_STATE_FILLED		1
@@ -27,10 +28,10 @@ void chunk_pool_init(struct chunk_pool *cp)
 
 static void chunk_pool_add(struct chunk_pool *cp, struct chunk *c)
 {
-	LOCK_ACQUIRE_THREAD(&cp->lock);
+	LOCK_ACQUIRE(&cp->lock);
 	list_add_tail(&c->list, &cp->list);
 	cp->count += 1;
-	LOCK_RELEASE_THREAD();
+	LOCK_RELEASE();
 }
 
 void chunk_pool_set_filled(struct chunk_pool *cp)
@@ -48,13 +49,17 @@ size_t chunk_pool_size(struct chunk_pool *cp)
 	return cp->count;
 }
 
+bool chunk_pool_is_empty(struct chunk_pool *cp)
+{
+	return list_empty(&cp->list);
+}
 
 struct chunk *chunk_pool_pop(struct chunk_pool *cp)
 {
 	struct list_head *first;
 	struct chunk *c = NULL;
 
-	LOCK_ACQUIRE_THREAD(&cp->lock);
+	LOCK_ACQUIRE(&cp->lock);
 	first = cp->list.next;
 	if (list_empty(&cp->list)) {
 		if (!chunk_pool_is_filled(cp))
@@ -65,9 +70,9 @@ struct chunk *chunk_pool_pop(struct chunk_pool *cp)
 		c = list_entry(first, struct chunk, list);
 		list_del(first);
 	}
-	LOCK_RELEASE_THREAD();
+	LOCK_RELEASE();
 
-	/* return CHUNK_POP_WAIT would be very rare case, because it
+	/* return CHUNK_POP_WAIT would be a rare case, because it
 	 * means copying over SSH is faster than traversing
 	 * local/remote file paths.
 	 */
@@ -88,53 +93,66 @@ void chunk_pool_release(struct chunk_pool *cp)
 }
 
 /* paths of copy source resoltion */
-static int resolve_dst_path(const char *src_file_path, char *dst_file_path,
-			    struct path_resolve_args *a)
+static char *resolve_dst_path(const char *src_file_path, struct path_resolve_args *a)
 {
-        char copy[PATH_MAX];
+        char copy[PATH_MAX + 1], dst_file_path[PATH_MAX + 1];
         char *prefix;
         int offset;
+	int ret;
 
-        strncpy(copy, a->src_path, PATH_MAX - 1);
+        strncpy(copy, a->src_path, PATH_MAX);
         prefix = dirname(copy);
         if (!prefix) {
                 mscp_set_error("dirname: %s", strerrno());
-                return -1;
+                return NULL;
         }
-        if (strlen(prefix) == 1 && prefix[0] == '.')
-                offset = 0;
-        else
-                offset = strlen(prefix) + 1;
+
+	offset = strlen(prefix) + 1;
+	if (strlen(prefix) == 1) { /* corner cases */
+		switch (prefix[0]) {
+		case '.':
+			offset = 0;
+			break;
+		case '/':
+			offset = 1;
+			break;
+		}
+	}
 
         if (!a->src_path_is_dir && !a->dst_path_is_dir) {
                 /* src path is file. dst path is (1) file, or (2) does not exist.
                  * In the second case, we need to put src under the dst.
                  */
                 if (a->dst_path_should_dir)
-                        snprintf(dst_file_path, PATH_MAX - 1, "%s/%s",
-                                 a->dst_path, a->src_path + offset);
+                        ret = snprintf(dst_file_path, PATH_MAX, "%s/%s",
+				       a->dst_path, a->src_path + offset);
                 else
-                        strncpy(dst_file_path, a->dst_path, PATH_MAX - 1);
+                        ret = snprintf(dst_file_path, PATH_MAX, "%s", a->dst_path);
         }
 
         /* src is file, and dst is dir */
         if (!a->src_path_is_dir && a->dst_path_is_dir)
-                snprintf(dst_file_path, PATH_MAX - 1, "%s/%s",
-			 a->dst_path, a->src_path + offset);
+                ret = snprintf(dst_file_path, PATH_MAX, "%s/%s",
+			       a->dst_path, a->src_path + offset);
 
         /* both are directory */
         if (a->src_path_is_dir && a->dst_path_is_dir)
-                snprintf(dst_file_path, PATH_MAX - 1, "%s/%s",
-			 a->dst_path, src_file_path + offset);
+                ret = snprintf(dst_file_path, PATH_MAX, "%s/%s",
+			       a->dst_path, src_file_path + offset);
 
         /* dst path does not exist. change dir name to dst_path */
         if (a->src_path_is_dir && !a->dst_path_is_dir)
-                snprintf(dst_file_path, PATH_MAX - 1, "%s/%s",
-                         a->dst_path, src_file_path + strlen(a->src_path) + 1);
+                ret = snprintf(dst_file_path, PATH_MAX, "%s/%s",
+			       a->dst_path, src_file_path + strlen(a->src_path) + 1);
+
+	if (ret >= PATH_MAX) {
+		mpr_warn(a->msg_fp, "Too long path: %s\n", dst_file_path);
+		return NULL;
+	}
 
         mpr_debug(a->msg_fp, "file: %s -> %s\n", src_file_path, dst_file_path);
 
-        return 0;
+        return strndup(dst_file_path, PATH_MAX);
 }
 
 /* chunk preparation */
@@ -190,7 +208,16 @@ static int resolve_chunk(struct path *p, struct path_resolve_args *a)
         return 0;
 }
 
-static int append_path(sftp_session sftp, const char *path, mstat s,
+void free_path(struct path *p)
+{
+	if (p->path)
+		free(p->path);
+	if (p->dst_path)
+		free(p->dst_path);
+	free(p);
+}
+
+static int append_path(sftp_session sftp, const char *path, struct stat st,
 		       struct list_head *path_list, struct path_resolve_args *a)
 {
 	struct path *p;
@@ -202,13 +229,16 @@ static int append_path(sftp_session sftp, const char *path, mstat s,
 
 	memset(p, 0, sizeof(*p));
 	INIT_LIST_HEAD(&p->list);
-	strncpy(p->path, path, PATH_MAX - 1);
-	p->size = mstat_size(s);
-	p->mode = mstat_mode(s);
+	p->path = strndup(path, PATH_MAX);
+	if (!p->path)
+		goto free_out;
+	p->size = st.st_size;
+	p->mode = st.st_mode;
 	p->state = FILE_STATE_INIT;
 	lock_init(&p->lock);
 
-	if (resolve_dst_path(p->path, p->dst_path, a) < 0)
+	p->dst_path = resolve_dst_path(p->path, a);
+	if (!p->dst_path)
 		goto free_out;
 
 	if (resolve_chunk(p, a) < 0)
@@ -221,7 +251,7 @@ static int append_path(sftp_session sftp, const char *path, mstat s,
 	return 0;
 
 free_out:
-	free(p);
+	free_path(p);
 	return -1;
 }
 
@@ -238,51 +268,44 @@ static bool check_path_should_skip(const char *path)
 static int walk_path_recursive(sftp_session sftp, const char *path,
 			       struct list_head *path_list, struct path_resolve_args *a)
 {
-	char next_path[PATH_MAX];
-	mdirent *e;
-	mdir *d;
-	mstat s;
+	char next_path[PATH_MAX + 1];
+	struct dirent *e;
+	struct stat st;
+	MDIR *d;
 	int ret;
 
-	if (mscp_stat(path, &s, sftp) < 0)
+	if (mscp_stat(path, &st, sftp) < 0) {
+		mpr_warn(a->msg_fp, "%s: %s\n",  strerrno(), path);
 		return -1;
+	}
 
-	if (mstat_is_regular(s)) {
+	if (S_ISREG(st.st_mode)) {
 		/* this path is regular file. it is to be copied */
-		ret = append_path(sftp, path, s, path_list, a);
-		mscp_stat_free(s);
-		return ret;
+		return append_path(sftp, path, st, path_list, a);
 	}
 
-	if (!mstat_is_dir(s)) {
-		/* not regular file and not directory, skip it. */
-		mscp_stat_free(s);
-		return 0; 
-	}
+	if (!S_ISDIR(st.st_mode))
+		return 0; /* not a regular file and not a directory, skip it. */
 
-	mscp_stat_free(s);
-
-
-	/* ok, this path is directory. walk it. */
-	if (!(d = mscp_opendir(path, sftp)))
+	/* ok, this path is a directory. walk through it. */
+	if (!(d = mscp_opendir(path, sftp))) {
+		mpr_warn(a->msg_fp, "%s: %s\n", strerrno(), path);
 		return -1;
+	}
 	
-	for (e = mscp_readdir(d); !mdirent_is_null(e); e = mscp_readdir(d)) {
-		if (check_path_should_skip(mdirent_name(e))) {
-			mscp_dirent_free(e);
+	for (e = mscp_readdir(d); e; e = mscp_readdir(d)) {
+		if (check_path_should_skip(e->d_name))
+			continue;
+		
+		ret = snprintf(next_path, PATH_MAX, "%s/%s", path, e->d_name);
+		if (ret >= PATH_MAX) {
+			mpr_warn(a->msg_fp, "Too long path: %s/%s\n", path, e->d_name);
 			continue;
 		}
-		
-		if (strlen(path) + 1 + strlen(mdirent_name(e)) > PATH_MAX) {
-			mscp_set_error("too long path: %s/%s", path, mdirent_name(e));
-			mscp_dirent_free(e);
-			return -1;
-		}
-		snprintf(next_path, sizeof(next_path), "%s/%s", path, mdirent_name(e));
-		ret = walk_path_recursive(sftp, next_path, path_list, a);
-		mscp_dirent_free(e);
-		if (ret < 0)
-			return ret;
+
+		walk_path_recursive(sftp, next_path, path_list, a);
+		/* do not stop even when walk_path_recursive returns
+		 * -1 due to an unreadable file. go to a next file. */
 	}
 
 	mscp_closedir(d);
@@ -314,10 +337,11 @@ static int touch_dst_path(struct path *p, sftp_session sftp)
 {
         /* XXX: should reflect the permission of the original directory? */
         mode_t mode =  S_IRWXU | S_IRWXG | S_IRWXO;
+	struct stat st;
         char path[PATH_MAX];
         char *needle;
         int ret;
-	mfh h;
+	mf *f;
 
         strncpy(path, p->dst_path, sizeof(path));
 
@@ -326,22 +350,17 @@ static int touch_dst_path(struct path *p, sftp_session sftp)
         for (needle = strchr(path + 1, '/'); needle; needle = strchr(needle + 1, '/')) {
                 *needle = '\0';
 
-		mstat s;
-		if (mscp_stat(path, &s, sftp) == 0) {
-			if (mstat_is_dir(s)) {
-				mscp_stat_free(s);
+		if (mscp_stat(path, &st, sftp) == 0) {
+			if (S_ISDIR(st.st_mode))
 				goto next; /* directory exists. go deeper */
-			} else {
-				mscp_stat_free(s);
+			else
 				return -1; /* path exists, but not directory. */
-			}
 		}
 
-		if (mscp_stat_check_err_noent(sftp) == 0) {
+		if (errno == ENOENT) {
 			/* no file on the path. create directory. */
 			if (mscp_mkdir(path, mode, sftp) < 0) {
-				mscp_set_error("mkdir %s: %s", path,
-					       mscp_strerror(sftp));
+				mscp_set_error("mscp_mkdir %s: %s", path, strerrno());
 				return -1;
 			}
 		}
@@ -349,12 +368,15 @@ static int touch_dst_path(struct path *p, sftp_session sftp)
                 *needle = '/';
         }
 
-        /* open file with O_TRUNC to set file size 0 */
-	h = mscp_open(p->dst_path, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR, 0, sftp);
-	if (mscp_open_is_failed(h))
+	/* Do not set O_TRUNC here. Instead, do mscp_setstat() at the
+	 * end. see https://bugzilla.mindrot.org/show_bug.cgi?id=3431 */
+	f = mscp_open(p->dst_path, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR, sftp);
+	if (!f) {
+		mscp_set_error("mscp_open %s: %s\n", p->dst_path, strerrno());
 		return -1;
+	}
 
-	mscp_close(h);
+	mscp_close(f);
 
         return 0;
 }
@@ -363,7 +385,7 @@ static int prepare_dst_path(FILE *msg_fp, struct path *p, sftp_session dst_sftp)
 {
 	int ret = 0;
 
-	LOCK_ACQUIRE_THREAD(&p->lock);
+	LOCK_ACQUIRE(&p->lock);
 	if (p->state == FILE_STATE_INIT) {
 		if (touch_dst_path(p, dst_sftp) < 0) {
 			ret = -1;
@@ -374,7 +396,7 @@ static int prepare_dst_path(FILE *msg_fp, struct path *p, sftp_session dst_sftp)
 	}
 
 out:
-	LOCK_RELEASE_THREAD();
+	LOCK_RELEASE();
 	return ret;
 }
 
@@ -518,16 +540,16 @@ static int copy_chunk_r2l(struct chunk *c, sftp_file sf, int fd,
         return 0;
 }
 
-static int _copy_chunk(struct chunk *c, mfh s, mfh d,
+static int _copy_chunk(struct chunk *c, mf *s, mf *d,
 		       int nr_ahead, int buf_sz, size_t *counter)
 {
-	if (s.fd > 0 && d.sf) /* local to remote copy */
-		return copy_chunk_l2r(c, s.fd, d.sf, nr_ahead, buf_sz, counter);
-	else if (s.sf && d.fd > 0)  /* remote to local copy */
-		return copy_chunk_r2l(c, s.sf, d.fd, nr_ahead, buf_sz, counter);
+	if (s->local && d->remote) /* local to remote copy */
+		return copy_chunk_l2r(c, s->local, d->remote, nr_ahead, buf_sz, counter);
+	else if (s->remote && d->local)  /* remote to local copy */
+		return copy_chunk_r2l(c, s->remote, d->local, nr_ahead, buf_sz, counter);
 
-	assert(true); /* not reached */
-	return -1;
+	assert(false);
+	return -1; /* not reached */
 }
 
 int copy_chunk(FILE *msg_fp, struct chunk *c,
@@ -536,7 +558,7 @@ int copy_chunk(FILE *msg_fp, struct chunk *c,
 {
 	mode_t mode;
 	int flags;
-	mfh s, d;
+	mf *s, *d;
 	int ret;
 
 	assert((src_sftp && !dst_sftp) || (!src_sftp && dst_sftp));
@@ -547,21 +569,33 @@ int copy_chunk(FILE *msg_fp, struct chunk *c,
 	/* open src */
         flags = O_RDONLY;
         mode = S_IRUSR;
-	s = mscp_open(c->p->path, flags, mode, c->off, src_sftp);
-	if (mscp_open_is_failed(s)) {
-		mscp_close(d);
+	s = mscp_open(c->p->path, flags, mode, src_sftp);
+	if (!s) {
+		mscp_set_error("mscp_open: %s: %s", c->p->path, strerrno());
+		return -1;
+	}
+	if (mscp_lseek(s, c->off) < 0) {
+		mscp_set_error("mscp_lseek: %s: %s", c->p->path, strerrno());
 		return -1;
 	}
 
 	/* open dst */
         flags = O_WRONLY;
         mode = S_IRUSR|S_IWUSR;
-	d = mscp_open(c->p->dst_path, flags, mode, c->off, dst_sftp);
-	if (mscp_open_is_failed(d))
+	d = mscp_open(c->p->dst_path, flags, mode, dst_sftp);
+	if (!d) {
+		mscp_close(s);
+		mscp_set_error("mscp_open: %s: %s", c->p->dst_path, strerrno());
 		return -1;
+	}
+	if (mscp_lseek(d, c->off) < 0) {
+		mscp_set_error("mscp_lseek: %s: %s", c->p->dst_path, strerrno());
+		return -1;
+	}
 
 	mpr_debug(msg_fp, "copy chunk start: %s 0x%lx-0x%lx\n",
 		  c->p->path, c->off, c->off + c->len);
+
 	ret = _copy_chunk(c, s, d, nr_ahead, buf_sz, counter);
 
 	mpr_debug(msg_fp, "copy chunk done: %s 0x%lx-0x%lx\n",
@@ -575,7 +609,9 @@ int copy_chunk(FILE *msg_fp, struct chunk *c,
 
 	if (refcnt_dec(&c->p->refcnt) == 0) {
 		c->p->state = FILE_STATE_DONE;
-		mscp_chmod(c->p->dst_path, c->p->mode, dst_sftp);
+		if (mscp_setstat(c->p->dst_path, c->p->mode, c->p->size, dst_sftp) < 0)
+			mpr_err(msg_fp, "failed to chmod and truncate %s: %s\n",
+				c->p->path, strerrno());
 		mpr_info(msg_fp, "copy done: %s\n", c->p->path);
 	}
 

src/path.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _PATH_H_
 #define _PATH_H_
 
@@ -14,11 +15,11 @@
 struct path {
 	struct list_head	list;	/* mscp->path_list */
 
-	char	path[PATH_MAX];		/* file path */
-	size_t	size;			/* size of file on this path */
-	mode_t	mode;			/* permission */
+	char	*path;		/* file path */
+	size_t	size;		/* size of file on this path */
+	mode_t	mode;		/* permission */
 
-	char	dst_path[PATH_MAX];	/* copy dst path */
+	char	*dst_path;	/* copy dst path */
 
 	int	state;
 	lock	lock;
@@ -62,6 +63,9 @@ bool chunk_pool_is_filled(struct chunk_pool *cp);
 /* return number of chunks in the pool */
 size_t chunk_pool_size(struct chunk_pool *cp);
 
+/* return true if chunk pool is empty (all chunks are already poped) */
+bool chunk_pool_is_empty(struct chunk_pool *cp);
+
 /* free chunks in the chunk_pool */
 void chunk_pool_release(struct chunk_pool *cp);
 
@@ -90,6 +94,9 @@ struct path_resolve_args {
 int walk_src_path(sftp_session src_sftp, const char *src_path,
 		  struct list_head *path_list, struct path_resolve_args *a);
 
+/* free struct path */
+void free_path(struct path *p);
+
 /* copy a chunk. either src_sftp or dst_sftp is not null, and another is null */
 int copy_chunk(FILE *msg_fp, struct chunk *c,
 	       sftp_session src_sftp, sftp_session dst_sftp,
@@ -98,248 +105,4 @@ int copy_chunk(FILE *msg_fp, struct chunk *c,
 /* just print contents. just for debugging */
 void path_dump(struct list_head *path_list);
 
-
-
-/* wrap DIR/dirent and sftp_dir/sftp_attribute. not thread safe */
-struct mscp_dir {
-        DIR *l;
-        sftp_dir r;
-        sftp_session sftp;
-};
-typedef struct mscp_dir mdir;
-
-struct mscp_dirent {
-        struct dirent *l;
-        sftp_attributes r;
-};
-typedef struct mscp_dirent mdirent;
-
-#define mdirent_name(e) ((e->l) ? e->l->d_name : e->r->name)
-#define mdirent_is_dir(e) ((e->l) ?                                     \
-                           (e->l->d_type == DT_DIR) :                   \
-                           (e->r->type == SSH_FILEXFER_TYPE_DIRECTORY))
-#define mdirent_is_null(e) (e->l == NULL && e->r == NULL)
-
-static mdir *mscp_opendir(const char *path, sftp_session sftp)
-{
-        mdir *d;
-
-        if (!(d = malloc(sizeof(*d))))
-                return NULL;
-        memset(d, 0, sizeof(*d));
-
-        d->sftp = sftp;
-
-        if (sftp) {
-                d->r = sftp_opendir(sftp, path);
-                if (!d->r) {
-                        mscp_set_error("sftp_opendir '%s': %s",
-				       path, sftp_get_ssh_error(sftp));
-                        free(d);
-                        return NULL;
-                }
-        } else {
-                d->l = opendir(path);
-                if (!d->l) {
-                        mscp_set_error("opendir '%s': %s", path, strerrno());
-                        free(d);
-                        return NULL;
-                }
-        }
-        return d;
-}
-
-static int mscp_closedir(mdir *d)
-{
-        int ret;
-        if (d->r)
-                ret = sftp_closedir(d->r);
-        else
-                ret = closedir(d->l);
-        free(d);
-        return ret;
-}
-
-static mdirent *mscp_readdir(mdir *d)
-{
-        static mdirent e;
-
-        memset(&e, 0, sizeof(e));
-        if (d->r)
-                e.r = sftp_readdir(d->sftp, d->r);
-        else
-                e.l = readdir(d->l);
-        return &e;
-}
-
-static void mscp_dirent_free(mdirent *e)
-{
-	if (e->r) {
-		sftp_attributes_free(e->r);
-		e->r = NULL;
-	}
-}
-
-/* wrap retriving error */
-static const char *mscp_strerror(sftp_session sftp)
-{
-	if (sftp)
-		return sftp_get_ssh_error(sftp);
-	return strerrno();
-}
-
-/* warp stat/sftp_stat */
-struct mscp_stat {
-        struct stat l;
-        sftp_attributes r;
-};
-typedef struct mscp_stat mstat;
-
-static int mscp_stat(const char *path, mstat *s, sftp_session sftp)
-{
-        memset(s, 0, sizeof(*s));
-
-        if (sftp) {
-                s->r = sftp_stat(sftp, path);
-                if (!s->r)
-                        return -1;
-        } else {
-                if (stat(path, &s->l) < 0)
-                        return -1;
-        }
-
-        return 0;
-}
-
-static int mscp_stat_check_err_noent(sftp_session sftp)
-{
-	if (sftp) {
-		if (sftp_get_error(sftp) == SSH_FX_NO_SUCH_PATH ||
-		    sftp_get_error(sftp) == SSH_FX_NO_SUCH_FILE)
-			return 0;
-	} else {
-		if (errno == ENOENT)
-			return 0;
-	}
-	return -1;
-}
-
-static void mscp_stat_free(mstat s) {
-        if (s.r)
-                sftp_attributes_free(s.r);
-}
-
-#define mstat_size(s) ((s.r) ? s.r->size : s.l.st_size)
-#define mstat_mode(s) ((s.r) ?                                  \
-                       s.r->permissions :                       \
-                       s.l.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO))
-#define mstat_is_regular(s) ((s.r) ?                                    \
-                             (s.r->type == SSH_FILEXFER_TYPE_REGULAR) : \
-                             S_ISREG(s.l.st_mode))
-#define mstat_is_dir(s) ((s.r) ?                        \
-                         (s.r->type == SSH_FILEXFER_TYPE_DIRECTORY) :   \
-                         S_ISDIR(s.l.st_mode))
-
-/* wrap mkdir */
-static int mscp_mkdir(const char *path, mode_t mode, sftp_session sftp)
-{
-	int ret;
-
-	if (sftp) {
-		ret = sftp_mkdir(sftp, path, mode);
-		if (ret < 0 &&
-		    sftp_get_error(sftp) != SSH_FX_FILE_ALREADY_EXISTS) {
-			mscp_set_error("sftp_mkdir '%s': %s",
-				       path, sftp_get_ssh_error(sftp));
-			return -1;
-		}
-	} else {
-		if (mkdir(path, mode) == -1 && errno != EEXIST) {
-			mscp_set_error("mkdir '%s': %s", path, strerrno());
-			return -1;
-		}
-	}
-
-	return 0;
-}
-
-/* wrap open/sftp_open */
-struct mscp_file_handle {
-	int fd;
-	sftp_file sf;
-};
-typedef struct mscp_file_handle mfh;
-
-static mfh mscp_open(const char *path, int flags, mode_t mode, size_t off,
-		      sftp_session sftp)
-{
-	mfh h;
-
-	h.fd = -1;
-	h.sf = NULL;
-
-	if (sftp) {
-		h.sf = sftp_open(sftp, path, flags, mode);
-		if (!h.sf) {
-			mscp_set_error("sftp_open '%s': %s",
-				       path, sftp_get_ssh_error(sftp));
-			return h;
-		}
-
-		if (sftp_seek64(h.sf, off) < 0) {
-			mscp_set_error("sftp_seek64 '%s': %s",
-				       path, sftp_get_ssh_error(sftp));
-			sftp_close(h.sf);
-			h.sf = NULL;
-			return h;
-		}
-	} else {
-		h.fd = open(path, flags, mode);
-		if (h.fd < 0) {
-			mscp_set_error("open '%s': %s", path, strerrno());
-			return h;
-		}
-		if (lseek(h.fd, off, SEEK_SET) < 0) {
-			mscp_set_error("lseek '%s': %s", path, strerrno());
-			close(h.fd);
-			h.fd = -1;
-			return h;
-		}
-	}
-
-	return h;
-}
-
-#define mscp_open_is_failed(h) (h.fd < 0 && h.sf == NULL)
-
-static void mscp_close(mfh h)
-{
-	if (h.sf)
-		sftp_close(h.sf);
-	if (h.fd > 0)
-		close(h.fd);
-	h.sf = NULL;
-	h.fd = -1;
-}
-
-/* wrap chmod/sftp_chmod */
-
-static int mscp_chmod(const char *path, mode_t mode, sftp_session sftp)
-{
-	if (sftp) {
-		if (sftp_chmod(sftp, path, mode) < 0)  {
-			mscp_set_error("sftp_chmod '%s': %s",
-				       path, sftp_get_ssh_error(sftp));
-			return -1;
-		}
-	} else {
-		if (chmod(path, mode) < 0) {
-			mscp_set_error("chmod '%s': %s", path, strerrno());
-			return -1;
-		}
-	}
-
-	return 0;
-}
-
 #endif /* _PATH_H_ */

src/platform.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifdef __APPLE__
 #include <stdlib.h>
 #include <sys/types.h>
@@ -101,7 +102,7 @@ sem_t *sem_create(int value)
 
 	if (sem_init(sem, 0, value) < 0) {
 		free(sem);
-		return sem;
+		return NULL;
 	}
 
 	return sem;

src/platform.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _PLATFORM_H_
 #define _PLATFORM_H_
 

src/pymscp.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <errno.h>
@@ -97,17 +98,20 @@ static PyObject *wrap_mscp_init(PyObject *self, PyObject *args, PyObject *kw)
 		"coremask",	/* const char * */
 
 		"max_startups",	/* int */
+		"interval",	/* int */
 		"severity",	/* int, MSCP_SERVERITY_* */
 		"msg_fd",	/* int */
 
 		/*  mscp_ssh_opts */
 		"login_name",	/* const char * */
 		"port",		/* const char * */
+		"config",	/* const char * */
 		"identity",	/* const char * */
 
 		"cipher",	/* const char * */
 		"hmac",		/* const char * */
 		"compress",	/* const char * */
+		"ccalgo",       /* const char * */
 		"password",	/* const char * */
 		"passphrase",	/* const char * */
 
@@ -116,10 +120,10 @@ static PyObject *wrap_mscp_init(PyObject *self, PyObject *args, PyObject *kw)
 		"enable_nagle",		/* bool */
 		NULL,
 	};
-	const char *fmt = "si" "|" "ii" "kkk" "s" "iii" "sss" "sssss" "ipp";
+	const char *fmt = "si" "|" "ii" "kkk" "s" "iiii" "ssss" "ssssss" "ipp";
 	char *coremask = NULL;
-	char *login_name = NULL, *port = NULL, *identity = NULL;
-	char *cipher = NULL, *hmac = NULL, *compress = NULL;
+	char *login_name = NULL, *port = NULL, *config = NULL, *identity = NULL;
+	char *cipher = NULL, *hmac = NULL, *compress = NULL, *ccalgo = NULL;
 	char *password = NULL, *passphrase = NULL;
 
 	struct instance *i;
@@ -144,14 +148,17 @@ static PyObject *wrap_mscp_init(PyObject *self, PyObject *args, PyObject *kw)
 					  &i->mo.buf_sz,
 					  &coremask,
 					  &i->mo.max_startups,
+					  &i->mo.interval,
 					  &i->mo.severity,
 					  &i->mo.msg_fd,
 					  &login_name,
 					  &port,
+					  &config,
 					  &identity,
 					  &cipher,
 					  &hmac,
 					  &compress,
+					  &ccalgo,
 					  &password,
 					  &passphrase,
 					  &i->so.debug_level,
@@ -167,6 +174,8 @@ static PyObject *wrap_mscp_init(PyObject *self, PyObject *args, PyObject *kw)
 		strncpy(i->so.login_name, login_name, MSCP_SSH_MAX_LOGIN_NAME - 1);
 	if (port)
 		strncpy(i->so.port, port, MSCP_SSH_MAX_PORT_STR - 1);
+	if (config)
+		strncpy(i->so.config, config, PATH_MAX - 1);
 	if (identity)
 		strncpy(i->so.identity, identity, MSCP_SSH_MAX_IDENTITY_PATH - 1);
 	if (cipher)
@@ -175,6 +184,8 @@ static PyObject *wrap_mscp_init(PyObject *self, PyObject *args, PyObject *kw)
 		strncpy(i->so.hmac, hmac, MSCP_SSH_MAX_HMAC_STR - 1);
 	if (compress)
 		strncpy(i->so.compress, compress, MSCP_SSH_MAX_COMP_STR - 1);
+	if (ccalgo)
+		strncpy(i->so.ccalgo, ccalgo, MSCP_SSH_MAX_CCALGO_STR - 1);
 	if (password)
 		strncpy(i->so.password, password, MSCP_SSH_MAX_PASSWORD - 1);
 	if (passphrase)
@@ -375,7 +386,7 @@ static PyObject *wrap_mscp_get_stats(PyObject *self, PyObject *args, PyObject *k
 
 	mscp_get_stats(m, &s);
 
-	return Py_BuildValue("KKd", s.total, s.done, s.finished);
+	return Py_BuildValue("KKO", s.total, s.done, PyBool_FromLong(s.finished));
 }
 
 static PyObject *wrap_mscp_cleanup(PyObject *self, PyObject *args, PyObject *kw)

src/rename-logic.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-
-from os.path import dirname, basename, isfile, isdir, exists
-from os import listdir
-import sys
-
-"""
-
-This file simply implements the src_path to dst_path conversion logic
-just for test. file_fill() and file_fill_recursive() in file.c
-implements this logic.
-
-"""
-
-
-def recursive(src, rel_path, dst, dst_should_dir, replace_dir_name):
-    
-    if isfile(src):
-        if dst_should_dir:
-            print("{} => {}/{}{}".format(src, dst, rel_path, basename(src)))
-        else:
-            print("{} => {}{}".format(src, rel_path, dst))
-        return
-        
-    # src is directory
-    for f in listdir(src):
-        next_src = "{}/{}".format(src, f)
-        if replace_dir_name and dst_should_dir:
-            next_rel_path = ""
-        else:
-            next_rel_path = "{}{}/".format(rel_path, basename(src))
-        recursive(next_src, next_rel_path, dst, dst_should_dir, False)
-
-
-def fill_dst(srclist, dst):
-    dst_must_dir = len(srclist) > 1
-    for src in srclist:
-        dst_should_dir = isdir(src) | isdir(dst)
-        replace_dir_name = not isdir(dst)
-        recursive(src, "", dst, dst_should_dir | dst_must_dir, replace_dir_name)
-
-
-def main():
-    if (len(sys.argv) < 2):
-        print("usage: {} source ... target".format(sys.argv[0]))
-    fill_dst(sys.argv[1:len(sys.argv) - 1], sys.argv[len(sys.argv) - 1])
-
-main()

src/ssh.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -64,6 +65,12 @@ static int ssh_set_opts(ssh_session ssh, struct mscp_ssh_opts *opts)
 		return -1;
 	}
 
+	if (is_specified(opts->ccalgo) &&
+	    ssh_options_set(ssh, SSH_OPTIONS_CCALGO, opts->ccalgo) < 0) {
+		mscp_set_error("failed to set cclago");
+		return -1;
+	}
+
 	/* if NOT specified to enable Nagle's algorithm, disable it (set TCP_NODELAY) */
 	if (!opts->enable_nagle) {
 		int v = 1;
@@ -73,6 +80,12 @@ static int ssh_set_opts(ssh_session ssh, struct mscp_ssh_opts *opts)
 		}
 	}
 
+	if (is_specified(opts->config) &&
+	    ssh_options_parse_config(ssh, opts->config) < 0) {
+		mscp_set_error("failed to parse ssh_config: %s", opts->config);
+		return -1;
+	}
+
 	return 0;
 }
 
@@ -149,14 +162,14 @@ static ssh_session ssh_init_session(const char *sshdst, struct mscp_ssh_opts *op
 	cb.userdata = opts;
 	ssh_set_callbacks(ssh, &cb);
 
-	if (ssh_set_opts(ssh, opts) != 0)
-		goto free_out;
-
 	if (ssh_options_set(ssh, SSH_OPTIONS_HOST, sshdst) != SSH_OK) {
 		mscp_set_error("failed to set destination host");
 		goto free_out;
 	}
 
+	if (ssh_set_opts(ssh, opts) != 0)
+		goto free_out;
+
 	if (ssh_connect(ssh) != SSH_OK) {
 		mscp_set_error("failed to connect ssh server: %s", ssh_get_error(ssh));
 		goto free_out;

src/ssh.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _SSH_H_
 #define _SSH_H_
 

src/util.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-3.0-only */
 #ifndef _UTIL_H_
 #define _UTIL_H_
 

test/test_e2e.py

@@ -3,7 +3,9 @@
 test_e2e.py: End-to-End test for mscp executable.
 """
 
+import platform
 import pytest
+import getpass
 import os
 
 from subprocess import check_call, CalledProcessError, PIPE
@@ -11,11 +13,15 @@ from util import File, check_same_md5sum
 
 
 def run2ok(args):
-    check_call(list(map(str, args)))
+    cmd = list(map(str, args))
+    print("cmd: {}".format(" ".join(cmd)))
+    check_call(cmd)
 
 def run2ng(args):
+    cmd = list(map(str, args))
+    print("cmd: {}".format(" ".join(cmd)))
     with pytest.raises(CalledProcessError) as e:
-        check_call(list(map(str, args)))
+        check_call(cmd)
 
 
 """ usage test """
@@ -56,11 +62,16 @@ param_single_copy = [
 @pytest.mark.parametrize("src, dst", param_single_copy)
 def test_single_copy(mscp, src_prefix, dst_prefix, src, dst):
     src.make()
-    run2ok([mscp, "-H", src_prefix + src.path, dst_prefix + dst.path])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src.path, dst_prefix + dst.path])
     assert check_same_md5sum(src, dst)
     src.cleanup()
     dst.cleanup()
 
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+def test_failed_to_copy_nonexistent_file(mscp, src_prefix, dst_prefix):
+    src = "nonexistent_src"
+    dst = "nonexistent_dst"
+    run2ng([mscp, "-H", "-vvv", src_prefix + src, dst_prefix + dst])
 
 param_double_copy = [
     (File("src1", size = 1024 * 1024), File("src2", size = 1024 * 1024),
@@ -72,7 +83,7 @@ param_double_copy = [
 def test_double_copy(mscp, src_prefix, dst_prefix, s1, s2, d1, d2):
     s1.make()
     s2.make()
-    run2ok([mscp, "-H", src_prefix + s1.path, src_prefix + s2.path, dst_prefix + "dst"])
+    run2ok([mscp, "-H", "-vvv", src_prefix + s1.path, src_prefix + s2.path, dst_prefix + "dst"])
     assert check_same_md5sum(s1, d1)
     assert check_same_md5sum(s2, d2)
     s1.cleanup()
@@ -80,6 +91,47 @@ def test_double_copy(mscp, src_prefix, dst_prefix, s1, s2, d1, d2):
     d1.cleanup()
     d2.cleanup()
 
+
+remote_v6_prefix = "[::1]:{}/".format(os.getcwd())
+param_remote_v6_prefix = [
+    ("", remote_v6_prefix), (remote_v6_prefix, "")
+]
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_v6_prefix)
+@pytest.mark.parametrize("s1, s2, d1, d2", param_double_copy)
+def test_double_copy_with_ipv6_notation(mscp, src_prefix, dst_prefix, s1, s2, d1, d2):
+    s1.make()
+    s2.make()
+    run2ok([mscp, "-H", "-vvv",
+            src_prefix + s1.path, src_prefix + s2.path, dst_prefix + "dst"])
+    assert check_same_md5sum(s1, d1)
+    assert check_same_md5sum(s2, d2)
+    s1.cleanup()
+    s2.cleanup()
+    d1.cleanup()
+    d2.cleanup()
+
+
+remote_user_v6_prefix = "{}@[::1]:{}/".format(getpass.getuser(), os.getcwd())
+param_remote_user_v6_prefix = [
+    ("", remote_user_v6_prefix), (remote_user_v6_prefix, "")
+]
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_user_v6_prefix)
+@pytest.mark.parametrize("s1, s2, d1, d2", param_double_copy)
+def test_double_copy_with_user_and_ipv6_notation(mscp, src_prefix, dst_prefix,
+                                                 s1, s2, d1, d2):
+    s1.make()
+    s2.make()
+    run2ok([mscp, "-H", "-vvv",
+            src_prefix + s1.path, src_prefix + s2.path, dst_prefix + "dst"])
+    assert check_same_md5sum(s1, d1)
+    assert check_same_md5sum(s2, d2)
+    s1.cleanup()
+    s2.cleanup()
+    d1.cleanup()
+    d2.cleanup()
+
+
+
 param_dir_copy = [
     ( "src_dir", "dst_dir",
         [ File("src_dir/t1", size = 64),
@@ -109,11 +161,11 @@ def test_dir_copy(mscp, src_prefix, dst_prefix, src_dir, dst_dir, src, dst, twic
     for f in src:
         f.make()
 
-    run2ok([mscp, "-H", src_prefix + src_dir, dst_prefix + dst_dir])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src_dir, dst_prefix + dst_dir])
     for sf, df in zip(src, dst):
         assert check_same_md5sum(sf, df)
 
-    run2ok([mscp, "-H", src_prefix + src_dir, dst_prefix + dst_dir])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src_dir, dst_prefix + dst_dir])
     for sf, df in zip(src, twice):
         assert check_same_md5sum(sf, df)
 
@@ -122,35 +174,105 @@ def test_dir_copy(mscp, src_prefix, dst_prefix, src_dir, dst_dir, src, dst, twic
         df.cleanup()
         tf.cleanup()
 
+
+param_dir_copy_single = [
+    ("src_dir", "dst_dir",
+     File("src_dir/t1", size = 1024 * 1024),
+     File("dst_dir/src_dir/t1"),
+     )
+]
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+@pytest.mark.parametrize("src_dir, dst_dir, src, dst", param_dir_copy_single)
+def test_dir_copy_single(mscp, src_prefix, dst_prefix, src_dir, dst_dir, src, dst):
+    src.make()
+    os.mkdir(dst_dir)
+    run2ok([mscp, "-H", "-vvv", src_prefix + src_dir, dst_prefix + dst_dir])
+    assert check_same_md5sum(src, dst)
+    src.cleanup()
+    dst.cleanup()
+
 @pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
 def test_override_single_file(mscp, src_prefix, dst_prefix):
     src = File("src", size = 128).make()
     dst = File("dst", size = 128).make()
     assert not check_same_md5sum(src, dst)
 
-    run2ok([mscp, "-H", src_prefix + src.path, dst_prefix + dst.path])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src.path, dst_prefix + dst.path])
     assert check_same_md5sum(src, dst)
 
     src.cleanup()
     dst.cleanup()
 
+absolute_remote_prefix = "localhost:"
+param_absolute_remote_prefix = [
+    ("", absolute_remote_prefix), (absolute_remote_prefix, "")
+]
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_absolute_remote_prefix)
+def test_copy_file_under_root_to_dir(mscp, src_prefix, dst_prefix):
+    src = File("/mscp-test-src", size = 1024).make()
+    dst = File("/tmp/mscp-test-src")
+
+    run2ok([mscp, "-H", "-vvv", src_prefix + src.path,
+            dst_prefix + os.path.dirname(dst.path)])
+    assert check_same_md5sum(src, dst)
+    src.cleanup()
+    dst.cleanup(preserve_dir = True)
+
+
 @pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
 def test_min_chunk(mscp, src_prefix, dst_prefix):
     src = File("src", size = 16 * 1024).make()
     dst = File("dst")
 
-    run2ok([mscp, "-H", "-s", 8192, src_prefix + src.path, dst_prefix + dst.path])
+    run2ok([mscp, "-H", "-vvv", "-s", 32768, src_prefix + src.path, dst_prefix + dst.path])
     assert check_same_md5sum(src, dst)
 
     src.cleanup()
     dst.cleanup()
 
+
+def is_alpine():
+    if os.path.exists("/etc/os-release"):
+        with open("/etc/os-release", "r") as f:
+            for line in f:
+                if line.strip() == "ID=alpine":
+                    return True
+    return False
+
+param_glob_copy = [
+    (
+        "src*", "dstx",
+        [ File("src1"), File("src2"), File("src3") ],
+        [ File("dstx/src1"), File("dstx/src2"), File("dstx/src3") ],
+    ),
+    (
+        "src*", "dstx",
+        [ File("src1/s1"), File("src2/s2"), File("src3/s3") ],
+        [ File("dstx/s1"), File("dstx/s2"), File("dstx/s3") ],
+    )
+]
+
+@pytest.mark.skipif(is_alpine(),
+                    reason = "musl does not implement glob ALTDIRFUNC")
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+@pytest.mark.parametrize("src_glob_path, dst_path, srcs, dsts", param_glob_copy)
+def test_glob_src_path(mscp, src_prefix, dst_prefix,
+                       src_glob_path, dst_path, srcs, dsts):
+    for src in srcs:
+        src.make(size = 1024 * 1024)
+
+    run2ok([mscp, "-H", "-vvv", src_prefix + src_glob_path, dst_prefix + dst_path])
+    for src, dst in zip(srcs, dsts):
+        assert check_same_md5sum(src, dst)
+        src.cleanup()
+        dst.cleanup()
+
 @pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
 def test_thread_affinity(mscp, src_prefix, dst_prefix):
     src = File("src", size = 64 * 1024).make()
     dst = File("dst")
 
-    run2ok([mscp, "-H", "-n", 4, "-m", "0x01", "-s", 8192, "-S", 65536,
+    run2ok([mscp, "-H", "-vvv", "-n", 4, "-m", "0x01",
             src_prefix + src.path, dst_prefix + dst.path])
     assert check_same_md5sum(src, dst)
 
@@ -162,7 +284,7 @@ def test_cannot_override_file_with_dir(mscp, src_prefix, dst_prefix):
     src = File("src", size = 128).make()
     dst = File("dst").make()
 
-    run2ng([mscp, "-H", src_prefix + src.path, dst_prefix + "dst/src"])
+    run2ng([mscp, "-H", "-vvv", src_prefix + src.path, dst_prefix + "dst/src"])
 
     src.cleanup()
     dst.cleanup()
@@ -171,7 +293,7 @@ def test_cannot_override_file_with_dir(mscp, src_prefix, dst_prefix):
 def test_transfer_zero_bytes(mscp, src_prefix, dst_prefix):
     src = File("src", size = 0).make()
     dst = File("dst")
-    run2ok([mscp, "-H", src_prefix + src.path, dst_prefix + "dst"])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src.path, dst_prefix + "dst"])
     assert os.path.exists("dst")
     src.cleanup()
     dst.cleanup()
@@ -180,18 +302,102 @@ def test_transfer_zero_bytes(mscp, src_prefix, dst_prefix):
 def test_override_dst_having_larger_size(mscp, src_prefix, dst_prefix):
     src = File("src", size = 1024 * 1024).make()
     dst = File("dst", size = 1024 * 1024 * 2).make()
-    run2ok([mscp, "-H", src_prefix + src.path, dst_prefix + "dst"])
+    run2ok([mscp, "-H", "-vvv", src_prefix + src.path, dst_prefix + "dst"])
     assert check_same_md5sum(src, dst)
     src.cleanup()
     dst.cleanup()
 
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+def test_dont_truncate_dst(mscp, src_prefix, dst_prefix):
+    f = File("srcanddst", size = 1024 * 1024 * 128).make()
+    md5_before = f.md5sum()
+    run2ok([mscp, "-H", "-vvv", src_prefix + f.path, dst_prefix + f.path])
+    md5_after = f.md5sum()
+    assert md5_before == md5_after
+    f.cleanup()
+
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+@pytest.mark.parametrize("src, dst", param_single_copy)
+def test_set_port(mscp, src_prefix, dst_prefix, src, dst):
+    src.make()
+    run2ng([mscp, "-H", "-vvv", "-p", 21, src_prefix + src.path, dst_prefix + dst.path])
+    run2ng([mscp, "-H", "-vvv", "-P", 21, src_prefix + src.path, dst_prefix + dst.path])
+    src.cleanup()
+
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+def test_set_conn_interval(mscp, src_prefix, dst_prefix):
+    srcs = []
+    dsts = []
+    for x in range(500):
+        srcs.append(File("src/file{}".format(x), size = 128).make())
+        dsts.append(File("dst/file{}".format(x)))
+    run2ok([mscp, "-H", "-vvv", "-I", 1, src_prefix + "src", dst_prefix + "dst"])
+
+    for src, dst in zip(srcs, dsts):
+        assert check_same_md5sum(src, dst)
+        src.cleanup()
+        dst.cleanup()
+
 compressions = ["yes", "no", "none"]
 @pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
 @pytest.mark.parametrize("compress", compressions)
 def test_compression(mscp, src_prefix, dst_prefix, compress):
     src = File("src", size = 1024 * 1024).make()
     dst = File("dst", size = 1024 * 1024 * 2).make()
-    run2ok([mscp, "-H", "-C", compress, src_prefix + src.path, dst_prefix + "dst"])
+    run2ok([mscp, "-H", "-vvv", "-C", compress, src_prefix + src.path, dst_prefix + "dst"])
     assert check_same_md5sum(src, dst)
     src.cleanup()
     dst.cleanup()
+
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_remote_prefix)
+def test_ccalgo(mscp, src_prefix, dst_prefix):
+    src = File("src", size = 1024 * 1024).make()
+    dst = File("dst").make()
+    if platform.system() == "Darwin":
+        # Darwin does not support TCP_CONGESTION
+        algo = "cubic"
+        run = run2ng
+    elif platform.system() == "Linux":
+        # Linux supports TCP_CONGESTION
+        with open("/proc/sys/net/ipv4/tcp_allowed_congestion_control", "r") as f:
+            algo = f.read().strip().split().pop()
+        run = run2ok
+    run([mscp, "-H", "-vvv", "-g", algo, src_prefix + src.path, dst_prefix + "dst"])
+
+
+testhost = "mscptestlocalhost"
+testhost_prefix = "{}:{}/".format(testhost, os.getcwd()) # use current dir
+param_testhost_prefix = [
+    ("", testhost_prefix), (testhost_prefix, "")
+]
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_testhost_prefix)
+def test_config_ok(mscp, src_prefix, dst_prefix):
+    config = "/tmp/mscp_test_ssh_config"
+    with open(config, "w") as f:
+        f.write("host {}\n".format(testhost))
+        f.write("    hostname localhost\n")
+
+    src = File("src", size = 1024 * 1024).make()
+    dst = File("dst", size = 1024 * 1024 * 2).make()
+    run2ok([mscp, "-H", "-vvv", "-F", config,
+            src_prefix + src.path, dst_prefix + "dst"])
+
+    os.remove(config)
+    assert check_same_md5sum(src, dst)
+    src.cleanup()
+    dst.cleanup()
+
+@pytest.mark.parametrize("src_prefix, dst_prefix", param_testhost_prefix)
+def test_config_ng(mscp, src_prefix, dst_prefix):
+    config = "/tmp/mscp_test_ssh_config"
+    with open(config, "w") as f:
+        f.write("\n") # use empty ssh_config
+
+    src = File("src", size = 1024 * 1024).make()
+    dst = File("dst", size = 1024 * 1024 * 2).make()
+    run2ng([mscp, "-H", "-vvv", "-F", config,
+            src_prefix + src.path, dst_prefix + "dst"])
+
+    os.remove(config)
+    src.cleanup()
+    dst.cleanup()

test/test_python.py

@@ -104,6 +104,12 @@ def test_login_failed():
     with pytest.raises(RuntimeError) as e:
         m.connect()
 
+def test_get_stat_before_copy_start():
+    m = mscp.mscp("localhost", mscp.LOCAL2REMOTE)
+    m.connect()
+    (total, done, finished) = m.stats()
+    assert total == 0 and done == 0
+
 
 param_invalid_kwargs = [
     { "nr_threads": -1 },
@@ -115,6 +121,7 @@ param_invalid_kwargs = [
     { "cipher": "invalid" },
     { "hmac": "invalid"},
     { "compress": "invalid"},
+    { "ccalgo": "invalid"},
 ]
 
 @pytest.mark.parametrize("kw", param_invalid_kwargs)

test/util.py

@@ -22,7 +22,10 @@ class File():
     def __str__(self):
         return self.path
 
-    def make(self):
+    def make(self, size = None):
+        if size:
+            self.size = size
+
         d = os.path.dirname(self.path)
         if d:
             os.makedirs(d, exist_ok = True)
@@ -43,8 +46,10 @@ class File():
         with open(self.path, "wb") as f:
             f.write(os.urandom(self.size))
 
-    def cleanup(self):
+    def cleanup(self, preserve_dir = False):
         os.remove(self.path)
+        if preserve_dir:
+            return
         tmp = os.path.dirname(self.path)
         while tmp and not tmp in [".", "/"]:
             if len(os.listdir(tmp)) == 0: