/*

* 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 "Utils.h"

#include "Process.h"

#include "sehandle.h"

#include <android-base/chrono_utils.h>

#include <android-base/file.h>

#include <android-base/logging.h>

#include <android-base/properties.h>

#include <android-base/scopeguard.h>

#include <android-base/stringprintf.h>

#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <cutils/fs.h>

#include <logwrap/logwrap.h>

#include <private/android_filesystem_config.h>

#include <private/android_projectid_config.h>

#include <dirent.h>

#include <fcntl.h>

#include <linux/fs.h>

#include <linux/posix_acl.h>

#include <linux/posix_acl_xattr.h>

#include <mntent.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/mount.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/sysmacros.h>

#include <sys/types.h>

#include <sys/vfs.h>

#include <sys/wait.h>

#include <sys/xattr.h>

#include <unistd.h>

#include <filesystem>

#include <list>

#include <mutex>

#include <regex>

#include <thread>

#ifndef UMOUNT_NOFOLLOW

#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */

#endif

using namespace std::chrono_literals;

using android::base::EndsWith;

using android::base::ReadFileToString;

using android::base::StartsWith;

using android::base::StringPrintf;

using android::base::unique_fd;

namespace android {

namespace vold {

char* sBlkidContext = nullptr;

char* sBlkidUntrustedContext = nullptr;

char* sFsckContext = nullptr;

char* sFsckUntrustedContext = nullptr;

bool sSleepOnUnmount = true;

static const char* kBlkidPath = "/system/bin/blkid";

static const char* kKeyPath = "/data/misc/vold";

static const char* kProcDevices = "/proc/devices";

static const char* kProcFilesystems = "/proc/filesystems";

static const char* kAndroidDir = "/Android/";

static const char* kAppDataDir = "/Android/data/";

static const char* kAppMediaDir = "/Android/media/";

static const char* kAppObbDir = "/Android/obb/";

static const char* kMediaProviderCtx = "u:r:mediaprovider:";

static const char* kMediaProviderAppCtx = "u:r:mediaprovider_app:";

// Lock used to protect process-level SELinux changes from racing with each

// other between multiple threads.

static std::mutex kSecurityLock;

std::string GetFuseMountPathForUser(userid_t user_id, const std::string& relative_upper_path) {

return StringPrintf("/mnt/user/%d/%s", user_id, relative_upper_path.c_str());

}

status_t CreateDeviceNode(const std::string& path, dev_t dev) {

std::lock_guard<std::mutex> lock(kSecurityLock);

const char* cpath = path.c_str();

auto clearfscreatecon = android::base::make_scope_guard([] { setfscreatecon(nullptr); });

auto secontext = std::unique_ptr<char, void (*)(char*)>(nullptr, freecon);

char* tmp_secontext;

if (selabel_lookup(sehandle, &tmp_secontext, cpath, S_IFBLK) == 0) {

secontext.reset(tmp_secontext);

if (setfscreatecon(secontext.get()) != 0) {

LOG(ERROR) << "Failed to setfscreatecon for device node " << path;

return -EINVAL;

}

} else if (errno == ENOENT) {

LOG(DEBUG) << "No selabel defined for device node " << path;

} else {

PLOG(ERROR) << "Failed to look up selabel for device node " << path;

return -errno;

}

mode_t mode = 0660 | S_IFBLK;

if (mknod(cpath, mode, dev) < 0) {

if (errno != EEXIST) {

PLOG(ERROR) << "Failed to create device node for " << major(dev) << ":" << minor(dev)

<< " at " << path;

return -errno;

}

}

return OK;

}

status_t DestroyDeviceNode(const std::string& path) {

const char* cpath = path.c_str();

if (TEMP_FAILURE_RETRY(unlink(cpath))) {

return -errno;

} else {

return OK;

}

}

// Sets a default ACL on the directory.

status_t SetDefaultAcl(const std::string& path, mode_t mode, uid_t uid, gid_t gid,

std::vector<gid_t> additionalGids) {

if (IsSdcardfsUsed()) {

// sdcardfs magically takes care of this

return OK;

}

size_t num_entries = 3 + (additionalGids.size() > 0 ? additionalGids.size() + 1 : 0);

size_t size = sizeof(posix_acl_xattr_header) + num_entries * sizeof(posix_acl_xattr_entry);

auto buf = std::make_unique<uint8_t[]>(size);

posix_acl_xattr_header* acl_header = reinterpret_cast<posix_acl_xattr_header*>(buf.get());

acl_header->a_version = POSIX_ACL_XATTR_VERSION;

posix_acl_xattr_entry* entry =

reinterpret_cast<posix_acl_xattr_entry*>(buf.get() + sizeof(posix_acl_xattr_header));

int tag_index = 0;

entry[tag_index].e_tag = ACL_USER_OBJ;

// The existing mode_t mask has the ACL in the lower 9 bits:

// the lowest 3 for "other", the next 3 the group, the next 3 for the owner

// Use the mode_t masks to get these bits out, and shift them to get the

// correct value per entity.

//

// Eg if mode_t = 0700, rwx for the owner, then & S_IRWXU >> 6 results in 7

entry[tag_index].e_perm = (mode & S_IRWXU) >> 6;

entry[tag_index].e_id = uid;

tag_index++;

entry[tag_index].e_tag = ACL_GROUP_OBJ;

entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;

entry[tag_index].e_id = gid;

tag_index++;

if (additionalGids.size() > 0) {

for (gid_t additional_gid : additionalGids) {

entry[tag_index].e_tag = ACL_GROUP;

entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;

entry[tag_index].e_id = additional_gid;

tag_index++;

}

entry[tag_index].e_tag = ACL_MASK;

entry[tag_index].e_perm = (mode & S_IRWXG) >> 3;

entry[tag_index].e_id = 0;

tag_index++;

}

entry[tag_index].e_tag = ACL_OTHER;

entry[tag_index].e_perm = mode & S_IRWXO;

entry[tag_index].e_id = 0;

int ret = setxattr(path.c_str(), XATTR_NAME_POSIX_ACL_DEFAULT, acl_header, size, 0);

if (ret != 0) {

PLOG(ERROR) << "Failed to set default ACL on " << path;

}

return ret;

}

int SetQuotaInherit(const std::string& path) {

unsigned int flags;

android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));

if (fd == -1) {

PLOG(ERROR) << "Failed to open " << path << " to set project id inheritance.";

return -1;

}

int ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);

