blob: 31d3dc63a0ad52b141a69e65923dfb1c8d35315f [file] [log] [blame]
Elliott Hughes38104452015-04-17 13:57:15 -07001/*
2 * Copyright (C) 2015 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
Yabin Cui19bec5b2015-09-22 15:52:57 -070017#define TRACE_TAG ADB
Elliott Hughes88b4c852015-04-30 17:32:03 -070018
Elliott Hughes38104452015-04-17 13:57:15 -070019#include "adb_utils.h"
Josh Gaoea7457b2016-08-30 15:39:25 -070020#include "adb_unique_fd.h"
Elliott Hughes38104452015-04-17 13:57:15 -070021
Elliott Hughes7cf35752015-04-17 17:03:59 -070022#include <stdlib.h>
Elliott Hughes38104452015-04-17 13:57:15 -070023#include <sys/stat.h>
24#include <sys/types.h>
25#include <unistd.h>
26
Elliott Hughes88b4c852015-04-30 17:32:03 -070027#include <algorithm>
Josh Gao62ff9d42016-08-30 15:23:35 -070028#include <vector>
Elliott Hughes88b4c852015-04-30 17:32:03 -070029
Colin Crosse6794072017-02-23 21:23:05 -080030#include <android-base/file.h>
Elliott Hughesf55ead92015-12-04 22:00:26 -080031#include <android-base/logging.h>
David Pursell19d0c232016-04-07 11:25:48 -070032#include <android-base/parseint.h>
Elliott Hughesf55ead92015-12-04 22:00:26 -080033#include <android-base/stringprintf.h>
34#include <android-base/strings.h>
Elliott Hughes88b4c852015-04-30 17:32:03 -070035
Josh Gao1eef4782015-11-20 15:37:31 -080036#include "adb.h"
Elliott Hughes88b4c852015-04-30 17:32:03 -070037#include "adb_trace.h"
Elliott Hughesdf5bb432015-04-19 13:17:01 -070038#include "sysdeps.h"
39
Yurii Zubrytskyic0889ab2016-05-25 15:17:10 -070040#ifdef _WIN32
41# ifndef WIN32_LEAN_AND_MEAN
42# define WIN32_LEAN_AND_MEAN
43# endif
44# include "windows.h"
45# include "shlobj.h"
Josh Gao62ff9d42016-08-30 15:23:35 -070046#else
47#include <pwd.h>
Yurii Zubrytskyic0889ab2016-05-25 15:17:10 -070048#endif
49
Spencer Low939d0002015-08-01 17:29:23 -070050
Josh Gao1eef4782015-11-20 15:37:31 -080051#if defined(_WIN32)
52constexpr char kNullFileName[] = "NUL";
53#else
54constexpr char kNullFileName[] = "/dev/null";
55#endif
56
57void close_stdin() {
58 int fd = unix_open(kNullFileName, O_RDONLY);
59 if (fd == -1) {
60 fatal_errno("failed to open %s", kNullFileName);
61 }
62
63 if (TEMP_FAILURE_RETRY(dup2(fd, STDIN_FILENO)) == -1) {
64 fatal_errno("failed to redirect stdin to %s", kNullFileName);
65 }
66 unix_close(fd);
67}
68
Elliott Hughes7cf35752015-04-17 17:03:59 -070069bool getcwd(std::string* s) {
70 char* cwd = getcwd(nullptr, 0);
71 if (cwd != nullptr) *s = cwd;
72 free(cwd);
73 return (cwd != nullptr);
74}
75
Elliott Hughes38104452015-04-17 13:57:15 -070076bool directory_exists(const std::string& path) {
77 struct stat sb;
Josh Gaoa0e185b2017-03-23 16:05:12 -070078 return stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode);
Elliott Hughes38104452015-04-17 13:57:15 -070079}
80
Elliott Hughes38104452015-04-17 13:57:15 -070081std::string escape_arg(const std::string& s) {
Elliott Hughes48db87f2015-04-17 20:50:11 -070082 std::string result = s;
Elliott Hughes38104452015-04-17 13:57:15 -070083
Elliott Hughesde52ce22015-05-15 12:06:00 -070084 // Escape any ' in the string (before we single-quote the whole thing).
85 // The correct way to do this for the shell is to replace ' with '\'' --- that is,
86 // close the existing single-quoted string, escape a single single-quote, and start
87 // a new single-quoted string. Like the C preprocessor, the shell will concatenate
88 // these pieces into one string.
89 for (size_t i = 0; i < s.size(); ++i) {
90 if (s[i] == '\'') {
91 result.insert(i, "'\\'");
92 i += 2;
93 }
Elliott Hughes38104452015-04-17 13:57:15 -070094 }
Elliott Hughes48db87f2015-04-17 20:50:11 -070095
96 // Prefix and suffix the whole string with '.
97 result.insert(result.begin(), '\'');
98 result.push_back('\'');
Elliott Hughes38104452015-04-17 13:57:15 -070099 return result;
100}
Elliott Hughes88b4c852015-04-30 17:32:03 -0700101
Spencer Low1ec9ceb2016-02-10 15:03:50 -0800102// Given a relative or absolute filepath, create the directory hierarchy
Spencer Low939d0002015-08-01 17:29:23 -0700103// as needed. Returns true if the hierarchy is/was setup.
Elliott Hughesd189cfb2015-07-30 17:42:01 -0700104bool mkdirs(const std::string& path) {
Spencer Low939d0002015-08-01 17:29:23 -0700105 // TODO: all the callers do unlink && mkdirs && adb_creat ---
106 // that's probably the operation we should expose.
107
108 // Implementation Notes:
109 //
110 // Pros:
111 // - Uses dirname, so does not need to deal with OS_PATH_SEPARATOR.
112 // - On Windows, uses mingw dirname which accepts '/' and '\\', drive letters
113 // (C:\foo), UNC paths (\\server\share\dir\dir\file), and Unicode (when
114 // combined with our adb_mkdir() which takes UTF-8).
115 // - Is optimistic wrt thinking that a deep directory hierarchy will exist.
116 // So it does as few stat()s as possible before doing mkdir()s.
117 // Cons:
118 // - Recursive, so it uses stack space relative to number of directory
119 // components.
120
Josh Gao49726bc2016-02-26 13:26:55 -0800121 // If path points to a symlink to a directory, that's fine.
122 struct stat sb;
123 if (stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) {
Spencer Low939d0002015-08-01 17:29:23 -0700124 return true;
125 }
126
Colin Crosse6794072017-02-23 21:23:05 -0800127 const std::string parent(android::base::Dirname(path));
Spencer Low1ec9ceb2016-02-10 15:03:50 -0800128
Spencer Low939d0002015-08-01 17:29:23 -0700129 // If dirname returned the same path as what we passed in, don't go recursive.
130 // This can happen on Windows when walking up the directory hierarchy and not
131 // finding anything that already exists (unlike POSIX that will eventually
132 // find . or /).
133 if (parent == path) {
134 errno = ENOENT;
135 return false;
136 }
137
Josh Gaofe1a6122015-11-04 14:51:23 -0800138 // Recursively make parent directories of 'path'.
Spencer Low939d0002015-08-01 17:29:23 -0700139 if (!mkdirs(parent)) {
140 return false;
141 }
142
Josh Gaofe1a6122015-11-04 14:51:23 -0800143 // Now that the parent directory hierarchy of 'path' has been ensured,
Spencer Low1ec9ceb2016-02-10 15:03:50 -0800144 // create path itself.
Josh Gaofe1a6122015-11-04 14:51:23 -0800145 if (adb_mkdir(path, 0775) == -1) {
Spencer Low939d0002015-08-01 17:29:23 -0700146 const int saved_errno = errno;
Spencer Low1ec9ceb2016-02-10 15:03:50 -0800147 // If someone else created the directory, that is ok.
148 if (directory_exists(path)) {
Spencer Low939d0002015-08-01 17:29:23 -0700149 return true;
150 }
Spencer Low1ec9ceb2016-02-10 15:03:50 -0800151 // There might be a pre-existing file at 'path', or there might have been some other error.
Spencer Low939d0002015-08-01 17:29:23 -0700152 errno = saved_errno;
153 return false;
154 }
155
156 return true;
Elliott Hughesd189cfb2015-07-30 17:42:01 -0700157}
158
Yabin Cui19bec5b2015-09-22 15:52:57 -0700159std::string dump_hex(const void* data, size_t byte_count) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700160 byte_count = std::min(byte_count, size_t(16));
161
162 const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
163
164 std::string line;
165 for (size_t i = 0; i < byte_count; ++i) {
166 android::base::StringAppendF(&line, "%02x", p[i]);
167 }
168 line.push_back(' ');
169
170 for (size_t i = 0; i < byte_count; ++i) {
Spencer Low28bc2cb2015-11-07 18:51:54 -0800171 int ch = p[i];
172 line.push_back(isprint(ch) ? ch : '.');
Elliott Hughes88b4c852015-04-30 17:32:03 -0700173 }
174
Yabin Cui19bec5b2015-09-22 15:52:57 -0700175 return line;
Elliott Hughes88b4c852015-04-30 17:32:03 -0700176}
Elliott Hughes09ccf1f2015-07-18 12:21:30 -0700177
Elliott Hughesb628cb12015-08-03 10:38:08 -0700178std::string perror_str(const char* msg) {
179 return android::base::StringPrintf("%s: %s", msg, strerror(errno));
180}
Yabin Cui5fc22312015-10-06 15:10:05 -0700181
182#if !defined(_WIN32)
Josh Gaoe7388122016-02-16 17:34:53 -0800183// Windows version provided in sysdeps_win32.cpp
Yabin Cui5fc22312015-10-06 15:10:05 -0700184bool set_file_block_mode(int fd, bool block) {
185 int flags = fcntl(fd, F_GETFL, 0);
186 if (flags == -1) {
187 PLOG(ERROR) << "failed to fcntl(F_GETFL) for fd " << fd;
188 return false;
189 }
190 flags = block ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);
191 if (fcntl(fd, F_SETFL, flags) != 0) {
192 PLOG(ERROR) << "failed to fcntl(F_SETFL) for fd " << fd << ", flags " << flags;
193 return false;
194 }
195 return true;
196}
197#endif
David Pursell19d0c232016-04-07 11:25:48 -0700198
199bool forward_targets_are_valid(const std::string& source, const std::string& dest,
200 std::string* error) {
201 if (android::base::StartsWith(source, "tcp:")) {
202 // The source port may be 0 to allow the system to select an open port.
203 int port;
204 if (!android::base::ParseInt(&source[4], &port) || port < 0) {
205 *error = android::base::StringPrintf("Invalid source port: '%s'", &source[4]);
206 return false;
207 }
208 }
209
210 if (android::base::StartsWith(dest, "tcp:")) {
211 // The destination port must be > 0.
212 int port;
213 if (!android::base::ParseInt(&dest[4], &port) || port <= 0) {
214 *error = android::base::StringPrintf("Invalid destination port: '%s'", &dest[4]);
215 return false;
216 }
217 }
218
219 return true;
220}
Yurii Zubrytskyicc3a8952016-05-27 11:07:40 -0700221
Josh Gao62ff9d42016-08-30 15:23:35 -0700222std::string adb_get_homedir_path() {
Yurii Zubrytskyic0889ab2016-05-25 15:17:10 -0700223#ifdef _WIN32
Yurii Zubrytskyic0889ab2016-05-25 15:17:10 -0700224 WCHAR path[MAX_PATH];
225 const HRESULT hr = SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, path);
226 if (FAILED(hr)) {
227 D("SHGetFolderPathW failed: %s", android::base::SystemErrorCodeToString(hr).c_str());
228 return {};
229 }
230 std::string home_str;
231 if (!android::base::WideToUTF8(path, &home_str)) {
232 return {};
233 }
234 return home_str;
235#else
236 if (const char* const home = getenv("HOME")) {
237 return home;
238 }
Josh Gao62ff9d42016-08-30 15:23:35 -0700239
240 struct passwd pwent;
241 struct passwd* result;
242 int pwent_max = sysconf(_SC_GETPW_R_SIZE_MAX);
243 std::vector<char> buf(pwent_max);
244 int rc = getpwuid_r(getuid(), &pwent, buf.data(), buf.size(), &result);
245 if (rc == 0 && result) {
246 return result->pw_dir;
247 }
248
249 LOG(FATAL) << "failed to get user home directory";
Yurii Zubrytskyic0889ab2016-05-25 15:17:10 -0700250 return {};
251#endif
252}
Josh Gao62ff9d42016-08-30 15:23:35 -0700253
254std::string adb_get_android_dir_path() {
255 std::string user_dir = adb_get_homedir_path();
256 std::string android_dir = user_dir + OS_PATH_SEPARATOR + ".android";
257 struct stat buf;
258 if (stat(android_dir.c_str(), &buf) == -1) {
259 if (adb_mkdir(android_dir.c_str(), 0750) == -1) {
260 PLOG(FATAL) << "Cannot mkdir '" << android_dir << "'";
261 }
262 }
263 return android_dir;
264}
Josh Gaoea7457b2016-08-30 15:39:25 -0700265
266void AdbCloser::Close(int fd) {
267 adb_close(fd);
268}
Elliott Hughes97e74bb2017-02-06 16:20:30 -0800269
270int usage(const char* fmt, ...) {
271 fprintf(stderr, "adb: ");
272
273 va_list ap;
274 va_start(ap, fmt);
275 vfprintf(stderr, fmt, ap);
276 va_end(ap);
277
278 fprintf(stderr, "\n");
279 return 1;
280}