Configuracio.cc

Veure la documentació d'aquest fitxer.

/*
 * Copyright (c) 2012 Toni Corvera
 *
 * This file is part of TFCWeb.
 *
 * TFCWeb 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.
 *
 * TFCWeb 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 TFCWeb. If not, see <http://www.gnu.org/licenses/>.
 */

#include "Configuracio.h"

#include <cassert>
#include <iostream>
#include <sstream>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/program_options.hpp>

using namespace std;
namespace fs = boost::filesystem;
namespace po = boost::program_options;

namespace {

// Valors per defecte
const unsigned short PORT_PER_DEFECTE = 8000;
const string ARREL_PER_DEFECTE("."); // fs::path produeix error en Windows ¿¿¿???
const char * CONFIG_PER_DEFECTE = "tfcweb.conf";
const char * INDEX_PER_DEFECTE = "index.html";
const string REALME_PER_DEFECTE(PACKAGE_NAME);
const Permis PERMIS_PER_DEFECTE = LECTURA;
enum {
    FILS_PER_DEFECTE = 100
};

const char * MISSATGE_ERROR_ARREL_INCORRECTA =
        "L'arrel ha de ser un directori existent i llegible";

template<typename TipusExcepcio>
void valida_arrel(const fs::path & candidata) {
    if (!fs::exists(candidata) || !fs::is_directory(candidata)) {
        throw TipusExcepcio(MISSATGE_ERROR_ARREL_INCORRECTA);
    }
    if (!tfc::utils::es_llegible(candidata)) {
        throw TipusExcepcio(MISSATGE_ERROR_ARREL_INCORRECTA);
    }
}

typedef vector< std::pair<string, FlagsPermis> > permisos_preparats_t;
void prepara_permisos(permisos_preparats_t & permisos_preparats,
                      const vector<string> rutes,
                      FlagsPermis permisos)
{
    // No serveix: Cal afegir la ruta base
    //      boost::bind(&Cerber::defineix_regla, &cerber, _1, permisos)
    //std::for_each(rutes.begin(), rutes.end(),
    //              boost::bind(&Cerber::defineix_regla, &cerber, ruta_absoluta, permisos));
    for (auto it=rutes.begin(); it != rutes.end(); ++it) {
        permisos_preparats.push_back( make_pair(*it, permisos) );
    }
}

inline bool config_llegible(const fs::path & cfg) {
    return fs::exists(cfg) && fs::is_regular_file(cfg) && utils::es_llegible(cfg);
}

} // ns anònim

