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 <stdio.h>
  33 #include <stdlib.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <fcntl.h>
  37 #include <errno.h>
  38 #ifdef HAVE_UNISTD_H
  39 # include <unistd.h>
  40 #endif
  41
  42 #ifdef HAVE_SYS_PARAM_H
  43 # include <sys/param.h>
  44 #endif
  45 #ifdef STATFS_DEFINED_BY_SYS_VFS
  46 # include <sys/vfs.h>
  47 #else
  48 # ifdef STATFS_DEFINED_BY_SYS_MOUNT
  49 #  include <sys/mount.h>
  50 # else
  51 #  ifdef STATFS_DEFINED_BY_SYS_STATFS
  52 #   include <sys/statfs.h>
  53 #  endif
  54 # endif
  55 #endif
  56
  57 #define NONAMELESSUNION
  58 #define NONAMELESSSTRUCT
  59 #include "winbase.h"
  60 #include "winternl.h"
  61 #include "wine/winbase16.h"   /* for GetCurrentTask */
  62 #include "winerror.h"
  63 #include "winioctl.h"
  64 #include "ntddstor.h"
  65 #include "ntddcdrm.h"
  66 #include "drive.h"
  67 #include "file.h"
  68 #include "msdos.h"
  69 #include "task.h"
  70 #include "wine/unicode.h"
  71 #include "wine/library.h"
  72 #include "wine/server.h"
  73 #include "wine/debug.h"
  74
  75 WINE_DEFAULT_DEBUG_CHANNEL(dosfs);
  76 WINE_DECLARE_DEBUG_CHANNEL(file);
  77
  78 typedef struct
  79 {
  80     char     *root;      /* root dir in Unix format without trailing / */
  81     LPWSTR    dos_cwd;   /* cwd in DOS format without leading or trailing \ */
  82     char     *unix_cwd;  /* cwd in Unix format without leading or trailing / */
  83     char     *device;    /* raw device path */
  84     WCHAR     label_conf[12]; /* drive label as cfg'd in wine config */
  85     WCHAR     label_read[12]; /* drive label as read from device */
  86     DWORD     serial_conf;    /* drive serial number as cfg'd in wine config */
  87     UINT      type;      /* drive type */
  88     UINT      flags;     /* drive flags */
  89     UINT      codepage;  /* drive code page */
  90     dev_t     dev;       /* unix device number */
  91     ino_t     ino;       /* unix inode number */
  92 } DOSDRIVE;
  93
  94
  95 static const WCHAR DRIVE_Types[][8] =
  96 {
  97     { 0 }, /* DRIVE_UNKNOWN */
  98     { 0 }, /* DRIVE_NO_ROOT_DIR */
  99     {'f','l','o','p','p','y',0}, /* DRIVE_REMOVABLE */
 100     {'h','d',0}, /* DRIVE_FIXED */
 101     {'n','e','t','w','o','r','k',0}, /* DRIVE_REMOTE */
 102     {'c','d','r','o','m',0}, /* DRIVE_CDROM */
 103     {'r','a','m','d','i','s','k',0} /* DRIVE_RAMDISK */
 104 };
 105
 106
 107 /* Known filesystem types */
 108
 109 typedef struct
 110 {
 111     const WCHAR name[6];
 112     UINT      flags;
 113 } FS_DESCR;
 114
 115 static const FS_DESCR DRIVE_Filesystems[] =
 116 {
 117     { {'u','n','i','x',0}, DRIVE_CASE_SENSITIVE | DRIVE_CASE_PRESERVING },
 118     { {'m','s','d','o','s',0}, DRIVE_SHORT_NAMES },
 119     { {'d','o','s',0}, DRIVE_SHORT_NAMES },
 120     { {'f','a','t',0}, DRIVE_SHORT_NAMES },
 121     { {'v','f','a','t',0}, DRIVE_CASE_PRESERVING },
 122     { {'w','i','n','9','5',0}, DRIVE_CASE_PRESERVING },
 123     { { 0 }, 0 }
 124 };
 125
 126
 127 static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
 128 static int DRIVE_CurDrive = -1;
 129
 130 static HTASK16 DRIVE_LastTask = 0;
 131
 132 /* strdup on the process heap */
 133 inline static char *heap_strdup( const char *str )
 134 {
 135     INT len = strlen(str) + 1;
 136     LPSTR p = HeapAlloc( GetProcessHeap(), 0, len );
 137     if (p) memcpy( p, str, len );
 138     return p;
 139 }
 140
 141 extern void CDROM_InitRegistry(int dev);
 142
 143 /***********************************************************************
 144  *           DRIVE_GetDriveType
 145  */
 146 static UINT DRIVE_GetDriveType( LPCWSTR name )
 147 {
 148     WCHAR buffer[20];
 149     int i;
 150     static const WCHAR TypeW[] = {'T','y','p','e',0};
 151     static const WCHAR hdW[] = {'h','d',0};
 152
 153     PROFILE_GetWineIniString( name, TypeW, hdW, buffer, 20 );
 154     if(!buffer[0])
 155         strcpyW(buffer,hdW);
 156     for (i = 0; i < sizeof(DRIVE_Types)/sizeof(DRIVE_Types[0]); i++)
 157     {
 158         if (!strcmpiW( buffer, DRIVE_Types[i] )) return i;
 159     }
 160     MESSAGE("%s: unknown drive type %s, defaulting to 'hd'.\n",
 161             debugstr_w(name), debugstr_w(buffer) );
 162     return DRIVE_FIXED;
 163 }
 164
 165
 166 /***********************************************************************
 167  *           DRIVE_GetFSFlags
 168  */
 169 static UINT DRIVE_GetFSFlags( LPCWSTR name, LPCWSTR value )
 170 {
 171     const FS_DESCR *descr;
 172
 173     for (descr = DRIVE_Filesystems; *descr->name; descr++)
 174         if (!strcmpiW( value, descr->name )) return descr->flags;
 175     MESSAGE("%s: unknown filesystem type %s, defaulting to 'win95'.\n",
 176             debugstr_w(name), debugstr_w(value) );
 177     return DRIVE_CASE_PRESERVING;
 178 }
 179
 180
 181 /***********************************************************************
 182  *           DRIVE_Init
 183  */
 184 int DRIVE_Init(void)
 185 {
 186     int i, len, count = 0;
 187     WCHAR name[] = {'D','r','i','v','e',' ','A',0};
 188     WCHAR drive_env[] = {'=','A',':',0};
 189     WCHAR path[MAX_PATHNAME_LEN];
 190     WCHAR buffer[80];
 191     struct stat drive_stat_buffer;
 192     WCHAR *p;
 193     DOSDRIVE *drive;
 194     static const WCHAR PathW[] = {'P','a','t','h',0};
 195     static const WCHAR empty_strW[] = { 0 };
 196     static const WCHAR CodepageW[] = {'C','o','d','e','p','a','g','e',0};
 197     static const WCHAR LabelW[] = {'L','a','b','e','l',0};
 198     static const WCHAR SerialW[] = {'S','e','r','i','a','l',0};
 199     static const WCHAR zeroW[] = {'0',0};
 200     static const WCHAR def_serialW[] = {'1','2','3','4','5','6','7','8',0};
 201     static const WCHAR FilesystemW[] = {'F','i','l','e','s','y','s','t','e','m',0};
 202     static const WCHAR win95W[] = {'w','i','n','9','5',0};
 203     static const WCHAR DeviceW[] = {'D','e','v','i','c','e',0};
 204     static const WCHAR ReadVolInfoW[] = {'R','e','a','d','V','o','l','I','n','f','o',0};
 205     static const WCHAR FailReadOnlyW[] = {'F','a','i','l','R','e','a','d','O','n','l','y',0};
 206     static const WCHAR driveC_labelW[] = {'D','r','i','v','e',' ','C',' ',' ',' ',' ',0};
 207
 208     for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, name[6]++, drive++)
 209     {
 210         PROFILE_GetWineIniString( name, PathW, empty_strW, path, MAX_PATHNAME_LEN );
 211         if (path[0])
 212         {
 213             /* Get the code page number */
 214             PROFILE_GetWineIniString( name, CodepageW, zeroW, /* 0 == CP_ACP */
 215                                       buffer, 80 );
 216             drive->codepage = strtolW( buffer, NULL, 10 );
 217
 218             p = path + strlenW(path) - 1;
 219             while ((p > path) && (*p == '/')) *p-- = '\0';
 220
 221             if (path[0] == '/')
 222             {
 223                 len = WideCharToMultiByte(drive->codepage, 0, path, -1, NULL, 0, NULL, NULL);
 224                 drive->root = HeapAlloc(GetProcessHeap(), 0, len);
 225                 WideCharToMultiByte(drive->codepage, 0, path, -1, drive->root, len, NULL, NULL);
 226             }
 227             else
 228             {
 229                 /* relative paths are relative to config dir */
 230                 const char *config = wine_get_config_dir();
 231                 len = strlen(config);
 232                 len += WideCharToMultiByte(drive->codepage, 0, path, -1, NULL, 0, NULL, NULL) + 2;
 233                 drive->root = HeapAlloc( GetProcessHeap(), 0, len );
 234                 len -= sprintf( drive->root, "%s/", config );
 235                 WideCharToMultiByte(drive->codepage, 0, path, -1, drive->root + strlen(drive->root), len, NULL, NULL);
 236             }
 237
 238             if (stat( drive->root, &drive_stat_buffer ))
 239             {
 240                 MESSAGE("Could not stat %s (%s), ignoring drive %c:\n",
 241                         drive->root, strerror(errno), 'A' + i);
 242                 HeapFree( GetProcessHeap(), 0, drive->root );
 243                 drive->root = NULL;
 244                 continue;
 245             }
 246             if (!S_ISDIR(drive_stat_buffer.st_mode))
 247             {
 248                 MESSAGE("%s is not a directory, ignoring drive %c:\n",
 249                         drive->root, 'A' + i );
 250                 HeapFree( GetProcessHeap(), 0, drive->root );
 251                 drive->root = NULL;
 252                 continue;
 253             }
 254
 255             drive->dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(drive->dos_cwd[0]));
 256             drive->unix_cwd = heap_strdup( "" );
 257             drive->type     = DRIVE_GetDriveType( name );
 258             drive->device   = NULL;
 259             drive->flags    = 0;
 260             drive->dev      = drive_stat_buffer.st_dev;
 261             drive->ino      = drive_stat_buffer.st_ino;
 262
 263             /* Get the drive label */
 264             PROFILE_GetWineIniString( name, LabelW, empty_strW, drive->label_conf, 12 );
 265             if ((len = strlenW(drive->label_conf)) < 11)
 266             {
 267                 /* Pad label with spaces */
 268                 while(len < 11) drive->label_conf[len++] = ' ';
 269                 drive->label_conf[11] = '\0';
 270             }
 271
 272             /* Get the serial number */
 273             PROFILE_GetWineIniString( name, SerialW, def_serialW, buffer, 80 );
 274             drive->serial_conf = strtoulW( buffer, NULL, 16 );
 275
 276             /* Get the filesystem type */
 277             PROFILE_GetWineIniString( name, FilesystemW, win95W, buffer, 80 );
 278             drive->flags = DRIVE_GetFSFlags( name, buffer );
 279
 280             /* Get the device */
 281             PROFILE_GetWineIniString( name, DeviceW, empty_strW, buffer, 80 );
 282             if (buffer[0])
 283             {
 284                 int cd_fd;
 285                 len = WideCharToMultiByte(CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL);
 286                 drive->device = HeapAlloc(GetProcessHeap(), 0, len);
 287                 WideCharToMultiByte(drive->codepage, 0, buffer, -1, drive->device, len, NULL, NULL);
 288
 289                 if (PROFILE_GetWineIniBool( name, ReadVolInfoW, 1))
 290                     drive->flags |= DRIVE_READ_VOL_INFO;
 291
 292                 if (drive->type == DRIVE_CDROM)
 293                 {
 294                     if ((cd_fd = open(drive->device, O_RDONLY|O_NONBLOCK)) != -1)
 295                     {
 296                         CDROM_InitRegistry(cd_fd);
 297                         close(cd_fd);
 298                     }
 299                 }
 300             }
 301
 302             /* Get the FailReadOnly flag */
 303             if (PROFILE_GetWineIniBool( name, FailReadOnlyW, 0 ))
 304                 drive->flags |= DRIVE_FAIL_READ_ONLY;
 305
 306             /* Make the first hard disk the current drive */
 307             if ((DRIVE_CurDrive == -1) && (drive->type == DRIVE_FIXED))
 308                 DRIVE_CurDrive = i;
 309
 310             count++;
 311             TRACE("%s: path=%s type=%s label=%s serial=%08lx "
 312                   "flags=%08x codepage=%u dev=%x ino=%x\n",
 313                   debugstr_w(name), drive->root, debugstr_w(DRIVE_Types[drive->type]),
 314                   debugstr_w(drive->label_conf), drive->serial_conf, drive->flags,
 315                   drive->codepage, (int)drive->dev, (int)drive->ino );
 316         }
 317         else WARN("%s: not defined\n", debugstr_w(name) );
 318     }
 319
 320     if (!count)
 321     {
 322         MESSAGE("Warning: no valid DOS drive found, check your configuration file.\n" );
 323         /* Create a C drive pointing to Unix root dir */
 324         DOSDrives[2].root     = heap_strdup( "/" );
 325         DOSDrives[2].dos_cwd  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSDrives[2].dos_cwd[0]));
 326         DOSDrives[2].unix_cwd = heap_strdup( "" );
 327         strcpyW( DOSDrives[2].label_conf, driveC_labelW );
 328         DOSDrives[2].serial_conf   = 12345678;
 329         DOSDrives[2].type     = DRIVE_FIXED;
 330         DOSDrives[2].device   = NULL;
 331         DOSDrives[2].flags    = 0;
 332         DRIVE_CurDrive = 2;
 333     }
 334
 335     /* Make sure the current drive is valid */
 336     if (DRIVE_CurDrive == -1)
 337     {
 338         for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
 339         {
 340             if (drive->root && !(drive->flags & DRIVE_DISABLED))
 341             {
 342                 DRIVE_CurDrive = i;
 343                 break;
 344             }
 345         }
 346     }
 347
 348     /* get current working directory info for all drives */
 349     for (i = 0; i < MAX_DOS_DRIVES; i++, drive_env[1]++)
 350     {
 351         if (!GetEnvironmentVariableW(drive_env, path, MAX_PATHNAME_LEN)) continue;
 352         /* sanity check */
 353         if (toupperW(path[0]) != drive_env[1] || path[1] != ':') continue;
 354         DRIVE_Chdir( i, path + 2 );
 355     }
 356     return 1;
 357 }
 358
 359
 360 /***********************************************************************
 361  *           DRIVE_IsValid
 362  */
 363 int DRIVE_IsValid( int drive )
 364 {
 365     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
 366     return (DOSDrives[drive].root &&
 367             !(DOSDrives[drive].flags & DRIVE_DISABLED));
 368 }
 369
 370
 371 /***********************************************************************
 372  *           DRIVE_GetCurrentDrive
 373  */
 374 int DRIVE_GetCurrentDrive(void)
 375 {
 376     TDB *pTask = TASK_GetCurrent();
 377     if (pTask && (pTask->curdrive & 0x80)) return pTask->curdrive & ~0x80;
 378     return DRIVE_CurDrive;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           DRIVE_SetCurrentDrive
 384  */
 385 int DRIVE_SetCurrentDrive( int drive )
 386 {
 387     TDB *pTask = TASK_GetCurrent();
 388     if (!DRIVE_IsValid( drive ))
 389     {
 390         SetLastError( ERROR_INVALID_DRIVE );
 391         return 0;
 392     }
 393     TRACE("%c:\n", 'A' + drive );
 394     DRIVE_CurDrive = drive;
 395     if (pTask) pTask->curdrive = drive | 0x80;
 396     return 1;
 397 }
 398
 399
 400 /***********************************************************************
 401  *           DRIVE_FindDriveRoot
 402  *
 403  * Find a drive for which the root matches the beginning of the given path.
 404  * This can be used to translate a Unix path into a drive + DOS path.
 405  * Return value is the drive, or -1 on error. On success, path is modified
 406  * to point to the beginning of the DOS path.
 407  *
 408  * Note: path must be in the encoding of the underlying Unix file system.
 409  */
 410 int DRIVE_FindDriveRoot( const char **path )
 411 {
 412     /* Starting with the full path, check if the device and inode match any of
 413      * the wine 'drives'. If not then remove the last path component and try
 414      * again. If the last component was a '..' then skip a normal component
 415      * since it's a directory that's ascended back out of.
 416      */
 417     int drive, level, len;
 418     char buffer[MAX_PATHNAME_LEN];
 419     char *p;
 420     struct stat st;
 421
 422     strcpy( buffer, *path );
 423     while ((p = strchr( buffer, '\\' )) != NULL)
 424         *p = '/';
 425     len = strlen(buffer);
 426
 427     /* strip off trailing slashes */
 428     while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 429
 430     for (;;)
 431     {
 432         /* Find the drive */
 433         if (stat( buffer, &st ) == 0 && S_ISDIR( st.st_mode ))
 434         {
 435             for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 436             {
 437                if (!DOSDrives[drive].root ||
 438                    (DOSDrives[drive].flags & DRIVE_DISABLED))
 439                    continue;
 440
 441                if ((DOSDrives[drive].dev == st.st_dev) &&
 442                    (DOSDrives[drive].ino == st.st_ino))
 443                {
 444                    if (len == 1) len = 0;  /* preserve root slash in returned path */
 445                    TRACE( "%s -> drive %c:, root='%s', name='%s'\n",
 446                        *path, 'A' + drive, buffer, *path + len);
 447                    *path += len;
 448                    if (!**path) *path = "\\";
 449                    return drive;
 450                }
 451             }
 452         }
 453         if (len <= 1) return -1;  /* reached root */
 454
 455         level = 0;
 456         while (level < 1)
 457         {
 458             /* find start of the last path component */
 459             while (len > 1 && buffer[len - 1] != '/') len--;
 460             if (!buffer[len]) break;  /* empty component -> reached root */
 461             /* does removing it take us up a level? */
 462             if (strcmp( buffer + len, "." ) != 0)
 463                 level += strcmp( buffer + len, ".." ) ? 1 : -1;
 464             buffer[len] = 0;
 465             /* strip off trailing slashes */
 466             while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 467         }
 468     }
 469 }
 470
 471
 472 /***********************************************************************
 473  *           DRIVE_FindDriveRootW
 474  *
 475  * Unicode version of DRIVE_FindDriveRoot.
 476  */
 477 int DRIVE_FindDriveRootW( LPCWSTR *path )
 478 {
 479     int drive, level, len;
 480     WCHAR buffer[MAX_PATHNAME_LEN];
 481     WCHAR *p;
 482     struct stat st;
 483
 484     strcpyW( buffer, *path );
 485     while ((p = strchrW( buffer, '\\' )) != NULL)
 486         *p = '/';
 487     len = strlenW(buffer);
 488
 489     /* strip off trailing slashes */
 490     while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 491
 492     for (;;)
 493     {
 494         int codepage = -1;
 495
 496         /* Find the drive */
 497         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 498         {
 499             char buffA[MAX_PATHNAME_LEN];
 500
 501             if (!DOSDrives[drive].root ||
 502                 (DOSDrives[drive].flags & DRIVE_DISABLED))
 503                 continue;
 504
 505             if (codepage != DOSDrives[drive].codepage)
 506             {
 507                 WideCharToMultiByte( DOSDrives[drive].codepage, 0, buffer, -1,
 508                                      buffA, sizeof(buffA), NULL, NULL );
 509                 if (stat( buffA, &st ) == -1 || !S_ISDIR( st.st_mode ))
 510                 {
 511                     codepage = -1;
 512                     continue;
 513                 }
 514                 codepage = DOSDrives[drive].codepage;
 515             }
 516
 517             if ((DOSDrives[drive].dev == st.st_dev) &&
 518                 (DOSDrives[drive].ino == st.st_ino))
 519             {
 520                 static const WCHAR rootW[] = {'\\',0};
 521
 522                 if (len == 1) len = 0;  /* preserve root slash in returned path */
 523                 TRACE( "%s -> drive %c:, root=%s, name=%s\n",
 524                        debugstr_w(*path), 'A' + drive, debugstr_w(buffer), debugstr_w(*path + len));
 525                 *path += len;
 526                 if (!**path) *path = rootW;
 527                 return drive;
 528             }
 529         }
 530         if (len <= 1) return -1;  /* reached root */
 531
 532         level = 0;
 533         while (level < 1)
 534         {
 535             static const WCHAR dotW[] = {'.',0};
 536             static const WCHAR dotdotW[] = {'.','.',0};
 537
 538             /* find start of the last path component */
 539             while (len > 1 && buffer[len - 1] != '/') len--;
 540             if (!buffer[len]) break;  /* empty component -> reached root */
 541             /* does removing it take us up a level? */
 542             if (strcmpW( buffer + len, dotW ) != 0)
 543                 level += strcmpW( buffer + len, dotdotW ) ? 1 : -1;
 544             buffer[len] = 0;
 545             /* strip off trailing slashes */
 546             while (len > 1 && buffer[len - 1] == '/') buffer[--len] = 0;
 547         }
 548     }
 549 }
 550
 551
 552 /***********************************************************************
 553  *           DRIVE_GetRoot
 554  */
 555 const char * DRIVE_GetRoot( int drive )
 556 {
 557     if (!DRIVE_IsValid( drive )) return NULL;
 558     return DOSDrives[drive].root;
 559 }
 560
 561
 562 /***********************************************************************
 563  *           DRIVE_GetDosCwd
 564  */
 565 LPCWSTR DRIVE_GetDosCwd( int drive )
 566 {
 567     TDB *pTask = TASK_GetCurrent();
 568     if (!DRIVE_IsValid( drive )) return NULL;
 569
 570     /* Check if we need to change the directory to the new task. */
 571     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 572         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 573         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 574     {
 575         static const WCHAR rootW[] = {'\\',0};
 576         WCHAR curdirW[MAX_PATH];
 577         MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
 578         /* Perform the task-switch */
 579         if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
 580         DRIVE_LastTask = GetCurrentTask();
 581     }
 582     return DOSDrives[drive].dos_cwd;
 583 }
 584
 585
 586 /***********************************************************************
 587  *           DRIVE_GetUnixCwd
 588  */
 589 const char * DRIVE_GetUnixCwd( int drive )
 590 {
 591     TDB *pTask = TASK_GetCurrent();
 592     if (!DRIVE_IsValid( drive )) return NULL;
 593
 594     /* Check if we need to change the directory to the new task. */
 595     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 596         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 597         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 598     {
 599         static const WCHAR rootW[] = {'\\',0};
 600         WCHAR curdirW[MAX_PATH];
 601         MultiByteToWideChar(CP_ACP, 0, pTask->curdir, -1, curdirW, MAX_PATH);
 602         /* Perform the task-switch */
 603         if (!DRIVE_Chdir( drive, curdirW )) DRIVE_Chdir( drive, rootW );
 604         DRIVE_LastTask = GetCurrentTask();
 605     }
 606     return DOSDrives[drive].unix_cwd;
 607 }
 608
 609
 610 /***********************************************************************
 611  *           DRIVE_GetDevice
 612  */
 613 const char * DRIVE_GetDevice( int drive )
 614 {
 615     return (DRIVE_IsValid( drive )) ? DOSDrives[drive].device : NULL;
 616 }
 617
 618 /******************************************************************
 619  *              static WORD CDROM_Data_FindBestVoldesc
 620  *
 621  *
 622  */
 623 static WORD CDROM_Data_FindBestVoldesc(int fd)
 624 {
 625     BYTE cur_vd_type, max_vd_type = 0;
 626     unsigned int offs, best_offs = 0, extra_offs = 0;
 627     char sig[3];
 628
 629     for (offs = 0x8000; offs <= 0x9800; offs += 0x800)
 630     {
 631         /* if 'CDROM' occurs at position 8, this is a pre-iso9660 cd, and
 632          * the volume label is displaced forward by 8
 633          */
 634         lseek(fd, offs + 11, SEEK_SET); /* check for non-ISO9660 signature */
 635         read(fd, &sig, 3);
 636         if ((sig[0] == 'R') && (sig[1] == 'O') && (sig[2]=='M'))
 637         {
 638             extra_offs = 8;
 639         }
 640         lseek(fd, offs + extra_offs, SEEK_SET);
 641         read(fd, &cur_vd_type, 1);
 642         if (cur_vd_type == 0xff) /* voldesc set terminator */
 643             break;
 644         if (cur_vd_type > max_vd_type)
 645         {
 646             max_vd_type = cur_vd_type;
 647             best_offs = offs + extra_offs;
 648         }
 649     }
 650     return best_offs;
 651 }
 652
 653 /***********************************************************************
 654  *           DRIVE_ReadSuperblock
 655  *
 656  * NOTE
 657  *      DRIVE_SetLabel and DRIVE_SetSerialNumber use this in order
 658  * to check, that they are writing on a FAT filesystem !
 659  */
 660 int DRIVE_ReadSuperblock (int drive, char * buff)
 661 {
 662 #define DRIVE_SUPER 96
 663     int fd;
 664     off_t offs;
 665     int ret = 0;
 666     struct stat stat_buf;
 667
 668     memset(buff, 0, DRIVE_SUPER);
 669        /* O_NONBLOCK in case we're opening FIFO; will be reset later */
 670     if ((fd = open(DOSDrives[drive].device, O_RDONLY|O_NOCTTY|O_NONBLOCK)) != -1) {
 671         if (fstat(fd, &stat_buf) < 0) { /* shouldn't happen since we just opened that file */
 672             ERR("fstat() failed for opened device '%s' (drive %c:) ! IT SHOULDN'T HAPPEN !!!\n",
 673                 DOSDrives[drive].device, 'A'+drive);
 674             ret = -1;
 675         } else if (!S_ISBLK(stat_buf.st_mode)) {
 676             ERR("Device '%s' (drive %c:) is not a block device - check your config\n",
 677                 DOSDrives[drive].device, 'A'+drive);
 678             ret = -1;
 679                         /* reset O_NONBLOCK */
 680         } else if (fcntl(fd, F_SETFL, 0) < 0 || fcntl(fd, F_GETFL) & O_NONBLOCK) {
 681             ERR("fcntl() failed to reset O_NONBLOCK for device '%s' (drive %c:)\n",
 682                 DOSDrives[drive].device, 'A'+drive);
 683             ret = -1;
 684         }
 685         if (ret) {
 686             close(fd);
 687             fd = -1;
 688         }
 689     } else {
 690         if (!DOSDrives[drive].device)
 691             ERR("No device configured for drive %c: !\n", 'A'+drive);
 692         else
 693             ERR("Couldn't open device '%s' for drive %c: ! (%s)\n", DOSDrives[drive].device, 'A'+drive,
 694                 (stat(DOSDrives[drive].device, &stat_buf)) ?
 695                         "not available or symlink not valid ?" : "no permission");
 696     }
 697     if (fd == -1) {
 698         ERR("Can't read drive volume info ! Either pre-set it or make sure the device to read it from is accessible !\n");
 699         PROFILE_UsageWineIni();
 700         return -1;
 701     }
 702
 703     switch(DOSDrives[drive].type)
 704     {
 705         case DRIVE_REMOVABLE:
 706         case DRIVE_FIXED:
 707             offs = 0;
 708             break;
 709         case DRIVE_CDROM:
 710             offs = CDROM_Data_FindBestVoldesc(fd);
 711             break;
 712         default:
 713             offs = 0;
 714             break;
 715     }
 716
 717     if ((offs) && (lseek(fd,offs,SEEK_SET)!=offs))
 718     {
 719         ret = -4;
 720         goto the_end;
 721     }
 722     if (read(fd,buff,DRIVE_SUPER)!=DRIVE_SUPER)
 723     {
 724         ret = -2;
 725         goto the_end;
 726     }
 727
 728     switch(DOSDrives[drive].type)
 729     {
 730         case DRIVE_REMOVABLE:
 731         case DRIVE_FIXED:
 732             if ((buff[0x26]!=0x29) ||  /* Check for FAT present */
 733                 /* FIXME: do really all FAT have their name beginning with
 734                    "FAT" ? (At least FAT12, FAT16 and FAT32 have :) */
 735                 memcmp( buff+0x36,"FAT",3))
 736             {
 737                 ERR("The filesystem is not FAT !! (device=%s)\n",
 738                     DOSDrives[drive].device);
 739                 ret = -3;
 740                 goto the_end;
 741             }
 742             break;
 743         case DRIVE_CDROM:
 744             if (strncmp(&buff[1],"CD001",5)) /* Check for iso9660 present */
 745             {
 746                 ret = -3;
 747                 goto the_end;
 748             }
 749             /* FIXME: do we need to check for "CDROM", too ? (high sierra) */
 750             break;
 751         default:
 752             ret = -3;
 753             goto the_end;
 754     }
 755
 756     return close(fd);
 757  the_end:
 758     close(fd);
 759     return ret;
 760 }
 761
 762
 763 /***********************************************************************
 764  *           DRIVE_WriteSuperblockEntry
 765  *
 766  * NOTE
 767  *      We are writing as little as possible (ie. not the whole SuperBlock)
 768  * not to interfere with kernel. The drive can be mounted !
 769  */
 770 int DRIVE_WriteSuperblockEntry (int drive, off_t ofs, size_t len, char * buff)
 771 {
 772     int fd;
 773
 774     if ((fd=open(DOSDrives[drive].device,O_WRONLY))==-1)
 775     {
 776         ERR("Cannot open the device %s (for writing)\n",
 777             DOSDrives[drive].device);
 778         return -1;
 779     }
 780     if (lseek(fd,ofs,SEEK_SET)!=ofs)
 781     {
 782         ERR("lseek failed on device %s !\n",
 783             DOSDrives[drive].device);
 784         close(fd);
 785         return -2;
 786     }
 787     if (write(fd,buff,len)!=len)
 788     {
 789         close(fd);
 790         ERR("Cannot write on %s !\n",
 791             DOSDrives[drive].device);
 792         return -3;
 793     }
 794     return close (fd);
 795 }
 796
 797 /******************************************************************
 798  *              static HANDLE   CDROM_Open
 799  *
 800  *
 801  */
 802 static HANDLE   CDROM_Open(int drive)
 803 {
 804     WCHAR root[] = {'\\','\\','.','\\','A',':',0};
 805     root[4] += drive;
 806     return CreateFileW(root, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 807 }
 808
 809 /**************************************************************************
 810  *                              CDROM_Data_GetLabel             [internal]
 811  */
 812 DWORD CDROM_Data_GetLabel(int drive, WCHAR *label)
 813 {
 814 #define LABEL_LEN       32+1
 815     int dev = open(DOSDrives[drive].device, O_RDONLY|O_NONBLOCK);
 816     WORD offs = CDROM_Data_FindBestVoldesc(dev);
 817     WCHAR label_read[LABEL_LEN]; /* Unicode possible, too */
 818     DWORD unicode_id = 0;
 819
 820     if (offs)
 821     {
 822         if ((lseek(dev, offs+0x58, SEEK_SET) == offs+0x58)
 823         &&  (read(dev, &unicode_id, 3) == 3))
 824         {
 825             int ver = (unicode_id & 0xff0000) >> 16;
 826
 827             if ((lseek(dev, offs+0x28, SEEK_SET) != offs+0x28)
 828             ||  (read(dev, &label_read, LABEL_LEN) != LABEL_LEN))
 829                 goto failure;
 830
 831             close(dev);
 832             if ((LOWORD(unicode_id) == 0x2f25) /* Unicode ID */
 833             &&  ((ver == 0x40) || (ver == 0x43) || (ver == 0x45)))
 834             { /* yippee, unicode */
 835                 int i;
 836                 WORD ch;
 837                 for (i=0; i<LABEL_LEN;i++)
 838                 { /* Motorola -> Intel Unicode conversion :-\ */
 839                      ch = label_read[i];
 840                      label_read[i] = (ch << 8) | (ch >> 8);
 841                 }
 842                 strncpyW(label, label_read, 11);
 843                 label[11] = 0;
 844             }
 845             else
 846             {
 847                 MultiByteToWideChar(DOSDrives[drive].codepage, 0, (LPSTR)label_read, -1, label, 11);
 848                 label[11] = '\0';
 849             }
 850             return 1;
 851         }
 852     }
 853 failure:
 854     close(dev);
 855     ERR("error reading label !\n");
 856     return 0;
 857 }
 858
 859 /**************************************************************************
 860  *                              CDROM_GetLabel                  [internal]
 861  */
 862 static DWORD CDROM_GetLabel(int drive, WCHAR *label)
 863 {
 864     HANDLE              h = CDROM_Open(drive);
 865     CDROM_DISK_DATA     cdd;
 866     DWORD               br;
 867     DWORD               ret = 1;
 868
 869     if (!h || !DeviceIoControl(h, IOCTL_CDROM_DISK_TYPE, NULL, 0, &cdd, sizeof(cdd), &br, 0))
 870         return 0;
 871
 872     switch (cdd.DiskData & 0x03)
 873     {
 874     case CDROM_DISK_DATA_TRACK:
 875         if (!CDROM_Data_GetLabel(drive, label))
 876             ret = 0;
 877         break;
 878     case CDROM_DISK_AUDIO_TRACK:
 879     {
 880         static const WCHAR audioCD[] = {'A','u','d','i','o',' ','C','D',' ',' ',' ',0};
 881         strcpyW(label, audioCD);
 882         break;
 883     }
 884     case CDROM_DISK_DATA_TRACK|CDROM_DISK_AUDIO_TRACK:
 885         FIXME("Need to get the label of a mixed mode CD!\n");
 886         /* This assumes that the first track is a data track! */
 887         /* I guess the correct way would be to enumerate all data tracks
 888            and check each for the title */
 889         if (!CDROM_Data_GetLabel(drive, label))
 890             ret = 0;
 891         break;
 892     case 0:
 893         ret = 0;
 894         break;
 895     }
 896     TRACE("CD: label is %s\n", debugstr_w(label));
 897
 898     return ret;
 899 }
 900 /***********************************************************************
 901  *           DRIVE_GetLabel
 902  */
 903 LPCWSTR DRIVE_GetLabel( int drive )
 904 {
 905     int read = 0;
 906     char buff[DRIVE_SUPER];
 907     int offs = -1;
 908
 909     if (!DRIVE_IsValid( drive )) return NULL;
 910     if (DOSDrives[drive].type == DRIVE_CDROM)
 911     {
 912         read = CDROM_GetLabel(drive, DOSDrives[drive].label_read);
 913     }
 914     else
 915     if (DOSDrives[drive].flags & DRIVE_READ_VOL_INFO)
 916     {
 917         if (DRIVE_ReadSuperblock(drive,(char *) buff))
 918             ERR("Invalid or unreadable superblock on %s (%c:).\n",
 919                 DOSDrives[drive].device, (char)(drive+'A'));
 920         else {
 921             if (DOSDrives[drive].type == DRIVE_REMOVABLE ||
 922                 DOSDrives[drive].type == DRIVE_FIXED)
 923                 offs = 0x2b;
 924
 925             /* FIXME: ISO9660 uses a 32 bytes long label. Should we do also? */
 926             if (offs != -1)
 927                 MultiByteToWideChar(DOSDrives[drive].codepage, 0, buff+offs, 11,
 928                                     DOSDrives[drive].label_read, 11);
 929             DOSDrives[drive].label_read[11]='\0';
 930             read = 1;
 931         }
 932     }
 933
 934     return (read) ?
 935         DOSDrives[drive].label_read : DOSDrives[drive].label_conf;
 936 }
 937
 938 #define CDFRAMES_PERSEC                 75
 939 #define CDFRAMES_PERMIN                 (CDFRAMES_PERSEC * 60)
 940 #define FRAME_OF_ADDR(a) ((a)[0] * CDFRAMES_PERMIN + (a)[1] * CDFRAMES_PERSEC + (a)[2])
 941 #define FRAME_OF_TOC(toc, idx)  FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
 942
 943 /**************************************************************************
 944  *                              CDROM_Audio_GetSerial           [internal]
 945  */
 946 static DWORD CDROM_Audio_GetSerial(HANDLE h)
 947 {
 948     unsigned long serial = 0;
 949     int i;
 950     WORD wMagic;
 951     DWORD dwStart, dwEnd, br;
 952     CDROM_TOC toc;
 953
 954     if (!DeviceIoControl(h, IOCTL_CDROM_READ_TOC, NULL, 0, &toc, sizeof(toc), &br, 0))
 955         return 0;
 956
 957     /*
 958      * wMagic collects the wFrames from track 1
 959      * dwStart, dwEnd collect the beginning and end of the disc respectively, in
 960      * frames.
 961      * There it is collected for correcting the serial when there are less than
 962      * 3 tracks.
 963      */
 964     wMagic = toc.TrackData[0].Address[2];
 965     dwStart = FRAME_OF_TOC(toc, toc.FirstTrack);
 966
 967     for (i = 0; i <= toc.LastTrack - toc.FirstTrack; i++) {
 968         serial += (toc.TrackData[i].Address[0] << 16) |
 969             (toc.TrackData[i].Address[1] << 8) | toc.TrackData[i].Address[2];
 970     }
 971     dwEnd = FRAME_OF_TOC(toc, toc.LastTrack + 1);
 972
 973     if (toc.LastTrack - toc.FirstTrack + 1 < 3)
 974         serial += wMagic + (dwEnd - dwStart);
 975
 976     return serial;
 977 }
 978
 979 /**************************************************************************
 980  *                              CDROM_Data_GetSerial            [internal]
 981  */
 982 static DWORD CDROM_Data_GetSerial(int drive)
 983 {
 984     int dev = open(DOSDrives[drive].device, O_RDONLY|O_NONBLOCK);
 985     WORD offs;
 986     union {
 987         unsigned long val;
 988         unsigned char p[4];
 989     } serial;
 990     BYTE b0 = 0, b1 = 1, b2 = 2, b3 = 3;
 991
 992
 993     if (dev == -1) return 0;
 994     offs = CDROM_Data_FindBestVoldesc(dev);
 995
 996     serial.val = 0;
 997     if (offs)
 998     {
 999         BYTE buf[2048];
1000         OSVERSIONINFOA ovi;
1001         int i;
1002
1003         lseek(dev, offs, SEEK_SET);
1004         read(dev, buf, 2048);
1005         /*
1006          * OK, another braindead one... argh. Just believe it.
1007          * Me$$ysoft chose to reverse the serial number in NT4/W2K.
1008          * It's true and nobody will ever be able to change it.
1009          */
1010         ovi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
1011         GetVersionExA(&ovi);
1012         if ((ovi.dwPlatformId == VER_PLATFORM_WIN32_NT) &&  (ovi.dwMajorVersion >= 4))
1013         {
1014             b0 = 3; b1 = 2; b2 = 1; b3 = 0;
1015         }
1016         for (i = 0; i < 2048; i += 4)
1017         {
1018             /* DON'T optimize this into DWORD !! (breaks overflow) */
1019             serial.p[b0] += buf[i+b0];
1020             serial.p[b1] += buf[i+b1];
1021             serial.p[b2] += buf[i+b2];
1022             serial.p[b3] += buf[i+b3];
1023         }
1024     }
1025     close(dev);
1026     return serial.val;
1027 }
1028
1029 /**************************************************************************
1030  *                              CDROM_GetSerial                 [internal]
1031  */
1032 static DWORD CDROM_GetSerial(int drive)
1033 {
1034     DWORD               serial = 0;
1035     HANDLE              h = CDROM_Open(drive);
1036     CDROM_DISK_DATA     cdd;
1037     DWORD               br;
1038
1039     if (!h || ! !DeviceIoControl(h, IOCTL_CDROM_DISK_TYPE, NULL, 0, &cdd, sizeof(cdd), &br, 0))
1040         return 0;
1041
1042     switch (cdd.DiskData & 0x03)
1043     {
1044     case CDROM_DISK_DATA_TRACK:
1045         /* hopefully a data CD */
1046         serial = CDROM_Data_GetSerial(drive);
1047         break;
1048     case CDROM_DISK_AUDIO_TRACK:
1049         /* fall thru */
1050     case CDROM_DISK_DATA_TRACK|CDROM_DISK_AUDIO_TRACK:
1051         serial = CDROM_Audio_GetSerial(h);
1052         break;
1053     case 0:
1054         break;
1055     }
1056
1057     if (serial)
1058         TRACE("CD serial number is %04x-%04x.\n", HIWORD(serial), LOWORD(serial));
1059
1060     CloseHandle(h);
1061
1062     return serial;
1063 }
1064
1065 /***********************************************************************
1066  *           DRIVE_GetSerialNumber
1067  */
1068 DWORD DRIVE_GetSerialNumber( int drive )
1069 {
1070     DWORD serial = 0;
1071     char buff[DRIVE_SUPER];
1072
1073     TRACE("drive %d, type = %d\n", drive, DOSDrives[drive].type);
1074
1075     if (!DRIVE_IsValid( drive )) return 0;
1076
1077     if (DOSDrives[drive].flags & DRIVE_READ_VOL_INFO)
1078     {
1079         switch(DOSDrives[drive].type)
1080         {
1081         case DRIVE_REMOVABLE:
1082         case DRIVE_FIXED:
1083             if (DRIVE_ReadSuperblock(drive,(char *) buff))
1084                 MESSAGE("Invalid or unreadable superblock on %s (%c:)."
1085                         " Maybe not FAT?\n" ,
1086                         DOSDrives[drive].device, 'A'+drive);
1087             else
1088                 serial = *((DWORD*)(buff+0x27));
1089             break;
1090         case DRIVE_CDROM:
1091             serial = CDROM_GetSerial(drive);
1092             break;
1093         default:
1094             FIXME("Serial number reading from file system on drive %c: not supported yet.\n", drive+'A');
1095         }
1096     }
1097
1098     return (serial) ? serial : DOSDrives[drive].serial_conf;
1099 }
1100
1101
1102 /***********************************************************************
1103  *           DRIVE_SetSerialNumber
1104  */
1105 int DRIVE_SetSerialNumber( int drive, DWORD serial )
1106 {
1107     char buff[DRIVE_SUPER];
1108
1109     if (!DRIVE_IsValid( drive )) return 0;
1110
1111     if (DOSDrives[drive].flags & DRIVE_READ_VOL_INFO)
1112     {
1113         if ((DOSDrives[drive].type != DRIVE_REMOVABLE) &&
1114             (DOSDrives[drive].type != DRIVE_FIXED)) return 0;
1115         /* check, if the drive has a FAT filesystem */
1116         if (DRIVE_ReadSuperblock(drive, buff)) return 0;
1117         if (DRIVE_WriteSuperblockEntry(drive, 0x27, 4, (char *) &serial)) return 0;
1118         return 1;
1119     }
1120
1121     if (DOSDrives[drive].type == DRIVE_CDROM) return 0;
1122     DOSDrives[drive].serial_conf = serial;
1123     return 1;
1124 }
1125
1126
1127 /***********************************************************************
1128  *           DRIVE_GetType
1129  */
1130 static UINT DRIVE_GetType( int drive )
1131 {
1132     if (!DRIVE_IsValid( drive )) return DRIVE_NO_ROOT_DIR;
1133     return DOSDrives[drive].type;
1134 }
1135
1136
1137 /***********************************************************************
1138  *           DRIVE_GetFlags
1139  */
1140 UINT DRIVE_GetFlags( int drive )
1141 {
1142     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
1143     return DOSDrives[drive].flags;
1144 }
1145
1146 /***********************************************************************
1147  *           DRIVE_GetCodepage
1148  */
1149 UINT DRIVE_GetCodepage( int drive )
1150 {
1151     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
1152     return DOSDrives[drive].codepage;
1153 }
1154
1155
1156 /***********************************************************************
1157  *           DRIVE_Chdir
1158  */
1159 int DRIVE_Chdir( int drive, LPCWSTR path )
1160 {
1161     DOS_FULL_NAME full_name;
1162     WCHAR buffer[MAX_PATHNAME_LEN];
1163     LPSTR unix_cwd;
1164     BY_HANDLE_FILE_INFORMATION info;
1165     TDB *pTask = TASK_GetCurrent();
1166
1167     buffer[0] = 'A' + drive;
1168     buffer[1] = ':';
1169     buffer[2] = 0;
1170     TRACE("(%s,%s)\n", debugstr_w(buffer), debugstr_w(path) );
1171     strncpyW( buffer + 2, path, MAX_PATHNAME_LEN - 2 );
1172     buffer[MAX_PATHNAME_LEN - 1] = 0; /* ensure 0 termination */
1173
1174     if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
1175     if (!FILE_Stat( full_name.long_name, &info, NULL )) return 0;
1176     if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
1177     {
1178         SetLastError( ERROR_FILE_NOT_FOUND );
1179         return 0;
1180     }
1181     unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
1182     while (*unix_cwd == '/') unix_cwd++;
1183
1184     TRACE("(%c:): unix_cwd=%s dos_cwd=%s\n",
1185             'A' + drive, unix_cwd, debugstr_w(full_name.short_name + 3) );
1186
1187     HeapFree( GetProcessHeap(), 0, DOSDrives[drive].dos_cwd );
1188     HeapFree( GetProcessHeap(), 0, DOSDrives[drive].unix_cwd );
1189     DOSDrives[drive].dos_cwd  = HeapAlloc(GetProcessHeap(), 0, (strlenW(full_name.short_name) - 2) * sizeof(WCHAR));
1190     strcpyW(DOSDrives[drive].dos_cwd, full_name.short_name + 3);
1191     DOSDrives[drive].unix_cwd = heap_strdup( unix_cwd );
1192
1193     if (pTask && (pTask->curdrive & 0x80) &&
1194         ((pTask->curdrive & ~0x80) == drive))
1195     {
1196         WideCharToMultiByte(CP_ACP, 0, full_name.short_name + 2, -1,
1197                             pTask->curdir, sizeof(pTask->curdir), NULL, NULL);
1198         DRIVE_LastTask = GetCurrentTask();
1199     }
1200     return 1;
1201 }
1202
1203
1204 /***********************************************************************
1205  *           DRIVE_Disable
1206  */
1207 int DRIVE_Disable( int drive  )
1208 {
1209     if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
1210     {
1211         SetLastError( ERROR_INVALID_DRIVE );
1212         return 0;
1213     }
1214     DOSDrives[drive].flags |= DRIVE_DISABLED;
1215     return 1;
1216 }
1217
1218
1219 /***********************************************************************
1220  *           DRIVE_Enable
1221  */
1222 int DRIVE_Enable( int drive  )
1223 {
1224     if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
1225     {
1226         SetLastError( ERROR_INVALID_DRIVE );
1227         return 0;
1228     }
1229     DOSDrives[drive].flags &= ~DRIVE_DISABLED;
1230     return 1;
1231 }
1232
1233
1234 /***********************************************************************
1235  *           DRIVE_SetLogicalMapping
1236  */
1237 int DRIVE_SetLogicalMapping ( int existing_drive, int new_drive )
1238 {
1239  /* If new_drive is already valid, do nothing and return 0
1240     otherwise, copy DOSDrives[existing_drive] to DOSDrives[new_drive] */
1241
1242     DOSDRIVE *old, *new;
1243
1244     old = DOSDrives + existing_drive;
1245     new = DOSDrives + new_drive;
1246
1247     if ((existing_drive < 0) || (existing_drive >= MAX_DOS_DRIVES) ||
1248         !old->root ||
1249         (new_drive < 0) || (new_drive >= MAX_DOS_DRIVES))
1250     {
1251         SetLastError( ERROR_INVALID_DRIVE );
1252         return 0;
1253     }
1254
1255     if ( new->root )
1256     {
1257         TRACE("Can't map drive %c: to already existing drive %c:\n",
1258               'A' + existing_drive, 'A' + new_drive );
1259         /* it is already mapped there, so return success */
1260         if (!strcmp(old->root,new->root))
1261             return 1;
1262         return 0;
1263     }
1264
1265     new->root     = heap_strdup( old->root );
1266     new->dos_cwd  = HeapAlloc(GetProcessHeap(), 0, (strlenW(old->dos_cwd) + 1) * sizeof(WCHAR));
1267     strcpyW(new->dos_cwd, old->dos_cwd);
1268     new->unix_cwd = heap_strdup( old->unix_cwd );
1269     new->device   = heap_strdup( old->device );
1270     memcpy ( new->label_conf, old->label_conf, 12 );
1271     memcpy ( new->label_read, old->label_read, 12 );
1272     new->serial_conf = old->serial_conf;
1273     new->type = old->type;
1274     new->flags = old->flags;
1275     new->dev = old->dev;
1276     new->ino = old->ino;
1277
1278     TRACE("Drive %c: is now equal to drive %c:\n",
1279           'A' + new_drive, 'A' + existing_drive );
1280
1281     return 1;
1282 }
1283
1284
1285 /***********************************************************************
1286  *           DRIVE_OpenDevice
1287  *
1288  * Open the drive raw device and return a Unix fd (or -1 on error).
1289  */
1290 int DRIVE_OpenDevice( int drive, int flags )
1291 {
1292     if (!DRIVE_IsValid( drive )) return -1;
1293     return open( DOSDrives[drive].device, flags );
1294 }
1295
1296
1297 /***********************************************************************
1298  *           DRIVE_GetFreeSpace
1299  */
1300 static int DRIVE_GetFreeSpace( int drive, PULARGE_INTEGER size,
1301                                PULARGE_INTEGER available )
1302 {
1303     struct statfs info;
1304
1305     if (!DRIVE_IsValid(drive))
1306     {
1307         SetLastError( ERROR_PATH_NOT_FOUND );
1308         return 0;
1309     }
1310
1311 /* FIXME: add autoconf check for this */
1312 #if defined(__svr4__) || defined(_SCO_DS) || defined(__sun)
1313     if (statfs( DOSDrives[drive].root, &info, 0, 0) < 0)
1314 #else
1315     if (statfs( DOSDrives[drive].root, &info) < 0)
1316 #endif
1317     {
1318         FILE_SetDosError();
1319         WARN("cannot do statfs(%s)\n", DOSDrives[drive].root);
1320         return 0;
1321     }
1322
1323     size->QuadPart = RtlEnlargedUnsignedMultiply( info.f_bsize, info.f_blocks );
1324 #ifdef HAVE_STRUCT_STATFS_F_BAVAIL
1325     available->QuadPart = RtlEnlargedUnsignedMultiply( info.f_bavail, info.f_bsize );
1326 #else
1327 # ifdef HAVE_STRUCT_STATFS_F_BFREE
1328     available->QuadPart = RtlEnlargedUnsignedMultiply( info.f_bfree, info.f_bsize );
1329 # else
1330 #  error "statfs has no bfree/bavail member!"
1331 # endif
1332 #endif
1333     if (DOSDrives[drive].type == DRIVE_CDROM)
1334     { /* ALWAYS 0, even if no real CD-ROM mounted there !! */
1335         available->QuadPart = 0;
1336     }
1337     return 1;
1338 }
1339
1340 /***********************************************************************
1341  *       DRIVE_GetCurrentDirectory
1342  * Returns "X:\\path\\etc\\".
1343  *
1344  * Despite the API description, return required length including the
1345  * terminating null when buffer too small. This is the real behaviour.
1346 */
1347 static UINT DRIVE_GetCurrentDirectory( UINT buflen, LPWSTR buf )
1348 {
1349     UINT ret;
1350     LPCWSTR dos_cwd = DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
1351     static const WCHAR driveA_rootW[] = {'A',':','\\',0};
1352
1353     ret = strlenW(dos_cwd) + 3; /* length of WHOLE current directory */
1354     if (ret >= buflen) return ret + 1;
1355
1356     strcpyW( buf, driveA_rootW );
1357     buf[0] += DRIVE_GetCurrentDrive();
1358     strcatW( buf, dos_cwd );
1359     return ret;
1360 }
1361
1362
1363 /***********************************************************************
1364  *           DRIVE_BuildEnv
1365  *
1366  * Build the environment array containing the drives' current directories.
1367  * Resulting pointer must be freed with HeapFree.
1368  */
1369 char *DRIVE_BuildEnv(void)
1370 {
1371     int i, length = 0;
1372     LPCWSTR cwd[MAX_DOS_DRIVES];
1373     char *env, *p;
1374
1375     for (i = 0; i < MAX_DOS_DRIVES; i++)
1376     {
1377         if ((cwd[i] = DRIVE_GetDosCwd(i)) && cwd[i][0])
1378             length += WideCharToMultiByte(DRIVE_GetCodepage(i), 0,
1379                                           cwd[i], -1, NULL, 0, NULL, NULL) + 7;
1380     }
1381     if (!(env = HeapAlloc( GetProcessHeap(), 0, length+1 ))) return NULL;
1382     for (i = 0, p = env; i < MAX_DOS_DRIVES; i++)
1383     {
1384         if (cwd[i] && cwd[i][0])
1385         {
1386             *p++ = '='; *p++ = 'A' + i; *p++ = ':';
1387             *p++ = '='; *p++ = 'A' + i; *p++ = ':'; *p++ = '\\';
1388             WideCharToMultiByte(DRIVE_GetCodepage(i), 0, cwd[i], -1, p, 0x7fffffff, NULL, NULL);
1389             p += strlen(p) + 1;
1390         }
1391     }
1392     *p = 0;
1393     return env;
1394 }
1395
1396
1397 /***********************************************************************
1398  *           GetDiskFreeSpace   (KERNEL.422)
1399  */
1400 BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
1401                                   LPDWORD sector_bytes, LPDWORD free_clusters,
1402                                   LPDWORD total_clusters )
1403 {
1404     return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
1405                                 free_clusters, total_clusters );
1406 }
1407
1408
1409 /***********************************************************************
1410  *           GetDiskFreeSpaceW   (KERNEL32.@)
1411  *
1412  * Fails if expression resulting from current drive's dir and "root"
1413  * is not a root dir of the target drive.
1414  *
1415  * UNDOC: setting some LPDWORDs to NULL is perfectly possible
1416  * if the corresponding info is unneeded.
1417  *
1418  * FIXME: needs to support UNC names from Win95 OSR2 on.
1419  *
1420  * Behaviour under Win95a:
1421  * CurrDir     root   result
1422  * "E:\\TEST"  "E:"   FALSE
1423  * "E:\\"      "E:"   TRUE
1424  * "E:\\"      "E"    FALSE
1425  * "E:\\"      "\\"   TRUE
1426  * "E:\\TEST"  "\\"   TRUE
1427  * "E:\\TEST"  ":\\"  FALSE
1428  * "E:\\TEST"  "E:\\" TRUE
1429  * "E:\\TEST"  ""     FALSE
1430  * "E:\\"      ""     FALSE (!)
1431  * "E:\\"      0x0    TRUE
1432  * "E:\\TEST"  0x0    TRUE  (!)
1433  * "E:\\TEST"  "C:"   TRUE  (when CurrDir of "C:" set to "\\")
1434  * "E:\\TEST"  "C:"   FALSE (when CurrDir of "C:" set to "\\TEST")
1435  */
1436 BOOL WINAPI GetDiskFreeSpaceW( LPCWSTR root, LPDWORD cluster_sectors,
1437                                    LPDWORD sector_bytes, LPDWORD free_clusters,
1438                                    LPDWORD total_clusters )
1439 {
1440     int drive, sec_size;
1441     ULARGE_INTEGER size,available;
1442     LPCWSTR path;
1443     DWORD cluster_sec;
1444
1445     TRACE("%s,%p,%p,%p,%p\n", debugstr_w(root), cluster_sectors, sector_bytes,
1446           free_clusters, total_clusters);
1447
1448     if (!root || root[0] == '\\' || root[0] == '/')
1449         drive = DRIVE_GetCurrentDrive();
1450     else
1451     if (root[0] && root[1] == ':') /* root contains drive tag */
1452     {
1453         drive = toupperW(root[0]) - 'A';
1454         path = &root[2];
1455         if (path[0] == '\0')
1456         {
1457             path = DRIVE_GetDosCwd(drive);
1458             if (!path)
1459             {
1460                 SetLastError(ERROR_PATH_NOT_FOUND);
1461                 return FALSE;
1462             }
1463         }
1464         else
1465         if (path[0] == '\\')
1466             path++;
1467
1468         if (path[0]) /* oops, we are in a subdir */
1469         {
1470             SetLastError(ERROR_INVALID_NAME);
1471             return FALSE;
1472         }
1473     }
1474     else
1475     {
1476         if (!root[0])
1477             SetLastError(ERROR_PATH_NOT_FOUND);
1478         else
1479             SetLastError(ERROR_INVALID_NAME);
1480         return FALSE;
1481     }
1482
1483     if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
1484
1485     /* Cap the size and available at 2GB as per specs.  */
1486     if ((size.s.HighPart) ||(size.s.LowPart > 0x7fffffff))
1487     {
1488         size.s.HighPart = 0;
1489         size.s.LowPart = 0x7fffffff;
1490     }
1491     if ((available.s.HighPart) ||(available.s.LowPart > 0x7fffffff))
1492     {
1493         available.s.HighPart =0;
1494         available.s.LowPart = 0x7fffffff;
1495     }
1496     sec_size = (DRIVE_GetType(drive)==DRIVE_CDROM) ? 2048 : 512;
1497     size.s.LowPart            /= sec_size;
1498     available.s.LowPart       /= sec_size;
1499     /* FIXME: probably have to adjust those variables too for CDFS */
1500     cluster_sec = 1;
1501     while (cluster_sec * 65536 < size.s.LowPart) cluster_sec *= 2;
1502
1503     if (cluster_sectors)
1504         *cluster_sectors = cluster_sec;
1505     if (sector_bytes)
1506         *sector_bytes    = sec_size;
1507     if (free_clusters)
1508         *free_clusters   = available.s.LowPart / cluster_sec;
1509     if (total_clusters)
1510         *total_clusters  = size.s.LowPart / cluster_sec;
1511     return TRUE;
1512 }
1513
1514
1515 /***********************************************************************
1516  *           GetDiskFreeSpaceA   (KERNEL32.@)
1517  */
1518 BOOL WINAPI GetDiskFreeSpaceA( LPCSTR root, LPDWORD cluster_sectors,
1519                                    LPDWORD sector_bytes, LPDWORD free_clusters,
1520                                    LPDWORD total_clusters )
1521 {
1522     UNICODE_STRING rootW;
1523     BOOL ret = FALSE;
1524
1525     if (root)
1526     {
1527         if(!RtlCreateUnicodeStringFromAsciiz(&rootW, root))
1528         {
1529             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1530             return FALSE;
1531         }
1532     }
1533     else
1534         rootW.Buffer = NULL;
1535
1536     ret = GetDiskFreeSpaceW(rootW.Buffer, cluster_sectors, sector_bytes,
1537                             free_clusters, total_clusters );
1538     RtlFreeUnicodeString(&rootW);
1539
1540     return ret;
1541 }
1542
1543
1544 /***********************************************************************
1545  *           GetDiskFreeSpaceExW   (KERNEL32.@)
1546  *
1547  *  This function is used to acquire the size of the available and
1548  *  total space on a logical volume.
1549  *
1550  * RETURNS
1551  *
1552  *  Zero on failure, nonzero upon success. Use GetLastError to obtain
1553  *  detailed error information.
1554  *
1555  */
1556 BOOL WINAPI GetDiskFreeSpaceExW( LPCWSTR root,
1557                                      PULARGE_INTEGER avail,
1558                                      PULARGE_INTEGER total,
1559                                      PULARGE_INTEGER totalfree)
1560 {
1561     int drive;
1562     ULARGE_INTEGER size,available;
1563
1564     if (!root) drive = DRIVE_GetCurrentDrive();
1565     else
1566     { /* C: always works for GetDiskFreeSpaceEx */
1567         if ((root[1]) && ((root[1] != ':') || (root[2] && root[2] != '\\')))
1568         {
1569             FIXME("there are valid root names which are not supported yet\n");
1570             /* ..like UNC names, for instance. */
1571
1572             WARN("invalid root '%s'\n", debugstr_w(root));
1573             return FALSE;
1574         }
1575         drive = toupperW(root[0]) - 'A';
1576     }
1577
1578     if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
1579
1580     if (total)
1581     {
1582         total->s.HighPart = size.s.HighPart;
1583         total->s.LowPart = size.s.LowPart;
1584     }
1585
1586     if (totalfree)
1587     {
1588         totalfree->s.HighPart = available.s.HighPart;
1589         totalfree->s.LowPart = available.s.LowPart;
1590     }
1591
1592     if (avail)
1593     {
1594         if (FIXME_ON(dosfs))
1595         {
1596             /* On Windows2000, we need to check the disk quota
1597                allocated for the user owning the calling process. We
1598                don't want to be more obtrusive than necessary with the
1599                FIXME messages, so don't print the FIXME unless Wine is
1600                actually masquerading as Windows2000. */
1601
1602             OSVERSIONINFOA ovi;
1603             ovi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
1604             if (GetVersionExA(&ovi))
1605             {
1606               if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4)
1607                   FIXME("no per-user quota support yet\n");
1608             }
1609         }
1610
1611         /* Quick hack, should eventually be fixed to work 100% with
1612            Windows2000 (see comment above). */
1613         avail->s.HighPart = available.s.HighPart;
1614         avail->s.LowPart = available.s.LowPart;
1615     }
1616
1617     return TRUE;
1618 }
1619
1620 /***********************************************************************
1621  *           GetDiskFreeSpaceExA   (KERNEL32.@)
1622  */
1623 BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root, PULARGE_INTEGER avail,
1624                                      PULARGE_INTEGER total,
1625                                      PULARGE_INTEGER  totalfree)
1626 {
1627     UNICODE_STRING rootW;
1628     BOOL ret;
1629
1630     if (root) RtlCreateUnicodeStringFromAsciiz(&rootW, root);
1631     else rootW.Buffer = NULL;
1632
1633     ret = GetDiskFreeSpaceExW( rootW.Buffer, avail, total, totalfree);
1634
1635     RtlFreeUnicodeString(&rootW);
1636     return ret;
1637 }
1638
1639 /***********************************************************************
1640  *           GetDriveType   (KERNEL.136)
1641  * This function returns the type of a drive in Win16.
1642  * Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
1643  * remote drive API. The return value DRIVE_REMOTE for CD-ROMs has been
1644  * verified on Win 3.11 and Windows 95. Some programs rely on it, so don't
1645  * do any pseudo-clever changes.
1646  *
1647  * RETURNS
1648  *      drivetype DRIVE_xxx
1649  */
1650 UINT16 WINAPI GetDriveType16( UINT16 drive ) /* [in] number (NOT letter) of drive */
1651 {
1652     UINT type = DRIVE_GetType(drive);
1653     TRACE("(%c:)\n", 'A' + drive );
1654     if (type == DRIVE_CDROM) type = DRIVE_REMOTE;
1655     return type;
1656 }
1657
1658
1659 /***********************************************************************
1660  *           GetDriveTypeW   (KERNEL32.@)
1661  *
1662  * Returns the type of the disk drive specified. If root is NULL the
1663  * root of the current directory is used.
1664  *
1665  * RETURNS
1666  *
1667  *  Type of drive (from Win32 SDK):
1668  *
1669  *   DRIVE_UNKNOWN     unable to find out anything about the drive
1670  *   DRIVE_NO_ROOT_DIR nonexistent root dir
1671  *   DRIVE_REMOVABLE   the disk can be removed from the machine
1672  *   DRIVE_FIXED       the disk can not be removed from the machine
1673  *   DRIVE_REMOTE      network disk
1674  *   DRIVE_CDROM       CDROM drive
1675  *   DRIVE_RAMDISK     virtual disk in RAM
1676  */
1677 UINT WINAPI GetDriveTypeW(LPCWSTR root) /* [in] String describing drive */
1678 {
1679     int drive;
1680     TRACE("(%s)\n", debugstr_w(root));
1681
1682     if (NULL == root) drive = DRIVE_GetCurrentDrive();
1683     else
1684     {
1685         if ((root[1]) && (root[1] != ':'))
1686         {
1687             WARN("invalid root %s\n", debugstr_w(root));
1688             return DRIVE_NO_ROOT_DIR;
1689         }
1690         drive = toupperW(root[0]) - 'A';
1691     }
1692     return DRIVE_GetType(drive);
1693 }
1694
1695
1696 /***********************************************************************
1697  *           GetDriveTypeA   (KERNEL32.@)
1698  */
1699 UINT WINAPI GetDriveTypeA( LPCSTR root )
1700 {
1701     UNICODE_STRING rootW;
1702     UINT ret = 0;
1703
1704     if (root)
1705     {
1706         if( !RtlCreateUnicodeStringFromAsciiz(&rootW, root))
1707         {
1708             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1709             return 0;
1710         }
1711     }
1712     else
1713         rootW.Buffer = NULL;
1714
1715     ret = GetDriveTypeW(rootW.Buffer);
1716
1717     RtlFreeUnicodeString(&rootW);
1718     return ret;
1719
1720 }
1721
1722
1723 /***********************************************************************
1724  *           GetCurrentDirectory   (KERNEL.411)
1725  */
1726 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
1727 {
1728     WCHAR cur_dirW[MAX_PATH];
1729
1730     DRIVE_GetCurrentDirectory(MAX_PATH, cur_dirW);
1731     return (UINT16)WideCharToMultiByte(CP_ACP, 0, cur_dirW, -1, buf, buflen, NULL, NULL);
1732 }
1733
1734
1735 /***********************************************************************
1736  *           GetCurrentDirectoryW   (KERNEL32.@)
1737  */
1738 UINT WINAPI GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
1739 {
1740     UINT ret;
1741     WCHAR longname[MAX_PATHNAME_LEN];
1742     WCHAR shortname[MAX_PATHNAME_LEN];
1743
1744     ret = DRIVE_GetCurrentDirectory(MAX_PATHNAME_LEN, shortname);
1745     if ( ret > MAX_PATHNAME_LEN ) {
1746       ERR_(file)("pathnamelength (%d) > MAX_PATHNAME_LEN!\n", ret );
1747       return ret;
1748     }
1749     GetLongPathNameW(shortname, longname, MAX_PATHNAME_LEN);
1750     ret = strlenW( longname ) + 1;
1751     if (ret > buflen) return ret;
1752     strcpyW(buf, longname);
1753     return ret - 1;
1754 }
1755
1756 /***********************************************************************
1757  *           GetCurrentDirectoryA   (KERNEL32.@)
1758  */
1759 UINT WINAPI GetCurrentDirectoryA( UINT buflen, LPSTR buf )
1760 {
1761     WCHAR bufferW[MAX_PATH];
1762     DWORD ret, retW;
1763
1764     retW = GetCurrentDirectoryW(MAX_PATH, bufferW);
1765
1766     if (!retW)
1767         ret = 0;
1768     else if (retW > MAX_PATH)
1769     {
1770         SetLastError(ERROR_FILENAME_EXCED_RANGE);
1771         ret = 0;
1772     }
1773     else
1774     {
1775         ret = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1776         if (buflen >= ret)
1777         {
1778             WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buf, buflen, NULL, NULL);
1779             ret--; /* length without 0 */
1780         }
1781     }
1782     return ret;
1783 }
1784
1785
1786 /***********************************************************************
1787  *           SetCurrentDirectory   (KERNEL.412)
1788  */
1789 BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
1790 {
1791     return SetCurrentDirectoryA( dir );
1792 }
1793
1794
1795 /***********************************************************************
1796  *           SetCurrentDirectoryW   (KERNEL32.@)
1797  */
1798 BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dir )
1799 {
1800     int drive, olddrive = DRIVE_GetCurrentDrive();
1801
1802     if (!dir)
1803     {
1804         SetLastError(ERROR_INVALID_PARAMETER);
1805         return FALSE;
1806     }
1807     if (dir[0] && (dir[1]==':'))
1808     {
1809         drive = toupperW( *dir ) - 'A';
1810         dir += 2;
1811     }
1812     else
1813         drive = olddrive;
1814
1815     /* WARNING: we need to set the drive before the dir, as DRIVE_Chdir
1816        sets pTask->curdir only if pTask->curdrive is drive */
1817     if (!(DRIVE_SetCurrentDrive( drive )))
1818         return FALSE;
1819
1820     /* FIXME: what about empty strings? Add a \\ ? */
1821     if (!DRIVE_Chdir( drive, dir )) {
1822         DRIVE_SetCurrentDrive(olddrive);
1823         return FALSE;
1824     }
1825     return TRUE;
1826 }
1827
1828
1829 /***********************************************************************
1830  *           SetCurrentDirectoryA   (KERNEL32.@)
1831  */
1832 BOOL WINAPI SetCurrentDirectoryA( LPCSTR dir )
1833 {
1834     UNICODE_STRING dirW;
1835     BOOL ret = FALSE;
1836
1837     if (!dir)
1838     {
1839         SetLastError(ERROR_INVALID_PARAMETER);
1840         return FALSE;
1841     }
1842
1843     if (RtlCreateUnicodeStringFromAsciiz(&dirW, dir))
1844     {
1845         ret = SetCurrentDirectoryW(dirW.Buffer);
1846         RtlFreeUnicodeString(&dirW);
1847     }
1848     else
1849         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1850     return ret;
1851 }
1852
1853
1854 /***********************************************************************
1855  *           GetLogicalDriveStringsA   (KERNEL32.@)
1856  */
1857 UINT WINAPI GetLogicalDriveStringsA( UINT len, LPSTR buffer )
1858 {
1859     int drive, count;
1860
1861     for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
1862         if (DRIVE_IsValid(drive)) count++;
1863     if ((count * 4) + 1 <= len)
1864     {
1865         LPSTR p = buffer;
1866         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
1867             if (DRIVE_IsValid(drive))
1868             {
1869                 *p++ = 'a' + drive;
1870                 *p++ = ':';
1871                 *p++ = '\\';
1872                 *p++ = '\0';
1873             }
1874         *p = '\0';
1875         return count * 4;
1876     }
1877     else
1878         return (count * 4) + 1; /* account for terminating null */
1879     /* The API tells about these different return values */
1880 }
1881
1882
1883 /***********************************************************************
1884  *           GetLogicalDriveStringsW   (KERNEL32.@)
1885  */
1886 UINT WINAPI GetLogicalDriveStringsW( UINT len, LPWSTR buffer )
1887 {
1888     int drive, count;
1889
1890     for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
1891         if (DRIVE_IsValid(drive)) count++;
1892     if (count * 4 * sizeof(WCHAR) <= len)
1893     {
1894         LPWSTR p = buffer;
1895         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
1896             if (DRIVE_IsValid(drive))
1897             {
1898                 *p++ = (WCHAR)('a' + drive);
1899                 *p++ = (WCHAR)':';
1900                 *p++ = (WCHAR)'\\';
1901                 *p++ = (WCHAR)'\0';
1902             }
1903         *p = (WCHAR)'\0';
1904     }
1905     return count * 4 * sizeof(WCHAR);
1906 }
1907
1908
1909 /***********************************************************************
1910  *           GetLogicalDrives   (KERNEL32.@)
1911  */
1912 DWORD WINAPI GetLogicalDrives(void)
1913 {
1914     DWORD ret = 0;
1915     int drive;
1916
1917     for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
1918     {
1919         if ( (DRIVE_IsValid(drive)) ||
1920             (DOSDrives[drive].type == DRIVE_CDROM)) /* audio CD is also valid */
1921             ret |= (1 << drive);
1922     }
1923     return ret;
1924 }
1925
1926
1927 /***********************************************************************
1928  *           GetVolumeInformationW   (KERNEL32.@)
1929  */
1930 BOOL WINAPI GetVolumeInformationW( LPCWSTR root, LPWSTR label,
1931                                        DWORD label_len, DWORD *serial,
1932                                        DWORD *filename_len, DWORD *flags,
1933                                        LPWSTR fsname, DWORD fsname_len )
1934 {
1935     int drive;
1936     LPWSTR cp;
1937
1938     /* FIXME, SetLastError()s missing */
1939
1940     if (!root) drive = DRIVE_GetCurrentDrive();
1941     else
1942     {
1943         if (root[0] && root[1] != ':')
1944         {
1945             WARN("invalid root %s\n", debugstr_w(root));
1946             return FALSE;
1947         }
1948         drive = toupperW(root[0]) - 'A';
1949     }
1950     if (!DRIVE_IsValid( drive )) return FALSE;
1951     if (label && label_len)
1952     {
1953        strncpyW( label, DRIVE_GetLabel(drive), label_len );
1954        label[label_len - 1] = 0; /* ensure 0 termination */
1955        cp = label + strlenW(label);
1956        while (cp != label && *(cp-1) == ' ') cp--;
1957        *cp = '\0';
1958     }
1959     if (serial) *serial = DRIVE_GetSerialNumber(drive);
1960
1961     /* Set the filesystem information */
1962     /* Note: we only emulate a FAT fs at present */
1963
1964     if (filename_len) {
1965         if (DOSDrives[drive].flags & DRIVE_SHORT_NAMES)
1966             *filename_len = 12;
1967         else
1968             *filename_len = 255;
1969     }
1970     if (flags)
1971       {
1972        *flags=0;
1973        if (DOSDrives[drive].flags & DRIVE_CASE_SENSITIVE)
1974          *flags|=FS_CASE_SENSITIVE;
1975        if (DOSDrives[drive].flags & DRIVE_CASE_PRESERVING)
1976          *flags|=FS_CASE_IS_PRESERVED;
1977       }
1978     if (fsname && fsname_len)
1979     {
1980         /* Diablo checks that return code ... */
1981         if (DOSDrives[drive].type == DRIVE_CDROM)
1982         {
1983             static const WCHAR cdfsW[] = {'C','D','F','S',0};
1984             strncpyW( fsname, cdfsW, fsname_len );
1985         }
1986         else
1987         {
1988             static const WCHAR fatW[] = {'F','A','T',0};
1989             strncpyW( fsname, fatW, fsname_len );
1990         }
1991         fsname[fsname_len - 1] = 0; /* ensure 0 termination */
1992     }
1993     return TRUE;
1994 }
1995
1996
1997 /***********************************************************************
1998  *           GetVolumeInformationA   (KERNEL32.@)
1999  */
2000 BOOL WINAPI GetVolumeInformationA( LPCSTR root, LPSTR label,
2001                                        DWORD label_len, DWORD *serial,
2002                                        DWORD *filename_len, DWORD *flags,
2003                                        LPSTR fsname, DWORD fsname_len )
2004 {
2005     UNICODE_STRING rootW;
2006     LPWSTR labelW, fsnameW;
2007     BOOL ret;
2008
2009     if (root) RtlCreateUnicodeStringFromAsciiz(&rootW, root);
2010     else rootW.Buffer = NULL;
2011     labelW = label ? HeapAlloc(GetProcessHeap(), 0, label_len * sizeof(WCHAR)) : NULL;
2012     fsnameW = fsname ? HeapAlloc(GetProcessHeap(), 0, fsname_len * sizeof(WCHAR)) : NULL;
2013
2014     if ((ret = GetVolumeInformationW(rootW.Buffer, labelW, label_len, serial,
2015                                     filename_len, flags, fsnameW, fsname_len)))
2016     {
2017         if (label) WideCharToMultiByte(CP_ACP, 0, labelW, -1, label, label_len, NULL, NULL);
2018         if (fsname) WideCharToMultiByte(CP_ACP, 0, fsnameW, -1, fsname, fsname_len, NULL, NULL);
2019     }
2020
2021     RtlFreeUnicodeString(&rootW);
2022     if (labelW) HeapFree( GetProcessHeap(), 0, labelW );
2023     if (fsnameW) HeapFree( GetProcessHeap(), 0, fsnameW );
2024     return ret;
2025 }
2026
2027 /***********************************************************************
2028  *           SetVolumeLabelW   (KERNEL32.@)
2029  */
2030 BOOL WINAPI SetVolumeLabelW( LPCWSTR root, LPCWSTR volname )
2031 {
2032     int drive;
2033
2034     /* FIXME, SetLastErrors missing */
2035
2036     if (!root) drive = DRIVE_GetCurrentDrive();
2037     else
2038     {
2039         if ((root[1]) && (root[1] != ':'))
2040         {
2041             WARN("invalid root %s\n", debugstr_w(root));
2042             return FALSE;
2043         }
2044         drive = toupperW(root[0]) - 'A';
2045     }
2046     if (!DRIVE_IsValid( drive )) return FALSE;
2047
2048     /* some copy protection stuff check this */
2049     if (DOSDrives[drive].type == DRIVE_CDROM) return FALSE;
2050
2051     strncpyW(DOSDrives[drive].label_conf, volname, 12);
2052     DOSDrives[drive].label_conf[12 - 1] = 0; /* ensure 0 termination */
2053     return TRUE;
2054 }
2055
2056 /***********************************************************************
2057  *           SetVolumeLabelA   (KERNEL32.@)
2058  */
2059 BOOL WINAPI SetVolumeLabelA(LPCSTR root, LPCSTR volname)
2060 {
2061     UNICODE_STRING rootW, volnameW;
2062     BOOL ret;
2063
2064     if (root) RtlCreateUnicodeStringFromAsciiz(&rootW, root);
2065     else rootW.Buffer = NULL;
2066     if (volname) RtlCreateUnicodeStringFromAsciiz(&volnameW, volname);
2067     else volnameW.Buffer = NULL;
2068
2069     ret = SetVolumeLabelW( rootW.Buffer, volnameW.Buffer );
2070
2071     RtlFreeUnicodeString(&rootW);
2072     RtlFreeUnicodeString(&volnameW);
2073     return ret;
2074 }
2075
2076 /***********************************************************************
2077  *           GetVolumeNameForVolumeMountPointW   (KERNEL32.@)
2078  */
2079 DWORD WINAPI GetVolumeNameForVolumeMountPointW(LPWSTR str, DWORD a, DWORD b)
2080 {
2081     FIXME("(%s, %lx, %lx): stub\n", debugstr_w(str), a, b);
2082     return 0;
2083 }