CGI.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 "CGI.h"
#include "Excepcions.h"
#include "Log.h"
#include "portabilitat.h"
#include "Transformacions.h"

#include <array>
#include <cassert>
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
#include <boost/date_time.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/process.hpp>
#include <boost/regex.hpp>
#include <boost/thread.hpp>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;
using namespace boost::filesystem;
using boost::algorithm::to_lower_copy;
namespace proc = boost::process;

namespace {

class ErrorCodificacio : public ErrorTFC {
public:
    ErrorCodificacio(const string & w = "Error en codificació de valor")
        : ErrorTFC(w)
    {
        // buit
    }
};

} // ns anònim

namespace tfc {

ProgramaCGI::ProgramaCGI(const PeticioHTTP & peticio, const boost::filesystem::path &arrel_servidor)
    throw (ErrorRutaInexistent)
    : RecursDinamic(peticio), arrel_servidor_(arrel_servidor)
{
    // Ruta del CGI:
    ruta_ = arrel_servidor_ / peticio.ruta().ruta();
    assert( exists(ruta_) && is_regular_file(ruta_) ); // PRECONDICIÓ
    assert( portabilitat::permis_execucio(ruta_) ); // PRECONDICIÓ
    // Salvaguardes, per si es violèssin les PREs amb asserts desactivats;
    // tenint en compte que executarem l'arxiu millor assegurar el tret
    if (!exists(ruta_) || !is_regular_file(ruta_)) {
        throw ErrorRutaInexistent(peticio.ruta().ruta()+" no és un fitxer vàlid");
    }
    if (!portabilitat::permis_execucio(ruta_)) {
        throw ErrorRutaInexistent("Configuració de permisos incorrecta");
    }
}

void ProgramaCGI::envia(asio::ip::tcp::socket & socket) const throw (std::runtime_error) {
    std::array<char, MIDA_BUFFER> buf;

    // Referència: http://www.highscore.de/boost/gsoc2010/

    proc::context ctx;
    // Comportament d'e/s estàndard. Per defecte s'hereten.
    // null() descarta, però no tanca
    if (peticio().te_cos()) {
        ctx.streams[proc::stdin_id] = proc::behavior::pipe();
    }
    else {
        ctx.streams[proc::stdin_id] = proc::behavior::null();
    }
    ctx.streams[proc::stdout_id] = proc::behavior::pipe();
    ctx.streams[proc::stderr_id] = proc::behavior::pipe();
    // L'entorn està en ctx.env. Per defecte s'hereta l'entorn del procés
    // pare
    // Variables estàndard:
    // http://www.perlfect.com/articles/cgi_env.shtml
    // http://www.tutorialspoint.com/perl/perl_cgi.htm
    ctx.env = proc::environment(); // buidem
    if (peticio().te_cos()) {
        ctx.env["CONTENT_LENGTH"] = lexical_cast<string>(peticio().cos().lock()->mida());
    }
    else {
        ctx.env["CONTENT_LENGTH"] = "0";
    }
    ctx.env["HTTP_COOKIE"] = peticio().capsalera("Cookie");
    ctx.env["CONTENT_TYPE"] = peticio().capsalera("Content-Type");
    ctx.env["DOCUMENT_ROOT"] = arrel_servidor_.string();
    ctx.env["HTTP_REFERER"] = peticio().capsalera("Referer");
    ctx.env["HTTP_USER_AGENT"] = peticio().capsalera("User-Agent");
    // XXX: En realitat no s'implementa perquè script/args no es resol a script amb arguments /args
    ctx.env["PATH_INFO"] = "";
    ctx.env["PATH_TRANSLATED"] = "";
    ctx.env["QUERY_STRING"] = peticio().ruta().query();
    ctx.env["REMOTE_ADDR"] = socket.remote_endpoint().address().to_string();
    ctx.env["REMOTE_HOST"] = socket.remote_endpoint().address().to_string(); // TODO: resoldre
    ctx.env["REQUEST_METHOD"] = NomTipusPeticioHTTP::nom(peticio().tipus());
    ctx.env["SCRIPT_NAME"] = peticio().ruta().ruta(); // Ruta "virtual"
    ctx.env["SERVER_NAME"] = socket.local_endpoint().address().to_string();
    ctx.env["SERVER_PORT"] = lexical_cast<string>(socket.local_endpoint().port());

    // http://www.w3.org/TR/html401/interact/forms.html#adef-enctype
    // Els formularis en POST s'envien amb Content-Encoding
    // application/x-www-form-urlencoded en condicions normals (nom=valor&nom=valor...,
    //                                   url encode, amb espais canviats a '+')
    // multipart/form-data per a `input type="file"`
    // De totes formes és tasca del CGI descodificar els valors
    //  http://www.tutorialspoint.com/perl/perl_cgi.htm

    // fork & exec
    proc::child cgi = proc::create_child(ruta_.string(), vector<string>(), ctx);
    proc::pistream is(cgi.get_handle(proc::stdout_id));
    proc::pistream is_err(cgi.get_handle(proc::stderr_id));
    if (peticio().te_cos()) {
        // Síncron:
        proc::postream os(cgi.get_handle(proc::stdin_id));
        const string & cos = peticio().cos().lock()->contingut();
        os.write(cos.c_str(), cos.size()); // Li passem el cos del missatge...
        os.close(); // ...i tanquem l'entrada de dades del procés (important!)
    }

    // Exhaureix les capçaleres generades pel CGI
    stringstream capss;
    // XXX: En les proves en Windows de CGIs un \r\n s'ha vist com a \r\r (???)
    //      Acceptem qualsevol combinació de CR i LF per terminar la línia
    const regex re_final_caps("^[\r\n]*$");
    while (!is.eof() && socket.is_open()) {
        string linia;
        getline(is, linia, '\n');
        if (linia.empty() || regex_match(linia, re_final_caps)) {
            // Final de les capçaleres
            break;
        }
        capss << linia << '\n';
    }
    capss.write("\r\n", 2); // El final de les capçaleres ben marcat encara
                     // que el CGI no ho faci
    this->envia_literal(socket, capss.str());

    // I a continuació, segueix enviant les dades generades pel CGI (el cos
    // del missatge), codificades
    while (!is.eof() && socket.is_open()) {
        is.read(buf.data(), buf.size());
        const streamsize bytes = is.gcount();
        cerr << "Enviant: " << string(buf.data(), bytes) << endl;
        this->envia(socket, string(buf.data(), bytes));
    }
    int ret = cgi.wait();
    if (0 != ret) {
        log() << NivellError
              << "Error d'execució de CGI " << ruta_ << ": " << is_err.rdbuf() << commit;

    }

#if 0
    const bool cal_transformar = (0 != transformacio_.get());
    while (ifs.good() && socket.is_open()) {
        ifs.read(buffer.data(), buffer.size());
        const streamsize bytes = ifs.gcount();

        string bloc(buffer.data(), bytes);
        if (cal_transformar) {
            bloc = transformacio_->transforma(bloc);
        }
        this->envia(socket, bloc);
    }
    if (!ifs.eof()) {
        // Error
        throw ErrorLlegintFitxer();
    }
    if (cal_transformar && socket.is_open()) {
        this->envia(socket, transformacio_->finalitza());
    }
#endif
}

} // ns tfc

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