Sweden-Number/programs/winecfg/drive.c

373 lines
11 KiB
C

/*
* Drive management code
*
* Copyright 2003 Mark Westcott
* Copyright 2003-2004 Mike Hearn
* Copyright 2004 Chris Morgan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
*/
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ntstatus.h>
#define WIN32_NO_STATUS
#include <windef.h>
#include <winbase.h>
#include <winternl.h>
#include <winioctl.h>
#include <winreg.h>
#include <wine/debug.h>
#include <shellapi.h>
#include <objbase.h>
#include <shlguid.h>
#include <shlwapi.h>
#include <shlobj.h>
#define WINE_MOUNTMGR_EXTENSIONS
#include <ddk/mountmgr.h>
#include <wine/library.h>
#include "winecfg.h"
#include "resource.h"
WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
struct drive drives[26]; /* one for each drive letter */
static inline int letter_to_index(char letter)
{
return (toupper(letter) - 'A');
}
/* This function produces a mask for each drive letter that isn't
* currently used. Each bit of the long result represents a letter,
* with A being the least significant bit, and Z being the most
* significant.
*
* To calculate this, we loop over each letter, and see if we can get
* a drive entry for it. If so, we set the appropriate bit. At the
* end, we flip each bit, to give the desired result.
*
* The letter parameter is always marked as being available. This is
* so the edit dialog can display the currently used drive letter
* alongside the available ones.
*/
long drive_available_mask(char letter)
{
long result = 0;
int i;
WINE_TRACE("\n");
for(i = 0; i < 26; i++)
{
if (!drives[i].in_use) continue;
result |= (1 << (letter_to_index(drives[i].letter)));
}
result = ~result;
if (letter) result |= DRIVE_MASK_BIT(letter);
WINE_TRACE("finished drive letter loop with %lx\n", result);
return result;
}
BOOL add_drive(char letter, const char *targetpath, const char *device, const WCHAR *label,
DWORD serial, DWORD type)
{
int driveIndex = letter_to_index(letter);
if(drives[driveIndex].in_use)
return FALSE;
WINE_TRACE("letter == '%c', unixpath == %s, device == %s, label == %s, serial == %08x, type == %d\n",
letter, wine_dbgstr_a(targetpath), wine_dbgstr_a(device),
wine_dbgstr_w(label), serial, type);
drives[driveIndex].letter = toupper(letter);
drives[driveIndex].unixpath = strdupA(targetpath);
drives[driveIndex].device = device ? strdupA(device) : NULL;
drives[driveIndex].label = label ? strdupW(label) : NULL;
drives[driveIndex].serial = serial;
drives[driveIndex].type = type;
drives[driveIndex].in_use = TRUE;
drives[driveIndex].modified = TRUE;
return TRUE;
}
/* deallocates the contents of the drive. does not free the drive itself */
void delete_drive(struct drive *d)
{
HeapFree(GetProcessHeap(), 0, d->unixpath);
d->unixpath = NULL;
HeapFree(GetProcessHeap(), 0, d->device);
d->device = NULL;
HeapFree(GetProcessHeap(), 0, d->label);
d->label = NULL;
d->serial = 0;
d->in_use = FALSE;
d->modified = TRUE;
}
static DWORD get_drive_type( char letter )
{
HKEY hKey;
char driveValue[4];
DWORD ret = DRIVE_UNKNOWN;
sprintf(driveValue, "%c:", letter);
if (RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hKey) != ERROR_SUCCESS)
WINE_TRACE(" Unable to open Software\\Wine\\Drives\n" );
else
{
char buffer[80];
DWORD size = sizeof(buffer);
if (!RegQueryValueExA( hKey, driveValue, NULL, NULL, (LPBYTE)buffer, &size ))
{
WINE_TRACE("Got type '%s' for %s\n", buffer, driveValue );
if (!lstrcmpi( buffer, "hd" )) ret = DRIVE_FIXED;
else if (!lstrcmpi( buffer, "network" )) ret = DRIVE_REMOTE;
else if (!lstrcmpi( buffer, "floppy" )) ret = DRIVE_REMOVABLE;
else if (!lstrcmpi( buffer, "cdrom" )) ret = DRIVE_CDROM;
}
RegCloseKey(hKey);
}
return ret;
}
static void set_drive_label( char letter, const WCHAR *label )
{
static const WCHAR emptyW[1];
WCHAR device[] = {'a',':','\\',0}; /* SetVolumeLabel() requires a trailing slash */
device[0] = letter;
if (!label) label = emptyW;
if(!SetVolumeLabelW(device, label))
{
WINE_WARN("unable to set volume label for devicename of %s, label of %s\n",
wine_dbgstr_w(device), wine_dbgstr_w(label));
PRINTERROR();
}
else
{
WINE_TRACE(" set volume label for devicename of %s, label of %s\n",
wine_dbgstr_w(device), wine_dbgstr_w(label));
}
}
/* set the drive serial number via a .windows-serial file */
static void set_drive_serial( char letter, DWORD serial )
{
char filename[] = "a:\\.windows-serial";
HANDLE hFile;
filename[0] = letter;
WINE_TRACE("Putting serial number of %08X into file '%s'\n", serial, filename);
hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
DWORD w;
char buffer[16];
sprintf( buffer, "%X\n", serial );
WriteFile(hFile, buffer, strlen(buffer), &w, NULL);
CloseHandle(hFile);
}
}
#if 0
/* currently unused, but if users have this burning desire to be able to rename drives,
we can put it back in.
*/
BOOL copyDrive(struct drive *pSrc, struct drive *pDst)
{
if(pDst->in_use)
{
WINE_TRACE("pDst already in use\n");
return FALSE;
}
if(!pSrc->unixpath) WINE_TRACE("!pSrc->unixpath\n");
if(!pSrc->label) WINE_TRACE("!pSrc->label\n");
if(!pSrc->serial) WINE_TRACE("!pSrc->serial\n");
pDst->unixpath = strdupA(pSrc->unixpath);
pDst->label = strdupA(pSrc->label);
pDst->serial = strdupA(pSrc->serial);
pDst->type = pSrc->type;
pDst->in_use = TRUE;
return TRUE;
}
BOOL moveDrive(struct drive *pSrc, struct drive *pDst)
{
WINE_TRACE("pSrc->letter == %c, pDst->letter == %c\n", pSrc->letter, pDst->letter);
if(!copyDrive(pSrc, pDst))
{
WINE_TRACE("copyDrive failed\n");
return FALSE;
}
delete_drive(pSrc);
return TRUE;
}
#endif
static HANDLE open_mountmgr(void)
{
HANDLE ret;
if ((ret = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
0, 0 )) == INVALID_HANDLE_VALUE)
WINE_ERR( "failed to open mount manager err %u\n", GetLastError() );
return ret;
}
/* Load currently defined drives into the drives array */
BOOL load_drives(void)
{
DWORD i, size = 1024;
HANDLE mgr;
WCHAR root[] = {'A',':',0};
if ((mgr = open_mountmgr()) == INVALID_HANDLE_VALUE) return FALSE;
while (root[0] <= 'Z')
{
struct mountmgr_unix_drive input;
struct mountmgr_unix_drive *data;
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) break;
memset( &input, 0, sizeof(input) );
input.letter = root[0];
if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE, &input, sizeof(input),
data, size, NULL, NULL ))
{
char *unixpath = NULL, *device = NULL;
WCHAR volname[MAX_PATH];
DWORD serial;
if (data->mount_point_offset) unixpath = (char *)data + data->mount_point_offset;
if (data->device_offset) device = (char *)data + data->device_offset;
if (!GetVolumeInformationW( root, volname, sizeof(volname)/sizeof(WCHAR),
&serial, NULL, NULL, NULL, 0 ))
{
volname[0] = 0;
serial = 0;
}
if (unixpath) /* FIXME: handle unmounted drives too */
add_drive( root[0], unixpath, device, volname, serial, get_drive_type(root[0]) );
root[0]++;
}
else
{
if (GetLastError() == ERROR_MORE_DATA) size = data->size;
else root[0]++; /* skip this drive */
}
HeapFree( GetProcessHeap(), 0, data );
}
/* reset modified flags */
for (i = 0; i < 26; i++) drives[i].modified = FALSE;
CloseHandle( mgr );
return TRUE;
}
/* some of this code appears to be broken by bugs in Wine: the label
* setting code has no effect, for instance */
void apply_drive_changes(void)
{
int i;
HANDLE mgr;
DWORD len;
struct mountmgr_unix_drive *ioctl;
WINE_TRACE("\n");
if ((mgr = open_mountmgr()) == INVALID_HANDLE_VALUE) return;
/* add each drive and remove as we go */
for(i = 0; i < 26; i++)
{
if (!drives[i].modified) continue;
drives[i].modified = FALSE;
len = sizeof(*ioctl);
if (drives[i].in_use)
{
len += strlen(drives[i].unixpath) + 1;
if (drives[i].device) len += strlen(drives[i].device) + 1;
}
if (!(ioctl = HeapAlloc( GetProcessHeap(), 0, len ))) continue;
ioctl->size = len;
ioctl->letter = 'a' + i;
ioctl->device_offset = 0;
if (drives[i].in_use)
{
char *ptr = (char *)(ioctl + 1);
ioctl->type = drives[i].type;
strcpy( ptr, drives[i].unixpath );
ioctl->mount_point_offset = ptr - (char *)ioctl;
if (drives[i].device)
{
ptr += strlen(ptr) + 1;
strcpy( ptr, drives[i].device );
ioctl->device_offset = ptr - (char *)ioctl;
}
}
else
{
ioctl->type = DRIVE_NO_ROOT_DIR;
ioctl->mount_point_offset = 0;
}
if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_DEFINE_UNIX_DRIVE, ioctl, len, NULL, 0, NULL, NULL ))
{
set_drive_label( drives[i].letter, drives[i].label );
if (drives[i].in_use) set_drive_serial( drives[i].letter, drives[i].serial );
WINE_TRACE( "set drive %c: to %s type %u\n", 'a' + i,
wine_dbgstr_a(drives[i].unixpath), drives[i].type );
}
else WINE_WARN( "failed to set drive %c: to %s type %u err %u\n", 'a' + i,
wine_dbgstr_a(drives[i].unixpath), drives[i].type, GetLastError() );
}
CloseHandle( mgr );
}