namespace tfc {

Configuracio::Configuracio(int argc, char *argv[]) throw (ErrorOpcions,AjudaDemanada,VersioDemanada)
    : argc_(argc), argv_(argv),
      arrel_(ARREL_PER_DEFECTE),
      index_(INDEX_PER_DEFECTE),
      port_(PORT_PER_DEFECTE),
      config_(CONFIG_PER_DEFECTE),
      auth_user_(), auth_pass_(), auth_realme_(REALME_PER_DEFECTE),
      cerber_(PERMIS_PER_DEFECTE)
{
    // Contindrà la relació de rutes i permisos configurats
    // XXX: S'ha optat per fer què qualsevol permís diferent de PRIVAT impliqui el
    //      permís de lectura.
    permisos_preparats_t permisos_preparats;

    // TODO: rutes_publiques per permetre re-escriure permisos més restrictius en subdirectoris

    // Opcions només de línia de comandes
    po::options_description clidesc("Opcions de línia de comandes"), cfgdesc("Configuració");
    clidesc.add_options()
         ("help", "mostra aquest missatge d'ajuda")
         ("config",
          po::value<fs::path>(&config_)->default_value(CONFIG_PER_DEFECTE),
          "fitxer de configuració")
         ("version", "mostra informació de l'entorn de compilació")
    ;
    // Opcions de l'arxiu de configuració (i la línia de comandes)
    // po::value(...)->composing() permet combinar valors de la línia
    // de comandes i la configuració. Si no s'especifica, el valor
    // que es defineix primer (línia de comandes) serà l'utilitzat
    cfgdesc.add_options()
         ("port,p",
          po::value<unsigned short>(&port_)->default_value(PORT_PER_DEFECTE),
          "especifica el port en què escoltar")
         ("arrel,r",
          po::value<fs::path>(&arrel_)->default_value(ARREL_PER_DEFECTE),
          "directori arrel dels documents del servidor")
         ("index", // TODO: Utilitzar
          po::value<string>(&index_)->default_value(INDEX_PER_DEFECTE),
          "fitxer d'índex per defecte")
         ("usuari,U",
          po::value<string>(&auth_user_)->default_value(""),
          "nom d'usuari per directoris d'accés restringit")
         ("contrasenya,P",
          po::value<string>(&auth_pass_)->default_value(""),
          "contrasenya per directoris d'accés restringit")
         ("fils,t",
          po::value<size_t>(&fils_)->default_value(FILS_PER_DEFECTE),
          "nombre de fils simultanis")
         ("realme,R",
          po::value<string>(&auth_realme_)->default_value(REALME_PER_DEFECTE),
          "realme d'autenticació")
         ("privat,n",
          po::value< vector<string> >()
            ->composing()
            ->notifier(bind(&prepara_permisos, boost::ref(permisos_preparats), _1, PRIVAT)),
          "ruta privada (error 403 en accedir-hi); es poden definir múltiples")
         ("protegit,c",
          po::value< vector<string> >()
            ->composing()
            ->notifier(bind(&prepara_permisos, boost::ref(permisos_preparats), _1, LECTURA|PROTEGIT)),
          "ruta protegida (requereix usuari/contrasenya); es poden definir múltiples")
         ("cgi,x",
          po::value< vector<string> >()
             ->composing()
             ->notifier(bind(&prepara_permisos, boost::ref(permisos_preparats), _1, LECTURA|EXECUCIO)),
          "ruta en què es permet executar CGIs; es poden definir múltiples")
         ("escribible,e",
          po::value< vector<string> >()
            ->composing()
            ->notifier(bind(&prepara_permisos, boost::ref(permisos_preparats), _1, LECTURA|ESCRIPTURA)),
          "ruta en què es permeten mètodes d'escriptura (PUT i DELETE); "
          "es poden definir múltiples")
         ("llegible,l",
          po::value< vector<string> >()
            ->composing()
            ->notifier(bind(&prepara_permisos, boost::ref(permisos_preparats), _1, LECTURA)),
          "ruta en què es permet accés de lectura (GET, HEAD, ...); "
          "permet definir permisos més laxos dintre de rutes restringrides; "
          "es poden definir múltiples ")

         // Per composar valors a partir de diferents orígens s'utilitza
         // value(...)->composing()
         // http://www.boost.org/doc/libs/1_49_0/doc/html/program_options/tutorial.html#id2500303
    ;
    po::options_description desc("Opcions");
    desc.add(clidesc);
    desc.add(cfgdesc);

    // Primer la línia de comandes, ja que els valors sense "composing" es quedaran
    // amb el primer valor que se'ls assigni.
    po::variables_map varmap;
    try {
        po::store(po::parse_command_line(argc_, argv_, desc), varmap);
        valida_arrel<ErrorLiniaComandes>(varmap["arrel"].as<fs::path>());

        // Per a assignar realment els valors passats a les variables associades
        // cal cridar program_options::notify(), però això també crida els callbacks
        // associats amb notifier(), per tant és millor fer una única crida a notify.
        // Sense notificadores pròpies es crida notify() després de cada store()
        // Per a comprovar el valor d'una opció abans de cridar notify() cal extreure'l
        // manualment de varmap
        const fs::path cfg = varmap["config"].as<fs::path>(); // és un boost::any, cal fer un cast

        if (config_llegible(cfg))
        {
            try {
                // parse_config_file té menys prioritat que parse_command_line, si quelcom
                // es defineix en la línia de comandes no es sobreescriu des del fitxer de
                // configuració
                po::store(po::parse_config_file<char>(cfg.string().c_str(), cfgdesc), varmap);
                valida_arrel<ErrorConfiguracio>(varmap["arrel"].as<fs::path>());
            }
            catch (const po::error & e) {
                throw ErrorConfiguracio(string("Error de configuració: ") + e.what());
            }
        }
    }
    catch (const po::error & e) {
        throw ErrorLiniaComandes(string("Error en la línia de comandes: ") + e.what());
    }

    po::notify(varmap); // "promocionem" els valors, cridem els callbacks
    if (config_llegible(config_)) { // Després de notify()!
        config_ = fs::canonical(config_);
    }

    if (varmap.count("help")) {
        ostringstream oss;
        desc.print(oss);
        throw AjudaDemanada(oss.str());
    }
    if (varmap.count("version")) {
        throw VersioDemanada();
    }
    arrel_ = fs::canonical(arrel_);

    // Sanejament d'índex
    index_ = fs::path(index_).filename().string();

    // Permisos per defecte
    cerber_.defineix_regla(arrel_, LECTURA);
    cerber_.defineix_regla(arrel_.parent_path(), PRIVAT);
    cerber_.defineix_regla(Cerber::ruta_t("/"), PRIVAT); // En realitat innecessari
    // Permisos configurats. XXX: L'ordre de definició no es respecta!
    // No serveix: Cal afegir la ruta base
    //      boost::bind(&Cerber::defineix_regla, &cerber_, _1, PRIVAT)
    // Functor: Afegeix ruta arrel a rutes relatives
    struct CreaRuta {
        typedef fs::path result_type; // Permet a boost::bind() obtenir el tipus retornat
        fs::path operator()(const string & s, const fs::path & arrel) {
            fs::path tmp(s);
            if (!tmp.has_root_directory()) {
                tmp = arrel / tmp;
            }
            // canonicalitzar?
            if (fs::exists(tmp)) {
                tmp = fs::canonical(tmp);
            }
            return tmp;
        }
    };
    // En no respectar l'ordre cal utilitzar un callback de pre-processament
    //std::for_each(rutes_privades.begin(), rutes_privades.end(),
    //              boost::bind(&Cerber::defineix_regla, &cerber_, crea_ruta, PRIVAT));

    // Processa els permisos preparats, afegint-los al Cèrber:
    // XXX: GCC 4.4 no és capaç de resoldre la crida a bind
    // auto ruta_absoluta = boost::bind(CreaRuta(), _1, arrel_);
    CreaRuta ruta_absoluta;
    for (auto it=permisos_preparats.begin(); it!=permisos_preparats.end(); ++it) {
        cerr << "Permís configurat: " << it->first << ": " << nom_permis(it->second) << endl;
        //cerber_.defineix_regla(ruta_absoluta(it->first), it->second);
        cerber_.defineix_regla(ruta_absoluta(it->first, arrel_), it->second);
    }

    // INVARIANTS
    assert( fs::exists(arrel_) );
    assert( fs::is_directory(arrel_) );
    assert( arrel_ == fs::canonical(arrel_) );
}

// friend Configuracio
ostream& operator<<(ostream & os, const Configuracio & c) {
    const bool config_existeix = fs::exists(c.config());
    // INVARIANTS
    assert( utils::es_canonic(c.arrel()) );
    assert( !config_existeix || utils::es_canonic(c.config()) );

    return os << "Configuració {"
                << "\n\tPort: " << c.port()
                << "\n\tArrel: " << c.arrel()
                << "\n\tNombre de fils: " << c.fils()
                << "\n\tIndex: " << c.index()
                << "\n\tConfiguració: " << c.config()
                    << " [" << (config_existeix ? "" : "no ") << "existeix]"
                << "\n\tNom d'usuari: " << c.usuari()
                << "\n\tContrasenya: " << c.contrasenya()
                << "\n\tRealme: " << c.realme()
                << "\n}"
#if 0
                   "\n"
                << c.cerber_
#endif
                ;
}

} // ns tfc

// vim:set ts=4 et ai: //