Something went wrong. Try again.
Reactos
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031/* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS system libraries * FILE: dll/win32/kernel32/client/dosdev.c * PURPOSE: Dos device functions * PROGRAMMER: Ariadne (ariadne@xs4all.nl) * Pierre Schweitzer * UPDATE HISTORY: * Created 01/11/98 */
/* INCLUDES ******************************************************************/
#include <k32.h>
#define NDEBUG#include <debug.h>#include <dbt.h>DEBUG_CHANNEL(kernel32file);
/* FUNCTIONS *****************************************************************/
/* * @implemented */NTSTATUSIsGlobalDeviceMap( HANDLE DirectoryHandle, PBOOLEAN IsGlobal){ NTSTATUS Status; DWORD ReturnLength; UNICODE_STRING GlobalString; OBJECT_NAME_INFORMATION NameInfo, *PNameInfo;
/* We need both parameters */ if (DirectoryHandle == 0 || IsGlobal == NULL) { return STATUS_INVALID_PARAMETER; }
PNameInfo = NULL; _SEH2_TRY { /* Query handle information */ Status = NtQueryObject(DirectoryHandle, ObjectNameInformation, &NameInfo, 0, &ReturnLength); /* Only failure we tolerate is length mismatch */ if (NT_SUCCESS(Status) || Status == STATUS_INFO_LENGTH_MISMATCH) { /* Allocate big enough buffer */ PNameInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, ReturnLength); if (PNameInfo == NULL) { Status = STATUS_NO_MEMORY; _SEH2_LEAVE; }
/* Query again handle information */ Status = NtQueryObject(DirectoryHandle, ObjectNameInformation, PNameInfo, ReturnLength, &ReturnLength);
/* * If it succeed, check we have Global?? * If so, return success */ if (NT_SUCCESS(Status)) { RtlInitUnicodeString(&GlobalString, L"\\GLOBAL??"); *IsGlobal = RtlEqualUnicodeString(&GlobalString, &PNameInfo->Name, FALSE); Status = STATUS_SUCCESS; } } } _SEH2_FINALLY { if (PNameInfo != NULL) { RtlFreeHeap(RtlGetProcessHeap(), 0, PNameInfo); } } _SEH2_END;
return Status;}
/* * @implemented */DWORDFindSymbolicLinkEntry( PWSTR NameToFind, PWSTR NamesList, DWORD TotalEntries, PBOOLEAN Found){ WCHAR Current; DWORD Entries; PWSTR PartialNamesList;
/* We need all parameters to be set */ if (NameToFind == NULL || NamesList == NULL || Found == NULL) { return ERROR_INVALID_PARAMETER; }
/* Assume failure */ *Found = FALSE;
/* If no entries, job done, nothing found */ if (TotalEntries == 0) { return ERROR_SUCCESS; }
/* Start browsing the names list */ Entries = 0; PartialNamesList = NamesList; /* As long as we didn't find the name... */ while (wcscmp(NameToFind, PartialNamesList) != 0) { /* We chomped an entry! */ ++Entries;
/* We're out of entries, bail out not to overrun */ if (Entries > TotalEntries) { /* * Even though we found nothing, * the function ran fine */ return ERROR_SUCCESS; }
/* Jump to the next string */ do { Current = *PartialNamesList; ++PartialNamesList; } while (Current != UNICODE_NULL); }
/* * We're here because the loop stopped: * it means we found the name in the list */ *Found = TRUE; return ERROR_SUCCESS;}
/* * @implemented */BOOLWINAPIDefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath ){ BOOL Result; NTSTATUS Status; ANSI_STRING AnsiString; PWSTR TargetPathBuffer; UNICODE_STRING TargetPathU; PUNICODE_STRING DeviceNameU;
/* Convert DeviceName using static unicode string */ RtlInitAnsiString(&AnsiString, lpDeviceName); DeviceNameU = &NtCurrentTeb()->StaticUnicodeString; Status = RtlAnsiStringToUnicodeString(DeviceNameU, &AnsiString, FALSE); if (!NT_SUCCESS(Status)) { /* * If the static unicode string is too small, * it's because the name is too long... * so, return appropriate status! */ if (Status == STATUS_BUFFER_OVERFLOW) { SetLastError(ERROR_FILENAME_EXCED_RANGE); return FALSE; }
BaseSetLastNTError(Status); return FALSE; }
/* Convert target path if existing */ if (lpTargetPath != NULL) { RtlInitAnsiString(&AnsiString, lpTargetPath); Status = RtlAnsiStringToUnicodeString(&TargetPathU, &AnsiString, TRUE); if (!NT_SUCCESS(Status)) { BaseSetLastNTError(Status); return FALSE; }
TargetPathBuffer = TargetPathU.Buffer; } else { TargetPathBuffer = NULL; }
/* Call W */ Result = DefineDosDeviceW(dwFlags, DeviceNameU->Buffer, TargetPathBuffer);
/* Free target path if allocated */ if (TargetPathBuffer != NULL) { RtlFreeUnicodeString(&TargetPathU); }
return Result;}
/* * @implemented */BOOLWINAPIDefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath ){ ULONG ArgumentCount; ULONG BufferSize; BASE_API_MESSAGE ApiMessage; PBASE_DEFINE_DOS_DEVICE DefineDosDeviceRequest = &ApiMessage.Data.DefineDosDeviceRequest; PCSR_CAPTURE_BUFFER CaptureBuffer; UNICODE_STRING NtTargetPathU; UNICODE_STRING DeviceNameU; HANDLE hUser32; DEV_BROADCAST_VOLUME dbcv; DWORD dwRecipients; typedef long (WINAPI *BSM_type)(DWORD, LPDWORD, UINT, WPARAM, LPARAM); BSM_type BSM_ptr; BOOLEAN LUIDDeviceMapsEnabled; WCHAR Letter; WPARAM wParam;
/* Get status about local device mapping */ LUIDDeviceMapsEnabled = BaseStaticServerData->LUIDDeviceMapsEnabled;
/* Validate input & flags */ if ((dwFlags & 0xFFFFFFE0) || ((dwFlags & DDD_EXACT_MATCH_ON_REMOVE) && !(dwFlags & DDD_REMOVE_DEFINITION)) || (lpTargetPath == NULL && !(dwFlags & (DDD_LUID_BROADCAST_DRIVE | DDD_REMOVE_DEFINITION))) || ((dwFlags & DDD_LUID_BROADCAST_DRIVE) && (lpDeviceName == NULL || lpTargetPath != NULL || dwFlags & (DDD_NO_BROADCAST_SYSTEM | DDD_EXACT_MATCH_ON_REMOVE | DDD_RAW_TARGET_PATH) || !LUIDDeviceMapsEnabled))) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
/* Initialize device unicode string to ease its use */ RtlInitUnicodeString(&DeviceNameU, lpDeviceName);
/* The buffer for CSR call will contain it */ BufferSize = DeviceNameU.MaximumLength; ArgumentCount = 1;
/* If we don't have target path, use empty string */ if (lpTargetPath == NULL) { RtlInitUnicodeString(&NtTargetPathU, NULL); } else { /* Else, use it raw if asked to */ if (dwFlags & DDD_RAW_TARGET_PATH) { RtlInitUnicodeString(&NtTargetPathU, lpTargetPath); } else { /* Otherwise, use it converted */ if (!RtlDosPathNameToNtPathName_U(lpTargetPath, &NtTargetPathU, NULL, NULL)) { WARN("RtlDosPathNameToNtPathName_U() failed\n"); BaseSetLastNTError(STATUS_OBJECT_NAME_INVALID); return FALSE; } }
/* This target path will be the second arg */ ArgumentCount = 2; BufferSize += NtTargetPathU.MaximumLength; }
/* Allocate the capture buffer for our strings */ CaptureBuffer = CsrAllocateCaptureBuffer(ArgumentCount, BufferSize); if (CaptureBuffer == NULL) { if (!(dwFlags & DDD_RAW_TARGET_PATH)) { RtlFreeUnicodeString(&NtTargetPathU); }
SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; }
/* Set the flags */ DefineDosDeviceRequest->Flags = dwFlags;
/* Allocate a buffer for the device name */ DefineDosDeviceRequest->DeviceName.MaximumLength = CsrAllocateMessagePointer(CaptureBuffer, DeviceNameU.MaximumLength, (PVOID*)&DefineDosDeviceRequest->DeviceName.Buffer); /* And copy it while upcasing it */ RtlUpcaseUnicodeString(&DefineDosDeviceRequest->DeviceName, &DeviceNameU, FALSE);
/* If we have a target path, copy it too, and free it if allocated */ if (NtTargetPathU.Length != 0) { DefineDosDeviceRequest->TargetPath.MaximumLength = CsrAllocateMessagePointer(CaptureBuffer, NtTargetPathU.MaximumLength, (PVOID*)&DefineDosDeviceRequest->TargetPath.Buffer); RtlCopyUnicodeString(&DefineDosDeviceRequest->TargetPath, &NtTargetPathU);
if (!(dwFlags & DDD_RAW_TARGET_PATH)) { RtlFreeUnicodeString(&NtTargetPathU); } } /* Otherwise, null initialize the string */ else { RtlInitUnicodeString(&DefineDosDeviceRequest->TargetPath, NULL); }
/* Finally, call the server */ CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage, CaptureBuffer, CSR_CREATE_API_NUMBER(BASESRV_SERVERDLL_INDEX, BasepDefineDosDevice), sizeof(*DefineDosDeviceRequest)); CsrFreeCaptureBuffer(CaptureBuffer);
/* Return failure if any */ if (!NT_SUCCESS(ApiMessage.Status)) { WARN("CsrClientCallServer() failed (Status %lx)\n", ApiMessage.Status); BaseSetLastNTError(ApiMessage.Status); return FALSE; }
/* Here is the success path, we will always return true */
/* Should broadcast the event? Only do if not denied and if drive letter */ if (!(dwFlags & DDD_NO_BROADCAST_SYSTEM) && DeviceNameU.Length == 2 * sizeof(WCHAR) && DeviceNameU.Buffer[1] == L':') { /* Make sure letter is valid and there are no local device mappings */ Letter = RtlUpcaseUnicodeChar(DeviceNameU.Buffer[0]) - L'A'; if (Letter < 26 && !LUIDDeviceMapsEnabled) { /* Rely on user32 for broadcasting */ hUser32 = LoadLibraryW(L"user32.dll"); if (hUser32 != 0) { /* Get the function pointer */ BSM_ptr = (BSM_type)GetProcAddress(hUser32, "BroadcastSystemMessageW"); if (BSM_ptr) { /* Set our target */ dwRecipients = BSM_APPLICATIONS;
/* And initialize our structure */ dbcv.dbcv_size = sizeof(DEV_BROADCAST_VOLUME); dbcv.dbcv_devicetype = DBT_DEVTYP_VOLUME; dbcv.dbcv_reserved = 0;
/* Set the volume which had the event */ dbcv.dbcv_unitmask = 1 << Letter; dbcv.dbcv_flags = DBTF_NET;
/* And properly set the event (removal or arrival?) */ wParam = (dwFlags & DDD_REMOVE_DEFINITION) ? DBT_DEVICEREMOVECOMPLETE : DBT_DEVICEARRIVAL;
/* And broadcast! */ BSM_ptr(BSF_SENDNOTIFYMESSAGE | BSF_FLUSHDISK, &dwRecipients, WM_DEVICECHANGE, wParam, (LPARAM)&dbcv); }
/* We're done! */ FreeLibrary(hUser32); } } }
return TRUE;}
/* * @implemented */DWORDWINAPIQueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax ){ NTSTATUS Status; USHORT CurrentPosition; ANSI_STRING AnsiString; UNICODE_STRING TargetPathU; PUNICODE_STRING DeviceNameU; DWORD RetLength, CurrentLength, Length; PWSTR DeviceNameBuffer, TargetPathBuffer;
/* If we want a specific device name, convert it */ if (lpDeviceName != NULL) { /* Convert DeviceName using static unicode string */ RtlInitAnsiString(&AnsiString, lpDeviceName); DeviceNameU = &NtCurrentTeb()->StaticUnicodeString; Status = RtlAnsiStringToUnicodeString(DeviceNameU, &AnsiString, FALSE); if (!NT_SUCCESS(Status)) { /* * If the static unicode string is too small, * it's because the name is too long... * so, return appropriate status! */ if (Status == STATUS_BUFFER_OVERFLOW) { SetLastError(ERROR_FILENAME_EXCED_RANGE); return FALSE; }
BaseSetLastNTError(Status); return FALSE; }
DeviceNameBuffer = DeviceNameU->Buffer; } else { DeviceNameBuffer = NULL; }
/* Allocate the output buffer for W call */ TargetPathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, ucchMax * sizeof(WCHAR)); if (TargetPathBuffer == NULL) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return 0; }
/* Call W */ Length = QueryDosDeviceW(DeviceNameBuffer, TargetPathBuffer, ucchMax); /* We'll return that length in case of a success */ RetLength = Length;
/* Handle the case where we would fill output buffer completly */ if (Length != 0 && Length == ucchMax) { /* This will be our work length (but not the one we return) */ --Length; /* Already 0 the last char */ lpTargetPath[Length] = ANSI_NULL; }
/* If we had an output, start the convert loop */ if (Length != 0) { /* * We'll have to loop because TargetPathBuffer may contain * several strings (NULL separated) * We'll start at position 0 */ CurrentPosition = 0; while (CurrentPosition < Length) { /* Get the maximum length */ CurrentLength = min(Length - CurrentPosition, MAXUSHORT / 2);
/* Initialize our output string */ AnsiString.Length = 0; AnsiString.MaximumLength = CurrentLength + sizeof(ANSI_NULL); AnsiString.Buffer = &lpTargetPath[CurrentPosition];
/* Initialize input string that will be converted */ TargetPathU.Length = CurrentLength * sizeof(WCHAR); TargetPathU.MaximumLength = CurrentLength * sizeof(WCHAR) + sizeof(UNICODE_NULL); TargetPathU.Buffer = &TargetPathBuffer[CurrentPosition];
/* Convert to ANSI */ Status = RtlUnicodeStringToAnsiString(&AnsiString, &TargetPathU, FALSE); if (!NT_SUCCESS(Status)) { BaseSetLastNTError(Status); /* In case of a failure, forget about everything */ RetLength = 0;
goto Leave; }
/* Move to the next string */ CurrentPosition += CurrentLength; } }
Leave: /* Free our intermediate buffer and leave */ RtlFreeHeap(RtlGetProcessHeap(), 0, TargetPathBuffer);
return RetLength;}
/* * @implemented */DWORDWINAPIQueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax ){ PWSTR Ptr; PVOID Buffer; NTSTATUS Status; USHORT i, TotalEntries; UNICODE_STRING UnicodeString; OBJECT_ATTRIBUTES ObjectAttributes; HANDLE DirectoryHandle, DeviceHandle; BOOLEAN IsGlobal, GlobalNeeded, Found; POBJECT_DIRECTORY_INFORMATION DirInfo; OBJECT_DIRECTORY_INFORMATION NullEntry = {{0}}; ULONG ReturnLength, NameLength, Length, Context, BufferLength;
/* Open the '\??' directory */ RtlInitUnicodeString(&UnicodeString, L"\\??"); InitializeObjectAttributes(&ObjectAttributes, &UnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL); Status = NtOpenDirectoryObject(&DirectoryHandle, DIRECTORY_QUERY, &ObjectAttributes); if (!NT_SUCCESS(Status)) { WARN("NtOpenDirectoryObject() failed (Status %lx)\n", Status); BaseSetLastNTError(Status); return 0; }
Buffer = NULL; _SEH2_TRY { if (lpDeviceName != NULL) { /* Open the lpDeviceName link object */ RtlInitUnicodeString(&UnicodeString, lpDeviceName); InitializeObjectAttributes(&ObjectAttributes, &UnicodeString, OBJ_CASE_INSENSITIVE, DirectoryHandle, NULL); Status = NtOpenSymbolicLinkObject(&DeviceHandle, SYMBOLIC_LINK_QUERY, &ObjectAttributes); if (!NT_SUCCESS(Status)) { WARN("NtOpenSymbolicLinkObject() failed (Status %lx)\n", Status); _SEH2_LEAVE; }
/* * Make sure we don't overrun the output buffer, so convert our DWORD * size to USHORT size properly */ Length = (ucchMax <= MAXULONG / sizeof(WCHAR)) ? (ucchMax * sizeof(WCHAR)) : MAXULONG;
/* Query link target */ UnicodeString.Length = 0; UnicodeString.MaximumLength = Length <= MAXUSHORT ? Length : MAXUSHORT; UnicodeString.Buffer = lpTargetPath;
ReturnLength = 0; Status = NtQuerySymbolicLinkObject(DeviceHandle, &UnicodeString, &ReturnLength); NtClose(DeviceHandle); if (!NT_SUCCESS(Status)) { WARN("NtQuerySymbolicLinkObject() failed (Status %lx)\n", Status); _SEH2_LEAVE; }
TRACE("ReturnLength: %lu\n", ReturnLength); TRACE("TargetLength: %hu\n", UnicodeString.Length); TRACE("Target: '%wZ'\n", &UnicodeString);
Length = ReturnLength / sizeof(WCHAR); /* Make sure we null terminate output buffer */ if (Length == 0 || lpTargetPath[Length - 1] != UNICODE_NULL) { if (Length >= ucchMax) { TRACE("Buffer is too small\n"); Status = STATUS_BUFFER_TOO_SMALL; _SEH2_LEAVE; }
/* Append null-character */ lpTargetPath[Length] = UNICODE_NULL; Length++; }
if (Length < ucchMax) { /* Append null-character */ lpTargetPath[Length] = UNICODE_NULL; Length++; }
_SEH2_LEAVE; }
/* * If LUID device maps are enabled, * ?? may not point to BaseNamedObjects * It may only be local DOS namespace. * And thus, it might be required to browse * Global?? for global devices */ GlobalNeeded = FALSE; if (BaseStaticServerData->LUIDDeviceMapsEnabled) { /* Assume ?? == Global?? */ IsGlobal = TRUE; /* Check if it's the case */ Status = IsGlobalDeviceMap(DirectoryHandle, &IsGlobal); if (NT_SUCCESS(Status) && !IsGlobal) { /* It's not, we'll have to browse Global?? too! */ GlobalNeeded = TRUE; } }
/* * Make sure we don't overrun the output buffer, so convert our DWORD * size to USHORT size properly */ BufferLength = (ucchMax <= MAXULONG / sizeof(WCHAR)) ? (ucchMax * sizeof(WCHAR)) : MAXULONG; Length = 0; Ptr = lpTargetPath;
Context = 0; TotalEntries = 0;
/* * We'll query all entries at once, with a rather big buffer * If it's too small, we'll grow it by 2. * Limit the number of attempts to 3. */ for (i = 0; i < 3; ++i) { /* Allocate the query buffer */ Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); if (Buffer == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; _SEH2_LEAVE; }
/* Perform the query */ Status = NtQueryDirectoryObject(DirectoryHandle, Buffer, BufferLength, FALSE, TRUE, &Context, &ReturnLength); /* Only failure accepted is: no more entries */ if (!NT_SUCCESS(Status)) { if (Status != STATUS_NO_MORE_ENTRIES) { _SEH2_LEAVE; }
/* * Which is a success! But break out, * it means our query returned no results * so, nothing to parse. */ Status = STATUS_SUCCESS; break; }
/* In case we had them all, start browsing for devices */ if (Status != STATUS_MORE_ENTRIES) { DirInfo = Buffer;
/* Loop until we find the nul entry (terminating entry) */ while (TRUE) { /* It's an entry full of zeroes */ if (RtlCompareMemory(&NullEntry, DirInfo, sizeof(NullEntry)) == sizeof(NullEntry)) { break; }
/* Only handle symlinks */ if (!wcscmp(DirInfo->TypeName.Buffer, L"SymbolicLink")) { TRACE("Name: '%wZ'\n", &DirInfo->Name);
/* Get name length in chars to only comparisons */ NameLength = DirInfo->Name.Length / sizeof(WCHAR);
/* Make sure we don't overrun output buffer */ if (Length > ucchMax || NameLength > ucchMax - Length || ucchMax - NameLength - Length < sizeof(WCHAR)) { Status = STATUS_BUFFER_TOO_SMALL; _SEH2_LEAVE; }
/* Copy and NULL terminate string */ memcpy(Ptr, DirInfo->Name.Buffer, DirInfo->Name.Length); Ptr[NameLength] = UNICODE_NULL;
Ptr += (NameLength + 1); Length += (NameLength + 1);
/* * Keep the entries count, in case we would have to * handle GLOBAL?? too */ ++TotalEntries; }
/* Move to the next entry */ ++DirInfo; }
/* * No need to loop again here, we got all the entries * Note: we don't free the buffer here, because we may * need it for GLOBAL??, so we save a few cycles here. */ break; }
/* Failure path here, we'll need bigger buffer */ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer); Buffer = NULL;
/* We can't have bigger than that one, so leave */ if (BufferLength == MAXULONG) { break; }
/* Prevent any overflow while computing new size */ if (MAXULONG - BufferLength < BufferLength) { BufferLength = MAXULONG; } else { BufferLength *= 2; } }
/* * Out of the hot loop, but with more entries left? * that's an error case, leave here! */ if (Status == STATUS_MORE_ENTRIES) { Status = STATUS_BUFFER_TOO_SMALL; _SEH2_LEAVE; }
/* Now, if we had to handle GLOBAL??, go for it! */ if (BaseStaticServerData->LUIDDeviceMapsEnabled && NT_SUCCESS(Status) && GlobalNeeded) { NtClose(DirectoryHandle); DirectoryHandle = 0;
RtlInitUnicodeString(&UnicodeString, L"\\GLOBAL??"); InitializeObjectAttributes(&ObjectAttributes, &UnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL); Status = NtOpenDirectoryObject(&DirectoryHandle, DIRECTORY_QUERY, &ObjectAttributes); if (!NT_SUCCESS(Status)) { WARN("NtOpenDirectoryObject() failed (Status %lx)\n", Status); _SEH2_LEAVE; }
/* * We'll query all entries at once, with a rather big buffer * If it's too small, we'll grow it by 2. * Limit the number of attempts to 3. */ for (i = 0; i < 3; ++i) { /* If we had no buffer from previous attempt, allocate one */ if (Buffer == NULL) { Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); if (Buffer == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; _SEH2_LEAVE; } }
/* Perform the query */ Status = NtQueryDirectoryObject(DirectoryHandle, Buffer, BufferLength, FALSE, TRUE, &Context, &ReturnLength); /* Only failure accepted is: no more entries */ if (!NT_SUCCESS(Status)) { if (Status != STATUS_NO_MORE_ENTRIES) { _SEH2_LEAVE; }
/* * Which is a success! But break out, * it means our query returned no results * so, nothing to parse. */ Status = STATUS_SUCCESS; break; }
/* In case we had them all, start browsing for devices */ if (Status != STATUS_MORE_ENTRIES) { DirInfo = Buffer;
/* Loop until we find the nul entry (terminating entry) */ while (TRUE) { /* It's an entry full of zeroes */ if (RtlCompareMemory(&NullEntry, DirInfo, sizeof(NullEntry)) == sizeof(NullEntry)) { break; }
/* Only handle symlinks */ if (!wcscmp(DirInfo->TypeName.Buffer, L"SymbolicLink")) { TRACE("Name: '%wZ'\n", &DirInfo->Name);
/* * Now, we previously already browsed ??, and we * don't want to devices twice, so we'll check * the output buffer for duplicates. * We'll add our entry only if we don't have already * returned it. */ if (FindSymbolicLinkEntry(DirInfo->Name.Buffer, lpTargetPath, TotalEntries, &Found) == ERROR_SUCCESS && !Found) { /* Get name length in chars to only comparisons */ NameLength = DirInfo->Name.Length / sizeof(WCHAR);
/* Make sure we don't overrun output buffer */ if (Length > ucchMax || NameLength > ucchMax - Length || ucchMax - NameLength - Length < sizeof(WCHAR)) { RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer); NtClose(DirectoryHandle); BaseSetLastNTError(STATUS_BUFFER_TOO_SMALL); return 0; }
/* Copy and NULL terminate string */ memcpy(Ptr, DirInfo->Name.Buffer, DirInfo->Name.Length); Ptr[NameLength] = UNICODE_NULL;
Ptr += (NameLength + 1); Length += (NameLength + 1); } }
/* Move to the next entry */ ++DirInfo; }
/* No need to loop again here, we got all the entries */ break; }
/* Failure path here, we'll need bigger buffer */ RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer); Buffer = NULL;
/* We can't have bigger than that one, so leave */ if (BufferLength == MAXULONG) { break; }
/* Prevent any overflow while computing new size */ if (MAXULONG - BufferLength < BufferLength) { BufferLength = MAXULONG; } else { BufferLength *= 2; } }
/* * Out of the hot loop, but with more entries left? * that's an error case, leave here! */ if (Status == STATUS_MORE_ENTRIES) { Status = STATUS_BUFFER_TOO_SMALL; _SEH2_LEAVE; } }
/* If we failed somewhere, just leave */ if (!NT_SUCCESS(Status)) { _SEH2_LEAVE; }
/* If we returned no entries, time to write the empty string */ if (Length == 0) { /* Unless output buffer is too small! */ if (ucchMax <= 0) { Status = STATUS_BUFFER_TOO_SMALL; _SEH2_LEAVE; }
/* Emptry string is one char (terminator!) */ *Ptr = UNICODE_NULL; ++Ptr; Length = 1; }
/* * If we have enough room, we need to double terminate the buffer: * that's a MULTI_SZ buffer, its end is marked by double NULL. * One was already added during the "copy string" process. * If we don't have enough room: that's a failure case. */ if (Length < ucchMax) { *Ptr = UNICODE_NULL; ++Ptr; } else { Status = STATUS_BUFFER_TOO_SMALL; } } _SEH2_FINALLY { if (DirectoryHandle != 0) { NtClose(DirectoryHandle); }
if (Buffer != NULL) { RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer); }
if (!NT_SUCCESS(Status)) { Length = 0; BaseSetLastNTError(Status); } } _SEH2_END;
return Length;}
/* EOF */