name string | code string | asm string | file string |
|---|---|---|---|
archive_read_format_rar_cleanup | static int
archive_read_format_rar_cleanup(struct archive_read *a)
{
struct rar *rar;
rar = (struct rar *)(a->format->data);
free_codes(a);
clear_filters(&rar->filters);
free(rar->filename);
free(rar->filename_save);
free(rar->dbo);
free(rar->unp_buffer);
free(rar->lzss.window);
__archive_ppmd7_fun... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x932f0
movq -0x10(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
callq 0x94c60
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_le16dec | static inline uint16_t
archive_le16dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p1 = p[1];
unsigned int p0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
orl -0x18(%rbp), %eax
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
read_header | static int
read_header(struct archive_read *a, struct archive_entry *entry,
char head_type)
{
const void *h;
const char *p, *endp;
struct rar *rar;
struct rar_header rar_header;
struct rar_file_header file_header;
int64_t header_size;
unsigned filename_size, end;
char *filename;
char *strp... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl $0x0, -0xb4(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x4f18(%rax), %rax
movq %rax, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_le32dec | static inline uint32_t
archive_le32dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p3 = p[3];
unsigned int p2... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
get_time | static time_t
get_time(int ttime)
{
struct tm tm;
tm.tm_sec = 2 * (ttime & 0x1f);
tm.tm_min = (ttime >> 5) & 0x3f;
tm.tm_hour = (ttime >> 11) & 0x1f;
tm.tm_mday = (ttime >> 16) & 0x1f;
tm.tm_mon = ((ttime >> 21) & 0x0f) - 1;
tm.tm_year = ((ttime >> 25) & 0x7f) + 80;
tm.tm_isdst = -1;
return mktime(&tm... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x1f, %eax
shll %eax
movl %eax, -0x40(%rbp)
movl -0x4(%rbp), %eax
sarl $0x5, %eax
andl $0x3f, %eax
movl %eax, -0x3c(%rbp)
movl -0x4(%rbp), %eax
sarl $0xb, %eax
andl $0x1f, %eax
movl %eax, -0x38(%rbp)
movl -0x4(%rbp), %eax
sarl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
read_exttime | static int
read_exttime(const char *p, struct rar *rar, const char *endp)
{
unsigned rmode, flags, rem, j, count;
int ttime, i;
struct tm *tm;
time_t t;
long nsec;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE__LOCALTIME64_S)
struct tm tmbuf;
#endif
#if defined(HAVE__LOCALTIME64_S)
errno_t terr;
__time6... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x8f3f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8f600
movq -0x10(%rbp), %rdi
callq 0x8df20
movzwl %ax, %eax
movl %eax, -0x28(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
read_symlink_stored | static int
read_symlink_stored(struct archive_read *a, struct archive_entry *entry,
struct archive_string_conv *sconv)
{
const void *h;
const char *p;
struct rar *rar;
int ret = (ARCHIVE_OK);
rar = (struct rar *)(a->format->data);
if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NUL... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %eax, %eax
movl %eax, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
read_data_stored | static int
read_data_stored(struct archive_read *a, const void **buff, size_t *size,
int64_t *offset)
{
struct rar *rar;
ssize_t bytes_avail;
rar = (struct rar *)(a->format->data);
if (rar->bytes_remaining == 0 &&
!(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER))
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x8f960
movq -0x30(%rbp), %rax
movl (%rax), %eax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
run_filters | static int
run_filters(struct archive_read *a)
{
struct rar *rar = (struct rar *)(a->format->data);
struct rar_filters *filters = &rar->filters;
struct rar_filter *filter = filters->stack;
size_t start = filters->filterstart;
size_t end = start + filter->blocklength;
uint32_t lastfilteraddress;
uint32_t l... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x390, %rax # imm = 0x390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x2... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
rar_br_preparation | static int
rar_br_preparation(struct archive_read *a, struct rar_br *br)
{
struct rar *rar = (struct rar *)(a->format->data);
if (rar->bytes_remaining > 0) {
br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
if (br->next_in == NULL) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FOR... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jle 0x90a85
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
movl $0x1, %esi
callq 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
parse_codes | static int
parse_codes(struct archive_read *a)
{
int i, j, val, n, r;
unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
unsigned int maxorder;
struct huffman_code precode;
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
free_codes(a);
/* Skip to the next ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $0x4f30, %rax # imm = 0x4F30
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x932f0
movq -0x80(%rbp), %rax
movl 0x8(%rax), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
lzss_emit_match | static inline void
lzss_emit_match(struct rar *rar, int offset, int length)
{
int dstoffs = lzss_current_offset(&rar->lzss);
int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss);
int l, li, remaining;
unsigned char *d, *s;
remaining = length;
while (remaining > 0) {
l = remaining;
if (dstoffs >... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x350, %rdi # imm = 0x350
callq 0x93e50
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x350, %rdi... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
copy_from_lzss_window | static int
copy_from_lzss_window(struct archive_read *a, void *buffer,
int64_t startpos, int length)
{
int windowoffs, firstpart;
struct rar *rar = (struct rar *)(a->format->data);
windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
firstpart = lzss_size(&rar->lzss) - windowoffs;... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x350, %rdi # imm = 0x350
movq -0x20(%rbp), %rsi
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
execute_filter | static int
execute_filter(struct archive_read *a, struct rar_filter *filter, struct rar_virtual_machine *vm, size_t pos)
{
if (filter->prog->fingerprint == 0x1D0E06077D)
return execute_filter_delta(filter, vm);
if (filter->prog->fingerprint == 0x35AD576887)
return execute_filter_e8(filter, vm, pos, 0);
if... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movabsq $0x1d0e06077d, %rcx # imm = 0x1D0E06077D
cmpq %rcx, 0x20(%rax)
jne 0x92494
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
delete_filter | static void
delete_filter(struct rar_filter *filter)
{
while (filter)
{
struct rar_filter *next = filter->next;
free(filter->globaldata);
free(filter);
filter = next;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x925bf
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rdi
callq 0x10470
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9258c
add... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
execute_filter_rgb | static int
execute_filter_rgb(struct rar_filter *filter, struct rar_virtual_machine *vm)
{
uint32_t stride = filter->initialregisters[0];
uint32_t byteoffset = filter->initialregisters[1];
uint32_t blocklength = filter->initialregisters[4];
uint8_t *src, *dst;
uint32_t i, j;
if (blocklength > PROGRAM_WORK_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1e000, -0x24(%rbp) # imm = 0x1E000
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
free_codes | static void
free_codes(struct archive_read *a)
{
struct rar *rar = (struct rar *)(a->format->data);
free(rar->maincode.tree);
free(rar->offsetcode.tree);
free(rar->lowoffsetcode.tree);
free(rar->lengthcode.tree);
free(rar->maincode.table);
free(rar->offsetcode.table);
free(rar->lowoffsetcode.table);
f... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
ppmd_read | static Byte
ppmd_read(void *p)
{
struct archive_read *a = ((IByteIn*)p)->a;
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
Byte b;
if (!rar_br_read_ahead(a, br, 8))
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated RAR file d... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4f30, %rax # imm = 0x4F30
movq %rax, -0x28(%rbp)
movq -0x28(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
rar_fls | static inline int
rar_fls(unsigned int word)
{
word |= (word >> 1);
word |= (word >> 2);
word |= (word >> 4);
word |= (word >> 8);
word |= (word >> 16);
return word - (word >> 1);
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x2, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x4, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
new_node | static int
new_node(struct huffman_code *code)
{
void *new_tree;
if (code->numallocatedentries == code->numentries) {
int new_num_entries = 256;
if (code->numentries > 0) {
new_num_entries = code->numentries * 2;
}
new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree));
if... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x93966
movl $0x100, -0x1c(%rbp) # imm = 0x100
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x93929
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
add_value | static int
add_value(struct archive_read *a, struct huffman_code *code, int value,
int codebits, int length)
{
int lastnode, bitpos, bit;
/* int repeatpos, repeatnode, nextnode; */
free(code->table);
code->table = NULL;
if(length > code->maxlength)
code->maxlength = length;
if(length < code-... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10470
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
make_table | static int
make_table(struct archive_read *a, struct huffman_code *code)
{
if (code->maxlength < code->minlength || code->maxlength > 10)
code->tablesize = 10;
else
code->tablesize = code->maxlength;
code->table =
(struct huffman_table_entry *)calloc(1, sizeof(*code->table)
* ((size_t)1 << code->... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x93bba
movq -0x10(%rbp), %rax
cmpl $0xa, 0x14(%rax)
jle 0x93bc7
movq -0x10(%rbp), %rax
movl $0xa, 0x18(%rax)
jmp 0x93bd5
movq -0x10(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
make_table_recurse | static int
make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
struct huffman_table_entry *table, int depth,
int maxdepth)
{
int currtablesize, i, ret = (ARCHIVE_OK);
if (!code->tree)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x93c83
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x2212e4(%rip), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
read_filter | static int
read_filter(struct archive_read *a, int64_t *end)
{
struct rar *rar = (struct rar *)(a->format->data);
uint8_t flags, val, *code;
uint16_t length, i;
if (!rar_decode_byte(a, &flags))
return 0;
length = (flags & 0x07) + 1;
if (length == 7)
{
if (!rar_decode_byte(a, &val))
return 0... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x94080
cmpl $0x0, %eax
jne 0x93f00
movl $0x0, -0x4(%rbp)
jmp 0x94076
movzbl -0x21(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
parse_filter | static int
parse_filter(struct archive_read *a, const uint8_t *bytes, uint16_t length, uint8_t flags)
{
struct rar *rar = (struct rar *)(a->format->data);
struct rar_filters *filters = &rar->filters;
struct memory_bit_reader br = { 0 };
struct rar_program_code *prog;
struct rar_filter *filter, **nextfilter;
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %cl, %al
movw %dx, %cx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x390, %rax # imm = 0x390
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
membr_next_rarvm_number | static uint32_t
membr_next_rarvm_number(struct memory_bit_reader *br)
{
uint32_t val;
switch (membr_bits(br, 2))
{
case 0:
return membr_bits(br, 4);
case 1:
val = membr_bits(br, 8);
if (val >= 16)
return val;
return 0xFFFFFF00 | (val << 4) | membr_bits(br, 4);
case 2:
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x94870
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
testl %eax, %eax
je 0x94789
jmp 0x94775
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x9479c
jmp 0x9477f
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x947e3
jmp 0x947... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
delete_program_code | static void
delete_program_code(struct rar_program_code *prog)
{
while (prog)
{
struct rar_program_code *next = prog->next;
free(prog->staticdata);
free(prog->globalbackup);
free(prog);
prog = next;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9485b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rdi
callq 0x10470
movq -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
compile_program | static struct rar_program_code *
compile_program(const uint8_t *bytes, size_t length)
{
struct memory_bit_reader br = { 0 };
struct rar_program_code *prog;
// uint32_t instrcount = 0;
uint8_t xor;
size_t i;
xor = 0;
for (i = 1; i < length; i++)
xor ^= bytes[i];
if (!length || xor != bytes[0])
r... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10810
movb $0x0, -0x49(%rbp)
movq $0x1, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x94949
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movzbl (%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
create_filter | static struct rar_filter *
create_filter(struct rar_program_code *prog, const uint8_t *globaldata, uint32_t globaldatalen, uint32_t registers[8], size_t startpos, uint32_t length)
{
struct rar_filter *filter;
filter = calloc(1, sizeof(*filter));
if (!filter)
return NULL;
filter->prog = prog;
filter->glob... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x11580
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x94ad6
movq $0x0, -0x8(%rbp)
jmp 0x94b9f
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
membr_fill | static int
membr_fill(struct memory_bit_reader *br, int bits)
{
while (br->available < bits && br->offset < br->length)
{
br->bits = (br->bits << 8) | br->bytes[br->offset++];
br->available += 8;
}
if (bits > br->available)
{
br->at_eof = 1;
return 0;
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x15(%rbp)
jge 0x94be2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setb %al
movb %al, -0x15(%rbp)
movb -0x1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_support_format_rar5 | int archive_read_support_format_rar5(struct archive *_a) {
struct archive_read* ar;
int ret;
struct rar5* rar;
if(ARCHIVE_OK != (ret = get_archive_read(_a, &ar)))
return ret;
rar = malloc(sizeof(*rar));
if(rar == NULL) {
archive_set_error(&ar->archive, ENOMEM,
"Can't allocate rar5 data");
return ARC... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x94de0
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x94cd4
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x94dd1
movl $0x5330, %edi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_options | static int rar5_options(struct archive_read *a, const char *key,
const char *val) {
(void) a;
(void) key;
(void) val;
/* No options supported in this version. Return the ARCHIVE_WARN code
* to signal the options supervisor that the unpacker didn't handle
* setting this option. */
return ARCHIVE_WARN;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_read_header | static int rar5_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct rar5* rar = get_context(a);
int ret;
if(rar->header_initialized == 0) {
init_header(a);
if ((ret = try_skip_sfx(a)) < ARCHIVE_WARN)
return ret;
rar->header_initialized = 1;
}
if(rar->skipped_magic == 0) {
if(... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x94f85
movq -0x10(%rbp), %rdi
callq 0x956b0
movq -0x10(%rbp), %rdi
callq 0x956e0
movl %eax, -0x24(%rbp)
cmpl $-0x14, %eax
jg... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_read_data | static int rar5_read_data(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset) {
int ret;
struct rar5* rar = get_context(a);
if (size)
*size = 0;
if(rar->file.dir > 0) {
/* Don't process any data if this file entry was declared
* as a directory. This is needed, because entries mark... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x95057
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movb 0x4bc8(%rax), %al
shr... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_read_data_skip | static int rar5_read_data_skip(struct archive_read *a) {
struct rar5* rar = get_context(a);
if(rar->main.solid) {
/* In solid archives, instead of skipping the data, we need to
* extract it, and dispose the result. The side effect of this
* operation will be setting up the initial window buffer state
* ne... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x2c(%rax), %al
andb $0x1, %al
cmpb $0x0, %al
je 0x9521e
jmp 0x951c8
movq -0x18(%rbp), %rax
cmpq $0x0, 0x4ba8(%rax)
jle 0x9521c
movq -0x18(%rbp), %rax
movl 0x8(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
bid_standard | static int bid_standard(struct archive_read* a) {
const uint8_t* p;
char signature[sizeof(rar5_signature_xor)];
rar5_signature(signature);
if(!read_ahead(a, sizeof(rar5_signature_xor), &p))
return -1;
if(!memcmp(signature, p, sizeof(rar5_signature_xor)))
return 30;
return -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x955d0
movq -0x10(%rbp), %rdi
movl $0x8, %esi
leaq -0x18(%rbp), %rdx
callq 0x95620
cmpl $0x0, %eax
jne 0x95445
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x95471
leaq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
bid_sfx | static int bid_sfx(struct archive_read *a)
{
const char *p;
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return -1;
if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
/* This is a PE file */
char signature[sizeof(rar5_signature_xor)];
ssize_t offset = 0x10000;
ssize_t window = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x954b4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x955c2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
try_skip_sfx | static int try_skip_sfx(struct archive_read *a)
{
const char *p;
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return ARCHIVE_EOF;
if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)
{
char signature[sizeof(rar5_signature_xor)];
const void *h;
const char *q;
size_t skip, total = 0... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x95714
movl $0x1, -0x4(%rbp)
jmp 0x9587c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %eax
jne 0x9572d
movq -0x18(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_base_block | static int process_base_block(struct archive_read* a,
struct archive_entry* entry)
{
const size_t SMALLEST_RAR5_BLOCK_SIZE = 3;
struct rar5* rar = get_context(a);
uint32_t hdr_crc, computed_crc;
size_t raw_hdr_size = 0, hdr_size_len, hdr_size;
size_t header_id = 0;
size_t header_flags = 0;
const uint8_t* p;... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x3, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95cb0
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
skip_unprocessed_bytes | static int skip_unprocessed_bytes(struct archive_read* a) {
struct rar5* rar = get_context(a);
int ret;
if(rar->file.bytes_remaining) {
/* Use different skipping method in block merging mode than in
* normal mode. If merge mode is active, rar5_read_data_skip
* can't be used, because it could allow recursive... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x4ba8(%rax)
je 0x95d35
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x95d17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x4ba8(%rax), %rsi
callq 0x95... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
read_var_sized | static int read_var_sized(struct archive_read* a, size_t* pvalue,
size_t* pvalue_len)
{
uint64_t v;
uint64_t v_size = 0;
const int ret = pvalue_len ? read_var(a, &v, &v_size)
: read_var(a, &v, NULL);
if(ret == 1 && pvalue) {
*pvalue = (size_t) v;
}
if(pvalue_len) {
/* Possible data truncation sh... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x95df9
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x96b60
movl %eax, -0x30(%rbp)
jmp 0x95e0d
movq -0x8(%rbp), %rdi
leaq -0x20(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_head_main | static int process_head_main(struct archive_read* a, struct rar5* rar,
struct archive_entry* entry, size_t block_flags)
{
int ret;
size_t extra_data_size = 0;
size_t extra_field_size = 0;
size_t extra_field_id = 0;
size_t archive_flags = 0;
enum MAIN_FLAGS {
VOLUME = 0x0001, /* multi-volume archive... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x95eba
movq -0x10(%rbp), %rdi
lea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_head_service | static int process_head_service(struct archive_read* a, struct rar5* rar,
struct archive_entry* entry, size_t block_flags)
{
/* Process this SERVICE block the same way as FILE blocks. */
int ret = process_head_file(a, rar, entry, block_flags);
if(ret != ARCHIVE_OK)
return ret;
rar->file.service = 1;
/* But... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x96150
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x9610e
movl -0x2c(%rbp), %ea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_head_file | static int process_head_file(struct archive_read* a, struct rar5* rar,
struct archive_entry* entry, size_t block_flags)
{
ssize_t extra_data_size = 0;
size_t data_size = 0;
size_t file_flags = 0;
size_t file_attr = 0;
size_t compression_info = 0;
size_t host_os = 0;
size_t name_size = 0;
uint64_t unpacked_s... | pushq %rbp
movq %rsp, %rbp
subq $0x20c0, %rsp # imm = 0x20C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
scan_for_signature | static int scan_for_signature(struct archive_read* a) {
const uint8_t* p;
const int chunk_size = 512;
ssize_t i;
char signature[sizeof(rar5_signature_xor)];
/* If we're here, it means we're on an 'unknown territory' data.
* There's no indication what kind of data we're reading here.
* It could be some text co... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x200, -0x1c(%rbp) # imm = 0x200
leaq -0x30(%rbp), %rdi
callq 0x955d0
movq -0x10(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
leaq -0x18(%rbp), %rdx
callq 0x95620
cmpl $0x0, %eax
jne 0x96a7c
movl $0x1, -0x4(%rbp)
jmp 0x96aeb
movq $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
read_var | static int read_var(struct archive_read* a, uint64_t* pvalue,
uint64_t* pvalue_len)
{
uint64_t result = 0;
size_t shift, i;
const uint8_t* p;
uint8_t b;
/* We will read maximum of 8 bytes. We don't have to handle the
* situation to read the RAR5 variable-sized value stored at the end of
* the file, becaus... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
leaq -0x40(%rbp), %rdx
callq 0x95620
cmpl $0x0, %eax
jne 0x96b9f
movl $0x0, -0x4(%rbp)
jmp 0x96cb1
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_main_locator_extra_block | static int process_main_locator_extra_block(struct archive_read* a,
struct rar5* rar)
{
uint64_t locator_flags;
enum LOCATOR_FLAGS {
QLIST = 0x01, RECOVERY = 0x02,
};
if(!read_var(a, &locator_flags, NULL)) {
return ARCHIVE_EOF;
}
if(locator_flags & QLIST) {
if(!read_var(a, &rar->qlist_offset, NULL)) ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x96b60
cmpl $0x0, %eax
jne 0x96cef
movl $0x1, -0x4(%rbp)
jmp 0x96d5c
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x96d22
movq -0x10... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
reset_file_context | static void reset_file_context(struct rar5* rar) {
memset(&rar->file, 0, sizeof(rar->file));
blake2sp_init(&rar->file.b2state, 32);
if(rar->main.solid) {
rar->cstate.solid_offset += rar->cstate.write_ptr;
} else {
rar->cstate.solid_offset = 0;
}
rar->cstate.write_ptr = 0;
rar->cstate.last_write_ptr = 0;
r... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi # imm = 0x4BA8
xorl %esi, %esi
movl $0x768, %edx # imm = 0x768
callq 0x10810
movq -0x8(%rbp), %rdi
addq $0x4ba8, %rdi # imm = 0x4BA8
addq $0x70, %rdi
movl $0x20, %esi
callq 0xe09e0
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
free_filters | static void free_filters(struct rar5* rar) {
struct cdeque* d = &rar->cstate.filters;
/* Free any remaining filters. All filters should be naturally
* consumed by the unpacking function, so remaining filters after
* unpacking normally mean that unpacking wasn't successful.
* But still of course we shouldn't le... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x38, %rax
addq $0x4b00, %rax # imm = 0x4B00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x970d0
cmpq $0x0, %rax
jbe 0x97095
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_file_extra_htime | static int parse_file_extra_htime(struct archive_read* a,
struct archive_entry* e, struct rar5* rar, ssize_t* extra_data_size)
{
char unix_time = 0;
size_t flags = 0;
size_t value_len;
enum HTIME_FLAGS {
IS_UNIX = 0x01,
HAS_MTIME = 0x02,
HAS_CTIME = 0x04,
HAS_ATIME = 0x08,
HAS_UNIX_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x95dc0
cmpl $0x0, %eax
jne 0x97356
movl $0x1, -0x4(%rbp)
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_file_extra_owner | static int parse_file_extra_owner(struct archive_read* a,
struct archive_entry* e, ssize_t* extra_data_size)
{
uint64_t flags = 0;
uint64_t value_size = 0;
uint64_t id = 0;
size_t name_len = 0;
size_t name_size = 0;
char namebuf[OWNER_MAXNAMELEN];
const uint8_t* p;
if(!read_var(a, &flags, &value_size))
r... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_htime_item | static int parse_htime_item(struct archive_read* a, char unix_time,
uint64_t* where, ssize_t* extra_data_size)
{
if(unix_time) {
uint32_t time_val;
if(!read_u32(a, &time_val))
return ARCHIVE_EOF;
*extra_data_size -= 4;
*where = (uint64_t) time_val;
} else {
uint64_t windows_time;
if(!read_u64(a, &... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x97c97
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x95d50
cmpl $0x0, %eax
jne 0x97c7b
movl $0x1, -0x4(%rbp)
jmp 0x97cda
movq -0x28(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
use_data | static int use_data(struct rar5* rar, const void** buf, size_t* size,
int64_t* offset)
{
int i;
for(i = 0; i < rar5_countof(rar->cstate.dready); i++) {
struct data_ready *d = &rar->cstate.dready[i];
if(d->used) {
if(buf) *buf = d->buf;
if(size) *size = d->size;
if(offset) *offset = d->offset;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x2, %rax
jge 0x97ea1
movq -0x10(%rbp), %rax
addq $0x38, %rax
addq $0x4b30, %rax # imm = 0x4B30
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
do_unpack | static int do_unpack(struct archive_read* a, struct rar5* rar,
const void** buf, size_t* size, int64_t* offset)
{
enum COMPRESSION_METHOD {
STORE = 0, FASTEST = 1, FAST = 2, NORMAL = 3, GOOD = 4,
BEST = 5
};
if(rar->file.service > 0) {
return do_unstore_file(a, rar, buf, size, offset);
} else {
switch(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb 0x4bc8(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jle 0x97f00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
do_unstore_file | static int do_unstore_file(struct archive_read* a,
struct rar5* rar, const void** buf, size_t* size, int64_t* offset)
{
size_t to_read;
const uint8_t* p;
if(rar->file.bytes_remaining == 0 && rar->main.volume > 0 &&
rar->generic.split_after > 0)
{
int ret;
rar->cstate.switch_multivolume = 1;
ret = a... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x4ba8(%rax)
jne 0x9802d
movq -0x18(%rbp), %rax
movb 0x2c(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
advance_multivolume | static int advance_multivolume(struct archive_read* a) {
int lret;
struct rar5* rar = get_context(a);
/* A small state machine that will skip unnecessary data, needed to
* switch from one multivolume to another. Such skipping is needed if
* we want to be an stream-oriented (instead of file-oriented)
* unpacke... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x2c(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x98213
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movb 0x2c(%rax), %cl
andb $-... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
update_crc | static void update_crc(struct rar5* rar, const uint8_t* p, size_t to_read) {
int verify_crc;
if(rar->skip_mode) {
#if defined CHECK_CRC_ON_SOLID_SKIP
verify_crc = 1;
#else
verify_crc = 0;
#endif
} else
verify_crc = 1;
if(verify_crc) {
/* Don't update CRC32 if the file doesn't have the
* `stored_crc3... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x982a7
movl $0x0, -0x1c(%rbp)
jmp 0x982ae
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x98316
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4bec(%rax)
jbe 0x982e8
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
skip_base_block | static int skip_base_block(struct archive_read* a) {
int ret;
struct rar5* rar = get_context(a);
/* Create a new local archive_entry structure that will be operated on
* by header reader; operations on this archive_entry will be discarded.
*/
struct archive_entry* entry = archive_entry_new();
ret = process_ba... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
callq 0x5bf70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x958e0
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5bf40
cmpl $-0x1e, -0x14(%rbp)
jne 0x98369... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
do_uncompress_file | static int do_uncompress_file(struct archive_read* a) {
struct rar5* rar = get_context(a);
int ret;
int64_t max_end_pos;
if(!rar->cstate.initialized) {
/* Don't perform full context reinitialization if we're
* processing a solid archive. */
if(!rar->main.solid || !rar->cstate.window_buf) {
init_unpack(ra... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
cmpb $0x0, %al
jne 0x98407
movq -0x18(%rbp), %rax
movb 0x2c(%rax), %al
andb $0x1, %al
cmpb $0x0, %al
je 0x983ee
movq -0x18(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
init_unpack | static void init_unpack(struct rar5* rar) {
rar->file.calculated_crc32 = 0;
init_window_mask(rar);
free(rar->cstate.window_buf);
free(rar->cstate.filtered_buf);
if(rar->cstate.window_size > 0) {
rar->cstate.window_buf = calloc(1, rar->cstate.window_size);
rar->cstate.filtered_buf = calloc(1, rar->cstate.wind... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4bf0(%rax)
movq -0x8(%rbp), %rdi
callq 0x96e40
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jle 0x98644
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_block | static int process_block(struct archive_read* a) {
const uint8_t* p;
struct rar5* rar = get_context(a);
int ret;
/* If we don't have any data to be processed, this most probably means
* we need to switch to the next volume. */
if(rar->main.volume && rar->file.bytes_remaining == 0) {
ret = advance_multivolume(... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x2c(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x98759
movq -0x20(%rbp), %rax
cmpq $0x0, 0x4ba8(%rax)
jne 0x98759
movq -0x10(%rbp), %rdi... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
apply_filters | static int apply_filters(struct archive_read* a) {
struct filter_info* flt;
struct rar5* rar = get_context(a);
int ret;
rar->cstate.all_filters_applied = 0;
/* Get the first filter that can be applied to our data. The data
* needs to be fully unpacked before the filter can be run. */
if(CDE_OK == cdeque_front... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x38(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x38, %rax
addq $0x4b00, %rax # imm = 0x4B00
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_block_header | static int parse_block_header(struct archive_read* a, const uint8_t* p,
ssize_t* block_size, struct compressed_block_header* hdr)
{
uint8_t calculated_cksum;
memcpy(hdr, p, sizeof(struct compressed_block_header));
if(bf_byte_count(hdr) > 2) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Un... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x98d80
movzbl %al, %eax
cmpl $0x2, %eax
jle 0x98c5e
movq -0x10(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
merge_block | static int merge_block(struct archive_read* a, ssize_t block_size,
const uint8_t** p)
{
struct rar5* rar = get_context(a);
ssize_t cur_block_size, partial_offset = 0;
const uint8_t* lp;
int ret;
if(rar->merge_mode) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Recursive merge is not allo... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x98df6
movq -0x10(%rbp), %rdi
movl $0x16, %esi
leaq 0x21c707(%rip), %rdx ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_tables | static int parse_tables(struct archive_read* a, struct rar5* rar,
const uint8_t* p)
{
int ret, value, i, w, idx = 0;
uint8_t bit_length[HUFF_BC],
table[HUFF_TABLE_SIZE],
nibble_mask = 0xF0,
nibble_shift = 4;
enum { ESCAPE = 15 };
/* The data for table generation is compressed using a simple RLE-like
*... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movb $-0x10, -0x201(%rbp)
movb $0x4, -0x202(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x14, -0x30(%rbp)
jge 0x99209
movslq -0x2c(%rbp), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
do_uncompress_block | static int do_uncompress_block(struct archive_read* a, const uint8_t* p) {
struct rar5* rar = get_context(a);
uint16_t num;
int ret;
const uint64_t cmask = rar->cstate.window_mask;
const struct compressed_block_header* hdr = &rar->last_block_hdr;
const uint8_t bit_size = 1 + bf_bit_size(hdr);
while(1) {
if(r... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x5328, %rax # imm = 0x5328
movq %rax, -0x38(%rbp)
movq -0x38(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
archive_le16dec | static inline uint16_t
archive_le16dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p1 = p[1];
unsigned int p0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
orl -0x18(%rbp), %eax
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
create_decode_tables | static int create_decode_tables(uint8_t* bit_length,
struct decode_table* table, int size)
{
int code, upper_limit = 0, i, lc[16];
uint32_t decode_pos_clone[rar5_countof(table->decode_pos)];
ssize_t cur_len, quick_data_size;
memset(&lc, 0, sizeof(lc));
memset(table->decode_num, 0, sizeof(table->decode_num));
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10810
movq -0x10(%rbp), %rdi
addq $0xc88, %rdi # imm = 0xC88
xorl %esi, %esi
movl $0x264, %edx # im... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
decode_number | static int decode_number(struct archive_read* a, struct decode_table* table,
const uint8_t* p, uint16_t* num)
{
int i, bits, dist, ret;
uint16_t bitfield;
uint32_t pos;
struct rar5* rar = get_context(a);
if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &bitfield))) {
return ret;
}
bitfield &= 0xfffe;
if... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x3a(%rbp), %rcx
callq 0x9a110
movl %eax, %ecx
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
read_bits_16 | static int read_bits_16(struct archive_read* a, struct rar5* rar,
const uint8_t* p, uint16_t* value)
{
if(rar->bits.in_addr >= rar->cstate.cur_block_size) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_PROGRAMMER,
"Premature end of stream during extraction of data (#2)");
return ARCHIVE_FATAL;
}
int bits... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq 0x5314(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x90(%rcx), %rax
jl 0x9a163
movq -0x10(%rbp), %rdi
movl $0x16, %esi
leaq 0x21b54b(%rip), %rdx # 0x2b569b... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
decode_code_length | static int decode_code_length(struct archive_read* a, struct rar5* rar,
const uint8_t* p, uint16_t code)
{
int lbits, length = 2;
if(code < 8) {
lbits = 0;
length += code;
} else {
lbits = code / 4 - 1;
length += (4 | (code & 3)) << lbits;
}
if(lbits > 0) {
int add;
if(ARCHIVE_OK != read_consume_bi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movl $0x2, -0x2c(%rbp)
movzwl -0x22(%rbp), %eax
cmpl $0x8, %eax
jge 0x9a2ae
movl $0x0, -0x28(%rbp)
movzwl -0x22(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
j... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
read_consume_bits | static int read_consume_bits(struct archive_read* a, struct rar5* rar,
const uint8_t* p, int n, int* value)
{
uint16_t v;
int ret, num;
if(n == 0 || n > 16) {
/* This is a programmer error and should never happen
* in runtime. */
return ARCHIVE_FATAL;
}
ret = read_bits_16(a, rar, p, &v);
if(ret != ARCHI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x9a477
cmpl $0x10, -0x24(%rbp)
jle 0x9a480
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x9a4e0
movq -0x10(%rbp), %rdi
movq -0x1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
copy_string | static int copy_string(struct archive_read* a, int len, int dist) {
struct rar5* rar = get_context(a);
const uint64_t cmask = rar->cstate.window_mask;
const uint64_t write_ptr = rar->cstate.write_ptr +
rar->cstate.solid_offset;
int i;
if (rar->cstate.window_buf == NULL)
return ARCHIVE_FATAL;
/* The unpac... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x88(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
dist_cache_touch | static int dist_cache_touch(struct rar5* rar, int idx) {
int* q = rar->cstate.dist_cache;
int i, dist = q[idx];
for(i = idx; i > 0; i--)
q[i] = q[i - 1];
q[0] = dist;
return dist;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x38, %rax
addq $0x4b20, %rax # imm = 0x4B20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
parse_filter_data | static int parse_filter_data(struct archive_read* a, struct rar5* rar,
const uint8_t* p, uint32_t* filter_data)
{
int i, bytes, ret;
uint32_t data = 0;
if(ARCHIVE_OK != (ret = read_consume_bits(a, rar, p, 2, &bytes)))
return ret;
bytes++;
for(i = 0; i < bytes; i++) {
uint16_t byte;
if(ARCHIVE_OK != (ret... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %ecx
leaq -0x30(%rbp), %r8
callq 0x9a450
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
is_valid_filter_block_start | static int is_valid_filter_block_start(struct rar5* rar,
uint32_t start)
{
const int64_t block_start = (ssize_t) start + rar->cstate.write_ptr;
const int64_t last_bs = rar->cstate.last_block_start;
const ssize_t last_bl = rar->cstate.last_block_length;
if(last_bs == 0 || last_bl == 0) {
/* We didn't have any... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addq 0x70(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x4b48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x4b50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
add_new_filter | static struct filter_info* add_new_filter(struct rar5* rar) {
struct filter_info* f =
(struct filter_info*) calloc(1, sizeof(struct filter_info));
if(!f) {
return NULL;
}
cdeque_push_back(&rar->cstate.filters, cdeque_filter(f));
return f;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x11580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9aa20
movq $0x0, -0x8(%rbp)
jmp 0x9aa4f
movq -0x10(%rbp), %rax
addq $0x38, %rax
addq $0x4b00, %rax # imm = 0x4B00
movq %rax, -0x20(%rbp)
movq -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
run_filter | static int run_filter(struct archive_read* a, struct filter_info* flt) {
int ret;
struct rar5* rar = get_context(a);
free(rar->cstate.filtered_buf);
rar->cstate.filtered_buf = malloc(flt->block_length);
if(!rar->cstate.filtered_buf) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for filt... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x10470
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x116e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
run_delta_filter | static int run_delta_filter(struct rar5* rar, struct filter_info* flt) {
int i;
ssize_t dest_pos, src_pos = 0;
for(i = 0; i < flt->channels; i++) {
uint8_t prev_byte = 0;
for(dest_pos = i;
dest_pos < flt->block_length;
dest_pos += flt->channels)
{
uint8_t byte;
byte = rar->cstate.window_buf[
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x9ad3f
movb $0x0, -0x29(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
run_e8e9_filter | static int run_e8e9_filter(struct rar5* rar, struct filter_info* flt,
int extended)
{
const uint32_t file_size = 0x1000000;
ssize_t i;
circular_memcpy(rar->cstate.filtered_buf,
rar->cstate.window_buf, rar->cstate.window_mask,
rar->cstate.solid_offset + flt->block_start,
rar->cstate.solid_offset + f... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1000000, -0x18(%rbp) # imm = 0x1000000
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
run_arm_filter | static int run_arm_filter(struct rar5* rar, struct filter_info* flt) {
ssize_t i = 0;
uint32_t offset;
circular_memcpy(rar->cstate.filtered_buf,
rar->cstate.window_buf, rar->cstate.window_mask,
rar->cstate.solid_offset + flt->block_start,
rar->cstate.solid_offset + flt->block_start + flt->block_lengt... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
push_data_ready | static int push_data_ready(struct archive_read* a, struct rar5* rar,
const uint8_t* buf, size_t size, int64_t offset)
{
int i;
/* Don't push if we're in skip mode. This is needed because solid
* streams need full processing even if we're skipping data. After
* fully processing the stream, we need to discard ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x9b092
movl $0x0, -0x4(%rbp)
jmp 0x9b1a8
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x4bb8(%rcx), %rcx
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
circular_memcpy | static void circular_memcpy(uint8_t* dst, uint8_t* window, const uint64_t mask,
int64_t start, int64_t end)
{
if((start & mask) > (end & mask)) {
ssize_t len1 = mask + 1 - (start & mask);
ssize_t len2 = end & mask;
memcpy(dst, &window[start & mask], len1);
memcpy(dst + len1, window, len2);
} else {
mem... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
andq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
andq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x9b247
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
push_data | static void push_data(struct archive_read* a, struct rar5* rar,
const uint8_t* buf, int64_t idx_begin, int64_t idx_end)
{
const uint64_t wmask = rar->cstate.window_mask;
const ssize_t solid_write_ptr = (rar->cstate.solid_offset +
rar->cstate.last_write_ptr) & wmask;
idx_begin += rar->cstate.solid_offset;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x78(%rcx), %rax
andq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
verify_checksums | static int verify_checksums(struct archive_read* a) {
int verify_crc;
struct rar5* rar = get_context(a);
/* Check checksums only when actually unpacking the data. There's no
* need to calculate checksum when we're skipping data in solid archives
* (skipping in solid archives is the same thing as unpacking compr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x9b4fc
movl $0x1, -0x14(%rbp)
jmp 0x9b503
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9b5c7
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4bec(%rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
cdeque_free | static void cdeque_free(struct cdeque* d) {
if(!d)
return;
if(!d->arr)
return;
free(d->arr);
d->arr = NULL;
d->beg_pos = -1;
d->end_pos = -1;
d->cap_mask = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9b5f5
jmp 0x9b638
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9b602
jmp 0x9b638
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movw $0xffff, (%rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
archive_read_format_raw_read_header | static int
archive_read_format_raw_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct raw_info *info;
info = (struct raw_info *)(a->format->data);
if (info->end_of_file)
return (ARCHIVE_EOF);
a->archive.archive_format = ARCHIVE_FORMAT_RAW;
a->archive.archive_format_name = "raw";
arc... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x9b7d5
movl $0x1, -0x4(%rbp)
jmp 0x9b82b
movq -0x10(%rbp), %rax
movl $0x90000, 0x10(%rax) #... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_raw.c |
archive_read_format_raw_read_data_skip | static int
archive_read_format_raw_read_data_skip(struct archive_read *a)
{
struct raw_info *info = (struct raw_info *)(a->format->data);
/* Consume the bytes we read last time. */
if (info->unconsumed) {
__archive_read_consume(a, info->unconsumed);
info->unconsumed = 0;
}
info->end_of_file = 1;
return (ARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9b9b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x66cc0
movq -0x10(%rbp), %rax
movq $0x0,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_raw.c |
archive_read_support_format_tar | int
archive_read_support_format_tar(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct tar *tar;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_tar");
tar = (struct tar *)calloc(1, sizeof(*tar));
if (tar == NULL) {
archive_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x21a10a(%rip), %rcx # 0x2b5ba3
callq 0xe9670
movl %eax, -0x28(%rbp)
cmpl $-0x1e, -0x28(%rbp)
jne 0x9bab3
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
archive_read_format_tar_options | static int
archive_read_format_tar_options(struct archive_read *a,
const char *key, const char *val)
{
struct tar *tar;
int ret = ARCHIVE_FAILED;
tar = (struct tar *)(a->format->data);
if (strcmp(key, "compat-2x") == 0) {
/* Handle UTF-8 filenames as libarchive 2.x */
tar->compat_2x = (val != NULL && val[... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffe7, -0x2c(%rbp) # imm = 0xFFFFFFE7
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2173e4(%rip), %rsi # 0x2b321c
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
archive_read_format_tar_read_header | static int
archive_read_format_tar_read_header(struct archive_read *a,
struct archive_entry *entry)
{
/*
* When converting tar archives to cpio archives, it is
* essential that each distinct file have a distinct inode
* number. To simplify this, we keep a static count here to
* assign fake dev/inode numbe... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl 0x28f512(%rip), %eax # 0x32b504
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5dfc0
movq -0x18(%rbp), %rdi
movl 0x28f4f9(%rip), %eax # 0x32b500
addl $0x1, %eax
movl %eax, 0x28f4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
archive_block_is_null | static int
archive_block_is_null(const char *p)
{
unsigned i;
for (i = 0; i < 512; i++)
if (*p++)
return (0);
return (1);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x200, -0x14(%rbp) # imm = 0x200
jae 0x9c812
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x9c805
movl $0x0, -0x4(%rbp)
jmp 0x9c819
jmp 0x9c807
movl -0x14(%rbp), %eax
addl $0x1, %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
tar_atol_base_n | static int64_t
tar_atol_base_n(const char *p, size_t char_cnt, int base)
{
int64_t l, maxval, limit, last_digit_limit;
int digit, sign;
maxval = INT64_MAX;
limit = INT64_MAX / base;
last_digit_limit = INT64_MAX % base;
/* the pointer will not be dereferenced if char_cnt is zero
* due to the way the && operato... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movslq -0x1c(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movslq -0x1c(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
tar_flush_unconsumed | static void
tar_flush_unconsumed(struct archive_read *a, size_t *unconsumed)
{
if (*unconsumed) {
/*
void *data = (void *)__archive_read_ahead(a, *unconsumed, NULL);
* this block of code is to poison claimed unconsumed space, ensuring
* things break if it is in use still.
* currently it WILL break things, s... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9d575
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x66cc0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_Solaris_ACL | static int
header_Solaris_ACL(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h, size_t *unconsumed)
{
const struct archive_entry_header_ustar *header;
size_t size;
int err, acl_type;
int64_t type;
char *acl, *p;
/*
* read_body_to_string adds a NUL terminator, but we need ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x7c, %rdi
movl $0xc, %esi
callq 0x9cb30
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_longlink | static int
header_longlink(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h, size_t *unconsumed)
{
int err;
err = read_body_to_string(a, tar, &(tar->longlink), h, unconsumed);
if (err != ARCHIVE_OK)
return (err);
err = tar_read_header(a, tar, entry, unconsumed);
if ((err !... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x90, %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x9e740
movl %eax, -0x34(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_pax_extensions | static int
header_pax_extensions(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h, size_t *unconsumed)
{
int err, err2;
err = read_body_to_string(a, tar, &(tar->pax_header), h, unconsumed);
if (err != ARCHIVE_OK)
return (err);
/* Parse the next header. */
err = tar_read_h... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0xc0, %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x9e740
movl %eax, -0x34(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
read_mac_metadata_blob | static int
read_mac_metadata_blob(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h, size_t *unconsumed)
{
int64_t size;
size_t msize;
const void *data;
const char *p, *name;
const wchar_t *wp, *wname;
(void)h; /* UNUSED */
wname = wp = archive_entry_pathname_w(entry);
if... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5cb10
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x9e45c
jmp 0x9e3f6
movq -0x60(%rbp), %rax
cmpl $0x0,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
read_body_to_string | static int
read_body_to_string(struct archive_read *a, struct tar *tar,
struct archive_string *as, const void *h, size_t *unconsumed)
{
int64_t size;
const struct archive_entry_header_ustar *header;
const void *src;
(void)tar; /* UNUSED */
header = (const struct archive_entry_header_ustar *)h;
size = tar_at... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x7c, %rdi
movl $0xc, %esi
callq 0x9cb30
movq %rax, -0x38(%rbp)
cmpq $0x100000, -0x38(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
pax_header | static int
pax_header(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, struct archive_string *in_as)
{
size_t attr_length, l, line_length, value_length;
char *p;
char *key, *value;
struct archive_string *as;
struct archive_string_conv *sconv;
int err, err2;
char *attr = in_as->s;
attr_... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.