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

#include <cstdlib>
#include <iostream>
#include <string>
#include <boost/algorithm/string.hpp>
#include <boost/scoped_array.hpp>
#include <boost/thread.hpp>

using boost::algorithm::to_lower_copy;
namespace fs = boost::filesystem;

/*
 * Sortida UTF-8 a la consola a Windows
 *
 * No ho he aconseguit. Mètodes provats:
 * - Canviar la pàgina de codis de la consola
 *   Codis de pàgina: http://msdn.microsoft.com/en-us/library/dd317756(VS.85).aspx
 *   GetConsoleOutputCP: http://msdn.microsoft.com/en-us/library/ms683169(VS.85).aspx
 *   SetConsoleOutputCP: http://msdn.microsoft.com/en-us/library/ms686036(VS.85).aspx
 * - Canvi de mode de la consolaa UTF-8 o UTF-16
 *   http://blogs.msdn.com/b/michkap/archive/2008/03/18/8306597.aspx
 *   _setmode: http://msdn.microsoft.com/library/tw4k6df8(VS.80).aspx
 */

#ifdef _WIN32
#   include <windows.h>
#   include <fcntl.h>
#   include <io.h>
#   include <stdio.h>
#   define _CRT_SECURE_NO_WARNINGS // Sembla que no funciona
#   ifdef _MSC_VER
#      pragma warning( disable: 4996 ) // Warning associat a funcions insegures
#   endif
#endif

#undef TFC_CANVI_DE_PAGINA
#undef TFC_CANVI_DE_MODE

namespace {
#ifdef _WIN32

#   ifdef TFC_CANVI_DE_PAGINA
UINT codepage_inicial;
#   endif

#if 0
// Conversió UTF-8 a wstr. A prop, però no funciona bé
std::wstring utf_a_wstr(const std::string& s)
{
    const int slength = (int)s.length() + 1;
    const int len = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), slength, 0, 0); 
    wchar_t * buf = 0;
    try {
        buf = new wchar_t[len];
        MultiByteToWideChar(CP_UTF8, 0, s.c_str(), slength, buf, len);
        std::wstring r(buf);
        delete[] buf;
        return r;
    }
    catch (...) {
        delete [] buf;
    }
}
#endif

inline void canvia_consola_a_utf8() {
#   ifdef TFC_CANVI_DE_PAGINA
    codepage_inicial = ::GetConsoleOutputCP();
    ::SetConsoleOutputCP(CP_UTF8);
#   endif
#   ifdef TFC_CANVI_DE_MODE
    _setmode(_fileno(stdout), _O_U8TEXT);
    _setmode(_fileno(stderr), _O_U8TEXT);
#   endif
}

void restaura_consola() {
#   ifdef TFC_CANVI_DE_PAGINA
    // Restaura el codi de pàgina
    ::SetConsoleOutputCP(codepage_inicial);
#   endif
}
#else /* ! WIN32 */
#   define canvia_consola_a_utf8() /* res */
#   define restaura_consola() /* res */
#endif

void exit_callback() {
    restaura_consola();
}

} // ns anònim

// Només glibc >= 2.1 garantitza que es puguin fer servir
// getenv i familia en programes multi-fil de forma segura
// http://www.delorie.com/gnu/docs/glibc/libc_554.html
boost::mutex env_mtx;

