CosResposta.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 "CosResposta.h"

#include <sstream>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>

using namespace std;

using boost::lexical_cast;

namespace tfc {

size_t CosResposta::envia(socket_tcp & socket, const string & buffer) const
    throw (ErrorEscrivintEnSocket)
{
    string dades;
    transformacio_ptr pTrans( transformacio() );
    if (0 == pTrans.get()) {
        // No cal transformar
        dades = buffer;
    }
    else {
        dades = pTrans->transforma( buffer );
    }
    return envia_literal(socket, dades); // throws ErrorEscrivintEnSocket
}

size_t CosResposta::envia_literal(socket_tcp & socket, const string & buffer) const
    throw (ErrorEscrivintEnSocket)
{
    // Quan el client tanca la sessió (p.e. CTRL+C mentre descarrega), es produeix
    // un error "connection reset by peer"
    try {
        // socket.write_some envia el que pot (bloca fins escriure alguna cosa o fallar)
        // asio::write() envia tot el buffer, blocant el que calgui
        return boost::asio::write(socket, boost::asio::buffer(buffer));
    }
    catch (const boost::system::system_error &) {
        // TODO: Es pot distingir si és un "connection reset by peer"?
        throw ErrorEscrivintEnSocket();
    }
}

void CosResposta::envia_eom(socket_tcp & socket) const throw (ErrorEscrivintEnSocket)
{
    if (0 != trans_.get()) {
        envia_literal(socket, trans_->finalitza()); // throws ErrorEscrivintEnSocket
    }
}


CosResposta::tipus_capsaleres CosResposta::capsaleres() const {
    tipus_capsaleres tc;
    if (!ce_.empty()) {
        tc.push_back( make_pair("Content-Encoding", ce_) );
    }
    if (!te_.empty()) {
        tc.push_back( make_pair("Transfer-Encoding", te_) );
    }
    return tc;
}

void CosResposta::determina_codificacions() {
    using namespace boost;

    // chunked HA de ser acceptat per els clients HTTP/1.1
    chunked_ok_ = peticio().versio() >= HTTP_1_1;

    if (peticio().versio() < HTTP_1_1) {
        // Els clients HTTP/1.0 tècnicament poden implementar codificacions
        // (gzip i compress), però no (necessàriament) han de suportar chunked
        // Podem optar per codificar, no indicar un Content-Length, i tancar la
        // connexió quan després de cada fitxer servit, però per simplicitat
        // en aquesta implementació símplement no es codificarà en versions
        // d'HTTP menors d'1.1
        deflate_ok_ = false;
        chunked_ok_ = false;
        return;
    }
    assert( peticio().versio() >= HTTP_1_1 );

    // Transformacions acceptades
    const string tr = peticio().capsalera("Accept-Encoding");
    if (tr.empty() || "identity" == to_lower_copy(tr)) {
        // No té gaire sentit aplicar "identity"
        deflate_ok_ = false;
        chunked_ok_ = false;
        return;
    }

    char_separator<char> separador(",");
    tokenizer< char_separator<char> > tokens(tr, separador);

    // Com que només s'implementen deflate i chunked no es
    // generalitza més el codi

    const boost::regex re_espais("\\s*");
    for (auto it=tokens.begin(); it != tokens.end(); ++it) {
        // Elimina els espais...
        const string enc = boost::regex_replace(*it, re_espais, "");
        // ...i compara sense diferenciar majús./minus.
        if ("deflate" == to_lower_copy(enc)) {
            deflate_ok_ = true;
            break;
        }
    }

    assert( chunked_ok_ );

    // Només s'implementen deflate i chunked
    // deflate presenta el problema de calcular la mida, per simplicitat
    // només s'aplica deflate quan es combina amb chunked
    // chunked per sí sol només és rellevant quan no es pot especificar la mida
    // XXX: implementar deflate si la mida es coneix
    if (!deflate_ok_) {
        te_ = "chunked";
        // trans_.reset( new TransformacioChunked() );
    }
    else {
        te_ = "chunked";
        ce_ = "deflate";
        CadenaTransformacions * pTrans = new CadenaTransformacions();
        trans_.reset( pTrans );
        pTrans->afegeix<TransformacioDeflate>();
        pTrans->afegeix<TransformacioChunked>();
    }
}

string CosPaginaError::html() const {
    if (!cache_.empty()) {
        return cache_;
    }

    ostringstream ss;

    const string titol = lexical_cast<string>(static_cast<int>(error_)) + ": " +
                         FrasesEstatHTTP::frase(error_);

    ss << "<!DOCTYPE html>\n"
          "<html>\n"
          "<head>\n"
          "\t<title>" << titol << "</title>\n"
          "</head>\n"
          "<body>\n"
          "\t<h1>Error " << titol << "</h1>\n"
          "\t<p>" << missatge_ << "</p>\n"
          "\t<hr />\n"
          "\t<address>" << Servidor::signatura() << "</address>\n"
          "</body>\n"
          "</html>\n";
    cache_ = ss.str();

    return cache_;
}

CosPaginaError::tipus_capsaleres CosPaginaError::capsaleres() const {
    tipus_capsaleres c = RecursDinamic::capsaleres();
    c.push_back( make_pair("Content-Type", "text/html; charset=utf-8") ); // FIXME: charset
    c.push_back( make_pair("Content-Length", lexical_cast<string>(html().length())) );
    return c;
}

} // ns tfc

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