util.h

Go to the documentation of this file.

 
 
#ifndef PSTSDK_UTIL_UTIL_H
#define PSTSDK_UTIL_UTIL_H
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <time.h>
#include <memory>
#include <string>
#include <vector>
#include <boost/utility.hpp>
 
#include "pstsdk/util/errors.h"
#include "pstsdk/util/primitives.h"
 
#if defined(_WIN32) || defined(__MINGW32__)
#define NOMINMAX
#include <windows.h>
#endif
 
#ifdef _MSC_VER
#include <share.h>
#endif
 
namespace pstsdk
{
 
class file : private boost::noncopyable
{
public:
    // TODO
    file() {
        m_pfile = nullptr;
        m_filename = L"";
    }
 
    file(const std::wstring& filename, bool writable = false);
    
    ~file();
 
    virtual size_t read(std::vector<byte>& buffer, ulonglong offset) const;
 
 
    virtual size_t write(const std::vector<byte>& buffer, ulonglong offset);
 
private:
    std::wstring m_filename;    
    FILE * m_pfile;             
};
 
 
time_t filetime_to_time_t(ulonglong filetime);
 
ulonglong time_t_to_filetime(time_t time);
 
time_t vt_date_to_time_t(double vt_time);
 
double time_t_to_vt_date(time_t time);
 
bool test_bit(const byte* pbytes, ulong bit);
 
std::string bytes_to_string(const std::vector<byte> &bytes);
 
std::wstring bytes_to_wstring(const std::vector<byte> &bytes);
 
std::vector<byte> wstring_to_bytes(const std::wstring &wstr);
 
} // end pstsdk namespace
 
inline pstsdk::file::file(const std::wstring& filename, bool writable)
: m_filename(filename)
{
    // "r+b" rather than "w+b": every write in this library is an in-place edit of
    // an existing store, so truncating on open would destroy it.
    const char* mode = writable ? "r+b" : "rb";
 
#ifdef _MSC_VER
    // not fopen_s: it opens exclusively, so a second handle on the same store
    // fails, and both this library and its callers open one store more than once
    m_pfile = _fsopen(std::string(filename.begin(), filename.end()).c_str(), mode, _SH_DENYNO);
#else
    m_pfile = fopen(std::string(filename.begin(), filename.end()).c_str(), mode);
#endif
    if(m_pfile == NULL)
        throw std::runtime_error("fopen failed");
}
 
inline pstsdk::file::~file()
{
    if (!m_pfile) return;
    fflush(m_pfile);
    fclose(m_pfile);
}
 
inline size_t pstsdk::file::read(std::vector<byte>& buffer, ulonglong offset) const
{
#ifdef _MSC_VER
    if(_fseeki64(m_pfile, offset, SEEK_SET) != 0)
#else
    if(fseek(m_pfile, offset, SEEK_SET) != 0)
#endif
    {
        throw std::out_of_range("fseek failed");
    }
 
    size_t read = fread(&buffer[0], 1, buffer.size(), m_pfile);
 
    if(read != buffer.size())
        throw std::out_of_range("fread failed");
 
    return read;
}
 
inline size_t pstsdk::file::write(const std::vector<byte>& buffer, ulonglong offset)
{
#ifdef _MSC_VER
    if(_fseeki64(m_pfile, offset, SEEK_SET) != 0)
#else
    if(fseek(m_pfile, offset, SEEK_SET) != 0)
#endif
    {
        throw std::out_of_range("fseek failed");
    }
 
    size_t write = fwrite(&buffer[0], 1, buffer.size(), m_pfile);
 
    if(write != buffer.size())
        throw std::out_of_range("fwrite failed");
 
    // another handle on this file has its own buffer, and on Windows those are
    // not coherent with this one until the bytes actually land
    fflush(m_pfile);
 
    return write;
}
 
inline time_t pstsdk::filetime_to_time_t(ulonglong filetime)
{
    const ulonglong jan1970 = 116444736000000000ULL;
 
    return (filetime - jan1970) / 10000000;
}
 
inline pstsdk::ulonglong pstsdk::time_t_to_filetime(time_t time)
{
    const ulonglong jan1970 = 116444736000000000ULL;
 
    return (time * 10000000) + jan1970;
}
 
inline time_t pstsdk::vt_date_to_time_t(double)
{
    throw not_implemented("vt_date_to_time_t");
}
 
inline double pstsdk::time_t_to_vt_date(time_t)
{
    throw not_implemented("vt_date_to_time_t");
}
 
inline bool pstsdk::test_bit(const byte* pbytes, ulong bit)
{
    return (*(pbytes + (bit >> 3)) & (0x80 >> (bit & 7))) != 0;
}
 
#if defined(_WIN32) || defined(__MINGW32__)
 
// We know that std::wstring is always UCS-2LE on Windows.
 
inline std::wstring pstsdk::bytes_to_wstring(const std::vector<byte> &bytes)
{
    if(bytes.size() == 0)
        return std::wstring();
 
    return std::wstring(reinterpret_cast<const wchar_t *>(&bytes[0]), bytes.size()/sizeof(wchar_t));
}
 
inline std::vector<pstsdk::byte> pstsdk::wstring_to_bytes(const std::wstring &wstr)
{
    if(wstr.size() == 0)
        return std::vector<byte>();
 
    const byte *begin = reinterpret_cast<const byte *>(&wstr[0]);
    return std::vector<byte>(begin, begin + wstr.size()*sizeof(wchar_t));
}
 
