1 /*
2 * Copyright (C) 2007 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 "minadbd_services.h"
18
19 #include <errno.h>
20 #include <inttypes.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include <functional>
27 #include <memory>
28 #include <set>
29 #include <string>
30 #include <string_view>
31 #include <thread>
32
33 #include <android-base/file.h>
34 #include <android-base/logging.h>
35 #include <android-base/memory.h>
36 #include <android-base/parseint.h>
37 #include <android-base/properties.h>
38 #include <android-base/stringprintf.h>
39 #include <android-base/strings.h>
40
41 #include "adb.h"
42 #include "adb_unique_fd.h"
43 #include "adb_utils.h"
44 #include "fuse_adb_provider.h"
45 #include "fuse_sideload.h"
46 #include "minadbd/types.h"
47 #include "recovery_utils/battery_utils.h"
48 #include "services.h"
49 #include "sysdeps.h"
50
51 static int minadbd_socket = -1;
52 static bool rescue_mode = false;
53 static std::string sideload_mount_point = FUSE_SIDELOAD_HOST_MOUNTPOINT;
54
SetMinadbdSocketFd(int socket_fd)55 void SetMinadbdSocketFd(int socket_fd) {
56 minadbd_socket = socket_fd;
57 }
58
SetMinadbdRescueMode(bool rescue)59 void SetMinadbdRescueMode(bool rescue) {
60 rescue_mode = rescue;
61 }
62
SetSideloadMountPoint(const std::string & path)63 void SetSideloadMountPoint(const std::string& path) {
64 sideload_mount_point = path;
65 }
66
WriteCommandToFd(MinadbdCommand cmd,int fd)67 static bool WriteCommandToFd(MinadbdCommand cmd, int fd) {
68 char message[kMinadbdMessageSize];
69 memcpy(message, kMinadbdCommandPrefix, strlen(kMinadbdStatusPrefix));
70 android::base::put_unaligned(message + strlen(kMinadbdStatusPrefix), cmd);
71
72 if (!android::base::WriteFully(fd, message, kMinadbdMessageSize)) {
73 PLOG(ERROR) << "Failed to write message " << message;
74 return false;
75 }
76 return true;
77 }
78
79 // Blocks and reads the command status from |fd|. Returns false if the received message has a
80 // format error.
WaitForCommandStatus(int fd,MinadbdCommandStatus * status)81 static bool WaitForCommandStatus(int fd, MinadbdCommandStatus* status) {
82 char buffer[kMinadbdMessageSize];
83 if (!android::base::ReadFully(fd, buffer, kMinadbdMessageSize)) {
84 PLOG(ERROR) << "Failed to response status from socket";
85 exit(kMinadbdSocketIOError);
86 }
87
88 std::string message(buffer, buffer + kMinadbdMessageSize);
89 if (!android::base::StartsWith(message, kMinadbdStatusPrefix)) {
90 LOG(ERROR) << "Failed to parse status in " << message;
91 return false;
92 }
93
94 *status = android::base::get_unaligned<MinadbdCommandStatus>(
95 message.substr(strlen(kMinadbdStatusPrefix)).c_str());
96 return true;
97 }
98
RunAdbFuseSideload(int sfd,const std::string & args,MinadbdCommandStatus * status)99 static MinadbdErrorCode RunAdbFuseSideload(int sfd, const std::string& args,
100 MinadbdCommandStatus* status) {
101 auto pieces = android::base::Split(args, ":");
102 int64_t file_size;
103 int block_size;
104 if (pieces.size() != 2 || !android::base::ParseInt(pieces[0], &file_size) || file_size <= 0 ||
105 !android::base::ParseInt(pieces[1], &block_size) || block_size <= 0) {
106 LOG(ERROR) << "bad sideload-host arguments: " << args;
107 return kMinadbdHostCommandArgumentError;
108 }
109
110 LOG(INFO) << "sideload-host file size " << file_size << ", block size " << block_size;
111
112 if (!WriteCommandToFd(MinadbdCommand::kInstall, minadbd_socket)) {
113 return kMinadbdSocketIOError;
114 }
115
116 auto adb_data_reader = std::make_unique<FuseAdbDataProvider>(sfd, file_size, block_size);
117 if (int result = run_fuse_sideload(std::move(adb_data_reader), sideload_mount_point.c_str());
118 result != 0) {
119 LOG(ERROR) << "Failed to start fuse";
120 return kMinadbdFuseStartError;
121 }
122
123 if (!WaitForCommandStatus(minadbd_socket, status)) {
124 return kMinadbdMessageFormatError;
125 }
126
127 // Signal host-side adb to stop. For sideload mode, we always send kMinadbdServicesExitSuccess
128 // (i.e. "DONEDONE") regardless of the install result. For rescue mode, we send failure message on
129 // install error.
130 if (!rescue_mode || *status == MinadbdCommandStatus::kSuccess) {
131 if (!android::base::WriteFully(sfd, kMinadbdServicesExitSuccess,
132 strlen(kMinadbdServicesExitSuccess))) {
133 return kMinadbdHostSocketIOError;
134 }
135 } else {
136 if (!android::base::WriteFully(sfd, kMinadbdServicesExitFailure,
137 strlen(kMinadbdServicesExitFailure))) {
138 return kMinadbdHostSocketIOError;
139 }
140 }
141
142 return kMinadbdSuccess;
143 }
144
145 // Sideload service always exits after serving an install command.
SideloadHostService(unique_fd sfd,const std::string & args)146 static void SideloadHostService(unique_fd sfd, const std::string& args) {
147 MinadbdCommandStatus status;
148 exit(RunAdbFuseSideload(sfd.get(), args, &status));
149 }
150
151 // Rescue service waits for the next command after an install command.
RescueInstallHostService(unique_fd sfd,const std::string & args)152 static void RescueInstallHostService(unique_fd sfd, const std::string& args) {
153 MinadbdCommandStatus status;
154 if (auto result = RunAdbFuseSideload(sfd.get(), args, &status); result != kMinadbdSuccess) {
155 exit(result);
156 }
157 }
158
159 // Answers the query on a given property |prop|, by writing the result to the given |sfd|. The
160 // result will be newline-terminated, so nonexistent or nonallowed query will be answered with "\n".
161 // If given an empty string, dumps all the supported properties (analogous to `adb shell getprop`)
162 // in lines, e.g. "[prop]: [value]".
RescueGetpropHostService(unique_fd sfd,const std::string & prop)163 static void RescueGetpropHostService(unique_fd sfd, const std::string& prop) {
164 constexpr const char* kRescueBatteryLevelProp = "rescue.battery_level";
165 static const std::set<std::string> kGetpropAllowedProps = {
166 // clang-format off
167 kRescueBatteryLevelProp,
168 "ro.build.date.utc",
169 "ro.build.fingerprint",
170 "ro.build.flavor",
171 "ro.build.id",
172 "ro.build.product",
173 "ro.build.tags",
174 "ro.build.version.incremental",
175 "ro.product.device",
176 "ro.product.vendor.device",
177 // clang-format on
178 };
179
180 auto query_prop = [](const std::string& key) {
181 if (key == kRescueBatteryLevelProp) {
182 auto battery_info = GetBatteryInfo();
183 return std::to_string(battery_info.capacity);
184 }
185 return android::base::GetProperty(key, "");
186 };
187
188 std::string result;
189 if (prop.empty()) {
190 for (const auto& key : kGetpropAllowedProps) {
191 auto value = query_prop(key);
192 if (value.empty()) {
193 continue;
194 }
195 result += "[" + key + "]: [" + value + "]\n";
196 }
197 } else if (kGetpropAllowedProps.find(prop) != kGetpropAllowedProps.end()) {
198 result = query_prop(prop) + "\n";
199 }
200 if (result.empty()) {
201 result = "\n";
202 }
203 if (!android::base::WriteFully(sfd, result.data(), result.size())) {
204 exit(kMinadbdHostSocketIOError);
205 }
206
207 // Send heartbeat signal to keep the rescue service alive.
208 if (!WriteCommandToFd(MinadbdCommand::kNoOp, minadbd_socket)) {
209 exit(kMinadbdSocketIOError);
210 }
211 if (MinadbdCommandStatus status; !WaitForCommandStatus(minadbd_socket, &status)) {
212 exit(kMinadbdMessageFormatError);
213 }
214 }
215
216 // Reboots into the given target. We don't reboot directly from minadbd, but going through recovery
217 // instead. This allows recovery to finish all the pending works (clear BCB, save logs etc) before
218 // the reboot.
RebootHostService(unique_fd,const std::string & target)219 static void RebootHostService(unique_fd /* sfd */, const std::string& target) {
220 MinadbdCommand command;
221 if (target == "bootloader") {
222 command = MinadbdCommand::kRebootBootloader;
223 } else if (target == "rescue") {
224 command = MinadbdCommand::kRebootRescue;
225 } else if (target == "recovery") {
226 command = MinadbdCommand::kRebootRecovery;
227 } else if (target == "fastboot") {
228 command = MinadbdCommand::kRebootFastboot;
229 } else {
230 command = MinadbdCommand::kRebootAndroid;
231 }
232 if (!WriteCommandToFd(command, minadbd_socket)) {
233 exit(kMinadbdSocketIOError);
234 }
235 MinadbdCommandStatus status;
236 if (!WaitForCommandStatus(minadbd_socket, &status)) {
237 exit(kMinadbdMessageFormatError);
238 }
239 }
240
WipeDeviceService(unique_fd fd,const std::string & args)241 static void WipeDeviceService(unique_fd fd, const std::string& args) {
242 auto pieces = android::base::Split(args, ":");
243 if (pieces.size() != 2 || pieces[0] != "userdata") {
244 LOG(ERROR) << "Failed to parse wipe device command arguments " << args;
245 exit(kMinadbdHostCommandArgumentError);
246 }
247
248 size_t message_size;
249 if (!android::base::ParseUint(pieces[1], &message_size) ||
250 message_size < strlen(kMinadbdServicesExitSuccess)) {
251 LOG(ERROR) << "Failed to parse wipe device message size in " << args;
252 exit(kMinadbdHostCommandArgumentError);
253 }
254
255 WriteCommandToFd(MinadbdCommand::kWipeData, minadbd_socket);
256 MinadbdCommandStatus status;
257 if (!WaitForCommandStatus(minadbd_socket, &status)) {
258 exit(kMinadbdMessageFormatError);
259 }
260
261 std::string response = (status == MinadbdCommandStatus::kSuccess) ? kMinadbdServicesExitSuccess
262 : kMinadbdServicesExitFailure;
263 response += std::string(message_size - response.size(), '\0');
264 if (!android::base::WriteFully(fd, response.c_str(), response.size())) {
265 exit(kMinadbdHostSocketIOError);
266 }
267 }
268
daemon_service_to_socket(std::string_view)269 asocket* daemon_service_to_socket(std::string_view) {
270 return nullptr;
271 }
272
daemon_service_to_fd(std::string_view name,atransport *)273 unique_fd daemon_service_to_fd(std::string_view name, atransport* /* transport */) {
274 // Common services that are supported both in sideload and rescue modes.
275 if (android::base::ConsumePrefix(&name, "reboot:")) {
276 // "reboot:<target>", where target must be one of the following.
277 std::string args(name);
278 if (args.empty() || args == "bootloader" || args == "rescue" || args == "recovery" ||
279 args == "fastboot") {
280 return create_service_thread("reboot",
281 std::bind(RebootHostService, std::placeholders::_1, args));
282 }
283 return unique_fd{};
284 }
285
286 // Rescue-specific services.
287 if (rescue_mode) {
288 if (android::base::ConsumePrefix(&name, "rescue-install:")) {
289 // rescue-install:<file-size>:<block-size>
290 std::string args(name);
291 return create_service_thread(
292 "rescue-install", std::bind(RescueInstallHostService, std::placeholders::_1, args));
293 } else if (android::base::ConsumePrefix(&name, "rescue-getprop:")) {
294 // rescue-getprop:<prop>
295 std::string args(name);
296 return create_service_thread(
297 "rescue-getprop", std::bind(RescueGetpropHostService, std::placeholders::_1, args));
298 } else if (android::base::ConsumePrefix(&name, "rescue-wipe:")) {
299 // rescue-wipe:target:<message-size>
300 std::string args(name);
301 return create_service_thread("rescue-wipe",
302 std::bind(WipeDeviceService, std::placeholders::_1, args));
303 }
304
305 return unique_fd{};
306 }
307
308 // Sideload-specific services.
309 if (name.starts_with("sideload:")) {
310 // This exit status causes recovery to print a special error message saying to use a newer adb
311 // (that supports sideload-host).
312 exit(kMinadbdAdbVersionError);
313 } else if (android::base::ConsumePrefix(&name, "sideload-host:")) {
314 // sideload-host:<file-size>:<block-size>
315 std::string args(name);
316 return create_service_thread("sideload-host",
317 std::bind(SideloadHostService, std::placeholders::_1, args));
318 }
319 return unique_fd{};
320 }
321