blob: 42191c6f35f7a11a7e3761293b848ebfa7c110fa [file] [log] [blame]
Elliott Hughes58305772015-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
Elliott Hughese67f1f82015-04-30 17:32:03 -070017#define TRACE_TAG TRACE_ADB
18
Elliott Hughes58305772015-04-17 13:57:15 -070019#include "adb_utils.h"
20
Elliott Hughesa7090b92015-04-17 17:03:59 -070021#include <stdlib.h>
Elliott Hughes58305772015-04-17 13:57:15 -070022#include <sys/stat.h>
23#include <sys/types.h>
24#include <unistd.h>
25
Elliott Hughese67f1f82015-04-30 17:32:03 -070026#include <algorithm>
27
Elliott Hughes3d5f60d2015-07-18 12:21:30 -070028#include <base/logging.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070029#include <base/stringprintf.h>
Elliott Hughes3d5f60d2015-07-18 12:21:30 -070030#include <base/strings.h>
Elliott Hughes381cfa92015-07-23 17:12:58 -070031#include <cutils/sockets.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070032
33#include "adb_trace.h"
Elliott Hughes53daee62015-04-19 13:17:01 -070034#include "sysdeps.h"
35
Elliott Hughesd48dbd82015-07-24 11:35:40 -070036#if defined(_WIN32)
37#include <ws2tcpip.h>
38#else
39#include <netdb.h>
40#endif
41
Elliott Hughesa7090b92015-04-17 17:03:59 -070042bool getcwd(std::string* s) {
43 char* cwd = getcwd(nullptr, 0);
44 if (cwd != nullptr) *s = cwd;
45 free(cwd);
46 return (cwd != nullptr);
47}
48
Elliott Hughes58305772015-04-17 13:57:15 -070049bool directory_exists(const std::string& path) {
50 struct stat sb;
51 return lstat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode);
52}
53
Elliott Hughes58305772015-04-17 13:57:15 -070054std::string escape_arg(const std::string& s) {
Elliott Hughes5498ade2015-04-17 20:50:11 -070055 std::string result = s;
Elliott Hughes58305772015-04-17 13:57:15 -070056
Elliott Hughes84b0bf22015-05-15 12:06:00 -070057 // Escape any ' in the string (before we single-quote the whole thing).
58 // The correct way to do this for the shell is to replace ' with '\'' --- that is,
59 // close the existing single-quoted string, escape a single single-quote, and start
60 // a new single-quoted string. Like the C preprocessor, the shell will concatenate
61 // these pieces into one string.
62 for (size_t i = 0; i < s.size(); ++i) {
63 if (s[i] == '\'') {
64 result.insert(i, "'\\'");
65 i += 2;
66 }
Elliott Hughes58305772015-04-17 13:57:15 -070067 }
Elliott Hughes5498ade2015-04-17 20:50:11 -070068
69 // Prefix and suffix the whole string with '.
70 result.insert(result.begin(), '\'');
71 result.push_back('\'');
Elliott Hughes58305772015-04-17 13:57:15 -070072 return result;
73}
Elliott Hughese67f1f82015-04-30 17:32:03 -070074
Alex Vallée47d67c92015-05-06 16:26:00 -040075bool mkdirs(const std::string& path) {
76 for (size_t i = adb_dirstart(path, 1); i != std::string::npos; i = adb_dirstart(path, i + 1)) {
77 if (adb_mkdir(path.substr(0, i), 0775) == -1 && errno != EEXIST) {
78 return false;
Alex Vallée14216142015-05-06 17:22:25 -040079 }
Alex Vallée14216142015-05-06 17:22:25 -040080 }
Alex Vallée47d67c92015-05-06 16:26:00 -040081 return true;
Alex Vallée14216142015-05-06 17:22:25 -040082}
83
Elliott Hughese67f1f82015-04-30 17:32:03 -070084void dump_hex(const void* data, size_t byte_count) {
85 byte_count = std::min(byte_count, size_t(16));
86
87 const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
88
89 std::string line;
90 for (size_t i = 0; i < byte_count; ++i) {
91 android::base::StringAppendF(&line, "%02x", p[i]);
92 }
93 line.push_back(' ');
94
95 for (size_t i = 0; i < byte_count; ++i) {
96 int c = p[i];
97 if (c < 32 || c > 127) {
98 c = '.';
99 }
100 line.push_back(c);
101 }
102
103 DR("%s\n", line.c_str());
104}
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700105
106bool parse_host_and_port(const std::string& address,
107 std::string* canonical_address,
108 std::string* host, int* port,
109 std::string* error) {
110 host->clear();
111
112 bool ipv6 = true;
113 bool saw_port = false;
114 size_t colons = std::count(address.begin(), address.end(), ':');
115 size_t dots = std::count(address.begin(), address.end(), '.');
116 std::string port_str;
117 if (address[0] == '[') {
118 // [::1]:123
119 if (address.rfind("]:") == std::string::npos) {
120 *error = android::base::StringPrintf("bad IPv6 address '%s'", address.c_str());
121 return false;
122 }
123 *host = address.substr(1, (address.find("]:") - 1));
124 port_str = address.substr(address.rfind("]:") + 2);
125 saw_port = true;
126 } else if (dots == 0 && colons >= 2 && colons <= 7) {
127 // ::1
128 *host = address;
129 } else if (colons <= 1) {
130 // 1.2.3.4 or some.accidental.domain.com
131 ipv6 = false;
132 std::vector<std::string> pieces = android::base::Split(address, ":");
133 *host = pieces[0];
134 if (pieces.size() > 1) {
135 port_str = pieces[1];
136 saw_port = true;
137 }
138 }
139
140 if (host->empty()) {
141 *error = android::base::StringPrintf("no host in '%s'", address.c_str());
142 return false;
143 }
144
145 if (saw_port) {
146 if (sscanf(port_str.c_str(), "%d", port) != 1 || *port <= 0 || *port > 65535) {
147 *error = android::base::StringPrintf("bad port number '%s' in '%s'",
148 port_str.c_str(), address.c_str());
149 return false;
150 }
151 }
152
153 *canonical_address = android::base::StringPrintf(ipv6 ? "[%s]:%d" : "%s:%d", host->c_str(), *port);
154 LOG(DEBUG) << "parsed " << address << " as " << *host << " and " << *port
155 << " (" << *canonical_address << ")";
156 return true;
157}
Elliott Hughes381cfa92015-07-23 17:12:58 -0700158
159int network_connect(const std::string& host, int port, int type, int timeout, std::string* error) {
160 int getaddrinfo_error = 0;
161 int fd = socket_network_client_timeout(host.c_str(), port, type, timeout, &getaddrinfo_error);
162 if (fd != -1) {
163 return fd;
164 }
165 if (getaddrinfo_error != 0) {
Elliott Hughesd48dbd82015-07-24 11:35:40 -0700166 // TODO: gai_strerror is not thread safe on Win32.
Elliott Hughes381cfa92015-07-23 17:12:58 -0700167 *error = gai_strerror(getaddrinfo_error);
168 } else {
169 *error = strerror(errno);
170 }
171 return -1;
172}