errors.hpp

#ifndef FLUKS_ERRORS_HPP
#define FLUKS_ERRORS_HPP

#include <exception>
#include <string>

namespace fluks {

/** Not to be caught.
 *
 * Do not use directly. To conditionally throw an Assertion object, use the
 * Assert() function.
 */
struct Assertion : std::exception {
	Assertion(std::string_view msg) : _msg(msg) {}
	virtual ~Assertion() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

#ifndef NASSERT
inline void Assert(bool cond, std::string_view msg) {
	if (!cond) throw Assertion(msg);
}
/* macro version, which short-circuits evaluation of second argument, but
 * it doesn't work well with namespaces */
/*
#	define Assert(cond, msg)				do { \
		if (!(cond)) throw fluks::Assertion(msg);	\
	}							while(0)
*/
#else
#	define Assert(cond, msg)	do { \
	}				while(0)
#endif

/** Specified crypto/hash spec was bad */
struct Bad_spec : std::exception {
	Bad_spec(std::string_view msg) : _msg("Bad crypto spec: ") {
		_msg += msg;
	}

	virtual ~Bad_spec() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

struct Bad_uuid : std::exception {
	Bad_uuid(std::string_view uuid) : _msg("Bad UUID: ") {
		_msg += uuid;
	}

	virtual ~Bad_uuid() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

struct Crypt_error : virtual std::exception {
	Crypt_error(std::string_view msg) : _msg("Crypto error: ") {
		_msg += msg;
	}

	virtual ~Crypt_error() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;

protected:
	Crypt_error() {}
};

struct Disk_error : std::exception {
	Disk_error(std::string_view msg) : _msg("Disk error: ") {
		_msg += msg;
	}

	virtual ~Disk_error() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

/** Device mapper error */
struct Dm_error : std::exception {
	Dm_error(std::string_view msg) : _msg("Device mapper error: ") {
		_msg += msg;
	}

	virtual ~Dm_error() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}
	std::string _msg;
};

struct Hash_error : virtual std::exception {
};

struct No_header : std::exception {
	virtual ~No_header() noexcept {}

	const char *what() const noexcept override {
		return "LUKS header not found";
	}
};

struct No_private_key : std::exception {
	No_private_key() {}
	virtual ~No_private_key() noexcept {}

	const char *what() const noexcept override {
		return "The private key hasn't been decrypted yet";
	}
};

/** Thrown if something is probably a bad idea. There is no work-around. */
struct Safety : std::exception {
	Safety(std::string_view msg) : _msg("Safety error: ") {
		_msg += msg;
	}

	virtual ~Safety() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

struct Slots_full : std::exception {
	virtual ~Slots_full() noexcept {}

	const char *what() const noexcept override {
		return "All key slots are used.";
	}
};

/** An SSL error wrapping exception type. */
struct Ssl_error : virtual std::exception {
	Ssl_error() : Ssl_error("OpenSSL error") {}
	Ssl_error(std::string_view msg);
	virtual ~Ssl_error() noexcept {}

	const char *what() const noexcept override {
		return _msg.c_str();
	}

	std::string _msg;
};

/** An SSL crypto error. */
struct Ssl_crypt_error : Crypt_error, Ssl_error {
	Ssl_crypt_error() {}
	virtual ~Ssl_crypt_error() noexcept {}

	const char *what() const noexcept override {
		return Ssl_error::what();
	}
};

/** An SSL hashing error. */
struct Ssl_hash_error : Hash_error, Ssl_error {
	Ssl_hash_error() {}
	virtual ~Ssl_hash_error() noexcept {}

	const char *what() const noexcept override {
		return Ssl_error::what();
	}
};

struct Unsupported_version : std::exception {
	virtual ~Unsupported_version() noexcept {}

	const char *what() const noexcept override {
		return "unsupported LUKS header version";
	}
};

/** \throw std::system_error */
void	throw_errno(int e);

}

#endif