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) semi-stub\n", debugstr_a(source), debugstr_a(dest), progress, data, flags, handle);
 147
 148     return MoveFileWithProgressA(source, dest, progress, data, flags);
 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) semi-stub\n", debugstr_w(source), debugstr_w(dest), progress, data, flags, handle);
 157
 158     return MoveFileWithProgressW(source, dest, progress, data, flags);
 159 }
 160
 161 /*************************************************************************
 162  *           CreateFileTransactedA   (KERNEL32.@)
 163  */
 164 HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileTransactedA( LPCSTR name, DWORD access, DWORD sharing,
 165                                                        LPSECURITY_ATTRIBUTES sa, DWORD creation,
 166                                                        DWORD attributes, HANDLE template,
 167                                                        HANDLE transaction, PUSHORT version,
 168                                                        PVOID param )
 169 {
 170     FIXME("(%s %lx %lx %p %lx %lx %p %p %p %p): semi-stub\n", debugstr_a(name), access, sharing, sa,
 171            creation, attributes, template, transaction, version, param);
 172     return CreateFileA(name, access, sharing, sa, creation, attributes, template);
 173 }
 174
 175 /*************************************************************************
 176  *           CreateFileTransactedW   (KERNEL32.@)
 177  */
 178 HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileTransactedW( LPCWSTR name, DWORD access, DWORD sharing,
 179                                                        LPSECURITY_ATTRIBUTES sa, DWORD creation,
 180                                                        DWORD attributes, HANDLE template, HANDLE transaction,
 181                                                        PUSHORT version, PVOID param )
 182 {
 183     FIXME("(%s %lx %lx %p %lx %lx %p %p %p %p): semi-stub\n", debugstr_w(name), access, sharing, sa,
 184            creation, attributes, template, transaction, version, param);
 185     return CreateFileW(name, access, sharing, sa, creation, attributes, template);
 186 }
 187
 188 /***********************************************************************
 189  *           CreateDirectoryTransactedA   (KERNEL32.@)
 190  */
 191 BOOL WINAPI DECLSPEC_HOTPATCH CreateDirectoryTransactedA(LPCSTR template, LPCSTR path, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 192 {
 193     FIXME("(%s %s %p %p): semi-stub\n", debugstr_a(template), debugstr_a(path), sa, transaction);
 194     return CreateDirectoryExA(template, path, sa);
 195 }
 196
 197 /***********************************************************************
 198  *           CreateDirectoryTransactedW   (KERNEL32.@)
 199  */
 200 BOOL WINAPI DECLSPEC_HOTPATCH CreateDirectoryTransactedW(LPCWSTR template, LPCWSTR path, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 201 {
 202     FIXME("(%s %s %p %p): semi-stub\n", debugstr_w(template), debugstr_w(path), sa, transaction);
 203     return CreateDirectoryExW(template, path, sa);
 204 }
 205
 206 /***********************************************************************
 207  *           DeleteFileTransactedA   (KERNEL32.@)
 208  */
 209 BOOL WINAPI DECLSPEC_HOTPATCH DeleteFileTransactedA(LPCSTR path, HANDLE transaction)
 210 {
 211     FIXME("(%s %p): semi-stub\n", debugstr_a(path), transaction);
 212     return DeleteFileA(path);
 213 }
 214
 215 /***********************************************************************
 216  *           DeleteFileTransactedW   (KERNEL32.@)
 217  */
 218 BOOL WINAPI DECLSPEC_HOTPATCH DeleteFileTransactedW(LPCWSTR path, HANDLE transaction)
 219 {
 220     FIXME("(%s %p): semi-stub\n", debugstr_w(path), transaction);
 221     return DeleteFileW(path);
 222 }
 223
 224 /******************************************************************************
 225  *           FindFirstFileTransactedA   (KERNEL32.@)
 226  */
 227 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileTransactedA( LPCSTR filename, FINDEX_INFO_LEVELS level,
 228                                                           LPVOID data, FINDEX_SEARCH_OPS search_op,
 229                                                           LPVOID filter, DWORD flags, HANDLE transaction )
 230 {
 231     FIXME("(%s %d %p %d %p %lx %p): semi-stub\n", debugstr_a(filename), level, data, search_op, filter, flags, transaction);
 232     return FindFirstFileExA(filename, level, data, search_op, filter, flags);
 233 }
 234
 235 /******************************************************************************
 236  *           FindFirstFileTransactedW   (KERNEL32.@)
 237  */
 238 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileTransactedW( LPCWSTR filename, FINDEX_INFO_LEVELS level,
 239                                                           LPVOID data, FINDEX_SEARCH_OPS search_op,
 240                                                           LPVOID filter, DWORD flags, HANDLE transaction )
 241 {
 242     FIXME("(%s %d %p %d %p %lx %p): semi-stub\n", debugstr_w(filename), level, data, search_op, filter, flags, transaction);
 243     return FindFirstFileExW(filename, level, data, search_op, filter, flags);
 244 }
 245
 246
 247 /**************************************************************************
 248  *           GetFileAttributesTransactedA   (KERNEL32.@)
 249  */
 250 DWORD WINAPI DECLSPEC_HOTPATCH GetFileAttributesTransactedA(LPCSTR name, GET_FILEEX_INFO_LEVELS level, void *ptr, HANDLE transaction)
 251 {
 252     FIXME("(%s %p): semi-stub\n", debugstr_a(name), transaction);
 253     return GetFileAttributesExA(name, level, ptr);
 254 }
 255
 256 /**************************************************************************
 257  *           GetFileAttributesTransactedW   (KERNEL32.@)
 258  */
 259 DWORD WINAPI DECLSPEC_HOTPATCH GetFileAttributesTransactedW(LPCWSTR name, GET_FILEEX_INFO_LEVELS level, void *ptr, HANDLE transaction)
 260 {
 261     FIXME("(%s %p): semi-stub\n", debugstr_w(name), transaction);
 262     return GetFileAttributesExW(name, level, ptr);
 263 }
 264
 265 /***********************************************************************
 266  *           RemoveDirectoryTransactedA   (KERNEL32.@)
 267  */
 268 BOOL WINAPI DECLSPEC_HOTPATCH RemoveDirectoryTransactedA(LPCSTR path, HANDLE transaction)
 269 {
 270     FIXME("(%s %p): semi-stub\n", debugstr_a(path), transaction);
 271     return RemoveDirectoryA(path);
 272 }
 273
 274 /***********************************************************************
 275  *           RemoveDirectoryTransactedW   (KERNEL32.@)
 276  */
 277 BOOL WINAPI DECLSPEC_HOTPATCH RemoveDirectoryTransactedW(LPCWSTR path, HANDLE transaction)
 278 {
 279     FIXME("(%s %p): semi-stub\n", debugstr_w(path), transaction);
 280     return RemoveDirectoryW(path);
 281 }
 282
 283 /**************************************************************************
 284  *           MoveFileWithProgressA   (KERNEL32.@)
 285  */
 286 BOOL WINAPI MoveFileWithProgressA( LPCSTR source, LPCSTR dest,
 287                                    LPPROGRESS_ROUTINE fnProgress,
 288                                    LPVOID param, DWORD flag )
 289 {
 290     WCHAR *sourceW, *destW;
 291     BOOL ret;
 292
 293     if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
 294     if (dest)
 295     {
 296         if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
 297     }
 298     else
 299         destW = NULL;
 300
 301     ret = MoveFileWithProgressW( sourceW, destW, fnProgress, param, flag );
 302     HeapFree( GetProcessHeap(), 0, destW );
 303     return ret;
 304 }
 305
 306 /**************************************************************************
 307  *           MoveFileExA   (KERNEL32.@)
 308  */
 309 BOOL WINAPI MoveFileExA( LPCSTR source, LPCSTR dest, DWORD flag )
 310 {
 311     return MoveFileWithProgressA( source, dest, NULL, NULL, flag );
 312 }
 313
 314
 315 /**************************************************************************
 316  *           MoveFileW   (KERNEL32.@)
 317  *
 318  *  Move file or directory
 319  */
 320 BOOL WINAPI MoveFileW( LPCWSTR source, LPCWSTR dest )
 321 {
 322     return MoveFileExW( source, dest, MOVEFILE_COPY_ALLOWED );
 323 }
 324
 325
 326 /**************************************************************************
 327  *           MoveFileA   (KERNEL32.@)
 328  */
 329 BOOL WINAPI MoveFileA( LPCSTR source, LPCSTR dest )
 330 {
 331     return MoveFileExA( source, dest, MOVEFILE_COPY_ALLOWED );
 332 }
 333
 334
 335 /***********************************************************************
 336  *           CreateDirectoryExA   (KERNEL32.@)
 337  */
 338 BOOL WINAPI CreateDirectoryExA( LPCSTR template, LPCSTR path, LPSECURITY_ATTRIBUTES sa )
 339 {
 340     WCHAR *pathW, *templateW = NULL;
 341     BOOL ret;
 342
 343     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
 344     if (template && !(templateW = FILE_name_AtoW( template, TRUE ))) return FALSE;
 345
 346     ret = CreateDirectoryExW( templateW, pathW, sa );
 347     HeapFree( GetProcessHeap(), 0, templateW );
 348     return ret;
 349 }
 350
 351
 352 /***********************************************************************
 353  *           GetSystemDirectoryW   (KERNEL32.@)
 354  *
 355  * See comment for GetWindowsDirectoryA.
 356  */
 357 UINT WINAPI GetSystemDirectoryW( LPWSTR path, UINT count )
 358 {
 359     UINT len = ARRAY_SIZE(system_dir);
 360     if (path && count >= len)
 361     {
 362         lstrcpyW( path, system_dir );
 363         len--;
 364     }
 365     return len;
 366 }
 367
 368
 369 /***********************************************************************
 370  *           GetSystemDirectoryA   (KERNEL32.@)
 371  *
 372  * See comment for GetWindowsDirectoryA.
 373  */
 374 UINT WINAPI GetSystemDirectoryA( LPSTR path, UINT count )
 375 {
 376     return copy_filename_WtoA( system_dir, path, count );
 377 }
 378
 379
 380 /***********************************************************************
 381  *           wine_get_unix_file_name (KERNEL32.@) Not a Windows API
 382  *
 383  * Return the full Unix file name for a given path.
 384  * Returned buffer must be freed by caller.
 385  */
 386 char * CDECL wine_get_unix_file_name( LPCWSTR dosW )
 387 {
 388     UNICODE_STRING nt_name;
 389     OBJECT_ATTRIBUTES attr;
 390     NTSTATUS status;
 391     ULONG size = 256;
 392     char *buffer;
 393
 394     if (!RtlDosPathNameToNtPathName_U( dosW, &nt_name, NULL, NULL )) return NULL;
 395     InitializeObjectAttributes( &attr, &nt_name, 0, 0, NULL );
 396     for (;;)
 397     {
 398         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size )))
 399         {
 400             RtlFreeUnicodeString( &nt_name );
 401             return NULL;
 402         }
 403         status = wine_nt_to_unix_file_name( &attr, buffer, &size, FILE_OPEN_IF );
 404         if (status != STATUS_BUFFER_TOO_SMALL) break;
 405         HeapFree( GetProcessHeap(), 0, buffer );
 406     }
 407     RtlFreeUnicodeString( &nt_name );
 408     if (status && status != STATUS_NO_SUCH_FILE)
 409     {
 410         HeapFree( GetProcessHeap(), 0, buffer );
 411         SetLastError( RtlNtStatusToDosError( status ) );
 412         return NULL;
 413     }
 414     return buffer;
 415 }
 416
 417
 418 /***********************************************************************
 419  *           wine_get_dos_file_name (KERNEL32.@) Not a Windows API
 420  *
 421  * Return the full DOS file name for a given Unix path.
 422  * Returned buffer must be freed by caller.
 423  */
 424 WCHAR * CDECL wine_get_dos_file_name( LPCSTR str )
 425 {
 426     UNICODE_STRING nt_name;
 427     NTSTATUS status;
 428     WCHAR *buffer;
 429     ULONG len = strlen(str) + 1;
 430
 431     if (str[0] != '/')  /* relative path name */
 432     {
 433         if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 434         MultiByteToWideChar( CP_UNIXCP, 0, str, len, buffer, len );
 435         status = RtlDosPathNameToNtPathName_U_WithStatus( buffer, &nt_name, NULL, NULL );
 436         RtlFreeHeap( GetProcessHeap(), 0, buffer );
 437         if (!set_ntstatus( status )) return NULL;
 438         buffer = nt_name.Buffer;
 439         len = nt_name.Length / sizeof(WCHAR) + 1;
 440     }
 441     else
 442     {
 443         len += 8;  /* \??\unix prefix */
 444         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
 445         if (!set_ntstatus( wine_unix_to_nt_file_name( str, buffer, &len )))
 446         {
 447             HeapFree( GetProcessHeap(), 0, buffer );
 448             return NULL;
 449         }
 450     }
 451     if (buffer[5] == ':')
 452     {
 453         /* get rid of the \??\ prefix */
 454         /* FIXME: should implement RtlNtPathNameToDosPathName and use that instead */
 455         memmove( buffer, buffer + 4, (len - 4) * sizeof(WCHAR) );
 456     }
 457     else buffer[1] = '\\';
 458     return buffer;
 459 }
 460
 461 /*************************************************************************
 462  *           CreateSymbolicLinkA   (KERNEL32.@)
 463  */
 464 BOOLEAN WINAPI CreateSymbolicLinkA(LPCSTR link, LPCSTR target, DWORD flags)
 465 {
 466     FIXME("(%s %s %ld): stub\n", debugstr_a(link), debugstr_a(target), flags);
 467     return TRUE;
 468 }
 469
 470 /*************************************************************************
 471  *           CreateHardLinkTransactedA   (KERNEL32.@)
 472  */
 473 BOOL WINAPI CreateHardLinkTransactedA(LPCSTR link, LPCSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 474 {
 475     FIXME("(%s %s %p %p): stub\n", debugstr_a(link), debugstr_a(target), sa, transaction);
 476     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 477     return FALSE;
 478 }
 479
 480 /*************************************************************************
 481  *           CreateHardLinkTransactedW   (KERNEL32.@)
 482  */
 483 BOOL WINAPI CreateHardLinkTransactedW(LPCWSTR link, LPCWSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
 484 {
 485     FIXME("(%s %s %p %p): stub\n", debugstr_w(link), debugstr_w(target), sa, transaction);
 486     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 487     return FALSE;
 488 }
 489
 490 /*************************************************************************
 491  *           CheckNameLegalDOS8Dot3A   (KERNEL32.@)
 492  */
 493 BOOL WINAPI CheckNameLegalDOS8Dot3A(const char *name, char *oemname, DWORD oemname_len,
 494         BOOL *contains_spaces, BOOL *is_legal)
 495 {
 496     WCHAR *nameW;
 497
 498     TRACE("(%s %p %lu %p %p)\n", name, oemname,
 499             oemname_len, contains_spaces, is_legal);
 500
 501     if (!name || !is_legal)
 502         return FALSE;
 503
 504     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
 505
 506     return CheckNameLegalDOS8Dot3W( nameW, oemname, oemname_len, contains_spaces, is_legal );
 507 }
 508
 509 /*************************************************************************
 510  *           CheckNameLegalDOS8Dot3W   (KERNEL32.@)
 511  */
 512 BOOL WINAPI CheckNameLegalDOS8Dot3W(const WCHAR *name, char *oemname, DWORD oemname_len,
 513         BOOL *contains_spaces_ret, BOOL *is_legal)
 514 {
 515     OEM_STRING oem_str;
 516     UNICODE_STRING nameW;
 517     BOOLEAN contains_spaces;
 518
 519     TRACE("(%s %p %lu %p %p)\n", wine_dbgstr_w(name), oemname,
 520           oemname_len, contains_spaces_ret, is_legal);
 521
 522     if (!name || !is_legal)
 523         return FALSE;
 524
 525     RtlInitUnicodeString( &nameW, name );
 526
 527     if (oemname) {
 528         oem_str.Length = oemname_len;
 529         oem_str.MaximumLength = oemname_len;
 530         oem_str.Buffer = oemname;
 531     }
 532
 533     *is_legal = RtlIsNameLegalDOS8Dot3( &nameW, oemname ? &oem_str : NULL, &contains_spaces );
 534     if (contains_spaces_ret) *contains_spaces_ret = contains_spaces;
 535
 536     return TRUE;
 537 }
 538
 539 /*************************************************************************
 540  *           SetSearchPathMode   (KERNEL32.@)
 541  */
 542 BOOL WINAPI SetSearchPathMode( DWORD flags )
 543 {
 544     return set_ntstatus( RtlSetSearchPathMode( flags ));
 545 }