Servidor.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 "AutoIndex.h"
#include "Base64.h"
#include "CGI.h"
#include "CodisEstatHTTP.h"
#include "Configuracio.h"
#include "DataHTTP.h"
#include "Log.h"
#include "PeticioHTTP.h"
#include "Recurs.h"
#include "RespostaHTTP.h"
#include "Servidor.h"
#include "utils.h"

#include <array>
#include <cassert>
#include <iostream>
#include <map>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>

using namespace boost;
using namespace boost::asio::ip;
using namespace std;
using namespace tfc;
namespace fs = boost::filesystem;

namespace {
    // TODO: canvi a Boost Regex
    vector<string> split(const string & str, char delim = ' ') {
        stringstream ss(str);
        string ostr;
        vector<string> l;
        while (getline(ss, ostr, delim)) {
            l.push_back(ostr);
        }
        return l;
    }

    // TODO: Apache: + "Server at <domini> Port <n>"
    const string SIGNATURA = PACKAGE_NAME "/" PACKAGE_VERSION;

    class ErrorRutaRelativaEnPeticio : public ErrorHTTPBadRequest {
    public:
        ErrorRutaRelativaEnPeticio(const string & w = "Petició amb ruta relativa",
                                   CodiEstatHTTP codi = CODI_400)
            : ErrorHTTPBadRequest(w, codi)
        {
            // buit
        }
    };

    class ErrorHTTP11SenseHost : public ErrorHTTPBadRequest {
    public:
        explicit ErrorHTTP11SenseHost(const string & w, CodiEstatHTTP codi)
            : ErrorHTTPBadRequest(w, codi)
        {
            // buit
        }
    };

    class ErrorAutenticacio : public ErrorTFC {
    public:
        explicit ErrorAutenticacio(const string & msg = "Error d'autenticació",
                                   const string & realm = "")
            : ErrorTFC(msg), realme(realm)
        {
            // buit
        }
        virtual ~ErrorAutenticacio() throw() {}
        const string realme;
    };

    // Drecera
    inline bool te_capsalera(const PeticioHTTP & p, const string & nom) {
        bool e;
        p.capsalera(nom, &e);
        return e;
    }

    // Usat en asserts
    inline bool es_connectat(Servidor::socket_ptr & s) {
        return s->is_open();
    }

    const regex regex_capsalera("^([\\w-]+): (.*)$", boost::regbase::perl);

    class ErrorTimeout : public tfc::ErrorRebentDades {
    public:
        explicit ErrorTimeout(const string & w = "Temps exhaurit esperant dades")
            : ErrorRebentDades(w)
        {
            // buit
        }
    };

    class ErrorConnexioTancada : public tfc::ErrorRebentDades {
    public:
        explicit ErrorConnexioTancada(const string & w = "Connexió tancada prematurament")
            : ErrorRebentDades(w)
        {
            // buit
        }
    };

    enum {
        // Amb la implementació actual es col·loca tota la petició rebuda en
        // memòria, aquest valor defineix una mida límit per al cos de la
        // petició. Peticions més grans es rebutjaran.
        MIDA_MAXIMA_COS_PETICIO = 8<<20 // 8 MiB
    };
 // XXX: G++ 4.4 té problemes si la classe es defineix dins el mètode
    struct FunctorReadSome {
        Servidor::socket_t & socket;
        asio::mutable_buffers_1 & buf;
        system::error_code & ec;
        FunctorReadSome(Servidor::socket_t & sock,
                        asio::mutable_buffers_1 & b,
                        system::error_code & e)
            : socket(sock), buf(b), ec(e)
        {}
        size_t operator()() {
            return socket.read_some(buf, ec);
        }
    };

} // ns anònim

