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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x52ca98
movq 0x3a0(%r14), %rdi
callq 0x52c762
movq 0x398(%r14), %rdi
callq 0x52d41d
movq 0x390(%r14), %rdi
callq 0x41e70
movq 0x48(%r14), %rdi
callq 0x41e70
movq 0x50(%r14), %rdi
callq 0x41e70
movq 0x100(%r1... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
leaq 0x2(%rdi), %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rbx, %rdx
ja 0x52a721
movzwl (%rdi), %r14d
leaq 0x30(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsi), %rax
movq %rax, 0x38(%rsp)
leaq 0x78(%rsi)... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rsi), %rax
movq 0x20(%rax), %rax
movabsq $0x393cd7e57d, %r8 # imm = 0x393CD7E57D
cmpq %r8, %rax
jle 0x52c570
movabsq $0x393cd7e57e, %r8 # imm = 0x393CD7E57E
cmpq %r8, %rax
je 0x52c5a3
movabsq $0x951c2c5dc8, %rcx # im... | /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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r15
movl 0x4f38(%r15), %ecx
cmpl $0x7, %ecx
jg 0x52cb5f
leaq 0x4f30(%r15), %rsi
movq %rbx, %rdi
callq 0x52c83c
testl %eax, %eax
setne %al
movl 0x4f38(%r15), %ecx
cmpl $0x8, %ecx
setge %dl
orb %al, %dl
je 0x52cb75
movq 0x4f30(%r15), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
create_code | static int
create_code(struct archive_read *a, struct huffman_code *code,
unsigned char *lengths, int numsymbols, char maxlength)
{
int i, j, codebits = 0, symbolsleft = numsymbols;
code->numentries = 0;
code->numallocatedentries = 0;
if (new_node(code) < 0) {
archive_set_error(&a->archive, ENO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rsi)
movq %rsi, %rdi
callq 0x52cf2a
testl %eax, %eax
js 0x52cd31
movq %rbx, 0x8(%rsp)
movl $0x1, 0x8(%r15)
movabsq $-0x7fffffff80000001, %rax # imm = 0x80000... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
read_next_symbol | static int
read_next_symbol(struct archive_read *a, struct huffman_code *code)
{
unsigned char bit;
unsigned int bits;
int length, value, node;
struct rar *rar;
struct rar_br *br;
if (!code->table)
{
if (make_table(a, code) != (ARCHIVE_OK))
return -1;
}
rar = (struct rar *)(a->format->data... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rsi)
je 0x52ceb5
movq 0x818(%rbx), %rax
movq (%rax), %r12
leaq 0x4f30(%r12), %r15
movl 0x4f38(%r12), %edx
movl 0x18(%r14), %esi
cmpl %esi, %edx
jge 0x52cdf7
movq %rbx, %rdi
movq %r15, %rsi
callq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
rar_decode_byte | static int
rar_decode_byte(struct archive_read *a, uint8_t *byte)
{
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
if (!rar_br_read_ahead(a, br, 8))
return 0;
*byte = (uint8_t)rar_br_bits(br, 8);
rar_br_consume(br, 8);
return 1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movl 0x4f38(%r14), %ecx
cmpl $0x7, %ecx
jg 0x52d12b
leaq 0x4f30(%r14), %rsi
callq 0x52c83c
testl %eax, %eax
setne %al
movl 0x4f38(%r14), %ecx
cmpl $0x8, %ecx
setge %dl
orb %al, %dl
xorl %eax, %eax
cmpb $0x1, %dl
jne 0x52d147
movq ... | /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;
}
} | testq %rdi, %rdi
je 0x52d455
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x30(%rbx), %r14
callq 0x41e70
movq 0x10(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
movq %r14, %rbx
testq %r14, %r14
jne 0x52d429
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18ff5e(%rip), %rcx # 0x6bd3cb
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x52d572
movl $0x1, %edi
movl $0x5330, %e... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rcx, %r8
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x818(%rdi), %rcx
movq (%rcx), %r14
testq %rax, %rax
je 0x52d84c
movq $0x0, (%rax)
movb 0x4bc8(%r14), %cl
testb $0x8, %cl
jne 0x52d889
cmpl $0x... | /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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
testb $0x1, 0x2c(%r15)
jne 0x52edaf
movq 0x4ba8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x511e26
movq %rax, %rcx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpq %r14, %rcx
jne 0x52eda9
movq $0x0, 0x4ba8(%r15)
xorl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_cleanup | static int rar5_cleanup(struct archive_read *a) {
struct rar5* rar = get_context(a);
free(rar->cstate.window_buf);
free(rar->cstate.filtered_buf);
free(rar->vol.push_buf);
free_filters(rar);
cdeque_free(&rar->cstate.filters);
free(rar);
a->format->data = NULL;
return ARCHIVE_OK;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x50(%r14), %rdi
callq 0x41e70
movq 0x58(%r14), %rdi
callq 0x41e70
movq 0x5320(%r14), %rdi
callq 0x41e70
movq %r14, %rdi
callq 0x53033e
movq 0x4b40(%r14), %rdi
testq %rdi, %rdi
je 0x52ee2a
callq 0x41e70
movq %r14, %rdi
callq ... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x4ba8(%r14), %r12
testq %r12, %r12
je 0x52eebc
cmpl $0x0, 0xc(%r14)
je 0x52eeaa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x511e26
movl $0xffffffe2, %ebp # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
read_u32 | static int read_u32(struct archive_read* a, uint32_t* pvalue) {
const uint8_t* p;
if(!read_ahead(a, 4, &p))
return 0;
*pvalue = archive_le32dec(p);
return ARCHIVE_OK == consume(a, 4) ? 1 : 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl $0x4, %esi
callq 0x511af8
testq %rax, %rax
je 0x52f115
movl (%rax), %eax
movl %eax, (%r14)
movl $0x4, %esi
movq %rbx, %rdi
callq 0x511e26
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x4, %rcx
sete %al
jmp 0x52f117
xorl %e... | /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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %bpl
testb $0x1, %dl
je 0x52f152
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
cmpq $0x0, (%rsp)
sete %bpl
xorl %r15d, %r15d
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
cal... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp # imm = 0x2028
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %rdx, %rdi
callq 0x50bfd0
testb $0x4, 0x38(%rbx)
jne 0x52f33b
leaq 0x4ba8(%rbx), %r... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl $0x8, %esi
callq 0x511af8
testq %rax, %rax
je 0x52f942
movl $0x1, %r12d
xorl %ecx, %ecx
xorl %edx, %edx
movq %rdx, %rsi
movzbl -0x1(%rax,%r12), %edi
movl %edi, %edx
andl $0x7f, ... | /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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x52f892
movl $0x1, %ebx
testl %eax, %eax
je 0x52f9af
movq 0x8(%rsp), %rax
testb $0x1, %al
je 0x52f994
leaq 0x10(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x5... | /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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
callq 0x50c361
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52ee53
movl %eax, %ebx
movq %r14, %rdi
callq 0x50c34f
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ebx
je 0x530747
cmpl $0x2, 0x28(%r15)
jne 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
push_window_data | static void push_window_data(struct archive_read* a, struct rar5* rar,
int64_t idx_begin, int64_t idx_end)
{
push_data(a, rar, rar->cstate.window_buf, idx_begin, idx_end);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %r12
movq 0x50(%rsi), %r15
movq 0x68(%rsi), %rcx
movq 0x88(%rsi), %rsi
movq 0x78(%r14), %r8
leaq (%r8,%rsi), %rdx
andq %rcx, %rdx
addq %rsi, %rax
addq %rsi, %rbx
movq %rax, %rsi
andq %rcx, %rsi
movq %rbx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
leaq 0xc88(%rsi), %r15
xorl %ebp, %ebp
movl $0x264, %edx # imm = 0x264... | /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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r15
leaq 0xe(%rsp), %rcx
movq %r15, %rsi
callq 0x530aae
testl %eax, %eax
jne 0x530aa4
movzwl 0xe(%rsp), %eax
andl $-0x2, %eax
movl 0x84(%r14), %edx
cmpl %eax, 0x4(%r14,%rdx,4)
jle 0x530a3e
movb $0x10, ... | /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... | movq %rcx, %rax
movslq 0x5314(%rsi), %rcx
cmpq %rcx, 0x90(%rsi)
jle 0x530aed
movzbl (%rdx,%rcx), %edi
shll $0x10, %edi
movzbl 0x1(%rdx,%rcx), %r8d
shll $0x8, %r8d
orl %edi, %r8d
movzbl 0x2(%rdx,%rcx), %edx
orl %r8d, %edx
movb $0x8, %cl
subb 0x5310(%rsi), %cl
shrl %cl, %edx
movw %dx, (%rax)
xorl %eax, %eax
retq
pushq %r... | /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... | movq 0x818(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x530e76
movl $0x1, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x90000, 0x10(%rdi) # imm = 0x90000
leaq 0x115e68(%rip), %rax # 0x646cf6
movq %rax, 0x18(%rdi)
leaq 0x18abae(%rip), %rsi # 0x6bba47
movq %rbx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_raw.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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movslq 0x33a371(%rip), %rsi # 0x86b714
incq %rsi
movq %rbx, %rdi
callq 0x50d2cc
movslq 0x33a35b(%rip), %rsi # 0x86b710
incq %rsi
movl %esi, 0x33a352(%rip) # 0x86b710
movq %rbx, %rdi
call... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
archive_read_format_tar_cleanup | static int
archive_read_format_tar_cleanup(struct archive_read *a)
{
struct tar *tar;
tar = (struct tar *)(a->format->data);
gnu_clear_sparse_list(tar);
archive_string_free(&tar->acl_text);
archive_string_free(&tar->entry_pathname);
archive_string_free(&tar->entry_pathname_override);
archive_string_free(&tar->e... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0x5317e0
movq (%rdi), %rax
movq %rax, 0x140(%r14)
callq 0x41e70
jmp 0x5317c3
xorl %r15d, %r15d
movq %r15, 0x148(%r14)
movq %r14, %rdi
callq 0x539f3f
leaq 0x18(%r14), %rdi
callq 0x539f3f
l... | /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... | movl %edx, %ecx
movl %edx, %r10d
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movq %r8, %rax
xorl %edx, %edx
divq %r10
xorl %r9d, %r9d
testq %rsi, %rsi
je 0x531bb1
pushq %r14
pushq %rbx
xorl %r9d, %r9d
xorl %r11d, %r11d
movzbl (%rdi,%r11), %ebx
cmpl $0x9, %ebx
je 0x531af6
cmpl $0x20, %ebx
jne 0x531b03
in... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
tar_read_header | static int
tar_read_header(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, size_t *unconsumed)
{
ssize_t bytes;
int err, eof_vol_header;
const char *h;
const struct archive_entry_header_ustar *header;
const struct archive_entry_header_gnutar *gnuheader;
eof_vol_header = 0;
/* Loop unt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rcx), %rsi
leaq 0x20(%rsp), %rbp
leaq 0x194ce6(%rip), %r14 # 0x6c68c6
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
je 0x531bf9
movq %r12, %rdi
callq 0x511e26
movq $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
gnu_add_sparse_entry | static int
gnu_add_sparse_entry(struct archive_read *a, struct tar *tar,
int64_t offset, int64_t remaining)
{
struct sparse_block *p;
p = (struct sparse_block *)calloc(1, sizeof(*p));
if (p == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
if (tar->sparse_last !... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x41eb8
testq %rax, %rax
je 0x53259f
movq 0x148(%r12), %rcx
leaq 0x140(%r12), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %rax, 0x148(%r12)
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_ustar | static int
header_ustar(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h)
{
const struct archive_entry_header_ustar *header;
struct archive_string *as;
int err = ARCHIVE_OK, r;
header = (const struct archive_entry_header_ustar *)h;
/* Copy name into an internal buffer to en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18(%rsi), %r13
cmpb $0x0, 0x159(%rcx)
movq $0x0, 0x20(%rsi)
je 0x533a4b
leaq 0x159(%r15), %rsi
movl $0x9b, %edx
movq %r13, %rdi
callq 0x53a01f
movq 0x18(%rbx), %rax
movq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_old_tar | static int
header_old_tar(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h)
{
const struct archive_entry_header_ustar *header;
int err = ARCHIVE_OK, err2;
/* Copy filename over (to ensure null termination). */
header = (const struct archive_entry_header_ustar *)h;
if (archiv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x190(%rsi), %rcx
movl $0x64, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x50d517
xorl %r13d, %r13d
movl $0x0, %ebp
testl %eax, %eax
je 0x533c10
movq 0x190(%rbx), %rsi
leaq 0... | /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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x7c(%rdx), %rdi
movl $0xc, %esi
callq 0x531a01
cmpq $0x100001, %rax # imm = 0x100001
jb 0x533db4
leaq 0x18a155(%rip), %rdx # 0x6bdeff
movq %r12, %rdi
movl $0x16, %esi
jmp 0x533e25
movq %rax, %r15
leaq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
gnu_sparse_old_parse | static int
gnu_sparse_old_parse(struct archive_read *a, struct tar *tar,
const struct gnu_sparse *sparse, int length)
{
while (length > 0 && sparse->offset[0] != 0) {
if (gnu_add_sparse_entry(a, tar,
tar_atol(sparse->offset, sizeof(sparse->offset)),
tar_atol(sparse->numbytes, sizeof(sparse->numbytes)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x5345d8
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incl %ebp
cmpb $0x0, (%r14)
je 0x5345d8
movl $0xc, %esi
movq %r14, %rdi
callq 0x531a01
movq %rax, %r13
addq $0xc, %r14
movl $0xc, %es... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
warc_read | static int
_warc_read(struct archive_read *a, const void **buf, size_t *bsz, int64_t *off)
{
struct warc_s *w = a->format->data;
const char *rab;
ssize_t nrd;
if (w->cntoff >= w->cntlen) {
eof:
/* it's our lucky day, no work, we can leave early */
*buf = NULL;
*bsz = 0U;
*off = w->cntoff + 4U/*for \r\n\r\... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbp
movq 0x8(%rbp), %rax
cmpq (%rbp), %rax
jae 0x535078
movq %rdi, %r12
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x535030
movq %r12, %rdi
callq 0x511e26
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
warc_cleanup | static int
_warc_cleanup(struct archive_read *a)
{
struct warc_s *w = a->format->data;
if (w->pool.len > 0U) {
free(w->pool.str);
}
archive_string_free(&w->sver);
free(w);
a->format->data = NULL;
return (ARCHIVE_OK);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x5350ee
movq 0x20(%r14), %rdi
callq 0x41e70
leaq 0x30(%r14), %rdi
callq 0x539f3f
movq %r14, %rdi
callq 0x41e70
movq 0x818(%rbx), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
archive_read_format_zip_streamable_read_header | static int
archive_read_format_zip_streamable_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct zip *zip;
a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
if (a->archive.archive_format_name == NULL)
a->archive.archive_format_name = "ZIP";
zip = (struct zip *)(a->format->data);
/*
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50000, 0x10(%rdi) # imm = 0x50000
cmpq $0x0, 0x18(%rdi)
jne 0x535ac7
leaq 0x185355(%rip), %rax # 0x6bae18
movq %rax, 0x18(%rbx)
movq 0x818(%rbx), %rax
movq (%rax), %r15
cmpl $-0x1, 0x38(%r15)
jne 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_local_file_header | static int
zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry,
struct zip *zip)
{
const char *p;
const void *h;
const wchar_t *wp;
const char *cp;
size_t len, filename_length, extra_length;
struct archive_string_conv *sconv;
struct zip_entry *zip_entry = zip->entry;
struct zip_en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x70(%rdx), %r15
movq 0x28(%r15), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%r15), %rbp
movl 0x78(%r15), %eax
movl %eax, 0x20(%rsp)
movw $0x0, 0xa1(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_time | static time_t
zip_time(const char *p)
{
int msTime, msDate;
struct tm ts;
msTime = (0xff & (unsigned)p[0]) + 256 * (0xff & (unsigned)p[1]);
msDate = (0xff & (unsigned)p[2]) + 256 * (0xff & (unsigned)p[3]);
memset(&ts, 0, sizeof(ts));
ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
ts.tm_mon =... | subq $0x38, %rsp
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %edx
movl %edx, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %esi
movzbl 0x3(%rdi), %r8d
movl %r8d, %r9d
shll $0x8, %r9d
orl %esi, %r9d
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
shrl %r8d
addl $0x50, %r8d
movl %r8... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
trad_enc_decrypt_update | static void
trad_enc_decrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in,
size_t in_len, uint8_t *out, size_t out_len)
{
unsigned i, max;
max = (unsigned)((in_len < out_len)? in_len: out_len);
for (i = 0; i < max; i++) {
uint8_t t = in[i] ^ trad_enc_decrypt_byte(ctx);
out[i] = t;
trad_enc_update_k... | cmpq %r8, %rdx
cmovbq %rdx, %r8
testl %r8d, %r8d
je 0x53863c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %r8d, %r12d
xorl %r13d, %r13d
movl 0x8(%r15), %eax
orl $0x2, %eax
movl %eax, %ecx
xorl $0x1, %ecx
imull %eax, %ecx
shrl $0x8, %ecx
xorb (%r14,%r13), %c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
check_authentication_code | static int
check_authentication_code(struct archive_read *a, const void *_p)
{
struct zip *zip = (struct zip *)(a->format->data);
/* Check authentication code. */
if (zip->hctx_valid) {
const void *p;
uint8_t hmac[20];
size_t hmac_len = 20;
int cmp;
archive_hmac_sha1_final(&zip->hctx, hmac, &hmac_len);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rdi
xorl %ebp, %ebp
cmpb $0x0, 0x1ff0(%rdi)
je 0x538701
movq %rsi, %r14
leaq 0x20(%rsp), %rdx
movq $0x14, (%rdx)
leaq 0x324c67(%rip), %rax # 0x85d2e0
addq $0x1fe8, %rdi # imm = 0x1FE8
movq %rsp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
consume_optional_marker | static int
consume_optional_marker(struct archive_read *a, struct zip *zip)
{
if (zip->end_of_entry && (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) {
const char *p;
if (NULL == (p = __archive_read_ahead(a, 24, NULL))) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP end-... | xorl %eax, %eax
cmpb $0x0, 0xa2(%rsi)
je 0x538802
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x70(%rsi), %rcx
testb $0x8, 0x7e(%rcx)
je 0x5387fb
movq %rdi, %r14
movl $0x18, %esi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x538790
cmpb $0x50, (%rax)
jne 0x538769
cmpb $0x4b, 0x1(%rax)
jne 0x538769
cmpb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
init_WinZip_AES_decryption | static int
init_WinZip_AES_decryption(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
const void *p;
const uint8_t *pv;
size_t key_len, salt_len;
uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE];
int retry;
int r;
if (zip->cctx_valid || zip->hctx_valid)
return (ARCHIVE_OK);
switch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x818(%rdi), %rax
movq (%rax), %r12
xorl %eax, %eax
cmpb $0x0, 0x1fe0(%r12)
jne 0x538cbd
cmpb $0x0, 0x1ff0(%r12)
jne 0x538cbd
movq %rdi, %rbx
movq 0x70(%r12), %rax
movl 0x88(%rax), %eax
cmpl $0x1, %eax
je 0x538ab3
cmpl $0x3, %eax
je... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_data_zipx_zstd | static int
zip_read_data_zipx_zstd(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip *zip = (struct zip *)(a->format->data);
ssize_t bytes_avail = 0, in_bytes, to_consume;
const void *compressed_buff;
int r;
size_t ret;
uint64_t total_out;
ZSTD_outBuffer out;
ZSTD_inBuff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq $0x0, (%rsp)
cmpb $0x0, 0xa1(%r14)
je 0x5397da
movq %rsp, %r13
movl $0x1, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x511af8
movq (%r13), %rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_alloc_decryption_buffer | static int
zip_alloc_decryption_buffer(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
size_t bs = 256 * 1024;
if (zip->decrypted_buffer == NULL) {
zip->decrypted_buffer_size = bs;
zip->decrypted_buffer = malloc(bs);
if (zip->decrypted_buffer == NULL) {
archive_set_error(&a->ar... | pushq %r14
pushq %rbx
pushq %rax
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x1f50(%r14), %rax
testq %rax, %rax
jne 0x539c89
movq %rdi, %rbx
movq $0x40000, 0x1f60(%r14) # imm = 0x40000
movl $0x40000, %edi # imm = 0x40000
callq 0x41ec0
movq %rax, 0x1f50(%r14)
testq %rax, %rax
je 0x539c9a
movq %rax, 0x1f58(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
ppmd_read | static Byte
ppmd_read(void* p) {
/* Get the handle to current decompression context. */
struct archive_read *a = ((IByteIn*)p)->a;
struct zip *zip = (struct zip*) a->format->data;
ssize_t bytes_avail = 0;
/* Fetch next byte. */
const uint8_t* data = __archive_read_ahead(a, 1, &bytes_avail);
if(bytes_avail < 1) ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r12
movq %rsp, %r15
movq $0x0, (%r15)
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x511af8
cmpq $0x0, (%r15)
jle 0x539d09
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x511e26
incq 0x238(%r12... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_strncat | struct archive_string *
archive_strncat(struct archive_string *as, const void *_p, size_t n)
{
size_t s;
const char *p, *pp;
p = (const char *)_p;
/* Like strlen(p), except won't examine positions beyond p[n]. */
s = 0;
pp = p;
while (s < n && *pp) {
pp++;
s++;
}
if ((as = archive_string_append(as, p, s)... | pushq %rax
testq %rdx, %rdx
je 0x53a03d
movq %rdx, %rax
xorl %edx, %edx
cmpb $0x0, (%rsi,%rdx)
je 0x53a03f
incq %rdx
cmpq %rdx, %rax
jne 0x53a02a
movq %rax, %rdx
jmp 0x53a03f
xorl %edx, %edx
callq 0x539e36
testq %rax, %rax
je 0x53a04b
popq %rcx
retq
leaq 0x129cc3(%rip), %rsi # 0x663d15
movl $0x1, %edi
callq 0x53e2db... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
free_sconv_object | static void
free_sconv_object(struct archive_string_conv *sc)
{
free(sc->from_charset);
free(sc->to_charset);
archive_string_free(&sc->utftmp);
#if HAVE_ICONV
if (sc->cd != (iconv_t)-1)
iconv_close(sc->cd);
if (sc->cd_w != (iconv_t)-1)
iconv_close(sc->cd_w);
#endif
free(sc);
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x41e70
movq 0x10(%rbx), %rdi
callq 0x41e70
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
popq %rbx
jmp 0x41e70
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_mstring_copy_utf8 | int
archive_mstring_copy_utf8(struct archive_mstring *aes, const char *utf8)
{
if (utf8 == NULL) {
aes->aes_set = 0;
return (0);
}
aes->aes_set = AES_SET_UTF8;
archive_string_empty(&(aes->aes_mbs));
archive_string_empty(&(aes->aes_wcs));
archive_strncpy(&(aes->aes_utf8), utf8, strlen(utf8));
retur... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x53aee5
movq %rsi, %rbx
movl $0x2, 0x60(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x38(%r14)
movq %rax, 0x20(%r14)
addq $0x18, %r14
movq %rsi, %rdi
callq 0x3fd60
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x53a01f
movq %rbx, %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
strncat_from_utf8_libarchive2 | static int
strncat_from_utf8_libarchive2(struct archive_string *as,
const void *_p, size_t len, struct archive_string_conv *sc)
{
const char *s;
int n;
char *p;
char *end;
uint32_t unicode;
#if HAVE_WCRTOMB
mbstate_t shift_state;
memset(&shift_state, 0, sizeof(shift_state));
#else
/* Clear the shift state ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, 0x18(%rsp)
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
movq %rdi, 0x8(%rsp)
callq 0x539f80
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x53b2b2
movq 0x8(%rsp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_string_append_unicode | static int
archive_string_append_unicode(struct archive_string *as, const void *_p,
size_t len, struct archive_string_conv *sc)
{
const char *s;
char *p, *endp;
uint32_t uc;
size_t w;
int n, ret = 0, ts, tm;
int (*parse)(uint32_t *, const char *, size_t);
size_t (*unparse)(char *, size_t, uint32_t);
if (sc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl 0x24(%rcx), %eax
leaq 0x25ba(%rip), %rcx # 0x53d8a0
movq %rcx, 0x8(%rsp)
movl $0x2, %r15d
movb $0x1, %r14b
btl $0xa, %eax
jb 0x53b35a
btl $0xc, %eax
jb 0x53b337
btl $0x8, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
strncat_from_utf8_to_utf8 | static int
strncat_from_utf8_to_utf8(struct archive_string *as, const void *_p,
size_t len, struct archive_string_conv *sc)
{
const char *s;
char *p, *endp;
int n, ret = 0;
(void)sc; /* UNUSED */
if (archive_string_ensure(as, as->length + len + 1) == NULL)
return (-1);
s = (const char *)_p;
p = as->s + ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x539f80
testq %rax, %rax
je 0x53d56b
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x8(%rbx), %r13
addq %rax, %r13
leaq (%rax,%rc... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
best_effort_strncat_in_locale | static int
best_effort_strncat_in_locale(struct archive_string *as, const void *_p,
size_t length, struct archive_string_conv *sc)
{
size_t remaining;
const uint8_t *itp;
int return_value = 0; /* success */
/*
* If both from-locale and to-locale is the same, this makes a copy.
* And then this checks all co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x0, 0x20(%rcx)
je 0x53d5fa
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x539e36
testq %rax, %rax
je 0x53d66f
movq $0x0, (%rsp)
xorl %ebp, %ebp
testq %r12, %r12
je 0x53d674
leaq 0xc(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
utf8_to_unicode | static int
_utf8_to_unicode(uint32_t *pwc, const char *s, size_t n)
{
static const char utf8_count[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 00 - 0F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 10 - 1F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 20 - 2F */
1, 1, 1, 1, 1, 1... | xorl %eax, %eax
testq %rdx, %rdx
je 0x53d6d4
movzbl (%rsi), %ecx
testl %ecx, %ecx
je 0x53d6d4
leaq 0x181b58(%rip), %rax # 0x6bf1f0
movsbl (%rcx,%rax), %eax
cmpl %eax, %edx
jge 0x53d6d5
cmpl $0x2, %edx
jl 0x53d6c5
movl %edx, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl $0x1, %r8d
movb (%rsi,%r8), %cl
and... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
unicode_to_utf8 | static size_t
unicode_to_utf8(char *p, size_t remaining, uint32_t uc)
{
char *_p = p;
/* Invalid Unicode char maps to Replacement character */
if (uc > UNICODE_MAX)
uc = UNICODE_R_CHAR;
/* Translate code point to UTF8 */
if (uc <= 0x7f) {
if (remaining == 0)
return (0);
*p++ = (char)uc;
} else if (uc <=... | cmpl $0x110000, %edx # imm = 0x110000
movl $0xfffd, %ecx # imm = 0xFFFD
cmovbl %edx, %ecx
cmpl $0x7f, %ecx
ja 0x53d972
testq %rsi, %rsi
je 0x53d9d0
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
jmp 0x53da01
cmpl $0x7ff, %ecx # imm = 0x7FF
ja 0x53d998
cmpq $0x2, %rsi
jb 0x53d9d0
movl %ecx, %eax
shrl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
_archive_write_open_filter | static int
__archive_write_open_filter(struct archive_write_filter *f)
{
int ret;
ret = ARCHIVE_OK;
if (f->next_filter != NULL)
ret = __archive_write_open_filter(f->next_filter);
if (ret != ARCHIVE_OK)
return (ret);
if (f->state != ARCHIVE_WRITE_FILTER_STATE_NEW)
return (ARCHIVE_FATAL);
if (f->open == NULL... | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x53f40e
callq 0x53f3f8
testl %eax, %eax
jne 0x53f442
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $0x1, 0x5c(%rbx)
jne 0x53f442
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x53f438
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
movl $0x2, %edx
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write.c |
archive_write_disk_set_acls | int
archive_write_disk_set_acls(struct archive *a, int fd, const char *name,
struct archive_acl *abstract_acl, __LA_MODE_T mode)
{
(void)a; /* UNUSED */
(void)fd; /* UNUSED */
(void)name; /* UNUSED */
(void)abstract_acl; /* UNUSED */
(void)mode; /* UNUSED */
return (ARCHIVE_OK);
} | xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_write_disk_free | static int
_archive_write_disk_free(struct archive *_a)
{
struct archive_write_disk *a;
int ret;
if (_a == NULL)
return (ARCHIVE_OK);
archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
a = (struct archive_write_disk *)_a;
ret = _archive_wr... | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x53f9f6
movq %rdi, %rbx
leaq 0x1862a5(%rip), %rcx # 0x6c5bd3
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0xffff, %edx # imm = 0xFFFF
callq 0x55de18
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x53f9f8
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_write_disk_finish_entry | static int
_archive_write_disk_finish_entry(struct archive *_a)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
int ret = ARCHIVE_OK;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_write_finish_entry");
if (a->archive.state... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1854a0(%rip), %rcx # 0x6c5a4a
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x6, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x540cbc
xorl %ebp, %ebp
testb $0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_write_disk_data_block | static ssize_t
_archive_write_disk_data_block(struct archive *_a,
const void *buff, size_t size, int64_t offset)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
ssize_t r;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_DATA, "archive_write_data_block");
a->offs... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1852a2(%rip), %rcx # 0x6c602e
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x4, %edx
callq 0x55de18
movl %eax, %ecx
movq $-0x1e, %rax
cmpl $-0x1e, %ecx
je 0x540ded
movq %r12, 0x208(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
set_times | static int
set_times(struct archive_write_disk *a,
int fd, int mode, const char *name,
time_t atime, long atime_nanos,
time_t birthtime, long birthtime_nanos,
time_t mtime, long mtime_nanos,
time_t cctime, long ctime_nanos)
{
/* Note: set_time doesn't use libarchive return conventions!
* It uses ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rsp), %rax
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rsp, %rax
testl %esi, %esi
js 0x540fd5
movl %esi, %edi
movq %rax, %rsi
callq 0x3f550
jmp 0x540fea
movl $0xffffff9c, %edi # imm = 0xFFFFFF9C
movq %rdx, %rsi
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_write_add_filter_bzip2 | int
archive_write_add_filter_bzip2(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_bzi... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x53e895
movq %rax, %rbx
leaq 0x1840db(%rip), %rcx # 0x6c6073
movq %r14, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x54202a
movl $0x1, %edi
movl $0x70,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_compressor_bzip2_open | static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r15
movq 0x60(%r15), %rax
testq %rax, %rax
je 0x542142
movq 0x68(%r15), %r14
jmp 0x542199
movq 0x8(%rbx), %rdi
movl $0x10000, %r14d # imm = 0x10000
cmpl $0xb0c5c0de, (%rdi) # imm = 0xB0C5C0DE
jne 0x542180
callq 0x53e7ac... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_compressor_bzip2_write | static int
archive_compressor_bzip2_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *data = (struct private_data *)f->data;
/* Update statistics */
data->total_in += length;
/* Compress input data to output buffer */
SET_NEXT_IN(data, buff);
data->stream.avail_in... | pushq %rax
movq 0x40(%rdi), %rax
addq %rdx, 0x58(%rax)
movq %rsi, 0x8(%rax)
movl %edx, 0x10(%rax)
movq %rax, %rsi
xorl %edx, %edx
callq 0x54229f
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_write_add_filter_compress | int
archive_write_add_filter_compress(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_compress");
f->open = &arch... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x53e895
movq %rax, %rbx
leaq 0x183e1c(%rip), %rcx # 0x6c6188
movq %r14, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x5423a9
leaq 0x20(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c |
zisofs_detect_magic | static void
zisofs_detect_magic(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file = iso9660->cur_file;
const unsigned char *p, *endp;
const unsigned char *magic_buff;
uint32_t uncompressed_size;
unsigned char header_size;
unsigned char log2_bs;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %r13
movq 0x20(%r13), %rdi
callq 0x50c953
movq %rax, %r14
cmpq $0x40, %rax
movl $0x40, %ebp
cmovlq %rax, %rbp
movslq 0x21c(%rbx), %rax
movslq %ebp, %r10
testq %rax, %rax
jne 0x54... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
wb_write_to_temp | static int
wb_write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
const char *xp = buff;
size_t xs = s;
/*
* If a written data size is big enough to use system-call
* and there is no waiting data, this calls write_to_temp() in
* order to reduce a extra memory copy.
*/
if (wb_remaining(a) =... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x4001, %rdx # imm = 0x4001
jb 0x54a519
movq 0xf8(%r15), %rax
cmpq $0x10000, 0x102e0(%rax) # imm = 0x10000
jne 0x54a519
movq %rbx, %r12
andq $-0x800, %r12 # imm = 0xF800
addq %r12, 0x102f0(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
wb_set_offset | static int
wb_set_offset(struct archive_write *a, int64_t off)
{
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
int64_t used, ext_bytes;
if (iso9660->wbuff_type != WB_TO_TEMP) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal Programming error: iso9660:wb_set_offset()");
return (... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r12
cmpl $0x1, 0x102e8(%r12)
jne 0x54a651
movq %rsi, %r14
movq 0x102e0(%r12), %rax
movq 0x102f0(%r12), %rsi
movl $0x10000, %edx # imm = 0x10000
movq %rax, %rcx
negq %rcx
leaq (%rsi,%rcx), %rdi
addq $0x10000, %rdi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_VD | static int
write_VD(struct archive_write *a, struct vdd *vdd)
{
struct iso9660 *iso9660;
unsigned char *bp;
uint16_t volume_set_size = 1;
char identifier[256];
enum VD_type vdt;
enum vdc vdc;
unsigned char vd_ver, fst_ver;
int r;
iso9660 = a->format_data;
switch (vdd->vdd_type) {
case VDD_JOLIET:
vdt = VD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq 0xf8(%rdi), %rcx
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
je 0x54a95d
cmpl $0x2, %eax
jne 0x54a969
movl $0x1, %r13d
movb $0x2, %al
movb $0x2, %dl
jmp 0x54a970
movb $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_gen_joliet_identifier | static int
isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
unsigned char *p;
size_t l;
int r;
size_t ffmax, parent_len;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node_joliet, isoent_cmp_key_jolie... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl 0x38(%rsi), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x54c4ae
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %rcx
movl $0x60000, %eax # imm = 0x60000
movq %rcx, 0x18(%rsp)
andl 0x10370(%rcx), %eax
cmpl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
idr_start | static int
idr_start(struct archive_write *a, struct idr *idr, int cnt, int ffmax,
int num_size, int null_size, const struct archive_rb_tree_ops *rbt_ops)
{
int r;
(void)ffmax; /* UNUSED */
r = idr_ensure_poolsize(a, idr, cnt);
if (r != ARCHIVE_OK)
return (r);
__archive_rb_tree_init(&(idr->rbtree), rbt_ops... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r14
cmpl %edx, 0x28(%rsi)
jge 0x54ca29
movl %edx, %r12d
movq %rdi, %r13
addl $0x7f, %r12d
andl $-0x80, %r12d
movq (%r14), %rdi
movslq %r12d, %rsi
shlq $0x6, %rsi
callq 0x41e68
testq %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
idr_set_num | static void
idr_set_num(unsigned char *p, int num)
{
static const char xdig[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z'
};
num %= sizeof(xdig) * sizeof(xdig) * sizeof(... | movslq %esi, %rcx
movabsq $-0x4c33f8fa07b9c44d, %rdx # imm = 0xB3CC0705F8463BB3
movq %rcx, %rax
mulq %rdx
shrq $0xf, %rdx
imull $0xb640, %edx, %eax # imm = 0xB640
subl %eax, %ecx
imull $0x6523, %ecx, %eax # imm = 0x6523
shrl $0x19, %eax
leaq 0x17a02a(%rip), %rdx # 0x6c6e40
movb (%rax,%rdx), %sil
movb %sil, (... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_cmp_iso9660_identifier | static int
isoent_cmp_iso9660_identifier(const struct isoent *p1, const struct isoent *p2)
{
const char *s1, *s2;
int cmp;
int l;
s1 = p1->identifier;
s2 = p2->identifier;
/* Compare File Name */
l = p1->ext_off;
if (l > p2->ext_off)
l = p2->ext_off;
cmp = memcmp(s1, s2, l);
if (cmp != 0)
return (cmp);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
movq 0xa8(%rsi), %r15
movslq 0xb0(%r14), %r12
movslq 0xb0(%rsi), %rbp
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movslq %eax, %r13
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r13, %rdx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
set_time_915 | static void
set_time_915(unsigned char *p, time_t t)
{
struct tm tm;
get_tmfromtime(&tm, &t);
set_num_711(p+0, tm.tm_year);
set_num_711(p+1, tm.tm_mon+1);
set_num_711(p+2, tm.tm_mday);
set_num_711(p+3, tm.tm_hour);
set_num_711(p+4, tm.tm_min);
set_num_711(p+5, tm.tm_sec);
set_num_712(p+6, (char)(get_gmoffset(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
callq 0x40f90
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f460
movb 0x14(%r15), %al
movb %al, (%rbx)
movb 0x10(%r15), %al
incb %al
movb %al, 0x1(%rbx)
movb 0xc(%r15), %al
movb %al, 0x2(%rbx)
movb 0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
set_SUSP_CE | static int
set_SUSP_CE(unsigned char *p, int location, int offset, int size)
{
unsigned char *bp = p -1;
/* Extend the System Use Area
* "CE" Format:
* len ver
* +----+----+----+----+-----------+-----------+
* | 'C'| 'E'| 1C | 01 | LOCATION1 | LOCATION2 |
* +----+----+----+----+--... | movl $0x11c4543, (%rdi) # imm = 0x11C4543
movb %sil, 0x4(%rdi)
movl %esi, %eax
shrl $0x8, %eax
movb %al, 0x5(%rdi)
movl %esi, %r8d
shrl $0x10, %r8d
movb %r8b, 0x6(%rdi)
movl %esi, %r9d
shrl $0x18, %r9d
movb %r9b, 0x7(%rdi)
movb %r9b, 0x8(%rdi)
movb %r8b, 0x9(%rdi)
movb %al, 0xa(%rdi)
movb %sil, 0xb(%rdi)
movb %dl,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
set_str_a_characters_bp | static int
set_str_a_characters_bp(struct archive_write *a, unsigned char *bp,
int from, int to, const char *s, enum vdc vdc)
{
int r;
switch (vdc) {
case VDC_STD:
set_str(bp+from, s, to - from + 1, 0x20,
a_characters_map);
r = ARCHIVE_OK;
break;
case VDC_LOWERCASE:
set_str(bp+from, s, to - from ... | leal -0x2(%r9), %eax
cmpl $0x2, %eax
jb 0x54e5ad
pushq %rax
cmpl $0x1, %r9d
je 0x54e5c4
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %r9d, %r9d
jne 0x54e5e4
movl %edx, %eax
addq %rax, %rsi
subl %edx, %ecx
incl %ecx
movslq %ecx, %rdx
leaq 0x178945(%rip), %rcx # 0x6c6ef0
jmp 0x54e5d7
movl %edx, %eax
addq %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
set_option_info | static void
set_option_info(struct archive_string *info, int *opt, const char *key,
enum keytype type, ...)
{
va_list ap;
char prefix;
const char *s;
int d;
prefix = (*opt==0)? ' ':',';
va_start(ap, type);
switch (type) {
case KEY_FLG:
d = va_arg(ap, int);
archive_string_sprintf(info, "%c%s%s",
... | pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rbx
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x54ebdd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_free_all | static void
isoent_free_all(struct isoent *isoent)
{
struct isoent *np, *np_temp;
if (isoent == NULL)
return;
np = isoent;
for (;;) {
if (np->dir) {
if (np->children.first != NULL) {
/* Enter to sub directories. */
np = np->children.first;
continue;
}
}
for (;;) {
np_temp = np;
if (... | testq %rdi, %rdi
je 0x54ee24
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r14, %rbx
testb $0x2, 0xe8(%r14)
je 0x54edf4
movq 0x28(%rbx), %r14
testq %r14, %r14
jne 0x54edde
movq 0x70(%rbx), %r14
testq %r14, %r14
jne 0x54ee13
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x549b0d
cmpq %rbx, %r14
movq %r14, %rbx
jn... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
archive_write_set_format_mtree_default | static int
archive_write_set_format_mtree_default(struct archive *_a, const char *fn)
{
struct archive_write *a = (struct archive_write *)_a;
struct mtree_writer *mtree;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, fn);
if (a->format_free != NULL)
(a->format_free)(a);
if ((mtree = calloc(1,... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x54ef7a
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x54eeb8
movq %rbx, %rdi
callq *%rax
movl $0x1, %edi
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
archive_write_mtree_data | static ssize_t
archive_write_mtree_data(struct archive_write *a, const void *buff, size_t n)
{
struct mtree_writer *mtree= a->format_data;
if (n > mtree->entry_bytes_remaining)
n = (size_t)mtree->entry_bytes_remaining;
mtree->entry_bytes_remaining -= n;
/* We don't need to compute a regular file sum */
if (mtr... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0xf8(%rdi), %r15
movq 0x78(%r15), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rbx
movq (%r15), %rax
subq %rbx, %rcx
movq %rcx, 0x78(%r15)
testq %rax, %rax
je 0x5503cf
cmpl $0x8000, 0xe4(%rax) # imm = 0x8000
jne 0x5503cf
movq %rsi, %r14
movl 0xe0(%r15), %eax
testb $0x1, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
attr_counter_set_free | static void
attr_counter_set_free(struct mtree_writer *mtree)
{
struct att_counter_set *acs = &mtree->acs;
attr_counter_free(&acs->uid_list);
attr_counter_free(&acs->gid_list);
attr_counter_free(&acs->mode_list);
attr_counter_free(&acs->flags_list);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
testq %rdi, %rdi
je 0x550565
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r14
jne 0x550549
movq $0x0, 0xb8(%rbx)
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x55058d
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
mtree_entry_free | static void
mtree_entry_free(struct mtree_entry *me)
{
archive_string_free(&me->parentdir);
archive_string_free(&me->basename);
archive_string_free(&me->pathname);
archive_string_free(&me->symlink);
archive_string_free(&me->uname);
archive_string_free(&me->gname);
archive_string_free(&me->fflags_text);
free(me-... | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x539f3f
leaq 0x50(%rbx), %rdi
callq 0x539f3f
leaq 0x68(%rbx), %rdi
callq 0x539f3f
leaq 0x80(%rbx), %rdi
callq 0x539f3f
leaq 0x98(%rbx), %rdi
callq 0x539f3f
leaq 0xb0(%rbx), %rdi
callq 0x539f3f
leaq 0xc8(%rbx), %rdi
callq 0x539f3f
movq 0x28(%rbx), %rdi
callq 0x41e70
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
write_mtree_entry | static int
write_mtree_entry(struct archive_write *a, struct mtree_entry *me)
{
struct mtree_writer *mtree = a->format_data;
struct archive_string *str;
int keys, ret;
if (me->dir_info) {
if (mtree->classic) {
/*
* Output a comment line to describe the full
* pathname of the entry as mtree utility doe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0xf8(%rdi), %rbx
cmpq $0x0, 0x28(%rsi)
je 0x550cf2
cmpl $0x0, 0xd8(%rbx)
je 0x550ce1
cmpl $0x0, 0x124(%rbx)
jne 0x550cad
leaq 0x58(%rbx), %rdi
movl $0xa, %esi
callq 0x53a0ad
movq 0x38(%r12), %rdx
movq 0x50(%r12), %rcx
leaq 0x58(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
mtree_quote | static void
mtree_quote(struct archive_string *s, const char *str)
{
const char *start;
char buf[4];
unsigned char c;
for (start = str; *str != '\0'; ++str) {
if (safe_char[*(const unsigned char *)str])
continue;
if (start != str)
archive_strncat(s, start, str - start);
c = (unsigned char)*str;
buf[0... | movb (%rsi), %al
testb %al, %al
je 0x551951
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1(%rsi), %r12
leaq 0x175eb9(%rip), %r13 # 0x6c7770
leaq 0x4(%rsp), %r15
movq %rsi, %r14
movzbl %al, %ecx
cmpb $0x0, (%rcx,%r13)
jne 0x55191f
leaq -0x1(%r12), %rbp
cmpq %rsi,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c |
archive_write_set_format_pax_restricted | int
archive_write_set_format_pax_restricted(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_pax_restricted");
r = archive_write_set_format_pax(&a->archive);
a->archive.archive_format ... | pushq %rbx
movq %rdi, %rbx
leaq 0x176264(%rip), %rcx # 0x6c7ed7
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
cmpl $-0x1e, %eax
jne 0x551c8e
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
popq %rbx
retq
movq %rbx, %rdi
callq 0x551caa
movl $0x30003, 0x10(%rbx) # imm = 0x30003
leaq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_data | static ssize_t
archive_write_pax_data(struct archive_write *a, const void *buff, size_t s)
{
struct pax *pax;
size_t ws;
size_t total;
int ret;
pax = (struct pax *)a->format_data;
/*
* According to GNU PAX format 1.0, write a sparse map
* before the body.
*/
if (archive_strlen(&(pax->sparse_map))) {
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rbp
movq 0x48(%rbp), %rdx
testq %rdx, %rdx
je 0x5533ee
movq 0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x53e917
testl %eax, %eax
jne 0x5533e1
movq 0x58(%rbp), %rsi
movq %r15, %rdi
c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_free | static int
archive_write_pax_free(struct archive_write *a)
{
struct pax *pax;
pax = (struct pax *)a->format_data;
if (pax == NULL)
return (ARCHIVE_OK);
archive_string_free(&pax->pax_header);
archive_string_free(&pax->sparse_map);
archive_string_free(&pax->l_url_encoded_name);
sparse_list_clear(pax);
free(pa... | pushq %r14
pushq %rbx
pushq %rax
movq 0xf8(%rdi), %r14
testq %r14, %r14
je 0x5534d6
movq %rdi, %rbx
leaq 0x28(%r14), %rdi
callq 0x539f3f
leaq 0x40(%r14), %rdi
callq 0x539f3f
leaq 0x10(%r14), %rdi
callq 0x539f3f
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x5534c3
movq (%rdi), %rax
movq %rax, 0x60(%r14)
callq 0x41e70
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_finish_entry | static int
archive_write_pax_finish_entry(struct archive_write *a)
{
struct pax *pax;
uint64_t remaining;
int ret;
pax = (struct pax *)a->format_data;
remaining = pax->entry_bytes_remaining;
if (remaining == 0) {
while (pax->sparse_list) {
struct sparse_block *sb;
if (!pax->sparse_list->is_hole)
rema... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
movq (%r15), %r14
testq %r14, %r14
jne 0x553524
movq 0x60(%r15), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x553524
cmpl $0x0, 0x8(%rdi)
jne 0x553510
addq 0x18(%rdi), %r14
movq (%rdi), %r12
callq 0x41e70
movq %r12, 0x60(%r15)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
add_pax_attr_int | static void
add_pax_attr_int(struct archive_string *as, const char *key, int64_t value)
{
char tmp[1 + 3 * sizeof(value)];
tmp[sizeof(tmp) - 1] = 0;
add_pax_attr(as, key, format_int(tmp + sizeof(tmp) - 1, value));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x17(%rsp), %r14
movb $0x0, 0x1(%r14)
movq %rdx, %rsi
negq %rsi
cmovsq %rdx, %rsi
leaq 0x14c630(%rip), %rdi # 0x69ff9b
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
shrq $0x3... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
sparse_list_add | static int
sparse_list_add(struct pax *pax, int64_t offset, int64_t length)
{
int64_t last_offset;
int r;
if (pax->sparse_tail == NULL)
last_offset = 0;
else {
last_offset = pax->sparse_tail->offset +
pax->sparse_tail->remaining;
}
if (last_offset < offset) {
/* Add a hole block. */
r = _sparse_lis... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x553c8b
movq 0x18(%rax), %rsi
addq 0x10(%rax), %rsi
jmp 0x553c8d
xorl %esi, %esi
movq %r14, %rdx
subq %rsi, %rdx
jle 0x553cac
movq %r15, %rdi
movl $0x1, %ecx
callq 0x554294
testl %eax, %eax
je 0x5... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_header_xattrs | static int
archive_write_pax_header_xattrs(struct archive_write *a,
struct pax *pax, struct archive_entry *entry)
{
int i = archive_entry_xattr_reset(entry);
while (i--) {
const char *name;
const void *value;
char *url_encoded_name = NULL, *encoded_name = NULL;
size_t size;
int r;
archive_entry_xatt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbp
movq %rdi, %rbx
movq %rdx, 0x58(%rsp)
movq %rdx, %rdi
callq 0x50df28
testl %eax, %eax
je 0x554087
movq %rbx, 0x48(%rsp)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x50(%rsp)
leaq 0x28(%rbp), %rcx
movq %rcx, 0x40(%rsp)
movl $0x3, %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
build_pax_attribute_name | static char *
build_pax_attribute_name(char *dest, const char *src)
{
char buff[64];
const char *p;
/* Handle the null filename case. */
if (src == NULL || *src == '\0') {
strcpy(dest, "PaxHeader/blank");
return (dest);
}
/* Prune final '/' and other unwanted final elements. */
p = src + strlen(src);
for ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x554134
movq %rsi, %r14
movb (%rsi), %bpl
testb %bpl, %bpl
je 0x554134
movq %r14, %rdi
callq 0x3fd60
testq %rax, %rax
jle 0x554109
movb -0x1(%r14,%rax), %cl
cmpb $0x2f, %cl
je 0x5540fc
cmpq $0x1, %rax
je 0x55415d
cmpb $0x2e, %cl
jne ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
add_pax_attr_binary | static void
add_pax_attr_binary(struct archive_string *as, const char *key,
const char *value, size_t value_len)
{
int digits, i, len, next_ten;
char tmp[1 + 3 * sizeof(int)]; /* < 3 base-10 digits per byte */
/*-
* PAX attributes have the following layout:
* <len> <space> <key> <=> <value> <nl>
*/
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3fd60
leal (%r14,%rax), %ecx
addl $0x3, %ecx
testl %ecx, %ecx
jle 0x5541d6
xorl %eax, %eax
movl $0x1, %edx
movl $0xcccccccd, %esi # imm = 0xCCCCCCCD
movl %ecx, %edi
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_set_format_raw | int
archive_write_set_format_raw(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct raw *raw;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_raw");
/* If someone else was already registered, unregister them. */
if (a->format_free != ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x173e5b(%rip), %rcx # 0x6c8170
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x5543d7
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x554343
movq %rbx, %rdi
callq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_raw.c |
archive_write_raw_header | static int
archive_write_raw_header(struct archive_write *a, struct archive_entry *entry)
{
struct raw *raw = (struct raw *)a->format_data;
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_set_error(&a->archive, ERANGE,
"Raw format only supports filetype AE_IFREG");
return (ARCHIVE_FATAL);
}
if... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r14
movq %rsi, %rdi
callq 0x50c423
cmpl $0x8000, %eax # imm = 0x8000
jne 0x55440d
movl (%r14), %eax
testl %eax, %eax
jle 0x554430
leaq 0x173dc9(%rip), %rdx # 0x6c81d4
jmp 0x554414
leaq 0x173d95(%rip), %rdx # 0x6c81a9
movq %rbx, %rdi
movl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_raw.c |
archive_write_shar_data_sed | static ssize_t
archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
{
static const size_t ensured = 65533;
struct shar *shar;
const char *src;
char *buf, *buf_end;
int ret;
size_t written = n;
shar = (struct shar *)a->format_data;
if (!shar->has_data || n == 0)
return (0);
src =... | xorl %eax, %eax
testq %rdx, %rdx
je 0x554ba7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xf8(%rdi), %r13
cmpl $0x0, 0x10(%r13)
je 0x554b99
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x60(%r13), %r12
movl $0x10000, %esi # imm = 0x10000
movq %r12, %rdi
callq 0x539... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
archive_write_shar_data_uuencode | static ssize_t
archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
size_t length)
{
struct shar *shar;
const char *src;
size_t n;
int ret;
shar = (struct shar *)a->format_data;
if (!shar->has_data)
return (ARCHIVE_OK);
src = (const char *)buff;
if (shar->outpos != 0) {
n = 45 -... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xf8(%rdi), %r14
cmpl $0x0, 0x10(%r14)
je 0x554e8e
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x554e92
movl $0x2d, %ebp
subq %rax, %rbp
cmpq %rbx, %rbp
cmovaeq %rbx, %rbp
leaq (%r14,%rax), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
uuencode_group | static void
uuencode_group(const char _in[3], char out[4])
{
const unsigned char *in = (const unsigned char *)_in;
int t;
t = (in[0] << 16) | (in[1] << 8) | in[2];
out[0] = UUENC( 0x3f & (t >> 18) );
out[1] = UUENC( 0x3f & (t >> 12) );
out[2] = UUENC( 0x3f & (t >> 6) );
out[3] = UUENC( 0x3f & t );
} | movzbl (%rdi), %ecx
movl %ecx, %r8d
shll $0x10, %r8d
movzbl 0x1(%rdi), %r9d
shll $0x8, %r9d
movzbl 0x2(%rdi), %eax
leal (%r9,%rax), %edx
orl %r8d, %r9d
movl %ecx, %edi
shrb $0x2, %dil
addb $0x20, %dil
cmpb $0x4, %cl
movzbl %dil, %edi
movl $0x60, %ecx
cmovbl %ecx, %edi
movb %dil, (%rsi)
shrl $0xc, %r9d
andl $0x3f, %r9d
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
archive_write_set_format_ustar | int
archive_write_set_format_ustar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct ustar *ustar;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_ustar");
/* If someone else was already registered, unregister them. */
if (a->format_... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1734e3(%rip), %rcx # 0x6c8630
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x555224
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x55517b
movq %rbx, %rdi
callq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c |
archive_write_ustar_header | static int
archive_write_ustar_header(struct archive_write *a, struct archive_entry *entry)
{
char buff[512];
int ret, ret2;
struct ustar *ustar;
struct archive_entry *entry_main;
struct archive_string_conv *sconv;
ustar = (struct ustar *)a->format_data;
/* Setup default string conversion. */
if (ustar->opt_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %r13
movq 0x10(%r13), %r15
testq %r15, %r15
jne 0x555301
cmpl $0x0, 0x20(%r13)
je 0x5552ea
movq 0x18(%r13), %r15
jmp 0x555301
movq %r14, %rdi
callq 0x53a698
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c |
format_number | static int
format_number(int64_t v, char *p, int s, int maxsize, int strict)
{
int64_t limit;
limit = ((int64_t)1 << (s*3));
/* "Strict" only permits octal values with proper termination. */
if (strict)
return (format_octal(v, p, s));
/*
* In non-strict mode, we allow the number to overwrite one or
* more... | testl %r8d, %r8d
je 0x555ca0
jmp 0x555cfc
movl %ecx, %eax
testq %rdi, %rdi
sets %cl
cmpl %eax, %edx
setg %r8b
orb %cl, %r8b
jne 0x555cd1
leal (%rdx,%rdx,2), %ecx
movl $0x1, %r8d
shlq %cl, %r8
leal 0x1(%rax), %ecx
cmpq %rdi, %r8
jg 0x555c9e
incl %edx
shlq $0x3, %r8
cmpl %edx, %ecx
jne 0x555cc2
movl %eax, %ecx
addq %rcx,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.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.