unicode.c

 
#include <winpr/config.h>
#include <winpr/assert.h>
 
#include <errno.h>
#include <wctype.h>
 
#include <winpr/crt.h>
#include <winpr/error.h>
#include <winpr/print.h>
 
#ifndef _WIN32
 
#include "unicode.h"
 
#if !defined(WITH_WINPR_DEPRECATED)
static
#endif
    int
    MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte,
                        LPWSTR lpWideCharStr, int cchWideChar)
{
  return int_MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr, cbMultiByte, lpWideCharStr,
                                 cchWideChar);
}
 
#if !defined(WITH_WINPR_DEPRECATED)
static
#endif
    int
    WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar,
                        LPSTR lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar,
                        LPBOOL lpUsedDefaultChar)
{
  return int_WideCharToMultiByte(CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr,
                                 cbMultiByte, lpDefaultChar, lpUsedDefaultChar);
}
 
#endif
 
#if defined(WITH_WINPR_DEPRECATED)
int ConvertToUnicode(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte,
                     LPWSTR* lpWideCharStr, int cchWideChar)
{
  int status = 0;
  BOOL allocate = FALSE;
 
  if (!lpMultiByteStr)
    return 0;
 
  if (!lpWideCharStr)
    return 0;
 
  if (cbMultiByte == -1)
  {
    size_t len = strnlen(lpMultiByteStr, INT_MAX);
    if (len >= INT_MAX)
      return 0;
    cbMultiByte = (int)(len + 1);
  }
 
  if (cchWideChar == 0)
  {
    cchWideChar =
        MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr, cbMultiByte, nullptr, 0);
    allocate = TRUE;
  }
  else if (!(*lpWideCharStr))
    allocate = TRUE;
 
  if (cchWideChar < 1)
    return 0;
 
  if (allocate)
  {
    *lpWideCharStr = (LPWSTR)calloc((size_t)cchWideChar + 1ull, sizeof(WCHAR));
 
    if (!(*lpWideCharStr))
    {
      // SetLastError(ERROR_INSUFFICIENT_BUFFER);
      return 0;
    }
  }
 
  status = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr, cbMultiByte, *lpWideCharStr,
                               cchWideChar);
 
  if (status != cchWideChar)
  {
    if (allocate)
    {
      free(*lpWideCharStr);
      *lpWideCharStr = nullptr;
      status = 0;
    }
  }
 
  return status;
}
#endif
 
#if defined(WITH_WINPR_DEPRECATED)
int ConvertFromUnicode(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar,
                       LPSTR* lpMultiByteStr, int cbMultiByte, LPCSTR lpDefaultChar,
                       LPBOOL lpUsedDefaultChar)
{
  int status = 0;
  BOOL allocate = FALSE;
 
  if (!lpWideCharStr)
    return 0;
 
  if (!lpMultiByteStr)
    return 0;
 
  if (cchWideChar == -1)
    cchWideChar = (int)(_wcslen(lpWideCharStr) + 1);
 
  if (cbMultiByte == 0)
  {
    cbMultiByte = WideCharToMultiByte(CodePage, dwFlags, lpWideCharStr, cchWideChar, nullptr, 0,
                                      nullptr, nullptr);
    allocate = TRUE;
  }
  else if (!(*lpMultiByteStr))
    allocate = TRUE;
 
  if (cbMultiByte < 1)
    return 0;
 
  if (allocate)
  {
    *lpMultiByteStr = (LPSTR)calloc(1, (size_t)cbMultiByte + 1ull);
 
    if (!(*lpMultiByteStr))
    {
      // SetLastError(ERROR_INSUFFICIENT_BUFFER);
      return 0;
    }
  }
 
  status = WideCharToMultiByte(CodePage, dwFlags, lpWideCharStr, cchWideChar, *lpMultiByteStr,
                               cbMultiByte, lpDefaultChar, lpUsedDefaultChar);
 
  if ((status != cbMultiByte) && allocate)
  {
    status = 0;
  }
 
  if ((status <= 0) && allocate)
  {
    free(*lpMultiByteStr);
    *lpMultiByteStr = nullptr;
  }
 
  return status;
}
#endif
 
