db.cpp

Go to the documentation of this file.

/// \file db.cpp
/// \brief Реализация обёртки SQLite-базы данных и утилит CIDR.
/// \details Содержит реализацию BlockerDB, парсера CIDR и вспомогательных
///          функций для работы с IP-адресами.
 
#include "db.h"
 
#include <arpa/inet.h>
#include <cstring>
#include <iostream>
#include <sstream>
#include <stdexcept>
 
/**********************************************************************/
/*  CIDR parsing                                                      */
/**********************************************************************/
 
CIDR ParseCIDR(const std::string &str) {
  CIDR result{};
  result.prefixlen = 32;
 
  auto slash = str.find('/');
  std::string ip_str =
      (slash != std::string::npos) ? str.substr(0, slash) : str;
 
  if (inet_pton(AF_INET, ip_str.c_str(), &result.ip) != 1)
    throw std::invalid_argument("invalid IP address: " + ip_str);
 
  if (slash != std::string::npos) {
    unsigned long pl = std::stoul(str.substr(slash + 1));
    if (pl > 32)
      throw std::invalid_argument("invalid prefix length: " +
                                  std::to_string(pl));
    result.prefixlen = static_cast<uint32_t>(pl);
    result.ip &= htonl(pl == 0 ? 0 : (0xFFFFFFFFu << (32 - pl)));
  }
 
  return result;
}
 
/**********************************************************************/
/*  IP conversion                                                     */
/**********************************************************************/
 
std::string IPToString(uint32_t ip) {
  char buf[INET_ADDRSTRLEN];
  inet_ntop(AF_INET, &ip, buf, sizeof(buf));
  return buf;
}
 
/**********************************************************************/
/*  SQLite callback                                                   */
/**********************************************************************/
 
/// Колбэк sqlite3_exec, собирающий строки (ip, comment).
/// @param[in] data  Указатель на вектор BlockEntry.
/// @param[in] argv  Массив полей строки SQL.
/// @return 0 (код успеха для sqlite3_exec).
static int StepCallback(void *data, int /*argc*/, char **argv,
                        char ** /*colNames*/) {
  auto *entries = static_cast<std::vector<BlockEntry> *>(data);
  if (argv[0] && argv[1])
    entries->push_back({argv[0], argv[1]});
  return 0;
}
 
/**********************************************************************/
/*  BlockerDB constructor / destructor                                 */
/**********************************************************************/
 
BlockerDB::BlockerDB(const std::string &path) : db_(nullptr) {
  int rc = sqlite3_open(path.c_str(), &db_);
  if (rc != SQLITE_OK) {
    std::string err = sqlite3_errmsg(db_);
    sqlite3_close(db_);
    throw std::runtime_error("failed to open database: " + err);
  }
}
 
BlockerDB::~BlockerDB() {
  if (db_)
    sqlite3_close(db_);
}
 
/**********************************************************************/
/*  Schema migration                                                  */
/**********************************************************************/
 
void BlockerDB::Migrate() {
  sqlite3_exec(db_, "PRAGMA journal_mode=WAL;", nullptr, nullptr, nullptr);
 
  const char *sql = "CREATE TABLE IF NOT EXISTS whitelist_ips ("
                    "  id         INTEGER PRIMARY KEY AUTOINCREMENT,"
                    "  ip         TEXT NOT NULL UNIQUE,"
                    "  comment    TEXT DEFAULT '',"
                    "  created_at TEXT DEFAULT (datetime('now'))"
                    ");"
                    "CREATE TABLE IF NOT EXISTS blocked_ips ("
                    "  id         INTEGER PRIMARY KEY AUTOINCREMENT,"
                    "  ip         TEXT NOT NULL UNIQUE,"
                    "  comment    TEXT DEFAULT '',"
                    "  created_at TEXT DEFAULT (datetime('now'))"
                    ");";
 
  char *err = nullptr;
  if (sqlite3_exec(db_, sql, nullptr, nullptr, &err) != SQLITE_OK) {
    std::string msg = err;
    sqlite3_free(err);
    throw std::runtime_error("migration failed: " + msg);
  }
 
  /* Idempotent: silently ignored if column already exists. */
  sqlite3_exec(db_, "ALTER TABLE blocked_ips ADD COLUMN last_blocked_at TEXT",
               nullptr, nullptr, nullptr);
}
 
