system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

mountmgr: Use wide character string literals.

Browse source 
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Alexandre Julliard 2021-11-29 17:32:46 +01:00
parent 406309e133
commit f98d956e52
2 changed files with 75 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

168
dlls/mountmgr.sys/device.c
View file

@ -43,27 +43,16 @@ WINE_DEFAULT_DEBUG_CHANNEL(mountmgr);
static const WCHAR drive_types[][8] = static const WCHAR drive_types[][8] =
{ {
{ 0 }, /* DEVICE_UNKNOWN */ L"", /* DEVICE_UNKNOWN */
{ 0 }, /* DEVICE_HARDDISK */ L"", /* DEVICE_HARDDISK */
{'h','d',0}, /* DEVICE_HARDDISK_VOL */ L"hd", /* DEVICE_HARDDISK_VOL */
{'f','l','o','p','p','y',0}, /* DEVICE_FLOPPY */ L"floppy", /* DEVICE_FLOPPY */
{'c','d','r','o','m',0}, /* DEVICE_CDROM */ L"cdrom", /* DEVICE_CDROM */
{'c','d','r','o','m',0}, /* DEVICE_DVD */ L"cdrom", /* DEVICE_DVD */
{'n','e','t','w','o','r','k',0}, /* DEVICE_NETWORK */ L"network", /* DEVICE_NETWORK */
{'r','a','m','d','i','s','k',0} /* DEVICE_RAMDISK */ L"ramdisk" /* DEVICE_RAMDISK */
}; };
static const WCHAR drives_keyW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\','D','r','i','v','e','s',0};
static const WCHAR ports_keyW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\','P','o','r','t','s',0};
static const WCHAR scsi_keyW[] = {'H','A','R','D','W','A','R','E','\\','D','E','V','I','C','E','M','A','P','\\','S','c','s','i',0};
static const WCHAR scsi_port_keyW[] = {'S','c','s','i',' ','P','o','r','t',' ','%','d',0};
static const WCHAR scsi_bus_keyW[] = {'S','c','s','i',' ','B','u','s',' ','%','d',0};
static const WCHAR target_id_keyW[] = {'T','a','r','g','e','t',' ','I','d',' ','%','d',0};
static const WCHAR lun_keyW[] = {'L','o','g','i','c','a','l',' ','U','n','i','t',' ','I','d',' ','%','d',0};
static const WCHAR devnameW[] = {'D','e','v','i','c','e','N','a','m','e',0};
enum fs_type enum fs_type
{ {
FS_ERROR, /* error accessing the device */ FS_ERROR, /* error accessing the device */
@ -629,15 +618,6 @@ static DWORD VOLUME_GetAudioCDSerial( const CDROM_TOC *toc )
/* create the disk device for a given volume */ /* create the disk device for a given volume */
static NTSTATUS create_disk_device( enum device_type type, struct disk_device **device_ret, struct volume *volume ) static NTSTATUS create_disk_device( enum device_type type, struct disk_device **device_ret, struct volume *volume )
{ {
static const WCHAR harddiskvolW[] = {'\\','D','e','v','i','c','e',
'\\','H','a','r','d','d','i','s','k','V','o','l','u','m','e','%','u',0};
static const WCHAR harddiskW[] = {'\\','D','e','v','i','c','e','\\','H','a','r','d','d','i','s','k','%','u',0};
static const WCHAR cdromW[] = {'\\','D','e','v','i','c','e','\\','C','d','R','o','m','%','u',0};
static const WCHAR floppyW[] = {'\\','D','e','v','i','c','e','\\','F','l','o','p','p','y','%','u',0};
static const WCHAR ramdiskW[] = {'\\','D','e','v','i','c','e','\\','R','a','m','d','i','s','k','%','u',0};
static const WCHAR cdromlinkW[] = {'\\','?','?','\\','C','d','R','o','m','%','u',0};
static const WCHAR physdriveW[] = {'\\','?','?','\\','P','h','y','s','i','c','a','l','D','r','i','v','e','%','u',0};
UINT i, first = 0; UINT i, first = 0;
NTSTATUS status = 0; NTSTATUS status = 0;
const WCHAR *format = NULL; const WCHAR *format = NULL;
@ -651,23 +631,23 @@ static NTSTATUS create_disk_device( enum device_type type, struct disk_device **
case DEVICE_UNKNOWN: case DEVICE_UNKNOWN:
case DEVICE_HARDDISK: case DEVICE_HARDDISK:
case DEVICE_NETWORK: /* FIXME */ case DEVICE_NETWORK: /* FIXME */
format = harddiskW; format = L"\\Device\\Harddisk%u";
link_format = physdriveW; link_format = L"\\??\\PhysicalDrive%u";
break; break;
case DEVICE_HARDDISK_VOL: case DEVICE_HARDDISK_VOL:
format = harddiskvolW; format = L"\\Device\\HarddiskVolume%u";
first = 1; /* harddisk volumes start counting from 1 */ first = 1; /* harddisk volumes start counting from 1 */
break; break;
case DEVICE_FLOPPY: case DEVICE_FLOPPY:
format = floppyW; format = L"\\Device\\Floppy%u";
break; break;
case DEVICE_CDROM: case DEVICE_CDROM:
case DEVICE_DVD: case DEVICE_DVD:
format = cdromW; format = L"\\Device\\CdRom%u";
link_format = cdromlinkW; link_format = L"\\??\\CdRom%u";
break; break;
case DEVICE_RAMDISK: case DEVICE_RAMDISK:
format = ramdiskW; format = L"\\Device\\Ramdisk%u";
break; break;
} }
@ -929,9 +909,8 @@ static BOOL get_volume_device_info( struct volume *volume )
{ {
if (!(toc.TrackData[0].Control & 0x04)) /* audio track */ if (!(toc.TrackData[0].Control & 0x04)) /* audio track */
{ {
static const WCHAR audiocdW[] = {'A','u','d','i','o',' ','C','D',0};
TRACE( "%s: found audio CD\n", debugstr_a(unix_device) ); TRACE( "%s: found audio CD\n", debugstr_a(unix_device) );
lstrcpynW( volume->label, audiocdW, ARRAY_SIZE(volume->label) ); wcscpy( volume->label, L"Audio CD" );
volume->serial = VOLUME_GetAudioCDSerial( &toc ); volume->serial = VOLUME_GetAudioCDSerial( &toc );
volume->fs_type = FS_ISO9660; volume->fs_type = FS_ISO9660;
CloseHandle( handle ); CloseHandle( handle );
@ -1091,9 +1070,9 @@ static void create_drive_devices(void)
unsigned int i; unsigned int i;
HKEY drives_key; HKEY drives_key;
enum device_type drive_type; enum device_type drive_type;
WCHAR driveW[] = {'a',':',0}; WCHAR driveW[] = L"a:";
if (RegOpenKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &drives_key )) drives_key = 0; if (RegOpenKeyW( HKEY_LOCAL_MACHINE, L"Software\\Wine\\Drives", &drives_key )) drives_key = 0;
for (i = 0; i < MAX_DOS_DRIVES; i++) for (i = 0; i < MAX_DOS_DRIVES; i++)
{ {
@ -1145,12 +1124,6 @@ static void create_drive_devices(void)
static void create_scsi_entry( struct volume *volume, const struct scsi_info *info ) static void create_scsi_entry( struct volume *volume, const struct scsi_info *info )
{ {
static UCHAR tape_no = 0; static UCHAR tape_no = 0;
static const WCHAR tapeW[] = {'T','a','p','e','%','d',0};
static const WCHAR init_id_keyW[] = {'I','n','i','t','i','a','t','o','r',' ','I','d',' ','%','d',0};
static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
static const WCHAR bus_time_scanW[] = {'F','i','r','s','t','B','u','s','T','i','m','e','S','c','a','n','I','n','M','s',0};
static const WCHAR typeW[] = {'T','y','p','e',0};
static const WCHAR identW[] = {'I','d','e','n','t','i','f','i','e','r',0};
WCHAR dataW[50]; WCHAR dataW[50];
DWORD sizeW; DWORD sizeW;
@ -1162,32 +1135,32 @@ static void create_scsi_entry( struct volume *volume, const struct scsi_info *in
HKEY target_key; HKEY target_key;
HKEY lun_key; HKEY lun_key;
if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, scsi_keyW, 0, KEY_READ|KEY_WRITE, &scsi_key )) return; if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\Scsi", 0, KEY_READ|KEY_WRITE, &scsi_key )) return;
swprintf( dataW, ARRAY_SIZE( dataW ), scsi_port_keyW, info->addr.PortNumber ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Scsi Port %d", info->addr.PortNumber );
if (RegCreateKeyExW( scsi_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &port_key, NULL )) return; if (RegCreateKeyExW( scsi_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &port_key, NULL )) return;
RegCloseKey( scsi_key ); RegCloseKey( scsi_key );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, info->driver, strlen(info->driver)+1); RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, info->driver, strlen(info->driver)+1);
RegSetValueExW( port_key, driverW, 0, REG_SZ, (const BYTE *)dataW, sizeW ); RegSetValueExW( port_key, L"Driver", 0, REG_SZ, (const BYTE *)dataW, sizeW );
value = 10; value = 10;
RegSetValueExW( port_key, bus_time_scanW, 0, REG_DWORD, (const BYTE *)&value, sizeof(value)); RegSetValueExW( port_key, L"FirstBusTimeScanInMs", 0, REG_DWORD, (const BYTE *)&value, sizeof(value));
value = 0; value = 0;
swprintf( dataW, ARRAY_SIZE( dataW ), scsi_bus_keyW, info->addr.PathId ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Scsi Bus %d", info->addr.PathId );
if (RegCreateKeyExW( port_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &bus_key, NULL )) return; if (RegCreateKeyExW( port_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &bus_key, NULL )) return;
RegCloseKey( port_key ); RegCloseKey( port_key );
swprintf( dataW, ARRAY_SIZE( dataW ), init_id_keyW, info->init_id ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Initiator Id %d", info->init_id );
if (RegCreateKeyExW( bus_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &target_key, NULL )) return; if (RegCreateKeyExW( bus_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &target_key, NULL )) return;
RegCloseKey( target_key ); RegCloseKey( target_key );
swprintf( dataW, ARRAY_SIZE( dataW ), target_id_keyW, info->addr.TargetId ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Target Id %d", info->addr.TargetId );
if (RegCreateKeyExW( bus_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &target_key, NULL )) return; if (RegCreateKeyExW( bus_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &target_key, NULL )) return;
RegCloseKey( bus_key ); RegCloseKey( bus_key );
swprintf( dataW, ARRAY_SIZE( dataW ), lun_keyW, info->addr.Lun ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Logical Unit Id %d", info->addr.Lun );
if (RegCreateKeyExW( target_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &lun_key, NULL )) return; if (RegCreateKeyExW( target_key, dataW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &lun_key, NULL )) return;
RegCloseKey( target_key ); RegCloseKey( target_key );
@ -1216,22 +1189,22 @@ static void create_scsi_entry( struct volume *volume, const struct scsi_info *in
default: data = "OtherPeripheral"; break; default: data = "OtherPeripheral"; break;
} }
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, data, strlen(data)+1); RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, data, strlen(data)+1);
RegSetValueExW( lun_key, typeW, 0, REG_SZ, (const BYTE *)dataW, sizeW ); RegSetValueExW( lun_key, L"Type", 0, REG_SZ, (const BYTE *)dataW, sizeW );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, info->model, strlen(info->model)+1); RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &sizeW, info->model, strlen(info->model)+1);
RegSetValueExW( lun_key, identW, 0, REG_SZ, (const BYTE *)dataW, sizeW ); RegSetValueExW( lun_key, L"Identifier", 0, REG_SZ, (const BYTE *)dataW, sizeW );
if (volume) if (volume)
{ {
UNICODE_STRING *dev = &volume->device->name; UNICODE_STRING *dev = &volume->device->name;
WCHAR *buffer = wcschr( dev->Buffer+1, '\\' ) + 1; WCHAR *buffer = wcschr( dev->Buffer+1, '\\' ) + 1;
ULONG length = dev->Length - (buffer - dev->Buffer)*sizeof(WCHAR); ULONG length = dev->Length - (buffer - dev->Buffer)*sizeof(WCHAR);
RegSetValueExW( lun_key, devnameW, 0, REG_SZ, (const BYTE *)buffer, length ); RegSetValueExW( lun_key, L"DeviceName", 0, REG_SZ, (const BYTE *)buffer, length );
} }
else if (info->type == SCSI_TAPE_PERIPHERAL) else if (info->type == SCSI_TAPE_PERIPHERAL)
{ {
swprintf( dataW, ARRAY_SIZE( dataW ), tapeW, tape_no++ ); swprintf( dataW, ARRAY_SIZE( dataW ), L"Tape%d", tape_no++ );
RegSetValueExW( lun_key, devnameW, 0, REG_SZ, (const BYTE *)dataW, lstrlenW( dataW ) ); RegSetValueExW( lun_key, L"DeviceName", 0, REG_SZ, (const BYTE *)dataW, lstrlenW( dataW ) );
} }
RegCloseKey( lun_key ); RegCloseKey( lun_key );
@ -1354,10 +1327,10 @@ found:
wine_dbgstr_a(mount_point), type ); wine_dbgstr_a(mount_point), type );
/* hack: force the drive type in the registry */ /* hack: force the drive type in the registry */
if (!RegCreateKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey )) if (!RegCreateKeyW( HKEY_LOCAL_MACHINE, L"Software\\Wine\\Drives", &hkey ))
{ {
const WCHAR *type_name = drive_types[type]; const WCHAR *type_name = drive_types[type];
WCHAR name[] = {'a',':',0}; WCHAR name[] = L"a:";
name[0] += drive->drive; name[0] += drive->drive;
if (!type_name[0] && type == DEVICE_HARDDISK) type_name = drive_types[DEVICE_FLOPPY]; if (!type_name[0] && type == DEVICE_HARDDISK) type_name = drive_types[DEVICE_FLOPPY];
@ -1405,9 +1378,9 @@ NTSTATUS remove_dos_device( int letter, const char *udi )
MOUNTMGR_CALL( set_dosdev_symlink, &params ); MOUNTMGR_CALL( set_dosdev_symlink, &params );
/* clear the registry key too */ /* clear the registry key too */
if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey )) if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, L"Software\\Wine\\Drives", &hkey ))
{ {
WCHAR name[] = {'a',':',0}; WCHAR name[] = L"a:";
name[0] += drive->drive; name[0] += drive->drive;
RegDeleteValueW( hkey, name ); RegDeleteValueW( hkey, name );
RegCloseKey( hkey ); RegCloseKey( hkey );
@ -1688,14 +1661,9 @@ static NTSTATUS WINAPI harddisk_query_volume( DEVICE_OBJECT *device, IRP *irp )
} }
case FileFsAttributeInformation: case FileFsAttributeInformation:
{ {
static const WCHAR fatW[] = {'F','A','T'};
static const WCHAR fat32W[] = {'F','A','T','3','2'};
static const WCHAR ntfsW[] = {'N','T','F','S'};
static const WCHAR cdfsW[] = {'C','D','F','S'};
static const WCHAR udfW[] = {'U','D','F'};
FILE_FS_ATTRIBUTE_INFORMATION *info = irp->AssociatedIrp.SystemBuffer; FILE_FS_ATTRIBUTE_INFORMATION *info = irp->AssociatedIrp.SystemBuffer;
enum mountmgr_fs_type fs_type = get_mountmgr_fs_type(volume->fs_type); enum mountmgr_fs_type fs_type = get_mountmgr_fs_type(volume->fs_type);
const WCHAR *fsname;
if (length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION)) if (length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION))
{ {
@ -1706,37 +1674,33 @@ static NTSTATUS WINAPI harddisk_query_volume( DEVICE_OBJECT *device, IRP *irp )
switch (fs_type) switch (fs_type)
{ {
case MOUNTMGR_FS_TYPE_ISO9660: case MOUNTMGR_FS_TYPE_ISO9660:
fsname = L"CDFS";
info->FileSystemAttributes = FILE_READ_ONLY_VOLUME; info->FileSystemAttributes = FILE_READ_ONLY_VOLUME;
info->MaximumComponentNameLength = 221; info->MaximumComponentNameLength = 221;
info->FileSystemNameLength = min( sizeof(cdfsW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, cdfsW, info->FileSystemNameLength);
break; break;
case MOUNTMGR_FS_TYPE_UDF: case MOUNTMGR_FS_TYPE_UDF:
fsname = L"UDF";
info->FileSystemAttributes = FILE_READ_ONLY_VOLUME | FILE_UNICODE_ON_DISK | FILE_CASE_SENSITIVE_SEARCH; info->FileSystemAttributes = FILE_READ_ONLY_VOLUME | FILE_UNICODE_ON_DISK | FILE_CASE_SENSITIVE_SEARCH;
info->MaximumComponentNameLength = 255; info->MaximumComponentNameLength = 255;
info->FileSystemNameLength = min( sizeof(udfW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, udfW, info->FileSystemNameLength);
break; break;
case MOUNTMGR_FS_TYPE_FAT: case MOUNTMGR_FS_TYPE_FAT:
fsname = L"FAT";
info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */ info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */
info->MaximumComponentNameLength = 255; info->MaximumComponentNameLength = 255;
info->FileSystemNameLength = min( sizeof(fatW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, fatW, info->FileSystemNameLength);
break; break;
case MOUNTMGR_FS_TYPE_FAT32: case MOUNTMGR_FS_TYPE_FAT32:
fsname = L"FAT32";
info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */ info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES; /* FIXME */
info->MaximumComponentNameLength = 255; info->MaximumComponentNameLength = 255;
info->FileSystemNameLength = min( sizeof(fat32W), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, fat32W, info->FileSystemNameLength);
break; break;
default: default:
fsname = L"NTFS";
info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES | FILE_PERSISTENT_ACLS; info->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES | FILE_PERSISTENT_ACLS;
info->MaximumComponentNameLength = 255; info->MaximumComponentNameLength = 255;
info->FileSystemNameLength = min( sizeof(ntfsW), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, ntfsW, info->FileSystemNameLength);
break; break;
} }
info->FileSystemNameLength = min( wcslen(fsname) * sizeof(WCHAR), length - offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) );
memcpy(info->FileSystemName, fsname, info->FileSystemNameLength);
io->Information = offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) + info->FileSystemNameLength; io->Information = offsetof( FILE_FS_ATTRIBUTE_INFORMATION, FileSystemName ) + info->FileSystemNameLength;
status = STATUS_SUCCESS; status = STATUS_SUCCESS;
break; break;
@ -1868,14 +1832,6 @@ NTSTATUS WINAPI harddisk_driver_entry( DRIVER_OBJECT *driver, UNICODE_STRING *pa
static BOOL create_port_device( DRIVER_OBJECT *driver, int n, const char *unix_path, static BOOL create_port_device( DRIVER_OBJECT *driver, int n, const char *unix_path,
const char *dosdevices_path, HKEY windows_ports_key ) const char *dosdevices_path, HKEY windows_ports_key )
{ {
static const WCHAR comW[] = {'C','O','M','%','u',0};
static const WCHAR lptW[] = {'L','P','T','%','u',0};
static const WCHAR device_serialW[] = {'\\','D','e','v','i','c','e','\\','S','e','r','i','a','l','%','u',0};
static const WCHAR device_parallelW[] = {'\\','D','e','v','i','c','e','\\','P','a','r','a','l','l','e','l','%','u',0};
static const WCHAR dosdevices_comW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','C','O','M','%','u',0};
static const WCHAR dosdevices_auxW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','A','U','X',0};
static const WCHAR dosdevices_lptW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','L','P','T','%','u',0};
static const WCHAR dosdevices_prnW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','P','R','N',0};
const WCHAR *dos_name_format, *nt_name_format, *reg_value_format, *symlink_format, *default_device; const WCHAR *dos_name_format, *nt_name_format, *reg_value_format, *symlink_format, *default_device;
WCHAR dos_name[7], reg_value[256], nt_buffer[32], symlink_buffer[32]; WCHAR dos_name[7], reg_value[256], nt_buffer[32], symlink_buffer[32];
UNICODE_STRING nt_name, symlink_name, default_name; UNICODE_STRING nt_name, symlink_name, default_name;
@ -1888,19 +1844,19 @@ static BOOL create_port_device( DRIVER_OBJECT *driver, int n, const char *unix_p
if (driver == serial_driver) if (driver == serial_driver)
{ {
dos_name_format = comW; dos_name_format = L"COM%u";
nt_name_format = device_serialW; nt_name_format = L"\\Device\\Serial%u";
reg_value_format = comW; reg_value_format = L"COM%u";
symlink_format = dosdevices_comW; symlink_format = L"\\DosDevices\\COM%u";
default_device = dosdevices_auxW; default_device = L"\\DosDevices\\AUX";
} }
else else
{ {
dos_name_format = lptW; dos_name_format = L"LPT%u";
nt_name_format = device_parallelW; nt_name_format = L"\\Device\\Parallel%u";
reg_value_format = dosdevices_lptW; reg_value_format = L"\\DosDevices\\LPT%u";
symlink_format = dosdevices_lptW; symlink_format = L"\\DosDevices\\LPT%u";
default_device = dosdevices_prnW; default_device = L"\\DosDevices\\PRN";
} }
swprintf( dos_name, ARRAY_SIZE(dos_name), dos_name_format, n ); swprintf( dos_name, ARRAY_SIZE(dos_name), dos_name_format, n );
@ -1936,14 +1892,6 @@ static BOOL create_port_device( DRIVER_OBJECT *driver, int n, const char *unix_p
/* find and create serial or parallel ports */ /* find and create serial or parallel ports */
static void create_port_devices( DRIVER_OBJECT *driver, const char *devices ) static void create_port_devices( DRIVER_OBJECT *driver, const char *devices )
{ {
static const WCHAR serialcomm_keyW[] = {'H','A','R','D','W','A','R','E','\\',
'D','E','V','I','C','E','M','A','P','\\',
'S','E','R','I','A','L','C','O','M','M',0};
static const WCHAR parallel_ports_keyW[] = {'H','A','R','D','W','A','R','E','\\',
'D','E','V','I','C','E','M','A','P','\\',
'P','A','R','A','L','L','E','L',' ','P','O','R','T','S',0};
static const WCHAR comW[] = {'C','O','M'};
static const WCHAR lptW[] = {'L','P','T'};
const WCHAR *windows_ports_key_name; const WCHAR *windows_ports_key_name;
const char *dosdev_fmt; const char *dosdev_fmt;
char dosdev[8]; char dosdev[8];
@ -1959,19 +1907,19 @@ static void create_port_devices( DRIVER_OBJECT *driver, const char *devices )
if (driver == serial_driver) if (driver == serial_driver)
{ {
dosdev_fmt = "com%u"; dosdev_fmt = "com%u";
windows_ports_key_name = serialcomm_keyW; windows_ports_key_name = L"HARDWARE\\DEVICEMAP\\SERIALCOMM";
port_prefix = comW; port_prefix = L"COM";
} }
else else
{ {
dosdev_fmt = "lpt%u"; dosdev_fmt = "lpt%u";
windows_ports_key_name = parallel_ports_keyW; windows_ports_key_name = L"HARDWARE\\DEVICEMAP\\PARALLEL PORTS";
port_prefix = lptW; port_prefix = L"LPT";
} }
/* @@ Wine registry key: HKLM\Software\Wine\Ports */ /* @@ Wine registry key: HKLM\Software\Wine\Ports */
RegCreateKeyExW( HKEY_LOCAL_MACHINE, ports_keyW, 0, NULL, 0, RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Wine\\Ports", 0, NULL, 0,
KEY_QUERY_VALUE, NULL, &wine_ports_key, NULL ); KEY_QUERY_VALUE, NULL, &wine_ports_key, NULL );
RegCreateKeyExW( HKEY_LOCAL_MACHINE, windows_ports_key_name, 0, NULL, REG_OPTION_VOLATILE, RegCreateKeyExW( HKEY_LOCAL_MACHINE, windows_ports_key_name, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &windows_ports_key, NULL ); KEY_ALL_ACCESS, NULL, &windows_ports_key, NULL );

53
dlls/mountmgr.sys/mountmgr.c
View file

@ -92,10 +92,9 @@ static struct mount_point *add_mount_point( DEVICE_OBJECT *device, UNICODE_STRIN
/* create the DosDevices mount point symlink for a new device */ /* create the DosDevices mount point symlink for a new device */
struct mount_point *add_dosdev_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name, int drive ) struct mount_point *add_dosdev_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name, int drive )
{ {
static const WCHAR driveW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','%','c',':',0}; WCHAR link[] = L"\\DosDevices\\A:";
WCHAR link[sizeof(driveW)];
swprintf( link, ARRAY_SIZE(link), driveW, 'A' + drive ); link[12] = 'A' + drive;
return add_mount_point( device, device_name, link ); return add_mount_point( device, device_name, link );
} }
@ -103,13 +102,10 @@ struct mount_point *add_dosdev_mount_point( DEVICE_OBJECT *device, UNICODE_STRIN
struct mount_point *add_volume_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name, struct mount_point *add_volume_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name,
const GUID *guid ) const GUID *guid )
{ {
static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{', WCHAR link[64];
'%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
'%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x',
'%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0};
WCHAR link[sizeof(volumeW)];
swprintf( link, ARRAY_SIZE(link), volumeW, guid->Data1, guid->Data2, guid->Data3, swprintf( link, ARRAY_SIZE(link), L"\\??\\Volume{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
guid->Data1, guid->Data2, guid->Data3,
guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]); guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
return add_mount_point( device, device_name, link ); return add_mount_point( device, device_name, link );
@ -620,25 +616,9 @@ static DWORD WINAPI run_loop_thread( void *arg )
/* main entry point for the mount point manager driver */ /* main entry point for the mount point manager driver */
NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path ) NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
{ {
static const WCHAR mounted_devicesW[] = {'S','y','s','t','e','m','\\','M','o','u','n','t','e','d','D','e','v','i','c','e','s',0};
static const WCHAR device_mountmgrW[] = {'\\','D','e','v','i','c','e','\\','M','o','u','n','t','P','o','i','n','t','M','a','n','a','g','e','r',0};
static const WCHAR link_mountmgrW[] = {'\\','?','?','\\','M','o','u','n','t','P','o','i','n','t','M','a','n','a','g','e','r',0};
static const WCHAR harddiskW[] = {'\\','D','r','i','v','e','r','\\','H','a','r','d','d','i','s','k',0};
static const WCHAR driver_serialW[] = {'\\','D','r','i','v','e','r','\\','S','e','r','i','a','l',0};
static const WCHAR driver_parallelW[] = {'\\','D','r','i','v','e','r','\\','P','a','r','a','l','l','e','l',0};
static const WCHAR devicemapW[] = {'H','A','R','D','W','A','R','E','\\','D','E','V','I','C','E','M','A','P','\\','S','c','s','i',0};
#ifdef _WIN64 #ifdef _WIN64
static const WCHAR qualified_ports_keyW[] = {'\\','R','E','G','I','S','T','R','Y','\\',
'M','A','C','H','I','N','E','\\','S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\','P','o','r','t','s'}; /* no null terminator */
static const WCHAR wow64_ports_keyW[] = {'S','o','f','t','w','a','r','e','\\',
'W','o','w','6','4','3','2','N','o','d','e','\\','W','i','n','e','\\',
'P','o','r','t','s',0};
static const WCHAR symbolic_link_valueW[] = {'S','y','m','b','o','l','i','c','L','i','n','k','V','a','l','u','e',0};
HKEY wow64_ports_key = NULL; HKEY wow64_ports_key = NULL;
#endif #endif
void *instance; void *instance;
UNICODE_STRING nameW, linkW; UNICODE_STRING nameW, linkW;
DEVICE_OBJECT *device; DEVICE_OBJECT *device;
@ -655,8 +635,8 @@ NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = mountmgr_ioctl; driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = mountmgr_ioctl;
RtlInitUnicodeString( &nameW, device_mountmgrW ); RtlInitUnicodeString( &nameW, L"\\Device\\MountPointManager" );
RtlInitUnicodeString( &linkW, link_mountmgrW ); RtlInitUnicodeString( &linkW, L"\\??\\MountPointManager" );
if (!(status = IoCreateDevice( driver, 0, &nameW, 0, 0, FALSE, &device ))) if (!(status = IoCreateDevice( driver, 0, &nameW, 0, 0, FALSE, &device )))
status = IoCreateSymbolicLink( &linkW, &nameW ); status = IoCreateSymbolicLink( &linkW, &nameW );
if (status) if (status)
@ -665,14 +645,14 @@ NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
return status; return status;
} }
RegCreateKeyExW( HKEY_LOCAL_MACHINE, mounted_devicesW, 0, NULL, RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\MountedDevices", 0, NULL,
REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &mount_key, NULL ); REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &mount_key, NULL );
if (!RegCreateKeyExW( HKEY_LOCAL_MACHINE, devicemapW, 0, NULL, REG_OPTION_VOLATILE, if (!RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\Scsi", 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &devicemap_key, NULL )) KEY_ALL_ACCESS, NULL, &devicemap_key, NULL ))
RegCloseKey( devicemap_key ); RegCloseKey( devicemap_key );
RtlInitUnicodeString( &nameW, harddiskW ); RtlInitUnicodeString( &nameW, L"\\Driver\\Harddisk" );
status = IoCreateDriver( &nameW, harddisk_driver_entry ); status = IoCreateDriver( &nameW, harddisk_driver_entry );
params.op_thread = CreateThread( NULL, 0, device_op_thread, NULL, 0, NULL ); params.op_thread = CreateThread( NULL, 0, device_op_thread, NULL, 0, NULL );
@ -681,17 +661,18 @@ NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
#ifdef _WIN64 #ifdef _WIN64
/* create a symlink so that the Wine port overrides key can be edited with 32-bit reg or regedit */ /* create a symlink so that the Wine port overrides key can be edited with 32-bit reg or regedit */
RegCreateKeyExW( HKEY_LOCAL_MACHINE, wow64_ports_keyW, 0, NULL, REG_OPTION_CREATE_LINK, RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Wow6432Node\\Wine\\Ports", 0, NULL,
KEY_SET_VALUE, NULL, &wow64_ports_key, NULL ); REG_OPTION_CREATE_LINK, KEY_SET_VALUE, NULL, &wow64_ports_key, NULL );
RegSetValueExW( wow64_ports_key, symbolic_link_valueW, 0, REG_LINK, RegSetValueExW( wow64_ports_key, L"SymbolicLinkValue", 0, REG_LINK,
(BYTE *)qualified_ports_keyW, sizeof(qualified_ports_keyW) ); (BYTE *)L"\\REGISTRY\\MACHINE\\Software\\Wine\\Ports",
sizeof(L"\\REGISTRY\\MACHINE\\Software\\Wine\\Ports") - sizeof(WCHAR) );
RegCloseKey( wow64_ports_key ); RegCloseKey( wow64_ports_key );
#endif #endif
RtlInitUnicodeString( &nameW, driver_serialW ); RtlInitUnicodeString( &nameW, L"\\Driver\\Serial" );
IoCreateDriver( &nameW, serial_driver_entry ); IoCreateDriver( &nameW, serial_driver_entry );
RtlInitUnicodeString( &nameW, driver_parallelW ); RtlInitUnicodeString( &nameW, L"\\Driver\\Parallel" );
IoCreateDriver( &nameW, parallel_driver_entry ); IoCreateDriver( &nameW, parallel_driver_entry );
return status; return status;