Recurs.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 "DataHTTP.h"
#include "Recurs.h"
#include "TipusMIME.h"
#include "utils.h"

#include <array>
#include <cassert>
#include <fstream>
#include <sstream>
#include <boost/asio.hpp>
#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>

using namespace boost::asio::ip;
using namespace boost::filesystem;
using namespace std;

namespace {
    enum {
        MIDA_BUFFER = 8192
    };

    template<typename T> string hexadecimal(const T & t) {
        ostringstream oss;
        oss << std::hex << t;
        return oss.str();
    }
} // ns anònim

namespace tfc {

// FIXME: rutes com /INEXISTENT/../ són vàlides en Apache i webfsd, però perquè wget les normalitza
// curl les envia tal qual, webfsd no les normalitza, apache sí
// FIXME: Url decoding Re-FIXME: Incorporar en Disseny com amb Base64

Recurs::Recurs(const PeticioHTTP &peticio,
               const boost::filesystem::path &arrel_servidor) throw (ErrorRutaInexistent)
    : CosResposta(peticio), arrel_servidor_(arrel_servidor)
{
    // PRECONDICIONS: arrel_servidor existeix, és un directori, és absoluta i canònica
    assert( exists(arrel_servidor) && is_directory(arrel_servidor) );
    assert( arrel_servidor.is_absolute() );
    assert( canonical(arrel_servidor) == arrel_servidor );

    const string ruta_peticio = peticio.ruta().ruta();
    const path arrel_i_peticio(arrel_servidor_ / path(ruta_peticio));
    if (!exists(arrel_i_peticio)) {;
        throw ErrorRutaInexistent("Ruta inexistent: " + ruta_peticio);
    }
    assert( exists(arrel_i_peticio) );
    const path ruta_en_disc(canonical(arrel_i_peticio));

    // FIXME: Assegurar que està dintre del servidor
    //path ruta_en_servidor(ruta_peticio);

    // FIXME: Representació POSIX de regex[^/] en Windows???

    fisica_ = ruta_en_disc;
    // POSTCONDICIONS: NR.ruta_fisica és absoluta i canònica
    assert( fisica_.is_absolute() );
    assert( canonical(fisica_) == fisica_ );
}

void Recurs::envia(tcp::socket & socket) const throw (runtime_error)
{
#if 0
    istream_iterator<char[MIDA_BUFFER]> begin(ifs), end();
    ostream_iterator<char[MIDA_BUFFER]> osi(gc.osi());
#endif

    ifstream ifs(fisica_.string().c_str(), ifstream::in | ifstream::binary);
    //ifs.exceptions( ifstream::failbit | ifstream::badbit );
    std::array<char, MIDA_BUFFER> buffer;

    // FIXME: Són INVARIANTS?
    // invariant de Recurs
    assert( canonical(fisica_) == fisica_ );
    // => symlinks seguits
    assert( is_regular_file(fisica_) );

    while (ifs.good() && socket.is_open()) {
        ifs.read(buffer.data(), buffer.size());
        const streamsize bytes = ifs.gcount();
        const string bloc(buffer.data(), bytes);
        this->envia(socket, bloc);
    }
    if (!ifs.eof()) {
        // Error
        throw ErrorLlegintFitxer();
    }
}

Recurs::tipus_capsaleres Recurs::capsaleres() const {
    using namespace boost;

    assert( is_regular_file(fisica()) );

    Recurs::tipus_capsaleres capsaleres = CosResposta::capsaleres();
    const string mida = lexical_cast<string>(file_size(fisica()));
    const time_t mtime = filesystem::last_write_time(fisica());
    capsaleres.push_back( make_pair("Last-Modified", data_http(mtime)) );
    capsaleres.push_back( make_pair("ETag", this->entity_tag()) );
    const string mime = RegistreTipusMIME::tipus(fisica());
    capsaleres.push_back( make_pair("Content-Type", mime) );

    // RFC 2616, 4.3 "
    // If a Content-Length header field (section 14.13) is present, its
    // decimal value in OCTETs represents both the entity-length and the
    // transfer-length. The Content-Length header field MUST NOT be sent
    // if these two lengths are different
    // "
    if (0 == transformacio().get()) {
        // No es transformarà <=> la mida és coneguda
        capsaleres.push_back( make_pair("Content-Length", mida) );
    }

    return capsaleres;
}

string Recurs::entity_tag() const {
    using utils::to_string;
    // Elements que composen l'ETag:
    // - marca de temps de modificació
    // - mida
    // - ruta física
    const time_t mtime = last_write_time(fisica_);
    const size_t mida = file_size(fisica_);
    // Re-utilitzem el hasher std::hash
    const size_t hsh = hash<string>()(fisica_.string());

    // W marca "weak" (no s'asegura unicitat)
    // RFC 2616, pàg. 126, exemples: ETag: "xyzzy"; ETag: W/"xyzzy"; ETag: ""
    return "W/\"" + hexadecimal(hsh) + "-" +
                     hexadecimal(mida) + "-" +
                     hexadecimal(mtime)  + "\"";
}

} // ns tfc

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