pub const STRING_GFLAGS_NULL: u32 = 4096;
pub const META_TYPE_NULL: u32 = 0;
pub const META_TYPE_INTEGER: u32 = 1;
pub const META_TYPE_STRING: u32 = 2;
pub const META_TYPE_BOOLEAN: u32 = 3;
pub const YARA_ERROR_LEVEL_ERROR: u32 = 0;
pub const YARA_ERROR_LEVEL_WARNING: u32 = 1;
pub const ERROR_SUCCESS: u32 = 0;
pub const ERROR_INSUFICIENT_MEMORY: u32 = 1;
pub const ERROR_INSUFFICIENT_MEMORY: u32 = 1;
pub const ERROR_COULD_NOT_ATTACH_TO_PROCESS: u32 = 2;
pub const ERROR_COULD_NOT_OPEN_FILE: u32 = 3;
pub const ERROR_COULD_NOT_MAP_FILE: u32 = 4;
pub const ERROR_INVALID_FILE: u32 = 6;
pub const ERROR_CORRUPT_FILE: u32 = 7;
pub const ERROR_UNSUPPORTED_FILE_VERSION: u32 = 8;
pub const ERROR_INVALID_REGULAR_EXPRESSION: u32 = 9;
pub const ERROR_INVALID_HEX_STRING: u32 = 10;
pub const ERROR_SYNTAX_ERROR: u32 = 11;
pub const ERROR_LOOP_NESTING_LIMIT_EXCEEDED: u32 = 12;
pub const ERROR_DUPLICATED_LOOP_IDENTIFIER: u32 = 13;
pub const ERROR_DUPLICATED_IDENTIFIER: u32 = 14;
pub const ERROR_DUPLICATED_TAG_IDENTIFIER: u32 = 15;
pub const ERROR_DUPLICATED_META_IDENTIFIER: u32 = 16;
pub const ERROR_DUPLICATED_STRING_IDENTIFIER: u32 = 17;
pub const ERROR_UNREFERENCED_STRING: u32 = 18;
pub const ERROR_UNDEFINED_STRING: u32 = 19;
pub const ERROR_UNDEFINED_IDENTIFIER: u32 = 20;
pub const ERROR_MISPLACED_ANONYMOUS_STRING: u32 = 21;
pub const ERROR_INCLUDES_CIRCULAR_REFERENCE: u32 = 22;
pub const ERROR_INCLUDE_DEPTH_EXCEEDED: u32 = 23;
pub const ERROR_WRONG_TYPE: u32 = 24;
pub const ERROR_EXEC_STACK_OVERFLOW: u32 = 25;
pub const ERROR_SCAN_TIMEOUT: u32 = 26;
pub const ERROR_TOO_MANY_SCAN_THREADS: u32 = 27;
pub const ERROR_CALLBACK_ERROR: u32 = 28;
pub const ERROR_INVALID_ARGUMENT: u32 = 29;
pub const ERROR_TOO_MANY_MATCHES: u32 = 30;
pub const ERROR_INTERNAL_FATAL_ERROR: u32 = 31;
pub const ERROR_NESTED_FOR_OF_LOOP: u32 = 32;
pub const ERROR_INVALID_FIELD_NAME: u32 = 33;
pub const ERROR_UNKNOWN_MODULE: u32 = 34;
pub const ERROR_NOT_A_STRUCTURE: u32 = 35;
pub const ERROR_NOT_INDEXABLE: u32 = 36;
pub const ERROR_NOT_A_FUNCTION: u32 = 37;
pub const ERROR_INVALID_FORMAT: u32 = 38;
pub const ERROR_TOO_MANY_ARGUMENTS: u32 = 39;
pub const ERROR_WRONG_ARGUMENTS: u32 = 40;
pub const ERROR_WRONG_RETURN_TYPE: u32 = 41;
pub const ERROR_DUPLICATED_STRUCTURE_MEMBER: u32 = 42;
pub const ERROR_EMPTY_STRING: u32 = 43;
pub const ERROR_DIVISION_BY_ZERO: u32 = 44;
pub const ERROR_REGULAR_EXPRESSION_TOO_LARGE: u32 = 45;
pub const ERROR_TOO_MANY_RE_FIBERS: u32 = 46;
pub const ERROR_COULD_NOT_READ_PROCESS_MEMORY: u32 = 47;
pub const ERROR_INVALID_EXTERNAL_VARIABLE_TYPE: u32 = 48;
pub const ERROR_REGULAR_EXPRESSION_TOO_COMPLEX: u32 = 49;
pub const ERROR_INVALID_MODULE_NAME: u32 = 50;
pub const ERROR_TOO_MANY_STRINGS: u32 = 51;
pub const ERROR_INTEGER_OVERFLOW: u32 = 52;
pub const ERROR_CALLBACK_REQUIRED: u32 = 53;
pub const ERROR_INVALID_OPERAND: u32 = 54;
pub const ERROR_COULD_NOT_READ_FILE: u32 = 55;
pub const ERROR_DUPLICATED_EXTERNAL_VARIABLE: u32 = 56;
pub const ERROR_INVALID_MODULE_DATA: u32 = 57;
pub const ERROR_WRITING_FILE: u32 = 58;
pub const ERROR_INVALID_MODIFIER: u32 = 59;
pub const ERROR_DUPLICATED_MODIFIER: u32 = 60;
pub const CALLBACK_MSG_RULE_MATCHING: u32 = 1;
pub const CALLBACK_MSG_RULE_NOT_MATCHING: u32 = 2;
pub const CALLBACK_MSG_SCAN_FINISHED: u32 = 3;
pub const CALLBACK_MSG_IMPORT_MODULE: u32 = 4;
pub const CALLBACK_MSG_MODULE_IMPORTED: u32 = 5;
pub const CALLBACK_CONTINUE: u32 = 0;
pub const CALLBACK_ABORT: u32 = 1;
pub const CALLBACK_ERROR: u32 = 2;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
pub type FILE = _IO_FILE;
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
pub _next: *mut _IO_marker,
pub _sbuf: *mut _IO_FILE,
pub _pos: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__IO_marker() {
assert_eq!(
::std::mem::size_of::<_IO_marker>(),
24usize,
concat!("Size of: ", stringify!(_IO_marker))
);
assert_eq!(
::std::mem::align_of::<_IO_marker>(),
8usize,
concat!("Alignment of ", stringify!(_IO_marker))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_marker>()))._next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_marker),
"::",
stringify!(_next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_marker>()))._sbuf as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_marker),
"::",
stringify!(_sbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_marker>()))._pos as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_marker),
"::",
stringify!(_pos)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub __pad1: *mut ::std::os::raw::c_void,
pub __pad2: *mut ::std::os::raw::c_void,
pub __pad3: *mut ::std::os::raw::c_void,
pub __pad4: *mut ::std::os::raw::c_void,
pub __pad5: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad1 as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad2 as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad3 as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad4 as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type YR_STREAM_READ_FUNC = ::std::option::Option<
unsafe extern "C" fn(
ptr: *mut ::std::os::raw::c_void,
size: usize,
count: usize,
user_data: *mut ::std::os::raw::c_void,
) -> usize,
>;
pub type YR_STREAM_WRITE_FUNC = ::std::option::Option<
unsafe extern "C" fn(
ptr: *const ::std::os::raw::c_void,
size: usize,
count: usize,
user_data: *mut ::std::os::raw::c_void,
) -> usize,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _YR_STREAM {
pub user_data: *mut ::std::os::raw::c_void,
pub read: YR_STREAM_READ_FUNC,
pub write: YR_STREAM_WRITE_FUNC,
}
#[test]
fn bindgen_test_layout__YR_STREAM() {
assert_eq!(
::std::mem::size_of::<_YR_STREAM>(),
24usize,
concat!("Size of: ", stringify!(_YR_STREAM))
);
assert_eq!(
::std::mem::align_of::<_YR_STREAM>(),
8usize,
concat!("Alignment of ", stringify!(_YR_STREAM))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_YR_STREAM>())).user_data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_YR_STREAM),
"::",
stringify!(user_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_YR_STREAM>())).read as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_YR_STREAM),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_YR_STREAM>())).write as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_YR_STREAM),
"::",
stringify!(write)
)
);
}
pub type YR_STREAM = _YR_STREAM;
pub type YR_ARENA = [u64; 3usize];
pub type YR_MUTEX = pthread_mutex_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_NAMESPACE {
pub t_flags: [i32; 32usize],
pub __bindgen_anon_1: YR_NAMESPACE__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_NAMESPACE__bindgen_ty_1 {
pub name: *mut ::std::os::raw::c_char,
pub name_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_NAMESPACE__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_NAMESPACE__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_NAMESPACE__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_NAMESPACE__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(YR_NAMESPACE__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_NAMESPACE__bindgen_ty_1>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_NAMESPACE__bindgen_ty_1),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_NAMESPACE__bindgen_ty_1>())).name_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_NAMESPACE__bindgen_ty_1),
"::",
stringify!(name_)
)
);
}
#[test]
fn bindgen_test_layout_YR_NAMESPACE() {
assert_eq!(
::std::mem::size_of::<YR_NAMESPACE>(),
136usize,
concat!("Size of: ", stringify!(YR_NAMESPACE))
);
assert_eq!(
::std::mem::align_of::<YR_NAMESPACE>(),
8usize,
concat!("Alignment of ", stringify!(YR_NAMESPACE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_NAMESPACE>())).t_flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_NAMESPACE),
"::",
stringify!(t_flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_META {
pub type_: i32,
pub integer: i64,
pub __bindgen_anon_1: YR_META__bindgen_ty_1,
pub __bindgen_anon_2: YR_META__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_META__bindgen_ty_1 {
pub identifier: *const ::std::os::raw::c_char,
pub identifier_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_META__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_META__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_META__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_META__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(YR_META__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_META__bindgen_ty_1>())).identifier as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_META__bindgen_ty_1),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_META__bindgen_ty_1>())).identifier_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_META__bindgen_ty_1),
"::",
stringify!(identifier_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_META__bindgen_ty_2 {
pub string: *mut ::std::os::raw::c_char,
pub string_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_META__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<YR_META__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(YR_META__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<YR_META__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(YR_META__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_META__bindgen_ty_2>())).string as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_META__bindgen_ty_2),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_META__bindgen_ty_2>())).string_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_META__bindgen_ty_2),
"::",
stringify!(string_)
)
);
}
#[test]
fn bindgen_test_layout_YR_META() {
assert_eq!(
::std::mem::size_of::<YR_META>(),
32usize,
concat!("Size of: ", stringify!(YR_META))
);
assert_eq!(
::std::mem::align_of::<YR_META>(),
8usize,
concat!("Alignment of ", stringify!(YR_META))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_META>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_META),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_META>())).integer as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(YR_META),
"::",
stringify!(integer)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_MATCHES {
pub count: i32,
pub __bindgen_anon_1: YR_MATCHES__bindgen_ty_1,
pub __bindgen_anon_2: YR_MATCHES__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_MATCHES__bindgen_ty_1 {
pub head: *mut YR_MATCH,
pub head_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_MATCHES__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_MATCHES__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_MATCHES__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_MATCHES__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(YR_MATCHES__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCHES__bindgen_ty_1>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCHES__bindgen_ty_1),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCHES__bindgen_ty_1>())).head_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCHES__bindgen_ty_1),
"::",
stringify!(head_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_MATCHES__bindgen_ty_2 {
pub tail: *mut YR_MATCH,
pub tail_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_MATCHES__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<YR_MATCHES__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(YR_MATCHES__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<YR_MATCHES__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(YR_MATCHES__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCHES__bindgen_ty_2>())).tail as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCHES__bindgen_ty_2),
"::",
stringify!(tail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCHES__bindgen_ty_2>())).tail_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCHES__bindgen_ty_2),
"::",
stringify!(tail_)
)
);
}
#[test]
fn bindgen_test_layout_YR_MATCHES() {
assert_eq!(
::std::mem::size_of::<YR_MATCHES>(),
24usize,
concat!("Size of: ", stringify!(YR_MATCHES))
);
assert_eq!(
::std::mem::align_of::<YR_MATCHES>(),
8usize,
concat!("Alignment of ", stringify!(YR_MATCHES))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCHES>())).count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCHES),
"::",
stringify!(count)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_STRING {
pub g_flags: i32,
pub length: i32,
pub __bindgen_anon_1: YR_STRING__bindgen_ty_1,
pub __bindgen_anon_2: YR_STRING__bindgen_ty_2,
pub __bindgen_anon_3: YR_STRING__bindgen_ty_3,
pub __bindgen_anon_4: YR_STRING__bindgen_ty_4,
pub chain_gap_min: i32,
pub chain_gap_max: i32,
pub fixed_offset: i64,
pub matches: [YR_MATCHES; 32usize],
pub private_matches: [YR_MATCHES; 32usize],
pub unconfirmed_matches: [YR_MATCHES; 32usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_STRING__bindgen_ty_1 {
pub identifier: *mut ::std::os::raw::c_char,
pub identifier_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_STRING__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_STRING__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_STRING__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_STRING__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(YR_STRING__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_STRING__bindgen_ty_1>())).identifier as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_1),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_STRING__bindgen_ty_1>())).identifier_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_1),
"::",
stringify!(identifier_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_STRING__bindgen_ty_2 {
pub string: *mut u8,
pub string_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_STRING__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<YR_STRING__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(YR_STRING__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<YR_STRING__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(YR_STRING__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING__bindgen_ty_2>())).string as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_2),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING__bindgen_ty_2>())).string_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_2),
"::",
stringify!(string_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_STRING__bindgen_ty_3 {
pub chained_to: *mut YR_STRING,
pub chained_to_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_STRING__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<YR_STRING__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(YR_STRING__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<YR_STRING__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(YR_STRING__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_STRING__bindgen_ty_3>())).chained_to as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_3),
"::",
stringify!(chained_to)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_STRING__bindgen_ty_3>())).chained_to_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_3),
"::",
stringify!(chained_to_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_STRING__bindgen_ty_4 {
pub rule: *mut YR_RULE,
pub rule_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_STRING__bindgen_ty_4() {
assert_eq!(
::std::mem::size_of::<YR_STRING__bindgen_ty_4>(),
8usize,
concat!("Size of: ", stringify!(YR_STRING__bindgen_ty_4))
);
assert_eq!(
::std::mem::align_of::<YR_STRING__bindgen_ty_4>(),
8usize,
concat!("Alignment of ", stringify!(YR_STRING__bindgen_ty_4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING__bindgen_ty_4>())).rule as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_4),
"::",
stringify!(rule)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING__bindgen_ty_4>())).rule_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING__bindgen_ty_4),
"::",
stringify!(rule_)
)
);
}
#[test]
fn bindgen_test_layout_YR_STRING() {
assert_eq!(
::std::mem::size_of::<YR_STRING>(),
2360usize,
concat!("Size of: ", stringify!(YR_STRING))
);
assert_eq!(
::std::mem::align_of::<YR_STRING>(),
8usize,
concat!("Alignment of ", stringify!(YR_STRING))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).g_flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(g_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).length as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).chain_gap_min as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(chain_gap_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).chain_gap_max as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(chain_gap_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).fixed_offset as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(fixed_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).matches as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(matches)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).private_matches as *const _ as usize },
824usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(private_matches)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_STRING>())).unconfirmed_matches as *const _ as usize },
1592usize,
concat!(
"Offset of field: ",
stringify!(YR_STRING),
"::",
stringify!(unconfirmed_matches)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_RULE {
pub g_flags: i32,
pub t_flags: [i32; 32usize],
pub __bindgen_anon_1: YR_RULE__bindgen_ty_1,
pub __bindgen_anon_2: YR_RULE__bindgen_ty_2,
pub __bindgen_anon_3: YR_RULE__bindgen_ty_3,
pub __bindgen_anon_4: YR_RULE__bindgen_ty_4,
pub __bindgen_anon_5: YR_RULE__bindgen_ty_5,
pub num_atoms: i32,
pub time_cost: i64,
pub time_cost_per_thread: [i64; 32usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_RULE__bindgen_ty_1 {
pub identifier: *const ::std::os::raw::c_char,
pub identifier_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_RULE__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_RULE__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_RULE__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_RULE__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULE__bindgen_ty_1>())).identifier as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_1),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULE__bindgen_ty_1>())).identifier_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_1),
"::",
stringify!(identifier_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_RULE__bindgen_ty_2 {
pub tags: *const ::std::os::raw::c_char,
pub tags_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_RULE__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<YR_RULE__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(YR_RULE__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<YR_RULE__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_2>())).tags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_2),
"::",
stringify!(tags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_2>())).tags_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_2),
"::",
stringify!(tags_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_RULE__bindgen_ty_3 {
pub metas: *mut YR_META,
pub metas_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_RULE__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<YR_RULE__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(YR_RULE__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<YR_RULE__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE__bindgen_ty_3))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_3>())).metas as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_3),
"::",
stringify!(metas)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_3>())).metas_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_3),
"::",
stringify!(metas_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_RULE__bindgen_ty_4 {
pub strings: *mut YR_STRING,
pub strings_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_RULE__bindgen_ty_4() {
assert_eq!(
::std::mem::size_of::<YR_RULE__bindgen_ty_4>(),
8usize,
concat!("Size of: ", stringify!(YR_RULE__bindgen_ty_4))
);
assert_eq!(
::std::mem::align_of::<YR_RULE__bindgen_ty_4>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE__bindgen_ty_4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_4>())).strings as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_4),
"::",
stringify!(strings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_4>())).strings_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_4),
"::",
stringify!(strings_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_RULE__bindgen_ty_5 {
pub ns: *mut YR_NAMESPACE,
pub ns_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_RULE__bindgen_ty_5() {
assert_eq!(
::std::mem::size_of::<YR_RULE__bindgen_ty_5>(),
8usize,
concat!("Size of: ", stringify!(YR_RULE__bindgen_ty_5))
);
assert_eq!(
::std::mem::align_of::<YR_RULE__bindgen_ty_5>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE__bindgen_ty_5))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_5>())).ns as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_5),
"::",
stringify!(ns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE__bindgen_ty_5>())).ns_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE__bindgen_ty_5),
"::",
stringify!(ns_)
)
);
}
#[test]
fn bindgen_test_layout_YR_RULE() {
assert_eq!(
::std::mem::size_of::<YR_RULE>(),
448usize,
concat!("Size of: ", stringify!(YR_RULE))
);
assert_eq!(
::std::mem::align_of::<YR_RULE>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE>())).g_flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE),
"::",
stringify!(g_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE>())).t_flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE),
"::",
stringify!(t_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE>())).num_atoms as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE),
"::",
stringify!(num_atoms)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE>())).time_cost as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE),
"::",
stringify!(time_cost)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULE>())).time_cost_per_thread as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(YR_RULE),
"::",
stringify!(time_cost_per_thread)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_EXTERNAL_VARIABLE {
pub type_: i32,
pub value: YR_EXTERNAL_VARIABLE__bindgen_ty_1,
pub __bindgen_anon_1: YR_EXTERNAL_VARIABLE__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_EXTERNAL_VARIABLE__bindgen_ty_1 {
pub i: i64,
pub f: f64,
pub s: *mut ::std::os::raw::c_char,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_EXTERNAL_VARIABLE__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<YR_EXTERNAL_VARIABLE__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<YR_EXTERNAL_VARIABLE__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE__bindgen_ty_1>())).i as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_1),
"::",
stringify!(i)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE__bindgen_ty_1>())).f as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_1),
"::",
stringify!(f)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE__bindgen_ty_1>())).s as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_1),
"::",
stringify!(s)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union YR_EXTERNAL_VARIABLE__bindgen_ty_2 {
pub identifier: *const ::std::os::raw::c_char,
pub identifier_: i64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_YR_EXTERNAL_VARIABLE__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<YR_EXTERNAL_VARIABLE__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<YR_EXTERNAL_VARIABLE__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE__bindgen_ty_2>())).identifier as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_2),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE__bindgen_ty_2>())).identifier_ as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE__bindgen_ty_2),
"::",
stringify!(identifier_)
)
);
}
#[test]
fn bindgen_test_layout_YR_EXTERNAL_VARIABLE() {
assert_eq!(
::std::mem::size_of::<YR_EXTERNAL_VARIABLE>(),
24usize,
concat!("Size of: ", stringify!(YR_EXTERNAL_VARIABLE))
);
assert_eq!(
::std::mem::align_of::<YR_EXTERNAL_VARIABLE>(),
8usize,
concat!("Alignment of ", stringify!(YR_EXTERNAL_VARIABLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_EXTERNAL_VARIABLE>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(YR_EXTERNAL_VARIABLE),
"::",
stringify!(value)
)
);
}
pub type YR_AC_TRANSITION_TABLE = u64;
pub type YR_AC_MATCH_TABLE = u64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RE_NODE {
pub type_: ::std::os::raw::c_int,
pub __bindgen_anon_1: RE_NODE__bindgen_ty_1,
pub __bindgen_anon_2: RE_NODE__bindgen_ty_2,
pub greedy: ::std::os::raw::c_int,
pub re_class: *mut RE_CLASS,
pub children_head: *mut RE_NODE,
pub children_tail: *mut RE_NODE,
pub prev_sibling: *mut RE_NODE,
pub next_sibling: *mut RE_NODE,
pub forward_code: *mut u8,
pub backward_code: *mut u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RE_NODE__bindgen_ty_1 {
pub value: ::std::os::raw::c_int,
pub count: ::std::os::raw::c_int,
pub start: ::std::os::raw::c_int,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_RE_NODE__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<RE_NODE__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(RE_NODE__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<RE_NODE__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(RE_NODE__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE__bindgen_ty_1>())).value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE__bindgen_ty_1),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE__bindgen_ty_1>())).count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE__bindgen_ty_1),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE__bindgen_ty_1>())).start as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE__bindgen_ty_1),
"::",
stringify!(start)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RE_NODE__bindgen_ty_2 {
pub mask: ::std::os::raw::c_int,
pub end: ::std::os::raw::c_int,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_RE_NODE__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<RE_NODE__bindgen_ty_2>(),
4usize,
concat!("Size of: ", stringify!(RE_NODE__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<RE_NODE__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(RE_NODE__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE__bindgen_ty_2>())).mask as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE__bindgen_ty_2),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE__bindgen_ty_2>())).end as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE__bindgen_ty_2),
"::",
stringify!(end)
)
);
}
#[test]
fn bindgen_test_layout_RE_NODE() {
assert_eq!(
::std::mem::size_of::<RE_NODE>(),
72usize,
concat!("Size of: ", stringify!(RE_NODE))
);
assert_eq!(
::std::mem::align_of::<RE_NODE>(),
8usize,
concat!("Alignment of ", stringify!(RE_NODE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).greedy as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(greedy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).re_class as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(re_class)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).children_head as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(children_head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).children_tail as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(children_tail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).prev_sibling as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(prev_sibling)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).next_sibling as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(next_sibling)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).forward_code as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(forward_code)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_NODE>())).backward_code as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RE_NODE),
"::",
stringify!(backward_code)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RE_CLASS {
pub negated: u8,
pub bitmap: [u8; 32usize],
}
#[test]
fn bindgen_test_layout_RE_CLASS() {
assert_eq!(
::std::mem::size_of::<RE_CLASS>(),
33usize,
concat!("Size of: ", stringify!(RE_CLASS))
);
assert_eq!(
::std::mem::align_of::<RE_CLASS>(),
1usize,
concat!("Alignment of ", stringify!(RE_CLASS))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_CLASS>())).negated as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_CLASS),
"::",
stringify!(negated)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_CLASS>())).bitmap as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(RE_CLASS),
"::",
stringify!(bitmap)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RE_AST {
pub flags: u32,
pub root_node: *mut RE_NODE,
}
#[test]
fn bindgen_test_layout_RE_AST() {
assert_eq!(
::std::mem::size_of::<RE_AST>(),
16usize,
concat!("Size of: ", stringify!(RE_AST))
);
assert_eq!(
::std::mem::align_of::<RE_AST>(),
8usize,
concat!("Alignment of ", stringify!(RE_AST))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_AST>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RE_AST),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RE_AST>())).root_node as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RE_AST),
"::",
stringify!(root_node)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct YR_MATCH {
pub base: i64,
pub offset: i64,
pub match_length: i32,
pub data_length: i32,
pub data: *const u8,
pub chain_length: i32,
pub prev: *mut YR_MATCH,
pub next: *mut YR_MATCH,
}
#[test]
fn bindgen_test_layout_YR_MATCH() {
assert_eq!(
::std::mem::size_of::<YR_MATCH>(),
56usize,
concat!("Size of: ", stringify!(YR_MATCH))
);
assert_eq!(
::std::mem::align_of::<YR_MATCH>(),
8usize,
concat!("Alignment of ", stringify!(YR_MATCH))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).base as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).match_length as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(match_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).data_length as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(data_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).chain_length as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(chain_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).prev as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_MATCH>())).next as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(YR_MATCH),
"::",
stringify!(next)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_RULES {
pub tidx_mask: [::std::os::raw::c_uchar; 4usize],
pub code_start: *const u8,
pub mutex: YR_MUTEX,
pub arena: *mut YR_ARENA,
pub rules_list_head: *mut YR_RULE,
pub externals_list_head: *mut YR_EXTERNAL_VARIABLE,
pub ac_transition_table: YR_AC_TRANSITION_TABLE,
pub ac_match_table: YR_AC_MATCH_TABLE,
pub ac_tables_size: u32,
pub time_cost: u64,
}
#[test]
fn bindgen_test_layout_YR_RULES() {
assert_eq!(
::std::mem::size_of::<YR_RULES>(),
112usize,
concat!("Size of: ", stringify!(YR_RULES))
);
assert_eq!(
::std::mem::align_of::<YR_RULES>(),
8usize,
concat!("Alignment of ", stringify!(YR_RULES))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).tidx_mask as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(tidx_mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).code_start as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(code_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).mutex as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).arena as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(arena)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).rules_list_head as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(rules_list_head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).externals_list_head as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(externals_list_head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).ac_transition_table as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(ac_transition_table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).ac_match_table as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(ac_match_table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).ac_tables_size as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(ac_tables_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES>())).time_cost as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES),
"::",
stringify!(time_cost)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct YR_RULES_STATS {
pub rules: u32,
pub strings: u32,
pub ac_matches: u32,
pub ac_root_match_list_length: u32,
pub ac_average_match_list_length: f32,
pub top_ac_match_list_lengths: [u32; 100usize],
pub ac_match_list_length_pctls: [u32; 101usize],
pub ac_tables_size: u32,
}
#[test]
fn bindgen_test_layout_YR_RULES_STATS() {
assert_eq!(
::std::mem::size_of::<YR_RULES_STATS>(),
828usize,
concat!("Size of: ", stringify!(YR_RULES_STATS))
);
assert_eq!(
::std::mem::align_of::<YR_RULES_STATS>(),
4usize,
concat!("Alignment of ", stringify!(YR_RULES_STATS))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES_STATS>())).rules as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(rules)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES_STATS>())).strings as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(strings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES_STATS>())).ac_matches as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(ac_matches)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULES_STATS>())).ac_root_match_list_length as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(ac_root_match_list_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULES_STATS>())).ac_average_match_list_length as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(ac_average_match_list_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULES_STATS>())).top_ac_match_list_lengths as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(top_ac_match_list_lengths)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<YR_RULES_STATS>())).ac_match_list_length_pctls as *const _
as usize
},
420usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(ac_match_list_length_pctls)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<YR_RULES_STATS>())).ac_tables_size as *const _ as usize },
824usize,
concat!(
"Offset of field: ",
stringify!(YR_RULES_STATS),
"::",
stringify!(ac_tables_size)
)
);
}
pub type YR_CALLBACK_FUNC = ::std::option::Option<
unsafe extern "C" fn(
message: ::std::os::raw::c_int,
message_data: *mut ::std::os::raw::c_void,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type YR_COMPILER_CALLBACK_FUNC = ::std::option::Option<
unsafe extern "C" fn(
error_level: ::std::os::raw::c_int,
file_name: *const ::std::os::raw::c_char,
line_number: ::std::os::raw::c_int,
message: *const ::std::os::raw::c_char,
user_data: *mut ::std::os::raw::c_void,
),
>;
pub type YR_COMPILER_INCLUDE_CALLBACK_FUNC = ::std::option::Option<
unsafe extern "C" fn(
include_name: *const ::std::os::raw::c_char,
calling_rule_filename: *const ::std::os::raw::c_char,
calling_rule_namespace: *const ::std::os::raw::c_char,
user_data: *mut ::std::os::raw::c_void,
) -> *const ::std::os::raw::c_char,
>;
pub type YR_COMPILER_INCLUDE_FREE_FUNC = ::std::option::Option<
unsafe extern "C" fn(
callback_result_ptr: *const ::std::os::raw::c_char,
user_data: *mut ::std::os::raw::c_void,
),
>;
pub type YR_COMPILER_RE_AST_CALLBACK_FUNC = ::std::option::Option<
unsafe extern "C" fn(
rule: *const YR_RULE,
string_identifier: *const ::std::os::raw::c_char,
re_ast: *const RE_AST,
user_data: *mut ::std::os::raw::c_void,
),
>;
pub type YR_COMPILER = [u64; 1269usize];
extern "C" {
pub fn yr_compiler_create(compiler: *mut *mut YR_COMPILER) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_destroy(compiler: *mut YR_COMPILER);
}
extern "C" {
pub fn yr_compiler_set_callback(
compiler: *mut YR_COMPILER,
callback: YR_COMPILER_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn yr_compiler_set_include_callback(
compiler: *mut YR_COMPILER,
include_callback: YR_COMPILER_INCLUDE_CALLBACK_FUNC,
include_free: YR_COMPILER_INCLUDE_FREE_FUNC,
user_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn yr_compiler_set_re_ast_callback(
compiler: *mut YR_COMPILER,
re_ast_callback: YR_COMPILER_RE_AST_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn yr_compiler_set_atom_quality_table(
compiler: *mut YR_COMPILER,
table: *const ::std::os::raw::c_void,
entries: ::std::os::raw::c_int,
warning_threshold: ::std::os::raw::c_uchar,
);
}
extern "C" {
pub fn yr_compiler_load_atom_quality_table(
compiler: *mut YR_COMPILER,
filename: *const ::std::os::raw::c_char,
warning_threshold: ::std::os::raw::c_uchar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_add_file(
compiler: *mut YR_COMPILER,
rules_file: *mut FILE,
namespace_: *const ::std::os::raw::c_char,
file_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_add_fd(
compiler: *mut YR_COMPILER,
rules_fd: ::std::os::raw::c_int,
namespace_: *const ::std::os::raw::c_char,
file_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_add_string(
compiler: *mut YR_COMPILER,
rules_string: *const ::std::os::raw::c_char,
namespace_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_get_error_message(
compiler: *mut YR_COMPILER,
buffer: *mut ::std::os::raw::c_char,
buffer_size: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn yr_compiler_get_current_file_name(
compiler: *mut YR_COMPILER,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn yr_compiler_define_integer_variable(
compiler: *mut YR_COMPILER,
identifier: *const ::std::os::raw::c_char,
value: i64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_define_boolean_variable(
compiler: *mut YR_COMPILER,
identifier: *const ::std::os::raw::c_char,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_define_float_variable(
compiler: *mut YR_COMPILER,
identifier: *const ::std::os::raw::c_char,
value: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_define_string_variable(
compiler: *mut YR_COMPILER,
identifier: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_compiler_get_rules(
compiler: *mut YR_COMPILER,
rules: *mut *mut YR_RULES,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_scan_mem(
rules: *mut YR_RULES,
buffer: *const u8,
buffer_size: usize,
flags: ::std::os::raw::c_int,
callback: YR_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_scan_file(
rules: *mut YR_RULES,
filename: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
callback: YR_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_scan_fd(
rules: *mut YR_RULES,
fd: ::std::os::raw::c_int,
flags: ::std::os::raw::c_int,
callback: YR_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_scan_proc(
rules: *mut YR_RULES,
pid: ::std::os::raw::c_int,
flags: ::std::os::raw::c_int,
callback: YR_CALLBACK_FUNC,
user_data: *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_save(
rules: *mut YR_RULES,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_save_stream(
rules: *mut YR_RULES,
stream: *mut YR_STREAM,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_load(
filename: *const ::std::os::raw::c_char,
rules: *mut *mut YR_RULES,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_load_stream(
stream: *mut YR_STREAM,
rules: *mut *mut YR_RULES,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_destroy(rules: *mut YR_RULES) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_define_integer_variable(
rules: *mut YR_RULES,
identifier: *const ::std::os::raw::c_char,
value: i64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_define_boolean_variable(
rules: *mut YR_RULES,
identifier: *const ::std::os::raw::c_char,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_define_float_variable(
rules: *mut YR_RULES,
identifier: *const ::std::os::raw::c_char,
value: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_define_string_variable(
rules: *mut YR_RULES,
identifier: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rules_reset_profiling_info(rules: *mut YR_RULES);
}
extern "C" {
pub fn yr_rules_print_profiling_info(rules: *mut YR_RULES);
}
extern "C" {
pub fn yr_rules_get_stats(
rules: *mut YR_RULES,
stats: *mut YR_RULES_STATS,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_rule_disable(rule: *mut YR_RULE);
}
extern "C" {
pub fn yr_rule_enable(rule: *mut YR_RULE);
}
extern "C" {
pub fn yr_initialize() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_finalize() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn yr_finalize_thread();
}
extern "C" {
pub fn yr_get_tidx() -> ::std::os::raw::c_int;
}