1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
// OpenVPN -- An application to securely tunnel IP networks
// over a single port, with support for SSL/TLS-based
// session authentication and key exchange,
// packet encryption, packet authentication, and
// packet compression.
//
// Copyright (C) 2012- OpenVPN Inc.
//
// SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
#pragma once
#ifdef _WIN32
#include <string>
#include <vector>
#include <memory>
namespace openvpn::wstring {
/**
* @brief Convert a UTF-8 string to UTF-16
*
* @param str The UTF-8 string to be converted
* @return std::wstring The converted UTF-16 string
*/
inline std::wstring from_utf8(const std::string &str)
{
std::wstring wStr; // enable RVO
if (str.empty())
return wStr;
const int str_size = static_cast<int>(str.size());
const auto reqSize = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, nullptr, 0);
if (reqSize == 0)
throw std::runtime_error("MultiByteToWideChar(1) failed with code: [" + std::to_string(::GetLastError()) + "]");
wStr.resize(reqSize, L'\0'); // Allocate space
if (::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, wStr.data(), reqSize) == 0)
throw std::runtime_error("MultiByteToWideChar(2) failed with code: [" + std::to_string(::GetLastError()) + "]");
return wStr;
}
/**
* @brief Convert a UTF-16 string to UTF-8
*
* @param wstr The UTF-16 string to be converted
* @return std::string The converted UTF-8 string
*/
inline std::string to_utf8(const std::wstring &wstr)
{
std::string str; // For RVO
if (wstr.empty())
return str;
const int wstr_size = static_cast<int>(wstr.size());
const auto reqSize = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, nullptr, 0, nullptr, nullptr);
if (reqSize == 0)
throw std::runtime_error("WideCharToMultiByte(1) failed with code: [" + std::to_string(::GetLastError()) + "]");
str.resize(reqSize, '\0'); // Allocate space
if (::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, str.data(), reqSize, nullptr, nullptr) == 0)
throw std::runtime_error("WideCharToMultiByte(2) failed with code: [" + std::to_string(::GetLastError()) + "]");
return str;
}
/**
* @brief Split a wide character string into a C array of it's letters
*
* @param wstr The wide string to be split
* @return std::unique_ptr<wchar_t[]> Smart pointer to the generated array
*/
inline std::unique_ptr<wchar_t[]> to_wchar_t(const std::wstring &wstr)
{
const size_t len = wstr.length();
std::unique_ptr<wchar_t[]> ret(new wchar_t[len + 1]);
size_t i;
for (i = 0; i < len; ++i)
ret[i] = wstr[i];
ret[i] = L'\0';
return ret;
}
/**
* @brief Convert a UTF-8 string vector to a UTF-16 MULTI_SZ string
*
* MULTI_SZ is a format used in the Windows Registry. It's a buffer
* containing multiple NUL terminated strings concatenated with each
* other, with an extra NUL at the end to signal termination of the
* MULTI_SZ string itself.
*
* @param strvec The vector of strings to convert
* @return std::wstring The converted MULTI_SZ string
*/
inline std::wstring pack_string_vector(const std::vector<std::string> &strvec)
{
if (strvec.empty())
{
return std::wstring(2, L'\0'); // empty MULTI_SZ
}
std::wstring ret;
for (auto &s : strvec)
{
ret += from_utf8(s);
ret += L'\0';
}
ret += L'\0';
return ret;
}
#endif // #ifdef _WIN32
}
|
