archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/public/internal/termsrv/inc/rdpdr.h

1534 lines
50 KiB
Raw Permalink Blame History

/*++
Copyright (c) 1998-2000 Microsoft Corporation
Module Name :
rdrdr.h
Abstract:
Type definitions for the Rdp redirector protocol
Revision History:
--*/
#ifndef _RDPDR_
#define _RDPDR_
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
//
// Turn off compiler padding of structures
// Save previous packing style if 32-bit build.
//
#ifdef OS_WIN16
#pragma pack (1)
#else
#pragma pack (push, drpack, 1)
#endif
//
// version info.
//
#define RDPDR_MAJOR_VERSION 1
#define RDPDR_MINOR_VERSION 5
//
// version comparison macro
//
#define COMPARE_VERSION(Minor1, Major1, Minor2, Major2) \
(((LONG)MAKELONG(Minor1, Major1)) - ((LONG)MAKELONG(Minor2, Major2)))
#define RDPDR_MAJOR_VERSION_PORTS 1
#define RDPDR_MINOR_VERSION_PORTS 5
#define RDPDR_MAJOR_VERSION_DRIVE 1
#define RDPDR_MINOR_VERSION_DRIVE 5
//
// NULL Client Device ID.
//
#define RDPDR_INVALIDDEVICEID (ULONG)-1
//
// This string precedes the session id number in the file name path when
// a user-mode component opens us for device management.
//
#define RDPDYN_SESSIONIDSTRING L"\\session"
//
// Device Names for RDPDR Device Manager Control Device
//
// NT Names
#define RDPDRDVMGR_DEVICE_PATH_A "\\Device\\RdpDrDvMgr"
#define RDPDRDVMGR_DEVICE_PATH_U L"\\Device\\RdpDrDvMgr"
#define RDPDRDVMGR_DEVICE_PATH_A_LENGTH sizeof(RDPDRDVMGR_DEVICE_PATH_A)
#define RDPDRDVMGR_DEVICE_PATH_U_LENGTH sizeof(RDPDRDVMGR_DEVICE_PATH_U)
// Win32 Names
#define RDPDRDVMGR_W32DEVICE_NAME_A "RdpDrDvMgr"
#define RDPDRDVMGR_W32DEVICE_NAME_U L"RdpDrDvMgr"
#define RDPDRDVMGR_W32DEVICE_PATH_A "\\DosDevices\\RdpDrDvMgr"
#define RDPDRDVMGR_W32DEVICE_PATH_U L"\\DosDevices\\RdpDrDvMgr"
#define RDPDRDVMGR_W32DEVICE_PATH_A_LENGTH sizeof(RDPDRDVMGR_W32DEVICE_PATH_A)
#define RDPDRDVMGR_W32DEVICE_PATH_U_LENGTH sizeof(RDPDRDVMGR_W32DEVICE_PATH_U)
// Maximum number of characters in a ULONG -> STRING conversion.
#define RDPDRMAXULONGSTRING 16 // Big enough for a 32-bit int.
#define RDPDRMAXDOSNAMELEN 16
//
// Maximum number of characters (not bytes!) in a reference string.
//
#define RDPDRMAXREFSTRINGLEN \
(RDPDRMAXDOSNAMELEN + RDPDRMAXULONGSTRING + RDPDR_MAX_COMPUTER_NAME_LENGTH + 5 + RDPDRMAXDOSNAMELEN + 1)
// DosDeviceName + Session ID + computer name + delimiters + preferred dos name + terminator
//
// Maximum number of characters in a NT device name string
//
#define RDPDRMAXNTDEVICENAMEGLEN \
((sizeof(RDPDR_PORT_DEVICE_NAME_U) / sizeof(WCHAR)) + RDPDRMAXREFSTRINGLEN + 1)
// NT Device name + Reference string + terminator null
//
// Dr Network Provider Dll Name
//
#define RDPDR_PROVIDER_NAME_U L"Microsoft Terminal Services"
#define RDPDR_PROVIDER_NAME_A "Microsoft Terminal Services"
// The following constant defines the length of the above name.
#define RDPDR_PROVIDER_NAME_U_LENGTH (sizeof(RDPDR_PROVIDER_NAME_U))
#define RDPDR_PROVIDER_NAME_A_LENGTH (sizeof(RDPDR_PROVIDER_NAME_A))
//
// RDPDR Device Manager Event Codes for IOCTL Responses from Server
//
// Message Code Corresponding Message Meaning
// ---------------------------------------------------------------------------
// RDPDREVT_PRINTERANNOUNCE RDPDR_PRINTERDEVICE_SUB New printer device.
// RDPDREVT_BUFFERTOOSMALL RDPDR_BUFFERTOOSMALL IOCTL output buffer
// is too small.
// RDPDREVT_PORTANNOUNCE RDPDR_PORTDEVICE_SUB New redirect port
// device.
// RDPDREVT_REMOVEDEVICE RDPDR_REMOVEDEVICE A client-side device
// has been removed.
// RDPDREVT_SESSIONDISCONNECT NONE Client has disconnected
// from the session.
// RDPDREVT_DRIVEANNOUNCE RDPDR_DRIVEDEVICE_SUB New redirected drive
// device
//
// Message Codes
#define RDPDREVT_BASE 0
#define RDPDREVT_PRINTERANNOUNCE RDPDREVT_BASE + 1
#define RDPDREVT_BUFFERTOOSMALL RDPDREVT_BASE + 2
#define RDPDREVT_REMOVEDEVICE RDPDREVT_BASE + 3
#define RDPDREVT_PORTANNOUNCE RDPDREVT_BASE + 4
#define RDPDREVT_SESSIONDISCONNECT RDPDREVT_BASE + 5
#define RDPDREVT_DRIVEANNOUNCE RDPDREVT_BASE + 6
//
// Device Manager IOCTL's
//
// IOCTL Input Buffer Output Message Code
// (Above-Defined Buffer Follows
// Header in Driver-Response)
// ----------------------------------------------------------------------------
// IOCTL_RDPDR_GETNEXTDEVMGMTEVENT NONE RDPDREVT_PRINTERANNOUNCE
// RDPDREVT_BUFFERTOOSMALL
// IOCTL_RDPDR_DBGADDNEWPRINTER NONE NONE
// IOCTL_RDPDR_CLIENTMSG opaque data NONE
// intended for
// session's
// corresponding
// client.
//
#define IOCTL_RDPDR_GETNEXTDEVMGMTEVENT \
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
#ifdef DBG
#define IOCTL_RDPDR_DBGADDNEWPRINTER \
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
#endif
#define IOCTL_RDPDR_CLIENTMSG \
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
//
// TS Printer Port Defines
//
#define RDPDRPRT_BASEPORTNAME L"TS" // TS Port Base Name
#define RDPDR_PORTNAMEDIGITS 6 // This value must match JobyL's value for USB
// max port number.
#define RDPDR_PORTNAMEDIGITSTOPAD 3 // We pad the first 3 to make things line
// up nicely in UI up to port 999
#define RDPDR_MAXPORTNAMELEN \
(((sizeof(RDPDRPRT_BASEPORTNAME)-sizeof(WCHAR))/sizeof(WCHAR)) \
+ RDPDR_PORTNAMEDIGITS + 1) // In characters, including the terminator.
//
// Driver name and ioctls
//
#define RDPDR_DEVICE_NAME_A "\\Device\\RdpDr"
#define RDPDR_DEVICE_NAME_U L"\\Device\\RdpDr"
#define RDPDR_DEVICE_NAME_A_LENGTH sizeof(RDPDR_DEVICE_NAME_A)
#define RDPDR_DEVICE_NAME_U_LENGTH sizeof(RDPDR_DEVICE_NAME_U)
#define RDPDR_PORT_DEVICE_NAME_A "\\Device\\RdpDrPort"
#define RDPDR_PORT_DEVICE_NAME_U L"\\Device\\RdpDrPort"
#define RDPDR_PORT_DEVICE_NAME_A_LENGTH sizeof(RDPDR_PORT_DEVICE_NAME_A)
#define RDPDR_PORT_DEVICE_NAME_U_LENGTH sizeof(RDPDR_PORT_DEVICE_NAME_U)
#define FSCTL_DR_START CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
100, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define FSCTL_DR_STOP CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
101, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define FSCTL_DR_DELETE_CONNECTION CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
102, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define FSCTL_DR_GET_CONNECTION_INFO CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
103, METHOD_NEITHER, FILE_ANY_ACCESS)
#define FSCTL_DR_ENUMERATE_CONNECTIONS CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
104, METHOD_NEITHER, FILE_ANY_ACCESS)
#define FSCTL_DR_ENUMERATE_SHARES CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
105, METHOD_NEITHER, FILE_ANY_ACCESS)
#define FSCTL_DR_ENUMERATE_SERVERS CTL_CODE(FILE_DEVICE_NETWORK_FILE_SYSTEM, \
106, METHOD_NEITHER, FILE_ANY_ACCESS)
//
// Channel Name
//
#define DR_CHANNEL_NAME "RDPDR"
//
// Smartcard Name
//
#define DR_SMARTCARD_SUBSYSTEM "SCARD"
//
// Smartcard Name
//
#define DR_SMARTCARD_FILEID 1
//
// Component Ids
//
#define RDPDR_CTYP_CORE 0x4472 /* 'Dr' */
#define RDPDR_CTYP_PRN 0x5052 /* 'PR' */
//
// Core Packet Ids
//
#define DR_CORE_SERVER_ANNOUNCE 0x496E /* 'In' */
#define DR_CORE_CLIENTID_CONFIRM 0x4343 /* 'CC' */
#define DR_CORE_CLIENT_NAME 0x434E /* 'CN' */
#define DR_CORE_DEVICE_ANNOUNCE 0x6461 /* 'da' */
#define DR_CORE_DEVICELIST_ANNOUNCE 0x4441 /* 'DA' */
#define DR_CORE_DEVICELIST_REPLY 0x4452 /* 'DR' */
#define DR_CORE_DEVICE_REPLY 0x6472 /* 'dr' */
#define DR_CORE_DEVICE_IOREQUEST 0x4952 /* 'IR' */
#define DR_CORE_DEVICE_IOCOMPLETION 0x4943 /* 'IC' */
#define DR_CORE_SERVER_CAPABILITY 0x5350 /* 'SP' */
#define DR_CORE_CLIENT_CAPABILITY 0x4350 /* 'CP' */
#define DR_CORE_DEVICE_REMOVE 0x646D /* 'dm' */
#define DR_CORE_DEVICELIST_REMOVE 0x444D /* 'DM' */
#define DR_CORE_CLIENT_DISPLAY_NAME 0x444E /* 'DN' */
#define DR_PRN_CACHE_DATA 0x5043 /* 'PC' */
//
// Protocol header
//
typedef struct tagRDPDR_HEADER {
SHORT Component;
SHORT PacketId;
} RDPDR_HEADER, *PRDPDR_HEADER;
#ifdef __cplusplus
inline
BOOL
IsValidHeader(
PVOID pData
)
{
PRDPDR_HEADER pRdpdrHeader;
pRdpdrHeader = (PRDPDR_HEADER)pData;
if( (pRdpdrHeader != NULL) &&
((pRdpdrHeader->Component == RDPDR_CTYP_CORE) ||
(pRdpdrHeader->Component == RDPDR_CTYP_PRN)) ) {
SHORT sPacketId;
sPacketId = pRdpdrHeader->PacketId;
if( (sPacketId == DR_CORE_SERVER_ANNOUNCE ) ||
(sPacketId == DR_CORE_CLIENTID_CONFIRM ) ||
(sPacketId == DR_CORE_CLIENT_NAME ) ||
(sPacketId == DR_CORE_DEVICE_ANNOUNCE ) ||
(sPacketId == DR_CORE_DEVICELIST_ANNOUNCE) ||
(sPacketId == DR_CORE_DEVICELIST_REPLY ) ||
(sPacketId == DR_CORE_DEVICE_REPLY ) ||
(sPacketId == DR_CORE_DEVICE_IOREQUEST ) ||
(sPacketId == DR_CORE_DEVICE_IOCOMPLETION) ||
(sPacketId == DR_PRN_CACHE_DATA ) ||
(sPacketId == DR_CORE_SERVER_CAPABILITY ) ||
(sPacketId == DR_CORE_CLIENT_CAPABILITY ) ||
(sPacketId == DR_CORE_DEVICE_REMOVE ) ||
(sPacketId == DR_CORE_DEVICELIST_REMOVE ) ||
(sPacketId == DR_CORE_CLIENT_DISPLAY_NAME)) {
return( TRUE );
}
}
return( FALSE );
}
#endif // __cplusplus
//
// RDPDR capability PDUs
//
// This is used during the client/server connection time to determine what
// the client and server are capable of doing
//
typedef struct tagRDPDR_CAPABILITY_SET_HEADER
{
RDPDR_HEADER Header;
UINT16 numberCapabilities;
UINT16 pad1;
} RDPDR_CAPABILITY_SET_HEADER, *PRDPDR_CAPABILITY_SET_HEADER;
typedef struct tagRDPDR_CAPABILITY_HEADER
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
} RDPDR_CAPABILITY_HEADER, *PRDPDR_CAPABILITY_HEADER;
#define RDPDR_GENERAL_CAPABILITY_TYPE 0x1
#define RDPDR_PRINT_CAPABILITY_TYPE 0x2
#define RDPDR_PORT_CAPABILITY_TYPE 0x3
#define RDPDR_FS_CAPABILITY_TYPE 0x4
#define RDPDR_SMARTCARD_CAPABILITY_TYPE 0x5
//
// RDPDR general capability
//
typedef struct tagRDPDR_GENERAL_CAPABILITY
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
#define RDPDR_GENERAL_CAPABILITY_VERSION_01 0x1
UINT32 osType;
#define RDPDR_OS_TYPE_UNKNOWN 0x0
#define RDPDR_OS_TYPE_WIN9X 0x1
#define RDPDR_OS_TYPE_WINNT 0x2
UINT32 osVersion;
// For windows platforms, the high word is the major version
// The low word is the minor version
UINT16 protocolMajorVersion;
UINT16 protocolMinorVersion;
UINT32 ioCode1;
#define RDPDR_IRP_MJ_CREATE 0x0001
#define RDPDR_IRP_MJ_CLEANUP 0x0002
#define RDPDR_IRP_MJ_CLOSE 0x0004
#define RDPDR_IRP_MJ_READ 0x0008
#define RDPDR_IRP_MJ_WRITE 0x0010
#define RDPDR_IRP_MJ_FLUSH_BUFFERS 0x0020
#define RDPDR_IRP_MJ_SHUTDOWN 0x0040
#define RDPDR_IRP_MJ_DEVICE_CONTROL 0x0080
#define RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION 0x0100
#define RDPDR_IRP_MJ_SET_VOLUME_INFORMATION 0x0200
#define RDPDR_IRP_MJ_QUERY_INFORMATION 0x0400
#define RDPDR_IRP_MJ_SET_INFORMATION 0x0800
#define RDPDR_IRP_MJ_DIRECTORY_CONTROL 0x1000
#define RDPDR_IRP_MJ_LOCK_CONTROL 0x2000
#define RDPDR_IRP_MJ_QUERY_SECURITY 0x4000
#define RDPDR_IRP_MJ_SET_SECURITY 0x8000
UINT32 ioCode2;
UINT32 extendedPDU;
#define RDPDR_DEVICE_REMOVE_PDUS 0x0001
#define RDPDR_CLIENT_DISPLAY_NAME_PDU 0x0002
UINT32 extraFlags1;
UINT32 extraFlags2;
} RDPDR_GENERAL_CAPABILITY, *PRDPDR_GENERAL_CAPABILITY;
//
// RDPDR printing capability
//
typedef struct tagRDPDR_PRINT_CAPABILITY
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
#define RDPDR_PRINT_CAPABILITY_VERSION_01 0x1
} RDPDR_PRINT_CAPABILITY, *PRDPDR_PRINT_CAPABILITY;
//
// RDPDR port capability
//
typedef struct tagRDPDR_PORT_CAPABILITY
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
#define RDPDR_PORT_CAPABILITY_VERSION_01 0x1
} RDPDR_PORT_CAPABILITY, *PRDPDR_PORT_CAPABILITY;
//
// RDPDR file system capability
//
typedef struct tagRDPDR_FS_CAPABILITY
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
#define RDPDR_FS_CAPABILITY_VERSION_01 0x1
} RDPDR_FS_CAPABILITY, *PRDPDR_FS_CAPABILITY;
//
// RDPDR smart card subsystem capability
//
typedef struct tagRDPDR_SMARTCARD_CAPABILITY
{
UINT16 capabilityType;
UINT16 capabilityLength;
UINT32 version;
#define RDPDR_SMARTCARD_CAPABILITY_VERSION_01 0x1
} RDPDR_SMARTCARD_CAPABILITY, *PRDPDR_SMARTCARD_CAPABILITY;
typedef struct tagRDPDR_VERSION {
SHORT Major;
SHORT Minor;
} RDPDR_VERSION, *PRDPDR_VERSION;
//
// Device types
//
#define RDPDR_DTYP_SERIAL 0x00000001
#define RDPDR_DTYP_PARALLEL 0x00000002
#define RDPDR_DRYP_PRINTPORT 0x00000010
#define RDPDR_DTYP_PRINT 0x00000004
#define RDPDR_DTYP_FILESYSTEM 0x00000008
#define RDPDR_DTYP_SMARTCARD 0x00000020
//
// RDPDR_SERVER_ANNOUNCE
//
// Sent by the Server to establish communications and provide a client Id
//
typedef struct tagRDPDR_SERVER_ANNOUNCE
{
ULONG ClientId; // Unique client identifier.
} RDPDR_SERVER_ANNOUNCE, *PRDPDR_SERVER_ANNOUNCE;
typedef struct tagRDPDR_SERVER_ANNOUNCE_PACKET
{
RDPDR_HEADER Header;
RDPDR_VERSION VersionInfo; // Server version Info.
RDPDR_SERVER_ANNOUNCE ServerAnnounce;
} RDPDR_SERVER_ANNOUNCE_PACKET, *PRDPDR_SERVER_ANNOUNCE_PACKET;
//
// RDPDR_CLIENTID_CONFIRM
//
// Sent by the client to confirm the client id or propose reusing a
// pre-existing client Id. If the client sends acceptance the ID from the
// RDPDR_SERVER_ANNOUNCE, that's the end of it.
// If the client proposes a different id, the server will send a
// RPPDR_CLIENTID_CONFIRM back to either insist on the original clientId or
// accept the client provided one.
//
typedef struct tagRDPDR_CLIENTID_CONFIRM
{
ULONG ClientId; // Unique client identifier.
} RDPDR_CLIENTID_CONFIRM, *PRDPDR_CLIENTID_CONFIRM;
typedef struct tagRDPDR_CLIENT_CONFIRM_PACKET
{
RDPDR_HEADER Header;
RDPDR_VERSION VersionInfo; // Client version Info.
RDPDR_CLIENTID_CONFIRM ClientConfirm;
} RDPDR_CLIENT_CONFIRM_PACKET, *PRDPDR_CLIENT_CONFIRM_PACKET;
#ifndef MAX_COMPUTERNAME_LENGTH
#define MAX_COMPUTERNAME_LENGTH 15 // From winbase.h
#endif // MAX_COMPUTERNAME_LENGTH
#define RDPDR_MAX_COMPUTER_NAME_LENGTH (MAX_COMPUTERNAME_LENGTH + 1)
#define RDPDR_MAX_DOSNAMELEN 16
typedef struct tagRDPDR_CLIENT_NAME
{
ULONG Unicode:1; // flag to indicate the computer name is unicode or
// ansi.
ULONG CodePage; // code page of the ansi string.
ULONG ComputerNameLen;// length of the computer name in bytes that
// follows this structures.
//
// computer name follows.
//
} RDPDR_CLIENT_NAME, *PRDPDR_CLIENT_NAME;
typedef struct tagRDPDR_CLIENT_NAME_PACKET
{
RDPDR_HEADER Header;
RDPDR_CLIENT_NAME Name;
} RDPDR_CLIENT_NAME_PACKET, *PRDPDR_CLIENT_NAME_PACKET;
#define RDPDR_MAX_CLIENT_DISPLAY_NAME 64
typedef struct tagRDPDR_CLIENT_DISPLAY_NAME
{
BYTE ComputerDisplayNameLen;
//
// computer display name follows
//
} RDPDR_CLIENT_DISPLAY_NAME, *PRDPDR_CLIENT_DISPLAY_NAME;
typedef struct tagRDPDR_CLIENT_DISPLAY_NAME_PACKET
{
RDPDR_HEADER Header;
RDPDR_CLIENT_DISPLAY_NAME Name;
} RDPDR_CLIENT_DISPLAY_NAME_PACKET, *PRDPDR_CLIENT_DISPLAY_NAME_PACKET;
//
// RDPDR_DEVICE_ANNOUNCE
//
// Sent by the client to indicate a device is available
//
#define PREFERRED_DOS_NAME_SIZE 8
typedef struct tagRDPDR_DEVICE_ANNOUNCE
{
ULONG DeviceType; // Type of device, as listed above
ULONG DeviceId; // An id to refer the device later
UCHAR PreferredDosName[PREFERRED_DOS_NAME_SIZE]; // Preferred device name COM99:\null
// Long enough?
ULONG DeviceDataLength; // Length of Type specific data (follows)
} RDPDR_DEVICE_ANNOUNCE, *PRDPDR_DEVICE_ANNOUNCE;
typedef struct tagRDPDR_DEVICE_ANNOUNCE_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICE_ANNOUNCE DeviceAnnounce;
} RDPDR_DEVICE_ANNOUNCE_PACKET, *PRDPDR_DEVICE_ANNOUNCE_PACKET;
//
// RDPDR_DEVICELIST_ANNOUNCE
//
// Sent by the client to indicate a number of devices are available
//
typedef struct tagRDPDR_DEVICELIST_ANNOUNCE
{
ULONG DeviceCount; // Number of devices
// DeviceCount RDPDR_DEVICE_ANNOUNCE structures follows
} RDPDR_DEVICELIST_ANNOUNCE, *PRDPDR_DEVICELIST_ANNOUNCE;
typedef struct tagRDPDR_DEVICELIST_ANNOUNCE_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICELIST_ANNOUNCE DeviceListAnnounce;
RDPDR_DEVICE_ANNOUNCE DeviceAnnounce;
} RDPDR_DEVICELIST_ANNOUNCE_PACKET, *PRDPDR_DEVICELIST_ANNOUNCE_PACKET;
#define DR_FIRSTDEVICEANNOUNCE(DeviceListPacket) \
(&((PRDPDR_DEVICELIST_ANNOUNCE_PACKET)(DeviceListPacket))->DeviceAnnounce)
#define DR_NEXTDEVICEANNOUNCE(DeviceAnnounce) \
(PRDPDR_DEVICE_ANNOUNCE) \
((((PUCHAR)(DeviceAnnounce)) + sizeof(RDPDR_DEVICE_ANNOUNCE) + \
((DeviceAnnounce)->DeviceDataLength)))
#define DR_CHECK_DEVICEDATALEN(DeviceAnnounce, DeviceSub) \
(DeviceAnnounce->DeviceDataLength <= (sizeof(DeviceSub) - sizeof(*DeviceAnnounce)))
//
// RDPDR_DEVICE_REMOVE
//
// Sent by the client to indicate a device to be removed
//
typedef struct tagRDPDR_DEVICE_REMOVE
{
ULONG DeviceId; // An id to refer the device later
} RDPDR_DEVICE_REMOVE, *PRDPDR_DEVICE_REMOVE;
typedef struct tagRDPDR_DEVICE_REMOVE_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICE_REMOVE DeviceRemove;
} RDPDR_DEVICE_REMOVE_PACKET, *PRDPDR_DEVICE_REMOVE_PACKET;
//
// RDPDR_DEVICELIST_REMOVE
//
// Sent by the client to indicate a number of devices are to be removed
//
typedef struct tagRDPDR_DEVICELIST_REMOVE
{
ULONG DeviceCount; // Number of devices
// DeviceCount RDPDR_DEVICE_REMOVE structures follows
} RDPDR_DEVICELIST_REMOVE, *PRDPDR_DEVICELIST_REMOVE;
typedef struct tagRDPDR_DEVICELIST_REMOVE_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICELIST_REMOVE DeviceListRemove;
RDPDR_DEVICE_REMOVE DeviceRemove;
} RDPDR_DEVICELIST_REMOVE_PACKET, *PRDPDR_DEVICELIST_REMOVE_PACKET;
#define DR_FIRSTDEVICEREMOVE(DeviceListPacket) \
(&((PRDPDR_DEVICELIST_REMOVE_PACKET)(DeviceListPacket))->DeviceRemove)
#define DR_NEXTDEVICEREMOVE(DeviceRemove) \
(PRDPDR_DEVICE_REMOVE) \
((((PUCHAR)(DeviceRemove)) + sizeof(RDPDR_DEVICE_REMOVE)))
#define RDPDR_DEVICE_REPLY_SUCCESS 0x00000000 // Accepted device
#define RDPDR_DEVICE_REPLY_REJECTED 0x00000001 // Generic will not use
//
// RDPDR_DEVICE_REPLY
//
// Sent by the server to indicate whether a device will be used
//
typedef struct tagRDPDR_DEVICE_REPLY
{
ULONG DeviceId; // Id supplied in RDPDR_DEVICE_ANNOUNCE
ULONG ResultCode; // Success or reason code
} RDPDR_DEVICE_REPLY, *PRDPDR_DEVICE_REPLY;
typedef struct tagRDPDR_DEVICE_REPLY_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICE_REPLY DeviceReply;
} RDPDR_DEVICE_REPLY_PACKET, *PRDPDR_DEVICE_REPLY_PACKET;
//
// RDPDR_DEVICELIST_REPLY
//
// Sent by the server to indicate which devices will be used
//
typedef struct tagRDPDR_DEVICELIST_REPLY
{
ULONG DeviceCount; // Number of devices
// DeviceReplies follow
} RDPDR_DEVICELIST_REPLY, *PRDPDR_DEVICELIST_REPLY;
typedef struct tagRDPDR_DEVICELIST_REPLY_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICELIST_REPLY DeviceListReply;
RDPDR_DEVICE_REPLY DeviceReply;
} RDPDR_DEVICELIST_REPLY_PACKET_PACKET,
*PRDPDR_DEVICELIST_REPLY_PACKET_PACKET;
//
// RDPDR_UPDATE_DEVICEINFO
//
// Sent by the server to update information about the device, for example
// if the user does configuration on it.
//
typedef struct tagRDPDR_UPDATE_DEVICEINFO
{
ULONG DeviceId; // Relevant device
ULONG DeviceDataLength; // Length of type specific data (follows)
} RDPDR_UPDATE_DEVICEINFO, *PRDPDR_UPDATE_DEVICEINFO;
typedef struct tagRDPDR_UPDATE_DEVICEINFO_PACKET
{
RDPDR_HEADER Header;
RDPDR_UPDATE_DEVICEINFO DeviceUpdate;
UCHAR Data;
} RDPDR_UPDATE_DEVICEINFO_PACKET, *PRDPDR_UPDATE_DEVICEINFO_PACKET;
//
// Define the file create disposition values
// These are defined in ntioapi.h
//
#define FILE_SUPERSEDE 0x00000000
#define FILE_OPEN 0x00000001
#define FILE_CREATE 0x00000002
#define FILE_OPEN_IF 0x00000003
#define FILE_OVERWRITE 0x00000004
#define FILE_OVERWRITE_IF 0x00000005
#define FILE_MAXIMUM_DISPOSITION 0x00000005
//
// Define the I/O status information return values for NtCreateFile/NtOpenFile
// These are defined in ntioapi.h
//
#define FILE_SUPERSEDED 0x00000000
#define FILE_OPENED 0x00000001
#define FILE_CREATED 0x00000002
#define FILE_OVERWRITTEN 0x00000003
#define FILE_EXISTS 0x00000004
#define FILE_DOES_NOT_EXIST 0x00000005
//
// Define the file create/open option flags
// Also defined in ntioapi.h
//
#define FILE_DIRECTORY_FILE 0x00000001
#define FILE_WRITE_THROUGH 0x00000002
#define FILE_SEQUENTIAL_ONLY 0x00000004
#define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
#define FILE_SYNCHRONOUS_IO_ALERT 0x00000010
#define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
#define FILE_NON_DIRECTORY_FILE 0x00000040
#define FILE_CREATE_TREE_CONNECTION 0x00000080
#define FILE_COMPLETE_IF_OPLOCKED 0x00000100
#define FILE_NO_EA_KNOWLEDGE 0x00000200
#define FILE_OPEN_FOR_RECOVERY 0x00000400
#define FILE_RANDOM_ACCESS 0x00000800
#define FILE_DELETE_ON_CLOSE 0x00001000
#define FILE_OPEN_BY_FILE_ID 0x00002000
#define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000
#define FILE_NO_COMPRESSION 0x00008000
#define FILE_RESERVE_OPFILTER 0x00100000
#define FILE_OPEN_REPARSE_POINT 0x00200000
#define FILE_OPEN_NO_RECALL 0x00400000
#define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
#define FILE_COPY_STRUCTURED_STORAGE 0x00000041
#define FILE_STRUCTURED_STORAGE 0x00000441
#define FILE_VALID_OPTION_FLAGS 0x00ffffff
//
// Define the file system information class
// Server can query the client file system with
// each of these information class.
// These are defined in ntioapi.h
//
typedef enum _RDPFSINFOCLASS {
RdpFsVolumeInformation = 1,
RdpFsLabelInformation, // 2
RdpFsSizeInformation, // 3
RdpFsDeviceInformation, // 4
RdpFsAttributeInformation, // 5
RdpFsControlInformation, // 6
RdpFsFullSizeInformation, // 7
RdpFsObjectIdInformation, // 8
RdpFsMaximumInformation
} RDP_FS_INFORMATION_CLASS, *PRDP_FS_INFORMATION_CLASS;
//
// This is the maximum length for the file system volume
// information structures
// (not including variable file length)
// Need to update this value if there is update to the file
// system volume information structures
//
#define RDP_FILE_VOLUME_INFO_MAXLENGTH 32
//
// Define file system information classes
//
typedef struct _RDP_FILE_FS_LABEL_INFORMATION {
ULONG VolumeLabelLength;
WCHAR VolumeLabel[1];
} RDP_FILE_FS_LABEL_INFORMATION;
typedef UNALIGNED RDP_FILE_FS_LABEL_INFORMATION * PRDP_FILE_FS_LABEL_INFORMATION;
typedef struct _RDP_FILE_FS_VOLUME_INFORMATION {
LARGE_INTEGER VolumeCreationTime;
ULONG VolumeSerialNumber;
ULONG VolumeLabelLength;
BYTE SupportsObjects;
WCHAR VolumeLabel[1];
} RDP_FILE_FS_VOLUME_INFORMATION;
typedef UNALIGNED RDP_FILE_FS_VOLUME_INFORMATION * PRDP_FILE_FS_VOLUME_INFORMATION;
typedef struct _RDP_FILE_FS_SIZE_INFORMATION {
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER AvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
} RDP_FILE_FS_SIZE_INFORMATION;
typedef UNALIGNED RDP_FILE_FS_SIZE_INFORMATION * PRDP_FILE_FS_SIZE_INFORMATION;
typedef struct _RDP_FILE_FS_FULL_SIZE_INFORMATION {
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER CallerAvailableAllocationUnits;
LARGE_INTEGER ActualAvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
} RDP_FILE_FS_FULL_SIZE_INFORMATION;
typedef UNALIGNED RDP_FILE_FS_FULL_SIZE_INFORMATION * PRDP_FILE_FS_FULL_SIZE_INFORMATION;
typedef struct _RDP_FILE_FS_ATTRIBUTE_INFORMATION {
ULONG FileSystemAttributes;
LONG MaximumComponentNameLength;
ULONG FileSystemNameLength;
WCHAR FileSystemName[1];
} RDP_FILE_FS_ATTRIBUTE_INFORMATION;
typedef UNALIGNED RDP_FILE_FS_ATTRIBUTE_INFORMATION * PRDP_FILE_FS_ATTRIBUTE_INFORMATION;
//
// Define the file information class
// Server can query the client file with
// each of these information class.
// These are defined in ntioapi.h
//
typedef enum _RDP_FILE_INFORMATION_CLASS {
RdpFileDirectoryInformation = 1,
RdpFileFullDirectoryInformation, // 2
RdpFileBothDirectoryInformation, // 3
RdpFileBasicInformation, // 4
RdpFileStandardInformation, // 5
RdpFileInternalInformation, // 6
RdpFileEaInformation, // 7
RdpFileAccessInformation, // 8
RdpFileNameInformation, // 9
RdpFileRenameInformation, // 10
RdpFileLinkInformation, // 11
RdpFileNamesInformation, // 12
RdpFileDispositionInformation, // 13
RdpFilePositionInformation, // 14
RdpFileFullEaInformation, // 15
RdpFileModeInformation, // 16
RdpFileAlignmentInformation, // 17
RdpFileAllInformation, // 18
RdpFileAllocationInformation, // 19
RdpFileEndOfFileInformation, // 20
RdpFileAlternateNameInformation, // 21
RdpFileStreamInformation, // 22
RdpFilePipeInformation, // 23
RdpFilePipeLocalInformation, // 24
RdpFilePipeRemoteInformation, // 25
RdpFileMailslotQueryInformation, // 26
RdpFileMailslotSetInformation, // 27
RdpFileCompressionInformation, // 28
RdpFileObjectIdInformation, // 29
RdpFileCompletionInformation, // 30
RdpFileMoveClusterInformation, // 31
RdpFileQuotaInformation, // 32
RdpFileReparsePointInformation, // 33
RdpFileNetworkOpenInformation, // 34
RdpFileAttributeTagInformation, // 35
RdpFileTrackingInformation, // 36
RdpFileMaximumInformation
} RDP_FILE_INFORMATION_CLASS, *PRDP_FILE_INFORMATION_CLASS;
//
// This is the maximum length for the file information structures
// (not including variable file length)
// Need to update this value if there is update to the file
// information structures
//
#define RDP_FILE_INFORMATION_MAXLENGTH 36
//
// Define file information classes
//
typedef struct _RDP_FILE_BASIC_INFORMATION {
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
ULONG FileAttributes;
} RDP_FILE_BASIC_INFORMATION;
typedef UNALIGNED RDP_FILE_BASIC_INFORMATION * PRDP_FILE_BASIC_INFORMATION;
typedef struct _RDP_FILE_STANDARD_INFORMATION {
LARGE_INTEGER AllocationSize;
LARGE_INTEGER EndOfFile;
ULONG NumberOfLinks;
BOOLEAN DeletePending;
BOOLEAN Directory;
} RDP_FILE_STANDARD_INFORMATION;
typedef UNALIGNED RDP_FILE_STANDARD_INFORMATION * PRDP_FILE_STANDARD_INFORMATION;
typedef struct _RDP_FILE_ATTRIBUTE_TAG_INFORMATION {
ULONG FileAttributes;
ULONG ReparseTag;
} RDP_FILE_ATTRIBUTE_TAG_INFORMATION;
typedef UNALIGNED RDP_FILE_ATTRIBUTE_TAG_INFORMATION * PRDP_FILE_ATTRIBUTE_TAG_INFORMATION;
typedef struct _RDP_FILE_INTERNAL_INFORMATION {
LARGE_INTEGER IndexNumber;
} RDP_FILE_INTERNAL_INFORMATION;
typedef UNALIGNED RDP_FILE_INTERNAL_INFORMATION * PRDP_FILE_INTERNAL_INFORMATION;
typedef struct _RDP_FILE_RENAME_INFORMATION {
BOOLEAN ReplaceIfExists;
BOOLEAN RootDirectory; // Specify if the FileName contains the root directory
ULONG FileNameLength;
WCHAR FileName[1];
} RDP_FILE_RENAME_INFORMATION;
typedef RDP_FILE_RENAME_INFORMATION * PRDP_FILE_RENAME_INFORMATION;
//
// This is the maximum length for any directory information structure
// (not including variable file length)
// Need to update this macro if there is update to the directory
// information structure
//
#define RDP_FILE_DIRECTORY_INFO_MAXLENGTH 96
typedef struct _RDP_FILE_DIRECTORY_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER EndOfFile;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG FileNameLength;
WCHAR FileName[1];
} RDP_FILE_DIRECTORY_INFORMATION;
typedef UNALIGNED RDP_FILE_DIRECTORY_INFORMATION * PRDP_FILE_DIRECTORY_INFORMATION;
typedef struct _RDP_FILE_FULL_DIR_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER EndOfFile;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG FileNameLength;
ULONG EaSize;
WCHAR FileName[1];
} RDP_FILE_FULL_DIR_INFORMATION;
typedef UNALIGNED RDP_FILE_FULL_DIR_INFORMATION *PRDP_FILE_FULL_DIR_INFORMATION;
typedef struct _RDP_FILE_BOTH_DIR_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER EndOfFile;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG FileNameLength;
ULONG EaSize;
CHAR ShortNameLength;
WCHAR ShortName[12];
WCHAR FileName[1];
} RDP_FILE_BOTH_DIR_INFORMATION;
typedef UNALIGNED RDP_FILE_BOTH_DIR_INFORMATION *PRDP_FILE_BOTH_DIR_INFORMATION;
typedef struct _RDP_FILE_NAMES_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
ULONG FileNameLength;
WCHAR FileName[1];
} RDP_FILE_NAMES_INFORMATION;
typedef UNALIGNED RDP_FILE_NAMES_INFORMATION * PRDP_FILE_NAMES_INFORMATION;
typedef struct _RDP_FILE_END_OF_FILE_INFORMATION {
LARGE_INTEGER EndOfFile;
} RDP_FILE_END_OF_FILE_INFORMATION;
typedef UNALIGNED RDP_FILE_END_OF_FILE_INFORMATION * PRDP_FILE_END_OF_FILE_INFORMATION;
//
// File I/O Operation
// This is defined in mrx.h
//
typedef enum _RDP_LOWIO_OPS {
RDP_LOWIO_OP_READ=0,
RDP_LOWIO_OP_WRITE,
RDP_LOWIO_OP_SHAREDLOCK,
RDP_LOWIO_OP_EXCLUSIVELOCK,
RDP_LOWIO_OP_UNLOCK,
RDP_LOWIO_OP_UNLOCK_MULTIPLE,
//LOWIO_OP_UNLOCKALLBYKEY,
RDP_LOWIO_OP_FSCTL,
RDP_LOWIO_OP_IOCTL,
RDP_LOWIO_OP_NOTIFY_CHANGE_DIRECTORY,
RDP_LOWIO_OP_CLEAROUT,
RDP_LOWIO_OP_MAXIMUM
} RDP_LOWIO_OPS;
//
// File locking information
//
typedef struct _RDP_LOCK_INFO {
LONG LengthLow; // Number of bytes to lock
LONG LengthHigh;
LONG OffsetLow;
LONG OffsetHigh; // Byte offset where lock starts
} RDP_LOCK_INFO;
typedef UNALIGNED RDP_LOCK_INFO *PRDP_LOCK_INFO;
//
// Lock flags
//
#define SL_FAIL_IMMEDIATELY 0x01
#define SL_EXCLUSIVE_LOCK 0x02
typedef ULONG SECURITY_INFORMATION, *PSECURITY_INFORMATION;
//
// RDPDR_DEVICE_IOREQUEST
//
// Sent by the server to get an IO Request processed on a device
//
// IRP_MJ_CREATE
// IRP_MJ_CLEANUP
// IRP_MJ_CLOSE
// IRP_MJ_READ
// IRP_MJ_WRITE
// IRP_MJ_FLUSH_BUFFERS
// IRP_MJ_SHUTDOWN
// IRP_MJ_DEVICE_CONTROL
// IRP_MJ_INTERNAL_DEVICE_CONTROL
//
// The specific IOCTLs for serial DEVICE_CONTROL calls are:
//
// <split these in to sent and handled locally?>
// IOCTL_SERIAL_SET_BAUD_RATE
// IOCTL_SERIAL_GET_BAUD_RATE
// IOCTL_SERIAL_SET_LINE_CONTROL
// IOCTL_SERIAL_GET_LINE_CONTROL
// IOCTL_SERIAL_SET_TIMEOUTS
// IOCTL_SERIAL_GET_TIMEOUTS
// IOCTL_SERIAL_SET_CHARS
// IOCTL_SERIAL_GET_CHARS
// IOCTL_SERIAL_SET_DTR
// IOCTL_SERIAL_CLR_DTR
// IOCTL_SERIAL_RESET_DEVICE
// IOCTL_SERIAL_SET_RTS
// IOCTL_SERIAL_CLR_RTS
// IOCTL_SERIAL_SET_XOFF
// IOCTL_SERIAL_SET_XON
// IOCTL_SERIAL_SET_BREAK_ON
// IOCTL_SERIAL_SET_BREAK_OFF
// IOCTL_SERIAL_SET_QUEUE_SIZE
// IOCTL_SERIAL_GET_WAIT_MASK
// IOCTL_SERIAL_SET_WAIT_MASK
// IOCTL_SERIAL_WAIT_ON_MASK
// IOCTL_SERIAL_IMMEDIATE_CHAR
// IOCTL_SERIAL_PURGE
// IOCTL_SERIAL_GET_HANDFLOW
// IOCTL_SERIAL_SET_HANDFLOW
// IOCTL_SERIAL_GET_MODEMSTATUS
// IOCTL_SERIAL_GET_DTRRTS
// IOCTL_SERIAL_GET_COMMSTATUS
// IOCTL_SERIAL_GET_PROPERTIES
// IOCTL_SERIAL_XOFF_COUNTER
// IOCTL_SERIAL_LSRMST_INSERT
// IOCTL_SERIAL_CONFIG_SIZE
// IOCTL_SERIAL_GET_STATS
// IOCTL_SERIAL_CLEAR_STATS
//
// The specific IOCTLs for parallel DEVICE_CONTROL calls are:
//
// For IRP_MJ_DEVICE_CONTROL:
// IOCTL_PAR_QUERY_INFORMATION
// IOCTL_PAR_SET_INFORMATION
// IOCTL_PAR_QUERY_DEVICE_ID
// IOCTL_PAR_QUERY_DEVICE_ID_SIZE
// IOCTL_SERIAL_GET_TIMEOUTS
// IOCTL_SERIAL_SET_TIMEOUTS
//
// For IRP_MJ_INTERNAL_DEVICE_CONTROL:
// IOCTL_INTERNAL_GET_PARALLEL_PORT_INFO
// IOCTL_INTERNAL_PARALLEL_PORT_ALLOCATE
// IOCTL_INTERNAL_PARALLEL_CONNECT_INTERRUPT
// IOCTL_INTERNAL_PARALLEL_DISCONNECT_INTERRUPT
//
//
typedef struct tagRDPDR_DEVICE_IOREQUEST
{
ULONG DeviceId; // Id used in DeviceAnnounce
ULONG FileId; // Id for file on the device
ULONG CompletionId; // Id to return completion status
ULONG MajorFunction; // The IRP_MJ_XXX request
ULONG MinorFunction; // The subfunction of above, usually for SCSI
//
// The following Parameters depend on the IRP_MJ_XXX that is set
// in MajorFunction.
//
union {
// IRP_MJ_CREATE
struct {
ACCESS_MASK DesiredAccess;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG ShareAccess;
ULONG Disposition;
ULONG CreateOptions;
ULONG PathLength;
// PathLength Bytes follow
} Create;
// IRP_MJ_CLEANUP
// Sent, no structure
// IRP_MJ_CLOSE
// Sent, no structure
// IRP_MJ_READ
struct {
ULONG Length; // Number of UCHARs to read
LONG OffsetLow; // Byte offset where read starts
LONG OffsetHigh; // offset is defined from the beginning of the file
// Length Bytes follow
} Read;
// IRP_MJ_WRITE
struct {
ULONG Length; // Number of UCHARs to write
LONG OffsetLow; // Byte offset where write starts
LONG OffsetHigh; // offset is defined from the beginning of the file
// Length Bytes follow
} Write;
// IRP_MJ_FLUSH_BUFFERS
// Sent, no structure
// IRP_MJ_SHUTDOWN
// Not sent, no structure
// IRP_MJ_DEVICE_CONTROL, IRP_MJ_INTERNAL_DEVICE_CONTROL
// IRP_MJ_FILE_SYSTEM_CONTROL is collapsed into device control
// on the client side
struct {
ULONG OutputBufferLength;
ULONG InputBufferLength;
ULONG IoControlCode; // IOCTL_XXX
// InputBufferLength Bytes follow
} DeviceIoControl;
// IRP_MJ_QUERY_VOLUME_INFORMATION
struct {
RDP_FS_INFORMATION_CLASS FsInformationClass;
ULONG Length; // length of query buffer
} QueryVolume;
// IRP_MJ_SET_VOLUME_INFORMATION
struct {
RDP_FS_INFORMATION_CLASS FsInformationClass;
ULONG Length;
//Length Bytes follow
} SetVolume;
// IRP_MJ_QUERY_INFORMATION
struct {
RDP_FILE_INFORMATION_CLASS FileInformationClass;
ULONG Length; // length of query buffer
} QueryFile;
// IRP_MJ_SET_INFORMATION
struct {
RDP_FILE_INFORMATION_CLASS FileInformationClass;
ULONG Length;
//Length Bytes follow
} SetFile;
// IRP_MJ_QUERY_SECURITY
struct {
SECURITY_INFORMATION SecurityInformation;
ULONG Length; // length of query buffer
} QuerySd;
// IRP_MJ_SET_SECURITY
struct {
SECURITY_INFORMATION SecurityInformation;
ULONG Length;
} SetSd;
// IRP_MJ_DIRECTORY_CONTROL
struct {
RDP_FILE_INFORMATION_CLASS FileInformationClass;
BOOLEAN InitialQuery;
ULONG PathLength;
ULONG Length; // length of query buffer
// PathLength Bytes follow
} QueryDir;
// IRP_MJ_DIRECTORY_CONTROL
struct {
BOOLEAN WatchTree;
ULONG CompletionFilter;
ULONG Length;
} NotifyChangeDir;
// IRP_MJ_LOCK_CONTROL
struct {
ULONG Operation;
ULONG Flags;
ULONG NumLocks;
// LockInfo List follow
} Locks;
} Parameters;
} RDPDR_DEVICE_IOREQUEST, *PRDPDR_DEVICE_IOREQUEST;
typedef struct tagRDPDR_IOREQUEST_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICE_IOREQUEST IoRequest;
} RDPDR_IOREQUEST_PACKET, *PRDPDR_IOREQUEST_PACKET;
//
// RDPDR_DEVICE_IOCOMPLETION
//
// Sent by the client to indicate an I/O operation has completed
//
typedef struct tagRDPDR_DEVICE_IOCOMPLETION
{
ULONG DeviceId; // Given a CompletionId, is this necessary?
ULONG CompletionId; // Completion Id supplied by the request
ULONG IoStatus; // Status code
//
// The following Parameters depend on the IRP_MJ_XXX that was set
// in the MajorFunction element of the original request.
//
union {
// IRP_MJ_CREATE
struct {
ULONG FileId; // File to refer to in future IO operations
UCHAR Information; // Create/Open return information
} Create;
// Sent, no structure
// IRP_MJ_CLEANUP
// Sent, no structure
// IRP_MJ_CLOSE
// Sent, no structure
// IRP_MJ_READ
struct {
ULONG Length; // Number of UCHARs that were read
UCHAR Buffer[1]; // UCHARs that were read
} Read;
// IRP_MJ_WRITE
struct {
ULONG Length; // Number of UCHARs that were written
} Write;
// IRP_MJ_FLUSH_BUFFERS
// Sent, no structure
// IRP_MJ_SHUTDOWN
// Not sent, no structure
// IRP_MJ_DEVICE_CONTROL, IRP_MJ_INTERNAL_DEVICE_CONTROL
// IRP_MJ_FILE_SYSTEM_CONTROL is collapsed into device control
// on the client side
struct {
ULONG OutputBufferLength;
UCHAR OutputBuffer[1]; // Depends on IOCTL_XXX
} DeviceIoControl;
// IRP_MJ_QUERY_VOLUME_INFORMATION
struct {
ULONG Length;
UCHAR Buffer[1];
} QueryVolume;
// IRP_MJ_SET_VOLUME_INFORMATION
struct {
ULONG Length;
} SetVolume;
// IRP_MJ_QUERY_INFORMATION
struct {
ULONG Length;
UCHAR Buffer[1];
} QueryFile;
// IRP_MJ_SET_INFORMATION
struct {
ULONG Length;
} SetFile;
// IRP_MJ_DIRECTORY_CONTROL
struct {
ULONG Length;
UCHAR Buffer[1];
} QueryDir;
// IRP_MJ_QUERY_SECURITY
struct {
ULONG Length;
UCHAR Buffer[1];
} QuerySd;
// IRP_MJ_SET_SECURITY
struct {
ULONG Length;
} SetSd;
// IRP_MJ_LOCK_CONTROL
// Sent, no structure
} Parameters;
} RDPDR_DEVICE_IOCOMPLETION, *PRDPDR_DEVICE_IOCOMPLETION;
typedef struct tagRDPDR_IOCOMPLETION_PACKET
{
RDPDR_HEADER Header;
RDPDR_DEVICE_IOCOMPLETION IoCompletion;
} RDPDR_IOCOMPLETION_PACKET, *PRDPDR_IOCOMPLETION_PACKET;
//
// RDPDRDVMGR Event Header
//
// This header prefixes all device management events.
//
typedef struct tagRDPDRDVMGR_EVENTHEADER
{
ULONG EventType; // Event-Type Field
ULONG EventLength; // Event-Length Field
} RDPDRDVMGR_EVENTHEADER, *PRDPDRDVMGR_EVENTHEADER;
//
// Buffer Too-Small Event
//
typedef struct tagRDPDR_BUFFERTOOSMALL
{
ULONG RequiredSize; // Required Size for Request to Succeed.
} RDPDR_BUFFERTOOSMALL, *PRDPDR_BUFFERTOOSMALL;
//
// This information is sent to the server from the client.
//
// It contains information about a client-attached printing device and
// is included with the RDPDR_DEVICE_ANNOUNCE struct ... following the
// rest of the RDPDR_DEVICE_ANNOUNCE struct fields.
//
typedef struct tagRDPDR_PRINTERDEVICE_ANNOUNCE
{
ULONG Flags; // Contain the flag bits defined below
//
ULONG CodePage; // Ansi code page to use to convert the
// ansi string to unicode.
ULONG PnPNameLen; // Length (in bytes) of PnP wide-character name
// that was discovered by the client.
ULONG DriverLen; // Length (in bytes) of driver wide-character
// name that was discovered by the client.
ULONG PrinterNameLen; // Length (in bytes) of printer wide-character
// name that was discovered by the client.
ULONG CachedFieldsLen; // This is simply printer-associated binary
// data that is stashed away on the client
// machine for the server. Note that this
// data is specific to the server that
// cached the data.
// The actual fields corresponding to the above field lengths follow this
// struct in the order that the field lengths appear in this typedef.
} RDPDR_PRINTERDEVICE_ANNOUNCE, *PRDPDR_PRINTERDEVICE_ANNOUNCE;
// RDPDR_PRINTERDEVICE_ANNOUNCE structure contains ansi strings
#define RDPDR_PRINTER_ANNOUNCE_FLAG_ANSI 0x1
// The printer being announced is the default printer on the client.
#define RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER 0x2
// The printer being announced is a network printer
#define RDPDR_PRINTER_ANNOUNCE_FLAG_NETWORKPRINTER 0x4
// The printer being announced is a TS redirected printer
// It means that the printer name has been rebuilt by the client
// and the name is based on the original server/client/printer names
// (the printer is going to be nested or is nested at the nth level).
#define RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER 0x8
#define DEVICERDR_PRINT_SERVER_NAME TEXT("PrintServerName")
#define DEVICERDR_CLIENT_NAME TEXT("ClientName")
#define DEVICERDR_PRINTER_NAME TEXT("PrinterName")
//
// cache data printer events.
//
#define RDPDR_ADD_PRINTER_EVENT 0x1
#define RDPDR_UPDATE_PRINTER_EVENT 0x2
#define RDPDR_DELETE_PRINTER_EVENT 0x3
#define RDPDR_RENAME_PRINTER_EVENT 0x4
typedef struct tagRDPDR_PRINTER_CACHEDATA_PACKET
{
RDPDR_HEADER Header;
ULONG EventId;
//
// data structure that corresponds to the EventID will follow.
// Ex: for AddPrinter Event RDPDR_PRINTER_ADD_CACHEDATA will follow.
//
} RDPDR_PRINTER_CACHEDATA_PACKET, *PRDPDR_PRINTER_CACHEDATA_PACKET;
//
// RDPDR_PRINTER_ADD_CACHEDATA
//
// This structure is sent to the client from the server, when a new printer
// queue is manually added to the user session.
//
//
typedef struct tagRDPDR_PRINTER_ADD_CACHEDATA
{
UCHAR PortDosName[PREFERRED_DOS_NAME_SIZE];
// port name in ANSI format.
ULONG PnPNameLen; // Length (in bytes) of PnP wide-character name
// that was discovered by the client.
ULONG DriverLen; // Length (in bytes) of driver wide-character
// name that was discovered by the client.
ULONG PrinterNameLen; // Length (in bytes) of printer wide-character
// name that was discovered by the client.
ULONG CachedFieldsLen; // This is simply printer-associated binary
// data that is stashed away on the client
// machine for the server. Note that this
// data is specific to the server that
// cached the data.
// variable length data will follow.
} RDPDR_PRINTER_ADD_CACHEDATA, *PRDPDR_PRINTER_ADD_CACHEDATA;
//
// RDPDR_PRINTER_DELETE_CACHEDATA
//
// This structure is sent to the client from the server, when a printer
// queue is manually deleted from the user session.
//
//
typedef struct tagRDPDR_PRINTER_DELETE_CACHEDATA
{
ULONG PrinterNameLen; // Length (in bytes) of printer wide-character
// name.
// string data will follow.
} RDPDR_PRINTER_DELETE_CACHEDATA, *PRDPDR_PRINTER_DELETE_CACHEDATA;
//
// RDPDR_PRINTER_RENAME_CACHEDATA
//
// This structure is sent to the client from the server, when a printer
// queue is manually renamed from the user session.
//
//
typedef struct tagRDPDR_PRINTER_RENAME_CACHEDATA
{
ULONG OldPrinterNameLen; // Length (in bytes) of printer
// wide-character name.
ULONG NewPrinterNameLen; // Length (in bytes) of printer
// wide-character name.
// string data will follow.
} RDPDR_PRINTER_RENAME_CACHEDATA, *PRDPDR_PRINTER_RENAME_CACHEDATA;
//
// RDPDR_PRINTER_UPDATE_CACHEDATA
//
// This structure is sent to the client from the server, when the printer
// configuration is modified.
//
//
typedef struct tagRDPDR_PRINTER_UPDATE_CACHEDATA
{
ULONG PrinterNameLen; // Length (in bytes) of printer wide-character
// name.
ULONG ConfigDataLen; // Length of the cache data that will
// follow the printer name.
// string data will follow.
} RDPDR_PRINTER_UPDATE_CACHEDATA, *PRDPDR_PRINTER_UPDATE_CACHEDATA;
//
// Printer device "subclass" of RDPDR_DEVICE_ANNOUNCE.
// This message is sent from the kernel-mode "dr" to the user-mode
// "dr" so the user-mode "dr" can install a printer.
//
typedef struct tagRDPDR_PRINTERDEVICE_SUB
{
WCHAR portName[RDPDR_MAXPORTNAMELEN];
WCHAR clientName[RDPDR_MAX_COMPUTER_NAME_LENGTH];
RDPDR_DEVICE_ANNOUNCE deviceFields;
RDPDR_PRINTERDEVICE_ANNOUNCE clientPrinterFields;
} RDPDR_PRINTERDEVICE_SUB, *PRDPDR_PRINTERDEVICE_SUB;
//
// Drive device "subclass" of RDPDR_DEVICE_ANNOUNCE.
// This message is sent from the kernel-mode "dr" to the user-mode
// "dr" so the user-mode "dr" can create a UNC connection.
//
typedef struct tagRDPDR_DRIVEDEVICE_SUB
{
WCHAR driveName[RDPDR_MAXPORTNAMELEN];
WCHAR clientName[RDPDR_MAX_COMPUTER_NAME_LENGTH];
RDPDR_DEVICE_ANNOUNCE deviceFields;
WCHAR clientDisplayName[RDPDR_MAX_CLIENT_DISPLAY_NAME];
} RDPDR_DRIVEDEVICE_SUB, *PRDPDR_DRIVEDEVICE_SUB;
//
// Indicate to the user-mode component that a device has been removed.
//
typedef struct tagRDPDR_REMOVEDEVICE
{
ULONG deviceID;
} RDPDR_REMOVEDEVICE, *PRDPDR_REMOVEDEVICE;
//
// Port device "subclass" of RDPDR_DEVICE_ANNOUNCE. This message is
// sent from the kernel-mode "dr" to the user-mode "dr" so the user-mode
// "dr" can install a port.
//
typedef struct tagRDPDR_PORTDEVICE_SUB
{
WCHAR portName[RDPDR_MAXPORTNAMELEN];
WCHAR devicePath[RDPDRMAXNTDEVICENAMEGLEN];
RDPDR_DEVICE_ANNOUNCE deviceFields;
} RDPDR_PORTDEVICE_SUB, *PRDPDR_PORTDEVICE_SUB;
//
// Restore packing style (previous for 32-bit, default for 16-bit).
//
#ifdef OS_WIN16
#pragma pack ()
#else
#pragma pack (pop, drpack)
#endif
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // RDPDR