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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/port.h"
26 #include <sys/types.h>
28 #ifdef HAVE_SYS_STAT_H
29 # include <sys/stat.h>
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39 #include "wine/library.h"
41 #include "ntdll_misc.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(file
);
45 static const WCHAR DeviceRootW
[] = {'\\','\\','.','\\',0};
46 static const WCHAR NTDosPrefixW
[] = {'\\','?','?','\\',0};
47 static const WCHAR UncPfxW
[] = {'U','N','C','\\',0};
49 #define IS_SEPARATOR(ch) ((ch) == '\\' || (ch) == '/')
51 #define MAX_DOS_DRIVES 26
59 /***********************************************************************
62 * Retrieve device/inode number for all the drives. Helper for find_drive_root.
64 static inline int get_drives_info( struct drive_info info
[MAX_DOS_DRIVES
] )
66 const char *config_dir
= wine_get_config_dir();
71 buffer
= RtlAllocateHeap( GetProcessHeap(), 0, strlen(config_dir
) + sizeof("/dosdevices/a:") );
72 if (!buffer
) return 0;
73 strcpy( buffer
, config_dir
);
74 strcat( buffer
, "/dosdevices/a:" );
75 p
= buffer
+ strlen(buffer
) - 2;
77 for (i
= ret
= 0; i
< MAX_DOS_DRIVES
; i
++)
80 if (!stat( buffer
, &st
))
82 info
[i
].dev
= st
.st_dev
;
83 info
[i
].ino
= st
.st_ino
;
92 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
97 /***********************************************************************
98 * remove_last_componentA
100 * Remove the last component of the path. Helper for find_drive_rootA.
102 static inline unsigned int remove_last_componentA( const char *path
, unsigned int len
)
108 /* find start of the last path component */
109 unsigned int prev
= len
;
110 if (prev
<= 1) break; /* reached root */
111 while (prev
> 1 && path
[prev
- 1] != '/') prev
--;
112 /* does removing it take us up a level? */
113 if (len
- prev
!= 1 || path
[prev
] != '.') /* not '.' */
115 if (len
- prev
== 2 && path
[prev
] == '.' && path
[prev
+1] == '.') /* is it '..'? */
120 /* strip off trailing slashes */
121 while (prev
> 1 && path
[prev
- 1] == '/') prev
--;
128 /***********************************************************************
131 * Find a drive for which the root matches the beginning of the given path.
132 * This can be used to translate a Unix path into a drive + DOS path.
133 * Return value is the drive, or -1 on error. On success, ppath is modified
134 * to point to the beginning of the DOS path.
136 static NTSTATUS
find_drive_rootA( LPCSTR
*ppath
, unsigned int len
, int *drive_ret
)
138 /* Starting with the full path, check if the device and inode match any of
139 * the wine 'drives'. If not then remove the last path component and try
140 * again. If the last component was a '..' then skip a normal component
141 * since it's a directory that's ascended back out of.
145 const char *path
= *ppath
;
147 struct drive_info info
[MAX_DOS_DRIVES
];
149 /* get device and inode of all drives */
150 if (!get_drives_info( info
)) return STATUS_OBJECT_PATH_NOT_FOUND
;
152 /* strip off trailing slashes */
153 while (len
> 1 && path
[len
- 1] == '/') len
--;
155 /* make a copy of the path */
156 if (!(buffer
= RtlAllocateHeap( GetProcessHeap(), 0, len
+ 1 ))) return STATUS_NO_MEMORY
;
157 memcpy( buffer
, path
, len
);
162 if (!stat( buffer
, &st
) && S_ISDIR( st
.st_mode
))
165 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
167 if ((info
[drive
].dev
== st
.st_dev
) && (info
[drive
].ino
== st
.st_ino
))
169 if (len
== 1) len
= 0; /* preserve root slash in returned path */
170 TRACE( "%s -> drive %c:, root=%s, name=%s\n",
171 debugstr_a(path
), 'A' + drive
, debugstr_a(buffer
), debugstr_a(path
+ len
));
174 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
175 return STATUS_SUCCESS
;
179 if (len
<= 1) break; /* reached root */
180 len
= remove_last_componentA( buffer
, len
);
183 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
184 return STATUS_OBJECT_PATH_NOT_FOUND
;
188 /***********************************************************************
189 * remove_last_componentW
191 * Remove the last component of the path. Helper for find_drive_rootW.
193 static inline int remove_last_componentW( const WCHAR
*path
, int len
)
199 /* find start of the last path component */
201 if (prev
<= 1) break; /* reached root */
202 while (prev
> 1 && !IS_SEPARATOR(path
[prev
- 1])) prev
--;
203 /* does removing it take us up a level? */
204 if (len
- prev
!= 1 || path
[prev
] != '.') /* not '.' */
206 if (len
- prev
== 2 && path
[prev
] == '.' && path
[prev
+1] == '.') /* is it '..'? */
211 /* strip off trailing slashes */
212 while (prev
> 1 && IS_SEPARATOR(path
[prev
- 1])) prev
--;
219 /***********************************************************************
222 * Find a drive for which the root matches the beginning of the given path.
223 * This can be used to translate a Unix path into a drive + DOS path.
224 * Return value is the drive, or -1 on error. On success, ppath is modified
225 * to point to the beginning of the DOS path.
227 static int find_drive_rootW( LPCWSTR
*ppath
)
229 /* Starting with the full path, check if the device and inode match any of
230 * the wine 'drives'. If not then remove the last path component and try
231 * again. If the last component was a '..' then skip a normal component
232 * since it's a directory that's ascended back out of.
234 int drive
, lenA
, lenW
;
236 const WCHAR
*path
= *ppath
;
238 struct drive_info info
[MAX_DOS_DRIVES
];
240 /* get device and inode of all drives */
241 if (!get_drives_info( info
)) return -1;
243 /* strip off trailing slashes */
244 lenW
= strlenW(path
);
245 while (lenW
> 1 && IS_SEPARATOR(path
[lenW
- 1])) lenW
--;
247 /* convert path to Unix encoding */
248 lenA
= ntdll_wcstoumbs( 0, path
, lenW
, NULL
, 0, NULL
, NULL
);
249 if (!(buffer
= RtlAllocateHeap( GetProcessHeap(), 0, lenA
+ 1 ))) return -1;
250 lenA
= ntdll_wcstoumbs( 0, path
, lenW
, buffer
, lenA
, NULL
, NULL
);
252 for (p
= buffer
; *p
; p
++) if (*p
== '\\') *p
= '/';
256 if (!stat( buffer
, &st
) && S_ISDIR( st
.st_mode
))
259 for (drive
= 0; drive
< MAX_DOS_DRIVES
; drive
++)
261 if ((info
[drive
].dev
== st
.st_dev
) && (info
[drive
].ino
== st
.st_ino
))
263 if (lenW
== 1) lenW
= 0; /* preserve root slash in returned path */
264 TRACE( "%s -> drive %c:, root=%s, name=%s\n",
265 debugstr_w(path
), 'A' + drive
, debugstr_a(buffer
), debugstr_w(path
+ lenW
));
267 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
272 if (lenW
<= 1) break; /* reached root */
273 lenW
= remove_last_componentW( path
, lenW
);
275 /* we only need the new length, buffer already contains the converted string */
276 lenA
= ntdll_wcstoumbs( 0, path
, lenW
, NULL
, 0, NULL
, NULL
);
279 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
284 /***********************************************************************
285 * RtlDetermineDosPathNameType_U (NTDLL.@)
287 DOS_PATHNAME_TYPE WINAPI
RtlDetermineDosPathNameType_U( PCWSTR path
)
289 if (IS_SEPARATOR(path
[0]))
291 if (!IS_SEPARATOR(path
[1])) return ABSOLUTE_PATH
; /* "/foo" */
292 if (path
[2] != '.') return UNC_PATH
; /* "//foo" */
293 if (IS_SEPARATOR(path
[3])) return DEVICE_PATH
; /* "//./foo" */
294 if (path
[3]) return UNC_PATH
; /* "//.foo" */
295 return UNC_DOT_PATH
; /* "//." */
299 if (!path
[0] || path
[1] != ':') return RELATIVE_PATH
; /* "foo" */
300 if (IS_SEPARATOR(path
[2])) return ABSOLUTE_DRIVE_PATH
; /* "c:/foo" */
301 return RELATIVE_DRIVE_PATH
; /* "c:foo" */
305 /***********************************************************************
306 * RtlIsDosDeviceName_U (NTDLL.@)
308 * Check if the given DOS path contains a DOS device name.
310 * Returns the length of the device name in the low word and its
311 * position in the high word (both in bytes, not WCHARs), or 0 if no
312 * device name is found.
314 ULONG WINAPI
RtlIsDosDeviceName_U( PCWSTR dos_name
)
316 static const WCHAR consoleW
[] = {'\\','\\','.','\\','C','O','N',0};
317 static const WCHAR auxW
[3] = {'A','U','X'};
318 static const WCHAR comW
[3] = {'C','O','M'};
319 static const WCHAR conW
[3] = {'C','O','N'};
320 static const WCHAR lptW
[3] = {'L','P','T'};
321 static const WCHAR nulW
[3] = {'N','U','L'};
322 static const WCHAR prnW
[3] = {'P','R','N'};
324 const WCHAR
*start
, *end
, *p
;
326 switch(RtlDetermineDosPathNameType_U( dos_name
))
332 if (!strcmpiW( dos_name
, consoleW
))
333 return MAKELONG( sizeof(conW
), 4 * sizeof(WCHAR
) ); /* 4 is length of \\.\ prefix */
339 end
= dos_name
+ strlenW(dos_name
) - 1;
340 if (end
>= dos_name
&& *end
== ':') end
--; /* remove trailing ':' */
342 /* find start of file name */
343 for (start
= end
; start
>= dos_name
; start
--)
345 if (IS_SEPARATOR(start
[0])) break;
346 /* check for ':' but ignore if before extension (for things like NUL:.txt) */
347 if (start
[0] == ':' && start
[1] != '.') break;
351 /* remove extension */
352 if ((p
= strchrW( start
, '.' )))
355 if (end
>= dos_name
&& *end
== ':') end
--; /* remove trailing ':' before extension */
359 /* no extension, remove trailing spaces */
360 while (end
>= dos_name
&& *end
== ' ') end
--;
363 /* now we have a potential device name between start and end, check it */
364 switch(end
- start
+ 1)
367 if (strncmpiW( start
, auxW
, 3 ) &&
368 strncmpiW( start
, conW
, 3 ) &&
369 strncmpiW( start
, nulW
, 3 ) &&
370 strncmpiW( start
, prnW
, 3 )) break;
371 return MAKELONG( 3 * sizeof(WCHAR
), (start
- dos_name
) * sizeof(WCHAR
) );
373 if (strncmpiW( start
, comW
, 3 ) && strncmpiW( start
, lptW
, 3 )) break;
374 if (*end
<= '0' || *end
> '9') break;
375 return MAKELONG( 4 * sizeof(WCHAR
), (start
- dos_name
) * sizeof(WCHAR
) );
376 default: /* can't match anything */
383 /**************************************************************************
384 * RtlDosPathNameToNtPathName_U [NTDLL.@]
386 * dos_path: a DOS path name (fully qualified or not)
387 * ntpath: pointer to a UNICODE_STRING to hold the converted
389 * file_part:will point (in ntpath) to the file part in the path
390 * cd: directory reference (optional)
393 * + fill the cd structure
395 BOOLEAN WINAPI
RtlDosPathNameToNtPathName_U(PCWSTR dos_path
,
396 PUNICODE_STRING ntpath
,
400 static const WCHAR LongFileNamePfxW
[4] = {'\\','\\','?','\\'};
402 WCHAR local
[MAX_PATH
];
405 TRACE("(%s,%p,%p,%p)\n",
406 debugstr_w(dos_path
), ntpath
, file_part
, cd
);
410 FIXME("Unsupported parameter\n");
411 memset(cd
, 0, sizeof(*cd
));
414 if (!dos_path
|| !*dos_path
) return FALSE
;
416 if (!strncmpW(dos_path
, LongFileNamePfxW
, 4))
418 ntpath
->Length
= strlenW(dos_path
) * sizeof(WCHAR
);
419 ntpath
->MaximumLength
= ntpath
->Length
+ sizeof(WCHAR
);
420 ntpath
->Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, ntpath
->MaximumLength
);
421 if (!ntpath
->Buffer
) return FALSE
;
422 memcpy( ntpath
->Buffer
, dos_path
, ntpath
->MaximumLength
);
423 ntpath
->Buffer
[1] = '?'; /* change \\?\ to \??\ */
426 if ((ptr
= strrchrW( ntpath
->Buffer
, '\\' )) && ptr
[1]) *file_part
= ptr
+ 1;
427 else *file_part
= NULL
;
433 sz
= RtlGetFullPathName_U(dos_path
, sizeof(local
), ptr
, file_part
);
434 if (sz
== 0) return FALSE
;
435 if (sz
> sizeof(local
))
437 if (!(ptr
= RtlAllocateHeap(GetProcessHeap(), 0, sz
))) return FALSE
;
438 sz
= RtlGetFullPathName_U(dos_path
, sz
, ptr
, file_part
);
441 ntpath
->MaximumLength
= sz
+ (4 /* unc\ */ + 4 /* \??\ */) * sizeof(WCHAR
);
442 ntpath
->Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, ntpath
->MaximumLength
);
445 if (ptr
!= local
) RtlFreeHeap(GetProcessHeap(), 0, ptr
);
449 strcpyW(ntpath
->Buffer
, NTDosPrefixW
);
450 switch (RtlDetermineDosPathNameType_U(ptr
))
452 case UNC_PATH
: /* \\foo */
454 strcatW(ntpath
->Buffer
, UncPfxW
);
456 case DEVICE_PATH
: /* \\.\foo */
464 strcatW(ntpath
->Buffer
, ptr
+ offset
);
465 ntpath
->Length
= strlenW(ntpath
->Buffer
) * sizeof(WCHAR
);
467 if (file_part
&& *file_part
)
468 *file_part
= ntpath
->Buffer
+ ntpath
->Length
/ sizeof(WCHAR
) - strlenW(*file_part
);
470 /* FIXME: cd filling */
472 if (ptr
!= local
) RtlFreeHeap(GetProcessHeap(), 0, ptr
);
476 /******************************************************************
479 * Searchs a file of name 'name' into a ';' separated list of paths
481 * Doesn't seem to search elsewhere than the paths list
482 * Stores the result in buffer (file_part will point to the position
483 * of the file name in the buffer)
485 * - how long shall the paths be ??? (MAX_PATH or larger with \\?\ constructs ???)
487 ULONG WINAPI
RtlDosSearchPath_U(LPCWSTR paths
, LPCWSTR search
, LPCWSTR ext
,
488 ULONG buffer_size
, LPWSTR buffer
,
491 DOS_PATHNAME_TYPE type
= RtlDetermineDosPathNameType_U(search
);
494 if (type
== RELATIVE_PATH
)
496 ULONG allocated
= 0, needed
, filelen
;
499 filelen
= 1 /* for \ */ + strlenW(search
) + 1 /* \0 */;
501 /* Windows only checks for '.' without worrying about path components */
502 if (strchrW( search
, '.' )) ext
= NULL
;
503 if (ext
!= NULL
) filelen
+= strlenW(ext
);
509 for (needed
= 0, ptr
= paths
; *ptr
!= 0 && *ptr
++ != ';'; needed
++);
510 if (needed
+ filelen
> allocated
)
512 if (!name
) name
= RtlAllocateHeap(GetProcessHeap(), 0,
513 (needed
+ filelen
) * sizeof(WCHAR
));
516 WCHAR
*newname
= RtlReAllocateHeap(GetProcessHeap(), 0, name
,
517 (needed
+ filelen
) * sizeof(WCHAR
));
518 if (!newname
) RtlFreeHeap(GetProcessHeap(), 0, name
);
522 allocated
= needed
+ filelen
;
524 memmove(name
, paths
, needed
* sizeof(WCHAR
));
525 /* append '\\' if none is present */
526 if (needed
> 0 && name
[needed
- 1] != '\\') name
[needed
++] = '\\';
527 strcpyW(&name
[needed
], search
);
528 if (ext
) strcatW(&name
[needed
], ext
);
529 if (RtlDoesFileExists_U(name
))
531 len
= RtlGetFullPathName_U(name
, buffer_size
, buffer
, file_part
);
536 RtlFreeHeap(GetProcessHeap(), 0, name
);
538 else if (RtlDoesFileExists_U(search
))
540 len
= RtlGetFullPathName_U(search
, buffer_size
, buffer
, file_part
);
547 /******************************************************************
550 * Helper for RtlGetFullPathName_U.
551 * Get rid of . and .. components in the path.
553 static inline void collapse_path( WCHAR
*path
, UINT mark
)
557 /* convert every / into a \ */
558 for (p
= path
; *p
; p
++) if (*p
== '/') *p
= '\\';
560 /* collapse duplicate backslashes */
561 next
= path
+ max( 1, mark
);
562 for (p
= next
; *p
; p
++) if (*p
!= '\\' || next
[-1] != '\\') *next
++ = *p
;
572 case '\\': /* .\ component */
574 memmove( p
, next
, (strlenW(next
) + 1) * sizeof(WCHAR
) );
576 case 0: /* final . */
577 if (p
> path
+ mark
) p
--;
581 if (p
[2] == '\\') /* ..\ component */
587 while (p
> path
+ mark
&& p
[-1] != '\\') p
--;
589 memmove( p
, next
, (strlenW(next
) + 1) * sizeof(WCHAR
) );
592 else if (!p
[2]) /* final .. */
597 while (p
> path
+ mark
&& p
[-1] != '\\') p
--;
598 if (p
> path
+ mark
) p
--;
606 /* skip to the next component */
607 while (*p
&& *p
!= '\\') p
++;
610 /* remove last dot in previous dir name */
611 if (p
> path
+ mark
&& p
[-1] == '.') memmove( p
-1, p
, (strlenW(p
) + 1) * sizeof(WCHAR
) );
616 /* remove trailing spaces and dots (yes, Windows really does that, don't ask) */
617 while (p
> path
+ mark
&& (p
[-1] == ' ' || p
[-1] == '.')) p
--;
622 /******************************************************************
625 * Skip the \\share\dir\ part of a file name. Helper for RtlGetFullPathName_U.
627 static const WCHAR
*skip_unc_prefix( const WCHAR
*ptr
)
630 while (*ptr
&& !IS_SEPARATOR(*ptr
)) ptr
++; /* share name */
631 while (IS_SEPARATOR(*ptr
)) ptr
++;
632 while (*ptr
&& !IS_SEPARATOR(*ptr
)) ptr
++; /* dir name */
633 while (IS_SEPARATOR(*ptr
)) ptr
++;
638 /******************************************************************
639 * get_full_path_helper
641 * Helper for RtlGetFullPathName_U
642 * Note: name and buffer are allowed to point to the same memory spot
644 static ULONG
get_full_path_helper(LPCWSTR name
, LPWSTR buffer
, ULONG size
)
646 ULONG reqsize
= 0, mark
= 0, dep
= 0, deplen
;
647 DOS_PATHNAME_TYPE type
;
648 LPWSTR ins_str
= NULL
;
650 const UNICODE_STRING
* cd
;
653 /* return error if name only consists of spaces */
654 for (ptr
= name
; *ptr
; ptr
++) if (*ptr
!= ' ') break;
659 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
660 cd
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
.DosPath
;
662 cd
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
.DosPath
;
664 switch (type
= RtlDetermineDosPathNameType_U(name
))
666 case UNC_PATH
: /* \\foo */
667 ptr
= skip_unc_prefix( name
);
671 case DEVICE_PATH
: /* \\.\foo */
675 case ABSOLUTE_DRIVE_PATH
: /* c:\foo */
676 reqsize
= sizeof(WCHAR
);
677 tmp
[0] = toupperW(name
[0]);
683 case RELATIVE_DRIVE_PATH
: /* c:foo */
685 if (toupperW(name
[0]) != toupperW(cd
->Buffer
[0]) || cd
->Buffer
[1] != ':')
687 UNICODE_STRING var
, val
;
693 var
.Length
= 3 * sizeof(WCHAR
);
694 var
.MaximumLength
= 4 * sizeof(WCHAR
);
697 val
.MaximumLength
= size
;
698 val
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, size
);
700 switch (RtlQueryEnvironmentVariable_U(NULL
, &var
, &val
))
703 /* FIXME: Win2k seems to check that the environment variable actually points
704 * to an existing directory. If not, root of the drive is used
705 * (this seems also to be the only spot in RtlGetFullPathName that the
706 * existence of a part of a path is checked)
709 case STATUS_BUFFER_TOO_SMALL
:
710 reqsize
= val
.Length
+ sizeof(WCHAR
); /* append trailing '\\' */
711 val
.Buffer
[val
.Length
/ sizeof(WCHAR
)] = '\\';
712 ins_str
= val
.Buffer
;
714 case STATUS_VARIABLE_NOT_FOUND
:
715 reqsize
= 3 * sizeof(WCHAR
);
722 ERR("Unsupported status code\n");
730 case RELATIVE_PATH
: /* foo */
731 reqsize
= cd
->Length
;
732 ins_str
= cd
->Buffer
;
733 if (cd
->Buffer
[1] != ':')
735 ptr
= skip_unc_prefix( cd
->Buffer
);
736 mark
= ptr
- cd
->Buffer
;
741 case ABSOLUTE_PATH
: /* \xxx */
742 if (name
[0] == '/') /* may be a Unix path */
744 const WCHAR
*ptr
= name
;
745 int drive
= find_drive_rootW( &ptr
);
748 reqsize
= 3 * sizeof(WCHAR
);
749 tmp
[0] = 'A' + drive
;
758 if (cd
->Buffer
[1] == ':')
760 reqsize
= 2 * sizeof(WCHAR
);
761 tmp
[0] = cd
->Buffer
[0];
768 ptr
= skip_unc_prefix( cd
->Buffer
);
769 reqsize
= (ptr
- cd
->Buffer
) * sizeof(WCHAR
);
770 mark
= reqsize
/ sizeof(WCHAR
);
771 ins_str
= cd
->Buffer
;
775 case UNC_DOT_PATH
: /* \\. */
776 reqsize
= 4 * sizeof(WCHAR
);
791 deplen
= strlenW(name
+ dep
) * sizeof(WCHAR
);
792 if (reqsize
+ deplen
+ sizeof(WCHAR
) > size
)
794 /* not enough space, return need size (including terminating '\0') */
795 reqsize
+= deplen
+ sizeof(WCHAR
);
799 memmove(buffer
+ reqsize
/ sizeof(WCHAR
), name
+ dep
, deplen
+ sizeof(WCHAR
));
800 if (reqsize
) memcpy(buffer
, ins_str
, reqsize
);
803 if (ins_str
&& ins_str
!= tmp
&& ins_str
!= cd
->Buffer
)
804 RtlFreeHeap(GetProcessHeap(), 0, ins_str
);
806 collapse_path( buffer
, mark
);
807 reqsize
= strlenW(buffer
) * sizeof(WCHAR
);
814 /******************************************************************
815 * RtlGetFullPathName_U (NTDLL.@)
817 * Returns the number of bytes written to buffer (not including the
818 * terminating NULL) if the function succeeds, or the required number of bytes
819 * (including the terminating NULL) if the buffer is too small.
821 * file_part will point to the filename part inside buffer (except if we use
822 * DOS device name, in which case file_in_buf is NULL)
825 DWORD WINAPI
RtlGetFullPathName_U(const WCHAR
* name
, ULONG size
, WCHAR
* buffer
,
832 TRACE("(%s %lu %p %p)\n", debugstr_w(name
), size
, buffer
, file_part
);
834 if (!name
|| !*name
) return 0;
836 if (file_part
) *file_part
= NULL
;
838 /* check for DOS device name */
839 dosdev
= RtlIsDosDeviceName_U(name
);
842 DWORD offset
= HIWORD(dosdev
) / sizeof(WCHAR
); /* get it in WCHARs, not bytes */
843 DWORD sz
= LOWORD(dosdev
); /* in bytes */
845 if (8 + sz
+ 2 > size
) return sz
+ 10;
846 strcpyW(buffer
, DeviceRootW
);
847 memmove(buffer
+ 4, name
+ offset
, sz
);
848 buffer
[4 + sz
/ sizeof(WCHAR
)] = '\0';
849 /* file_part isn't set in this case */
853 reqsize
= get_full_path_helper(name
, buffer
, size
);
854 if (!reqsize
) return 0;
857 LPWSTR tmp
= RtlAllocateHeap(GetProcessHeap(), 0, reqsize
);
858 reqsize
= get_full_path_helper(name
, tmp
, reqsize
);
859 if (reqsize
> size
) /* it may have worked the second time */
861 RtlFreeHeap(GetProcessHeap(), 0, tmp
);
862 return reqsize
+ sizeof(WCHAR
);
864 memcpy( buffer
, tmp
, reqsize
+ sizeof(WCHAR
) );
865 RtlFreeHeap(GetProcessHeap(), 0, tmp
);
869 if (file_part
&& (ptr
= strrchrW(buffer
, '\\')) != NULL
&& ptr
>= buffer
+ 2 && *++ptr
)
874 /*************************************************************************
875 * RtlGetLongestNtPathLength [NTDLL.@]
877 * Get the longest allowed path length
883 * The longest allowed path length (277 characters under Win2k).
885 DWORD WINAPI
RtlGetLongestNtPathLength(void)
887 return MAX_NT_PATH_LENGTH
;
890 /******************************************************************
891 * RtlIsNameLegalDOS8Dot3 (NTDLL.@)
893 * Returns TRUE iff unicode is a valid DOS (8+3) name.
894 * If the name is valid, oem gets filled with the corresponding OEM string
895 * spaces is set to TRUE if unicode contains spaces
897 BOOLEAN WINAPI
RtlIsNameLegalDOS8Dot3( const UNICODE_STRING
*unicode
,
898 OEM_STRING
*oem
, BOOLEAN
*spaces
)
900 static const char* illegal
= "*?<>|\"+=,;[]:/\\\345";
905 BOOLEAN got_space
= FALSE
;
909 oem_str
.Length
= sizeof(buffer
);
910 oem_str
.MaximumLength
= sizeof(buffer
);
911 oem_str
.Buffer
= buffer
;
914 if (RtlUpcaseUnicodeStringToCountedOemString( oem
, unicode
, FALSE
) != STATUS_SUCCESS
)
917 if (oem
->Length
> 12) return FALSE
;
919 /* a starting . is invalid, except for . and .. */
920 if (oem
->Buffer
[0] == '.')
922 if (oem
->Length
!= 1 && (oem
->Length
!= 2 || oem
->Buffer
[1] != '.')) return FALSE
;
923 if (spaces
) *spaces
= FALSE
;
927 for (i
= 0; i
< oem
->Length
; i
++)
929 switch (oem
->Buffer
[i
])
932 /* leading/trailing spaces not allowed */
933 if (!i
|| i
== oem
->Length
-1 || oem
->Buffer
[i
+1] == '.') return FALSE
;
937 if (dot
!= -1) return FALSE
;
941 if (strchr(illegal
, oem
->Buffer
[i
])) return FALSE
;
945 /* check file part is shorter than 8, extension shorter than 3
946 * dot cannot be last in string
950 if (oem
->Length
> 8) return FALSE
;
954 if (dot
> 8 || (oem
->Length
- dot
> 4) || dot
== oem
->Length
- 1) return FALSE
;
956 if (spaces
) *spaces
= got_space
;
960 /******************************************************************
961 * RtlGetCurrentDirectory_U (NTDLL.@)
964 NTSTATUS WINAPI
RtlGetCurrentDirectory_U(ULONG buflen
, LPWSTR buf
)
969 TRACE("(%lu %p)\n", buflen
, buf
);
973 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
974 us
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
.DosPath
;
976 us
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
.DosPath
;
978 len
= us
->Length
/ sizeof(WCHAR
);
979 if (us
->Buffer
[len
- 1] == '\\' && us
->Buffer
[len
- 2] != ':')
982 if (buflen
/ sizeof(WCHAR
) > len
)
984 memcpy(buf
, us
->Buffer
, len
* sizeof(WCHAR
));
994 return len
* sizeof(WCHAR
);
997 /******************************************************************
998 * RtlSetCurrentDirectory_U (NTDLL.@)
1001 NTSTATUS WINAPI
RtlSetCurrentDirectory_U(const UNICODE_STRING
* dir
)
1003 FILE_FS_DEVICE_INFORMATION device_info
;
1004 OBJECT_ATTRIBUTES attr
;
1005 UNICODE_STRING newdir
;
1013 newdir
.Buffer
= NULL
;
1015 RtlAcquirePebLock();
1017 if (NtCurrentTeb()->Tib
.SubSystemTib
) /* FIXME: hack */
1018 curdir
= &((WIN16_SUBSYSTEM_TIB
*)NtCurrentTeb()->Tib
.SubSystemTib
)->curdir
;
1020 curdir
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
;
1022 if (!RtlDosPathNameToNtPathName_U( dir
->Buffer
, &newdir
, NULL
, NULL
))
1024 nts
= STATUS_OBJECT_NAME_INVALID
;
1028 attr
.Length
= sizeof(attr
);
1029 attr
.RootDirectory
= 0;
1030 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1031 attr
.ObjectName
= &newdir
;
1032 attr
.SecurityDescriptor
= NULL
;
1033 attr
.SecurityQualityOfService
= NULL
;
1035 nts
= NtOpenFile( &handle
, 0, &attr
, &io
, 0, FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
);
1036 if (nts
!= STATUS_SUCCESS
) goto out
;
1038 /* don't keep the directory handle open on removable media */
1039 if (!NtQueryVolumeInformationFile( handle
, &io
, &device_info
,
1040 sizeof(device_info
), FileFsDeviceInformation
) &&
1041 (device_info
.Characteristics
& FILE_REMOVABLE_MEDIA
))
1047 if (curdir
->Handle
) NtClose( curdir
->Handle
);
1048 curdir
->Handle
= handle
;
1050 /* append trailing \ if missing */
1051 size
= newdir
.Length
/ sizeof(WCHAR
);
1052 ptr
= newdir
.Buffer
;
1053 ptr
+= 4; /* skip \??\ prefix */
1055 if (size
&& ptr
[size
- 1] != '\\') ptr
[size
++] = '\\';
1057 memcpy( curdir
->DosPath
.Buffer
, ptr
, size
* sizeof(WCHAR
));
1058 curdir
->DosPath
.Buffer
[size
] = 0;
1059 curdir
->DosPath
.Length
= size
* sizeof(WCHAR
);
1061 TRACE( "curdir now %s %p\n", debugstr_w(curdir
->DosPath
.Buffer
), curdir
->Handle
);
1064 RtlFreeUnicodeString( &newdir
);
1065 RtlReleasePebLock();
1070 /******************************************************************
1071 * wine_unix_to_nt_file_name (NTDLL.@) Not a Windows API
1073 NTSTATUS
wine_unix_to_nt_file_name( const ANSI_STRING
*name
, UNICODE_STRING
*nt
)
1075 static const WCHAR prefixW
[] = {'\\','?','?','\\','a',':','\\'};
1076 unsigned int lenW
, lenA
= name
->Length
;
1077 const char *path
= name
->Buffer
;
1083 if (!lenA
|| path
[0] != '/')
1088 if ((status
= DIR_get_unix_cwd( &cwd
)) != STATUS_SUCCESS
) return status
;
1090 size
= strlen(cwd
) + lenA
+ 1;
1091 if (!(newcwd
= RtlReAllocateHeap( GetProcessHeap(), 0, cwd
, size
)))
1093 status
= STATUS_NO_MEMORY
;
1097 end
= cwd
+ strlen(cwd
);
1098 if (end
> cwd
&& end
[-1] != '/') *end
++ = '/';
1099 memcpy( end
, path
, lenA
);
1103 status
= find_drive_rootA( &path
, lenA
, &drive
);
1104 lenA
-= (path
- cwd
);
1109 status
= find_drive_rootA( &path
, lenA
, &drive
);
1110 lenA
-= (path
- name
->Buffer
);
1113 if (status
!= STATUS_SUCCESS
) goto done
;
1114 while (lenA
&& path
[0] == '/') { lenA
--; path
++; }
1116 lenW
= ntdll_umbstowcs( 0, path
, lenA
, NULL
, 0 );
1117 if (!(nt
->Buffer
= RtlAllocateHeap( GetProcessHeap(), 0,
1118 (lenW
+ 1) * sizeof(WCHAR
) + sizeof(prefixW
) )))
1120 status
= STATUS_NO_MEMORY
;
1124 memcpy( nt
->Buffer
, prefixW
, sizeof(prefixW
) );
1125 nt
->Buffer
[4] += drive
;
1126 ntdll_umbstowcs( 0, path
, lenA
, nt
->Buffer
+ sizeof(prefixW
)/sizeof(WCHAR
), lenW
);
1127 lenW
+= sizeof(prefixW
)/sizeof(WCHAR
);
1128 nt
->Buffer
[lenW
] = 0;
1129 nt
->Length
= lenW
* sizeof(WCHAR
);
1130 nt
->MaximumLength
= nt
->Length
+ sizeof(WCHAR
);
1131 for (p
= nt
->Buffer
+ sizeof(prefixW
)/sizeof(WCHAR
); *p
; p
++) if (*p
== '/') *p
= '\\';
1134 RtlFreeHeap( GetProcessHeap(), 0, cwd
);