blob: cdd8dbede1193c6f72913de245886983a2a01017 [file] [log] [blame]
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "shell_service.h"
#include <gtest/gtest.h>
#include <signal.h>
#include <string>
#include <vector>
#include <android-base/strings.h>
#include "adb.h"
#include "adb_io.h"
#include "shell_protocol.h"
#include "sysdeps.h"
class ShellServiceTest : public ::testing::Test {
public:
static void SetUpTestCase() {
// This is normally done in main.cpp.
saved_sigpipe_handler_ = signal(SIGPIPE, SIG_IGN);
}
static void TearDownTestCase() {
signal(SIGPIPE, saved_sigpipe_handler_);
}
// Helpers to start and cleanup a subprocess. Cleanup normally does not
// need to be called manually unless multiple subprocesses are run from
// a single test.
void StartTestSubprocess(const char* command, SubprocessType type,
SubprocessProtocol protocol);
void CleanupTestSubprocess();
void StartTestCommandInProcess(std::string name, Command command, SubprocessProtocol protocol);
virtual void TearDown() override { CleanupTestSubprocess(); }
static sighandler_t saved_sigpipe_handler_;
unique_fd command_fd_;
};
sighandler_t ShellServiceTest::saved_sigpipe_handler_ = nullptr;
void ShellServiceTest::StartTestSubprocess(
const char* command, SubprocessType type, SubprocessProtocol protocol) {
command_fd_ = StartSubprocess(command, nullptr, type, protocol);
ASSERT_TRUE(command_fd_ >= 0);
}
void ShellServiceTest::CleanupTestSubprocess() {
}
void ShellServiceTest::StartTestCommandInProcess(std::string name, Command command,
SubprocessProtocol protocol) {
command_fd_ = StartCommandInProcess(std::move(name), std::move(command), protocol);
ASSERT_TRUE(command_fd_ >= 0);
}
namespace {
// Reads raw data from |fd| until it closes or errors.
std::string ReadRaw(borrowed_fd fd) {
char buffer[1024];
char *cur_ptr = buffer, *end_ptr = buffer + sizeof(buffer);
while (1) {
int bytes = adb_read(fd, cur_ptr, end_ptr - cur_ptr);
if (bytes <= 0) {
return std::string(buffer, cur_ptr);
}
cur_ptr += bytes;
}
}
// Reads shell protocol data from |fd| until it closes or errors. Fills
// |stdout| and |stderr| with their respective data, and returns the exit code
// read from the protocol or -1 if an exit code packet was not received.
int ReadShellProtocol(borrowed_fd fd, std::string* stdout, std::string* stderr) {
int exit_code = -1;
stdout->clear();
stderr->clear();
auto protocol = std::make_unique<ShellProtocol>(fd.get());
while (protocol->Read()) {
switch (protocol->id()) {
case ShellProtocol::kIdStdout:
stdout->append(protocol->data(), protocol->data_length());
break;
case ShellProtocol::kIdStderr:
stderr->append(protocol->data(), protocol->data_length());
break;
case ShellProtocol::kIdExit:
EXPECT_EQ(-1, exit_code) << "Multiple exit packets received";
EXPECT_EQ(1u, protocol->data_length());
exit_code = protocol->data()[0];
break;
default:
ADD_FAILURE() << "Unidentified packet ID: " << protocol->id();
}
}
return exit_code;
}
// Checks if each line in |lines| exists in the same order in |output|. Blank
// lines in |output| are ignored for simplicity.
bool ExpectLinesEqual(const std::string& output,
const std::vector<std::string>& lines) {
auto output_lines = android::base::Split(output, "\r\n");
size_t i = 0;
for (const std::string& line : lines) {
// Skip empty lines in output.
while (i < output_lines.size() && output_lines[i].empty()) {
++i;
}
if (i >= output_lines.size()) {
ADD_FAILURE() << "Ran out of output lines";
return false;
}
EXPECT_EQ(line, output_lines[i]);
++i;
}
while (i < output_lines.size() && output_lines[i].empty()) {
++i;
}
EXPECT_EQ(i, output_lines.size()) << "Found unmatched output lines";
return true;
}
} // namespace
// Tests a raw subprocess with no protocol.
TEST_F(ShellServiceTest, RawNoProtocolSubprocess) {
// [ -t 0 ] checks if stdin is connected to a terminal.
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"echo foo; echo bar >&2; [ -t 0 ]; echo $?",
SubprocessType::kRaw, SubprocessProtocol::kNone));
// [ -t 0 ] == 0 means we have a terminal (PTY). Even when requesting a raw subprocess, without
// the shell protocol we should always force a PTY to ensure proper cleanup.
ExpectLinesEqual(ReadRaw(command_fd_), {"foo", "bar", "0"});
}
// Tests a PTY subprocess with no protocol.
TEST_F(ShellServiceTest, PtyNoProtocolSubprocess) {
// [ -t 0 ] checks if stdin is connected to a terminal.
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"echo foo; echo bar >&2; [ -t 0 ]; echo $?",
SubprocessType::kPty, SubprocessProtocol::kNone));
// [ -t 0 ] == 0 means we have a terminal (PTY).
ExpectLinesEqual(ReadRaw(command_fd_), {"foo", "bar", "0"});
}
// Tests a raw subprocess with the shell protocol.
TEST_F(ShellServiceTest, RawShellProtocolSubprocess) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"echo foo; echo bar >&2; echo baz; exit 24",
SubprocessType::kRaw, SubprocessProtocol::kShell));
std::string stdout, stderr;
EXPECT_EQ(24, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {"foo", "baz"});
ExpectLinesEqual(stderr, {"bar"});
}
// Tests a PTY subprocess with the shell protocol.
TEST_F(ShellServiceTest, PtyShellProtocolSubprocess) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"echo foo; echo bar >&2; echo baz; exit 50",
SubprocessType::kPty, SubprocessProtocol::kShell));
// PTY always combines stdout and stderr but the shell protocol should
// still give us an exit code.
std::string stdout, stderr;
EXPECT_EQ(50, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {"foo", "bar", "baz"});
ExpectLinesEqual(stderr, {});
}
// Tests an interactive PTY session.
TEST_F(ShellServiceTest, InteractivePtySubprocess) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"", SubprocessType::kPty, SubprocessProtocol::kShell));
// Use variable substitution so echoed input is different from output.
const char* commands[] = {"TEST_STR=abc123",
"echo --${TEST_STR}--",
"exit"};
ShellProtocol* protocol = new ShellProtocol(command_fd_);
for (std::string command : commands) {
// Interactive shell requires a newline to complete each command.
command.push_back('\n');
memcpy(protocol->data(), command.data(), command.length());
ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, command.length()));
}
delete protocol;
std::string stdout, stderr;
EXPECT_EQ(0, ReadShellProtocol(command_fd_, &stdout, &stderr));
// An unpredictable command prompt makes parsing exact output difficult but
// it should at least contain echoed input and the expected output.
for (const char* command : commands) {
EXPECT_FALSE(stdout.find(command) == std::string::npos);
}
EXPECT_FALSE(stdout.find("--abc123--") == std::string::npos);
}
// Tests closing raw subprocess stdin.
TEST_F(ShellServiceTest, CloseClientStdin) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"cat; echo TEST_DONE",
SubprocessType::kRaw, SubprocessProtocol::kShell));
std::string input = "foo\nbar";
ShellProtocol* protocol = new ShellProtocol(command_fd_);
memcpy(protocol->data(), input.data(), input.length());
ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, input.length()));
ASSERT_TRUE(protocol->Write(ShellProtocol::kIdCloseStdin, 0));
delete protocol;
std::string stdout, stderr;
EXPECT_EQ(0, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {"foo", "barTEST_DONE"});
ExpectLinesEqual(stderr, {});
}
// Tests that nothing breaks when the stdin/stdout pipe closes.
TEST_F(ShellServiceTest, CloseStdinStdoutSubprocess) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"exec 0<&-; exec 1>&-; echo bar >&2",
SubprocessType::kRaw, SubprocessProtocol::kShell));
std::string stdout, stderr;
EXPECT_EQ(0, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {});
ExpectLinesEqual(stderr, {"bar"});
}
// Tests that nothing breaks when the stderr pipe closes.
TEST_F(ShellServiceTest, CloseStderrSubprocess) {
ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
"exec 2>&-; echo foo",
SubprocessType::kRaw, SubprocessProtocol::kShell));
std::string stdout, stderr;
EXPECT_EQ(0, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {"foo"});
ExpectLinesEqual(stderr, {});
}
// Tests an inprocess command with no protocol.
TEST_F(ShellServiceTest, RawNoProtocolInprocess) {
ASSERT_NO_FATAL_FAILURE(
StartTestCommandInProcess("123",
[](auto args, auto in, auto out, auto err) -> int {
EXPECT_EQ("123", args);
char input[10];
EXPECT_TRUE(ReadFdExactly(in, input, 2));
input[2] = 0;
EXPECT_STREQ("in", input);
WriteFdExactly(out, "out\n");
WriteFdExactly(err, "err\n");
return 0;
},
SubprocessProtocol::kNone));
WriteFdExactly(command_fd_, "in");
ExpectLinesEqual(ReadRaw(command_fd_), {"out", "err"});
}
// Tests an inprocess command with the shell protocol.
TEST_F(ShellServiceTest, RawShellProtocolInprocess) {
ASSERT_NO_FATAL_FAILURE(
StartTestCommandInProcess("321",
[](auto args, auto in, auto out, auto err) -> int {
EXPECT_EQ("321", args);
char input[10];
EXPECT_TRUE(ReadFdExactly(in, input, 2));
input[2] = 0;
EXPECT_STREQ("in", input);
WriteFdExactly(out, "out\n");
WriteFdExactly(err, "err\n");
return 0;
},
SubprocessProtocol::kShell));
{
auto write_protocol = std::make_unique<ShellProtocol>(command_fd_);
memcpy(write_protocol->data(), "in", 2);
write_protocol->Write(ShellProtocol::kIdStdin, 2);
}
std::string stdout, stderr;
// For in-process commands the exit code is always the default (1).
EXPECT_EQ(1, ReadShellProtocol(command_fd_, &stdout, &stderr));
ExpectLinesEqual(stdout, {"out"});
ExpectLinesEqual(stderr, {"err"});
}