if (ret == -1) {

PLOG(ERROR) << "Failed to get flags for " << path << " to set project id inheritance.";

return ret;

}

flags |= FS_PROJINHERIT_FL;

ret = ioctl(fd, FS_IOC_SETFLAGS, &flags);

if (ret == -1) {

PLOG(ERROR) << "Failed to set flags for " << path << " to set project id inheritance.";

return ret;

}

return 0;

}

bool IsLegacyUserdata(const std::string& path) {

struct statfs s;

if (statfs(path.c_str(), &s) != 0) {

PLOG(WARNING) << "statfs failed for " << path;

return false;

}

return (s.f_type == EXT4_SUPER_MAGIC);

}

int SetQuotaProjectId(const std::string& path, long projectId) {

struct fsxattr fsx;

android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));

if (fd == -1) {

PLOG(ERROR) << "Failed to open " << path << " to set project id.";

return -1;

}

int ret = ioctl(fd, FS_IOC_FSGETXATTR, &fsx);

if (ret == -1) {

PLOG(ERROR) << "Failed to get extended attributes for " << path << " to get project id.";

return ret;

}

fsx.fsx_projid = projectId;

ret = ioctl(fd, FS_IOC_FSSETXATTR, &fsx);

if (ret == -1) {

int err = errno;

if (IsLegacyUserdata(path) && (err == EINVAL || err == ENOTTY || err == EOPNOTSUPP)) {

LOG(WARNING) << "Project quota not supported on " << path

<< " (errno=" << err << "), skipping for legacy userdata";

return 0; // swallow

}

PLOG(ERROR) << "Failed to set project id on " << path;

return ret;

}

return 0;

}

int PrepareDirWithProjectId(const std::string& path, mode_t mode, uid_t uid, gid_t gid,

long projectId) {

int ret = fs_prepare_dir(path.c_str(), mode, uid, gid);

if (ret != 0) {

return ret;

}

if (!IsSdcardfsUsed()) {

ret = SetQuotaProjectId(path, projectId);

}

return ret;

}

