adb: add interfaces for Encoder/Decoder. am: 49ba558aa8 (0864b999) · Commits · e / os / android_system_core

adb/client/adb_install.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -290,7 +290,7 @@ static int install_app_legacy(int argc, const char** argv, bool use_fastdeploy)
		}
		}

		if (do_sync_push(apk_file, apk_dest.c_str(), false, true)) {
		if (do_sync_push(apk_file, apk_dest.c_str(), false, CompressionType::Any)) {
		result = pm_command(argc, argv);
		delete_device_file(apk_dest);
		}

adb/client/bugreport.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -282,5 +282,5 @@ int Bugreport::SendShellCommand(const std::string& command, bool disable_shell_p

		bool Bugreport::DoSyncPull(const std::vector<const char>& srcs, const char dst, bool copy_attrs,
		const char* name) {
		return do_sync_pull(srcs, dst, copy_attrs, false, name);
		return do_sync_pull(srcs, dst, copy_attrs, CompressionType::None, name);
		}

adb/client/commandline.cpp

+52 −31

Original line number	Diff line number	Diff line
		@@ -129,20 +129,20 @@ static void help() {
		" reverse --remove-all remove all reverse socket connections from device\n"
		"\n"
		"file transfer:\n"
		" push [--sync] [-zZ] LOCAL... REMOTE\n"
		" push [--sync] [-z ALGORITHM] [-Z] LOCAL... REMOTE\n"
		" copy local files/directories to device\n"
		" --sync: only push files that are newer on the host than the device\n"
		" -z: enable compression\n"
		" -z: enable compression with a specified algorithm (any, none, brotli)\n"
		" -Z: disable compression\n"
		" pull [-azZ] REMOTE... LOCAL\n"
		" pull [-a] [-z ALGORITHM] [-Z] REMOTE... LOCAL\n"
		" copy files/dirs from device\n"
		" -a: preserve file timestamp and mode\n"
		" -z: enable compression\n"
		" -z: enable compression with a specified algorithm (any, none, brotli)\n"
		" -Z: disable compression\n"
		" sync [-lzZ] [all\|data\|odm\|oem\|product\|system\|system_ext\|vendor]\n"
		" sync [-l] [-z ALGORITHM] [-Z] [all\|data\|odm\|oem\|product\|system\|system_ext\|vendor]\n"
		" sync a local build from $ANDROID_PRODUCT_OUT to the device (default all)\n"
		" -l: list files that would be copied, but don't copy them\n"
		" -z: enable compression\n"
		" -z: enable compression with a specified algorithm (any, none, brotli)\n"
		" -Z: disable compression\n"
		"\n"
		"shell:\n"
		@@ -1314,12 +1314,34 @@ static int restore(int argc, const char** argv) {
		return 0;
		}

		static CompressionType parse_compression_type(const std::string& str, bool allow_numbers) {
		if (allow_numbers) {
		if (str == "0") {
		return CompressionType::None;
		} else if (str == "1") {
		return CompressionType::Any;
		}
		}

		if (str == "any") {
		return CompressionType::Any;
		} else if (str == "none") {
		return CompressionType::None;
		}

		if (str == "brotli") {
		return CompressionType::Brotli;
		}

		error_exit("unexpected compression type %s", str.c_str());
		}

		static void parse_push_pull_args(const char** arg, int narg, std::vector<const char> srcs,
		const char** dst, bool* copy_attrs, bool* sync, bool* compressed) {
		const char** dst, bool* copy_attrs, bool* sync,
		CompressionType* compression) {
		*copy_attrs = false;
		const char* adb_compression = getenv("ADB_COMPRESSION");
		if (adb_compression && strcmp(adb_compression, "0") == 0) {
		*compressed = false;
		if (const char* adb_compression = getenv("ADB_COMPRESSION")) {
		*compression = parse_compression_type(adb_compression, true);
		}

		srcs->clear();
		@@ -1333,13 +1355,13 @@ static void parse_push_pull_args(const char** arg, int narg, std::vector<const c
		} else if (!strcmp(*arg, "-a")) {
		*copy_attrs = true;
		} else if (!strcmp(*arg, "-z")) {
		if (compressed != nullptr) {
		*compressed = true;
		if (narg < 2) {
		error_exit("-z requires an argument");
		}
		compression = parse_compression_type(++arg, false);
		--narg;
		} else if (!strcmp(*arg, "-Z")) {
		if (compressed != nullptr) {
		*compressed = false;
		}
		*compression = CompressionType::None;
		} else if (!strcmp(*arg, "--sync")) {
		if (sync != nullptr) {
		*sync = true;
		@@ -1894,22 +1916,22 @@ int adb_commandline(int argc, const char** argv) {
		} else if (!strcmp(argv[0], "push")) {
		bool copy_attrs = false;
		bool sync = false;
		bool compressed = true;
		CompressionType compression = CompressionType::Any;
		std::vector<const char*> srcs;
		const char* dst = nullptr;

		parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs, &sync, &compressed);
		parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs, &sync, &compression);
		if (srcs.empty() \|\| !dst) error_exit("push requires an argument");
		return do_sync_push(srcs, dst, sync, compressed) ? 0 : 1;
		return do_sync_push(srcs, dst, sync, compression) ? 0 : 1;
		} else if (!strcmp(argv[0], "pull")) {
		bool copy_attrs = false;
		bool compressed = true;
		CompressionType compression = CompressionType::Any;
		std::vector<const char*> srcs;
		const char* dst = ".";

		parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs, nullptr, &compressed);
		parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs, nullptr, &compression);
		if (srcs.empty()) error_exit("pull requires an argument");
		return do_sync_pull(srcs, dst, copy_attrs, compressed) ? 0 : 1;
		return do_sync_pull(srcs, dst, copy_attrs, compression) ? 0 : 1;
		} else if (!strcmp(argv[0], "install")) {
		if (argc < 2) error_exit("install requires an argument");
		return install_app(argc, argv);
		@@ -1925,27 +1947,26 @@ int adb_commandline(int argc, const char** argv) {
		} else if (!strcmp(argv[0], "sync")) {
		std::string src;
		bool list_only = false;
		bool compressed = true;
		CompressionType compression = CompressionType::Any;

		const char* adb_compression = getenv("ADB_COMPRESSION");
		if (adb_compression && strcmp(adb_compression, "0") == 0) {
		compressed = false;
		if (const char* adb_compression = getenv("ADB_COMPRESSION"); adb_compression) {
		compression = parse_compression_type(adb_compression, true);
		}

		int opt;
		while ((opt = getopt(argc, const_cast<char**>(argv), "lzZ")) != -1) {
		while ((opt = getopt(argc, const_cast<char**>(argv), "lz:Z")) != -1) {
		switch (opt) {
		case 'l':
		list_only = true;
		break;
		case 'z':
		compressed = true;
		compression = parse_compression_type(optarg, false);
		break;
		case 'Z':
		compressed = false;
		compression = CompressionType::None;
		break;
		default:
		error_exit("usage: adb sync [-lzZ] [PARTITION]");
		error_exit("usage: adb sync [-l] [-z ALGORITHM] [-Z] [PARTITION]");
		}
		}

		@@ -1954,7 +1975,7 @@ int adb_commandline(int argc, const char** argv) {
		} else if (optind + 1 == argc) {
		src = argv[optind];
		} else {
		error_exit("usage: adb sync [-lzZ] [PARTITION]");
		error_exit("usage: adb sync [-l] [-z ALGORITHM] [-Z] [PARTITION]");
		}

		std::vector<std::string> partitions{"data", "odm", "oem", "product",
		@@ -1965,7 +1986,7 @@ int adb_commandline(int argc, const char** argv) {
		std::string src_dir{product_file(partition)};
		if (!directory_exists(src_dir)) continue;
		found = true;
		if (!do_sync_sync(src_dir, "/" + partition, list_only, compressed)) return 1;
		if (!do_sync_sync(src_dir, "/" + partition, list_only, compression)) return 1;
		}
		}
		if (!found) error_exit("don't know how to sync %s partition", src.c_str());

adb/client/fastdeploy.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -112,7 +112,7 @@ static void push_to_device(const void* data, size_t byte_count, const char* dst,
		// but can't be removed until after the push.
		unix_close(tf.release());

		if (!do_sync_push(srcs, dst, sync, true)) {
		if (!do_sync_push(srcs, dst, sync, CompressionType::Any)) {
		error_exit("Failed to push fastdeploy agent to device.");
		}
		}

adb/client/file_sync_client.cpp

+128 −74

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@
		#include <memory>
		#include <sstream>
		#include <string>
		#include <variant>
		#include <vector>

		#include "sysdeps.h"
		@@ -262,6 +263,18 @@ class SyncConnection {
		bool HaveSendRecv2() const { return have_sendrecv_v2_; }
		bool HaveSendRecv2Brotli() const { return have_sendrecv_v2_brotli_; }

		// Resolve a compression type which might be CompressionType::Any to a specific compression
		// algorithm.
		CompressionType ResolveCompressionType(CompressionType compression) const {
		if (compression == CompressionType::Any) {
		if (HaveSendRecv2Brotli()) {
		return CompressionType::Brotli;
		}
		return CompressionType::None;
		}
		return compression;
		}

		const FeatureSet& Features() const { return features_; }

		bool IsValid() { return fd >= 0; }
		@@ -323,7 +336,7 @@ class SyncConnection {
		return WriteFdExactly(fd, buf.data(), buf.size());
		}

		bool SendSend2(std::string_view path, mode_t mode, bool compressed) {
		bool SendSend2(std::string_view path, mode_t mode, CompressionType compression) {
		if (path.length() > 1024) {
		Error("SendRequest failed: path too long: %zu", path.length());
		errno = ENAMETOOLONG;
		@@ -339,7 +352,18 @@ class SyncConnection {
		syncmsg msg;
		msg.send_v2_setup.id = ID_SEND_V2;
		msg.send_v2_setup.mode = mode;
		msg.send_v2_setup.flags = compressed ? kSyncFlagBrotli : kSyncFlagNone;
		msg.send_v2_setup.flags = 0;
		switch (compression) {
		case CompressionType::None:
		break;

		case CompressionType::Brotli:
		msg.send_v2_setup.flags = kSyncFlagBrotli;
		break;

		case CompressionType::Any:
		LOG(FATAL) << "unexpected CompressionType::Any";
		}

		buf.resize(sizeof(SyncRequest) + path.length() + sizeof(msg.send_v2_setup));

		@@ -352,7 +376,7 @@ class SyncConnection {
		return WriteFdExactly(fd, buf.data(), buf.size());
		}

		bool SendRecv2(const std::string& path) {
		bool SendRecv2(const std::string& path, CompressionType compression) {
		if (path.length() > 1024) {
		Error("SendRequest failed: path too long: %zu", path.length());
		errno = ENAMETOOLONG;
		@@ -367,7 +391,18 @@ class SyncConnection {

		syncmsg msg;
		msg.recv_v2_setup.id = ID_RECV_V2;
		msg.recv_v2_setup.flags = kSyncFlagBrotli;
		msg.recv_v2_setup.flags = 0;
		switch (compression) {
		case CompressionType::None:
		break;

		case CompressionType::Brotli:
		msg.recv_v2_setup.flags \|= kSyncFlagBrotli;
		break;

		case CompressionType::Any:
		LOG(FATAL) << "unexpected CompressionType::Any";
		}

		buf.resize(sizeof(SyncRequest) + path.length() + sizeof(msg.recv_v2_setup));

		@@ -533,9 +568,15 @@ class SyncConnection {
		return true;
		}

		bool SendLargeFileCompressed(const std::string& path, mode_t mode, const std::string& lpath,
		const std::string& rpath, unsigned mtime) {
		if (!SendSend2(path, mode, true)) {
		bool SendLargeFile(const std::string& path, mode_t mode, const std::string& lpath,
		const std::string& rpath, unsigned mtime, CompressionType compression) {
		if (!HaveSendRecv2()) {
		return SendLargeFileLegacy(path, mode, lpath, rpath, mtime);
		}

		compression = ResolveCompressionType(compression);

		if (!SendSend2(path, mode, compression)) {
		Error("failed to send ID_SEND_V2 message '%s': %s", path.c_str(), strerror(errno));
		return false;
		}
		@@ -558,7 +599,21 @@ class SyncConnection {
		syncsendbuf sbuf;
		sbuf.id = ID_DATA;

		BrotliEncoder<SYNC_DATA_MAX> encoder;
		std::variant<std::monostate, NullEncoder, BrotliEncoder> encoder_storage;
		Encoder* encoder = nullptr;
		switch (compression) {
		case CompressionType::None:
		encoder = &encoder_storage.emplace<NullEncoder>(SYNC_DATA_MAX);
		break;

		case CompressionType::Brotli:
		encoder = &encoder_storage.emplace<BrotliEncoder>(SYNC_DATA_MAX);
		break;

		case CompressionType::Any:
		LOG(FATAL) << "unexpected CompressionType::Any";
		}

		bool sending = true;
		while (sending) {
		Block input(SYNC_DATA_MAX);
		@@ -569,10 +624,10 @@ class SyncConnection {
		}

		if (r == 0) {
		encoder.Finish();
		encoder->Finish();
		} else {
		input.resize(r);
		encoder.Append(std::move(input));
		encoder->Append(std::move(input));
		RecordBytesTransferred(r);
		bytes_copied += r;
		ReportProgress(rpath, bytes_copied, total_size);
		@@ -580,7 +635,7 @@ class SyncConnection {

		while (true) {
		Block output;
		EncodeResult result = encoder.Encode(&output);
		EncodeResult result = encoder->Encode(&output);
		if (result == EncodeResult::Error) {
		Error("compressing '%s' locally failed", lpath.c_str());
		return false;
		@@ -610,12 +665,8 @@ class SyncConnection {
		return WriteOrDie(lpath, rpath, &msg.data, sizeof(msg.data));
		}

		bool SendLargeFile(const std::string& path, mode_t mode, const std::string& lpath,
		const std::string& rpath, unsigned mtime, bool compressed) {
		if (compressed && HaveSendRecv2Brotli()) {
		return SendLargeFileCompressed(path, mode, lpath, rpath, mtime);
		}

		bool SendLargeFileLegacy(const std::string& path, mode_t mode, const std::string& lpath,
		const std::string& rpath, unsigned mtime) {
		std::string path_and_mode = android::base::StringPrintf("%s,%d", path.c_str(), mode);
		if (!SendRequest(ID_SEND_V1, path_and_mode)) {
		Error("failed to send ID_SEND_V1 message '%s': %s", path_and_mode.c_str(),
		@@ -921,7 +972,7 @@ static bool sync_stat_fallback(SyncConnection& sc, const std::string& path, stru
		}

		static bool sync_send(SyncConnection& sc, const std::string& lpath, const std::string& rpath,
		unsigned mtime, mode_t mode, bool sync, bool compressed) {
		unsigned mtime, mode_t mode, bool sync, CompressionType compression) {
		if (sync) {
		struct stat st;
		if (sync_lstat(sc, rpath, &st)) {
		@@ -964,7 +1015,7 @@ static bool sync_send(SyncConnection& sc, const std::string& lpath, const std::s
		return false;
		}
		} else {
		if (!sc.SendLargeFile(rpath, mode, lpath, rpath, mtime, compressed)) {
		if (!sc.SendLargeFile(rpath, mode, lpath, rpath, mtime, compression)) {
		return false;
		}
		}
		@@ -1027,8 +1078,10 @@ static bool sync_recv_v1(SyncConnection& sc, const char* rpath, const char* lpat
		}

		static bool sync_recv_v2(SyncConnection& sc, const char* rpath, const char* lpath, const char* name,
		uint64_t expected_size) {
		if (!sc.SendRecv2(rpath)) return false;
		uint64_t expected_size, CompressionType compression) {
		compression = sc.ResolveCompressionType(compression);

		if (!sc.SendRecv2(rpath, compression)) return false;

		adb_unlink(lpath);
		unique_fd lfd(adb_creat(lpath, 0644));
		@@ -1040,9 +1093,24 @@ static bool sync_recv_v2(SyncConnection& sc, const char* rpath, const char* lpat
		uint64_t bytes_copied = 0;

		Block buffer(SYNC_DATA_MAX);
		BrotliDecoder decoder(std::span(buffer.data(), buffer.size()));
		bool reading = true;
		while (reading) {
		std::variant<std::monostate, NullDecoder, BrotliDecoder> decoder_storage;
		Decoder* decoder = nullptr;

		std::span buffer_span(buffer.data(), buffer.size());
		switch (compression) {
		case CompressionType::None:
		decoder = &decoder_storage.emplace<NullDecoder>(buffer_span);
		break;

		case CompressionType::Brotli:
		decoder = &decoder_storage.emplace<BrotliDecoder>(buffer_span);
		break;

		case CompressionType::Any:
		LOG(FATAL) << "unexpected CompressionType::Any";
		}

		while (true) {
		syncmsg msg;
		if (!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) {
		adb_unlink(lpath);
		@@ -1050,17 +1118,15 @@ static bool sync_recv_v2(SyncConnection& sc, const char* rpath, const char* lpat
		}

		if (msg.data.id == ID_DONE) {
		adb_unlink(lpath);
		if (!decoder->Finish()) {
		sc.Error("unexpected ID_DONE");
		return false;
		}

		if (msg.data.id != ID_DATA) {
		} else if (msg.data.id != ID_DATA) {
		adb_unlink(lpath);
		sc.ReportCopyFailure(rpath, lpath, msg);
		return false;
		}

		} else {
		if (msg.data.size > sc.max) {
		sc.Error("msg.data.size too large: %u (max %zu)", msg.data.size, sc.max);
		adb_unlink(lpath);
		@@ -1072,11 +1138,12 @@ static bool sync_recv_v2(SyncConnection& sc, const char* rpath, const char* lpat
		adb_unlink(lpath);
		return false;
		}
		decoder.Append(std::move(block));
		decoder->Append(std::move(block));
		}

		while (true) {
		std::span<char> output;
		DecodeResult result = decoder.Decode(&output);
		DecodeResult result = decoder->Decode(&output);

		if (result == DecodeResult::Error) {
		sc.Error("decompress failed");
		@@ -1102,33 +1169,19 @@ static bool sync_recv_v2(SyncConnection& sc, const char* rpath, const char* lpat
		} else if (result == DecodeResult::MoreOutput) {
		continue;
		} else if (result == DecodeResult::Done) {
		reading = false;
		break;
		sc.RecordFilesTransferred(1);
		return true;
		} else {
		LOG(FATAL) << "invalid DecodeResult: " << static_cast<int>(result);
		}
		}
		}

		syncmsg msg;
		if (!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) {
		sc.Error("failed to read ID_DONE");
		return false;
		}

		if (msg.data.id != ID_DONE) {
		sc.Error("unexpected message after transfer: id = %d (expected ID_DONE)", msg.data.id);
		return false;
		}

		sc.RecordFilesTransferred(1);
		return true;
		}

		static bool sync_recv(SyncConnection& sc, const char* rpath, const char* lpath, const char* name,
		uint64_t expected_size, bool compressed) {
		if (sc.HaveSendRecv2() && compressed) {
		return sync_recv_v2(sc, rpath, lpath, name, expected_size);
		uint64_t expected_size, CompressionType compression) {
		if (sc.HaveSendRecv2()) {
		return sync_recv_v2(sc, rpath, lpath, name, expected_size, compression);
		} else {
		return sync_recv_v1(sc, rpath, lpath, name, expected_size);
		}
		@@ -1210,7 +1263,8 @@ static bool is_root_dir(std::string_view path) {
		}

		static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath, std::string rpath,
		bool check_timestamps, bool list_only, bool compressed) {
		bool check_timestamps, bool list_only,
		CompressionType compression) {
		sc.NewTransfer();

		// Make sure that both directory paths end in a slash.
		@@ -1292,7 +1346,7 @@ static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath, std::st
		if (list_only) {
		sc.Println("would push: %s -> %s", ci.lpath.c_str(), ci.rpath.c_str());
		} else {
		if (!sync_send(sc, ci.lpath, ci.rpath, ci.time, ci.mode, false, compressed)) {
		if (!sync_send(sc, ci.lpath, ci.rpath, ci.time, ci.mode, false, compression)) {
		return false;
		}
		}
		@@ -1308,7 +1362,7 @@ static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath, std::st
		}

		bool do_sync_push(const std::vector<const char>& srcs, const char dst, bool sync,
		bool compressed) {
		CompressionType compression) {
		SyncConnection sc;
		if (!sc.IsValid()) return false;

		@@ -1373,7 +1427,7 @@ bool do_sync_push(const std::vector<const char>& srcs, const char dst, bool sy
		dst_dir.append(android::base::Basename(src_path));
		}

		success &= copy_local_dir_remote(sc, src_path, dst_dir, sync, false, compressed);
		success &= copy_local_dir_remote(sc, src_path, dst_dir, sync, false, compression);
		continue;
		} else if (!should_push_file(st.st_mode)) {
		sc.Warning("skipping special file '%s' (mode = 0o%o)", src_path, st.st_mode);
		@@ -1394,7 +1448,7 @@ bool do_sync_push(const std::vector<const char>& srcs, const char dst, bool sy

		sc.NewTransfer();
		sc.SetExpectedTotalBytes(st.st_size);
		success &= sync_send(sc, src_path, dst_path, st.st_mtime, st.st_mode, sync, compressed);
		success &= sync_send(sc, src_path, dst_path, st.st_mtime, st.st_mode, sync, compression);
		sc.ReportTransferRate(src_path, TransferDirection::push);
		}

		@@ -1480,7 +1534,7 @@ static int set_time_and_mode(const std::string& lpath, time_t time,
		}

		static bool copy_remote_dir_local(SyncConnection& sc, std::string rpath, std::string lpath,
		bool copy_attrs, bool compressed) {
		bool copy_attrs, CompressionType compression) {
		sc.NewTransfer();

		// Make sure that both directory paths end in a slash.
		@@ -1510,7 +1564,7 @@ static bool copy_remote_dir_local(SyncConnection& sc, std::string rpath, std::st
		continue;
		}

		if (!sync_recv(sc, ci.rpath.c_str(), ci.lpath.c_str(), nullptr, ci.size, compressed)) {
		if (!sync_recv(sc, ci.rpath.c_str(), ci.lpath.c_str(), nullptr, ci.size, compression)) {
		return false;
		}

		@@ -1528,7 +1582,7 @@ static bool copy_remote_dir_local(SyncConnection& sc, std::string rpath, std::st
		}

		bool do_sync_pull(const std::vector<const char>& srcs, const char dst, bool copy_attrs,
		bool compressed, const char* name) {
		CompressionType compression, const char* name) {
		SyncConnection sc;
		if (!sc.IsValid()) return false;

		@@ -1602,7 +1656,7 @@ bool do_sync_pull(const std::vector<const char>& srcs, const char dst, bool co
		dst_dir.append(android::base::Basename(src_path));
		}

		success &= copy_remote_dir_local(sc, src_path, dst_dir, copy_attrs, compressed);
		success &= copy_remote_dir_local(sc, src_path, dst_dir, copy_attrs, compression);
		continue;
		} else if (!should_pull_file(src_st.st_mode)) {
		sc.Warning("skipping special file '%s' (mode = 0o%o)", src_path, src_st.st_mode);
		@@ -1621,7 +1675,7 @@ bool do_sync_pull(const std::vector<const char>& srcs, const char dst, bool co

		sc.NewTransfer();
		sc.SetExpectedTotalBytes(src_st.st_size);
		if (!sync_recv(sc, src_path, dst_path, name, src_st.st_size, compressed)) {
		if (!sync_recv(sc, src_path, dst_path, name, src_st.st_size, compression)) {
		success = false;
		continue;
		}
		@@ -1638,11 +1692,11 @@ bool do_sync_pull(const std::vector<const char>& srcs, const char dst, bool co
		}

		bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only,
		bool compressed) {
		CompressionType compression) {
		SyncConnection sc;
		if (!sc.IsValid()) return false;

		bool success = copy_local_dir_remote(sc, lpath, rpath, true, list_only, compressed);
		bool success = copy_local_dir_remote(sc, lpath, rpath, true, list_only, compression);
		if (!list_only) {
		sc.ReportOverallTransferRate(TransferDirection::push);
		}