blob: 2262a93e989bb88a82b727d9c274b2221d63d1c8 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Dan Albert76649012015-02-24 15:51:19 -080017#include <dirent.h>
18#include <errno.h>
Spencer Low6001c872015-05-13 00:02:55 -070019#include <inttypes.h>
Dan Albert76649012015-02-24 15:51:19 -080020#include <limits.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080021#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080024#include <sys/stat.h>
25#include <sys/time.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080026#include <sys/types.h>
Dan Albert76649012015-02-24 15:51:19 -080027#include <time.h>
Elliott Hughesae5a6c02015-09-27 12:55:37 -070028#include <unistd.h>
Greg Hackmann7a5e2bd2014-05-06 08:48:18 -070029#include <utime.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080030
Josh Gaocda6a2b2015-11-02 16:45:47 -080031#include <functional>
Elliott Hughesa925dba2015-08-24 14:49:43 -070032#include <memory>
Elliott Hughes6d929972015-10-27 13:40:35 -070033#include <vector>
Elliott Hughesa925dba2015-08-24 14:49:43 -070034
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080035#include "sysdeps.h"
Dan Albert76649012015-02-24 15:51:19 -080036
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080037#include "adb.h"
38#include "adb_client.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080039#include "adb_io.h"
Alex Vallée14216142015-05-06 17:22:25 -040040#include "adb_utils.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080041#include "file_sync_service.h"
Elliott Hughesb708d162015-10-27 16:03:15 -070042#include "line_printer.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080043
Elliott Hughesae5a6c02015-09-27 12:55:37 -070044#include <base/file.h>
Elliott Hughesaa245492015-08-03 10:38:08 -070045#include <base/strings.h>
Elliott Hughes5c742702015-07-30 17:42:01 -070046#include <base/stringprintf.h>
47
Elliott Hughesaa245492015-08-03 10:38:08 -070048struct syncsendbuf {
49 unsigned id;
50 unsigned size;
51 char data[SYNC_DATA_MAX];
52};
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080053
Elliott Hughesaa245492015-08-03 10:38:08 -070054class SyncConnection {
55 public:
Elliott Hughesb708d162015-10-27 16:03:15 -070056 SyncConnection() : total_bytes(0), start_time_ms_(CurrentTimeMs()) {
Elliott Hughesaa245492015-08-03 10:38:08 -070057 max = SYNC_DATA_MAX; // TODO: decide at runtime.
58
59 std::string error;
60 fd = adb_connect("sync:", &error);
61 if (fd < 0) {
Elliott Hughesb708d162015-10-27 16:03:15 -070062 Error("connect failed: %s", error.c_str());
Elliott Hughesaa245492015-08-03 10:38:08 -070063 }
64 }
65
66 ~SyncConnection() {
67 if (!IsValid()) return;
68
Spencer Low351ecd12015-10-14 17:32:44 -070069 if (SendQuit()) {
70 // We sent a quit command, so the server should be doing orderly
71 // shutdown soon. But if we encountered an error while we were using
72 // the connection, the server might still be sending data (before
73 // doing orderly shutdown), in which case we won't wait for all of
74 // the data nor the coming orderly shutdown. In the common success
75 // case, this will wait for the server to do orderly shutdown.
76 ReadOrderlyShutdown(fd);
77 }
Elliott Hughesaa245492015-08-03 10:38:08 -070078 adb_close(fd);
79 }
80
81 bool IsValid() { return fd >= 0; }
82
Elliott Hughesae5a6c02015-09-27 12:55:37 -070083 bool SendRequest(int id, const char* path_and_mode) {
84 size_t path_length = strlen(path_and_mode);
85 if (path_length > 1024) {
Elliott Hughesb708d162015-10-27 16:03:15 -070086 Error("SendRequest failed: path too long: %zu", path_length);
Elliott Hughesae5a6c02015-09-27 12:55:37 -070087 errno = ENAMETOOLONG;
88 return false;
89 }
90
91 // Sending header and payload in a single write makes a noticeable
92 // difference to "adb sync" performance.
Elliott Hughes6d929972015-10-27 13:40:35 -070093 std::vector<char> buf(sizeof(SyncRequest) + path_length);
94 SyncRequest* req = reinterpret_cast<SyncRequest*>(&buf[0]);
Elliott Hughesae5a6c02015-09-27 12:55:37 -070095 req->id = id;
96 req->path_length = path_length;
97 char* data = reinterpret_cast<char*>(req + 1);
98 memcpy(data, path_and_mode, path_length);
99
Elliott Hughes6d929972015-10-27 13:40:35 -0700100 return WriteFdExactly(fd, &buf[0], buf.size());
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700101 }
102
103 // Sending header, payload, and footer in a single write makes a huge
104 // difference to "adb sync" performance.
105 bool SendSmallFile(const char* path_and_mode,
Elliott Hughesb708d162015-10-27 16:03:15 -0700106 const char* rpath,
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700107 const char* data, size_t data_length,
108 unsigned mtime) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700109 Print(rpath);
110
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700111 size_t path_length = strlen(path_and_mode);
112 if (path_length > 1024) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700113 Error("SendSmallFile failed: path too long: %zu", path_length);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700114 errno = ENAMETOOLONG;
115 return false;
116 }
117
Elliott Hughes6d929972015-10-27 13:40:35 -0700118 std::vector<char> buf(sizeof(SyncRequest) + path_length +
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700119 sizeof(SyncRequest) + data_length +
Elliott Hughes6d929972015-10-27 13:40:35 -0700120 sizeof(SyncRequest));
121 char* p = &buf[0];
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700122
123 SyncRequest* req_send = reinterpret_cast<SyncRequest*>(p);
124 req_send->id = ID_SEND;
125 req_send->path_length = path_length;
126 p += sizeof(SyncRequest);
127 memcpy(p, path_and_mode, path_length);
128 p += path_length;
129
130 SyncRequest* req_data = reinterpret_cast<SyncRequest*>(p);
131 req_data->id = ID_DATA;
132 req_data->path_length = data_length;
133 p += sizeof(SyncRequest);
134 memcpy(p, data, data_length);
135 p += data_length;
136
137 SyncRequest* req_done = reinterpret_cast<SyncRequest*>(p);
138 req_done->id = ID_DONE;
139 req_done->path_length = mtime;
140 p += sizeof(SyncRequest);
141
Elliott Hughes6d929972015-10-27 13:40:35 -0700142 if (!WriteFdExactly(fd, &buf[0], (p - &buf[0]))) return false;
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700143
144 total_bytes += data_length;
145 return true;
146 }
147
148 bool CopyDone(const char* from, const char* to) {
149 syncmsg msg;
150 if (!ReadFdExactly(fd, &msg.status, sizeof(msg.status))) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700151 Error("failed to copy '%s' to '%s': no ID_DONE: %s", from, to, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700152 return false;
153 }
154 if (msg.status.id == ID_OKAY) {
155 return true;
156 }
157 if (msg.status.id != ID_FAIL) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700158 Error("failed to copy '%s' to '%s': unknown reason %d", from, to, msg.status.id);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700159 return false;
160 }
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700161 return ReportCopyFailure(from, to, msg);
162 }
163
164 bool ReportCopyFailure(const char* from, const char* to, const syncmsg& msg) {
Elliott Hughes6d929972015-10-27 13:40:35 -0700165 std::vector<char> buf(msg.status.msglen + 1);
166 if (!ReadFdExactly(fd, &buf[0], msg.status.msglen)) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700167 Error("failed to copy '%s' to '%s'; failed to read reason (!): %s",
168 from, to, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700169 return false;
170 }
Elliott Hughes6d929972015-10-27 13:40:35 -0700171 buf[msg.status.msglen] = 0;
Elliott Hughesb708d162015-10-27 16:03:15 -0700172 Error("failed to copy '%s' to '%s': %s", from, to, &buf[0]);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700173 return false;
174 }
175
Elliott Hughesb708d162015-10-27 16:03:15 -0700176 std::string TransferRate() {
177 uint64_t ms = CurrentTimeMs() - start_time_ms_;
178 if (total_bytes == 0 || ms == 0) return "";
179
180 double s = static_cast<double>(ms) / 1000LL;
181 double rate = (static_cast<double>(total_bytes) / s) / (1024*1024);
182 return android::base::StringPrintf(" %.1f MB/s (%" PRId64 " bytes in %.3fs)",
183 rate, total_bytes, s);
184 }
185
186 void Print(const std::string& s) {
187 // TODO: we actually don't want ELIDE; we want "ELIDE if smart, FULL if dumb".
188 line_printer_.Print(s, LinePrinter::ELIDE);
189 }
190
Josh Gao983c41c2015-11-02 17:15:57 -0800191 void Printf(const char* fmt, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))) {
192 std::string s;
193 va_list ap;
194 va_start(ap, fmt);
195 android::base::StringAppendV(&s, fmt, ap);
196 va_end(ap);
197
198 Print(s);
199 }
200
Elliott Hughesb708d162015-10-27 16:03:15 -0700201 void Error(const char* fmt, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))) {
202 std::string s = "adb: error: ";
203
204 va_list ap;
205 va_start(ap, fmt);
206 android::base::StringAppendV(&s, fmt, ap);
207 va_end(ap);
208
209 line_printer_.Print(s, LinePrinter::FULL);
210 }
211
Elliott Hughesaa245492015-08-03 10:38:08 -0700212 uint64_t total_bytes;
213
214 // TODO: add a char[max] buffer here, to replace syncsendbuf...
215 int fd;
216 size_t max;
217
218 private:
Elliott Hughesb708d162015-10-27 16:03:15 -0700219 uint64_t start_time_ms_;
220
221 LinePrinter line_printer_;
Elliott Hughesaa245492015-08-03 10:38:08 -0700222
Spencer Low351ecd12015-10-14 17:32:44 -0700223 bool SendQuit() {
224 return SendRequest(ID_QUIT, ""); // TODO: add a SendResponse?
Elliott Hughesaa245492015-08-03 10:38:08 -0700225 }
226
Elliott Hughesb708d162015-10-27 16:03:15 -0700227 static uint64_t CurrentTimeMs() {
228 struct timeval tv;
229 gettimeofday(&tv, 0); // (Not clock_gettime because of Mac/Windows.)
230 return static_cast<uint64_t>(tv.tv_sec) * 1000 + tv.tv_usec / 1000;
Elliott Hughesaa245492015-08-03 10:38:08 -0700231 }
232};
233
Josh Gaocda6a2b2015-11-02 16:45:47 -0800234typedef void (sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char* name);
Elliott Hughesaa245492015-08-03 10:38:08 -0700235
Josh Gaocda6a2b2015-11-02 16:45:47 -0800236static bool sync_ls(SyncConnection& sc, const char* path,
237 std::function<sync_ls_cb> func) {
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700238 if (!sc.SendRequest(ID_LIST, path)) return false;
Elliott Hughesaa245492015-08-03 10:38:08 -0700239
240 while (true) {
241 syncmsg msg;
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700242 if (!ReadFdExactly(sc.fd, &msg.dent, sizeof(msg.dent))) return false;
Elliott Hughesaa245492015-08-03 10:38:08 -0700243
244 if (msg.dent.id == ID_DONE) return true;
245 if (msg.dent.id != ID_DENT) return false;
246
Elliott Hughesf4465202015-08-24 14:27:03 -0700247 size_t len = msg.dent.namelen;
Elliott Hughesaa245492015-08-03 10:38:08 -0700248 if (len > 256) return false; // TODO: resize buffer? continue?
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800249
Elliott Hughes5c742702015-07-30 17:42:01 -0700250 char buf[257];
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700251 if (!ReadFdExactly(sc.fd, buf, len)) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800252 buf[len] = 0;
253
Josh Gaocda6a2b2015-11-02 16:45:47 -0800254 func(msg.dent.mode, msg.dent.size, msg.dent.time, buf);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800255 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800256}
257
Elliott Hughesaa245492015-08-03 10:38:08 -0700258static bool sync_finish_stat(SyncConnection& sc, unsigned int* timestamp,
259 unsigned int* mode, unsigned int* size) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800260 syncmsg msg;
Elliott Hughesaa245492015-08-03 10:38:08 -0700261 if (!ReadFdExactly(sc.fd, &msg.stat, sizeof(msg.stat)) || msg.stat.id != ID_STAT) {
262 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800263 }
264
Elliott Hughesf4465202015-08-24 14:27:03 -0700265 if (timestamp) *timestamp = msg.stat.time;
266 if (mode) *mode = msg.stat.mode;
267 if (size) *size = msg.stat.size;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800268
Elliott Hughesaa245492015-08-03 10:38:08 -0700269 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800270}
271
Elliott Hughesaa245492015-08-03 10:38:08 -0700272static bool sync_stat(SyncConnection& sc, const char* path,
273 unsigned int* timestamp, unsigned int* mode, unsigned int* size) {
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700274 return sc.SendRequest(ID_STAT, path) && sync_finish_stat(sc, timestamp, mode, size);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275}
276
Elliott Hughesb708d162015-10-27 16:03:15 -0700277static bool SendLargeFile(SyncConnection& sc, const char* path_and_mode,
278 const char* lpath, const char* rpath,
279 unsigned mtime) {
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700280 if (!sc.SendRequest(ID_SEND, path_and_mode)) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700281 sc.Error("failed to send ID_SEND message '%s': %s", path_and_mode, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700282 return false;
283 }
284
Elliott Hughesb708d162015-10-27 16:03:15 -0700285 struct stat st;
286 if (stat(lpath, &st) == -1) {
287 sc.Error("cannot stat '%s': %s", lpath, strerror(errno));
288 return false;
Spencer Lowd8cce182015-08-28 01:07:30 -0700289 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800290
Elliott Hughesb708d162015-10-27 16:03:15 -0700291 uint64_t total_size = st.st_size;
292 uint64_t bytes_copied = 0;
293
294 int lfd = adb_open(lpath, O_RDONLY);
Elliott Hughesaa245492015-08-03 10:38:08 -0700295 if (lfd < 0) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700296 sc.Error("cannot open '%s': %s", lpath, strerror(errno));
Spencer Lowd8cce182015-08-28 01:07:30 -0700297 return false;
Mark Lindner76f2a932014-03-11 17:55:59 -0700298 }
299
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700300 syncsendbuf sbuf;
301 sbuf.id = ID_DATA;
Elliott Hughesaa245492015-08-03 10:38:08 -0700302 while (true) {
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700303 int ret = adb_read(lfd, sbuf.data, sc.max);
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700304 if (ret <= 0) {
Spencer Lowd8cce182015-08-28 01:07:30 -0700305 if (ret < 0) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700306 sc.Error("cannot read '%s': %s", lpath, strerror(errno));
Spencer Lowd8cce182015-08-28 01:07:30 -0700307 adb_close(lfd);
308 return false;
309 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800310 break;
311 }
312
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700313 sbuf.size = ret;
314 if (!WriteFdExactly(sc.fd, &sbuf, sizeof(unsigned) * 2 + ret)) {
Spencer Lowd8cce182015-08-28 01:07:30 -0700315 adb_close(lfd);
316 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800317 }
Elliott Hughesaa245492015-08-03 10:38:08 -0700318 sc.total_bytes += ret;
Mark Lindner76f2a932014-03-11 17:55:59 -0700319
Elliott Hughesb708d162015-10-27 16:03:15 -0700320 bytes_copied += ret;
321
322 int percentage = static_cast<int>(bytes_copied * 100 / total_size);
Josh Gao983c41c2015-11-02 17:15:57 -0800323 sc.Printf("%s: %d%%", rpath, percentage);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800324 }
325
326 adb_close(lfd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800327
Elliott Hughesaa245492015-08-03 10:38:08 -0700328 syncmsg msg;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800329 msg.data.id = ID_DONE;
Elliott Hughesf4465202015-08-24 14:27:03 -0700330 msg.data.size = mtime;
Elliott Hughes081696d2015-09-03 11:06:00 -0700331 if (!WriteFdExactly(sc.fd, &msg.data, sizeof(msg.data))) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700332 sc.Error("failed to send ID_DONE message for '%s': %s", rpath, strerror(errno));
Elliott Hughesaa245492015-08-03 10:38:08 -0700333 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800334 }
335
Elliott Hughesaa245492015-08-03 10:38:08 -0700336 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800337}
338
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700339static bool sync_send(SyncConnection& sc, const char* lpath, const char* rpath,
Elliott Hughesb708d162015-10-27 16:03:15 -0700340 unsigned mtime, mode_t mode)
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700341{
342 std::string path_and_mode = android::base::StringPrintf("%s,%d", rpath, mode);
343
344 if (S_ISLNK(mode)) {
345#if !defined(_WIN32)
346 char buf[PATH_MAX];
347 ssize_t data_length = readlink(lpath, buf, PATH_MAX - 1);
348 if (data_length == -1) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700349 sc.Error("readlink '%s' failed: %s", lpath, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700350 return false;
351 }
352 buf[data_length++] = '\0';
353
Elliott Hughesb708d162015-10-27 16:03:15 -0700354 if (!sc.SendSmallFile(path_and_mode.c_str(), rpath, buf, data_length, mtime)) return false;
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700355 return sc.CopyDone(lpath, rpath);
356#endif
357 }
358
359 if (!S_ISREG(mode)) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700360 sc.Error("local file '%s' has unsupported mode: 0o%o", lpath, mode);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700361 return false;
362 }
363
364 struct stat st;
365 if (stat(lpath, &st) == -1) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700366 sc.Error("failed to stat local file '%s': %s", lpath, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700367 return false;
368 }
369 if (st.st_size < SYNC_DATA_MAX) {
370 std::string data;
371 if (!android::base::ReadFileToString(lpath, &data)) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700372 sc.Error("failed to read all of '%s': %s", lpath, strerror(errno));
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700373 return false;
374 }
Elliott Hughesb708d162015-10-27 16:03:15 -0700375 if (!sc.SendSmallFile(path_and_mode.c_str(), rpath, data.data(), data.size(), mtime)) {
376 return false;
377 }
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700378 } else {
Elliott Hughesb708d162015-10-27 16:03:15 -0700379 if (!SendLargeFile(sc, path_and_mode.c_str(), lpath, rpath, mtime)) {
380 return false;
381 }
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700382 }
383 return sc.CopyDone(lpath, rpath);
384}
385
Elliott Hughesb708d162015-10-27 16:03:15 -0700386static bool sync_recv(SyncConnection& sc, const char* rpath, const char* lpath) {
387 sc.Print(rpath);
388
Elliott Hughesaa245492015-08-03 10:38:08 -0700389 unsigned size = 0;
Elliott Hughesb708d162015-10-27 16:03:15 -0700390 if (!sync_stat(sc, rpath, nullptr, nullptr, &size)) return false;
Mark Lindner76f2a932014-03-11 17:55:59 -0700391
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700392 if (!sc.SendRequest(ID_RECV, rpath)) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800393
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700394 adb_unlink(lpath);
Josh Gao45b6fc82015-11-04 14:51:23 -0800395 if (!mkdirs(adb_dirname(lpath))) {
396 sc.Error("failed to create parent directory '%s': %s",
397 adb_dirname(lpath).c_str(), strerror(errno));
398 return false;
399 }
400
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700401 int lfd = adb_creat(lpath, 0644);
402 if (lfd < 0) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700403 sc.Error("cannot create '%s': %s", lpath, strerror(errno));
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700404 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800405 }
406
Elliott Hughesb708d162015-10-27 16:03:15 -0700407 uint64_t bytes_copied = 0;
Elliott Hughesaa245492015-08-03 10:38:08 -0700408 while (true) {
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700409 syncmsg msg;
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700410 if (!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) {
Spencer Lowd8cce182015-08-28 01:07:30 -0700411 adb_close(lfd);
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700412 adb_unlink(lpath);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700413 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800414 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800415
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700416 if (msg.data.id == ID_DONE) break;
417
418 if (msg.data.id != ID_DATA) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800419 adb_close(lfd);
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700420 adb_unlink(lpath);
421 sc.ReportCopyFailure(rpath, lpath, msg);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700422 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800423 }
424
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700425 if (msg.data.size > sc.max) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700426 sc.Error("msg.data.size too large: %u (max %zu)", msg.data.size, sc.max);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800427 adb_close(lfd);
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700428 adb_unlink(lpath);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700429 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800430 }
431
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700432 char buffer[SYNC_DATA_MAX];
433 if (!ReadFdExactly(sc.fd, buffer, msg.data.size)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800434 adb_close(lfd);
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700435 adb_unlink(lpath);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700436 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800437 }
438
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700439 if (!WriteFdExactly(lfd, buffer, msg.data.size)) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700440 sc.Error("cannot write '%s': %s", lpath, strerror(errno));
Elliott Hughes8b43c3e2015-10-23 21:06:11 -0700441 adb_close(lfd);
442 adb_unlink(lpath);
443 return false;
444 }
445
446 sc.total_bytes += msg.data.size;
Mark Lindner76f2a932014-03-11 17:55:59 -0700447
Elliott Hughesb708d162015-10-27 16:03:15 -0700448 bytes_copied += msg.data.size;
449
450 int percentage = static_cast<int>(bytes_copied * 100 / size);
Josh Gao983c41c2015-11-02 17:15:57 -0800451 sc.Printf("%s: %d%%", rpath, percentage);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800452 }
453
454 adb_close(lfd);
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700455 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800456}
457
Elliott Hughesaa245492015-08-03 10:38:08 -0700458bool do_sync_ls(const char* path) {
459 SyncConnection sc;
460 if (!sc.IsValid()) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800461
Josh Gaocda6a2b2015-11-02 16:45:47 -0800462 return sync_ls(sc, path, [](unsigned mode, unsigned size, unsigned time,
463 const char* name) {
464 printf("%08x %08x %08x %s\n", mode, size, time, name);
465 });
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800466}
467
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800468struct copyinfo
469{
Josh Gaocda6a2b2015-11-02 16:45:47 -0800470 std::string src;
471 std::string dst;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800472 unsigned int time;
473 unsigned int mode;
Elliott Hughesae5a6c02015-09-27 12:55:37 -0700474 uint64_t size;
Josh Gaofc7c3b62015-11-03 14:44:04 -0800475 bool skip;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800476};
477
Josh Gaod9731572015-11-03 15:23:03 -0800478static copyinfo mkcopyinfo(const std::string& spath, const std::string& dpath,
479 const char* name, bool isdir) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800480 copyinfo result;
Josh Gaod9731572015-11-03 15:23:03 -0800481 result.src = spath + name;
482 result.dst = dpath + name;
483 if (isdir) {
484 result.src.push_back('/');
485 result.dst.push_back('/');
486 }
Josh Gaocda6a2b2015-11-02 16:45:47 -0800487 result.time = 0;
488 result.mode = 0;
489 result.size = 0;
Josh Gaofc7c3b62015-11-03 14:44:04 -0800490 result.skip = false;
Josh Gaocda6a2b2015-11-02 16:45:47 -0800491 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800492}
493
Elliott Hughesaa245492015-08-03 10:38:08 -0700494static bool IsDotOrDotDot(const char* name) {
495 return name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'));
496}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800497
Josh Gaocda6a2b2015-11-02 16:45:47 -0800498static int local_build_list(SyncConnection& sc, std::vector<copyinfo>* filelist,
Josh Gaod9731572015-11-03 15:23:03 -0800499 const std::string& lpath, const std::string& rpath) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800500 std::vector<copyinfo> dirlist;
Josh Gaod9731572015-11-03 15:23:03 -0800501 std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(lpath.c_str()), closedir);
Elliott Hughesaa245492015-08-03 10:38:08 -0700502 if (!dir) {
Josh Gaod9731572015-11-03 15:23:03 -0800503 sc.Error("cannot open '%s': %s", lpath.c_str(), strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800504 return -1;
505 }
506
Elliott Hughesb708d162015-10-27 16:03:15 -0700507 dirent* de;
Elliott Hughesaa245492015-08-03 10:38:08 -0700508 while ((de = readdir(dir.get()))) {
509 if (IsDotOrDotDot(de->d_name)) continue;
510
Josh Gaod9731572015-11-03 15:23:03 -0800511 std::string stat_path = lpath + de->d_name;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800512
Elliott Hughesaa245492015-08-03 10:38:08 -0700513 struct stat st;
Josh Gaod9731572015-11-03 15:23:03 -0800514 if (!lstat(stat_path.c_str(), &st)) {
Daniel Rosenberg686bce62014-06-30 20:29:40 -0700515 if (S_ISDIR(st.st_mode)) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800516 dirlist.push_back(mkcopyinfo(lpath, rpath, de->d_name, 1));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800517 } else {
Elliott Hughesaa245492015-08-03 10:38:08 -0700518 if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
Josh Gaod9731572015-11-03 15:23:03 -0800519 sc.Error("skipping special file '%s'", lpath.c_str());
Daniel Rosenberg686bce62014-06-30 20:29:40 -0700520 } else {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800521 copyinfo ci = mkcopyinfo(lpath, rpath, de->d_name, 0);
522 ci.time = st.st_mtime;
523 ci.mode = st.st_mode;
524 ci.size = st.st_size;
525 filelist->push_back(ci);
Daniel Rosenberg686bce62014-06-30 20:29:40 -0700526 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800527 }
Daniel Rosenberg686bce62014-06-30 20:29:40 -0700528 } else {
Josh Gaod9731572015-11-03 15:23:03 -0800529 sc.Error("cannot lstat '%s': %s", stat_path.c_str(),
530 strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800531 }
532 }
533
Elliott Hughesaa245492015-08-03 10:38:08 -0700534 // Close this directory and recurse.
535 dir.reset();
Josh Gaocda6a2b2015-11-02 16:45:47 -0800536 for (const copyinfo& ci : dirlist) {
537 local_build_list(sc, filelist, ci.src.c_str(), ci.dst.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800538 }
539
540 return 0;
541}
542
Josh Gaod9731572015-11-03 15:23:03 -0800543static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath,
544 std::string rpath, bool check_timestamps,
545 bool list_only) {
546 // Make sure that both directory paths end in a slash.
547 if (lpath.empty() || rpath.empty()) {
548 return false;
549 }
550 if (lpath.back() != '/') {
551 lpath.push_back('/');
552 }
553 if (rpath.back() != '/') {
554 rpath.push_back('/');
555 }
556
557 // Recursively build the list of files to copy.
Josh Gaocda6a2b2015-11-02 16:45:47 -0800558 std::vector<copyinfo> filelist;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800559 int pushed = 0;
560 int skipped = 0;
Elliott Hughesb708d162015-10-27 16:03:15 -0700561 if (local_build_list(sc, &filelist, lpath, rpath)) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700562 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800563 }
564
Elliott Hughesaa245492015-08-03 10:38:08 -0700565 if (check_timestamps) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800566 for (const copyinfo& ci : filelist) {
Josh Gaod9731572015-11-03 15:23:03 -0800567 if (!sc.SendRequest(ID_STAT, ci.dst.c_str())) {
568 return false;
569 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800570 }
Josh Gaocda6a2b2015-11-02 16:45:47 -0800571 for (copyinfo& ci : filelist) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800572 unsigned int timestamp, mode, size;
Josh Gaod9731572015-11-03 15:23:03 -0800573 if (!sync_finish_stat(sc, &timestamp, &mode, &size)) {
574 return false;
575 }
Josh Gaocda6a2b2015-11-02 16:45:47 -0800576 if (size == ci.size) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800577 /* for links, we cannot update the atime/mtime */
Josh Gaocda6a2b2015-11-02 16:45:47 -0800578 if ((S_ISREG(ci.mode & mode) && timestamp == ci.time) ||
579 (S_ISLNK(ci.mode & mode) && timestamp >= ci.time)) {
Josh Gaofc7c3b62015-11-03 14:44:04 -0800580 ci.skip = true;
Elliott Hughesaa245492015-08-03 10:38:08 -0700581 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800582 }
583 }
584 }
Josh Gaocda6a2b2015-11-02 16:45:47 -0800585
586 for (const copyinfo& ci : filelist) {
Josh Gaofc7c3b62015-11-03 14:44:04 -0800587 if (!ci.skip) {
Elliott Hughesb708d162015-10-27 16:03:15 -0700588 if (list_only) {
Josh Gaod9731572015-11-03 15:23:03 -0800589 sc.Error("would push: %s -> %s", ci.src.c_str(),
590 ci.dst.c_str());
Elliott Hughesb708d162015-10-27 16:03:15 -0700591 } else {
Josh Gaod9731572015-11-03 15:23:03 -0800592 if (!sync_send(sc, ci.src.c_str(), ci.dst.c_str(), ci.time,
593 ci.mode)) {
594 return false;
Elliott Hughesb708d162015-10-27 16:03:15 -0700595 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800596 }
597 pushed++;
598 } else {
599 skipped++;
600 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800601 }
602
Josh Gaod9731572015-11-03 15:23:03 -0800603 sc.Printf("%s: %d file%s pushed. %d file%s skipped.%s\n", rpath.c_str(),
604 pushed, (pushed == 1) ? "" : "s", skipped,
605 (skipped == 1) ? "" : "s", sc.TransferRate().c_str());
Elliott Hughesaa245492015-08-03 10:38:08 -0700606 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800607}
608
Josh Gao05786772015-10-30 16:57:19 -0700609bool do_sync_push(const std::vector<const char*>& srcs, const char* dst) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700610 SyncConnection sc;
611 if (!sc.IsValid()) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800612
Josh Gao05786772015-10-30 16:57:19 -0700613 bool success = true;
Elliott Hughesaa245492015-08-03 10:38:08 -0700614 unsigned mode;
Josh Gao05786772015-10-30 16:57:19 -0700615 if (!sync_stat(sc, dst, nullptr, &mode, nullptr)) return false;
616 bool dst_isdir = mode != 0 && S_ISDIR(mode);
617
618 if (!dst_isdir) {
619 if (srcs.size() > 1) {
620 sc.Error("target '%s' is not a directory", dst);
621 return false;
622 } else {
623 size_t dst_len = strlen(dst);
624 if (dst[dst_len - 1] == '/') {
625 sc.Error("failed to access '%s': Not a directory", dst);
626 return false;
627 }
628 }
Elliott Hughesaa245492015-08-03 10:38:08 -0700629 }
Josh Gao05786772015-10-30 16:57:19 -0700630
631 for (const char* src_path : srcs) {
632 const char* dst_path = dst;
633 struct stat st;
634 if (stat(src_path, &st)) {
635 sc.Error("cannot stat '%s': %s", src_path, strerror(errno));
636 success = false;
637 continue;
638 }
639
640 if (S_ISDIR(st.st_mode)) {
641 success &= copy_local_dir_remote(sc, src_path, dst, false, false);
642 continue;
643 }
644
645 std::string path_holder;
646 if (mode != 0 && S_ISDIR(mode)) {
647 // If we're copying a local file to a remote directory,
648 // we really want to copy to remote_dir + "/" + local_filename.
649 path_holder = android::base::StringPrintf(
650 "%s/%s", dst_path, adb_basename(src_path).c_str());
651 dst_path = path_holder.c_str();
652 }
653 success &= sync_send(sc, src_path, dst_path, st.st_mtime, st.st_mode);
654 }
655
Elliott Hughesb708d162015-10-27 16:03:15 -0700656 sc.Print("\n");
Josh Gao05786772015-10-30 16:57:19 -0700657 return success;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800658}
659
Josh Gaocda6a2b2015-11-02 16:45:47 -0800660static bool remote_build_list(SyncConnection& sc,
661 std::vector<copyinfo>* filelist,
Josh Gaod9731572015-11-03 15:23:03 -0800662 const std::string& rpath,
663 const std::string& lpath) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800664 std::vector<copyinfo> dirlist;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800665
Elliott Hughesaa245492015-08-03 10:38:08 -0700666 // Put the files/dirs in rpath on the lists.
Josh Gaocda6a2b2015-11-02 16:45:47 -0800667 auto callback = [&](unsigned mode, unsigned size, unsigned time,
668 const char* name) {
669 if (S_ISDIR(mode)) {
670 // Don't try recursing down "." or "..".
671 if (IsDotOrDotDot(name)) return;
672
673 dirlist.push_back(mkcopyinfo(rpath, lpath, name, 1));
674 } else if (S_ISREG(mode) || S_ISLNK(mode)) {
675 copyinfo ci = mkcopyinfo(rpath, lpath, name, 0);
676 ci.time = time;
677 ci.mode = mode;
678 ci.size = size;
679 filelist->push_back(ci);
680 } else {
681 sc.Print(android::base::StringPrintf("skipping special file '%s'\n",
682 name));
683 }
684 };
685
Josh Gaod9731572015-11-03 15:23:03 -0800686 if (!sync_ls(sc, rpath.c_str(), callback)) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700687 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800688 }
689
Elliott Hughesaa245492015-08-03 10:38:08 -0700690 // Recurse into each directory we found.
Josh Gaocda6a2b2015-11-02 16:45:47 -0800691 while (!dirlist.empty()) {
692 copyinfo current = dirlist.back();
693 dirlist.pop_back();
694 if (!remote_build_list(sc, filelist, current.src.c_str(),
695 current.dst.c_str())) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700696 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800697 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800698 }
699
Elliott Hughesaa245492015-08-03 10:38:08 -0700700 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800701}
702
Dan Albertbac34742015-02-25 17:51:28 -0800703static int set_time_and_mode(const char *lpath, time_t time, unsigned int mode)
Lajos Molnarde8ff4a2013-04-19 12:41:09 -0700704{
Greg Hackmann7a5e2bd2014-05-06 08:48:18 -0700705 struct utimbuf times = { time, time };
706 int r1 = utime(lpath, &times);
Lajos Molnarde8ff4a2013-04-19 12:41:09 -0700707
708 /* use umask for permissions */
Josh Gaocda6a2b2015-11-02 16:45:47 -0800709 mode_t mask = umask(0000);
Lajos Molnarde8ff4a2013-04-19 12:41:09 -0700710 umask(mask);
711 int r2 = chmod(lpath, mode & ~mask);
712
713 return r1 ? : r2;
714}
715
Josh Gaod9731572015-11-03 15:23:03 -0800716static bool copy_remote_dir_local(SyncConnection& sc, std::string rpath,
717 std::string lpath, bool copy_attrs) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700718 // Make sure that both directory paths end in a slash.
Josh Gaod9731572015-11-03 15:23:03 -0800719 if (rpath.empty() || lpath.empty()) {
720 return false;
721 }
722 if (rpath.back() != '/') {
723 rpath.push_back('/');
724 }
725 if (lpath.back() != '/') {
726 lpath.push_back('/');
727 }
Riley Andrews4d04d242014-12-12 13:12:36 -0800728
Elliott Hughesaa245492015-08-03 10:38:08 -0700729 // Recursively build the list of files to copy.
Elliott Hughesb708d162015-10-27 16:03:15 -0700730 sc.Print("pull: building file list...");
Josh Gaocda6a2b2015-11-02 16:45:47 -0800731 std::vector<copyinfo> filelist;
Josh Gaod9731572015-11-03 15:23:03 -0800732 if (!remote_build_list(sc, &filelist, rpath.c_str(), lpath.c_str())) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800733 return false;
734 }
Elliott Hughesaa245492015-08-03 10:38:08 -0700735
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800736 int pulled = 0;
737 int skipped = 0;
Josh Gaocda6a2b2015-11-02 16:45:47 -0800738 for (const copyinfo &ci : filelist) {
Josh Gaofc7c3b62015-11-03 14:44:04 -0800739 if (!ci.skip) {
Josh Gaocda6a2b2015-11-02 16:45:47 -0800740 sc.Printf("pull: %s -> %s", ci.src.c_str(), ci.dst.c_str());
741 if (!sync_recv(sc, ci.src.c_str(), ci.dst.c_str())) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700742 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800743 }
Lajos Molnarde8ff4a2013-04-19 12:41:09 -0700744
Josh Gaocda6a2b2015-11-02 16:45:47 -0800745 if (copy_attrs &&
746 set_time_and_mode(ci.dst.c_str(), ci.time, ci.mode)) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700747 return false;
Lajos Molnarde8ff4a2013-04-19 12:41:09 -0700748 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800749 pulled++;
750 } else {
751 skipped++;
752 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800753 }
754
Josh Gaod9731572015-11-03 15:23:03 -0800755 sc.Printf("%s: %d file%s pulled. %d file%s skipped.%s\n", rpath.c_str(),
756 pulled, (pulled == 1) ? "" : "s", skipped,
757 (skipped == 1) ? "" : "s", sc.TransferRate().c_str());
Elliott Hughesaa245492015-08-03 10:38:08 -0700758 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800759}
760
Josh Gao05786772015-10-30 16:57:19 -0700761bool do_sync_pull(const std::vector<const char*>& srcs, const char* dst,
762 bool copy_attrs) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700763 SyncConnection sc;
764 if (!sc.IsValid()) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800765
Josh Gao05786772015-10-30 16:57:19 -0700766 bool success = true;
Elliott Hughes5c742702015-07-30 17:42:01 -0700767 unsigned mode, time;
Josh Gao05786772015-10-30 16:57:19 -0700768 struct stat st;
769 if (stat(dst, &st)) {
770 // If we're only pulling one file, the destination path might point to
771 // a path that doesn't exist yet.
772 if (srcs.size() != 1 || errno != ENOENT) {
773 sc.Error("cannot stat '%s': %s", dst, strerror(errno));
774 return false;
775 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800776 }
777
Josh Gao05786772015-10-30 16:57:19 -0700778 bool dst_isdir = S_ISDIR(st.st_mode);
779 if (!dst_isdir) {
780 if (srcs.size() > 1) {
781 sc.Error("target '%s' is not a directory", dst);
Elliott Hughesaa245492015-08-03 10:38:08 -0700782 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800783 } else {
Josh Gao05786772015-10-30 16:57:19 -0700784 size_t dst_len = strlen(dst);
785 if (dst[dst_len - 1] == '/') {
786 sc.Error("failed to access '%s': Not a directory", dst);
Elliott Hughesaa245492015-08-03 10:38:08 -0700787 return false;
Elliott Hughes5c742702015-07-30 17:42:01 -0700788 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800789 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800790 }
Elliott Hughesaa245492015-08-03 10:38:08 -0700791
Josh Gao05786772015-10-30 16:57:19 -0700792 for (const char* src_path : srcs) {
793 const char* dst_path = dst;
794 if (!sync_stat(sc, src_path, &time, &mode, nullptr)) return false;
795 if (mode == 0) {
796 sc.Error("remote object '%s' does not exist", src_path);
797 success = false;
798 continue;
799 }
800
801 if (S_ISREG(mode) || S_ISLNK(mode) || S_ISCHR(mode) || S_ISBLK(mode)) {
802 std::string path_holder;
803 struct stat st;
804 if (stat(dst_path, &st) == 0) {
805 if (S_ISDIR(st.st_mode)) {
806 // If we're copying a remote file to a local directory,
807 // we really want to copy to local_dir + "/" +
808 // basename(remote).
809 path_holder = android::base::StringPrintf(
810 "%s/%s", dst_path, adb_basename(src_path).c_str());
811 dst_path = path_holder.c_str();
812 }
813 }
814 if (!sync_recv(sc, src_path, dst_path)) {
815 success = false;
816 continue;
817 } else {
818 if (copy_attrs && set_time_and_mode(dst_path, time, mode)) {
819 success = false;
820 continue;
821 }
822 }
823 } else if (S_ISDIR(mode)) {
824 success &= copy_remote_dir_local(sc, src_path, dst_path, copy_attrs);
825 continue;
826 } else {
827 sc.Error("remote object '%s' not a file or directory", src_path);
828 success = false;
829 continue;
830 }
831 }
832
833 sc.Print("\n");
834 return success;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800835}
836
Elliott Hughesaa245492015-08-03 10:38:08 -0700837bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only) {
Elliott Hughesaa245492015-08-03 10:38:08 -0700838 SyncConnection sc;
839 if (!sc.IsValid()) return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800840
Josh Gaod9731572015-11-03 15:23:03 -0800841 return copy_local_dir_remote(sc, lpath, rpath, true, list_only);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800842}