Home /Modules/web-server-technology/envelopment.cpp

envelopment.cpp

web-server-technology/native/envelopment.cpp · 262 line(s) · c

/*
 * web-server-technology/native/envelopment.cpp
 *
 * Implementation of the Side-2 envelopment model: resolver + config loader.
 * Transport-agnostic by design (no sockets, no HTTP wire handling), so it can
 * be unit-tested on its own and so Side 1 carries no dependency on it.
 *
 * Config grammar (line-oriented; '#' starts a comment; blank lines ignored):
 *
 *   envelopment = on|off
 *   scientist   = true|false
 *   domain      = <host>
 *
 *   program     = <name>                 # begins a program block
 *   kind        = static|sql|meme
 *   mount       = /prefix
 *   root        = /path                  # static
 *   db          = /path                  # sql
 *   db-writable = true|false             # sql
 *   meme-type   = text/plain; charset=utf-8   # meme
 *   meme-body   = <single-line body text>     # meme
 *
 *   warrant     = <cause>                # begins a warrant block
 *   subject     = <host>|*
 *   path        = /prefix                # optional
 *   use         = <program-name>
 *   enabled     = true|false
 *
 * A "program" or "warrant" line opens a new block; subsequent block keys apply
 * to the most recently opened block until the next block opener.
 */
#include "envelopment.h"

#include <cctype>
#include <fstream>
#include <memory>
#include <sstream>

#include "../../lib/web-server-technology/native/include/slweb.h"

