4 * Copyright 2002, 2003, 2004 Alexandre Julliard
5 * Copyright 2003 Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include <sys/types.h>
26 #define WIN32_NO_STATUS
29 #include "wine/debug.h"
30 #include "ntdll_misc.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(file
);
34 #define IS_SEPARATOR(ch) ((ch) == '\\' || (ch) == '/')
36 /***********************************************************************
37 * RtlDetermineDosPathNameType_U (NTDLL.@)
39 DOS_PATHNAME_TYPE WINAPI
RtlDetermineDosPathNameType_U( PCWSTR path
)
41 if (IS_SEPARATOR(path
[0]))
43 if (!IS_SEPARATOR(path
[1])) return ABSOLUTE_PATH
; /* "/foo" */
44 if (path
[2] != '.' && path
[2] != '?') return UNC_PATH
; /* "//foo" */
45 if (IS_SEPARATOR(path
[3])) return DEVICE_PATH
; /* "//./foo" or "//?/foo" */
46 if (path
[3]) return UNC_PATH
; /* "//.foo" or "//?foo" */
47 return UNC_DOT_PATH
; /* "//." or "//?" */
51 if (!path
[0] || path
[1] != ':') return RELATIVE_PATH
; /* "foo" */
52 if (IS_SEPARATOR(path
[2])) return ABSOLUTE_DRIVE_PATH
; /* "c:/foo" */
53 return RELATIVE_DRIVE_PATH
; /* "c:foo" */
57 /***********************************************************************
58 * RtlIsDosDeviceName_U (NTDLL.@)
60 * Check if the given DOS path contains a DOS device name.
62 * Returns the length of the device name in the low word and its
63 * position in the high word (both in bytes, not WCHARs), or 0 if no
64 * device name is found.
66 ULONG WINAPI
RtlIsDosDeviceName_U( PCWSTR dos_name
)
68 static const WCHAR auxW
[] = {'A','U','X'};
69 static const WCHAR comW
[] = {'C','O','M'};
70 static const WCHAR conW
[] = {'C','O','N'};
71 static const WCHAR lptW
[] = {'L','P','T'};
72 static const WCHAR nulW
[] = {'N','U','L'};
73 static const WCHAR prnW
[] = {'P','R','N'};
74 static const WCHAR coninW
[] = {'C','O','N','I','N','$'};
75 static const WCHAR conoutW
[] = {'C','O','N','O','U','T','$'};
77 const WCHAR
*start
, *end
, *p
;
79 switch(RtlDetermineDosPathNameType_U( dos_name
))
85 if (!wcsicmp( dos_name
, L
"\\\\.\\CON" ))
86 return MAKELONG( sizeof(conW
), 4 * sizeof(WCHAR
) ); /* 4 is length of \\.\ prefix */
88 case ABSOLUTE_DRIVE_PATH
:
89 case RELATIVE_DRIVE_PATH
:
90 start
= dos_name
+ 2; /* skip drive letter */
97 /* find start of file name */
98 for (p
= start
; *p
; p
++) if (IS_SEPARATOR(*p
)) start
= p
+ 1;
100 /* truncate at extension and ':' */
101 for (end
= start
; *end
; end
++) if (*end
== '.' || *end
== ':') break;
104 /* remove trailing spaces */
105 while (end
>= start
&& *end
== ' ') end
--;
107 /* now we have a potential device name between start and end, check it */
108 switch(end
- start
+ 1)
111 if (wcsnicmp( start
, auxW
, 3 ) &&
112 wcsnicmp( start
, conW
, 3 ) &&
113 wcsnicmp( start
, nulW
, 3 ) &&
114 wcsnicmp( start
, prnW
, 3 )) break;
115 return MAKELONG( 3 * sizeof(WCHAR
), (start
- dos_name
) * sizeof(WCHAR
) );
117 if (wcsnicmp( start
, comW
, 3 ) && wcsnicmp( start
, lptW
, 3 )) break;
118 if (*end
<= '0' || *end
> '9') break;
119 return MAKELONG( 4 * sizeof(WCHAR
), (start
- dos_name
) * sizeof(WCHAR
) );
121 if (wcsnicmp( start
, coninW
, ARRAY_SIZE(coninW
) )) break;
122 return MAKELONG( sizeof(coninW
), (start
- dos_name
) * sizeof(WCHAR
) );
124 if (wcsnicmp( start
, conoutW
, ARRAY_SIZE(conoutW
) )) break;
125 return MAKELONG( sizeof(conoutW
), (start
- dos_name
) * sizeof(WCHAR
) );
126 default: /* can't match anything */
132 /******************************************************************
135 * Helper for RtlDosPathNameToNtPathName_U_WithStatus.
136 * Test if the path is an exisiting directory.
138 static BOOL
is_valid_directory(LPCWSTR path
)
140 OBJECT_ATTRIBUTES attr
;
141 UNICODE_STRING ntpath
;
146 if (!RtlDosPathNameToNtPathName_U(path
, &ntpath
, NULL
, NULL
))
149 attr
.Length
= sizeof(attr
);
150 attr
.RootDirectory
= 0;
151 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
152 attr
.ObjectName
= &ntpath
;
153 attr
.SecurityDescriptor
= NULL
;
154 attr
.SecurityQualityOfService
= NULL
;
156 nts
= NtOpenFile(&handle
, FILE_READ_ATTRIBUTES
| SYNCHRONIZE
, &attr
, &io
,
157 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
158 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
);
159 RtlFreeUnicodeString(&ntpath
);
160 if (nts
!= STATUS_SUCCESS
)
166 /**************************************************************************
167 * RtlDosPathNameToNtPathName_U_WithStatus [NTDLL.@]
169 * dos_path: a DOS path name (fully qualified or not)
170 * ntpath: pointer to a UNICODE_STRING to hold the converted
172 * file_part:will point (in ntpath) to the file part in the path
173 * cd: directory reference (optional)
176 * + fill the cd structure
178 NTSTATUS WINAPI
RtlDosPathNameToNtPathName_U_WithStatus(const WCHAR
*dos_path
, UNICODE_STRING
*ntpath
,
179 WCHAR
**file_part
, CURDIR
*cd
)
181 static const WCHAR global_prefix
[] = {'\\','\\','?','\\'};
182 static const WCHAR global_prefix2
[] = {'\\','?','?','\\'};
183 NTSTATUS nts
= STATUS_SUCCESS
;
184 ULONG sz
, offset
, dosdev
;
185 WCHAR local
[MAX_PATH
];
188 TRACE("(%s,%p,%p,%p)\n", debugstr_w(dos_path
), ntpath
, file_part
, cd
);
192 FIXME("Unsupported parameter\n");
193 memset(cd
, 0, sizeof(*cd
));
196 if (!dos_path
|| !*dos_path
)
197 return STATUS_OBJECT_NAME_INVALID
;
199 if (!memcmp(dos_path
, global_prefix
, sizeof(global_prefix
)) ||
200 (!memcmp(dos_path
, global_prefix2
, sizeof(global_prefix2
)) && dos_path
[4]))
202 ntpath
->Length
= wcslen(dos_path
) * sizeof(WCHAR
);
203 ntpath
->MaximumLength
= ntpath
->Length
+ sizeof(WCHAR
);
204 ntpath
->Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, ntpath
->MaximumLength
);
205 if (!ntpath
->Buffer
) return STATUS_NO_MEMORY
;
206 memcpy( ntpath
->Buffer
, dos_path
, ntpath
->MaximumLength
);
207 ntpath
->Buffer
[1] = '?'; /* change \\?\ to \??\ */
210 if ((ptr
= wcsrchr( ntpath
->Buffer
, '\\' )) && ptr
[1]) *file_part
= ptr
+ 1;
211 else *file_part
= NULL
;
213 return STATUS_SUCCESS
;
216 dosdev
= RtlIsDosDeviceName_U(dos_path
);
217 if ((offset
= HIWORD(dosdev
)))
219 sz
= offset
+ sizeof(WCHAR
);
221 if (sz
> sizeof(local
) &&
222 (!(ptr
= RtlAllocateHeap(GetProcessHeap(), 0, sz
))))
223 return STATUS_NO_MEMORY
;
225 memcpy(ptr
, dos_path
, offset
);
226 ptr
[offset
/sizeof(WCHAR
)] = '\0';
228 if (!is_valid_directory(ptr
))
230 nts
= STATUS_OBJECT_NAME_INVALID
;
234 if (file_part
) *file_part
= NULL
;
238 wcscpy(ptr
, L
"\\\\.\\");
239 memcpy(ptr
+ 4, dos_path
+ offset
/ sizeof(WCHAR
), sz
);
240 ptr
[4 + sz
/ sizeof(WCHAR
)] = '\0';
241 sz
+= 4 * sizeof(WCHAR
);
245 sz
= RtlGetFullPathName_U(dos_path
, sizeof(local
), ptr
, file_part
);
246 if (sz
== 0) return STATUS_OBJECT_NAME_INVALID
;
248 if (sz
> sizeof(local
))
250 if (!(ptr
= RtlAllocateHeap(GetProcessHeap(), 0, sz
))) return STATUS_NO_MEMORY
;
251 sz
= RtlGetFullPathName_U(dos_path
, sz
, ptr
, file_part
);
254 sz
+= (1 /* NUL */ + 4 /* unc\ */ + 4 /* \??\ */) * sizeof(WCHAR
);
257 nts
= STATUS_OBJECT_NAME_INVALID
;
261 ntpath
->MaximumLength
= sz
;
262 ntpath
->Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, ntpath
->MaximumLength
);
265 nts
= STATUS_NO_MEMORY
;
269 wcscpy(ntpath
->Buffer
, L
"\\??\\");
270 switch (RtlDetermineDosPathNameType_U(ptr
))
272 case UNC_PATH
: /* \\foo */
274 wcscat(ntpath
->Buffer
, L
"UNC\\");
276 case DEVICE_PATH
: /* \\.\foo */
284 wcscat(ntpath
->Buffer
, ptr
+ offset
);
285 ntpath
->Length
= wcslen(ntpath
->Buffer
) * sizeof(WCHAR
);
287 if (file_part
&& *file_part
)
288 *file_part
= ntpath
->Buffer
+ ntpath
->Length
/ sizeof(WCHAR
) - wcslen(*file_part
);
290 /* FIXME: cd filling */
293 if (ptr
!= local
) RtlFreeHeap(GetProcessHeap(), 0, ptr
);
297 /**************************************************************************
298 * RtlDosPathNameToNtPathName_U [NTDLL.@]
300 * See RtlDosPathNameToNtPathName_U_WithStatus
302 BOOLEAN WINAPI
RtlDosPathNameToNtPathName_U(PCWSTR dos_path
,
303 PUNICODE_STRING ntpath
,
307 return RtlDosPathNameToNtPathName_U_WithStatus(dos_path
, ntpath
, file_part
, cd
) == STATUS_SUCCESS
;
310 /**************************************************************************
311 * RtlDosPathNameToRelativeNtPathName_U_WithStatus [NTDLL.@]
313 * See RtlDosPathNameToNtPathName_U_WithStatus (except the last parameter)
315 NTSTATUS WINAPI
RtlDosPathNameToRelativeNtPathName_U_WithStatus(const WCHAR
*dos_path
,
316 UNICODE_STRING
*ntpath
, WCHAR
**file_part
, RTL_RELATIVE_NAME
*relative
)
318 TRACE("(%s,%p,%p,%p)\n", debugstr_w(dos_path
), ntpath
, file_part
, relative
);
322 FIXME("Unsupported parameter\n");
323 memset(relative
, 0, sizeof(*relative
));
326 /* FIXME: fill parameter relative */
328 return RtlDosPathNameToNtPathName_U_WithStatus(dos_path
, ntpath
, file_part
, NULL
);
331 /**************************************************************************
332 * RtlReleaseRelativeName [NTDLL.@]
334 void WINAPI
RtlReleaseRelativeName(RTL_RELATIVE_NAME
*relative
)
338 /******************************************************************
341 * Searches a file of name 'name' into a ';' separated list of paths
343 * Doesn't seem to search elsewhere than the paths list
344 * Stores the result in buffer (file_part will point to the position
345 * of the file name in the buffer)
347 * - how long shall the paths be ??? (MAX_PATH or larger with \\?\ constructs ???)
349 ULONG WINAPI
RtlDosSearchPath_U(LPCWSTR paths
, LPCWSTR search
, LPCWSTR ext
,
350 ULONG buffer_size
, LPWSTR buffer
,
353 DOS_PATHNAME_TYPE type
= RtlDetermineDosPathNameType_U(search
);
356 if (type
== RELATIVE_PATH
)
358 ULONG allocated
= 0, needed
, filelen
;
361 filelen
= 1 /* for \ */ + wcslen(search
) + 1 /* \0 */;
363 /* Windows only checks for '.' without worrying about path components */
364 if (wcschr( search
, '.' )) ext
= NULL
;
365 if (ext
!= NULL
) filelen
+= wcslen(ext
);
371 for (needed
= 0, ptr
= paths
; *ptr
!= 0 && *ptr
++ != ';'; needed
++);
372 if (needed
+ filelen
> allocated
)
374 if (!name
) name
= RtlAllocateHeap(GetProcessHeap(), 0,
375 (needed
+ filelen
) * sizeof(WCHAR
));
378 WCHAR
*newname
= RtlReAllocateHeap(GetProcessHeap(), 0, name
,
379 (needed
+ filelen
) * sizeof(WCHAR
));
380 if (!newname
) RtlFreeHeap(GetProcessHeap(), 0, name
);
384 allocated
= needed
+ filelen
;
386 memmove(name
, paths
, needed
* sizeof(WCHAR
));
387 /* append '\\' if none is present */
388 if (needed
> 0 && name
[needed
- 1] != '\\') name
[needed
++] = '\\';
389 wcscpy(&name
[needed
], search
);
390 if (ext
) wcscat(&name
[needed
], ext
);
391 if (RtlDoesFileExists_U(name
))
393 len
= RtlGetFullPathName_U(name
, buffer_size
, buffer
, file_part
);
398 RtlFreeHeap(GetProcessHeap(), 0, name
);
400 else if (RtlDoesFileExists_U(search
))
402 len
= RtlGetFullPathName_U(search
, buffer_size
, buffer
, file_part
);
409 /******************************************************************
412 * Helper for RtlGetFullPathName_U.
413 * Get rid of . and .. components in the path.
415 static inline void collapse_path( WCHAR
*path
, UINT mark
)
419 /* convert every / into a \ */
420 for (p
= path
; *p
; p
++) if (*p
== '/') *p
= '\\';
422 /* collapse duplicate backslashes */
423 next
= path
+ max( 1, mark
);
424 for (p
= next
; *p
; p
++) if (*p
!= '\\' || next
[-1] != '\\') *next
++ = *p
;
434 case '\\': /* .\ component */
436 memmove( p
, next
, (wcslen(next
) + 1) * sizeof(WCHAR
) );
438 case 0: /* final . */
439 if (p
> path
+ mark
) p
--;
443 if (p
[2] == '\\') /* ..\ component */
449 while (p
> path
+ mark
&& p
[-1] != '\\') p
--;
451 memmove( p
, next
, (wcslen(next
) + 1) * sizeof(WCHAR
) );
454 else if (!p
[2]) /* final .. */
459 while (p
> path
+ mark
&& p
[-1] != '\\') p
--;
460 if (p
> path
+ mark
) p
--;
468 /* skip to the next component */
469 while (*p
&& *p
!= '\\') p
++;
472 /* remove last dot in previous dir name */
473 if (p
> path
+ mark
&& p
[-1] == '.') memmove( p
-1, p
, (wcslen(p
) + 1) * sizeof(WCHAR
) );
478 /* remove trailing spaces and dots (yes, Windows really does that, don't ask) */
479 while (p
> path
+ mark
&& (p
[-1] == ' ' || p
[-1] == '.')) p
--;
484 /******************************************************************
487 * Skip the \\share\dir\ part of a file name. Helper for RtlGetFullPathName_U.
489 static const WCHAR
*skip_unc_prefix( const WCHAR
*ptr
)
492 while (*ptr
&& !IS_SEPARATOR(*ptr
)) ptr
++; /* share name */
493 while (IS_SEPARATOR(*ptr
)) ptr
++;
494 while (*ptr
&& !IS_SEPARATOR(*ptr
)) ptr
++; /* dir name */
495 while (IS_SEPARATOR(*ptr
)) ptr
++;
500 /******************************************************************
501 * get_full_path_helper
503 * Helper for RtlGetFullPathName_U
504 * Note: name and buffer are allowed to point to the same memory spot
506 static ULONG
get_full_path_helper(LPCWSTR name
, LPWSTR buffer
, ULONG size
)
508 ULONG reqsize
= 0, mark
= 0, dep
= 0, deplen
;
509 LPWSTR ins_str
= NULL
;
511 const UNICODE_STRING
* cd
;
514 /* return error if name only consists of spaces */
515 for (ptr
= name
; *ptr
; ptr
++) if (*ptr
!= ' ') break;
520 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
521 cd
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
.DosPath
;
523 cd
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
.DosPath
;
525 switch (RtlDetermineDosPathNameType_U(name
))
527 case UNC_PATH
: /* \\foo */
528 ptr
= skip_unc_prefix( name
);
532 case DEVICE_PATH
: /* \\.\foo */
536 case ABSOLUTE_DRIVE_PATH
: /* c:\foo */
537 reqsize
= sizeof(WCHAR
);
544 case RELATIVE_DRIVE_PATH
: /* c:foo */
546 if (wcsnicmp( name
, cd
->Buffer
, 2 ))
548 UNICODE_STRING var
, val
;
554 var
.Length
= 3 * sizeof(WCHAR
);
555 var
.MaximumLength
= 4 * sizeof(WCHAR
);
558 val
.MaximumLength
= size
;
559 val
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, size
);
561 switch (RtlQueryEnvironmentVariable_U(NULL
, &var
, &val
))
564 /* FIXME: Win2k seems to check that the environment variable actually points
565 * to an existing directory. If not, root of the drive is used
566 * (this seems also to be the only spot in RtlGetFullPathName that the
567 * existence of a part of a path is checked)
570 case STATUS_BUFFER_TOO_SMALL
:
571 reqsize
= val
.Length
+ sizeof(WCHAR
); /* append trailing '\\' */
572 val
.Buffer
[val
.Length
/ sizeof(WCHAR
)] = '\\';
573 ins_str
= val
.Buffer
;
575 case STATUS_VARIABLE_NOT_FOUND
:
576 reqsize
= 3 * sizeof(WCHAR
);
581 RtlFreeHeap(GetProcessHeap(), 0, val
.Buffer
);
584 ERR("Unsupported status code\n");
585 RtlFreeHeap(GetProcessHeap(), 0, val
.Buffer
);
593 case RELATIVE_PATH
: /* foo */
594 reqsize
= cd
->Length
;
595 ins_str
= cd
->Buffer
;
596 if (cd
->Buffer
[1] != ':')
598 ptr
= skip_unc_prefix( cd
->Buffer
);
599 mark
= ptr
- cd
->Buffer
;
604 case ABSOLUTE_PATH
: /* \xxx */
605 if (name
[0] == '/') /* may be a Unix path */
613 nt_str
= RtlAllocateHeap( GetProcessHeap(), 0, (wcslen(name
) + 9) * sizeof(WCHAR
) );
614 wcscpy( nt_str
, L
"\\??\\unix" );
615 wcscat( nt_str
, name
);
616 RtlInitUnicodeString( &str
, nt_str
);
617 buflen
= 3 * wcslen(name
) + 1;
618 unix_name
= RtlAllocateHeap( GetProcessHeap(), 0, buflen
);
619 status
= wine_nt_to_unix_file_name( &str
, unix_name
, &buflen
, FILE_OPEN_IF
);
620 if (!status
|| status
== STATUS_NO_SUCH_FILE
)
622 buflen
= wcslen(name
) + 9;
623 status
= wine_unix_to_nt_file_name( unix_name
, nt_str
, &buflen
);
625 RtlFreeHeap( GetProcessHeap(), 0, unix_name
);
626 if (!status
&& buflen
> 6 && nt_str
[5] == ':')
628 reqsize
= (buflen
- 4) * sizeof(WCHAR
);
631 memcpy( buffer
, nt_str
+ 4, reqsize
);
632 collapse_path( buffer
, 3 );
633 reqsize
-= sizeof(WCHAR
);
635 RtlFreeHeap( GetProcessHeap(), 0, nt_str
);
638 RtlFreeHeap( GetProcessHeap(), 0, nt_str
);
640 if (cd
->Buffer
[1] == ':')
642 reqsize
= 2 * sizeof(WCHAR
);
643 tmp
[0] = cd
->Buffer
[0];
650 ptr
= skip_unc_prefix( cd
->Buffer
);
651 reqsize
= (ptr
- cd
->Buffer
) * sizeof(WCHAR
);
652 mark
= reqsize
/ sizeof(WCHAR
);
653 ins_str
= cd
->Buffer
;
657 case UNC_DOT_PATH
: /* \\. */
658 reqsize
= 4 * sizeof(WCHAR
);
673 deplen
= wcslen(name
+ dep
) * sizeof(WCHAR
);
674 if (reqsize
+ deplen
+ sizeof(WCHAR
) > size
)
676 /* not enough space, return need size (including terminating '\0') */
677 reqsize
+= deplen
+ sizeof(WCHAR
);
681 memmove(buffer
+ reqsize
/ sizeof(WCHAR
), name
+ dep
, deplen
+ sizeof(WCHAR
));
682 if (reqsize
) memcpy(buffer
, ins_str
, reqsize
);
684 if (ins_str
!= tmp
&& ins_str
!= cd
->Buffer
)
685 RtlFreeHeap(GetProcessHeap(), 0, ins_str
);
687 collapse_path( buffer
, mark
);
688 reqsize
= wcslen(buffer
) * sizeof(WCHAR
);
695 /******************************************************************
696 * RtlGetFullPathName_U (NTDLL.@)
698 * Returns the number of bytes written to buffer (not including the
699 * terminating NULL) if the function succeeds, or the required number of bytes
700 * (including the terminating NULL) if the buffer is too small.
702 * file_part will point to the filename part inside buffer (except if we use
703 * DOS device name, in which case file_in_buf is NULL)
706 DWORD WINAPI
RtlGetFullPathName_U(const WCHAR
* name
, ULONG size
, WCHAR
* buffer
,
713 TRACE("(%s %u %p %p)\n", debugstr_w(name
), size
, buffer
, file_part
);
715 if (!name
|| !*name
) return 0;
717 if (file_part
) *file_part
= NULL
;
719 /* check for DOS device name */
720 dosdev
= RtlIsDosDeviceName_U(name
);
723 DWORD offset
= HIWORD(dosdev
) / sizeof(WCHAR
); /* get it in WCHARs, not bytes */
724 DWORD sz
= LOWORD(dosdev
); /* in bytes */
726 if (8 + sz
+ 2 > size
) return sz
+ 10;
727 wcscpy(buffer
, L
"\\\\.\\");
728 memmove(buffer
+ 4, name
+ offset
, sz
);
729 buffer
[4 + sz
/ sizeof(WCHAR
)] = '\0';
730 /* file_part isn't set in this case */
734 reqsize
= get_full_path_helper(name
, buffer
, size
);
735 if (!reqsize
) return 0;
738 LPWSTR tmp
= RtlAllocateHeap(GetProcessHeap(), 0, reqsize
);
739 reqsize
= get_full_path_helper(name
, tmp
, reqsize
);
740 if (reqsize
+ sizeof(WCHAR
) > size
) /* it may have worked the second time */
742 RtlFreeHeap(GetProcessHeap(), 0, tmp
);
743 return reqsize
+ sizeof(WCHAR
);
745 memcpy( buffer
, tmp
, reqsize
+ sizeof(WCHAR
) );
746 RtlFreeHeap(GetProcessHeap(), 0, tmp
);
750 if (file_part
&& (ptr
= wcsrchr(buffer
, '\\')) != NULL
&& ptr
>= buffer
+ 2 && *++ptr
)
755 /*************************************************************************
756 * RtlGetLongestNtPathLength [NTDLL.@]
758 * Get the longest allowed path length
764 * The longest allowed path length (277 characters under Win2k).
766 DWORD WINAPI
RtlGetLongestNtPathLength(void)
768 return MAX_NT_PATH_LENGTH
;
771 /******************************************************************
772 * RtlIsNameLegalDOS8Dot3 (NTDLL.@)
774 * Returns TRUE iff unicode is a valid DOS (8+3) name.
775 * If the name is valid, oem gets filled with the corresponding OEM string
776 * spaces is set to TRUE if unicode contains spaces
778 BOOLEAN WINAPI
RtlIsNameLegalDOS8Dot3( const UNICODE_STRING
*unicode
,
779 OEM_STRING
*oem
, BOOLEAN
*spaces
)
781 static const char illegal
[] = "*?<>|\"+=,;[]:/\\\345";
786 BOOLEAN got_space
= FALSE
;
790 oem_str
.Length
= sizeof(buffer
);
791 oem_str
.MaximumLength
= sizeof(buffer
);
792 oem_str
.Buffer
= buffer
;
795 if (RtlUpcaseUnicodeStringToCountedOemString( oem
, unicode
, FALSE
) != STATUS_SUCCESS
)
798 if (oem
->Length
> 12) return FALSE
;
800 /* a starting . is invalid, except for . and .. */
801 if (oem
->Length
> 0 && oem
->Buffer
[0] == '.')
803 if (oem
->Length
!= 1 && (oem
->Length
!= 2 || oem
->Buffer
[1] != '.')) return FALSE
;
804 if (spaces
) *spaces
= FALSE
;
808 for (i
= 0; i
< oem
->Length
; i
++)
810 switch (oem
->Buffer
[i
])
813 /* leading/trailing spaces not allowed */
814 if (!i
|| i
== oem
->Length
-1 || oem
->Buffer
[i
+1] == '.') return FALSE
;
818 if (dot
!= -1) return FALSE
;
822 if (strchr(illegal
, oem
->Buffer
[i
])) return FALSE
;
826 /* check file part is shorter than 8, extension shorter than 3
827 * dot cannot be last in string
831 if (oem
->Length
> 8) return FALSE
;
835 if (dot
> 8 || (oem
->Length
- dot
> 4) || dot
== oem
->Length
- 1) return FALSE
;
837 if (spaces
) *spaces
= got_space
;
841 /******************************************************************
842 * RtlGetCurrentDirectory_U (NTDLL.@)
845 ULONG WINAPI
RtlGetCurrentDirectory_U(ULONG buflen
, LPWSTR buf
)
850 TRACE("(%u %p)\n", buflen
, buf
);
854 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
855 us
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
.DosPath
;
857 us
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
.DosPath
;
859 len
= us
->Length
/ sizeof(WCHAR
);
860 if (us
->Buffer
[len
- 1] == '\\' && us
->Buffer
[len
- 2] != ':')
863 if (buflen
/ sizeof(WCHAR
) > len
)
865 memcpy(buf
, us
->Buffer
, len
* sizeof(WCHAR
));
875 return len
* sizeof(WCHAR
);
878 /******************************************************************
879 * RtlSetCurrentDirectory_U (NTDLL.@)
882 NTSTATUS WINAPI
RtlSetCurrentDirectory_U(const UNICODE_STRING
* dir
)
884 FILE_FS_DEVICE_INFORMATION device_info
;
885 OBJECT_ATTRIBUTES attr
;
886 UNICODE_STRING newdir
;
894 newdir
.Buffer
= NULL
;
898 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
899 curdir
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
;
901 curdir
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
;
903 if (!RtlDosPathNameToNtPathName_U( dir
->Buffer
, &newdir
, NULL
, NULL
))
905 nts
= STATUS_OBJECT_NAME_INVALID
;
909 attr
.Length
= sizeof(attr
);
910 attr
.RootDirectory
= 0;
911 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
912 attr
.ObjectName
= &newdir
;
913 attr
.SecurityDescriptor
= NULL
;
914 attr
.SecurityQualityOfService
= NULL
;
916 nts
= NtOpenFile( &handle
, FILE_TRAVERSE
| SYNCHRONIZE
, &attr
, &io
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
917 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
);
918 if (nts
!= STATUS_SUCCESS
) goto out
;
920 /* don't keep the directory handle open on removable media */
921 if (!NtQueryVolumeInformationFile( handle
, &io
, &device_info
,
922 sizeof(device_info
), FileFsDeviceInformation
) &&
923 (device_info
.Characteristics
& FILE_REMOVABLE_MEDIA
))
929 if (curdir
->Handle
) NtClose( curdir
->Handle
);
930 curdir
->Handle
= handle
;
932 /* append trailing \ if missing */
933 size
= newdir
.Length
/ sizeof(WCHAR
);
935 ptr
+= 4; /* skip \??\ prefix */
937 if (size
&& ptr
[size
- 1] != '\\') ptr
[size
++] = '\\';
939 /* convert \??\UNC\ path to \\ prefix */
940 if (size
>= 4 && !wcsnicmp(ptr
, L
"UNC\\", 4))
947 memcpy( curdir
->DosPath
.Buffer
, ptr
, size
* sizeof(WCHAR
));
948 curdir
->DosPath
.Buffer
[size
] = 0;
949 curdir
->DosPath
.Length
= size
* sizeof(WCHAR
);
951 TRACE( "curdir now %s %p\n", debugstr_w(curdir
->DosPath
.Buffer
), curdir
->Handle
);
954 RtlFreeUnicodeString( &newdir
);