1 //===-- AdbClient.cpp -------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // Other libraries and framework includes
11 #include "AdbClient.h"
12 
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/FileUtilities.h"
17 
18 #include "lldb/Core/DataBuffer.h"
19 #include "lldb/Core/DataBufferHeap.h"
20 #include "lldb/Core/DataEncoder.h"
21 #include "lldb/Core/DataExtractor.h"
22 #include "lldb/Core/StreamString.h"
23 #include "lldb/Host/ConnectionFileDescriptor.h"
24 #include "lldb/Host/FileSpec.h"
25 #include "lldb/Host/PosixApi.h"
26 
27 #include <limits.h>
28 
29 #include <algorithm>
30 #include <cstdlib>
31 #include <fstream>
32 #include <sstream>
33 
34 // On Windows, transitive dependencies pull in <Windows.h>, which defines a
35 // macro that clashes with a method name.
36 #ifdef SendMessage
37 #undef SendMessage
38 #endif
39 
40 using namespace lldb;
41 using namespace lldb_private;
42 using namespace lldb_private::platform_android;
43 
44 namespace {
45 
46 const std::chrono::seconds kReadTimeout(8);
47 const char *kOKAY = "OKAY";
48 const char *kFAIL = "FAIL";
49 const char *kDATA = "DATA";
50 const char *kDONE = "DONE";
51 
52 const char *kSEND = "SEND";
53 const char *kRECV = "RECV";
54 const char *kSTAT = "STAT";
55 
56 const size_t kSyncPacketLen = 8;
57 // Maximum size of a filesync DATA packet.
58 const size_t kMaxPushData = 2 * 1024;
59 // Default mode for pushed files.
60 const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG
61 
62 const char *kSocketNamespaceAbstract = "localabstract";
63 const char *kSocketNamespaceFileSystem = "localfilesystem";
64 
65 Error ReadAllBytes(Connection &conn, void *buffer, size_t size) {
66   using namespace std::chrono;
67 
68   Error error;
69   ConnectionStatus status;
70   char *read_buffer = static_cast<char *>(buffer);
71 
72   auto now = steady_clock::now();
73   const auto deadline = now + kReadTimeout;
74   size_t total_read_bytes = 0;
75   while (total_read_bytes < size && now < deadline) {
76     uint32_t timeout_usec = duration_cast<microseconds>(deadline - now).count();
77     auto read_bytes =
78         conn.Read(read_buffer + total_read_bytes, size - total_read_bytes,
79                   timeout_usec, status, &error);
80     if (error.Fail())
81       return error;
82     total_read_bytes += read_bytes;
83     if (status != eConnectionStatusSuccess)
84       break;
85     now = steady_clock::now();
86   }
87   if (total_read_bytes < size)
88     error = Error(
89         "Unable to read requested number of bytes. Connection status: %d.",
90         status);
91   return error;
92 }
93 
94 } // namespace
95 
96 Error AdbClient::CreateByDeviceID(const std::string &device_id,
97                                   AdbClient &adb) {
98   DeviceIDList connect_devices;
99   auto error = adb.GetDevices(connect_devices);
100   if (error.Fail())
101     return error;
102 
103   std::string android_serial;
104   if (!device_id.empty())
105     android_serial = device_id;
106   else if (const char *env_serial = std::getenv("ANDROID_SERIAL"))
107     android_serial = env_serial;
108 
109   if (android_serial.empty()) {
110     if (connect_devices.size() != 1)
111       return Error("Expected a single connected device, got instead %zu - try "
112                    "setting 'ANDROID_SERIAL'",
113                    connect_devices.size());
114     adb.SetDeviceID(connect_devices.front());
115   } else {
116     auto find_it = std::find(connect_devices.begin(), connect_devices.end(),
117                              android_serial);
118     if (find_it == connect_devices.end())
119       return Error("Device \"%s\" not found", android_serial.c_str());
120 
121     adb.SetDeviceID(*find_it);
122   }
123   return error;
124 }
125 
126 AdbClient::AdbClient() {}
127 
128 AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {}
129 
130 AdbClient::~AdbClient() {}
131 
132 void AdbClient::SetDeviceID(const std::string &device_id) {
133   m_device_id = device_id;
134 }
135 
136 const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
137 
138 Error AdbClient::Connect() {
139   Error error;
140   m_conn.reset(new ConnectionFileDescriptor);
141   m_conn->Connect("connect://localhost:5037", &error);
142 
143   return error;
144 }
145 
146 Error AdbClient::GetDevices(DeviceIDList &device_list) {
147   device_list.clear();
148 
149   auto error = SendMessage("host:devices");
150   if (error.Fail())
151     return error;
152 
153   error = ReadResponseStatus();
154   if (error.Fail())
155     return error;
156 
157   std::vector<char> in_buffer;
158   error = ReadMessage(in_buffer);
159 
160   llvm::StringRef response(&in_buffer[0], in_buffer.size());
161   llvm::SmallVector<llvm::StringRef, 4> devices;
162   response.split(devices, "\n", -1, false);
163 
164   for (const auto device : devices)
165     device_list.push_back(device.split('\t').first);
166 
167   // Force disconnect since ADB closes connection after host:devices
168   // response is sent.
169   m_conn.reset();
170   return error;
171 }
172 
173 Error AdbClient::SetPortForwarding(const uint16_t local_port,
174                                    const uint16_t remote_port) {
175   char message[48];
176   snprintf(message, sizeof(message), "forward:tcp:%d;tcp:%d", local_port,
177            remote_port);
178 
179   const auto error = SendDeviceMessage(message);
180   if (error.Fail())
181     return error;
182 
183   return ReadResponseStatus();
184 }
185 
186 Error AdbClient::SetPortForwarding(const uint16_t local_port,
187                                    const char *remote_socket_name,
188                                    const UnixSocketNamespace socket_namespace) {
189   char message[PATH_MAX];
190   const char *sock_namespace_str =
191       (socket_namespace == UnixSocketNamespaceAbstract)
192           ? kSocketNamespaceAbstract
193           : kSocketNamespaceFileSystem;
194   snprintf(message, sizeof(message), "forward:tcp:%d;%s:%s", local_port,
195            sock_namespace_str, remote_socket_name);
196 
197   const auto error = SendDeviceMessage(message);
198   if (error.Fail())
199     return error;
200 
201   return ReadResponseStatus();
202 }
203 
204 Error AdbClient::DeletePortForwarding(const uint16_t local_port) {
205   char message[32];
206   snprintf(message, sizeof(message), "killforward:tcp:%d", local_port);
207 
208   const auto error = SendDeviceMessage(message);
209   if (error.Fail())
210     return error;
211 
212   return ReadResponseStatus();
213 }
214 
215 Error AdbClient::SendMessage(const std::string &packet, const bool reconnect) {
216   Error error;
217   if (!m_conn || reconnect) {
218     error = Connect();
219     if (error.Fail())
220       return error;
221   }
222 
223   char length_buffer[5];
224   snprintf(length_buffer, sizeof(length_buffer), "%04x",
225            static_cast<int>(packet.size()));
226 
227   ConnectionStatus status;
228 
229   m_conn->Write(length_buffer, 4, status, &error);
230   if (error.Fail())
231     return error;
232 
233   m_conn->Write(packet.c_str(), packet.size(), status, &error);
234   return error;
235 }
236 
237 Error AdbClient::SendDeviceMessage(const std::string &packet) {
238   std::ostringstream msg;
239   msg << "host-serial:" << m_device_id << ":" << packet;
240   return SendMessage(msg.str());
241 }
242 
243 Error AdbClient::ReadMessage(std::vector<char> &message) {
244   message.clear();
245 
246   char buffer[5];
247   buffer[4] = 0;
248 
249   auto error = ReadAllBytes(buffer, 4);
250   if (error.Fail())
251     return error;
252 
253   unsigned int packet_len = 0;
254   sscanf(buffer, "%x", &packet_len);
255 
256   message.resize(packet_len, 0);
257   error = ReadAllBytes(&message[0], packet_len);
258   if (error.Fail())
259     message.clear();
260 
261   return error;
262 }
263 
264 Error AdbClient::ReadMessageStream(std::vector<char> &message,
265                                    uint32_t timeout_ms) {
266   auto start = std::chrono::steady_clock::now();
267   message.clear();
268 
269   Error error;
270   lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
271   char buffer[1024];
272   while (error.Success() && status == lldb::eConnectionStatusSuccess) {
273     auto end = std::chrono::steady_clock::now();
274     uint32_t elapsed_time =
275         std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
276             .count();
277     if (elapsed_time >= timeout_ms)
278       return Error("Timed out");
279 
280     size_t n = m_conn->Read(buffer, sizeof(buffer),
281                             1000 * (timeout_ms - elapsed_time), status, &error);
282     if (n > 0)
283       message.insert(message.end(), &buffer[0], &buffer[n]);
284   }
285   return error;
286 }
287 
288 Error AdbClient::ReadResponseStatus() {
289   char response_id[5];
290 
291   static const size_t packet_len = 4;
292   response_id[packet_len] = 0;
293 
294   auto error = ReadAllBytes(response_id, packet_len);
295   if (error.Fail())
296     return error;
297 
298   if (strncmp(response_id, kOKAY, packet_len) != 0)
299     return GetResponseError(response_id);
300 
301   return error;
302 }
303 
304 Error AdbClient::GetResponseError(const char *response_id) {
305   if (strcmp(response_id, kFAIL) != 0)
306     return Error("Got unexpected response id from adb: \"%s\"", response_id);
307 
308   std::vector<char> error_message;
309   auto error = ReadMessage(error_message);
310   if (error.Success())
311     error.SetErrorString(
312         std::string(&error_message[0], error_message.size()).c_str());
313 
314   return error;
315 }
316 
317 Error AdbClient::SwitchDeviceTransport() {
318   std::ostringstream msg;
319   msg << "host:transport:" << m_device_id;
320 
321   auto error = SendMessage(msg.str());
322   if (error.Fail())
323     return error;
324 
325   return ReadResponseStatus();
326 }
327 
328 Error AdbClient::StartSync() {
329   auto error = SwitchDeviceTransport();
330   if (error.Fail())
331     return Error("Failed to switch to device transport: %s", error.AsCString());
332 
333   error = Sync();
334   if (error.Fail())
335     return Error("Sync failed: %s", error.AsCString());
336 
337   return error;
338 }
339 
340 Error AdbClient::Sync() {
341   auto error = SendMessage("sync:", false);
342   if (error.Fail())
343     return error;
344 
345   return ReadResponseStatus();
346 }
347 
348 Error AdbClient::ReadAllBytes(void *buffer, size_t size) {
349   return ::ReadAllBytes(*m_conn, buffer, size);
350 }
351 
352 Error AdbClient::internalShell(const char *command, uint32_t timeout_ms,
353                                std::vector<char> &output_buf) {
354   output_buf.clear();
355 
356   auto error = SwitchDeviceTransport();
357   if (error.Fail())
358     return Error("Failed to switch to device transport: %s", error.AsCString());
359 
360   StreamString adb_command;
361   adb_command.Printf("shell:%s", command);
362   error = SendMessage(adb_command.GetData(), false);
363   if (error.Fail())
364     return error;
365 
366   error = ReadResponseStatus();
367   if (error.Fail())
368     return error;
369 
370   error = ReadMessageStream(output_buf, timeout_ms);
371   if (error.Fail())
372     return error;
373 
374   // ADB doesn't propagate return code of shell execution - if
375   // output starts with /system/bin/sh: most likely command failed.
376   static const char *kShellPrefix = "/system/bin/sh:";
377   if (output_buf.size() > strlen(kShellPrefix)) {
378     if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
379       return Error("Shell command %s failed: %s", command,
380                    std::string(output_buf.begin(), output_buf.end()).c_str());
381   }
382 
383   return Error();
384 }
385 
386 Error AdbClient::Shell(const char *command, uint32_t timeout_ms,
387                        std::string *output) {
388   std::vector<char> output_buffer;
389   auto error = internalShell(command, timeout_ms, output_buffer);
390   if (error.Fail())
391     return error;
392 
393   if (output)
394     output->assign(output_buffer.begin(), output_buffer.end());
395   return error;
396 }
397 
398 Error AdbClient::ShellToFile(const char *command, uint32_t timeout_ms,
399                              const FileSpec &output_file_spec) {
400   std::vector<char> output_buffer;
401   auto error = internalShell(command, timeout_ms, output_buffer);
402   if (error.Fail())
403     return error;
404 
405   const auto output_filename = output_file_spec.GetPath();
406   std::ofstream dst(output_filename, std::ios::out | std::ios::binary);
407   if (!dst.is_open())
408     return Error("Unable to open local file %s", output_filename.c_str());
409 
410   dst.write(&output_buffer[0], output_buffer.size());
411   dst.close();
412   if (!dst)
413     return Error("Failed to write file %s", output_filename.c_str());
414   return Error();
415 }
416 
417 std::unique_ptr<AdbClient::SyncService>
418 AdbClient::GetSyncService(Error &error) {
419   std::unique_ptr<SyncService> sync_service;
420   error = StartSync();
421   if (error.Success())
422     sync_service.reset(new SyncService(std::move(m_conn)));
423 
424   return sync_service;
425 }
426 
427 Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
428                                                const FileSpec &local_file) {
429   const auto local_file_path = local_file.GetPath();
430   llvm::FileRemover local_file_remover(local_file_path.c_str());
431 
432   std::ofstream dst(local_file_path, std::ios::out | std::ios::binary);
433   if (!dst.is_open())
434     return Error("Unable to open local file %s", local_file_path.c_str());
435 
436   const auto remote_file_path = remote_file.GetPath(false);
437   auto error = SendSyncRequest(kRECV, remote_file_path.length(),
438                                remote_file_path.c_str());
439   if (error.Fail())
440     return error;
441 
442   std::vector<char> chunk;
443   bool eof = false;
444   while (!eof) {
445     error = PullFileChunk(chunk, eof);
446     if (error.Fail())
447       return error;
448     if (!eof)
449       dst.write(&chunk[0], chunk.size());
450   }
451 
452   local_file_remover.releaseFile();
453   return error;
454 }
455 
456 Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
457                                                const FileSpec &remote_file) {
458   const auto local_file_path(local_file.GetPath());
459   std::ifstream src(local_file_path.c_str(), std::ios::in | std::ios::binary);
460   if (!src.is_open())
461     return Error("Unable to open local file %s", local_file_path.c_str());
462 
463   std::stringstream file_description;
464   file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode;
465   std::string file_description_str = file_description.str();
466   auto error = SendSyncRequest(kSEND, file_description_str.length(),
467                                file_description_str.c_str());
468   if (error.Fail())
469     return error;
470 
471   char chunk[kMaxPushData];
472   while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) {
473     size_t chunk_size = src.gcount();
474     error = SendSyncRequest(kDATA, chunk_size, chunk);
475     if (error.Fail())
476       return Error("Failed to send file chunk: %s", error.AsCString());
477   }
478   error = SendSyncRequest(kDONE, local_file.GetModificationTime().seconds(),
479                           nullptr);
480   if (error.Fail())
481     return error;
482 
483   std::string response_id;
484   uint32_t data_len;
485   error = ReadSyncHeader(response_id, data_len);
486   if (error.Fail())
487     return Error("Failed to read DONE response: %s", error.AsCString());
488   if (response_id == kFAIL) {
489     std::string error_message(data_len, 0);
490     error = ReadAllBytes(&error_message[0], data_len);
491     if (error.Fail())
492       return Error("Failed to read DONE error message: %s", error.AsCString());
493     return Error("Failed to push file: %s", error_message.c_str());
494   } else if (response_id != kOKAY)
495     return Error("Got unexpected DONE response: %s", response_id.c_str());
496 
497   // If there was an error reading the source file, finish the adb file
498   // transfer first so that adb isn't expecting any more data.
499   if (src.bad())
500     return Error("Failed read on %s", local_file_path.c_str());
501   return error;
502 }
503 
504 Error AdbClient::SyncService::internalStat(const FileSpec &remote_file,
505                                            uint32_t &mode, uint32_t &size,
506                                            uint32_t &mtime) {
507   const std::string remote_file_path(remote_file.GetPath(false));
508   auto error = SendSyncRequest(kSTAT, remote_file_path.length(),
509                                remote_file_path.c_str());
510   if (error.Fail())
511     return Error("Failed to send request: %s", error.AsCString());
512 
513   static const size_t stat_len = strlen(kSTAT);
514   static const size_t response_len = stat_len + (sizeof(uint32_t) * 3);
515 
516   std::vector<char> buffer(response_len);
517   error = ReadAllBytes(&buffer[0], buffer.size());
518   if (error.Fail())
519     return Error("Failed to read response: %s", error.AsCString());
520 
521   DataExtractor extractor(&buffer[0], buffer.size(), eByteOrderLittle,
522                           sizeof(void *));
523   offset_t offset = 0;
524 
525   const void *command = extractor.GetData(&offset, stat_len);
526   if (!command)
527     return Error("Failed to get response command");
528   const char *command_str = static_cast<const char *>(command);
529   if (strncmp(command_str, kSTAT, stat_len))
530     return Error("Got invalid stat command: %s", command_str);
531 
532   mode = extractor.GetU32(&offset);
533   size = extractor.GetU32(&offset);
534   mtime = extractor.GetU32(&offset);
535   return Error();
536 }
537 
538 Error AdbClient::SyncService::PullFile(const FileSpec &remote_file,
539                                        const FileSpec &local_file) {
540   return executeCommand([this, &remote_file, &local_file]() {
541     return internalPullFile(remote_file, local_file);
542   });
543 }
544 
545 Error AdbClient::SyncService::PushFile(const FileSpec &local_file,
546                                        const FileSpec &remote_file) {
547   return executeCommand([this, &local_file, &remote_file]() {
548     return internalPushFile(local_file, remote_file);
549   });
550 }
551 
552 Error AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode,
553                                    uint32_t &size, uint32_t &mtime) {
554   return executeCommand([this, &remote_file, &mode, &size, &mtime]() {
555     return internalStat(remote_file, mode, size, mtime);
556   });
557 }
558 
559 bool AdbClient::SyncService::IsConnected() const {
560   return m_conn && m_conn->IsConnected();
561 }
562 
563 AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn)
564     : m_conn(std::move(conn)) {}
565 
566 Error AdbClient::SyncService::executeCommand(
567     const std::function<Error()> &cmd) {
568   if (!m_conn)
569     return Error("SyncService is disconnected");
570 
571   const auto error = cmd();
572   if (error.Fail())
573     m_conn.reset();
574 
575   return error;
576 }
577 
578 AdbClient::SyncService::~SyncService() {}
579 
580 Error AdbClient::SyncService::SendSyncRequest(const char *request_id,
581                                               const uint32_t data_len,
582                                               const void *data) {
583   const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0));
584   DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *));
585   auto offset = encoder.PutData(0, request_id, strlen(request_id));
586   encoder.PutU32(offset, data_len);
587 
588   Error error;
589   ConnectionStatus status;
590   m_conn->Write(data_sp->GetBytes(), kSyncPacketLen, status, &error);
591   if (error.Fail())
592     return error;
593 
594   if (data)
595     m_conn->Write(data, data_len, status, &error);
596   return error;
597 }
598 
599 Error AdbClient::SyncService::ReadSyncHeader(std::string &response_id,
600                                              uint32_t &data_len) {
601   char buffer[kSyncPacketLen];
602 
603   auto error = ReadAllBytes(buffer, kSyncPacketLen);
604   if (error.Success()) {
605     response_id.assign(&buffer[0], 4);
606     DataExtractor extractor(&buffer[4], 4, eByteOrderLittle, sizeof(void *));
607     offset_t offset = 0;
608     data_len = extractor.GetU32(&offset);
609   }
610 
611   return error;
612 }
613 
614 Error AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer,
615                                             bool &eof) {
616   buffer.clear();
617 
618   std::string response_id;
619   uint32_t data_len;
620   auto error = ReadSyncHeader(response_id, data_len);
621   if (error.Fail())
622     return error;
623 
624   if (response_id == kDATA) {
625     buffer.resize(data_len, 0);
626     error = ReadAllBytes(&buffer[0], data_len);
627     if (error.Fail())
628       buffer.clear();
629   } else if (response_id == kDONE) {
630     eof = true;
631   } else if (response_id == kFAIL) {
632     std::string error_message(data_len, 0);
633     error = ReadAllBytes(&error_message[0], data_len);
634     if (error.Fail())
635       return Error("Failed to read pull error message: %s", error.AsCString());
636     return Error("Failed to pull file: %s", error_message.c_str());
637   } else
638     return Error("Pull failed with unknown response: %s", response_id.c_str());
639 
640   return Error();
641 }
642 
643 Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
644   return ::ReadAllBytes(*m_conn, buffer, size);
645 }
646