namespace sleela {
namespace wst {

const char *program_kind_name(ProgramKind k) {
  // Delegate the naming to the shared C core so there is one source of truth.
  slweb_program_kind ck = k == ProgramKind::Static ? SLWEB_PROGRAM_STATIC
                          : k == ProgramKind::Sql  ? SLWEB_PROGRAM_SQL
                                                   : SLWEB_PROGRAM_MEME;
  return slweb_program_kind_name(ck);
}

const Program *Envelopment::find_program(const std::string &name) const {
  for (const auto &p : programs)
    if (p.name == name) return &p;
  return nullptr;
}

namespace {
// Build a transient slweb_envelopment mirror of this server-side Envelopment so
// the Scientist-gate and longest-prefix resolution run in the shared C core.
// The server's richer Program (meme body, roots, db dir) is kept here; slweb
// only needs names/kinds/mounts and the warrant routing keys.
struct SlwebEnvDeleter {
  void operator()(slweb_envelopment *e) const { slweb_env_free(e); }
};
std::unique_ptr<slweb_envelopment, SlwebEnvDeleter> build_mirror(
    const Envelopment &env) {
  std::unique_ptr<slweb_envelopment, SlwebEnvDeleter> m(
      slweb_env_new(env.domain.c_str()));
  if (!m) return m;
  slweb_env_set_enabled(m.get(), env.enabled ? 1 : 0);
  slweb_env_set_scientist(m.get(), env.scientist ? 1 : 0);
  for (const auto &p : env.programs) {
    slweb_program_kind k = p.kind == ProgramKind::Static ? SLWEB_PROGRAM_STATIC
                           : p.kind == ProgramKind::Sql  ? SLWEB_PROGRAM_SQL
                                                         : SLWEB_PROGRAM_MEME;
    slweb_env_add_program(m.get(), p.name.c_str(), k, p.mount.c_str(), "",
                          p.db_writable ? 1 : 0);
  }
  for (const auto &w : env.warrants)
    slweb_env_add_warrant(m.get(), w.cause.c_str(), w.subject.c_str(),
                          w.path_prefix.c_str(), w.program.c_str(),
                          w.enabled ? 1 : 0);
  return m;
}
}  // namespace

bool Envelopment::active() const {
  // Scientist-gate rule lives in the shared C core.
  auto m = build_mirror(*this);
  return m && slweb_env_active(m.get()) != 0;
}

const Program *Envelopment::resolve(const std::string &host,
                                    const std::string &path,
                                    std::string &out_cause) const {
  // Longest-matching-path-prefix resolution and the active() gate are performed
  // by the shared C core (slweb); we map the chosen program NAME back to the
  // server-side Program, which carries the transport details (body/root/dir).
  auto m = build_mirror(*this);
  if (!m) return nullptr;
  char prog[SLWEB_MAX_NAME], cause[SLWEB_MAX_PATH];
  slweb_program_kind kind;
  if (slweb_env_resolve(m.get(), host.c_str(), path.c_str(), prog, cause,
                        &kind) != SLWEB_OK)
    return nullptr;
  const Program *p = find_program(prog);
  if (!p) return nullptr;
  out_cause = cause;
  return p;
}

// ---- parsing helpers --------------------------------------------------------
namespace {

std::string trim(const std::string &s) {
  size_t a = 0, b = s.size();
  while (a < b && std::isspace((unsigned char)s[a])) ++a;
  while (b > a && std::isspace((unsigned char)s[b - 1])) --b;
  return s.substr(a, b - a);
}

std::string lower(std::string s) {
  for (char &c : s) c = (char)std::tolower((unsigned char)c);
  return s;
}

bool parse_bool(const std::string &v, bool &out) {
  std::string l = lower(trim(v));
  if (l == "on" || l == "true" || l == "yes" || l == "1") { out = true; return true; }
  if (l == "off" || l == "false" || l == "no" || l == "0") { out = false; return true; }
  return false;
}

}  // namespace

// Apply a single top-level (non-block) setting. Block keys are handled by the
// loader because they need the "current block" context.
bool apply_envelopment_setting(const std::string &key, const std::string &value,
                               Envelopment &out, std::string &err) {
  std::string k = lower(trim(key));
  std::string v = trim(value);
  if (k == "envelopment") {
    bool b;
    if (!parse_bool(v, b)) { err = "envelopment must be on/off"; return false; }
    out.enabled = b;
    return true;
  }
  if (k == "scientist") {
    bool b;
    if (!parse_bool(v, b)) { err = "scientist must be true/false"; return false; }
    out.scientist = b;
    return true;
  }
  if (k == "domain") {
    out.domain = v;
    return true;
  }
  // Not a recognized top-level envelopment key; ignore quietly so the same file
  // can hold base-server settings too.
  return true;
}

bool load_envelopment_config(const std::string &path, Envelopment &out,
                             std::string &err) {
  std::ifstream f(path);
  if (!f) { err = "cannot open config file: " + path; return false; }

  enum class Block { None, Program, Warrant };
  Block block = Block::None;
  Program cur_prog;
  Warrant cur_warr;

  auto flush_program = [&]() {
    if (block == Block::Program && !cur_prog.name.empty())
      out.programs.push_back(cur_prog);
  };
  auto flush_warrant = [&]() {
    if (block == Block::Warrant && !cur_warr.cause.empty())
      out.warrants.push_back(cur_warr);
  };

  std::string line;
  int lineno = 0;
  while (std::getline(f, line)) {
    ++lineno;
    // strip comment
    size_t hash = line.find('#');
    if (hash != std::string::npos) line = line.substr(0, hash);
    std::string t = trim(line);
    if (t.empty()) continue;
    size_t eq = t.find('=');
    if (eq == std::string::npos) {
      err = "line " + std::to_string(lineno) + ": expected key=value";
      return false;
    }
    std::string k = lower(trim(t.substr(0, eq)));
    std::string v = trim(t.substr(eq + 1));

    // Block openers.
    if (k == "program") {
      flush_program();
      flush_warrant();
      cur_prog = Program{};
      cur_prog.name = v;
      block = Block::Program;
      continue;
    }
    if (k == "warrant") {
      flush_program();
      flush_warrant();
      cur_warr = Warrant{};
      cur_warr.cause = v;
      block = Block::Warrant;
      continue;
    }

    // Block keys.
    if (block == Block::Program) {
      if (k == "kind") {
        std::string lv = lower(v);
        if (lv == "static") cur_prog.kind = ProgramKind::Static;
        else if (lv == "sql") cur_prog.kind = ProgramKind::Sql;
        else if (lv == "meme") cur_prog.kind = ProgramKind::Meme;
        else { err = "line " + std::to_string(lineno) + ": kind must be static/sql/meme"; return false; }
        continue;
      }
      if (k == "mount") { cur_prog.mount = v; continue; }
      if (k == "root") { cur_prog.root = v; continue; }
      if (k == "db") { cur_prog.db_dir = v; continue; }
      if (k == "db-writable") {
        if (!parse_bool(v, cur_prog.db_writable)) { err = "line " + std::to_string(lineno) + ": db-writable must be true/false"; return false; }
        continue;
      }
      if (k == "meme-type") { cur_prog.meme_type = v; continue; }
      if (k == "meme-body") { cur_prog.meme_body = v; continue; }
      // fall through to top-level settings (e.g. envelopment/scientist/domain)
    } else if (block == Block::Warrant) {
      if (k == "subject") { cur_warr.subject = v; continue; }
      if (k == "path") { cur_warr.path_prefix = v; continue; }
      if (k == "use") { cur_warr.program = v; continue; }
      if (k == "enabled") {
        if (!parse_bool(v, cur_warr.enabled)) { err = "line " + std::to_string(lineno) + ": enabled must be true/false"; return false; }
        continue;
      }
      // fall through
    }

    // Top-level settings (envelopment/scientist/domain) or ignorable keys.
    if (!apply_envelopment_setting(k, v, out, err)) {
      err = "line " + std::to_string(lineno) + ": " + err;
      return false;
    }
  }
  flush_program();
  flush_warrant();
  return true;
}

}  // namespace wst
}  // namespace sleela