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#include "wificond/tests/shell_utils.h"
18
19#include <fcntl.h>
20#include <poll.h>
21#include <signal.h>
22#include <string.h>
23#include <sys/types.h>
24#include <sys/wait.h>
25#include <time.h>
26#include <unistd.h>
27
28#include <android-base/logging.h>
29#include <android-base/unique_fd.h>
30
31using android::base::unique_fd;
32
33namespace android {
34namespace wificond {
35namespace tests {
36namespace integration {
37namespace {
38
39#ifdef __ANDROID__
40const char kShellPath[] = "/system/bin/sh";
41#else
42const char kShellPath[] = "/bin/sh";
43#endif
44
45const int kShellTimeoutMs = 30 * 1000;
46const int kMillisecondsPerSecond = 1000;
47const int kNanosecondsPerMillisecond = 1000 * 1000;
48
49// Represents some arbitrary, non-decreasing time in milliseconds.
50int64_t GetCurrentTimeMs() {
51  struct timespec ts;
52  clock_gettime(CLOCK_MONOTONIC, &ts);
53  return (int64_t{ts.tv_sec} * kMillisecondsPerSecond) +
54         (ts.tv_nsec / kNanosecondsPerMillisecond);
55}
56
57}  // namespace
58
59int RunShellCommand(const std::string& shell_command, std::string* output) {
60  int fds[2];
61  if (pipe2(fds, O_NONBLOCK) != 0) {
62    LOG(FATAL) << "Failed to create pipe";
63  }
64  unique_fd read_fd(fds[0]);
65  unique_fd write_fd(fds[1]);
66  fcntl(read_fd.get(), F_SETFL, O_CLOEXEC | O_NONBLOCK);
67
68  const pid_t child_pid = fork();
69  if (child_pid == -1) {
70    LOG(FATAL) << "Failed to fork child for shell command: " << shell_command;
71  }
72
73  if (child_pid == 0) {  // We are in the child process.
74    close(0);  // Don't want to read anything in this process.
75    dup2(write_fd.get(), 1);  // Replace existing stdout with the pipe.
76    read_fd.reset();
77    write_fd.reset();
78    // Note that we're keeping parent stderr.
79    execl(kShellPath, "sh", "-c", shell_command.c_str(), nullptr);
80    LOG(FATAL) << "exec() of child failed " << strerror(errno);
81  }
82
83  // We are in the parent process.
84  write_fd.reset();  // Close this or we never get HUP from child.
85  struct pollfd shell_output;
86  memset(&shell_output, 0, sizeof(shell_output));
87  shell_output.fd = read_fd.get();
88  shell_output.events = POLLIN;
89
90  ssize_t nread;
91  char buf[512];
92  int64_t start_time_ms = GetCurrentTimeMs();
93  while (GetCurrentTimeMs() - start_time_ms < kShellTimeoutMs) {
94    int64_t time_left_ms = kShellTimeoutMs - (GetCurrentTimeMs() - start_time_ms);
95    poll(&shell_output, 1, (time_left_ms < 0) ? 0 : time_left_ms);
96    // Blindly read from this file descriptor until there is no data available.
97    do {
98      nread = TEMP_FAILURE_RETRY(read(shell_output.fd, buf, sizeof(buf)));
99      if (output && nread > 0) {
100        output->append(buf, nread);
101      }
102    } while (nread > 0);
103
104    // We're done if the child process has closed its stdout.
105    if (shell_output.revents & POLLHUP) {
106      break;
107    }
108  }
109
110  // Reap our child's exit status.
111  int wait_status = 0;
112  int waitpid_ret = 0;
113  start_time_ms = GetCurrentTimeMs();
114  auto NeedToWaitForChild = [child_pid, &wait_status, &waitpid_ret]() {
115    if (waitpid_ret == 0) {
116      waitpid_ret = waitpid(child_pid, &wait_status, WNOHANG);
117      if (waitpid_ret == -1) {
118        LOG(ERROR) << "waitpid() returned -1 on error(" << errno << "): "
119                   << strerror(errno);
120      }
121    }
122    return waitpid_ret == 0;
123  };
124
125  start_time_ms = GetCurrentTimeMs();
126  while (NeedToWaitForChild() && GetCurrentTimeMs() - start_time_ms < 1000) {
127    usleep(1000);
128  }
129
130  // Child still hasn't died.  Send our child the big hammer.
131  if (waitpid_ret != child_pid) {
132    int kill_ret = kill(child_pid, SIGKILL);
133    // Allow kill to fail with ESRCH, since it indicated that the child may
134    // have already died.
135    if (kill_ret != 0 && errno != ESRCH) {
136      LOG(ERROR) << "Failed to send signal to child: " << strerror(errno);
137    }
138
139    // Wait for the child to die after receiving that signal.
140    start_time_ms = GetCurrentTimeMs();
141    while (NeedToWaitForChild() && GetCurrentTimeMs() - start_time_ms < 1000) {
142      usleep(1000);
143    }
144  }
145
146  if (waitpid_ret == child_pid && WIFEXITED(wait_status)) {
147    return WEXITSTATUS(wait_status);
148  }
149
150  LOG(ERROR) << "Shell command timed out.";
151  return -1;
152}
153
154}  // namespace integration
155}  // namespace tests
156}  // namespace wificond
157}  // namespace android
158