Bug Summary

File:tools/lldb/source/Plugins/Platform/Android/AdbClient.cpp
Warning:line 88, column 13
2nd function call argument is an uninitialized value

Annotated Source Code

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/Host/ConnectionFileDescriptor.h"
19#include "lldb/Host/FileSpec.h"
20#include "lldb/Host/FileSystem.h"
21#include "lldb/Host/PosixApi.h"
22#include "lldb/Utility/DataBuffer.h"
23#include "lldb/Utility/DataBufferHeap.h"
24#include "lldb/Utility/DataEncoder.h"
25#include "lldb/Utility/DataExtractor.h"
26#include "lldb/Utility/StreamString.h"
27
28#include <limits.h>
29
30#include <algorithm>
31#include <cstdlib>
32#include <fstream>
33#include <sstream>
34
35// On Windows, transitive dependencies pull in <Windows.h>, which defines a
36// macro that clashes with a method name.
37#ifdef SendMessage
38#undef SendMessage
39#endif
40
41using namespace lldb;
42using namespace lldb_private;
43using namespace lldb_private::platform_android;
44using namespace std::chrono;
45
46namespace {
47
48const seconds kReadTimeout(8);
49const char *kOKAY = "OKAY";
50const char *kFAIL = "FAIL";
51const char *kDATA = "DATA";
52const char *kDONE = "DONE";
53
54const char *kSEND = "SEND";
55const char *kRECV = "RECV";
56const char *kSTAT = "STAT";
57
58const size_t kSyncPacketLen = 8;
59// Maximum size of a filesync DATA packet.
60const size_t kMaxPushData = 2 * 1024;
61// Default mode for pushed files.
62const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG
63
64const char *kSocketNamespaceAbstract = "localabstract";
65const char *kSocketNamespaceFileSystem = "localfilesystem";
66
67Error ReadAllBytes(Connection &conn, void *buffer, size_t size) {
68
69 Error error;
70 ConnectionStatus status;
6
'status' declared without an initial value
71 char *read_buffer = static_cast<char *>(buffer);
72
73 auto now = steady_clock::now();
74 const auto deadline = now + kReadTimeout;
75 size_t total_read_bytes = 0;
76 while (total_read_bytes < size && now < deadline) {
7
Assuming 'total_read_bytes' is < 'size'
8
Loop condition is false. Execution continues on line 87
77 auto read_bytes =
78 conn.Read(read_buffer + total_read_bytes, size - total_read_bytes,
79 duration_cast<microseconds>(deadline - now), 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)
9
Taking true branch
88 error = Error(
10
2nd function call argument is an uninitialized value
89 "Unable to read requested number of bytes. Connection status: %d.",
90 status);
91 return error;
92}
93
94} // namespace
95
96Error 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
126AdbClient::AdbClient() {}
127
128AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {}
129
130AdbClient::~AdbClient() {}
131
132void AdbClient::SetDeviceID(const std::string &device_id) {
133 m_device_id = device_id;
134}
135
136const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
137
138Error 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
146Error 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
173Error 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
186Error AdbClient::SetPortForwarding(const uint16_t local_port,
187 llvm::StringRef remote_socket_name,
188 const UnixSocketNamespace socket_namespace) {
189 char message[PATH_MAX4096];
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.str().c_str());
196
197 const auto error = SendDeviceMessage(message);
198 if (error.Fail())
199 return error;
200
201 return ReadResponseStatus();
202}
203
204Error 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
215Error 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
237Error 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
243Error 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
264Error AdbClient::ReadMessageStream(std::vector<char> &message,
265 milliseconds timeout) {
266 auto start = 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 = steady_clock::now();
274 auto elapsed = end - start;
275 if (elapsed >= timeout)
276 return Error("Timed out");
277
278 size_t n = m_conn->Read(buffer, sizeof(buffer),
279 duration_cast<microseconds>(timeout - elapsed),
280 status, &error);
281 if (n > 0)
282 message.insert(message.end(), &buffer[0], &buffer[n]);
283 }
284 return error;
285}
286
287Error AdbClient::ReadResponseStatus() {
288 char response_id[5];
289
290 static const size_t packet_len = 4;
291 response_id[packet_len] = 0;
292
293 auto error = ReadAllBytes(response_id, packet_len);
294 if (error.Fail())
295 return error;
296
297 if (strncmp(response_id, kOKAY, packet_len) != 0)
298 return GetResponseError(response_id);
299
300 return error;
301}
302
303Error AdbClient::GetResponseError(const char *response_id) {
304 if (strcmp(response_id, kFAIL) != 0)
305 return Error("Got unexpected response id from adb: \"%s\"", response_id);
306
307 std::vector<char> error_message;
308 auto error = ReadMessage(error_message);
309 if (error.Success())
310 error.SetErrorString(
311 std::string(&error_message[0], error_message.size()).c_str());
312
313 return error;
314}
315
316Error AdbClient::SwitchDeviceTransport() {
317 std::ostringstream msg;
318 msg << "host:transport:" << m_device_id;
319
320 auto error = SendMessage(msg.str());
321 if (error.Fail())
322 return error;
323
324 return ReadResponseStatus();
325}
326
327Error AdbClient::StartSync() {
328 auto error = SwitchDeviceTransport();
329 if (error.Fail())
330 return Error("Failed to switch to device transport: %s", error.AsCString());
331
332 error = Sync();
333 if (error.Fail())
334 return Error("Sync failed: %s", error.AsCString());
335
336 return error;
337}
338
339Error AdbClient::Sync() {
340 auto error = SendMessage("sync:", false);
341 if (error.Fail())
342 return error;
343
344 return ReadResponseStatus();
345}
346
347Error AdbClient::ReadAllBytes(void *buffer, size_t size) {
348 return ::ReadAllBytes(*m_conn, buffer, size);
349}
350
351Error AdbClient::internalShell(const char *command, milliseconds timeout,
352 std::vector<char> &output_buf) {
353 output_buf.clear();
354
355 auto error = SwitchDeviceTransport();
356 if (error.Fail())
357 return Error("Failed to switch to device transport: %s", error.AsCString());
358
359 StreamString adb_command;
360 adb_command.Printf("shell:%s", command);
361 error = SendMessage(adb_command.GetString(), false);
362 if (error.Fail())
363 return error;
364
365 error = ReadResponseStatus();
366 if (error.Fail())
367 return error;
368
369 error = ReadMessageStream(output_buf, timeout);
370 if (error.Fail())
371 return error;
372
373 // ADB doesn't propagate return code of shell execution - if
374 // output starts with /system/bin/sh: most likely command failed.
375 static const char *kShellPrefix = "/system/bin/sh:";
376 if (output_buf.size() > strlen(kShellPrefix)) {
377 if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
378 return Error("Shell command %s failed: %s", command,
379 std::string(output_buf.begin(), output_buf.end()).c_str());
380 }
381
382 return Error();
383}
384
385Error AdbClient::Shell(const char *command, milliseconds timeout,
386 std::string *output) {
387 std::vector<char> output_buffer;
388 auto error = internalShell(command, timeout, output_buffer);
389 if (error.Fail())
390 return error;
391
392 if (output)
393 output->assign(output_buffer.begin(), output_buffer.end());
394 return error;
395}
396
397Error AdbClient::ShellToFile(const char *command, milliseconds timeout,
398 const FileSpec &output_file_spec) {
399 std::vector<char> output_buffer;
400 auto error = internalShell(command, timeout, output_buffer);
401 if (error.Fail())
402 return error;
403
404 const auto output_filename = output_file_spec.GetPath();
405 std::ofstream dst(output_filename, std::ios::out | std::ios::binary);
406 if (!dst.is_open())
407 return Error("Unable to open local file %s", output_filename.c_str());
408
409 dst.write(&output_buffer[0], output_buffer.size());
410 dst.close();
411 if (!dst)
412 return Error("Failed to write file %s", output_filename.c_str());
413 return Error();
414}
415
416std::unique_ptr<AdbClient::SyncService>
417AdbClient::GetSyncService(Error &error) {
418 std::unique_ptr<SyncService> sync_service;
419 error = StartSync();
420 if (error.Success())
421 sync_service.reset(new SyncService(std::move(m_conn)));
422
423 return sync_service;
424}
425
426Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
427 const FileSpec &local_file) {
428 const auto local_file_path = local_file.GetPath();
429 llvm::FileRemover local_file_remover(local_file_path);
430
431 std::ofstream dst(local_file_path, std::ios::out | std::ios::binary);
432 if (!dst.is_open())
433 return Error("Unable to open local file %s", local_file_path.c_str());
434
435 const auto remote_file_path = remote_file.GetPath(false);
436 auto error = SendSyncRequest(kRECV, remote_file_path.length(),
437 remote_file_path.c_str());
438 if (error.Fail())
439 return error;
440
441 std::vector<char> chunk;
442 bool eof = false;
443 while (!eof) {
444 error = PullFileChunk(chunk, eof);
445 if (error.Fail())
446 return error;
447 if (!eof)
448 dst.write(&chunk[0], chunk.size());
449 }
450
451 local_file_remover.releaseFile();
452 return error;
453}
454
455Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
456 const FileSpec &remote_file) {
457 const auto local_file_path(local_file.GetPath());
458 std::ifstream src(local_file_path.c_str(), std::ios::in | std::ios::binary);
459 if (!src.is_open())
460 return Error("Unable to open local file %s", local_file_path.c_str());
461
462 std::stringstream file_description;
463 file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode;
464 std::string file_description_str = file_description.str();
465 auto error = SendSyncRequest(kSEND, file_description_str.length(),
466 file_description_str.c_str());
467 if (error.Fail())
468 return error;
469
470 char chunk[kMaxPushData];
471 while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) {
472 size_t chunk_size = src.gcount();
473 error = SendSyncRequest(kDATA, chunk_size, chunk);
474 if (error.Fail())
475 return Error("Failed to send file chunk: %s", error.AsCString());
476 }
477 error = SendSyncRequest(
478 kDONE, llvm::sys::toTimeT(FileSystem::GetModificationTime(local_file)),
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
504Error 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())
2
Assuming the condition is false
3
Taking false branch
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());
4
Calling 'SyncService::ReadAllBytes'
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
538Error 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
545Error 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
552Error 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);
1
Calling 'SyncService::internalStat'
556 });
557}
558
559bool AdbClient::SyncService::IsConnected() const {
560 return m_conn && m_conn->IsConnected();
561}
562
563AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn)
564 : m_conn(std::move(conn)) {}
565
566Error 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
578AdbClient::SyncService::~SyncService() {}
579
580Error 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
599Error 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
614Error 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
643Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
644 return ::ReadAllBytes(*m_conn, buffer, size);
5
Calling 'ReadAllBytes'
645}