adb sync cleanup.
We can double the speed of "adb sync" (on N9) if we increase SYNC_DATA_MAX
from 64KiB to 256KiB. This change doesn't do that, because I still haven't
managed to plumb through the information about whether we're a new adb/adbd
to file_sync_client.cpp and file_sync_service.cpp. But this is already a big
change with a lot of cleanup, so let's do the cleanup and worry about the
intended change another day...
This change does improve performance somewhat by halving the number of
lstat(2) calls made on the client side, and ensuring that most packets are
sent with a single write. This has the pleasing result of making the null
sync on an AOSP N9 go from just over 300ms to around 100ms, which means it
now seems instantaneous (https://en.wikipedia.org/wiki/Mental_chronometry).
Change-Id: If9f6d4c1f93ec752b95f71211bbbb1c513045166
diff --git a/SERVICES.TXT b/SERVICES.TXT
index 63000f2..30c21f7 100644
--- a/SERVICES.TXT
+++ b/SERVICES.TXT
@@ -237,7 +237,7 @@
Note that there is no single-shot service to retrieve the list only once.
sync:
- This starts the file synchronisation service, used to implement "adb push"
+ This starts the file synchronization service, used to implement "adb push"
and "adb pull". Since this service is pretty complex, it will be detailed
in a companion document named SYNC.TXT
diff --git a/SYNC.TXT b/SYNC.TXT
index e74d217..06d7804 100644
--- a/SYNC.TXT
+++ b/SYNC.TXT
@@ -25,12 +25,9 @@
The following sync requests are accepted:
LIST - List the files in a folder
+RECV - Retrieve a file from device
SEND - Send a file to device
-RECV - Retreive a file from device
-
-Not yet documented:
STAT - Stat a file
-ULNK - Unlink (remove) a file. (Not currently supported)
For all of the sync request above the must be followed by length number of
bytes containing an utf-8 string with a remote filename.
@@ -40,7 +37,7 @@
respond with zero or more directory entries or "dents".
The directory entries will be returned in the following form
-1. A four-byte sync response id beeing "DENT"
+1. A four-byte sync response id "DENT"
2. A four-byte integer representing file mode.
3. A four-byte integer representing file size.
4. A four-byte integer representing last modified time.
@@ -60,13 +57,13 @@
adb push disk_image /some_block_device
to work.
-After this the actual file is sent in chunks. Each chucks has the following
+After this the actual file is sent in chunks. Each chunk has the following
format.
A sync request with id "DATA" and length equal to the chunk size. After
follows chunk size number of bytes. This is repeated until the file is
-transfered. Each chunk must not be larger than 64k.
+transferred. Each chunk must not be larger than 64k.
-When the file is tranfered a sync request "DONE" is sent, where length is set
+When the file is transferred a sync request "DONE" is sent, where length is set
to the last modified time for the file. The server responds to this last
request (but not to chuck requests) with an "OKAY" sync response (length can
be ignored).
@@ -77,8 +74,8 @@
the file that will be returned. Just as for the SEND sync request the file
received is split up into chunks. The sync response id is "DATA" and length is
the chuck size. After follows chunk size number of bytes. This is repeated
-until the file is transfered. Each chuck will not be larger than 64k.
+until the file is transferred. Each chuck will not be larger than 64k.
-When the file is transfered a sync resopnse "DONE" is retrieved where the
+When the file is transferred a sync response "DONE" is retrieved where the
length can be ignored.
diff --git a/adb_client.cpp b/adb_client.cpp
index 4bf647c..a1bbb78 100644
--- a/adb_client.cpp
+++ b/adb_client.cpp
@@ -44,28 +44,6 @@
static int __adb_server_port = DEFAULT_ADB_PORT;
static const char* __adb_server_name = NULL;
-static std::string perror_str(const char* msg) {
- return android::base::StringPrintf("%s: %s", msg, strerror(errno));
-}
-
-static bool ReadProtocolString(int fd, std::string* s, std::string* error) {
- char buf[5];
- if (!ReadFdExactly(fd, buf, 4)) {
- *error = perror_str("protocol fault (couldn't read status length)");
- return false;
- }
- buf[4] = 0;
-
- unsigned long len = strtoul(buf, 0, 16);
- s->resize(len, '\0');
- if (!ReadFdExactly(fd, &(*s)[0], len)) {
- *error = perror_str("protocol fault (couldn't read status message)");
- return false;
- }
-
- return true;
-}
-
void adb_set_transport(TransportType type, const char* serial)
{
__adb_transport = type;
@@ -175,7 +153,7 @@
return -1;
}
- if(!SendProtocolString(fd, service)) {
+ if (!SendProtocolString(fd, service)) {
*error = perror_str("write failure during connection");
adb_close(fd);
return -1;
diff --git a/adb_io.cpp b/adb_io.cpp
index 5ae6ec3..7092609 100644
--- a/adb_io.cpp
+++ b/adb_io.cpp
@@ -32,7 +32,27 @@
length = 0xffff;
}
- return WriteFdFmt(fd, "%04x", length) && WriteFdExactly(fd, s);
+ // The cost of sending two strings outweighs the cost of formatting.
+ // "adb sync" performance is affected by this.
+ return WriteFdFmt(fd, "%04x%.*s", length, length, s.c_str());
+}
+
+bool ReadProtocolString(int fd, std::string* s, std::string* error) {
+ char buf[5];
+ if (!ReadFdExactly(fd, buf, 4)) {
+ *error = perror_str("protocol fault (couldn't read status length)");
+ return false;
+ }
+ buf[4] = 0;
+
+ unsigned long len = strtoul(buf, 0, 16);
+ s->resize(len, '\0');
+ if (!ReadFdExactly(fd, &(*s)[0], len)) {
+ *error = perror_str("protocol fault (couldn't read status message)");
+ return false;
+ }
+
+ return true;
}
bool SendOkay(int fd) {
diff --git a/adb_io.h b/adb_io.h
index 8d50a6d..9c3b2a5 100644
--- a/adb_io.h
+++ b/adb_io.h
@@ -30,23 +30,22 @@
// Writes a protocol-format string; a four hex digit length followed by the string data.
bool SendProtocolString(int fd, const std::string& s);
-/*
- * Reads exactly len bytes from fd into buf.
- *
- * Returns false if there is an error or if EOF was reached before len bytes
- * were read. If EOF was found, errno will be set to 0.
- *
- * If this function fails, the contents of buf are undefined.
- */
-bool ReadFdExactly(int fd, void *buf, size_t len);
+// Reads a protocol-format string; a four hex digit length followed by the string data.
+bool ReadProtocolString(int fd, std::string* s, std::string* error);
-/*
- * Writes exactly len bytes from buf to fd.
- *
- * Returns false if there is an error or if the fd was closed before the write
- * completed. If the other end of the fd (such as in a socket, pipe, or fifo),
- * is closed, errno will be set to 0.
- */
+// Reads exactly len bytes from fd into buf.
+//
+// Returns false if there is an error or if EOF was reached before len bytes
+// were read. If EOF was found, errno will be set to 0.
+//
+// If this function fails, the contents of buf are undefined.
+bool ReadFdExactly(int fd, void* buf, size_t len);
+
+// Writes exactly len bytes from buf to fd.
+//
+// Returns false if there is an error or if the fd was closed before the write
+// completed. If the other end of the fd (such as in a socket, pipe, or fifo),
+// is closed, errno will be set to 0.
bool WriteFdExactly(int fd, const void* buf, size_t len);
// Same as above, but for strings.
diff --git a/adb_utils.cpp b/adb_utils.cpp
index ca843bd..e5dc692 100644
--- a/adb_utils.cpp
+++ b/adb_utils.cpp
@@ -225,3 +225,7 @@
<< " (" << *canonical_address << ")";
return true;
}
+
+std::string perror_str(const char* msg) {
+ return android::base::StringPrintf("%s: %s", msg, strerror(errno));
+}
diff --git a/adb_utils.h b/adb_utils.h
index 739efcc..b38ec59 100644
--- a/adb_utils.h
+++ b/adb_utils.h
@@ -44,4 +44,6 @@
std::string* host, int* port,
std::string* error);
+std::string perror_str(const char* msg);
+
#endif
diff --git a/commandline.cpp b/commandline.cpp
index c7b7675..e1e21ed 100644
--- a/commandline.cpp
+++ b/commandline.cpp
@@ -381,7 +381,7 @@
fdi = fds[1];
free(fds);
- for(;;) {
+ while (true) {
/* fdi is really the client's stdin, so use read, not adb_read here */
D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi);
r = unix_read(fdi, buf, 1024);
@@ -889,14 +889,14 @@
}
static void parse_push_pull_args(const char **arg, int narg, char const **path1,
- char const **path2, int *show_progress,
+ char const **path2, bool* show_progress,
int *copy_attrs) {
- *show_progress = 0;
+ *show_progress = false;
*copy_attrs = 0;
while (narg > 0) {
if (!strcmp(*arg, "-p")) {
- *show_progress = 1;
+ *show_progress = true;
} else if (!strcmp(*arg, "-a")) {
*copy_attrs = 1;
} else {
@@ -1331,33 +1331,25 @@
/* do_sync_*() commands */
else if (!strcmp(argv[0], "ls")) {
if (argc != 2) return usage();
- return do_sync_ls(argv[1]);
+ return do_sync_ls(argv[1]) ? 0 : 1;
}
else if (!strcmp(argv[0], "push")) {
- int show_progress = 0;
- int copy_attrs = 0; // unused
+ bool show_progress = false;
+ int copy_attrs = 0;
const char* lpath = NULL, *rpath = NULL;
parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs);
-
- if ((lpath != NULL) && (rpath != NULL)) {
- return do_sync_push(lpath, rpath, show_progress);
- }
-
- return usage();
+ if (!lpath || !rpath || copy_attrs != 0) return usage();
+ return do_sync_push(lpath, rpath, show_progress) ? 0 : 1;
}
else if (!strcmp(argv[0], "pull")) {
- int show_progress = 0;
+ bool show_progress = false;
int copy_attrs = 0;
const char* rpath = NULL, *lpath = ".";
parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs);
-
- if (rpath != NULL) {
- return do_sync_pull(rpath, lpath, show_progress, copy_attrs);
- }
-
- return usage();
+ if (!rpath) return usage();
+ return do_sync_pull(rpath, lpath, show_progress, copy_attrs) ? 0 : 1;
}
else if (!strcmp(argv[0], "install")) {
if (argc < 2) return usage();
@@ -1401,20 +1393,20 @@
std::string vendor_src_path = product_file("vendor");
std::string oem_src_path = product_file("oem");
- int rc = 0;
- if (rc == 0 && (src.empty() || src == "system")) {
- rc = do_sync_sync(system_src_path, "/system", list_only);
+ bool okay = true;
+ if (okay && (src.empty() || src == "system")) {
+ okay = do_sync_sync(system_src_path, "/system", list_only);
}
- if (rc == 0 && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) {
- rc = do_sync_sync(vendor_src_path, "/vendor", list_only);
+ if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) {
+ okay = do_sync_sync(vendor_src_path, "/vendor", list_only);
}
- if (rc == 0 && (src.empty() || src == "oem") && directory_exists(oem_src_path)) {
- rc = do_sync_sync(oem_src_path, "/oem", list_only);
+ if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) {
+ okay = do_sync_sync(oem_src_path, "/oem", list_only);
}
- if (rc == 0 && (src.empty() || src == "data")) {
- rc = do_sync_sync(data_src_path, "/data", list_only);
+ if (okay && (src.empty() || src == "data")) {
+ okay = do_sync_sync(data_src_path, "/data", list_only);
}
- return rc;
+ return okay ? 0 : 1;
}
/* passthrough commands */
else if (!strcmp(argv[0],"get-state") ||
@@ -1535,20 +1527,16 @@
return -1;
}
+ int result = -1;
const char* apk_file = argv[last_apk];
std::string apk_dest = android::base::StringPrintf(where, adb_basename(apk_file).c_str());
- int err = do_sync_push(apk_file, apk_dest.c_str(), 0 /* no show progress */);
- if (err) {
- goto cleanup_apk;
- } else {
- argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
- }
-
- err = pm_command(transport, serial, argc, argv);
+ if (!do_sync_push(apk_file, apk_dest.c_str(), false)) goto cleanup_apk;
+ argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
+ result = pm_command(transport, serial, argc, argv);
cleanup_apk:
delete_file(transport, serial, apk_dest);
- return err;
+ return result;
}
static int install_multiple_app(TransportType transport, const char* serial, int argc,
diff --git a/fdevent.cpp b/fdevent.cpp
index a8abade..e722d66 100644
--- a/fdevent.cpp
+++ b/fdevent.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, Brian Swetland <swetland@frotz.net>
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -688,7 +688,7 @@
fdevent_subproc_setup();
#endif // !ADB_HOST
- for(;;) {
+ while (true) {
D("--- ---- waiting for events\n");
fdevent_process();
diff --git a/file_sync_client.cpp b/file_sync_client.cpp
index da80013..c37c6dd 100644
--- a/file_sync_client.cpp
+++ b/file_sync_client.cpp
@@ -35,36 +35,21 @@
#include "adb_utils.h"
#include "file_sync_service.h"
+#include <base/strings.h>
#include <base/stringprintf.h>
-static unsigned long long total_bytes;
-static long long start_time;
+struct syncsendbuf {
+ unsigned id;
+ unsigned size;
+ char data[SYNC_DATA_MAX];
+};
-static long long NOW()
-{
+static syncsendbuf send_buffer;
+
+static long long NOW() {
struct timeval tv;
gettimeofday(&tv, 0);
- return ((long long) tv.tv_usec) +
- 1000000LL * ((long long) tv.tv_sec);
-}
-
-static void BEGIN()
-{
- total_bytes = 0;
- start_time = NOW();
-}
-
-static void END()
-{
- long long t = NOW() - start_time;
- if(total_bytes == 0) return;
-
- if (t == 0) /* prevent division by 0 :-) */
- t = 1000000;
-
- fprintf(stderr,"%lld KB/s (%lld bytes in %lld.%03llds)\n",
- ((total_bytes * 1000000LL) / t) / 1024LL,
- total_bytes, (t / 1000000LL), (t % 1000000LL) / 1000LL);
+ return ((long long) tv.tv_usec) + 1000000LL * ((long long) tv.tv_sec);
}
static void print_transfer_progress(uint64_t bytes_current,
@@ -82,148 +67,123 @@
fflush(stderr);
}
-static void sync_quit(int fd) {
- syncmsg msg;
-
- msg.req.id = ID_QUIT;
- msg.req.namelen = 0;
-
- WriteFdExactly(fd, &msg.req, sizeof(msg.req));
-}
-
-typedef void (*sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char *name, void *cookie);
-
-static int sync_ls(int fd, const char* path, sync_ls_cb func, void* cookie) {
- int len = strlen(path);
- if (len > 1024) goto fail;
-
- syncmsg msg;
- msg.req.id = ID_LIST;
- msg.req.namelen = htoll(len);
-
- if (!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) || !WriteFdExactly(fd, path, len)) {
- goto fail;
+static bool SendRequest(int fd, int id, const char* path) {
+ size_t path_length = strlen(path);
+ if (path_length > 1024) {
+ fprintf(stderr, "SendRequest failed: path too long: %zu", path_length);
+ return false;
}
- for (;;) {
- if (!ReadFdExactly(fd, &msg.dent, sizeof(msg.dent))) break;
- if (msg.dent.id == ID_DONE) return 0;
- if (msg.dent.id != ID_DENT) break;
+ // Sending header and payload in a single write makes a noticeable
+ // difference to "adb sync" performance.
+ char buf[sizeof(SyncRequest) + path_length] __attribute__((aligned(8)));
+ SyncRequest* req = reinterpret_cast<SyncRequest*>(buf);
+ req->id = id;
+ req->path_length = htoll(path_length);
+ char* data = reinterpret_cast<char*>(req + 1);
+ memcpy(data, path, path_length);
- len = ltohl(msg.dent.namelen);
- if (len > 256) break;
+ return WriteFdExactly(fd, buf, sizeof(buf));
+}
+
+class SyncConnection {
+ public:
+ SyncConnection() : total_bytes(0), start_time_(NOW()) {
+ max = SYNC_DATA_MAX; // TODO: decide at runtime.
+
+ std::string error;
+ fd = adb_connect("sync:", &error);
+ if (fd < 0) {
+ fprintf(stderr, "error: %s\n", error.c_str());
+ }
+ }
+
+ ~SyncConnection() {
+ if (!IsValid()) return;
+
+ SendQuit();
+ ShowTransferRate();
+ adb_close(fd);
+ }
+
+ bool IsValid() { return fd >= 0; }
+
+ uint64_t total_bytes;
+
+ // TODO: add a char[max] buffer here, to replace syncsendbuf...
+ int fd;
+ size_t max;
+
+ private:
+ uint64_t start_time_;
+
+ void SendQuit() {
+ SendRequest(fd, ID_QUIT, ""); // TODO: add a SendResponse?
+ }
+
+ void ShowTransferRate() {
+ uint64_t t = NOW() - start_time_;
+ if (total_bytes == 0 || t == 0) return;
+
+ fprintf(stderr, "%lld KB/s (%" PRId64 " bytes in %lld.%03llds)\n",
+ ((total_bytes * 1000000LL) / t) / 1024LL,
+ total_bytes, (t / 1000000LL), (t % 1000000LL) / 1000LL);
+ }
+};
+
+typedef void (*sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char* name, void* cookie);
+
+static bool sync_ls(int fd, const char* path, sync_ls_cb func, void* cookie) {
+ if (!SendRequest(fd, ID_LIST, path)) return false;
+
+ while (true) {
+ syncmsg msg;
+ if (!ReadFdExactly(fd, &msg.dent, sizeof(msg.dent))) return false;
+
+ if (msg.dent.id == ID_DONE) return true;
+ if (msg.dent.id != ID_DENT) return false;
+
+ size_t len = ltohl(msg.dent.namelen);
+ if (len > 256) return false; // TODO: resize buffer? continue?
char buf[257];
- if (!ReadFdExactly(fd, buf, len)) break;
+ if (!ReadFdExactly(fd, buf, len)) return false;
buf[len] = 0;
func(ltohl(msg.dent.mode), ltohl(msg.dent.size), ltohl(msg.dent.time), buf, cookie);
}
-
-fail:
- adb_close(fd);
- return -1;
}
-struct syncsendbuf {
- unsigned id;
- unsigned size;
- char data[SYNC_DATA_MAX];
-};
+static bool sync_start_stat(SyncConnection& sc, const char* path) {
+ return SendRequest(sc.fd, ID_STAT, path);
+}
-static syncsendbuf send_buffer;
-
-static int sync_readtime(int fd, const char* path, unsigned int* timestamp, unsigned int* mode) {
+static bool sync_finish_stat(SyncConnection& sc, unsigned int* timestamp,
+ unsigned int* mode, unsigned int* size) {
syncmsg msg;
- int len = strlen(path);
-
- msg.req.id = ID_STAT;
- msg.req.namelen = htoll(len);
-
- if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) ||
- !WriteFdExactly(fd, path, len)) {
- return -1;
+ if (!ReadFdExactly(sc.fd, &msg.stat, sizeof(msg.stat)) || msg.stat.id != ID_STAT) {
+ return false;
}
- if(!ReadFdExactly(fd, &msg.stat, sizeof(msg.stat))) {
- return -1;
- }
+ if (timestamp) *timestamp = ltohl(msg.stat.time);
+ if (mode) *mode = ltohl(msg.stat.mode);
+ if (size) *size = ltohl(msg.stat.size);
- if(msg.stat.id != ID_STAT) {
- return -1;
- }
-
- *timestamp = ltohl(msg.stat.time);
- *mode = ltohl(msg.stat.mode);
- return 0;
+ return true;
}
-static int sync_start_readtime(int fd, const char *path)
-{
- syncmsg msg;
- int len = strlen(path);
-
- msg.req.id = ID_STAT;
- msg.req.namelen = htoll(len);
-
- if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) ||
- !WriteFdExactly(fd, path, len)) {
- return -1;
- }
-
- return 0;
+static bool sync_stat(SyncConnection& sc, const char* path,
+ unsigned int* timestamp, unsigned int* mode, unsigned int* size) {
+ return sync_start_stat(sc, path) && sync_finish_stat(sc, timestamp, mode, size);
}
-static int sync_finish_readtime(int fd, unsigned int *timestamp,
- unsigned int *mode, unsigned int *size)
-{
- syncmsg msg;
-
- if(!ReadFdExactly(fd, &msg.stat, sizeof(msg.stat)))
- return -1;
-
- if(msg.stat.id != ID_STAT)
- return -1;
-
- *timestamp = ltohl(msg.stat.time);
- *mode = ltohl(msg.stat.mode);
- *size = ltohl(msg.stat.size);
-
- return 0;
-}
-
-static int sync_readmode(int fd, const char* path, unsigned* mode) {
- syncmsg msg;
- int len = strlen(path);
-
- msg.req.id = ID_STAT;
- msg.req.namelen = htoll(len);
-
- if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) ||
- !WriteFdExactly(fd, path, len)) {
- return -1;
- }
-
- if(!ReadFdExactly(fd, &msg.stat, sizeof(msg.stat))) {
- return -1;
- }
-
- if(msg.stat.id != ID_STAT) {
- return -1;
- }
-
- *mode = ltohl(msg.stat.mode);
- return 0;
-}
-
-static int write_data_file(int fd, const char *path, syncsendbuf *sbuf, bool show_progress)
-{
- int lfd, err = 0;
+static int write_data_file(SyncConnection& sc, const char* path, syncsendbuf* sbuf, bool show_progress) {
+ int err = 0;
unsigned long long size = 0;
- lfd = adb_open(path, O_RDONLY);
- if(lfd < 0) {
- fprintf(stderr,"cannot open '%s': %s\n", path, strerror(errno));
+ int lfd = adb_open(path, O_RDONLY);
+ if (lfd < 0) {
+ fprintf(stderr, "cannot open '%s': %s\n", path, strerror(errno));
return -1;
}
@@ -231,7 +191,7 @@
// Determine local file size.
struct stat st;
if (stat(path, &st)) {
- fprintf(stderr,"cannot stat '%s': %s\n", path, strerror(errno));
+ fprintf(stderr, "cannot stat '%s': %s\n", path, strerror(errno));
return -1;
}
@@ -239,29 +199,27 @@
}
sbuf->id = ID_DATA;
- for(;;) {
- int ret;
-
- ret = adb_read(lfd, sbuf->data, SYNC_DATA_MAX);
- if(!ret)
+ while (true) {
+ int ret = adb_read(lfd, sbuf->data, sc.max);
+ if (!ret)
break;
- if(ret < 0) {
+ if (ret < 0) {
if(errno == EINTR)
continue;
- fprintf(stderr,"cannot read '%s': %s\n", path, strerror(errno));
+ fprintf(stderr, "cannot read '%s': %s\n", path, strerror(errno));
break;
}
sbuf->size = htoll(ret);
- if(!WriteFdExactly(fd, sbuf, sizeof(unsigned) * 2 + ret)){
+ if (!WriteFdExactly(sc.fd, sbuf, sizeof(unsigned) * 2 + ret)) {
err = -1;
break;
}
- total_bytes += ret;
+ sc.total_bytes += ret;
if (show_progress) {
- print_transfer_progress(total_bytes, size);
+ print_transfer_progress(sc.total_bytes, size);
}
}
@@ -269,42 +227,11 @@
return err;
}
-static int write_data_buffer(int fd, char* file_buffer, int size, syncsendbuf *sbuf,
- bool show_progress)
-{
- int err = 0;
- int total = 0;
-
- sbuf->id = ID_DATA;
- while (total < size) {
- int count = size - total;
- if (count > SYNC_DATA_MAX) {
- count = SYNC_DATA_MAX;
- }
-
- memcpy(sbuf->data, &file_buffer[total], count);
- sbuf->size = htoll(count);
- if(!WriteFdExactly(fd, sbuf, sizeof(unsigned) * 2 + count)){
- err = -1;
- break;
- }
- total += count;
- total_bytes += count;
-
- if (show_progress) {
- print_transfer_progress(total, size);
- }
- }
-
- return err;
-}
-
#if defined(_WIN32)
-extern int write_data_link(int fd, const char *path, syncsendbuf *sbuf) __attribute__((error("no symlinks on Windows")));
+extern int write_data_link(SyncConnection& sc, const char* path, syncsendbuf* sbuf) __attribute__((error("no symlinks on Windows")));
#else
-static int write_data_link(int fd, const char *path, syncsendbuf *sbuf)
-{
- int len = readlink(path, sbuf->data, SYNC_DATA_MAX-1);
+static int write_data_link(SyncConnection& sc, const char* path, syncsendbuf* sbuf) {
+ ssize_t len = readlink(path, sbuf->data, sc.max - 1);
if (len < 0) {
fprintf(stderr, "error reading link '%s': %s\n", path, strerror(errno));
return -1;
@@ -314,131 +241,84 @@
sbuf->size = htoll(len + 1);
sbuf->id = ID_DATA;
- if (!WriteFdExactly(fd, sbuf, sizeof(unsigned) * 2 + len + 1)) {
+ if (!WriteFdExactly(sc.fd, sbuf, sizeof(unsigned) * 2 + len + 1)) {
return -1;
}
- total_bytes += len + 1;
+ sc.total_bytes += len + 1;
return 0;
}
#endif
-static int sync_send(int fd, const char *lpath, const char *rpath,
- unsigned mtime, mode_t mode, bool show_progress)
+static bool sync_send(SyncConnection& sc, const char *lpath, const char *rpath,
+ unsigned mtime, mode_t mode, bool show_progress)
{
- syncmsg msg;
- int len, r;
- syncsendbuf *sbuf = &send_buffer;
- char* file_buffer = NULL;
- int size = 0;
- char tmp[64];
+ syncsendbuf* sbuf = &send_buffer;
- len = strlen(rpath);
- if(len > 1024) goto fail;
+ std::string path_and_mode = android::base::StringPrintf("%s,%d", rpath, mode);
+ if (!SendRequest(sc.fd, ID_SEND, path_and_mode.c_str())) goto fail;
- snprintf(tmp, sizeof(tmp), ",%d", mode);
- r = strlen(tmp);
-
- msg.req.id = ID_SEND;
- msg.req.namelen = htoll(len + r);
-
- if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) ||
- !WriteFdExactly(fd, rpath, len) || !WriteFdExactly(fd, tmp, r)) {
- free(file_buffer);
+ if (S_ISREG(mode)) {
+ write_data_file(sc, lpath, sbuf, show_progress);
+ } else if (S_ISLNK(mode)) {
+ write_data_link(sc, lpath, sbuf);
+ } else {
goto fail;
}
- if (file_buffer) {
- write_data_buffer(fd, file_buffer, size, sbuf, show_progress);
- free(file_buffer);
- } else if (S_ISREG(mode))
- write_data_file(fd, lpath, sbuf, show_progress);
- else if (S_ISLNK(mode))
- write_data_link(fd, lpath, sbuf);
- else
- goto fail;
-
+ syncmsg msg;
msg.data.id = ID_DONE;
msg.data.size = htoll(mtime);
- if(!WriteFdExactly(fd, &msg.data, sizeof(msg.data)))
- goto fail;
+ if (!WriteFdExactly(sc.fd, &msg.data, sizeof(msg.data))) goto fail;
- if(!ReadFdExactly(fd, &msg.status, sizeof(msg.status)))
- return -1;
+ if (!ReadFdExactly(sc.fd, &msg.status, sizeof(msg.status))) goto fail;
- if(msg.status.id != ID_OKAY) {
- if(msg.status.id == ID_FAIL) {
- len = ltohl(msg.status.msglen);
- if(len > 256) len = 256;
- if(!ReadFdExactly(fd, sbuf->data, len)) {
- return -1;
- }
+ if (msg.status.id != ID_OKAY) {
+ if (msg.status.id == ID_FAIL) {
+ size_t len = ltohl(msg.status.msglen);
+ if (len > 256) len = 256;
+ if (!ReadFdExactly(sc.fd, sbuf->data, len)) goto fail;
sbuf->data[len] = 0;
- } else
+ } else {
strcpy(sbuf->data, "unknown reason");
-
- fprintf(stderr,"failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data);
- return -1;
+ }
+ fprintf(stderr, "failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data);
+ return false;
}
- return 0;
+ return true;
fail:
- fprintf(stderr,"protocol failure\n");
- adb_close(fd);
- return -1;
+ fprintf(stderr, "protocol failure\n");
+ return false;
}
-static int sync_recv(int fd, const char* rpath, const char* lpath, bool show_progress) {
+static int sync_recv(SyncConnection& sc, const char* rpath, const char* lpath, bool show_progress) {
syncmsg msg;
- int len;
int lfd = -1;
char *buffer = send_buffer.data;
unsigned id;
- unsigned long long size = 0;
- len = strlen(rpath);
- if(len > 1024) return -1;
+ size_t len = strlen(rpath);
+ if (len > 1024) return -1;
+ unsigned size = 0;
if (show_progress) {
- // Determine remote file size.
- syncmsg stat_msg;
- stat_msg.req.id = ID_STAT;
- stat_msg.req.namelen = htoll(len);
-
- if (!WriteFdExactly(fd, &stat_msg.req, sizeof(stat_msg.req)) ||
- !WriteFdExactly(fd, rpath, len)) {
- return -1;
- }
-
- if (!ReadFdExactly(fd, &stat_msg.stat, sizeof(stat_msg.stat))) {
- return -1;
- }
-
- if (stat_msg.stat.id != ID_STAT) return -1;
-
- size = ltohl(stat_msg.stat.size);
+ if (!sync_stat(sc, rpath, nullptr, nullptr, &size)) return -1;
}
- msg.req.id = ID_RECV;
- msg.req.namelen = htoll(len);
- if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) ||
- !WriteFdExactly(fd, rpath, len)) {
- return -1;
- }
+ if (!SendRequest(sc.fd, ID_RECV, rpath)) return -1;
+ if (!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) return -1;
- if(!ReadFdExactly(fd, &msg.data, sizeof(msg.data))) {
- return -1;
- }
id = msg.data.id;
- if((id == ID_DATA) || (id == ID_DONE)) {
+ if (id == ID_DATA || id == ID_DONE) {
adb_unlink(lpath);
mkdirs(lpath);
lfd = adb_creat(lpath, 0644);
if(lfd < 0) {
- fprintf(stderr,"cannot create '%s': %s\n", lpath, strerror(errno));
+ fprintf(stderr, "cannot create '%s': %s\n", lpath, strerror(errno));
return -1;
}
goto handle_data;
@@ -446,37 +326,37 @@
goto remote_error;
}
- for(;;) {
- if(!ReadFdExactly(fd, &msg.data, sizeof(msg.data))) {
+ while (true) {
+ if(!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) {
return -1;
}
id = msg.data.id;
handle_data:
len = ltohl(msg.data.size);
- if(id == ID_DONE) break;
- if(id != ID_DATA) goto remote_error;
- if(len > SYNC_DATA_MAX) {
- fprintf(stderr,"data overrun\n");
+ if (id == ID_DONE) break;
+ if (id != ID_DATA) goto remote_error;
+ if (len > sc.max) {
+ fprintf(stderr, "msg.data.size too large: %zu (max %zu)\n", len, sc.max);
adb_close(lfd);
return -1;
}
- if(!ReadFdExactly(fd, buffer, len)) {
+ if(!ReadFdExactly(sc.fd, buffer, len)) {
adb_close(lfd);
return -1;
}
if(!WriteFdExactly(lfd, buffer, len)) {
- fprintf(stderr,"cannot write '%s': %s\n", rpath, strerror(errno));
+ fprintf(stderr, "cannot write '%s': %s\n", rpath, strerror(errno));
adb_close(lfd);
return -1;
}
- total_bytes += len;
+ sc.total_bytes += len;
if (show_progress) {
- print_transfer_progress(total_bytes, size);
+ print_transfer_progress(sc.total_bytes, size);
}
}
@@ -490,7 +370,7 @@
if(id == ID_FAIL) {
len = ltohl(msg.data.size);
if(len > 256) len = 256;
- if(!ReadFdExactly(fd, buffer, len)) {
+ if(!ReadFdExactly(sc.fd, buffer, len)) {
return -1;
}
buffer[len] = 0;
@@ -498,31 +378,20 @@
memcpy(buffer, &id, 4);
buffer[4] = 0;
}
- fprintf(stderr,"failed to copy '%s' to '%s': %s\n", rpath, lpath, buffer);
+ fprintf(stderr, "failed to copy '%s' to '%s': %s\n", rpath, lpath, buffer);
return 0;
}
-/* --- */
static void do_sync_ls_cb(unsigned mode, unsigned size, unsigned time,
- const char *name, void *cookie)
-{
+ const char* name, void* /*cookie*/) {
printf("%08x %08x %08x %s\n", mode, size, time, name);
}
-int do_sync_ls(const char* path) {
- std::string error;
- int fd = adb_connect("sync:", &error);
- if (fd < 0) {
- fprintf(stderr,"error: %s\n", error.c_str());
- return 1;
- }
+bool do_sync_ls(const char* path) {
+ SyncConnection sc;
+ if (!sc.IsValid()) return false;
- if (sync_ls(fd, path, do_sync_ls_cb, 0)) {
- return 1;
- }
-
- sync_quit(fd);
- return 0;
+ return sync_ls(sc.fd, path, do_sync_ls_cb, 0);
}
struct copyinfo
@@ -545,7 +414,7 @@
copyinfo *ci = reinterpret_cast<copyinfo*>(malloc(sizeof(copyinfo) + ssize + dsize));
if(ci == 0) {
- fprintf(stderr,"out of memory\n");
+ fprintf(stderr, "out of memory\n");
abort();
}
@@ -562,54 +431,41 @@
return ci;
}
+static bool IsDotOrDotDot(const char* name) {
+ return name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'));
+}
-static int local_build_list(copyinfo **filelist,
- const char *lpath, const char *rpath)
-{
- DIR *d;
- struct dirent *de;
- struct stat st;
+static int local_build_list(copyinfo** filelist, const char* lpath, const char* rpath) {
copyinfo *dirlist = 0;
copyinfo *ci, *next;
- d = opendir(lpath);
- if(d == 0) {
- fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno));
+ std::unique_ptr<DIR, int(*)(DIR*)> dir(opendir(lpath), closedir);
+ if (!dir) {
+ fprintf(stderr, "cannot open '%s': %s\n", lpath, strerror(errno));
return -1;
}
- while((de = readdir(d))) {
+ dirent *de;
+ while ((de = readdir(dir.get()))) {
+ if (IsDotOrDotDot(de->d_name)) continue;
+
char stat_path[PATH_MAX];
- char *name = de->d_name;
-
- if(name[0] == '.') {
- if(name[1] == 0) continue;
- if((name[1] == '.') && (name[2] == 0)) continue;
- }
-
- /*
- * We could use d_type if HAVE_DIRENT_D_TYPE is defined, but reiserfs
- * always returns DT_UNKNOWN, so we just use stat() for all cases.
- */
- if (strlen(lpath) + strlen(de->d_name) + 1 > sizeof(stat_path))
+ if (strlen(lpath) + strlen(de->d_name) + 1 > sizeof(stat_path)) {
+ fprintf(stderr, "skipping long path '%s%s'\n", lpath, de->d_name);
continue;
+ }
strcpy(stat_path, lpath);
strcat(stat_path, de->d_name);
- if(!lstat(stat_path, &st)) {
+ struct stat st;
+ if (!lstat(stat_path, &st)) {
if (S_ISDIR(st.st_mode)) {
- ci = mkcopyinfo(lpath, rpath, name, 1);
+ ci = mkcopyinfo(lpath, rpath, de->d_name, 1);
ci->next = dirlist;
dirlist = ci;
} else {
- ci = mkcopyinfo(lpath, rpath, name, 0);
- if(lstat(ci->src, &st)) {
- fprintf(stderr,"cannot stat '%s': %s\n", ci->src, strerror(errno));
- free(ci);
- closedir(d);
- return -1;
- }
- if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
+ ci = mkcopyinfo(lpath, rpath, de->d_name, 0);
+ if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
fprintf(stderr, "skipping special file '%s'\n", ci->src);
free(ci);
} else {
@@ -625,9 +481,9 @@
}
}
- closedir(d);
-
- for(ci = dirlist; ci != 0; ci = next) {
+ // Close this directory and recurse.
+ dir.reset();
+ for (ci = dirlist; ci != 0; ci = next) {
next = ci->next;
local_build_list(filelist, ci->src, ci->dst);
free(ci);
@@ -636,60 +492,55 @@
return 0;
}
-
-static int copy_local_dir_remote(int fd, const char *lpath, const char *rpath, int checktimestamps, int listonly)
-{
+static bool copy_local_dir_remote(SyncConnection& sc, const char* lpath, const char* rpath,
+ bool check_timestamps, bool list_only) {
copyinfo *filelist = 0;
copyinfo *ci, *next;
int pushed = 0;
int skipped = 0;
- if((lpath[0] == 0) || (rpath[0] == 0)) return -1;
- if(lpath[strlen(lpath) - 1] != '/') {
+ if ((lpath[0] == 0) || (rpath[0] == 0)) return false;
+ if (lpath[strlen(lpath) - 1] != '/') {
int tmplen = strlen(lpath)+2;
char *tmp = reinterpret_cast<char*>(malloc(tmplen));
- if(tmp == 0) return -1;
+ if(tmp == 0) return false;
snprintf(tmp, tmplen, "%s/",lpath);
lpath = tmp;
}
- if(rpath[strlen(rpath) - 1] != '/') {
+ if (rpath[strlen(rpath) - 1] != '/') {
int tmplen = strlen(rpath)+2;
char *tmp = reinterpret_cast<char*>(malloc(tmplen));
- if(tmp == 0) return -1;
+ if(tmp == 0) return false;
snprintf(tmp, tmplen, "%s/",rpath);
rpath = tmp;
}
- if(local_build_list(&filelist, lpath, rpath)) {
- return -1;
+ if (local_build_list(&filelist, lpath, rpath)) {
+ return false;
}
- if(checktimestamps){
- for(ci = filelist; ci != 0; ci = ci->next) {
- if(sync_start_readtime(fd, ci->dst)) {
- return 1;
- }
+ if (check_timestamps) {
+ for (ci = filelist; ci != 0; ci = ci->next) {
+ if (!sync_start_stat(sc, ci->dst)) return false;
}
for(ci = filelist; ci != 0; ci = ci->next) {
unsigned int timestamp, mode, size;
- if(sync_finish_readtime(fd, ×tamp, &mode, &size))
- return 1;
- if(size == ci->size) {
+ if (!sync_finish_stat(sc, ×tamp, &mode, &size)) return false;
+ if (size == ci->size) {
/* for links, we cannot update the atime/mtime */
- if((S_ISREG(ci->mode & mode) && timestamp == ci->time) ||
- (S_ISLNK(ci->mode & mode) && timestamp >= ci->time))
+ if ((S_ISREG(ci->mode & mode) && timestamp == ci->time) ||
+ (S_ISLNK(ci->mode & mode) && timestamp >= ci->time)) {
ci->flag = 1;
+ }
}
}
}
- for(ci = filelist; ci != 0; ci = next) {
+ for (ci = filelist; ci != 0; ci = next) {
next = ci->next;
- if(ci->flag == 0) {
- fprintf(stderr,"%spush: %s -> %s\n", listonly ? "would " : "", ci->src, ci->dst);
- if(!listonly &&
- sync_send(fd, ci->src, ci->dst, ci->time, ci->mode,
- 0 /* no show progress */)) {
- return 1;
+ if (ci->flag == 0) {
+ fprintf(stderr, "%spush: %s -> %s\n", list_only ? "would " : "", ci->src, ci->dst);
+ if (!list_only && !sync_send(sc, ci->src, ci->dst, ci->time, ci->mode, false)) {
+ return false;
}
pushed++;
} else {
@@ -698,55 +549,37 @@
free(ci);
}
- fprintf(stderr,"%d file%s pushed. %d file%s skipped.\n",
+ fprintf(stderr, "%d file%s pushed. %d file%s skipped.\n",
pushed, (pushed == 1) ? "" : "s",
skipped, (skipped == 1) ? "" : "s");
- return 0;
+ return true;
}
-
-int do_sync_push(const char* lpath, const char* rpath, bool show_progress) {
- std::string error;
- int fd = adb_connect("sync:", &error);
- if (fd < 0) {
- fprintf(stderr,"error: %s\n", error.c_str());
- return 1;
- }
+bool do_sync_push(const char* lpath, const char* rpath, bool show_progress) {
+ SyncConnection sc;
+ if (!sc.IsValid()) return false;
struct stat st;
if (stat(lpath, &st)) {
- fprintf(stderr,"cannot stat '%s': %s\n", lpath, strerror(errno));
- sync_quit(fd);
- return 1;
+ fprintf(stderr, "cannot stat '%s': %s\n", lpath, strerror(errno));
+ return false;
}
if (S_ISDIR(st.st_mode)) {
- BEGIN();
- if (copy_local_dir_remote(fd, lpath, rpath, 0, 0)) {
- return 1;
- }
- } else {
- unsigned mode;
- if (sync_readmode(fd, rpath, &mode)) {
- return 1;
- }
- std::string path_holder;
- if ((mode != 0) && S_ISDIR(mode)) {
- // If we're copying a local file to a remote directory,
- // we really want to copy to remote_dir + "/" + local_filename.
- path_holder = android::base::StringPrintf("%s/%s", rpath, adb_basename(lpath).c_str());
- rpath = path_holder.c_str();
- }
- BEGIN();
- if (sync_send(fd, lpath, rpath, st.st_mtime, st.st_mode, show_progress)) {
- return 1;
- }
+ return copy_local_dir_remote(sc, lpath, rpath, false, false);
}
- END();
- sync_quit(fd);
- return 0;
+ unsigned mode;
+ if (!sync_stat(sc, rpath, nullptr, &mode, nullptr)) return false;
+ std::string path_holder;
+ if (mode != 0 && S_ISDIR(mode)) {
+ // If we're copying a local file to a remote directory,
+ // we really want to copy to remote_dir + "/" + local_filename.
+ path_holder = android::base::StringPrintf("%s/%s", rpath, adb_basename(lpath).c_str());
+ rpath = path_holder.c_str();
+ }
+ return sync_send(sc, lpath, rpath, st.st_mtime, st.st_mode, show_progress);
}
@@ -766,11 +599,8 @@
if (S_ISDIR(mode)) {
copyinfo **dirlist = args->dirlist;
- /* Don't try recursing down "." or ".." */
- if (name[0] == '.') {
- if (name[1] == '\0') return;
- if ((name[1] == '.') && (name[2] == '\0')) return;
- }
+ // Don't try recursing down "." or "..".
+ if (IsDotOrDotDot(name)) return;
ci = mkcopyinfo(args->rpath, args->lpath, name, 1);
ci->next = *dirlist;
@@ -789,9 +619,8 @@
}
}
-static int remote_build_list(int syncfd, copyinfo **filelist,
- const char *rpath, const char *lpath)
-{
+static bool remote_build_list(int syncfd, copyinfo **filelist,
+ const char *rpath, const char *lpath) {
copyinfo *dirlist = NULL;
sync_ls_build_list_cb_args args;
@@ -800,22 +629,22 @@
args.rpath = rpath;
args.lpath = lpath;
- /* Put the files/dirs in rpath on the lists. */
- if (sync_ls(syncfd, rpath, sync_ls_build_list_cb, (void *)&args)) {
- return 1;
+ // Put the files/dirs in rpath on the lists.
+ if (!sync_ls(syncfd, rpath, sync_ls_build_list_cb, (void *)&args)) {
+ return false;
}
- /* Recurse into each directory we found. */
+ // Recurse into each directory we found.
while (dirlist != NULL) {
copyinfo *next = dirlist->next;
- if (remote_build_list(syncfd, filelist, dirlist->src, dirlist->dst)) {
- return 1;
+ if (!remote_build_list(syncfd, filelist, dirlist->src, dirlist->dst)) {
+ return false;
}
free(dirlist);
dirlist = next;
}
- return 0;
+ return true;
}
static int set_time_and_mode(const char *lpath, time_t time, unsigned int mode)
@@ -831,101 +660,57 @@
return r1 ? : r2;
}
-/* Return a copy of the path string with / appended if needed */
-static char *add_slash_to_path(const char *path)
-{
- if (path[strlen(path) - 1] != '/') {
- size_t len = strlen(path) + 2;
- char *path_with_slash = reinterpret_cast<char*>(malloc(len));
- if (path_with_slash == NULL)
- return NULL;
- snprintf(path_with_slash, len, "%s/", path);
- return path_with_slash;
- } else {
- return strdup(path);
- }
-}
+static bool copy_remote_dir_local(SyncConnection& sc, const char* rpath, const char* lpath,
+ int copy_attrs) {
+ // Make sure that both directory paths end in a slash.
+ std::string rpath_clean(rpath);
+ std::string lpath_clean(lpath);
+ if (rpath_clean.empty() || lpath_clean.empty()) return false;
+ if (rpath_clean.back() != '/') rpath_clean.push_back('/');
+ if (lpath_clean.back() != '/') lpath_clean.push_back('/');
-static int copy_remote_dir_local(int fd, const char *rpath, const char *lpath,
- int copy_attrs)
-{
- copyinfo *filelist = 0;
- copyinfo *ci, *next;
+ // Recursively build the list of files to copy.
+ fprintf(stderr, "pull: building file list...\n");
+ copyinfo* filelist = nullptr;
+ if (!remote_build_list(sc.fd, &filelist, rpath_clean.c_str(), lpath_clean.c_str())) return false;
+
int pulled = 0;
int skipped = 0;
- char *rpath_clean = NULL;
- char *lpath_clean = NULL;
- int ret = 0;
-
- if (rpath[0] == '\0' || lpath[0] == '\0') {
- ret = -1;
- goto finish;
- }
-
- /* Make sure that both directory paths end in a slash. */
- rpath_clean = add_slash_to_path(rpath);
- if (!rpath_clean) {
- ret = -1;
- goto finish;
- }
- lpath_clean = add_slash_to_path(lpath);
- if (!lpath_clean) {
- ret = -1;
- goto finish;
- }
-
- /* Recursively build the list of files to copy. */
- fprintf(stderr, "pull: building file list...\n");
- if (remote_build_list(fd, &filelist, rpath_clean, lpath_clean)) {
- ret = -1;
- goto finish;
- }
-
- for (ci = filelist; ci != 0; ci = next) {
- next = ci->next;
+ copyinfo* ci = filelist;
+ while (ci) {
+ copyinfo* next = ci->next;
if (ci->flag == 0) {
fprintf(stderr, "pull: %s -> %s\n", ci->src, ci->dst);
- if (sync_recv(fd, ci->src, ci->dst, 0 /* no show progress */)) {
- ret = -1;
- goto finish;
+ if (sync_recv(sc, ci->src, ci->dst, false)) {
+ return false;
}
if (copy_attrs && set_time_and_mode(ci->dst, ci->time, ci->mode)) {
- ret = -1;
- goto finish;
+ return false;
}
pulled++;
} else {
skipped++;
}
free(ci);
+ ci = next;
}
fprintf(stderr, "%d file%s pulled. %d file%s skipped.\n",
pulled, (pulled == 1) ? "" : "s",
skipped, (skipped == 1) ? "" : "s");
-
-finish:
- free(lpath_clean);
- free(rpath_clean);
- return ret;
+ return true;
}
-int do_sync_pull(const char* rpath, const char* lpath, bool show_progress, int copy_attrs) {
- std::string error;
- int fd = adb_connect("sync:", &error);
- if (fd < 0) {
- fprintf(stderr,"error: %s\n", error.c_str());
- return 1;
- }
+bool do_sync_pull(const char* rpath, const char* lpath, bool show_progress, int copy_attrs) {
+ SyncConnection sc;
+ if (!sc.IsValid()) return false;
unsigned mode, time;
- if (sync_readtime(fd, rpath, &time, &mode)) {
- return 1;
- }
+ if (!sync_stat(sc, rpath, &time, &mode, nullptr)) return false;
if (mode == 0) {
- fprintf(stderr,"remote object '%s' does not exist\n", rpath);
- return 1;
+ fprintf(stderr, "remote object '%s' does not exist\n", rpath);
+ return false;
}
if (S_ISREG(mode) || S_ISLNK(mode) || S_ISCHR(mode) || S_ISBLK(mode)) {
@@ -939,44 +724,27 @@
lpath = path_holder.c_str();
}
}
- BEGIN();
- if (sync_recv(fd, rpath, lpath, show_progress)) {
- return 1;
+ if (sync_recv(sc, rpath, lpath, show_progress)) {
+ return false;
} else {
if (copy_attrs && set_time_and_mode(lpath, time, mode)) {
- return 1;
+ return false;
}
}
- } else if(S_ISDIR(mode)) {
- BEGIN();
- if (copy_remote_dir_local(fd, rpath, lpath, copy_attrs)) {
- return 1;
- }
- } else {
- fprintf(stderr,"remote object '%s' not a file or directory\n", rpath);
- return 1;
+ return true;
+ } else if (S_ISDIR(mode)) {
+ return copy_remote_dir_local(sc, rpath, lpath, copy_attrs);
}
- END();
- sync_quit(fd);
- return 0;
+
+ fprintf(stderr, "remote object '%s' not a file or directory\n", rpath);
+ return false;
}
-int do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only)
-{
+bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only) {
fprintf(stderr, "syncing %s...\n", rpath.c_str());
- std::string error;
- int fd = adb_connect("sync:", &error);
- if (fd < 0) {
- fprintf(stderr, "error: %s\n", error.c_str());
- return 1;
- }
+ SyncConnection sc;
+ if (!sc.IsValid()) return false;
- BEGIN();
- if (copy_local_dir_remote(fd, lpath.c_str(), rpath.c_str(), 1, list_only)) {
- return 1;
- }
- END();
- sync_quit(fd);
- return 0;
+ return copy_local_dir_remote(sc, lpath.c_str(), rpath.c_str(), true, list_only);
}
diff --git a/file_sync_service.cpp b/file_sync_service.cpp
index ea019f4..1323d83 100644
--- a/file_sync_service.cpp
+++ b/file_sync_service.cpp
@@ -34,6 +34,7 @@
#include "adb_io.h"
#include "private/android_filesystem_config.h"
+#include <base/stringprintf.h>
#include <base/strings.h>
static bool should_use_fs_config(const std::string& path) {
@@ -76,38 +77,23 @@
return true;
}
-static int do_stat(int s, const char *path)
-{
+static bool do_stat(int s, const char* path) {
syncmsg msg;
- struct stat st;
-
msg.stat.id = ID_STAT;
- if(lstat(path, &st)) {
- msg.stat.mode = 0;
- msg.stat.size = 0;
- msg.stat.time = 0;
- } else {
- msg.stat.mode = htoll(st.st_mode);
- msg.stat.size = htoll(st.st_size);
- msg.stat.time = htoll(st.st_mtime);
- }
+ struct stat st;
+ memset(&st, 0, sizeof(st));
+ // TODO: add a way to report that the stat failed!
+ lstat(path, &st);
+ msg.stat.mode = htoll(st.st_mode);
+ msg.stat.size = htoll(st.st_size);
+ msg.stat.time = htoll(st.st_mtime);
- return WriteFdExactly(s, &msg.stat, sizeof(msg.stat)) ? 0 : -1;
+ return WriteFdExactly(s, &msg.stat, sizeof(msg.stat));
}
-static int do_list(int s, const char *path)
-{
- struct dirent *de;
- struct stat st;
-
- char tmp[1024 + 256 + 1];
- char *fname;
-
- size_t len = strlen(path);
- memcpy(tmp, path, len);
- tmp[len] = '/';
- fname = tmp + len + 1;
+static bool do_list(int s, const char* path) {
+ dirent* de;
syncmsg msg;
msg.dent.id = ID_DENT;
@@ -116,22 +102,19 @@
if (!d) goto done;
while ((de = readdir(d.get()))) {
- int len = strlen(de->d_name);
+ std::string filename(android::base::StringPrintf("%s/%s", path, de->d_name));
- /* not supposed to be possible, but
- if it does happen, let's not buffer overrun */
- if(len > 256) continue;
-
- strcpy(fname, de->d_name);
- if(lstat(tmp, &st) == 0) {
+ struct stat st;
+ if (lstat(filename.c_str(), &st) == 0) {
+ size_t d_name_length = strlen(de->d_name);
msg.dent.mode = htoll(st.st_mode);
msg.dent.size = htoll(st.st_size);
msg.dent.time = htoll(st.st_mtime);
- msg.dent.namelen = htoll(len);
+ msg.dent.namelen = htoll(d_name_length);
- if(!WriteFdExactly(s, &msg.dent, sizeof(msg.dent)) ||
- !WriteFdExactly(s, de->d_name, len)) {
- return -1;
+ if (!WriteFdExactly(s, &msg.dent, sizeof(msg.dent)) ||
+ !WriteFdExactly(s, de->d_name, d_name_length)) {
+ return false;
}
}
}
@@ -142,43 +125,33 @@
msg.dent.size = 0;
msg.dent.time = 0;
msg.dent.namelen = 0;
- return WriteFdExactly(s, &msg.dent, sizeof(msg.dent)) ? 0 : -1;
+ return WriteFdExactly(s, &msg.dent, sizeof(msg.dent));
}
-static int fail_message(int s, const char *reason)
-{
+static bool fail_message(int s, const std::string& reason) {
+ D("sync: failure: %s\n", reason.c_str());
+
syncmsg msg;
- int len = strlen(reason);
-
- D("sync: failure: %s\n", reason);
-
msg.data.id = ID_FAIL;
- msg.data.size = htoll(len);
- if(!WriteFdExactly(s, &msg.data, sizeof(msg.data)) ||
- !WriteFdExactly(s, reason, len)) {
- return -1;
- } else {
- return 0;
- }
+ msg.data.size = htoll(reason.size());
+ return WriteFdExactly(s, &msg.data, sizeof(msg.data)) && WriteFdExactly(s, reason);
}
-static int fail_errno(int s)
-{
+// TODO: callers of this have already failed, and should probably ignore its
+// return value (http://b/23437039).
+static bool fail_errno(int s) {
return fail_message(s, strerror(errno));
}
-static int handle_send_file(int s, char *path, uid_t uid,
- gid_t gid, mode_t mode, char *buffer, bool do_unlink)
-{
+static bool handle_send_file(int s, char *path, uid_t uid,
+ gid_t gid, mode_t mode, std::vector<char>& buffer, bool do_unlink) {
syncmsg msg;
unsigned int timestamp = 0;
- int fd;
- fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode);
+ int fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode);
if(fd < 0 && errno == ENOENT) {
if (!secure_mkdirs(path)) {
- if(fail_errno(s))
- return -1;
+ if (fail_errno(s)) return false;
fd = -1;
} else {
fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode);
@@ -188,8 +161,7 @@
fd = adb_open_mode(path, O_WRONLY | O_CLOEXEC, mode);
}
if(fd < 0) {
- if(fail_errno(s))
- return -1;
+ if (fail_errno(s)) return false;
fd = -1;
} else {
if(fchown(fd, uid, gid) != 0) {
@@ -205,7 +177,7 @@
fchmod(fd, mode);
}
- for(;;) {
+ while (true) {
unsigned int len;
if(!ReadFdExactly(s, &msg.data, sizeof(msg.data)))
@@ -220,22 +192,21 @@
goto fail;
}
len = ltohl(msg.data.size);
- if(len > SYNC_DATA_MAX) {
+ if (len > buffer.size()) { // TODO: resize buffer?
fail_message(s, "oversize data message");
goto fail;
}
- if(!ReadFdExactly(s, buffer, len))
- goto fail;
+ if (!ReadFdExactly(s, &buffer[0], len)) goto fail;
- if(fd < 0)
- continue;
- if(!WriteFdExactly(fd, buffer, len)) {
+ if (fd < 0) continue;
+
+ if (!WriteFdExactly(fd, &buffer[0], len)) {
int saved_errno = errno;
adb_close(fd);
if (do_unlink) adb_unlink(path);
fd = -1;
errno = saved_errno;
- if(fail_errno(s)) return -1;
+ if (fail_errno(s)) return false;
}
}
@@ -249,75 +220,67 @@
msg.status.id = ID_OKAY;
msg.status.msglen = 0;
- if(!WriteFdExactly(s, &msg.status, sizeof(msg.status)))
- return -1;
+ if (!WriteFdExactly(s, &msg.status, sizeof(msg.status))) return false;
}
- return 0;
+ return true;
fail:
- if(fd >= 0)
- adb_close(fd);
+ if (fd >= 0) adb_close(fd);
if (do_unlink) adb_unlink(path);
- return -1;
+ return false;
}
#if defined(_WIN32)
-extern int handle_send_link(int s, char *path, char *buffer) __attribute__((error("no symlinks on Windows")));
+extern bool handle_send_link(int s, char *path, std::vector<char>& buffer) __attribute__((error("no symlinks on Windows")));
#else
-static int handle_send_link(int s, char *path, char *buffer)
-{
+static bool handle_send_link(int s, char *path, std::vector<char>& buffer) {
syncmsg msg;
unsigned int len;
int ret;
- if(!ReadFdExactly(s, &msg.data, sizeof(msg.data)))
- return -1;
+ if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) return false;
- if(msg.data.id != ID_DATA) {
+ if (msg.data.id != ID_DATA) {
fail_message(s, "invalid data message: expected ID_DATA");
- return -1;
+ return false;
}
len = ltohl(msg.data.size);
- if(len > SYNC_DATA_MAX) {
+ if (len > buffer.size()) { // TODO: resize buffer?
fail_message(s, "oversize data message");
- return -1;
+ return false;
}
- if(!ReadFdExactly(s, buffer, len))
- return -1;
+ if (!ReadFdExactly(s, &buffer[0], len)) return false;
- ret = symlink(buffer, path);
- if(ret && errno == ENOENT) {
+ ret = symlink(&buffer[0], path);
+ if (ret && errno == ENOENT) {
if (!secure_mkdirs(path)) {
fail_errno(s);
- return -1;
+ return false;
}
- ret = symlink(buffer, path);
+ ret = symlink(&buffer[0], path);
}
- if(ret) {
+ if (ret) {
fail_errno(s);
- return -1;
+ return false;
}
- if(!ReadFdExactly(s, &msg.data, sizeof(msg.data)))
- return -1;
+ if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) return false;
- if(msg.data.id == ID_DONE) {
+ if (msg.data.id == ID_DONE) {
msg.status.id = ID_OKAY;
msg.status.msglen = 0;
- if(!WriteFdExactly(s, &msg.status, sizeof(msg.status)))
- return -1;
+ if (!WriteFdExactly(s, &msg.status, sizeof(msg.status))) return false;
} else {
fail_message(s, "invalid data message: expected ID_DONE");
- return -1;
+ return false;
}
- return 0;
+ return true;
}
#endif
-static int do_send(int s, char *path, char *buffer)
-{
+static bool do_send(int s, char* path, std::vector<char>& buffer) {
unsigned int mode;
bool is_link = false;
bool do_unlink;
@@ -365,32 +328,28 @@
return handle_send_file(s, path, uid, gid, mode, buffer, do_unlink);
}
-static int do_recv(int s, const char *path, char *buffer)
-{
- syncmsg msg;
- int fd, r;
-
- fd = adb_open(path, O_RDONLY | O_CLOEXEC);
- if(fd < 0) {
- if(fail_errno(s)) return -1;
- return 0;
+static bool do_recv(int s, const char* path, std::vector<char>& buffer) {
+ int fd = adb_open(path, O_RDONLY | O_CLOEXEC);
+ if (fd < 0) {
+ if (fail_errno(s)) return false;
+ return true;
}
+ syncmsg msg;
msg.data.id = ID_DATA;
- for(;;) {
- r = adb_read(fd, buffer, SYNC_DATA_MAX);
- if(r <= 0) {
- if(r == 0) break;
- if(errno == EINTR) continue;
- r = fail_errno(s);
+ while (true) {
+ int r = adb_read(fd, &buffer[0], buffer.size());
+ if (r <= 0) {
+ if (r == 0) break;
+ if (errno == EINTR) continue;
+ bool status = fail_errno(s);
adb_close(fd);
- return r;
+ return status;
}
msg.data.size = htoll(r);
- if(!WriteFdExactly(s, &msg.data, sizeof(msg.data)) ||
- !WriteFdExactly(s, buffer, r)) {
+ if (!WriteFdExactly(s, &msg.data, sizeof(msg.data)) || !WriteFdExactly(s, &buffer[0], r)) {
adb_close(fd);
- return -1;
+ return false;
}
}
@@ -398,66 +357,62 @@
msg.data.id = ID_DONE;
msg.data.size = 0;
- if(!WriteFdExactly(s, &msg.data, sizeof(msg.data))) {
- return -1;
- }
-
- return 0;
+ return WriteFdExactly(s, &msg.data, sizeof(msg.data));
}
-void file_sync_service(int fd, void *cookie)
-{
- syncmsg msg;
+static bool handle_sync_command(int fd, std::vector<char>& buffer) {
+ D("sync: waiting for request\n");
+
+ SyncRequest request;
+ if (!ReadFdExactly(fd, &request, sizeof(request))) {
+ fail_message(fd, "command read failure");
+ return false;
+ }
+ size_t path_length = ltohl(request.path_length);
+ if (path_length > 1024) {
+ fail_message(fd, "path too long");
+ return false;
+ }
char name[1025];
- unsigned namelen;
+ if (!ReadFdExactly(fd, name, path_length)) {
+ fail_message(fd, "filename read failure");
+ return false;
+ }
+ name[path_length] = 0;
- char *buffer = reinterpret_cast<char*>(malloc(SYNC_DATA_MAX));
- if(buffer == 0) goto fail;
+ const char* id = reinterpret_cast<const char*>(&request.id);
+ D("sync: '%.4s' '%s'\n", id, name);
- for(;;) {
- D("sync: waiting for command\n");
-
- if(!ReadFdExactly(fd, &msg.req, sizeof(msg.req))) {
- fail_message(fd, "command read failure");
- break;
- }
- namelen = ltohl(msg.req.namelen);
- if(namelen > 1024) {
- fail_message(fd, "invalid namelen");
- break;
- }
- if(!ReadFdExactly(fd, name, namelen)) {
- fail_message(fd, "filename read failure");
- break;
- }
- name[namelen] = 0;
-
- msg.req.namelen = 0;
- D("sync: '%s' '%s'\n", (char*) &msg.req, name);
-
- switch(msg.req.id) {
- case ID_STAT:
- if(do_stat(fd, name)) goto fail;
- break;
- case ID_LIST:
- if(do_list(fd, name)) goto fail;
- break;
- case ID_SEND:
- if(do_send(fd, name, buffer)) goto fail;
- break;
- case ID_RECV:
- if(do_recv(fd, name, buffer)) goto fail;
- break;
- case ID_QUIT:
- goto fail;
- default:
- fail_message(fd, "unknown command");
- goto fail;
- }
+ switch (request.id) {
+ case ID_STAT:
+ if (!do_stat(fd, name)) return false;
+ break;
+ case ID_LIST:
+ if (!do_list(fd, name)) return false;
+ break;
+ case ID_SEND:
+ if (!do_send(fd, name, buffer)) return false;
+ break;
+ case ID_RECV:
+ if (!do_recv(fd, name, buffer)) return false;
+ break;
+ case ID_QUIT:
+ return false;
+ default:
+ fail_message(fd, android::base::StringPrintf("unknown command '%.4s' (%08x)",
+ id, request.id));
+ return false;
}
-fail:
- if(buffer != 0) free(buffer);
+ return true;
+}
+
+void file_sync_service(int fd, void* cookie) {
+ std::vector<char> buffer(SYNC_DATA_MAX);
+
+ while (handle_sync_command(fd, buffer)) {
+ }
+
D("sync: done\n");
adb_close(fd);
}
diff --git a/file_sync_service.h b/file_sync_service.h
index 1d3e3bd..c0df075 100644
--- a/file_sync_service.h
+++ b/file_sync_service.h
@@ -26,7 +26,6 @@
#define ID_STAT MKID('S','T','A','T')
#define ID_LIST MKID('L','I','S','T')
-#define ID_ULNK MKID('U','L','N','K')
#define ID_SEND MKID('S','E','N','D')
#define ID_RECV MKID('R','E','C','V')
#define ID_DENT MKID('D','E','N','T')
@@ -36,41 +35,41 @@
#define ID_FAIL MKID('F','A','I','L')
#define ID_QUIT MKID('Q','U','I','T')
+struct SyncRequest {
+ uint32_t id; // ID_STAT, et cetera.
+ uint32_t path_length; // <= 1024
+ // Followed by 'path_length' bytes of path (not NUL-terminated).
+} __attribute__((packed)) ;
+
union syncmsg {
- unsigned id;
- struct {
- unsigned id;
- unsigned namelen;
- } req;
- struct {
+ struct __attribute__((packed)) {
unsigned id;
unsigned mode;
unsigned size;
unsigned time;
} stat;
- struct {
+ struct __attribute__((packed)) {
unsigned id;
unsigned mode;
unsigned size;
unsigned time;
unsigned namelen;
} dent;
- struct {
+ struct __attribute__((packed)) {
unsigned id;
unsigned size;
} data;
- struct {
+ struct __attribute__((packed)) {
unsigned id;
unsigned msglen;
} status;
-} ;
+};
-
-void file_sync_service(int fd, void *cookie);
-int do_sync_ls(const char *path);
-int do_sync_push(const char *lpath, const char *rpath, bool show_progress);
-int do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only);
-int do_sync_pull(const char *rpath, const char *lpath, bool show_progress, int pullTime);
+void file_sync_service(int fd, void* cookie);
+bool do_sync_ls(const char* path);
+bool do_sync_push(const char* lpath, const char* rpath, bool show_progress);
+bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only);
+bool do_sync_pull(const char* rpath, const char* lpath, bool show_progress, int copy_attrs);
#define SYNC_DATA_MAX (64*1024)
diff --git a/services.cpp b/services.cpp
index 255be09..c8c2d54 100644
--- a/services.cpp
+++ b/services.cpp
@@ -438,8 +438,7 @@
}
#endif
-int service_to_fd(const char *name)
-{
+int service_to_fd(const char* name) {
int ret = -1;
if(!strncmp(name, "tcp:", 4)) {
@@ -503,13 +502,11 @@
} else if(!strncmp(name, "unroot:", 7)) {
ret = create_service_thread(restart_unroot_service, NULL);
} else if(!strncmp(name, "backup:", 7)) {
- ret = create_subproc_thread(
- android::base::StringPrintf("/system/bin/bu backup %s",
- (name + 7)).c_str(),
- SubprocessType::kRaw);
- } else if(!strncmp(name, "restore:", 8)) {
- ret = create_subproc_thread("/system/bin/bu restore",
+ ret = create_subproc_thread(android::base::StringPrintf("/system/bin/bu backup %s",
+ (name + 7)).c_str(),
SubprocessType::kRaw);
+ } else if(!strncmp(name, "restore:", 8)) {
+ ret = create_subproc_thread("/system/bin/bu restore", SubprocessType::kRaw);
} else if(!strncmp(name, "tcpip:", 6)) {
int port;
if (sscanf(name + 6, "%d", &port) != 1) {
@@ -667,8 +664,7 @@
#endif
#if ADB_HOST
-asocket* host_service_to_socket(const char* name, const char *serial)
-{
+asocket* host_service_to_socket(const char* name, const char* serial) {
if (!strcmp(name,"track-devices")) {
return create_device_tracker();
} else if (!strncmp(name, "wait-for-", strlen("wait-for-"))) {
diff --git a/transport.cpp b/transport.cpp
index 2ea4d44..ea673f2 100644
--- a/transport.cpp
+++ b/transport.cpp
@@ -865,8 +865,7 @@
}
bool atransport::CanUseFeature(const std::string& feature) const {
- return has_feature(feature) &&
- supported_features().count(feature) > 0;
+ return has_feature(feature) && supported_features().count(feature) > 0;
}
#if ADB_HOST