dlls/kernel32/path.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 Erik Bos
   5  * Copyright 1996, 2004 Alexandre Julliard
   6  * Copyright 2003 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  */
  23
  24 #include <errno.h>
  25 #include <stdio.h>
  26 #include <stdarg.h>
  27
  28 #include "winerror.h"
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35
  36 #include "kernel_private.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(file);
  40
  41 #define MAX_PATHNAME_LEN        1024
  42
  43 static const WCHAR system_dir[] = L"C:\\windows\\system32";
  44
  45 /***********************************************************************
  46  *           copy_filename_WtoA
  47  *
  48  * copy a file name back to OEM/Ansi, but only if the buffer is large enough
  49  */
  50 static DWORD copy_filename_WtoA( LPCWSTR nameW, LPSTR buffer, DWORD len )
  51 {
  52     UNICODE_STRING strW;
  53     DWORD ret;
  54     BOOL is_ansi = AreFileApisANSI();
  55
  56     RtlInitUnicodeString( &strW, nameW );
  57
  58     ret = is_ansi ? RtlUnicodeStringToAnsiSize(&strW) : RtlUnicodeStringToOemSize(&strW);
  59     if (buffer && ret <= len)
  60     {
  61         ANSI_STRING str;
  62
  63         str.Buffer = buffer;
  64         str.MaximumLength = min( len, UNICODE_STRING_MAX_CHARS );
  65         if (is_ansi)
  66             RtlUnicodeStringToAnsiString( &str, &strW, FALSE );
  67         else
  68             RtlUnicodeStringToOemString( &str, &strW, FALSE );
  69         ret = str.Length;  /* length without terminating 0 */
  70     }
  71     return ret;
  72 }
  73
  74 /***********************************************************************
  75  *           GetShortPathNameA   (KERNEL32.@)
  76  */
  77 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
  78 {
  79     WCHAR *longpathW;
  80     WCHAR shortpathW[MAX_PATH];
  81     DWORD ret;
  82
  83     TRACE("%s\n", debugstr_a(longpath));
  84
  85     if (!(longpathW = FILE_name_AtoW( longpath, FALSE ))) return 0;
  86
  87     ret = GetShortPathNameW(longpathW, shortpathW, MAX_PATH);
  88
  89     if (!ret) return 0;
  90     if (ret > MAX_PATH)
  91     {
  92         SetLastError(ERROR_FILENAME_EXCED_RANGE);
  93         return 0;
  94     }
  95     return copy_filename_WtoA( shortpathW, shortpath, shortlen );
  96 }
  97
  98
  99 /**************************************************************************
 100  *           CopyFileA   (KERNEL32.@)
 101  */
 102 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
 103 {
 104     WCHAR *sourceW, *destW;
 105     BOOL ret;
 106
 107     if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
 108     if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
 109
 110     ret = CopyFileW( sourceW, destW, fail_if_exists );
 111
 112     HeapFree( GetProcessHeap(), 0, destW );
 113     return ret;
 114 }
 115
 116
 117 /**************************************************************************
 118  *           CopyFileExA   (KERNEL32.@)
 119  */
 120 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
 121                         LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
 122                         LPBOOL cancelFlagPointer, DWORD copyFlags)
 123 {
 124     WCHAR *sourceW, *destW;
 125     BOOL ret;
 126
 127     /* can't use the TEB buffer since we may have a callback routine */
 128     if (!(sourceW = FILE_name_AtoW( sourceFilename, TRUE ))) return FALSE;
 129     if (!(destW = FILE_name_AtoW( destFilename, TRUE )))
 130     {
 131         HeapFree( GetProcessHeap(), 0, sourceW );
 132         return FALSE;
 133     }
 134     ret = CopyFileExW(sourceW, destW, progressRoutine, appData,
 135                       cancelFlagPointer, copyFlags);
 136     HeapFree( GetProcessHeap(), 0, sourceW );
 137     HeapFree( GetProcessHeap(), 0, destW );
 138     return ret;
 139 }
 140
 141 /**************************************************************************
 142  *           MoveFileTransactedA   (KERNEL32.@)
 143  */
 144 BOOL WINAPI MoveFileTransactedA(const char *source, const char *dest, LPPROGRESS_ROUTINE progress, void *data, DWORD flags, HANDLE handle)
 145 {
 146     FIXME("(%s, %s, %p, %p, %d, %p)\n", debugstr_a(source), debugstr_a(dest), progress, data, flags, handle);
 147     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 148     return FALSE;
 149 }
 150
 151 /**************************************************************************
 152  *           MoveFileTransactedW   (KERNEL32.@)
 153  */
 154 BOOL WINAPI MoveFileTransactedW(const WCHAR *source, const WCHAR *dest, LPPROGRESS_ROUTINE progress, void *data, DWORD flags, HANDLE handle)
 155 {
 156     FIXME("(%s, %s, %p, %p, %d, %p)\n", debugstr_w(source), debugstr_w(dest), progress, data, flags, handle);
 157     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 158     return FALSE;
 159 }
 160
 161 /**************************************************************************
 162  *           MoveFileWithProgressA   (KERNEL32.@)
 163  */
 164 BOOL WINAPI MoveFileWithProgressA( LPCSTR source, LPCSTR dest,
 165                                    LPPROGRESS_ROUTINE fnProgress,
 166                                    LPVOID param, DWORD flag )
 167 {
 168     WCHAR *sourceW, *destW;
 169     BOOL ret;
 170
 171     if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
 172     if (dest)
 173     {
 174         if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
 175     }
 176     else
 177         destW = NULL;
 178
 179     ret = MoveFileWithProgressW( sourceW, destW, fnProgress, param, flag );
 180     HeapFree( GetProcessHeap(), 0, destW );
 181     return ret;
 182 }
 183
 184 /**************************************************************************
 185  *           MoveFileExA   (KERNEL32.@)
 186  */
 187 BOOL WINAPI MoveFileExA( LPCSTR source, LPCSTR dest, DWORD flag )
 188 {
 189     return MoveFileWithProgressA( source, dest, NULL, NULL, flag );
 190 }
 191
 192
 193 /**************************************************************************
 194  *           MoveFileW   (KERNEL32.@)
 195  *
 196  *  Move file or directory
 197  */
 198 BOOL WINAPI MoveFileW( LPCWSTR source, LPCWSTR dest )
 199 {
 200     return MoveFileExW( source, dest, MOVEFILE_COPY_ALLOWED );
 201 }
 202
 203
 204 /**************************************************************************
 205  *           MoveFileA   (KERNEL32.@)
 206  */
 207 BOOL WINAPI MoveFileA( LPCSTR source, LPCSTR dest )
 208 {
 209     return MoveFileExA( source, dest, MOVEFILE_COPY_ALLOWED );
 210 }
 211
 212
 213 /***********************************************************************
 214  *           CreateDirectoryExA   (KERNEL32.@)
 215  */
 216 BOOL WINAPI CreateDirectoryExA( LPCSTR template, LPCSTR path, LPSECURITY_ATTRIBUTES sa )
 217 {
 218     WCHAR *pathW, *templateW = NULL;
 219     BOOL ret;
 220
 221     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
 222     if (template && !(templateW = FILE_name_AtoW( template, TRUE ))) return FALSE;
 223
 224     ret = CreateDirectoryExW( templateW, pathW, sa );
 225     HeapFree( GetProcessHeap(), 0, templateW );
 226     return ret;
 227 }
 228
 229
 230 /***********************************************************************
 231  *           GetSystemDirectoryW   (KERNEL32.@)
 232  *
 233  * See comment for GetWindowsDirectoryA.
 234  */
 235 UINT WINAPI GetSystemDirectoryW( LPWSTR path, UINT count )
 236 {
 237     UINT len = ARRAY_SIZE(system_dir);
 238     if (path && count >= len)
 239     {
 240         lstrcpyW( path, system_dir );
 241         len--;
 242     }
 243     return len;
 244 }
 245
 246
 247 /***********************************************************************
 248  *           GetSystemDirectoryA   (KERNEL32.@)
 249  *
 250  * See comment for GetWindowsDirectoryA.
 251  */
 252 UINT WINAPI GetSystemDirectoryA( LPSTR path, UINT count )
 253 {
 254     return copy_filename_WtoA( system_dir, path, count );
 255 }
 256
 257
 258 /***********************************************************************
 259  *           Wow64EnableWow64FsRedirection   (KERNEL32.@)
 260  *
 261  * Microsoft C++ Redistributable installers are depending on all %eax bits being set.
 262  */
 263 DWORD /*BOOLEAN*/ WINAPI KERNEL32_Wow64EnableWow64FsRedirection( BOOLEAN enable )
 264 {
 265     return set_ntstatus( RtlWow64EnableFsRedirection( enable ));
 266 }
 267
 268
 269 /***********************************************************************
 270  *           wine_get_unix_file_name (KERNEL32.@) Not a Windows API
 271  *
 272  * Return the full Unix file name for a given path.
 273  * Returned buffer must be freed by caller.
 274  */
 275 char * CDECL wine_get_unix_file_name( LPCWSTR dosW )
 276 {
 277     UNICODE_STRING nt_name;
 278     NTSTATUS status;
 279     SIZE_T size = 256;
 280     char *buffer;
 281
 282     if (!RtlDosPathNameToNtPathName_U( dosW, &nt_name, NULL, NULL )) return NULL;
 283     for (;;)
 284     {
 285         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size )))
 286         {
 287             RtlFreeUnicodeString( &nt_name );
 288             return NULL;
 289         }
 290         status = wine_nt_to_unix_file_name( &nt_name, buffer, &size, FILE_OPEN_IF );
 291         if (status != STATUS_BUFFER_TOO_SMALL) break;
 292         HeapFree( GetProcessHeap(), 0, buffer );
 293     }
 294     RtlFreeUnicodeString( &nt_name );
 295     if (status && status != STATUS_NO_SUCH_FILE)
 296     {
 297         HeapFree( GetProcessHeap(), 0, buffer );
 298         SetLastError( RtlNtStatusToDosError( status ) );
 299         return NULL;
 300     }
 301     return buffer;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           wine_get_dos_file_name (KERNEL32.@) Not a Windows API
 307  *
 308  * Return the full DOS file name for a given Unix path.
 309  * Returned buffer must be freed by caller.
 310  */
 311 WCHAR * CDECL wine_get_dos_file_name( LPCSTR str )
 312 {
 313     UNICODE_STRING nt_name;
 314     NTSTATUS status;
 315     WCHAR *buffer;
 316     SIZE_T len = strlen(str) + 1;
 317
 318     if (str[0] != '/')  /* relative path name */
 319     {
 320         if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 321         MultiByteToWideChar( CP_UNIXCP, 0, str, len, buffer, len );
 322         status = RtlDosPathNameToNtPathName_U_WithStatus( buffer, &nt_name, NULL, NULL );
 323         RtlFreeHeap( GetProcessHeap(), 0, buffer );
 324         if (!set_ntstatus( status )) return NULL;
 325         buffer = nt_name.Buffer;
 326         len = nt_name.Length / sizeof(WCHAR) + 1;
 327     }
 328     else
 329     {
 330         len += 8;  /* \??\unix prefix */
 331         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 332         if (!set_ntstatus( wine_unix_to_nt_file_name( str, buffer, &len )))
 333         {
 334             HeapFree( GetProcessHeap(), 0, buffer );
 335             return NULL;
 336         }
 337     }
 338     if (buffer[5] == ':')
 339     {
 340         /* get rid of the \??\ prefix */
 341         /* FIXME: should implement RtlNtPathNameToDosPathName and use that instead */
 342         memmove( buffer, buffer + 4, (len - 4) * sizeof(WCHAR) );
 343     }
 344     else buffer[1] = '\\';
 345     return buffer;
 346 }
 347
 348 /*************************************************************************
 349  *           CreateSymbolicLinkA   (KERNEL32.@)
 350  */
 351 BOOLEAN WINAPI CreateSymbolicLinkA(LPCSTR link, LPCSTR target, DWORD flags)
 352 {
 353     FIXME("(%s %s %d): stub\n", debugstr_a(link), debugstr_a(target), flags);
 354     return TRUE;
 355 }
 356
 357 /*************************************************************************
 358  *           CreateHardLinkTransactedA   (KERNEL32.@)
 359  */
 360 BOOL WINAPI CreateHardLinkTransactedA(LPCSTR link, LPCSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 361 {
 362     FIXME("(%s %s %p %p): stub\n", debugstr_a(link), debugstr_a(target), sa, transaction);
 363     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 364     return FALSE;
 365 }
 366
 367 /*************************************************************************
 368  *           CreateHardLinkTransactedW   (KERNEL32.@)
 369  */
 370 BOOL WINAPI CreateHardLinkTransactedW(LPCWSTR link, LPCWSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 371 {
 372     FIXME("(%s %s %p %p): stub\n", debugstr_w(link), debugstr_w(target), sa, transaction);
 373     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 374     return FALSE;
 375 }
 376
 377 /*************************************************************************
 378  *           CheckNameLegalDOS8Dot3A   (KERNEL32.@)
 379  */
 380 BOOL WINAPI CheckNameLegalDOS8Dot3A(const char *name, char *oemname, DWORD oemname_len,
 381         BOOL *contains_spaces, BOOL *is_legal)
 382 {
 383     WCHAR *nameW;
 384
 385     TRACE("(%s %p %u %p %p)\n", name, oemname,
 386             oemname_len, contains_spaces, is_legal);
 387
 388     if (!name || !is_legal)
 389         return FALSE;
 390
 391     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
 392
 393     return CheckNameLegalDOS8Dot3W( nameW, oemname, oemname_len, contains_spaces, is_legal );
 394 }
 395
 396 /*************************************************************************
 397  *           CheckNameLegalDOS8Dot3W   (KERNEL32.@)
 398  */
 399 BOOL WINAPI CheckNameLegalDOS8Dot3W(const WCHAR *name, char *oemname, DWORD oemname_len,
 400         BOOL *contains_spaces_ret, BOOL *is_legal)
 401 {
 402     OEM_STRING oem_str;
 403     UNICODE_STRING nameW;
 404     BOOLEAN contains_spaces;
 405
 406     TRACE("(%s %p %u %p %p)\n", wine_dbgstr_w(name), oemname,
 407           oemname_len, contains_spaces_ret, is_legal);
 408
 409     if (!name || !is_legal)
 410         return FALSE;
 411
 412     RtlInitUnicodeString( &nameW, name );
 413
 414     if (oemname) {
 415         oem_str.Length = oemname_len;
 416         oem_str.MaximumLength = oemname_len;
 417         oem_str.Buffer = oemname;
 418     }
 419
 420     *is_legal = RtlIsNameLegalDOS8Dot3( &nameW, oemname ? &oem_str : NULL, &contains_spaces );
 421     if (contains_spaces_ret) *contains_spaces_ret = contains_spaces;
 422
 423     return TRUE;
 424 }
 425
 426 /*************************************************************************
 427  *           SetSearchPathMode   (KERNEL32.@)
 428  */
 429 BOOL WINAPI SetSearchPathMode( DWORD flags )
 430 {
 431     return set_ntstatus( RtlSetSearchPathMode( flags ));
 432 }