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 "config.h"
  25 #include "wine/port.h"
  26
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <stdarg.h>
  30
  31 #include "winerror.h"
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winternl.h"
  37
  38 #include "kernel_private.h"
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(file);
  43
  44 #define MAX_PATHNAME_LEN        1024
  45
  46
  47 /* check if a file name is for an executable file (.exe or .com) */
  48 static inline BOOL is_executable( const WCHAR *name )
  49 {
  50     static const WCHAR exeW[] = {'.','e','x','e',0};
  51     static const WCHAR comW[] = {'.','c','o','m',0};
  52     int len = strlenW(name);
  53
  54     if (len < 4) return FALSE;
  55     return (!strcmpiW( name + len - 4, exeW ) || !strcmpiW( name + len - 4, comW ));
  56 }
  57
  58 /***********************************************************************
  59  *           copy_filename_WtoA
  60  *
  61  * copy a file name back to OEM/Ansi, but only if the buffer is large enough
  62  */
  63 static DWORD copy_filename_WtoA( LPCWSTR nameW, LPSTR buffer, DWORD len )
  64 {
  65     UNICODE_STRING strW;
  66     DWORD ret;
  67     BOOL is_ansi = AreFileApisANSI();
  68
  69     RtlInitUnicodeString( &strW, nameW );
  70
  71     ret = is_ansi ? RtlUnicodeStringToAnsiSize(&strW) : RtlUnicodeStringToOemSize(&strW);
  72     if (buffer && ret <= len)
  73     {
  74         ANSI_STRING str;
  75
  76         str.Buffer = buffer;
  77         str.MaximumLength = min( len, UNICODE_STRING_MAX_CHARS );
  78         if (is_ansi)
  79             RtlUnicodeStringToAnsiString( &str, &strW, FALSE );
  80         else
  81             RtlUnicodeStringToOemString( &str, &strW, FALSE );
  82         ret = str.Length;  /* length without terminating 0 */
  83     }
  84     return ret;
  85 }
  86
  87 /***********************************************************************
  88  *           add_boot_rename_entry
  89  *
  90  * Adds an entry to the registry that is loaded when windows boots and
  91  * checks if there are some files to be removed or renamed/moved.
  92  * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
  93  * non-NULL then the file is moved, otherwise it is deleted.  The
  94  * entry of the registry key is always appended with two zero
  95  * terminated strings. If <fn2> is NULL then the second entry is
  96  * simply a single 0-byte. Otherwise the second filename goes
  97  * there. The entries are prepended with \??\ before the path and the
  98  * second filename gets also a '!' as the first character if
  99  * MOVEFILE_REPLACE_EXISTING is set. After the final string another
 100  * 0-byte follows to indicate the end of the strings.
 101  * i.e.:
 102  * \??\D:\test\file1[0]
 103  * !\??\D:\test\file1_renamed[0]
 104  * \??\D:\Test|delete[0]
 105  * [0]                        <- file is to be deleted, second string empty
 106  * \??\D:\test\file2[0]
 107  * !\??\D:\test\file2_renamed[0]
 108  * [0]                        <- indicates end of strings
 109  *
 110  * or:
 111  * \??\D:\test\file1[0]
 112  * !\??\D:\test\file1_renamed[0]
 113  * \??\D:\Test|delete[0]
 114  * [0]                        <- file is to be deleted, second string empty
 115  * [0]                        <- indicates end of strings
 116  *
 117  */
 118 static BOOL add_boot_rename_entry( LPCWSTR source, LPCWSTR dest, DWORD flags )
 119 {
 120     static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
 121                                       'F','i','l','e','R','e','n','a','m','e',
 122                                       'O','p','e','r','a','t','i','o','n','s',0};
 123     static const WCHAR SessionW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 124                                      'M','a','c','h','i','n','e','\\',
 125                                      'S','y','s','t','e','m','\\',
 126                                      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 127                                      'C','o','n','t','r','o','l','\\',
 128                                      'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
 129     static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
 130
 131     OBJECT_ATTRIBUTES attr;
 132     UNICODE_STRING nameW, source_name, dest_name;
 133     KEY_VALUE_PARTIAL_INFORMATION *info;
 134     BOOL rc = FALSE;
 135     HANDLE Reboot = 0;
 136     DWORD len1, len2;
 137     DWORD DataSize = 0;
 138     BYTE *Buffer = NULL;
 139     WCHAR *p;
 140
 141     if (!RtlDosPathNameToNtPathName_U( source, &source_name, NULL, NULL ))
 142     {
 143         SetLastError( ERROR_PATH_NOT_FOUND );
 144         return FALSE;
 145     }
 146     dest_name.Buffer = NULL;
 147     if (dest && !RtlDosPathNameToNtPathName_U( dest, &dest_name, NULL, NULL ))
 148     {
 149         RtlFreeUnicodeString( &source_name );
 150         SetLastError( ERROR_PATH_NOT_FOUND );
 151         return FALSE;
 152     }
 153
 154     attr.Length = sizeof(attr);
 155     attr.RootDirectory = 0;
 156     attr.ObjectName = &nameW;
 157     attr.Attributes = 0;
 158     attr.SecurityDescriptor = NULL;
 159     attr.SecurityQualityOfService = NULL;
 160     RtlInitUnicodeString( &nameW, SessionW );
 161
 162     if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
 163     {
 164         WARN("Error creating key for reboot management [%s]\n",
 165              "SYSTEM\\CurrentControlSet\\Control\\Session Manager");
 166         RtlFreeUnicodeString( &source_name );
 167         RtlFreeUnicodeString( &dest_name );
 168         return FALSE;
 169     }
 170
 171     len1 = source_name.Length + sizeof(WCHAR);
 172     if (dest)
 173     {
 174         len2 = dest_name.Length + sizeof(WCHAR);
 175         if (flags & MOVEFILE_REPLACE_EXISTING)
 176             len2 += sizeof(WCHAR); /* Plus 1 because of the leading '!' */
 177     }
 178     else len2 = sizeof(WCHAR); /* minimum is the 0 characters for the empty second string */
 179
 180     RtlInitUnicodeString( &nameW, ValueName );
 181
 182     /* First we check if the key exists and if so how many bytes it already contains. */
 183     if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
 184                          NULL, 0, &DataSize ) == STATUS_BUFFER_TOO_SMALL)
 185     {
 186         if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
 187             goto Quit;
 188         if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
 189                              Buffer, DataSize, &DataSize )) goto Quit;
 190         info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
 191         if (info->Type != REG_MULTI_SZ) goto Quit;
 192         if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR);  /* remove terminating null (will be added back later) */
 193     }
 194     else
 195     {
 196         DataSize = info_size;
 197         if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
 198             goto Quit;
 199     }
 200
 201     memcpy( Buffer + DataSize, source_name.Buffer, len1 );
 202     DataSize += len1;
 203     p = (WCHAR *)(Buffer + DataSize);
 204     if (dest)
 205     {
 206         if (flags & MOVEFILE_REPLACE_EXISTING)
 207             *p++ = '!';
 208         memcpy( p, dest_name.Buffer, len2 );
 209         DataSize += len2;
 210     }
 211     else
 212     {
 213         *p = 0;
 214         DataSize += sizeof(WCHAR);
 215     }
 216
 217     /* add final null */
 218     p = (WCHAR *)(Buffer + DataSize);
 219     *p = 0;
 220     DataSize += sizeof(WCHAR);
 221
 222     rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
 223
 224  Quit:
 225     RtlFreeUnicodeString( &source_name );
 226     RtlFreeUnicodeString( &dest_name );
 227     if (Reboot) NtClose(Reboot);
 228     HeapFree( GetProcessHeap(), 0, Buffer );
 229     return(rc);
 230 }
 231
 232
 233 /***********************************************************************
 234  *           GetFullPathNameW   (KERNEL32.@)
 235  * NOTES
 236  *   if the path closed with '\', *lastpart is 0
 237  */
 238 DWORD WINAPI GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer,
 239                                LPWSTR *lastpart )
 240 {
 241     return RtlGetFullPathName_U(name, len * sizeof(WCHAR), buffer, lastpart) / sizeof(WCHAR);
 242 }
 243
 244 /***********************************************************************
 245  *           GetFullPathNameA   (KERNEL32.@)
 246  * NOTES
 247  *   if the path closed with '\', *lastpart is 0
 248  */
 249 DWORD WINAPI GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer,
 250                                LPSTR *lastpart )
 251 {
 252     WCHAR *nameW;
 253     WCHAR bufferW[MAX_PATH], *lastpartW = NULL;
 254     DWORD ret;
 255
 256     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return 0;
 257
 258     ret = GetFullPathNameW( nameW, MAX_PATH, bufferW, &lastpartW);
 259
 260     if (!ret) return 0;
 261     if (ret > MAX_PATH)
 262     {
 263         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 264         return 0;
 265     }
 266     ret = copy_filename_WtoA( bufferW, buffer, len );
 267     if (ret < len && lastpart)
 268     {
 269         if (lastpartW)
 270             *lastpart = buffer + FILE_name_WtoA( bufferW, lastpartW - bufferW, NULL, 0 );
 271         else
 272             *lastpart = NULL;
 273     }
 274     return ret;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           GetLongPathNameW   (KERNEL32.@)
 280  *
 281  * NOTES
 282  *  observed (Win2000):
 283  *  shortpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 284  *  shortpath="":   LastError=ERROR_PATH_NOT_FOUND, ret=0
 285  */
 286 DWORD WINAPI GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath, DWORD longlen )
 287 {
 288     WCHAR               tmplongpath[MAX_PATHNAME_LEN];
 289     LPCWSTR             p;
 290     DWORD               sp = 0, lp = 0;
 291     DWORD               tmplen;
 292     BOOL                unixabsolute;
 293     WIN32_FIND_DATAW    wfd;
 294     HANDLE              goit;
 295     BOOL                is_legal_8dot3;
 296
 297     if (!shortpath)
 298     {
 299         SetLastError(ERROR_INVALID_PARAMETER);
 300         return 0;
 301     }
 302     if (!shortpath[0])
 303     {
 304         SetLastError(ERROR_PATH_NOT_FOUND);
 305         return 0;
 306     }
 307
 308     TRACE("%s,%p,%d\n", debugstr_w(shortpath), longpath, longlen);
 309
 310     if (shortpath[0] == '\\' && shortpath[1] == '\\')
 311     {
 312         FIXME("UNC pathname %s\n", debugstr_w(shortpath));
 313
 314         tmplen = strlenW(shortpath);
 315         if (tmplen < longlen)
 316         {
 317             if (longpath != shortpath) strcpyW( longpath, shortpath );
 318             return tmplen;
 319         }
 320         return tmplen + 1;
 321     }
 322
 323     unixabsolute = (shortpath[0] == '/');
 324
 325     /* check for drive letter */
 326     if (!unixabsolute && shortpath[1] == ':' )
 327     {
 328         tmplongpath[0] = shortpath[0];
 329         tmplongpath[1] = ':';
 330         lp = sp = 2;
 331     }
 332
 333     while (shortpath[sp])
 334     {
 335         /* check for path delimiters and reproduce them */
 336         if (shortpath[sp] == '\\' || shortpath[sp] == '/')
 337         {
 338             if (!lp || (tmplongpath[lp-1] != '\\' && tmplongpath[lp-1] != '/'))
 339             {
 340                 /* strip double delimiters */
 341                 tmplongpath[lp++] = shortpath[sp];
 342             }
 343             tmplongpath[lp] = 0; /* terminate string */
 344             sp++;
 345             continue;
 346         }
 347
 348         p = shortpath + sp;
 349         if (sp == 0 && p[0] == '.' && (p[1] == '/' || p[1] == '\\'))
 350         {
 351             tmplongpath[lp++] = *p++;
 352             tmplongpath[lp++] = *p++;
 353             sp += 2;
 354         }
 355         for (; *p && *p != '/' && *p != '\\'; p++);
 356         tmplen = p - (shortpath + sp);
 357         lstrcpynW(tmplongpath + lp, shortpath + sp, tmplen + 1);
 358
 359         if (tmplongpath[lp] == '.')
 360         {
 361             if (tmplen == 1 || (tmplen == 2 && tmplongpath[lp + 1] == '.'))
 362             {
 363                 lp += tmplen;
 364                 sp += tmplen;
 365                 continue;
 366             }
 367         }
 368
 369         /* Check if the file exists */
 370         goit = FindFirstFileW(tmplongpath, &wfd);
 371         if (goit == INVALID_HANDLE_VALUE)
 372         {
 373             TRACE("not found %s!\n", debugstr_w(tmplongpath));
 374             SetLastError ( ERROR_FILE_NOT_FOUND );
 375             return 0;
 376         }
 377         FindClose(goit);
 378
 379         is_legal_8dot3 = FALSE;
 380         CheckNameLegalDOS8Dot3W(tmplongpath + lp, NULL, 0, NULL, &is_legal_8dot3);
 381         /* Use the existing file name if it's a short name */
 382         if (is_legal_8dot3)
 383             strcpyW(tmplongpath + lp, wfd.cFileName);
 384         lp += strlenW(tmplongpath + lp);
 385         sp += tmplen;
 386     }
 387     tmplen = strlenW(shortpath) - 1;
 388     if ((shortpath[tmplen] == '/' || shortpath[tmplen] == '\\') &&
 389         (tmplongpath[lp - 1] != '/' && tmplongpath[lp - 1] != '\\'))
 390         tmplongpath[lp++] = shortpath[tmplen];
 391     tmplongpath[lp] = 0;
 392
 393     tmplen = strlenW(tmplongpath) + 1;
 394     if (tmplen <= longlen)
 395     {
 396         strcpyW(longpath, tmplongpath);
 397         TRACE("returning %s\n", debugstr_w(longpath));
 398         tmplen--; /* length without 0 */
 399     }
 400
 401     return tmplen;
 402 }
 403
 404 /***********************************************************************
 405  *           GetLongPathNameA   (KERNEL32.@)
 406  */
 407 DWORD WINAPI GetLongPathNameA( LPCSTR shortpath, LPSTR longpath, DWORD longlen )
 408 {
 409     WCHAR *shortpathW;
 410     WCHAR longpathW[MAX_PATH];
 411     DWORD ret;
 412
 413     TRACE("%s\n", debugstr_a(shortpath));
 414
 415     if (!(shortpathW = FILE_name_AtoW( shortpath, FALSE ))) return 0;
 416
 417     ret = GetLongPathNameW(shortpathW, longpathW, MAX_PATH);
 418
 419     if (!ret) return 0;
 420     if (ret > MAX_PATH)
 421     {
 422         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 423         return 0;
 424     }
 425     return copy_filename_WtoA( longpathW, longpath, longlen );
 426 }
 427
 428
 429 /***********************************************************************
 430  *           GetShortPathNameW   (KERNEL32.@)
 431  *
 432  * NOTES
 433  *  observed:
 434  *  longpath=NULL: LastError=ERROR_INVALID_PARAMETER, ret=0
 435  *  longpath="" or invalid: LastError=ERROR_BAD_PATHNAME, ret=0
 436  *
 437  * more observations ( with NT 3.51 (WinDD) ):
 438  * longpath <= 8.3 -> just copy longpath to shortpath
 439  * longpath > 8.3  ->
 440  *             a) file does not exist -> return 0, LastError = ERROR_FILE_NOT_FOUND
 441  *             b) file does exist     -> set the short filename.
 442  * - trailing slashes are reproduced in the short name, even if the
 443  *   file is not a directory
 444  * - the absolute/relative path of the short name is reproduced like found
 445  *   in the long name
 446  * - longpath and shortpath may have the same address
 447  * Peter Ganten, 1999
 448  */
 449 DWORD WINAPI GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
 450 {
 451     WCHAR               *tmpshortpath;
 452     LPCWSTR             p;
 453     DWORD               sp = 0, lp = 0;
 454     DWORD               tmplen, buf_len;
 455     WIN32_FIND_DATAW    wfd;
 456     HANDLE              goit;
 457
 458     TRACE("%s\n", debugstr_w(longpath));
 459
 460     if (!longpath)
 461     {
 462         SetLastError(ERROR_INVALID_PARAMETER);
 463         return 0;
 464     }
 465     if (!longpath[0])
 466     {
 467         SetLastError(ERROR_BAD_PATHNAME);
 468         return 0;
 469     }
 470
 471     /* code below only removes characters from string, never adds, so this is
 472      * the largest buffer that tmpshortpath will need to have */
 473     buf_len = strlenW(longpath) + 1;
 474     tmpshortpath = HeapAlloc(GetProcessHeap(), 0, buf_len * sizeof(WCHAR));
 475     if (!tmpshortpath)
 476     {
 477         SetLastError(ERROR_OUTOFMEMORY);
 478         return 0;
 479     }
 480
 481     if (longpath[0] == '\\' && longpath[1] == '\\' && longpath[2] == '?' && longpath[3] == '\\')
 482     {
 483         memcpy(tmpshortpath, longpath, 4 * sizeof(WCHAR));
 484         sp = lp = 4;
 485     }
 486
 487     /* check for drive letter */
 488     if (longpath[lp] != '/' && longpath[lp + 1] == ':' )
 489     {
 490         tmpshortpath[sp] = longpath[lp];
 491         tmpshortpath[sp + 1] = ':';
 492         sp += 2;
 493         lp += 2;
 494     }
 495
 496     while (longpath[lp])
 497     {
 498         /* check for path delimiters and reproduce them */
 499         if (longpath[lp] == '\\' || longpath[lp] == '/')
 500         {
 501             if (!sp || (tmpshortpath[sp-1] != '\\' && tmpshortpath[sp-1] != '/'))
 502             {
 503                 /* strip double delimiters */
 504                 tmpshortpath[sp] = longpath[lp];
 505                 sp++;
 506             }
 507             tmpshortpath[sp] = 0; /* terminate string */
 508             lp++;
 509             continue;
 510         }
 511
 512         p = longpath + lp;
 513         if (lp == 0 && p[0] == '.' && (p[1] == '/' || p[1] == '\\'))
 514         {
 515             tmpshortpath[sp++] = *p++;
 516             tmpshortpath[sp++] = *p++;
 517             lp += 2;
 518         }
 519         for (; *p && *p != '/' && *p != '\\'; p++);
 520         tmplen = p - (longpath + lp);
 521         lstrcpynW(tmpshortpath + sp, longpath + lp, tmplen + 1);
 522
 523         if (tmpshortpath[sp] == '.')
 524         {
 525             if (tmplen == 1 || (tmplen == 2 && tmpshortpath[sp + 1] == '.'))
 526             {
 527                 sp += tmplen;
 528                 lp += tmplen;
 529                 continue;
 530             }
 531         }
 532
 533         /* Check if the file exists and use the existing short file name */
 534         goit = FindFirstFileW(tmpshortpath, &wfd);
 535         if (goit == INVALID_HANDLE_VALUE) goto notfound;
 536         FindClose(goit);
 537
 538         /* In rare cases (like "a.abcd") short path may be longer than original path.
 539          * Make sure we have enough space in temp buffer. */
 540         if (wfd.cAlternateFileName[0] && tmplen < strlenW(wfd.cAlternateFileName))
 541         {
 542             WCHAR *new_buf;
 543             buf_len += strlenW(wfd.cAlternateFileName) - tmplen;
 544             new_buf = HeapReAlloc(GetProcessHeap(), 0, tmpshortpath, buf_len * sizeof(WCHAR));
 545             if(!new_buf)
 546             {
 547                 HeapFree(GetProcessHeap(), 0, tmpshortpath);
 548                 SetLastError(ERROR_OUTOFMEMORY);
 549                 return 0;
 550             }
 551             tmpshortpath = new_buf;
 552         }
 553
 554         strcpyW(tmpshortpath + sp, wfd.cAlternateFileName[0] ? wfd.cAlternateFileName : wfd.cFileName);
 555         sp += strlenW(tmpshortpath + sp);
 556         lp += tmplen;
 557     }
 558     tmpshortpath[sp] = 0;
 559
 560     tmplen = strlenW(tmpshortpath) + 1;
 561     if (tmplen <= shortlen)
 562     {
 563         strcpyW(shortpath, tmpshortpath);
 564         TRACE("returning %s\n", debugstr_w(shortpath));
 565         tmplen--; /* length without 0 */
 566     }
 567
 568     HeapFree(GetProcessHeap(), 0, tmpshortpath);
 569     return tmplen;
 570
 571  notfound:
 572     HeapFree(GetProcessHeap(), 0, tmpshortpath);
 573     TRACE("not found!\n" );
 574     SetLastError ( ERROR_FILE_NOT_FOUND );
 575     return 0;
 576 }
 577
 578 /***********************************************************************
 579  *           GetShortPathNameA   (KERNEL32.@)
 580  */
 581 DWORD WINAPI GetShortPathNameA( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
 582 {
 583     WCHAR *longpathW;
 584     WCHAR shortpathW[MAX_PATH];
 585     DWORD ret;
 586
 587     TRACE("%s\n", debugstr_a(longpath));
 588
 589     if (!(longpathW = FILE_name_AtoW( longpath, FALSE ))) return 0;
 590
 591     ret = GetShortPathNameW(longpathW, shortpathW, MAX_PATH);
 592
 593     if (!ret) return 0;
 594     if (ret > MAX_PATH)
 595     {
 596         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 597         return 0;
 598     }
 599     return copy_filename_WtoA( shortpathW, shortpath, shortlen );
 600 }
 601
 602
 603 /***********************************************************************
 604  *           GetTempPathA   (KERNEL32.@)
 605  */
 606 DWORD WINAPI GetTempPathA( DWORD count, LPSTR path )
 607 {
 608     WCHAR pathW[MAX_PATH];
 609     UINT ret;
 610
 611     ret = GetTempPathW(MAX_PATH, pathW);
 612
 613     if (!ret)
 614         return 0;
 615
 616     if (ret > MAX_PATH)
 617     {
 618         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 619         return 0;
 620     }
 621     return copy_filename_WtoA( pathW, path, count );
 622 }
 623
 624
 625 /***********************************************************************
 626  *           GetTempPathW   (KERNEL32.@)
 627  */
 628 DWORD WINAPI GetTempPathW( DWORD count, LPWSTR path )
 629 {
 630     static const WCHAR tmp[]  = { 'T', 'M', 'P', 0 };
 631     static const WCHAR temp[] = { 'T', 'E', 'M', 'P', 0 };
 632     static const WCHAR userprofile[] = { 'U','S','E','R','P','R','O','F','I','L','E',0 };
 633     WCHAR tmp_path[MAX_PATH];
 634     UINT ret;
 635
 636     TRACE("%u,%p\n", count, path);
 637
 638     if (!(ret = GetEnvironmentVariableW( tmp, tmp_path, MAX_PATH )) &&
 639         !(ret = GetEnvironmentVariableW( temp, tmp_path, MAX_PATH )) &&
 640         !(ret = GetEnvironmentVariableW( userprofile, tmp_path, MAX_PATH )) &&
 641         !(ret = GetWindowsDirectoryW( tmp_path, MAX_PATH )))
 642         return 0;
 643
 644     if (ret > MAX_PATH)
 645     {
 646         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 647         return 0;
 648     }
 649
 650     ret = GetFullPathNameW(tmp_path, MAX_PATH, tmp_path, NULL);
 651     if (!ret) return 0;
 652
 653     if (ret > MAX_PATH - 2)
 654     {
 655         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 656         return 0;
 657     }
 658
 659     if (tmp_path[ret-1] != '\\')
 660     {
 661         tmp_path[ret++] = '\\';
 662         tmp_path[ret]   = '\0';
 663     }
 664
 665     ret++; /* add space for terminating 0 */
 666
 667     if (count >= ret)
 668     {
 669         lstrcpynW(path, tmp_path, count);
 670         /* the remaining buffer must be zeroed up to 32766 bytes in XP or 32767
 671          * bytes after it, we will assume the > XP behavior for now */
 672         memset(path + ret, 0, (min(count, 32767) - ret) * sizeof(WCHAR));
 673         ret--; /* return length without 0 */
 674     }
 675     else if (count)
 676     {
 677         /* the buffer must be cleared if contents will not fit */
 678         memset(path, 0, count * sizeof(WCHAR));
 679     }
 680
 681     TRACE("returning %u, %s\n", ret, debugstr_w(path));
 682     return ret;
 683 }
 684
 685
 686 /***********************************************************************
 687  *           GetTempFileNameA   (KERNEL32.@)
 688  */
 689 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique, LPSTR buffer)
 690 {
 691     WCHAR *pathW, *prefixW = NULL;
 692     WCHAR bufferW[MAX_PATH];
 693     UINT ret;
 694
 695     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return 0;
 696     if (prefix && !(prefixW = FILE_name_AtoW( prefix, TRUE ))) return 0;
 697
 698     ret = GetTempFileNameW(pathW, prefixW, unique, bufferW);
 699     if (ret) FILE_name_WtoA( bufferW, -1, buffer, MAX_PATH );
 700
 701     HeapFree( GetProcessHeap(), 0, prefixW );
 702     return ret;
 703 }
 704
 705 /***********************************************************************
 706  *           GetTempFileNameW   (KERNEL32.@)
 707  */
 708 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique, LPWSTR buffer )
 709 {
 710     static const WCHAR formatW[] = {'%','x','.','t','m','p',0};
 711
 712     int i;
 713     LPWSTR p;
 714     DWORD attr;
 715
 716     if ( !path || !buffer )
 717     {
 718         SetLastError( ERROR_INVALID_PARAMETER );
 719         return 0;
 720     }
 721
 722     /* ensure that the provided directory exists */
 723     attr = GetFileAttributesW(path);
 724     if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
 725     {
 726         TRACE("path not found %s\n", debugstr_w(path));
 727         SetLastError( ERROR_DIRECTORY );
 728         return 0;
 729     }
 730
 731     strcpyW( buffer, path );
 732     p = buffer + strlenW(buffer);
 733
 734     /* add a \, if there isn't one  */
 735     if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
 736
 737     if (prefix)
 738         for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
 739
 740     unique &= 0xffff;
 741
 742     if (unique) sprintfW( p, formatW, unique );
 743     else
 744     {
 745         /* get a "random" unique number and try to create the file */
 746         HANDLE handle;
 747         UINT num = GetTickCount() & 0xffff;
 748         static UINT last;
 749
 750         /* avoid using the same name twice in a short interval */
 751         if (last - num < 10) num = last + 1;
 752         if (!num) num = 1;
 753         unique = num;
 754         do
 755         {
 756             sprintfW( p, formatW, unique );
 757             handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
 758                                   CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
 759             if (handle != INVALID_HANDLE_VALUE)
 760             {  /* We created it */
 761                 TRACE("created %s\n", debugstr_w(buffer) );
 762                 CloseHandle( handle );
 763                 last = unique;
 764                 break;
 765             }
 766             if (GetLastError() != ERROR_FILE_EXISTS &&
 767                 GetLastError() != ERROR_SHARING_VIOLATION)
 768                 break;  /* No need to go on */
 769             if (!(++unique & 0xffff)) unique = 1;
 770         } while (unique != num);
 771     }
 772
 773     TRACE("returning %s\n", debugstr_w(buffer) );
 774     return unique;
 775 }
 776
 777
 778 /***********************************************************************
 779  *           contains_pathW
 780  *
 781  * Check if the file name contains a path; helper for SearchPathW.
 782  * A relative path is not considered a path unless it starts with ./ or ../
 783  */
 784 static inline BOOL contains_pathW (LPCWSTR name)
 785 {
 786     if (RtlDetermineDosPathNameType_U( name ) != RELATIVE_PATH) return TRUE;
 787     if (name[0] != '.') return FALSE;
 788     if (name[1] == '/' || name[1] == '\\') return TRUE;
 789     return (name[1] == '.' && (name[2] == '/' || name[2] == '\\'));
 790 }
 791
 792 /***********************************************************************
 793  *      find_actctx_dllpath
 794  *
 795  * Find the path (if any) of the dll from the activation context.
 796  * Returned path doesn't include a name.
 797  */
 798 static NTSTATUS find_actctx_dllpath(const WCHAR *libname, WCHAR **path)
 799 {
 800     static const WCHAR winsxsW[] = {'\\','w','i','n','s','x','s','\\'};
 801     static const WCHAR dotManifestW[] = {'.','m','a','n','i','f','e','s','t',0};
 802
 803     ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *info;
 804     ACTCTX_SECTION_KEYED_DATA data;
 805     UNICODE_STRING nameW;
 806     NTSTATUS status;
 807     SIZE_T needed, size = 1024;
 808     WCHAR *p;
 809
 810     RtlInitUnicodeString( &nameW, libname );
 811     data.cbSize = sizeof(data);
 812     status = RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
 813                                                     ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
 814                                                     &nameW, &data );
 815     if (status != STATUS_SUCCESS) return status;
 816
 817     for (;;)
 818     {
 819         if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
 820         {
 821             status = STATUS_NO_MEMORY;
 822             goto done;
 823         }
 824         status = RtlQueryInformationActivationContext( 0, data.hActCtx, &data.ulAssemblyRosterIndex,
 825                                                        AssemblyDetailedInformationInActivationContext,
 826                                                        info, size, &needed );
 827         if (status == STATUS_SUCCESS) break;
 828         if (status != STATUS_BUFFER_TOO_SMALL) goto done;
 829         HeapFree( GetProcessHeap(), 0, info );
 830         size = needed;
 831         /* restart with larger buffer */
 832     }
 833
 834     if (!info->lpAssemblyManifestPath || !info->lpAssemblyDirectoryName)
 835     {
 836         status = STATUS_SXS_KEY_NOT_FOUND;
 837         goto done;
 838     }
 839
 840     if ((p = strrchrW( info->lpAssemblyManifestPath, '\\' )))
 841     {
 842         DWORD dirlen = info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
 843
 844         p++;
 845         if (strncmpiW( p, info->lpAssemblyDirectoryName, dirlen ) || strcmpiW( p + dirlen, dotManifestW ))
 846         {
 847             /* manifest name does not match directory name, so it's not a global
 848              * windows/winsxs manifest; use the manifest directory name instead */
 849             dirlen = p - info->lpAssemblyManifestPath;
 850             needed = (dirlen + 1) * sizeof(WCHAR);
 851             if (!(*path = p = HeapAlloc( GetProcessHeap(), 0, needed )))
 852             {
 853                 status = STATUS_NO_MEMORY;
 854                 goto done;
 855             }
 856             memcpy( p, info->lpAssemblyManifestPath, dirlen * sizeof(WCHAR) );
 857             *(p + dirlen) = 0;
 858             goto done;
 859         }
 860     }
 861
 862     needed = (strlenW( DIR_Windows ) * sizeof(WCHAR) +
 863               sizeof(winsxsW) + info->ulAssemblyDirectoryNameLength + 2*sizeof(WCHAR));
 864
 865     if (!(*path = p = HeapAlloc( GetProcessHeap(), 0, needed )))
 866     {
 867         status = STATUS_NO_MEMORY;
 868         goto done;
 869     }
 870     strcpyW( p, DIR_Windows );
 871     p += strlenW(p);
 872     memcpy( p, winsxsW, sizeof(winsxsW) );
 873     p += sizeof(winsxsW) / sizeof(WCHAR);
 874     memcpy( p, info->lpAssemblyDirectoryName, info->ulAssemblyDirectoryNameLength );
 875     p += info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
 876     *p++ = '\\';
 877     *p = 0;
 878 done:
 879     HeapFree( GetProcessHeap(), 0, info );
 880     RtlReleaseActivationContext( data.hActCtx );
 881     return status;
 882 }
 883
 884 /***********************************************************************
 885  * SearchPathW [KERNEL32.@]
 886  *
 887  * Searches for a specified file in the search path.
 888  *
 889  * PARAMS
 890  *    path      [I] Path to search (NULL means default)
 891  *    name      [I] Filename to search for.
 892  *    ext       [I] File extension to append to file name. The first
 893  *                  character must be a period. This parameter is
 894  *                  specified only if the filename given does not
 895  *                  contain an extension.
 896  *    buflen    [I] size of buffer, in characters
 897  *    buffer    [O] buffer for found filename
 898  *    lastpart  [O] address of pointer to last used character in
 899  *                  buffer (the final '\')
 900  *
 901  * RETURNS
 902  *    Success: length of string copied into buffer, not including
 903  *             terminating null character. If the filename found is
 904  *             longer than the length of the buffer, the length of the
 905  *             filename is returned.
 906  *    Failure: Zero
 907  *
 908  * NOTES
 909  *    If the file is not found, calls SetLastError(ERROR_FILE_NOT_FOUND)
 910  *    (tested on NT 4.0)
 911  */
 912 DWORD WINAPI SearchPathW( LPCWSTR path, LPCWSTR name, LPCWSTR ext, DWORD buflen,
 913                           LPWSTR buffer, LPWSTR *lastpart )
 914 {
 915     DWORD ret = 0;
 916
 917     if (!name || !name[0])
 918     {
 919         SetLastError(ERROR_INVALID_PARAMETER);
 920         return 0;
 921     }
 922
 923     /* If the name contains an explicit path, ignore the path */
 924
 925     if (contains_pathW(name))
 926     {
 927         /* try first without extension */
 928         if (RtlDoesFileExists_U( name ))
 929             return GetFullPathNameW( name, buflen, buffer, lastpart );
 930
 931         if (ext)
 932         {
 933             LPCWSTR p = strrchrW( name, '.' );
 934             if (p && !strchrW( p, '/' ) && !strchrW( p, '\\' ))
 935                 ext = NULL;  /* Ignore the specified extension */
 936         }
 937
 938         /* Allocate a buffer for the file name and extension */
 939         if (ext)
 940         {
 941             LPWSTR tmp;
 942             DWORD len = strlenW(name) + strlenW(ext);
 943
 944             if (!(tmp = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
 945             {
 946                 SetLastError( ERROR_OUTOFMEMORY );
 947                 return 0;
 948             }
 949             strcpyW( tmp, name );
 950             strcatW( tmp, ext );
 951             if (RtlDoesFileExists_U( tmp ))
 952                 ret = GetFullPathNameW( tmp, buflen, buffer, lastpart );
 953             HeapFree( GetProcessHeap(), 0, tmp );
 954         }
 955     }
 956     else if (path && path[0])  /* search in the specified path */
 957     {
 958         ret = RtlDosSearchPath_U( path, name, ext, buflen * sizeof(WCHAR),
 959                                   buffer, lastpart ) / sizeof(WCHAR);
 960     }
 961     else  /* search in active context and default path */
 962     {
 963         WCHAR *dll_path = NULL, *search = NULL;
 964         DWORD req_len, name_len;
 965
 966         req_len = name_len = strlenW(name);
 967
 968         if (strchrW( name, '.' )) ext = NULL;
 969         if (ext)
 970         {
 971             DWORD ext_len = strlenW(ext);
 972
 973             req_len += ext_len;
 974             name_len += ext_len;
 975
 976             search = HeapAlloc( GetProcessHeap(), 0, (name_len + ext_len + 1) * sizeof(WCHAR) );
 977             if (!search)
 978             {
 979                 SetLastError( ERROR_OUTOFMEMORY );
 980                 return 0;
 981             }
 982             strcpyW( search, name );
 983             strcatW( search, ext );
 984             name = search;
 985
 986             /* now that we have combined name we don't need extension any more */
 987         }
 988
 989         /* When file is found with activation context no attempt is made
 990           to check if it's really exist, path is returned only basing on context info. */
 991         if (find_actctx_dllpath( name, &dll_path ) == STATUS_SUCCESS)
 992         {
 993             DWORD path_len;
 994
 995             path_len = strlenW(dll_path);
 996             req_len += path_len;
 997
 998             if (lastpart) *lastpart = NULL;
 999
1000             /* count null termination char too */
1001             if (req_len + 1 <= buflen)
1002             {
1003                 memcpy( buffer, dll_path, path_len * sizeof(WCHAR) );
1004                 memcpy( &buffer[path_len], name, name_len * sizeof(WCHAR) );
1005                 buffer[req_len] = 0;
1006                 if (lastpart) *lastpart = buffer + path_len;
1007                 ret = req_len;
1008             }
1009             else
1010                 ret = req_len + 1;
1011
1012             HeapFree( GetProcessHeap(), 0, dll_path );
1013             HeapFree( GetProcessHeap(), 0, search );
1014         }
1015         else
1016         {
1017             if ((dll_path = MODULE_get_dll_load_path( NULL )))
1018             {
1019                 ret = RtlDosSearchPath_U( dll_path, name, NULL, buflen * sizeof(WCHAR),
1020                                           buffer, lastpart ) / sizeof(WCHAR);
1021                 HeapFree( GetProcessHeap(), 0, dll_path );
1022                 HeapFree( GetProcessHeap(), 0, search );
1023             }
1024             else
1025             {
1026                 SetLastError( ERROR_OUTOFMEMORY );
1027                 return 0;
1028             }
1029         }
1030     }
1031
1032     if (!ret) SetLastError( ERROR_FILE_NOT_FOUND );
1033     else TRACE( "found %s\n", debugstr_w(buffer) );
1034     return ret;
1035 }
1036
1037
1038 /***********************************************************************
1039  *           SearchPathA   (KERNEL32.@)
1040  *
1041  * See SearchPathW.
1042  */
1043 DWORD WINAPI SearchPathA( LPCSTR path, LPCSTR name, LPCSTR ext,
1044                           DWORD buflen, LPSTR buffer, LPSTR *lastpart )
1045 {
1046     WCHAR *pathW = NULL, *nameW, *extW = NULL;
1047     WCHAR bufferW[MAX_PATH];
1048     DWORD ret;
1049
1050     if (!name)
1051     {
1052         SetLastError(ERROR_INVALID_PARAMETER);
1053         return 0;
1054     }
1055
1056     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return 0;
1057     if (path && !(pathW = FILE_name_AtoW( path, TRUE ))) return 0;
1058
1059     if (ext && !(extW = FILE_name_AtoW( ext, TRUE )))
1060     {
1061         HeapFree( GetProcessHeap(), 0, pathW );
1062         return 0;
1063     }
1064
1065     ret = SearchPathW(pathW, nameW, extW, MAX_PATH, bufferW, NULL);
1066
1067     HeapFree( GetProcessHeap(), 0, pathW );
1068     HeapFree( GetProcessHeap(), 0, extW );
1069
1070     if (!ret) return 0;
1071     if (ret > MAX_PATH)
1072     {
1073         SetLastError(ERROR_FILENAME_EXCED_RANGE);
1074         return 0;
1075     }
1076     ret = copy_filename_WtoA( bufferW, buffer, buflen );
1077     if (buflen > ret && lastpart)
1078         *lastpart = strrchr(buffer, '\\') + 1;
1079     return ret;
1080 }
1081
1082 static BOOL is_same_file(HANDLE h1, HANDLE h2)
1083 {
1084     int fd1;
1085     BOOL ret = FALSE;
1086     if (wine_server_handle_to_fd(h1, 0, &fd1, NULL) == STATUS_SUCCESS)
1087     {
1088         int fd2;
1089         if (wine_server_handle_to_fd(h2, 0, &fd2, NULL) == STATUS_SUCCESS)
1090         {
1091             struct stat stat1, stat2;
1092             if (fstat(fd1, &stat1) == 0 && fstat(fd2, &stat2) == 0)
1093                 ret = (stat1.st_dev == stat2.st_dev && stat1.st_ino == stat2.st_ino);
1094             wine_server_release_fd(h2, fd2);
1095         }
1096         wine_server_release_fd(h1, fd1);
1097     }
1098     return ret;
1099 }
1100
1101 /**************************************************************************
1102  *           CopyFileW   (KERNEL32.@)
1103  */
1104 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
1105 {
1106     return CopyFileExW( source, dest, NULL, NULL, NULL,
1107                         fail_if_exists ? COPY_FILE_FAIL_IF_EXISTS : 0 );
1108 }
1109
1110
1111 /**************************************************************************
1112  *           CopyFileA   (KERNEL32.@)
1113  */
1114 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
1115 {
1116     WCHAR *sourceW, *destW;
1117     BOOL ret;
1118
1119     if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
1120     if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
1121
1122     ret = CopyFileW( sourceW, destW, fail_if_exists );
1123
1124     HeapFree( GetProcessHeap(), 0, destW );
1125     return ret;
1126 }
1127
1128
1129 /**************************************************************************
1130  *           CopyFileExW   (KERNEL32.@)
1131  */
1132 BOOL WINAPI CopyFileExW(LPCWSTR source, LPCWSTR dest,
1133                         LPPROGRESS_ROUTINE progress, LPVOID param,
1134                         LPBOOL cancel_ptr, DWORD flags)
1135 {
1136     static const int buffer_size = 65536;
1137     HANDLE h1, h2;
1138     BY_HANDLE_FILE_INFORMATION info;
1139     DWORD count;
1140     BOOL ret = FALSE;
1141     char *buffer;
1142
1143     if (!source || !dest)
1144     {
1145         SetLastError(ERROR_INVALID_PARAMETER);
1146         return FALSE;
1147     }
1148     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size )))
1149     {
1150         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1151         return FALSE;
1152     }
1153
1154     TRACE("%s -> %s, %x\n", debugstr_w(source), debugstr_w(dest), flags);
1155
1156     if ((h1 = CreateFileW(source, GENERIC_READ,
1157                      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1158                      NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
1159     {
1160         WARN("Unable to open source %s\n", debugstr_w(source));
1161         HeapFree( GetProcessHeap(), 0, buffer );
1162         return FALSE;
1163     }
1164
1165     if (!GetFileInformationByHandle( h1, &info ))
1166     {
1167         WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
1168         HeapFree( GetProcessHeap(), 0, buffer );
1169         CloseHandle( h1 );
1170         return FALSE;
1171     }
1172
1173     if (!(flags & COPY_FILE_FAIL_IF_EXISTS))
1174     {
1175         BOOL same_file = FALSE;
1176         h2 = CreateFileW( dest, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1177                          OPEN_EXISTING, 0, 0);
1178         if (h2 != INVALID_HANDLE_VALUE)
1179         {
1180             same_file = is_same_file( h1, h2 );
1181             CloseHandle( h2 );
1182         }
1183         if (same_file)
1184         {
1185             HeapFree( GetProcessHeap(), 0, buffer );
1186             CloseHandle( h1 );
1187             SetLastError( ERROR_SHARING_VIOLATION );
1188             return FALSE;
1189         }
1190     }
1191
1192     if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1193                              (flags & COPY_FILE_FAIL_IF_EXISTS) ? CREATE_NEW : CREATE_ALWAYS,
1194                              info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
1195     {
1196         WARN("Unable to open dest %s\n", debugstr_w(dest));
1197         HeapFree( GetProcessHeap(), 0, buffer );
1198         CloseHandle( h1 );
1199         return FALSE;
1200     }
1201
1202     while (ReadFile( h1, buffer, buffer_size, &count, NULL ) && count)
1203     {
1204         char *p = buffer;
1205         while (count != 0)
1206         {
1207             DWORD res;
1208             if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
1209             p += res;
1210             count -= res;
1211         }
1212     }
1213     ret =  TRUE;
1214 done:
1215     /* Maintain the timestamp of source file to destination file */
1216     SetFileTime(h2, NULL, NULL, &info.ftLastWriteTime);
1217     HeapFree( GetProcessHeap(), 0, buffer );
1218     CloseHandle( h1 );
1219     CloseHandle( h2 );
1220     return ret;
1221 }
1222
1223
1224 /**************************************************************************
1225  *           CopyFileExA   (KERNEL32.@)
1226  */
1227 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
1228                         LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
1229                         LPBOOL cancelFlagPointer, DWORD copyFlags)
1230 {
1231     WCHAR *sourceW, *destW;
1232     BOOL ret;
1233
1234     /* can't use the TEB buffer since we may have a callback routine */
1235     if (!(sourceW = FILE_name_AtoW( sourceFilename, TRUE ))) return FALSE;
1236     if (!(destW = FILE_name_AtoW( destFilename, TRUE )))
1237     {
1238         HeapFree( GetProcessHeap(), 0, sourceW );
1239         return FALSE;
1240     }
1241     ret = CopyFileExW(sourceW, destW, progressRoutine, appData,
1242                       cancelFlagPointer, copyFlags);
1243     HeapFree( GetProcessHeap(), 0, sourceW );
1244     HeapFree( GetProcessHeap(), 0, destW );
1245     return ret;
1246 }
1247
1248
1249 /**************************************************************************
1250  *           MoveFileWithProgressW   (KERNEL32.@)
1251  */
1252 BOOL WINAPI MoveFileWithProgressW( LPCWSTR source, LPCWSTR dest,
1253                                    LPPROGRESS_ROUTINE fnProgress,
1254                                    LPVOID param, DWORD flag )
1255 {
1256     FILE_BASIC_INFORMATION info;
1257     UNICODE_STRING nt_name;
1258     OBJECT_ATTRIBUTES attr;
1259     IO_STATUS_BLOCK io;
1260     NTSTATUS status;
1261     HANDLE source_handle = 0, dest_handle;
1262     ANSI_STRING source_unix, dest_unix;
1263
1264     TRACE("(%s,%s,%p,%p,%04x)\n",
1265           debugstr_w(source), debugstr_w(dest), fnProgress, param, flag );
1266
1267     if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1268         return add_boot_rename_entry( source, dest, flag );
1269
1270     if (!dest)
1271         return DeleteFileW( source );
1272
1273     if (flag & MOVEFILE_WRITE_THROUGH)
1274         FIXME("MOVEFILE_WRITE_THROUGH unimplemented\n");
1275
1276     /* check if we are allowed to rename the source */
1277
1278     if (!RtlDosPathNameToNtPathName_U( source, &nt_name, NULL, NULL ))
1279     {
1280         SetLastError( ERROR_PATH_NOT_FOUND );
1281         return FALSE;
1282     }
1283     source_unix.Buffer = NULL;
1284     dest_unix.Buffer = NULL;
1285     attr.Length = sizeof(attr);
1286     attr.RootDirectory = 0;
1287     attr.Attributes = OBJ_CASE_INSENSITIVE;
1288     attr.ObjectName = &nt_name;
1289     attr.SecurityDescriptor = NULL;
1290     attr.SecurityQualityOfService = NULL;
1291
1292     status = NtOpenFile( &source_handle, SYNCHRONIZE, &attr, &io, 0, FILE_SYNCHRONOUS_IO_NONALERT );
1293     if (status == STATUS_SUCCESS)
1294         status = wine_nt_to_unix_file_name( &nt_name, &source_unix, FILE_OPEN, FALSE );
1295     RtlFreeUnicodeString( &nt_name );
1296     if (status != STATUS_SUCCESS)
1297     {
1298         SetLastError( RtlNtStatusToDosError(status) );
1299         goto error;
1300     }
1301     status = NtQueryInformationFile( source_handle, &io, &info, sizeof(info), FileBasicInformation );
1302     if (status != STATUS_SUCCESS)
1303     {
1304         SetLastError( RtlNtStatusToDosError(status) );
1305         goto error;
1306     }
1307
1308     /* we must have write access to the destination, and it must */
1309     /* not exist except if MOVEFILE_REPLACE_EXISTING is set */
1310
1311     if (!RtlDosPathNameToNtPathName_U( dest, &nt_name, NULL, NULL ))
1312     {
1313         SetLastError( ERROR_PATH_NOT_FOUND );
1314         goto error;
1315     }
1316     status = NtOpenFile( &dest_handle, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, &attr, &io, 0,
1317                          FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
1318     if (status == STATUS_SUCCESS)  /* destination exists */
1319     {
1320         NtClose( dest_handle );
1321         if (!(flag & MOVEFILE_REPLACE_EXISTING))
1322         {
1323             SetLastError( ERROR_ALREADY_EXISTS );
1324             RtlFreeUnicodeString( &nt_name );
1325             goto error;
1326         }
1327         else if (info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) /* cannot replace directory */
1328         {
1329             SetLastError( ERROR_ACCESS_DENIED );
1330             goto error;
1331         }
1332     }
1333     else if (status != STATUS_OBJECT_NAME_NOT_FOUND)
1334     {
1335         SetLastError( RtlNtStatusToDosError(status) );
1336         RtlFreeUnicodeString( &nt_name );
1337         goto error;
1338     }
1339
1340     status = wine_nt_to_unix_file_name( &nt_name, &dest_unix, FILE_OPEN_IF, FALSE );
1341     RtlFreeUnicodeString( &nt_name );
1342     if (status != STATUS_SUCCESS && status != STATUS_NO_SUCH_FILE)
1343     {
1344         SetLastError( RtlNtStatusToDosError(status) );
1345         goto error;
1346     }
1347
1348     /* now perform the rename */
1349
1350     if (rename( source_unix.Buffer, dest_unix.Buffer ) == -1)
1351     {
1352         if (errno == EXDEV && (flag & MOVEFILE_COPY_ALLOWED))
1353         {
1354             NtClose( source_handle );
1355             RtlFreeAnsiString( &source_unix );
1356             RtlFreeAnsiString( &dest_unix );
1357             if (!CopyFileExW( source, dest, fnProgress,
1358                               param, NULL, COPY_FILE_FAIL_IF_EXISTS ))
1359                 return FALSE;
1360             return DeleteFileW( source );
1361         }
1362         FILE_SetDosError();
1363         /* if we created the destination, remove it */
1364         if (io.Information == FILE_CREATED) unlink( dest_unix.Buffer );
1365         goto error;
1366     }
1367
1368     /* fixup executable permissions */
1369
1370     if (is_executable( source ) != is_executable( dest ))
1371     {
1372         struct stat fstat;
1373         if (stat( dest_unix.Buffer, &fstat ) != -1)
1374         {
1375             if (is_executable( dest ))
1376                 /* set executable bit where read bit is set */
1377                 fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
1378             else
1379                 fstat.st_mode &= ~0111;
1380             chmod( dest_unix.Buffer, fstat.st_mode );
1381         }
1382     }
1383
1384     NtClose( source_handle );
1385     RtlFreeAnsiString( &source_unix );
1386     RtlFreeAnsiString( &dest_unix );
1387     return TRUE;
1388
1389 error:
1390     if (source_handle) NtClose( source_handle );
1391     RtlFreeAnsiString( &source_unix );
1392     RtlFreeAnsiString( &dest_unix );
1393     return FALSE;
1394 }
1395
1396 /**************************************************************************
1397  *           MoveFileWithProgressA   (KERNEL32.@)
1398  */
1399 BOOL WINAPI MoveFileWithProgressA( LPCSTR source, LPCSTR dest,
1400                                    LPPROGRESS_ROUTINE fnProgress,
1401                                    LPVOID param, DWORD flag )
1402 {
1403     WCHAR *sourceW, *destW;
1404     BOOL ret;
1405
1406     if (!(sourceW = FILE_name_AtoW( source, FALSE ))) return FALSE;
1407     if (dest)
1408     {
1409         if (!(destW = FILE_name_AtoW( dest, TRUE ))) return FALSE;
1410     }
1411     else
1412         destW = NULL;
1413
1414     ret = MoveFileWithProgressW( sourceW, destW, fnProgress, param, flag );
1415     HeapFree( GetProcessHeap(), 0, destW );
1416     return ret;
1417 }
1418
1419 /**************************************************************************
1420  *           MoveFileExW   (KERNEL32.@)
1421  */
1422 BOOL WINAPI MoveFileExW( LPCWSTR source, LPCWSTR dest, DWORD flag )
1423 {
1424     return MoveFileWithProgressW( source, dest, NULL, NULL, flag );
1425 }
1426
1427 /**************************************************************************
1428  *           MoveFileExA   (KERNEL32.@)
1429  */
1430 BOOL WINAPI MoveFileExA( LPCSTR source, LPCSTR dest, DWORD flag )
1431 {
1432     return MoveFileWithProgressA( source, dest, NULL, NULL, flag );
1433 }
1434
1435
1436 /**************************************************************************
1437  *           MoveFileW   (KERNEL32.@)
1438  *
1439  *  Move file or directory
1440  */
1441 BOOL WINAPI MoveFileW( LPCWSTR source, LPCWSTR dest )
1442 {
1443     return MoveFileExW( source, dest, MOVEFILE_COPY_ALLOWED );
1444 }
1445
1446
1447 /**************************************************************************
1448  *           MoveFileA   (KERNEL32.@)
1449  */
1450 BOOL WINAPI MoveFileA( LPCSTR source, LPCSTR dest )
1451 {
1452     return MoveFileExA( source, dest, MOVEFILE_COPY_ALLOWED );
1453 }
1454
1455
1456 /*************************************************************************
1457  *           CreateHardLinkW   (KERNEL32.@)
1458  */
1459 BOOL WINAPI CreateHardLinkW(LPCWSTR lpFileName, LPCWSTR lpExistingFileName,
1460     LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1461 {
1462     NTSTATUS status;
1463     UNICODE_STRING ntDest, ntSource;
1464     ANSI_STRING unixDest, unixSource;
1465     BOOL ret = FALSE;
1466
1467     TRACE("(%s, %s, %p)\n", debugstr_w(lpFileName),
1468         debugstr_w(lpExistingFileName), lpSecurityAttributes);
1469
1470     ntDest.Buffer = ntSource.Buffer = NULL;
1471     if (!RtlDosPathNameToNtPathName_U( lpFileName, &ntDest, NULL, NULL ) ||
1472         !RtlDosPathNameToNtPathName_U( lpExistingFileName, &ntSource, NULL, NULL ))
1473     {
1474         SetLastError( ERROR_PATH_NOT_FOUND );
1475         goto err;
1476     }
1477
1478     unixSource.Buffer = unixDest.Buffer = NULL;
1479     status = wine_nt_to_unix_file_name( &ntSource, &unixSource, FILE_OPEN, FALSE );
1480     if (!status)
1481     {
1482         status = wine_nt_to_unix_file_name( &ntDest, &unixDest, FILE_CREATE, FALSE );
1483         if (!status) /* destination must not exist */
1484         {
1485             status = STATUS_OBJECT_NAME_EXISTS;
1486         } else if (status == STATUS_NO_SUCH_FILE)
1487         {
1488             status = STATUS_SUCCESS;
1489         }
1490     }
1491
1492     if (status)
1493          SetLastError( RtlNtStatusToDosError(status) );
1494     else if (!link( unixSource.Buffer, unixDest.Buffer ))
1495     {
1496         TRACE("Hardlinked '%s' to '%s'\n", debugstr_a( unixDest.Buffer ),
1497                 debugstr_a( unixSource.Buffer ));
1498         ret = TRUE;
1499     }
1500     else
1501         FILE_SetDosError();
1502
1503     RtlFreeAnsiString( &unixSource );
1504     RtlFreeAnsiString( &unixDest );
1505
1506 err:
1507     RtlFreeUnicodeString( &ntSource );
1508     RtlFreeUnicodeString( &ntDest );
1509     return ret;
1510 }
1511
1512
1513 /*************************************************************************
1514  *           CreateHardLinkA   (KERNEL32.@)
1515  */
1516 BOOL WINAPI CreateHardLinkA(LPCSTR lpFileName, LPCSTR lpExistingFileName,
1517     LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1518 {
1519     WCHAR *sourceW, *destW;
1520     BOOL res;
1521
1522     if (!(sourceW = FILE_name_AtoW( lpExistingFileName, TRUE )))
1523     {
1524         return FALSE;
1525     }
1526     if (!(destW = FILE_name_AtoW( lpFileName, TRUE )))
1527     {
1528         HeapFree( GetProcessHeap(), 0, sourceW );
1529         return FALSE;
1530     }
1531
1532     res = CreateHardLinkW( destW, sourceW, lpSecurityAttributes );
1533
1534     HeapFree( GetProcessHeap(), 0, sourceW );
1535     HeapFree( GetProcessHeap(), 0, destW );
1536
1537     return res;
1538 }
1539
1540
1541 /***********************************************************************
1542  *           CreateDirectoryW   (KERNEL32.@)
1543  * RETURNS:
1544  *      TRUE : success
1545  *      FALSE : failure
1546  *              ERROR_DISK_FULL:        on full disk
1547  *              ERROR_ALREADY_EXISTS:   if directory name exists (even as file)
1548  *              ERROR_ACCESS_DENIED:    on permission problems
1549  *              ERROR_FILENAME_EXCED_RANGE: too long filename(s)
1550  */
1551 BOOL WINAPI CreateDirectoryW( LPCWSTR path, LPSECURITY_ATTRIBUTES sa )
1552 {
1553     OBJECT_ATTRIBUTES attr;
1554     UNICODE_STRING nt_name;
1555     IO_STATUS_BLOCK io;
1556     NTSTATUS status;
1557     HANDLE handle;
1558     BOOL ret = FALSE;
1559
1560     TRACE( "%s\n", debugstr_w(path) );
1561
1562     if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1563     {
1564         SetLastError( ERROR_PATH_NOT_FOUND );
1565         return FALSE;
1566     }
1567     attr.Length = sizeof(attr);
1568     attr.RootDirectory = 0;
1569     attr.Attributes = OBJ_CASE_INSENSITIVE;
1570     attr.ObjectName = &nt_name;
1571     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1572     attr.SecurityQualityOfService = NULL;
1573
1574     status = NtCreateFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, NULL,
1575                            FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_CREATE,
1576                            FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 );
1577
1578     if (status == STATUS_SUCCESS)
1579     {
1580         NtClose( handle );
1581         ret = TRUE;
1582     }
1583     else SetLastError( RtlNtStatusToDosError(status) );
1584
1585     RtlFreeUnicodeString( &nt_name );
1586     return ret;
1587 }
1588
1589
1590 /***********************************************************************
1591  *           CreateDirectoryA   (KERNEL32.@)
1592  */
1593 BOOL WINAPI CreateDirectoryA( LPCSTR path, LPSECURITY_ATTRIBUTES sa )
1594 {
1595     WCHAR *pathW;
1596
1597     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1598     return CreateDirectoryW( pathW, sa );
1599 }
1600
1601
1602 /***********************************************************************
1603  *           CreateDirectoryExA   (KERNEL32.@)
1604  */
1605 BOOL WINAPI CreateDirectoryExA( LPCSTR template, LPCSTR path, LPSECURITY_ATTRIBUTES sa )
1606 {
1607     WCHAR *pathW, *templateW = NULL;
1608     BOOL ret;
1609
1610     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1611     if (template && !(templateW = FILE_name_AtoW( template, TRUE ))) return FALSE;
1612
1613     ret = CreateDirectoryExW( templateW, pathW, sa );
1614     HeapFree( GetProcessHeap(), 0, templateW );
1615     return ret;
1616 }
1617
1618
1619 /***********************************************************************
1620  *           CreateDirectoryExW   (KERNEL32.@)
1621  */
1622 BOOL WINAPI CreateDirectoryExW( LPCWSTR template, LPCWSTR path, LPSECURITY_ATTRIBUTES sa )
1623 {
1624     return CreateDirectoryW( path, sa );
1625 }
1626
1627
1628 /***********************************************************************
1629  *           RemoveDirectoryW   (KERNEL32.@)
1630  */
1631 BOOL WINAPI RemoveDirectoryW( LPCWSTR path )
1632 {
1633     OBJECT_ATTRIBUTES attr;
1634     UNICODE_STRING nt_name;
1635     ANSI_STRING unix_name;
1636     IO_STATUS_BLOCK io;
1637     NTSTATUS status;
1638     HANDLE handle;
1639     BOOL ret = FALSE;
1640
1641     TRACE( "%s\n", debugstr_w(path) );
1642
1643     if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1644     {
1645         SetLastError( ERROR_PATH_NOT_FOUND );
1646         return FALSE;
1647     }
1648     attr.Length = sizeof(attr);
1649     attr.RootDirectory = 0;
1650     attr.Attributes = OBJ_CASE_INSENSITIVE;
1651     attr.ObjectName = &nt_name;
1652     attr.SecurityDescriptor = NULL;
1653     attr.SecurityQualityOfService = NULL;
1654
1655     status = NtOpenFile( &handle, DELETE | SYNCHRONIZE, &attr, &io,
1656                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1657                          FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
1658     if (status == STATUS_SUCCESS)
1659         status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN, FALSE );
1660     RtlFreeUnicodeString( &nt_name );
1661
1662     if (status != STATUS_SUCCESS)
1663     {
1664         SetLastError( RtlNtStatusToDosError(status) );
1665         return FALSE;
1666     }
1667
1668     if (!(ret = (rmdir( unix_name.Buffer ) != -1))) FILE_SetDosError();
1669     RtlFreeAnsiString( &unix_name );
1670     NtClose( handle );
1671     return ret;
1672 }
1673
1674
1675 /***********************************************************************
1676  *           RemoveDirectoryA   (KERNEL32.@)
1677  */
1678 BOOL WINAPI RemoveDirectoryA( LPCSTR path )
1679 {
1680     WCHAR *pathW;
1681
1682     if (!(pathW = FILE_name_AtoW( path, FALSE ))) return FALSE;
1683     return RemoveDirectoryW( pathW );
1684 }
1685
1686
1687 /***********************************************************************
1688  *           GetCurrentDirectoryW   (KERNEL32.@)
1689  */
1690 UINT WINAPI GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
1691 {
1692     return RtlGetCurrentDirectory_U( buflen * sizeof(WCHAR), buf ) / sizeof(WCHAR);
1693 }
1694
1695
1696 /***********************************************************************
1697  *           GetCurrentDirectoryA   (KERNEL32.@)
1698  */
1699 UINT WINAPI GetCurrentDirectoryA( UINT buflen, LPSTR buf )
1700 {
1701     WCHAR bufferW[MAX_PATH];
1702     DWORD ret;
1703
1704     if (buflen && buf && ((ULONG_PTR)buf >> 16) == 0)
1705     {
1706         /* Win9x catches access violations here, returning zero.
1707          * This behaviour resulted in some people not noticing
1708          * that they got the argument order wrong. So let's be
1709          * nice and fail gracefully if buf is invalid and looks
1710          * more like a buflen. */
1711         SetLastError(ERROR_INVALID_PARAMETER);
1712         return 0;
1713     }
1714
1715     ret = RtlGetCurrentDirectory_U( sizeof(bufferW), bufferW );
1716     if (!ret) return 0;
1717     if (ret > sizeof(bufferW))
1718     {
1719         SetLastError(ERROR_FILENAME_EXCED_RANGE);
1720         return 0;
1721     }
1722     return copy_filename_WtoA( bufferW, buf, buflen );
1723 }
1724
1725
1726 /***********************************************************************
1727  *           SetCurrentDirectoryW   (KERNEL32.@)
1728  */
1729 BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dir )
1730 {
1731     UNICODE_STRING dirW;
1732     NTSTATUS status;
1733
1734     RtlInitUnicodeString( &dirW, dir );
1735     status = RtlSetCurrentDirectory_U( &dirW );
1736     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
1737     return !status;
1738 }
1739
1740
1741 /***********************************************************************
1742  *           SetCurrentDirectoryA   (KERNEL32.@)
1743  */
1744 BOOL WINAPI SetCurrentDirectoryA( LPCSTR dir )
1745 {
1746     WCHAR *dirW;
1747     UNICODE_STRING strW;
1748     NTSTATUS status;
1749
1750     if (!(dirW = FILE_name_AtoW( dir, FALSE ))) return FALSE;
1751     RtlInitUnicodeString( &strW, dirW );
1752     status = RtlSetCurrentDirectory_U( &strW );
1753     if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
1754     return !status;
1755 }
1756
1757
1758 /***********************************************************************
1759  *           GetWindowsDirectoryW   (KERNEL32.@)
1760  *
1761  * See comment for GetWindowsDirectoryA.
1762  */
1763 UINT WINAPI GetWindowsDirectoryW( LPWSTR path, UINT count )
1764 {
1765     UINT len = strlenW( DIR_Windows ) + 1;
1766     if (path && count >= len)
1767     {
1768         strcpyW( path, DIR_Windows );
1769         len--;
1770     }
1771     return len;
1772 }
1773
1774
1775 /***********************************************************************
1776  *           GetWindowsDirectoryA   (KERNEL32.@)
1777  *
1778  * Return value:
1779  * If buffer is large enough to hold full path and terminating '\0' character
1780  * function copies path to buffer and returns length of the path without '\0'.
1781  * Otherwise function returns required size including '\0' character and
1782  * does not touch the buffer.
1783  */
1784 UINT WINAPI GetWindowsDirectoryA( LPSTR path, UINT count )
1785 {
1786     return copy_filename_WtoA( DIR_Windows, path, count );
1787 }
1788
1789
1790 /***********************************************************************
1791  *           GetSystemWindowsDirectoryA   (KERNEL32.@) W2K, TS4.0SP4
1792  */
1793 UINT WINAPI GetSystemWindowsDirectoryA( LPSTR path, UINT count )
1794 {
1795     return GetWindowsDirectoryA( path, count );
1796 }
1797
1798
1799 /***********************************************************************
1800  *           GetSystemWindowsDirectoryW   (KERNEL32.@) W2K, TS4.0SP4
1801  */
1802 UINT WINAPI GetSystemWindowsDirectoryW( LPWSTR path, UINT count )
1803 {
1804     return GetWindowsDirectoryW( path, count );
1805 }
1806
1807
1808 /***********************************************************************
1809  *           GetSystemDirectoryW   (KERNEL32.@)
1810  *
1811  * See comment for GetWindowsDirectoryA.
1812  */
1813 UINT WINAPI GetSystemDirectoryW( LPWSTR path, UINT count )
1814 {
1815     UINT len = strlenW( DIR_System ) + 1;
1816     if (path && count >= len)
1817     {
1818         strcpyW( path, DIR_System );
1819         len--;
1820     }
1821     return len;
1822 }
1823
1824
1825 /***********************************************************************
1826  *           GetSystemDirectoryA   (KERNEL32.@)
1827  *
1828  * See comment for GetWindowsDirectoryA.
1829  */
1830 UINT WINAPI GetSystemDirectoryA( LPSTR path, UINT count )
1831 {
1832     return copy_filename_WtoA( DIR_System, path, count );
1833 }
1834
1835
1836 /***********************************************************************
1837  *           GetSystemWow64DirectoryW   (KERNEL32.@)
1838  *
1839  * As seen on MSDN
1840  * - On Win32 we should return ERROR_CALL_NOT_IMPLEMENTED
1841  * - On Win64 we should return the SysWow64 (system64) directory
1842  */
1843 UINT WINAPI GetSystemWow64DirectoryW( LPWSTR path, UINT count )
1844 {
1845     UINT len;
1846
1847     if (!DIR_SysWow64)
1848     {
1849         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1850         return 0;
1851     }
1852     len = strlenW( DIR_SysWow64 ) + 1;
1853     if (path && count >= len)
1854     {
1855         strcpyW( path, DIR_SysWow64 );
1856         len--;
1857     }
1858     return len;
1859 }
1860
1861
1862 /***********************************************************************
1863  *           GetSystemWow64DirectoryA   (KERNEL32.@)
1864  *
1865  * See comment for GetWindowsWow64DirectoryW.
1866  */
1867 UINT WINAPI GetSystemWow64DirectoryA( LPSTR path, UINT count )
1868 {
1869     if (!DIR_SysWow64)
1870     {
1871         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1872         return 0;
1873     }
1874     return copy_filename_WtoA( DIR_SysWow64, path, count );
1875 }
1876
1877
1878 /***********************************************************************
1879  *           Wow64EnableWow64FsRedirection   (KERNEL32.@)
1880  */
1881 BOOLEAN WINAPI Wow64EnableWow64FsRedirection( BOOLEAN enable )
1882 {
1883     NTSTATUS status = RtlWow64EnableFsRedirection( enable );
1884     if (status) SetLastError( RtlNtStatusToDosError(status) );
1885     return !status;
1886 }
1887
1888
1889 /***********************************************************************
1890  *           Wow64DisableWow64FsRedirection   (KERNEL32.@)
1891  */
1892 BOOL WINAPI Wow64DisableWow64FsRedirection( PVOID *old_value )
1893 {
1894     NTSTATUS status = RtlWow64EnableFsRedirectionEx( TRUE, (ULONG *)old_value );
1895     if (status) SetLastError( RtlNtStatusToDosError(status) );
1896     return !status;
1897 }
1898
1899
1900 /***********************************************************************
1901  *           Wow64RevertWow64FsRedirection   (KERNEL32.@)
1902  */
1903 BOOL WINAPI Wow64RevertWow64FsRedirection( PVOID old_value )
1904 {
1905     NTSTATUS status = RtlWow64EnableFsRedirection( !old_value );
1906     if (status) SetLastError( RtlNtStatusToDosError(status) );
1907     return !status;
1908 }
1909
1910
1911 /***********************************************************************
1912  *           NeedCurrentDirectoryForExePathW   (KERNEL32.@)
1913  */
1914 BOOL WINAPI NeedCurrentDirectoryForExePathW( LPCWSTR name )
1915 {
1916     static const WCHAR env_name[] = {'N','o','D','e','f','a','u','l','t',
1917                                      'C','u','r','r','e','n','t',
1918                                      'D','i','r','e','c','t','o','r','y',
1919                                      'I','n','E','x','e','P','a','t','h',0};
1920     WCHAR env_val;
1921
1922     /* MSDN mentions some 'registry location'. We do not use registry. */
1923     FIXME("(%s): partial stub\n", debugstr_w(name));
1924
1925     if (strchrW(name, '\\'))
1926         return TRUE;
1927
1928     /* Check the existence of the variable, not value */
1929     if (!GetEnvironmentVariableW( env_name, &env_val, 1 ))
1930         return TRUE;
1931
1932     return FALSE;
1933 }
1934
1935
1936 /***********************************************************************
1937  *           NeedCurrentDirectoryForExePathA   (KERNEL32.@)
1938  */
1939 BOOL WINAPI NeedCurrentDirectoryForExePathA( LPCSTR name )
1940 {
1941     WCHAR *nameW;
1942
1943     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return TRUE;
1944     return NeedCurrentDirectoryForExePathW( nameW );
1945 }
1946
1947
1948 /***********************************************************************
1949  *           wine_get_unix_file_name (KERNEL32.@) Not a Windows API
1950  *
1951  * Return the full Unix file name for a given path.
1952  * Returned buffer must be freed by caller.
1953  */
1954 char * CDECL wine_get_unix_file_name( LPCWSTR dosW )
1955 {
1956     UNICODE_STRING nt_name;
1957     ANSI_STRING unix_name;
1958     NTSTATUS status;
1959
1960     if (!RtlDosPathNameToNtPathName_U( dosW, &nt_name, NULL, NULL )) return NULL;
1961     status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN_IF, FALSE );
1962     RtlFreeUnicodeString( &nt_name );
1963     if (status && status != STATUS_NO_SUCH_FILE)
1964     {
1965         SetLastError( RtlNtStatusToDosError( status ) );
1966         return NULL;
1967     }
1968     return unix_name.Buffer;
1969 }
1970
1971
1972 /***********************************************************************
1973  *           wine_get_dos_file_name (KERNEL32.@) Not a Windows API
1974  *
1975  * Return the full DOS file name for a given Unix path.
1976  * Returned buffer must be freed by caller.
1977  */
1978 WCHAR * CDECL wine_get_dos_file_name( LPCSTR str )
1979 {
1980     UNICODE_STRING nt_name;
1981     ANSI_STRING unix_name;
1982     NTSTATUS status;
1983     DWORD len;
1984
1985     RtlInitAnsiString( &unix_name, str );
1986     status = wine_unix_to_nt_file_name( &unix_name, &nt_name );
1987     if (status)
1988     {
1989         SetLastError( RtlNtStatusToDosError( status ) );
1990         return NULL;
1991     }
1992     if (nt_name.Buffer[5] == ':')
1993     {
1994         /* get rid of the \??\ prefix */
1995         /* FIXME: should implement RtlNtPathNameToDosPathName and use that instead */
1996         len = nt_name.Length - 4 * sizeof(WCHAR);
1997         memmove( nt_name.Buffer, nt_name.Buffer + 4, len );
1998         nt_name.Buffer[len / sizeof(WCHAR)] = 0;
1999     }
2000     else
2001         nt_name.Buffer[1] = '\\';
2002     return nt_name.Buffer;
2003 }
2004
2005 /*************************************************************************
2006  *           CreateSymbolicLinkW   (KERNEL32.@)
2007  */
2008 BOOLEAN WINAPI CreateSymbolicLinkW(LPCWSTR link, LPCWSTR target, DWORD flags)
2009 {
2010     FIXME("(%s %s %d): stub\n", debugstr_w(link), debugstr_w(target), flags);
2011     return TRUE;
2012 }
2013
2014 /*************************************************************************
2015  *           CreateSymbolicLinkA   (KERNEL32.@)
2016  */
2017 BOOLEAN WINAPI CreateSymbolicLinkA(LPCSTR link, LPCSTR target, DWORD flags)
2018 {
2019     FIXME("(%s %s %d): stub\n", debugstr_a(link), debugstr_a(target), flags);
2020     return TRUE;
2021 }
2022
2023 /*************************************************************************
2024  *           CreateHardLinkTransactedA   (KERNEL32.@)
2025  */
2026 BOOL WINAPI CreateHardLinkTransactedA(LPCSTR link, LPCSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
2027 {
2028     FIXME("(%s %s %p %p): stub\n", debugstr_a(link), debugstr_a(target), sa, transaction);
2029     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2030     return FALSE;
2031 }
2032
2033 /*************************************************************************
2034  *           CreateHardLinkTransactedW   (KERNEL32.@)
2035  */
2036 BOOL WINAPI CreateHardLinkTransactedW(LPCWSTR link, LPCWSTR target, LPSECURITY_ATTRIBUTES sa, HANDLE transaction)
2037 {
2038     FIXME("(%s %s %p %p): stub\n", debugstr_w(link), debugstr_w(target), sa, transaction);
2039     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2040     return FALSE;
2041 }
2042
2043 /*************************************************************************
2044  *           CheckNameLegalDOS8Dot3A   (KERNEL32.@)
2045  */
2046 BOOL WINAPI CheckNameLegalDOS8Dot3A(const char *name, char *oemname, DWORD oemname_len,
2047         BOOL *contains_spaces, BOOL *is_legal)
2048 {
2049     WCHAR *nameW;
2050
2051     TRACE("(%s %p %u %p %p)\n", name, oemname,
2052             oemname_len, contains_spaces, is_legal);
2053
2054     if (!name || !is_legal)
2055         return FALSE;
2056
2057     if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
2058
2059     return CheckNameLegalDOS8Dot3W( nameW, oemname, oemname_len, contains_spaces, is_legal );
2060 }
2061
2062 /*************************************************************************
2063  *           CheckNameLegalDOS8Dot3W   (KERNEL32.@)
2064  */
2065 BOOL WINAPI CheckNameLegalDOS8Dot3W(const WCHAR *name, char *oemname, DWORD oemname_len,
2066         BOOL *contains_spaces_ret, BOOL *is_legal)
2067 {
2068     OEM_STRING oem_str;
2069     UNICODE_STRING nameW;
2070     BOOLEAN contains_spaces;
2071
2072     TRACE("(%s %p %u %p %p)\n", wine_dbgstr_w(name), oemname,
2073           oemname_len, contains_spaces_ret, is_legal);
2074
2075     if (!name || !is_legal)
2076         return FALSE;
2077
2078     RtlInitUnicodeString( &nameW, name );
2079
2080     if (oemname) {
2081         oem_str.Length = oemname_len;
2082         oem_str.MaximumLength = oemname_len;
2083         oem_str.Buffer = oemname;
2084     }
2085
2086     *is_legal = RtlIsNameLegalDOS8Dot3( &nameW, oemname ? &oem_str : NULL, &contains_spaces );
2087     if (contains_spaces_ret) *contains_spaces_ret = contains_spaces;
2088
2089     return TRUE;
2090 }
2091
2092 BOOL WINAPI SetSearchPathMode(DWORD flags)
2093 {
2094     FIXME("(%x): stub\n", flags);
2095     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2096     return FALSE;
2097 }