/**********************************************************************/
/*  CIDR match helper                                                  */
/**********************************************************************/
 
/// Проверяет, входит ли IP в указанную CIDR-подсеть.
/// @param[in] ip        IP-адрес в network byte order.
/// @param[in] cidr_str  CIDR-строка вида "10.0.0.0/8".
/// @return true если ip находится в подсети.
static bool MatchesCIDR(uint32_t ip, const std::string &cidr_str) {
  auto slash = cidr_str.find('/');
  if (slash == std::string::npos)
    return false;
 
  uint32_t cidr_ip;
  if (inet_pton(AF_INET, cidr_str.substr(0, slash).c_str(), &cidr_ip) != 1)
    return false;
 
  unsigned long pl = std::stoul(cidr_str.substr(slash + 1));
  if (pl > 32)
    return false;
 
  uint32_t mask = htonl(pl == 0 ? 0 : (0xFFFFFFFFu << (32 - pl)));
  return (ip & mask) == (cidr_ip & mask);
}
 
/**********************************************************************/
/*  Update last_blocked_at                                             */
/**********************************************************************/
 
void BlockerDB::UpdateLastBlockedAt(uint32_t ip) {
  std::string ip_str = IPToString(ip);
 
  /* Exact match */
  {
    const std::string sql =
        "UPDATE blocked_ips SET last_blocked_at = datetime('now') WHERE ip = ?";
    sqlite3_stmt *stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
      sqlite3_bind_text(stmt, 1, ip_str.c_str(), -1, SQLITE_TRANSIENT);
      sqlite3_step(stmt);
      sqlite3_finalize(stmt);
    }
  }
 
  /* CIDR match: update any covering subnet entry */
  {
    const std::string sql = "SELECT ip FROM blocked_ips WHERE ip LIKE '%/%'";
    sqlite3_stmt *stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK)
      return;
 
    std::vector<std::string> matching;
    while (sqlite3_step(stmt) == SQLITE_ROW) {
      const char *cidr_str =
          reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
      if (cidr_str && MatchesCIDR(ip, cidr_str))
        matching.emplace_back(cidr_str);
    }
    sqlite3_finalize(stmt);
 
    for (const auto &cidr : matching) {
      const std::string upd = "UPDATE blocked_ips SET last_blocked_at = "
                              "datetime('now') WHERE ip = ?";
      sqlite3_stmt *us = nullptr;
      if (sqlite3_prepare_v2(db_, upd.c_str(), -1, &us, nullptr) == SQLITE_OK) {
        sqlite3_bind_text(us, 1, cidr.c_str(), -1, SQLITE_TRANSIENT);
        sqlite3_step(us);
        sqlite3_finalize(us);
      }
    }
  }
}
 
/**********************************************************************/
/*  Query helpers                                                      */
/**********************************************************************/
 
std::vector<BlockEntry> BlockerDB::GetWhitelist() {
  return GetEntries("whitelist_ips");
}
 
std::vector<BlockEntry> BlockerDB::GetBlacklist() {
  return GetEntries("blocked_ips");
}
 
std::vector<BlockEntry> BlockerDB::GetEntries(const std::string &table) {
  std::vector<BlockEntry> entries;
  std::string sql = "SELECT ip, comment FROM " + table;
 
  char *err = nullptr;
  if (sqlite3_exec(db_, sql.c_str(), StepCallback, &entries, &err) !=
      SQLITE_OK) {
    std::string msg = err;
    sqlite3_free(err);
    throw std::runtime_error("query failed: " + msg);
  }
 
  return entries;
}