| // Copyright 2020 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "syslog-cat/syslogcat.h" |
| |
| #include <sys/socket.h> |
| #include <sys/un.h> |
| |
| #include <base/check.h> |
| #include <base/check_op.h> |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_file.h> |
| #include <base/logging.h> |
| #include <base/posix/eintr_wrapper.h> |
| #include <base/strings/stringprintf.h> |
| |
| namespace { |
| |
| base::ScopedFD PrepareSocket(const std::string& identifier, |
| int severity, |
| int pid, |
| const base::FilePath& socket_path) { |
| DCHECK(!identifier.empty()); |
| DCHECK_GE(severity, 0); |
| DCHECK_LE(severity, 7); |
| |
| // Open the unix socket to write logs. |
| base::ScopedFD sock( |
| socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_CLOEXEC, 0)); |
| if (!sock.is_valid()) { |
| PLOG(ERROR) << "opening stream socket"; |
| return base::ScopedFD(); |
| } |
| |
| // Connect the syslog unix socket file. |
| struct sockaddr_un server = {}; |
| server.sun_family = AF_UNIX; |
| CHECK_GT(sizeof(server.sun_path), socket_path.value().length()); |
| strncpy(server.sun_path, socket_path.value().c_str(), |
| sizeof(server.sun_path)); |
| if (HANDLE_EINTR(connect(sock.get(), (struct sockaddr*)&server, |
| sizeof(struct sockaddr_un))) < 0) { |
| PLOG(ERROR) << "connecting stream socket"; |
| return base::ScopedFD(); |
| } |
| |
| // Construct the header string to send. |
| std::string header = base::StringPrintf("TAG=%s[%d]\nPRIORITY=%d\n\n", |
| identifier.c_str(), pid, severity); |
| |
| // Send headers (tag and severity). |
| if (!base::WriteFileDescriptor(sock.get(), header)) { |
| PLOG(ERROR) << "writing headers on stream socket"; |
| return base::ScopedFD(); |
| } |
| |
| return sock; |
| } |
| |
| bool CreateSocketAndBindToFD(const std::string& identifier, |
| int severity, |
| int pid, |
| int target_fd, |
| const base::FilePath& socket_path) { |
| base::ScopedFD sock = PrepareSocket(identifier, severity, pid, socket_path); |
| if (!sock.is_valid()) { |
| LOG(ERROR) << "Failed to open the rsyslog socket for stderr."; |
| return false; |
| } |
| |
| // Connect the socket to stderr. |
| if (HANDLE_EINTR(dup2(sock.get(), target_fd)) == -1) { |
| PLOG(ERROR) << "duping the stderr"; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| } // namespace |
| |
| void ExecuteCommandWithRedirection( |
| const std::string& target_command, |
| const std::vector<const char*>& target_command_argv, |
| const std::string& identifier, |
| int severity_stdout, |
| int severity_stderr, |
| const base::FilePath& socket_path_stdout, |
| const base::FilePath& socket_path_stderr) { |
| // Prepare a pid. |
| pid_t pid = getpid(); |
| |
| // Open the unix socket to redirect logs from stdout (and stderr). |
| bool ret_stdout = CreateSocketAndBindToFD(identifier, severity_stdout, pid, |
| STDOUT_FILENO, socket_path_stdout); |
| CHECK(ret_stdout) << "Failed to bind stdout."; |
| |
| // Open the unix socket to redirect logs from stderr. |
| // We prepare a separate socket for stderr even if the severities are same, |
| // in order to prevent interleave of simultaneous lines. |
| bool ret_stderr = CreateSocketAndBindToFD(identifier, severity_stderr, pid, |
| STDERR_FILENO, socket_path_stderr); |
| CHECK(ret_stderr) << "Failed to bind stderr."; |
| |
| // Execute the target process. |
| execvp(const_cast<char*>(target_command.c_str()), |
| const_cast<char**>(target_command_argv.data())); |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // The code below is executed only when the execvp() above failed. |
| // (eg. the executable doesn't exist, or is not executable) |
| |
| PLOG(ERROR) << "execvp '" << target_command << "'"; |
| } |