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