git.oblomov.eu Git - wine/blob - files/directory.c

   1 /*
   2  * DOS directories functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <unistd.h>
  12 #include <errno.h>
  13
  14 #include "windows.h"
  15 #include "winerror.h"
  16 #include "drive.h"
  17 #include "file.h"
  18 #include "heap.h"
  19 #include "msdos.h"
  20 #include "options.h"
  21 #include "debug.h"
  22
  23 #define MAX_PATH_ELEMENTS 20
  24
  25 static char *DIR_WindowsDosDir;
  26 static char *DIR_WindowsUnixDir;
  27 static char *DIR_SystemDosDir;
  28 static char *DIR_SystemUnixDir;
  29 static char *DIR_TempDosDir;
  30 static char *DIR_TempUnixDir;
  31
  32 static char *DIR_DosPath[MAX_PATH_ELEMENTS];  /* Path in DOS format */
  33 static char *DIR_UnixPath[MAX_PATH_ELEMENTS]; /* Path in Unix format */
  34 static int DIR_PathElements = 0;
  35
  36 /***********************************************************************
  37  *           DIR_GetPath
  38  *
  39  * Get a path name from the wine.ini file and make sure it is valid.
  40  */
  41 static int DIR_GetPath( const char *keyname, const char *defval,
  42                         char **dos_path, char **unix_path )
  43 {
  44     char path[MAX_PATHNAME_LEN];
  45     DOS_FULL_NAME full_name;
  46
  47     BY_HANDLE_FILE_INFORMATION info;
  48
  49     PROFILE_GetWineIniString( "wine", keyname, defval, path, sizeof(path) );
  50     if (!DOSFS_GetFullName( path, TRUE, &full_name ) ||
  51         !FILE_Stat( full_name.long_name, &info ) ||
  52         !(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
  53     {
  54         fprintf(stderr, "Invalid path '%s' for %s directory\n", path, keyname);
  55         return 0;
  56     }
  57     *unix_path = HEAP_strdupA( SystemHeap, 0, full_name.long_name );
  58     *dos_path  = HEAP_strdupA( SystemHeap, 0, full_name.short_name );
  59     return 1;
  60 }
  61
  62
  63 /***********************************************************************
  64  *           DIR_ParseWindowsPath
  65  */
  66 void DIR_ParseWindowsPath( char *path )
  67 {
  68     char *p;
  69     DOS_FULL_NAME full_name;
  70     BY_HANDLE_FILE_INFORMATION info;
  71     int i;
  72
  73     for ( ; path && *path; path = p)
  74     {
  75         p = strchr( path, ';' );
  76         if (p) while (*p == ';') *p++ = '\0';
  77
  78         if (DIR_PathElements >= MAX_PATH_ELEMENTS)
  79         {
  80             fprintf( stderr, "Warning: path has more than %d elements.\n",
  81                      MAX_PATH_ELEMENTS );
  82             break;
  83         }
  84         if (!DOSFS_GetFullName( path, TRUE, &full_name ) ||
  85             !FILE_Stat( full_name.long_name, &info ) ||
  86             !(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
  87         {
  88             fprintf(stderr,"Warning: invalid dir '%s' in path, deleting it.\n",
  89                     path );
  90             continue;
  91         }
  92         DIR_UnixPath[DIR_PathElements] = HEAP_strdupA( SystemHeap, 0,
  93                                                        full_name.long_name );
  94         DIR_DosPath[DIR_PathElements]  = HEAP_strdupA( SystemHeap, 0,
  95                                                        full_name.short_name );
  96         DIR_PathElements++;
  97     }
  98
  99     if (TRACE_ON(dosfs))
 100         for (i = 0; i < DIR_PathElements; i++)
 101         {
 102             TRACE(dosfs, "Path[%d]: %s = %s\n",
 103                            i, DIR_DosPath[i], DIR_UnixPath[i] );
 104         }
 105 }
 106
 107
 108 /***********************************************************************
 109  *           DIR_Init
 110  */
 111 int DIR_Init(void)
 112 {
 113     char path[MAX_PATHNAME_LEN], *env_p;
 114     int drive;
 115     const char *cwd;
 116
 117     if (!getcwd( path, MAX_PATHNAME_LEN ))
 118     {
 119         perror( "Could not get current directory" );
 120         return 0;
 121     }
 122     cwd = path;
 123     if ((drive = DRIVE_FindDriveRoot( &cwd )) == -1)
 124     {
 125         fprintf( stderr, "Warning: could not find DOS drive for cwd %s; starting in windows directory.\n",
 126                  cwd );
 127     }
 128     else
 129     {
 130         DRIVE_SetCurrentDrive( drive );
 131         DRIVE_Chdir( drive, cwd );
 132     }
 133
 134     if (!(DIR_GetPath( "windows", "c:\\windows",
 135                        &DIR_WindowsDosDir, &DIR_WindowsUnixDir ))) return 0;
 136     if (!(DIR_GetPath( "system", "c:\\windows\\system",
 137                        &DIR_SystemDosDir, &DIR_SystemUnixDir ))) return 0;
 138     if (!(DIR_GetPath( "temp", "c:\\windows",
 139                        &DIR_TempDosDir, &DIR_TempUnixDir ))) return 0;
 140     if (-1==access(DIR_TempUnixDir,W_OK)) {
 141         if (errno==EACCES)
 142                 fprintf(stderr,"Warning: The Temporary Directory (as specified in wine.conf) is NOT writeable. Please check your configuration.\n");
 143         else
 144                 fprintf(stderr,"Warning: Access to Temporary Directory failed (%s).\n",strerror(errno));
 145     }
 146
 147     if (drive == -1)
 148     {
 149         drive = DIR_WindowsDosDir[0] - 'A';
 150         DRIVE_SetCurrentDrive( drive );
 151         DRIVE_Chdir( drive, DIR_WindowsDosDir + 2 );
 152     }
 153
 154     PROFILE_GetWineIniString("wine", "path", "c:\\windows;c:\\windows\\system",
 155                              path, sizeof(path) );
 156     DIR_ParseWindowsPath( path );
 157
 158     TRACE(dosfs, "WindowsDir = %s\n", DIR_WindowsDosDir);
 159     TRACE(dosfs, "SystemDir  = %s\n", DIR_SystemDosDir);
 160     TRACE(dosfs, "TempDir    = %s\n", DIR_TempDosDir);
 161     TRACE(dosfs, "Cwd        = %c:\\%s\n",
 162                  'A' + drive, DRIVE_GetDosCwd( drive ) );
 163
 164     /* Put the temp and Windows and system directories into the environment */
 165
 166     env_p = HEAP_xalloc( SystemHeap, 0, strlen(DIR_TempDosDir) + 6 );
 167     strcpy( env_p, "TEMP=" );
 168     strcpy( env_p + 5, DIR_TempDosDir );
 169     putenv( env_p );
 170     env_p = HEAP_xalloc( SystemHeap, 0, strlen(DIR_WindowsDosDir) + 8 );
 171     strcpy( env_p, "windir=" );
 172     strcpy( env_p + 7, DIR_WindowsDosDir );
 173     putenv( env_p );
 174     env_p = HEAP_xalloc( SystemHeap, 0, strlen(DIR_SystemDosDir) + 11 );
 175     strcpy( env_p, "winsysdir=" );
 176     strcpy( env_p + 10, DIR_SystemDosDir );
 177     putenv( env_p );
 178
 179     return 1;
 180 }
 181
 182
 183 /***********************************************************************
 184  *           GetTempPath32A   (KERNEL32.292)
 185  */
 186 UINT32 WINAPI GetTempPath32A( UINT32 count, LPSTR path )
 187 {
 188     if (path) lstrcpyn32A( path, DIR_TempDosDir, count );
 189     return strlen( DIR_TempDosDir );
 190 }
 191
 192
 193 /***********************************************************************
 194  *           GetTempPath32W   (KERNEL32.293)
 195  */
 196 UINT32 WINAPI GetTempPath32W( UINT32 count, LPWSTR path )
 197 {
 198     if (path) lstrcpynAtoW( path, DIR_TempDosDir, count );
 199     return strlen( DIR_TempDosDir );
 200 }
 201
 202
 203 /***********************************************************************
 204  *           DIR_GetTempUnixDir
 205  */
 206 UINT32 DIR_GetTempUnixDir( LPSTR path, UINT32 count )
 207 {
 208     if (path) lstrcpyn32A( path, DIR_TempUnixDir, count );
 209     return strlen( DIR_TempUnixDir );
 210 }
 211
 212
 213 /***********************************************************************
 214  *           DIR_GetWindowsUnixDir
 215  */
 216 UINT32 DIR_GetWindowsUnixDir( LPSTR path, UINT32 count )
 217 {
 218     if (path) lstrcpyn32A( path, DIR_WindowsUnixDir, count );
 219     return strlen( DIR_WindowsUnixDir );
 220 }
 221
 222
 223 /***********************************************************************
 224  *           DIR_GetSystemUnixDir
 225  */
 226 UINT32 DIR_GetSystemUnixDir( LPSTR path, UINT32 count )
 227 {
 228     if (path) lstrcpyn32A( path, DIR_SystemUnixDir, count );
 229     return strlen( DIR_SystemUnixDir );
 230 }
 231
 232
 233 /***********************************************************************
 234  *           DIR_GetDosPath
 235  */
 236 UINT32 DIR_GetDosPath( INT32 element, LPSTR path, UINT32 count )
 237 {
 238     if ((element < 0) || (element >= DIR_PathElements)) return 0;
 239     if (path) lstrcpyn32A( path, DIR_DosPath[element], count );
 240     return strlen( DIR_DosPath[element] );
 241 }
 242
 243
 244 /***********************************************************************
 245  *           GetTempDrive   (KERNEL.92)
 246  */
 247 BYTE WINAPI GetTempDrive( BYTE ignored )
 248 {
 249     /* FIXME: apparently Windows does something with the ignored byte */
 250     return DIR_TempDosDir[0];
 251 }
 252
 253
 254 UINT32 WINAPI WIN16_GetTempDrive( BYTE ignored )
 255 {
 256     /* A closer look at krnl386.exe shows what the SDK doesn't mention:
 257      *
 258      * returns:
 259      *   AL: driveletter
 260      *   AH: ':'                - yes, some kernel code even does stosw with
 261      *                            the returned AX.
 262      *   DX: 1 for success
 263      */
 264     return MAKELONG( GetTempDrive(ignored) | (':' << 8), 1 );
 265 }
 266
 267
 268 /***********************************************************************
 269  *           GetWindowsDirectory16   (KERNEL.134)
 270  */
 271 UINT16 WINAPI GetWindowsDirectory16( LPSTR path, UINT16 count )
 272 {
 273     return (UINT16)GetWindowsDirectory32A( path, count );
 274 }
 275
 276
 277 /***********************************************************************
 278  *           GetWindowsDirectory32A   (KERNEL32.311)
 279  */
 280 UINT32 WINAPI GetWindowsDirectory32A( LPSTR path, UINT32 count )
 281 {
 282     if (path) lstrcpyn32A( path, DIR_WindowsDosDir, count );
 283     return strlen( DIR_WindowsDosDir );
 284 }
 285
 286
 287 /***********************************************************************
 288  *           GetWindowsDirectory32W   (KERNEL32.312)
 289  */
 290 UINT32 WINAPI GetWindowsDirectory32W( LPWSTR path, UINT32 count )
 291 {
 292     if (path) lstrcpynAtoW( path, DIR_WindowsDosDir, count );
 293     return strlen( DIR_WindowsDosDir );
 294 }
 295
 296
 297 /***********************************************************************
 298  *           GetSystemDirectory16   (KERNEL.135)
 299  */
 300 UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
 301 {
 302     return (UINT16)GetSystemDirectory32A( path, count );
 303 }
 304
 305
 306 /***********************************************************************
 307  *           GetSystemDirectory32A   (KERNEL32.282)
 308  */
 309 UINT32 WINAPI GetSystemDirectory32A( LPSTR path, UINT32 count )
 310 {
 311     if (path) lstrcpyn32A( path, DIR_SystemDosDir, count );
 312     return strlen( DIR_SystemDosDir );
 313 }
 314
 315
 316 /***********************************************************************
 317  *           GetSystemDirectory32W   (KERNEL32.283)
 318  */
 319 UINT32 WINAPI GetSystemDirectory32W( LPWSTR path, UINT32 count )
 320 {
 321     if (path) lstrcpynAtoW( path, DIR_SystemDosDir, count );
 322     return strlen( DIR_SystemDosDir );
 323 }
 324
 325
 326 /***********************************************************************
 327  *           CreateDirectory16   (KERNEL.144)
 328  */
 329 BOOL16 WINAPI CreateDirectory16( LPCSTR path, LPVOID dummy )
 330 {
 331     TRACE(file,"(%s,%p)\n", path, dummy );
 332     return (BOOL16)CreateDirectory32A( path, NULL );
 333 }
 334
 335
 336 /***********************************************************************
 337  *           CreateDirectory32A   (KERNEL32.39)
 338  */
 339 BOOL32 WINAPI CreateDirectory32A( LPCSTR path,
 340                                   LPSECURITY_ATTRIBUTES lpsecattribs )
 341 {
 342     DOS_FULL_NAME full_name;
 343
 344     TRACE(file, "(%s,%p)\n", path, lpsecattribs );
 345     if (DOSFS_IsDevice( path ))
 346     {
 347         TRACE(file, "cannot use device '%s'!\n",path);
 348         DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk );
 349         return FALSE;
 350     }
 351     if (!DOSFS_GetFullName( path, FALSE, &full_name )) return 0;
 352     if ((mkdir( full_name.long_name, 0777 ) == -1) && (errno != EEXIST))
 353     {
 354         FILE_SetDosError();
 355         return FALSE;
 356     }
 357     return TRUE;
 358 }
 359
 360
 361 /***********************************************************************
 362  *           CreateDirectory32W   (KERNEL32.42)
 363  */
 364 BOOL32 WINAPI CreateDirectory32W( LPCWSTR path,
 365                                   LPSECURITY_ATTRIBUTES lpsecattribs )
 366 {
 367     LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
 368     BOOL32 ret = CreateDirectory32A( xpath, lpsecattribs );
 369     HeapFree( GetProcessHeap(), 0, xpath );
 370     return ret;
 371 }
 372
 373
 374 /***********************************************************************
 375  *           CreateDirectoryEx32A   (KERNEL32.40)
 376  */
 377 BOOL32 WINAPI CreateDirectoryEx32A( LPCSTR template, LPCSTR path,
 378                                     LPSECURITY_ATTRIBUTES lpsecattribs)
 379 {
 380     return CreateDirectory32A(path,lpsecattribs);
 381 }
 382
 383
 384 /***********************************************************************
 385  *           CreateDirectoryEx32W   (KERNEL32.41)
 386  */
 387 BOOL32 WINAPI CreateDirectoryEx32W( LPCWSTR template, LPCWSTR path,
 388                                     LPSECURITY_ATTRIBUTES lpsecattribs)
 389 {
 390     return CreateDirectory32W(path,lpsecattribs);
 391 }
 392
 393
 394 /***********************************************************************
 395  *           RemoveDirectory16   (KERNEL)
 396  */
 397 BOOL16 WINAPI RemoveDirectory16( LPCSTR path )
 398 {
 399     return (BOOL16)RemoveDirectory32A( path );
 400 }
 401
 402
 403 /***********************************************************************
 404  *           RemoveDirectory32A   (KERNEL32.437)
 405  */
 406 BOOL32 WINAPI RemoveDirectory32A( LPCSTR path )
 407 {
 408     DOS_FULL_NAME full_name;
 409
 410     TRACE(file, "'%s'\n", path );
 411
 412     if (DOSFS_IsDevice( path ))
 413     {
 414         TRACE(file, "cannot remove device '%s'!\n", path);
 415         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 416         return FALSE;
 417     }
 418     if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
 419     if (rmdir( full_name.long_name ) == -1)
 420     {
 421         FILE_SetDosError();
 422         return FALSE;
 423     }
 424     return TRUE;
 425 }
 426
 427
 428 /***********************************************************************
 429  *           RemoveDirectory32W   (KERNEL32.438)
 430  */
 431 BOOL32 WINAPI RemoveDirectory32W( LPCWSTR path )
 432 {
 433     LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
 434     BOOL32 ret = RemoveDirectory32A( xpath );
 435     HeapFree( GetProcessHeap(), 0, xpath );
 436     return ret;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           DIR_TryPath
 442  *
 443  * Helper function for DIR_SearchPath.
 444  */
 445 static BOOL32 DIR_TryPath( LPCSTR unix_dir, LPCSTR dos_dir, LPCSTR name,
 446                            DOS_FULL_NAME *full_name )
 447 {
 448     LPSTR p_l = full_name->long_name + strlen(unix_dir) + 1;
 449     LPSTR p_s = full_name->short_name + strlen(dos_dir) + 1;
 450
 451     if ((p_s >= full_name->short_name + sizeof(full_name->short_name) - 14) ||
 452         (p_l >= full_name->long_name + sizeof(full_name->long_name) - 1))
 453     {
 454         DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk );
 455         return FALSE;
 456     }
 457     if (!DOSFS_FindUnixName( unix_dir, name, p_l,
 458                    sizeof(full_name->long_name) - (p_l - full_name->long_name),
 459                    p_s, DRIVE_GetFlags( dos_dir[0] - 'A' ) ))
 460         return FALSE;
 461     strcpy( full_name->long_name, unix_dir );
 462     p_l[-1] = '/';
 463     strcpy( full_name->short_name, dos_dir );
 464     p_s[-1] = '\\';
 465     return TRUE;
 466 }
 467
 468
 469 /***********************************************************************
 470  *           DIR_TryModulePath
 471  *
 472  * Helper function for DIR_SearchPath.
 473  */
 474 static BOOL32 DIR_TryModulePath( LPCSTR name, DOS_FULL_NAME *full_name )
 475 {
 476     /* FIXME: for now, GetModuleFileName32A can't return more */
 477     /* than OFS_MAXPATHNAME. This may change with Win32. */
 478     char buffer[OFS_MAXPATHNAME];
 479     LPSTR p;
 480
 481     if (!GetCurrentTask()) return FALSE;
 482     GetModuleFileName32A( GetCurrentTask(), buffer, sizeof(buffer) );
 483     if (!(p = strrchr( buffer, '\\' ))) return FALSE;
 484     if (sizeof(buffer) - (++p - buffer) <= strlen(name)) return FALSE;
 485     strcpy( p, name );
 486     return DOSFS_GetFullName( buffer, TRUE, full_name );
 487 }
 488
 489
 490 /***********************************************************************
 491  *           DIR_SearchPath
 492  *
 493  * Implementation of SearchPath32A. 'win32' specifies whether the search
 494  * order is Win16 (module path last) or Win32 (module path first).
 495  *
 496  * FIXME: should return long path names.
 497  */
 498 DWORD DIR_SearchPath( LPCSTR path, LPCSTR name, LPCSTR ext,
 499                       DOS_FULL_NAME *full_name, BOOL32 win32 )
 500 {
 501     DWORD len;
 502     LPCSTR p;
 503     int i;
 504     LPSTR tmp = NULL;
 505     BOOL32 ret = TRUE;
 506
 507     /* First check the supplied parameters */
 508
 509     p = strrchr( name, '.' );
 510     if (p && !strchr( p, '/' ) && !strchr( p, '\\' ))
 511         ext = NULL;  /* Ignore the specified extension */
 512     if ((*name && (name[1] == ':')) ||
 513         strchr( name, '/' ) || strchr( name, '\\' ))
 514         path = NULL;  /* Ignore path if name already contains a path */
 515     if (path && !*path) path = NULL;  /* Ignore empty path */
 516
 517     len = strlen(name);
 518     if (ext) len += strlen(ext);
 519     if (path) len += strlen(path) + 1;
 520
 521     /* Allocate a buffer for the file name and extension */
 522
 523     if (path || ext)
 524     {
 525         if (!(tmp = HeapAlloc( GetProcessHeap(), 0, len + 1 )))
 526         {
 527             SetLastError( ERROR_OUTOFMEMORY );
 528             return 0;
 529         }
 530         if (path)
 531         {
 532             strcpy( tmp, path );
 533             strcat( tmp, "\\" );
 534             strcat( tmp, name );
 535         }
 536         else strcpy( tmp, name );
 537         if (ext) strcat( tmp, ext );
 538         name = tmp;
 539     }
 540
 541     /* If we have an explicit path, everything's easy */
 542
 543     if (path || (*name && (name[1] == ':')) ||
 544         strchr( name, '/' ) || strchr( name, '\\' ))
 545     {
 546         ret = DOSFS_GetFullName( name, TRUE, full_name );
 547         goto done;
 548     }
 549
 550     /* Try the path of the current executable (for Win32 search order) */
 551
 552     if (win32 && DIR_TryModulePath( name, full_name )) goto done;
 553
 554     /* Try the current directory */
 555
 556     if (DOSFS_GetFullName( name, TRUE, full_name )) goto done;
 557
 558     /* Try the Windows directory */
 559
 560     if (DIR_TryPath( DIR_WindowsUnixDir, DIR_WindowsDosDir, name, full_name ))
 561         goto done;
 562
 563     /* Try the Windows system directory */
 564
 565     if (DIR_TryPath( DIR_SystemUnixDir, DIR_SystemDosDir, name, full_name ))
 566         goto done;
 567
 568     /* Try the path of the current executable (for Win16 search order) */
 569
 570     if (!win32 && DIR_TryModulePath( name, full_name )) goto done;
 571
 572     /* Try all directories in path */
 573
 574     for (i = 0; i < DIR_PathElements; i++)
 575     {
 576         if (DIR_TryPath( DIR_UnixPath[i], DIR_DosPath[i], name, full_name ))
 577             goto done;
 578     }
 579
 580     ret = FALSE;
 581 done:
 582     if (tmp) HeapFree( GetProcessHeap(), 0, tmp );
 583     return ret;
 584 }
 585
 586
 587 /***********************************************************************
 588  *           SearchPath32A   (KERNEL32.447)
 589  */
 590 DWORD WINAPI SearchPath32A( LPCSTR path, LPCSTR name, LPCSTR ext, DWORD buflen,
 591                             LPSTR buffer, LPSTR *lastpart )
 592 {
 593     LPSTR p, res;
 594     DOS_FULL_NAME full_name;
 595
 596     if (!DIR_SearchPath( path, name, ext, &full_name, TRUE )) return 0;
 597     lstrcpyn32A( buffer, full_name.short_name, buflen );
 598     res = full_name.long_name +
 599               strlen(DRIVE_GetRoot( full_name.short_name[0] - 'A' ));
 600     while (*res == '/') res++;
 601     if (buflen)
 602     {
 603         if (buflen > 3) lstrcpyn32A( buffer + 3, res, buflen - 3 );
 604         for (p = buffer; *p; p++) if (*p == '/') *p = '\\';
 605         if (lastpart) *lastpart = strrchr( buffer, '\\' ) + 1;
 606     }
 607     return *res ? strlen(res) + 2 : 3;
 608 }
 609
 610
 611 /***********************************************************************
 612  *           SearchPath32W   (KERNEL32.448)
 613  */
 614 DWORD WINAPI SearchPath32W( LPCWSTR path, LPCWSTR name, LPCWSTR ext,
 615                             DWORD buflen, LPWSTR buffer, LPWSTR *lastpart )
 616 {
 617     LPWSTR p;
 618     LPSTR res;
 619     DOS_FULL_NAME full_name;
 620
 621     LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
 622     LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 623     LPSTR extA  = HEAP_strdupWtoA( GetProcessHeap(), 0, ext );
 624     DWORD ret = DIR_SearchPath( pathA, nameA, extA, &full_name, TRUE );
 625     HeapFree( GetProcessHeap(), 0, extA );
 626     HeapFree( GetProcessHeap(), 0, nameA );
 627     HeapFree( GetProcessHeap(), 0, pathA );
 628     if (!ret) return 0;
 629
 630     lstrcpynAtoW( buffer, full_name.short_name, buflen );
 631     res = full_name.long_name +
 632               strlen(DRIVE_GetRoot( full_name.short_name[0] - 'A' ));
 633     while (*res == '/') res++;
 634     if (buflen)
 635     {
 636         if (buflen > 3) lstrcpynAtoW( buffer + 3, res, buflen - 3 );
 637         for (p = buffer; *p; p++) if (*p == '/') *p = '\\';
 638         if (lastpart)
 639         {
 640             for (p = *lastpart = buffer; *p; p++)
 641                 if (*p == '\\') *lastpart = p + 1;
 642         }
 643     }
 644     return *res ? strlen(res) + 2 : 3;
 645 }
 646
 647