namespace tfc {

Servidor::~Servidor() {
    if (socket_->is_open()) {
        socket_->cancel();
        socket_->close();
    }
}

// FIXME: Re-anomenar. Product name? veure RFC per "Server:"
// static
const string& Servidor::signatura() {
    return SIGNATURA; // Servidor/Versió
}

PeticioHTTP Servidor::analitza_peticio() throw (ErrorHTTP) {
    string pet;
    // Primera linia
    // RFC 2068, pg30: "servers SHOULD ignore any empty line(s)
    //                        received where a Request-Line is expected"
    while (buffer_.tellg() < buffer_.tellp() &&
           ( pet == "" || pet == "\r" ) )
    {
        getline(buffer_, pet, '\n');
    }

    const vector<string> tokens = split(pet, ' ');
    if (tokens.size() != 3) {
        throw ErrorHTTPBadRequest("Format de petició incorrecte o desconegut");
    }

    const string & verb = tokens[0];
    string path = tokens[1];

    if ('\r' != * tokens[2].rbegin()) {
        // Línea acabada en \n. FIXME: L'hauríem d'acceptar??
        throw ErrorHTTPBadRequest("Petició mal formada");
    }
    const string versio_txt = tokens[2].substr(0, tokens[2].length()-1);
    VersioHTTP versio = HTTP_DESCONEGUT;
    // TODO: 0.9
    if ("HTTP/1.0" == versio_txt) {
        versio = HTTP_1_0;
    }
    else if ("HTTP/1.1" == versio_txt) {
        versio = HTTP_1_1;
    }
    else {
        regex re("HTTP/(\\d+)\\.(\\d+)");
        smatch m;
        if (regex_match(versio_txt, m, re)) {
            try {
                const int major = lexical_cast<int>(m[1]);
                //const int minor = lexical_cast<int>(m[2]);
                switch (major) {
                case 0: // Tècnicament incorrecte
                    versio = HTTP_DESCONEGUT;
                    break;
                case 1:
                    versio = HTTP_1_X;
                    break;
                default: assert( major > 1 );
                    versio = HTTP_SUPERIOR;
                    break;
                }
            }
            catch (const bad_lexical_cast &) {
                // Queda sense definir
            }
        }
    }

    try {
        TipusPeticioHTTP tipus = NomTipusPeticioHTTP::tipus(verb); // throws
        assert( tipus != desconegut ); // POSTCONDICIÓ
        // En proxies es fa servir ruta completa (amb esquema i host), en servidors
        // finals només es fa servir path absolut, però:
        // RFC 2068, pàg. 35 "
        // To allow for transition to absoluteURIs in all requests in future
        // versions of HTTP, all HTTP/1.1 servers MUST accept the absoluteURI
        // form in requests, even though HTTP/1.1 clients will only generate
        // them in requests to proxies.
        // "
        // No poden contindre ".." FIXME: Vist en algun moment, però no ho trobo a l'RFC
        // Sanejament de ruta
        // TODO: ruta pot ser '*' si el mètode ho permet (OPTIONS, algun altre?)
        // TODO: rutes com // confondràn l'analitzador de Uris, una opció seria
        //        passar 'http://example.com' + ruta i després esborrar esquema i autoritat
        // Sanejament de ruta
        Uri ruta(path); // throws ErrorAnalisiUrl
        if (!ruta.te_ruta_absoluta()) {
            if (path == "*" && OPTIONS != tipus) { // Cas especial: Mètode options accepta '*'
                throw ErrorRutaRelativaEnPeticio();
            }
        }
        ruta.autoritat("");
        ruta.esquema("");
        assert( OPTIONS == tipus || path != "*" );
        return PeticioHTTP(tipus, ruta, versio);
    }
    catch (const ErrorAnalisiUrl & e) {
        throw ErrorHTTPBadRequest("URL de petició incorrecta");
    }
    catch (const ErrorMetodeDesconegut & e) {
        // RFC 2068, pàg. 35
        // "[...] 501 (Not Implemented) if the method is unrecognized or
        // not implemented by the server"
        throw ErrorHTTP(e.what(), CODI_501);
    }
    assert( !"Error intern, linia inabastable" );
}

size_t Servidor::llegeix_socket(stringstream & buffer,
                                unsigned int timeout_ms) throw (ErrorRebentDades)
{
    tcp::socket & socket = *socket_; // FIXME: <- Usat per ajudar IDE
    if (!socket.is_open()) {
        throw ErrorConnexioTancada();
    }
    boost::array<char, MIDA_BUFFER_LECTURA> tmp;
    asio::mutable_buffers_1 buf(asio::buffer(tmp));
    system::error_code ec;

    // El mode síncron d'Asio no permet indicar timeouts directament, i read_some
    // bloca fins que hi ha algun byte o fins que es tanca el socket
    // Per a solucinar-ho utilitzem un "future", una variable que es computa
    // de manera asíncrona, d'aquesta manera es pot indicar un timeout
    // sense passar a utilitzar les interfícies asíncrones d'Asio.
    packaged_task<size_t> pt(FunctorReadSome(socket,buf,ec));
    unique_future<size_t> fut_llegits = pt.get_future(); // associació
    // Fem la lectura en un fil separat...
    boost::thread task(boost::move(pt));
    // Llegim del socket ó fallem en cas d'un timeout.
    // En aquest cas, un timeout implica que read_some() s'ha quedat esperant
    // a rebre algun byte sense èxit.
    fut_llegits.timed_wait(posix_time::millisec(timeout_ms));

    if (!fut_llegits.is_ready()) {
        throw ErrorTimeout();
    }
    if (fut_llegits.has_exception()) {
        throw ErrorRebentDades();
    }
    const size_t llegits = fut_llegits.get();

    if (llegits > 0) {
        buffer.write(tmp.cbegin(), llegits);
    }
    if (ec == asio::error::eof) {
        throw ErrorConnexioTancada();
    }
    else if (ec) {
        throw ErrorRebentDades(); // XXX: Passa alguna vegada?
    }
    return llegits;
}

size_t Servidor::omple_buffer(unsigned int timeout_ms) throw (ErrorRebentDades) {
    if (buffer_.tellg() < buffer_.tellp()) {
        return 0;
    }
    return llegeix_socket(timeout_ms);
}

// TODO: Els servidors reals solen acceptar \n sense \r
void Servidor::extreu_capsaleres(PeticioHTTP & peticio) throw (ErrorHTTP, ErrorRebentDades) {
    // Processament de (totes) les capçaleres
    bool final_capsaleres = false;
    // Cas especial ja s'ha buidat el buffer <-> sense capçaleres
    final_capsaleres = ( buffer_.tellg() == buffer_.tellp() );
    do {
        // Exhaurim el buffer...
        string linia;
        // FIXME: Cas especial: Última lectura del buffer <-> linia incompleta
        while (!final_capsaleres && buffer_.tellg() < buffer_.tellp()) {
            getline(buffer_, linia, '\n');
            // Les capçaleres han d'acabar en \r\n
            if (linia.empty() || '\r' != utils::final(linia)) {
                log() << NivellError
                    << "Capçalera mal formada (sense \\r) [" << linia << "]" << commit;
                continue;
            }
            if (1 == linia.size()) {
                assert( "\r" == linia );
                // Capçalera buida <-> Final de capçaleres
                log() << NivellDebug << "Final de capçaleres assolit" << commit;
                final_capsaleres = true;
                break;
            }
            linia.erase( linia.size() - 1 );
            assert( '\r' != utils::final(linia) ); // XXX: Pot una capçalera contenir '\r'??
            smatch m;
            // FIXME: RFC 1945
            // * Each header field consists of a name followed immediately by a colon (":"),
            //   a single space (SP) character, and the field value
            // * Field names are case insensitive
            // * Header fields can be extended over multiple lines by preceding each extra line
            //   with at least one SP or HT (→ \t), though this is not recommended
            if (regex_match(linia, m, regex_capsalera)) {
                const string nom = m[1],
                             valor = m[2];
                peticio.afegeix_capsalera(nom, valor);
            }
            else {
                log() << NivellError
                    << "Capçalera mal formada [" << linia <<"]" << commit;
            }
        }
        // Si encara queden capçaleres per rebre, re-omplim el buffer
        if (!final_capsaleres) {
            llegeix_socket();
        }
    } while(!final_capsaleres);
    assert( final_capsaleres );
}

Servidor::Servidor(const Configuracio & c, socket_ptr &s) throw ()
    : cfg(c), socket_(s), buffer_()
{
    // PRECONDICIÓ
    assert( es_connectat(socket_) );
}

void Servidor::aten() throw (ErrorHTTP) {
    // --- Ajuda a l'hora de produïr errors ---
    // (i per tant no està definida)
    static PeticioHTTP peticio_erronia(desconegut, Uri(""), HTTP_DESCONEGUT);

    // Functor per a simplificar la gestió d'errors:
    // si la petició està definida, la retorna, altrament retorna peticio_erronia
    struct PeticioEnError {
        PeticioEnError(std::unique_ptr<PeticioHTTP> & peticio) : peticio_(peticio) {}
        const PeticioHTTP& operator()() {
            if (0 != peticio_.get()) {
                return *peticio_;
            }
            return peticio_erronia;
        }
        const std::unique_ptr<PeticioHTTP> & peticio_;
    };
    // --- Final de l'ajuda ---

    std::unique_ptr<RespostaHTTP> resposta;
    std::unique_ptr<PeticioHTTP> peticio;
    assert( 0 == resposta.get() && 0 == peticio.get());

    TipusPeticioHTTP tipus_peticio = desconegut;

    PeticioEnError e_peticio(peticio);

    try {
        const Uri host("http://" + lexical_cast<string>(socket_->local_endpoint()));

        // TODO: (forat de seguretat) No llegir tot en memòria
        omple_buffer(); // throws ErrorRebentDades

        peticio.reset( new PeticioHTTP(analitza_peticio()) ); // throws ErrorHTTP
        assert( peticio->tipus() != desconegut ); // POSTCONDICIÓ
        tipus_peticio = peticio->tipus();
        log() << NivellInfo
            << NomTipusPeticioHTTP::nom(peticio->tipus())
            << " "
            << peticio->ruta()
            << " (" << peticio->versio() << ")"
            << ", des de "
            << socket_->remote_endpoint().address() << commit;

        Uri url_completa(host);
        url_completa.ruta(peticio->ruta().ruta()); // URL de la petició

        this->extreu_capsaleres(*peticio); //-> POSTCONDICIÓ: Totes les capçaleres llegides
        // TODO: Cal enviar un 100 en HTTP/1.1 abans de llegir el cos?
        this->extreu_cos(*peticio);

        if (CONNECT == peticio->tipus()) {
            // El mètode CONNECT és reservat per l'RFC 2616, per a ús en
            // proxies que puguin canviar a mode túnel, però no detalla com funciona.
            // En qualsevol cas en aquest projecte no s'implementa la funcionalitat
            // de proxy, per tant no s'implementa el mètode CONNECT
            throw ErrorHTTPIntern("Aquest servidor no implementa el mètode CONNECT", CODI_501);
        }

        // TODO: Permisos:
        fs::path ruta_virtual(cfg.arrel() / fs::path(peticio->ruta().ruta()));
        if (fs::exists(ruta_virtual)) {
            ruta_virtual = fs::canonical(ruta_virtual);
        }
        CodiEstatHTTP permisos = cfg.cerber().acces(ruta_virtual, peticio->tipus());

        if (CODI_403 == permisos) {
            throw ErrorHTTPBadRequest("No es permet l'accés a "+peticio->ruta().str(),CODI_403);
        }
        if (CODI_405 == permisos) {
            throw ErrorHTTPBadRequest("Mètode no permés a "+peticio->ruta().str(),CODI_405);
        }

        if (CODI_401 == permisos) { // Directori protegit
            // Ha enviat credencials?
            const string auth = peticio->capsalera("Authorization");
            if (auth.empty()) {
                throw ErrorAutenticacio("Cal autenticació", cfg.realme());
            }
            smatch m;
            // L'altre mètode especificat és el Digest, especificat en l'RFC 2069
            // No s'implementarà en aquest projecte
            if (!regex_match(auth, m, regex("^Basic\\s+(.*)", regbase::perl))) {
                throw ErrorHTTPBadRequest("Mètode d'autenticació desconegut", CODI_401);
            }
            const string & credencials = Base64::descodifica(m[1]);
            // Credencials: nom_usuari:contrasenya
            // El nom d'usuari no pot contenir ':' mentre que la contrasenya sí
            // (RFC 2068, pàg. 67)
            if (!regex_match(credencials, m, regex("^([^:]*):(.*)$"))) {
                throw ErrorHTTPBadRequest("Format de credencials incorrecte", CODI_401);
            }
            const string & usuari = m[1], & pass = m[2];
            if (usuari != cfg.usuari() || pass != cfg.contrasenya()) {
                throw ErrorAutenticacio("Credencials incorrectes", cfg.realme());
            }
            // Autenticat, podem seguir normalment
        }

        // RFC 2068, pàg. 35: GET i HEAD són els únics mètodes d'implementació obligatòria

        assert( desconegut != peticio->tipus() );
        if (PUT == peticio->tipus() || METODE_DELETE == peticio->tipus()) {
            resposta = aten_peticio_escriptura(url_completa, *peticio);
        }
        else if (TRACE == peticio->tipus() || OPTIONS == peticio->tipus()) {
            resposta = aten_peticio_informacio(url_completa, *peticio);
        }
        else {
            assert( GET == peticio->tipus()
                    || HEAD == peticio->tipus()
                    || POST == peticio->tipus() );
            resposta = aten_peticio_lectura(url_completa, *peticio);
        }
    }
    catch (const ErrorHTTP & e) {
        resposta.reset(new RespostaHTTP(e.codi()));
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(e_peticio(), e.codi(), e.what()));
        resposta->defineix_cos(spcr);
    }
    catch (const ErrorAutenticacio & e) {
        assert( 0 != peticio.get() );
        resposta.reset(new RespostaHTTP(CODI_401));
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(*peticio, CODI_401, e.what()));
        resposta->defineix_cos(spcr);
        resposta->afegeix_capsalera("WWW-Authenticate", "Basic realm=\""+e.realme+"\"");
    }
    catch (const ErrorTimeout & e) {
        if (0 == peticio.get()) {
            // Timeout durant la petició, no té sentit respondre
            log() << NivellError
                  << "Temps exhaurit esperant petició, es tanca la connexió" << commit;
            socket_->close();
            return;
        }
        assert( 0 != peticio.get() );
        resposta.reset(new RespostaHTTP(CODI_408));
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(*peticio, CODI_408, e.what()));
        resposta->defineix_cos(spcr);
    }
    catch (const ErrorRebentDades & e) {
        if (0 == peticio.get()) {
            // Tancament de socket durant la petició, no té sentit respondre
            log() << NivellError
                  << "Socket tancat esperant petició" << commit;
            socket_->close();
            return;
        }
        assert( 0 != peticio.get() );
        if (!socket_->is_open()) { // XXX: Per alguna raó is_open() és cert
                                   //      encara que el client el tanqui
            return;
        }
        resposta.reset(new RespostaHTTP(CODI_400));
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(*peticio, CODI_400, e.what()));
        resposta->defineix_cos(spcr);
    }
    catch (const runtime_error & e) { // també ErrorTFC
        // Com en el catch(...), evitem fallar cas de trobar una excepció inesperada
        // en aquest cas a més podem obtenir un missatge d'error
        log() << NivellError << "Excepció inesperada: " << e.what() << commit;
        resposta.reset(new RespostaHTTP(CODI_500));
        const char * msg = "Error intern del servidor";
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(e_peticio(), resposta->codi(), msg));
        resposta->defineix_cos(spcr);
    }
    catch (...) { // Evitem que el programa falli si es llença alguna excepció no control·lada
        log() << NivellError << "@@@ Error inesperat @@@" << commit;
        resposta.reset(new RespostaHTTP(CODI_500));
        const char * msg = "Error intern del servidor";
        std::shared_ptr<CosResposta> spcr(new CosPaginaError(e_peticio(), resposta->codi(), msg));
        resposta->defineix_cos(spcr);
    }
    // TODO: Provocar error. Vist que error 500 mostra missatge, i després capçaleres
    assert( 0 != resposta.get() );

    // TODO: Aplicar filtres

    // Capçaleres generals
    resposta->afegeix_capsalera("Server", signatura());
    resposta->afegeix_capsalera("Date", data_http());
    // Si es produeix un error rebent dades pot ser que no tinguem una petició
    // en condicions
    const bool peticio_rebuda = (0 != peticio.get());
    bool pipeline = peticio_rebuda; // No té sentit escoltar més sense petició

    if (peticio_rebuda) {
        // Mantenim la connexió oberta?
        // Format de connection (RFC 2068, 14.10): 1 o més tokens, separats per comes
        const string connection = peticio->capsalera("Connection");
        if ("close" == to_lower_copy(connection)) { // TODO: Extreure tokens individuals
            // S'ha sol·licitat tancar-la expliícitament
            pipeline = false;
        }
        else {
            // En HTTP/1.1 el comportament per defecte és mantenir-la oberta
            // no cal fer res
            if (peticio->versio() < HTTP_1_1) {
                // En altres versions optem per tancar la connexió
                pipeline = false;
            }
        }
        if (!pipeline) {
            resposta->afegeix_capsalera("Connection", "close");
        }
    }
