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

#include <boost/array.hpp>
#include <boost/bimap.hpp>
#include <boost/assign.hpp>

using namespace std;

namespace {

// boost::bimap és un mapa bidireccional, és a dir, un mapa en què es pot fer sevir
// tant el primer com el segon element com a clau de cerca.
// bimap.left es correspon a un mapa normal
// bimap.right es correspon a un mapa invers (el valor fa de clau i viceversa)
typedef boost::bimap<unsigned int, char> uint_a_char_bimap;
// assign::map_list_of no es pot utilitzar directament amb bimap
// http://www.boost.org/doc/libs/1_49_0/libs/bimap/example/bimap_and_boost/assign.cpp
uint_a_char_bimap TRADUCCIO = boost::assign::list_of<uint_a_char_bimap::relation>
    (  0, 'A' )
    (  1, 'B' )
    (  2, 'C' )
    (  3, 'D' )
    (  4, 'E' )
    (  5, 'F' )
    (  6, 'G' )
    (  7, 'H' )
    (  8, 'I' )
    (  9, 'J' )
    ( 10, 'K' )
    ( 11, 'L' )
    ( 12, 'M' )
    ( 13, 'N' )
    ( 14, 'O' )
    ( 15, 'P' )
    ( 16, 'Q' )
    ( 17, 'R' )
    ( 18, 'S' )
    ( 19, 'T' )
    ( 20, 'U' )
    ( 21, 'V' )
    ( 22, 'W' )
    ( 23, 'X' )
    ( 24, 'Y' )
    ( 25, 'Z' )
    ( 26, 'a' )
    ( 27, 'b' )
    ( 28, 'c' )
    ( 29, 'd' )
    ( 30, 'e' )
    ( 31, 'f' )
    ( 32, 'g' )
    ( 33, 'h' )
    ( 34, 'i' )
    ( 35, 'j' )
    ( 36, 'k' )
    ( 37, 'l' )
    ( 38, 'm' )
    ( 39, 'n' )
    ( 40, 'o' )
    ( 41, 'p' )
    ( 42, 'q' )
    ( 43, 'r' )
    ( 44, 's' )
    ( 45, 't' )
    ( 46, 'u' )
    ( 47, 'v' )
    ( 48, 'w' )
    ( 49, 'x' )
    ( 50, 'y' )
    ( 51, 'z' )
    ( 52, '0' )
    ( 53, '1' )
    ( 54, '2' )
    ( 55, '3' )
    ( 56, '4' )
    ( 57, '5' )
    ( 58, '6' )
    ( 59, '7' )
    ( 60, '8' )
    ( 61, '9' )
    ( 62, '+' )
    ( 63, '/' );
} // ns anònim

namespace tfc {

namespace Base64 {

string codifica(const string & S) {
    string s(S);
    // extensió (padding):
    short padding = 0;
    if (s.length() % 3 == 1) {
        s.push_back(0);
        s.push_back(0);
        padding = 2;
    }
    else if (s.length() % 3 == 2) {
        s.push_back(0);
        padding = 1;
    }
    assert( 0 == (s.length() % 3) );
    string r;
    r.reserve(static_cast<size_t>(s.length() * 1.34)); // base64 afegeix ~33%
    typedef bitset<sizeof(int)*8> bset;
    for (auto it=s.begin(); it != s.end(); it+=3) {
        // Important que sigui unsigned char per cadenes "binàries"
        const unsigned char a = *it,
                            b = *(it+1),
                            c = *(it+2);
        typedef unsigned int uint;
        const unsigned long abc = a<<16 | b<<8 | c;
        const uint x1 = static_cast<uint>( abc & 0x00003f),
                   x2 = static_cast<uint>((abc & 0x000fc0) >> 6),
                   x3 = static_cast<uint>((abc & 0x03f000) >> 12),
                   x4 = static_cast<uint>((abc & 0xfc0000) >> 18);
        r.push_back(TRADUCCIO.left.at(x4));
        r.push_back(TRADUCCIO.left.at(x3));
        r.push_back(TRADUCCIO.left.at(x2));
        r.push_back(TRADUCCIO.left.at(x1));
    }
    if (padding > 0) {
        for (auto rit = r.rbegin(); rit != r.rbegin()+padding; ++rit) {
            *rit = '=';
        }
    }
    return r;
}

inline string descodifica_bloc(const boost::array<char,4> & bloc, size_t valids=4) {
    if ( valids == 0 ) { return ""; }

    unsigned long bytes = 0;
    for (size_t idx=0; idx<valids; ++idx) {
        bytes = bytes << 6 | TRADUCCIO.right.at(bloc[idx]);
    }
    const size_t offset_ajust = (4-valids)*6;
    bytes = bytes << offset_ajust;
    assert( 0 == (bytes & 0xFF000000) );
    const char d3 = bytes & 0x0000FF,
               d2 = (bytes & 0x00FF00) >> 8,
               d1 = (bytes & 0xFF0000) >> 16;
    string r;
    r.reserve(3);
    r.push_back(d1);
    r.push_back(d2);
    r.push_back(d3);
    // Re-ajust: assegurem que no afegim 0's extra
    switch (offset_ajust) {
    case 6:
        r.erase(r.length()-1);
        break;
    case 12:
        r.erase(r.length()-2);
        break;
    case 18: // ???
        r.erase(r.length()-3);
        break;
    default:
        break;
    }
    return r;
}

string descodifica(const string & S) {
    string s;
    s.reserve(S.length());
    // Neteja de la cadena: Tots els valors fora de la taula de traducció
    // s'han d'ignorar
    for (auto it=S.begin(); it!=S.end(); ++it) {
        try {
            TRADUCCIO.right.at(*it);
            s.push_back(*it);
        }
        catch (const std::out_of_range &) {
            continue;
        }
    }
    string r;
    r.reserve(s.length()); // de sobres, serà ~ un 33% més curta
    boost::array<char,4> bloc;
    size_t idx=0;
    // TODO: Ignorar > 63!
    for (auto it=s.begin(); it != s.end(); ++it) {
        bloc[idx++] = *it;

        if (idx == 4) {
            r.append(descodifica_bloc(bloc));
            idx=0;
        }
    }
    const size_t resta = (s.length() % 4);
    r.append(descodifica_bloc(bloc, resta));
    return r;
}

} // ns Base64

} // ns tfc

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