// Assume UCS-2LE, use WideCharToMultiByte to support pre Win 10
inline std::string pstsdk::bytes_to_string(const std::vector<byte> &bytes)
{
    // Do the wstr cast and use c_str to avoid any issues stemming from null terminator
    std::wstring ws = bytes_to_wstring(bytes);
    size_t utf8_sz = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), NULL, 0, NULL, NULL);
 
    std::vector<char> utf8_str(utf8_sz);
    size_t copied = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), &utf8_str.data()[0], utf8_sz, NULL, NULL);
 
    if (copied != utf8_sz)
        throw std::runtime_error("Expected to copy " + std::to_string(utf8_sz) + " bytes but copied " + std::to_string(copied));
 
    return { utf8_str.begin(), utf8_str.end() };
}
 
#else // !(defined(_WIN32) || defined(__MINGW32__))
 
// We're going to have to do this the hard way, since we don't know how
// big wchar_t really is, or what encoding it uses.
#include <iconv.h>
 
// Not "WCHAR_T": libiconv implements that through the platform's mbrtowc, so
// on macOS it follows LC_CTYPE and rejects anything outside it. Under the C
// locale a right single quote comes back EILSEQ. glibc hardwires WCHAR_T to
// UCS-4 and never showed this. Both libraries take a fixed width name, and
// every platform reaching this branch is little endian with a 4 byte wchar_t.
static_assert(sizeof(wchar_t) == 4, "expected a 4 byte wchar_t off Windows");
#define PSTSDK_WCHAR_ENCODING "UTF-32LE"
 
inline std::wstring pstsdk::bytes_to_wstring(const std::vector<byte> &bytes)
{
    if(bytes.size() == 0)
        return std::wstring();
 
    // Up to one wchar_t for every 2 bytes, if there are no surrogate pairs.
    if(bytes.size() % 2 != 0)
        throw std::runtime_error("Cannot interpret odd number of bytes as UTF-16LE");
    std::wstring out(bytes.size() / 2, L'\0');
 
    iconv_t cd(::iconv_open(PSTSDK_WCHAR_ENCODING, "UTF-16LE"));
    if(cd == (iconv_t)(-1)) {
        perror("bytes_to_wstring");
        throw std::runtime_error("Unable to convert from UTF-16LE to wstring");
    }
 
    const char *inbuf = reinterpret_cast<const char *>(&bytes[0]);
    size_t inbytesleft = bytes.size();
    char *outbuf = reinterpret_cast<char *>(&out[0]);
    size_t outbytesleft = out.size() * sizeof(wchar_t);
    size_t result = ::iconv(cd, const_cast<char **>(&inbuf), &inbytesleft, &outbuf, &outbytesleft);
    const int err = errno;
    ::iconv_close(cd);
    if(result == (size_t)(-1) || inbytesleft > 0 || outbytesleft % sizeof(wchar_t) != 0)
        throw std::runtime_error("Failed to convert from UTF-16LE to wstring: "
            + std::string(std::strerror(err)) + ", "
            + std::to_string(inbytesleft) + " of "
            + std::to_string(bytes.size()) + " bytes left");
 
    out.resize(out.size() - (outbytesleft / sizeof(wchar_t)));
    return out;
}
 
// Allows reading wstring props directly into std::string for non-Windows
inline std::string pstsdk::bytes_to_string(const std::vector<byte> &bytes)
{
    if(bytes.size() == 0)
        return std::string();
 
    // Up to one wchar_t for every 2 bytes, if there are no surrogate pairs.
    if(bytes.size() % 2 != 0)
        throw std::runtime_error("Cannot interpret odd number of bytes as UTF-16LE");
 
    // Up to 4 bytes out per char
    std::string out(bytes.size() * 2, L'\0');
 
    iconv_t cd(::iconv_open("UTF-8", "UTF-16LE"));
    if(cd == (iconv_t)(-1)) {
        perror("bytes_to_string");
        throw std::runtime_error("Unable to convert from UTF-16LE to string");
    }
 
    const char *inbuf = reinterpret_cast<const char *>(&bytes[0]);
    size_t inbytesleft = bytes.size();
    char *outbuf = reinterpret_cast<char *>(&out[0]);
    size_t outbytesleft = out.size();
    size_t result = ::iconv(cd, const_cast<char **>(&inbuf), &inbytesleft, &outbuf, &outbytesleft);
    ::iconv_close(cd);
 
    if(result == (size_t)(-1) || inbytesleft > 0)
        throw std::runtime_error("Failed to convert from UTF-16LE to string");
 
    out.resize(out.size() - outbytesleft);
 
    return out;
}
 
inline std::vector<pstsdk::byte> pstsdk::wstring_to_bytes(const std::wstring &wstr)
{
    if(wstr.size() == 0)
        return std::vector<byte>();
 
    // Up to 4 bytes per character if all codepoints are surrogate pairs.
    std::vector<byte> out(wstr.size() * 4);
 
    iconv_t cd(::iconv_open("UTF-16LE", PSTSDK_WCHAR_ENCODING));
    if(cd == (iconv_t)(-1)) {
        perror("wstring_to_bytes");
        throw std::runtime_error("Unable to convert from wstring to UTF-16LE");
    }
 
    const char *inbuf = reinterpret_cast<const char *>(&wstr[0]);
    size_t inbytesleft = wstr.size() * sizeof(wchar_t);
    char *outbuf = reinterpret_cast<char *>(&out[0]);
    size_t outbytesleft = out.size();
    size_t result = ::iconv(cd, const_cast<char **>(&inbuf), &inbytesleft, &outbuf, &outbytesleft);
    ::iconv_close(cd);
    if(result == (size_t)(-1) || inbytesleft > 0)
        throw std::runtime_error("Failed to convert from wstring to UTF-16LE");
 
    out.resize(out.size() - outbytesleft);
    return out;
}
 
#endif // !(defined(_WIN32) || defined(__MINGW32__))
 
#endif