#if !defined(NDEBUG)
    // Per ajudar en les proves durant el desenvolupament, afegim ID del fil
    resposta->afegeix_capsalera("X-Thread-Id", lexical_cast<string>(this_thread::get_id()));
#endif
    // Capçaleres específiques del cos
    if (resposta->te_cos()) {
        const auto capsaleres_cos = resposta->cos().lock()->capsaleres();
        resposta->afegeix_capsaleres(capsaleres_cos.begin(), capsaleres_cos.end());
    }
    // Accept-Ranges s'associa a un recurs
    resposta->afegeix_capsalera("Accept-Ranges", "none"); // TODO: "bytes");
    // RFC 2616: pàg. 106: "
    // An Allow header field MUST be present in a 405 (Method Not Allowed) response.
    // "
    if (resposta->codi() < CODI_300 || resposta->codi() == CODI_405) {
        string allow = "GET, HEAD, POST, TRACE, OPTIONS";
        //static string m[] = { "GET", "HEAD" };

        const fs::path r = cfg.arrel() / peticio->ruta().ruta();
        if (CODI_200 == cfg.cerber().acces(r, PUT)) {
            allow += ", PUT";
        }
        if (CODI_200 == cfg.cerber().acces(r, METODE_DELETE)) {
            allow += ", DELETE";
        }
        resposta->afegeix_capsalera("Allow", allow);
    }

    // No fem cas a les capçaleres Accept-*:
    // RFC 2068, pàg. 61:
    // "HTTP/1.1 servers are allowed to return responses which are
    //  not acceptable according to the accept headers sent in the request.
    //  In some cases, this may even be preferable to sending a 406
    //  response."

    try {
        this->envia_resposta(tipus_peticio, *resposta.get());
    }
    catch (const ErrorEscrivintEnSocket & e) {
        // Error en el socket, alguna cosa ha fallat
        log() << NivellError << "Error en enviar resposta: " << e.what() << commit;
        return;
    }

    if (pipeline && socket_->is_open()) {
        log() << NivellInfo << "Reutilitzant socket " << socket_->remote_endpoint() << commit;
        aten();
    }
}

