1046 lines
32 KiB
C
1046 lines
32 KiB
C
/*
|
|
* Win32 device functions
|
|
*
|
|
* Copyright 1998 Marcus Meissner
|
|
* Copyright 1998 Ulrich Weigand
|
|
* Copyright 1998 Patrik Stridvall
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
# include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
# include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
# include <arpa/inet.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <time.h>
|
|
|
|
#include "ntstatus.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winreg.h"
|
|
#include "winerror.h"
|
|
#include "winnls.h"
|
|
#include "file.h"
|
|
#include "winioctl.h"
|
|
#include "winnt.h"
|
|
#include "iphlpapi.h"
|
|
#include "kernel_private.h"
|
|
#include "wine/server.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(file);
|
|
|
|
|
|
static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_DHCP(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_HASP (DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_NetBIOS(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
static BOOL DeviceIo_VNB(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped);
|
|
|
|
/*
|
|
* VxD names are taken from the Win95 DDK
|
|
*/
|
|
|
|
struct VxDInfo
|
|
{
|
|
LPCSTR name;
|
|
WORD id;
|
|
BOOL (*deviceio)(DWORD, LPVOID, DWORD,
|
|
LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
|
|
};
|
|
|
|
static const struct VxDInfo VxDList[] =
|
|
{
|
|
/* Standard VxD IDs */
|
|
{ "VMM", 0x0001, NULL },
|
|
{ "DEBUG", 0x0002, NULL },
|
|
{ "VPICD", 0x0003, NULL },
|
|
{ "VDMAD", 0x0004, NULL },
|
|
{ "VTD", 0x0005, NULL },
|
|
{ "V86MMGR", 0x0006, NULL },
|
|
{ "PAGESWAP", 0x0007, NULL },
|
|
{ "PARITY", 0x0008, NULL },
|
|
{ "REBOOT", 0x0009, NULL },
|
|
{ "VDD", 0x000A, NULL },
|
|
{ "VSD", 0x000B, NULL },
|
|
{ "VMD", 0x000C, NULL },
|
|
{ "VKD", 0x000D, NULL },
|
|
{ "VCD", 0x000E, DeviceIo_VCD },
|
|
{ "VPD", 0x000F, NULL },
|
|
{ "BLOCKDEV", 0x0010, NULL },
|
|
{ "VMCPD", 0x0011, NULL },
|
|
{ "EBIOS", 0x0012, NULL },
|
|
{ "BIOSXLAT", 0x0013, NULL },
|
|
{ "VNETBIOS", 0x0014, DeviceIo_NetBIOS },
|
|
{ "DOSMGR", 0x0015, NULL },
|
|
{ "WINLOAD", 0x0016, NULL },
|
|
{ "SHELL", 0x0017, NULL },
|
|
{ "VMPOLL", 0x0018, NULL },
|
|
{ "VPROD", 0x0019, NULL },
|
|
{ "DOSNET", 0x001A, NULL },
|
|
{ "VFD", 0x001B, NULL },
|
|
{ "VDD2", 0x001C, NULL },
|
|
{ "WINDEBUG", 0x001D, NULL },
|
|
{ "TSRLOAD", 0x001E, NULL },
|
|
{ "BIOSHOOK", 0x001F, NULL },
|
|
{ "INT13", 0x0020, NULL },
|
|
{ "PAGEFILE", 0x0021, NULL },
|
|
{ "SCSI", 0x0022, NULL },
|
|
{ "MCA_POS", 0x0023, NULL },
|
|
{ "SCSIFD", 0x0024, NULL },
|
|
{ "VPEND", 0x0025, NULL },
|
|
{ "VPOWERD", 0x0026, NULL },
|
|
{ "VXDLDR", 0x0027, NULL },
|
|
{ "NDIS", 0x0028, NULL },
|
|
{ "BIOS_EXT", 0x0029, NULL },
|
|
{ "VWIN32", 0x002A, DeviceIo_VWin32 },
|
|
{ "VCOMM", 0x002B, NULL },
|
|
{ "SPOOLER", 0x002C, NULL },
|
|
{ "WIN32S", 0x002D, NULL },
|
|
{ "DEBUGCMD", 0x002E, NULL },
|
|
|
|
{ "VNB", 0x0031, DeviceIo_VNB },
|
|
{ "SERVER", 0x0032, NULL },
|
|
{ "CONFIGMG", 0x0033, NULL },
|
|
{ "DWCFGMG", 0x0034, NULL },
|
|
{ "SCSIPORT", 0x0035, NULL },
|
|
{ "VFBACKUP", 0x0036, NULL },
|
|
{ "ENABLE", 0x0037, NULL },
|
|
{ "VCOND", 0x0038, NULL },
|
|
|
|
{ "EFAX", 0x003A, NULL },
|
|
{ "DSVXD", 0x003B, NULL },
|
|
{ "ISAPNP", 0x003C, NULL },
|
|
{ "BIOS", 0x003D, NULL },
|
|
{ "WINSOCK", 0x003E, NULL },
|
|
{ "WSOCK", 0x003E, NULL },
|
|
{ "WSIPX", 0x003F, NULL },
|
|
{ "IFSMgr", 0x0040, DeviceIo_IFSMgr },
|
|
{ "VCDFSD", 0x0041, NULL },
|
|
{ "MRCI2", 0x0042, NULL },
|
|
{ "PCI", 0x0043, NULL },
|
|
{ "PELOADER", 0x0044, NULL },
|
|
{ "EISA", 0x0045, NULL },
|
|
{ "DRAGCLI", 0x0046, NULL },
|
|
{ "DRAGSRV", 0x0047, NULL },
|
|
{ "PERF", 0x0048, NULL },
|
|
{ "AWREDIR", 0x0049, NULL },
|
|
|
|
/* Far East support */
|
|
{ "ETEN", 0x0060, NULL },
|
|
{ "CHBIOS", 0x0061, NULL },
|
|
{ "VMSGD", 0x0062, NULL },
|
|
{ "VPPID", 0x0063, NULL },
|
|
{ "VIME", 0x0064, NULL },
|
|
{ "VHBIOSD", 0x0065, NULL },
|
|
|
|
/* Multimedia OEM IDs */
|
|
{ "VTDAPI", 0x0442, DeviceIo_VTDAPI },
|
|
{ "MMDEVLDR", 0x044A, DeviceIo_MMDEVLDR },
|
|
|
|
/* Network Device IDs */
|
|
{ "VNetSup", 0x0480, NULL },
|
|
{ "VRedir", 0x0481, NULL },
|
|
{ "VBrowse", 0x0482, NULL },
|
|
{ "VSHARE", 0x0483, NULL },
|
|
{ "IFSMgr", 0x0484, NULL },
|
|
{ "MEMPROBE", 0x0485, NULL },
|
|
{ "VFAT", 0x0486, NULL },
|
|
{ "NWLINK", 0x0487, NULL },
|
|
{ "VNWLINK", 0x0487, NULL },
|
|
{ "NWSUP", 0x0487, NULL },
|
|
{ "VTDI", 0x0488, NULL },
|
|
{ "VIP", 0x0489, NULL },
|
|
{ "VTCP", 0x048A, NULL },
|
|
{ "VCache", 0x048B, NULL },
|
|
{ "VUDP", 0x048C, NULL },
|
|
{ "VAsync", 0x048D, NULL },
|
|
{ "NWREDIR", 0x048E, NULL },
|
|
{ "STAT80", 0x048F, NULL },
|
|
{ "SCSIPORT", 0x0490, NULL },
|
|
{ "FILESEC", 0x0491, NULL },
|
|
{ "NWSERVER", 0x0492, NULL },
|
|
{ "SECPROV", 0x0493, NULL },
|
|
{ "NSCL", 0x0494, NULL },
|
|
{ "WSTCP", 0x0495, NULL },
|
|
{ "NDIS2SUP", 0x0496, NULL },
|
|
{ "MSODISUP", 0x0497, NULL },
|
|
{ "Splitter", 0x0498, NULL },
|
|
{ "PPP", 0x0499, NULL },
|
|
{ "VDHCP", 0x049A, DeviceIo_DHCP },
|
|
{ "VNBT", 0x049B, NULL },
|
|
{ "LOGGER", 0x049D, NULL },
|
|
{ "EFILTER", 0x049E, NULL },
|
|
{ "FFILTER", 0x049F, NULL },
|
|
{ "TFILTER", 0x04A0, NULL },
|
|
{ "AFILTER", 0x04A1, NULL },
|
|
{ "IRLAMP", 0x04A2, NULL },
|
|
|
|
{ "PCCARD", 0x097C, DeviceIo_PCCARD },
|
|
{ "HASP95", 0x3721, DeviceIo_HASP },
|
|
|
|
/* WINE additions, ids unknown */
|
|
{ "MONODEBG.VXD", 0x4242, DeviceIo_MONODEBG },
|
|
|
|
{ NULL, 0, NULL }
|
|
};
|
|
|
|
HANDLE DEVICE_Open( LPCWSTR filenameW, DWORD access, LPSECURITY_ATTRIBUTES sa )
|
|
{
|
|
const struct VxDInfo *info;
|
|
char filename[MAX_PATH];
|
|
|
|
if (!WideCharToMultiByte(CP_ACP, 0, filenameW, -1, filename, MAX_PATH, NULL, NULL))
|
|
{
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return 0;
|
|
}
|
|
|
|
for (info = VxDList; info->name; info++)
|
|
if (!strncasecmp( info->name, filename, strlen(info->name) ))
|
|
return FILE_CreateDevice( info->id | 0x10000, access, sa );
|
|
|
|
FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
|
|
filename);
|
|
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return 0;
|
|
}
|
|
|
|
static DWORD DEVICE_GetClientID( HANDLE handle )
|
|
{
|
|
DWORD ret = 0;
|
|
SERVER_START_REQ( get_device_id )
|
|
{
|
|
req->handle = handle;
|
|
if (!wine_server_call( req )) ret = reply->id;
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
static const struct VxDInfo *DEVICE_GetInfo( DWORD clientID )
|
|
{
|
|
const struct VxDInfo *info = NULL;
|
|
|
|
if (clientID & 0x10000)
|
|
{
|
|
for (info = VxDList; info->name; info++)
|
|
if (info->id == LOWORD(clientID)) break;
|
|
}
|
|
return info;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* DeviceIoControl (KERNEL32.@)
|
|
* This is one of those big ugly nasty procedure which can do
|
|
* a million and one things when it comes to devices. It can also be
|
|
* used for VxD communication.
|
|
*
|
|
* A return value of FALSE indicates that something has gone wrong which
|
|
* GetLastError can decipher.
|
|
*/
|
|
BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DWORD clientID;
|
|
|
|
TRACE( "(%p,%ld,%p,%ld,%p,%ld,%p,%p)\n",
|
|
hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped );
|
|
|
|
if (!(clientID = DEVICE_GetClientID( hDevice )))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check if this is a user defined control code for a VxD */
|
|
if( HIWORD( dwIoControlCode ) == 0 )
|
|
{
|
|
const struct VxDInfo *info;
|
|
if (!(info = DEVICE_GetInfo( clientID )))
|
|
{
|
|
FIXME( "No device found for id %lx\n", clientID);
|
|
}
|
|
else if ( info->deviceio )
|
|
{
|
|
return info->deviceio( dwIoControlCode,
|
|
lpvInBuffer, cbInBuffer,
|
|
lpvOutBuffer, cbOutBuffer,
|
|
lpcbBytesReturned, lpOverlapped );
|
|
}
|
|
else
|
|
{
|
|
FIXME( "Unimplemented control %ld for VxD device %s\n",
|
|
dwIoControlCode, info->name ? info->name : "???" );
|
|
/* FIXME: this is for invalid calls on W98SE,
|
|
* but maybe we should use ERROR_CALL_NOT_IMPLEMENTED
|
|
* instead ? */
|
|
SetLastError( ERROR_INVALID_FUNCTION );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if (lpOverlapped)
|
|
{
|
|
status = NtDeviceIoControlFile(hDevice, lpOverlapped->hEvent,
|
|
NULL, NULL,
|
|
(PIO_STATUS_BLOCK)lpOverlapped,
|
|
dwIoControlCode,
|
|
lpvInBuffer, cbInBuffer,
|
|
lpvOutBuffer, cbOutBuffer);
|
|
if (status) SetLastError(RtlNtStatusToDosError(status));
|
|
if (lpcbBytesReturned) *lpcbBytesReturned = lpOverlapped->InternalHigh;
|
|
return !status;
|
|
}
|
|
else
|
|
{
|
|
IO_STATUS_BLOCK iosb;
|
|
|
|
status = NtDeviceIoControlFile(hDevice, NULL, NULL, NULL, &iosb,
|
|
dwIoControlCode,
|
|
lpvInBuffer, cbInBuffer,
|
|
lpvOutBuffer, cbOutBuffer);
|
|
if (status) SetLastError(RtlNtStatusToDosError(status));
|
|
if (lpcbBytesReturned) *lpcbBytesReturned = iosb.Information;
|
|
return !status;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* DeviceIo_VTDAPI
|
|
*/
|
|
static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
BOOL retv = TRUE;
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case 5:
|
|
if (lpvOutBuffer && (cbOutBuffer>=4))
|
|
*(DWORD*)lpvOutBuffer = GetTickCount();
|
|
|
|
if (lpcbBytesReturned)
|
|
*lpcbBytesReturned = 4;
|
|
|
|
break;
|
|
|
|
default:
|
|
FIXME( "Control %ld not implemented\n", dwIoControlCode);
|
|
retv = FALSE;
|
|
break;
|
|
}
|
|
|
|
return retv;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* DeviceIo_IFSMgr
|
|
* NOTES
|
|
* These ioctls are used by 'MSNET32.DLL'.
|
|
*
|
|
* I have been unable to uncover any documentation about the ioctls so
|
|
* the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
|
|
* based on reasonable guesses on information found in the Windows 95 DDK.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* IFSMgr DeviceIO service
|
|
*/
|
|
|
|
#define IFS_IOCTL_21 100
|
|
#define IFS_IOCTL_2F 101
|
|
#define IFS_IOCTL_GET_RES 102
|
|
#define IFS_IOCTL_GET_NETPRO_NAME_A 103
|
|
|
|
struct win32apireq {
|
|
unsigned long ar_proid;
|
|
unsigned long ar_eax;
|
|
unsigned long ar_ebx;
|
|
unsigned long ar_ecx;
|
|
unsigned long ar_edx;
|
|
unsigned long ar_esi;
|
|
unsigned long ar_edi;
|
|
unsigned long ar_ebp;
|
|
unsigned short ar_error;
|
|
unsigned short ar_pad;
|
|
};
|
|
|
|
static void win32apieq_2_CONTEXT(struct win32apireq *pIn,CONTEXT86 *pCxt)
|
|
{
|
|
memset(pCxt,0,sizeof(*pCxt));
|
|
|
|
pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
|
|
pCxt->Eax = pIn->ar_eax;
|
|
pCxt->Ebx = pIn->ar_ebx;
|
|
pCxt->Ecx = pIn->ar_ecx;
|
|
pCxt->Edx = pIn->ar_edx;
|
|
pCxt->Esi = pIn->ar_esi;
|
|
pCxt->Edi = pIn->ar_edi;
|
|
|
|
/* FIXME: Only partial CONTEXT86_CONTROL */
|
|
pCxt->Ebp = pIn->ar_ebp;
|
|
|
|
/* FIXME: pIn->ar_proid ignored */
|
|
/* FIXME: pIn->ar_error ignored */
|
|
/* FIXME: pIn->ar_pad ignored */
|
|
}
|
|
|
|
static void CONTEXT_2_win32apieq(CONTEXT86 *pCxt,struct win32apireq *pOut)
|
|
{
|
|
memset(pOut,0,sizeof(struct win32apireq));
|
|
|
|
pOut->ar_eax = pCxt->Eax;
|
|
pOut->ar_ebx = pCxt->Ebx;
|
|
pOut->ar_ecx = pCxt->Ecx;
|
|
pOut->ar_edx = pCxt->Edx;
|
|
pOut->ar_esi = pCxt->Esi;
|
|
pOut->ar_edi = pCxt->Edi;
|
|
|
|
/* FIXME: Only partial CONTEXT86_CONTROL */
|
|
pOut->ar_ebp = pCxt->Ebp;
|
|
|
|
/* FIXME: pOut->ar_proid ignored */
|
|
/* FIXME: pOut->ar_error ignored */
|
|
/* FIXME: pOut->ar_pad ignored */
|
|
}
|
|
|
|
static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
BOOL retv = TRUE;
|
|
TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped);
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case IFS_IOCTL_21:
|
|
case IFS_IOCTL_2F:{
|
|
CONTEXT86 cxt;
|
|
struct win32apireq *pIn=(struct win32apireq *) lpvInBuffer;
|
|
struct win32apireq *pOut=(struct win32apireq *) lpvOutBuffer;
|
|
|
|
TRACE(
|
|
"Control '%s': "
|
|
"proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
|
|
"edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
|
|
"error=0x%04x, pad=0x%04x\n",
|
|
(dwIoControlCode==IFS_IOCTL_21)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
|
|
pIn->ar_proid, pIn->ar_eax, pIn->ar_ebx, pIn->ar_ecx,
|
|
pIn->ar_edx, pIn->ar_esi, pIn->ar_edi, pIn->ar_ebp,
|
|
pIn->ar_error, pIn->ar_pad
|
|
);
|
|
|
|
win32apieq_2_CONTEXT(pIn,&cxt);
|
|
|
|
if(dwIoControlCode==IFS_IOCTL_21)
|
|
INSTR_CallBuiltinHandler( &cxt, 0x21 );
|
|
else
|
|
INSTR_CallBuiltinHandler( &cxt, 0x2f );
|
|
|
|
CONTEXT_2_win32apieq(&cxt,pOut);
|
|
|
|
retv = TRUE;
|
|
} break;
|
|
case IFS_IOCTL_GET_RES:{
|
|
FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
|
|
retv = FALSE;
|
|
} break;
|
|
case IFS_IOCTL_GET_NETPRO_NAME_A:{
|
|
FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
|
|
retv = FALSE;
|
|
} break;
|
|
default:
|
|
FIXME( "Control %ld not implemented\n", dwIoControlCode);
|
|
retv = FALSE;
|
|
}
|
|
|
|
return retv;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* DeviceIo_VCD
|
|
*/
|
|
static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
BOOL retv = TRUE;
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case IOCTL_SERIAL_LSRMST_INSERT:
|
|
{
|
|
FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
|
|
retv = FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
FIXME( "Unknown Control %ld\n", dwIoControlCode);
|
|
retv = FALSE;
|
|
break;
|
|
}
|
|
|
|
return retv;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DeviceIo_VWin32
|
|
*/
|
|
|
|
static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS *pIn, CONTEXT86 *pCxt )
|
|
{
|
|
memset( pCxt, 0, sizeof(*pCxt) );
|
|
/* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
|
|
will interpret 32-bit register contents as linear pointers */
|
|
|
|
pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
|
|
pCxt->Eax = pIn->reg_EAX;
|
|
pCxt->Ebx = pIn->reg_EBX;
|
|
pCxt->Ecx = pIn->reg_ECX;
|
|
pCxt->Edx = pIn->reg_EDX;
|
|
pCxt->Esi = pIn->reg_ESI;
|
|
pCxt->Edi = pIn->reg_EDI;
|
|
|
|
/* FIXME: Only partial CONTEXT86_CONTROL */
|
|
|
|
pCxt->EFlags = pIn->reg_Flags & ~0x00020000; /* clear vm86 mode */
|
|
}
|
|
|
|
static void CONTEXT_2_DIOCRegs( CONTEXT86 *pCxt, DIOC_REGISTERS *pOut )
|
|
{
|
|
memset( pOut, 0, sizeof(DIOC_REGISTERS) );
|
|
|
|
pOut->reg_EAX = pCxt->Eax;
|
|
pOut->reg_EBX = pCxt->Ebx;
|
|
pOut->reg_ECX = pCxt->Ecx;
|
|
pOut->reg_EDX = pCxt->Edx;
|
|
pOut->reg_ESI = pCxt->Esi;
|
|
pOut->reg_EDI = pCxt->Edi;
|
|
|
|
/* FIXME: Only partial CONTEXT86_CONTROL */
|
|
pOut->reg_Flags = pCxt->EFlags;
|
|
}
|
|
|
|
#define DIOC_AH(regs) (((unsigned char*)&((regs)->reg_EAX))[1])
|
|
#define DIOC_AL(regs) (((unsigned char*)&((regs)->reg_EAX))[0])
|
|
#define DIOC_BH(regs) (((unsigned char*)&((regs)->reg_EBX))[1])
|
|
#define DIOC_BL(regs) (((unsigned char*)&((regs)->reg_EBX))[0])
|
|
#define DIOC_DH(regs) (((unsigned char*)&((regs)->reg_EDX))[1])
|
|
#define DIOC_DL(regs) (((unsigned char*)&((regs)->reg_EDX))[0])
|
|
|
|
#define DIOC_AX(regs) (((unsigned short*)&((regs)->reg_EAX))[0])
|
|
#define DIOC_BX(regs) (((unsigned short*)&((regs)->reg_EBX))[0])
|
|
#define DIOC_CX(regs) (((unsigned short*)&((regs)->reg_ECX))[0])
|
|
#define DIOC_DX(regs) (((unsigned short*)&((regs)->reg_EDX))[0])
|
|
|
|
#define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
|
|
|
|
static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
BOOL retv = TRUE;
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case VWIN32_DIOC_DOS_IOCTL:
|
|
case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
|
|
case VWIN32_DIOC_DOS_INT13:
|
|
case VWIN32_DIOC_DOS_INT25:
|
|
case VWIN32_DIOC_DOS_INT26:
|
|
case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
|
|
case VWIN32_DIOC_DOS_DRIVEINFO:
|
|
{
|
|
CONTEXT86 cxt;
|
|
DIOC_REGISTERS *pIn = (DIOC_REGISTERS *)lpvInBuffer;
|
|
DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
|
|
BYTE intnum = 0;
|
|
|
|
TRACE( "Control '%s': "
|
|
"eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
|
|
"edx=0x%08lx, esi=0x%08lx, edi=0x%08lx \n",
|
|
(dwIoControlCode == VWIN32_DIOC_DOS_IOCTL)? "VWIN32_DIOC_DOS_IOCTL" :
|
|
(dwIoControlCode == VWIN32_DIOC_DOS_INT25)? "VWIN32_DIOC_DOS_INT25" :
|
|
(dwIoControlCode == VWIN32_DIOC_DOS_INT26)? "VWIN32_DIOC_DOS_INT26" :
|
|
(dwIoControlCode == VWIN32_DIOC_DOS_DRIVEINFO)? "VWIN32_DIOC_DOS_DRIVEINFO" : "???",
|
|
pIn->reg_EAX, pIn->reg_EBX, pIn->reg_ECX,
|
|
pIn->reg_EDX, pIn->reg_ESI, pIn->reg_EDI );
|
|
|
|
DIOCRegs_2_CONTEXT( pIn, &cxt );
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case VWIN32_DIOC_DOS_IOCTL: /* Call int 21h */
|
|
case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
|
|
case VWIN32_DIOC_DOS_DRIVEINFO: /* Call int 21h 730x */
|
|
intnum = 0x21;
|
|
break;
|
|
case VWIN32_DIOC_DOS_INT13:
|
|
intnum = 0x13;
|
|
break;
|
|
case VWIN32_DIOC_DOS_INT25:
|
|
intnum = 0x25;
|
|
break;
|
|
case VWIN32_DIOC_DOS_INT26:
|
|
intnum = 0x26;
|
|
break;
|
|
case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
|
|
intnum = 0x31;
|
|
break;
|
|
}
|
|
|
|
INSTR_CallBuiltinHandler( &cxt, intnum );
|
|
CONTEXT_2_DIOCRegs( &cxt, pOut );
|
|
}
|
|
break;
|
|
|
|
case VWIN32_DIOC_SIMCTRLC:
|
|
FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
|
|
retv = FALSE;
|
|
break;
|
|
|
|
default:
|
|
FIXME( "Unknown Control %ld\n", dwIoControlCode);
|
|
retv = FALSE;
|
|
break;
|
|
}
|
|
|
|
return retv;
|
|
}
|
|
|
|
/* this is the main multimedia device loader */
|
|
static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped
|
|
);
|
|
switch (dwIoControlCode) {
|
|
case 5:
|
|
/* Hmm. */
|
|
*(DWORD*)lpvOutBuffer=0;
|
|
*lpcbBytesReturned=4;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
/* this is used by some Origin games */
|
|
static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
switch (dwIoControlCode) {
|
|
case 1: /* version */
|
|
*(LPDWORD)lpvOutBuffer = 0x20004; /* WC SecretOps */
|
|
break;
|
|
case 9: /* debug output */
|
|
ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer));
|
|
break;
|
|
default:
|
|
FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped
|
|
);
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* pccard */
|
|
static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
switch (dwIoControlCode) {
|
|
case 0x0000: /* PCCARD_Get_Version */
|
|
case 0x0001: /* PCCARD_Card_Services */
|
|
default:
|
|
FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped
|
|
);
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL DeviceIo_HASP(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
BOOL retv = TRUE;
|
|
FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped);
|
|
|
|
return retv;
|
|
}
|
|
|
|
typedef UCHAR (WINAPI *NetbiosFunc)(LPVOID);
|
|
|
|
static BOOL DeviceIo_NetBIOS(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
static HMODULE netapi;
|
|
static NetbiosFunc pNetbios;
|
|
|
|
if (dwIoControlCode != 256)
|
|
{
|
|
FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped);
|
|
}
|
|
else
|
|
{
|
|
if (!pNetbios)
|
|
{
|
|
if (!netapi) netapi = LoadLibraryA("netapi32.dll");
|
|
if (netapi) pNetbios = (NetbiosFunc)GetProcAddress(netapi, "Netbios");
|
|
}
|
|
if (pNetbios)
|
|
{
|
|
pNetbios(lpvInBuffer);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL DeviceIo_DHCP(DWORD dwIoControlCode, LPVOID lpvInBuffer,
|
|
DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
DWORD error;
|
|
|
|
switch (dwIoControlCode) {
|
|
case 1:
|
|
{
|
|
/* since IpReleaseAddress/IpRenewAddress are not implemented, say there
|
|
* are no DHCP adapters
|
|
*/
|
|
error = ERROR_FILE_NOT_FOUND;
|
|
break;
|
|
}
|
|
|
|
/* FIXME: don't know what this means */
|
|
case 5:
|
|
if (lpcbBytesReturned)
|
|
*lpcbBytesReturned = sizeof(DWORD);
|
|
if (lpvOutBuffer && cbOutBuffer >= 4)
|
|
{
|
|
*(LPDWORD)lpvOutBuffer = 0;
|
|
error = NO_ERROR;
|
|
}
|
|
else
|
|
error = ERROR_BUFFER_OVERFLOW;
|
|
break;
|
|
|
|
default:
|
|
FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
|
|
dwIoControlCode,
|
|
lpvInBuffer,cbInBuffer,
|
|
lpvOutBuffer,cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpOverlapped);
|
|
error = ERROR_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (error)
|
|
SetLastError(error);
|
|
return error == NO_ERROR;
|
|
}
|
|
|
|
typedef DWORD (WINAPI *GetNetworkParamsFunc)(PFIXED_INFO, PDWORD);
|
|
typedef DWORD (WINAPI *GetAdaptersInfoFunc)(PIP_ADAPTER_INFO, PDWORD);
|
|
|
|
typedef struct _nbtInfo
|
|
{
|
|
DWORD ip;
|
|
DWORD winsPrimary;
|
|
DWORD winsSecondary;
|
|
DWORD dnsPrimary;
|
|
DWORD dnsSecondary;
|
|
DWORD unk0;
|
|
} nbtInfo;
|
|
|
|
#define MAX_NBT_ENTRIES 7
|
|
|
|
typedef struct _nbtTable
|
|
{
|
|
DWORD numEntries;
|
|
nbtInfo table[MAX_NBT_ENTRIES];
|
|
UCHAR pad[6];
|
|
WORD nodeType;
|
|
WORD scopeLen;
|
|
char scope[254];
|
|
} nbtTable;
|
|
|
|
static BOOL DeviceIo_VNB(DWORD dwIoControlCode,
|
|
LPVOID lpvInBuffer, DWORD cbInBuffer,
|
|
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
|
|
LPDWORD lpcbBytesReturned,
|
|
LPOVERLAPPED lpOverlapped)
|
|
{
|
|
static HMODULE iphlpapi;
|
|
static GetNetworkParamsFunc pGetNetworkParams;
|
|
static GetAdaptersInfoFunc pGetAdaptersInfo;
|
|
DWORD error;
|
|
|
|
switch (dwIoControlCode)
|
|
{
|
|
case 116:
|
|
if (lpcbBytesReturned)
|
|
*lpcbBytesReturned = sizeof(nbtTable);
|
|
if (!lpvOutBuffer || cbOutBuffer < sizeof(nbtTable))
|
|
error = ERROR_BUFFER_OVERFLOW;
|
|
else
|
|
{
|
|
nbtTable *info = (nbtTable *)lpvOutBuffer;
|
|
|
|
memset(info, 0, sizeof(nbtTable));
|
|
if (!iphlpapi)
|
|
{
|
|
iphlpapi = LoadLibraryA("iphlpapi.dll");
|
|
pGetNetworkParams = (GetNetworkParamsFunc)GetProcAddress(iphlpapi,"GetNetworkParams");
|
|
pGetAdaptersInfo = (GetAdaptersInfoFunc)GetProcAddress(iphlpapi, "GetAdaptersInfo");
|
|
}
|
|
if (iphlpapi)
|
|
{
|
|
DWORD size = 0;
|
|
|
|
error = pGetNetworkParams(NULL, &size);
|
|
if (ERROR_BUFFER_OVERFLOW == error)
|
|
{
|
|
PFIXED_INFO fixedInfo = (PFIXED_INFO)HeapAlloc(
|
|
GetProcessHeap(), 0, size);
|
|
|
|
error = pGetNetworkParams(fixedInfo, &size);
|
|
if (NO_ERROR == error)
|
|
{
|
|
info->nodeType = (WORD)fixedInfo->NodeType;
|
|
info->scopeLen = min(strlen(fixedInfo->ScopeId) + 1,
|
|
sizeof(info->scope) - 2);
|
|
memcpy(info->scope + 1, fixedInfo->ScopeId,
|
|
info->scopeLen);
|
|
info->scope[info->scopeLen + 1] = '\0';
|
|
{
|
|
/* convert into L2-encoded version */
|
|
char *ptr, *lenPtr;
|
|
|
|
for (ptr = info->scope + 1; *ptr &&
|
|
ptr - info->scope < sizeof(info->scope); )
|
|
{
|
|
for (lenPtr = ptr - 1, *lenPtr = 0;
|
|
*ptr && *ptr != '.' &&
|
|
ptr - info->scope < sizeof(info->scope);
|
|
ptr++)
|
|
*lenPtr += 1;
|
|
ptr++;
|
|
}
|
|
}
|
|
/* could set DNS servers here too, but since
|
|
* ipconfig.exe and winipcfg.exe read these from the
|
|
* registry, there's no point */
|
|
}
|
|
if (fixedInfo)
|
|
HeapFree(GetProcessHeap(), 0, fixedInfo);
|
|
}
|
|
size = 0;
|
|
error = pGetAdaptersInfo(NULL, &size);
|
|
if (ERROR_BUFFER_OVERFLOW == error)
|
|
{
|
|
PIP_ADAPTER_INFO adapterInfo = (PIP_ADAPTER_INFO)
|
|
HeapAlloc(GetProcessHeap(), 0, size);
|
|
|
|
error = pGetAdaptersInfo(adapterInfo, &size);
|
|
if (NO_ERROR == error)
|
|
{
|
|
PIP_ADAPTER_INFO ptr = adapterInfo;
|
|
|
|
for (ptr = adapterInfo; ptr && info->numEntries <
|
|
MAX_NBT_ENTRIES; ptr = ptr->Next)
|
|
{
|
|
unsigned long addr;
|
|
|
|
addr = inet_addr(
|
|
ptr->IpAddressList.IpAddress.String);
|
|
if (addr != 0 && addr != INADDR_NONE)
|
|
info->table[info->numEntries].ip =
|
|
ntohl(addr);
|
|
addr = inet_addr(
|
|
ptr->PrimaryWinsServer.IpAddress.String);
|
|
if (addr != 0 && addr != INADDR_NONE)
|
|
info->table[info->numEntries].winsPrimary
|
|
= ntohl(addr);
|
|
addr = inet_addr(
|
|
ptr->SecondaryWinsServer.IpAddress.String);
|
|
if (addr != 0 && addr != INADDR_NONE)
|
|
info->table[info->numEntries].winsSecondary
|
|
= ntohl(addr);
|
|
info->numEntries++;
|
|
}
|
|
}
|
|
if (adapterInfo)
|
|
HeapFree(GetProcessHeap(), 0, adapterInfo);
|
|
}
|
|
}
|
|
else
|
|
error = GetLastError();
|
|
}
|
|
break;
|
|
|
|
case 119:
|
|
/* nbtstat.exe uses this, but the return seems to be a bunch of
|
|
* pointers, so it's not so easy to reverse engineer. Fall through
|
|
* to unimplemented...
|
|
*/
|
|
default:
|
|
FIXME( "Unimplemented control %ld for VxD device VNB\n",
|
|
dwIoControlCode );
|
|
error = ERROR_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (error)
|
|
SetLastError(error);
|
|
return error == NO_ERROR;
|
|
}
|