namespace tfc {

namespace portabilitat {

using namespace std;

void init() {
    std::atexit(exit_callback);
    canvia_consola_a_utf8();
    ::setlocale(LC_TIME, "C"); // XXX: Necessari?
}

// https://www.securecoding.cert.org/confluence/plugins/viewsource/viewpagesrc.action?pageId=1703960
// "
// The C standard says getenv() has the following behavior [ISO/IEC 9899:2011]:
// The getenv function returns a pointer to a string associated with the matched
// list member. The string pointed to shall not be modified by the program but may
// be overwritten by a subsequent call to the getenv function.
// "

//

string getenv(const string & var, bool * existeix) {
    boost::unique_lock<boost::mutex> lock(env_mtx);
#if 0
    // Codi (teòricament) més robust per a Windows
    // getenv_s només està definida en versions recents d'stdlib.h.
    //
    // Amb MSVC 2010/2011 no hi ha problema, però amb Mingw sí ja que només
    // fa servir msvcrt.dll per defecte.
    // És possible enllaçar a versions que incloguin les versions *_s (p.e. -lmsvcr80)
    // però he considerat que no val la pena perquè, estrictament parlant, la seguretat
    // que aporta getenv_s no és gaire; només evita que crides consecutives
    // re-escriguin el buffer, però no és "thread-safe" i igualment cal serialitzar
    // les crides, per això n'hi ha prou amb blocar i copiar el buffer immediatament.
    //
    // http://msdn.microsoft.com/en-us/library/tehxacec.aspx
    // http://msdn.microsoft.com/en-us/library/tb2sfw2z.aspx
    size_t bufsize;
    ::getenv_s(&bufsize, NULL, 0, var.c_str());
    if (0 == bufsize) { // No existeix
        if (0 != existeix) {
            *existeix = false;
        }
        return string();
    }
    if (0 != existeix) {
        *existeix = true;
    }

    boost::scoped_array<char> val(new char[bufsize]);
    ::getenv_s(&bufsize, val.get(), bufsize, val.get());
    return string(val.get());
#endif // Codi mort: getenv_s() (Windows)
    const char * val = std::getenv(var.c_str());
    if (0 != existeix) {
        *existeix = ( 0 != val );
    }
    if (0 == val) {
        return string();
    }
    return string(val);
}

bool setenv(const string & var, const string & valor) {
    boost::unique_lock<boost::mutex> lock(env_mtx);
#if defined(_WIN32)
    // Vegeu el bloc intern de comentaris de getenv() a sobre
    // http://msdn.microsoft.com/en-us/library/83zh4e6k.aspx
    // http://msdn.microsoft.com/en-us/library/eyw7eyfw.aspx
    //const errno_t ret = ::_putenv_s(var.c_str(), valor.c_str());
    // _putenv() espera VARIABLE=VALOR concatenades
    const string cat(var.c_str()+string("=")+valor.c_str());
    const int ret = ::_putenv(cat.c_str());
#else
#   ifdef HAVE_SETENV
    const int ret = ::setenv(var.c_str(), valor.c_str(), 1);
//   elif defined(HAVE_SETENV)
    // !! putenv associa l'string a l'entorn de manera permanent, per
    //    tant s'ha de mantenir en memòria fins què es canvii.
    //    Per simplicitat no s'implementa el seu ús ja que les plataformes
    //    principals tenen setenv.
#   else
#       error Cap forma suportada de modificar l`entorn
#   endif // setenv/putenv
#endif // Windows / POSIX
    return 0 == ret;
}

bool unsetenv(const string & var) {
#if defined(_WIN32)
    // En Windows es fa servir la cadena buida
    // http://msdn.microsoft.com/en-us/library/eyw7eyfw.aspx
    return portabilitat::setenv(var, "");
#else
#   ifdef HAVE_UNSETENV
    boost::unique_lock<boost::mutex> lock(env_mtx);
    const int ret = ::unsetenv(var.c_str());
    return 0 == ret;
#   else
#       error Cap forma suportada de modificar l`entorn
#   endif
#endif
}

string ruta_temporal() throw (runtime_error) {
    string d;
#ifdef _WIN32
    static const string MISSATGE_ERROR("Error obtenint el directori temporal");
    // http://msdn.microsoft.com/en-us/library/aa364992(v=vs.85).aspx
    // Mingw rebutja passar "" directament a GetTempPath (com a l'exemple de l'MSDN)
    DWORD buflen = ::GetTempPath(0, const_cast<LPSTR>(""));
    if (0 == buflen) {
        throw runtime_error(MISSATGE_ERROR);
    }
    vector<char> buf(buflen);
    buflen = ::GetTempPath(static_cast<DWORD>(buf.size()), &buf[0]);
    if (0 == buflen || buf.size() < buflen) {
        throw runtime_error(MISSATGE_ERROR);
    }
    d.assign(buf.begin(), buf.begin()+buflen);
#else
    // tempnam() (desaconsellat)
    // fa servir, en ordre: TMPDIR, P_tmpdir, "/tmp"
    // http://www.delorie.com/gnu/docs/glibc/libc_295.html#IDX1612
    bool existeix;
    d = getenv("TMPDIR", &existeix);
    if (!existeix) {
#       ifdef P_tmpdir
        d = P_tmpdir;
#       endif
        if (d.empty()) {
            d = "/tmp";
        }
    }
#endif
    return d;
}

shared_ptr<ofstream> fitxer_temporal(const string & patro, string & nom, const string & dir)
                                                                        throw (runtime_error) {
    static const string MISSATGE_ERROR("Error en crear fitxer temporal");
#ifdef _WIN32
    // http://msdn.microsoft.com/en-us/library/aa363875%28VS.85%29.aspx
    // Nom de directori temporal (race condition?)
    // MSDN: "This buffer should be MAX_PATH characters to accommodate the path
    //        plus the terminating null character."
    // Una alternativa passaria per utilitzar UuidCreate()
    char buffer[MAX_PATH];
    UINT ret = ::GetTempFileName(dir.c_str(), patro.c_str(), 0, buffer);
    if (ret == 0) {
        throw runtime_error(MISSATGE_ERROR);
    }
    nom.assign(buffer, buffer+ret);
    shared_ptr<ofstream> pofs(new ofstream(nom.c_str(), ios::out|ios::binary));
#else
#   ifdef HAVE_MKSTEMP
    vector<char> buf(dir.begin(), dir.end());
    buf.push_back('/');
    buf.insert(buf.end(), patro.begin(), patro.end());
    // patro ha d'acabar amb 'XXXXXX'
    buf.insert(buf.end(), 6, 'X');
    buf.push_back(0);
    int fd = ::mkstemp(&buf[0]);
    if (-1 == fd) {
        throw runtime_error(&buf[0]);
        throw runtime_error(MISSATGE_ERROR+";1");
    }
    nom.assign(buf.begin(), buf.end());
    // L'obrim com a ofstream...
    shared_ptr<ofstream> pofs(new ofstream(nom.c_str(), ios::out|ios::binary));
    if (pofs->fail()) {
        throw runtime_error(MISSATGE_ERROR+";2");
    }
    // I tanquem el handle tipus C
    ::close(fd);
#   else
#       error Cap forma suportada de crear fitxers temporals
#   endif
#endif
    return pofs;
}

} // ns portabilitat

} // ns tfc