void Servidor::extreu_cos(PeticioHTTP & peticio) throw (ErrorHTTP, ErrorRebentDades) {
    // TODO: No col·locar en memòria
    // TODO: Respondre interinament amb 100 en HTTP/1.1
    // Cal enviar una resposta final igualment I no cal que esperi a rebre-la,
    // pot enviar el cos i ignorar la resposta interina

    // Capçaleres llegides. Cal llegir cos?

    // RFC 2068: L'existència d'un cos en un petició bé indicada per la
    //           presència de la capçalera Content-Length ó Transfer-Encoding
    // FIXME: Els mètodes que no permeten cos NO HAURIEN de tenir-lo (RFC2068, p32)
    // TODO: Veure RFC 2068, 4.4: Gestió de longitud i codificació de cos
    // - Si no es pot determinar la mida del missatge es pot respondre amb 400
    //   ó amb 411 (sol·licitar re-enviament amb longitud)
    //
    const bool te_cos = te_capsalera(peticio, "Content-Length") ||
                       te_capsalera(peticio, "Transfer-Encoding");
    if (!te_cos) {
        return;
    }

    // RFC 2616, 8.2.3
    const string expect = peticio.capsalera("Expect");
    if (peticio.versio() >= HTTP_1_1) {
        bool envia_100 = false;
        if (HTTP_1_1 == peticio.versio()) {
            // RFC 2616, 8.2.3, pàg. 49
            // Excepció especial per compatibilitat amb l'RFC 2068 <=> només en HTTP 1.1
            if (PUT == peticio.tipus() || METODE_DELETE == peticio.tipus()) {
                envia_100 = true;
            }
        }
        if (!envia_100 && !expect.empty()) {
            envia_100 = (expect == "100-continue");
        }
        if (envia_100) {
            RespostaHTTP continua(CODI_100);
            envia_resposta(peticio.tipus(), continua);
        }
    }

    stringstream buffer_cos; // El cos s'escriurà aquí
    std::array<char, MIDA_BUFFER_LECTURA> tempbuf; // buffer temporal de lectura
    // Exhaurim el buffer de recepció...
    while (buffer_.tellp() > buffer_.tellg()) {
        const size_t llegits = buffer_.readsome(tempbuf.data(), tempbuf.size());
        buffer_cos.write(tempbuf.data(), llegits);
    }

    // TODO: RFC 2068, pàg. 33: "
    // Messages MUST NOT include both a Content-Length header field and the
    // "chunked" transfer coding. If both are received, the Content-Length
    // MUST be ignored.
    // "
    if (!te_capsalera(peticio, "Content-Length")) {
        assert( te_capsalera(peticio, "Transfer-Encoding") );
        // RFC 2068, pàg.33: "
        // For compatibility with HTTP/1.0 applications, HTTP/1.1 requests
        // containing a message-body MUST include a valid Content-Length header
        // field unless the server is known to be HTTP/1.1 compliant. If a
        // request contains a message-body and a Content-Length is not given,
        // the server SHOULD respond with 400 (bad request) if it cannot
        // determine the length of the message, or with 411 (length required) if
        // it wishes to insist on receiving a valid Content-Length.
        // "
        // RFC 2616, pàg. 24: "
        // Whenever a transfer-coding is applied to a message-body, the set of
        // transfer-codings MUST include "chunked", unless the message is
        // terminated by closing the connection. When the "chunked" transfer-
        // coding is used, it MUST be the last transfer-coding applied to the
        // message-body.
        // " <=> no té sentit que els clients tanquin per finalitzar, per tant
        //       HAN d'incloure chunked
        // [...] "
        // A server which receives an entity-body with a transfer-coding it does
        // not understand SHOULD return 501 (Unimplemented), and close the
        // connection. A server MUST NOT send transfer-codings to an HTTP/1.0
        // client.
        // "
        const string te = to_lower_copy(peticio.capsalera("Transfer-Encoding"));
        // Només acceptem "chunked"
        if ("chunked" != te) {
            throw ErrorHTTP("Codificació de missatge no suportada", CODI_501);
        }
        assert( "chunked" == te );

        TransformacioChunked chunked;
        // XXX: Idealment caldria implementar destransforma() sense necessitar el
        //      cos sencer i/o poder aprofitar un "AplicadorTransformacio"
        // Comprovem si es pot descodificar, és a dir, si està complet
        // Com que la transformació inversa només està definida per a missatges
        // sencers caldrà haver completat el missatge abans de poder aconseguir-ho
        EstatTransformacioInversa estat;
        string descodificat = chunked.destransforma(buffer_cos.str(), estat);
        // Si el format no és acceptable no cal continuar
        if (FORMAT_INCORRECTE == estat) {
            throw ErrorHTTPBadRequest("Format codificat no reconegut", CODI_411);
        }
        while (TRANSFORMAT != estat) {
            // Cal seguir extraient
            const size_t llegits = llegeix_socket(buffer_cos);
            if (0 == llegits) { // XXX: Pot passar?
                throw ErrorTimeout();
            }
            descodificat = chunked.destransforma(buffer_cos.str(), estat);
            if (FORMAT_INCORRECTE == estat) {
                throw ErrorHTTPBadRequest("Format codificat no reconegut", CODI_411);
            }
        }
        cerr << "Final de transformació" << endl;
        assert( TRANSFORMAT == estat );

        log() << NivellDebug << "Petició amb cos (chunked), mida: "
                             << descodificat.length() << commit;
        buffer_cos.str(descodificat); // Re-emplaçem el codificat pel descodificat
    }
    else {
        size_t length;
        const string content_length = peticio.capsalera("Content-Length");
        // Comprovació de valor ben format
        if (!regex_match(content_length, regex("^\\d+$"))) {
            // Mal format
            throw ErrorHTTPBadRequest("Capçalera Content-Length mal formada");
        }
        length = boost::lexical_cast<size_t>(content_length);
        log() << NivellDebug << "Petició amb cos, mida indicada: " << length << commit;
        // XXX: Salvaguarda ja que es col·loca en memòria
        if (length > MIDA_MAXIMA_COS_PETICIO) {
            throw ErrorHTTPBadRequest("Petició massa gran", CODI_413);
        }

        while (length > buffer_cos.str().length()) {
            llegeix_socket(buffer_cos); // throws en error o timeout
        }
        const size_t rebuts = buffer_cos.str().length();
        if (rebuts != length) {
            throw ErrorHTTPBadRequest("La mida de l'entitat rebuda ("+
                                      lexical_cast<string>(rebuts)+
                                      ") difereix de la indicada ("+
                                      lexical_cast<string>(length)+")",
                                      CODI_400);
        }
    }

    const string & cos = buffer_cos.str();
    std::shared_ptr<CosPeticio> cos_peticio(new CosPeticio(cos.length()));
    cos_peticio->afegeix(cos);
    assert( cos_peticio->mida() == cos.length() );
    peticio.defineix_cos(cos_peticio);
    log() << NivellDebug << "Cos rebut, mida: " << cos_peticio->mida() << commit;
}

