Transformacions.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 "Transformacions.h"
#include "utils.h"

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

using namespace std;
using namespace boost;

namespace {

// ZLIB_CONST és una addició relativament recent, per evitar problemes
// de compatibilitat amb versions anteriors de moment es fa servir la
// forma clàssica
#if 1 || !defined(ZLIB_CONST)
inline Bytef* converteix_next_in(const string & s) {
    return const_cast<Bytef*>(reinterpret_cast<const Bytef*>(s.c_str()));
}
#else
inline const Bytef* converteix_next_in(const string & s) {
    return reinterpret_cast<const Bytef*>(s.c_str());
}
#endif

} // ns anònim

namespace tfc {

bool FuncioExtractoraIstream::operator()(string & bloc) {
    bloc.erase();
    if (!ist_.good()) {
        return false;
    }
    const streamsize bytes = ist_.readsome(&buffer_[0], MIDA_BUFFER);
    bloc.assign(&buffer_[0], static_cast<string::size_type>(bytes));
    return bytes > 0;
}

bool FuncioEscriptoraOstream::operator()(const string & bloc) {
    if (!ost_.good()) {
        return false;
    }
    ost_.write(bloc.c_str(), bloc.length());
    return !ost_.bad();
}

string TransformacioChunked::transforma(const string & bloc) const {
    ostringstream oss;
    // chunk-size [ chunk-extension ] CRLF
    // "The chunk-size field is a string of hex digits indicating the size of the chunk"
    oss << std::hex << bloc.length() << "\r\n";
    // chunk-data CRLF
    oss.write(bloc.c_str(), bloc.length());
    oss << "\r\n";
    return oss.str();
}

string TransformacioChunked::destransforma(const string & text_transformat,
                                           EstatTransformacioInversa &estat) const {
    // L'RFC 2616 presenta un possible algorisme en pseudocodi a la pàgina 169
    istringstream iss(text_transformat);
    string r;
    r.reserve(text_transformat.length()); // La mida serà menor, però similar
    iss.exceptions(ios::badbit|ios::failbit|ios::eofbit);
    static const size_t MIDA_BUFFER = 4096;
    std::array<char, MIDA_BUFFER> buffer;
    estat = TRANSFORMAT;
    try {
        string params;
        const regex re_parcial_mida("^([[:xdigit:]]+)", regbase::perl);
        smatch m;
        // Lectura d'un "chunk"
        while (iss.good()) {
            // Inici de bloc: mida [params] CRLF. p.e. f33;xyxCRLF
            getline(iss, params, '\n');
            if (!regex_search(params, m, re_parcial_mida)) {
                estat = FORMAT_INCORRECTE;
                break;
            }
            unsigned long mida_bloc;
            mida_bloc = utils::from_string<unsigned long>(m[1], std::hex);
            if (0 == mida_bloc) {
                // Final
                break;
            }
            // Bloc
            size_t llegits=0;
            // XXX: iss.good() no serveix per què l'EOF no s'activa (???) (G++ 4.4)
            const streamsize fi = iss.str().size();
            while (iss.tellg() < fi && llegits < mida_bloc) {
                const size_t bufvalids = std::min<size_t>(MIDA_BUFFER, mida_bloc-llegits);
                const size_t bytes = static_cast<size_t>(iss.readsome(&buffer[0], bufvalids));
                r.append(&buffer[0], static_cast<streamsize>(bytes));
                llegits += bytes;
            }
            if (llegits != mida_bloc) {
                // El bloc no s'ha llegit correctament
                estat = NO_TRANSFORMAT;
                break;
            }
            // Final de bloc: CRLF
            iss.seekg(2, ios::cur );
        }
        // Tots els blocs llegits o EOF
        // Lectura de trailer
        while (estat != FORMAT_INCORRECTE && false && iss.good()) {
            // TODO: (pàg. 169:)
            // read entity-header
            // while (entity-header not empty) {
            // append entity-header to existing header fields
            // read entity-header
            // }
        }
    }
    catch (const ios_base::failure &) {
    }
    if (TRANSFORMAT == estat && (iss.fail() || iss.bad())) {
        estat = NO_TRANSFORMAT;
    }
    return r;
}

string TransformacioChunked::finalitza() const {
    // Chunked-Body   = *chunk
    //                  last-chunk
    //                  trailer
    //                  CRLF
    // last-chunk = 1*("0") [ chunk-extension ] CRLF
    // trailer    = *(entity-header CRLF)
    return "0\r\n" // last-chunk
            "\r\n" // trailer
            "\r\n"; // CRLF
}

AplicadorTransformacioBase::~AplicadorTransformacioBase() {
    // Cal definir el destructor (virtual) en un mòdul (és a dir,
    // fora de la capçalera) per que l'enllaçador el col·loqui
    // correctament (altrament no enllaça)
}

void AplicadorTransformacioBase::aplica() {
    string buffer;
    Transformacio * pTrans = transformacio();
    while (extractora_(buffer)) {
        const bool ok = escriptora_(pTrans->transforma(buffer));
        buffer.erase();
        if (!ok) {
            break;
        }
    }
    escriptora_(pTrans->finalitza());
}

bool TransformacioDeflate::inicialitza(Mode mode) const {
    if (CAP == mode) {
        return false;
    }
    desinicialitza();
    //memset(&strm_, 0x00, sizeof(z_stream));
    strm_.zalloc = Z_NULL;
    strm_.zfree = Z_NULL;
    strm_.opaque = Z_NULL;
    int ret;
    if (DEFLATE == mode) {
        // IMPORTANT:
        // Internet Explorer no accepta el format per defecte
        // Si es fa servir deflateInit es genera el format "zlib", és a dir,
        // deflate amb capçaleres (RFC 1950+RFC 1951).
        // En base a l'RFC d'HTTP (2616, pàg. 23), aquesta és la codificació "deflate",
        // i els altres clients provats (Firefox, Chrome, wget) l'accepten com a tal,
        // però IE dona error.
        // Amb deflateInit2 es poden suprimir les capçaleres zlib, enviant nomes dades
        // comprimides amb deflate. Aquest format és el que IE espera i la resta de
        // navegadors l'accepten, però estrictament parlant no és el correcte, així
        // que no és decartable que doni altres problemes en el futur...
        // Discussió relacionada: http://stackoverflow.com/questions/1077869/internet-explorer-8-deflate
        //ret = ::deflateInit(&strm_, Z_BEST_SPEED);
        // http://www.zlib.net/manual.html#deflateInit2
        ret = ::deflateInit2(&strm_, Z_BEST_SPEED,
                             Z_DEFLATED, // mètode (només existeix aquest per ara)
                             -15, // bits de finestra (log 2),
                                  // valors negatius -8..-15 suprimeixen les capçaleres
                                  // valors > 15 canvien al format gzip        
                             8, // nivell de memòria reservada, 8 per defecte
                             Z_DEFAULT_STRATEGY); // estratègia
    }
    else {
        // XXX: Què passa llavors amb l'inflate? Cal també utilitzar inflateInit2()?
        ret = ::inflateInit(&strm_);
    }
    const bool ok = ( Z_OK == ret );
    inicialitzat_ = (ok ? mode : CAP);
    return ok;
}

// La transformació GZIP / ZLIB podria utilitzar Boost.Iostreams,
// que a la pràctica presenta unes intefícies més generals de transformació
// http://www.boost.org/doc/libs/1_49_0/libs/iostreams/doc/classes/zlib.html
// http://www.boost.org/doc/libs/1_49_0/libs/iostreams/doc/classes/gzip.html

string TransformacioDeflate::transforma(const string & bloc) const {
    string t;
    if (DEFLATE != inicialitzat_) {
        inicialitza(DEFLATE);
    }
    //::compress2(dest, destLen, bloc.c_str(), bloc.length(), Z_BEST_SPEED);
    strm_.avail_in = bloc.length();
    strm_.next_in = converteix_next_in(bloc);
    std::array<unsigned char,MIDA_BUFFER_ZLIB> buf;
    do {
        strm_.avail_out = MIDA_BUFFER_ZLIB;
        strm_.next_out = buf.data();
        const int ret = ::deflate(&strm_, Z_SYNC_FLUSH);
        if (Z_STREAM_ERROR == ret) {
            return string(); // FIXME: <--
        }
        const size_t bytes = MIDA_BUFFER_ZLIB - strm_.avail_out;
        t.append(reinterpret_cast<char*>(buf.data()), bytes);
    } while (0 == strm_.avail_out);
    assert( 0 == strm_.avail_in );
    return t;
}

string TransformacioDeflate::finalitza() const {
    desinicialitza();
    return "";
}

string TransformacioDeflate::destransforma(const string & text_transformat,
                                           EstatTransformacioInversa & estat) const {
    string d;
    estat = TRANSFORMAT;
    inicialitza(INFLATE);
    strm_.avail_in = text_transformat.length();
    strm_.next_in = converteix_next_in(text_transformat);
    std::array<unsigned char,MIDA_BUFFER_ZLIB> buf;
    do {
        strm_.avail_out = MIDA_BUFFER_ZLIB;
        strm_.next_out = buf.data();
        const int ret = ::inflate(&strm_, Z_SYNC_FLUSH);
        switch (ret) {
        // TODO: Diferenciar entre format incorrecte i altres errors
        case Z_STREAM_ERROR:
        case Z_NEED_DICT:
        case Z_DATA_ERROR:
        case Z_MEM_ERROR:
            desinicialitza();
            estat = NO_TRANSFORMAT;
            return string(); // FIXME: <--
        default:
            break;
        }
        const size_t bytes = MIDA_BUFFER_ZLIB - strm_.avail_out;
        d.append(reinterpret_cast<char*>(buf.data()), bytes);
    } while (0 == strm_.avail_out);
    return d;
}

void TransformacioDeflate::desinicialitza() const {
    if (CAP == inicialitzat_) {
        return;
    }

    if (DEFLATE == inicialitzat_) {
        ::deflateEnd(&strm_);
    }
    else { assert( INFLATE == inicialitzat_ );
        ::inflateEnd(&strm_);
    }
    inicialitzat_ = CAP;
    memset(&strm_, 0x00, sizeof(z_stream));
}

string CadenaTransformacions::transforma(const string &bloc) const {
    string r(bloc);
    for (auto it=cadena_.begin(); it != cadena_.end(); ++it) {
        r = (*it)->transforma(r);
    }
    return r;
}

string CadenaTransformacions::finalitza() const {
    string f;
    for (auto it=cadena_.begin(); it != cadena_.end(); ++it) {
        f.append( (*it)->finalitza() );
    }
    return f;
}

string CadenaTransformacions::destransforma(const string & text,
                                            EstatTransformacioInversa & estat) const {
    estat = TRANSFORMAT;
    string r(text);
    for (auto rit=cadena_.rbegin(); estat == TRANSFORMAT && rit != cadena_.rend(); ++rit) {
        r = (*rit)->destransforma(r, estat);
    }
    return r;
}

} // ns tfc

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