path: root/src/launchpad-process-pool/loader_mount.cc

/*
 * Copyright (c) 2024 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * 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 "launchpad-process-pool/loader_mount.hh"

#include <bundle_cpp.h>
#include <bundle_internal.h>
#include <dlog-redirect-stdout.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/limits.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <filesystem>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <aul_keys.hh>
#include <exception.hh>
#include <parcelable.hh>
#include <util.hh>

#include "launchpad-process-pool/launchpad_args.hh"
#include "launchpad-process-pool/log_private.hh"

namespace fs = std::filesystem;
namespace {

bool IsExceptable(const std::string& path) {
  static char buf[PATH_MAX];
  ssize_t len = readlink(path.c_str(), buf, sizeof(buf));
  if (len < 0) {
    _E("readlink() is failed. errno: %d", errno);
    return false;
  }

  buf[len] = '\0';
  if (strstr(buf, "log") != nullptr ||
      strstr(buf, "trace") != nullptr ||
      strstr(buf, "dev") != nullptr)
    return true;

  return false;
}

std::vector<int> GetExceptableFds() {
  std::vector<int> fds;
  try {
    fs::path proc_path("/proc/self/fd");
    for (const auto& entry : fs::directory_iterator(proc_path)) {
      if (!isdigit(entry.path().filename().string()[0]))
        continue;

      int fd = std::stoi(entry.path().filename().string());
      if (dlog_is_log_fd(fd) || IsExceptable(entry.path().string()))
        fds.push_back(fd);
    }
  } catch (const fs::filesystem_error& e) {
    _E("Exception occurs. error(%s)", e.what());
  }

  return fds;
}

int ChangeMountNamespace(pid_t pid) {
  std::string mnt_path = "/proc/" + std::to_string(pid) + "/ns/mnt";
  int fd = open(mnt_path.c_str(), O_RDONLY);
  if (fd < 0) {
    _E("open() is failed. path(%s), errno(%d)", mnt_path.c_str(), errno);
    return -1;
  }

  int ret = ::setns(fd, 0);
  close(fd);
  if (ret != 0) {
    _E("setns() is failed. path(%s), errno(%d)", mnt_path.c_str(), errno);
    return -1;
  }

  _D("setns() is successful. pid(%d)", pid);
  return 0;
}

class Request : public tizen_base::Parcelable {
 public:
  explicit Request(tizen_base::Parcel* parcel) { ReadFromParcel(parcel); }

  Request(pid_t pid, tizen_base::Bundle b) : pid_(pid), b_(std::move(b)) {}

  pid_t GetPid() const { return pid_; }

  const tizen_base::Bundle& GetBundle() const { return b_; }

  void WriteToParcel(tizen_base::Parcel* parcel) const override {
    parcel->WriteInt32(pid_);
    bundle_raw* raw = nullptr;
    int len = 0;
    bundle_encode(b_.GetHandle(), &raw, &len);
    parcel->WriteInt32(len);
    parcel->Write(reinterpret_cast<unsigned char*>(raw), len);
    bundle_free_encoded_rawdata(&raw);
  }

  void ReadFromParcel(tizen_base::Parcel* parcel) override {
    parcel->ReadInt32(&pid_);
    int len = 0;
    parcel->ReadInt32(&len);
    if (len > 0) {
      std::vector<uint8_t> data(len);
      parcel->Read(data.data(), data.size());
      b_ = tizen_base::Bundle(
          bundle_decode(reinterpret_cast<bundle_raw*>(data.data()), len), false,
          true);
    }
  }

 private:
  pid_t pid_;
  tizen_base::Bundle b_;
};

class Reply : public tizen_base::Parcelable {
 public:
  explicit Reply(tizen_base::Parcel* parcel) { ReadFromParcel(parcel); }

  explicit Reply(int result) : result_(result) {}

  int GetResult() const { return result_; }

  void WriteToParcel(tizen_base::Parcel* parcel) const override {
    parcel->WriteInt32(result_);
  }

  void ReadFromParcel(tizen_base::Parcel* parcel) override {
    parcel->ReadInt32(&result_);
  }

 private:
  int result_ = -1;
};

}  // namespace

namespace launchpad {

LoaderMount::LoaderMount() : Executor(this), launchpad_ppid_(getppid()) {
  Prepare();
}

LoaderMount::~LoaderMount() { Dispose(); }

void LoaderMount::Prepare() {
  if (pid_ > 0) return;

  int pipe_fd[2];
  if (CreatePipe(&pipe_fd) != 0) return;

  read_socket_.reset(new Socket(pipe_fd[0]));
  int write_fd = pipe_fd[1];

  if (CreatePipe(&pipe_fd) != 0) return;

  int read_fd = pipe_fd[0];
  write_socket_.reset(new Socket(pipe_fd[1]));

  _W("read_socket=%d, write_socket=%d",
     read_socket_->GetFd(), write_socket_->GetFd());
  pid_ = Executor::Execute();
  if (pid_ == -1) {
    _E("Failed to fork process. errno(%d)", errno);
    close(read_fd);
    close(write_fd);
    return;
  }

  read_socket_.reset(new Socket(read_fd));
  write_socket_.reset(new Socket(write_fd));
}

void LoaderMount::Dispose() {
  read_socket_.reset();
  write_socket_.reset();
  if (pid_ > 0) {
    if (kill(pid_, SIGKILL) == -1)
      _E("Failed to send kill signal. pid(%d), errno(%d)", pid_, errno);

    pid_ = -1;
  }
}

void LoaderMount::HandleSigchld(pid_t pid) {
  if (pid_ != pid) return;

  pid_ = -1;
  Dispose();
  Prepare();
}

int LoaderMount::Mount(pid_t pid, const AppInfo* app_info) {
  auto& b = app_info->GetBundle();
  if (b.GetType(kAulMountGadgetPaths) == BUNDLE_TYPE_NONE) return 0;

  tizen_base::Parcel parcel;
  Request request(pid, b);
  request.WriteToParcel(&parcel);

  _W("Send mount request");
  int ret = Write(parcel);
  if (ret != 0) return ret;

  parcel.Clear();
  ret = Read(&parcel);
  if (ret!= 0) return ret;

  _W("receive result");
  Reply reply(&parcel);
  return reply.GetResult();
}

void LoaderMount::OnExecution() {
  _D("Mount Manager");
  char** args = LaunchpadArgs::GetInst().GetArgs();
  size_t length = strlen(args[0]);
  memset(args[0], '\0', length);
  snprintf(args[0], length, "/usr/bin/loader-mount");

  std::vector<int> except_fds = GetExceptableFds();
  except_fds.push_back(read_socket_->GetFd());
  except_fds.push_back(write_socket_->GetFd());
  Util::CloseAllFds(except_fds);
  int ret = ProcessRequests();
  exit(ret);
}


int LoaderMount::CreatePipe(int (*pipe_fd)[2]) {
  *pipe_fd[0] = -1;
  *pipe_fd[2] = -1;

  if (pipe(*pipe_fd) == -1) {
    _E("pipe() is failed. errno(%d)", errno);
    return -1;
  }

  if (fcntl(*pipe_fd[0], F_SETPIPE_SZ, Socket::kSocketMaxBufferSize) == -1)
    _E("Failed to set pipe size. errno(%d)", errno);

  if (fcntl(*pipe_fd[1], F_SETPIPE_SZ, Socket::kSocketMaxBufferSize) == -1)
    _E("Failed to set pipe size. errno(%d)", errno);

  return 0;
}

int LoaderMount::Write(const tizen_base::Parcel& parcel) {
  size_t data_size = parcel.GetDataSize();
  int ret =
      write_socket_->Write(static_cast<void*>(&data_size), sizeof(data_size));
  if (ret != 0) {
    _E("Write() is failed. error(%d)", ret);
    return -1;
  }

  return write_socket_->Write(parcel.GetData(), parcel.GetDataSize());
}

int LoaderMount::Read(tizen_base::Parcel* parcel) {
  size_t data_size = 0;
  int ret =
      read_socket_->Read(static_cast<void*>(&data_size), sizeof(data_size));
  if (ret != 0) {
    _E("Read() is failed. error(%d)", ret);
    return -1;
  }

  std::vector<uint8_t> data(data_size);
  ret = read_socket_->Read(data.data(), data.size());
  if (ret != 0) {
    _E("Read() is failed. error(%d)", ret);
    return -1;
  }

  parcel->Write(data.data(), data.size());
  return 0;
}

int LoaderMount::ProcessRequests() {
  tizen_base::Parcel parcel;
  while (true) {
    parcel.Clear();
    int ret = Read(&parcel);
    if (ret != 0) continue;

    _W("Request received");
    Request request(&parcel);
    ret = ChangeMountNamespace(request.GetPid());
    if (ret == 0) {
      ret = Util::MountGadgetDirectories(request.GetBundle());
      ChangeMountNamespace(launchpad_ppid_);
    }

    Reply reply(ret);
    parcel.Clear();
    reply.WriteToParcel(&parcel);
    Write(parcel);
  }

  return 0;
}

}  // namespace launchpad