Servidor::resposta_uptr Servidor::aten_peticio_lectura(const Uri & url_peticio,
                                                         PeticioHTTP & peticio)
                                                                      throw (ErrorHTTP)
{
    assert( HEAD == peticio.tipus()
            || GET == peticio.tipus()
            || POST == peticio.tipus() ); // PRECONDICIÓ
    resposta_uptr resposta;
    try {
#if 0
        cerr << "- Petició " << string(62, '-') << "\n"
             << peticio << "\n"
             << string(72, '-') << endl;
#endif

        if (peticio.versio() >= HTTP_1_1) {
            // HTTP/1.1 imposa que s'envïi una capçalera Host en totes les peticions
            if (!te_capsalera(peticio, "Host")) {
                throw ErrorHTTP11SenseHost("Rebuda petició HTTP/1.1 sense capçalera host",
                                           CODI_400);
            }
        }

        Recurs r(peticio, cfg.arrel()); // throws ErrorRutaInexistent
        FlagsPermis perms = cfg.cerber().permis(r.fisica());
        assert( 0 != (perms & LECTURA)); // PRECONDICIÓ
        resposta.reset(new RespostaHTTP(CODI_200));

        log() << NivellDebug << "Recurs (real) sol·licitat: " << r.fisica() << commit;

        // Ajusta a índex per defecte
        if (is_directory(r.fisica())) {
            // XXX: index.html Configurable
            const filesystem::path index_path(r.fisica() / cfg.index());
            // is_regular_file és true per symlinks
            if (exists(index_path) && is_regular_file(index_path)) {
                // Re-escrivim la petició amb la ruta modificada
                Uri nova_ruta(peticio.ruta());
                nova_ruta.ruta(nova_ruta.ruta()+"/"+cfg.index());
                peticio = PeticioHTTP(peticio.tipus(), nova_ruta, peticio.versio());
                r = Recurs(peticio, cfg.arrel());
                // Re-analitzem
                perms = cfg.cerber().permis(r.fisica());
            }
        }

        // TODO: No generar autoindex si és un directori cgi-bin
        if (is_directory(r.fisica())) {
            assert( canonical(r.fisica()) == r.fisica() );
            // FIXME: Passar Host: com a endpoint si present
            // FIXME: Canonical vs Server path
            AutoIndex * ai = new AutoIndex(peticio, socket_->local_endpoint(), url_peticio, r);
            resposta->defineix_cos(std::shared_ptr<CosResposta>(ai));
        }
        else if (is_regular_file(r.fisica())) {
            // L'interfície per afegir un cos a la resposta fa servir punters
            // intel·ligentsm per tant cal crear un nou cos amb la implementació
            // concreta
            CosResposta * copia = 0;
            const bool ex = (0 != (perms & EXECUCIO)); // Es permet executar
            if (ex) { // => Ruta configurada com executable
                // TODO: com es comprova ownership!?
                if (!portabilitat::permis_execucio(r.fisica())) {
                    // A les rutes configurades per CGIs no es permet accedir
                    // a fitxers no executables. Protecció per no expossar el codi
                    // font d'scripts amb permissos incorrectes
                    throw ErrorHTTPIntern("Configuració de permisos incorrecta",CODI_500);
                }
                copia = new ProgramaCGI(peticio, cfg.arrel());
            }
            else {
                // Ruta "normal"
                copia = new Recurs(peticio, cfg.arrel());
            }
            resposta->defineix_cos(std::shared_ptr<CosResposta>(copia));
        }
        else {
            // Altres tipus de fitxers (pipes, sockets, dispositius...)
            // No es permet l'accés en qualsevol cas
            throw ErrorHTTPBadRequest("No es permet l'accés a "+r.fisica().string(),CODI_403);
        }
    }
    catch (const ErrorRutaInexistent &) {
        throw ErrorHTTP("No s'ha trobat en el servidor: "+peticio.ruta().ruta(), CODI_404);
    }
    assert( 0 != resposta.get() );
    return resposta;
} // aten_peticio_lectura()

