RtlGUIDFromString, RtlStringFromGUID.
*/
#include "config.h"
+#include "wine/port.h"
#include <stdarg.h>
#include "ntstatus.h"
#include "winreg.h"
#include "winternl.h"
#include "winerror.h"
+#include "thread.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
static const struct error_table error_table[20];
/**************************************************************************
- * RtlNtStatusToDosError (NTDLL.@)
+ * RtlNtStatusToDosErrorNoTeb (NTDLL.@)
*
* Convert an NTSTATUS code to a Win32 error code.
*
* The mapped Win32 error code, or ERROR_MR_MID_NOT_FOUND if there is no
* mapping defined.
*/
-ULONG WINAPI RtlNtStatusToDosError( NTSTATUS status )
+ULONG WINAPI RtlNtStatusToDosErrorNoTeb( NTSTATUS status )
{
const struct error_table *table = error_table;
return ERROR_MR_MID_NOT_FOUND;
}
+/**************************************************************************
+ * RtlNtStatusToDosError (NTDLL.@)
+ *
+ * Convert an NTSTATUS code to a Win32 error code.
+ *
+ * PARAMS
+ * status [I] Nt error code to map.
+ *
+ * RETURNS
+ * The mapped Win32 error code, or ERROR_MR_MID_NOT_FOUND if there is no
+ * mapping defined.
+ */
+ULONG WINAPI RtlNtStatusToDosError( NTSTATUS status )
+{
+ /* FIXME: This function obviously does something with the Teb */
+ return RtlNtStatusToDosErrorNoTeb( status );
+}
+
+/**********************************************************************
+ * RtlGetLastWin32Error (NTDLL.@)
+ *
+ * Get the current per-thread error value set by a system function or the user.
+ *
+ * PARAMS
+ * None.
+ *
+ * RETURNS
+ * The current error value for the thread, as set by SetLastWin32Error() or SetLastError().
+ */
+DWORD WINAPI RtlGetLastWin32Error(void)
+{
+ return NtCurrentTeb()->LastErrorValue;
+}
+
+/***********************************************************************
+ * RtlSetLastWin32Error (NTDLL.@)
+ * RtlRestoreLastWin32Error (NTDLL.@)
+ *
+ * Set the per-thread error value.
+ *
+ * PARAMS
+ * err [I] The new error value to set
+ */
+void WINAPI RtlSetLastWin32Error( DWORD err )
+{
+ NtCurrentTeb()->LastErrorValue = err;
+}
/* conversion tables */
@ stub RtlGetElementGenericTable
@ stdcall RtlGetFullPathName_U(wstr long ptr ptr)
@ stdcall RtlGetGroupSecurityDescriptor(ptr ptr ptr)
+@ stdcall RtlGetLastWin32Error()
@ stdcall RtlGetLongestNtPathLength()
@ stub RtlGetNtGlobalFlags
@ stdcall RtlGetNtProductType(ptr)
@ stdcall RtlGetProcessHeaps(long ptr)
@ stdcall RtlGetSaclSecurityDescriptor(ptr ptr ptr ptr)
@ stub RtlGetUserInfoHeap
+@ stdcall RtlGUIDFromString(ptr ptr)
@ stdcall RtlIdentifierAuthoritySid(ptr)
@ stdcall RtlImageDirectoryEntryToData(long long long ptr)
@ stdcall RtlImageNtHeader(long)
@ stdcall RtlNewSecurityObject(long long long long long long)
@ stdcall RtlNormalizeProcessParams(ptr)
@ stdcall RtlNtStatusToDosError(long)
+@ stdcall RtlNtStatusToDosErrorNoTeb(long)
@ stub RtlNumberGenericTableElements
@ stdcall RtlNumberOfClearBits(ptr)
@ stdcall RtlNumberOfSetBits(ptr)
@ stdcall RtlRaiseException(ptr)
@ stdcall RtlRaiseStatus(long)
@ stdcall RtlRandom(ptr)
+@ stdcall RtlRestoreLastWin32Error(long) RtlSetLastWin32Error
@ stdcall RtlReAllocateHeap(long long ptr long)
@ stub RtlRealPredecessor
@ stub RtlRealSuccessor
@ stdcall RtlSetEnvironmentVariable(ptr ptr ptr)
@ stdcall RtlSetGroupSecurityDescriptor(ptr ptr long)
@ stub RtlSetInformationAcl
+@ stdcall RtlSetLastWin32Error(long)
@ stdcall RtlSetOwnerSecurityDescriptor(ptr ptr long)
@ stdcall RtlSetSaclSecurityDescriptor(ptr long ptr long)
@ stub RtlSetSecurityObject
@ stdcall RtlSizeHeap(long long ptr)
@ stub RtlSplay
@ stub RtlStartRXact
-@ stub RtlStringFromGUID
+@ stdcall RtlStringFromGUID(ptr ptr)
@ stdcall RtlSubAuthorityCountSid(ptr)
@ stdcall RtlSubAuthoritySid(ptr long)
@ stub RtlSubtreePredecessor
} /* if */
return STATUS_SUCCESS;
}
+
+
+/*************************************************************************
+ * RtlGUIDFromString (NTDLL.@)
+ *
+ * Convert a string representation of a GUID into a GUID.
+ *
+ * PARAMS
+ * str [I] String representation in the format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
+ * guid [O] Destination for the converted GUID
+ *
+ * RETURNS
+ * Success: STATUS_SUCCESS. guid contains the converted value.
+ * Failure: STATUS_INVALID_PARAMETER, if str is not in the expected format.
+ *
+ * SEE ALSO
+ * See RtlStringFromGUID.
+ */
+NTSTATUS WINAPI RtlGUIDFromString(const UNICODE_STRING *str, GUID* guid)
+{
+ int i = 0;
+ const WCHAR *lpszCLSID = str->Buffer;
+ BYTE* lpOut = (BYTE*)guid;
+
+ TRACE("(%s,%p)\n", debugstr_us(str), guid);
+
+ /* Convert string: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+ * to memory: DWORD... WORD WORD BYTES............
+ */
+ while (i < 37)
+ {
+ switch (i)
+ {
+ case 0:
+ if (*lpszCLSID != '{')
+ return STATUS_INVALID_PARAMETER;
+ break;
+
+ case 9: case 14: case 19: case 24:
+ if (*lpszCLSID != '-')
+ return STATUS_INVALID_PARAMETER;
+ break;
+
+ case 37:
+ if (*lpszCLSID != '}')
+ return STATUS_INVALID_PARAMETER;
+ break;
+
+ default:
+ {
+ WCHAR ch = *lpszCLSID, ch2 = lpszCLSID[1];
+ unsigned char byte;
+
+ /* Read two hex digits as a byte value */
+ if (ch >= '0' && ch <= '9') ch = ch - '0';
+ else if (ch >= 'a' && ch <= 'f') ch = ch - 'a' + 10;
+ else if (ch >= 'A' && ch <= 'F') ch = ch - 'A' + 10;
+ else return STATUS_INVALID_PARAMETER;
+
+ if (ch2 >= '0' && ch2 <= '9') ch2 = ch2 - '0';
+ else if (ch2 >= 'a' && ch2 <= 'f') ch2 = ch2 - 'a' + 10;
+ else if (ch2 >= 'A' && ch2 <= 'F') ch2 = ch2 - 'A' + 10;
+ else return STATUS_INVALID_PARAMETER;
+
+ byte = ch << 4 | ch2;
+
+ switch (i)
+ {
+#ifndef WORDS_BIGENDIAN
+ /* For Big Endian machines, we store the data such that the
+ * dword/word members can be read as DWORDS and WORDS correctly. */
+ /* Dword */
+ case 1: lpOut[3] = byte; break;
+ case 3: lpOut[2] = byte; break;
+ case 5: lpOut[1] = byte; break;
+ case 7: lpOut[0] = byte; lpOut += 4; break;
+ /* Word */
+ case 10: case 15: lpOut[1] = byte; break;
+ case 12: case 17: lpOut[0] = byte; lpOut += 2; break;
+#endif
+ /* Byte */
+ default: lpOut[0] = byte; lpOut++; break;
+ }
+ lpszCLSID++; /* Skip 2nd character of byte */
+ i++;
+ }
+ }
+ lpszCLSID++;
+ i++;
+ }
+
+ return STATUS_SUCCESS;
+}
+
+/*************************************************************************
+ * RtlStringFromGUID (NTDLL.@)
+ *
+ * Convert a GUID into a string representation of a GUID.
+ *
+ * PARAMS
+ * guid [I] GUID to convert
+ * str [O] Destination for the converted string
+ *
+ * RETURNS
+ * Success: STATUS_SUCCESS. str contains the converted value.
+ * Failure: STATUS_NO_MEMORY, if memory for str cannot be allocated.
+ *
+ * SEE ALSO
+ * See RtlGUIDFromString.
+ */
+NTSTATUS WINAPI RtlStringFromGUID(const GUID* guid, UNICODE_STRING *str)
+{
+ static const WCHAR szFormat[] = { '{','%','0','8','l','X','-',
+ '%','0','4','X','-', '%','0','4','X','-','%','0','2','X','%','0','2','X',
+ '-', '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
+ '%','0','2','X','%','0','2','X','}','\0' };
+
+ TRACE("(%p,%p)\n", guid, str);
+
+ str->Buffer = (WCHAR*)RtlAllocateHeap( ntdll_get_process_heap(), 0, 40 * sizeof(WCHAR));
+ if (!str->Buffer)
+ {
+ str->Length = str->MaximumLength = 0;
+ return STATUS_NO_MEMORY;
+ }
+ str->Length = str->MaximumLength = 40;
+ sprintfW(str->Buffer, szFormat, guid->Data1, guid->Data2, guid->Data3,
+ guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
+ guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+
+ return STATUS_SUCCESS;
+}
#include <stdarg.h>
#include <stdlib.h>
+#define INITGUID
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winreg.h"
#include "winternl.h"
+#include "guiddef.h"
/* Function ptrs for ntdll calls */
static HMODULE hntdll = 0;
static CHAR (WINAPI *pRtlUpperChar)(CHAR);
static NTSTATUS (WINAPI *pRtlUpperString)(STRING *, const STRING *);
static NTSTATUS (WINAPI *pRtlValidateUnicodeString)(long, UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlGUIDFromString)(const UNICODE_STRING*,GUID*);
+static NTSTATUS (WINAPI *pRtlStringFromGUID)(const GUID*, UNICODE_STRING*);
/*static VOID (WINAPI *pRtlFreeOemString)(PSTRING);*/
/*static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);*/
pRtlUpperChar = (void *)GetProcAddress(hntdll, "RtlUpperChar");
pRtlUpperString = (void *)GetProcAddress(hntdll, "RtlUpperString");
pRtlValidateUnicodeString = (void *)GetProcAddress(hntdll, "RtlValidateUnicodeString");
+ pRtlGUIDFromString = (void *)GetProcAddress(hntdll, "RtlGUIDFromString");
+ pRtlStringFromGUID = (void *)GetProcAddress(hntdll, "RtlStringFromGUID");
} /* if */
}
int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}
+static const WCHAR szGuid[] = { '{','0','1','0','2','0','3','0','4','-',
+ '0','5','0','6','-' ,'0','7','0','8','-','0','9','0','A','-',
+ '0','B','0','C','0','D','0','E','0','F','0','A','}','\0' };
+DEFINE_GUID(IID_Endianess, 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B,
+ 0x0C, 0x0D, 0x0E, 0x0F, 0x0A);
+
+static void test_RtlGUIDFromString(void)
+{
+ GUID guid;
+ UNICODE_STRING str;
+ NTSTATUS ret;
+
+ str.Length = str.MaximumLength = (sizeof(szGuid) - 1) / sizeof(WCHAR);
+ str.Buffer = (LPWSTR)szGuid;
+
+ ret = pRtlGUIDFromString(&str, &guid);
+ ok(ret == 0, "expected ret=0, got 0x%0lx\n", ret);
+ ok(memcmp(&guid, &IID_Endianess, sizeof(guid)) == 0, "Endianess broken\n");
+}
+
+static void test_RtlStringFromGUID(void)
+{
+ UNICODE_STRING str;
+ NTSTATUS ret;
+
+ str.Length = str.MaximumLength = 0;
+ str.Buffer = NULL;
+
+ ret = pRtlStringFromGUID(&IID_Endianess, &str);
+ ok(ret == 0, "expected ret=0, got 0x%0lx\n", ret);
+ ok(str.Buffer && !lstrcmpW(str.Buffer, szGuid), "Endianess broken\n");
+}
START_TEST(rtlstr)
{
test_RtlAppendUnicodeStringToString();
} /* if */
- if (pRtlInitUnicodeStringEx) {
- test_RtlInitUnicodeStringEx();
- } /* if */
- if (pRtlDuplicateUnicodeString) {
+ if (pRtlInitUnicodeStringEx)
+ test_RtlInitUnicodeStringEx();
+ if (pRtlDuplicateUnicodeString)
test_RtlDuplicateUnicodeString();
- } /* if */
- if (pRtlFindCharInUnicodeString) {
+ if (pRtlFindCharInUnicodeString)
test_RtlFindCharInUnicodeString();
- } /* if */
- /*
+ if (pRtlGUIDFromString)
+ test_RtlGUIDFromString();
+ if (pRtlStringFromGUID)
+ test_RtlStringFromGUID();
+ /*
* test_RtlUpcaseUnicodeChar();
* test_RtlUpcaseUnicodeString();
* test_RtlDowncaseUnicodeString();
void WINAPI RtlReleasePebLock(void);
void WINAPI RtlReleaseResource(LPRTL_RWLOCK);
ULONG WINAPI RtlRemoveVectoredExceptionHandler(PVOID);
-DWORD WINAPI RtlRestoreLastWin32Error(DWORD);
+void WINAPI RtlRestoreLastWin32Error(DWORD);
void WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
void WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
NTSTATUS WINAPI RtlSetEnvironmentVariable(PWSTR*,PUNICODE_STRING,PUNICODE_STRING);
NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
NTSTATUS WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
-DWORD WINAPI RtlSetLastWin32Error(DWORD);
+void WINAPI RtlSetLastWin32Error(DWORD);
NTSTATUS WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
NTSTATUS WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
ULONG WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
http://git.etersoft.ru/projects / wine / eterwine.git / commitdiff