tests/shell_utils.cpp

   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
  31 using android::base::unique_fd;
  32
  33 namespace android {
  34 namespace wificond {
  35 namespace tests {
  36 namespace integration {
  37 namespace {
  38
  39 #ifdef __ANDROID__
  40 const char kShellPath[] = "/system/bin/sh";
  41 #else
  42 const char kShellPath[] = "/bin/sh";
  43 #endif
  44
  45 const int kShellTimeoutMs = 30 * 1000;
  46 const int kMillisecondsPerSecond = 1000;
  47 const int kNanosecondsPerMillisecond = 1000 * 1000;
  48
  49 // Represents some arbitrary, non-decreasing time in milliseconds.
  50 int64_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
  59 int 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