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 50 : #[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 50 : fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::PE_LoadConfiguration>) -> Self {
26 50 : unsafe {
27 50 : let config_ref = ffi_entry.as_ref().unwrap();
28 50 :
29 50 : 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 50 : } 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 50 : } 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 50 : } 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 50 : } 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 50 : } 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 50 : } 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 50 : } else if ffi::PE_LoadConfigurationV7::classof(config_ref) {
79 10 : let raw = {
80 10 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
81 10 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV7>;
82 10 : std::mem::transmute::<From, To>(ffi_entry)
83 10 : };
84 10 : LoadConfiguration::V7(LoadConfigV7::from_ffi(raw))
85 40 : } 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 40 : } 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 40 : } 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 40 : } else if ffi::PE_LoadConfigurationV11::classof(config_ref) {
107 40 : let raw = {
108 40 : type From = cxx::UniquePtr<ffi::PE_LoadConfiguration>;
109 40 : type To = cxx::UniquePtr<ffi::PE_LoadConfigurationV11>;
110 40 : std::mem::transmute::<From, To>(ffi_entry)
111 40 : };
112 40 : LoadConfiguration::V11(LoadConfigV11::from_ffi(raw))
113 : } else {
114 0 : LoadConfiguration::Base(Base::from_ffi(ffi_entry))
115 : }
116 : }
117 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
134 50 : f.debug_struct("Base")
135 50 : .field("characteristics", &self.characteristics())
136 50 : .field("timedatestamp", &self.timedatestamp())
137 50 : .field("major_version", &self.major_version())
138 50 : .field("minor_version", &self.minor_version())
139 50 : .field("global_flags_clear", &self.global_flags_clear())
140 50 : .field("global_flags_set", &self.global_flags_set())
141 50 : .field("critical_section_default_timeout", &self.critical_section_default_timeout())
142 50 : .field("decommit_free_block_threshold", &self.decommit_free_block_threshold())
143 50 : .field("decommit_total_free_threshold", &self.decommit_total_free_threshold())
144 50 : .field("lock_prefix_table", &self.lock_prefix_table())
145 50 : .field("maximum_allocation_size", &self.maximum_allocation_size())
146 50 : .field("virtual_memory_threshold", &self.virtual_memory_threshold())
147 50 : .field("process_affinity_mask", &self.process_affinity_mask())
148 50 : .field("process_heap_flags", &self.process_heap_flags())
149 50 : .field("csd_version", &self.csd_version())
150 50 : .field("reserved1", &self.reserved1())
151 50 : .field("dependent_load_flags", &self.dependent_load_flags())
152 50 : .field("editlist", &self.editlist())
153 50 : .field("security_cookie", &self.security_cookie())
154 50 : .finish()
155 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 50 : f.debug_struct("LoadConfigV0")
273 50 : .field("se_handler_table", &self.se_handler_table())
274 50 : .field("se_handler_count", &self.se_handler_count())
275 50 : .finish()
276 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
336 50 : f.debug_struct("LoadConfigV1")
337 50 : .field("guard_cf_check_function_pointer", &self.guard_cf_check_function_pointer())
338 50 : .field("guard_cf_dispatch_function_pointer", &self.guard_cf_dispatch_function_pointer())
339 50 : .field("guard_cf_function_table", &self.guard_cf_function_table())
340 50 : .field("guard_cf_function_count", &self.guard_cf_function_count())
341 50 : .field("guard_flags", &self.guard_flags())
342 50 : .finish()
343 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 50 : f.debug_struct("LoadConfigV2")
405 50 : .field("code_integrity", &self.code_integrity())
406 50 : .finish()
407 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
469 50 : f.debug_struct("LoadConfigV3")
470 50 : .field("guard_address_taken_iat_entry_table", &self.guard_address_taken_iat_entry_table())
471 50 : .field("guard_address_taken_iat_entry_count", &self.guard_address_taken_iat_entry_count())
472 50 : .field("guard_long_jump_target_table", &self.guard_long_jump_target_table())
473 50 : .field("guard_long_jump_target_count", &self.guard_long_jump_target_count())
474 50 : .finish()
475 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
561 50 : f.debug_struct("LoadConfigV4")
562 50 : .field("dynamic_value_reloc_table", &self.dynamic_value_reloc_table())
563 50 : .field("hybrid_metadata_pointer", &self.hybrid_metadata_pointer())
564 50 : .finish()
565 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
655 50 : f.debug_struct("LoadConfigV5")
656 50 : .field("guard_rf_failure_routine", &self.guard_rf_failure_routine())
657 50 : .field("guard_rf_failure_routine_function_pointer", &self.guard_rf_failure_routine_function_pointer())
658 50 : .field("dynamic_value_reloctable_offset", &self.dynamic_value_reloctable_offset())
659 50 : .field("dynamic_value_reloctable_section", &self.dynamic_value_reloctable_section())
660 50 : .field("reserved2", &self.reserved2())
661 50 : .finish()
662 50 : }
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 50 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
777 50 : f.debug_struct("LoadConfigV6")
778 50 : .field("guard_rf_verify_stackpointer_function_pointer", &self.guard_rf_verify_stackpointer_function_pointer())
779 50 : .field("hotpatch_table_offset", &self.hotpatch_table_offset())
780 50 : .finish()
781 50 : }
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 20 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
892 20 : let base = self as &dyn AsLoadConfigV7;
893 20 : f.write_str(format!("{base:?}").as_str())
894 20 : }
895 : }
896 :
897 :
898 : impl std::fmt::Debug for &dyn AsLoadConfigV7 {
899 60 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
900 60 : f.debug_struct("LoadConfigV7")
901 60 : .field("reserved3", &self.reserved3())
902 60 : .field("addressof_unicode_string", &self.addressof_unicode_string())
903 60 : .finish()
904 60 : }
905 : }
906 :
907 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV7> for LoadConfigV7<'a> {
908 10 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV7>) -> Self {
909 10 : Self {
910 10 : ptr,
911 10 : _owner: PhantomData,
912 10 : }
913 10 : }
914 : }
915 :
916 : pub trait AsLoadConfigV7 {
917 : #[doc(hidden)]
918 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7;
919 :
920 24 : fn reserved3(&self) -> u32 {
921 24 : self.as_v7().reserved3()
922 24 : }
923 :
924 24 : fn addressof_unicode_string(&self) -> u64 {
925 24 : self.as_v7().addressof_unicode_string()
926 24 : }
927 : }
928 :
929 : impl AsBase for LoadConfigV7<'_> {
930 190 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
931 190 : self.ptr
932 190 : .as_ref()
933 190 : .unwrap()
934 190 : .as_ref()
935 190 : .as_ref()
936 190 : .as_ref()
937 190 : .as_ref()
938 190 : .as_ref()
939 190 : .as_ref()
940 190 : .as_ref()
941 190 : .as_ref()
942 190 : }
943 : }
944 :
945 : impl AsLoadConfigV0 for LoadConfigV7<'_> {
946 20 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
947 20 : self.ptr
948 20 : .as_ref()
949 20 : .unwrap()
950 20 : .as_ref()
951 20 : .as_ref()
952 20 : .as_ref()
953 20 : .as_ref()
954 20 : .as_ref()
955 20 : .as_ref()
956 20 : .as_ref()
957 20 : }
958 : }
959 :
960 : impl AsLoadConfigV1 for LoadConfigV7<'_> {
961 50 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
962 50 : self.ptr
963 50 : .as_ref()
964 50 : .unwrap()
965 50 : .as_ref()
966 50 : .as_ref()
967 50 : .as_ref()
968 50 : .as_ref()
969 50 : .as_ref()
970 50 : .as_ref()
971 50 : }
972 : }
973 :
974 : impl AsLoadConfigV2 for LoadConfigV7<'_> {
975 10 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
976 10 : self.ptr
977 10 : .as_ref()
978 10 : .unwrap()
979 10 : .as_ref()
980 10 : .as_ref()
981 10 : .as_ref()
982 10 : .as_ref()
983 10 : .as_ref()
984 10 : }
985 : }
986 :
987 : impl AsLoadConfigV3 for LoadConfigV7<'_> {
988 40 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
989 40 : self.ptr
990 40 : .as_ref()
991 40 : .unwrap()
992 40 : .as_ref()
993 40 : .as_ref()
994 40 : .as_ref()
995 40 : .as_ref()
996 40 : }
997 : }
998 :
999 : impl AsLoadConfigV4 for LoadConfigV7<'_> {
1000 20 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1001 20 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1002 20 : }
1003 : }
1004 :
1005 : impl AsLoadConfigV5 for LoadConfigV7<'_> {
1006 50 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1007 50 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1008 50 : }
1009 : }
1010 :
1011 : impl AsLoadConfigV6 for LoadConfigV7<'_> {
1012 20 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1013 20 : self.ptr.as_ref().unwrap().as_ref()
1014 20 : }
1015 : }
1016 :
1017 : impl AsLoadConfigV7 for LoadConfigV7<'_> {
1018 40 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1019 40 : self.ptr.as_ref().unwrap()
1020 40 : }
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 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1039 40 : f.debug_struct("LoadConfigV8")
1040 40 : .field("volatile_metadata_pointer", &self.volatile_metadata_pointer())
1041 40 : .finish()
1042 40 : }
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 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1190 40 : f.debug_struct("LoadConfigV9")
1191 40 : .field("guard_eh_continuation_table", &self.guard_eh_continuation_table())
1192 40 : .field("guard_eh_continuation_count", &self.guard_eh_continuation_count())
1193 40 : .finish()
1194 40 : }
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 40 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1363 40 : f.debug_struct("LoadConfigV10")
1364 40 : .field("guard_xfg_check_function_pointer", &self.guard_xfg_check_function_pointer())
1365 40 : .field("guard_xfg_dispatch_function_pointer", &self.guard_xfg_dispatch_function_pointer())
1366 40 : .field("guard_xfg_table_dispatch_function_pointer", &self.guard_xfg_table_dispatch_function_pointer())
1367 40 : .finish()
1368 40 : }
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 80 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1553 80 : let base = self as &dyn AsLoadConfigV11;
1554 80 : f.write_str(format!("{base:?}").as_str())
1555 80 : }
1556 : }
1557 :
1558 : impl std::fmt::Debug for &dyn AsLoadConfigV11 {
1559 80 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560 80 : f.debug_struct("LoadConfigV11")
1561 80 : .field("cast_guard_os_determined_failure_mode", &self.cast_guard_os_determined_failure_mode())
1562 80 : .finish()
1563 80 : }
1564 : }
1565 :
1566 : impl<'a> FromFFI<ffi::PE_LoadConfigurationV11> for LoadConfigV11<'a> {
1567 40 : fn from_ffi(ptr: cxx::UniquePtr<ffi::PE_LoadConfigurationV11>) -> Self {
1568 40 : Self {
1569 40 : ptr,
1570 40 : _owner: PhantomData,
1571 40 : }
1572 40 : }
1573 : }
1574 :
1575 : pub trait AsLoadConfigV11 {
1576 : #[doc(hidden)]
1577 : fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11;
1578 :
1579 80 : fn cast_guard_os_determined_failure_mode(&self) -> u64 {
1580 80 : self.as_v11().cast_guard_os_determined_failure_mode()
1581 80 : }
1582 : }
1583 :
1584 : impl AsBase for LoadConfigV11<'_> {
1585 760 : fn as_base(&self) -> &ffi::PE_LoadConfiguration {
1586 760 : self.ptr
1587 760 : .as_ref()
1588 760 : .unwrap()
1589 760 : .as_ref()
1590 760 : .as_ref()
1591 760 : .as_ref()
1592 760 : .as_ref()
1593 760 : .as_ref()
1594 760 : .as_ref()
1595 760 : .as_ref()
1596 760 : .as_ref()
1597 760 : .as_ref()
1598 760 : .as_ref()
1599 760 : .as_ref()
1600 760 : .as_ref()
1601 760 : }
1602 : }
1603 :
1604 : impl AsLoadConfigV0 for LoadConfigV11<'_> {
1605 80 : fn as_v0(&self) -> &ffi::PE_LoadConfigurationV0 {
1606 80 : self.ptr
1607 80 : .as_ref()
1608 80 : .unwrap()
1609 80 : .as_ref()
1610 80 : .as_ref()
1611 80 : .as_ref()
1612 80 : .as_ref()
1613 80 : .as_ref()
1614 80 : .as_ref()
1615 80 : .as_ref()
1616 80 : .as_ref()
1617 80 : .as_ref()
1618 80 : .as_ref()
1619 80 : .as_ref()
1620 80 : }
1621 : }
1622 :
1623 : impl AsLoadConfigV1 for LoadConfigV11<'_> {
1624 200 : fn as_v1(&self) -> &ffi::PE_LoadConfigurationV1 {
1625 200 : self.ptr
1626 200 : .as_ref()
1627 200 : .unwrap()
1628 200 : .as_ref()
1629 200 : .as_ref()
1630 200 : .as_ref()
1631 200 : .as_ref()
1632 200 : .as_ref()
1633 200 : .as_ref()
1634 200 : .as_ref()
1635 200 : .as_ref()
1636 200 : .as_ref()
1637 200 : .as_ref()
1638 200 : }
1639 : }
1640 :
1641 : impl AsLoadConfigV2 for LoadConfigV11<'_> {
1642 40 : fn as_v2(&self) -> &ffi::PE_LoadConfigurationV2 {
1643 40 : self.ptr
1644 40 : .as_ref()
1645 40 : .unwrap()
1646 40 : .as_ref()
1647 40 : .as_ref()
1648 40 : .as_ref()
1649 40 : .as_ref()
1650 40 : .as_ref()
1651 40 : .as_ref()
1652 40 : .as_ref()
1653 40 : .as_ref()
1654 40 : .as_ref()
1655 40 : }
1656 : }
1657 :
1658 : impl AsLoadConfigV3 for LoadConfigV11<'_> {
1659 160 : fn as_v3(&self) -> &ffi::PE_LoadConfigurationV3 {
1660 160 : self.ptr
1661 160 : .as_ref()
1662 160 : .unwrap()
1663 160 : .as_ref()
1664 160 : .as_ref()
1665 160 : .as_ref()
1666 160 : .as_ref()
1667 160 : .as_ref()
1668 160 : .as_ref()
1669 160 : .as_ref()
1670 160 : .as_ref()
1671 160 : }
1672 : }
1673 :
1674 : impl AsLoadConfigV4 for LoadConfigV11<'_> {
1675 80 : fn as_v4(&self) -> &ffi::PE_LoadConfigurationV4 {
1676 80 : self.ptr
1677 80 : .as_ref()
1678 80 : .unwrap()
1679 80 : .as_ref()
1680 80 : .as_ref()
1681 80 : .as_ref()
1682 80 : .as_ref()
1683 80 : .as_ref()
1684 80 : .as_ref()
1685 80 : .as_ref()
1686 80 : }
1687 : }
1688 :
1689 : impl AsLoadConfigV5 for LoadConfigV11<'_> {
1690 200 : fn as_v5(&self) -> &ffi::PE_LoadConfigurationV5 {
1691 200 : self.ptr
1692 200 : .as_ref()
1693 200 : .unwrap()
1694 200 : .as_ref()
1695 200 : .as_ref()
1696 200 : .as_ref()
1697 200 : .as_ref()
1698 200 : .as_ref()
1699 200 : .as_ref()
1700 200 : }
1701 : }
1702 :
1703 : impl AsLoadConfigV6 for LoadConfigV11<'_> {
1704 80 : fn as_v6(&self) -> &ffi::PE_LoadConfigurationV6 {
1705 80 : self.ptr
1706 80 : .as_ref()
1707 80 : .unwrap()
1708 80 : .as_ref()
1709 80 : .as_ref()
1710 80 : .as_ref()
1711 80 : .as_ref()
1712 80 : .as_ref()
1713 80 : }
1714 : }
1715 :
1716 : impl AsLoadConfigV7 for LoadConfigV11<'_> {
1717 80 : fn as_v7(&self) -> &ffi::PE_LoadConfigurationV7 {
1718 80 : self.ptr
1719 80 : .as_ref()
1720 80 : .unwrap()
1721 80 : .as_ref()
1722 80 : .as_ref()
1723 80 : .as_ref()
1724 80 : .as_ref()
1725 80 : }
1726 : }
1727 :
1728 : impl AsLoadConfigV8 for LoadConfigV11<'_> {
1729 40 : fn as_v8(&self) -> &ffi::PE_LoadConfigurationV8 {
1730 40 : self.ptr.as_ref().unwrap().as_ref().as_ref().as_ref()
1731 40 : }
1732 : }
1733 :
1734 : impl AsLoadConfigV9 for LoadConfigV11<'_> {
1735 80 : fn as_v9(&self) -> &ffi::PE_LoadConfigurationV9 {
1736 80 : self.ptr.as_ref().unwrap().as_ref().as_ref()
1737 80 : }
1738 : }
1739 :
1740 : impl AsLoadConfigV10 for LoadConfigV11<'_> {
1741 120 : fn as_v10(&self) -> &ffi::PE_LoadConfigurationV10 {
1742 120 : self.ptr.as_ref().unwrap().as_ref()
1743 120 : }
1744 : }
1745 :
1746 : impl AsLoadConfigV11 for LoadConfigV11<'_> {
1747 80 : fn as_v11(&self) -> &ffi::PE_LoadConfigurationV11 {
1748 80 : self.ptr.as_ref().unwrap()
1749 80 : }
1750 : }
|
