1use abol_core::{attribute::ToRadiusAttribute, packet::Packet};
2use std::net::{Ipv4Addr, Ipv6Addr};
3pub const VENDOR_MICROSOFT: u32 = 311u32;
4pub const MS_CHAP_RESPONSE_TYPE: u8 = 1u8;
5pub const MS_CHAP_ERROR_TYPE: u8 = 2u8;
6pub const MS_CHAP_CPW_1_TYPE: u8 = 3u8;
7pub const MS_CHAP_CPW_2_TYPE: u8 = 4u8;
8pub const MS_CHAP_LM_ENC_PW_TYPE: u8 = 5u8;
9pub const MS_CHAP_NT_ENC_PW_TYPE: u8 = 6u8;
10pub const MS_MPPE_ENCRYPTION_POLICY_TYPE: u8 = 7u8;
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12#[repr(u32)]
13pub enum MsMppeEncryptionPolicy {
14 EncryptionAllowed,
15 EncryptionRequired,
16 Unknown(u32),
17}
18impl From<u32> for MsMppeEncryptionPolicy {
19 fn from(v: u32) -> Self {
20 match v {
21 1u32 => Self::EncryptionAllowed,
22 2u32 => Self::EncryptionRequired,
23 other => Self::Unknown(other),
24 }
25 }
26}
27impl From<MsMppeEncryptionPolicy> for u32 {
28 fn from(e: MsMppeEncryptionPolicy) -> Self {
29 match e {
30 MsMppeEncryptionPolicy::EncryptionAllowed => 1u32,
31 MsMppeEncryptionPolicy::EncryptionRequired => 2u32,
32 MsMppeEncryptionPolicy::Unknown(v) => v,
33 }
34 }
35}
36pub const MS_MPPE_ENCRYPTION_TYPE_TYPE: u8 = 8u8;
37pub const MS_MPPE_ENCRYPTION_TYPES_TYPE: u8 = 8u8;
38#[derive(Debug, Clone, Copy, PartialEq, Eq)]
39#[repr(u32)]
40pub enum MsMppeEncryptionTypes {
41 Rc440bitAllowed,
42 Rc4128bitAllowed,
43 Rc440or128BitAllowed,
44 Unknown(u32),
45}
46impl From<u32> for MsMppeEncryptionTypes {
47 fn from(v: u32) -> Self {
48 match v {
49 1u32 => Self::Rc440bitAllowed,
50 2u32 => Self::Rc4128bitAllowed,
51 6u32 => Self::Rc440or128BitAllowed,
52 other => Self::Unknown(other),
53 }
54 }
55}
56impl From<MsMppeEncryptionTypes> for u32 {
57 fn from(e: MsMppeEncryptionTypes) -> Self {
58 match e {
59 MsMppeEncryptionTypes::Rc440bitAllowed => 1u32,
60 MsMppeEncryptionTypes::Rc4128bitAllowed => 2u32,
61 MsMppeEncryptionTypes::Rc440or128BitAllowed => 6u32,
62 MsMppeEncryptionTypes::Unknown(v) => v,
63 }
64 }
65}
66pub const MS_RAS_VENDOR_TYPE: u8 = 9u8;
67pub const MS_CHAP_DOMAIN_TYPE: u8 = 10u8;
68pub const MS_CHAP_CHALLENGE_TYPE: u8 = 11u8;
69pub const MS_CHAP_MPPE_KEYS_TYPE: u8 = 12u8;
70pub const MS_BAP_USAGE_TYPE: u8 = 13u8;
71#[derive(Debug, Clone, Copy, PartialEq, Eq)]
72#[repr(u32)]
73pub enum MsBapUsage {
74 NotAllowed,
75 Allowed,
76 Required,
77 Unknown(u32),
78}
79impl From<u32> for MsBapUsage {
80 fn from(v: u32) -> Self {
81 match v {
82 0u32 => Self::NotAllowed,
83 1u32 => Self::Allowed,
84 2u32 => Self::Required,
85 other => Self::Unknown(other),
86 }
87 }
88}
89impl From<MsBapUsage> for u32 {
90 fn from(e: MsBapUsage) -> Self {
91 match e {
92 MsBapUsage::NotAllowed => 0u32,
93 MsBapUsage::Allowed => 1u32,
94 MsBapUsage::Required => 2u32,
95 MsBapUsage::Unknown(v) => v,
96 }
97 }
98}
99pub const MS_LINK_UTILIZATION_THRESHOLD_TYPE: u8 = 14u8;
100pub const MS_LINK_DROP_TIME_LIMIT_TYPE: u8 = 15u8;
101pub const MS_MPPE_SEND_KEY_TYPE: u8 = 16u8;
102pub const MS_MPPE_RECV_KEY_TYPE: u8 = 17u8;
103pub const MS_RAS_VERSION_TYPE: u8 = 18u8;
104pub const MS_OLD_ARAP_PASSWORD_TYPE: u8 = 19u8;
105pub const MS_NEW_ARAP_PASSWORD_TYPE: u8 = 20u8;
106pub const MS_ARAP_PW_CHANGE_REASON_TYPE: u8 = 21u8;
107#[derive(Debug, Clone, Copy, PartialEq, Eq)]
108#[repr(u32)]
109pub enum MsArapPwChangeReason {
110 JustChangePassword,
111 ExpiredPassword,
112 AdminRequiresPasswordChange,
113 PasswordTooShort,
114 Unknown(u32),
115}
116impl From<u32> for MsArapPwChangeReason {
117 fn from(v: u32) -> Self {
118 match v {
119 1u32 => Self::JustChangePassword,
120 2u32 => Self::ExpiredPassword,
121 3u32 => Self::AdminRequiresPasswordChange,
122 4u32 => Self::PasswordTooShort,
123 other => Self::Unknown(other),
124 }
125 }
126}
127impl From<MsArapPwChangeReason> for u32 {
128 fn from(e: MsArapPwChangeReason) -> Self {
129 match e {
130 MsArapPwChangeReason::JustChangePassword => 1u32,
131 MsArapPwChangeReason::ExpiredPassword => 2u32,
132 MsArapPwChangeReason::AdminRequiresPasswordChange => 3u32,
133 MsArapPwChangeReason::PasswordTooShort => 4u32,
134 MsArapPwChangeReason::Unknown(v) => v,
135 }
136 }
137}
138pub const MS_FILTER_TYPE: u8 = 22u8;
139pub const MS_ACCT_AUTH_TYPE_TYPE: u8 = 23u8;
140#[derive(Debug, Clone, Copy, PartialEq, Eq)]
141#[repr(u32)]
142pub enum MsAcctAuthType {
143 Pap,
144 Chap,
145 MsChap1,
146 MsChap2,
147 Eap,
148 Unknown(u32),
149}
150impl From<u32> for MsAcctAuthType {
151 fn from(v: u32) -> Self {
152 match v {
153 1u32 => Self::Pap,
154 2u32 => Self::Chap,
155 3u32 => Self::MsChap1,
156 4u32 => Self::MsChap2,
157 5u32 => Self::Eap,
158 other => Self::Unknown(other),
159 }
160 }
161}
162impl From<MsAcctAuthType> for u32 {
163 fn from(e: MsAcctAuthType) -> Self {
164 match e {
165 MsAcctAuthType::Pap => 1u32,
166 MsAcctAuthType::Chap => 2u32,
167 MsAcctAuthType::MsChap1 => 3u32,
168 MsAcctAuthType::MsChap2 => 4u32,
169 MsAcctAuthType::Eap => 5u32,
170 MsAcctAuthType::Unknown(v) => v,
171 }
172 }
173}
174pub const MS_ACCT_EAP_TYPE_TYPE: u8 = 24u8;
175#[derive(Debug, Clone, Copy, PartialEq, Eq)]
176#[repr(u32)]
177pub enum MsAcctEapType {
178 Md5,
179 Otp,
180 GenericTokenCard,
181 Tls,
182 Unknown(u32),
183}
184impl From<u32> for MsAcctEapType {
185 fn from(v: u32) -> Self {
186 match v {
187 4u32 => Self::Md5,
188 5u32 => Self::Otp,
189 6u32 => Self::GenericTokenCard,
190 13u32 => Self::Tls,
191 other => Self::Unknown(other),
192 }
193 }
194}
195impl From<MsAcctEapType> for u32 {
196 fn from(e: MsAcctEapType) -> Self {
197 match e {
198 MsAcctEapType::Md5 => 4u32,
199 MsAcctEapType::Otp => 5u32,
200 MsAcctEapType::GenericTokenCard => 6u32,
201 MsAcctEapType::Tls => 13u32,
202 MsAcctEapType::Unknown(v) => v,
203 }
204 }
205}
206pub const MS_CHAP2_RESPONSE_TYPE: u8 = 25u8;
207pub const MS_CHAP2_SUCCESS_TYPE: u8 = 26u8;
208pub const MS_CHAP2_CPW_TYPE: u8 = 27u8;
209pub const MS_PRIMARY_DNS_SERVER_TYPE: u8 = 28u8;
210pub const MS_SECONDARY_DNS_SERVER_TYPE: u8 = 29u8;
211pub const MS_PRIMARY_NBNS_SERVER_TYPE: u8 = 30u8;
212pub const MS_SECONDARY_NBNS_SERVER_TYPE: u8 = 31u8;
213pub const MS_RAS_CLIENT_NAME_TYPE: u8 = 34u8;
214pub const MS_RAS_CLIENT_VERSION_TYPE: u8 = 35u8;
215pub const MS_QUARANTINE_IPFILTER_TYPE: u8 = 36u8;
216pub const MS_QUARANTINE_SESSION_TIMEOUT_TYPE: u8 = 37u8;
217pub const MS_USER_SECURITY_IDENTITY_TYPE: u8 = 40u8;
218pub const MS_IDENTITY_TYPE_TYPE: u8 = 41u8;
219#[derive(Debug, Clone, Copy, PartialEq, Eq)]
220#[repr(u32)]
221pub enum MsIdentityType {
222 MachineHealthCheck,
223 IgnoreUserLookupFailure,
224 Unknown(u32),
225}
226impl From<u32> for MsIdentityType {
227 fn from(v: u32) -> Self {
228 match v {
229 1u32 => Self::MachineHealthCheck,
230 2u32 => Self::IgnoreUserLookupFailure,
231 other => Self::Unknown(other),
232 }
233 }
234}
235impl From<MsIdentityType> for u32 {
236 fn from(e: MsIdentityType) -> Self {
237 match e {
238 MsIdentityType::MachineHealthCheck => 1u32,
239 MsIdentityType::IgnoreUserLookupFailure => 2u32,
240 MsIdentityType::Unknown(v) => v,
241 }
242 }
243}
244pub const MS_SERVICE_CLASS_TYPE: u8 = 42u8;
245pub const MS_QUARANTINE_USER_CLASS_TYPE: u8 = 44u8;
246pub const MS_QUARANTINE_STATE_TYPE: u8 = 45u8;
247#[derive(Debug, Clone, Copy, PartialEq, Eq)]
248#[repr(u32)]
249pub enum MsQuarantineState {
250 FullAccess,
251 Quarantine,
252 Probation,
253 Unknown(u32),
254}
255impl From<u32> for MsQuarantineState {
256 fn from(v: u32) -> Self {
257 match v {
258 0u32 => Self::FullAccess,
259 1u32 => Self::Quarantine,
260 2u32 => Self::Probation,
261 other => Self::Unknown(other),
262 }
263 }
264}
265impl From<MsQuarantineState> for u32 {
266 fn from(e: MsQuarantineState) -> Self {
267 match e {
268 MsQuarantineState::FullAccess => 0u32,
269 MsQuarantineState::Quarantine => 1u32,
270 MsQuarantineState::Probation => 2u32,
271 MsQuarantineState::Unknown(v) => v,
272 }
273 }
274}
275pub const MS_QUARANTINE_GRACE_TIME_TYPE: u8 = 46u8;
276pub const MS_NETWORK_ACCESS_SERVER_TYPE_TYPE: u8 = 47u8;
277#[derive(Debug, Clone, Copy, PartialEq, Eq)]
278#[repr(u32)]
279pub enum MsNetworkAccessServerType {
280 Unspecified,
281 TerminalServerGateway,
282 RemoteAccessServer,
283 DhcpServer,
284 WirelessAccessPoint,
285 Hra,
286 HcapServer,
287 Unknown(u32),
288}
289impl From<u32> for MsNetworkAccessServerType {
290 fn from(v: u32) -> Self {
291 match v {
292 0u32 => Self::Unspecified,
293 1u32 => Self::TerminalServerGateway,
294 2u32 => Self::RemoteAccessServer,
295 3u32 => Self::DhcpServer,
296 4u32 => Self::WirelessAccessPoint,
297 5u32 => Self::Hra,
298 6u32 => Self::HcapServer,
299 other => Self::Unknown(other),
300 }
301 }
302}
303impl From<MsNetworkAccessServerType> for u32 {
304 fn from(e: MsNetworkAccessServerType) -> Self {
305 match e {
306 MsNetworkAccessServerType::Unspecified => 0u32,
307 MsNetworkAccessServerType::TerminalServerGateway => 1u32,
308 MsNetworkAccessServerType::RemoteAccessServer => 2u32,
309 MsNetworkAccessServerType::DhcpServer => 3u32,
310 MsNetworkAccessServerType::WirelessAccessPoint => 4u32,
311 MsNetworkAccessServerType::Hra => 5u32,
312 MsNetworkAccessServerType::HcapServer => 6u32,
313 MsNetworkAccessServerType::Unknown(v) => v,
314 }
315 }
316}
317pub const MS_AFW_ZONE_TYPE: u8 = 48u8;
318#[derive(Debug, Clone, Copy, PartialEq, Eq)]
319#[repr(u32)]
320pub enum MsAfwZone {
321 MsAfwZoneBoundaryPolicy,
322 MsAfwZoneUnprotectedPolicy,
323 MsAfwZoneProtectedPolicy,
324 Unknown(u32),
325}
326impl From<u32> for MsAfwZone {
327 fn from(v: u32) -> Self {
328 match v {
329 1u32 => Self::MsAfwZoneBoundaryPolicy,
330 2u32 => Self::MsAfwZoneUnprotectedPolicy,
331 3u32 => Self::MsAfwZoneProtectedPolicy,
332 other => Self::Unknown(other),
333 }
334 }
335}
336impl From<MsAfwZone> for u32 {
337 fn from(e: MsAfwZone) -> Self {
338 match e {
339 MsAfwZone::MsAfwZoneBoundaryPolicy => 1u32,
340 MsAfwZone::MsAfwZoneUnprotectedPolicy => 2u32,
341 MsAfwZone::MsAfwZoneProtectedPolicy => 3u32,
342 MsAfwZone::Unknown(v) => v,
343 }
344 }
345}
346pub const MS_AFW_PROTECTION_LEVEL_TYPE: u8 = 49u8;
347#[derive(Debug, Clone, Copy, PartialEq, Eq)]
348#[repr(u32)]
349pub enum MsAfwProtectionLevel {
350 HecpResponseSignOnly,
351 HecpResponseSignAndEncrypt,
352 Unknown(u32),
353}
354impl From<u32> for MsAfwProtectionLevel {
355 fn from(v: u32) -> Self {
356 match v {
357 1u32 => Self::HecpResponseSignOnly,
358 2u32 => Self::HecpResponseSignAndEncrypt,
359 other => Self::Unknown(other),
360 }
361 }
362}
363impl From<MsAfwProtectionLevel> for u32 {
364 fn from(e: MsAfwProtectionLevel) -> Self {
365 match e {
366 MsAfwProtectionLevel::HecpResponseSignOnly => 1u32,
367 MsAfwProtectionLevel::HecpResponseSignAndEncrypt => 2u32,
368 MsAfwProtectionLevel::Unknown(v) => v,
369 }
370 }
371}
372pub const MS_MACHINE_NAME_TYPE: u8 = 50u8;
373pub const MS_IPV6_FILTER_TYPE: u8 = 51u8;
374pub const MS_IPV4_REMEDIATION_SERVERS_TYPE: u8 = 52u8;
375pub const MS_IPV6_REMEDIATION_SERVERS_TYPE: u8 = 53u8;
376pub const MS_RNAP_NOT_QUARANTINE_CAPABLE_TYPE: u8 = 54u8;
377#[derive(Debug, Clone, Copy, PartialEq, Eq)]
378#[repr(u32)]
379pub enum MsRnapNotQuarantineCapable {
380 SoHSent,
381 SoHNotSent,
382 Unknown(u32),
383}
384impl From<u32> for MsRnapNotQuarantineCapable {
385 fn from(v: u32) -> Self {
386 match v {
387 0u32 => Self::SoHSent,
388 1u32 => Self::SoHNotSent,
389 other => Self::Unknown(other),
390 }
391 }
392}
393impl From<MsRnapNotQuarantineCapable> for u32 {
394 fn from(e: MsRnapNotQuarantineCapable) -> Self {
395 match e {
396 MsRnapNotQuarantineCapable::SoHSent => 0u32,
397 MsRnapNotQuarantineCapable::SoHNotSent => 1u32,
398 MsRnapNotQuarantineCapable::Unknown(v) => v,
399 }
400 }
401}
402pub const MS_QUARANTINE_SOH_TYPE: u8 = 55u8;
403pub const MS_RAS_CORRELATION_TYPE: u8 = 56u8;
404pub const MS_EXTENDED_QUARANTINE_STATE_TYPE: u8 = 57u8;
405#[derive(Debug, Clone, Copy, PartialEq, Eq)]
406#[repr(u32)]
407pub enum MsExtendedQuarantineState {
408 Transition,
409 Infected,
410 Unknown,
411 NoData,
412 Other(u32),
413}
414impl From<u32> for MsExtendedQuarantineState {
415 fn from(v: u32) -> Self {
416 match v {
417 1u32 => Self::Transition,
418 2u32 => Self::Infected,
419 3u32 => Self::Unknown,
420 4u32 => Self::NoData,
421 other => Self::Other(other),
422 }
423 }
424}
425impl From<MsExtendedQuarantineState> for u32 {
426 fn from(e: MsExtendedQuarantineState) -> Self {
427 match e {
428 MsExtendedQuarantineState::Transition => 1u32,
429 MsExtendedQuarantineState::Infected => 2u32,
430 MsExtendedQuarantineState::Unknown => 3u32,
431 MsExtendedQuarantineState::NoData => 4u32,
432 MsExtendedQuarantineState::Other(v) => v,
433 }
434 }
435}
436pub const MS_HCAP_USER_GROUPS_TYPE: u8 = 58u8;
437pub const MS_HCAP_LOCATION_GROUP_NAME_TYPE: u8 = 59u8;
438pub const MS_HCAP_USER_NAME_TYPE: u8 = 60u8;
439pub const MS_USER_IPV4_ADDRESS_TYPE: u8 = 61u8;
440pub const MS_USER_IPV6_ADDRESS_TYPE: u8 = 62u8;
441pub const MS_TSG_DEVICE_REDIRECTION_TYPE: u8 = 63u8;
442pub trait MicrosoftExt {
443 fn get_ms_chap_response(&self) -> Option<Vec<u8>>;
444 fn set_ms_chap_response(&mut self, value: impl Into<Vec<u8>>);
445 fn get_ms_chap_error(&self) -> Option<String>;
446 fn set_ms_chap_error(&mut self, value: impl Into<String>);
447 fn get_ms_chap_cpw_1(&self) -> Option<Vec<u8>>;
448 fn set_ms_chap_cpw_1(&mut self, value: impl Into<Vec<u8>>);
449 fn get_ms_chap_cpw_2(&self) -> Option<Vec<u8>>;
450 fn set_ms_chap_cpw_2(&mut self, value: impl Into<Vec<u8>>);
451 fn get_ms_chap_lm_enc_pw(&self) -> Option<Vec<u8>>;
452 fn set_ms_chap_lm_enc_pw(&mut self, value: impl Into<Vec<u8>>);
453 fn get_ms_chap_nt_enc_pw(&self) -> Option<Vec<u8>>;
454 fn set_ms_chap_nt_enc_pw(&mut self, value: impl Into<Vec<u8>>);
455 fn get_ms_mppe_encryption_policy(&self) -> Option<MsMppeEncryptionPolicy>;
456 fn set_ms_mppe_encryption_policy(&mut self, value: MsMppeEncryptionPolicy);
457 fn get_ms_mppe_encryption_type(&self) -> Option<u32>;
458 fn set_ms_mppe_encryption_type(&mut self, value: u32);
459 fn get_ms_mppe_encryption_types(&self) -> Option<MsMppeEncryptionTypes>;
460 fn set_ms_mppe_encryption_types(&mut self, value: MsMppeEncryptionTypes);
461 fn get_ms_ras_vendor(&self) -> Option<u32>;
462 fn set_ms_ras_vendor(&mut self, value: u32);
463 fn get_ms_chap_domain(&self) -> Option<String>;
464 fn set_ms_chap_domain(&mut self, value: impl Into<String>);
465 fn get_ms_chap_challenge(&self) -> Option<Vec<u8>>;
466 fn set_ms_chap_challenge(&mut self, value: impl Into<Vec<u8>>);
467 fn get_ms_chap_mppe_keys(&self) -> Option<Vec<u8>>;
468 fn set_ms_chap_mppe_keys(&mut self, value: impl Into<Vec<u8>>);
469 fn get_ms_bap_usage(&self) -> Option<MsBapUsage>;
470 fn set_ms_bap_usage(&mut self, value: MsBapUsage);
471 fn get_ms_link_utilization_threshold(&self) -> Option<u32>;
472 fn set_ms_link_utilization_threshold(&mut self, value: u32);
473 fn get_ms_link_drop_time_limit(&self) -> Option<u32>;
474 fn set_ms_link_drop_time_limit(&mut self, value: u32);
475 fn get_ms_mppe_send_key(&self) -> Option<Vec<u8>>;
476 fn set_ms_mppe_send_key(&mut self, value: impl Into<Vec<u8>>);
477 fn get_ms_mppe_recv_key(&self) -> Option<Vec<u8>>;
478 fn set_ms_mppe_recv_key(&mut self, value: impl Into<Vec<u8>>);
479 fn get_ms_ras_version(&self) -> Option<String>;
480 fn set_ms_ras_version(&mut self, value: impl Into<String>);
481 fn get_ms_old_arap_password(&self) -> Option<Vec<u8>>;
482 fn set_ms_old_arap_password(&mut self, value: impl Into<Vec<u8>>);
483 fn get_ms_new_arap_password(&self) -> Option<Vec<u8>>;
484 fn set_ms_new_arap_password(&mut self, value: impl Into<Vec<u8>>);
485 fn get_ms_arap_pw_change_reason(&self) -> Option<MsArapPwChangeReason>;
486 fn set_ms_arap_pw_change_reason(&mut self, value: MsArapPwChangeReason);
487 fn get_ms_filter(&self) -> Option<Vec<u8>>;
488 fn set_ms_filter(&mut self, value: impl Into<Vec<u8>>);
489 fn get_ms_acct_auth_type(&self) -> Option<MsAcctAuthType>;
490 fn set_ms_acct_auth_type(&mut self, value: MsAcctAuthType);
491 fn get_ms_acct_eap_type(&self) -> Option<MsAcctEapType>;
492 fn set_ms_acct_eap_type(&mut self, value: MsAcctEapType);
493 fn get_ms_chap2_response(&self) -> Option<Vec<u8>>;
494 fn set_ms_chap2_response(&mut self, value: impl Into<Vec<u8>>);
495 fn get_ms_chap2_success(&self) -> Option<Vec<u8>>;
496 fn set_ms_chap2_success(&mut self, value: impl Into<Vec<u8>>);
497 fn get_ms_chap2_cpw(&self) -> Option<Vec<u8>>;
498 fn set_ms_chap2_cpw(&mut self, value: impl Into<Vec<u8>>);
499 fn get_ms_primary_dns_server(&self) -> Option<Ipv4Addr>;
500 fn set_ms_primary_dns_server(&mut self, value: Ipv4Addr);
501 fn get_ms_secondary_dns_server(&self) -> Option<Ipv4Addr>;
502 fn set_ms_secondary_dns_server(&mut self, value: Ipv4Addr);
503 fn get_ms_primary_nbns_server(&self) -> Option<Ipv4Addr>;
504 fn set_ms_primary_nbns_server(&mut self, value: Ipv4Addr);
505 fn get_ms_secondary_nbns_server(&self) -> Option<Ipv4Addr>;
506 fn set_ms_secondary_nbns_server(&mut self, value: Ipv4Addr);
507 fn get_ms_ras_client_name(&self) -> Option<String>;
508 fn set_ms_ras_client_name(&mut self, value: impl Into<String>);
509 fn get_ms_ras_client_version(&self) -> Option<String>;
510 fn set_ms_ras_client_version(&mut self, value: impl Into<String>);
511 fn get_ms_quarantine_ipfilter(&self) -> Option<Vec<u8>>;
512 fn set_ms_quarantine_ipfilter(&mut self, value: impl Into<Vec<u8>>);
513 fn get_ms_quarantine_session_timeout(&self) -> Option<u32>;
514 fn set_ms_quarantine_session_timeout(&mut self, value: u32);
515 fn get_ms_user_security_identity(&self) -> Option<String>;
516 fn set_ms_user_security_identity(&mut self, value: impl Into<String>);
517 fn get_ms_identity_type(&self) -> Option<MsIdentityType>;
518 fn set_ms_identity_type(&mut self, value: MsIdentityType);
519 fn get_ms_service_class(&self) -> Option<String>;
520 fn set_ms_service_class(&mut self, value: impl Into<String>);
521 fn get_ms_quarantine_user_class(&self) -> Option<String>;
522 fn set_ms_quarantine_user_class(&mut self, value: impl Into<String>);
523 fn get_ms_quarantine_state(&self) -> Option<MsQuarantineState>;
524 fn set_ms_quarantine_state(&mut self, value: MsQuarantineState);
525 fn get_ms_quarantine_grace_time(&self) -> Option<u32>;
526 fn set_ms_quarantine_grace_time(&mut self, value: u32);
527 fn get_ms_network_access_server_type(&self) -> Option<MsNetworkAccessServerType>;
528 fn set_ms_network_access_server_type(&mut self, value: MsNetworkAccessServerType);
529 fn get_ms_afw_zone(&self) -> Option<MsAfwZone>;
530 fn set_ms_afw_zone(&mut self, value: MsAfwZone);
531 fn get_ms_afw_protection_level(&self) -> Option<MsAfwProtectionLevel>;
532 fn set_ms_afw_protection_level(&mut self, value: MsAfwProtectionLevel);
533 fn get_ms_machine_name(&self) -> Option<String>;
534 fn set_ms_machine_name(&mut self, value: impl Into<String>);
535 fn get_ms_ipv6_filter(&self) -> Option<Vec<u8>>;
536 fn set_ms_ipv6_filter(&mut self, value: impl Into<Vec<u8>>);
537 fn get_ms_ipv4_remediation_servers(&self) -> Option<Vec<u8>>;
538 fn set_ms_ipv4_remediation_servers(&mut self, value: impl Into<Vec<u8>>);
539 fn get_ms_ipv6_remediation_servers(&self) -> Option<Vec<u8>>;
540 fn set_ms_ipv6_remediation_servers(&mut self, value: impl Into<Vec<u8>>);
541 fn get_ms_rnap_not_quarantine_capable(&self) -> Option<MsRnapNotQuarantineCapable>;
542 fn set_ms_rnap_not_quarantine_capable(&mut self, value: MsRnapNotQuarantineCapable);
543 fn get_ms_quarantine_soh(&self) -> Option<Vec<u8>>;
544 fn set_ms_quarantine_soh(&mut self, value: impl Into<Vec<u8>>);
545 fn get_ms_ras_correlation(&self) -> Option<Vec<u8>>;
546 fn set_ms_ras_correlation(&mut self, value: impl Into<Vec<u8>>);
547 fn get_ms_extended_quarantine_state(&self) -> Option<MsExtendedQuarantineState>;
548 fn set_ms_extended_quarantine_state(&mut self, value: MsExtendedQuarantineState);
549 fn get_ms_hcap_user_groups(&self) -> Option<String>;
550 fn set_ms_hcap_user_groups(&mut self, value: impl Into<String>);
551 fn get_ms_hcap_location_group_name(&self) -> Option<String>;
552 fn set_ms_hcap_location_group_name(&mut self, value: impl Into<String>);
553 fn get_ms_hcap_user_name(&self) -> Option<String>;
554 fn set_ms_hcap_user_name(&mut self, value: impl Into<String>);
555 fn get_ms_user_ipv4_address(&self) -> Option<Ipv4Addr>;
556 fn set_ms_user_ipv4_address(&mut self, value: Ipv4Addr);
557 fn get_ms_user_ipv6_address(&self) -> Option<Ipv6Addr>;
558 fn set_ms_user_ipv6_address(&mut self, value: Ipv6Addr);
559 fn get_ms_tsg_device_redirection(&self) -> Option<u32>;
560 fn set_ms_tsg_device_redirection(&mut self, value: u32);
561}
562impl MicrosoftExt for Packet {
563 fn get_ms_chap_response(&self) -> Option<Vec<u8>> {
564 self.get_attribute_as::<Vec<u8>>(MS_CHAP_RESPONSE_TYPE)
565 }
566 fn set_ms_chap_response(&mut self, value: impl Into<Vec<u8>>) {
567 let wire_val: Vec<u8> = value.into();
568 if ToRadiusAttribute::to_bytes(&wire_val).len() != 50u32 as usize {
569 return;
570 }
571 self.set_attribute_as::<Vec<u8>>(MS_CHAP_RESPONSE_TYPE, wire_val);
572 }
573 fn get_ms_chap_error(&self) -> Option<String> {
574 self.get_attribute_as::<String>(MS_CHAP_ERROR_TYPE)
575 }
576 fn set_ms_chap_error(&mut self, value: impl Into<String>) {
577 let wire_val: String = value.into();
578 self.set_attribute_as::<String>(MS_CHAP_ERROR_TYPE, wire_val);
579 }
580 fn get_ms_chap_cpw_1(&self) -> Option<Vec<u8>> {
581 self.get_attribute_as::<Vec<u8>>(MS_CHAP_CPW_1_TYPE)
582 }
583 fn set_ms_chap_cpw_1(&mut self, value: impl Into<Vec<u8>>) {
584 let wire_val: Vec<u8> = value.into();
585 if ToRadiusAttribute::to_bytes(&wire_val).len() != 70u32 as usize {
586 return;
587 }
588 self.set_attribute_as::<Vec<u8>>(MS_CHAP_CPW_1_TYPE, wire_val);
589 }
590 fn get_ms_chap_cpw_2(&self) -> Option<Vec<u8>> {
591 self.get_attribute_as::<Vec<u8>>(MS_CHAP_CPW_2_TYPE)
592 }
593 fn set_ms_chap_cpw_2(&mut self, value: impl Into<Vec<u8>>) {
594 let wire_val: Vec<u8> = value.into();
595 if ToRadiusAttribute::to_bytes(&wire_val).len() != 84u32 as usize {
596 return;
597 }
598 self.set_attribute_as::<Vec<u8>>(MS_CHAP_CPW_2_TYPE, wire_val);
599 }
600 fn get_ms_chap_lm_enc_pw(&self) -> Option<Vec<u8>> {
601 self.get_attribute_as::<Vec<u8>>(MS_CHAP_LM_ENC_PW_TYPE)
602 }
603 fn set_ms_chap_lm_enc_pw(&mut self, value: impl Into<Vec<u8>>) {
604 let wire_val: Vec<u8> = value.into();
605 self.set_attribute_as::<Vec<u8>>(MS_CHAP_LM_ENC_PW_TYPE, wire_val);
606 }
607 fn get_ms_chap_nt_enc_pw(&self) -> Option<Vec<u8>> {
608 self.get_attribute_as::<Vec<u8>>(MS_CHAP_NT_ENC_PW_TYPE)
609 }
610 fn set_ms_chap_nt_enc_pw(&mut self, value: impl Into<Vec<u8>>) {
611 let wire_val: Vec<u8> = value.into();
612 self.set_attribute_as::<Vec<u8>>(MS_CHAP_NT_ENC_PW_TYPE, wire_val);
613 }
614 fn get_ms_mppe_encryption_policy(&self) -> Option<MsMppeEncryptionPolicy> {
615 self.get_attribute_as::<u32>(MS_MPPE_ENCRYPTION_POLICY_TYPE)
616 .map(MsMppeEncryptionPolicy::from)
617 }
618 fn set_ms_mppe_encryption_policy(&mut self, value: MsMppeEncryptionPolicy) {
619 let wire_val: u32 = value.into();
620 self.set_attribute_as::<u32>(MS_MPPE_ENCRYPTION_POLICY_TYPE, wire_val);
621 }
622 fn get_ms_mppe_encryption_type(&self) -> Option<u32> {
623 self.get_attribute_as::<u32>(MS_MPPE_ENCRYPTION_TYPE_TYPE)
624 }
625 fn set_ms_mppe_encryption_type(&mut self, value: u32) {
626 let wire_val = value;
627 self.set_attribute_as::<u32>(MS_MPPE_ENCRYPTION_TYPE_TYPE, wire_val);
628 }
629 fn get_ms_mppe_encryption_types(&self) -> Option<MsMppeEncryptionTypes> {
630 self.get_attribute_as::<u32>(MS_MPPE_ENCRYPTION_TYPES_TYPE)
631 .map(MsMppeEncryptionTypes::from)
632 }
633 fn set_ms_mppe_encryption_types(&mut self, value: MsMppeEncryptionTypes) {
634 let wire_val: u32 = value.into();
635 self.set_attribute_as::<u32>(MS_MPPE_ENCRYPTION_TYPES_TYPE, wire_val);
636 }
637 fn get_ms_ras_vendor(&self) -> Option<u32> {
638 self.get_attribute_as::<u32>(MS_RAS_VENDOR_TYPE)
639 }
640 fn set_ms_ras_vendor(&mut self, value: u32) {
641 let wire_val = value;
642 self.set_attribute_as::<u32>(MS_RAS_VENDOR_TYPE, wire_val);
643 }
644 fn get_ms_chap_domain(&self) -> Option<String> {
645 self.get_attribute_as::<String>(MS_CHAP_DOMAIN_TYPE)
646 }
647 fn set_ms_chap_domain(&mut self, value: impl Into<String>) {
648 let wire_val: String = value.into();
649 self.set_attribute_as::<String>(MS_CHAP_DOMAIN_TYPE, wire_val);
650 }
651 fn get_ms_chap_challenge(&self) -> Option<Vec<u8>> {
652 self.get_attribute_as::<Vec<u8>>(MS_CHAP_CHALLENGE_TYPE)
653 }
654 fn set_ms_chap_challenge(&mut self, value: impl Into<Vec<u8>>) {
655 let wire_val: Vec<u8> = value.into();
656 self.set_attribute_as::<Vec<u8>>(MS_CHAP_CHALLENGE_TYPE, wire_val);
657 }
658 fn get_ms_chap_mppe_keys(&self) -> Option<Vec<u8>> {
659 self.get_attribute_as::<Vec<u8>>(MS_CHAP_MPPE_KEYS_TYPE)
660 }
661 fn set_ms_chap_mppe_keys(&mut self, value: impl Into<Vec<u8>>) {
662 let wire_val: Vec<u8> = value.into();
663 if ToRadiusAttribute::to_bytes(&wire_val).len() != 24u32 as usize {
664 return;
665 }
666 self.set_attribute_as::<Vec<u8>>(MS_CHAP_MPPE_KEYS_TYPE, wire_val);
667 }
668 fn get_ms_bap_usage(&self) -> Option<MsBapUsage> {
669 self.get_attribute_as::<u32>(MS_BAP_USAGE_TYPE)
670 .map(MsBapUsage::from)
671 }
672 fn set_ms_bap_usage(&mut self, value: MsBapUsage) {
673 let wire_val: u32 = value.into();
674 self.set_attribute_as::<u32>(MS_BAP_USAGE_TYPE, wire_val);
675 }
676 fn get_ms_link_utilization_threshold(&self) -> Option<u32> {
677 self.get_attribute_as::<u32>(MS_LINK_UTILIZATION_THRESHOLD_TYPE)
678 }
679 fn set_ms_link_utilization_threshold(&mut self, value: u32) {
680 let wire_val = value;
681 self.set_attribute_as::<u32>(MS_LINK_UTILIZATION_THRESHOLD_TYPE, wire_val);
682 }
683 fn get_ms_link_drop_time_limit(&self) -> Option<u32> {
684 self.get_attribute_as::<u32>(MS_LINK_DROP_TIME_LIMIT_TYPE)
685 }
686 fn set_ms_link_drop_time_limit(&mut self, value: u32) {
687 let wire_val = value;
688 self.set_attribute_as::<u32>(MS_LINK_DROP_TIME_LIMIT_TYPE, wire_val);
689 }
690 fn get_ms_mppe_send_key(&self) -> Option<Vec<u8>> {
691 self.get_attribute_as::<Vec<u8>>(MS_MPPE_SEND_KEY_TYPE)
692 }
693 fn set_ms_mppe_send_key(&mut self, value: impl Into<Vec<u8>>) {
694 let wire_val: Vec<u8> = value.into();
695 self.set_attribute_as::<Vec<u8>>(MS_MPPE_SEND_KEY_TYPE, wire_val);
696 }
697 fn get_ms_mppe_recv_key(&self) -> Option<Vec<u8>> {
698 self.get_attribute_as::<Vec<u8>>(MS_MPPE_RECV_KEY_TYPE)
699 }
700 fn set_ms_mppe_recv_key(&mut self, value: impl Into<Vec<u8>>) {
701 let wire_val: Vec<u8> = value.into();
702 self.set_attribute_as::<Vec<u8>>(MS_MPPE_RECV_KEY_TYPE, wire_val);
703 }
704 fn get_ms_ras_version(&self) -> Option<String> {
705 self.get_attribute_as::<String>(MS_RAS_VERSION_TYPE)
706 }
707 fn set_ms_ras_version(&mut self, value: impl Into<String>) {
708 let wire_val: String = value.into();
709 self.set_attribute_as::<String>(MS_RAS_VERSION_TYPE, wire_val);
710 }
711 fn get_ms_old_arap_password(&self) -> Option<Vec<u8>> {
712 self.get_attribute_as::<Vec<u8>>(MS_OLD_ARAP_PASSWORD_TYPE)
713 }
714 fn set_ms_old_arap_password(&mut self, value: impl Into<Vec<u8>>) {
715 let wire_val: Vec<u8> = value.into();
716 self.set_attribute_as::<Vec<u8>>(MS_OLD_ARAP_PASSWORD_TYPE, wire_val);
717 }
718 fn get_ms_new_arap_password(&self) -> Option<Vec<u8>> {
719 self.get_attribute_as::<Vec<u8>>(MS_NEW_ARAP_PASSWORD_TYPE)
720 }
721 fn set_ms_new_arap_password(&mut self, value: impl Into<Vec<u8>>) {
722 let wire_val: Vec<u8> = value.into();
723 self.set_attribute_as::<Vec<u8>>(MS_NEW_ARAP_PASSWORD_TYPE, wire_val);
724 }
725 fn get_ms_arap_pw_change_reason(&self) -> Option<MsArapPwChangeReason> {
726 self.get_attribute_as::<u32>(MS_ARAP_PW_CHANGE_REASON_TYPE)
727 .map(MsArapPwChangeReason::from)
728 }
729 fn set_ms_arap_pw_change_reason(&mut self, value: MsArapPwChangeReason) {
730 let wire_val: u32 = value.into();
731 self.set_attribute_as::<u32>(MS_ARAP_PW_CHANGE_REASON_TYPE, wire_val);
732 }
733 fn get_ms_filter(&self) -> Option<Vec<u8>> {
734 self.get_attribute_as::<Vec<u8>>(MS_FILTER_TYPE)
735 }
736 fn set_ms_filter(&mut self, value: impl Into<Vec<u8>>) {
737 let wire_val: Vec<u8> = value.into();
738 self.set_attribute_as::<Vec<u8>>(MS_FILTER_TYPE, wire_val);
739 }
740 fn get_ms_acct_auth_type(&self) -> Option<MsAcctAuthType> {
741 self.get_attribute_as::<u32>(MS_ACCT_AUTH_TYPE_TYPE)
742 .map(MsAcctAuthType::from)
743 }
744 fn set_ms_acct_auth_type(&mut self, value: MsAcctAuthType) {
745 let wire_val: u32 = value.into();
746 self.set_attribute_as::<u32>(MS_ACCT_AUTH_TYPE_TYPE, wire_val);
747 }
748 fn get_ms_acct_eap_type(&self) -> Option<MsAcctEapType> {
749 self.get_attribute_as::<u32>(MS_ACCT_EAP_TYPE_TYPE)
750 .map(MsAcctEapType::from)
751 }
752 fn set_ms_acct_eap_type(&mut self, value: MsAcctEapType) {
753 let wire_val: u32 = value.into();
754 self.set_attribute_as::<u32>(MS_ACCT_EAP_TYPE_TYPE, wire_val);
755 }
756 fn get_ms_chap2_response(&self) -> Option<Vec<u8>> {
757 self.get_attribute_as::<Vec<u8>>(MS_CHAP2_RESPONSE_TYPE)
758 }
759 fn set_ms_chap2_response(&mut self, value: impl Into<Vec<u8>>) {
760 let wire_val: Vec<u8> = value.into();
761 if ToRadiusAttribute::to_bytes(&wire_val).len() != 50u32 as usize {
762 return;
763 }
764 self.set_attribute_as::<Vec<u8>>(MS_CHAP2_RESPONSE_TYPE, wire_val);
765 }
766 fn get_ms_chap2_success(&self) -> Option<Vec<u8>> {
767 self.get_attribute_as::<Vec<u8>>(MS_CHAP2_SUCCESS_TYPE)
768 }
769 fn set_ms_chap2_success(&mut self, value: impl Into<Vec<u8>>) {
770 let wire_val: Vec<u8> = value.into();
771 self.set_attribute_as::<Vec<u8>>(MS_CHAP2_SUCCESS_TYPE, wire_val);
772 }
773 fn get_ms_chap2_cpw(&self) -> Option<Vec<u8>> {
774 self.get_attribute_as::<Vec<u8>>(MS_CHAP2_CPW_TYPE)
775 }
776 fn set_ms_chap2_cpw(&mut self, value: impl Into<Vec<u8>>) {
777 let wire_val: Vec<u8> = value.into();
778 if ToRadiusAttribute::to_bytes(&wire_val).len() != 68u32 as usize {
779 return;
780 }
781 self.set_attribute_as::<Vec<u8>>(MS_CHAP2_CPW_TYPE, wire_val);
782 }
783 fn get_ms_primary_dns_server(&self) -> Option<Ipv4Addr> {
784 self.get_attribute_as::<Ipv4Addr>(MS_PRIMARY_DNS_SERVER_TYPE)
785 }
786 fn set_ms_primary_dns_server(&mut self, value: Ipv4Addr) {
787 let wire_val = value;
788 self.set_attribute_as::<Ipv4Addr>(MS_PRIMARY_DNS_SERVER_TYPE, wire_val);
789 }
790 fn get_ms_secondary_dns_server(&self) -> Option<Ipv4Addr> {
791 self.get_attribute_as::<Ipv4Addr>(MS_SECONDARY_DNS_SERVER_TYPE)
792 }
793 fn set_ms_secondary_dns_server(&mut self, value: Ipv4Addr) {
794 let wire_val = value;
795 self.set_attribute_as::<Ipv4Addr>(MS_SECONDARY_DNS_SERVER_TYPE, wire_val);
796 }
797 fn get_ms_primary_nbns_server(&self) -> Option<Ipv4Addr> {
798 self.get_attribute_as::<Ipv4Addr>(MS_PRIMARY_NBNS_SERVER_TYPE)
799 }
800 fn set_ms_primary_nbns_server(&mut self, value: Ipv4Addr) {
801 let wire_val = value;
802 self.set_attribute_as::<Ipv4Addr>(MS_PRIMARY_NBNS_SERVER_TYPE, wire_val);
803 }
804 fn get_ms_secondary_nbns_server(&self) -> Option<Ipv4Addr> {
805 self.get_attribute_as::<Ipv4Addr>(MS_SECONDARY_NBNS_SERVER_TYPE)
806 }
807 fn set_ms_secondary_nbns_server(&mut self, value: Ipv4Addr) {
808 let wire_val = value;
809 self.set_attribute_as::<Ipv4Addr>(MS_SECONDARY_NBNS_SERVER_TYPE, wire_val);
810 }
811 fn get_ms_ras_client_name(&self) -> Option<String> {
812 self.get_attribute_as::<String>(MS_RAS_CLIENT_NAME_TYPE)
813 }
814 fn set_ms_ras_client_name(&mut self, value: impl Into<String>) {
815 let wire_val: String = value.into();
816 self.set_attribute_as::<String>(MS_RAS_CLIENT_NAME_TYPE, wire_val);
817 }
818 fn get_ms_ras_client_version(&self) -> Option<String> {
819 self.get_attribute_as::<String>(MS_RAS_CLIENT_VERSION_TYPE)
820 }
821 fn set_ms_ras_client_version(&mut self, value: impl Into<String>) {
822 let wire_val: String = value.into();
823 self.set_attribute_as::<String>(MS_RAS_CLIENT_VERSION_TYPE, wire_val);
824 }
825 fn get_ms_quarantine_ipfilter(&self) -> Option<Vec<u8>> {
826 self.get_attribute_as::<Vec<u8>>(MS_QUARANTINE_IPFILTER_TYPE)
827 }
828 fn set_ms_quarantine_ipfilter(&mut self, value: impl Into<Vec<u8>>) {
829 let wire_val: Vec<u8> = value.into();
830 self.set_attribute_as::<Vec<u8>>(MS_QUARANTINE_IPFILTER_TYPE, wire_val);
831 }
832 fn get_ms_quarantine_session_timeout(&self) -> Option<u32> {
833 self.get_attribute_as::<u32>(MS_QUARANTINE_SESSION_TIMEOUT_TYPE)
834 }
835 fn set_ms_quarantine_session_timeout(&mut self, value: u32) {
836 let wire_val = value;
837 self.set_attribute_as::<u32>(MS_QUARANTINE_SESSION_TIMEOUT_TYPE, wire_val);
838 }
839 fn get_ms_user_security_identity(&self) -> Option<String> {
840 self.get_attribute_as::<String>(MS_USER_SECURITY_IDENTITY_TYPE)
841 }
842 fn set_ms_user_security_identity(&mut self, value: impl Into<String>) {
843 let wire_val: String = value.into();
844 self.set_attribute_as::<String>(MS_USER_SECURITY_IDENTITY_TYPE, wire_val);
845 }
846 fn get_ms_identity_type(&self) -> Option<MsIdentityType> {
847 self.get_attribute_as::<u32>(MS_IDENTITY_TYPE_TYPE)
848 .map(MsIdentityType::from)
849 }
850 fn set_ms_identity_type(&mut self, value: MsIdentityType) {
851 let wire_val: u32 = value.into();
852 self.set_attribute_as::<u32>(MS_IDENTITY_TYPE_TYPE, wire_val);
853 }
854 fn get_ms_service_class(&self) -> Option<String> {
855 self.get_attribute_as::<String>(MS_SERVICE_CLASS_TYPE)
856 }
857 fn set_ms_service_class(&mut self, value: impl Into<String>) {
858 let wire_val: String = value.into();
859 self.set_attribute_as::<String>(MS_SERVICE_CLASS_TYPE, wire_val);
860 }
861 fn get_ms_quarantine_user_class(&self) -> Option<String> {
862 self.get_attribute_as::<String>(MS_QUARANTINE_USER_CLASS_TYPE)
863 }
864 fn set_ms_quarantine_user_class(&mut self, value: impl Into<String>) {
865 let wire_val: String = value.into();
866 self.set_attribute_as::<String>(MS_QUARANTINE_USER_CLASS_TYPE, wire_val);
867 }
868 fn get_ms_quarantine_state(&self) -> Option<MsQuarantineState> {
869 self.get_attribute_as::<u32>(MS_QUARANTINE_STATE_TYPE)
870 .map(MsQuarantineState::from)
871 }
872 fn set_ms_quarantine_state(&mut self, value: MsQuarantineState) {
873 let wire_val: u32 = value.into();
874 self.set_attribute_as::<u32>(MS_QUARANTINE_STATE_TYPE, wire_val);
875 }
876 fn get_ms_quarantine_grace_time(&self) -> Option<u32> {
877 self.get_attribute_as::<u32>(MS_QUARANTINE_GRACE_TIME_TYPE)
878 }
879 fn set_ms_quarantine_grace_time(&mut self, value: u32) {
880 let wire_val = value;
881 self.set_attribute_as::<u32>(MS_QUARANTINE_GRACE_TIME_TYPE, wire_val);
882 }
883 fn get_ms_network_access_server_type(&self) -> Option<MsNetworkAccessServerType> {
884 self.get_attribute_as::<u32>(MS_NETWORK_ACCESS_SERVER_TYPE_TYPE)
885 .map(MsNetworkAccessServerType::from)
886 }
887 fn set_ms_network_access_server_type(&mut self, value: MsNetworkAccessServerType) {
888 let wire_val: u32 = value.into();
889 self.set_attribute_as::<u32>(MS_NETWORK_ACCESS_SERVER_TYPE_TYPE, wire_val);
890 }
891 fn get_ms_afw_zone(&self) -> Option<MsAfwZone> {
892 self.get_attribute_as::<u32>(MS_AFW_ZONE_TYPE)
893 .map(MsAfwZone::from)
894 }
895 fn set_ms_afw_zone(&mut self, value: MsAfwZone) {
896 let wire_val: u32 = value.into();
897 self.set_attribute_as::<u32>(MS_AFW_ZONE_TYPE, wire_val);
898 }
899 fn get_ms_afw_protection_level(&self) -> Option<MsAfwProtectionLevel> {
900 self.get_attribute_as::<u32>(MS_AFW_PROTECTION_LEVEL_TYPE)
901 .map(MsAfwProtectionLevel::from)
902 }
903 fn set_ms_afw_protection_level(&mut self, value: MsAfwProtectionLevel) {
904 let wire_val: u32 = value.into();
905 self.set_attribute_as::<u32>(MS_AFW_PROTECTION_LEVEL_TYPE, wire_val);
906 }
907 fn get_ms_machine_name(&self) -> Option<String> {
908 self.get_attribute_as::<String>(MS_MACHINE_NAME_TYPE)
909 }
910 fn set_ms_machine_name(&mut self, value: impl Into<String>) {
911 let wire_val: String = value.into();
912 self.set_attribute_as::<String>(MS_MACHINE_NAME_TYPE, wire_val);
913 }
914 fn get_ms_ipv6_filter(&self) -> Option<Vec<u8>> {
915 self.get_attribute_as::<Vec<u8>>(MS_IPV6_FILTER_TYPE)
916 }
917 fn set_ms_ipv6_filter(&mut self, value: impl Into<Vec<u8>>) {
918 let wire_val: Vec<u8> = value.into();
919 self.set_attribute_as::<Vec<u8>>(MS_IPV6_FILTER_TYPE, wire_val);
920 }
921 fn get_ms_ipv4_remediation_servers(&self) -> Option<Vec<u8>> {
922 self.get_attribute_as::<Vec<u8>>(MS_IPV4_REMEDIATION_SERVERS_TYPE)
923 }
924 fn set_ms_ipv4_remediation_servers(&mut self, value: impl Into<Vec<u8>>) {
925 let wire_val: Vec<u8> = value.into();
926 self.set_attribute_as::<Vec<u8>>(MS_IPV4_REMEDIATION_SERVERS_TYPE, wire_val);
927 }
928 fn get_ms_ipv6_remediation_servers(&self) -> Option<Vec<u8>> {
929 self.get_attribute_as::<Vec<u8>>(MS_IPV6_REMEDIATION_SERVERS_TYPE)
930 }
931 fn set_ms_ipv6_remediation_servers(&mut self, value: impl Into<Vec<u8>>) {
932 let wire_val: Vec<u8> = value.into();
933 self.set_attribute_as::<Vec<u8>>(MS_IPV6_REMEDIATION_SERVERS_TYPE, wire_val);
934 }
935 fn get_ms_rnap_not_quarantine_capable(&self) -> Option<MsRnapNotQuarantineCapable> {
936 self.get_attribute_as::<u32>(MS_RNAP_NOT_QUARANTINE_CAPABLE_TYPE)
937 .map(MsRnapNotQuarantineCapable::from)
938 }
939 fn set_ms_rnap_not_quarantine_capable(&mut self, value: MsRnapNotQuarantineCapable) {
940 let wire_val: u32 = value.into();
941 self.set_attribute_as::<u32>(MS_RNAP_NOT_QUARANTINE_CAPABLE_TYPE, wire_val);
942 }
943 fn get_ms_quarantine_soh(&self) -> Option<Vec<u8>> {
944 self.get_attribute_as::<Vec<u8>>(MS_QUARANTINE_SOH_TYPE)
945 }
946 fn set_ms_quarantine_soh(&mut self, value: impl Into<Vec<u8>>) {
947 let wire_val: Vec<u8> = value.into();
948 self.set_attribute_as::<Vec<u8>>(MS_QUARANTINE_SOH_TYPE, wire_val);
949 }
950 fn get_ms_ras_correlation(&self) -> Option<Vec<u8>> {
951 self.get_attribute_as::<Vec<u8>>(MS_RAS_CORRELATION_TYPE)
952 }
953 fn set_ms_ras_correlation(&mut self, value: impl Into<Vec<u8>>) {
954 let wire_val: Vec<u8> = value.into();
955 self.set_attribute_as::<Vec<u8>>(MS_RAS_CORRELATION_TYPE, wire_val);
956 }
957 fn get_ms_extended_quarantine_state(&self) -> Option<MsExtendedQuarantineState> {
958 self.get_attribute_as::<u32>(MS_EXTENDED_QUARANTINE_STATE_TYPE)
959 .map(MsExtendedQuarantineState::from)
960 }
961 fn set_ms_extended_quarantine_state(&mut self, value: MsExtendedQuarantineState) {
962 let wire_val: u32 = value.into();
963 self.set_attribute_as::<u32>(MS_EXTENDED_QUARANTINE_STATE_TYPE, wire_val);
964 }
965 fn get_ms_hcap_user_groups(&self) -> Option<String> {
966 self.get_attribute_as::<String>(MS_HCAP_USER_GROUPS_TYPE)
967 }
968 fn set_ms_hcap_user_groups(&mut self, value: impl Into<String>) {
969 let wire_val: String = value.into();
970 self.set_attribute_as::<String>(MS_HCAP_USER_GROUPS_TYPE, wire_val);
971 }
972 fn get_ms_hcap_location_group_name(&self) -> Option<String> {
973 self.get_attribute_as::<String>(MS_HCAP_LOCATION_GROUP_NAME_TYPE)
974 }
975 fn set_ms_hcap_location_group_name(&mut self, value: impl Into<String>) {
976 let wire_val: String = value.into();
977 self.set_attribute_as::<String>(MS_HCAP_LOCATION_GROUP_NAME_TYPE, wire_val);
978 }
979 fn get_ms_hcap_user_name(&self) -> Option<String> {
980 self.get_attribute_as::<String>(MS_HCAP_USER_NAME_TYPE)
981 }
982 fn set_ms_hcap_user_name(&mut self, value: impl Into<String>) {
983 let wire_val: String = value.into();
984 self.set_attribute_as::<String>(MS_HCAP_USER_NAME_TYPE, wire_val);
985 }
986 fn get_ms_user_ipv4_address(&self) -> Option<Ipv4Addr> {
987 self.get_attribute_as::<Ipv4Addr>(MS_USER_IPV4_ADDRESS_TYPE)
988 }
989 fn set_ms_user_ipv4_address(&mut self, value: Ipv4Addr) {
990 let wire_val = value;
991 self.set_attribute_as::<Ipv4Addr>(MS_USER_IPV4_ADDRESS_TYPE, wire_val);
992 }
993 fn get_ms_user_ipv6_address(&self) -> Option<Ipv6Addr> {
994 self.get_attribute_as::<Ipv6Addr>(MS_USER_IPV6_ADDRESS_TYPE)
995 }
996 fn set_ms_user_ipv6_address(&mut self, value: Ipv6Addr) {
997 let wire_val = value;
998 self.set_attribute_as::<Ipv6Addr>(MS_USER_IPV6_ADDRESS_TYPE, wire_val);
999 }
1000 fn get_ms_tsg_device_redirection(&self) -> Option<u32> {
1001 self.get_attribute_as::<u32>(MS_TSG_DEVICE_REDIRECTION_TYPE)
1002 }
1003 fn set_ms_tsg_device_redirection(&mut self, value: u32) {
1004 let wire_val = value;
1005 self.set_attribute_as::<u32>(MS_TSG_DEVICE_REDIRECTION_TYPE, wire_val);
1006 }
1007}