exception.hh

Go to the documentation of this file.

/*
 * libkeepass - KeePass key database importer/exporter
 * Copyright (C) 2014 Christian Kindahl
 * Copyright (C) 2024 Dominik Krümpelmann
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
 
#include "libkeepass/export.hh"
 
namespace keepass {
 
enum class ErrorCategory {
  kAuthentication, 
  kFormat,         
  kUnsupported,    
  kResourceLimit,  
  kIo,             
  kInternal        
};
 
LIBKEEPASS_API const char* ErrorCategoryName(ErrorCategory category) noexcept;
 
class LIBKEEPASS_API Error : public std::exception {
public:
  virtual ErrorCategory category() const noexcept = 0;
};
 
class LIBKEEPASS_API PasswordError final : public Error {
public:
  explicit PasswordError() = default;
 
  const char* what() const noexcept override { return "Invalid password."; }
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kAuthentication; }
};
 
class LIBKEEPASS_API FormatError : public Error {
private:
  const std::string msg_{};
  std::optional<uint64_t> offset_{};
 
public:
  explicit FormatError(std::string msg) : msg_(std::move(msg)) {}
 
  FormatError(std::string msg, uint64_t offset) : msg_(std::move(msg)), offset_(offset) {}
 
  const char* what() const noexcept override { return msg_.c_str(); }
 
  std::optional<uint64_t> offset() const noexcept { return offset_; }
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kFormat; }
};
 
class LIBKEEPASS_API UnsupportedFeatureError final : public FormatError {
public:
  explicit UnsupportedFeatureError(std::string msg) : FormatError(std::move(msg)) {}
 
  UnsupportedFeatureError(std::string msg, uint64_t offset) : FormatError(std::move(msg), offset) {}
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kUnsupported; }
};
 
class LIBKEEPASS_API ResourceLimitError final : public FormatError {
public:
  explicit ResourceLimitError(std::string msg) : FormatError(std::move(msg)) {}
 
  ResourceLimitError(std::string msg, uint64_t offset) : FormatError(std::move(msg), offset) {}
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kResourceLimit; }
};
 
class LIBKEEPASS_API InternalError : public Error {
private:
  const std::string msg_{};
 
public:
  explicit InternalError(std::string msg) : msg_(std::move(msg)) {}
 
  const char* what() const noexcept override { return msg_.c_str(); }
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kInternal; }
};
 
class LIBKEEPASS_API IoError : public Error {
private:
  const std::string msg_{};
 
public:
  explicit IoError(std::string msg) : msg_(std::move(msg)) {}
 
  const char* what() const noexcept override { return msg_.c_str(); }
 
  ErrorCategory category() const noexcept override { return ErrorCategory::kIo; }
};
 
class LIBKEEPASS_API FileNotFoundError final : public IoError {
public:
  FileNotFoundError() : IoError("File not found.") {}
};
 
} // namespace keepass