#ifdef _WIN32
#else
#   ifdef HAVE_UNISTD_H
#       include <unistd.h>
#   endif
#   ifdef HAVE_SYS_TYPES_H
#       include <sys/types.h>
#   endif
#   ifdef HAVE_SYS_STAT_H
#      include <sys/stat.h>
#   endif
#endif

namespace tfc {

namespace portabilitat {

// boost::filesystem no exposa els permisos per tenir definicions molt diferents
// segons la plataforma (de fet sí que els exposa però no proveu mètodes per
// comprovar-los contra les credencials de l'usuari)
bool permis_execucio(const fs::path & f) {
    assert( fs::is_regular_file(f) ); // PRECONDICIÓ
#ifdef _WIN32
    // En Windows no hi ha el concepte de permís d'execució però
    // es fa servir l'extensió per definir si es pot executar directament
    if (!f.has_extension()) {
        return false;
    }
    const string ext = to_lower_copy(f.extension().string());
    // Seria millor fer una comprovació més "profunda", per exemple en el
    // cas dels CGIs no és extrany que estiguin escrits en Perl (extensió .pl)
    return (".exe" == ext || ".com" == ext ); // No executables directament: || ".bat" == ext || ".cmd" == ext);
#else
    struct stat st;
    // TODO: acls
    ::stat(f.string().c_str(), &st); // lstat() no segueix symlinks
    if (0 == (st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))) {
        // Cap permís d'execució, no cal continuar
        return false;
    }
    const uid_t euid = ::geteuid();
    const gid_t egid = ::getegid();
    bool permis;
    if (euid == st.st_uid) { // Propietari
        permis = (0 != (S_IXUSR|st.st_mode));
    }
    else if (egid == st.st_gid) { // Grup
        permis = (0 != (S_IXGRP|st.st_mode));
    }
    else { // Ni propietari ni grup
        permis = (0 != (S_IXOTH|st.st_mode));
    }
    return permis;
#endif
}

} // ns portabilitat

} // ns tfc

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