files/drive.c

   1 /*
   2  * DOS drives handling functions
   3  *
   4  * Copyright 1993 Erik Bos
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * Label & serial number read support.
   8  *  (c) 1999 Petr Tomasek <tomasek@etf.cuni.cz>
   9  *  (c) 2000 Andreas Mohr (changes)
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <assert.h>
  30 #include <ctype.h>
  31 #include <string.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include <errno.h>
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42
  43 #define NONAMELESSUNION
  44 #define NONAMELESSSTRUCT
  45 #include "ntstatus.h"
  46 #include "windef.h"
  47 #include "winbase.h"
  48 #include "winreg.h"
  49 #include "winternl.h"
  50 #include "wine/winbase16.h"   /* for GetCurrentTask */
  51 #include "winerror.h"
  52 #include "winioctl.h"
  53 #include "ntddstor.h"
  54 #include "ntddcdrm.h"
  55 #include "file.h"
  56 #include "wine/unicode.h"
  57 #include "wine/library.h"
  58 #include "wine/server.h"
  59 #include "wine/debug.h"
  60
  61 WINE_DEFAULT_DEBUG_CHANNEL(dosfs);
  62 WINE_DECLARE_DEBUG_CHANNEL(file);
  63
  64 typedef struct
  65 {
  66     char     *root;      /* root dir in Unix format without trailing / */
  67     LPWSTR    dos_cwd;   /* cwd in DOS format without leading or trailing \ */
  68     char     *unix_cwd;  /* cwd in Unix format without leading or trailing / */
  69     char     *device;    /* raw device path */
  70     dev_t     dev;       /* unix device number */
  71     ino_t     ino;       /* unix inode number */
  72 } DOSDRIVE;
  73
  74
  75 #define MAX_DOS_DRIVES  26
  76
  77 static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
  78 static int DRIVE_CurDrive = -1;
  79
  80 static HTASK16 DRIVE_LastTask = 0;
  81
  82 /* strdup on the process heap */
  83 inline static char *heap_strdup( const char *str )
  84 {
  85     INT len = strlen(str) + 1;
  86     LPSTR p = HeapAlloc( GetProcessHeap(), 0, len );
  87     if (p) memcpy( p, str, len );
  88     return p;
  89 }
  90
  91 /***********************************************************************
  92  *           DRIVE_Init
  93  */
  94 int DRIVE_Init(void)
  95 {
  96     int i, len, symlink_count = 0, count = 0;
  97     WCHAR driveW[] = {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
  98                       'W','i','n','e','\\','W','i','n','e','\\',
  99                       'C','o','n','f','i','g','\\','D','r','i','v','e',' ','A',0};
 100     WCHAR drive_env[] = {'=','A',':',0};
 101     WCHAR path[MAX_PATHNAME_LEN];
 102     char tmp[MAX_PATHNAME_LEN*sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
 103     struct stat drive_stat_buffer;
 104     WCHAR *p;
 105     DOSDRIVE *drive;
 106     HKEY hkey;
 107     DWORD dummy;
 108     OBJECT_ATTRIBUTES attr;
 109     UNICODE_STRING nameW;
 110     char *root;
 111     const char *config_dir = wine_get_config_dir();
 112
 113     static const WCHAR PathW[] = {'P','a','t','h',0};
 114     static const WCHAR DeviceW[] = {'D','e','v','i','c','e',0};
 115
 116     attr.Length = sizeof(attr);
 117     attr.RootDirectory = 0;
 118     attr.ObjectName = &nameW;
 119     attr.Attributes = 0;
 120     attr.SecurityDescriptor = NULL;
 121     attr.SecurityQualityOfService = NULL;
 122
 123     /* get the root of the drives from symlinks */
 124
 125     root = NULL;
 126     for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
 127     {
 128         if (!root)
 129         {
 130             root = HeapAlloc( GetProcessHeap(), 0, strlen(config_dir) + sizeof("/dosdevices/a:") );
 131             strcpy( root, config_dir );
 132             strcat( root, "/dosdevices/a:" );
 133         }
 134         root[strlen(root)-2] = 'a' + i;
 135         if (stat( root, &drive_stat_buffer ))
 136         {
 137             if (!lstat( root, &drive_stat_buffer))
 138                 MESSAGE("Could not stat %s (%s), ignoring drive %c:\n",
 139                         root, strerror(errno), 'a' + i);
 140             continue;
 141         }
 142         if (!S_ISDIR(drive_stat_buffer.st_mode))
 143         {
 144             MESSAGE("%s is not a directory, ignoring drive %c:\n", root, 'a' + i );
 145             continue;
 146         }
 147         drive->root     = root;
 148         drive->dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(drive->dos_cwd[0]));
 149         drive->unix_cwd = heap_strdup( "" );
 150         drive->device   = NULL;
 151         drive->dev      = drive_stat_buffer.st_dev;
 152         drive->ino      = drive_stat_buffer.st_ino;
 153         root = NULL;
 154         symlink_count++;
 155     }
 156     if (root) HeapFree( GetProcessHeap(), 0, root );
 157
 158     /* now get the parameters from the config file */
 159
 160     for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
 161     {
 162         RtlInitUnicodeString( &nameW, driveW );
 163         nameW.Buffer[(nameW.Length / sizeof(WCHAR)) - 1] = 'A' + i;
 164         if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) != STATUS_SUCCESS) continue;
 165
 166         /* Get the root path */
 167         if (!symlink_count)
 168         {
 169             RtlInitUnicodeString( &nameW, PathW );
 170             if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
 171             {
 172                 WCHAR *data = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
 173                 ExpandEnvironmentStringsW( data, path, sizeof(path)/sizeof(WCHAR) );
 174
 175                 p = path + strlenW(path) - 1;
 176                 while ((p > path) && (*p == '/')) *p-- = '\0';
 177
 178                 if (path[0] == '/')
 179                 {
 180                     len = WideCharToMultiByte(CP_UNIXCP, 0, path, -1, NULL, 0, NULL, NULL);
 181                     drive->root = HeapAlloc(GetProcessHeap(), 0, len);
 182                     WideCharToMultiByte(CP_UNIXCP, 0, path, -1, drive->root, len, NULL, NULL);
 183                 }
 184                 else
 185                 {
 186                     /* relative paths are relative to config dir */
 187                     const char *config = wine_get_config_dir();
 188                     len = strlen(config);
 189                     len += WideCharToMultiByte(CP_UNIXCP, 0, path, -1, NULL, 0, NULL, NULL) + 2;
 190                     drive->root = HeapAlloc( GetProcessHeap(), 0, len );
 191                     len -= sprintf( drive->root, "%s/", config );
 192                     WideCharToMultiByte(CP_UNIXCP, 0, path, -1,
 193                                         drive->root + strlen(drive->root), len, NULL, NULL);
 194                 }
 195
 196                 if (stat( drive->root, &drive_stat_buffer ))
 197                 {
 198                     MESSAGE("Could not stat %s (%s), ignoring drive %c:\n",
 199                             drive->root, strerror(errno), 'A' + i);
 200                     HeapFree( GetProcessHeap(), 0, drive->root );
 201                     drive->root = NULL;
 202                     goto next;
 203                 }
 204                 if (!S_ISDIR(drive_stat_buffer.st_mode))
 205                 {
 206                     MESSAGE("%s is not a directory, ignoring drive %c:\n",
 207                             drive->root, 'A' + i );
 208                     HeapFree( GetProcessHeap(), 0, drive->root );
 209                     drive->root = NULL;
 210                     goto next;
 211                 }
 212
 213                 drive->dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(drive->dos_cwd[0]));
 214                 drive->unix_cwd = heap_strdup( "" );
 215                 drive->device   = NULL;
 216                 drive->dev      = drive_stat_buffer.st_dev;
 217                 drive->ino      = drive_stat_buffer.st_ino;
 218             }
 219         }
 220
 221         if (drive->root)
 222         {
 223             /* Get the device */
 224             RtlInitUnicodeString( &nameW, DeviceW );
 225             if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
 226             {
 227                 WCHAR *data = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
 228                 len = WideCharToMultiByte(CP_UNIXCP, 0, data, -1, NULL, 0, NULL, NULL);
 229                 drive->device = HeapAlloc(GetProcessHeap(), 0, len);
 230                 WideCharToMultiByte(CP_UNIXCP, 0, data, -1, drive->device, len, NULL, NULL);
 231             }
 232
 233             count++;
 234             TRACE("Drive %c: path=%s dev=%x ino=%x\n",
 235                   'A' + i, drive->root, (int)drive->dev, (int)drive->ino );
 236         }
 237
 238     next:
 239         NtClose( hkey );
 240     }
 241
 242     if (!count && !symlink_count)
 243     {
 244         MESSAGE("Warning: no valid DOS drive found, check your configuration file.\n" );
 245         /* Create a C drive pointing to Unix root dir */
 246         DOSDrives[2].root     = heap_strdup( "/" );
 247         DOSDrives[2].dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSDrives[2].dos_cwd[0]));
 248         DOSDrives[2].unix_cwd = heap_strdup( "" );
 249         DOSDrives[2].device   = NULL;
 250         DRIVE_CurDrive = 2;
 251     }
 252
 253     /* Make sure the current drive is valid */
 254     if (DRIVE_CurDrive == -1)
 255     {
 256         for (i = 2, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
 257         {
 258             if (drive->root)
 259             {
 260                 DRIVE_CurDrive = i;
 261                 break;
 262             }
 263         }
 264     }
 265
 266     /* get current working directory info for all drives */
 267     for (i = 0; i < MAX_DOS_DRIVES; i++, drive_env[1]++)
 268     {
 269         if (!GetEnvironmentVariableW(drive_env, path, MAX_PATHNAME_LEN)) continue;
 270         /* sanity check */
 271         if (toupperW(path[0]) != drive_env[1] || path[1] != ':') continue;
 272         DRIVE_Chdir( i, path + 2 );
 273     }
 274     return 1;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           DRIVE_IsValid
 280  */
 281 int DRIVE_IsValid( int drive )
 282 {
 283     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
 284     return (DOSDrives[drive].root != NULL);
 285 }
 286
 287
 288 /***********************************************************************
 289  *           DRIVE_GetCurrentDrive
 290  */
 291 int DRIVE_GetCurrentDrive(void)
 292 {
 293     TDB *pTask = GlobalLock16(GetCurrentTask());
 294     if (pTask && (pTask->curdrive & 0x80)) return pTask->curdrive & ~0x80;
 295     return DRIVE_CurDrive;
 296 }
 297
 298
 299 /***********************************************************************
 300  *           DRIVE_SetCurrentDrive
 301  */
 302 static int DRIVE_SetCurrentDrive( int drive )
 303 {
 304     TDB *pTask = GlobalLock16(GetCurrentTask());
 305     if (!DRIVE_IsValid( drive ))
 306     {
 307         SetLastError( ERROR_INVALID_DRIVE );
 308         return 0;
 309     }
 310     TRACE("%c:\n", 'A' + drive );
 311     DRIVE_CurDrive = drive;
 312     if (pTask) pTask->curdrive = drive | 0x80;
 313     return 1;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           DRIVE_FindDriveRoot
 319  *
 320  * Find a drive for which the root matches the beginning of the given path.
 321  * This can be used to translate a Unix path into a drive + DOS path.
 322  * Return value is the drive, or -1 on error. On success, path is modified
 323  * to point to the beginning of the DOS path.
 324  *
 325  * Note: path must be in the encoding of the underlying Unix file system.
 326  */
 327 int DRIVE_FindDriveRoot( const char **path )
 328 {
 329     /* Starting with the full path, check if the device and inode match any of
 330      * the wine 'drives'. If not then remove the last path component and try
 331      * again. If the last component was a '..' then skip a normal component
 332      * since it's a directory that's ascended back out of.
 333      */
 334     int drive, level, len;
 335     char buffer[MAX_PATHNAME_LEN];
 336     char *p;
 337     struct stat st;
 338
 339     strcpy( buffer, *path );
 340     for (p = buffer; *p; p++) if (*p == '\\') *p = '/';
 341     len = p - buffer;
 342
 343     /* strip off trailing slashes */
 344     while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 345
 346     for (;;)
 347     {
 348         /* Find the drive */
 349         if (stat( buffer, &st ) == 0 && S_ISDIR( st.st_mode ))
 350         {
 351             for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 352             {
 353                if (!DOSDrives[drive].root) continue;
 354
 355                if ((DOSDrives[drive].dev == st.st_dev) &&
 356                    (DOSDrives[drive].ino == st.st_ino))
 357                {
 358                    if (len == 1) len = 0;  /* preserve root slash in returned path */
 359                    TRACE( "%s -> drive %c:, root='%s', name='%s'\n",
 360                        *path, 'A' + drive, buffer, *path + len);
 361                    *path += len;
 362                    if (!**path) *path = "\\";
 363                    return drive;
 364                }
 365             }
 366         }
 367         if (len <= 1) return -1;  /* reached root */
 368
 369         level = 0;
 370         while (level < 1)
 371         {
 372             /* find start of the last path component */
 373             while (len > 1 && buffer[len - 1] != '/') len--;
 374             if (!buffer[len]) break;  /* empty component -> reached root */
 375             /* does removing it take us up a level? */
 376             if (strcmp( buffer + len, "." ) != 0)
 377                 level += strcmp( buffer + len, ".." ) ? 1 : -1;
 378             buffer[len] = 0;
 379             /* strip off trailing slashes */
 380             while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 381         }
 382     }
 383 }
 384
 385
 386 /***********************************************************************
 387  *           DRIVE_FindDriveRootW
 388  *
 389  * Unicode version of DRIVE_FindDriveRoot.
 390  */
 391 int DRIVE_FindDriveRootW( LPCWSTR *path )
 392 {
 393     int drive, level, len;
 394     WCHAR buffer[MAX_PATHNAME_LEN];
 395     WCHAR *p;
 396     struct stat st;
 397
 398     strcpyW( buffer, *path );
 399     for (p = buffer; *p; p++) if (*p == '\\') *p = '/';
 400     len = p - buffer;
 401
 402     /* strip off trailing slashes */
 403     while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 404
 405     for (;;)
 406     {
 407         char buffA[MAX_PATHNAME_LEN];
 408
 409         WideCharToMultiByte( CP_UNIXCP, 0, buffer, -1, buffA, sizeof(buffA), NULL, NULL );
 410         if (stat( buffA, &st ) == 0 && S_ISDIR( st.st_mode ))
 411         {
 412             /* Find the drive */
 413             for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 414             {
 415                 if (!DOSDrives[drive].root) continue;
 416
 417                 if ((DOSDrives[drive].dev == st.st_dev) &&
 418                     (DOSDrives[drive].ino == st.st_ino))
 419                 {
 420                     static const WCHAR rootW[] = {'\\',0};
 421
 422                     if (len == 1) len = 0;  /* preserve root slash in returned path */
 423                     TRACE( "%s -> drive %c:, root=%s, name=%s\n",
 424                            debugstr_w(*path), 'A' + drive, debugstr_w(buffer), debugstr_w(*path + len));
 425                     *path += len;
 426                     if (!**path) *path = rootW;
 427                     return drive;
 428                 }
 429             }
 430         }
 431         if (len <= 1) return -1;  /* reached root */
 432
 433         level = 0;
 434         while (level < 1)
 435         {
 436             static const WCHAR dotW[] = {'.',0};
 437             static const WCHAR dotdotW[] = {'.','.',0};
 438
 439             /* find start of the last path component */
 440             while (len > 1 && buffer[len - 1] != '/') len--;
 441             if (!buffer[len]) break;  /* empty component -> reached root */
 442             /* does removing it take us up a level? */
 443             if (strcmpW( buffer + len, dotW ) != 0)
 444                 level += strcmpW( buffer + len, dotdotW ) ? 1 : -1;
 445             buffer[len] = 0;
 446             /* strip off trailing slashes */
 447             while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 448         }
 449     }
 450 }
 451
 452
 453 /***********************************************************************
 454  *           DRIVE_GetRoot
 455  */
 456 const char * DRIVE_GetRoot( int drive )
 457 {
 458     if (!DRIVE_IsValid( drive )) return NULL;
 459     return DOSDrives[drive].root;
 460 }
 461
 462
 463 /***********************************************************************
 464  *           DRIVE_GetDosCwd
 465  */
 466 LPCWSTR DRIVE_GetDosCwd( int drive )
 467 {
 468     TDB *pTask = GlobalLock16(GetCurrentTask());
 469     if (!DRIVE_IsValid( drive )) return NULL;
 470
 471     /* Check if we need to change the directory to the new task. */
 472     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 473         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 474         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 475     {
 476         static const WCHAR rootW[] = {'\\',0};
 477         WCHAR curdirW[MAX_PATH];
 478         MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
 479         /* Perform the task-switch */
 480         if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
 481         DRIVE_LastTask = GetCurrentTask();
 482     }
 483     return DOSDrives[drive].dos_cwd;
 484 }
 485
 486
 487 /***********************************************************************
 488  *           DRIVE_GetUnixCwd
 489  */
 490 const char * DRIVE_GetUnixCwd( int drive )
 491 {
 492     TDB *pTask = GlobalLock16(GetCurrentTask());
 493     if (!DRIVE_IsValid( drive )) return NULL;
 494
 495     /* Check if we need to change the directory to the new task. */
 496     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 497         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 498         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 499     {
 500         static const WCHAR rootW[] = {'\\',0};
 501         WCHAR curdirW[MAX_PATH];
 502         MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
 503         /* Perform the task-switch */
 504         if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
 505         DRIVE_LastTask = GetCurrentTask();
 506     }
 507     return DOSDrives[drive].unix_cwd;
 508 }
 509
 510
 511 /***********************************************************************
 512  *           DRIVE_GetDevice
 513  */
 514 const char * DRIVE_GetDevice( int drive )
 515 {
 516     return (DRIVE_IsValid( drive )) ? DOSDrives[drive].device : NULL;
 517 }
 518
 519 /***********************************************************************
 520  *           DRIVE_Chdir
 521  */
 522 int DRIVE_Chdir( int drive, LPCWSTR path )
 523 {
 524     DOS_FULL_NAME full_name;
 525     WCHAR buffer[MAX_PATHNAME_LEN];
 526     LPSTR unix_cwd;
 527     BY_HANDLE_FILE_INFORMATION info;
 528     TDB *pTask = GlobalLock16(GetCurrentTask());
 529
 530     buffer[0] = 'A' + drive;
 531     buffer[1] = ':';
 532     buffer[2] = 0;
 533     TRACE("(%s,%s)\n", debugstr_w(buffer), debugstr_w(path) );
 534     strncpyW( buffer + 2, path, MAX_PATHNAME_LEN - 2 );
 535     buffer[MAX_PATHNAME_LEN - 1] = 0; /* ensure 0 termination */
 536
 537     if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
 538     if (!FILE_Stat( full_name.long_name, &info, NULL )) return 0;
 539     if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
 540     {
 541         SetLastError( ERROR_FILE_NOT_FOUND );
 542         return 0;
 543     }
 544     unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
 545     while (*unix_cwd == '/') unix_cwd++;
 546
 547     TRACE("(%c:): unix_cwd=%s dos_cwd=%s\n",
 548             'A' + drive, unix_cwd, debugstr_w(full_name.short_name + 3) );
 549
 550     HeapFree( GetProcessHeap(), 0, DOSDrives[drive].dos_cwd );
 551     HeapFree( GetProcessHeap(), 0, DOSDrives[drive].unix_cwd );
 552     DOSDrives[drive].dos_cwd  = HeapAlloc(GetProcessHeap(), 0, (strlenW(full_name.short_name) - 2) * sizeof(WCHAR));
 553     strcpyW(DOSDrives[drive].dos_cwd, full_name.short_name + 3);
 554     DOSDrives[drive].unix_cwd = heap_strdup( unix_cwd );
 555
 556     if (drive == DRIVE_CurDrive)
 557     {
 558         UNICODE_STRING dirW;
 559
 560         RtlInitUnicodeString( &dirW, full_name.short_name );
 561         RtlSetCurrentDirectory_U( &dirW );
 562     }
 563
 564     if (pTask && (pTask->curdrive & 0x80) &&
 565         ((pTask->curdrive & ~0x80) == drive))
 566     {
 567         WideCharToMultiByte(CP_ACP, 0, full_name.short_name + 2, -1,
 568                             pTask->curdir, sizeof(pTask->curdir), NULL, NULL);
 569         DRIVE_LastTask = GetCurrentTask();
 570     }
 571     return 1;
 572 }
 573
 574
 575 /***********************************************************************
 576  *       DRIVE_GetCurrentDirectory
 577  * Returns "X:\\path\\etc\\".
 578  *
 579  * Despite the API description, return required length including the
 580  * terminating null when buffer too small. This is the real behaviour.
 581 */
 582 static UINT DRIVE_GetCurrentDirectory( UINT buflen, LPWSTR buf )
 583 {
 584     UINT ret;
 585     LPCWSTR dos_cwd = DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
 586     static const WCHAR driveA_rootW[] = {'A',':','\\',0};
 587
 588     ret = strlenW(dos_cwd) + 3; /* length of WHOLE current directory */
 589     if (ret >= buflen) return ret + 1;
 590
 591     strcpyW( buf, driveA_rootW );
 592     buf[0] += DRIVE_GetCurrentDrive();
 593     strcatW( buf, dos_cwd );
 594     return ret;
 595 }
 596
 597
 598 /***********************************************************************
 599  *           DRIVE_BuildEnv
 600  *
 601  * Build the environment array containing the drives' current directories.
 602  * Resulting pointer must be freed with HeapFree.
 603  */
 604 WCHAR *DRIVE_BuildEnv(void)
 605 {
 606     int i, length = 0;
 607     LPCWSTR cwd[MAX_DOS_DRIVES];
 608     WCHAR *env, *p;
 609
 610     for (i = 0; i < MAX_DOS_DRIVES; i++)
 611     {
 612         if ((cwd[i] = DRIVE_GetDosCwd(i)) && cwd[i][0])
 613             length += strlenW(cwd[i]) + 8;
 614     }
 615     if (!(env = HeapAlloc( GetProcessHeap(), 0, (length+1) * sizeof(WCHAR) ))) return NULL;
 616     for (i = 0, p = env; i < MAX_DOS_DRIVES; i++)
 617     {
 618         if (cwd[i] && cwd[i][0])
 619         {
 620             *p++ = '='; *p++ = 'A' + i; *p++ = ':';
 621             *p++ = '='; *p++ = 'A' + i; *p++ = ':'; *p++ = '\\';
 622             strcpyW( p, cwd[i] );
 623             p += strlenW(p) + 1;
 624         }
 625     }
 626     *p = 0;
 627     return env;
 628 }
 629
 630
 631 /***********************************************************************
 632  *           GetCurrentDirectory   (KERNEL.411)
 633  */
 634 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
 635 {
 636     WCHAR cur_dirW[MAX_PATH];
 637
 638     DRIVE_GetCurrentDirectory(MAX_PATH, cur_dirW);
 639     return (UINT16)WideCharToMultiByte(CP_ACP, 0, cur_dirW, -1, buf, buflen, NULL, NULL);
 640 }
 641
 642
 643 /***********************************************************************
 644  *           GetCurrentDirectoryW   (KERNEL32.@)
 645  */
 646 UINT WINAPI GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
 647 {
 648     UINT ret;
 649     WCHAR longname[MAX_PATHNAME_LEN];
 650     WCHAR shortname[MAX_PATHNAME_LEN];
 651
 652     ret = DRIVE_GetCurrentDirectory(MAX_PATHNAME_LEN, shortname);
 653     if ( ret > MAX_PATHNAME_LEN ) {
 654       ERR_(file)("pathnamelength (%d) > MAX_PATHNAME_LEN!\n", ret );
 655       return ret;
 656     }
 657     GetLongPathNameW(shortname, longname, MAX_PATHNAME_LEN);
 658     ret = strlenW( longname ) + 1;
 659     if (ret > buflen) return ret;
 660     strcpyW(buf, longname);
 661     return ret - 1;
 662 }
 663
 664 /***********************************************************************
 665  *           GetCurrentDirectoryA   (KERNEL32.@)
 666  */
 667 UINT WINAPI GetCurrentDirectoryA( UINT buflen, LPSTR buf )
 668 {
 669     WCHAR bufferW[MAX_PATH];
 670     DWORD ret, retW;
 671
 672     retW = GetCurrentDirectoryW(MAX_PATH, bufferW);
 673
 674     if (!retW)
 675         ret = 0;
 676     else if (retW > MAX_PATH)
 677     {
 678         SetLastError(ERROR_FILENAME_EXCED_RANGE);
 679         ret = 0;
 680     }
 681     else
 682     {
 683         ret = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
 684         if (buflen >= ret)
 685         {
 686             WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buf, buflen, NULL, NULL);
 687             ret--; /* length without 0 */
 688         }
 689     }
 690     return ret;
 691 }
 692
 693
 694 /***********************************************************************
 695  *           SetCurrentDirectoryW   (KERNEL32.@)
 696  */
 697 BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dir )
 698 {
 699     int drive, olddrive = DRIVE_GetCurrentDrive();
 700
 701     if (!dir)
 702     {
 703         SetLastError(ERROR_INVALID_PARAMETER);
 704         return FALSE;
 705     }
 706     if (dir[0] && (dir[1]==':'))
 707     {
 708         drive = toupperW( *dir ) - 'A';
 709         dir += 2;
 710     }
 711     else
 712         drive = olddrive;
 713
 714     /* WARNING: we need to set the drive before the dir, as DRIVE_Chdir
 715        sets pTask->curdir only if pTask->curdrive is drive */
 716     if (!(DRIVE_SetCurrentDrive( drive )))
 717         return FALSE;
 718
 719     /* FIXME: what about empty strings? Add a \\ ? */
 720     if (!DRIVE_Chdir( drive, dir )) {
 721         DRIVE_SetCurrentDrive(olddrive);
 722         return FALSE;
 723     }
 724     return TRUE;
 725 }
 726
 727
 728 /***********************************************************************
 729  *           SetCurrentDirectoryA   (KERNEL32.@)
 730  */
 731 BOOL WINAPI SetCurrentDirectoryA( LPCSTR dir )
 732 {
 733     UNICODE_STRING dirW;
 734     BOOL ret = FALSE;
 735
 736     if (!dir)
 737     {
 738         SetLastError(ERROR_INVALID_PARAMETER);
 739         return FALSE;
 740     }
 741
 742     if (RtlCreateUnicodeStringFromAsciiz(&dirW, dir))
 743     {
 744         ret = SetCurrentDirectoryW(dirW.Buffer);
 745         RtlFreeUnicodeString(&dirW);
 746     }
 747     else
 748         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 749     return ret;
 750 }