static int FixupAppDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid, long projectId) {

namespace fs = std::filesystem;

// Setup the directory itself correctly

int ret = PrepareDirWithProjectId(path, mode, uid, gid, projectId);

if (ret != OK) {

return ret;

}

std::error_code ec;

// Fixup all of its file entries

for (auto itEntry = fs::directory_iterator(path, ec); itEntry != fs::directory_iterator();

itEntry.increment(ec)) {

if (ec == std::errc::no_such_file_or_directory) {

LOG(WARNING) << "Skipping non-existent directory entry: " << itEntry->path();

ec.clear();

continue;

} else if (ec) {

LOG(ERROR) << "Failed to iterate dir: " << ec.message();

return -1;

}

ret = lchown(itEntry->path().c_str(), uid, gid);

if (ret != 0) {

return ret;

}

ret = chmod(itEntry->path().c_str(), mode);

if (ret != 0) {

return ret;

}

if (!IsSdcardfsUsed()) {

ret = SetQuotaProjectId(itEntry->path(), projectId);

if (ret != 0) {

return ret;

}

}

}

return RestoreconRecursive(path);

}

int PrepareAppDirFromRoot(const std::string& path, const std::string& root, int appUid,

bool fixupExisting) {

long projectId;

size_t pos;

int ret = 0;

bool sdcardfsSupport = IsSdcardfsUsed();

// Make sure the Android/ directories exist and are setup correctly

ret = PrepareAndroidDirs(root);

if (ret != 0) {

LOG(ERROR) << "Failed to prepare Android/ directories.";

return ret;

}

// Now create the application-specific subdir(s)

// path is something like /data/media/0/Android/data/com.foo/files

// First, chop off the volume root, eg /data/media/0

std::string pathFromRoot = path.substr(root.length());

uid_t uid = appUid;

gid_t gid = AID_MEDIA_RW;

std::vector<gid_t> additionalGids;

std::string appDir;

// Check that the next part matches one of the allowed Android/ dirs

if (StartsWith(pathFromRoot, kAppDataDir)) {

appDir = kAppDataDir;

if (!sdcardfsSupport) {

gid = AID_EXT_DATA_RW;

// Also add the app's own UID as a group; since apps belong to a group

// that matches their UID, this ensures that they will always have access to

// the files created in these dirs, even if they are created by other processes

additionalGids.push_back(uid);

}

} else if (StartsWith(pathFromRoot, kAppMediaDir)) {

appDir = kAppMediaDir;

if (!sdcardfsSupport) {

gid = AID_MEDIA_RW;

// See comments for kAppDataDir above

additionalGids.push_back(uid);

}

} else if (StartsWith(pathFromRoot, kAppObbDir)) {

appDir = kAppObbDir;

if (!sdcardfsSupport) {

gid = AID_EXT_OBB_RW;

// See comments for kAppDataDir above

additionalGids.push_back(uid);

}

} else {

LOG(ERROR) << "Invalid application directory: " << path;

return -EINVAL;

}

// mode = 770, plus setgid bit on directory to inherit GID when apps

// create subdirs

mode_t mode = S_IRWXU | S_IRWXG | S_ISGID;

// the project ID for application-specific directories is directly

// derived from their uid

// Chop off the generic application-specific part, eg /Android/data/

// this leaves us with something like com.foo/files/

std::string leftToCreate = pathFromRoot.substr(appDir.length());

if (!EndsWith(leftToCreate, "/")) {

leftToCreate += "/";

}

std::string pathToCreate = root + appDir;

int depth = 0;

// Derive initial project ID

if (appDir == kAppDataDir || appDir == kAppMediaDir) {

projectId = uid - AID_APP_START + PROJECT_ID_EXT_DATA_START;

} else if (appDir == kAppObbDir) {

projectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;

}

while ((pos = leftToCreate.find('/')) != std::string::npos) {

std::string component = leftToCreate.substr(0, pos + 1);

leftToCreate = leftToCreate.erase(0, pos + 1);

pathToCreate = pathToCreate + component;

if (appDir == kAppDataDir && depth == 1 && component == "cache/") {

// All dirs use the "app" project ID, except for the cache dirs in

// Android/data, eg Android/data/com.foo/cache

// Note that this "sticks" - eg subdirs of this dir need the same

// project ID.

projectId = uid - AID_APP_START + PROJECT_ID_EXT_CACHE_START;

}

if (fixupExisting && access(pathToCreate.c_str(), F_OK) == 0) {

// Fixup all files in this existing directory with the correct UID/GID

// and project ID.

ret = FixupAppDir(pathToCreate, mode, uid, gid, projectId);

} else {

ret = PrepareDirWithProjectId(pathToCreate, mode, uid, gid, projectId);

}

if (ret != 0) {

return ret;

}

if (depth == 0) {

// Set the default ACL on the top-level application-specific directories,

// to ensure that even if applications run with a umask of 0077,

// new directories within these directories will allow the GID

// specified here to write; this is necessary for apps like

// installers and MTP, that require access here.

//

// See man (5) acl for more details.

ret = SetDefaultAcl(pathToCreate, mode, uid, gid, additionalGids);

if (ret != 0) {

return ret;

}

if (!sdcardfsSupport) {

// Set project ID inheritance, so that future subdirectories inherit the

// same project ID

ret = SetQuotaInherit(pathToCreate);

if (ret != 0) {

return ret;

}

}

}

depth++;

}

return OK;

}