Servidor::resposta_uptr Servidor::aten_peticio_escriptura(const Uri & u, PeticioHTTP & p)
                                                                        throw (ErrorHTTP)
{
    using namespace boost::filesystem;
    using boost::system::error_code;
    assert( p.tipus() == PUT || p.tipus() == METODE_DELETE ); // PRECONDICIÓ
    resposta_uptr resposta;

    if (p.versio() != HTTP_1_1) {
        // Només suportem aquestes peticions en HTTP/1.1
        // Futures versions no haurien de canviar la semàntica, però anem sobre segur
        throw ErrorHTTP("El mètode " + NomTipusPeticioHTTP::nom(p.tipus()) +
                        " només està implementat en HTTP/1.1",
                        CODI_501);
    }
    // TODO: Comprova permís

    const path ruta_real(cfg.arrel() / path(p.ruta().ruta()));

    const bool existeix = exists(ruta_real);
    // No fer coses rares amb elements especials de l'SO
    // TODO: Hi ha alguna forma de crear directoris amb PUT?
    if (existeix && !is_regular_file(ruta_real)) {
        throw ErrorHTTP(p.ruta().ruta()+" no és un fitxer vàlid", CODI_501);
    }

    if (p.tipus() == PUT) {
        // Si el recurs existeix, se sobreescriu.
        // Si no existeix i és permissible, es crea
        // Respostes:
        //  201 -> S'ha creat
        //  200 ó 204 -> S'ha modificat
        if (!p.te_cos()) {
            // XXX: Sense cos, s'hauria de crear un recurs buit?
            throw ErrorHTTPBadRequest("Petició PUT sense contingut", CODI_400);
        }
        // FIXME:
        // Si la petició conté capçaleres Content-* que no s'entenen o no es
        // suporten NO S'HAN D'IGNORAR, i s'ha de respondre amb 501
        // Escrivim a un fitxer temporal
        size_t content_length = 0;
        for (auto it = p.capsaleres().begin(); it != p.capsaleres().end(); ++it) {
            if ("content-length" == to_lower_copy(it->nom())) {
                try {
                    content_length = lexical_cast<size_t>(it->valor());
                    break;
                }
                catch (const boost::bad_lexical_cast & e) {
                    // FIXME: ó 411? ó 400?
                    throw ErrorHTTPBadRequest("La mida indicada en les capçaleres no s'entén", CODI_411);
                }
            }
        }
        if (content_length == 0) {
            throw ErrorHTTPBadRequest("Petició PUT sense mida", CODI_411);
        }
        // TODO: Utilitzar fitxer intermig temporal
        // codi portable d'exemple:
        // http://lists.boost.org/Archives/boost/2005/09/index.php#93150
        // http://web.archive.org/web/http://psycho.pl/pub/src/tmpfile.cc
        ofstream ofs(ruta_real.string().c_str(), ios::out|ios::binary|ios::trunc);
        if (ofs.fail()) {
            throw ErrorHTTPIntern("Error en obrir `"+p.ruta().ruta()+"` per escriure'n",
                                  CODI_503); // 503 no és 100% adequada, però crec que acceptable
        }
        const auto pCos = p.cos().lock();
        ofs.write(pCos->contingut().c_str(), pCos->mida());
        if (ofs.bad()) {
            throw ErrorHTTPIntern("Error en escriure a `"+p.ruta().ruta()+"`", CODI_500);
        }
        ofs.close();
        log() << NivellDebug << ruta_real << " escrit mitjançant PUT" << commit;
        const CodiEstatHTTP codi = (existeix ? CODI_204 : CODI_201);
        resposta.reset(new RespostaHTTP(codi));
    }
    else { assert( p.tipus() == METODE_DELETE );
        // Possibles respostes (RFC 2068, pàg. 53)
        // 2xx només si es pretén esborrar (es faci realment o no)
        //  202 -> OK, però encara no s'ha esborrat
        //  200 -> OK amb entitat missatge d'estat
        //  204 -> OK sense missatge
        // DELETE es pot implementar com esborrat o com moviment a una
        // ruta inaccessible
        if (!existeix) {
            throw ErrorHTTPBadRequest("El recurs "+p.ruta().ruta()+" no existeix", CODI_404);
        }
        assert( existeix );
        // XXX: remove() esborra symlinks sense seguir-los. És el funcionament dessitjable?
        error_code ec;
        remove(ruta_real.string(), ec); // retorna true si ruta_real existeix, no si s'esborra
        if (ec) {
            throw ErrorHTTP("Error esborrant el recurs "+p.ruta().ruta()+": "+
                            ec.category().message(ec.value())
                            , CODI_503); // ó 500
        }
        log() << NivellDebug << ruta_real << " esborrat" << commit;
        resposta.reset(new RespostaHTTP(CODI_204));
    }
    return resposta;
} // aten_peticio_escriptura()

