728 lines
23 KiB
Rust
728 lines
23 KiB
Rust
#![cfg(feature = "msos-descriptor")]
|
|
|
|
//! Microsoft OS Descriptors
|
|
//!
|
|
//! <https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/microsoft-os-2-0-descriptors-specification>
|
|
|
|
use core::mem::size_of;
|
|
|
|
use super::{capability_type, BosWriter};
|
|
use crate::types::InterfaceNumber;
|
|
|
|
/// A serialized Microsoft OS 2.0 Descriptor set.
|
|
///
|
|
/// Create with [`DeviceDescriptorSetBuilder`].
|
|
pub struct MsOsDescriptorSet<'d> {
|
|
descriptor: &'d [u8],
|
|
vendor_code: u8,
|
|
}
|
|
|
|
impl<'d> MsOsDescriptorSet<'d> {
|
|
/// Gets the raw bytes of the MS OS descriptor
|
|
pub fn descriptor(&self) -> &[u8] {
|
|
self.descriptor
|
|
}
|
|
|
|
/// Gets the vendor code used by the host to retrieve the MS OS descriptor
|
|
pub fn vendor_code(&self) -> u8 {
|
|
self.vendor_code
|
|
}
|
|
|
|
/// Returns `true` if no MS OS descriptor data is available
|
|
pub fn is_empty(&self) -> bool {
|
|
self.descriptor.is_empty()
|
|
}
|
|
}
|
|
|
|
/// Writes a Microsoft OS 2.0 Descriptor set into a buffer.
|
|
pub struct MsOsDescriptorWriter<'d> {
|
|
buf: &'d mut [u8],
|
|
|
|
position: usize,
|
|
config_mark: Option<usize>,
|
|
function_mark: Option<usize>,
|
|
vendor_code: u8,
|
|
}
|
|
|
|
impl<'d> MsOsDescriptorWriter<'d> {
|
|
pub(crate) fn new(buf: &'d mut [u8]) -> Self {
|
|
MsOsDescriptorWriter {
|
|
buf,
|
|
position: 0,
|
|
config_mark: None,
|
|
function_mark: None,
|
|
vendor_code: 0,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn build(mut self, bos: &mut BosWriter) -> MsOsDescriptorSet<'d> {
|
|
self.end();
|
|
|
|
if self.is_empty() {
|
|
MsOsDescriptorSet {
|
|
descriptor: &[],
|
|
vendor_code: 0,
|
|
}
|
|
} else {
|
|
self.write_bos(bos);
|
|
MsOsDescriptorSet {
|
|
descriptor: &self.buf[..self.position],
|
|
vendor_code: self.vendor_code,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns `true` if the MS OS descriptor header has not yet been written
|
|
pub fn is_empty(&self) -> bool {
|
|
self.position == 0
|
|
}
|
|
|
|
/// Returns `true` if a configuration subset header has been started
|
|
pub fn is_in_config_subset(&self) -> bool {
|
|
self.config_mark.is_some()
|
|
}
|
|
|
|
/// Returns `true` if a function subset header has been started and not yet ended
|
|
pub fn is_in_function_subset(&self) -> bool {
|
|
self.function_mark.is_some()
|
|
}
|
|
|
|
/// Write the MS OS descriptor set header.
|
|
///
|
|
/// - `windows_version` is an NTDDI version constant that describes a windows version. See the [`windows_version`]
|
|
/// module.
|
|
/// - `vendor_code` is the vendor request code used to read the MS OS descriptor set.
|
|
pub fn header(&mut self, windows_version: u32, vendor_code: u8) {
|
|
assert!(self.is_empty(), "You can only call MsOsDescriptorWriter::header once");
|
|
self.write(DescriptorSetHeader::new(windows_version));
|
|
self.vendor_code = vendor_code;
|
|
}
|
|
|
|
/// Add a device level feature descriptor.
|
|
///
|
|
/// Note that some feature descriptors may only be used at the device level in non-composite devices.
|
|
/// Those features must be written before the first call to [`Self::configuration`].
|
|
pub fn device_feature<T: DeviceLevelDescriptor>(&mut self, desc: T) {
|
|
assert!(
|
|
!self.is_empty(),
|
|
"device features may only be added after the header is written"
|
|
);
|
|
assert!(
|
|
self.config_mark.is_none(),
|
|
"device features must be added before the first configuration subset"
|
|
);
|
|
self.write(desc);
|
|
}
|
|
|
|
/// Add a configuration subset.
|
|
pub fn configuration(&mut self, config: u8) {
|
|
assert!(
|
|
!self.is_empty(),
|
|
"MsOsDescriptorWriter: configuration must be called after header"
|
|
);
|
|
Self::end_subset::<ConfigurationSubsetHeader>(self.buf, self.position, &mut self.config_mark);
|
|
self.config_mark = Some(self.position);
|
|
self.write(ConfigurationSubsetHeader::new(config));
|
|
}
|
|
|
|
/// Add a function subset.
|
|
pub fn function(&mut self, first_interface: InterfaceNumber) {
|
|
assert!(
|
|
self.config_mark.is_some(),
|
|
"MsOsDescriptorWriter: function subset requires a configuration subset"
|
|
);
|
|
self.end_function();
|
|
self.function_mark = Some(self.position);
|
|
self.write(FunctionSubsetHeader::new(first_interface));
|
|
}
|
|
|
|
/// Add a function level feature descriptor.
|
|
///
|
|
/// Note that some features may only be used at the function level. Those features must be written after a call
|
|
/// to [`Self::function`].
|
|
pub fn function_feature<T: FunctionLevelDescriptor>(&mut self, desc: T) {
|
|
assert!(
|
|
self.function_mark.is_some(),
|
|
"function features may only be added to a function subset"
|
|
);
|
|
self.write(desc);
|
|
}
|
|
|
|
/// Ends the current function subset (if any)
|
|
pub fn end_function(&mut self) {
|
|
Self::end_subset::<FunctionSubsetHeader>(self.buf, self.position, &mut self.function_mark);
|
|
}
|
|
|
|
fn write<T: Descriptor>(&mut self, desc: T) {
|
|
desc.write_to(&mut self.buf[self.position..]);
|
|
self.position += desc.size();
|
|
}
|
|
|
|
fn end_subset<T: DescriptorSet>(buf: &mut [u8], position: usize, mark: &mut Option<usize>) {
|
|
if let Some(mark) = mark.take() {
|
|
let len = position - mark;
|
|
let p = mark + T::LENGTH_OFFSET;
|
|
buf[p..(p + 2)].copy_from_slice(&(len as u16).to_le_bytes());
|
|
}
|
|
}
|
|
|
|
fn end(&mut self) {
|
|
if self.position > 0 {
|
|
Self::end_subset::<FunctionSubsetHeader>(self.buf, self.position, &mut self.function_mark);
|
|
Self::end_subset::<ConfigurationSubsetHeader>(self.buf, self.position, &mut self.config_mark);
|
|
Self::end_subset::<DescriptorSetHeader>(self.buf, self.position, &mut Some(0));
|
|
}
|
|
}
|
|
|
|
fn write_bos(&mut self, bos: &mut BosWriter) {
|
|
let windows_version = &self.buf[4..8];
|
|
let len = (self.position as u16).to_le_bytes();
|
|
bos.capability(
|
|
capability_type::PLATFORM,
|
|
&[
|
|
0, // reserved
|
|
// platform capability UUID, Microsoft OS 2.0 platform compabitility
|
|
0xdf,
|
|
0x60,
|
|
0xdd,
|
|
0xd8,
|
|
0x89,
|
|
0x45,
|
|
0xc7,
|
|
0x4c,
|
|
0x9c,
|
|
0xd2,
|
|
0x65,
|
|
0x9d,
|
|
0x9e,
|
|
0x64,
|
|
0x8a,
|
|
0x9f,
|
|
// Minimum compatible Windows version
|
|
windows_version[0],
|
|
windows_version[1],
|
|
windows_version[2],
|
|
windows_version[3],
|
|
// Descriptor set length
|
|
len[0],
|
|
len[1],
|
|
self.vendor_code,
|
|
0x0, // Device does not support alternate enumeration
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Microsoft Windows version codes
|
|
///
|
|
/// Windows 8.1 is the minimum version allowed for MS OS 2.0 descriptors.
|
|
pub mod windows_version {
|
|
/// Windows 8.1 (aka `NTDDI_WINBLUE`)
|
|
pub const WIN8_1: u32 = 0x06030000;
|
|
/// Windows 10
|
|
pub const WIN10: u32 = 0x0A000000;
|
|
}
|
|
|
|
mod sealed {
|
|
use core::mem::size_of;
|
|
|
|
/// A trait for descriptors
|
|
pub trait Descriptor: Sized {
|
|
const TYPE: super::DescriptorType;
|
|
|
|
/// The size of the descriptor's header.
|
|
fn size(&self) -> usize {
|
|
size_of::<Self>()
|
|
}
|
|
|
|
fn write_to(&self, buf: &mut [u8]);
|
|
}
|
|
|
|
pub trait DescriptorSet: Descriptor {
|
|
const LENGTH_OFFSET: usize;
|
|
}
|
|
}
|
|
|
|
use sealed::*;
|
|
|
|
/// Copies the data of `t` into `buf`.
|
|
///
|
|
/// # Safety
|
|
/// The type `T` must be able to be safely cast to `&[u8]`. (e.g. it is a `#[repr(packed)]` struct)
|
|
unsafe fn transmute_write_to<T: Sized>(t: &T, buf: &mut [u8]) {
|
|
let bytes = core::slice::from_raw_parts((t as *const T) as *const u8, size_of::<T>());
|
|
assert!(buf.len() >= bytes.len(), "MS OS descriptor buffer full");
|
|
(&mut buf[..bytes.len()]).copy_from_slice(bytes);
|
|
}
|
|
|
|
/// Table 9. Microsoft OS 2.0 descriptor wDescriptorType values.
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
#[repr(u16)]
|
|
pub enum DescriptorType {
|
|
/// MS OS descriptor set header
|
|
SetHeaderDescriptor = 0,
|
|
/// Configuration subset header
|
|
SubsetHeaderConfiguration = 1,
|
|
/// Function subset header
|
|
SubsetHeaderFunction = 2,
|
|
/// Compatible device ID feature descriptor
|
|
FeatureCompatibleId = 3,
|
|
/// Registry property feature descriptor
|
|
FeatureRegProperty = 4,
|
|
/// Minimum USB resume time feature descriptor
|
|
FeatureMinResumeTime = 5,
|
|
/// Vendor revision feature descriptor
|
|
FeatureModelId = 6,
|
|
/// CCGP device descriptor feature descriptor
|
|
FeatureCcgpDevice = 7,
|
|
/// Vendor revision feature descriptor
|
|
FeatureVendorRevision = 8,
|
|
}
|
|
|
|
/// Table 5. Descriptor set information structure.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct DescriptorSetInformation {
|
|
dwWindowsVersion: u32,
|
|
wMSOSDescriptorSetTotalLength: u16,
|
|
bMS_VendorCode: u8,
|
|
bAltEnumCode: u8,
|
|
}
|
|
|
|
/// Table 4. Microsoft OS 2.0 platform capability descriptor header.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct PlatformDescriptor {
|
|
bLength: u8,
|
|
bDescriptorType: u8,
|
|
bDevCapabilityType: u8,
|
|
bReserved: u8,
|
|
platformCapabilityUUID: [u8; 16],
|
|
descriptor_set_information: DescriptorSetInformation,
|
|
}
|
|
|
|
/// Table 10. Microsoft OS 2.0 descriptor set header.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct DescriptorSetHeader {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
dwWindowsVersion: u32,
|
|
wTotalLength: u16,
|
|
}
|
|
|
|
impl DescriptorSetHeader {
|
|
/// Creates a MS OS descriptor set header.
|
|
///
|
|
/// `windows_version` is the minimum Windows version the descriptor set can apply to.
|
|
pub fn new(windows_version: u32) -> Self {
|
|
DescriptorSetHeader {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
dwWindowsVersion: windows_version.to_le(),
|
|
wTotalLength: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Descriptor for DescriptorSetHeader {
|
|
const TYPE: DescriptorType = DescriptorType::SetHeaderDescriptor;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl DescriptorSet for DescriptorSetHeader {
|
|
const LENGTH_OFFSET: usize = 8;
|
|
}
|
|
|
|
/// Table 11. Configuration subset header.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct ConfigurationSubsetHeader {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
bConfigurationValue: u8,
|
|
bReserved: u8,
|
|
wTotalLength: u16,
|
|
}
|
|
|
|
impl ConfigurationSubsetHeader {
|
|
/// Creates a configuration subset header
|
|
pub fn new(config: u8) -> Self {
|
|
ConfigurationSubsetHeader {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
bConfigurationValue: config,
|
|
bReserved: 0,
|
|
wTotalLength: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Descriptor for ConfigurationSubsetHeader {
|
|
const TYPE: DescriptorType = DescriptorType::SubsetHeaderConfiguration;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl DescriptorSet for ConfigurationSubsetHeader {
|
|
const LENGTH_OFFSET: usize = 6;
|
|
}
|
|
|
|
/// Table 12. Function subset header.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct FunctionSubsetHeader {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
bFirstInterface: InterfaceNumber,
|
|
bReserved: u8,
|
|
wSubsetLength: u16,
|
|
}
|
|
|
|
impl FunctionSubsetHeader {
|
|
/// Creates a function subset header
|
|
pub fn new(first_interface: InterfaceNumber) -> Self {
|
|
FunctionSubsetHeader {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
bFirstInterface: first_interface,
|
|
bReserved: 0,
|
|
wSubsetLength: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Descriptor for FunctionSubsetHeader {
|
|
const TYPE: DescriptorType = DescriptorType::SubsetHeaderFunction;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl DescriptorSet for FunctionSubsetHeader {
|
|
const LENGTH_OFFSET: usize = 6;
|
|
}
|
|
|
|
// Feature Descriptors
|
|
|
|
/// A marker trait for feature descriptors that are valid at the device level.
|
|
pub trait DeviceLevelDescriptor: Descriptor {}
|
|
|
|
/// A marker trait for feature descriptors that are valid at the function level.
|
|
pub trait FunctionLevelDescriptor: Descriptor {}
|
|
|
|
/// Table 13. Microsoft OS 2.0 compatible ID descriptor.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct CompatibleIdFeatureDescriptor {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
compatibleId: [u8; 8],
|
|
subCompatibleId: [u8; 8],
|
|
}
|
|
|
|
impl DeviceLevelDescriptor for CompatibleIdFeatureDescriptor {}
|
|
impl FunctionLevelDescriptor for CompatibleIdFeatureDescriptor {}
|
|
|
|
impl Descriptor for CompatibleIdFeatureDescriptor {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureCompatibleId;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl CompatibleIdFeatureDescriptor {
|
|
/// Creates a compatible ID feature descriptor
|
|
///
|
|
/// The ids must be 8 ASCII bytes or fewer.
|
|
pub fn new(compatible_id: &str, sub_compatible_id: &str) -> Self {
|
|
assert!(compatible_id.len() <= 8 && sub_compatible_id.len() <= 8);
|
|
let mut cid = [0u8; 8];
|
|
(&mut cid[..compatible_id.len()]).copy_from_slice(compatible_id.as_bytes());
|
|
let mut scid = [0u8; 8];
|
|
(&mut scid[..sub_compatible_id.len()]).copy_from_slice(sub_compatible_id.as_bytes());
|
|
Self::new_raw(cid, scid)
|
|
}
|
|
|
|
fn new_raw(compatible_id: [u8; 8], sub_compatible_id: [u8; 8]) -> Self {
|
|
Self {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
compatibleId: compatible_id,
|
|
subCompatibleId: sub_compatible_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table 14. Microsoft OS 2.0 registry property descriptor
|
|
#[allow(non_snake_case)]
|
|
pub struct RegistryPropertyFeatureDescriptor<'a> {
|
|
name: &'a str,
|
|
data: PropertyData<'a>,
|
|
}
|
|
|
|
/// Data values that can be encoded into a registry property descriptor
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
|
pub enum PropertyData<'a> {
|
|
/// A registry property containing a string.
|
|
Sz(&'a str),
|
|
/// A registry property containing a string that expands environment variables.
|
|
ExpandSz(&'a str),
|
|
/// A registry property containing binary data.
|
|
Binary(&'a [u8]),
|
|
/// A registry property containing a little-endian 32-bit integer.
|
|
DwordLittleEndian(u32),
|
|
/// A registry property containing a big-endian 32-bit integer.
|
|
DwordBigEndian(u32),
|
|
/// A registry property containing a string that contains a symbolic link.
|
|
Link(&'a str),
|
|
/// A registry property containing multiple strings.
|
|
RegMultiSz(&'a [&'a str]),
|
|
}
|
|
|
|
fn write_bytes(val: &[u8], buf: &mut [u8]) -> usize {
|
|
assert!(buf.len() >= val.len());
|
|
buf[..val.len()].copy_from_slice(val);
|
|
val.len()
|
|
}
|
|
|
|
fn write_utf16(val: &str, buf: &mut [u8]) -> usize {
|
|
let mut pos = 0;
|
|
for c in val.encode_utf16() {
|
|
pos += write_bytes(&c.to_le_bytes(), &mut buf[pos..]);
|
|
}
|
|
pos + write_bytes(&0u16.to_le_bytes(), &mut buf[pos..])
|
|
}
|
|
|
|
impl<'a> PropertyData<'a> {
|
|
/// Gets the `PropertyDataType` for this property value
|
|
pub fn kind(&self) -> PropertyDataType {
|
|
match self {
|
|
PropertyData::Sz(_) => PropertyDataType::Sz,
|
|
PropertyData::ExpandSz(_) => PropertyDataType::ExpandSz,
|
|
PropertyData::Binary(_) => PropertyDataType::Binary,
|
|
PropertyData::DwordLittleEndian(_) => PropertyDataType::DwordLittleEndian,
|
|
PropertyData::DwordBigEndian(_) => PropertyDataType::DwordBigEndian,
|
|
PropertyData::Link(_) => PropertyDataType::Link,
|
|
PropertyData::RegMultiSz(_) => PropertyDataType::RegMultiSz,
|
|
}
|
|
}
|
|
|
|
/// Gets the size (in bytes) of this property value when encoded.
|
|
pub fn size(&self) -> usize {
|
|
match self {
|
|
PropertyData::Sz(val) | PropertyData::ExpandSz(val) | PropertyData::Link(val) => {
|
|
core::mem::size_of::<u16>() * (val.encode_utf16().count() + 1)
|
|
}
|
|
PropertyData::Binary(val) => val.len(),
|
|
PropertyData::DwordLittleEndian(val) | PropertyData::DwordBigEndian(val) => core::mem::size_of_val(val),
|
|
PropertyData::RegMultiSz(val) => {
|
|
core::mem::size_of::<u16>() * val.iter().map(|x| x.encode_utf16().count() + 1).sum::<usize>() + 1
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Encodes the data for this property value and writes it to `buf`.
|
|
pub fn write(&self, buf: &mut [u8]) -> usize {
|
|
match self {
|
|
PropertyData::Sz(val) | PropertyData::ExpandSz(val) | PropertyData::Link(val) => write_utf16(val, buf),
|
|
PropertyData::Binary(val) => write_bytes(val, buf),
|
|
PropertyData::DwordLittleEndian(val) => write_bytes(&val.to_le_bytes(), buf),
|
|
PropertyData::DwordBigEndian(val) => write_bytes(&val.to_be_bytes(), buf),
|
|
PropertyData::RegMultiSz(val) => {
|
|
let mut pos = 0;
|
|
for s in *val {
|
|
pos += write_utf16(s, &mut buf[pos..]);
|
|
}
|
|
pos + write_bytes(&0u16.to_le_bytes(), &mut buf[pos..])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table 15. wPropertyDataType values for the Microsoft OS 2.0 registry property descriptor.
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
#[repr(u16)]
|
|
pub enum PropertyDataType {
|
|
/// A registry property containing a string.
|
|
Sz = 1,
|
|
/// A registry property containing a string that expands environment variables.
|
|
ExpandSz = 2,
|
|
/// A registry property containing binary data.
|
|
Binary = 3,
|
|
/// A registry property containing a little-endian 32-bit integer.
|
|
DwordLittleEndian = 4,
|
|
/// A registry property containing a big-endian 32-bit integer.
|
|
DwordBigEndian = 5,
|
|
/// A registry property containing a string that contains a symbolic link.
|
|
Link = 6,
|
|
/// A registry property containing multiple strings.
|
|
RegMultiSz = 7,
|
|
}
|
|
|
|
impl<'a> DeviceLevelDescriptor for RegistryPropertyFeatureDescriptor<'a> {}
|
|
impl<'a> FunctionLevelDescriptor for RegistryPropertyFeatureDescriptor<'a> {}
|
|
|
|
impl<'a> Descriptor for RegistryPropertyFeatureDescriptor<'a> {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureRegProperty;
|
|
|
|
fn size(&self) -> usize {
|
|
10 + self.name_size() + self.data.size()
|
|
}
|
|
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
assert!(buf.len() >= self.size(), "MS OS descriptor buffer full");
|
|
|
|
let mut pos = 0;
|
|
pos += write_bytes(&(self.size() as u16).to_le_bytes(), &mut buf[pos..]);
|
|
pos += write_bytes(&(Self::TYPE as u16).to_le_bytes(), &mut buf[pos..]);
|
|
pos += write_bytes(&(self.data.kind() as u16).to_le_bytes(), &mut buf[pos..]);
|
|
pos += write_bytes(&(self.name_size() as u16).to_le_bytes(), &mut buf[pos..]);
|
|
pos += write_utf16(self.name, &mut buf[pos..]);
|
|
pos += write_bytes(&(self.data.size() as u16).to_le_bytes(), &mut buf[pos..]);
|
|
self.data.write(&mut buf[pos..]);
|
|
}
|
|
}
|
|
|
|
impl<'a> RegistryPropertyFeatureDescriptor<'a> {
|
|
/// A registry property.
|
|
pub fn new(name: &'a str, data: PropertyData<'a>) -> Self {
|
|
Self { name, data }
|
|
}
|
|
|
|
fn name_size(&self) -> usize {
|
|
core::mem::size_of::<u16>() * (self.name.encode_utf16().count() + 1)
|
|
}
|
|
}
|
|
|
|
/// Table 16. Microsoft OS 2.0 minimum USB recovery time descriptor.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct MinimumRecoveryTimeDescriptor {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
bResumeRecoveryTime: u8,
|
|
bResumeSignalingTime: u8,
|
|
}
|
|
|
|
impl DeviceLevelDescriptor for MinimumRecoveryTimeDescriptor {}
|
|
|
|
impl Descriptor for MinimumRecoveryTimeDescriptor {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureMinResumeTime;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl MinimumRecoveryTimeDescriptor {
|
|
/// Times are in milliseconds.
|
|
///
|
|
/// `resume_recovery_time` must be >= 0 and <= 10.
|
|
/// `resume_signaling_time` must be >= 1 and <= 20.
|
|
pub fn new(resume_recovery_time: u8, resume_signaling_time: u8) -> Self {
|
|
assert!(resume_recovery_time <= 10);
|
|
assert!(resume_signaling_time >= 1 && resume_signaling_time <= 20);
|
|
Self {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
bResumeRecoveryTime: resume_recovery_time,
|
|
bResumeSignalingTime: resume_signaling_time,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table 17. Microsoft OS 2.0 model ID descriptor.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct ModelIdDescriptor {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
modelId: [u8; 16],
|
|
}
|
|
|
|
impl DeviceLevelDescriptor for ModelIdDescriptor {}
|
|
|
|
impl Descriptor for ModelIdDescriptor {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureModelId;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl ModelIdDescriptor {
|
|
/// Creates a new model ID descriptor
|
|
///
|
|
/// `model_id` should be a uuid that uniquely identifies a physical device.
|
|
pub fn new(model_id: u128) -> Self {
|
|
Self {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
modelId: model_id.to_le_bytes(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table 18. Microsoft OS 2.0 CCGP device descriptor.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct CcgpDeviceDescriptor {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
}
|
|
|
|
impl DeviceLevelDescriptor for CcgpDeviceDescriptor {}
|
|
|
|
impl Descriptor for CcgpDeviceDescriptor {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureCcgpDevice;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl CcgpDeviceDescriptor {
|
|
/// Creates a new CCGP device descriptor
|
|
pub fn new() -> Self {
|
|
Self {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Table 19. Microsoft OS 2.0 vendor revision descriptor.
|
|
#[allow(non_snake_case)]
|
|
#[repr(C, packed(1))]
|
|
pub struct VendorRevisionDescriptor {
|
|
wLength: u16,
|
|
wDescriptorType: u16,
|
|
/// Revision number associated with the descriptor set. Modify it every time you add/modify a registry property or
|
|
/// other MS OS descriptor. Shell set to greater than or equal to 1.
|
|
VendorRevision: u16,
|
|
}
|
|
|
|
impl DeviceLevelDescriptor for VendorRevisionDescriptor {}
|
|
impl FunctionLevelDescriptor for VendorRevisionDescriptor {}
|
|
|
|
impl Descriptor for VendorRevisionDescriptor {
|
|
const TYPE: DescriptorType = DescriptorType::FeatureVendorRevision;
|
|
fn write_to(&self, buf: &mut [u8]) {
|
|
unsafe { transmute_write_to(self, buf) }
|
|
}
|
|
}
|
|
|
|
impl VendorRevisionDescriptor {
|
|
/// Creates a new vendor revision descriptor
|
|
pub fn new(revision: u16) -> Self {
|
|
assert!(revision >= 1);
|
|
Self {
|
|
wLength: (size_of::<Self>() as u16).to_le(),
|
|
wDescriptorType: (Self::TYPE as u16).to_le(),
|
|
VendorRevision: revision.to_le(),
|
|
}
|
|
}
|
|
}
|