2012-07-18 18:59:03 +00:00
|
|
|
#pragma once
|
2023-04-01 03:18:41 +00:00
|
|
|
///@file
|
2003-04-04 16:14:56 +00:00
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
#include "types.hh"
|
2020-04-24 20:57:51 +00:00
|
|
|
#include "error.hh"
|
2016-04-25 13:26:07 +00:00
|
|
|
#include "logging.hh"
|
2020-03-27 16:55:09 +00:00
|
|
|
#include "ansicolor.hh"
|
2003-04-08 12:00:51 +00:00
|
|
|
|
2003-10-22 10:48:22 +00:00
|
|
|
#include <sys/types.h>
|
2010-12-13 13:32:58 +00:00
|
|
|
#include <sys/stat.h>
|
2024-03-06 04:45:40 +00:00
|
|
|
#include <sys/resource.h>
|
2003-10-22 10:48:22 +00:00
|
|
|
#include <dirent.h>
|
2003-04-08 12:00:51 +00:00
|
|
|
#include <unistd.h>
|
2004-01-15 20:23:55 +00:00
|
|
|
#include <signal.h>
|
2016-09-20 13:39:08 +00:00
|
|
|
|
2021-12-31 02:16:59 +00:00
|
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
|
2021-12-01 22:06:15 +00:00
|
|
|
#include <atomic>
|
2014-07-10 14:50:51 +00:00
|
|
|
#include <functional>
|
2016-09-20 13:39:08 +00:00
|
|
|
#include <map>
|
2017-03-08 21:24:10 +00:00
|
|
|
#include <sstream>
|
2019-02-12 12:43:32 +00:00
|
|
|
#include <optional>
|
2009-11-24 12:56:26 +00:00
|
|
|
|
2015-11-07 03:51:33 +00:00
|
|
|
#ifndef HAVE_STRUCT_DIRENT_D_TYPE
|
|
|
|
#define DT_UNKNOWN 0
|
|
|
|
#define DT_REG 1
|
|
|
|
#define DT_LNK 2
|
|
|
|
#define DT_DIR 3
|
|
|
|
#endif
|
2003-06-27 13:55:12 +00:00
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
namespace nix {
|
2003-10-07 14:37:41 +00:00
|
|
|
|
2018-03-16 15:59:31 +00:00
|
|
|
struct Sink;
|
|
|
|
struct Source;
|
|
|
|
|
2023-02-01 12:34:32 +00:00
|
|
|
void initLibUtil();
|
2003-10-07 14:37:41 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* The system for which Nix is compiled.
|
|
|
|
*/
|
2019-05-03 08:44:32 +00:00
|
|
|
extern const std::string nativeSystem;
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return an environment variable.
|
|
|
|
*/
|
2019-11-22 15:06:44 +00:00
|
|
|
std::optional<std::string> getEnv(const std::string & key);
|
2004-05-12 09:35:51 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return a non empty environment variable. Returns nullopt if the env
|
|
|
|
* variable is set to ""
|
|
|
|
*/
|
2023-03-01 19:01:36 +00:00
|
|
|
std::optional<std::string> getEnvNonEmpty(const std::string & key);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Get the entire environment.
|
|
|
|
*/
|
2016-09-20 13:39:08 +00:00
|
|
|
std::map<std::string, std::string> getEnv();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Clear the environment.
|
|
|
|
*/
|
2018-02-26 17:29:40 +00:00
|
|
|
void clearEnv();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return An absolutized path, resolving paths relative to the
|
|
|
|
* specified directory, or the current directory otherwise. The path
|
|
|
|
* is also canonicalised.
|
|
|
|
*/
|
2020-01-21 15:27:53 +00:00
|
|
|
Path absPath(Path path,
|
2022-01-21 16:55:51 +00:00
|
|
|
std::optional<PathView> dir = {},
|
2020-01-21 15:27:53 +00:00
|
|
|
bool resolveSymlinks = false);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Canonicalise a path by removing all `.` or `..` components and
|
|
|
|
* double or trailing slashes. Optionally resolves all symlink
|
|
|
|
* components such that each component of the resulting path is *not*
|
|
|
|
* a symbolic link.
|
|
|
|
*/
|
2022-01-12 15:02:29 +00:00
|
|
|
Path canonPath(PathView path, bool resolveSymlinks = false);
|
2003-07-07 09:25:26 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return The directory part of the given canonical path, i.e.,
|
|
|
|
* everything before the final `/`. If the path is the root or an
|
|
|
|
* immediate child thereof (e.g., `/foo`), this means `/`
|
|
|
|
* is returned.
|
|
|
|
*/
|
2022-01-21 16:55:51 +00:00
|
|
|
Path dirOf(const PathView path);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return the base name of the given canonical path, i.e., everything
|
|
|
|
* following the final `/` (trailing slashes are removed).
|
|
|
|
*/
|
2019-12-05 18:11:09 +00:00
|
|
|
std::string_view baseNameOf(std::string_view path);
|
2003-04-08 12:00:51 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Perform tilde expansion on a path.
|
|
|
|
*/
|
2022-02-19 13:26:34 +00:00
|
|
|
std::string expandTilde(std::string_view path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Check whether 'path' is a descendant of 'dir'. Both paths must be
|
|
|
|
* canonicalized.
|
|
|
|
*/
|
2021-12-02 13:16:05 +00:00
|
|
|
bool isInDir(std::string_view path, std::string_view dir);
|
2013-07-12 12:01:25 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Check whether 'path' is equal to 'dir' or a descendant of
|
|
|
|
* 'dir'. Both paths must be canonicalized.
|
|
|
|
*/
|
2021-12-02 13:16:05 +00:00
|
|
|
bool isDirOrInDir(std::string_view path, std::string_view dir);
|
2018-01-16 17:50:38 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Get status of `path`.
|
|
|
|
*/
|
2022-02-18 12:26:40 +00:00
|
|
|
struct stat stat(const Path & path);
|
2010-12-13 13:32:58 +00:00
|
|
|
struct stat lstat(const Path & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return true iff the given path exists.
|
|
|
|
*/
|
2003-10-07 14:37:41 +00:00
|
|
|
bool pathExists(const Path & path);
|
2003-04-08 12:00:51 +00:00
|
|
|
|
2023-05-26 13:32:28 +00:00
|
|
|
/**
|
|
|
|
* A version of pathExists that returns false on a permission error.
|
|
|
|
* Useful for inferring default paths across directories that might not
|
|
|
|
* be readable.
|
|
|
|
* @return true iff the given path can be accessed and exists
|
|
|
|
*/
|
|
|
|
bool pathAccessible(const Path & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Read the contents (target) of a symbolic link. The result is not
|
|
|
|
* in any way canonicalised.
|
|
|
|
*/
|
2004-01-05 16:26:43 +00:00
|
|
|
Path readLink(const Path & path);
|
|
|
|
|
2005-02-01 13:48:46 +00:00
|
|
|
bool isLink(const Path & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Read the contents of a directory. The entries `.` and `..` are
|
|
|
|
* removed.
|
|
|
|
*/
|
2014-08-01 14:37:47 +00:00
|
|
|
struct DirEntry
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string name;
|
2014-08-01 14:37:47 +00:00
|
|
|
ino_t ino;
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* one of DT_*
|
|
|
|
*/
|
|
|
|
unsigned char type;
|
2022-02-25 15:00:00 +00:00
|
|
|
DirEntry(std::string name, ino_t ino, unsigned char type)
|
|
|
|
: name(std::move(name)), ino(ino), type(type) { }
|
2014-08-01 14:37:47 +00:00
|
|
|
};
|
|
|
|
|
2022-02-21 15:32:34 +00:00
|
|
|
typedef std::vector<DirEntry> DirEntries;
|
2014-08-01 14:37:47 +00:00
|
|
|
|
|
|
|
DirEntries readDirectory(const Path & path);
|
2003-11-19 17:27:16 +00:00
|
|
|
|
2014-10-03 20:37:51 +00:00
|
|
|
unsigned char getFileType(const Path & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Read the contents of a file into a string.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string readFile(int fd);
|
|
|
|
std::string readFile(const Path & path);
|
2018-03-27 21:12:31 +00:00
|
|
|
void readFile(const Path & path, Sink & sink);
|
2005-02-01 22:07:48 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Write a string to a file.
|
|
|
|
*/
|
2022-09-19 18:15:31 +00:00
|
|
|
void writeFile(const Path & path, std::string_view s, mode_t mode = 0666, bool sync = false);
|
2005-02-09 09:50:29 +00:00
|
|
|
|
2022-09-19 18:15:31 +00:00
|
|
|
void writeFile(const Path & path, Source & source, mode_t mode = 0666, bool sync = false);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Flush a file's parent directory to disk
|
|
|
|
*/
|
2022-09-19 18:15:31 +00:00
|
|
|
void syncParent(const Path & path);
|
2018-03-28 11:32:44 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Read a line from a file descriptor.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string readLine(int fd);
|
2009-03-28 19:29:55 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Write a line to a file descriptor.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
void writeLine(int fd, std::string s);
|
2009-03-28 19:29:55 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Delete a path; i.e., in the case of a directory, it is deleted
|
|
|
|
* recursively. It's not an error if the path does not exist. The
|
|
|
|
* second variant returns the number of bytes and blocks freed.
|
|
|
|
*/
|
2003-10-07 14:37:41 +00:00
|
|
|
void deletePath(const Path & path);
|
2003-08-22 20:12:44 +00:00
|
|
|
|
2020-07-30 11:10:49 +00:00
|
|
|
void deletePath(const Path & path, uint64_t & bytesFreed);
|
2005-12-15 21:11:39 +00:00
|
|
|
|
2019-10-09 17:21:07 +00:00
|
|
|
std::string getUserName();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return the given user's home directory from /etc/passwd.
|
|
|
|
*/
|
2022-04-13 08:26:50 +00:00
|
|
|
Path getHomeOf(uid_t userId);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return $HOME or the user's home directory from /etc/passwd.
|
|
|
|
*/
|
2017-05-05 14:40:12 +00:00
|
|
|
Path getHome();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return $XDG_CACHE_HOME or $HOME/.cache.
|
|
|
|
*/
|
2016-04-20 12:12:38 +00:00
|
|
|
Path getCacheDir();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return $XDG_CONFIG_HOME or $HOME/.config.
|
|
|
|
*/
|
2017-04-20 12:58:16 +00:00
|
|
|
Path getConfigDir();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return the directories to search for user configuration files
|
|
|
|
*/
|
2018-10-25 11:00:21 +00:00
|
|
|
std::vector<Path> getConfigDirs();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return $XDG_DATA_HOME or $HOME/.local/share.
|
|
|
|
*/
|
2017-04-25 16:56:29 +00:00
|
|
|
Path getDataDir();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return the path of the current executable.
|
|
|
|
*/
|
2022-06-22 20:43:53 +00:00
|
|
|
std::optional<Path> getSelfExe();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return $XDG_STATE_HOME or $HOME/.local/state.
|
|
|
|
*/
|
2021-11-17 20:35:21 +00:00
|
|
|
Path getStateDir();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create the Nix state directory and return the path to it.
|
|
|
|
*/
|
2021-11-17 20:35:21 +00:00
|
|
|
Path createNixStateDir();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a directory and all its parents, if necessary. Returns the
|
|
|
|
* list of created directories, in order of creation.
|
|
|
|
*/
|
2007-10-27 00:46:59 +00:00
|
|
|
Paths createDirs(const Path & path);
|
2022-06-22 20:43:53 +00:00
|
|
|
inline Paths createDirs(PathView path)
|
|
|
|
{
|
2022-01-21 16:55:51 +00:00
|
|
|
return createDirs(Path(path));
|
|
|
|
}
|
2005-03-24 17:46:38 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a symlink.
|
|
|
|
*/
|
2023-06-14 18:09:11 +00:00
|
|
|
void createSymlink(const Path & target, const Path & link);
|
2014-02-27 22:17:53 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Atomically create or replace a symlink.
|
|
|
|
*/
|
2023-06-14 18:09:11 +00:00
|
|
|
void replaceSymlink(const Path & target, const Path & link);
|
2015-04-09 09:42:04 +00:00
|
|
|
|
2022-04-13 12:10:36 +00:00
|
|
|
void renameFile(const Path & src, const Path & dst);
|
2022-03-17 14:28:46 +00:00
|
|
|
|
2022-04-13 12:19:42 +00:00
|
|
|
/**
|
|
|
|
* Similar to 'renameFile', but fallback to a copy+remove if `src` and `dst`
|
|
|
|
* are on a different filesystem.
|
|
|
|
*
|
|
|
|
* Beware that this might not be atomic because of the copy that happens behind
|
|
|
|
* the scenes
|
|
|
|
*/
|
|
|
|
void moveFile(const Path & src, const Path & dst);
|
|
|
|
|
2003-11-22 15:58:34 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Wrappers arount read()/write() that read/write exactly the
|
|
|
|
* requested number of bytes.
|
|
|
|
*/
|
2020-12-02 13:10:56 +00:00
|
|
|
void readFull(int fd, char * buf, size_t count);
|
2020-12-02 11:43:52 +00:00
|
|
|
void writeFull(int fd, std::string_view s, bool allowInterrupts = true);
|
2003-07-20 21:11:43 +00:00
|
|
|
|
2019-11-10 16:14:26 +00:00
|
|
|
MakeError(EndOfFile, Error);
|
2006-12-04 17:17:13 +00:00
|
|
|
|
2003-07-20 21:11:43 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Read a file descriptor until EOF occurs.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string drainFD(int fd, bool block = true, const size_t reserveSize=0);
|
2006-07-20 12:17:25 +00:00
|
|
|
|
2018-03-20 14:17:59 +00:00
|
|
|
void drainFD(int fd, Sink & sink, bool block = true);
|
2006-07-20 12:17:25 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* If cgroups are active, attempt to calculate the number of CPUs available.
|
|
|
|
* If cgroups are unavailable or if cpu.max is set to "max", return 0.
|
|
|
|
*/
|
2022-07-19 06:09:46 +00:00
|
|
|
unsigned int getMaxCPU();
|
2006-07-20 12:17:25 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Automatic cleanup of resources.
|
|
|
|
*/
|
2003-10-22 10:48:22 +00:00
|
|
|
|
2006-12-04 17:17:13 +00:00
|
|
|
|
2003-10-22 10:48:22 +00:00
|
|
|
class AutoDelete
|
|
|
|
{
|
2006-12-12 23:05:01 +00:00
|
|
|
Path path;
|
2003-10-22 10:48:22 +00:00
|
|
|
bool del;
|
2013-01-03 12:00:46 +00:00
|
|
|
bool recursive;
|
2003-10-22 10:48:22 +00:00
|
|
|
public:
|
2015-11-16 10:53:10 +00:00
|
|
|
AutoDelete();
|
2007-10-27 00:46:59 +00:00
|
|
|
AutoDelete(const Path & p, bool recursive = true);
|
2003-10-22 10:48:22 +00:00
|
|
|
~AutoDelete();
|
|
|
|
void cancel();
|
2015-11-16 10:53:10 +00:00
|
|
|
void reset(const Path & p, bool recursive = true);
|
2015-10-01 14:47:43 +00:00
|
|
|
operator Path() const { return path; }
|
2022-01-21 16:55:51 +00:00
|
|
|
operator PathView() const { return path; }
|
2003-10-22 10:48:22 +00:00
|
|
|
};
|
|
|
|
|
2004-06-22 09:51:44 +00:00
|
|
|
|
2003-10-22 10:48:22 +00:00
|
|
|
class AutoCloseFD
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
public:
|
|
|
|
AutoCloseFD();
|
|
|
|
AutoCloseFD(int fd);
|
2016-07-11 19:44:44 +00:00
|
|
|
AutoCloseFD(const AutoCloseFD & fd) = delete;
|
|
|
|
AutoCloseFD(AutoCloseFD&& fd);
|
2003-10-22 10:48:22 +00:00
|
|
|
~AutoCloseFD();
|
2016-07-11 19:44:44 +00:00
|
|
|
AutoCloseFD& operator =(const AutoCloseFD & fd) = delete;
|
|
|
|
AutoCloseFD& operator =(AutoCloseFD&& fd);
|
|
|
|
int get() const;
|
|
|
|
explicit operator bool() const;
|
|
|
|
int release();
|
2021-04-07 10:21:31 +00:00
|
|
|
void close();
|
2022-09-19 18:15:31 +00:00
|
|
|
void fsync();
|
2004-06-15 13:49:42 +00:00
|
|
|
};
|
|
|
|
|
2004-06-22 09:51:44 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a temporary directory.
|
|
|
|
*/
|
2020-03-30 17:14:17 +00:00
|
|
|
Path createTempDir(const Path & tmpRoot = "", const Path & prefix = "nix",
|
|
|
|
bool includePid = true, bool useGlobalCounter = true, mode_t mode = 0755);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a temporary file, returning a file handle and its path.
|
|
|
|
*/
|
2020-03-30 17:14:17 +00:00
|
|
|
std::pair<AutoCloseFD, Path> createTempFile(const Path & prefix = "nix");
|
|
|
|
|
|
|
|
|
2004-06-15 13:49:42 +00:00
|
|
|
class Pipe
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AutoCloseFD readSide, writeSide;
|
|
|
|
void create();
|
2021-04-07 10:21:31 +00:00
|
|
|
void close();
|
2003-10-22 10:48:22 +00:00
|
|
|
};
|
|
|
|
|
2004-06-22 09:51:44 +00:00
|
|
|
|
2017-01-16 21:39:27 +00:00
|
|
|
struct DIRDeleter
|
2003-10-22 10:48:22 +00:00
|
|
|
{
|
2017-01-16 21:39:27 +00:00
|
|
|
void operator()(DIR * dir) const {
|
|
|
|
closedir(dir);
|
|
|
|
}
|
2003-10-22 10:48:22 +00:00
|
|
|
};
|
|
|
|
|
2017-01-16 21:39:27 +00:00
|
|
|
typedef std::unique_ptr<DIR, DIRDeleter> AutoCloseDir;
|
|
|
|
|
2003-10-22 10:48:22 +00:00
|
|
|
|
2004-06-22 09:51:44 +00:00
|
|
|
class Pid
|
|
|
|
{
|
2017-01-19 15:58:39 +00:00
|
|
|
pid_t pid = -1;
|
|
|
|
bool separatePG = false;
|
|
|
|
int killSignal = SIGKILL;
|
2004-06-22 09:51:44 +00:00
|
|
|
public:
|
|
|
|
Pid();
|
2014-07-10 14:50:51 +00:00
|
|
|
Pid(pid_t pid);
|
2004-06-22 09:51:44 +00:00
|
|
|
~Pid();
|
|
|
|
void operator =(pid_t pid);
|
|
|
|
operator pid_t();
|
2017-03-16 09:52:28 +00:00
|
|
|
int kill();
|
2017-01-19 15:58:39 +00:00
|
|
|
int wait();
|
|
|
|
|
2004-06-22 09:51:44 +00:00
|
|
|
void setSeparatePG(bool separatePG);
|
2007-03-19 12:48:45 +00:00
|
|
|
void setKillSignal(int signal);
|
2016-10-12 13:49:37 +00:00
|
|
|
pid_t release();
|
2004-06-22 09:51:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Kill all processes running under the specified uid by sending them
|
|
|
|
* a SIGKILL.
|
|
|
|
*/
|
2006-12-07 00:16:07 +00:00
|
|
|
void killUser(uid_t uid);
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Fork a process that runs the given function, and return the child
|
|
|
|
* pid to the caller.
|
|
|
|
*/
|
2014-12-10 15:35:42 +00:00
|
|
|
struct ProcessOptions
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string errorPrefix = "";
|
2017-01-19 14:15:45 +00:00
|
|
|
bool dieWithParent = true;
|
|
|
|
bool runExitHandlers = false;
|
2021-10-06 11:54:59 +00:00
|
|
|
bool allowVfork = false;
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* use clone() with the specified flags (Linux only)
|
|
|
|
*/
|
|
|
|
int cloneFlags = 0;
|
2014-12-10 15:35:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
pid_t startProcess(std::function<void()> fun, const ProcessOptions & options = ProcessOptions());
|
2014-07-10 14:50:51 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Run a program and return its stdout in a string (i.e., like the
|
|
|
|
* shell backtick operator).
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string runProgram(Path program, bool searchPath = false,
|
2017-03-15 13:40:47 +00:00
|
|
|
const Strings & args = Strings(),
|
2023-05-18 10:18:34 +00:00
|
|
|
const std::optional<std::string> & input = {}, bool isInteractive = false);
|
2006-07-20 12:17:25 +00:00
|
|
|
|
2017-11-01 17:43:11 +00:00
|
|
|
struct RunOptions
|
|
|
|
{
|
2021-09-13 21:22:09 +00:00
|
|
|
Path program;
|
|
|
|
bool searchPath = true;
|
|
|
|
Strings args;
|
2019-05-11 20:35:53 +00:00
|
|
|
std::optional<uid_t> uid;
|
|
|
|
std::optional<uid_t> gid;
|
|
|
|
std::optional<Path> chdir;
|
2019-07-11 18:23:03 +00:00
|
|
|
std::optional<std::map<std::string, std::string>> environment;
|
2019-02-12 12:43:32 +00:00
|
|
|
std::optional<std::string> input;
|
2018-03-19 16:09:52 +00:00
|
|
|
Source * standardIn = nullptr;
|
|
|
|
Sink * standardOut = nullptr;
|
2019-07-11 18:23:03 +00:00
|
|
|
bool mergeStderrToStdout = false;
|
2023-05-18 10:18:34 +00:00
|
|
|
bool isInteractive = false;
|
2017-11-01 17:43:11 +00:00
|
|
|
};
|
|
|
|
|
2021-09-13 21:22:09 +00:00
|
|
|
std::pair<int, std::string> runProgram(RunOptions && options);
|
2017-11-01 17:43:11 +00:00
|
|
|
|
2018-03-16 15:59:31 +00:00
|
|
|
void runProgram2(const RunOptions & options);
|
|
|
|
|
2017-11-01 17:43:11 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Change the stack size.
|
|
|
|
*/
|
2024-03-06 04:45:40 +00:00
|
|
|
void setStackSize(rlim_t stackSize);
|
2021-04-07 11:40:13 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Restore the original inherited Unix process context (such as signal
|
|
|
|
* masks, stack size).
|
2023-02-01 17:38:54 +00:00
|
|
|
|
|
|
|
* See startSignalHandlerThread(), saveSignalMask().
|
2023-04-07 13:55:28 +00:00
|
|
|
*/
|
2021-10-15 14:25:49 +00:00
|
|
|
void restoreProcessContext(bool restoreMounts = true);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Save the current mount namespace. Ignored if called more than
|
|
|
|
* once.
|
|
|
|
*/
|
2021-10-15 14:25:49 +00:00
|
|
|
void saveMountNamespace();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Restore the mount namespace saved by saveMountNamespace(). Ignored
|
|
|
|
* if saveMountNamespace() was never called.
|
|
|
|
*/
|
2021-10-15 14:25:49 +00:00
|
|
|
void restoreMountNamespace();
|
2021-04-07 11:10:02 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Cause this thread to not share any FS attributes with the main
|
|
|
|
* thread, because this causes setns() in restoreMountNamespace() to
|
|
|
|
* fail.
|
|
|
|
*/
|
2021-12-16 20:26:22 +00:00
|
|
|
void unshareFilesystem();
|
|
|
|
|
2021-04-07 11:10:02 +00:00
|
|
|
|
2016-09-21 14:21:47 +00:00
|
|
|
class ExecError : public Error
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
int status;
|
|
|
|
|
|
|
|
template<typename... Args>
|
2019-12-05 17:23:32 +00:00
|
|
|
ExecError(int status, const Args & ... args)
|
2016-09-21 14:21:47 +00:00
|
|
|
: Error(args...), status(status)
|
|
|
|
{ }
|
|
|
|
};
|
2014-05-21 15:19:36 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Convert a list of strings to a null-terminated vector of `char
|
|
|
|
* *`s. The result must not be accessed beyond the lifetime of the
|
|
|
|
* list of strings.
|
|
|
|
*/
|
2015-06-09 08:50:55 +00:00
|
|
|
std::vector<char *> stringsToCharPtrs(const Strings & ss);
|
2014-12-12 14:01:16 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Close all file descriptors except those listed in the given set.
|
|
|
|
* Good practice in child processes.
|
|
|
|
*/
|
2022-02-21 15:28:23 +00:00
|
|
|
void closeMostFDs(const std::set<int> & exceptions);
|
2008-08-02 12:54:35 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Set the close-on-exec flag for the given file descriptor.
|
|
|
|
*/
|
2012-03-05 19:29:00 +00:00
|
|
|
void closeOnExec(int fd);
|
|
|
|
|
2006-07-20 12:17:25 +00:00
|
|
|
|
2004-01-15 20:23:55 +00:00
|
|
|
/* User interruption. */
|
|
|
|
|
2021-11-24 13:50:08 +00:00
|
|
|
extern std::atomic<bool> _isInterrupted;
|
2004-01-15 20:23:55 +00:00
|
|
|
|
2017-09-08 13:31:24 +00:00
|
|
|
extern thread_local std::function<bool()> interruptCheck;
|
|
|
|
|
2017-04-21 14:28:10 +00:00
|
|
|
void setInterruptThrown();
|
2016-03-29 13:08:24 +00:00
|
|
|
|
2004-01-15 20:23:55 +00:00
|
|
|
void _interrupted();
|
|
|
|
|
|
|
|
void inline checkInterrupt()
|
|
|
|
{
|
2017-09-08 13:31:24 +00:00
|
|
|
if (_isInterrupted || (interruptCheck && interruptCheck()))
|
|
|
|
_interrupted();
|
2004-01-15 20:23:55 +00:00
|
|
|
}
|
|
|
|
|
2019-11-10 16:14:26 +00:00
|
|
|
MakeError(Interrupted, BaseError);
|
2006-12-04 17:17:13 +00:00
|
|
|
|
2004-01-15 20:23:55 +00:00
|
|
|
|
2019-11-10 16:14:26 +00:00
|
|
|
MakeError(FormatError, Error);
|
2016-07-18 22:50:27 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* String tokenizer.
|
|
|
|
*/
|
2022-01-12 15:02:29 +00:00
|
|
|
template<class C> C tokenizeString(std::string_view s, std::string_view separators = " \t\n\r");
|
2005-09-22 15:43:22 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Concatenate the given strings with a separator between the
|
|
|
|
* elements.
|
|
|
|
*/
|
2019-05-02 19:09:52 +00:00
|
|
|
template<class C>
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string concatStringsSep(const std::string_view sep, const C & ss)
|
2019-05-02 19:09:52 +00:00
|
|
|
{
|
2022-01-12 15:02:29 +00:00
|
|
|
size_t size = 0;
|
|
|
|
// need a cast to string_view since this is also called with Symbols
|
|
|
|
for (const auto & s : ss) size += sep.size() + std::string_view(s).size();
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string s;
|
2022-01-12 15:02:29 +00:00
|
|
|
s.reserve(size);
|
2019-05-02 19:09:52 +00:00
|
|
|
for (auto & i : ss) {
|
|
|
|
if (s.size() != 0) s += sep;
|
|
|
|
s += i;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2022-01-12 15:02:29 +00:00
|
|
|
template<class ... Parts>
|
|
|
|
auto concatStrings(Parts && ... parts)
|
2022-02-25 15:00:00 +00:00
|
|
|
-> std::enable_if_t<(... && std::is_convertible_v<Parts, std::string_view>), std::string>
|
2022-01-12 15:02:29 +00:00
|
|
|
{
|
|
|
|
std::string_view views[sizeof...(parts)] = { parts... };
|
|
|
|
return concatStringsSep({}, views);
|
|
|
|
}
|
|
|
|
|
2019-05-02 19:09:52 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Add quotes around a collection of strings.
|
|
|
|
*/
|
2019-05-02 19:09:52 +00:00
|
|
|
template<class C> Strings quoteStrings(const C & c)
|
|
|
|
{
|
|
|
|
Strings res;
|
|
|
|
for (auto & s : c)
|
|
|
|
res.push_back("'" + s + "'");
|
|
|
|
return res;
|
|
|
|
}
|
2010-08-27 13:18:13 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Remove trailing whitespace from a string.
|
|
|
|
*
|
|
|
|
* \todo return std::string_view.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string chomp(std::string_view s);
|
2012-08-01 15:19:24 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Remove whitespace from the start and end of a string.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string trim(std::string_view s, std::string_view whitespace = " \n\r\t");
|
2015-04-09 09:42:04 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Replace all occurrences of a string inside another string.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string replaceStrings(
|
|
|
|
std::string s,
|
|
|
|
std::string_view from,
|
|
|
|
std::string_view to);
|
2015-06-17 14:20:11 +00:00
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string rewriteStrings(std::string s, const StringMap & rewrites);
|
2018-03-29 22:56:13 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Convert the exit status of a child as returned by wait() into an
|
|
|
|
* error string.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string statusToString(int status);
|
2004-06-22 08:50:25 +00:00
|
|
|
|
2004-06-22 11:03:41 +00:00
|
|
|
bool statusOk(int status);
|
|
|
|
|
2004-06-22 08:50:25 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Parse a string into an integer.
|
|
|
|
*/
|
2021-01-08 11:22:21 +00:00
|
|
|
template<class N>
|
2021-12-31 02:16:59 +00:00
|
|
|
std::optional<N> string2Int(const std::string_view s)
|
2009-11-24 12:26:25 +00:00
|
|
|
{
|
2021-01-08 11:22:21 +00:00
|
|
|
if (s.substr(0, 1) == "-" && !std::numeric_limits<N>::is_signed)
|
2021-01-08 11:51:19 +00:00
|
|
|
return std::nullopt;
|
2021-12-31 02:16:59 +00:00
|
|
|
try {
|
|
|
|
return boost::lexical_cast<N>(s.data(), s.size());
|
|
|
|
} catch (const boost::bad_lexical_cast &) {
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
2021-01-08 11:51:19 +00:00
|
|
|
}
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Like string2Int(), but support an optional suffix 'K', 'M', 'G' or
|
|
|
|
* 'T' denoting a binary unit prefix.
|
|
|
|
*/
|
2021-01-08 11:51:19 +00:00
|
|
|
template<class N>
|
2021-12-31 02:16:59 +00:00
|
|
|
N string2IntWithUnitPrefix(std::string_view s)
|
2021-01-08 11:51:19 +00:00
|
|
|
{
|
|
|
|
N multiplier = 1;
|
|
|
|
if (!s.empty()) {
|
|
|
|
char u = std::toupper(*s.rbegin());
|
|
|
|
if (std::isalpha(u)) {
|
|
|
|
if (u == 'K') multiplier = 1ULL << 10;
|
|
|
|
else if (u == 'M') multiplier = 1ULL << 20;
|
|
|
|
else if (u == 'G') multiplier = 1ULL << 30;
|
|
|
|
else if (u == 'T') multiplier = 1ULL << 40;
|
|
|
|
else throw UsageError("invalid unit specifier '%1%'", u);
|
2021-12-31 02:16:59 +00:00
|
|
|
s.remove_suffix(1);
|
2021-01-08 11:51:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (auto n = string2Int<N>(s))
|
|
|
|
return *n * multiplier;
|
|
|
|
throw UsageError("'%s' is not an integer", s);
|
2009-11-24 12:26:25 +00:00
|
|
|
}
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Parse a string into a float.
|
|
|
|
*/
|
2021-01-08 11:22:21 +00:00
|
|
|
template<class N>
|
2021-12-31 02:16:59 +00:00
|
|
|
std::optional<N> string2Float(const std::string_view s)
|
2016-01-04 23:40:40 +00:00
|
|
|
{
|
2021-12-31 02:16:59 +00:00
|
|
|
try {
|
|
|
|
return boost::lexical_cast<N>(s.data(), s.size());
|
|
|
|
} catch (const boost::bad_lexical_cast &) {
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
2016-01-04 23:40:40 +00:00
|
|
|
}
|
|
|
|
|
2004-09-10 13:32:08 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Convert a little-endian integer to host order.
|
|
|
|
*/
|
2022-12-07 11:58:58 +00:00
|
|
|
template<typename T>
|
|
|
|
T readLittleEndian(unsigned char * p)
|
|
|
|
{
|
|
|
|
T x = 0;
|
2022-12-12 11:40:51 +00:00
|
|
|
for (size_t i = 0; i < sizeof(x); ++i, ++p) {
|
|
|
|
x |= ((T) *p) << (i * 8);
|
|
|
|
}
|
2022-12-07 11:58:58 +00:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return true iff `s` starts with `prefix`.
|
|
|
|
*/
|
2020-06-12 21:12:36 +00:00
|
|
|
bool hasPrefix(std::string_view s, std::string_view prefix);
|
2016-04-29 19:04:40 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return true iff `s` ends in `suffix`.
|
|
|
|
*/
|
2019-12-05 18:11:09 +00:00
|
|
|
bool hasSuffix(std::string_view s, std::string_view suffix);
|
2008-08-25 13:31:57 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Convert a string to lower case.
|
|
|
|
*/
|
2016-09-14 12:42:15 +00:00
|
|
|
std::string toLower(const std::string & s);
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Escape a string as a shell word.
|
|
|
|
*/
|
2022-01-21 16:55:51 +00:00
|
|
|
std::string shellEscape(const std::string_view s);
|
2017-08-25 13:57:49 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Exception handling in destructors: print an error message, then
|
|
|
|
* ignore the exception.
|
|
|
|
*/
|
2022-12-02 14:03:40 +00:00
|
|
|
void ignoreException(Verbosity lvl = lvlError);
|
2008-09-17 10:02:55 +00:00
|
|
|
|
|
|
|
|
2014-08-20 14:01:16 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Tree formatting.
|
|
|
|
*/
|
2020-03-24 13:17:10 +00:00
|
|
|
constexpr char treeConn[] = "├───";
|
|
|
|
constexpr char treeLast[] = "└───";
|
|
|
|
constexpr char treeLine[] = "│ ";
|
|
|
|
constexpr char treeNull[] = " ";
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Determine whether ANSI escape sequences are appropriate for the
|
|
|
|
* present output.
|
|
|
|
*/
|
2021-07-02 00:19:01 +00:00
|
|
|
bool shouldANSI();
|
2020-03-24 13:17:10 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Truncate a string to 'width' printable characters. If 'filterAll'
|
|
|
|
* is true, all ANSI escape sequences are filtered out. Otherwise,
|
|
|
|
* some escape sequences (such as colour setting) are copied but not
|
|
|
|
* included in the character count. Also, tabs are expanded to
|
|
|
|
* spaces.
|
|
|
|
*/
|
2023-03-02 14:44:19 +00:00
|
|
|
std::string filterANSIEscapes(std::string_view s,
|
2018-03-15 15:08:07 +00:00
|
|
|
bool filterAll = false,
|
2018-02-07 14:19:10 +00:00
|
|
|
unsigned int width = std::numeric_limits<unsigned int>::max());
|
2014-08-20 14:01:16 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Base64 encoding/decoding.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string base64Encode(std::string_view s);
|
|
|
|
std::string base64Decode(std::string_view s);
|
2015-02-09 14:09:39 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Remove common leading whitespace from the lines in the string
|
|
|
|
* 's'. For example, if every line is indented by at least 3 spaces,
|
|
|
|
* then we remove 3 spaces from the start of every line.
|
|
|
|
*/
|
2020-08-20 10:21:46 +00:00
|
|
|
std::string stripIndentation(std::string_view s);
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Get the prefix of 's' up to and excluding the next line break (LF
|
|
|
|
* optionally preceded by CR), and the remainder following the line
|
|
|
|
* break.
|
|
|
|
*/
|
2022-12-07 11:58:58 +00:00
|
|
|
std::pair<std::string_view, std::string_view> getLine(std::string_view s);
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Get a value for the specified key from an associate container.
|
|
|
|
*/
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
template <class T>
|
2022-05-04 05:44:32 +00:00
|
|
|
const typename T::mapped_type * get(const T & map, const typename T::key_type & key)
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
{
|
|
|
|
auto i = map.find(key);
|
2022-05-04 05:44:32 +00:00
|
|
|
if (i == map.end()) return nullptr;
|
|
|
|
return &i->second;
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
}
|
|
|
|
|
2022-05-04 05:44:32 +00:00
|
|
|
template <class T>
|
|
|
|
typename T::mapped_type * get(T & map, const typename T::key_type & key)
|
|
|
|
{
|
|
|
|
auto i = map.find(key);
|
|
|
|
if (i == map.end()) return nullptr;
|
|
|
|
return &i->second;
|
|
|
|
}
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Get a value for the specified key from an associate container, or a default value if the key isn't present.
|
|
|
|
*/
|
2022-05-04 05:44:32 +00:00
|
|
|
template <class T>
|
|
|
|
const typename T::mapped_type & getOr(T & map,
|
|
|
|
const typename T::key_type & key,
|
|
|
|
const typename T::mapped_type & defaultValue)
|
|
|
|
{
|
|
|
|
auto i = map.find(key);
|
|
|
|
if (i == map.end()) return defaultValue;
|
|
|
|
return i->second;
|
|
|
|
}
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Remove and return the first item from a container.
|
|
|
|
*/
|
2021-08-20 09:18:35 +00:00
|
|
|
template <class T>
|
|
|
|
std::optional<typename T::value_type> remove_begin(T & c)
|
|
|
|
{
|
|
|
|
auto i = c.begin();
|
|
|
|
if (i == c.end()) return {};
|
|
|
|
auto v = std::move(*i);
|
|
|
|
c.erase(i);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Remove and return the first item from a container.
|
|
|
|
*/
|
2021-10-14 10:31:21 +00:00
|
|
|
template <class T>
|
|
|
|
std::optional<typename T::value_type> pop(T & c)
|
|
|
|
{
|
|
|
|
if (c.empty()) return {};
|
|
|
|
auto v = std::move(c.front());
|
|
|
|
c.pop();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-03-27 20:16:01 +00:00
|
|
|
template<typename T>
|
2020-09-21 16:40:11 +00:00
|
|
|
class Callback;
|
2016-09-16 16:54:14 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Start a thread that handles various signals. Also block those signals
|
|
|
|
* on the current thread (and thus any threads created by it).
|
2023-02-01 17:38:54 +00:00
|
|
|
* Saves the signal mask before changing the mask to block those signals.
|
|
|
|
* See saveSignalMask().
|
2023-04-07 13:55:28 +00:00
|
|
|
*/
|
2017-01-17 17:21:02 +00:00
|
|
|
void startSignalHandlerThread();
|
|
|
|
|
2023-02-01 17:38:54 +00:00
|
|
|
/**
|
|
|
|
* Saves the signal mask, which is the signal mask that nix will restore
|
|
|
|
* before creating child processes.
|
|
|
|
* See setChildSignalMask() to set an arbitrary signal mask instead of the
|
|
|
|
* current mask.
|
|
|
|
*/
|
|
|
|
void saveSignalMask();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the signal mask. Like saveSignalMask() but for a signal set that doesn't
|
|
|
|
* necessarily match the current thread's mask.
|
|
|
|
* See saveSignalMask() to set the saved mask to the current mask.
|
|
|
|
*/
|
|
|
|
void setChildSignalMask(sigset_t *sigs);
|
|
|
|
|
2017-01-17 17:21:02 +00:00
|
|
|
struct InterruptCallback
|
|
|
|
{
|
|
|
|
virtual ~InterruptCallback() { };
|
|
|
|
};
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Register a function that gets called on SIGINT (in a non-signal
|
|
|
|
* context).
|
|
|
|
*/
|
2017-01-17 17:21:02 +00:00
|
|
|
std::unique_ptr<InterruptCallback> createInterruptCallback(
|
|
|
|
std::function<void()> callback);
|
|
|
|
|
2017-01-25 12:37:02 +00:00
|
|
|
void triggerInterrupt();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* A RAII class that causes the current thread to receive SIGUSR1 when
|
|
|
|
* the signal handler thread receives SIGINT. That is, this allows
|
|
|
|
* SIGINT to be multiplexed to multiple threads.
|
|
|
|
*/
|
2017-01-25 12:37:02 +00:00
|
|
|
struct ReceiveInterrupts
|
|
|
|
{
|
|
|
|
pthread_t target;
|
|
|
|
std::unique_ptr<InterruptCallback> callback;
|
|
|
|
|
|
|
|
ReceiveInterrupts()
|
|
|
|
: target(pthread_self())
|
|
|
|
, callback(createInterruptCallback([&]() { pthread_kill(target, SIGUSR1); }))
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2017-08-14 20:42:17 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* A RAII helper that increments a counter on construction and
|
|
|
|
* decrements it on destruction.
|
|
|
|
*/
|
2017-08-14 20:42:17 +00:00
|
|
|
template<typename T>
|
|
|
|
struct MaintainCount
|
|
|
|
{
|
|
|
|
T & counter;
|
|
|
|
long delta;
|
|
|
|
MaintainCount(T & counter, long delta = 1) : counter(counter), delta(delta) { counter += delta; }
|
|
|
|
~MaintainCount() { counter -= delta; }
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return the number of rows and columns of the terminal.
|
|
|
|
*/
|
2017-08-25 13:57:49 +00:00
|
|
|
std::pair<unsigned short, unsigned short> getWindowSize();
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Used in various places.
|
|
|
|
*/
|
2017-10-30 18:57:40 +00:00
|
|
|
typedef std::function<bool(const Path & path)> PathFilter;
|
|
|
|
|
|
|
|
extern PathFilter defaultPathFilter;
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Common initialisation performed in child processes.
|
|
|
|
*/
|
2023-03-20 17:06:08 +00:00
|
|
|
void commonChildInit();
|
2017-10-30 18:57:40 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a Unix domain socket.
|
|
|
|
*/
|
2021-08-16 18:03:32 +00:00
|
|
|
AutoCloseFD createUnixDomainSocket();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Create a Unix domain socket in listen mode.
|
|
|
|
*/
|
2018-09-25 10:36:11 +00:00
|
|
|
AutoCloseFD createUnixDomainSocket(const Path & path, mode_t mode);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Bind a Unix domain socket to a path.
|
|
|
|
*/
|
2021-08-24 11:52:55 +00:00
|
|
|
void bind(int fd, const std::string & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Connect to a Unix domain socket.
|
|
|
|
*/
|
2021-08-24 11:52:55 +00:00
|
|
|
void connect(int fd, const std::string & path);
|
|
|
|
|
2018-09-25 10:36:11 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* A Rust/Python-like enumerate() iterator adapter.
|
|
|
|
*
|
|
|
|
* Borrowed from http://reedbeta.com/blog/python-like-enumerate-in-cpp17.
|
|
|
|
*/
|
2020-03-24 13:17:10 +00:00
|
|
|
template <typename T,
|
|
|
|
typename TIter = decltype(std::begin(std::declval<T>())),
|
|
|
|
typename = decltype(std::end(std::declval<T>()))>
|
|
|
|
constexpr auto enumerate(T && iterable)
|
|
|
|
{
|
|
|
|
struct iterator
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
TIter iter;
|
2023-04-02 22:11:16 +00:00
|
|
|
constexpr bool operator != (const iterator & other) const { return iter != other.iter; }
|
|
|
|
constexpr void operator ++ () { ++i; ++iter; }
|
|
|
|
constexpr auto operator * () const { return std::tie(i, *iter); }
|
2020-03-24 13:17:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct iterable_wrapper
|
|
|
|
{
|
|
|
|
T iterable;
|
2023-04-02 22:11:16 +00:00
|
|
|
constexpr auto begin() { return iterator{ 0, std::begin(iterable) }; }
|
|
|
|
constexpr auto end() { return iterator{ 0, std::end(iterable) }; }
|
2020-03-24 13:17:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return iterable_wrapper{ std::forward<T>(iterable) };
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* C++17 std::visit boilerplate
|
|
|
|
*/
|
2020-07-12 22:15:14 +00:00
|
|
|
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
|
|
|
|
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
|
|
|
|
|
|
|
|
|
2020-10-06 08:40:49 +00:00
|
|
|
std::string showBytes(uint64_t bytes);
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Provide an addition operator between strings and string_views
|
|
|
|
* inexplicably omitted from the standard library.
|
|
|
|
*/
|
2022-05-09 12:28:27 +00:00
|
|
|
inline std::string operator + (const std::string & s1, std::string_view s2)
|
|
|
|
{
|
|
|
|
auto s = s1;
|
|
|
|
s.append(s2);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline std::string operator + (std::string && s, std::string_view s2)
|
|
|
|
{
|
|
|
|
s.append(s2);
|
2022-06-02 14:48:53 +00:00
|
|
|
return std::move(s);
|
2022-05-09 12:28:27 +00:00
|
|
|
}
|
|
|
|
|
2022-12-07 11:58:58 +00:00
|
|
|
inline std::string operator + (std::string_view s1, const char * s2)
|
|
|
|
{
|
2022-12-12 11:36:19 +00:00
|
|
|
std::string s;
|
|
|
|
s.reserve(s1.size() + strlen(s2));
|
|
|
|
s.append(s1);
|
2022-12-07 11:58:58 +00:00
|
|
|
s.append(s2);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
}
|