anonymous_namespace{ArchiveSandbox.cpp} Namespace Reference

Functions
bool	drain_fd_nonblocking (int fd, std::string &out, bool &got_eof, bool &truncated)
bool	set_nonblocking (int fd)
void	set_worker_rlimits ()
bool	json_has_true (const std::string &jsonjson, const std::string &key)
int	json_read_int (const std::string &jsonjson, const std::string &key, int fallback=0)
std::string	json_read_string (const std::string &jsonjson, const std::string &key)

Function Documentation

drain_fd_nonblocking()

bool anonymous_namespace{ArchiveSandbox.cpp}::drain_fd_nonblocking	(	int	fd,
		std::string &	out,
		bool &	got_eof,
		bool &	truncated )

Definition at line 50 of file ArchiveSandbox.cpp.

                                                                                  {
    constexpr std::size_t max_output_bytes = 1024 * 1024;
    got_eof = false;
    std::array<char, 4096> buf{};
    while (true) {
        const ssize_t n = ::read(fd, buf.data(), buf.size());
        if (n == 0) {
            got_eof = true;
            return true;
        }
        if (n < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK) return true;
            return false;
        }
        const auto length = static_cast<std::size_t>(n);
        if (out.size() < max_output_bytes) {
            const auto copy = std::min(length, max_output_bytes - out.size());
            out.append(buf.data(), copy);
            if (copy != length) truncated = true;
        } else {
            truncated = true;
        }
    }
}

References drain_fd_nonblocking().

Referenced by drain_fd_nonblocking(), and run_archive_worker_bwrap().

json_has_true()

bool anonymous_namespace{ArchiveSandbox.cpp}::json_has_true	(	const std::string &	json,
		const std::string &	key )

Definition at line 104 of file ArchiveSandbox.cpp.

                                                                {
    const std::string pat = "\"" + key + "\":true";
    return json.find(pat) != std::string::npos;
}

References json_has_true().

Referenced by analyze_archive_in_sandbox(), and json_has_true().

json_read_int()

int anonymous_namespace{ArchiveSandbox.cpp}::json_read_int	(	const std::string &	json,
		const std::string &	key,
		int	fallback = 0 )

Definition at line 109 of file ArchiveSandbox.cpp.

                                                                               {
    const std::string pat = "\"" + key + "\":";
    std::size_t pos = json.find(pat);
    if (pos == std::string::npos) {
        return fallback;
    }
 
    pos += pat.size();
    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
        ++pos;
    }
 
    bool neg = false;
    if (pos < json.size() && json[pos] == '-') {
        neg = true;
        ++pos;
    }
 
    int value = 0;
    bool seen = false;
    while (pos < json.size() && std::isdigit(static_cast<unsigned char>(json[pos]))) {
        seen = true;
        value = value * 10 + (json[pos] - '0');
        ++pos;
    }
 
    if (!seen) {
        return fallback;
    }
 
    return neg ? -value : value;
}

References json_read_int().

Referenced by analyze_archive_in_sandbox(), and json_read_int().

json_read_string()

std::string anonymous_namespace{ArchiveSandbox.cpp}::json_read_string	(	const std::string &	json,
		const std::string &	key )

Definition at line 142 of file ArchiveSandbox.cpp.

                                                                        {
    const std::string pat = "\"" + key + "\":\"";
    std::size_t pos = json.find(pat);
    if (pos == std::string::npos) {
        return {};
    }
 
    pos += pat.size();
 
    std::string out;
    while (pos < json.size()) {
        char c = json[pos++];
        if (c == '\\') {
            if (pos < json.size()) {
                out.push_back(json[pos++]);
            }
            continue;
        }
        if (c == '"') {
            break;
        }
        out.push_back(c);
    }
 
    return out;
}

References json_read_string().

Referenced by analyze_archive_in_sandbox(), and json_read_string().

set_nonblocking()

bool anonymous_namespace{ArchiveSandbox.cpp}::set_nonblocking

(

int

fd

)

Definition at line 76 of file ArchiveSandbox.cpp.

                             {
    const int flags = ::fcntl(fd, F_GETFL, 0);
    if (flags < 0) return false;
    return ::fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0;
}

References set_nonblocking().

Referenced by run_archive_worker_bwrap(), and set_nonblocking().

set_worker_rlimits()

void anonymous_namespace{ArchiveSandbox.cpp}::set_worker_rlimits

(

)

Definition at line 82 of file ArchiveSandbox.cpp.

                          {
    struct rlimit cpu_lim {};
    cpu_lim.rlim_cur = 10;
    cpu_lim.rlim_max = 10;
    ::setrlimit(RLIMIT_CPU, &cpu_lim);
 
    struct rlimit as_lim {};
    as_lim.rlim_cur = 512ULL * 1024ULL * 1024ULL;
    as_lim.rlim_max = 512ULL * 1024ULL * 1024ULL;
    ::setrlimit(RLIMIT_AS, &as_lim);
 
    struct rlimit fsize_lim {};
    fsize_lim.rlim_cur = 128ULL * 1024ULL * 1024ULL;
    fsize_lim.rlim_max = 128ULL * 1024ULL * 1024ULL;
    ::setrlimit(RLIMIT_FSIZE, &fsize_lim);
 
    struct rlimit nofile_lim {};
    nofile_lim.rlim_cur = 64;
    nofile_lim.rlim_max = 64;
    ::setrlimit(RLIMIT_NOFILE, &nofile_lim);
}

References set_worker_rlimits().

Referenced by run_archive_worker_bwrap(), and set_worker_rlimits().