const WCHAR* ByteSwapUnicode(WCHAR* wstr, size_t length)
{
  WINPR_ASSERT(wstr || (length == 0));
 
  for (size_t x = 0; x < length; x++)
    wstr[x] = _byteswap_ushort(wstr[x]);
  return wstr;
}
 
SSIZE_T ConvertWCharToUtf8(const WCHAR* wstr, char* str, size_t len)
{
  if (!wstr)
  {
    if (str && len)
      str[0] = 0;
    return 0;
  }
 
  const size_t wlen = _wcslen(wstr);
  return ConvertWCharNToUtf8(wstr, wlen + 1, str, len);
}
 
SSIZE_T ConvertWCharNToUtf8(const WCHAR* wstr, size_t wlen, char* str, size_t len)
{
  BOOL isNullTerminated = FALSE;
  if (wlen == 0)
    return 0;
 
  WINPR_ASSERT(wstr);
  size_t iwlen = _wcsnlen(wstr, wlen);
 
  if ((len > INT32_MAX) || (wlen > INT32_MAX))
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return -1;
  }
 
  if (iwlen < wlen)
  {
    isNullTerminated = TRUE;
    iwlen++;
  }
  const int rc =
      WideCharToMultiByte(CP_UTF8, 0, wstr, (int)iwlen, str, (int)len, nullptr, nullptr);
  if ((rc <= 0) || ((len > 0) && ((size_t)rc > len)))
    return -1;
  else if (!isNullTerminated)
  {
    if (str && ((size_t)rc < len))
      str[rc] = '\0';
    return rc;
  }
  else if ((size_t)rc == len)
  {
    if (str && (str[rc - 1] != '\0'))
      return rc;
  }
  return rc - 1;
}
 
SSIZE_T ConvertMszWCharNToUtf8(const WCHAR* wstr, size_t wlen, char* str, size_t len)
{
  if (wlen == 0)
    return 0;
 
  WINPR_ASSERT(wstr);
 
  if ((len > INT32_MAX) || (wlen > INT32_MAX))
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return -1;
  }
 
  const int iwlen = (int)len;
  const int rc = WideCharToMultiByte(CP_UTF8, 0, wstr, (int)wlen, str, iwlen, nullptr, nullptr);
  if ((rc <= 0) || ((len > 0) && (rc > iwlen)))
    return -1;
 
  return rc;
}
 
SSIZE_T ConvertUtf8ToWChar(const char* str, WCHAR* wstr, size_t wlen)
{
  if (!str)
  {
    if (wstr && wlen)
      wstr[0] = 0;
    return 0;
  }
 
  const size_t len = strlen(str);
  return ConvertUtf8NToWChar(str, len + 1, wstr, wlen);
}
 
SSIZE_T ConvertUtf8NToWChar(const char* str, size_t len, WCHAR* wstr, size_t wlen)
{
  size_t ilen = strnlen(str, len);
  BOOL isNullTerminated = FALSE;
  if (len == 0)
    return 0;
 
  WINPR_ASSERT(str);
 
  if ((len > INT32_MAX) || (wlen > INT32_MAX))
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return -1;
  }
  if (ilen < len)
  {
    isNullTerminated = TRUE;
    ilen++;
  }
 
  const int iwlen = (int)wlen;
  const int rc = MultiByteToWideChar(CP_UTF8, 0, str, (int)ilen, wstr, iwlen);
  if ((rc <= 0) || ((wlen > 0) && (rc > iwlen)))
    return -1;
  if (!isNullTerminated)
  {
    if (wstr && (rc < iwlen))
      wstr[rc] = '\0';
    return rc;
  }
  else if (rc == iwlen)
  {
    if (wstr && (wstr[rc - 1] != '\0'))
      return rc;
  }
  return rc - 1;
}
 
