use crate::{Buf, BufMut, BufResult};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ContentType(pub u8);
impl ContentType {
pub const INVALID: Self = Self(0);
pub const CHANGE_CIPHER_SPEC: Self = Self(20);
pub const ALERT: Self = Self(21);
pub const HANDSHAKE: Self = Self(22);
pub const APPLICATION_DATA: Self = Self(23);
}
impl From<u8> for ContentType {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<ContentType> for u8 {
#[inline(always)]
fn from(val: ContentType) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProtocolVersion(pub u16);
impl ProtocolVersion {
pub const SSL3_0: Self = Self(768);
pub const TLS1_0: Self = Self(769);
pub const TLS1_1: Self = Self(770);
pub const TLS1_2: Self = Self(771);
pub const TLS1_3: Self = Self(772);
}
impl From<u16> for ProtocolVersion {
#[inline(always)]
fn from(val: u16) -> Self {
Self(val)
}
}
impl From<ProtocolVersion> for u16 {
#[inline(always)]
fn from(val: ProtocolVersion) -> u16 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HandshakeType(pub u8);
impl HandshakeType {
pub const CLIENT_HELLO: Self = Self(1);
pub const SERVER_HELLO: Self = Self(2);
pub const NEW_SESSION_TICKET: Self = Self(4);
pub const END_OF_EARLY_DATA: Self = Self(5);
pub const ENCRYPTED_EXTENSIONS: Self = Self(8);
pub const CERTIFICATE: Self = Self(11);
pub const CERTIFICATE_REQUEST: Self = Self(13);
pub const CERTIFICATE_VERIFY: Self = Self(15);
pub const FINISHED: Self = Self(20);
pub const KEY_UPDATE: Self = Self(24);
pub const MESSAGE_HASH: Self = Self(254);
}
impl From<u8> for HandshakeType {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<HandshakeType> for u8 {
#[inline(always)]
fn from(val: HandshakeType) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ExtensionType(pub u16);
impl ExtensionType {
pub const SERVER_NAME: Self = Self(0);
pub const SUPPORTED_GROUPS: Self = Self(10);
pub const SIGNATURE_ALGORITHMS: Self = Self(13);
pub const ALPN: Self = Self(16);
pub const PRE_SHARED_KEY: Self = Self(41);
pub const EARLY_DATA: Self = Self(42);
pub const SUPPORTED_VERSIONS: Self = Self(43);
pub const COOKIE: Self = Self(44);
pub const PSK_KEY_EXCHANGE_MODES: Self = Self(45);
pub const CERTIFICATE_AUTHORITIES: Self = Self(47);
pub const OID_FILTERS: Self = Self(48);
pub const POST_HANDSHAKE_AUTH: Self = Self(49);
pub const SIGNATURE_ALGORITHMS_CERT: Self = Self(50);
pub const KEY_SHARE: Self = Self(51);
}
impl From<u16> for ExtensionType {
#[inline(always)]
fn from(val: u16) -> Self {
Self(val)
}
}
impl From<ExtensionType> for u16 {
#[inline(always)]
fn from(val: ExtensionType) -> u16 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AlertLevel(pub u8);
impl AlertLevel {
pub const WARNING: Self = Self(1);
pub const FATAL: Self = Self(2);
}
impl From<u8> for AlertLevel {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<AlertLevel> for u8 {
#[inline(always)]
fn from(val: AlertLevel) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AlertDescription(pub u8);
impl AlertDescription {
pub const CLOSE_NOTIFY: Self = Self(0);
pub const UNEXPECTED_MESSAGE: Self = Self(10);
pub const BAD_RECORD_MAC: Self = Self(20);
pub const RECORD_OVERFLOW: Self = Self(22);
pub const HANDSHAKE_FAILURE: Self = Self(40);
pub const BAD_CERTIFICATE: Self = Self(42);
pub const UNSUPPORTED_CERTIFICATE: Self = Self(43);
pub const CERTIFICATE_REVOKED: Self = Self(44);
pub const CERTIFICATE_EXPIRED: Self = Self(45);
pub const CERTIFICATE_UNKNOWN: Self = Self(46);
pub const ILLEGAL_PARAMETER: Self = Self(47);
pub const UNKNOWN_CA: Self = Self(48);
pub const ACCESS_DENIED: Self = Self(49);
pub const DECODE_ERROR: Self = Self(50);
pub const DECRYPT_ERROR: Self = Self(51);
pub const PROTOCOL_VERSION: Self = Self(70);
pub const INSUFFICIENT_SECURITY: Self = Self(71);
pub const INTERNAL_ERROR: Self = Self(80);
pub const INAPPROPRIATE_FALLBACK: Self = Self(86);
pub const USER_CANCELED: Self = Self(90);
pub const MISSING_EXTENSION: Self = Self(109);
pub const UNSUPPORTED_EXTENSION: Self = Self(110);
pub const UNRECOGNIZED_NAME: Self = Self(112);
pub const BAD_CERTIFICATE_STATUS_RESPONSE: Self = Self(113);
pub const UNKNOWN_PSK_IDENTITY: Self = Self(115);
pub const CERTIFICATE_REQUIRED: Self = Self(116);
pub const NO_APPLICATION_PROTOCOL: Self = Self(120);
}
impl From<u8> for AlertDescription {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<AlertDescription> for u8 {
#[inline(always)]
fn from(val: AlertDescription) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SignatureScheme(pub u16);
impl SignatureScheme {
pub const RSA_PKCS1_SHA256: Self = Self(1025);
pub const ECDSA_SECP256R1_SHA256: Self = Self(1027);
pub const RSA_PSS_RSAE_SHA256: Self = Self(2052);
pub const ED25519: Self = Self(2055);
}
impl From<u16> for SignatureScheme {
#[inline(always)]
fn from(val: u16) -> Self {
Self(val)
}
}
impl From<SignatureScheme> for u16 {
#[inline(always)]
fn from(val: SignatureScheme) -> u16 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct KeyUpdateRequest(pub u8);
impl KeyUpdateRequest {
pub const UPDATE_NOT_REQUESTED: Self = Self(0);
pub const UPDATE_REQUESTED: Self = Self(1);
}
impl From<u8> for KeyUpdateRequest {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<KeyUpdateRequest> for u8 {
#[inline(always)]
fn from(val: KeyUpdateRequest) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NameType(pub u8);
impl NameType {
pub const HOST_NAME: Self = Self(0);
}
impl From<u8> for NameType {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<NameType> for u8 {
#[inline(always)]
fn from(val: NameType) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NamedGroup(pub u16);
impl NamedGroup {
pub const SECP256R1: Self = Self(23);
pub const SECP384R1: Self = Self(24);
pub const X25519: Self = Self(29);
pub const X448: Self = Self(30);
}
impl From<u16> for NamedGroup {
#[inline(always)]
fn from(val: u16) -> Self {
Self(val)
}
}
impl From<NamedGroup> for u16 {
#[inline(always)]
fn from(val: NamedGroup) -> u16 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PskKeyExchangeMode(pub u8);
impl PskKeyExchangeMode {
pub const PSK_KE: Self = Self(0);
pub const PSK_DHE_KE: Self = Self(1);
}
impl From<u8> for PskKeyExchangeMode {
#[inline(always)]
fn from(val: u8) -> Self {
Self(val)
}
}
impl From<PskKeyExchangeMode> for u8 {
#[inline(always)]
fn from(val: PskKeyExchangeMode) -> u8 {
val.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsRecordHeaderMapping<T> {
buffer: T,
}
impl<T> TlsRecordHeaderMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsRecordHeaderMapping<T> {
pub fn read_type(&self) -> BufResult<ContentType> {
Ok(self.buffer.get_u8(0)?.into())
}
pub fn read_legacy_record_version(&self) -> BufResult<ProtocolVersion> {
Ok(self.buffer.get_u16_be(1)?.into())
}
pub fn read_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(3)?)
}
pub fn read_fragment(&self) -> BufResult<&[u8]> {
let offset = 5;
let length = self.read_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsRecordHeaderMapping<T> {
pub fn write_type(&mut self, value: ContentType) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(0, value_to_write)
}
pub fn write_legacy_record_version(&mut self, value: ProtocolVersion) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(1, value_to_write)
}
pub fn write_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(3, value_to_write)
}
pub fn write_fragment(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 5;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsHandshakeMapping<T> {
buffer: T,
}
impl<T> TlsHandshakeMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsHandshakeMapping<T> {
pub fn read_msg_type(&self) -> BufResult<HandshakeType> {
Ok(self.buffer.get_u8(0)?.into())
}
pub fn read_length(&self) -> BufResult<u32> {
Ok(self.buffer.get_u24_be(1)?)
}
pub fn read_body(&self) -> BufResult<&[u8]> {
let offset = 4;
let length = self.read_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsHandshakeMapping<T> {
pub fn write_msg_type(&mut self, value: HandshakeType) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(0, value_to_write)
}
pub fn write_length(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u24_be(1, value_to_write)
}
pub fn write_body(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsAlertMapping<T> {
buffer: T,
}
impl<T> TlsAlertMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsAlertMapping<T> {
pub fn read_level(&self) -> BufResult<AlertLevel> {
Ok(self.buffer.get_u8(0)?.into())
}
pub fn read_description(&self) -> BufResult<AlertDescription> {
Ok(self.buffer.get_u8(1)?.into())
}
}
impl<T: BufMut> TlsAlertMapping<T> {
pub fn write_level(&mut self, value: AlertLevel) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(0, value_to_write)
}
pub fn write_description(&mut self, value: AlertDescription) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(1, value_to_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsExtensionMapping<T> {
buffer: T,
}
impl<T> TlsExtensionMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsExtensionMapping<T> {
pub fn read_extension_type(&self) -> BufResult<ExtensionType> {
Ok(self.buffer.get_u16_be(0)?.into())
}
pub fn read_extension_data_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(2)?)
}
pub fn read_extension_data(&self) -> BufResult<&[u8]> {
let offset = 4;
let length = self.read_extension_data_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsExtensionMapping<T> {
pub fn write_extension_type(&mut self, value: ExtensionType) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_extension_data_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(2, value_to_write)
}
pub fn write_extension_data(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsEncryptedExtensionsMapping<T> {
buffer: T,
}
impl<T> TlsEncryptedExtensionsMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsEncryptedExtensionsMapping<T> {
pub fn read_extensions_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_extensions(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_extensions_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsEncryptedExtensionsMapping<T> {
pub fn write_extensions_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_extensions(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCertificateRequestMapping<T> {
buffer: T,
}
impl<T> TlsCertificateRequestMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCertificateRequestMapping<T> {
pub fn read_certificate_request_context_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_certificate_request_context(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_certificate_request_context_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_extensions_length(&self) -> BufResult<u16> {
Ok(self
.buffer
.get_u16_be(1 + self.read_certificate_request_context_length()? as usize)?)
}
pub fn read_extensions(&self) -> BufResult<&[u8]> {
let offset = 3 + self.read_certificate_request_context_length()? as usize;
let length = self.read_extensions_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCertificateRequestMapping<T> {
pub fn write_certificate_request_context_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_certificate_request_context(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
pub fn write_extensions_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(
1 + self.read_certificate_request_context_length()? as usize,
value_to_write,
)
}
pub fn write_extensions(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 3 + self.read_certificate_request_context_length()? as usize;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCertificateEntryMapping<T> {
buffer: T,
}
impl<T> TlsCertificateEntryMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCertificateEntryMapping<T> {
pub fn read_cert_data_length(&self) -> BufResult<u32> {
Ok(self.buffer.get_u24_be(0)?)
}
pub fn read_cert_data(&self) -> BufResult<&[u8]> {
let offset = 3;
let length = self.read_cert_data_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_extensions_length(&self) -> BufResult<u16> {
Ok(self
.buffer
.get_u16_be(3 + self.read_cert_data_length()? as usize)?)
}
pub fn read_extensions(&self) -> BufResult<&[u8]> {
let offset = 5 + self.read_cert_data_length()? as usize;
let length = self.read_extensions_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCertificateEntryMapping<T> {
pub fn write_cert_data_length(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u24_be(0, value_to_write)
}
pub fn write_cert_data(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 3;
self.buffer.set_slice(offset, data)
}
pub fn write_extensions_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer
.set_u16_be(3 + self.read_cert_data_length()? as usize, value_to_write)
}
pub fn write_extensions(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 5 + self.read_cert_data_length()? as usize;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCertificateMapping<T> {
buffer: T,
}
impl<T> TlsCertificateMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCertificateMapping<T> {
pub fn read_certificate_request_context_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_certificate_request_context(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_certificate_request_context_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_certificate_list_length(&self) -> BufResult<u32> {
Ok(self
.buffer
.get_u24_be(1 + self.read_certificate_request_context_length()? as usize)?)
}
pub fn read_certificate_list(&self) -> BufResult<&[u8]> {
let offset = 4 + self.read_certificate_request_context_length()? as usize;
let length = self.read_certificate_list_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCertificateMapping<T> {
pub fn write_certificate_request_context_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_certificate_request_context(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
pub fn write_certificate_list_length(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u24_be(
1 + self.read_certificate_request_context_length()? as usize,
value_to_write,
)
}
pub fn write_certificate_list(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4 + self.read_certificate_request_context_length()? as usize;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCertificateVerifyMapping<T> {
buffer: T,
}
impl<T> TlsCertificateVerifyMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCertificateVerifyMapping<T> {
pub fn read_algorithm(&self) -> BufResult<SignatureScheme> {
Ok(self.buffer.get_u16_be(0)?.into())
}
pub fn read_signature_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(2)?)
}
pub fn read_signature(&self) -> BufResult<&[u8]> {
let offset = 4;
let length = self.read_signature_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCertificateVerifyMapping<T> {
pub fn write_algorithm(&mut self, value: SignatureScheme) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_signature_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(2, value_to_write)
}
pub fn write_signature(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsFinishedMapping<T> {
buffer: T,
}
impl<T> TlsFinishedMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsFinishedMapping<T> {
pub fn read_verify_data(&self) -> BufResult<&[u8]> {
let offset = 0;
let length = handshake.read_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsFinishedMapping<T> {
pub fn write_verify_data(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 0;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsNewSessionTicketMapping<T> {
buffer: T,
}
impl<T> TlsNewSessionTicketMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsNewSessionTicketMapping<T> {
pub fn read_ticket_lifetime(&self) -> BufResult<u32> {
Ok(self.buffer.get_u32_be(0)?)
}
pub fn read_ticket_age_add(&self) -> BufResult<u32> {
Ok(self.buffer.get_u32_be(4)?)
}
pub fn read_ticket_nonce_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(8)?)
}
pub fn read_ticket_nonce(&self) -> BufResult<&[u8]> {
let offset = 9;
let length = self.read_ticket_nonce_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_ticket_length(&self) -> BufResult<u16> {
Ok(self
.buffer
.get_u16_be(9 + self.read_ticket_nonce_length()? as usize)?)
}
pub fn read_ticket(&self) -> BufResult<&[u8]> {
let offset = 11 + self.read_ticket_nonce_length()? as usize;
let length = self.read_ticket_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_extensions_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(
11 + self.read_ticket_nonce_length()? as usize + self.read_ticket_length()? as usize,
)?)
}
pub fn read_extensions(&self) -> BufResult<&[u8]> {
let offset =
13 + self.read_ticket_nonce_length()? as usize + self.read_ticket_length()? as usize;
let length = self.read_extensions_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsNewSessionTicketMapping<T> {
pub fn write_ticket_lifetime(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u32_be(0, value_to_write)
}
pub fn write_ticket_age_add(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u32_be(4, value_to_write)
}
pub fn write_ticket_nonce_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(8, value_to_write)
}
pub fn write_ticket_nonce(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 9;
self.buffer.set_slice(offset, data)
}
pub fn write_ticket_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(
9 + self.read_ticket_nonce_length()? as usize,
value_to_write,
)
}
pub fn write_ticket(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 11 + self.read_ticket_nonce_length()? as usize;
self.buffer.set_slice(offset, data)
}
pub fn write_extensions_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(
11 + self.read_ticket_nonce_length()? as usize + self.read_ticket_length()? as usize,
value_to_write,
)
}
pub fn write_extensions(&mut self, data: &[u8]) -> BufResult<()> {
let offset =
13 + self.read_ticket_nonce_length()? as usize + self.read_ticket_length()? as usize;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsKeyUpdateMapping<T> {
buffer: T,
}
impl<T> TlsKeyUpdateMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsKeyUpdateMapping<T> {
pub fn read_request_update(&self) -> BufResult<KeyUpdateRequest> {
Ok(self.buffer.get_u8(0)?.into())
}
}
impl<T: BufMut> TlsKeyUpdateMapping<T> {
pub fn write_request_update(&mut self, value: KeyUpdateRequest) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(0, value_to_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsEndOfEarlyDataMapping<T> {
buffer: T,
}
impl<T> TlsEndOfEarlyDataMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsEndOfEarlyDataMapping<T> {}
impl<T: BufMut> TlsEndOfEarlyDataMapping<T> {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsServerNameEntryMapping<T> {
buffer: T,
}
impl<T> TlsServerNameEntryMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsServerNameEntryMapping<T> {
pub fn read_name_type(&self) -> BufResult<NameType> {
Ok(self.buffer.get_u8(0)?.into())
}
pub fn read_name_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(1)?)
}
pub fn read_name(&self) -> BufResult<&[u8]> {
let offset = 3;
let length = self.read_name_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsServerNameEntryMapping<T> {
pub fn write_name_type(&mut self, value: NameType) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u8(0, value_to_write)
}
pub fn write_name_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(1, value_to_write)
}
pub fn write_name(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 3;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsServerNameListMapping<T> {
buffer: T,
}
impl<T> TlsServerNameListMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsServerNameListMapping<T> {
pub fn read_server_name_list_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_server_name_list(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_server_name_list_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsServerNameListMapping<T> {
pub fn write_server_name_list_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_server_name_list(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsSupportedGroupsMapping<T> {
buffer: T,
}
impl<T> TlsSupportedGroupsMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsSupportedGroupsMapping<T> {
pub fn read_named_curve_list_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_named_curve_list(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_named_curve_list_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsSupportedGroupsMapping<T> {
pub fn write_named_curve_list_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_named_curve_list(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsSignatureAlgorithmsMapping<T> {
buffer: T,
}
impl<T> TlsSignatureAlgorithmsMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsSignatureAlgorithmsMapping<T> {
pub fn read_supported_signature_algorithms_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_supported_signature_algorithms(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_supported_signature_algorithms_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsSignatureAlgorithmsMapping<T> {
pub fn write_supported_signature_algorithms_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_supported_signature_algorithms(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsAlpnProtocolMapping<T> {
buffer: T,
}
impl<T> TlsAlpnProtocolMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsAlpnProtocolMapping<T> {
pub fn read_protocol_name_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_protocol_name(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_protocol_name_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsAlpnProtocolMapping<T> {
pub fn write_protocol_name_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_protocol_name(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsAlpnMapping<T> {
buffer: T,
}
impl<T> TlsAlpnMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsAlpnMapping<T> {
pub fn read_protocol_name_list_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_protocol_name_list(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_protocol_name_list_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsAlpnMapping<T> {
pub fn write_protocol_name_list_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_protocol_name_list(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsKeyShareEntryMapping<T> {
buffer: T,
}
impl<T> TlsKeyShareEntryMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsKeyShareEntryMapping<T> {
pub fn read_group(&self) -> BufResult<NamedGroup> {
Ok(self.buffer.get_u16_be(0)?.into())
}
pub fn read_key_exchange_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(2)?)
}
pub fn read_key_exchange(&self) -> BufResult<&[u8]> {
let offset = 4;
let length = self.read_key_exchange_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsKeyShareEntryMapping<T> {
pub fn write_group(&mut self, value: NamedGroup) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_key_exchange_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(2, value_to_write)
}
pub fn write_key_exchange(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsKeyShareClientHelloMapping<T> {
buffer: T,
}
impl<T> TlsKeyShareClientHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsKeyShareClientHelloMapping<T> {
pub fn read_client_shares_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_client_shares(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_client_shares_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsKeyShareClientHelloMapping<T> {
pub fn write_client_shares_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_client_shares(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsKeyShareServerHelloMapping<T> {
buffer: T,
}
impl<T> TlsKeyShareServerHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsKeyShareServerHelloMapping<T> {
pub fn read_server_share_group(&self) -> BufResult<NamedGroup> {
Ok(self.buffer.get_u16_be(0)?.into())
}
pub fn read_server_share_key_exchange_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(2)?)
}
pub fn read_server_share_key_exchange(&self) -> BufResult<&[u8]> {
let offset = 4;
let length = self.read_server_share_key_exchange_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsKeyShareServerHelloMapping<T> {
pub fn write_server_share_group(&mut self, value: NamedGroup) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_server_share_key_exchange_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(2, value_to_write)
}
pub fn write_server_share_key_exchange(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsSupportedVersionsClientHelloMapping<T> {
buffer: T,
}
impl<T> TlsSupportedVersionsClientHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsSupportedVersionsClientHelloMapping<T> {
pub fn read_versions_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_versions(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_versions_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsSupportedVersionsClientHelloMapping<T> {
pub fn write_versions_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_versions(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsSupportedVersionsServerHelloMapping<T> {
buffer: T,
}
impl<T> TlsSupportedVersionsServerHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsSupportedVersionsServerHelloMapping<T> {
pub fn read_selected_version(&self) -> BufResult<ProtocolVersion> {
Ok(self.buffer.get_u16_be(0)?.into())
}
}
impl<T: BufMut> TlsSupportedVersionsServerHelloMapping<T> {
pub fn write_selected_version(&mut self, value: ProtocolVersion) -> BufResult<()> {
let value_to_write = value.into();
self.buffer.set_u16_be(0, value_to_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPskIdentityMapping<T> {
buffer: T,
}
impl<T> TlsPskIdentityMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPskIdentityMapping<T> {
pub fn read_identity_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_identity(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_identity_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_obfuscated_ticket_age(&self) -> BufResult<u32> {
Ok(self
.buffer
.get_u32_be(2 + self.read_identity_length()? as usize)?)
}
}
impl<T: BufMut> TlsPskIdentityMapping<T> {
pub fn write_identity_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_identity(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
pub fn write_obfuscated_ticket_age(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer
.set_u32_be(2 + self.read_identity_length()? as usize, value_to_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPskBinderEntryMapping<T> {
buffer: T,
}
impl<T> TlsPskBinderEntryMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPskBinderEntryMapping<T> {
pub fn read_binder_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_binder(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_binder_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsPskBinderEntryMapping<T> {
pub fn write_binder_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_binder(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPreSharedKeyClientHelloMapping<T> {
buffer: T,
}
impl<T> TlsPreSharedKeyClientHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPreSharedKeyClientHelloMapping<T> {
pub fn read_identities_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_identities(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_identities_length()? as usize;
self.buffer.get_slice(offset, length)
}
pub fn read_binders_length(&self) -> BufResult<u16> {
Ok(self
.buffer
.get_u16_be(2 + self.read_identities_length()? as usize)?)
}
pub fn read_binders(&self) -> BufResult<&[u8]> {
let offset = 4 + self.read_identities_length()? as usize;
let length = self.read_binders_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsPreSharedKeyClientHelloMapping<T> {
pub fn write_identities_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_identities(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
pub fn write_binders_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer
.set_u16_be(2 + self.read_identities_length()? as usize, value_to_write)
}
pub fn write_binders(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 4 + self.read_identities_length()? as usize;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPreSharedKeyServerHelloMapping<T> {
buffer: T,
}
impl<T> TlsPreSharedKeyServerHelloMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPreSharedKeyServerHelloMapping<T> {
pub fn read_selected_identity(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
}
impl<T: BufMut> TlsPreSharedKeyServerHelloMapping<T> {
pub fn write_selected_identity(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPskKeyExchangeModesMapping<T> {
buffer: T,
}
impl<T> TlsPskKeyExchangeModesMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPskKeyExchangeModesMapping<T> {
pub fn read_ke_modes_length(&self) -> BufResult<u8> {
Ok(self.buffer.get_u8(0)?)
}
pub fn read_ke_modes(&self) -> BufResult<&[u8]> {
let offset = 1;
let length = self.read_ke_modes_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsPskKeyExchangeModesMapping<T> {
pub fn write_ke_modes_length(&mut self, value: u8) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u8(0, value_to_write)
}
pub fn write_ke_modes(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 1;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCookieMapping<T> {
buffer: T,
}
impl<T> TlsCookieMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCookieMapping<T> {
pub fn read_cookie_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_cookie(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_cookie_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCookieMapping<T> {
pub fn write_cookie_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_cookie(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsCertificateAuthoritiesMapping<T> {
buffer: T,
}
impl<T> TlsCertificateAuthoritiesMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsCertificateAuthoritiesMapping<T> {
pub fn read_authorities_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_authorities(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_authorities_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsCertificateAuthoritiesMapping<T> {
pub fn write_authorities_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_authorities(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsOidFiltersMapping<T> {
buffer: T,
}
impl<T> TlsOidFiltersMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsOidFiltersMapping<T> {
pub fn read_filters_length(&self) -> BufResult<u16> {
Ok(self.buffer.get_u16_be(0)?)
}
pub fn read_filters(&self) -> BufResult<&[u8]> {
let offset = 2;
let length = self.read_filters_length()? as usize;
self.buffer.get_slice(offset, length)
}
}
impl<T: BufMut> TlsOidFiltersMapping<T> {
pub fn write_filters_length(&mut self, value: u16) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u16_be(0, value_to_write)
}
pub fn write_filters(&mut self, data: &[u8]) -> BufResult<()> {
let offset = 2;
self.buffer.set_slice(offset, data)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsPostHandshakeAuthMapping<T> {
buffer: T,
}
impl<T> TlsPostHandshakeAuthMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsPostHandshakeAuthMapping<T> {}
impl<T: BufMut> TlsPostHandshakeAuthMapping<T> {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsEarlyDataIndicationMapping<T> {
buffer: T,
}
impl<T> TlsEarlyDataIndicationMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsEarlyDataIndicationMapping<T> {}
impl<T: BufMut> TlsEarlyDataIndicationMapping<T> {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlsEarlyDataTicketMapping<T> {
buffer: T,
}
impl<T> TlsEarlyDataTicketMapping<T> {
#[inline(always)]
pub fn new(buffer: T) -> Self {
Self { buffer }
}
pub fn into_inner(self) -> T {
self.buffer
}
}
impl<T: Buf> TlsEarlyDataTicketMapping<T> {
pub fn read_max_early_data_size(&self) -> BufResult<u32> {
Ok(self.buffer.get_u32_be(0)?)
}
}
impl<T: BufMut> TlsEarlyDataTicketMapping<T> {
pub fn write_max_early_data_size(&mut self, value: u32) -> BufResult<()> {
let value_to_write = value;
self.buffer.set_u32_be(0, value_to_write)
}
}