Servidor::resposta_uptr Servidor::aten_peticio_informacio(const Uri & u, PeticioHTTP & p)
                                                                           throw (ErrorHTTP)
{
    assert( TRACE == p.tipus() || OPTIONS == p.tipus() ); // PRECONDICIÓ
    resposta_uptr resposta;

    if (TRACE == p.tipus()) {
        // RFC 2068, 9.8 TRACE, pàg. 53
        // "The final recipient of the request SHOULD reflect the message received
        //  back to the client as the entity-body of a 200 (OK) response."
        if (p.te_cos()) {
            // "A TRACE request MUST NOT include an entity."
            throw ErrorHTTP("Petició TRACE amb cos", CODI_400);
        }
        resposta.reset(new RespostaHTTP(CODI_200));
        resposta->afegeix_capsalera("Content-Type", "text/html");
        resposta->afegeix_capsalera("Content-Length",
                                    lexical_cast<string>(buffer_.str().length()));
        CosTextual * pCos = new CosTextual(p, buffer_.str());
        std::shared_ptr<CosResposta> sptrCos(pCos);
        resposta->defineix_cos(sptrCos);
    }
    else { assert( OPTIONS == p.tipus() );
        // RFC 2616: 9.2, pàg. 52: "
        // A 200 response SHOULD include any header fields that indicate
        // optional features implemented by the server and applicable to that
        // resource (e.g., Allow)"
        // Allow s'inclou sempre, altres com la gestió de caché no estàn implementades,
        // per tant no cal fer res.
        // " The response body, if any, SHOULD also include
        // information about the communication options. The format for such a
        // body is not defined by this specification, but might be defined by
        // future extensions to HTTP. [...]  If no response body is included, the
        // response MUST include a Content-Length field with a field-value of
        // "0"."
        resposta.reset(new RespostaHTTP(CODI_200));
        resposta->afegeix_capsalera("Content-Length", "0");
    }

    return resposta;
} // aten_peticio_informacio()

