1 /*
2 * Copyright (C) 2021 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
17 #include "ServiceManagerHost.h"
18
19 #include <android-base/parseint.h>
20 #include <android-base/strings.h>
21 #include <binder/IServiceManager.h>
22 #include <binder/RpcSession.h>
23
24 #include "UtilsHost.h"
25
26 namespace android {
27
28 namespace {
29
30 const void* kDeviceServiceExtraId = "DeviceServiceExtra";
31
32 // Parse stdout of program execution to string. If any error, return 0.
parsePortNumber(const std::string & out,const std::string & what)33 unsigned int parsePortNumber(const std::string& out, const std::string& what) {
34 auto trimmed = android::base::Trim(out);
35 unsigned int port = 0;
36 if (!android::base::ParseUint(trimmed, &port)) {
37 int savedErrno = errno;
38 ALOGE("%s is not a valid %s: %s", trimmed.c_str(), what.c_str(), strerror(savedErrno));
39 return 0;
40 }
41 if (port == 0) {
42 ALOGE("0 is not a valid %s", what.c_str());
43 return 0; // explicitly
44 }
45 return port;
46 }
47
48 // RAII object for adb forwarding
49 class AdbForwarder {
50 public:
51 AdbForwarder() = default;
52 static std::optional<AdbForwarder> forward(unsigned int devicePort);
AdbForwarder(AdbForwarder && other)53 AdbForwarder(AdbForwarder&& other) noexcept { (*this) = std::move(other); }
54 AdbForwarder& operator=(AdbForwarder&&) noexcept;
55 ~AdbForwarder();
hostPort() const56 [[nodiscard]] const std::optional<unsigned int>& hostPort() const { return mPort; }
57
58 private:
59 DISALLOW_COPY_AND_ASSIGN(AdbForwarder);
AdbForwarder(unsigned int port)60 explicit AdbForwarder(unsigned int port) : mPort(port) {}
61 std::optional<unsigned int> mPort;
62 };
forward(unsigned int devicePort)63 std::optional<AdbForwarder> AdbForwarder::forward(unsigned int devicePort) {
64 auto result =
65 execute({"adb", "forward", "tcp:0", "tcp:" + std::to_string(devicePort)}, nullptr);
66 if (!result.ok()) {
67 ALOGE("Unable to run `adb forward tcp:0 tcp:%d`: %s", devicePort,
68 result.error().message().c_str());
69 return std::nullopt;
70 }
71 // Must end with exit code 0 (`has_value() && value() == 0`)
72 if (result->exitCode.value_or(1) != 0) {
73 ALOGE("Unable to run `adb forward tcp:0 tcp:%d`, command exits with %s", devicePort,
74 result->toString().c_str());
75 return std::nullopt;
76 }
77 if (!result->stderrStr.empty()) {
78 LOG_HOST("`adb forward tcp:0 tcp:%d` writes to stderr: %s", devicePort,
79 result->stderrStr.c_str());
80 }
81
82 unsigned int hostPort = parsePortNumber(result->stdoutStr, "host port");
83 if (hostPort == 0) return std::nullopt;
84
85 return AdbForwarder(hostPort);
86 }
87
operator =(AdbForwarder && other)88 AdbForwarder& AdbForwarder::operator=(AdbForwarder&& other) noexcept {
89 std::swap(mPort, other.mPort);
90 return *this;
91 }
92
~AdbForwarder()93 AdbForwarder::~AdbForwarder() {
94 if (!mPort.has_value()) return;
95
96 auto result = execute({"adb", "forward", "--remove", "tcp:" + std::to_string(*mPort)}, nullptr);
97 if (!result.ok()) {
98 ALOGE("Unable to run `adb forward --remove tcp:%d`: %s", *mPort,
99 result.error().message().c_str());
100 return;
101 }
102 // Must end with exit code 0 (`has_value() && value() == 0`)
103 if (result->exitCode.value_or(1) != 0) {
104 ALOGE("Unable to run `adb forward --remove tcp:%d`, command exits with %s", *mPort,
105 result->toString().c_str());
106 return;
107 }
108 if (!result->stderrStr.empty()) {
109 LOG_HOST("`adb forward --remove tcp:%d` writes to stderr: %s", *mPort,
110 result->stderrStr.c_str());
111 }
112
113 LOG_HOST("Successfully run `adb forward --remove tcp:%d`", *mPort);
114 }
115
cleanupCommandResult(const void * id,void * obj,void *)116 void cleanupCommandResult(const void* id, void* obj, void* /* cookie */) {
117 LOG_ALWAYS_FATAL_IF(id != kDeviceServiceExtraId,
118 "cleanupCommandResult invoked with mismatched ID %p, "
119 "expected %p",
120 id, kDeviceServiceExtraId);
121 auto ptr = static_cast<CommandResult*>(obj);
122 delete ptr;
123 }
124
125 } // namespace
126
getDeviceService(std::vector<std::string> && serviceDispatcherArgs,const RpcDelegateServiceManagerOptions & options)127 sp<IBinder> getDeviceService(std::vector<std::string>&& serviceDispatcherArgs,
128 const RpcDelegateServiceManagerOptions& options) {
129 std::vector<std::string> prefix{"adb", "shell", "servicedispatcher"};
130 serviceDispatcherArgs.insert(serviceDispatcherArgs.begin(), prefix.begin(), prefix.end());
131
132 auto result = execute(std::move(serviceDispatcherArgs), &CommandResult::stdoutEndsWithNewLine);
133 if (!result.ok()) {
134 ALOGE("%s", result.error().message().c_str());
135 return nullptr;
136 }
137
138 // `servicedispatcher` process must be alive to keep the port open.
139 if (result->exitCode.has_value()) {
140 ALOGE("Command exits with: %s", result->toString().c_str());
141 return nullptr;
142 }
143 if (!result->stderrStr.empty()) {
144 LOG_HOST("servicedispatcher writes to stderr: %s", result->stderrStr.c_str());
145 }
146
147 if (!result->stdoutEndsWithNewLine()) {
148 ALOGE("Unexpected command result: %s", result->toString().c_str());
149 return nullptr;
150 }
151
152 unsigned int devicePort = parsePortNumber(result->stdoutStr, "device port");
153 if (devicePort == 0) return nullptr;
154
155 auto forwardResult = AdbForwarder::forward(devicePort);
156 if (!forwardResult.has_value()) {
157 return nullptr;
158 }
159 LOG_ALWAYS_FATAL_IF(!forwardResult->hostPort().has_value());
160
161 auto rpcSession = RpcSession::make();
162 if (options.maxOutgoingConnections.has_value()) {
163 rpcSession->setMaxOutgoingConnections(*options.maxOutgoingConnections);
164 }
165
166 if (status_t status = rpcSession->setupInetClient("127.0.0.1", *forwardResult->hostPort());
167 status != OK) {
168 ALOGE("Unable to set up inet client on host port %u: %s", *forwardResult->hostPort(),
169 statusToString(status).c_str());
170 return nullptr;
171 }
172 auto binder = rpcSession->getRootObject();
173 if (binder == nullptr) {
174 ALOGE("RpcSession::getRootObject returns nullptr");
175 return nullptr;
176 }
177
178 LOG_ALWAYS_FATAL_IF(
179 nullptr !=
180 binder->attachObject(kDeviceServiceExtraId,
181 static_cast<void*>(new CommandResult(std::move(*result))), nullptr,
182 &cleanupCommandResult));
183 return binder;
184 }
185
186 } // namespace android
187