int SetAttrs(const std::string& path, unsigned int attrs) {

unsigned int flags;

android::base::unique_fd fd(

TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));

if (fd == -1) {

PLOG(ERROR) << "Failed to open " << path;

return -1;

}

if (ioctl(fd, FS_IOC_GETFLAGS, &flags)) {

PLOG(ERROR) << "Failed to get flags for " << path;

return -1;

}

if ((flags & attrs) == attrs) return 0;

flags |= attrs;

if (ioctl(fd, FS_IOC_SETFLAGS, &flags)) {

PLOG(ERROR) << "Failed to set flags for " << path << "(0x" << std::hex << attrs << ")";

return -1;

}

return 0;

}

status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid,

unsigned int attrs) {

std::lock_guard<std::mutex> lock(kSecurityLock);

const char* cpath = path.c_str();

auto clearfscreatecon = android::base::make_scope_guard([] { setfscreatecon(nullptr); });

auto secontext = std::unique_ptr<char, void (*)(char*)>(nullptr, freecon);

char* tmp_secontext;

if (selabel_lookup(sehandle, &tmp_secontext, cpath, S_IFDIR) == 0) {

secontext.reset(tmp_secontext);

if (setfscreatecon(secontext.get()) != 0) {

LOG(ERROR) << "Failed to setfscreatecon for directory " << path;

return -EINVAL;

}

} else if (errno == ENOENT) {

LOG(DEBUG) << "No selabel defined for directory " << path;

} else {

PLOG(ERROR) << "Failed to look up selabel for directory " << path;

return -errno;

}

if (fs_prepare_dir(cpath, mode, uid, gid) != 0) return -errno;

if (attrs && SetAttrs(path, attrs) != 0) return -errno;

return OK;

}

status_t ForceUnmount(const std::string& path) {

const char* cpath = path.c_str();

if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {

return OK;

}

// Apps might still be handling eject request, so wait before

// we start sending signals

if (sSleepOnUnmount) sleep(5);

KillProcessesWithOpenFiles(path, SIGINT);

if (sSleepOnUnmount) sleep(5);

if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {

return OK;

}

KillProcessesWithOpenFiles(path, SIGTERM);

if (sSleepOnUnmount) sleep(5);

if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {

return OK;

}

KillProcessesWithOpenFiles(path, SIGKILL);

if (sSleepOnUnmount) sleep(5);

if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {

return OK;

}

PLOG(INFO) << "ForceUnmount failed";

return -errno;

}

