Sweden-Number/files/drive.c

1254 lines
36 KiB
C

/*
* DOS drives handling functions
*
* Copyright 1993 Erik Bos
* Copyright 1996 Alexandre Julliard
*/
#include "config.h"
#include <assert.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef STATFS_DEFINED_BY_SYS_VFS
# include <sys/vfs.h>
#else
# ifdef STATFS_DEFINED_BY_SYS_MOUNT
# include <sys/mount.h>
# else
# ifdef STATFS_DEFINED_BY_SYS_STATFS
# include <sys/statfs.h>
# endif
# endif
#endif
#include "winbase.h"
#include "wine/winbase16.h" /* for GetCurrentTask */
#include "wine/winestring.h" /* for lstrcpyAtoW */
#include "winerror.h"
#include "drive.h"
#include "file.h"
#include "heap.h"
#include "msdos.h"
#include "options.h"
#include "task.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(dosfs)
DECLARE_DEBUG_CHANNEL(file)
typedef struct
{
char *root; /* root dir in Unix format without trailing / */
char *dos_cwd; /* cwd in DOS format without leading or trailing \ */
char *unix_cwd; /* cwd in Unix format without leading or trailing / */
char *device; /* raw device path */
char label[12]; /* drive label */
DWORD serial; /* drive serial number */
DRIVETYPE type; /* drive type */
UINT flags; /* drive flags */
dev_t dev; /* unix device number */
ino_t ino; /* unix inode number */
} DOSDRIVE;
static const char * const DRIVE_Types[] =
{
"floppy", /* TYPE_FLOPPY */
"hd", /* TYPE_HD */
"cdrom", /* TYPE_CDROM */
"network" /* TYPE_NETWORK */
};
/* Known filesystem types */
typedef struct
{
const char *name;
UINT flags;
} FS_DESCR;
static const FS_DESCR DRIVE_Filesystems[] =
{
{ "unix", DRIVE_CASE_SENSITIVE | DRIVE_CASE_PRESERVING },
{ "msdos", DRIVE_SHORT_NAMES },
{ "dos", DRIVE_SHORT_NAMES },
{ "fat", DRIVE_SHORT_NAMES },
{ "vfat", DRIVE_CASE_PRESERVING },
{ "win95", DRIVE_CASE_PRESERVING },
{ NULL, 0 }
};
static DOSDRIVE DOSDrives[MAX_DOS_DRIVES];
static int DRIVE_CurDrive = -1;
static HTASK16 DRIVE_LastTask = 0;
/***********************************************************************
* DRIVE_GetDriveType
*/
static DRIVETYPE DRIVE_GetDriveType( const char *name )
{
char buffer[20];
int i;
PROFILE_GetWineIniString( name, "Type", "hd", buffer, sizeof(buffer) );
for (i = 0; i < sizeof(DRIVE_Types)/sizeof(DRIVE_Types[0]); i++)
{
if (!strcasecmp( buffer, DRIVE_Types[i] )) return (DRIVETYPE)i;
}
MESSAGE("%s: unknown type '%s', defaulting to 'hd'.\n", name, buffer );
return TYPE_HD;
}
/***********************************************************************
* DRIVE_GetFSFlags
*/
static UINT DRIVE_GetFSFlags( const char *name, const char *value )
{
const FS_DESCR *descr;
for (descr = DRIVE_Filesystems; descr->name; descr++)
if (!strcasecmp( value, descr->name )) return descr->flags;
MESSAGE("%s: unknown filesystem type '%s', defaulting to 'win95'.\n",
name, value );
return DRIVE_CASE_PRESERVING;
}
/***********************************************************************
* DRIVE_Init
*/
int DRIVE_Init(void)
{
int i, len, count = 0;
char name[] = "Drive A";
char path[MAX_PATHNAME_LEN];
char buffer[80];
struct stat drive_stat_buffer;
char *p;
DOSDRIVE *drive;
for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, name[6]++, drive++)
{
PROFILE_GetWineIniString( name, "Path", "", path, sizeof(path)-1 );
if (path[0])
{
p = path + strlen(path) - 1;
while ((p > path) && ((*p == '/') || (*p == '\\'))) *p-- = '\0';
if (!path[0]) strcpy( path, "/" );
if (stat( path, &drive_stat_buffer ))
{
MESSAGE("Could not stat %s, ignoring drive %c:\n", path, 'A' + i );
continue;
}
if (!S_ISDIR(drive_stat_buffer.st_mode))
{
MESSAGE("%s is not a directory, ignoring drive %c:\n",
path, 'A' + i );
continue;
}
drive->root = HEAP_strdupA( SystemHeap, 0, path );
drive->dos_cwd = HEAP_strdupA( SystemHeap, 0, "" );
drive->unix_cwd = HEAP_strdupA( SystemHeap, 0, "" );
drive->type = DRIVE_GetDriveType( name );
drive->device = NULL;
drive->flags = 0;
drive->dev = drive_stat_buffer.st_dev;
drive->ino = drive_stat_buffer.st_ino;
/* Get the drive label */
PROFILE_GetWineIniString( name, "Label", name, drive->label, 12 );
if ((len = strlen(drive->label)) < 11)
{
/* Pad label with spaces */
memset( drive->label + len, ' ', 11 - len );
drive->label[12] = '\0';
}
/* Get the serial number */
PROFILE_GetWineIniString( name, "Serial", "12345678",
buffer, sizeof(buffer) );
drive->serial = strtoul( buffer, NULL, 16 );
/* Get the filesystem type */
PROFILE_GetWineIniString( name, "Filesystem", "win95",
buffer, sizeof(buffer) );
drive->flags = DRIVE_GetFSFlags( name, buffer );
/* Get the device */
PROFILE_GetWineIniString( name, "Device", "",
buffer, sizeof(buffer) );
if (buffer[0])
drive->device = HEAP_strdupA( SystemHeap, 0, buffer );
/* Make the first hard disk the current drive */
if ((DRIVE_CurDrive == -1) && (drive->type == TYPE_HD))
DRIVE_CurDrive = i;
count++;
TRACE_(dosfs)("%s: path=%s type=%s label='%s' serial=%08lx flags=%08x dev=%x ino=%x\n",
name, path, DRIVE_Types[drive->type],
drive->label, drive->serial, drive->flags,
(int)drive->dev, (int)drive->ino );
}
else WARN_(dosfs)("%s: not defined\n", name );
}
if (!count)
{
MESSAGE("Warning: no valid DOS drive found, check your configuration file.\n" );
/* Create a C drive pointing to Unix root dir */
DOSDrives[2].root = HEAP_strdupA( SystemHeap, 0, "/" );
DOSDrives[2].dos_cwd = HEAP_strdupA( SystemHeap, 0, "" );
DOSDrives[2].unix_cwd = HEAP_strdupA( SystemHeap, 0, "" );
strcpy( DOSDrives[2].label, "Drive C " );
DOSDrives[2].serial = 0x12345678;
DOSDrives[2].type = TYPE_HD;
DOSDrives[2].flags = 0;
DRIVE_CurDrive = 2;
}
/* Make sure the current drive is valid */
if (DRIVE_CurDrive == -1)
{
for (i = 0, drive = DOSDrives; i < MAX_DOS_DRIVES; i++, drive++)
{
if (drive->root && !(drive->flags & DRIVE_DISABLED))
{
DRIVE_CurDrive = i;
break;
}
}
}
return 1;
}
/***********************************************************************
* DRIVE_IsValid
*/
int DRIVE_IsValid( int drive )
{
if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
return (DOSDrives[drive].root &&
!(DOSDrives[drive].flags & DRIVE_DISABLED));
}
/***********************************************************************
* DRIVE_GetCurrentDrive
*/
int DRIVE_GetCurrentDrive(void)
{
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
if (pTask && (pTask->curdrive & 0x80)) return pTask->curdrive & ~0x80;
return DRIVE_CurDrive;
}
/***********************************************************************
* DRIVE_SetCurrentDrive
*/
int DRIVE_SetCurrentDrive( int drive )
{
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
if (!DRIVE_IsValid( drive ))
{
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
TRACE_(dosfs)("%c:\n", 'A' + drive );
DRIVE_CurDrive = drive;
if (pTask) pTask->curdrive = drive | 0x80;
return 1;
}
/***********************************************************************
* DRIVE_FindDriveRoot
*
* Find a drive for which the root matches the begginning of the given path.
* This can be used to translate a Unix path into a drive + DOS path.
* Return value is the drive, or -1 on error. On success, path is modified
* to point to the beginning of the DOS path.
*/
int DRIVE_FindDriveRoot( const char **path )
{
/* idea: check at all '/' positions.
* If the device and inode of that path is identical with the
* device and inode of the current drive then we found a solution.
* If there is another drive pointing to a deeper position in
* the file tree, we want to find that one, not the earlier solution.
*/
int drive, rootdrive = -1;
char buffer[MAX_PATHNAME_LEN];
char *next = buffer;
const char *p = *path;
struct stat st;
strcpy( buffer, "/" );
for (;;)
{
if (stat( buffer, &st ) || !S_ISDIR( st.st_mode )) break;
/* Find the drive */
for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
{
if (!DOSDrives[drive].root ||
(DOSDrives[drive].flags & DRIVE_DISABLED)) continue;
if ((DOSDrives[drive].dev == st.st_dev) &&
(DOSDrives[drive].ino == st.st_ino))
{
rootdrive = drive;
*path = p;
}
}
/* Get the next path component */
*next++ = '/';
while ((*p == '/') || (*p == '\\')) p++;
if (!*p) break;
while (!IS_END_OF_NAME(*p)) *next++ = *p++;
*next = 0;
}
*next = 0;
if (rootdrive != -1)
TRACE_(dosfs)("%s -> drive %c:, root='%s', name='%s'\n",
buffer, 'A' + rootdrive,
DOSDrives[rootdrive].root, *path );
return rootdrive;
}
/***********************************************************************
* DRIVE_GetRoot
*/
const char * DRIVE_GetRoot( int drive )
{
if (!DRIVE_IsValid( drive )) return NULL;
return DOSDrives[drive].root;
}
/***********************************************************************
* DRIVE_GetDosCwd
*/
const char * DRIVE_GetDosCwd( int drive )
{
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
if (!DRIVE_IsValid( drive )) return NULL;
/* Check if we need to change the directory to the new task. */
if (pTask && (pTask->curdrive & 0x80) && /* The task drive is valid */
((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
(DRIVE_LastTask != GetCurrentTask())) /* and the task changed */
{
/* Perform the task-switch */
if (!DRIVE_Chdir( drive, pTask->curdir )) DRIVE_Chdir( drive, "\\" );
DRIVE_LastTask = GetCurrentTask();
}
return DOSDrives[drive].dos_cwd;
}
/***********************************************************************
* DRIVE_GetUnixCwd
*/
const char * DRIVE_GetUnixCwd( int drive )
{
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
if (!DRIVE_IsValid( drive )) return NULL;
/* Check if we need to change the directory to the new task. */
if (pTask && (pTask->curdrive & 0x80) && /* The task drive is valid */
((pTask->curdrive & ~0x80) == drive) && /* and it's the one we want */
(DRIVE_LastTask != GetCurrentTask())) /* and the task changed */
{
/* Perform the task-switch */
if (!DRIVE_Chdir( drive, pTask->curdir )) DRIVE_Chdir( drive, "\\" );
DRIVE_LastTask = GetCurrentTask();
}
return DOSDrives[drive].unix_cwd;
}
/***********************************************************************
* DRIVE_GetLabel
*/
const char * DRIVE_GetLabel( int drive )
{
if (!DRIVE_IsValid( drive )) return NULL;
return DOSDrives[drive].label;
}
/***********************************************************************
* DRIVE_GetSerialNumber
*/
DWORD DRIVE_GetSerialNumber( int drive )
{
if (!DRIVE_IsValid( drive )) return 0;
return DOSDrives[drive].serial;
}
/***********************************************************************
* DRIVE_SetSerialNumber
*/
int DRIVE_SetSerialNumber( int drive, DWORD serial )
{
if (!DRIVE_IsValid( drive )) return 0;
DOSDrives[drive].serial = serial;
return 1;
}
/***********************************************************************
* DRIVE_GetType
*/
DRIVETYPE DRIVE_GetType( int drive )
{
if (!DRIVE_IsValid( drive )) return TYPE_INVALID;
return DOSDrives[drive].type;
}
/***********************************************************************
* DRIVE_GetFlags
*/
UINT DRIVE_GetFlags( int drive )
{
if ((drive < 0) || (drive >= MAX_DOS_DRIVES)) return 0;
return DOSDrives[drive].flags;
}
/***********************************************************************
* DRIVE_Chdir
*/
int DRIVE_Chdir( int drive, const char *path )
{
DOS_FULL_NAME full_name;
char buffer[MAX_PATHNAME_LEN];
LPSTR unix_cwd;
BY_HANDLE_FILE_INFORMATION info;
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
strcpy( buffer, "A:" );
buffer[0] += drive;
TRACE_(dosfs)("(%c:,%s)\n", buffer[0], path );
lstrcpynA( buffer + 2, path, sizeof(buffer) - 2 );
if (!DOSFS_GetFullName( buffer, TRUE, &full_name )) return 0;
if (!FILE_Stat( full_name.long_name, &info )) return 0;
if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
SetLastError( ERROR_FILE_NOT_FOUND );
return 0;
}
unix_cwd = full_name.long_name + strlen( DOSDrives[drive].root );
while (*unix_cwd == '/') unix_cwd++;
TRACE_(dosfs)("(%c:): unix_cwd=%s dos_cwd=%s\n",
'A' + drive, unix_cwd, full_name.short_name + 3 );
HeapFree( SystemHeap, 0, DOSDrives[drive].dos_cwd );
HeapFree( SystemHeap, 0, DOSDrives[drive].unix_cwd );
DOSDrives[drive].dos_cwd = HEAP_strdupA( SystemHeap, 0,
full_name.short_name + 3 );
DOSDrives[drive].unix_cwd = HEAP_strdupA( SystemHeap, 0, unix_cwd );
if (pTask && (pTask->curdrive & 0x80) &&
((pTask->curdrive & ~0x80) == drive))
{
lstrcpynA( pTask->curdir, full_name.short_name + 2,
sizeof(pTask->curdir) );
DRIVE_LastTask = GetCurrentTask();
}
return 1;
}
/***********************************************************************
* DRIVE_Disable
*/
int DRIVE_Disable( int drive )
{
if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
{
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
DOSDrives[drive].flags |= DRIVE_DISABLED;
return 1;
}
/***********************************************************************
* DRIVE_Enable
*/
int DRIVE_Enable( int drive )
{
if ((drive < 0) || (drive >= MAX_DOS_DRIVES) || !DOSDrives[drive].root)
{
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
DOSDrives[drive].flags &= ~DRIVE_DISABLED;
return 1;
}
/***********************************************************************
* DRIVE_SetLogicalMapping
*/
int DRIVE_SetLogicalMapping ( int existing_drive, int new_drive )
{
/* If new_drive is already valid, do nothing and return 0
otherwise, copy DOSDrives[existing_drive] to DOSDrives[new_drive] */
DOSDRIVE *old, *new;
old = DOSDrives + existing_drive;
new = DOSDrives + new_drive;
if ((existing_drive < 0) || (existing_drive >= MAX_DOS_DRIVES) ||
!old->root ||
(new_drive < 0) || (new_drive >= MAX_DOS_DRIVES))
{
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
if ( new->root )
{
TRACE_(dosfs)("Can\'t map drive %c to drive %c - "
"drive %c already exists\n",
'A' + existing_drive, 'A' + new_drive,
'A' + new_drive );
/* it is already mapped there, so return success */
if (!strcmp(old->root,new->root))
return 1;
return 0;
}
new->root = HEAP_strdupA( SystemHeap, 0, old->root );
new->dos_cwd = HEAP_strdupA( SystemHeap, 0, old->dos_cwd );
new->unix_cwd = HEAP_strdupA( SystemHeap, 0, old->unix_cwd );
memcpy ( new->label, old->label, 12 );
new->serial = old->serial;
new->type = old->type;
new->flags = old->flags;
new->dev = old->dev;
new->ino = old->ino;
TRACE_(dosfs)("Drive %c is now equal to drive %c\n",
'A' + new_drive, 'A' + existing_drive );
return 1;
}
/***********************************************************************
* DRIVE_OpenDevice
*
* Open the drive raw device and return a Unix fd (or -1 on error).
*/
int DRIVE_OpenDevice( int drive, int flags )
{
if (!DRIVE_IsValid( drive )) return -1;
return open( DOSDrives[drive].device, flags );
}
/***********************************************************************
* DRIVE_RawRead
*
* Read raw sectors from a device
*/
int DRIVE_RawRead(BYTE drive, DWORD begin, DWORD nr_sect, BYTE *dataptr, BOOL fake_success)
{
int fd;
if ((fd = DRIVE_OpenDevice( drive, O_RDONLY )) != -1)
{
lseek( fd, begin * 512, SEEK_SET );
/* FIXME: check errors */
read( fd, dataptr, nr_sect * 512 );
close( fd );
}
else
{
memset(dataptr, 0, nr_sect * 512);
if (fake_success)
{
if (begin == 0 && nr_sect > 1) *(dataptr + 512) = 0xf8;
if (begin == 1) *dataptr = 0xf8;
}
else
return 0;
}
return 1;
}
/***********************************************************************
* DRIVE_RawWrite
*
* Write raw sectors to a device
*/
int DRIVE_RawWrite(BYTE drive, DWORD begin, DWORD nr_sect, BYTE *dataptr, BOOL fake_success)
{
int fd;
if ((fd = DRIVE_OpenDevice( drive, O_RDONLY )) != -1)
{
lseek( fd, begin * 512, SEEK_SET );
/* FIXME: check errors */
write( fd, dataptr, nr_sect * 512 );
close( fd );
}
else
if (!(fake_success))
return 0;
return 1;
}
/***********************************************************************
* DRIVE_GetFreeSpace
*/
static int DRIVE_GetFreeSpace( int drive, PULARGE_INTEGER size,
PULARGE_INTEGER available )
{
struct statfs info;
unsigned long long bigsize,bigavail=0;
if (!DRIVE_IsValid(drive))
{
SetLastError( ERROR_INVALID_DRIVE );
return 0;
}
/* FIXME: add autoconf check for this */
#if defined(__svr4__) || defined(_SCO_DS) || defined(__sun)
if (statfs( DOSDrives[drive].root, &info, 0, 0) < 0)
#else
if (statfs( DOSDrives[drive].root, &info) < 0)
#endif
{
FILE_SetDosError();
WARN_(dosfs)("cannot do statfs(%s)\n", DOSDrives[drive].root);
return 0;
}
bigsize = (unsigned long long)info.f_bsize
* (unsigned long long)info.f_blocks;
#ifdef STATFS_HAS_BAVAIL
bigavail = (unsigned long long)info.f_bavail
* (unsigned long long)info.f_bsize;
#else
# ifdef STATFS_HAS_BFREE
bigavail = (unsigned long long)info.f_bfree
* (unsigned long long)info.f_bsize;
# else
# error "statfs has no bfree/bavail member!"
# endif
#endif
size->LowPart = (DWORD)bigsize;
size->HighPart = (DWORD)(bigsize>>32);
available->LowPart = (DWORD)bigavail;
available->HighPart = (DWORD)(bigavail>>32);
return 1;
}
/***********************************************************************
* GetDiskFreeSpace16 (KERNEL.422)
*/
BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
free_clusters, total_clusters );
}
/***********************************************************************
* GetDiskFreeSpace32A (KERNEL32.206)
*
* Fails if expression resulting from current drive's dir and "root"
* is not a root dir of the target drive.
*
* UNDOC: setting some LPDWORDs to NULL is perfectly possible
* if the corresponding info is unneeded.
*
* FIXME: needs to support UNC names from Win95 OSR2 on.
*
* Behaviour under Win95a:
* CurrDir root result
* "E:\\TEST" "E:" FALSE
* "E:\\" "E:" TRUE
* "E:\\" "E" FALSE
* "E:\\" "\\" TRUE
* "E:\\TEST" "\\" TRUE
* "E:\\TEST" ":\\" FALSE
* "E:\\TEST" "E:\\" TRUE
* "E:\\TEST" "" FALSE
* "E:\\" "" FALSE (!)
* "E:\\" 0x0 TRUE
* "E:\\TEST" 0x0 TRUE (!)
* "E:\\TEST" "C:" TRUE (when CurrDir of "C:" set to "\\")
* "E:\\TEST" "C:" FALSE (when CurrDir of "C:" set to "\\TEST")
*/
BOOL WINAPI GetDiskFreeSpaceA( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
int drive;
ULARGE_INTEGER size,available;
LPCSTR path;
DWORD cluster_sec;
if ((!root) || (root == "\\"))
drive = DRIVE_GetCurrentDrive();
else
if ( (strlen(root) >= 2) && (root[1] == ':')) /* root contains drive tag */
{
drive = toupper(root[0]) - 'A';
path = &root[2];
if (path[0] == '\0')
path = DRIVE_GetDosCwd(drive);
else
if (path[0] == '\\')
path++;
if (strlen(path)) /* oops, we are in a subdir */
return FALSE;
}
else
return FALSE;
if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
/* Cap the size and available at 2GB as per specs. */
if ((size.HighPart) ||(size.LowPart > 0x7fffffff))
{
size.HighPart = 0;
size.LowPart = 0x7fffffff;
}
if ((available.HighPart) ||(available.LowPart > 0x7fffffff))
{
available.HighPart =0;
available.LowPart = 0x7fffffff;
}
if (DRIVE_GetType(drive)==TYPE_CDROM) {
if (sector_bytes)
*sector_bytes = 2048;
size.LowPart /= 2048;
available.LowPart /= 2048;
} else {
if (sector_bytes)
*sector_bytes = 512;
size.LowPart /= 512;
available.LowPart /= 512;
}
/* fixme: probably have to adjust those variables too for CDFS */
cluster_sec = 1;
while (cluster_sec * 65536 < size.LowPart) cluster_sec *= 2;
if (cluster_sectors)
*cluster_sectors = cluster_sec;
if (free_clusters)
*free_clusters = available.LowPart / cluster_sec;
if (total_clusters)
*total_clusters = size.LowPart / cluster_sec;
return TRUE;
}
/***********************************************************************
* GetDiskFreeSpace32W (KERNEL32.207)
*/
BOOL WINAPI GetDiskFreeSpaceW( LPCWSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
LPSTR xroot;
BOOL ret;
xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root);
ret = GetDiskFreeSpaceA( xroot,cluster_sectors, sector_bytes,
free_clusters, total_clusters );
HeapFree( GetProcessHeap(), 0, xroot );
return ret;
}
/***********************************************************************
* GetDiskFreeSpaceEx32A (KERNEL32.871)
*
* This function is used to aquire the size of the available and
* total space on a logical volume.
*
* RETURNS
*
* Zero on failure, nonzero upon success. Use GetLastError to obtain
* detailed error information.
*
*/
BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root,
PULARGE_INTEGER avail,
PULARGE_INTEGER total,
PULARGE_INTEGER totalfree)
{
int drive;
ULARGE_INTEGER size,available;
if (!root) drive = DRIVE_GetCurrentDrive();
else
{
if ((root[1]) && ((root[1] != ':') || (root[2] != '\\')))
{
FIXME_(dosfs)("there are valid root names which are not supported yet\n");
/* ..like UNC names, for instance. */
WARN_(dosfs)("invalid root '%s'\n", root );
return FALSE;
}
drive = toupper(root[0]) - 'A';
}
if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
if (total)
{
total->HighPart = size.HighPart;
total->LowPart = size.LowPart ;
}
if (totalfree)
{
totalfree->HighPart = available.HighPart;
totalfree->LowPart = available.LowPart ;
}
if (avail)
{
FIXME_(dosfs)("no per-user quota support yet\n");
/* Quick hack */
avail->HighPart = totalfree->HighPart;
avail->LowPart = totalfree->LowPart ;
}
return TRUE;
}
/***********************************************************************
* GetDiskFreeSpaceEx32W (KERNEL32.873)
*/
BOOL WINAPI GetDiskFreeSpaceExW( LPCWSTR root, PULARGE_INTEGER avail,
PULARGE_INTEGER total,
PULARGE_INTEGER totalfree)
{
LPSTR xroot;
BOOL ret;
xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root);
ret = GetDiskFreeSpaceExA( xroot, avail, total, totalfree);
HeapFree( GetProcessHeap(), 0, xroot );
return ret;
}
/***********************************************************************
* GetDriveType16 (KERNEL.136)
* This functions returns the drivetype of a drive in Win16.
* Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
* remote drive API. The returnvalue DRIVE_REMOTE for CD-ROMs has been
* verified on Win3.11 and Windows 95. Some programs rely on it, so don't
* do any pseudo-clever changes.
*
* RETURNS
* drivetype DRIVE_xxx
*/
UINT16 WINAPI GetDriveType16(
UINT16 drive /* [in] number (NOT letter) of drive */
) {
TRACE_(dosfs)("(%c:)\n", 'A' + drive );
switch(DRIVE_GetType(drive))
{
case TYPE_FLOPPY: return DRIVE_REMOVABLE;
case TYPE_HD: return DRIVE_FIXED;
case TYPE_CDROM: return DRIVE_REMOTE;
case TYPE_NETWORK: return DRIVE_REMOTE;
case TYPE_INVALID:
default: return DRIVE_CANNOTDETERMINE;
}
}
/***********************************************************************
* GetDriveType32A (KERNEL32.208)
*
* Returns the type of the disk drive specified. If root is NULL the
* root of the current directory is used.
*
* RETURNS
*
* Type of drive (from Win32 SDK):
*
* DRIVE_UNKNOWN unable to find out anything about the drive
* DRIVE_NO_ROOT_DIR nonexistand root dir
* DRIVE_REMOVABLE the disk can be removed from the machine
* DRIVE_FIXED the disk can not be removed from the machine
* DRIVE_REMOTE network disk
* DRIVE_CDROM CDROM drive
* DRIVE_RAMDISK virtual disk in ram
*
* DRIVE_DOESNOTEXIST XXX Not valid return value
* DRIVE_CANNOTDETERMINE XXX Not valid return value
*
* BUGS
*
* Currently returns DRIVE_DOESNOTEXIST and DRIVE_CANNOTDETERMINE
* when it really should return DRIVE_NO_ROOT_DIR and DRIVE_UNKNOWN.
* Why where the former defines used?
*
* DRIVE_RAMDISK is unsupported.
*/
UINT WINAPI GetDriveTypeA(LPCSTR root /* String describing drive */)
{
int drive;
TRACE_(dosfs)("(%s)\n", debugstr_a(root));
if (NULL == root) drive = DRIVE_GetCurrentDrive();
else
{
if ((root[1]) && (root[1] != ':'))
{
WARN_(dosfs)("invalid root '%s'\n", debugstr_a(root));
return DRIVE_DOESNOTEXIST;
}
drive = toupper(root[0]) - 'A';
}
switch(DRIVE_GetType(drive))
{
case TYPE_FLOPPY: return DRIVE_REMOVABLE;
case TYPE_HD: return DRIVE_FIXED;
case TYPE_CDROM: return DRIVE_CDROM;
case TYPE_NETWORK: return DRIVE_REMOTE;
case TYPE_INVALID: return DRIVE_DOESNOTEXIST;
default: return DRIVE_CANNOTDETERMINE;
}
}
/***********************************************************************
* GetDriveType32W (KERNEL32.209)
*/
UINT WINAPI GetDriveTypeW( LPCWSTR root )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
UINT ret = GetDriveTypeA( xpath );
HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
/***********************************************************************
* GetCurrentDirectory16 (KERNEL.411)
*/
UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
{
return (UINT16)GetCurrentDirectoryA( buflen, buf );
}
/***********************************************************************
* GetCurrentDirectory32A (KERNEL32.196)
*
* Returns "X:\\path\\etc\\".
*
* Despite the API description, return required length including the
* terminating null when buffer too small. This is the real behaviour.
*/
UINT WINAPI GetCurrentDirectoryA( UINT buflen, LPSTR buf )
{
UINT ret;
const char *s = DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
assert(s);
ret = strlen(s) + 3; /* length of WHOLE current directory */
if (ret >= buflen) return ret + 1;
lstrcpynA( buf, "A:\\", MIN( 4, buflen ) );
if (buflen) buf[0] += DRIVE_GetCurrentDrive();
if (buflen > 3) lstrcpynA( buf + 3, s, buflen - 3 );
return ret;
}
/***********************************************************************
* GetCurrentDirectory32W (KERNEL32.197)
*/
UINT WINAPI GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
{
LPSTR xpath = HeapAlloc( GetProcessHeap(), 0, buflen+1 );
UINT ret = GetCurrentDirectoryA( buflen, xpath );
lstrcpyAtoW( buf, xpath );
HeapFree( GetProcessHeap(), 0, xpath );
return ret;
}
/***********************************************************************
* SetCurrentDirectory (KERNEL.412)
*/
BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
{
return SetCurrentDirectoryA( dir );
}
/***********************************************************************
* SetCurrentDirectory32A (KERNEL32.479)
*/
BOOL WINAPI SetCurrentDirectoryA( LPCSTR dir )
{
int olddrive, drive = DRIVE_GetCurrentDrive();
if (!dir) {
ERR_(file)("(NULL)!\n");
return FALSE;
}
if (dir[0] && (dir[1]==':'))
{
drive = tolower( *dir ) - 'a';
dir += 2;
}
/* WARNING: we need to set the drive before the dir, as DRIVE_Chdir
sets pTask->curdir only if pTask->curdrive is drive */
olddrive = drive; /* in case DRIVE_Chdir fails */
if (!(DRIVE_SetCurrentDrive( drive )))
return FALSE;
/* FIXME: what about empty strings? Add a \\ ? */
if (!DRIVE_Chdir( drive, dir )) {
DRIVE_SetCurrentDrive(olddrive);
return FALSE;
}
return TRUE;
}
/***********************************************************************
* SetCurrentDirectory32W (KERNEL32.480)
*/
BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dirW )
{
LPSTR dir = HEAP_strdupWtoA( GetProcessHeap(), 0, dirW );
BOOL res = SetCurrentDirectoryA( dir );
HeapFree( GetProcessHeap(), 0, dir );
return res;
}
/***********************************************************************
* GetLogicalDriveStrings32A (KERNEL32.231)
*/
UINT WINAPI GetLogicalDriveStringsA( UINT len, LPSTR buffer )
{
int drive, count;
for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
if (DRIVE_IsValid(drive)) count++;
if (count * 4 * sizeof(char) <= len)
{
LPSTR p = buffer;
for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
if (DRIVE_IsValid(drive))
{
*p++ = 'a' + drive;
*p++ = ':';
*p++ = '\\';
*p++ = '\0';
}
*p = '\0';
}
return count * 4 * sizeof(char);
}
/***********************************************************************
* GetLogicalDriveStrings32W (KERNEL32.232)
*/
UINT WINAPI GetLogicalDriveStringsW( UINT len, LPWSTR buffer )
{
int drive, count;
for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++)
if (DRIVE_IsValid(drive)) count++;
if (count * 4 * sizeof(WCHAR) <= len)
{
LPWSTR p = buffer;
for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
if (DRIVE_IsValid(drive))
{
*p++ = (WCHAR)('a' + drive);
*p++ = (WCHAR)':';
*p++ = (WCHAR)'\\';
*p++ = (WCHAR)'\0';
}
*p = (WCHAR)'\0';
}
return count * 4 * sizeof(WCHAR);
}
/***********************************************************************
* GetLogicalDrives (KERNEL32.233)
*/
DWORD WINAPI GetLogicalDrives(void)
{
DWORD ret = 0;
int drive;
for (drive = 0; drive < MAX_DOS_DRIVES; drive++)
if (DRIVE_IsValid(drive)) ret |= (1 << drive);
return ret;
}
/***********************************************************************
* GetVolumeInformation32A (KERNEL32.309)
*/
BOOL WINAPI GetVolumeInformationA( LPCSTR root, LPSTR label,
DWORD label_len, DWORD *serial,
DWORD *filename_len, DWORD *flags,
LPSTR fsname, DWORD fsname_len )
{
int drive;
char *cp;
/* FIXME, SetLastErrors missing */
if (!root) drive = DRIVE_GetCurrentDrive();
else
{
if ((root[1]) && (root[1] != ':'))
{
WARN_(dosfs)("invalid root '%s'\n",root);
return FALSE;
}
drive = toupper(root[0]) - 'A';
}
if (!DRIVE_IsValid( drive )) return FALSE;
if (label)
{
lstrcpynA( label, DRIVE_GetLabel(drive), label_len );
for (cp = label; *cp; cp++);
while (cp != label && *(cp-1) == ' ') cp--;
*cp = '\0';
}
if (serial) *serial = DRIVE_GetSerialNumber(drive);
/* Set the filesystem information */
/* Note: we only emulate a FAT fs at the present */
if (filename_len) {
if (DOSDrives[drive].flags & DRIVE_SHORT_NAMES)
*filename_len = 12;
else
*filename_len = 255;
}
if (flags)
{
*flags=0;
if (DOSDrives[drive].flags & DRIVE_CASE_SENSITIVE)
*flags|=FS_CASE_SENSITIVE;
if (DOSDrives[drive].flags & DRIVE_CASE_PRESERVING)
*flags|=FS_CASE_IS_PRESERVED ;
}
if (fsname) {
/* Diablo checks that return code ... */
if (DRIVE_GetType(drive)==TYPE_CDROM)
lstrcpynA( fsname, "CDFS", fsname_len );
else
lstrcpynA( fsname, "FAT", fsname_len );
}
return TRUE;
}
/***********************************************************************
* GetVolumeInformation32W (KERNEL32.310)
*/
BOOL WINAPI GetVolumeInformationW( LPCWSTR root, LPWSTR label,
DWORD label_len, DWORD *serial,
DWORD *filename_len, DWORD *flags,
LPWSTR fsname, DWORD fsname_len )
{
LPSTR xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
LPSTR xvolname = label ? HeapAlloc(GetProcessHeap(),0,label_len) : NULL;
LPSTR xfsname = fsname ? HeapAlloc(GetProcessHeap(),0,fsname_len) : NULL;
BOOL ret = GetVolumeInformationA( xroot, xvolname, label_len, serial,
filename_len, flags, xfsname,
fsname_len );
if (ret)
{
if (label) lstrcpyAtoW( label, xvolname );
if (fsname) lstrcpyAtoW( fsname, xfsname );
}
HeapFree( GetProcessHeap(), 0, xroot );
HeapFree( GetProcessHeap(), 0, xvolname );
HeapFree( GetProcessHeap(), 0, xfsname );
return ret;
}
/***********************************************************************
* SetVolumeLabelA (KERNEL32.675)
*/
BOOL WINAPI SetVolumeLabelA(LPCSTR rootpath,LPCSTR volname)
{
FIXME_(dosfs)("(%s,%s),stub!\n",rootpath,volname);
return TRUE;
}
/***********************************************************************
* SetVolumeLabelW (KERNEL32.676)
*/
BOOL WINAPI SetVolumeLabelW(LPCWSTR rootpath,LPCWSTR volname)
{
LPSTR xroot, xvol;
BOOL ret;
xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, rootpath);
xvol = HEAP_strdupWtoA( GetProcessHeap(), 0, volname);
ret = SetVolumeLabelA( xroot, xvol );
HeapFree( GetProcessHeap(), 0, xroot );
HeapFree( GetProcessHeap(), 0, xvol );
return ret;
}