SSIZE_T ConvertMszUtf8NToWChar(const char* str, size_t len, WCHAR* wstr, size_t wlen)
{
  if (len == 0)
    return 0;
 
  WINPR_ASSERT(str);
 
  if ((len > INT32_MAX) || (wlen > INT32_MAX))
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return -1;
  }
 
  const int iwlen = (int)wlen;
  const int rc = MultiByteToWideChar(CP_UTF8, 0, str, (int)len, wstr, iwlen);
  if ((rc <= 0) || ((wlen > 0) && (rc > iwlen)))
    return -1;
 
  return rc;
}
 
char* ConvertWCharToUtf8Alloc(const WCHAR* wstr, size_t* pUtfCharLength)
{
  char* tmp = nullptr;
  const SSIZE_T rc = ConvertWCharToUtf8(wstr, nullptr, 0);
  if (pUtfCharLength)
    *pUtfCharLength = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(char));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertWCharToUtf8(wstr, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pUtfCharLength)
    *pUtfCharLength = (size_t)rc2;
  return tmp;
}
 
char* ConvertWCharNToUtf8Alloc(const WCHAR* wstr, size_t wlen, size_t* pUtfCharLength)
{
  char* tmp = nullptr;
  const SSIZE_T rc = ConvertWCharNToUtf8(wstr, wlen, nullptr, 0);
 
  if (pUtfCharLength)
    *pUtfCharLength = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(char));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertWCharNToUtf8(wstr, wlen, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pUtfCharLength)
    *pUtfCharLength = (size_t)rc2;
  return tmp;
}
 
char* ConvertMszWCharNToUtf8Alloc(const WCHAR* wstr, size_t wlen, size_t* pUtfCharLength)
{
  char* tmp = nullptr;
  const SSIZE_T rc = ConvertMszWCharNToUtf8(wstr, wlen, nullptr, 0);
 
  if (pUtfCharLength)
    *pUtfCharLength = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(char));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertMszWCharNToUtf8(wstr, wlen, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pUtfCharLength)
    *pUtfCharLength = (size_t)rc2;
  return tmp;
}
 
WCHAR* ConvertUtf8ToWCharAlloc(const char* str, size_t* pSize)
{
  WCHAR* tmp = nullptr;
  const SSIZE_T rc = ConvertUtf8ToWChar(str, nullptr, 0);
  if (pSize)
    *pSize = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(WCHAR));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertUtf8ToWChar(str, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pSize)
    *pSize = (size_t)rc2;
  return tmp;
}
 
WCHAR* ConvertUtf8NToWCharAlloc(const char* str, size_t len, size_t* pSize)
{
  WCHAR* tmp = nullptr;
  const SSIZE_T rc = ConvertUtf8NToWChar(str, len, nullptr, 0);
  if (pSize)
    *pSize = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(WCHAR));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertUtf8NToWChar(str, len, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pSize)
    *pSize = (size_t)rc2;
  return tmp;
}
 
WCHAR* ConvertMszUtf8NToWCharAlloc(const char* str, size_t len, size_t* pSize)
{
  WCHAR* tmp = nullptr;
  const SSIZE_T rc = ConvertMszUtf8NToWChar(str, len, nullptr, 0);
  if (pSize)
    *pSize = 0;
  if (rc < 0)
    return nullptr;
  tmp = calloc((size_t)rc + 1ull, sizeof(WCHAR));
  if (!tmp)
    return nullptr;
  const SSIZE_T rc2 = ConvertMszUtf8NToWChar(str, len, tmp, (size_t)rc + 1ull);
  if (rc2 < 0)
  {
    free(tmp);
    return nullptr;
  }
  WINPR_ASSERT(rc == rc2);
  if (pSize)
    *pSize = (size_t)rc2;
  return tmp;
}