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

#include <cstdlib>
#include <boost/algorithm/string.hpp>
#include <boost/assign.hpp>
#include <boost/regex.hpp>
#include <boost/unordered_map.hpp>

using namespace boost::algorithm;
using namespace boost::gregorian;
using namespace boost::posix_time;
using namespace std;
using boost::lexical_cast;
using boost::unordered_map;

namespace {

using namespace tfc;

const string FORMAT_HTTP("%a, %d %b %Y %H:%M:%S GMT"); // %T no parseja

// Formats acceptats en la recepció (RFC 2068, 3.3.1):
// Sun, 06 Nov 1994 08:49:37 GMT  // RFC 822 <=> FORMAT_HTTP
// Sunday, 06-Nov-94 08:49:37 GMT // RFC 850
// Sun Nov  6 08:49:37 1994        // ANSI C asctime()

// Extracció dels valors a partir de expressions regulars
const boost::regex RE_RFC822(
        // 1: dia setmana, 2: dia mes, 3: mes, 4: any (xxxx), 5,6,7: hms
        "^(\\w{3}), (\\d{2}) (\\w{3}) (\\d{4}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$",
        boost::regbase::perl);

void extreu_rfc822(const string & s,
                   string & dia_sem, string & dia_mes,
                   string & mes, string & any,
                   string & hora, string & minut, string & segon)
{
    assert( boost::regex_match(s, RE_RFC822) ); // PRECONDICIÓ
    boost::smatch m;
    boost::regex_match(s, m, RE_RFC822);
    dia_sem = m[1];
    dia_mes = m[2];
    mes = m[3];
    any = m[4];
    hora = m[5];
    minut = m[6];
    segon = m[7];
}

const boost::regex RE_RFC850(
        // 1: dia setmana, 2: dia mes, 3: mes, 4: any (xx), 5,6,7: hms
        "^(\\w+), (\\d{2})-(\\w{3})-(\\d{2}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$",
        boost::regbase::perl);

void extreu_rfc850(const string & s,
                   string & dia_sem, string & dia_mes,
                   string & mes, string & any,
                   string & hora, string & minut, string & segon)
{
    assert( boost::regex_match(s, RE_RFC850) ); // PRECONDICIÓ
    boost::smatch m;
    boost::regex_match(s, m, RE_RFC850);
    dia_sem = m[1];
    dia_mes = m[2];
    mes = m[3];
    any = "19"+m[4];
    hora = m[5];
    minut = m[6];
    segon = m[7];
}

const boost::regex RE_ASCTIME(
        // 1: dia setmana, 2: mes, 3: dia mes (' 'x ó xx), 4,5,6: hms, 7: any (xxxx)
        "^(\\w{3}) (\\w{3})  ?(\\d{1,2}) (\\d{2}):(\\d{2}):(\\d{2}) (\\d{4})$",
        boost::regbase::perl);

void extreu_asctime(const string & s,
                     string & dia_sem, string & dia_mes,
                     string & mes, string & any,
                     string & hora, string & minut, string & segon)
{
    assert( boost::regex_match(s, RE_ASCTIME) ); // PRECONDICIÓ
    boost::smatch m;
    boost::regex_match(s, m, RE_ASCTIME);
    dia_sem = m[1];
    mes = m[2];
    dia_mes = m[3];
    hora = m[4];
    minut = m[5];
    segon = m[6];
    any = m[7];
}
// Traduccions de dates textuals
const unordered_map<string, int> DIES_SETMANA = boost::assign::map_list_of
        ( "mon", 0 ) ( "monday", 0 )
        ( "tue", 1 ) ( "tuesday", 1 )
        ( "wed", 2 ) ( "wednesday", 2 )
        ( "thu", 3 ) ( "thursday", 3 )
        ( "fri", 4 ) ( "friday", 4 )
        ( "sat", 5 ) ( "saturday", 5 )
        ( "sun", 6 ) ( "sunday", 6 );
const unordered_map<string, int> MESOS = boost::assign::map_list_of
        ( "jan", 0 )
        ( "feb", 1 )
        ( "mar", 2 )
        ( "apr", 3 )
        ( "may", 4 )
        ( "jun", 5 )
        ( "jul", 6 )
        ( "aug", 7 )
        ( "sep", 8 )
        ( "oct", 9 )
        ( "nov", 10 )
        ( "dec", 11 );

// Vegeu llegeix_data_http per detalls
inline time_t tfc_timegm(std::tm & t) {
    bool existia;
    const string tz = portabilitat::getenv("TZ", &existia);
    portabilitat::setenv("TZ", "UTC");
    const time_t r = mktime(&t);
    // Restaurem
    if (existia) {
        portabilitat::setenv("TZ", tz);
    }
    else {
        portabilitat::unsetenv("TZ");
    }
    return r;
}

} // ns anònim

namespace tfc {

string data_http(time_t t) {
    return utils::formata_data(t, FORMAT_HTTP);
}

string data_http() {
    return utils::formata_data(second_clock::universal_time(), FORMAT_HTTP);
}

// La lectura de dates amb Boost Date Time és força complicada per l'aplicació
// de fusos horaris i horaris d'estiu, com que el format de les dates HTTP
// és rígid i molt fàcil d'interpretar he optat per implementar la lectura
// TODO: Utilitzar date time si m'aclaro
time_t llegeix_data_http(const string & s) throw (ErrorFormatDataIncorrecte) {
    const bool es_rfc822 = boost::regex_match(s, RE_RFC822),
               es_rfc850 = boost::regex_match(s, RE_RFC850),
               es_asctime = boost::regex_match(s, RE_ASCTIME);

    if (!es_rfc822 && !es_rfc850 && !es_asctime) {
        throw ErrorFormatDataIncorrecte();
    }
    string dia_sem, dia_mes, mes, any, hora, minut, segon;
    void (*implementacio)(const string&,string&,string&,string&,string&,string&,string&,string&);
    if (es_rfc822) {
        implementacio = extreu_rfc822;
    }
    else if (es_rfc850) {
        implementacio = extreu_rfc850;
    }
    else {
        assert( es_asctime );
        implementacio = extreu_asctime;
    }
    implementacio(s, dia_sem, dia_mes, mes, any, hora, minut, segon);
    assert( any.length() == 4 ); // Any amb 4 xifres sempre

    const auto it_mes = MESOS.find(to_lower_copy(mes));
    const auto it_dsem = DIES_SETMANA.find(to_lower_copy(dia_sem));
    if (it_mes == MESOS.end() || it_dsem == DIES_SETMANA.end()) {
        throw ErrorFormatDataIncorrecte();
    }
    // mktime considera que el tm que rep està en temps local, no universal
    // en UNIX hi ha timegm que el considera universal, però no és portable
    // (http://www.gnu.org/software/libc/manual/html_node/Broken_002ddown-Time.html)
    // L'alternativa portable és canviar la variable d'entorn TZ a UTC abans de cridar mktime
    std::tm t = { 0 };
    t.tm_sec = lexical_cast<int>(segon);
    t.tm_min = lexical_cast<int>(minut);
    t.tm_hour = lexical_cast<int>(hora);
    t.tm_mday = lexical_cast<int>(dia_mes);
    t.tm_mon = it_mes->second;
    t.tm_year = lexical_cast<int>(any) - 1900; // Anys desde 1900!
    t.tm_wday = it_dsem->second;
    // tm_yday <- ignorat
    t.tm_isdst = 0; // UTC <-> Mai DST

    return tfc_timegm(t);
}

} // ns tfc

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