status_t KillProcessesWithTmpfsMountPrefix(const std::string& path) {

if (KillProcessesWithTmpfsMounts(path, SIGINT) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

if (KillProcessesWithTmpfsMounts(path, SIGTERM) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

if (KillProcessesWithTmpfsMounts(path, SIGKILL) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

// Send SIGKILL a second time to determine if we've

// actually killed everyone mount

if (KillProcessesWithTmpfsMounts(path, SIGKILL) == 0) {

return OK;

}

PLOG(ERROR) << "Failed to kill processes using " << path;

return -EBUSY;

}

status_t KillProcessesUsingPath(const std::string& path) {

if (KillProcessesWithOpenFiles(path, SIGINT, false /* killFuseDaemon */) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

if (KillProcessesWithOpenFiles(path, SIGTERM, false /* killFuseDaemon */) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

if (KillProcessesWithOpenFiles(path, SIGKILL, false /* killFuseDaemon */) == 0) {

return OK;

}

if (sSleepOnUnmount) sleep(5);

// Send SIGKILL a second time to determine if we've

// actually killed everyone with open files

// This time, we also kill the FUSE daemon if found

if (KillProcessesWithOpenFiles(path, SIGKILL, true /* killFuseDaemon */) == 0) {

return OK;

}

PLOG(ERROR) << "Failed to kill processes using " << path;

return -EBUSY;

}

status_t BindMount(const std::string& source, const std::string& target) {

if (UnmountTree(target) < 0) {

return -errno;

}

if (TEMP_FAILURE_RETRY(mount(source.c_str(), target.c_str(), nullptr, MS_BIND, nullptr)) < 0) {

PLOG(ERROR) << "Failed to bind mount " << source << " to " << target;

return -errno;

}

return OK;

}

status_t Symlink(const std::string& target, const std::string& linkpath) {

if (Unlink(linkpath) < 0) {

return -errno;

}

if (TEMP_FAILURE_RETRY(symlink(target.c_str(), linkpath.c_str())) < 0) {

PLOG(ERROR) << "Failed to create symlink " << linkpath << " to " << target;

return -errno;

}

return OK;

}

status_t Unlink(const std::string& linkpath) {

if (TEMP_FAILURE_RETRY(unlink(linkpath.c_str())) < 0 && errno != EINVAL && errno != ENOENT) {

PLOG(ERROR) << "Failed to unlink " << linkpath;

return -errno;

}

return OK;

}

status_t CreateDir(const std::string& dir, mode_t mode) {

struct stat sb;

if (TEMP_FAILURE_RETRY(stat(dir.c_str(), &sb)) == 0) {

if (S_ISDIR(sb.st_mode)) {

return OK;

} else if (TEMP_FAILURE_RETRY(unlink(dir.c_str())) == -1) {

PLOG(ERROR) << "Failed to unlink " << dir;

return -errno;

}

} else if (errno != ENOENT) {

PLOG(ERROR) << "Failed to stat " << dir;

return -errno;

}

if (TEMP_FAILURE_RETRY(mkdir(dir.c_str(), mode)) == -1 && errno != EEXIST) {

PLOG(ERROR) << "Failed to mkdir " << dir;

return -errno;

}

return OK;

}

bool FindValue(const std::string& raw, const std::string& key, std::string* value) {

auto qual = key + "=\"";

size_t start = 0;

while (true) {

start = raw.find(qual, start);

if (start == std::string::npos) return false;

if (start == 0 || raw[start - 1] == ' ') {

break;

}

start += 1;

}

start += qual.length();

auto end = raw.find("\"", start);

if (end == std::string::npos) return false;

*value = raw.substr(start, end - start);

return true;

}

static status_t readMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,

std::string* fsLabel, bool untrusted) {

fsType->clear();

fsUuid->clear();

fsLabel->clear();

std::vector<std::string> cmd;

cmd.push_back(kBlkidPath);

cmd.push_back("-c");

cmd.push_back("/dev/null");

cmd.push_back("-s");

cmd.push_back("TYPE");

cmd.push_back("-s");

cmd.push_back("UUID");

cmd.push_back("-s");

cmd.push_back("LABEL");

cmd.push_back(path);

std::vector<std::string> output;

status_t res = ForkExecvp(cmd, &output, untrusted ? sBlkidUntrustedContext : sBlkidContext);

if (res != OK) {

LOG(WARNING) << "blkid failed to identify " << path;

return res;

}

for (const auto& line : output) {

// Extract values from blkid output, if defined

FindValue(line, "TYPE", fsType);

FindValue(line, "UUID", fsUuid);

FindValue(line, "LABEL", fsLabel);

}

return OK;

}

status_t ReadMetadata(const std::string& path, std::string* fsType, std::string* fsUuid,

std::string* fsLabel) {

return readMetadata(path, fsType, fsUuid, fsLabel, false);

}

status_t ReadMetadataUntrusted(const std::string& path, std::string* fsType, std::string* fsUuid,

std::string* fsLabel) {

return readMetadata(path, fsType, fsUuid, fsLabel, true);

}

static std::vector<const char*> ConvertToArgv(const std::vector<std::string>& args) {

std::vector<const char*> argv;

argv.reserve(args.size() + 1);

for (const auto& arg : args) {

if (argv.empty()) {

LOG(DEBUG) << arg;

} else {

LOG(DEBUG) << " " << arg;

}

argv.emplace_back(arg.data());

}

argv.emplace_back(nullptr);

return argv;

}

static status_t ReadLinesFromFdAndLog(std::vector<std::string>* output,

android::base::unique_fd ufd) {

std::unique_ptr<FILE, int (*)(FILE*)> fp(android::base::Fdopen(std::move(ufd), "r"), fclose);

if (!fp) {

PLOG(ERROR) << "fdopen in ReadLinesFromFdAndLog";

return -errno;

}

if (output) output->clear();

char line[1024];

while (fgets(line, sizeof(line), fp.get()) != nullptr) {

LOG(DEBUG) << line;

if (output) output->emplace_back(line);

}

return OK;

}

status_t ForkExecvp(const std::vector<std::string>& args, std::vector<std::string>* output,

char* context) {

auto argv = ConvertToArgv(args);

android::base::unique_fd pipe_read, pipe_write;

if (!android::base::Pipe(&pipe_read, &pipe_write)) {

PLOG(ERROR) << "Pipe in ForkExecvp";

return -errno;

}

pid_t pid = fork();

if (pid == 0) {

if (context) {

if (setexeccon(context)) {

LOG(ERROR) << "Failed to setexeccon in ForkExecvp";

abort();

}

}

pipe_read.reset();

if (dup2(pipe_write.get(), STDOUT_FILENO) == -1) {

PLOG(ERROR) << "dup2 in ForkExecvp";

_exit(EXIT_FAILURE);

}

pipe_write.reset();

execvp(argv[0], const_cast<char**>(argv.data()));

PLOG(ERROR) << "exec in ForkExecvp";

_exit(EXIT_FAILURE);

}

if (pid == -1) {

PLOG(ERROR) << "fork in ForkExecvp";

return -errno;

}

pipe_write.reset();

auto st = ReadLinesFromFdAndLog(output, std::move(pipe_read));

if (st != 0) return st;

int status;

if (waitpid(pid, &status, 0) == -1) {

PLOG(ERROR) << "waitpid in ForkExecvp";

return -errno;

}

if (!WIFEXITED(status)) {

LOG(ERROR) << "Process did not exit normally, status: " << status;

return -ECHILD;

}

if (WEXITSTATUS(status)) {

LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);

return WEXITSTATUS(status);

}

return OK;

}

status_t ForkTimeout(int (*func)(void*), void* args, std::chrono::seconds timeout) {

int status;

// We're waiting on either the timeout or workload process to finish, so we're

// initially forking to get away from any other vold children

pid_t wait_timeout_pid = fork();

if (wait_timeout_pid == 0) {

pid_t pid = fork();

if (pid == 0) {

_exit(func(args));

}

if (pid == -1) {

_exit(EXIT_FAILURE);

}

pid_t timer_pid = fork();

if (timer_pid == 0) {

std::this_thread::sleep_for(timeout);

_exit(ETIMEDOUT);

}

if (timer_pid == -1) {

PLOG(ERROR) << "fork in ForkTimeout failed";

kill(pid, SIGTERM);

_exit(EXIT_FAILURE);

}

// Preserve the exit code of the first process to finish, and end the other

pid_t finished = wait(&status);

if (finished == pid) {

kill(timer_pid, SIGTERM);

} else {

kill(pid, SIGTERM);

}

if (!WIFEXITED(status)) {

_exit(ECHILD);

}

_exit(WEXITSTATUS(status));

}

if (waitpid(wait_timeout_pid, &status, 0) == -1) {

PLOG(ERROR) << "waitpid in ForkTimeout failed";

return -errno;

}

if (!WIFEXITED(status)) {

LOG(ERROR) << "Process did not exit normally, status: " << status;

return -ECHILD;

}

if (WEXITSTATUS(status)) {

LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);

return WEXITSTATUS(status);

}

return OK;

}

status_t ForkExecvpTimeout(const std::vector<std::string>& args, std::chrono::seconds timeout,

char* context) {

int status;

pid_t wait_timeout_pid = fork();

if (wait_timeout_pid == 0) {

pid_t pid = ForkExecvpAsync(args, context);

if (pid == -1) {

_exit(EXIT_FAILURE);

}

pid_t timer_pid = fork();

if (timer_pid == 0) {

std::this_thread::sleep_for(timeout);

_exit(ETIMEDOUT);

}

if (timer_pid == -1) {

PLOG(ERROR) << "fork in ForkExecvpAsync_timeout";

kill(pid, SIGTERM);

_exit(EXIT_FAILURE);

}

pid_t finished = wait(&status);

if (finished == pid) {

kill(timer_pid, SIGTERM);

} else {

kill(pid, SIGTERM);

}

if (!WIFEXITED(status)) {

_exit(ECHILD);

}

_exit(WEXITSTATUS(status));

}

if (waitpid(wait_timeout_pid, &status, 0) == -1) {

PLOG(ERROR) << "waitpid in ForkExecvpAsync_timeout";

return -errno;

}

if (!WIFEXITED(status)) {

LOG(ERROR) << "Process did not exit normally, status: " << status;

return -ECHILD;

}

if (WEXITSTATUS(status)) {

LOG(ERROR) << "Process exited with code: " << WEXITSTATUS(status);

return WEXITSTATUS(status);

}

return OK;

}

pid_t ForkExecvpAsync(const std::vector<std::string>& args, char* context) {

auto argv = ConvertToArgv(args);

pid_t pid = fork();

if (pid == 0) {

close(STDIN_FILENO);

close(STDOUT_FILENO);

close(STDERR_FILENO);

if (context) {

if (setexeccon(context)) {

LOG(ERROR) << "Failed to setexeccon in ForkExecvpAsync";

abort();

}

}

execvp(argv[0], const_cast<char**>(argv.data()));

PLOG(ERROR) << "exec in ForkExecvpAsync";

_exit(EXIT_FAILURE);

}

if (pid == -1) {

PLOG(ERROR) << "fork in ForkExecvpAsync";

return -1;

}

return pid;

}

status_t HexToStr(const std::string& hex, std::string& str) {

str.clear();

bool even = true;

char cur = 0;

for (size_t i = 0; i < hex.size(); i++) {

int val = 0;

switch (hex[i]) {

// clang-format off

case ' ': case '-': case ':': continue;

case 'f': case 'F': val = 15; break;

case 'e': case 'E': val = 14; break;

case 'd': case 'D': val = 13; break;

case 'c': case 'C': val = 12; break;

case 'b': case 'B': val = 11; break;

case 'a': case 'A': val = 10; break;

case '9': val = 9; break;

case '8': val = 8; break;

case '7': val = 7; break;

case '6': val = 6; break;

case '5': val = 5; break;

case '4': val = 4; break;

case '3': val = 3; break;

case '2': val = 2; break;

case '1': val = 1; break;

case '0': val = 0; break;

default: return -EINVAL;

// clang-format on

}

if (even) {

cur = val << 4;

} else {

cur += val;

str.push_back(cur);

cur = 0;

}

even = !even;

}

return even ? OK : -EINVAL;

}

static const char* kLookup = "0123456789abcdef";

status_t StrToHex(const std::string& str, std::string& hex) {

hex.clear();

for (size_t i = 0; i < str.size(); i++) {

hex.push_back(kLookup[(str[i] & 0xF0) >> 4]);

hex.push_back(kLookup[str[i] & 0x0F]);

}

return OK;

}

status_t StrToHex(const KeyBuffer& str, KeyBuffer& hex) {

hex.clear();

for (size_t i = 0; i < str.size(); i++) {

hex.push_back(kLookup[(str.data()[i] & 0xF0) >> 4]);

hex.push_back(kLookup[str.data()[i] & 0x0F]);

}

return OK;

}

status_t NormalizeHex(const std::string& in, std::string& out) {

std::string tmp;

if (HexToStr(in, tmp)) {

return -EINVAL;

}

return StrToHex(tmp, out);

}

status_t GetBlockDevSize(int fd, uint64_t* size) {

if (ioctl(fd, BLKGETSIZE64, size)) {

return -errno;

}

return OK;

}

status_t GetBlockDevSize(const std::string& path, uint64_t* size) {

int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);

status_t res = OK;

if (fd < 0) {

return -errno;

}

res = GetBlockDevSize(fd, size);

close(fd);

return res;

}