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, %ld, %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, %ld, %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     OBJECT_ATTRIBUTES attr;
 279     NTSTATUS status;
 280     ULONG size = 256;
 281     char *buffer;
 282
 283     if (!RtlDosPathNameToNtPathName_U( dosW, &nt_name, NULL, NULL )) return NULL;
 284     InitializeObjectAttributes( &attr, &nt_name, 0, 0, NULL );
 285     for (;;)
 286     {
 287         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size )))
 288         {
 289             RtlFreeUnicodeString( &nt_name );
 290             return NULL;
 291         }
 292         status = wine_nt_to_unix_file_name( &attr, buffer, &size, FILE_OPEN_IF );
 293         if (status != STATUS_BUFFER_TOO_SMALL) break;
 294         HeapFree( GetProcessHeap(), 0, buffer );
 295     }
 296     RtlFreeUnicodeString( &nt_name );
 297     if (status && status != STATUS_NO_SUCH_FILE)
 298     {
 299         HeapFree( GetProcessHeap(), 0, buffer );
 300         SetLastError( RtlNtStatusToDosError( status ) );
 301         return NULL;
 302     }
 303     return buffer;
 304 }
 305
 306
 307 /***********************************************************************
 308  *           wine_get_dos_file_name (KERNEL32.@) Not a Windows API
 309  *
 310  * Return the full DOS file name for a given Unix path.
 311  * Returned buffer must be freed by caller.
 312  */
 313 WCHAR * CDECL wine_get_dos_file_name( LPCSTR str )
 314 {
 315     UNICODE_STRING nt_name;
 316     NTSTATUS status;
 317     WCHAR *buffer;
 318     ULONG len = strlen(str) + 1;
 319
 320     if (str[0] != '/')  /* relative path name */
 321     {
 322         if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 323         MultiByteToWideChar( CP_UNIXCP, 0, str, len, buffer, len );
 324         status = RtlDosPathNameToNtPathName_U_WithStatus( buffer, &nt_name, NULL, NULL );
 325         RtlFreeHeap( GetProcessHeap(), 0, buffer );
 326         if (!set_ntstatus( status )) return NULL;
 327         buffer = nt_name.Buffer;
 328         len = nt_name.Length / sizeof(WCHAR) + 1;
 329     }
 330     else
 331     {
 332         len += 8;  /* \??\unix prefix */
 333         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 334         if (!set_ntstatus( wine_unix_to_nt_file_name( str, buffer, &len )))
 335         {
 336             HeapFree( GetProcessHeap(), 0, buffer );
 337             return NULL;
 338         }
 339     }
 340     if (buffer[5] == ':')
 341     {
 342         /* get rid of the \??\ prefix */
 343         /* FIXME: should implement RtlNtPathNameToDosPathName and use that instead */
 344         memmove( buffer, buffer + 4, (len - 4) * sizeof(WCHAR) );
 345     }
 346     else buffer[1] = '\\';
 347     return buffer;
 348 }
 349
 350 /*************************************************************************
 351  *           CreateSymbolicLinkA   (KERNEL32.@)
 352  */
 353 BOOLEAN WINAPI CreateSymbolicLinkA(LPCSTR link, LPCSTR target, DWORD flags)
 354 {
 355     FIXME("(%s %s %ld): stub\n", debugstr_a(link), debugstr_a(target), flags);
 356     return TRUE;
 357 }
 358
 359 /*************************************************************************
 360  *           CreateHardLinkTransactedA   (KERNEL32.@)
 361  */
 362 BOOL WINAPI CreateHardLinkTransactedA(LPCSTR link, LPCSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 363 {
 364     FIXME("(%s %s %p %p): stub\n", debugstr_a(link), debugstr_a(target), sa, transaction);
 365     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 366     return FALSE;
 367 }
 368
 369 /*************************************************************************
 370  *           CreateHardLinkTransactedW   (KERNEL32.@)
 371  */
 372 BOOL WINAPI CreateHardLinkTransactedW(LPCWSTR link, LPCWSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 373 {
 374     FIXME("(%s %s %p %p): stub\n", debugstr_w(link), debugstr_w(target), sa, transaction);
 375     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 376     return FALSE;
 377 }
 378
 379 /*************************************************************************
 380  *           CheckNameLegalDOS8Dot3A   (KERNEL32.@)
 381  */
 382 BOOL WINAPI CheckNameLegalDOS8Dot3A(const char *name, char *oemname, DWORD oemname_len,
 383         BOOL *contains_spaces, BOOL *is_legal)
 384 {
 385     WCHAR *nameW;
 386
 387     TRACE("(%s %p %lu %p %p)\n", name, oemname,
 388             oemname_len, contains_spaces, is_legal);
 389
 390     if (!name || !is_legal)
 391         return FALSE;
 392
 393     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
 394
 395     return CheckNameLegalDOS8Dot3W( nameW, oemname, oemname_len, contains_spaces, is_legal );
 396 }
 397
 398 /*************************************************************************
 399  *           CheckNameLegalDOS8Dot3W   (KERNEL32.@)
 400  */
 401 BOOL WINAPI CheckNameLegalDOS8Dot3W(const WCHAR *name, char *oemname, DWORD oemname_len,
 402         BOOL *contains_spaces_ret, BOOL *is_legal)
 403 {
 404     OEM_STRING oem_str;
 405     UNICODE_STRING nameW;
 406     BOOLEAN contains_spaces;
 407
 408     TRACE("(%s %p %lu %p %p)\n", wine_dbgstr_w(name), oemname,
 409           oemname_len, contains_spaces_ret, is_legal);
 410
 411     if (!name || !is_legal)
 412         return FALSE;
 413
 414     RtlInitUnicodeString( &nameW, name );
 415
 416     if (oemname) {
 417         oem_str.Length = oemname_len;
 418         oem_str.MaximumLength = oemname_len;
 419         oem_str.Buffer = oemname;
 420     }
 421
 422     *is_legal = RtlIsNameLegalDOS8Dot3( &nameW, oemname ? &oem_str : NULL, &contains_spaces );
 423     if (contains_spaces_ret) *contains_spaces_ret = contains_spaces;
 424
 425     return TRUE;
 426 }
 427
 428 /*************************************************************************
 429  *           SetSearchPathMode   (KERNEL32.@)
 430  */
 431 BOOL WINAPI SetSearchPathMode( DWORD flags )
 432 {
 433     return set_ntstatus( RtlSetSearchPathMode( flags ));
 434 }