/** * FreeRDP: A Remote Desktop Protocol Implementation * Device Redirection Virtual Channel * * Copyright 2010-2011 Vic Lee * Copyright 2010-2012 Marc-Andre Moreau * Copyright 2015-2016 Thincast Technologies GmbH * Copyright 2015 DI (FH) Martin Haimberger * Copyright 2016 Armin Novak * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include "rdpdr_main.h" #include "rdpdr_capabilities.h" #define RDPDR_CAPABILITY_HEADER_LENGTH 8 /* Output device direction general capability set */ static void rdpdr_write_general_capset(rdpdrPlugin* rdpdr, wStream* s) { WINPR_UNUSED(rdpdr); const RDPDR_CAPABILITY_HEADER header = { CAP_GENERAL_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH + 36, GENERAL_CAPABILITY_VERSION_02 }; const UINT32 ioCode1 = rdpdr->clientIOCode1 & rdpdr->serverIOCode1; const UINT32 ioCode2 = rdpdr->clientIOCode2 & rdpdr->serverIOCode2; rdpdr_write_capset_header(rdpdr->log, s, &header); Stream_Write_UINT32(s, rdpdr->clientOsType); /* osType, ignored on receipt */ Stream_Write_UINT32(s, rdpdr->clientOsVersion); /* osVersion, unused and must be set to zero */ Stream_Write_UINT16(s, rdpdr->clientVersionMajor); /* protocolMajorVersion, must be set to 1 */ Stream_Write_UINT16(s, rdpdr->clientVersionMinor); /* protocolMinorVersion */ Stream_Write_UINT32(s, ioCode1); /* ioCode1 */ Stream_Write_UINT32(s, ioCode2); /* ioCode2, must be set to zero, reserved for future use */ Stream_Write_UINT32(s, rdpdr->clientExtendedPDU); /* extendedPDU */ Stream_Write_UINT32(s, rdpdr->clientExtraFlags1); /* extraFlags1 */ Stream_Write_UINT32( s, rdpdr->clientExtraFlags2); /* extraFlags2, must be set to zero, reserved for future use */ Stream_Write_UINT32( s, rdpdr->clientSpecialTypeDeviceCap); /* SpecialTypeDeviceCap, number of special devices to be redirected before logon */ } /* Process device direction general capability set */ static UINT rdpdr_process_general_capset(rdpdrPlugin* rdpdr, wStream* s, const RDPDR_CAPABILITY_HEADER* header) { WINPR_ASSERT(header); if (header->CapabilityLength != 36) { WLog_Print(rdpdr->log, WLOG_ERROR, "CAP_GENERAL_TYPE::CapabilityLength expected 36, got %" PRIu32, header->CapabilityLength); return ERROR_INVALID_DATA; } if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 36)) return ERROR_INVALID_DATA; Stream_Read_UINT32(s, rdpdr->serverOsType); /* osType, ignored on receipt */ Stream_Read_UINT32(s, rdpdr->serverOsVersion); /* osVersion, unused and must be set to zero */ Stream_Read_UINT16(s, rdpdr->serverVersionMajor); /* protocolMajorVersion, must be set to 1 */ Stream_Read_UINT16(s, rdpdr->serverVersionMinor); /* protocolMinorVersion */ Stream_Read_UINT32(s, rdpdr->serverIOCode1); /* ioCode1 */ Stream_Read_UINT32( s, rdpdr->serverIOCode2); /* ioCode2, must be set to zero, reserved for future use */ Stream_Read_UINT32(s, rdpdr->serverExtendedPDU); /* extendedPDU */ Stream_Read_UINT32(s, rdpdr->serverExtraFlags1); /* extraFlags1 */ Stream_Read_UINT32( s, rdpdr->serverExtraFlags2); /* extraFlags2, must be set to zero, reserved for future use */ Stream_Read_UINT32( s, rdpdr->serverSpecialTypeDeviceCap); /* SpecialTypeDeviceCap, number of special devices to be redirected before logon */ return CHANNEL_RC_OK; } /* Output printer direction capability set */ static void rdpdr_write_printer_capset(rdpdrPlugin* rdpdr, wStream* s) { WINPR_UNUSED(rdpdr); const RDPDR_CAPABILITY_HEADER header = { CAP_PRINTER_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH, PRINT_CAPABILITY_VERSION_01 }; rdpdr_write_capset_header(rdpdr->log, s, &header); } /* Process printer direction capability set */ static UINT rdpdr_process_printer_capset(rdpdrPlugin* rdpdr, wStream* s, const RDPDR_CAPABILITY_HEADER* header) { WINPR_ASSERT(header); Stream_Seek(s, header->CapabilityLength); return CHANNEL_RC_OK; } /* Output port redirection capability set */ static void rdpdr_write_port_capset(rdpdrPlugin* rdpdr, wStream* s) { WINPR_UNUSED(rdpdr); const RDPDR_CAPABILITY_HEADER header = { CAP_PORT_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH, PORT_CAPABILITY_VERSION_01 }; rdpdr_write_capset_header(rdpdr->log, s, &header); } /* Process port redirection capability set */ static UINT rdpdr_process_port_capset(rdpdrPlugin* rdpdr, wStream* s, const RDPDR_CAPABILITY_HEADER* header) { WINPR_ASSERT(header); Stream_Seek(s, header->CapabilityLength); return CHANNEL_RC_OK; } /* Output drive redirection capability set */ static void rdpdr_write_drive_capset(rdpdrPlugin* rdpdr, wStream* s) { WINPR_UNUSED(rdpdr); const RDPDR_CAPABILITY_HEADER header = { CAP_DRIVE_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH, DRIVE_CAPABILITY_VERSION_02 }; rdpdr_write_capset_header(rdpdr->log, s, &header); } /* Process drive redirection capability set */ static UINT rdpdr_process_drive_capset(rdpdrPlugin* rdpdr, wStream* s, const RDPDR_CAPABILITY_HEADER* header) { WINPR_ASSERT(header); Stream_Seek(s, header->CapabilityLength); return CHANNEL_RC_OK; } /* Output smart card redirection capability set */ static void rdpdr_write_smartcard_capset(rdpdrPlugin* rdpdr, wStream* s) { WINPR_UNUSED(rdpdr); const RDPDR_CAPABILITY_HEADER header = { CAP_SMARTCARD_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH, SMARTCARD_CAPABILITY_VERSION_01 }; rdpdr_write_capset_header(rdpdr->log, s, &header); } /* Process smartcard redirection capability set */ static UINT rdpdr_process_smartcard_capset(rdpdrPlugin* rdpdr, wStream* s, const RDPDR_CAPABILITY_HEADER* header) { WINPR_ASSERT(header); Stream_Seek(s, header->CapabilityLength); return CHANNEL_RC_OK; } UINT rdpdr_process_capability_request(rdpdrPlugin* rdpdr, wStream* s) { UINT status = CHANNEL_RC_OK; UINT16 numCapabilities = 0; if (!rdpdr || !s) return CHANNEL_RC_NULL_DATA; WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_SERVER_CAPS); rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_CLIENT_CAPS); if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 4)) return ERROR_INVALID_DATA; Stream_Read_UINT16(s, numCapabilities); Stream_Seek(s, 2); /* pad (2 bytes) */ for (UINT16 i = 0; i < numCapabilities; i++) { RDPDR_CAPABILITY_HEADER header = { 0 }; UINT error = rdpdr_read_capset_header(rdpdr->log, s, &header); if (error != CHANNEL_RC_OK) return error; switch (header.CapabilityType) { case CAP_GENERAL_TYPE: status = rdpdr_process_general_capset(rdpdr, s, &header); break; case CAP_PRINTER_TYPE: status = rdpdr_process_printer_capset(rdpdr, s, &header); break; case CAP_PORT_TYPE: status = rdpdr_process_port_capset(rdpdr, s, &header); break; case CAP_DRIVE_TYPE: status = rdpdr_process_drive_capset(rdpdr, s, &header); break; case CAP_SMARTCARD_TYPE: status = rdpdr_process_smartcard_capset(rdpdr, s, &header); break; default: break; } if (status != CHANNEL_RC_OK) return status; } return CHANNEL_RC_OK; } /** * Function description * * @return 0 on success, otherwise a Win32 error code */ UINT rdpdr_send_capability_response(rdpdrPlugin* rdpdr) { wStream* s = NULL; WINPR_ASSERT(rdpdr); s = StreamPool_Take(rdpdr->pool, 256); if (!s) { WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!"); return CHANNEL_RC_NO_MEMORY; } Stream_Write_UINT16(s, RDPDR_CTYP_CORE); Stream_Write_UINT16(s, PAKID_CORE_CLIENT_CAPABILITY); Stream_Write_UINT16(s, 5); /* numCapabilities */ Stream_Write_UINT16(s, 0); /* pad */ rdpdr_write_general_capset(rdpdr, s); rdpdr_write_printer_capset(rdpdr, s); rdpdr_write_port_capset(rdpdr, s); rdpdr_write_drive_capset(rdpdr, s); rdpdr_write_smartcard_capset(rdpdr, s); return rdpdr_send(rdpdr, s); }