files/drive.c

   1 /*
   2  * DOS drives handling functions
   3  *
   4  * Copyright 1993 Erik Bos
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include "config.h"
   9
  10 #include <assert.h>
  11 #include <ctype.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18
  19 #ifdef HAVE_SYS_VFS_H
  20 # include <sys/vfs.h>
  21 #endif
  22 #ifdef HAVE_SYS_PARAM_H
  23 # include <sys/param.h>
  24 #endif
  25 #ifdef HAVE_SYS_MOUNT_H
  26 # include <sys/mount.h>
  27 #endif
  28 #ifdef HAVE_SYS_STATFS_H
  29 # include <sys/statfs.h>
  30 #endif
  31
  32 #include "windows.h"
  33 #include "winbase.h"
  34 #include "drive.h"
  35 #include "file.h"
  36 #include "heap.h"
  37 #include "msdos.h"
  38 #include "options.h"
  39 #include "task.h"
  40 #include "debug.h"
  41
  42 typedef struct
  43 {
  44     char     *root;      /* root dir in Unix format without trailing / */
  45     char     *dos_cwd;   /* cwd in DOS format without leading or trailing \ */
  46     char     *unix_cwd;  /* cwd in Unix format without leading or trailing / */
  47     char     *device;    /* raw device path */
  48     char      label[12]; /* drive label */
  49     DWORD     serial;    /* drive serial number */
  50     DRIVETYPE type;      /* drive type */
  51     UINT32    flags;     /* drive flags */
  52     dev_t     dev;       /* unix device number */
  53     ino_t     ino;       /* unix inode number */
  54 } DOSDRIVE;
  55
  56
  57 static const char * const DRIVE_Types[] =
  58 {
  59     "floppy",   /* TYPE_FLOPPY */
  60     "hd",       /* TYPE_HD */
  61     "cdrom",    /* TYPE_CDROM */
  62     "network"   /* TYPE_NETWORK */
  63 };
  64
  65
  66 /* Known filesystem types */
  67
  68 typedef struct
  69 {
  70     const char *name;
  71     UINT32      flags;
  72 } FS_DESCR;
  73
  74 static const FS_DESCR DRIVE_Filesystems[] =
  75 {
  76     { "unix",   DRIVE_CASE_SENSITIVE | DRIVE_CASE_PRESERVING },
  77     { "msdos",  DRIVE_SHORT_NAMES },
  78     { "dos",    DRIVE_SHORT_NAMES },
  79     { "fat",    DRIVE_SHORT_NAMES },
  80     { "vfat",   DRIVE_CASE_PRESERVING },
  81     { "win95",  DRIVE_CASE_PRESERVING },
  82     { NULL, 0 }
  83 };
  84
  85
  86 static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
  87 static int DRIVE_CurDrive = -1;
  88
  89 static HTASK16 DRIVE_LastTask = 0;
  90
  91
  92 /***********************************************************************
  93  *           DRIVE_GetDriveType
  94  */
  95 static DRIVETYPE DRIVE_GetDriveType( const char *name )
  96 {
  97     char buffer[20];
  98     int i;
  99
 100     PROFILE_GetWineIniString( name, "Type", "hd", buffer, sizeof(buffer) );
 101     for (i = 0; i < sizeof(DRIVE_Types)/sizeof(DRIVE_Types[0]); i++)
 102     {
 103         if (!lstrcmpi32A( buffer, DRIVE_Types[i] )) return (DRIVETYPE)i;
 104     }
 105     MSG("%s: unknown type '%s', defaulting to 'hd'.\n", name, buffer );
 106     return TYPE_HD;
 107 }
 108
 109
 110 /***********************************************************************
 111  *           DRIVE_GetFSFlags
 112  */
 113 static UINT32 DRIVE_GetFSFlags( const char *name, const char *value )
 114 {
 115     const FS_DESCR *descr;
 116
 117     for (descr = DRIVE_Filesystems; descr->name; descr++)
 118         if (!lstrcmpi32A( value, descr->name )) return descr->flags;
 119     MSG("%s: unknown filesystem type '%s', defaulting to 'unix'.\n",
 120         name, value );
 121     return DRIVE_CASE_SENSITIVE | DRIVE_CASE_PRESERVING;
 122 }
 123
 124
 125 /***********************************************************************
 126  *           DRIVE_Init
 127  */
 128 int DRIVE_Init(void)
 129 {
 130     int i, len, count = 0;
 131     char name[] = "Drive A";
 132     char path[MAX_PATHNAME_LEN];
 133     char buffer[80];
 134     struct stat drive_stat_buffer;
 135     char *p;
 136     DOSDRIVE *drive;
 137
 138     for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, name[6]++, drive++)
 139     {
 140         PROFILE_GetWineIniString( name, "Path", "", path, sizeof(path)-1 );
 141         if (path[0])
 142         {
 143             p = path + strlen(path) - 1;
 144             while ((p > path) && ((*p == '/') || (*p == '\\'))) *p-- = '\0';
 145             if (!path[0]) strcpy( path, "/" );
 146
 147             if (stat( path, &drive_stat_buffer ))
 148             {
 149                 MSG("Could not stat %s, ignoring drive %c:\n", path, 'A' + i );
 150                 continue;
 151             }
 152             if (!S_ISDIR(drive_stat_buffer.st_mode))
 153             {
 154                 MSG("%s is not a directory, ignoring drive %c:\n",
 155                     path, 'A' + i );
 156                 continue;
 157             }
 158
 159             drive->root = HEAP_strdupA( SystemHeap, 0, path );
 160             drive->dos_cwd  = HEAP_strdupA( SystemHeap, 0, "" );
 161             drive->unix_cwd = HEAP_strdupA( SystemHeap, 0, "" );
 162             drive->type     = DRIVE_GetDriveType( name );
 163             drive->device   = NULL;
 164             drive->flags    = 0;
 165             drive->dev      = drive_stat_buffer.st_dev;
 166             drive->ino      = drive_stat_buffer.st_ino;
 167
 168             /* Get the drive label */
 169             PROFILE_GetWineIniString( name, "Label", name, drive->label, 12 );
 170             if ((len = strlen(drive->label)) < 11)
 171             {
 172                 /* Pad label with spaces */
 173                 memset( drive->label + len, ' ', 11 - len );
 174                 drive->label[12] = '\0';
 175             }
 176
 177             /* Get the serial number */
 178             PROFILE_GetWineIniString( name, "Serial", "12345678",
 179                                       buffer, sizeof(buffer) );
 180             drive->serial = strtoul( buffer, NULL, 16 );
 181
 182             /* Get the filesystem type */
 183             PROFILE_GetWineIniString( name, "Filesystem", "unix",
 184                                       buffer, sizeof(buffer) );
 185             drive->flags = DRIVE_GetFSFlags( name, buffer );
 186
 187             /* Get the device */
 188             PROFILE_GetWineIniString( name, "Device", "",
 189                                       buffer, sizeof(buffer) );
 190             if (buffer[0])
 191                 drive->device = HEAP_strdupA( SystemHeap, 0, buffer );
 192
 193             /* Make the first hard disk the current drive */
 194             if ((DRIVE_CurDrive == -1) && (drive->type == TYPE_HD))
 195                 DRIVE_CurDrive = i;
 196
 197             count++;
 198             TRACE(dosfs, "%s: path=%s type=%s label='%s' serial=%08lx flags=%08x dev=%x ino=%x\n",
 199                            name, path, DRIVE_Types[drive->type],
 200                            drive->label, drive->serial, drive->flags,
 201                            (int)drive->dev, (int)drive->ino );
 202         }
 203         else WARN(dosfs, "%s: not defined\n", name );
 204     }
 205
 206     if (!count)
 207     {
 208         MSG("Warning: no valid DOS drive found, check your configuration file.\n" );
 209         /* Create a C drive pointing to Unix root dir */
 210         DOSDrives[2].root     = HEAP_strdupA( SystemHeap, 0, "/" );
 211         DOSDrives[2].dos_cwd  = HEAP_strdupA( SystemHeap, 0, "" );
 212         DOSDrives[2].unix_cwd = HEAP_strdupA( SystemHeap, 0, "" );
 213         strcpy( DOSDrives[2].label, "Drive C    " );
 214         DOSDrives[2].serial   = 0x12345678;
 215         DOSDrives[2].type     = TYPE_HD;
 216         DOSDrives[2].flags    = 0;
 217         DRIVE_CurDrive = 2;
 218     }
 219
 220     /* Make sure the current drive is valid */
 221     if (DRIVE_CurDrive == -1)
 222     {
 223         for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
 224         {
 225             if (drive->root && !(drive->flags & DRIVE_DISABLED))
 226             {
 227                 DRIVE_CurDrive = i;
 228                 break;
 229             }
 230         }
 231     }
 232
 233     return 1;
 234 }
 235
 236
 237 /***********************************************************************
 238  *           DRIVE_IsValid
 239  */
 240 int DRIVE_IsValid( int drive )
 241 {
 242     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
 243     return (DOSDrives[drive].root &&
 244             !(DOSDrives[drive].flags & DRIVE_DISABLED));
 245 }
 246
 247
 248 /***********************************************************************
 249  *           DRIVE_GetCurrentDrive
 250  */
 251 int DRIVE_GetCurrentDrive(void)
 252 {
 253     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 254     if (pTask && (pTask->curdrive & 0x80)) return pTask->curdrive & ~0x80;
 255     return DRIVE_CurDrive;
 256 }
 257
 258
 259 /***********************************************************************
 260  *           DRIVE_SetCurrentDrive
 261  */
 262 int DRIVE_SetCurrentDrive( int drive )
 263 {
 264     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 265     if (!DRIVE_IsValid( drive ))
 266     {
 267         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 268         return 0;
 269     }
 270     TRACE(dosfs, "%c:\n", 'A' + drive );
 271     DRIVE_CurDrive = drive;
 272     if (pTask) pTask->curdrive = drive | 0x80;
 273     return 1;
 274 }
 275
 276
 277 /***********************************************************************
 278  *           DRIVE_FindDriveRoot
 279  *
 280  * Find a drive for which the root matches the begginning of the given path.
 281  * This can be used to translate a Unix path into a drive + DOS path.
 282  * Return value is the drive, or -1 on error. On success, path is modified
 283  * to point to the beginning of the DOS path.
 284  */
 285 int DRIVE_FindDriveRoot( const char **path )
 286 {
 287     /* idea: check at all '/' positions.
 288      * If the device and inode of that path is identical with the
 289      * device and inode of the current drive then we found a solution.
 290      * If there is another drive pointing to a deeper position in
 291      * the file tree, we want to find that one, not the earlier solution.
 292      */
 293     int drive, rootdrive = -1;
 294     char buffer[MAX_PATHNAME_LEN];
 295     char *next = buffer;
 296     const char *p = *path;
 297     struct stat st;
 298
 299     strcpy( buffer, "/" );
 300     for (;;)
 301     {
 302         if (stat( buffer, &st ) || !S_ISDIR( st.st_mode )) break;
 303
 304         /* Find the drive */
 305
 306         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 307         {
 308            if (!DOSDrives[drive].root ||
 309                (DOSDrives[drive].flags & DRIVE_DISABLED)) continue;
 310
 311            if ((DOSDrives[drive].dev == st.st_dev) &&
 312                (DOSDrives[drive].ino == st.st_ino))
 313            {
 314                rootdrive = drive;
 315                *path = p;
 316            }
 317         }
 318
 319         /* Get the next path component */
 320
 321         *next++ = '/';
 322         while ((*p == '/') || (*p == '\\')) p++;
 323         if (!*p) break;
 324         while (!IS_END_OF_NAME(*p)) *next++ = *p++;
 325         *next = 0;
 326     }
 327     *next = 0;
 328
 329     if (rootdrive != -1)
 330         TRACE(dosfs, "%s -> drive %c:, root='%s', name='%s'\n",
 331                        buffer, 'A' + rootdrive,
 332                        DOSDrives[rootdrive].root, *path );
 333     return rootdrive;
 334 }
 335
 336
 337 /***********************************************************************
 338  *           DRIVE_GetRoot
 339  */
 340 const char * DRIVE_GetRoot( int drive )
 341 {
 342     if (!DRIVE_IsValid( drive )) return NULL;
 343     return DOSDrives[drive].root;
 344 }
 345
 346
 347 /***********************************************************************
 348  *           DRIVE_GetDosCwd
 349  */
 350 const char * DRIVE_GetDosCwd( int drive )
 351 {
 352     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 353     if (!DRIVE_IsValid( drive )) return NULL;
 354
 355     /* Check if we need to change the directory to the new task. */
 356     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 357         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 358         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 359     {
 360         /* Perform the task-switch */
 361         if (!DRIVE_Chdir( drive, pTask->curdir )) DRIVE_Chdir( drive, "\\" );
 362         DRIVE_LastTask = GetCurrentTask();
 363     }
 364     return DOSDrives[drive].dos_cwd;
 365 }
 366
 367
 368 /***********************************************************************
 369  *           DRIVE_GetUnixCwd
 370  */
 371 const char * DRIVE_GetUnixCwd( int drive )
 372 {
 373     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 374     if (!DRIVE_IsValid( drive )) return NULL;
 375
 376     /* Check if we need to change the directory to the new task. */
 377     if (pTask && (pTask->curdrive & 0x80) &&    /* The task drive is valid */
 378         ((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
 379         (DRIVE_LastTask != GetCurrentTask()))   /* and the task changed */
 380     {
 381         /* Perform the task-switch */
 382         if (!DRIVE_Chdir( drive, pTask->curdir )) DRIVE_Chdir( drive, "\\" );
 383         DRIVE_LastTask = GetCurrentTask();
 384     }
 385     return DOSDrives[drive].unix_cwd;
 386 }
 387
 388
 389 /***********************************************************************
 390  *           DRIVE_GetLabel
 391  */
 392 const char * DRIVE_GetLabel( int drive )
 393 {
 394     if (!DRIVE_IsValid( drive )) return NULL;
 395     return DOSDrives[drive].label;
 396 }
 397
 398
 399 /***********************************************************************
 400  *           DRIVE_GetSerialNumber
 401  */
 402 DWORD DRIVE_GetSerialNumber( int drive )
 403 {
 404     if (!DRIVE_IsValid( drive )) return 0;
 405     return DOSDrives[drive].serial;
 406 }
 407
 408
 409 /***********************************************************************
 410  *           DRIVE_SetSerialNumber
 411  */
 412 int DRIVE_SetSerialNumber( int drive, DWORD serial )
 413 {
 414     if (!DRIVE_IsValid( drive )) return 0;
 415     DOSDrives[drive].serial = serial;
 416     return 1;
 417 }
 418
 419
 420 /***********************************************************************
 421  *           DRIVE_GetType
 422  */
 423 DRIVETYPE DRIVE_GetType( int drive )
 424 {
 425     if (!DRIVE_IsValid( drive )) return TYPE_INVALID;
 426     return DOSDrives[drive].type;
 427 }
 428
 429
 430 /***********************************************************************
 431  *           DRIVE_GetFlags
 432  */
 433 UINT32 DRIVE_GetFlags( int drive )
 434 {
 435     if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
 436     return DOSDrives[drive].flags;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           DRIVE_Chdir
 442  */
 443 int DRIVE_Chdir( int drive, const char *path )
 444 {
 445     DOS_FULL_NAME full_name;
 446     char buffer[MAX_PATHNAME_LEN];
 447     LPSTR unix_cwd;
 448     BY_HANDLE_FILE_INFORMATION info;
 449     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 450
 451     TRACE(dosfs, "(%c:,%s)\n", 'A' + drive, path );
 452     strcpy( buffer, "A:" );
 453     buffer[0] += drive;
 454     lstrcpyn32A( buffer + 2, path, sizeof(buffer) - 2 );
 455
 456     if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
 457     if (!FILE_Stat( full_name.long_name, &info )) return 0;
 458     if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
 459     {
 460         DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk );
 461         return 0;
 462     }
 463     unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
 464     while (*unix_cwd == '/') unix_cwd++;
 465
 466     TRACE(dosfs, "(%c:): unix_cwd=%s dos_cwd=%s\n",
 467                    'A' + drive, unix_cwd, full_name.short_name + 3 );
 468
 469     HeapFree( SystemHeap, 0, DOSDrives[drive].dos_cwd );
 470     HeapFree( SystemHeap, 0, DOSDrives[drive].unix_cwd );
 471     DOSDrives[drive].dos_cwd  = HEAP_strdupA( SystemHeap, 0,
 472                                               full_name.short_name + 3 );
 473     DOSDrives[drive].unix_cwd = HEAP_strdupA( SystemHeap, 0, unix_cwd );
 474
 475     if (pTask && (pTask->curdrive & 0x80) &&
 476         ((pTask->curdrive & ~0x80) == drive))
 477     {
 478         lstrcpyn32A( pTask->curdir, full_name.short_name + 2,
 479                      sizeof(pTask->curdir) );
 480         DRIVE_LastTask = GetCurrentTask();
 481     }
 482     return 1;
 483 }
 484
 485
 486 /***********************************************************************
 487  *           DRIVE_Disable
 488  */
 489 int DRIVE_Disable( int drive  )
 490 {
 491     if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
 492     {
 493         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 494         return 0;
 495     }
 496     DOSDrives[drive].flags |= DRIVE_DISABLED;
 497     return 1;
 498 }
 499
 500
 501 /***********************************************************************
 502  *           DRIVE_Enable
 503  */
 504 int DRIVE_Enable( int drive  )
 505 {
 506     if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
 507     {
 508         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 509         return 0;
 510     }
 511     DOSDrives[drive].flags &= ~DRIVE_DISABLED;
 512     return 1;
 513 }
 514
 515
 516 /***********************************************************************
 517  *           DRIVE_SetLogicalMapping
 518  */
 519 int DRIVE_SetLogicalMapping ( int existing_drive, int new_drive )
 520 {
 521  /* If new_drive is already valid, do nothing and return 0
 522     otherwise, copy DOSDrives[existing_drive] to DOSDrives[new_drive] */
 523
 524     DOSDRIVE *old, *new;
 525
 526     old = DOSDrives + existing_drive;
 527     new = DOSDrives + new_drive;
 528
 529     if ((existing_drive < 0) || (existing_drive >= MAX_DOS_DRIVES) ||
 530         !old->root ||
 531         (new_drive < 0) || (new_drive >= MAX_DOS_DRIVES))
 532     {
 533         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 534         return 0;
 535     }
 536
 537     if ( new->root )
 538     {
 539         TRACE(dosfs, "Can\'t map drive %c to drive %c - "
 540                                 "drive %c already exists\n",
 541                         'A' + existing_drive, 'A' + new_drive,
 542                         'A' + new_drive );
 543         return 0;
 544     }
 545
 546     new->root = HEAP_strdupA( SystemHeap, 0, old->root );
 547     new->dos_cwd = HEAP_strdupA( SystemHeap, 0, old->dos_cwd );
 548     new->unix_cwd = HEAP_strdupA( SystemHeap, 0, old->unix_cwd );
 549     memcpy ( new->label, old->label, 12 );
 550     new->serial = old->serial;
 551     new->type = old->type;
 552     new->flags = old->flags;
 553     new->dev = old->dev;
 554     new->ino = old->ino;
 555
 556     TRACE(dosfs, "Drive %c is now equal to drive %c\n",
 557                     'A' + new_drive, 'A' + existing_drive );
 558
 559     return 1;
 560 }
 561
 562
 563 /***********************************************************************
 564  *           DRIVE_OpenDevice
 565  *
 566  * Open the drive raw device and return a Unix fd (or -1 on error).
 567  */
 568 int DRIVE_OpenDevice( int drive, int flags )
 569 {
 570     if (!DRIVE_IsValid( drive )) return -1;
 571     return open( DOSDrives[drive].device, flags );
 572 }
 573
 574
 575 /***********************************************************************
 576  *           DRIVE_GetFreeSpace
 577  */
 578 static int DRIVE_GetFreeSpace( int drive, DWORD *size, DWORD *available )
 579 {
 580     struct statfs info;
 581
 582     if (!DRIVE_IsValid(drive))
 583     {
 584         DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 585         return 0;
 586     }
 587
 588 /* FIXME: add autoconf check for this */
 589 #if defined(__svr4__) || defined(_SCO_DS)
 590     if (statfs( DOSDrives[drive].root, &info, 0, 0) < 0)
 591 #else
 592     if (statfs( DOSDrives[drive].root, &info) < 0)
 593 #endif
 594     {
 595         FILE_SetDosError();
 596         WARN(dosfs, "cannot do statfs(%s)\n", DOSDrives[drive].root);
 597         return 0;
 598     }
 599
 600     *size = info.f_bsize * info.f_blocks;
 601 #ifdef STATFS_HAS_BAVAIL
 602     *available = info.f_bavail * info.f_bsize;
 603 #else
 604 # ifdef STATFS_HAS_BFREE
 605     *available = info.f_bfree * info.f_bsize;
 606 # else
 607 #  error "statfs has no bfree/bavail member!"
 608 # endif
 609 #endif
 610     return 1;
 611 }
 612
 613
 614 /***********************************************************************
 615  *           GetDiskFreeSpace16   (KERNEL.422)
 616  */
 617 BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
 618                                   LPDWORD sector_bytes, LPDWORD free_clusters,
 619                                   LPDWORD total_clusters )
 620 {
 621     return GetDiskFreeSpace32A( root, cluster_sectors, sector_bytes,
 622                                 free_clusters, total_clusters );
 623 }
 624
 625
 626 /***********************************************************************
 627  *           GetDiskFreeSpace32A   (KERNEL32.206)
 628  */
 629 BOOL32 WINAPI GetDiskFreeSpace32A( LPCSTR root, LPDWORD cluster_sectors,
 630                                    LPDWORD sector_bytes, LPDWORD free_clusters,
 631                                    LPDWORD total_clusters )
 632 {
 633     int drive;
 634     DWORD size,available;
 635
 636     if (!root) drive = DRIVE_GetCurrentDrive();
 637     else
 638     {
 639         if ((root[1]) && ((root[1] != ':') || (root[2] != '\\')))
 640         {
 641             WARN(dosfs, "invalid root '%s'\n", root );
 642             return FALSE;
 643         }
 644         drive = toupper(root[0]) - 'A';
 645     }
 646     if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
 647
 648     /* Cap the size and available at 2GB as per specs.  */
 649     if (size > 0x7fffffff) size = 0x7fffffff;
 650     if (available > 0x7fffffff) available = 0x7fffffff;
 651
 652     if (DRIVE_GetType(drive)==TYPE_CDROM) {
 653         *sector_bytes    = 2048;
 654         size            /= 2048;
 655         available       /= 2048;
 656     } else {
 657         *sector_bytes    = 512;
 658         size            /= 512;
 659         available       /= 512;
 660     }
 661     /* fixme: probably have to adjust those variables too for CDFS */
 662     *cluster_sectors = 1;
 663     while (*cluster_sectors * 65536 < size) *cluster_sectors *= 2;
 664     *free_clusters   = available/ *cluster_sectors;
 665     *total_clusters  = size/ *cluster_sectors;
 666     return TRUE;
 667 }
 668
 669
 670 /***********************************************************************
 671  *           GetDiskFreeSpace32W   (KERNEL32.207)
 672  */
 673 BOOL32 WINAPI GetDiskFreeSpace32W( LPCWSTR root, LPDWORD cluster_sectors,
 674                                    LPDWORD sector_bytes, LPDWORD free_clusters,
 675                                    LPDWORD total_clusters )
 676 {
 677     LPSTR xroot;
 678     BOOL32 ret;
 679
 680     xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root);
 681     ret = GetDiskFreeSpace32A( xroot,cluster_sectors, sector_bytes,
 682                                free_clusters, total_clusters );
 683     HeapFree( GetProcessHeap(), 0, xroot );
 684     return ret;
 685 }
 686
 687
 688 /***********************************************************************
 689  *           GetDiskFreeSpaceEx32A   (KERNEL32.871)
 690  */
 691 BOOL32 WINAPI GetDiskFreeSpaceEx32A( LPCSTR root,
 692                                      LPULARGE_INTEGER avail,
 693                                      LPULARGE_INTEGER total,
 694                                      LPULARGE_INTEGER totalfree)
 695 {
 696     int drive;
 697     DWORD size,available;
 698
 699     if (!root) drive = DRIVE_GetCurrentDrive();
 700     else
 701     {
 702         if ((root[1]) && ((root[1] != ':') || (root[2] != '\\')))
 703         {
 704             WARN(dosfs, "invalid root '%s'\n", root );
 705             return FALSE;
 706         }
 707         drive = toupper(root[0]) - 'A';
 708     }
 709     if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
 710     /*FIXME: Do we have the number of bytes available to the user? */
 711     avail->HighPart = total->HighPart = 0;
 712     avail->LowPart = available;
 713     total->LowPart = size;
 714     if(totalfree)
 715       {
 716         totalfree->HighPart =0;
 717         totalfree->LowPart=  available;
 718       }
 719     return TRUE;
 720 }
 721
 722 /***********************************************************************
 723  *           GetDiskFreeSpaceEx32W   (KERNEL32.873)
 724  */
 725 BOOL32 WINAPI GetDiskFreeSpaceEx32W( LPCWSTR root, LPULARGE_INTEGER avail,
 726                                      LPULARGE_INTEGER total,
 727                                      LPULARGE_INTEGER  totalfree)
 728 {
 729     LPSTR xroot;
 730     BOOL32 ret;
 731
 732     xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root);
 733     ret = GetDiskFreeSpaceEx32A( xroot, avail, total, totalfree);
 734     HeapFree( GetProcessHeap(), 0, xroot );
 735     return ret;
 736 }
 737
 738 /***********************************************************************
 739  *           GetDriveType16   (KERNEL.136)
 740  */
 741 UINT16 WINAPI GetDriveType16( UINT16 drive )
 742 {
 743     TRACE(dosfs, "(%c:)\n", 'A' + drive );
 744     switch(DRIVE_GetType(drive))
 745     {
 746     case TYPE_FLOPPY:  return DRIVE_REMOVABLE;
 747     case TYPE_HD:      return DRIVE_FIXED;
 748     case TYPE_CDROM:   return DRIVE_REMOTE;
 749     case TYPE_NETWORK: return DRIVE_REMOTE;
 750     case TYPE_INVALID:
 751     default:           return DRIVE_CANNOTDETERMINE;
 752     }
 753 }
 754
 755
 756 /***********************************************************************
 757  *           GetDriveType32A   (KERNEL32.208)
 758  */
 759 UINT32 WINAPI GetDriveType32A( LPCSTR root )
 760 {
 761     TRACE(dosfs, "(%s)\n", root );
 762     if ((root[1]) && (root[1] != ':'))
 763     {
 764         WARN(dosfs, "invalid root '%s'\n", root );
 765         return DRIVE_DOESNOTEXIST;
 766     }
 767     switch(DRIVE_GetType(toupper(root[0]) - 'A'))
 768     {
 769     case TYPE_FLOPPY:  return DRIVE_REMOVABLE;
 770     case TYPE_HD:      return DRIVE_FIXED;
 771     case TYPE_CDROM:   return DRIVE_CDROM;
 772     case TYPE_NETWORK: return DRIVE_REMOTE;
 773     case TYPE_INVALID:
 774     default:           return DRIVE_CANNOTDETERMINE;
 775     }
 776 }
 777
 778
 779 /***********************************************************************
 780  *           GetDriveType32W   (KERNEL32.209)
 781  */
 782 UINT32 WINAPI GetDriveType32W( LPCWSTR root )
 783 {
 784     LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
 785     UINT32 ret = GetDriveType32A( xpath );
 786     HeapFree( GetProcessHeap(), 0, xpath );
 787     return ret;
 788 }
 789
 790
 791 /***********************************************************************
 792  *           GetCurrentDirectory16   (KERNEL.411)
 793  */
 794 UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
 795 {
 796     return (UINT16)GetCurrentDirectory32A( buflen, buf );
 797 }
 798
 799
 800 /***********************************************************************
 801  *           GetCurrentDirectory32A   (KERNEL32.196)
 802  *
 803  * Returns "X:\\path\\etc\\".
 804  */
 805 UINT32 WINAPI GetCurrentDirectory32A( UINT32 buflen, LPSTR buf )
 806 {
 807     char *pref = "A:\\";
 808     const char *s = DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
 809     assert(s);
 810     lstrcpyn32A( buf, pref, MIN( 4, buflen ) );
 811     if (buflen) buf[0] += DRIVE_GetCurrentDrive();
 812     if (buflen > 3) lstrcpyn32A( buf + 3, s, buflen - 3 );
 813     return strlen(s) + 3; /* length of WHOLE current directory */
 814 }
 815
 816
 817 /***********************************************************************
 818  *           GetCurrentDirectory32W   (KERNEL32.197)
 819  */
 820 UINT32 WINAPI GetCurrentDirectory32W( UINT32 buflen, LPWSTR buf )
 821 {
 822     LPSTR xpath = HeapAlloc( GetProcessHeap(), 0, buflen+1 );
 823     UINT32 ret = GetCurrentDirectory32A( buflen, xpath );
 824     lstrcpyAtoW( buf, xpath );
 825     HeapFree( GetProcessHeap(), 0, xpath );
 826     return ret;
 827 }
 828
 829
 830 /***********************************************************************
 831  *           SetCurrentDirectory   (KERNEL.412)
 832  */
 833 BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
 834 {
 835     return SetCurrentDirectory32A( dir );
 836 }
 837
 838
 839 /***********************************************************************
 840  *           SetCurrentDirectory32A   (KERNEL32.479)
 841  */
 842 BOOL32 WINAPI SetCurrentDirectory32A( LPCSTR dir )
 843 {
 844     int drive = DRIVE_GetCurrentDrive();
 845
 846     if (dir[0] && (dir[1]==':'))
 847     {
 848         drive = tolower( *dir ) - 'a';
 849         if (!DRIVE_IsValid( drive ))
 850         {
 851             DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
 852             return FALSE;
 853         }
 854         dir += 2;
 855     }
 856     /* FIXME: what about empty strings? Add a \\ ? */
 857     if (!DRIVE_Chdir( drive, dir )) return FALSE;
 858     if (drive == DRIVE_GetCurrentDrive()) return TRUE;
 859     return DRIVE_SetCurrentDrive( drive );
 860 }
 861
 862
 863 /***********************************************************************
 864  *           SetCurrentDirectory32W   (KERNEL32.480)
 865  */
 866 BOOL32 WINAPI SetCurrentDirectory32W( LPCWSTR dirW )
 867 {
 868     LPSTR dir = HEAP_strdupWtoA( GetProcessHeap(), 0, dirW );
 869     BOOL32 res = SetCurrentDirectory32A( dir );
 870     HeapFree( GetProcessHeap(), 0, dir );
 871     return res;
 872 }
 873
 874
 875 /***********************************************************************
 876  *           GetLogicalDriveStrings32A   (KERNEL32.231)
 877  */
 878 UINT32 WINAPI GetLogicalDriveStrings32A( UINT32 len, LPSTR buffer )
 879 {
 880     int drive, count;
 881
 882     for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
 883         if (DRIVE_IsValid(drive)) count++;
 884     if (count * 4 * sizeof(char) <= len)
 885     {
 886         LPSTR p = buffer;
 887         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 888             if (DRIVE_IsValid(drive))
 889             {
 890                 *p++ = 'a' + drive;
 891                 *p++ = ':';
 892                 *p++ = '\\';
 893                 *p++ = '\0';
 894             }
 895         *p = '\0';
 896     }
 897     return count * 4 * sizeof(char);
 898 }
 899
 900
 901 /***********************************************************************
 902  *           GetLogicalDriveStrings32W   (KERNEL32.232)
 903  */
 904 UINT32 WINAPI GetLogicalDriveStrings32W( UINT32 len, LPWSTR buffer )
 905 {
 906     int drive, count;
 907
 908     for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
 909         if (DRIVE_IsValid(drive)) count++;
 910     if (count * 4 * sizeof(WCHAR) <= len)
 911     {
 912         LPWSTR p = buffer;
 913         for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 914             if (DRIVE_IsValid(drive))
 915             {
 916                 *p++ = (WCHAR)('a' + drive);
 917                 *p++ = (WCHAR)':';
 918                 *p++ = (WCHAR)'\\';
 919                 *p++ = (WCHAR)'\0';
 920             }
 921         *p = (WCHAR)'\0';
 922     }
 923     return count * 4 * sizeof(WCHAR);
 924 }
 925
 926
 927 /***********************************************************************
 928  *           GetLogicalDrives   (KERNEL32.233)
 929  */
 930 DWORD WINAPI GetLogicalDrives(void)
 931 {
 932     DWORD ret = 0;
 933     int drive;
 934
 935     for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
 936         if (DRIVE_IsValid(drive)) ret |= (1 << drive);
 937     return ret;
 938 }
 939
 940
 941 /***********************************************************************
 942  *           GetVolumeInformation32A   (KERNEL32.309)
 943  */
 944 BOOL32 WINAPI GetVolumeInformation32A( LPCSTR root, LPSTR label,
 945                                        DWORD label_len, DWORD *serial,
 946                                        DWORD *filename_len, DWORD *flags,
 947                                        LPSTR fsname, DWORD fsname_len )
 948 {
 949     int drive;
 950
 951     /* FIXME, SetLastErrors missing */
 952
 953     if (!root) drive = DRIVE_GetCurrentDrive();
 954     else
 955     {
 956         if ((root[1]) && (root[1] != ':'))
 957         {
 958             WARN(dosfs, "invalid root '%s'\n",root);
 959             return FALSE;
 960         }
 961         drive = toupper(root[0]) - 'A';
 962     }
 963     if (!DRIVE_IsValid( drive )) return FALSE;
 964     if (label) lstrcpyn32A( label, DOSDrives[drive].label, label_len );
 965     if (serial) *serial = DOSDrives[drive].serial;
 966
 967     /* Set the filesystem information */
 968     /* Note: we only emulate a FAT fs at the present */
 969
 970     if (filename_len) *filename_len = 12;
 971     if (flags) *flags = 0;
 972     if (fsname) {
 973         /* Diablo checks that return code ... */
 974         if (DRIVE_GetType(drive)==TYPE_CDROM)
 975             lstrcpyn32A( fsname, "CDFS", fsname_len );
 976         else
 977             lstrcpyn32A( fsname, "FAT", fsname_len );
 978     }
 979     return TRUE;
 980 }
 981
 982
 983 /***********************************************************************
 984  *           GetVolumeInformation32W   (KERNEL32.310)
 985  */
 986 BOOL32 WINAPI GetVolumeInformation32W( LPCWSTR root, LPWSTR label,
 987                                        DWORD label_len, DWORD *serial,
 988                                        DWORD *filename_len, DWORD *flags,
 989                                        LPWSTR fsname, DWORD fsname_len )
 990 {
 991     LPSTR xroot    = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
 992     LPSTR xvolname = label ? HeapAlloc(GetProcessHeap(),0,label_len) : NULL;
 993     LPSTR xfsname  = fsname ? HeapAlloc(GetProcessHeap(),0,fsname_len) : NULL;
 994     BOOL32 ret = GetVolumeInformation32A( xroot, xvolname, label_len, serial,
 995                                           filename_len, flags, xfsname,
 996                                           fsname_len );
 997     if (ret)
 998     {
 999         if (label) lstrcpyAtoW( label, xvolname );
1000         if (fsname) lstrcpyAtoW( fsname, xfsname );
1001     }
1002     HeapFree( GetProcessHeap(), 0, xroot );
1003     HeapFree( GetProcessHeap(), 0, xvolname );
1004     HeapFree( GetProcessHeap(), 0, xfsname );
1005     return ret;
1006 }