[HNETCFG] Sync with Wine 3.0. CORE-14225
[reactos.git] / win32ss / drivers / videoprt / registry.c
1 /*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002-2004, 2007 ReactOS Team
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include "videoprt.h"
23
24 #include <ndk/obfuncs.h>
25
26 #define NDEBUG
27 #include <debug.h>
28
29 NTSTATUS
30 NTAPI
31 IntCopyRegistryKey(
32 _In_ HANDLE SourceKeyHandle,
33 _In_ HANDLE DestKeyHandle)
34 {
35 PVOID InfoBuffer;
36 PKEY_BASIC_INFORMATION KeyInformation;
37 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
38 OBJECT_ATTRIBUTES ObjectAttributes;
39 ULONG Index, InformationLength, RequiredLength;
40 UNICODE_STRING NameString;
41 NTSTATUS Status;
42 HANDLE SourceSubKeyHandle, DestSubKeyHandle;
43
44 /* Start with no buffer, set initial size */
45 InfoBuffer = NULL;
46 InformationLength = 256;
47
48 /* Start looping with key index 0 */
49 Index = 0;
50 while (TRUE)
51 {
52 /* Check if we have no buffer */
53 if (InfoBuffer == NULL)
54 {
55 /* Allocate a new buffer */
56 InfoBuffer = ExAllocatePoolWithTag(PagedPool,
57 InformationLength,
58 TAG_VIDEO_PORT_BUFFER);
59 if (InfoBuffer == NULL)
60 {
61 ERR_(VIDEOPRT, "Could not allocate buffer for key info\n");
62 return STATUS_INSUFFICIENT_RESOURCES;
63 }
64 }
65
66 /* Enumerate the next sub-key */
67 KeyInformation = InfoBuffer;
68 Status = ZwEnumerateKey(SourceKeyHandle,
69 Index,
70 KeyBasicInformation,
71 KeyInformation,
72 InformationLength,
73 &RequiredLength);
74 if ((Status == STATUS_BUFFER_OVERFLOW) ||
75 (Status == STATUS_BUFFER_TOO_SMALL))
76 {
77 /* Free the buffer and remember the required size */
78 ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
79 InfoBuffer = NULL;
80 InformationLength = RequiredLength;
81
82 /* Try again */
83 continue;
84 }
85 else if (Status == STATUS_NO_MORE_ENTRIES)
86 {
87 /* We are done with the sub-keys */
88 break;
89 }
90 else if (!NT_SUCCESS(Status))
91 {
92 ERR_(VIDEOPRT, "ZwEnumerateKey failed, status 0x%lx\n", Status);
93 goto Cleanup;
94 }
95
96 /* Initialize a unicode string from the key name */
97 NameString.Buffer = KeyInformation->Name;
98 NameString.Length = (USHORT)KeyInformation->NameLength;
99 NameString.MaximumLength = NameString.Length;
100
101 /* Initialize object attributes and open the source sub-key */
102 InitializeObjectAttributes(&ObjectAttributes,
103 &NameString,
104 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
105 SourceKeyHandle,
106 NULL);
107 Status = ZwOpenKey(&SourceSubKeyHandle, KEY_READ, &ObjectAttributes);
108 if (!NT_SUCCESS(Status))
109 {
110 ERR_(VIDEOPRT, "failed to open the source key.\n");
111 goto Cleanup;
112 }
113
114 /* Initialize object attributes and create the dest sub-key */
115 InitializeObjectAttributes(&ObjectAttributes,
116 &NameString,
117 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
118 DestKeyHandle,
119 NULL);
120 Status = ZwCreateKey(&DestSubKeyHandle,
121 KEY_WRITE,
122 &ObjectAttributes,
123 0,
124 NULL,
125 0,
126 NULL);
127 if (!NT_SUCCESS(Status))
128 {
129 ERR_(VIDEOPRT, "failed to create the destination key.\n");
130 ObCloseHandle(SourceSubKeyHandle, KernelMode);
131 goto Cleanup;
132 }
133
134 /* Recursively copy the sub-key */
135 Status = IntCopyRegistryKey(SourceSubKeyHandle, DestSubKeyHandle);
136 if (!NT_SUCCESS(Status))
137 {
138 /* Just warn, but continue with the remaining sub-keys */
139 WARN_(VIDEOPRT, "failed to copy subkey '%wZ'.\n", &NameString);
140 }
141
142 /* Close the sub-key handles */
143 ObCloseHandle(SourceSubKeyHandle, KernelMode);
144 ObCloseHandle(DestSubKeyHandle, KernelMode);
145
146 /* Next sub-key */
147 Index++;
148 }
149
150 /* Start looping with value index 0 */
151 Index = 0;
152 while (TRUE)
153 {
154 /* Check if we have no buffer */
155 if (InfoBuffer == NULL)
156 {
157 /* Allocate a new buffer */
158 InfoBuffer = ExAllocatePoolWithTag(PagedPool,
159 InformationLength,
160 TAG_VIDEO_PORT_BUFFER);
161 if (InfoBuffer == NULL)
162 {
163 ERR_(VIDEOPRT, "Could not allocate buffer for key values\n");
164 return Status;
165 }
166 }
167
168 /* Enumerate the next value */
169 KeyValueInformation = InfoBuffer;
170 Status = ZwEnumerateValueKey(SourceKeyHandle,
171 Index,
172 KeyValueFullInformation,
173 KeyValueInformation,
174 InformationLength,
175 &RequiredLength);
176 if ((Status == STATUS_BUFFER_OVERFLOW) ||
177 (Status == STATUS_BUFFER_TOO_SMALL))
178 {
179 /* Free the buffer and remember the required size */
180 ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
181 InfoBuffer = NULL;
182 InformationLength = RequiredLength;
183
184 /* Try again */
185 continue;
186 }
187 else if (Status == STATUS_NO_MORE_ENTRIES)
188 {
189 /* We are done with the values */
190 Status = STATUS_SUCCESS;
191 break;
192 }
193 else if (!NT_SUCCESS(Status))
194 {
195 ERR_(VIDEOPRT, "ZwEnumerateValueKey failed, status 0x%lx\n", Status);
196 goto Cleanup;
197 }
198
199 /* Initialize a unicode string from the value name */
200 NameString.Buffer = KeyValueInformation->Name;
201 NameString.Length = (USHORT)KeyValueInformation->NameLength;
202 NameString.MaximumLength = NameString.Length;
203
204 /* Create the key value in the destination key */
205 Status = ZwSetValueKey(DestKeyHandle,
206 &NameString,
207 KeyValueInformation->TitleIndex,
208 KeyValueInformation->Type,
209 (PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset,
210 KeyValueInformation->DataLength);
211 if (!NT_SUCCESS(Status))
212 {
213 /* Just warn, but continue with the remaining sub-keys */
214 WARN_(VIDEOPRT, "failed to set value '%wZ'.\n", &NameString);
215 }
216
217 /* Next subkey */
218 Index++;
219 }
220
221 Cleanup:
222 /* Free the buffer and return the failure code */
223 if (InfoBuffer != NULL)
224 ExFreePoolWithTag(InfoBuffer, TAG_VIDEO_PORT_BUFFER);
225 return Status;
226 }
227
228 NTSTATUS
229 NTAPI
230 IntCopyRegistryValue(
231 HANDLE SourceKeyHandle,
232 HANDLE DestKeyHandle,
233 PWSTR ValueName)
234 {
235 PKEY_VALUE_PARTIAL_INFORMATION ValueInformation;
236 UNICODE_STRING ValueNameString;
237 ULONG Length;
238 NTSTATUS Status;
239
240 RtlInitUnicodeString(&ValueNameString, ValueName);
241
242 /* Query the value length */
243 Status = ZwQueryValueKey(SourceKeyHandle,
244 &ValueNameString,
245 KeyValuePartialInformation,
246 NULL,
247 0,
248 &Length);
249 if ((Status != STATUS_BUFFER_OVERFLOW) &&
250 (Status != STATUS_BUFFER_TOO_SMALL))
251 {
252 /* The key seems not present */
253 NT_ASSERT(!NT_SUCCESS(Status));
254 return Status;
255 }
256
257 /* Allocate a buffer */
258 ValueInformation = ExAllocatePoolWithTag(PagedPool, Length, TAG_VIDEO_PORT_BUFFER);
259 if (ValueInformation == NULL)
260 {
261 return Status;
262 }
263
264 /* Query the value */
265 Status = ZwQueryValueKey(SourceKeyHandle,
266 &ValueNameString,
267 KeyValuePartialInformation,
268 ValueInformation,
269 Length,
270 &Length);
271 if (!NT_SUCCESS(Status))
272 {
273 ExFreePoolWithTag(ValueInformation, TAG_VIDEO_PORT_BUFFER);
274 return Status;
275 }
276
277 /* Write the registry value */
278 Status = ZwSetValueKey(DestKeyHandle,
279 &ValueNameString,
280 ValueInformation->TitleIndex,
281 ValueInformation->Type,
282 ValueInformation->Data,
283 ValueInformation->DataLength);
284
285 ExFreePoolWithTag(ValueInformation, TAG_VIDEO_PORT_BUFFER);
286
287 if (!NT_SUCCESS(Status))
288 {
289 ERR_(VIDEOPRT, "ZwSetValueKey failed: status 0x%lx\n", Status);
290 }
291
292 return Status;
293 }
294
295 NTSTATUS
296 NTAPI
297 IntSetupDeviceSettingsKey(
298 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
299 {
300 static UNICODE_STRING SettingsKeyName = RTL_CONSTANT_STRING(L"Settings");
301 HANDLE DevInstRegKey, SourceKeyHandle, DestKeyHandle;
302 OBJECT_ATTRIBUTES ObjectAttributes;
303 NTSTATUS Status;
304
305 /* Open the software key: HKLM\System\CurrentControlSet\Control\Class\<ClassGUID>\<n> */
306 Status = IoOpenDeviceRegistryKey(DeviceExtension->PhysicalDeviceObject,
307 PLUGPLAY_REGKEY_DRIVER,
308 KEY_ALL_ACCESS,
309 &DevInstRegKey);
310 if (Status != STATUS_SUCCESS)
311 {
312 ERR_(VIDEOPRT, "Failed to open device software key. Status 0x%lx\n", Status);
313 return Status;
314 }
315
316 /* Open the 'Settings' sub-key */
317 InitializeObjectAttributes(&ObjectAttributes,
318 &SettingsKeyName,
319 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
320 DevInstRegKey,
321 NULL);
322 Status = ZwOpenKey(&DestKeyHandle, KEY_WRITE, &ObjectAttributes);
323
324 /* Close the device software key */
325 ObCloseHandle(DevInstRegKey, KernelMode);
326
327 if (Status != STATUS_SUCCESS)
328 {
329 ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
330 return Status;
331 }
332
333 /* Open the device profile key */
334 InitializeObjectAttributes(&ObjectAttributes,
335 &DeviceExtension->RegistryPath,
336 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
337 NULL,
338 NULL);
339 Status = ZwOpenKey(&SourceKeyHandle, KEY_WRITE, &ObjectAttributes);
340 if (Status != STATUS_SUCCESS)
341 {
342 ERR_(VIDEOPRT, "ZwOpenKey failed for settings key: status 0x%lx\n", Status);
343 ObCloseHandle(DestKeyHandle, KernelMode);
344 return Status;
345 }
346
347 IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"InstalledDisplayDrivers");
348 IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"Attach.ToDesktop");
349
350 ObCloseHandle(SourceKeyHandle, KernelMode);
351 ObCloseHandle(DestKeyHandle, KernelMode);
352
353 return STATUS_SUCCESS;
354 }
355
356 NTSTATUS
357 NTAPI
358 IntCreateNewRegistryPath(
359 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
360 {
361 static UNICODE_STRING VideoIdValueName = RTL_CONSTANT_STRING(L"VideoId");
362 static UNICODE_STRING ControlVideoPathName =
363 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Video\\");
364 HANDLE DevInstRegKey, SettingsKey, NewKey;
365 UCHAR VideoIdBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + GUID_STRING_LENGTH];
366 UNICODE_STRING VideoIdString;
367 UUID VideoId;
368 PKEY_VALUE_PARTIAL_INFORMATION ValueInformation ;
369 NTSTATUS Status;
370 ULONG ResultLength;
371 USHORT KeyMaxLength;
372 OBJECT_ATTRIBUTES ObjectAttributes;
373
374 /* Open the hardware key: HKLM\System\CurrentControlSet\Enum\... */
375 Status = IoOpenDeviceRegistryKey(DeviceExtension->PhysicalDeviceObject,
376 PLUGPLAY_REGKEY_DEVICE,
377 KEY_ALL_ACCESS,
378 &DevInstRegKey);
379 if (Status != STATUS_SUCCESS)
380 {
381 ERR_(VIDEOPRT, "IoOpenDeviceRegistryKey failed: status 0x%lx\n", Status);
382 return Status;
383 }
384
385 /* Query the VideoId value */
386 ValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION)VideoIdBuffer;
387 Status = ZwQueryValueKey(DevInstRegKey,
388 &VideoIdValueName,
389 KeyValuePartialInformation,
390 ValueInformation,
391 sizeof(VideoIdBuffer),
392 &ResultLength);
393 if (!NT_SUCCESS(Status))
394 {
395 /* Create a new video Id */
396 Status = ExUuidCreate(&VideoId);
397 if (!NT_SUCCESS(Status))
398 {
399 ERR_(VIDEOPRT, "ExUuidCreate failed: status 0x%lx\n", Status);
400 ObCloseHandle(DevInstRegKey, KernelMode);
401 return Status;
402 }
403
404 /* Convert the GUID into a string */
405 Status = RtlStringFromGUID(&VideoId, &VideoIdString);
406 if (!NT_SUCCESS(Status))
407 {
408 ERR_(VIDEOPRT, "RtlStringFromGUID failed: status 0x%lx\n", Status);
409 ObCloseHandle(DevInstRegKey, KernelMode);
410 return Status;
411 }
412
413 /* Copy the GUID String to our buffer */
414 ValueInformation->DataLength = min(VideoIdString.Length, GUID_STRING_LENGTH);
415 RtlCopyMemory(ValueInformation->Data,
416 VideoIdString.Buffer,
417 ValueInformation->DataLength);
418
419 /* Free the GUID string */
420 RtlFreeUnicodeString(&VideoIdString);
421
422 /* Write the VideoId registry value */
423 Status = ZwSetValueKey(DevInstRegKey,
424 &VideoIdValueName,
425 0,
426 REG_SZ,
427 ValueInformation->Data,
428 ValueInformation->DataLength);
429 if (!NT_SUCCESS(Status))
430 {
431 ERR_(VIDEOPRT, "ZwSetValueKey failed: status 0x%lx\n", Status);
432 ObCloseHandle(DevInstRegKey, KernelMode);
433 return Status;
434 }
435 }
436
437 /* Initialize the VideoId string from the registry data */
438 VideoIdString.Buffer = (PWCHAR)ValueInformation->Data;
439 VideoIdString.Length = (USHORT)ValueInformation->DataLength;
440 VideoIdString.MaximumLength = VideoIdString.Length;
441
442 /* Close the hardware key */
443 ObCloseHandle(DevInstRegKey, KernelMode);
444
445 /* Calculate the size needed for the new registry path name */
446 KeyMaxLength = ControlVideoPathName.Length +
447 VideoIdString.Length +
448 sizeof(L"\\0000");
449
450 /* Allocate the path name buffer */
451 DeviceExtension->NewRegistryPath.Length = 0;
452 DeviceExtension->NewRegistryPath.MaximumLength = KeyMaxLength;
453 DeviceExtension->NewRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool,
454 KeyMaxLength,
455 TAG_VIDEO_PORT);
456 if (DeviceExtension->NewRegistryPath.Buffer == NULL)
457 {
458 ERR_(VIDEOPRT, "Failed to allocate key name buffer.\n");
459 return STATUS_INSUFFICIENT_RESOURCES;
460 }
461
462 /* Copy the root key name and append the VideoId string */
463 RtlCopyUnicodeString(&DeviceExtension->NewRegistryPath,
464 &ControlVideoPathName);
465 RtlAppendUnicodeStringToString(&DeviceExtension->NewRegistryPath,
466 &VideoIdString);
467
468 /* Check if we have the key already */
469 Status = RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE,
470 DeviceExtension->NewRegistryPath.Buffer);
471 if (Status != STATUS_SUCCESS)
472 {
473 /* Try to create the new key */
474 Status = RtlCreateRegistryKey(RTL_REGISTRY_ABSOLUTE,
475 DeviceExtension->NewRegistryPath.Buffer);
476 }
477
478 /* Append a the instance path */ /// \todo HACK
479 RtlAppendUnicodeToString(&DeviceExtension->NewRegistryPath, L"\\");
480 RtlAppendUnicodeToString(&DeviceExtension->NewRegistryPath, L"0000");
481
482 /* Check this key again */
483 Status = RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE,
484 DeviceExtension->NewRegistryPath.Buffer);
485 if (Status != STATUS_SUCCESS)
486 {
487 /* Try to create the new key */
488 Status = RtlCreateRegistryKey(RTL_REGISTRY_ABSOLUTE,
489 DeviceExtension->NewRegistryPath.Buffer);
490 if (!NT_SUCCESS(Status))
491 {
492 ERR_(VIDEOPRT, "Failed create key '%wZ'\n", &DeviceExtension->NewRegistryPath);
493 return Status;
494 }
495
496 /* Open the new key */
497 InitializeObjectAttributes(&ObjectAttributes,
498 &DeviceExtension->NewRegistryPath,
499 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
500 NULL,
501 NULL);
502 Status = ZwOpenKey(&NewKey, KEY_READ, &ObjectAttributes);
503 if (!NT_SUCCESS(Status))
504 {
505 ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
506 return Status;
507 }
508
509 /* Open the device profile key */
510 InitializeObjectAttributes(&ObjectAttributes,
511 &DeviceExtension->RegistryPath,
512 OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
513 NULL,
514 NULL);
515 Status = ZwOpenKey(&SettingsKey, KEY_READ, &ObjectAttributes);
516 if (!NT_SUCCESS(Status))
517 {
518 ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx\n", Status);
519 ObCloseHandle(NewKey, KernelMode);
520 return Status;
521 }
522
523 /* Copy the registry data from the legacy key */
524 Status = IntCopyRegistryKey(SettingsKey, NewKey);
525 }
526
527
528 return Status;
529 }
530
531 NTSTATUS
532 NTAPI
533 IntCreateRegistryPath(
534 IN PCUNICODE_STRING DriverRegistryPath,
535 OUT PUNICODE_STRING DeviceRegistryPath)
536 {
537 static WCHAR RegistryMachineSystem[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\";
538 static WCHAR CurrentControlSet[] = L"CURRENTCONTROLSET\\";
539 static WCHAR ControlSet[] = L"CONTROLSET";
540 static WCHAR Insert1[] = L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
541 static WCHAR Insert2[] = L"\\Device0";
542 BOOLEAN Valid;
543 UNICODE_STRING AfterControlSet;
544
545 AfterControlSet = *DriverRegistryPath;
546
547 /* Check if path begins with \\REGISTRY\\MACHINE\\SYSTEM\\ */
548 Valid = (DriverRegistryPath->Length > sizeof(RegistryMachineSystem) &&
549 0 == _wcsnicmp(DriverRegistryPath->Buffer, RegistryMachineSystem,
550 wcslen(RegistryMachineSystem)));
551 if (Valid)
552 {
553 AfterControlSet.Buffer += wcslen(RegistryMachineSystem);
554 AfterControlSet.Length -= sizeof(RegistryMachineSystem) - sizeof(UNICODE_NULL);
555
556 /* Check if path contains CURRENTCONTROLSET */
557 if (AfterControlSet.Length > sizeof(CurrentControlSet) &&
558 0 == _wcsnicmp(AfterControlSet.Buffer, CurrentControlSet, wcslen(CurrentControlSet)))
559 {
560 AfterControlSet.Buffer += wcslen(CurrentControlSet);
561 AfterControlSet.Length -= sizeof(CurrentControlSet) - sizeof(UNICODE_NULL);
562 }
563 /* Check if path contains CONTROLSETnum */
564 else if (AfterControlSet.Length > sizeof(ControlSet) &&
565 0 == _wcsnicmp(AfterControlSet.Buffer, ControlSet, wcslen(ControlSet)))
566 {
567 AfterControlSet.Buffer += wcslen(ControlSet);
568 AfterControlSet.Length -= sizeof(ControlSet) - sizeof(UNICODE_NULL);
569 while (AfterControlSet.Length > 0 &&
570 *AfterControlSet.Buffer >= L'0' &&
571 *AfterControlSet.Buffer <= L'9')
572 {
573 AfterControlSet.Buffer++;
574 AfterControlSet.Length -= sizeof(WCHAR);
575 }
576
577 Valid = (AfterControlSet.Length > 0 && L'\\' == *AfterControlSet.Buffer);
578 AfterControlSet.Buffer++;
579 AfterControlSet.Length -= sizeof(WCHAR);
580 AfterControlSet.MaximumLength = AfterControlSet.Length;
581 }
582 else
583 {
584 Valid = FALSE;
585 }
586 }
587
588 if (Valid)
589 {
590 DeviceRegistryPath->MaximumLength = DriverRegistryPath->Length + sizeof(Insert1) + sizeof(Insert2);
591 DeviceRegistryPath->Buffer = ExAllocatePoolWithTag(PagedPool,
592 DeviceRegistryPath->MaximumLength,
593 TAG_VIDEO_PORT);
594 if (DeviceRegistryPath->Buffer != NULL)
595 {
596 /* Build device path */
597 wcsncpy(DeviceRegistryPath->Buffer,
598 DriverRegistryPath->Buffer,
599 AfterControlSet.Buffer - DriverRegistryPath->Buffer);
600 DeviceRegistryPath->Length = (AfterControlSet.Buffer - DriverRegistryPath->Buffer) * sizeof(WCHAR);
601 RtlAppendUnicodeToString(DeviceRegistryPath, Insert1);
602 RtlAppendUnicodeStringToString(DeviceRegistryPath, &AfterControlSet);
603 RtlAppendUnicodeToString(DeviceRegistryPath, Insert2);
604
605 /* Check if registry key exists */
606 Valid = NT_SUCCESS(RtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE, DeviceRegistryPath->Buffer));
607
608 if (!Valid)
609 ExFreePoolWithTag(DeviceRegistryPath->Buffer, TAG_VIDEO_PORT);
610 }
611 else
612 {
613 Valid = FALSE;
614 }
615 }
616 else
617 {
618 WARN_(VIDEOPRT, "Unparsable registry path %wZ\n", DriverRegistryPath);
619 }
620
621 /* If path doesn't point to *ControlSet*, use DriverRegistryPath directly */
622 if (!Valid)
623 {
624 DeviceRegistryPath->MaximumLength = DriverRegistryPath->Length + sizeof(Insert2);
625 DeviceRegistryPath->Buffer = ExAllocatePoolWithTag(NonPagedPool,
626 DeviceRegistryPath->MaximumLength,
627 TAG_VIDEO_PORT);
628
629 if (!DeviceRegistryPath->Buffer)
630 return STATUS_NO_MEMORY;
631
632 RtlCopyUnicodeString(DeviceRegistryPath, DriverRegistryPath);
633 RtlAppendUnicodeToString(DeviceRegistryPath, Insert2);
634 }
635
636 DPRINT("Formatted registry key '%wZ' -> '%wZ'\n",
637 DriverRegistryPath, DeviceRegistryPath);
638
639 return STATUS_SUCCESS;
640 }