[KERNEL32]
[reactos.git] / reactos / dll / win32 / kernel32 / client / file / mntpoint.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/kernel32/client/file/mntpoint.c
5 * PURPOSE: File volume mount point functions
6 * PROGRAMMER: Pierre Schweitzer (pierre@reactos.org)
7 */
8
9 #include <k32.h>
10 #define NDEBUG
11 #include <debug.h>
12
13 /*
14 * @implemented
15 */
16 static BOOL
17 GetVolumeNameForRoot(IN LPCWSTR lpszRootPath,
18 OUT LPWSTR lpszVolumeName,
19 IN DWORD cchBufferLength)
20 {
21 BOOL Ret;
22 NTSTATUS Status;
23 PWSTR FoundVolume;
24 DWORD BytesReturned;
25 UNICODE_STRING NtPathName;
26 IO_STATUS_BLOCK IoStatusBlock;
27 PMOUNTMGR_MOUNT_POINT MountPoint;
28 ULONG CurrentMntPt, FoundVolumeLen;
29 PMOUNTMGR_MOUNT_POINTS MountPoints;
30 OBJECT_ATTRIBUTES ObjectAttributes;
31 HANDLE VolumeHandle, MountMgrHandle;
32 struct
33 {
34 MOUNTDEV_NAME;
35 WCHAR Buffer[MAX_PATH];
36 } MountDevName;
37
38 /* It makes no sense on a non-local drive */
39 if (GetDriveTypeW(lpszRootPath) == DRIVE_REMOTE)
40 {
41 SetLastError(ERROR_PATH_NOT_FOUND);
42 return FALSE;
43 }
44
45 /* Get the NT path */
46 if (!RtlDosPathNameToNtPathName_U(lpszRootPath, &NtPathName, NULL, NULL))
47 {
48 SetLastError(ERROR_PATH_NOT_FOUND);
49 return FALSE;
50 }
51
52 /* If it's a root path - likely - drop backslash to open volume */
53 if (NtPathName.Buffer[(NtPathName.Length / sizeof(WCHAR)) - 1] == L'\\')
54 {
55 NtPathName.Buffer[(NtPathName.Length / sizeof(WCHAR)) - 1] = UNICODE_NULL;
56 NtPathName.Length -= sizeof(WCHAR);
57 }
58
59 /* If that's a DOS volume, upper case the letter */
60 if (NtPathName.Length >= 2 * sizeof(WCHAR))
61 {
62 if (NtPathName.Buffer[(NtPathName.Length / sizeof(WCHAR)) - 1] == L':')
63 {
64 NtPathName.Buffer[(NtPathName.Length / sizeof(WCHAR)) - 2] = _toupper(NtPathName.Buffer[(NtPathName.Length / sizeof(WCHAR)) - 2]);
65 }
66 }
67
68 /* Attempt to open the volume */
69 InitializeObjectAttributes(&ObjectAttributes, &NtPathName,
70 OBJ_CASE_INSENSITIVE, NULL, NULL);
71 Status = NtOpenFile(&VolumeHandle, SYNCHRONIZE | FILE_READ_ATTRIBUTES,
72 &ObjectAttributes, &IoStatusBlock,
73 FILE_SHARE_READ | FILE_SHARE_WRITE,
74 FILE_SYNCHRONOUS_IO_ALERT);
75 if (!NT_SUCCESS(Status))
76 {
77 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
78 BaseSetLastNTError(Status);
79 return FALSE;
80 }
81
82 /* Query the device name - that's what we'll translate */
83 if (!DeviceIoControl(VolumeHandle, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL,
84 0, &MountDevName, sizeof(MountDevName), &BytesReturned,
85 NULL))
86 {
87 NtClose(VolumeHandle);
88 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
89 return FALSE;
90 }
91
92 /* No longer need the volume */
93 NtClose(VolumeHandle);
94 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
95
96 /* We'll keep the device name for later usage */
97 NtPathName.Length = MountDevName.NameLength;
98 NtPathName.MaximumLength = MountDevName.NameLength + sizeof(UNICODE_NULL);
99 NtPathName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, NtPathName.MaximumLength);
100 if (NtPathName.Buffer == NULL)
101 {
102 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
103 return FALSE;
104 }
105
106 RtlCopyMemory(NtPathName.Buffer, MountDevName.Name, NtPathName.Length);
107 NtPathName.Buffer[NtPathName.Length / sizeof(WCHAR)] = UNICODE_NULL;
108
109 /* Allocate the structure for querying the mount mgr */
110 MountPoint = RtlAllocateHeap(RtlGetProcessHeap(), 0,
111 NtPathName.Length + sizeof(MOUNTMGR_MOUNT_POINT));
112 if (MountPoint == NULL)
113 {
114 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
115 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
116 return FALSE;
117 }
118
119 /* 0 everything, we provide a device name */
120 RtlZeroMemory(MountPoint, sizeof(MOUNTMGR_MOUNT_POINT));
121 MountPoint->DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
122 MountPoint->DeviceNameLength = NtPathName.Length;
123 RtlCopyMemory((PVOID)((ULONG_PTR)MountPoint + sizeof(MOUNTMGR_MOUNT_POINT)), NtPathName.Buffer, NtPathName.Length);
124
125 /* Allocate a dummy output buffer to probe for size */
126 MountPoints = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(MOUNTMGR_MOUNT_POINTS));
127 if (MountPoints == NULL)
128 {
129 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
130 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
131 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
132 return FALSE;
133 }
134
135 /* Open a handle to the mount manager */
136 MountMgrHandle = CreateFileW(MOUNTMGR_DOS_DEVICE_NAME, 0,
137 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
138 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
139 INVALID_HANDLE_VALUE);
140 if (MountMgrHandle == INVALID_HANDLE_VALUE)
141 {
142 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
143 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
144 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
145 return FALSE;
146 }
147
148 /* Query the names associated to our device name */
149 Ret = DeviceIoControl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS,
150 MountPoint, NtPathName.Length + sizeof(MOUNTMGR_MOUNT_POINT),
151 MountPoints, sizeof(MOUNTMGR_MOUNT_POINTS), &BytesReturned,
152 NULL);
153 /* As long as the buffer is too small, keep looping */
154 while (!Ret && GetLastError() == ERROR_MORE_DATA)
155 {
156 ULONG BufferSize;
157
158 /* Get the size we've to allocate */
159 BufferSize = MountPoints->Size;
160 /* Reallocate the buffer with enough room */
161 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
162 MountPoints = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
163 if (MountPoints == NULL)
164 {
165 CloseHandle(MountMgrHandle);
166 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
167 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
168 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
169 return FALSE;
170 }
171
172 /* Reissue the request, it should work now! */
173 Ret = DeviceIoControl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS,
174 MountPoint, NtPathName.Length + sizeof(MOUNTMGR_MOUNT_POINT),
175 MountPoints, BufferSize, &BytesReturned, NULL);
176 }
177
178 /* We're done, no longer need the mount manager */
179 CloseHandle(MountMgrHandle);
180 /* Nor our input buffer */
181 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoint);
182
183 /* If the mount manager failed, just quit */
184 if (!Ret)
185 {
186 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
187 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
188 SetLastError(ERROR_INVALID_PARAMETER);
189 return FALSE;
190 }
191
192 CurrentMntPt = 0;
193 /* If there were no associated mount points, we'll return the device name */
194 if (MountPoints->NumberOfMountPoints == 0)
195 {
196 FoundVolume = NtPathName.Buffer;
197 FoundVolumeLen = NtPathName.Length;
198 }
199 /* Otherwise, find one which is matching */
200 else
201 {
202 for (; CurrentMntPt < MountPoints->NumberOfMountPoints; ++CurrentMntPt)
203 {
204 UNICODE_STRING SymbolicLink;
205
206 /* Make a string of it, to easy the checks */
207 SymbolicLink.Length = MountPoints->MountPoints[CurrentMntPt].SymbolicLinkNameLength;
208 SymbolicLink.MaximumLength = SymbolicLink.Length;
209 SymbolicLink.Buffer = (PVOID)((ULONG_PTR)&MountPoints->MountPoints[CurrentMntPt] + MountPoints->MountPoints[CurrentMntPt].SymbolicLinkNameOffset);
210 /* If that's a NT volume name (GUID form), keep it! */
211 if (MOUNTMGR_IS_NT_VOLUME_NAME(&SymbolicLink))
212 {
213 FoundVolume = SymbolicLink.Buffer;
214 FoundVolumeLen = SymbolicLink.Length;
215
216 break;
217 }
218 }
219 }
220
221 /* We couldn't find anything matching, return an error */
222 if (CurrentMntPt == MountPoints->NumberOfMountPoints)
223 {
224 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
225 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
226 SetLastError(ERROR_INVALID_PARAMETER);
227 return FALSE;
228 }
229
230 /* We found a matching volume, have we enough memory to return it? */
231 if (cchBufferLength * sizeof(WCHAR) < FoundVolumeLen + 2 * sizeof(WCHAR))
232 {
233 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
234 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
235 SetLastError(ERROR_FILENAME_EXCED_RANGE);
236 return FALSE;
237 }
238
239 /* Copy it back! */
240 RtlCopyMemory(lpszVolumeName, FoundVolume, FoundVolumeLen);
241 /* Make it compliant */
242 lpszVolumeName[1] = L'\\';
243 /* And transform it as root path */
244 lpszVolumeName[FoundVolumeLen / sizeof(WCHAR)] = L'\\';
245 lpszVolumeName[FoundVolumeLen / sizeof(WCHAR) + 1] = UNICODE_NULL;
246
247 /* We're done! */
248 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
249 RtlFreeHeap(RtlGetProcessHeap(), 0, MountPoints);
250 return TRUE;
251 }
252
253 /*
254 * @implemented
255 */
256 static BOOL
257 BasepGetVolumeNameFromReparsePoint(IN LPCWSTR lpszMountPoint,
258 OUT LPWSTR lpszVolumeName,
259 IN DWORD cchBufferLength,
260 OUT LPBOOL IsAMountPoint)
261 {
262 WCHAR Old;
263 DWORD BytesReturned;
264 HANDLE ReparseHandle;
265 UNICODE_STRING SubstituteName;
266 PREPARSE_DATA_BUFFER ReparseBuffer;
267
268 /* Try to open the reparse point */
269 ReparseHandle = CreateFileW(lpszMountPoint, 0,
270 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
271 OPEN_EXISTING,
272 FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS | FILE_ATTRIBUTE_NORMAL,
273 INVALID_HANDLE_VALUE);
274 /* It failed! */
275 if (ReparseHandle == INVALID_HANDLE_VALUE)
276 {
277 /* Report it's not a mount point (it's not a reparse point) */
278 if (IsAMountPoint != NULL)
279 {
280 *IsAMountPoint = FALSE;
281 }
282
283 /* And zero output */
284 if (lpszVolumeName != NULL && cchBufferLength >= 1)
285 {
286 lpszVolumeName[0] = UNICODE_NULL;
287 }
288
289 return FALSE;
290 }
291
292 /* This is a mount point! */
293 if (IsAMountPoint != NULL)
294 {
295 *IsAMountPoint = TRUE;
296 }
297
298 /* Prepare a buffer big enough to read its data */
299 ReparseBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
300 if (ReparseBuffer == NULL)
301 {
302 CloseHandle(ReparseHandle);
303 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
304
305 /* Zero output */
306 if (lpszVolumeName != NULL && cchBufferLength >= 1)
307 {
308 lpszVolumeName[0] = UNICODE_NULL;
309 }
310
311 return FALSE;
312 }
313
314 /* Dump the reparse point data */
315 if (!DeviceIoControl(ReparseHandle, FSCTL_GET_REPARSE_POINT, NULL, 0,
316 ReparseBuffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &BytesReturned,
317 NULL))
318 {
319 RtlFreeHeap(RtlGetProcessHeap(), 0, ReparseBuffer);
320 CloseHandle(ReparseHandle);
321
322 /* Zero output */
323 if (lpszVolumeName != NULL && cchBufferLength >= 1)
324 {
325 lpszVolumeName[0] = UNICODE_NULL;
326 }
327
328 return FALSE;
329 }
330
331 /* We no longer need the reparse point */
332 CloseHandle(ReparseHandle);
333
334 /* We only handle mount points */
335 if (ReparseBuffer->ReparseTag != IO_REPARSE_TAG_MOUNT_POINT)
336 {
337 RtlFreeHeap(RtlGetProcessHeap(), 0, ReparseBuffer);
338
339 /* Zero output */
340 if (lpszVolumeName != NULL && cchBufferLength >= 1)
341 {
342 lpszVolumeName[0] = UNICODE_NULL;
343 }
344
345 return FALSE;
346 }
347
348 /* Do we have enough room for copying substitue name? */
349 if ((ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength + sizeof(UNICODE_NULL)) > cchBufferLength * sizeof(WCHAR))
350 {
351 RtlFreeHeap(RtlGetProcessHeap(), 0, ReparseBuffer);
352 SetLastError(ERROR_FILENAME_EXCED_RANGE);
353
354 /* Zero output */
355 if (lpszVolumeName != NULL && cchBufferLength >= 1)
356 {
357 lpszVolumeName[0] = UNICODE_NULL;
358 }
359
360 return FALSE;
361 }
362
363 /* Copy the link target */
364 RtlCopyMemory(lpszVolumeName,
365 &ReparseBuffer->MountPointReparseBuffer.PathBuffer[ReparseBuffer->MountPointReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
366 ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength);
367 /* Make it DOS valid */
368 Old = lpszVolumeName[1];
369 /* We want a root path */
370 lpszVolumeName[1] = L'\\';
371 /* And null terminate obviously */
372 lpszVolumeName[ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength / sizeof(WCHAR)] = UNICODE_NULL;
373
374 /* Make it a string to easily check it */
375 SubstituteName.Length = ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength;
376 SubstituteName.MaximumLength = SubstituteName.Length;
377 SubstituteName.Buffer = lpszVolumeName;
378
379 /* No longer need the data? */
380 RtlFreeHeap(RtlGetProcessHeap(), 0, ReparseBuffer);
381
382 /* Is that a dos volume name with backslash? */
383 if (MOUNTMGR_IS_DOS_VOLUME_NAME_WB(&SubstituteName))
384 {
385 return TRUE;
386 }
387
388 /* No, so restore previous name and return to the caller */
389 lpszVolumeName[1] = Old;
390 SetLastError(ERROR_INVALID_PARAMETER);
391 return FALSE;
392 }
393
394 /*
395 * @implemented
396 */
397 BOOL
398 BasepGetVolumeNameForVolumeMountPoint(IN LPCWSTR lpszMountPoint,
399 OUT LPWSTR lpszVolumeName,
400 IN DWORD cchBufferLength,
401 OUT LPBOOL IsAMountPoint)
402 {
403 BOOL Ret;
404 UNICODE_STRING MountPoint;
405
406 /* Assume it's a mount point (likely for non reparse points) */
407 if (IsAMountPoint != NULL)
408 {
409 *IsAMountPoint = 1;
410 }
411
412 /* Make a string with the mount point name */
413 RtlInitUnicodeString(&MountPoint, lpszMountPoint);
414 /* Not a root path? */
415 if (MountPoint.Buffer[(MountPoint.Length / sizeof(WCHAR)) - 1] != L'\\')
416 {
417 BaseSetLastNTError(STATUS_OBJECT_NAME_INVALID);
418 /* Zero output */
419 if (lpszVolumeName != NULL && cchBufferLength >= 1)
420 {
421 lpszVolumeName[0] = UNICODE_NULL;
422 }
423
424 return FALSE;
425 }
426
427 /* Does it look like <letter>:\? */
428 if (MountPoint.Length == 3 * sizeof(WCHAR))
429 {
430 /* Try to get volume name for root path */
431 Ret = GetVolumeNameForRoot(lpszMountPoint, lpszVolumeName, cchBufferLength);
432 /* It failed? */
433 if (!Ret)
434 {
435 /* If wasn't a drive letter, so maybe a reparse point? */
436 if (MountPoint.Buffer[1] != ':')
437 {
438 Ret = BasepGetVolumeNameFromReparsePoint(lpszMountPoint, lpszVolumeName, cchBufferLength, IsAMountPoint);
439 }
440 /* It was, so zero output */
441 else if (lpszVolumeName != NULL && cchBufferLength >= 1)
442 {
443 lpszVolumeName[0] = UNICODE_NULL;
444 }
445 }
446 }
447 else
448 {
449 /* Try to get volume name for root path */
450 Ret = GetVolumeNameForRoot(lpszMountPoint, lpszVolumeName, cchBufferLength);
451 /* It failed? */
452 if (!Ret)
453 {
454 /* It was a DOS volume as UNC name, so fail and zero output */
455 if (MountPoint.Length == 14 && MountPoint.Buffer[0] == '\\' && MountPoint.Buffer[1] == '\\' &&
456 (MountPoint.Buffer[2] == '.' || MountPoint.Buffer[2] == '?') && MountPoint.Buffer[3] == L'\\' &&
457 MountPoint.Buffer[5] == ':')
458 {
459 if (lpszVolumeName != NULL && cchBufferLength >= 1)
460 {
461 lpszVolumeName[0] = UNICODE_NULL;
462 }
463 }
464 /* Maybe it's a reparse point? */
465 else
466 {
467 Ret = BasepGetVolumeNameFromReparsePoint(lpszMountPoint, lpszVolumeName, cchBufferLength, IsAMountPoint);
468 }
469 }
470 }
471
472 return Ret;
473 }
474
475 /**
476 * @name GetVolumeNameForVolumeMountPointW
477 * @implemented
478 *
479 * Return an unique volume name for a drive root or mount point.
480 *
481 * @param VolumeMountPoint
482 * Pointer to string that contains either root drive name or
483 * mount point name.
484 * @param VolumeName
485 * Pointer to buffer that is filled with resulting unique
486 * volume name on success.
487 * @param VolumeNameLength
488 * Size of VolumeName buffer in TCHARs.
489 *
490 * @return
491 * TRUE when the function succeeds and the VolumeName buffer is filled,
492 * FALSE otherwise.
493 */
494 BOOL
495 WINAPI
496 GetVolumeNameForVolumeMountPointW(IN LPCWSTR VolumeMountPoint,
497 OUT LPWSTR VolumeName,
498 IN DWORD VolumeNameLength)
499 {
500 BOOL Ret;
501
502 /* Just query our internal function */
503 Ret = BasepGetVolumeNameForVolumeMountPoint(VolumeMountPoint, VolumeName,
504 VolumeNameLength, NULL);
505 if (!Ret && VolumeName != NULL && VolumeNameLength >= 1)
506 {
507 VolumeName[0] = UNICODE_NULL;
508 }
509
510 return Ret;
511 }
512
513 /*
514 * @implemented
515 */
516 BOOL
517 WINAPI
518 GetVolumeNameForVolumeMountPointA(IN LPCSTR lpszVolumeMountPoint,
519 IN LPSTR lpszVolumeName,
520 IN DWORD cchBufferLength)
521 {
522 BOOL Ret;
523 ANSI_STRING VolumeName;
524 UNICODE_STRING VolumeNameU;
525 PUNICODE_STRING VolumeMountPointU;
526
527 /* Convert mount point to unicode */
528 VolumeMountPointU = Basep8BitStringToStaticUnicodeString(lpszVolumeMountPoint);
529 if (VolumeMountPointU == NULL)
530 {
531 return FALSE;
532 }
533
534 /* Initialize the strings we'll use for convention */
535 VolumeName.Buffer = lpszVolumeName;
536 VolumeName.Length = 0;
537 VolumeName.MaximumLength = cchBufferLength - 1;
538
539 VolumeNameU.Length = 0;
540 VolumeNameU.MaximumLength = (cchBufferLength - 1) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
541 /* Allocate a buffer big enough to contain the returned name */
542 VolumeNameU.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, VolumeNameU.MaximumLength);
543 if (VolumeNameU.Buffer == NULL)
544 {
545 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
546 return FALSE;
547 }
548
549 /* Query -W */
550 Ret = GetVolumeNameForVolumeMountPointW(VolumeMountPointU->Buffer, VolumeNameU.Buffer, cchBufferLength);
551 /* If it succeed, perform -A conversion */
552 if (Ret)
553 {
554 NTSTATUS Status;
555
556 /* Reinit our string for length */
557 RtlInitUnicodeString(&VolumeNameU, VolumeNameU.Buffer);
558 /* Convert to ANSI */
559 Status = RtlUnicodeStringToAnsiString(&VolumeName, &VolumeNameU, FALSE);
560 /* If conversion failed, force failure, otherwise, just null terminate */
561 if (!NT_SUCCESS(Status))
562 {
563 Ret = FALSE;
564 BaseSetLastNTError(Status);
565 }
566 else
567 {
568 VolumeName.Buffer[VolumeName.Length] = ANSI_NULL;
569 }
570 }
571
572 /* Internal buffer no longer needed */
573 RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeNameU.Buffer);
574
575 return Ret;
576 }
577
578 /*
579 * @unimplemented
580 */
581 BOOL
582 WINAPI
583 SetVolumeMountPointW(IN LPCWSTR lpszVolumeMountPoint,
584 IN LPCWSTR lpszVolumeName)
585 {
586 STUB;
587 return 0;
588 }
589
590 /*
591 * @unimplemented
592 */
593 BOOL
594 WINAPI
595 SetVolumeMountPointA(IN LPCSTR lpszVolumeMountPoint,
596 IN LPCSTR lpszVolumeName)
597 {
598 STUB;
599 return 0;
600 }
601
602 /*
603 * @unimplemented
604 */
605 BOOL
606 WINAPI
607 DeleteVolumeMountPointA(IN LPCSTR lpszVolumeMountPoint)
608 {
609 STUB;
610 return 0;
611 }
612
613 /*
614 * @unimplemented
615 */
616 BOOL
617 WINAPI
618 DeleteVolumeMountPointW(IN LPCWSTR lpszVolumeMountPoint)
619 {
620 STUB;
621 return 0;
622 }
623
624 /*
625 * @unimplemented
626 */
627 HANDLE
628 WINAPI
629 FindFirstVolumeMountPointW(IN LPCWSTR lpszRootPathName,
630 IN LPWSTR lpszVolumeMountPoint,
631 IN DWORD cchBufferLength)
632 {
633 STUB;
634 return 0;
635 }
636
637 /*
638 * @unimplemented
639 */
640 HANDLE
641 WINAPI
642 FindFirstVolumeMountPointA(IN LPCSTR lpszRootPathName,
643 IN LPSTR lpszVolumeMountPoint,
644 IN DWORD cchBufferLength)
645 {
646 STUB;
647 return 0;
648 }
649
650 /*
651 * @unimplemented
652 */
653 BOOL
654 WINAPI
655 FindNextVolumeMountPointA(IN HANDLE hFindVolumeMountPoint,
656 IN LPSTR lpszVolumeMountPoint,
657 DWORD cchBufferLength)
658 {
659 STUB;
660 return 0;
661 }
662
663 /*
664 * @unimplemented
665 */
666 BOOL
667 WINAPI
668 FindNextVolumeMountPointW(IN HANDLE hFindVolumeMountPoint,
669 IN LPWSTR lpszVolumeMountPoint,
670 DWORD cchBufferLength)
671 {
672 STUB;
673 return 0;
674 }
675
676 /*
677 * @unimplemented
678 */
679 BOOL
680 WINAPI
681 FindVolumeMountPointClose(IN HANDLE hFindVolumeMountPoint)
682 {
683 STUB;
684 return 0;
685 }
686
687 /* EOF */