mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed WCHAR constants, use endian safe definitions

Browse Source
This commit is contained in:
Armin Novak 2023-12-12 09:18:30 +01:00 committed by akallabeth
parent 28e5167435
commit 9575f386cd
21 changed files with 276 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
channels/drive/client/drive_file.c
View File

@ -117,7 +117,8 @@ static WCHAR* drive_file_combine_fullpath(const WCHAR* base_path, const WCHAR* p
goto fail;
/* Ensure the path does not contain sequences like '..' */
const WCHAR dotdot[] = { '.', '.', '\0' };
WCHAR dotdotbuffer[6] = { 0 };
const WCHAR* dotdot = InitializeConstWCharFromUtf8("..", dotdotbuffer, ARRAYSIZE(dotdotbuffer));
if (_wcsstr(&fullpath[base_path_length], dotdot))
{
char abuffer[MAX_PATH] = { 0 };

33
channels/drive/client/drive_main.c
View File

@ -439,13 +439,14 @@ static UINT drive_process_irp_set_information(DRIVE_DEVICE* drive, IRP* irp)
*/
static UINT drive_process_irp_query_volume_information(DRIVE_DEVICE* drive, IRP* irp)
{
UINT32 FsInformationClass;
UINT32 FsInformationClass = 0;
wStream* output = NULL;
DWORD lpSectorsPerCluster;
DWORD lpBytesPerSector;
DWORD lpNumberOfFreeClusters;
DWORD lpTotalNumberOfClusters;
WIN32_FILE_ATTRIBUTE_DATA wfad;
DWORD lpSectorsPerCluster = 0;
DWORD lpBytesPerSector = 0;
DWORD lpNumberOfFreeClusters = 0;
DWORD lpTotalNumberOfClusters = 0;
WIN32_FILE_ATTRIBUTE_DATA wfad = { 0 };
WCHAR LabelBuffer[32] = { 0 };
if (!drive || !irp)
return ERROR_INVALID_PARAMETER;
@ -464,8 +465,10 @@ static UINT drive_process_irp_query_volume_information(DRIVE_DEVICE* drive, IRP*
case FileFsVolumeInformation:
{
/* http://msdn.microsoft.com/en-us/library/cc232108.aspx */
const WCHAR volumeLabel[] = { 'F', 'R', 'E', 'E', 'R', 'D', 'P', '\0' };
const size_t length = 17ul + sizeof(volumeLabel);
const WCHAR* volumeLabel =
InitializeConstWCharFromUtf8("FREERDP", LabelBuffer, ARRAYSIZE(LabelBuffer));
const size_t volumeLabelLen = (_wcslen(volumeLabel) + 1) * sizeof(WCHAR);
const size_t length = 17ul + volumeLabelLen;
Stream_Write_UINT32(output, length); /* Length */
@ -480,10 +483,10 @@ static UINT drive_process_irp_query_volume_information(DRIVE_DEVICE* drive, IRP*
Stream_Write_UINT32(output,
wfad.ftCreationTime.dwHighDateTime); /* VolumeCreationTime */
Stream_Write_UINT32(output, lpNumberOfFreeClusters & 0xffff); /* VolumeSerialNumber */
Stream_Write_UINT32(output, sizeof(volumeLabel)); /* VolumeLabelLength */
Stream_Write_UINT32(output, volumeLabelLen); /* VolumeLabelLength */
Stream_Write_UINT8(output, 0); /* SupportsObjects */
/* Reserved(1), MUST NOT be added! */
Stream_Write(output, volumeLabel, sizeof(volumeLabel)); /* VolumeLabel (Unicode) */
Stream_Write(output, volumeLabel, volumeLabelLen); /* VolumeLabel (Unicode) */
}
break;
@ -506,8 +509,10 @@ static UINT drive_process_irp_query_volume_information(DRIVE_DEVICE* drive, IRP*
case FileFsAttributeInformation:
{
/* http://msdn.microsoft.com/en-us/library/cc232101.aspx */
const WCHAR diskType[] = { 'F', 'A', 'T', '3', '2', '\0' };
const size_t length = 12ul + sizeof(diskType);
const WCHAR* diskType =
InitializeConstWCharFromUtf8("FAT32", LabelBuffer, ARRAYSIZE(LabelBuffer));
const size_t diskTypeLen = (wcslen(diskType) + 1) * sizeof(WCHAR);
const size_t length = 12ul + diskTypeLen;
Stream_Write_UINT32(output, length); /* Length */
if (!Stream_EnsureRemainingCapacity(output, length))
@ -519,8 +524,8 @@ static UINT drive_process_irp_query_volume_information(DRIVE_DEVICE* drive, IRP*
Stream_Write_UINT32(output, FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES |
FILE_UNICODE_ON_DISK); /* FileSystemAttributes */
Stream_Write_UINT32(output, MAX_PATH); /* MaximumComponentNameLength */
Stream_Write_UINT32(output, sizeof(diskType)); /* FileSystemNameLength */
Stream_Write(output, diskType, sizeof(diskType)); /* FileSystemName (Unicode) */
Stream_Write_UINT32(output, diskTypeLen); /* FileSystemNameLength */
Stream_Write(output, diskType, diskTypeLen); /* FileSystemName (Unicode) */
}
break;

8
client/common/client_cliprdr_file.c
View File

@ -2230,11 +2230,13 @@ static BOOL add_directory(CliprdrLocalStream* stream, const char* path)
BOOL rc = FALSE;
char* next = NULL;
WCHAR dotbuffer[6] = { 0 };
WCHAR dotdotbuffer[6] = { 0 };
const WCHAR* dot = InitializeConstWCharFromUtf8(".", dotbuffer, ARRAYSIZE(dotbuffer));
const WCHAR* dotdot = InitializeConstWCharFromUtf8("..", dotdotbuffer, ARRAYSIZE(dotdotbuffer));
do
{
const WCHAR dot[] = { '.', '\0' };
const WCHAR dotdot[] = { '.', '.', '\0' };
if (_wcscmp(FindFileData.cFileName, dot) == 0)
continue;
if (_wcscmp(FindFileData.cFileName, dotdot) == 0)

25
libfreerdp/emu/scard/smartcard_emulate.c
View File

@ -37,10 +37,21 @@
#define MAX_CACHE_ITEM_SIZE 4096
#define MAX_CACHE_ITEM_VALUES 4096
static CHAR g_ReaderNameA[] = { 'F', 'r', 'e', 'e', 'R', 'D', 'P', ' ', 'E',
'm', 'u', 'l', 'a', 't', 'o', 'r', '\0', '\0' };
static WCHAR g_ReaderNameW[] = { 'F', 'r', 'e', 'e', 'R', 'D', 'P', ' ', 'E',
'm', 'u', 'l', 'a', 't', 'o', 'r', '\0', '\0' };
static const CHAR g_ReaderNameA[] = { 'F', 'r', 'e', 'e', 'R', 'D', 'P', ' ', 'E',
'm', 'u', 'l', 'a', 't', 'o', 'r', '\0', '\0' };
static INIT_ONCE g_ReaderNameWGuard = INIT_ONCE_STATIC_INIT;
static WCHAR g_ReaderNameW[32] = { 0 };
static size_t g_ReaderNameWLen = 0;
static BOOL CALLBACK g_ReaderNameWInit(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
{
WINPR_UNUSED(InitOnce);
WINPR_UNUSED(Parameter);
WINPR_UNUSED(Context);
InitializeConstWCharFromUtf8(g_ReaderNameA, g_ReaderNameW, ARRAYSIZE(g_ReaderNameW));
g_ReaderNameWLen = _wcsnlen(g_ReaderNameW, ARRAYSIZE(g_ReaderNameW) - 2) + 2;
return TRUE;
}
struct smartcard_emulation_context
{
@ -116,6 +127,7 @@ static BOOL scard_status_transition(SCardContext* context)
memcpy(reader->rgbAtr, ATR, sizeof(ATR));
}
{
InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit, NULL, NULL);
SCARD_READERSTATEW* reader = &context->readerStateW[0];
reader->szReader = g_ReaderNameW;
reader->dwEventState = SCARD_STATE_PRESENT;
@ -574,6 +586,7 @@ LONG WINAPI Emulate_SCardListReadersW(SmartcardEmulationContext* smartcard, SCAR
WINPR_UNUSED(mszGroups); /* Not required */
InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit, NULL, NULL);
if (SCARD_S_SUCCESS == status)
{
SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
@ -585,11 +598,11 @@ LONG WINAPI Emulate_SCardListReadersW(SmartcardEmulationContext* smartcard, SCAR
/* Return length only */
if (!mszReaders)
*pcchReaders = ARRAYSIZE(g_ReaderNameW);
*pcchReaders = g_ReaderNameWLen;
else
{
*pcchReaders = scard_copy_strings(value, mszReaders, *pcchReaders, g_ReaderNameW,
sizeof(g_ReaderNameW)) /
g_ReaderNameWLen * sizeof(WCHAR)) /
sizeof(WCHAR);
}
}

13
winpr/libwinpr/clipboard/synthetic_file.c
View File

@ -200,8 +200,10 @@ static BOOL add_directory_entry_to_list(wClipboard* clipboard, const WCHAR* loca
WCHAR* remote_name = NULL;
WCHAR* remote_base_name = NULL;
const WCHAR dot[2] = { '.', '\0' };
const WCHAR dotdot[3] = { '.', '.', '\0' };
WCHAR dotbuffer[6] = { 0 };
WCHAR dotdotbuffer[6] = { 0 };
const WCHAR* dot = InitializeConstWCharFromUtf8(".", dotbuffer, ARRAYSIZE(dotbuffer));
const WCHAR* dotdot = InitializeConstWCharFromUtf8("..", dotdotbuffer, ARRAYSIZE(dotdotbuffer));
WINPR_ASSERT(clipboard);
WINPR_ASSERT(local_dir_name);
@ -274,7 +276,8 @@ static BOOL add_directory_contents_to_list(wClipboard* clipboard, const WCHAR* l
const WCHAR* remote_name, wArrayList* files)
{
BOOL result = FALSE;
const WCHAR wildcard[] = { '/', '*', '\0' };
const WCHAR* wildcard = "/\0*\0\0\0";
const size_t wildcardLen = 3;
WINPR_ASSERT(clipboard);
WINPR_ASSERT(local_name);
@ -282,12 +285,12 @@ static BOOL add_directory_contents_to_list(wClipboard* clipboard, const WCHAR* l
WINPR_ASSERT(files);
size_t len = _wcslen(local_name);
WCHAR* namebuf = calloc(len + ARRAYSIZE(wildcard), sizeof(WCHAR));
WCHAR* namebuf = calloc(len + wildcardLen, sizeof(WCHAR));
if (!namebuf)
return FALSE;
_wcsncat(namebuf, local_name, len);
_wcsncat(namebuf, wildcard, ARRAYSIZE(wildcard));
_wcsncat(namebuf, wildcard, wildcardLen);
result = do_add_directory_contents_to_list(clipboard, local_name, remote_name, namebuf, files);

69
winpr/libwinpr/crt/test/TestString.c
View File

@ -3,29 +3,29 @@
#include <winpr/crt.h>
#include <winpr/windows.h>
static WCHAR testStringW[] = { 'T', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b',
'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x', ' ', 'j', 'u',
'm', 'p', 's', ' ', 'o', 'v', 'e', 'r', ' ', 't', 'h',
'e', ' ', 'l', 'a', 'z', 'y', ' ', 'd', 'o', 'g', '\0' };
static const CHAR testStringA[] = { 'T', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b',
'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x', ' ', 'j', 'u',
'm', 'p', 's', ' ', 'o', 'v', 'e', 'r', ' ', 't', 'h',
'e', ' ', 'l', 'a', 'z', 'y', ' ', 'd', 'o', 'g', '\0' };
#define testStringW_Length ((sizeof(testStringW) / sizeof(WCHAR)) - 1)
#define testStringA_Length ((sizeof(testStringA) / sizeof(CHAR)) - 1)
static WCHAR testToken1W[] = { 'q', 'u', 'i', 'c', 'k', '\0' };
static WCHAR testToken2W[] = { 'b', 'r', 'o', 'w', 'n', '\0' };
static WCHAR testToken3W[] = { 'f', 'o', 'x', '\0' };
static const CHAR testToken1A[] = { 'q', 'u', 'i', 'c', 'k', '\0' };
static const CHAR testToken2A[] = { 'b', 'r', 'o', 'w', 'n', '\0' };
static const CHAR testToken3A[] = { 'f', 'o', 'x', '\0' };
#define testToken1W_Length ((sizeof(testToken1W) / sizeof(WCHAR)) - 1)
#define testToken2W_Length ((sizeof(testToken2W) / sizeof(WCHAR)) - 1)
#define testToken3W_Length ((sizeof(testToken3W) / sizeof(WCHAR)) - 1)
#define testToken1A_Length ((sizeof(testToken1A) / sizeof(CHAR)) - 1)
#define testToken2A_Length ((sizeof(testToken2A) / sizeof(CHAR)) - 1)
#define testToken3A_Length ((sizeof(testToken3A) / sizeof(CHAR)) - 1)
static WCHAR testTokensW[] = { 'q', 'u', 'i', 'c', 'k', '\r', '\n', 'b', 'r', 'o',
'w', 'n', '\r', '\n', 'f', 'o', 'x', '\r', '\n', '\0' };
static const CHAR testTokensA[] = { 'q', 'u', 'i', 'c', 'k', '\r', '\n', 'b', 'r', 'o',
'w', 'n', '\r', '\n', 'f', 'o', 'x', '\r', '\n', '\0' };
#define testTokensW_Length ((sizeof(testTokensW) / sizeof(WCHAR)) - 1)
#define testTokensA_Length ((sizeof(testTokensA) / sizeof(CHAR)) - 1)
static WCHAR testDelimiter[] = { '\r', '\n', '\0' };
static const CHAR testDelimiterA[] = { '\r', '\n', '\0' };
#define testDelimiter_Length ((sizeof(testDelimiter) / sizeof(WCHAR)) - 1)
#define testDelimiterA_Length ((sizeof(testDelimiter) / sizeof(CHAR)) - 1)
struct url_test_pair
{
@ -92,7 +92,9 @@ int TestString(int argc, char* argv[])
return -1;
/* _wcslen */
WCHAR testStringW[ARRAYSIZE(testStringA)] = { 0 };
ConvertUtf8NToWChar(testStringA, ARRAYSIZE(testStringA), testStringW, ARRAYSIZE(testStringW));
const size_t testStringW_Length = testStringA_Length;
length = _wcslen(testStringW);
if (length != testStringW_Length)
@ -103,8 +105,15 @@ int TestString(int argc, char* argv[])
}
/* _wcschr */
union
{
char c[2];
WCHAR w;
} search;
search.c[0] = 'r';
search.c[1] = '\0';
p = _wcschr(testStringW, 'r');
p = _wcschr(testStringW, search.w);
pos = (p - testStringW);
if (pos != 11)
@ -113,7 +122,7 @@ int TestString(int argc, char* argv[])
return -1;
}
p = _wcschr(&testStringW[pos + 1], 'r');
p = _wcschr(&testStringW[pos + 1], search.w);
pos = (p - testStringW);
if (pos != 29)
@ -122,7 +131,7 @@ int TestString(int argc, char* argv[])
return -1;
}
p = _wcschr(&testStringW[pos + 1], 'r');
p = _wcschr(&testStringW[pos + 1], search.w);
if (p != NULL)
{
@ -132,32 +141,42 @@ int TestString(int argc, char* argv[])
}
/* wcstok_s */
WCHAR testDelimiterW[ARRAYSIZE(testDelimiterA)] = { 0 };
WCHAR testTokensW[ARRAYSIZE(testTokensA)] = { 0 };
ConvertUtf8NToWChar(testTokensA, ARRAYSIZE(testTokensA), testTokensW, ARRAYSIZE(testTokensW));
ConvertUtf8NToWChar(testDelimiterA, ARRAYSIZE(testDelimiterA), testDelimiterW,
ARRAYSIZE(testDelimiterW));
p = wcstok_s(testTokensW, testDelimiterW, &context);
p = wcstok_s(testTokensW, testDelimiter, &context);
WCHAR testToken1W[ARRAYSIZE(testToken1A)] = { 0 };
ConvertUtf8NToWChar(testToken1A, ARRAYSIZE(testToken1A), testToken1W, ARRAYSIZE(testToken1W));
if (memcmp(p, testToken1W, sizeof(testToken1W)) != 0)
{
printf("wcstok_s error: token #1 mismatch\n");
return -1;
}
p = wcstok_s(NULL, testDelimiter, &context);
p = wcstok_s(NULL, testDelimiterW, &context);
WCHAR testToken2W[ARRAYSIZE(testToken2A)] = { 0 };
ConvertUtf8NToWChar(testToken2A, ARRAYSIZE(testToken2A), testToken2W, ARRAYSIZE(testToken2W));
if (memcmp(p, testToken2W, sizeof(testToken2W)) != 0)
{
printf("wcstok_s error: token #2 mismatch\n");
return -1;
}
p = wcstok_s(NULL, testDelimiter, &context);
p = wcstok_s(NULL, testDelimiterW, &context);
WCHAR testToken3W[ARRAYSIZE(testToken3A)] = { 0 };
ConvertUtf8NToWChar(testToken3A, ARRAYSIZE(testToken3A), testToken3W, ARRAYSIZE(testToken3W));
if (memcmp(p, testToken3W, sizeof(testToken3W)) != 0)
{
printf("wcstok_s error: token #3 mismatch\n");
return -1;
}
p = wcstok_s(NULL, testDelimiter, &context);
p = wcstok_s(NULL, testDelimiterW, &context);
if (p != NULL)
{

24
winpr/libwinpr/dsparse/test/TestDsMakeSpn.c
View File

@ -60,18 +60,28 @@ fail:
static BOOL test_DsMakeSpnW(void)
{
WCHAR testServiceClass[] = { 'H', 'T', 'T', 'P', '\0' };
WCHAR testServiceName[] = { 'L', 'A', 'B', '1', '-', 'W', '2', 'K', '8', 'R', '2',
'-', 'G', 'W', '.', 'l', 'a', 'b', '1', '.', 'a', 'w',
'a', 'k', 'e', '.', 'l', 'o', 'c', 'a', 'l', '\0' };
WCHAR testSpn[] = { 'H', 'T', 'T', 'P', '/', 'L', 'A', 'B', '1', '-', 'W', '2', 'K',
'8', 'R', '2', '-', 'G', 'W', '.', 'l', 'a', 'b', '1', '.', 'a',
'w', 'a', 'k', 'e', '.', 'l', 'o', 'c', 'a', 'l', '\0' };
const CHAR ctestServiceClass[] = { 'H', 'T', 'T', 'P', '\0' };
const CHAR ctestServiceName[] = { 'L', 'A', 'B', '1', '-', 'W', '2', 'K', '8', 'R', '2',
'-', 'G', 'W', '.', 'l', 'a', 'b', '1', '.', 'a', 'w',
'a', 'k', 'e', '.', 'l', 'o', 'c', 'a', 'l', '\0' };
const CHAR ctestSpn[] = { 'H', 'T', 'T', 'P', '/', 'L', 'A', 'B', '1', '-', 'W', '2', 'K',
'8', 'R', '2', '-', 'G', 'W', '.', 'l', 'a', 'b', '1', '.', 'a',
'w', 'a', 'k', 'e', '.', 'l', 'o', 'c', 'a', 'l', '\0' };
WCHAR testServiceClass[ARRAYSIZE(ctestServiceClass)] = { 0 };
WCHAR testServiceName[ARRAYSIZE(ctestServiceName)] = { 0 };
WCHAR testSpn[ARRAYSIZE(ctestSpn)] = { 0 };
BOOL rc = FALSE;
WCHAR Spn[100] = { 0 };
DWORD status;
DWORD SpnLength = -1;
ConvertUtf8NToWChar(ctestServiceClass, ARRAYSIZE(ctestServiceClass), testServiceClass,
ARRAYSIZE(testServiceClass));
ConvertUtf8NToWChar(ctestServiceName, ARRAYSIZE(ctestServiceName), testServiceName,
ARRAYSIZE(testServiceName));
ConvertUtf8NToWChar(ctestSpn, ARRAYSIZE(ctestSpn), testSpn, ARRAYSIZE(testSpn));
status = DsMakeSpnW(testServiceClass, testServiceName, NULL, 0, NULL, &SpnLength, NULL);
if (status != ERROR_INVALID_PARAMETER)

9
winpr/libwinpr/file/test/TestFileDeleteFile.c
View File

@ -12,11 +12,10 @@ int TestFileDeleteFile(int argc, char* argv[])
char validA[] = "/tmp/valid-test-file-XXXXXX";
char validW[] = "/tmp/valid-test-file-XXXXXX";
WCHAR* validWW = NULL;
const char* invalidA = "/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const WCHAR invalidW[] = { '/', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', '\0' };
const char invalidA[] = "/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
WCHAR invalidW[sizeof(invalidA)] = { 0 };
ConvertUtf8NToWChar(invalidA, ARRAYSIZE(invalidA), invalidW, ARRAYSIZE(invalidW));
WINPR_UNUSED(argc);
WINPR_UNUSED(argv);

3
winpr/libwinpr/file/test/TestFileFindFirstFile.c
View File

@ -9,7 +9,6 @@
#include <winpr/windows.h>
static const CHAR testFile1A[] = "TestFile1A";
static const WCHAR testFile1W[] = { 'T', 'e', 's', 't', 'F', 'i', 'l', 'e', '1', 'W', '\0' };
static BOOL create_layout_files(size_t level, const char* BasePath, wArrayList* files)
{
@ -262,6 +261,8 @@ fail:
static int TestFileFindFirstFileW(const char* str)
{
WCHAR buffer[32] = { 0 };
const WCHAR* testFile1W = InitializeConstWCharFromUtf8("TestFile1W", buffer, ARRAYSIZE(buffer));
int rc = -1;
if (!str)
return -1;

44
winpr/libwinpr/path/path.c
View File

@ -914,41 +914,38 @@ char PathGetSeparatorA(unsigned long dwFlags)
WCHAR PathGetSeparatorW(unsigned long dwFlags)
{
WCHAR separator = PATH_SEPARATOR_CHR;
union
{
WCHAR w;
char c[2];
} cnv;
cnv.c[0] = PATH_SEPARATOR_CHR;
cnv.c[1] = '\0';
if (!dwFlags)
dwFlags = PATH_STYLE_NATIVE;
if (dwFlags == PATH_STYLE_WINDOWS)
separator = PATH_SEPARATOR_CHR;
cnv.c[0] = PATH_SEPARATOR_CHR;
else if (dwFlags == PATH_STYLE_UNIX)
separator = PATH_SEPARATOR_CHR;
cnv.c[0] = PATH_SEPARATOR_CHR;
else if (dwFlags == PATH_STYLE_NATIVE)
separator = PATH_SEPARATOR_CHR;
cnv.c[0] = PATH_SEPARATOR_CHR;
return separator;
return cnv.w;
}
/**
* PathGetSharedLibraryExtension
*/
static const CHAR SharedLibraryExtensionDllA[] = "dll";
static const CHAR SharedLibraryExtensionSoA[] = "so";
static const CHAR SharedLibraryExtensionDylibA[] = "dylib";
static const WCHAR SharedLibraryExtensionDllW[] = { 'd', 'l', 'l', '\0' };
static const WCHAR SharedLibraryExtensionSoW[] = { 's', 'o', '\0' };
static const WCHAR SharedLibraryExtensionDylibW[] = { 'd', 'y', 'l', 'i', 'b', '\0' };
static const CHAR SharedLibraryExtensionDotDllA[] = ".dll";
static const CHAR SharedLibraryExtensionDotSoA[] = ".so";
static const CHAR SharedLibraryExtensionDotDylibA[] = ".dylib";
static const WCHAR SharedLibraryExtensionDotDllW[] = { '.', 'd', 'l', 'l', '\0' };
static const WCHAR SharedLibraryExtensionDotSoW[] = { '.', 's', 'o', '\0' };
static const WCHAR SharedLibraryExtensionDotDylibW[] = { '.', 'd', 'y', 'l', 'i', 'b', '\0' };
PCSTR PathGetSharedLibraryExtensionA(unsigned long dwFlags)
{
if (dwFlags & PATH_SHARED_LIB_EXT_EXPLICIT)
@ -1009,6 +1006,20 @@ PCSTR PathGetSharedLibraryExtensionA(unsigned long dwFlags)
PCWSTR PathGetSharedLibraryExtensionW(unsigned long dwFlags)
{
WCHAR buffer[6][16] = { 0 };
const WCHAR* SharedLibraryExtensionDotDllW = InitializeConstWCharFromUtf8(
SharedLibraryExtensionDotDllA, buffer[0], ARRAYSIZE(buffer[0]));
const WCHAR* SharedLibraryExtensionDotSoW =
InitializeConstWCharFromUtf8(SharedLibraryExtensionDotSoA, buffer[1], ARRAYSIZE(buffer[1]));
const WCHAR* SharedLibraryExtensionDotDylibW = InitializeConstWCharFromUtf8(
SharedLibraryExtensionDotDylibA, buffer[2], ARRAYSIZE(buffer[2]));
const WCHAR* SharedLibraryExtensionDllW =
InitializeConstWCharFromUtf8(SharedLibraryExtensionDllA, buffer[3], ARRAYSIZE(buffer[3]));
const WCHAR* SharedLibraryExtensionSoW =
InitializeConstWCharFromUtf8(SharedLibraryExtensionSoA, buffer[4], ARRAYSIZE(buffer[4]));
const WCHAR* SharedLibraryExtensionDylibW =
InitializeConstWCharFromUtf8(SharedLibraryExtensionDylibA, buffer[5], ARRAYSIZE(buffer[5]));
if (dwFlags & PATH_SHARED_LIB_EXT_EXPLICIT)
{
if (dwFlags & PATH_SHARED_LIB_EXT_WITH_DOT)
@ -1121,7 +1132,8 @@ BOOL winpr_RemoveDirectory_RecursiveW(LPCWSTR lpPathName)
return FALSE;
_wcsncat(path_slash, lpPathName, pathnamelen);
const WCHAR star[] = { '*', '\0' };
WCHAR starbuffer[8] = { 0 };
const WCHAR* star = InitializeConstWCharFromUtf8("*", starbuffer, ARRAYSIZE(starbuffer));
const HRESULT hr = NativePathCchAppendW(path_slash, path_slash_len, star);
if (FAILED(hr))
goto fail;

29
winpr/libwinpr/sspi/CredSSP/credssp.c
View File

@ -300,18 +300,23 @@ const SecPkgInfoA CREDSSP_SecPkgInfoA = {
"Microsoft CredSSP Security Provider" /* Comment */
};
static WCHAR CREDSSP_SecPkgInfoW_Name[] = { 'C', 'R', 'E', 'D', 'S', 'S', 'P', '\0' };
static WCHAR CREDSSP_SecPkgInfoW_Comment[] = { 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't',
' ', 'C', 'r', 'e', 'd', 'S', 'S', 'P', ' ',
'S', 'e', 'c', 'u', 'r', 'i', 't', 'y', ' ',
'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', '\0' };
static WCHAR CREDSSP_SecPkgInfoW_NameBuffer[128] = { 0 };
static WCHAR CREDSSP_SecPkgInfoW_CommentBuffer[128] = { 0 };
const SecPkgInfoW CREDSSP_SecPkgInfoW = {
0x000110733, /* fCapabilities */
1, /* wVersion */
0xFFFF, /* wRPCID */
0x000090A8, /* cbMaxToken */
CREDSSP_SecPkgInfoW_Name, /* Name */
CREDSSP_SecPkgInfoW_Comment /* Comment */
0x000110733, /* fCapabilities */
1, /* wVersion */
0xFFFF, /* wRPCID */
0x000090A8, /* cbMaxToken */
CREDSSP_SecPkgInfoW_NameBuffer, /* Name */
CREDSSP_SecPkgInfoW_CommentBuffer /* Comment */
};
BOOL CREDSSP_init(void)
{
InitializeConstWCharFromUtf8(CREDSSP_SecPkgInfoA.Name, CREDSSP_SecPkgInfoW_NameBuffer,
ARRAYSIZE(CREDSSP_SecPkgInfoW_NameBuffer));
InitializeConstWCharFromUtf8(CREDSSP_SecPkgInfoA.Comment, CREDSSP_SecPkgInfoW_CommentBuffer,
ARRAYSIZE(CREDSSP_SecPkgInfoW_CommentBuffer));
return TRUE;
}

2
winpr/libwinpr/sspi/CredSSP/credssp.h
View File

@ -37,4 +37,6 @@ extern const SecPkgInfoW CREDSSP_SecPkgInfoW;
extern const SecurityFunctionTableA CREDSSP_SecurityFunctionTableA;
extern const SecurityFunctionTableW CREDSSP_SecurityFunctionTableW;
BOOL CREDSSP_init(void);
#endif /* WINPR_SSPI_CREDSSP_PRIVATE_H */

28
winpr/libwinpr/sspi/Kerberos/kerberos.c
View File

@ -69,19 +69,16 @@ const SecPkgInfoA KERBEROS_SecPkgInfoA = {
"Kerberos Security Package" /* Comment */
};
static WCHAR KERBEROS_SecPkgInfoW_Name[] = { 'K', 'e', 'r', 'b', 'e', 'r', 'o', 's', '\0' };
static WCHAR KERBEROS_SecPkgInfoW_Comment[] = { 'K', 'e', 'r', 'b', 'e', 'r', 'o', 's', ' ',
'S', 'e', 'c', 'u', 'r', 'i', 't', 'y', ' ',
'P', 'a', 'c', 'k', 'a', 'g', 'e', '\0' };
static WCHAR KERBEROS_SecPkgInfoW_NameBuffer[32] = { 0 };
static WCHAR KERBEROS_SecPkgInfoW_CommentBuffer[32] = { 0 };
const SecPkgInfoW KERBEROS_SecPkgInfoW = {
0x000F3BBF, /* fCapabilities */
1, /* wVersion */
0x0010, /* wRPCID */
0x0000BB80, /* cbMaxToken : 48k bytes maximum for Windows Server 2012 */
KERBEROS_SecPkgInfoW_Name, /* Name */
KERBEROS_SecPkgInfoW_Comment /* Comment */
0x000F3BBF, /* fCapabilities */
1, /* wVersion */
0x0010, /* wRPCID */
0x0000BB80, /* cbMaxToken : 48k bytes maximum for Windows Server 2012 */
KERBEROS_SecPkgInfoW_NameBuffer, /* Name */
KERBEROS_SecPkgInfoW_CommentBuffer /* Comment */
};
#ifdef WITH_KRB5
@ -1825,3 +1822,12 @@ const SecurityFunctionTableW KERBEROS_SecurityFunctionTableW = {
kerberos_SetContextAttributesW, /* SetContextAttributes */
kerberos_SetCredentialsAttributesW, /* SetCredentialsAttributes */
};
BOOL KERBEROS_init(void)
{
InitializeConstWCharFromUtf8(KERBEROS_SecPkgInfoA.Name, KERBEROS_SecPkgInfoW_NameBuffer,
ARRAYSIZE(KERBEROS_SecPkgInfoW_NameBuffer));
InitializeConstWCharFromUtf8(KERBEROS_SecPkgInfoA.Comment, KERBEROS_SecPkgInfoW_CommentBuffer,
ARRAYSIZE(KERBEROS_SecPkgInfoW_CommentBuffer));
return TRUE;
}

2
winpr/libwinpr/sspi/Kerberos/kerberos.h
View File

@ -34,4 +34,6 @@ extern const SecPkgInfoW KERBEROS_SecPkgInfoW;
extern const SecurityFunctionTableA KERBEROS_SecurityFunctionTableA;
extern const SecurityFunctionTableW KERBEROS_SecurityFunctionTableW;
BOOL KERBEROS_init(void);
#endif /* WINPR_SSPI_KERBEROS_PRIVATE_H */

33
winpr/libwinpr/sspi/NTLM/ntlm.c
View File

@ -1398,31 +1398,26 @@ const SecPkgInfoA NTLM_SecPkgInfoA = {
"NTLM Security Package" /* Comment */
};
static WCHAR NTLM_SecPkgInfoW_Name[] = { 'N', 'T', 'L', 'M', '\0' };
static WCHAR NTLM_SecPkgInfoW_Comment[] = {
'N', 'T', 'L', 'M', ' ', 'S', 'e', 'c', 'u', 'r', 'i',
't', 'y', ' ', 'P', 'a', 'c', 'k', 'a', 'g', 'e', '\0'
};
static WCHAR NTLM_SecPkgInfoW_NameBuffer[32] = { 0 };
static WCHAR NTLM_SecPkgInfoW_CommentBuffer[32] = { 0 };
const SecPkgInfoW NTLM_SecPkgInfoW = {
0x00082B37, /* fCapabilities */
1, /* wVersion */
0x000A, /* wRPCID */
0x00000B48, /* cbMaxToken */
NTLM_SecPkgInfoW_Name, /* Name */
NTLM_SecPkgInfoW_Comment /* Comment */
0x00082B37, /* fCapabilities */
1, /* wVersion */
0x000A, /* wRPCID */
0x00000B48, /* cbMaxToken */
NTLM_SecPkgInfoW_NameBuffer, /* Name */
NTLM_SecPkgInfoW_CommentBuffer /* Comment */
};
char* ntlm_negotiate_flags_string(char* buffer, size_t size, UINT32 flags)
{
int x;
if (!buffer || (size == 0))
return buffer;
_snprintf(buffer, size, "[0x%08" PRIx32 "] ", flags);
for (x = 0; x < 31; x++)
for (int x = 0; x < 31; x++)
{
const UINT32 mask = 1 << x;
size_t len = strnlen(buffer, size);
@ -1521,3 +1516,13 @@ BOOL ntlm_reset_cipher_state(PSecHandle phContext)
return TRUE;
}
BOOL NTLM_init(void)
{
InitializeConstWCharFromUtf8(NTLM_SecPkgInfoA.Name, NTLM_SecPkgInfoW_NameBuffer,
ARRAYSIZE(NTLM_SecPkgInfoW_NameBuffer));
InitializeConstWCharFromUtf8(NTLM_SecPkgInfoA.Comment, NTLM_SecPkgInfoW_CommentBuffer,
ARRAYSIZE(NTLM_SecPkgInfoW_CommentBuffer));
return TRUE;
}

2
winpr/libwinpr/sspi/NTLM/ntlm.h
View File

@ -296,4 +296,6 @@ SECURITY_STATUS ntlm_computeMicValue(NTLM_CONTEXT* ntlm, SecBuffer* micvalue);
#define WITH_DEBUG_NTLM
#endif
BOOL NTLM_init(void);
#endif /* WINPR_SSPI_NTLM_PRIVATE_H */

29
winpr/libwinpr/sspi/Negotiate/negotiate.c
View File

@ -73,19 +73,16 @@ const SecPkgInfoA NEGOTIATE_SecPkgInfoA = {
"Microsoft Package Negotiator" /* Comment */
};
static WCHAR NEGOTIATE_SecPkgInfoW_Name[] = { 'N', 'e', 'g', 'o', 't', 'i', 'a', 't', 'e', '\0' };
static WCHAR NEGOTIATE_SecPkgInfoW_Comment[] = { 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', ' ',
'P', 'a', 'c', 'k', 'a', 'g', 'e', ' ', 'N', 'e',
'g', 'o', 't', 'i', 'a', 't', 'o', 'r', '\0' };
static WCHAR NEGOTIATE_SecPkgInfoW_NameBuffer[32] = { 0 };
static WCHAR NEGOTIATE_SecPkgInfoW_CommentBuffer[32] = { 0 };
const SecPkgInfoW NEGOTIATE_SecPkgInfoW = {
0x00083BB3, /* fCapabilities */
1, /* wVersion */
0x0009, /* wRPCID */
0x00002FE0, /* cbMaxToken */
NEGOTIATE_SecPkgInfoW_Name, /* Name */
NEGOTIATE_SecPkgInfoW_Comment /* Comment */
0x00083BB3, /* fCapabilities */
1, /* wVersion */
0x0009, /* wRPCID */
0x00002FE0, /* cbMaxToken */
NEGOTIATE_SecPkgInfoW_NameBuffer, /* Name */
NEGOTIATE_SecPkgInfoW_CommentBuffer /* Comment */
};
static const WinPrAsn1_OID spnego_OID = { 6, (BYTE*)"\x2b\x06\x01\x05\x05\x02" };
@ -1642,3 +1639,13 @@ const SecurityFunctionTableW NEGOTIATE_SecurityFunctionTableW = {
negotiate_SetContextAttributesW, /* SetContextAttributes */
negotiate_SetCredentialsAttributesW, /* SetCredentialsAttributes */
};
BOOL NEGOTIATE_init(void)
{
InitializeConstWCharFromUtf8(NEGOTIATE_SecPkgInfoA.Name, NEGOTIATE_SecPkgInfoW_NameBuffer,
ARRAYSIZE(NEGOTIATE_SecPkgInfoW_NameBuffer));
InitializeConstWCharFromUtf8(NEGOTIATE_SecPkgInfoA.Comment, NEGOTIATE_SecPkgInfoW_CommentBuffer,
ARRAYSIZE(NEGOTIATE_SecPkgInfoW_CommentBuffer));
return TRUE;
}

2
winpr/libwinpr/sspi/Negotiate/negotiate.h
View File

@ -52,4 +52,6 @@ extern const SecPkgInfoW NEGOTIATE_SecPkgInfoW;
extern const SecurityFunctionTableA NEGOTIATE_SecurityFunctionTableA;
extern const SecurityFunctionTableW NEGOTIATE_SecurityFunctionTableW;
BOOL NEGOTIATE_init(void);
#endif /* WINPR_SSPI_NEGOTIATE_PRIVATE_H */

28
winpr/libwinpr/sspi/Schannel/schannel.c
View File

@ -445,17 +445,23 @@ const SecPkgInfoA SCHANNEL_SecPkgInfoA = {
"Schannel Security Package" /* Comment */
};
static WCHAR SCHANNEL_SecPkgInfoW_Name[] = { 'S', 'c', 'h', 'a', 'n', 'n', 'e', 'l', '\0' };
static WCHAR SCHANNEL_SecPkgInfoW_Comment[] = { 'S', 'c', 'h', 'a', 'n', 'n', 'e', 'l', ' ',
'S', 'e', 'c', 'u', 'r', 'i', 't', 'y', ' ',
'P', 'a', 'c', 'k', 'a', 'g', 'e', '\0' };
static WCHAR SCHANNEL_SecPkgInfoW_NameBuffer[32] = { 0 };
static WCHAR SCHANNEL_SecPkgInfoW_CommentBuffer[32] = { 0 };
const SecPkgInfoW SCHANNEL_SecPkgInfoW = {
0x000107B3, /* fCapabilities */
1, /* wVersion */
0x000E, /* wRPCID */
SCHANNEL_CB_MAX_TOKEN, /* cbMaxToken */
SCHANNEL_SecPkgInfoW_Name, /* Name */
SCHANNEL_SecPkgInfoW_Comment /* Comment */
0x000107B3, /* fCapabilities */
1, /* wVersion */
0x000E, /* wRPCID */
SCHANNEL_CB_MAX_TOKEN, /* cbMaxToken */
SCHANNEL_SecPkgInfoW_NameBuffer, /* Name */
SCHANNEL_SecPkgInfoW_CommentBuffer /* Comment */
};
BOOL SCHANNEL_init(void)
{
InitializeConstWCharFromUtf8(SCHANNEL_SecPkgInfoA.Name, SCHANNEL_SecPkgInfoW_NameBuffer,
ARRAYSIZE(SCHANNEL_SecPkgInfoW_NameBuffer));
InitializeConstWCharFromUtf8(SCHANNEL_SecPkgInfoA.Comment, SCHANNEL_SecPkgInfoW_CommentBuffer,
ARRAYSIZE(SCHANNEL_SecPkgInfoW_CommentBuffer));
return TRUE;
}

2
winpr/libwinpr/sspi/Schannel/schannel.h
View File

@ -48,4 +48,6 @@ extern const SecPkgInfoW SCHANNEL_SecPkgInfoW;
extern const SecurityFunctionTableA SCHANNEL_SecurityFunctionTableA;
extern const SecurityFunctionTableW SCHANNEL_SecurityFunctionTableW;
BOOL SCHANNEL_init(void);
#endif /* WINPR_SSPI_SCHANNEL_PRIVATE_H */

41
winpr/libwinpr/sspi/sspi_winpr.c
View File

@ -36,6 +36,7 @@
/* Authentication Functions: http://msdn.microsoft.com/en-us/library/windows/desktop/aa374731/ */
#include "NTLM/ntlm.h"
#include "NTLM/ntlm_export.h"
#include "CredSSP/credssp.h"
#include "Kerberos/kerberos.h"
@ -73,18 +74,14 @@ static const SecurityFunctionTableA_NAME SecurityFunctionTableA_NAME_LIST[] = {
{ "Schannel", &SCHANNEL_SecurityFunctionTableA }
};
static const WCHAR _NTLM_NAME_W[] = { 'N', 'T', 'L', 'M', '\0' };
static const WCHAR _KERBEROS_NAME_W[] = { 'K', 'e', 'r', 'b', 'e', 'r', 'o', 's', '\0' };
static const WCHAR _NEGOTIATE_NAME_W[] = { 'N', 'e', 'g', 'o', 't', 'i', 'a', 't', 'e', '\0' };
static const WCHAR _CREDSSP_NAME_W[] = { 'C', 'r', 'e', 'd', 'S', 'S', 'P', '\0' };
static const WCHAR _SCHANNEL_NAME_W[] = { 'S', 'c', 'h', 'a', 'n', 'n', 'e', 'l', '\0' };
static WCHAR BUFFER_NAME_LIST_W[5][32] = { 0 };
static const SecurityFunctionTableW_NAME SecurityFunctionTableW_NAME_LIST[] = {
{ _NTLM_NAME_W, &NTLM_SecurityFunctionTableW },
{ _KERBEROS_NAME_W, &KERBEROS_SecurityFunctionTableW },
{ _NEGOTIATE_NAME_W, &NEGOTIATE_SecurityFunctionTableW },
{ _CREDSSP_NAME_W, &CREDSSP_SecurityFunctionTableW },
{ _SCHANNEL_NAME_W, &SCHANNEL_SecurityFunctionTableW }
{ BUFFER_NAME_LIST_W[0], &NTLM_SecurityFunctionTableW },
{ BUFFER_NAME_LIST_W[1], &KERBEROS_SecurityFunctionTableW },
{ BUFFER_NAME_LIST_W[2], &NEGOTIATE_SecurityFunctionTableW },
{ BUFFER_NAME_LIST_W[3], &CREDSSP_SecurityFunctionTableW },
{ BUFFER_NAME_LIST_W[4], &SCHANNEL_SecurityFunctionTableW }
};
#define SecHandle_LOWER_MAX 0xFFFFFFFF
@ -949,11 +946,33 @@ PSecBuffer sspi_FindSecBuffer(PSecBufferDesc pMessage, ULONG BufferType)
return pSecBuffer;
}
static BOOL WINPR_init(void)
{
for (size_t x = 0; x < ARRAYSIZE(SecurityFunctionTableA_NAME_LIST); x++)
{
const SecurityFunctionTableA_NAME* const cur = &SecurityFunctionTableA_NAME_LIST[x];
InitializeConstWCharFromUtf8(cur->Name, BUFFER_NAME_LIST_W[x],
ARRAYSIZE(BUFFER_NAME_LIST_W[x]));
}
return TRUE;
}
static BOOL CALLBACK sspi_init(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
{
winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
sspi_ContextBufferAllocTableNew();
return TRUE;
if (!SCHANNEL_init())
return FALSE;
if (!KERBEROS_init())
return FALSE;
if (!NTLM_init())
return FALSE;
if (!CREDSSP_init())
return FALSE;
if (!NEGOTIATE_init())
return FALSE;
return WINPR_init();
}
void sspi_GlobalInit(void)