1/*
2 * Copyright (C) 2016 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#define LOG_TAG "dumpstate"
18
19#include "DumpstateUtil.h"
20
21#include <dirent.h>
22#include <fcntl.h>
23#include <sys/prctl.h>
24#include <sys/wait.h>
25#include <unistd.h>
26
27#include <vector>
28
29#include <android-base/file.h>
30#include <android-base/properties.h>
31#include <android-base/stringprintf.h>
32#include <android-base/strings.h>
33#include <android-base/unique_fd.h>
34#include <log/log.h>
35
36#include "DumpstateInternal.h"
37
38namespace android {
39namespace os {
40namespace dumpstate {
41
42namespace {
43
44static constexpr const char* kSuPath = "/system/xbin/su";
45
46static bool waitpid_with_timeout(pid_t pid, int timeout_ms, int* status) {
47    sigset_t child_mask, old_mask;
48    sigemptyset(&child_mask);
49    sigaddset(&child_mask, SIGCHLD);
50
51    if (sigprocmask(SIG_BLOCK, &child_mask, &old_mask) == -1) {
52        printf("*** sigprocmask failed: %s\n", strerror(errno));
53        return false;
54    }
55
56    timespec ts;
57    ts.tv_sec = MSEC_TO_SEC(timeout_ms);
58    ts.tv_nsec = (timeout_ms % 1000) * 1000000;
59    int ret = TEMP_FAILURE_RETRY(sigtimedwait(&child_mask, NULL, &ts));
60    int saved_errno = errno;
61
62    // Set the signals back the way they were.
63    if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
64        printf("*** sigprocmask failed: %s\n", strerror(errno));
65        if (ret == 0) {
66            return false;
67        }
68    }
69    if (ret == -1) {
70        errno = saved_errno;
71        if (errno == EAGAIN) {
72            errno = ETIMEDOUT;
73        } else {
74            printf("*** sigtimedwait failed: %s\n", strerror(errno));
75        }
76        return false;
77    }
78
79    pid_t child_pid = waitpid(pid, status, WNOHANG);
80    if (child_pid != pid) {
81        if (child_pid != -1) {
82            printf("*** Waiting for pid %d, got pid %d instead\n", pid, child_pid);
83        } else {
84            printf("*** waitpid failed: %s\n", strerror(errno));
85        }
86        return false;
87    }
88    return true;
89}
90}  // unnamed namespace
91
92CommandOptions CommandOptions::DEFAULT = CommandOptions::WithTimeout(10).Build();
93CommandOptions CommandOptions::AS_ROOT = CommandOptions::WithTimeout(10).AsRoot().Build();
94
95CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(int64_t timeout_ms) : values(timeout_ms) {
96}
97
98CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Always() {
99    values.always_ = true;
100    return *this;
101}
102
103CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::AsRoot() {
104    values.account_mode_ = SU_ROOT;
105    return *this;
106}
107
108CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::AsRootIfAvailable() {
109    if (!PropertiesHelper::IsUserBuild())
110        values.account_mode_ = SU_ROOT;
111    return *this;
112}
113
114CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::DropRoot() {
115    values.account_mode_ = DROP_ROOT;
116    return *this;
117}
118
119CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::RedirectStderr() {
120    values.output_mode_ = REDIRECT_TO_STDERR;
121    return *this;
122}
123
124CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Log(
125    const std::string& message) {
126    values.logging_message_ = message;
127    return *this;
128}
129
130CommandOptions CommandOptions::CommandOptionsBuilder::Build() {
131    return CommandOptions(values);
132}
133
134CommandOptions::CommandOptionsValues::CommandOptionsValues(int64_t timeout_ms)
135    : timeout_ms_(timeout_ms),
136      always_(false),
137      account_mode_(DONT_DROP_ROOT),
138      output_mode_(NORMAL_OUTPUT),
139      logging_message_("") {
140}
141
142CommandOptions::CommandOptions(const CommandOptionsValues& values) : values(values) {
143}
144
145int64_t CommandOptions::Timeout() const {
146    return MSEC_TO_SEC(values.timeout_ms_);
147}
148
149int64_t CommandOptions::TimeoutInMs() const {
150    return values.timeout_ms_;
151}
152
153bool CommandOptions::Always() const {
154    return values.always_;
155}
156
157PrivilegeMode CommandOptions::PrivilegeMode() const {
158    return values.account_mode_;
159}
160
161OutputMode CommandOptions::OutputMode() const {
162    return values.output_mode_;
163}
164
165std::string CommandOptions::LoggingMessage() const {
166    return values.logging_message_;
167}
168
169CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeout(int64_t timeout_sec) {
170    return CommandOptions::CommandOptionsBuilder(SEC_TO_MSEC(timeout_sec));
171}
172
173CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeoutInMs(int64_t timeout_ms) {
174    return CommandOptions::CommandOptionsBuilder(timeout_ms);
175}
176
177std::string PropertiesHelper::build_type_ = "";
178int PropertiesHelper::dry_run_ = -1;
179
180bool PropertiesHelper::IsUserBuild() {
181    if (build_type_.empty()) {
182        build_type_ = android::base::GetProperty("ro.build.type", "user");
183    }
184    return "user" == build_type_;
185}
186
187bool PropertiesHelper::IsDryRun() {
188    if (dry_run_ == -1) {
189        dry_run_ = android::base::GetBoolProperty("dumpstate.dry_run", false) ? 1 : 0;
190    }
191    return dry_run_ == 1;
192}
193
194int DumpFileToFd(int out_fd, const std::string& title, const std::string& path) {
195    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
196    if (fd.get() < 0) {
197        int err = errno;
198        if (title.empty()) {
199            dprintf(out_fd, "*** Error dumping %s: %s\n", path.c_str(), strerror(err));
200        } else {
201            dprintf(out_fd, "*** Error dumping %s (%s): %s\n", path.c_str(), title.c_str(),
202                    strerror(err));
203        }
204        fsync(out_fd);
205        return -1;
206    }
207    return DumpFileFromFdToFd(title, path, fd.get(), out_fd, PropertiesHelper::IsDryRun());
208}
209
210int RunCommandToFd(int fd, const std::string& title, const std::vector<std::string>& full_command,
211                   const CommandOptions& options) {
212    if (full_command.empty()) {
213        MYLOGE("No arguments on RunCommandToFd(%s)\n", title.c_str());
214        return -1;
215    }
216
217    int size = full_command.size() + 1;  // null terminated
218    int starting_index = 0;
219    if (options.PrivilegeMode() == SU_ROOT) {
220        starting_index = 2;  // "su" "root"
221        size += starting_index;
222    }
223
224    std::vector<const char*> args;
225    args.resize(size);
226
227    std::string command_string;
228    if (options.PrivilegeMode() == SU_ROOT) {
229        args[0] = kSuPath;
230        command_string += kSuPath;
231        args[1] = "root";
232        command_string += " root ";
233    }
234    for (size_t i = 0; i < full_command.size(); i++) {
235        args[i + starting_index] = full_command[i].data();
236        command_string += args[i + starting_index];
237        if (i != full_command.size() - 1) {
238            command_string += " ";
239        }
240    }
241    args[size - 1] = nullptr;
242
243    const char* command = command_string.c_str();
244
245    if (options.PrivilegeMode() == SU_ROOT && PropertiesHelper::IsUserBuild()) {
246        dprintf(fd, "Skipping '%s' on user build.\n", command);
247        return 0;
248    }
249
250    if (!title.empty()) {
251        dprintf(fd, "------ %s (%s) ------\n", title.c_str(), command);
252        fsync(fd);
253    }
254
255    const std::string& logging_message = options.LoggingMessage();
256    if (!logging_message.empty()) {
257        MYLOGI(logging_message.c_str(), command_string.c_str());
258    }
259
260    bool silent = (options.OutputMode() == REDIRECT_TO_STDERR);
261    bool redirecting_to_fd = STDOUT_FILENO != fd;
262
263    if (PropertiesHelper::IsDryRun() && !options.Always()) {
264        if (!title.empty()) {
265            dprintf(fd, "\t(skipped on dry run)\n");
266        } else if (redirecting_to_fd) {
267            // There is no title, but we should still print a dry-run message
268            dprintf(fd, "%s: skipped on dry run\n", command_string.c_str());
269        }
270        fsync(fd);
271        return 0;
272    }
273
274    const char* path = args[0];
275
276    uint64_t start = Nanotime();
277    pid_t pid = fork();
278
279    /* handle error case */
280    if (pid < 0) {
281        if (!silent) dprintf(fd, "*** fork: %s\n", strerror(errno));
282        MYLOGE("*** fork: %s\n", strerror(errno));
283        return pid;
284    }
285
286    /* handle child case */
287    if (pid == 0) {
288        if (options.PrivilegeMode() == DROP_ROOT && !DropRootUser()) {
289            if (!silent) {
290                dprintf(fd, "*** failed to drop root before running %s: %s\n", command,
291                        strerror(errno));
292            }
293            MYLOGE("*** could not drop root before running %s: %s\n", command, strerror(errno));
294            return -1;
295        }
296
297        if (silent) {
298            // Redirects stdout to stderr
299            TEMP_FAILURE_RETRY(dup2(STDERR_FILENO, STDOUT_FILENO));
300        } else if (redirecting_to_fd) {
301            // Redirect stdout to fd
302            TEMP_FAILURE_RETRY(dup2(fd, STDOUT_FILENO));
303            close(fd);
304        }
305
306        /* make sure the child dies when dumpstate dies */
307        prctl(PR_SET_PDEATHSIG, SIGKILL);
308
309        /* just ignore SIGPIPE, will go down with parent's */
310        struct sigaction sigact;
311        memset(&sigact, 0, sizeof(sigact));
312        sigact.sa_handler = SIG_IGN;
313        sigaction(SIGPIPE, &sigact, NULL);
314
315        execvp(path, (char**)args.data());
316        // execvp's result will be handled after waitpid_with_timeout() below, but
317        // if it failed, it's safer to exit dumpstate.
318        MYLOGD("execvp on command '%s' failed (error: %s)\n", command, strerror(errno));
319        // Must call _exit (instead of exit), otherwise it will corrupt the zip
320        // file.
321        _exit(EXIT_FAILURE);
322    }
323
324    /* handle parent case */
325    int status;
326    bool ret = waitpid_with_timeout(pid, options.TimeoutInMs(), &status);
327    fsync(fd);
328
329    uint64_t elapsed = Nanotime() - start;
330    if (!ret) {
331        if (errno == ETIMEDOUT) {
332            if (!silent)
333                dprintf(fd, "*** command '%s' timed out after %.3fs (killing pid %d)\n", command,
334                        static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
335            MYLOGE("*** command '%s' timed out after %.3fs (killing pid %d)\n", command,
336                   static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
337        } else {
338            if (!silent)
339                dprintf(fd, "*** command '%s': Error after %.4fs (killing pid %d)\n", command,
340                        static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
341            MYLOGE("command '%s': Error after %.4fs (killing pid %d)\n", command,
342                   static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
343        }
344        kill(pid, SIGTERM);
345        if (!waitpid_with_timeout(pid, 5000, nullptr)) {
346            kill(pid, SIGKILL);
347            if (!waitpid_with_timeout(pid, 5000, nullptr)) {
348                if (!silent)
349                    dprintf(fd, "could not kill command '%s' (pid %d) even with SIGKILL.\n",
350                            command, pid);
351                MYLOGE("could not kill command '%s' (pid %d) even with SIGKILL.\n", command, pid);
352            }
353        }
354        return -1;
355    }
356
357    if (WIFSIGNALED(status)) {
358        if (!silent)
359            dprintf(fd, "*** command '%s' failed: killed by signal %d\n", command, WTERMSIG(status));
360        MYLOGE("*** command '%s' failed: killed by signal %d\n", command, WTERMSIG(status));
361    } else if (WIFEXITED(status) && WEXITSTATUS(status) > 0) {
362        status = WEXITSTATUS(status);
363        if (!silent) dprintf(fd, "*** command '%s' failed: exit code %d\n", command, status);
364        MYLOGE("*** command '%s' failed: exit code %d\n", command, status);
365    }
366
367    return status;
368}
369
370int GetPidByName(const std::string& ps_name) {
371    DIR* proc_dir;
372    struct dirent* ps;
373    unsigned int pid;
374    std::string cmdline;
375
376    if (!(proc_dir = opendir("/proc"))) {
377        MYLOGE("Can't open /proc\n");
378        return -1;
379    }
380
381    while ((ps = readdir(proc_dir))) {
382        if (!(pid = atoi(ps->d_name))) {
383            continue;
384        }
385        android::base::ReadFileToString("/proc/" + std::string(ps->d_name) + "/cmdline", &cmdline);
386        if (cmdline.find(ps_name) == std::string::npos) {
387            continue;
388        } else {
389            closedir(proc_dir);
390            return pid;
391        }
392    }
393    MYLOGE("can't find the pid\n");
394    closedir(proc_dir);
395    return -1;
396}
397
398}  // namespace dumpstate
399}  // namespace os
400}  // namespace android
401