void Servidor::envia_resposta(TipusPeticioHTTP tipus, RespostaHTTP & r) const
                                                    throw (ErrorEscrivintEnSocket)
{
    log() << NivellDebug << "Enviant resposta (" << r.codi() << ")" << commit;

    // FIXME: HEAD + error 404, p.e., provoca un Content-Length per el text del missatge,
    //        és correcte? Almenys Winie té problemes amb això
    if (HEAD == tipus) {
        r.elimina_capsalera("Content-Length");
    }

    // Enviament de capçaleres
    {
        const string & frase = FrasesEstatHTTP::frase(r.codi());
        ostringstream oss_resposta;
        // Les respostes haurien de ser en la mateixa versió que el client
        // però no és obligatori i a la pràctica no hi ha cap diferència perquè es permeten
        // capçaleres posteriors a la versió d'HTTP
        oss_resposta << "HTTP/1.1 " << lexical_cast<string>(r.codi())
                     << " " << frase << "\r\n";
        r.imprimeix_capsaleres(oss_resposta, "\r\n");
        // Final de capçaleres.
        // Cas especial: Els CGIs també poden generar capçaleres i per
        // tant són ells els encarregats d'enviar el separador de capçaleres i cos.
        // Altres tipus de recursos dinàmics també podrien, teòricament.
        // Vegeu CosResposta::pot_generar_capsaleres()
        if (HEAD != tipus && r.te_cos()) {
            if (!r.cos().lock()->pot_generar_capsaleres()) {
                oss_resposta << "\r\n";
            }
        }
        else { // no te cos, o té cos però és un HEAD
            oss_resposta << "\r\n";
        }
        try {
            asio::write(*socket_, asio::buffer(oss_resposta.str()));
        }
        catch (const boost::system::system_error & e) {
            throw ErrorEscrivintEnSocket(e.what());
        }
    }

    assert( tipus != desconegut || r.codi() >= 400 );
    if (HEAD != tipus) {
        if (r.te_cos()) {
            assert( !r.cos().expired() );
            auto cos = r.cos().lock();
            try {
                cos->envia(*socket_); // throws runtime_error
                cos->envia_eom(*socket_); // throws ErrorEscrivintEnSocket
            }
            catch (const ErrorEscrivintEnSocket & e) {
                throw;
            }
            catch (const std::runtime_error & e) {
                throw ErrorEscrivintEnSocket(e.what());
            }
            log() << NivellDebug << "Cos enviat" << commit;
        }
        else {
            log() << NivellDebug << "Resposta sense cos" << commit;
        }
    }
}

void Servidor::tancar_sessio() {
    socket_->close();
}

} // ns tfc

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