Line data Source code
1 : use std::marker::PhantomData;
2 : use crate::common::FromFFI;
3 : use crate::pe::code_integrity::CodeIntegrity;
4 : use lief_ffi as ffi;
5 :
6 40 : #[derive(Debug)]
7 : pub enum LoadConfiguration<'a> {
8 : Base(Base<'a>),
9 : V0(LoadConfigV0<'a>),
10 : V1(LoadConfigV1<'a>),
11 : V2(LoadConfigV2<'a>),
12 : V3(LoadConfigV3<'a>),
13 : V4(LoadConfigV4<'a>),
14 : V5(LoadConfigV5<'a>),
15 : V6(LoadConfigV6<'a>),
16 : V7(LoadConfigV7<'a>),
17 : V8(LoadConfigV8<'a>),
18 : V9(LoadConfigV9<'a>),
19 : V10(LoadConfigV10<'a>),
20 : V11(LoadConfigV11<'a>),
21 : }
22 :
23 :
24 : impl<'a> FromFFI<ffi::PE_LoadConfiguration> for LoadConfiguration<'a> {
25 40 : fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::PE_LoadConfiguration>) -> Self {
26 40 : unsafe {
27 40 : let config_ref = ffi_entry.as_ref().unwrap();
28 40 :
29 40 : if ffi::PE_LoadConfigurationV0::classof(config_ref) {
30 0 : let raw = {
31 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
32 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV0>;
33 0 : std::mem::transmute::<From, To>(ffi_entry)
34 0 : };
35 0 : LoadConfiguration::V0(LoadConfigV0::from_ffi(raw))
36 40 : } else if ffi::PE_LoadConfigurationV1::classof(config_ref) {
37 0 : let raw = {
38 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
39 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV1>;
40 0 : std::mem::transmute::<From, To>(ffi_entry)
41 0 : };
42 0 : LoadConfiguration::V1(LoadConfigV1::from_ffi(raw))
43 40 : } else if ffi::PE_LoadConfigurationV2::classof(config_ref) {
44 0 : let raw = {
45 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
46 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV2>;
47 0 : std::mem::transmute::<From, To>(ffi_entry)
48 0 : };
49 0 : LoadConfiguration::V2(LoadConfigV2::from_ffi(raw))
50 40 : } else if ffi::PE_LoadConfigurationV3::classof(config_ref) {
51 0 : let raw = {
52 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
53 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV3>;
54 0 : std::mem::transmute::<From, To>(ffi_entry)
55 0 : };
56 0 : LoadConfiguration::V3(LoadConfigV3::from_ffi(raw))
57 40 : } else if ffi::PE_LoadConfigurationV4::classof(config_ref) {
58 0 : let raw = {
59 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
60 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV4>;
61 0 : std::mem::transmute::<From, To>(ffi_entry)
62 0 : };
63 0 : LoadConfiguration::V4(LoadConfigV4::from_ffi(raw))
64 40 : } else if ffi::PE_LoadConfigurationV5::classof(config_ref) {
65 0 : let raw = {
66 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
67 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV5>;
68 0 : std::mem::transmute::<From, To>(ffi_entry)
69 0 : };
70 0 : LoadConfiguration::V5(LoadConfigV5::from_ffi(raw))
71 40 : } else if ffi::PE_LoadConfigurationV6::classof(config_ref) {
72 0 : let raw = {
73 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
74 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV6>;
75 0 : std::mem::transmute::<From, To>(ffi_entry)
76 0 : };
77 0 : LoadConfiguration::V6(LoadConfigV6::from_ffi(raw))
78 40 : } else if ffi::PE_LoadConfigurationV7::classof(config_ref) {
79 8 : let raw = {
80 8 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
81 8 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV7>;
82 8 : std::mem::transmute::<From, To>(ffi_entry)
83 8 : };
84 8 : LoadConfiguration::V7(LoadConfigV7::from_ffi(raw))
85 32 : } else if ffi::PE_LoadConfigurationV8::classof(config_ref) {
86 0 : let raw = {
87 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
88 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV8>;
89 0 : std::mem::transmute::<From, To>(ffi_entry)
90 0 : };
91 0 : LoadConfiguration::V8(LoadConfigV8::from_ffi(raw))
92 32 : } else if ffi::PE_LoadConfigurationV9::classof(config_ref) {
93 0 : let raw = {
94 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
95 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV9>;
96 0 : std::mem::transmute::<From, To>(ffi_entry)
97 0 : };
98 0 : LoadConfiguration::V9(LoadConfigV9::from_ffi(raw))
99 32 : } else if ffi::PE_LoadConfigurationV10::classof(config_ref) {
100 0 : let raw = {
101 0 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
102 0 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV10>;
103 0 : std::mem::transmute::<From, To>(ffi_entry)
104 0 : };
105 0 : LoadConfiguration::V10(LoadConfigV10::from_ffi(raw))
106 32 : } else if ffi::PE_LoadConfigurationV11::classof(config_ref) {
107 32 : let raw = {
108 32 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
109 32 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV11>;
110 32 : std::mem::transmute::<From, To>(ffi_entry)
111 32 : };
112 32 : LoadConfiguration::V11(LoadConfigV11::from_ffi(raw))
113 : } else {
114 0 : LoadConfiguration::Base(Base::from_ffi(ffi_entry))
115 : }
116 : }
117 40 : }
118 : }
119 :
120 : pub struct Base<'a> {
121 : ptr: cxx::UniquePtr<ffi::PE_LoadConfiguration>,
122 : _owner: PhantomData<&'a ffi::PE_Binary>,
123 : }
124 :
125 : impl std::fmt::Debug for Base<'_> {
126 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
127 0 : let base = self as &dyn AsBase;
128 0 : f.write_str(format!("{base:?}").as_str())
129 0 : }
130 : }
131 :
132 : impl std::fmt::Debug for &dyn AsBase {
133 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
134 40 : f.debug_struct("Base")
135 40 : .field("characteristics", &self.characteristics())
136 40 : .field("timedatestamp", &self.timedatestamp())
137 40 : .field("major_version", &self.major_version())
138 40 : .field("minor_version", &self.minor_version())
139 40 : .field("global_flags_clear", &self.global_flags_clear())
140 40 : .field("global_flags_set", &self.global_flags_set())
141 40 : .field("critical_section_default_timeout", &self.critical_section_default_timeout())
142 40 : .field("decommit_free_block_threshold", &self.decommit_free_block_threshold())
143 40 : .field("decommit_total_free_threshold", &self.decommit_total_free_threshold())
144 40 : .field("lock_prefix_table", &self.lock_prefix_table())
145 40 : .field("maximum_allocation_size", &self.maximum_allocation_size())
146 40 : .field("virtual_memory_threshold", &self.virtual_memory_threshold())
147 40 : .field("process_affinity_mask", &self.process_affinity_mask())
148 40 : .field("process_heap_flags", &self.process_heap_flags())
149 40 : .field("csd_version", &self.csd_version())
150 40 : .field("reserved1", &self.reserved1())
151 40 : .field("dependent_load_flags", &self.dependent_load_flags())
152 40 : .field("editlist", &self.editlist())
153 40 : .field("security_cookie", &self.security_cookie())
154 40 : .finish()
155 40 : }
156 : }
157 :
158 : impl<'a> FromFFI<ffi::PE_LoadConfiguration> for Base<'a> {
159 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfiguration>) -> Self {
160 0 : Self {
161 0 : ptr,
162 0 : _owner: PhantomData,
163 0 : }
164 0 : }
165 : }
166 :
167 : pub trait AsBase {
168 : #[doc(hidden)]
169 : fn as_base(&self) -> &ffi::PE_LoadConfiguration;
170 :
171 5 : fn characteristics(&self) -> u32 {
172 5 : self.as_base().characteristics()
173 5 : }
174 :
175 0 : fn size(&self) -> u32 {
176 0 : self.as_base().size()
177 0 : }
178 :
179 5 : fn timedatestamp(&self) -> u32 {
180 5 : self.as_base().timedatestamp()
181 5 : }
182 :
183 5 : fn major_version(&self) -> u32 {
184 5 : self.as_base().major_version()
185 5 : }
186 :
187 5 : fn minor_version(&self) -> u32 {
188 5 : self.as_base().minor_version()
189 5 : }
190 :
191 5 : fn global_flags_clear(&self) -> u32 {
192 5 : self.as_base().global_flags_clear()
193 5 : }
194 :
195 5 : fn global_flags_set(&self) -> u32 {
196 5 : self.as_base().global_flags_set()
197 5 : }
198 :
199 5 : fn critical_section_default_timeout(&self) -> u32 {
200 5 : self.as_base().critical_section_default_timeout()
201 5 : }
202 :
203 5 : fn decommit_free_block_threshold(&self) -> u64 {
204 5 : self.as_base().decommit_free_block_threshold()
205 5 : }
206 :
207 5 : fn decommit_total_free_threshold(&self) -> u64 {
208 5 : self.as_base().decommit_total_free_threshold()
209 5 : }
210 :
211 5 : fn lock_prefix_table(&self) -> u64 {
212 5 : self.as_base().lock_prefix_table()
213 5 : }
214 :
215 5 : fn maximum_allocation_size(&self) -> u64 {
216 5 : self.as_base().maximum_allocation_size()
217 5 : }
218 :
219 5 : fn virtual_memory_threshold(&self) -> u64 {
220 5 : self.as_base().virtual_memory_threshold()
221 5 : }
222 :
223 5 : fn process_affinity_mask(&self) -> u64 {
224 5 : self.as_base().process_affinity_mask()
225 5 : }
226 :
227 5 : fn process_heap_flags(&self) -> u32 {
228 5 : self.as_base().process_heap_flags()
229 5 : }
230 :
231 5 : fn csd_version(&self) -> u16 {
232 5 : self.as_base().csd_version()
233 5 : }
234 :
235 5 : fn reserved1(&self) -> u16 {
236 5 : self.as_base().reserved1()
237 5 : }
238 :
239 5 : fn dependent_load_flags(&self) -> u16 {
240 5 : self.as_base().dependent_load_flags()
241 5 : }
242 :
243 5 : fn editlist(&self) -> u32 {
244 5 : self.as_base().editlist()
245 5 : }
246 :
247 5 : fn security_cookie(&self) -> u64 {
248 5 : self.as_base().security_cookie()
249 5 : }
250 : }
251 :
252 : impl AsBase for Base<'_> {
253 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
254 0 : self.ptr.as_ref().unwrap()
255 0 : }
256 : }
257 :
258 : pub struct LoadConfigV0<'a> {
259 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV0>,
260 : _owner: PhantomData<&'a ffi::PE_Binary>,
261 : }
262 :
263 : impl std::fmt::Debug for LoadConfigV0<'_> {
264 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
265 0 : let base = self as &dyn AsLoadConfigV0;
266 0 : f.write_str(format!("{base:?}").as_str())
267 0 : }
268 : }
269 :
270 : impl std::fmt::Debug for &dyn AsLoadConfigV0 {
271 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 40 : f.debug_struct("LoadConfigV0")
273 40 : .field("se_handler_table", &self.se_handler_table())
274 40 : .field("se_handler_count", &self.se_handler_count())
275 40 : .finish()
276 40 : }
277 : }
278 :
279 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV0> for LoadConfigV0<'a> {
280 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV0>) -> Self {
281 0 : Self {
282 0 : ptr,
283 0 : _owner: PhantomData,
284 0 : }
285 0 : }
286 : }
287 :
288 : pub trait AsLoadConfigV0 {
289 : #[doc(hidden)]
290 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0;
291 :
292 5 : fn se_handler_table(&self) -> u64 {
293 5 : self.as_v0().se_handler_table()
294 5 : }
295 :
296 5 : fn se_handler_count(&self) -> u64 {
297 5 : self.as_v0().se_handler_count()
298 5 : }
299 : }
300 :
301 : impl AsBase for LoadConfigV0<'_> {
302 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
303 0 : self.ptr.as_ref().unwrap().as_ref()
304 0 : }
305 : }
306 :
307 : impl AsLoadConfigV0 for LoadConfigV0<'_> {
308 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
309 0 : self.ptr.as_ref().unwrap()
310 0 : }
311 : }
312 :
313 : pub struct LoadConfigV1<'a> {
314 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV1>,
315 : _owner: PhantomData<&'a ffi::PE_Binary>,
316 : }
317 :
318 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV1> for LoadConfigV1<'a> {
319 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV1>) -> Self {
320 0 : Self {
321 0 : ptr,
322 0 : _owner: PhantomData,
323 0 : }
324 0 : }
325 : }
326 :
327 : impl std::fmt::Debug for LoadConfigV1<'_> {
328 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
329 0 : let base = self as &dyn AsLoadConfigV1;
330 0 : f.write_str(format!("{base:?}").as_str())
331 0 : }
332 : }
333 :
334 : impl std::fmt::Debug for &dyn AsLoadConfigV1 {
335 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
336 40 : f.debug_struct("LoadConfigV1")
337 40 : .field("guard_cf_check_function_pointer", &self.guard_cf_check_function_pointer())
338 40 : .field("guard_cf_dispatch_function_pointer", &self.guard_cf_dispatch_function_pointer())
339 40 : .field("guard_cf_function_table", &self.guard_cf_function_table())
340 40 : .field("guard_cf_function_count", &self.guard_cf_function_count())
341 40 : .field("guard_flags", &self.guard_flags())
342 40 : .finish()
343 40 : }
344 : }
345 :
346 : pub trait AsLoadConfigV1 {
347 : #[doc(hidden)]
348 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1;
349 :
350 5 : fn guard_cf_check_function_pointer(&self) -> u64 {
351 5 : self.as_v1().guard_cf_check_function_pointer()
352 5 : }
353 :
354 5 : fn guard_cf_dispatch_function_pointer(&self) -> u64 {
355 5 : self.as_v1().guard_cf_dispatch_function_pointer()
356 5 : }
357 :
358 5 : fn guard_cf_function_table(&self) -> u64 {
359 5 : self.as_v1().guard_cf_function_table()
360 5 : }
361 :
362 5 : fn guard_cf_function_count(&self) -> u64 {
363 5 : self.as_v1().guard_cf_function_count()
364 5 : }
365 :
366 5 : fn guard_flags(&self) -> u32 {
367 5 : self.as_v1().guard_flags()
368 5 : }
369 : }
370 :
371 : impl AsBase for LoadConfigV1<'_> {
372 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
373 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
374 0 : }
375 : }
376 :
377 : impl AsLoadConfigV0 for LoadConfigV1<'_> {
378 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
379 0 : self.ptr.as_ref().unwrap().as_ref()
380 0 : }
381 : }
382 :
383 : impl AsLoadConfigV1 for LoadConfigV1<'_> {
384 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
385 0 : self.ptr.as_ref().unwrap()
386 0 : }
387 : }
388 :
389 : pub struct LoadConfigV2<'a> {
390 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV2>,
391 : _owner: PhantomData<&'a ffi::PE_Binary>,
392 : }
393 :
394 :
395 : impl std::fmt::Debug for LoadConfigV2<'_> {
396 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
397 0 : let base = self as &dyn AsLoadConfigV2;
398 0 : f.write_str(format!("{base:?}").as_str())
399 0 : }
400 : }
401 :
402 : impl std::fmt::Debug for &dyn AsLoadConfigV2 {
403 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 40 : f.debug_struct("LoadConfigV2")
405 40 : .field("code_integrity", &self.code_integrity())
406 40 : .finish()
407 40 : }
408 : }
409 :
410 :
411 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV2> for LoadConfigV2<'a> {
412 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV2>) -> Self {
413 0 : Self {
414 0 : ptr,
415 0 : _owner: PhantomData,
416 0 : }
417 0 : }
418 : }
419 :
420 :
421 : pub trait AsLoadConfigV2 {
422 : #[doc(hidden)]
423 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2;
424 :
425 5 : fn code_integrity(&self) -> CodeIntegrity {
426 5 : CodeIntegrity::from_ffi(self.as_v2().code_integrity())
427 5 : }
428 : }
429 :
430 : impl AsBase for LoadConfigV2<'_> {
431 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
432 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
433 0 : }
434 : }
435 :
436 : impl AsLoadConfigV0 for LoadConfigV2<'_> {
437 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
438 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
439 0 : }
440 : }
441 :
442 : impl AsLoadConfigV1 for LoadConfigV2<'_> {
443 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
444 0 : self.ptr.as_ref().unwrap().as_ref()
445 0 : }
446 : }
447 :
448 : impl AsLoadConfigV2 for LoadConfigV2<'_> {
449 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
450 0 : self.ptr.as_ref().unwrap()
451 0 : }
452 : }
453 :
454 : pub struct LoadConfigV3<'a> {
455 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV3>,
456 : _owner: PhantomData<&'a ffi::PE_Binary>,
457 : }
458 :
459 : impl std::fmt::Debug for LoadConfigV3<'_> {
460 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
461 0 : let base = self as &dyn AsLoadConfigV3;
462 0 : f.write_str(format!("{base:?}").as_str())
463 0 : }
464 : }
465 :
466 :
467 : impl std::fmt::Debug for &dyn AsLoadConfigV3 {
468 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
469 40 : f.debug_struct("LoadConfigV3")
470 40 : .field("guard_address_taken_iat_entry_table", &self.guard_address_taken_iat_entry_table())
471 40 : .field("guard_address_taken_iat_entry_count", &self.guard_address_taken_iat_entry_count())
472 40 : .field("guard_long_jump_target_table", &self.guard_long_jump_target_table())
473 40 : .field("guard_long_jump_target_count", &self.guard_long_jump_target_count())
474 40 : .finish()
475 40 : }
476 : }
477 :
478 :
479 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV3> for LoadConfigV3<'a> {
480 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV3>) -> Self {
481 0 : Self {
482 0 : ptr,
483 0 : _owner: PhantomData,
484 0 : }
485 0 : }
486 : }
487 :
488 :
489 : pub trait AsLoadConfigV3 {
490 : #[doc(hidden)]
491 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3;
492 :
493 5 : fn guard_address_taken_iat_entry_table(&self) -> u64 {
494 5 : self.as_v3().guard_address_taken_iat_entry_table()
495 5 : }
496 :
497 5 : fn guard_address_taken_iat_entry_count(&self) -> u64 {
498 5 : self.as_v3().guard_address_taken_iat_entry_count()
499 5 : }
500 :
501 5 : fn guard_long_jump_target_table(&self) -> u64 {
502 5 : self.as_v3().guard_long_jump_target_table()
503 5 : }
504 :
505 5 : fn guard_long_jump_target_count(&self) -> u64 {
506 5 : self.as_v3().guard_long_jump_target_count()
507 5 : }
508 : }
509 :
510 : impl AsBase for LoadConfigV3<'_> {
511 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
512 0 : self.ptr
513 0 : .as_ref()
514 0 : .unwrap()
515 0 : .as_ref()
516 0 : .as_ref()
517 0 : .as_ref()
518 0 : .as_ref()
519 0 : }
520 : }
521 :
522 : impl AsLoadConfigV0 for LoadConfigV3<'_> {
523 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
524 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
525 0 : }
526 : }
527 :
528 : impl AsLoadConfigV1 for LoadConfigV3<'_> {
529 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
530 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
531 0 : }
532 : }
533 :
534 : impl AsLoadConfigV2 for LoadConfigV3<'_> {
535 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
536 0 : self.ptr.as_ref().unwrap().as_ref()
537 0 : }
538 : }
539 :
540 : impl AsLoadConfigV3 for LoadConfigV3<'_> {
541 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
542 0 : self.ptr.as_ref().unwrap()
543 0 : }
544 : }
545 :
546 : pub struct LoadConfigV4<'a> {
547 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV4>,
548 : _owner: PhantomData<&'a ffi::PE_Binary>,
549 : }
550 :
551 : impl std::fmt::Debug for LoadConfigV4<'_> {
552 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
553 0 : let base = self as &dyn AsLoadConfigV4;
554 0 : f.write_str(format!("{base:?}").as_str())
555 0 : }
556 : }
557 :
558 :
559 : impl std::fmt::Debug for &dyn AsLoadConfigV4 {
560 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
561 40 : f.debug_struct("LoadConfigV4")
562 40 : .field("dynamic_value_reloc_table", &self.dynamic_value_reloc_table())
563 40 : .field("hybrid_metadata_pointer", &self.hybrid_metadata_pointer())
564 40 : .finish()
565 40 : }
566 : }
567 :
568 :
569 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV4> for LoadConfigV4<'a> {
570 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV4>) -> Self {
571 0 : Self {
572 0 : ptr,
573 0 : _owner: PhantomData,
574 0 : }
575 0 : }
576 : }
577 :
578 : pub trait AsLoadConfigV4 {
579 : #[doc(hidden)]
580 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4;
581 :
582 5 : fn dynamic_value_reloc_table(&self) -> u64 {
583 5 : self.as_v4().dynamic_value_reloc_table()
584 5 : }
585 :
586 5 : fn hybrid_metadata_pointer(&self) -> u64 {
587 5 : self.as_v4().hybrid_metadata_pointer()
588 5 : }
589 : }
590 :
591 : impl AsBase for LoadConfigV4<'_> {
592 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
593 0 : self.ptr
594 0 : .as_ref()
595 0 : .unwrap()
596 0 : .as_ref()
597 0 : .as_ref()
598 0 : .as_ref()
599 0 : .as_ref()
600 0 : .as_ref()
601 0 : }
602 : }
603 :
604 : impl AsLoadConfigV0 for LoadConfigV4<'_> {
605 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
606 0 : self.ptr
607 0 : .as_ref()
608 0 : .unwrap()
609 0 : .as_ref()
610 0 : .as_ref()
611 0 : .as_ref()
612 0 : .as_ref()
613 0 : }
614 : }
615 :
616 : impl AsLoadConfigV1 for LoadConfigV4<'_> {
617 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
618 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
619 0 : }
620 : }
621 :
622 : impl AsLoadConfigV2 for LoadConfigV4<'_> {
623 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
624 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
625 0 : }
626 : }
627 :
628 : impl AsLoadConfigV3 for LoadConfigV4<'_> {
629 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
630 0 : self.ptr.as_ref().unwrap().as_ref()
631 0 : }
632 : }
633 :
634 : impl AsLoadConfigV4 for LoadConfigV4<'_> {
635 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
636 0 : self.ptr.as_ref().unwrap()
637 0 : }
638 : }
639 :
640 : pub struct LoadConfigV5<'a> {
641 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV5>,
642 : _owner: PhantomData<&'a ffi::PE_Binary>,
643 : }
644 :
645 : impl std::fmt::Debug for LoadConfigV5<'_> {
646 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
647 0 : let base = self as &dyn AsLoadConfigV5;
648 0 : f.write_str(format!("{base:?}").as_str())
649 0 : }
650 : }
651 :
652 :
653 : impl std::fmt::Debug for &dyn AsLoadConfigV5 {
654 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
655 40 : f.debug_struct("LoadConfigV5")
656 40 : .field("guard_rf_failure_routine", &self.guard_rf_failure_routine())
657 40 : .field("guard_rf_failure_routine_function_pointer", &self.guard_rf_failure_routine_function_pointer())
658 40 : .field("dynamic_value_reloctable_offset", &self.dynamic_value_reloctable_offset())
659 40 : .field("dynamic_value_reloctable_section", &self.dynamic_value_reloctable_section())
660 40 : .field("reserved2", &self.reserved2())
661 40 : .finish()
662 40 : }
663 : }
664 :
665 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV5> for LoadConfigV5<'a> {
666 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV5>) -> Self {
667 0 : Self {
668 0 : ptr,
669 0 : _owner: PhantomData,
670 0 : }
671 0 : }
672 : }
673 :
674 : pub trait AsLoadConfigV5 {
675 : #[doc(hidden)]
676 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5;
677 :
678 5 : fn guard_rf_failure_routine(&self) -> u64 {
679 5 : self.as_v5().guard_rf_failure_routine()
680 5 : }
681 :
682 5 : fn guard_rf_failure_routine_function_pointer(&self) -> u64 {
683 5 : self.as_v5().guard_rf_failure_routine_function_pointer()
684 5 : }
685 :
686 5 : fn dynamic_value_reloctable_offset(&self) -> u32 {
687 5 : self.as_v5().dynamic_value_reloctable_offset()
688 5 : }
689 :
690 5 : fn dynamic_value_reloctable_section(&self) -> u16 {
691 5 : self.as_v5().dynamic_value_reloctable_section()
692 5 : }
693 :
694 5 : fn reserved2(&self) -> u16 {
695 5 : self.as_v5().reserved2()
696 5 : }
697 : }
698 :
699 : impl AsBase for LoadConfigV5<'_> {
700 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
701 0 : self.ptr
702 0 : .as_ref()
703 0 : .unwrap()
704 0 : .as_ref()
705 0 : .as_ref()
706 0 : .as_ref()
707 0 : .as_ref()
708 0 : .as_ref()
709 0 : .as_ref()
710 0 : }
711 : }
712 :
713 : impl AsLoadConfigV0 for LoadConfigV5<'_> {
714 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
715 0 : self.ptr
716 0 : .as_ref()
717 0 : .unwrap()
718 0 : .as_ref()
719 0 : .as_ref()
720 0 : .as_ref()
721 0 : .as_ref()
722 0 : .as_ref()
723 0 : }
724 : }
725 :
726 : impl AsLoadConfigV1 for LoadConfigV5<'_> {
727 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
728 0 : self.ptr
729 0 : .as_ref()
730 0 : .unwrap()
731 0 : .as_ref()
732 0 : .as_ref()
733 0 : .as_ref()
734 0 : .as_ref()
735 0 : }
736 : }
737 :
738 : impl AsLoadConfigV2 for LoadConfigV5<'_> {
739 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
740 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
741 0 : }
742 : }
743 :
744 : impl AsLoadConfigV3 for LoadConfigV5<'_> {
745 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
746 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
747 0 : }
748 : }
749 :
750 : impl AsLoadConfigV4 for LoadConfigV5<'_> {
751 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
752 0 : self.ptr.as_ref().unwrap().as_ref()
753 0 : }
754 : }
755 :
756 : impl AsLoadConfigV5 for LoadConfigV5<'_> {
757 0 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
758 0 : self.ptr.as_ref().unwrap()
759 0 : }
760 : }
761 :
762 : pub struct LoadConfigV6<'a> {
763 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV6>,
764 : _owner: PhantomData<&'a ffi::PE_Binary>,
765 : }
766 :
767 : impl std::fmt::Debug for LoadConfigV6<'_> {
768 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
769 0 : let base = self as &dyn AsLoadConfigV6;
770 0 : f.write_str(format!("{base:?}").as_str())
771 0 : }
772 : }
773 :
774 :
775 : impl std::fmt::Debug for &dyn AsLoadConfigV6 {
776 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
777 40 : f.debug_struct("LoadConfigV6")
778 40 : .field("guard_rf_verify_stackpointer_function_pointer", &self.guard_rf_verify_stackpointer_function_pointer())
779 40 : .field("hotpatch_table_offset", &self.hotpatch_table_offset())
780 40 : .finish()
781 40 : }
782 : }
783 :
784 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV6> for LoadConfigV6<'a> {
785 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV6>) -> Self {
786 0 : Self {
787 0 : ptr,
788 0 : _owner: PhantomData,
789 0 : }
790 0 : }
791 : }
792 :
793 : pub trait AsLoadConfigV6 {
794 : #[doc(hidden)]
795 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6;
796 :
797 5 : fn guard_rf_verify_stackpointer_function_pointer(&self) -> u64 {
798 5 : self.as_v6().guard_rf_verify_stackpointer_function_pointer()
799 5 : }
800 :
801 5 : fn hotpatch_table_offset(&self) -> u32 {
802 5 : self.as_v6().hotpatch_table_offset()
803 5 : }
804 : }
805 :
806 : impl AsBase for LoadConfigV6<'_> {
807 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
808 0 : self.ptr
809 0 : .as_ref()
810 0 : .unwrap()
811 0 : .as_ref()
812 0 : .as_ref()
813 0 : .as_ref()
814 0 : .as_ref()
815 0 : .as_ref()
816 0 : .as_ref()
817 0 : .as_ref()
818 0 : }
819 : }
820 :
821 : impl AsLoadConfigV0 for LoadConfigV6<'_> {
822 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
823 0 : self.ptr
824 0 : .as_ref()
825 0 : .unwrap()
826 0 : .as_ref()
827 0 : .as_ref()
828 0 : .as_ref()
829 0 : .as_ref()
830 0 : .as_ref()
831 0 : .as_ref()
832 0 : }
833 : }
834 :
835 : impl AsLoadConfigV1 for LoadConfigV6<'_> {
836 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
837 0 : self.ptr
838 0 : .as_ref()
839 0 : .unwrap()
840 0 : .as_ref()
841 0 : .as_ref()
842 0 : .as_ref()
843 0 : .as_ref()
844 0 : .as_ref()
845 0 : }
846 : }
847 :
848 : impl AsLoadConfigV2 for LoadConfigV6<'_> {
849 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
850 0 : self.ptr
851 0 : .as_ref()
852 0 : .unwrap()
853 0 : .as_ref()
854 0 : .as_ref()
855 0 : .as_ref()
856 0 : .as_ref()
857 0 : }
858 : }
859 :
860 : impl AsLoadConfigV3 for LoadConfigV6<'_> {
861 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
862 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
863 0 : }
864 : }
865 :
866 : impl AsLoadConfigV4 for LoadConfigV6<'_> {
867 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
868 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
869 0 : }
870 : }
871 :
872 : impl AsLoadConfigV5 for LoadConfigV6<'_> {
873 0 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
874 0 : self.ptr.as_ref().unwrap().as_ref()
875 0 : }
876 : }
877 :
878 : impl AsLoadConfigV6 for LoadConfigV6<'_> {
879 0 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
880 0 : self.ptr.as_ref().unwrap()
881 0 : }
882 : }
883 :
884 : pub struct LoadConfigV7<'a> {
885 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV7>,
886 : _owner: PhantomData<&'a ffi::PE_Binary>,
887 : }
888 :
889 :
890 : impl std::fmt::Debug for LoadConfigV7<'_> {
891 16 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
892 16 : let base = self as &dyn AsLoadConfigV7;
893 16 : f.write_str(format!("{base:?}").as_str())
894 16 : }
895 : }
896 :
897 :
898 : impl std::fmt::Debug for &dyn AsLoadConfigV7 {
899 48 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
900 48 : f.debug_struct("LoadConfigV7")
901 48 : .field("reserved3", &self.reserved3())
902 48 : .field("addressof_unicode_string", &self.addressof_unicode_string())
903 48 : .finish()
904 48 : }
905 : }
906 :
907 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV7> for LoadConfigV7<'a> {
908 8 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV7>) -> Self {
909 8 : Self {
910 8 : ptr,
911 8 : _owner: PhantomData,
912 8 : }
913 8 : }
914 : }
915 :
916 : pub trait AsLoadConfigV7 {
917 : #[doc(hidden)]
918 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7;
919 :
920 20 : fn reserved3(&self) -> u32 {
921 20 : self.as_v7().reserved3()
922 20 : }
923 :
924 20 : fn addressof_unicode_string(&self) -> u64 {
925 20 : self.as_v7().addressof_unicode_string()
926 20 : }
927 : }
928 :
929 : impl AsBase for LoadConfigV7<'_> {
930 152 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
931 152 : self.ptr
932 152 : .as_ref()
933 152 : .unwrap()
934 152 : .as_ref()
935 152 : .as_ref()
936 152 : .as_ref()
937 152 : .as_ref()
938 152 : .as_ref()
939 152 : .as_ref()
940 152 : .as_ref()
941 152 : .as_ref()
942 152 : }
943 : }
944 :
945 : impl AsLoadConfigV0 for LoadConfigV7<'_> {
946 16 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
947 16 : self.ptr
948 16 : .as_ref()
949 16 : .unwrap()
950 16 : .as_ref()
951 16 : .as_ref()
952 16 : .as_ref()
953 16 : .as_ref()
954 16 : .as_ref()
955 16 : .as_ref()
956 16 : .as_ref()
957 16 : }
958 : }
959 :
960 : impl AsLoadConfigV1 for LoadConfigV7<'_> {
961 40 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
962 40 : self.ptr
963 40 : .as_ref()
964 40 : .unwrap()
965 40 : .as_ref()
966 40 : .as_ref()
967 40 : .as_ref()
968 40 : .as_ref()
969 40 : .as_ref()
970 40 : .as_ref()
971 40 : }
972 : }
973 :
974 : impl AsLoadConfigV2 for LoadConfigV7<'_> {
975 8 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
976 8 : self.ptr
977 8 : .as_ref()
978 8 : .unwrap()
979 8 : .as_ref()
980 8 : .as_ref()
981 8 : .as_ref()
982 8 : .as_ref()
983 8 : .as_ref()
984 8 : }
985 : }
986 :
987 : impl AsLoadConfigV3 for LoadConfigV7<'_> {
988 32 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
989 32 : self.ptr
990 32 : .as_ref()
991 32 : .unwrap()
992 32 : .as_ref()
993 32 : .as_ref()
994 32 : .as_ref()
995 32 : .as_ref()
996 32 : }
997 : }
998 :
999 : impl AsLoadConfigV4 for LoadConfigV7<'_> {
1000 16 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1001 16 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1002 16 : }
1003 : }
1004 :
1005 : impl AsLoadConfigV5 for LoadConfigV7<'_> {
1006 40 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1007 40 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1008 40 : }
1009 : }
1010 :
1011 : impl AsLoadConfigV6 for LoadConfigV7<'_> {
1012 16 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1013 16 : self.ptr.as_ref().unwrap().as_ref()
1014 16 : }
1015 : }
1016 :
1017 : impl AsLoadConfigV7 for LoadConfigV7<'_> {
1018 32 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1019 32 : self.ptr.as_ref().unwrap()
1020 32 : }
1021 : }
1022 :
1023 : pub struct LoadConfigV8<'a> {
1024 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV8>,
1025 : _owner: PhantomData<&'a ffi::PE_Binary>,
1026 : }
1027 :
1028 :
1029 : impl std::fmt::Debug for LoadConfigV8<'_> {
1030 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1031 0 : let base = self as &dyn AsLoadConfigV8;
1032 0 : f.write_str(format!("{base:?}").as_str())
1033 0 : }
1034 : }
1035 :
1036 :
1037 : impl std::fmt::Debug for &dyn AsLoadConfigV8 {
1038 32 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1039 32 : f.debug_struct("LoadConfigV8")
1040 32 : .field("volatile_metadata_pointer", &self.volatile_metadata_pointer())
1041 32 : .finish()
1042 32 : }
1043 : }
1044 :
1045 :
1046 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV8> for LoadConfigV8<'a> {
1047 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV8>) -> Self {
1048 0 : Self {
1049 0 : ptr,
1050 0 : _owner: PhantomData,
1051 0 : }
1052 0 : }
1053 : }
1054 :
1055 : pub trait AsLoadConfigV8 {
1056 : #[doc(hidden)]
1057 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8;
1058 :
1059 4 : fn volatile_metadata_pointer(&self) -> u64 {
1060 4 : self.as_v8().volatile_metadata_pointer()
1061 4 : }
1062 : }
1063 :
1064 : impl AsBase for LoadConfigV8<'_> {
1065 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
1066 0 : self.ptr
1067 0 : .as_ref()
1068 0 : .unwrap()
1069 0 : .as_ref()
1070 0 : .as_ref()
1071 0 : .as_ref()
1072 0 : .as_ref()
1073 0 : .as_ref()
1074 0 : .as_ref()
1075 0 : .as_ref()
1076 0 : .as_ref()
1077 0 : .as_ref()
1078 0 : }
1079 : }
1080 :
1081 : impl AsLoadConfigV0 for LoadConfigV8<'_> {
1082 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
1083 0 : self.ptr
1084 0 : .as_ref()
1085 0 : .unwrap()
1086 0 : .as_ref()
1087 0 : .as_ref()
1088 0 : .as_ref()
1089 0 : .as_ref()
1090 0 : .as_ref()
1091 0 : .as_ref()
1092 0 : .as_ref()
1093 0 : .as_ref()
1094 0 : }
1095 : }
1096 :
1097 : impl AsLoadConfigV1 for LoadConfigV8<'_> {
1098 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
1099 0 : self.ptr
1100 0 : .as_ref()
1101 0 : .unwrap()
1102 0 : .as_ref()
1103 0 : .as_ref()
1104 0 : .as_ref()
1105 0 : .as_ref()
1106 0 : .as_ref()
1107 0 : .as_ref()
1108 0 : .as_ref()
1109 0 : }
1110 : }
1111 :
1112 : impl AsLoadConfigV2 for LoadConfigV8<'_> {
1113 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
1114 0 : self.ptr
1115 0 : .as_ref()
1116 0 : .unwrap()
1117 0 : .as_ref()
1118 0 : .as_ref()
1119 0 : .as_ref()
1120 0 : .as_ref()
1121 0 : .as_ref()
1122 0 : .as_ref()
1123 0 : }
1124 : }
1125 :
1126 : impl AsLoadConfigV3 for LoadConfigV8<'_> {
1127 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
1128 0 : self.ptr
1129 0 : .as_ref()
1130 0 : .unwrap()
1131 0 : .as_ref()
1132 0 : .as_ref()
1133 0 : .as_ref()
1134 0 : .as_ref()
1135 0 : .as_ref()
1136 0 : }
1137 : }
1138 :
1139 : impl AsLoadConfigV4 for LoadConfigV8<'_> {
1140 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1141 0 : self.ptr
1142 0 : .as_ref()
1143 0 : .unwrap()
1144 0 : .as_ref()
1145 0 : .as_ref()
1146 0 : .as_ref()
1147 0 : .as_ref()
1148 0 : }
1149 : }
1150 :
1151 : impl AsLoadConfigV5 for LoadConfigV8<'_> {
1152 0 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1153 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1154 0 : }
1155 : }
1156 :
1157 : impl AsLoadConfigV6 for LoadConfigV8<'_> {
1158 0 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1159 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1160 0 : }
1161 : }
1162 :
1163 : impl AsLoadConfigV7 for LoadConfigV8<'_> {
1164 0 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1165 0 : self.ptr.as_ref().unwrap().as_ref()
1166 0 : }
1167 : }
1168 :
1169 : impl AsLoadConfigV8 for LoadConfigV8<'_> {
1170 0 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
1171 0 : self.ptr.as_ref().unwrap()
1172 0 : }
1173 : }
1174 :
1175 : pub struct LoadConfigV9<'a> {
1176 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV9>,
1177 : _owner: PhantomData<&'a ffi::PE_Binary>,
1178 : }
1179 :
1180 : impl std::fmt::Debug for LoadConfigV9<'_> {
1181 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1182 0 : let base = self as &dyn AsLoadConfigV9;
1183 0 : f.write_str(format!("{base:?}").as_str())
1184 0 : }
1185 : }
1186 :
1187 :
1188 : impl std::fmt::Debug for &dyn AsLoadConfigV9 {
1189 32 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1190 32 : f.debug_struct("LoadConfigV9")
1191 32 : .field("guard_eh_continuation_table", &self.guard_eh_continuation_table())
1192 32 : .field("guard_eh_continuation_count", &self.guard_eh_continuation_count())
1193 32 : .finish()
1194 32 : }
1195 : }
1196 :
1197 :
1198 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV9> for LoadConfigV9<'a> {
1199 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV9>) -> Self {
1200 0 : Self {
1201 0 : ptr,
1202 0 : _owner: PhantomData,
1203 0 : }
1204 0 : }
1205 : }
1206 :
1207 : pub trait AsLoadConfigV9 {
1208 : #[doc(hidden)]
1209 : fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9;
1210 :
1211 4 : fn guard_eh_continuation_table(&self) -> u64 {
1212 4 : self.as_v9().guard_eh_continuation_table()
1213 4 : }
1214 :
1215 4 : fn guard_eh_continuation_count(&self) -> u64 {
1216 4 : self.as_v9().guard_eh_continuation_count()
1217 4 : }
1218 : }
1219 :
1220 : impl AsBase for LoadConfigV9<'_> {
1221 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
1222 0 : self.ptr
1223 0 : .as_ref()
1224 0 : .unwrap()
1225 0 : .as_ref()
1226 0 : .as_ref()
1227 0 : .as_ref()
1228 0 : .as_ref()
1229 0 : .as_ref()
1230 0 : .as_ref()
1231 0 : .as_ref()
1232 0 : .as_ref()
1233 0 : .as_ref()
1234 0 : .as_ref()
1235 0 : }
1236 : }
1237 :
1238 : impl AsLoadConfigV0 for LoadConfigV9<'_> {
1239 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
1240 0 : self.ptr
1241 0 : .as_ref()
1242 0 : .unwrap()
1243 0 : .as_ref()
1244 0 : .as_ref()
1245 0 : .as_ref()
1246 0 : .as_ref()
1247 0 : .as_ref()
1248 0 : .as_ref()
1249 0 : .as_ref()
1250 0 : .as_ref()
1251 0 : .as_ref()
1252 0 : }
1253 : }
1254 :
1255 : impl AsLoadConfigV1 for LoadConfigV9<'_> {
1256 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
1257 0 : self.ptr
1258 0 : .as_ref()
1259 0 : .unwrap()
1260 0 : .as_ref()
1261 0 : .as_ref()
1262 0 : .as_ref()
1263 0 : .as_ref()
1264 0 : .as_ref()
1265 0 : .as_ref()
1266 0 : .as_ref()
1267 0 : .as_ref()
1268 0 : }
1269 : }
1270 :
1271 : impl AsLoadConfigV2 for LoadConfigV9<'_> {
1272 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
1273 0 : self.ptr
1274 0 : .as_ref()
1275 0 : .unwrap()
1276 0 : .as_ref()
1277 0 : .as_ref()
1278 0 : .as_ref()
1279 0 : .as_ref()
1280 0 : .as_ref()
1281 0 : .as_ref()
1282 0 : .as_ref()
1283 0 : }
1284 : }
1285 :
1286 : impl AsLoadConfigV3 for LoadConfigV9<'_> {
1287 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
1288 0 : self.ptr
1289 0 : .as_ref()
1290 0 : .unwrap()
1291 0 : .as_ref()
1292 0 : .as_ref()
1293 0 : .as_ref()
1294 0 : .as_ref()
1295 0 : .as_ref()
1296 0 : .as_ref()
1297 0 : }
1298 : }
1299 :
1300 : impl AsLoadConfigV4 for LoadConfigV9<'_> {
1301 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1302 0 : self.ptr
1303 0 : .as_ref()
1304 0 : .unwrap()
1305 0 : .as_ref()
1306 0 : .as_ref()
1307 0 : .as_ref()
1308 0 : .as_ref()
1309 0 : .as_ref()
1310 0 : }
1311 : }
1312 :
1313 : impl AsLoadConfigV5 for LoadConfigV9<'_> {
1314 0 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1315 0 : self.ptr
1316 0 : .as_ref()
1317 0 : .unwrap()
1318 0 : .as_ref()
1319 0 : .as_ref()
1320 0 : .as_ref()
1321 0 : .as_ref()
1322 0 : }
1323 : }
1324 :
1325 : impl AsLoadConfigV6 for LoadConfigV9<'_> {
1326 0 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1327 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1328 0 : }
1329 : }
1330 :
1331 : impl AsLoadConfigV7 for LoadConfigV9<'_> {
1332 0 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1333 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1334 0 : }
1335 : }
1336 :
1337 : impl AsLoadConfigV8 for LoadConfigV9<'_> {
1338 0 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
1339 0 : self.ptr.as_ref().unwrap().as_ref()
1340 0 : }
1341 : }
1342 :
1343 : impl AsLoadConfigV9 for LoadConfigV9<'_> {
1344 0 : fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
1345 0 : self.ptr.as_ref().unwrap()
1346 0 : }
1347 : }
1348 :
1349 : pub struct LoadConfigV10<'a> {
1350 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV10>,
1351 : _owner: PhantomData<&'a ffi::PE_Binary>,
1352 : }
1353 :
1354 : impl std::fmt::Debug for LoadConfigV10<'_> {
1355 0 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1356 0 : let base = self as &dyn AsLoadConfigV10;
1357 0 : f.write_str(format!("{base:?}").as_str())
1358 0 : }
1359 : }
1360 :
1361 : impl std::fmt::Debug for &dyn AsLoadConfigV10 {
1362 32 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1363 32 : f.debug_struct("LoadConfigV10")
1364 32 : .field("guard_xfg_check_function_pointer", &self.guard_xfg_check_function_pointer())
1365 32 : .field("guard_xfg_dispatch_function_pointer", &self.guard_xfg_dispatch_function_pointer())
1366 32 : .field("guard_xfg_table_dispatch_function_pointer", &self.guard_xfg_table_dispatch_function_pointer())
1367 32 : .finish()
1368 32 : }
1369 : }
1370 :
1371 :
1372 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV10> for LoadConfigV10<'a> {
1373 0 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV10>) -> Self {
1374 0 : Self {
1375 0 : ptr,
1376 0 : _owner: PhantomData,
1377 0 : }
1378 0 : }
1379 : }
1380 :
1381 : pub trait AsLoadConfigV10 {
1382 : #[doc(hidden)]
1383 : fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10;
1384 :
1385 4 : fn guard_xfg_check_function_pointer(&self) -> u64 {
1386 4 : self.as_v10().guard_xfg_check_function_pointer()
1387 4 : }
1388 :
1389 4 : fn guard_xfg_dispatch_function_pointer(&self) -> u64 {
1390 4 : self.as_v10().guard_xfg_dispatch_function_pointer()
1391 4 : }
1392 :
1393 4 : fn guard_xfg_table_dispatch_function_pointer(&self) -> u64 {
1394 4 : self.as_v10().guard_xfg_table_dispatch_function_pointer()
1395 4 : }
1396 : }
1397 :
1398 : impl AsBase for LoadConfigV10<'_> {
1399 0 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
1400 0 : self.ptr
1401 0 : .as_ref()
1402 0 : .unwrap()
1403 0 : .as_ref()
1404 0 : .as_ref()
1405 0 : .as_ref()
1406 0 : .as_ref()
1407 0 : .as_ref()
1408 0 : .as_ref()
1409 0 : .as_ref()
1410 0 : .as_ref()
1411 0 : .as_ref()
1412 0 : .as_ref()
1413 0 : .as_ref()
1414 0 : }
1415 : }
1416 :
1417 : impl AsLoadConfigV0 for LoadConfigV10<'_> {
1418 0 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
1419 0 : self.ptr
1420 0 : .as_ref()
1421 0 : .unwrap()
1422 0 : .as_ref()
1423 0 : .as_ref()
1424 0 : .as_ref()
1425 0 : .as_ref()
1426 0 : .as_ref()
1427 0 : .as_ref()
1428 0 : .as_ref()
1429 0 : .as_ref()
1430 0 : .as_ref()
1431 0 : .as_ref()
1432 0 : }
1433 : }
1434 :
1435 : impl AsLoadConfigV1 for LoadConfigV10<'_> {
1436 0 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
1437 0 : self.ptr
1438 0 : .as_ref()
1439 0 : .unwrap()
1440 0 : .as_ref()
1441 0 : .as_ref()
1442 0 : .as_ref()
1443 0 : .as_ref()
1444 0 : .as_ref()
1445 0 : .as_ref()
1446 0 : .as_ref()
1447 0 : .as_ref()
1448 0 : .as_ref()
1449 0 : }
1450 : }
1451 :
1452 : impl AsLoadConfigV2 for LoadConfigV10<'_> {
1453 0 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
1454 0 : self.ptr
1455 0 : .as_ref()
1456 0 : .unwrap()
1457 0 : .as_ref()
1458 0 : .as_ref()
1459 0 : .as_ref()
1460 0 : .as_ref()
1461 0 : .as_ref()
1462 0 : .as_ref()
1463 0 : .as_ref()
1464 0 : .as_ref()
1465 0 : }
1466 : }
1467 :
1468 : impl AsLoadConfigV3 for LoadConfigV10<'_> {
1469 0 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
1470 0 : self.ptr
1471 0 : .as_ref()
1472 0 : .unwrap()
1473 0 : .as_ref()
1474 0 : .as_ref()
1475 0 : .as_ref()
1476 0 : .as_ref()
1477 0 : .as_ref()
1478 0 : .as_ref()
1479 0 : .as_ref()
1480 0 : }
1481 : }
1482 :
1483 : impl AsLoadConfigV4 for LoadConfigV10<'_> {
1484 0 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1485 0 : self.ptr
1486 0 : .as_ref()
1487 0 : .unwrap()
1488 0 : .as_ref()
1489 0 : .as_ref()
1490 0 : .as_ref()
1491 0 : .as_ref()
1492 0 : .as_ref()
1493 0 : .as_ref()
1494 0 : }
1495 : }
1496 :
1497 : impl AsLoadConfigV5 for LoadConfigV10<'_> {
1498 0 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1499 0 : self.ptr
1500 0 : .as_ref()
1501 0 : .unwrap()
1502 0 : .as_ref()
1503 0 : .as_ref()
1504 0 : .as_ref()
1505 0 : .as_ref()
1506 0 : .as_ref()
1507 0 : }
1508 : }
1509 :
1510 : impl AsLoadConfigV6 for LoadConfigV10<'_> {
1511 0 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1512 0 : self.ptr
1513 0 : .as_ref()
1514 0 : .unwrap()
1515 0 : .as_ref()
1516 0 : .as_ref()
1517 0 : .as_ref()
1518 0 : .as_ref()
1519 0 : }
1520 : }
1521 :
1522 : impl AsLoadConfigV7 for LoadConfigV10<'_> {
1523 0 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1524 0 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1525 0 : }
1526 : }
1527 :
1528 : impl AsLoadConfigV8 for LoadConfigV10<'_> {
1529 0 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
1530 0 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1531 0 : }
1532 : }
1533 :
1534 : impl AsLoadConfigV9 for LoadConfigV10<'_> {
1535 0 : fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
1536 0 : self.ptr.as_ref().unwrap().as_ref()
1537 0 : }
1538 : }
1539 :
1540 : impl AsLoadConfigV10 for LoadConfigV10<'_> {
1541 0 : fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10 {
1542 0 : self.ptr.as_ref().unwrap()
1543 0 : }
1544 : }
1545 :
1546 : pub struct LoadConfigV11<'a> {
1547 : ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV11>,
1548 : _owner: PhantomData<&'a ffi::PE_Binary>,
1549 : }
1550 :
1551 : impl std::fmt::Debug for LoadConfigV11<'_> {
1552 64 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1553 64 : let base = self as &dyn AsLoadConfigV11;
1554 64 : f.write_str(format!("{base:?}").as_str())
1555 64 : }
1556 : }
1557 :
1558 : impl std::fmt::Debug for &dyn AsLoadConfigV11 {
1559 64 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560 64 : f.debug_struct("LoadConfigV11")
1561 64 : .field("cast_guard_os_determined_failure_mode", &self.cast_guard_os_determined_failure_mode())
1562 64 : .finish()
1563 64 : }
1564 : }
1565 :
1566 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV11> for LoadConfigV11<'a> {
1567 32 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV11>) -> Self {
1568 32 : Self {
1569 32 : ptr,
1570 32 : _owner: PhantomData,
1571 32 : }
1572 32 : }
1573 : }
1574 :
1575 : pub trait AsLoadConfigV11 {
1576 : #[doc(hidden)]
1577 : fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11;
1578 :
1579 64 : fn cast_guard_os_determined_failure_mode(&self) -> u64 {
1580 64 : self.as_v11().cast_guard_os_determined_failure_mode()
1581 64 : }
1582 : }
1583 :
1584 : impl AsBase for LoadConfigV11<'_> {
1585 608 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
1586 608 : self.ptr
1587 608 : .as_ref()
1588 608 : .unwrap()
1589 608 : .as_ref()
1590 608 : .as_ref()
1591 608 : .as_ref()
1592 608 : .as_ref()
1593 608 : .as_ref()
1594 608 : .as_ref()
1595 608 : .as_ref()
1596 608 : .as_ref()
1597 608 : .as_ref()
1598 608 : .as_ref()
1599 608 : .as_ref()
1600 608 : .as_ref()
1601 608 : }
1602 : }
1603 :
1604 : impl AsLoadConfigV0 for LoadConfigV11<'_> {
1605 64 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
1606 64 : self.ptr
1607 64 : .as_ref()
1608 64 : .unwrap()
1609 64 : .as_ref()
1610 64 : .as_ref()
1611 64 : .as_ref()
1612 64 : .as_ref()
1613 64 : .as_ref()
1614 64 : .as_ref()
1615 64 : .as_ref()
1616 64 : .as_ref()
1617 64 : .as_ref()
1618 64 : .as_ref()
1619 64 : .as_ref()
1620 64 : }
1621 : }
1622 :
1623 : impl AsLoadConfigV1 for LoadConfigV11<'_> {
1624 160 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
1625 160 : self.ptr
1626 160 : .as_ref()
1627 160 : .unwrap()
1628 160 : .as_ref()
1629 160 : .as_ref()
1630 160 : .as_ref()
1631 160 : .as_ref()
1632 160 : .as_ref()
1633 160 : .as_ref()
1634 160 : .as_ref()
1635 160 : .as_ref()
1636 160 : .as_ref()
1637 160 : .as_ref()
1638 160 : }
1639 : }
1640 :
1641 : impl AsLoadConfigV2 for LoadConfigV11<'_> {
1642 32 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
1643 32 : self.ptr
1644 32 : .as_ref()
1645 32 : .unwrap()
1646 32 : .as_ref()
1647 32 : .as_ref()
1648 32 : .as_ref()
1649 32 : .as_ref()
1650 32 : .as_ref()
1651 32 : .as_ref()
1652 32 : .as_ref()
1653 32 : .as_ref()
1654 32 : .as_ref()
1655 32 : }
1656 : }
1657 :
1658 : impl AsLoadConfigV3 for LoadConfigV11<'_> {
1659 128 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
1660 128 : self.ptr
1661 128 : .as_ref()
1662 128 : .unwrap()
1663 128 : .as_ref()
1664 128 : .as_ref()
1665 128 : .as_ref()
1666 128 : .as_ref()
1667 128 : .as_ref()
1668 128 : .as_ref()
1669 128 : .as_ref()
1670 128 : .as_ref()
1671 128 : }
1672 : }
1673 :
1674 : impl AsLoadConfigV4 for LoadConfigV11<'_> {
1675 64 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1676 64 : self.ptr
1677 64 : .as_ref()
1678 64 : .unwrap()
1679 64 : .as_ref()
1680 64 : .as_ref()
1681 64 : .as_ref()
1682 64 : .as_ref()
1683 64 : .as_ref()
1684 64 : .as_ref()
1685 64 : .as_ref()
1686 64 : }
1687 : }
1688 :
1689 : impl AsLoadConfigV5 for LoadConfigV11<'_> {
1690 160 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1691 160 : self.ptr
1692 160 : .as_ref()
1693 160 : .unwrap()
1694 160 : .as_ref()
1695 160 : .as_ref()
1696 160 : .as_ref()
1697 160 : .as_ref()
1698 160 : .as_ref()
1699 160 : .as_ref()
1700 160 : }
1701 : }
1702 :
1703 : impl AsLoadConfigV6 for LoadConfigV11<'_> {
1704 64 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1705 64 : self.ptr
1706 64 : .as_ref()
1707 64 : .unwrap()
1708 64 : .as_ref()
1709 64 : .as_ref()
1710 64 : .as_ref()
1711 64 : .as_ref()
1712 64 : .as_ref()
1713 64 : }
1714 : }
1715 :
1716 : impl AsLoadConfigV7 for LoadConfigV11<'_> {
1717 64 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1718 64 : self.ptr
1719 64 : .as_ref()
1720 64 : .unwrap()
1721 64 : .as_ref()
1722 64 : .as_ref()
1723 64 : .as_ref()
1724 64 : .as_ref()
1725 64 : }
1726 : }
1727 :
1728 : impl AsLoadConfigV8 for LoadConfigV11<'_> {
1729 32 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
1730 32 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1731 32 : }
1732 : }
1733 :
1734 : impl AsLoadConfigV9 for LoadConfigV11<'_> {
1735 64 : fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
1736 64 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1737 64 : }
1738 : }
1739 :
1740 : impl AsLoadConfigV10 for LoadConfigV11<'_> {
1741 96 : fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10 {
1742 96 : self.ptr.as_ref().unwrap().as_ref()
1743 96 : }
1744 : }
1745 :
1746 : impl AsLoadConfigV11 for LoadConfigV11<'_> {
1747 64 : fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11 {
1748 64 : self.ptr.as_ref().unwrap()
1749 64 : }
1750 : }
|
