lief-ffi 1.0.0

LIEF ffi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#[cxx::bridge]
pub mod ffi {
    unsafe extern "C++" {
        include!("LIEF/rust/ELF/NoteGnuProperty.hpp");

        type ELF_Note = crate::elf::note::ffi::ELF_Note;

        type ELF_NoteGnuProperty;

        #[Self = "ELF_NoteGnuProperty"]
        fn classof(note: &ELF_Note) -> bool;
        fn properties(self: &ELF_NoteGnuProperty) -> UniquePtr<ELF_NoteGnuProperty_it_properties>;
        fn find(self: &ELF_NoteGnuProperty, type_: u32) -> UniquePtr<ELF_NoteGnuProperty_Property>;

        type ELF_NoteGnuProperty_AArch64Feature;

        #[Self = "ELF_NoteGnuProperty_AArch64Feature"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn features(self: &ELF_NoteGnuProperty_AArch64Feature) -> UniquePtr<CxxVector<u64>>;

        type ELF_NoteGnuProperty_AArch64PAuth;

        #[Self = "ELF_NoteGnuProperty_AArch64PAuth"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn platform(self: &ELF_NoteGnuProperty_AArch64PAuth) -> u64;
        fn version(self: &ELF_NoteGnuProperty_AArch64PAuth) -> u64;

        type ELF_NoteGnuProperty_Generic;

        #[Self = "ELF_NoteGnuProperty_Generic"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn raw_type(self: &ELF_NoteGnuProperty_Generic) -> u32;

        type ELF_NoteGnuProperty_Needed;

        #[Self = "ELF_NoteGnuProperty_Needed"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn needs(self: &ELF_NoteGnuProperty_Needed) -> UniquePtr<CxxVector<u64>>;

        type ELF_NoteGnuProperty_NoteNoCopyOnProtected;

        #[Self = "ELF_NoteGnuProperty_NoteNoCopyOnProtected"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;

        type ELF_NoteGnuProperty_Property;

        fn get_type(self: &ELF_NoteGnuProperty_Property) -> u32;

        type ELF_NoteGnuProperty_StackSize;

        #[Self = "ELF_NoteGnuProperty_StackSize"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn stack_size(self: &ELF_NoteGnuProperty_StackSize) -> u64;

        type ELF_NoteGnuProperty_X86Features;

        #[Self = "ELF_NoteGnuProperty_X86Features"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn features(self: &ELF_NoteGnuProperty_X86Features) -> UniquePtr<CxxVector<u64>>;

        type ELF_NoteGnuProperty_X86ISA;

        #[Self = "ELF_NoteGnuProperty_X86ISA"]
        fn classof(prop: &ELF_NoteGnuProperty_Property) -> bool;
        fn values(self: &ELF_NoteGnuProperty_X86ISA) -> UniquePtr<CxxVector<u64>>;

        type ELF_NoteGnuProperty_it_properties;

        fn next(
            self: Pin<&mut ELF_NoteGnuProperty_it_properties>,
        ) -> UniquePtr<ELF_NoteGnuProperty_Property>;
        fn size(self: &ELF_NoteGnuProperty_it_properties) -> u64;
    }
    impl UniquePtr<ELF_NoteGnuProperty> {}
    impl UniquePtr<ELF_NoteGnuProperty_AArch64Feature> {}
    impl UniquePtr<ELF_NoteGnuProperty_AArch64PAuth> {}
    impl UniquePtr<ELF_NoteGnuProperty_Generic> {}
    impl UniquePtr<ELF_NoteGnuProperty_it_properties> {}
    impl UniquePtr<ELF_NoteGnuProperty_Needed> {}
    impl UniquePtr<ELF_NoteGnuProperty_NoteNoCopyOnProtected> {}
    impl UniquePtr<ELF_NoteGnuProperty_Property> {}
    impl UniquePtr<ELF_NoteGnuProperty_StackSize> {}
    impl UniquePtr<ELF_NoteGnuProperty_X86Features> {}
    impl UniquePtr<ELF_NoteGnuProperty_X86ISA> {}
}