shell_service.cpp - platform/packages/modules/adb - Gitiles

 /*
  * 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.
  */

 #define TRACE_TAG TRACE_SHELL

 #include "shell_service.h"

 #if !ADB_HOST

 #include <errno.h>
 #include <pty.h>
 #include <termios.h>

 #include <base/logging.h>
 #include <base/stringprintf.h>
 #include <paths.h>

 #include "adb.h"
 #include "adb_io.h"
 #include "adb_trace.h"
 #include "sysdeps.h"

 namespace {

 void init_subproc_child()
 {
     setsid();

     // Set OOM score adjustment to prevent killing
     int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
     if (fd >= 0) {
         adb_write(fd, "0", 1);
         adb_close(fd);
     } else {
        D("adb: unable to update oom_score_adj");
     }
 }

 // Reads from |fd| until close or failure.
 std::string ReadAll(int fd) {
     char buffer[512];
     std::string received;

     while (1) {
         int bytes = adb_read(fd, buffer, sizeof(buffer));
         if (bytes <= 0) {
             break;
         }
         received.append(buffer, bytes);
     }

     return received;
 }

 // Helper to automatically close an FD when it goes out of scope.
 class ScopedFd {
   public:
     ScopedFd() {}
     ~ScopedFd() { Reset(); }

     void Reset(int fd=-1) {
         if (fd != fd_) {
             if (valid()) {
                 adb_close(fd_);
             }
             fd_ = fd;
         }
     }

     int Release() {
         int temp = fd_;
         fd_ = -1;
         return temp;
     }

     bool valid() const { return fd_ >= 0; }

     int fd() const { return fd_; }

   private:
     int fd_ = -1;

     DISALLOW_COPY_AND_ASSIGN(ScopedFd);
 };

 // Creates a socketpair and saves the endpoints to |fd1| and |fd2|.
 bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) {
     int sockets[2];
     if (adb_socketpair(sockets) < 0) {
         PLOG(ERROR) << "cannot create socket pair";
         return false;
     }
     fd1->Reset(sockets[0]);
     fd2->Reset(sockets[1]);
     return true;
 }

 class Subprocess {
   public:
     Subprocess(const std::string& command, SubprocessType type);
     ~Subprocess();

     const std::string& command() const { return command_; }
     bool is_interactive() const { return command_.empty(); }

     int local_socket_fd() const { return local_socket_sfd_.fd(); }

     pid_t pid() const { return pid_; }

     // Sets up FDs, forks a subprocess, starts the subprocess manager thread,
     // and exec's the child. Returns false on failure.
     bool ForkAndExec();

   private:
     // Opens the file at |pts_name|.
     int OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd);

     static void* ThreadHandler(void* userdata);
     void WaitForExit();

     const std::string command_;
     SubprocessType type_;

     pid_t pid_ = -1;
     ScopedFd local_socket_sfd_;

     DISALLOW_COPY_AND_ASSIGN(Subprocess);
 };

 Subprocess::Subprocess(const std::string& command, SubprocessType type)
         : command_(command), type_(type) {
 }

 Subprocess::~Subprocess() {
 }

 bool Subprocess::ForkAndExec() {
     ScopedFd parent_sfd, child_sfd, parent_error_sfd, child_error_sfd;
     char pts_name[PATH_MAX];

     // Create a socketpair for the fork() child to report any errors back to
     // the parent. Since we use threads, logging directly from the child could
     // create a race condition.
     if (!CreateSocketpair(&parent_error_sfd, &child_error_sfd)) {
         LOG(ERROR) << "failed to create pipe for subprocess error reporting";
     }

     if (type_ == SubprocessType::kPty) {
         int fd;
         pid_ = forkpty(&fd, pts_name, nullptr, nullptr);
         parent_sfd.Reset(fd);
     } else {
         if (!CreateSocketpair(&parent_sfd, &child_sfd)) {
             return false;
         }
         pid_ = fork();
     }

     if (pid_ == -1) {
         PLOG(ERROR) << "fork failed";
         return false;
     }

     if (pid_ == 0) {
         // Subprocess child.
         init_subproc_child();

         if (type_ == SubprocessType::kPty) {
             child_sfd.Reset(OpenPtyChildFd(pts_name, &child_error_sfd));
         }

         dup2(child_sfd.fd(), STDIN_FILENO);
         dup2(child_sfd.fd(), STDOUT_FILENO);
         dup2(child_sfd.fd(), STDERR_FILENO);

         // exec doesn't trigger destructors, close the FDs manually.
         parent_sfd.Reset();
         child_sfd.Reset();
         parent_error_sfd.Reset();
         close_on_exec(child_error_sfd.fd());

         if (is_interactive()) {
             execl(_PATH_BSHELL, _PATH_BSHELL, "-", nullptr);
         } else {
             execl(_PATH_BSHELL, _PATH_BSHELL, "-c", command_.c_str(), nullptr);
         }
         WriteFdExactly(child_error_sfd.fd(), "exec '" _PATH_BSHELL "' failed");
         child_error_sfd.Reset();
         exit(-1);
     }

     // Subprocess parent.
     D("subprocess parent: subprocess FD = %d", parent_sfd.fd());

     // Wait to make sure the subprocess exec'd without error.
     child_error_sfd.Reset();
     std::string error_message = ReadAll(parent_error_sfd.fd());
     if (!error_message.empty()) {
         LOG(ERROR) << error_message;
         return false;
     }

     local_socket_sfd_.Reset(parent_sfd.Release());

     if (!adb_thread_create(ThreadHandler, this)) {
         PLOG(ERROR) << "failed to create subprocess thread";
         return false;
     }

     return true;
 }

 int Subprocess::OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd) {
     int child_fd = adb_open(pts_name, O_RDWR | O_CLOEXEC);
     if (child_fd == -1) {
         // Don't use WriteFdFmt; since we're in the fork() child we don't want
         // to allocate any heap memory to avoid race conditions.
         const char* messages[] = {"child failed to open pseudo-term slave ",
                                   pts_name, ": ", strerror(errno)};
         for (const char* message : messages) {
             WriteFdExactly(error_sfd->fd(), message);
         }
         exit(-1);
     }

     if (!is_interactive()) {
         termios tattr;
         if (tcgetattr(child_fd, &tattr) == -1) {
             WriteFdExactly(error_sfd->fd(), "tcgetattr failed");
             exit(-1);
         }

         cfmakeraw(&tattr);
         if (tcsetattr(child_fd, TCSADRAIN, &tattr) == -1) {
             WriteFdExactly(error_sfd->fd(), "tcsetattr failed");
             exit(-1);
         }
     }

     return child_fd;
 }

 void* Subprocess::ThreadHandler(void* userdata) {
     Subprocess* subprocess = reinterpret_cast<Subprocess*>(userdata);

     adb_thread_setname(android::base::StringPrintf(
             "shell srvc %d", subprocess->local_socket_fd()));

     subprocess->WaitForExit();

     D("deleting Subprocess");
     delete subprocess;

     return nullptr;
 }

 void Subprocess::WaitForExit() {
     D("waiting for pid %d", pid_);
     while (true) {
         int status;
         if (pid_ == waitpid(pid_, &status, 0)) {
             D("post waitpid (pid=%d) status=%04x", pid_, status);
             if (WIFSIGNALED(status)) {
                 D("subprocess killed by signal %d", WTERMSIG(status));
                 break;
             } else if (!WIFEXITED(status)) {
                 D("subprocess didn't exit");
                 break;
             } else if (WEXITSTATUS(status) >= 0) {
                 D("subprocess exit code = %d", WEXITSTATUS(status));
                 break;
             }
         }
     }

     // Pass the local socket FD to the shell cleanup fdevent.
     if (SHELL_EXIT_NOTIFY_FD >= 0) {
         int fd = local_socket_sfd_.fd();
         if (WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd))) {
             D("passed fd %d to SHELL_EXIT_NOTIFY_FD (%d) for pid %d",
               fd, SHELL_EXIT_NOTIFY_FD, pid_);
             // The shell exit fdevent now owns the FD and will close it once
             // the last bit of data flushes through.
             local_socket_sfd_.Release();
         } else {
             PLOG(ERROR) << "failed to write fd " << fd
                         << " to SHELL_EXIT_NOTIFY_FD (" << SHELL_EXIT_NOTIFY_FD
                         << ") for pid " << pid_;
         }
     }
 }

 }  // namespace

 int StartSubprocess(const char *name, SubprocessType type) {
     D("starting %s subprocess: '%s'",
       type == SubprocessType::kRaw ? "raw" : "PTY", name);

     Subprocess* subprocess = new Subprocess(name, type);
     if (!subprocess) {
         LOG(ERROR) << "failed to allocate new subprocess";
         return -1;
     }

     if (!subprocess->ForkAndExec()) {
         LOG(ERROR) << "failed to start subprocess";
         delete subprocess;
         return -1;
     }

     D("subprocess creation successful: local_socket_fd=%d, pid=%d",
       subprocess->local_socket_fd(), subprocess->pid());
     return subprocess->local_socket_fd();
 }

 #endif  // !ADB_HOST
	/*
	* 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.
	*/

	#define TRACE_TAG TRACE_SHELL

	#include "shell_service.h"

	#if !ADB_HOST

	#include <errno.h>
	#include <pty.h>
	#include <termios.h>

	#include <base/logging.h>
	#include <base/stringprintf.h>
	#include <paths.h>

	#include "adb.h"
	#include "adb_io.h"
	#include "adb_trace.h"
	#include "sysdeps.h"

	namespace {

	void init_subproc_child()
	{
	setsid();

	// Set OOM score adjustment to prevent killing
	int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY \| O_CLOEXEC);
	if (fd >= 0) {
	adb_write(fd, "0", 1);
	adb_close(fd);
	} else {
	D("adb: unable to update oom_score_adj");
	}
	}

	// Reads from \|fd\| until close or failure.
	std::string ReadAll(int fd) {
	char buffer[512];
	std::string received;

	while (1) {
	int bytes = adb_read(fd, buffer, sizeof(buffer));
	if (bytes <= 0) {
	break;
	}
	received.append(buffer, bytes);
	}

	return received;
	}

	// Helper to automatically close an FD when it goes out of scope.
	class ScopedFd {
	public:
	ScopedFd() {}
	~ScopedFd() { Reset(); }

	void Reset(int fd=-1) {
	if (fd != fd_) {
	if (valid()) {
	adb_close(fd_);
	}
	fd_ = fd;
	}
	}

	int Release() {
	int temp = fd_;
	fd_ = -1;
	return temp;
	}

	bool valid() const { return fd_ >= 0; }

	int fd() const { return fd_; }

	private:
	int fd_ = -1;

	DISALLOW_COPY_AND_ASSIGN(ScopedFd);
	};

	// Creates a socketpair and saves the endpoints to \|fd1\| and \|fd2\|.
	bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) {
	int sockets[2];
	if (adb_socketpair(sockets) < 0) {
	PLOG(ERROR) << "cannot create socket pair";
	return false;
	}
	fd1->Reset(sockets[0]);
	fd2->Reset(sockets[1]);
	return true;
	}

	class Subprocess {
	public:
	Subprocess(const std::string& command, SubprocessType type);
	~Subprocess();

	const std::string& command() const { return command_; }
	bool is_interactive() const { return command_.empty(); }

	int local_socket_fd() const { return local_socket_sfd_.fd(); }

	pid_t pid() const { return pid_; }

	// Sets up FDs, forks a subprocess, starts the subprocess manager thread,
	// and exec's the child. Returns false on failure.
	bool ForkAndExec();

	private:
	// Opens the file at \|pts_name\|.
	int OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd);

	static void* ThreadHandler(void* userdata);
	void WaitForExit();

	const std::string command_;
	SubprocessType type_;

	pid_t pid_ = -1;
	ScopedFd local_socket_sfd_;

	DISALLOW_COPY_AND_ASSIGN(Subprocess);
	};

	Subprocess::Subprocess(const std::string& command, SubprocessType type)
	: command_(command), type_(type) {
	}

	Subprocess::~Subprocess() {
	}

	bool Subprocess::ForkAndExec() {
	ScopedFd parent_sfd, child_sfd, parent_error_sfd, child_error_sfd;
	char pts_name[PATH_MAX];

	// Create a socketpair for the fork() child to report any errors back to
	// the parent. Since we use threads, logging directly from the child could
	// create a race condition.
	if (!CreateSocketpair(&parent_error_sfd, &child_error_sfd)) {
	LOG(ERROR) << "failed to create pipe for subprocess error reporting";
	}

	if (type_ == SubprocessType::kPty) {
	int fd;
	pid_ = forkpty(&fd, pts_name, nullptr, nullptr);
	parent_sfd.Reset(fd);
	} else {
	if (!CreateSocketpair(&parent_sfd, &child_sfd)) {
	return false;
	}
	pid_ = fork();
	}

	if (pid_ == -1) {
	PLOG(ERROR) << "fork failed";
	return false;
	}

	if (pid_ == 0) {
	// Subprocess child.
	init_subproc_child();

	if (type_ == SubprocessType::kPty) {
	child_sfd.Reset(OpenPtyChildFd(pts_name, &child_error_sfd));
	}

	dup2(child_sfd.fd(), STDIN_FILENO);
	dup2(child_sfd.fd(), STDOUT_FILENO);
	dup2(child_sfd.fd(), STDERR_FILENO);

	// exec doesn't trigger destructors, close the FDs manually.
	parent_sfd.Reset();
	child_sfd.Reset();
	parent_error_sfd.Reset();
	close_on_exec(child_error_sfd.fd());

	if (is_interactive()) {
	execl(_PATH_BSHELL, _PATH_BSHELL, "-", nullptr);
	} else {
	execl(_PATH_BSHELL, _PATH_BSHELL, "-c", command_.c_str(), nullptr);
	}
	WriteFdExactly(child_error_sfd.fd(), "exec '" _PATH_BSHELL "' failed");
	child_error_sfd.Reset();
	exit(-1);
	}

	// Subprocess parent.
	D("subprocess parent: subprocess FD = %d", parent_sfd.fd());

	// Wait to make sure the subprocess exec'd without error.
	child_error_sfd.Reset();
	std::string error_message = ReadAll(parent_error_sfd.fd());
	if (!error_message.empty()) {
	LOG(ERROR) << error_message;
	return false;
	}

	local_socket_sfd_.Reset(parent_sfd.Release());

	if (!adb_thread_create(ThreadHandler, this)) {
	PLOG(ERROR) << "failed to create subprocess thread";
	return false;
	}

	return true;
	}

	int Subprocess::OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd) {
	int child_fd = adb_open(pts_name, O_RDWR \| O_CLOEXEC);
	if (child_fd == -1) {
	// Don't use WriteFdFmt; since we're in the fork() child we don't want
	// to allocate any heap memory to avoid race conditions.
	const char* messages[] = {"child failed to open pseudo-term slave ",
	pts_name, ": ", strerror(errno)};
	for (const char* message : messages) {
	WriteFdExactly(error_sfd->fd(), message);
	}
	exit(-1);
	}

	if (!is_interactive()) {
	termios tattr;
	if (tcgetattr(child_fd, &tattr) == -1) {
	WriteFdExactly(error_sfd->fd(), "tcgetattr failed");
	exit(-1);
	}

	cfmakeraw(&tattr);
	if (tcsetattr(child_fd, TCSADRAIN, &tattr) == -1) {
	WriteFdExactly(error_sfd->fd(), "tcsetattr failed");
	exit(-1);
	}
	}

	return child_fd;
	}

	void* Subprocess::ThreadHandler(void* userdata) {
	Subprocess* subprocess = reinterpret_cast<Subprocess*>(userdata);

	adb_thread_setname(android::base::StringPrintf(
	"shell srvc %d", subprocess->local_socket_fd()));

	subprocess->WaitForExit();

	D("deleting Subprocess");
	delete subprocess;

	return nullptr;
	}

	void Subprocess::WaitForExit() {
	D("waiting for pid %d", pid_);
	while (true) {
	int status;
	if (pid_ == waitpid(pid_, &status, 0)) {
	D("post waitpid (pid=%d) status=%04x", pid_, status);
	if (WIFSIGNALED(status)) {
	D("subprocess killed by signal %d", WTERMSIG(status));
	break;
	} else if (!WIFEXITED(status)) {
	D("subprocess didn't exit");
	break;
	} else if (WEXITSTATUS(status) >= 0) {
	D("subprocess exit code = %d", WEXITSTATUS(status));
	break;
	}
	}
	}

	// Pass the local socket FD to the shell cleanup fdevent.
	if (SHELL_EXIT_NOTIFY_FD >= 0) {
	int fd = local_socket_sfd_.fd();
	if (WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd))) {
	D("passed fd %d to SHELL_EXIT_NOTIFY_FD (%d) for pid %d",
	fd, SHELL_EXIT_NOTIFY_FD, pid_);
	// The shell exit fdevent now owns the FD and will close it once
	// the last bit of data flushes through.
	local_socket_sfd_.Release();
	} else {
	PLOG(ERROR) << "failed to write fd " << fd
	<< " to SHELL_EXIT_NOTIFY_FD (" << SHELL_EXIT_NOTIFY_FD
	<< ") for pid " << pid_;
	}
	}
	}

	} // namespace

	int StartSubprocess(const char *name, SubprocessType type) {
	D("starting %s subprocess: '%s'",
	type == SubprocessType::kRaw ? "raw" : "PTY", name);

	Subprocess* subprocess = new Subprocess(name, type);
	if (!subprocess) {
	LOG(ERROR) << "failed to allocate new subprocess";
	return -1;
	}

	if (!subprocess->ForkAndExec()) {
	LOG(ERROR) << "failed to start subprocess";
	delete subprocess;
	return -1;
	}

	D("subprocess creation successful: local_socket_fd=%d, pid=%d",
	subprocess->local_socket_fd(), subprocess->pid());
	return subprocess->local_socket_fd();
	}

	#endif // !ADB_HOST