name string | code string | asm string | file string |
|---|---|---|---|
compress_filter_read | static ssize_t
compress_filter_read(struct archive_read_filter *self, const void **pblock)
{
struct private_data *state;
unsigned char *p, *start, *end;
int ret;
state = (struct private_data *)self->data;
if (state->end_of_stream) {
*pblock = NULL;
return (0);
}
p = start = (unsigned char *)state->out_block... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r13
cmpl $0x0, 0x3c(%r13)
je 0x12e635
movq $0x0, (%rsi)
xorl %r14d, %r14d
jmp 0x12e6aa
movq %rsi, (%rsp)
movq 0x28(%r13), %rbp
movq 0x30(%r13), %r12
movq %r12, %r14
testq %rbp, %rbp
jle 0x12e6a0
movq %rdi, %r15
addq %r12, %rb... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_compress.c |
archive_read_support_filter_lz4 | int
archive_read_support_filter_lz4(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "lz4",
&lz4_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if defined(HAVE_LIBLZ4)
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCHIVE_ERRNO_... | pushq %rbx
movq %rdi, %rbx
leaq 0x64a79(%rip), %rdx # 0x1938af
leaq 0xd7f43(%rip), %rcx # 0x206d80
xorl %esi, %esi
callq 0x1285b0
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %ecx, %ecx
jne 0x12ee6a
leaq 0x9c84c(%rip), %rdx # 0x1cb6a2
movq %rbx, %rdi
movl $0xffffffff, %esi # i... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_lz4.c |
_archive_read_program | int
__archive_read_program(struct archive_read_filter *self, const char *cmd)
{
struct program_filter *state;
static const size_t out_buf_len = 65536;
char *out_buf;
const char *prefix = "Program: ";
int ret;
size_t l;
l = strlen(prefix) + strlen(cmd) + 1;
state = calloc(1, sizeof(*state));
out_buf = malloc(o... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x14520
movq %rax, %r13
movl $0x1, %edi
movl $0x40, %esi
callq 0x14be0
movq %rax, %r14
movl $0x10000, %edi # imm = 0x10000
callq 0x14cd0
movq %rax, %r12
testq %r14, %r14
sete %al
testq %r12, %r12
sete %... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_program.c |
rpm_bidder_bid | static int
rpm_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *b;
ssize_t avail;
int bits_checked;
(void)self; /* UNUSED */
b = __archive_read_filter_ahead(filter, 8, &avail);
if (b == NULL)
return (0);
bits_checked = 0;
/*
* Verify Heade... | pushq %rax
movq %rsi, %rdi
movq %rsp, %rdx
movl $0x8, %esi
callq 0x12866b
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x12f619
cmpl $0xdbeeabed, (%rcx) # imm = 0xDBEEABED
jne 0x12f619
movb 0x4(%rcx), %dl
addb $-0x3, %dl
cmpb $0x1, %dl
ja 0x12f619
cmpb $0x0, 0x6(%rcx)
jne 0x12f619
xorl %edx, %edx
cmpb $0x2, ... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_rpm.c |
get_line | static ssize_t
get_line(const unsigned char *b, ssize_t avail, ssize_t *nlsize)
{
ssize_t len;
len = 0;
while (len < avail) {
switch (ascii[*b]) {
case 0: /* Non-ascii character or control character. */
if (nlsize != NULL)
*nlsize = 0;
return (-1);
case '\r':
if (avail-len > 1 && b[1] == '\n') {
... | movq %rsi, %rax
testq %rsi, %rsi
jle 0x12ff99
xorl %ecx, %ecx
leaq 0x9b955(%rip), %rsi # 0x1cb8b0
movzbl (%rdi), %r8d
movzbl (%r8,%rsi), %r8d
cmpl $0x9, %r8d
jg 0x12ff78
cmpl $0x1, %r8d
jne 0x12ff86
incq %rdi
incq %rcx
jmp 0x12ff8b
cmpl $0xa, %r8d
je 0x12ffc7
cmpl $0xd, %r8d
jne 0x12ff8b
jmp 0x12ffa6
testl %r8d, %r... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_uu.c |
archive_read_support_filter_lzma | int
archive_read_support_filter_lzma(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "lzma",
&lzma_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if HAVE_LZMA_H && HAVE_LIBLZMA
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCH... | pushq %rax
leaq 0x9fb53(%rip), %rdx # 0x1d0485
leaq 0xd651f(%rip), %rcx # 0x206e58
xorl %esi, %esi
callq 0x1285b0
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /mmatuska[P]libarchive/libarchive/archive_read_support_filter_xz.c |
xz_filter_read | static ssize_t
xz_filter_read(struct archive_read_filter *self, const void **p)
{
struct private_data *state;
size_t decompressed;
ssize_t avail_in;
int64_t member_in;
int ret;
state = (struct private_data *)self->data;
redo:
/* Empty our output buffer. */
state->stream.next_out = state->out_block;
state->s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x28(%rdi), %r14
leaq 0x20(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x8(%rsp), %r13
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
movq %rax, 0x18(%r14)
movq %rcx, 0x20(%r14)
movq 0xa8(%r14), %rax
mo... | /mmatuska[P]libarchive/libarchive/archive_read_support_filter_xz.c |
archive_read_support_filter_zstd | int
archive_read_support_filter_zstd(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "zstd",
&zstd_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if HAVE_ZSTD_H && HAVE_LIBZSTD
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCH... | pushq %rax
leaq 0x96dff(%rip), %rdx # 0x1c7f8f
leaq 0xd5d09(%rip), %rcx # 0x206ea0
xorl %esi, %esi
callq 0x1285b0
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /mmatuska[P]libarchive/libarchive/archive_read_support_filter_zstd.c |
archive_read_format_7zip_read_data | static int
archive_read_format_7zip_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
struct _7zip *zip;
ssize_t bytes;
int ret = ARCHIVE_OK;
zip = (struct _7zip *)(a->format->data);
if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
zip->has_e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbp
cmpl $-0x1, 0x50b8(%rbp)
jne 0x132118
movl $0x0, 0x50b8(%rbp)
cmpq $0x0, 0x120(%rbp)
je 0x13212a
movq %r15, %rdi
callq 0x13269f
movq 0xb8(... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
setup_decode_folder | static int
setup_decode_folder(struct archive_read *a, struct _7z_folder *folder,
int header)
{
struct _7zip *zip = (struct _7zip *)a->format->data;
const struct _7z_coder *coder1, *coder2;
const char *cname = (header)?"archive header":"file content";
unsigned i;
int r, found_bcj2 = 0;
/*
* Release the mem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movl $0x9be, %r12d # imm = 0x9BE
movq (%r14,%r12,8), %rdi
callq 0x14220
movq $0x0, (%r14,%r12,8)
incq %r12
cmpq $0x9c1, %r12 # ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
extract_pack_stream | static ssize_t
extract_pack_stream(struct archive_read *a, size_t minimum)
{
struct _7zip *zip = (struct _7zip *)a->format->data;
ssize_t bytes_avail;
int r;
if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
if (minimum == 0)
minimum = 1;
if (__archive_read_ahead(a, minimum, &bytes_avail) ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
cmpq $0x0, 0x128(%r14)
jne 0x1338a0
cmpq $-0x1, 0x130(%r14)
je 0x133969
movq 0xd8(%r14), %rdi
testq %rdi, %rdi
movq %rbx, 0x28(%rsp)
movq %rsi, 0xa0(%rsp)
je 0x133924
movq 0xe8(%r1... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
Bcj2_Decode | static ssize_t
Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize)
{
size_t inPos = 0, outPos = 0;
const uint8_t *buf0, *buf1, *buf2, *buf3;
size_t size0, size1, size2, size3;
const uint8_t *buffer, *bufferLim;
unsigned int i, j;
size0 = zip->tmp_stream_bytes_remaining;
buf0 = zip->tmp_stream_buff +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r9
movq %rsi, %r15
movq %rdi, %rbx
movq 0x4e50(%rdi), %r11
movq 0x4e38(%rdi), %rbp
addq 0x4e48(%rdi), %rbp
movq 0x4e20(%rdi), %r10
movq 0x4df0(%rdi), %rax
addq 0x4e08(%rdi), %rax
movq 0x4df8(%rdi), %rcx
movq 0x4e28(%rdi), %r1... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
read_StreamsInfo | static int
read_StreamsInfo(struct archive_read *a, struct _7z_stream_info *si)
{
struct _7zip *zip = (struct _7zip *)a->format->data;
const unsigned char *p;
unsigned i;
memset(si, 0, sizeof(*si));
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
if (*p == kPackInfo) {
uint64_t packPos;
if (read_PackI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rsi)
movups %xmm0, 0x40(%rsi)
movups %xmm0, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
read_Digests | static int
read_Digests(struct archive_read *a, struct _7z_digests *d, size_t num)
{
const unsigned char *p;
unsigned i;
if (num == 0)
return (-1);
memset(d, 0, sizeof(*d));
d->defineds = malloc(num);
if (d->defineds == NULL)
return (-1);
/*
* Read Bools.
*/
if ((p = header_bytes(a, 1)) == NULL)
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x1360ce
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %rdx, %rdi
callq 0x14cd0
movq %rax, (%r15)
testq %rax, %rax
je 0x1360ce
m... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
init_decompression | static int
init_decompression(struct archive_read *a, struct _7zip *zip,
const struct _7z_coder *coder1, const struct _7z_coder *coder2)
{
int r;
zip->codec = coder1->codec;
zip->codec2 = -1;
switch (zip->codec) {
case _7Z_COPY:
case _7Z_BZ2:
case _7Z_DEFLATE:
case _7Z_ZSTD:
case _7Z_PPMD:
if (coder2 !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r8
movq %r8, 0x128(%rsi)
movq $-0x1, 0x130(%rsi)
cmpq $0x303011a, %r8 # imm = 0x303011A
jg 0x136220
cmpq $0x30100, %r8 # imm = 0x30100
jg 0x1... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_7zip.c |
archive_read_format_ar_read_data | static int
archive_read_format_ar_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
ssize_t bytes_read;
struct ar *ar;
ar = (struct ar *)(a->format->data);
if (ar->entry_bytes_unconsumed) {
__archive_read_consume(a, ar->entry_bytes_unconsumed);
ar->entry_bytes_unconsume... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbp
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x137237
movq %r15, %rdi
callq 0x128915
movq $0x0, 0x8(%rbp)
cmpq $0x0, (%rbp)
jle 0x13728b
movq ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_ar.c |
cab_consume_cfdata | static int64_t
cab_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
{
struct cab *cab = (struct cab *)(a->format->data);
struct cfdata *cfdata;
int64_t cbytes, rbytes;
int err;
rbytes = cab_minimum_consume_cfdata(a, consumed_bytes);
if (rbytes < 0)
return (ARCHIVE_FATAL);
cfdata = cab->entry_cf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r15
callq 0x138fbc
testq %rax, %rax
js 0x138f98
movq %rbx, 0x18(%rsp)
je 0x138fa8
movq %rax, %r13
movq %r15, 0x8(%rsp)
movq 0x38(%r15), %r15
movl $0x1, %eax
movl %eax, ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cab.c |
lzx_br_fillup | static int
lzx_br_fillup(struct lzx_stream *strm, struct lzx_br *br)
{
/*
* x86 processor family can read misaligned data without an access error.
*/
int n = CACHE_BITS - br->cache_avail;
for (;;) {
switch (n >> 4) {
case 4:
if (strm->avail_in >= 8) {
br->cache_buffer =
((uint64_t)strm->next_in[... | movl $0x40, %eax
subl 0x8(%rsi), %eax
movl %eax, %ecx
sarl $0x4, %ecx
cmpl $0x3, %ecx
je 0x13afc5
cmpl $0x4, %ecx
je 0x13afb6
testl %ecx, %ecx
jne 0x13afcf
jmp 0x13b104
movq 0x8(%rdi), %rcx
cmpq $0x8, %rcx
jl 0x13afcf
jmp 0x13b099
movq 0x8(%rdi), %rcx
cmpq $0x6, %rcx
jge 0x13b038
movq 0x8(%rdi), %rcx
cmpq $0x1, %rcx
jl... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cab.c |
archive_read_format_cpio_read_header | static int
archive_read_format_cpio_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct cpio *cpio;
const void *h, *hl;
struct archive_string_conv *sconv;
size_t namelength;
size_t name_pad;
int r;
cpio = (struct cpio *)(a->format->data);
sconv = cpio->opt_sconv;
if (sconv == NULL) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x38(%r14), %r13
testq %r13, %r13
jne 0x13b99b
cmpl $0x0, 0x48(%r14)
jne 0x13b997
movq %rbx, %rdi
callq 0x15e0b8
movq %rax, 0x40(%r14)
movl $0x1, 0x48(%r14)
mo... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
archive_read_format_cpio_read_data | static int
archive_read_format_cpio_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
ssize_t bytes_read;
struct cpio *cpio;
cpio = (struct cpio *)(a->format->data);
if (cpio->entry_bytes_unconsumed) {
__archive_read_consume(a, cpio->entry_bytes_unconsumed);
cpio->entry... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x818(%rdi), %rax
movq (%rax), %rbp
movq 0x20(%rbp), %rsi
testq %rsi, %rsi
je 0x13bc96
movq %r12, %rdi
callq 0x128915
movq $0x0, 0x20(%rbp)
cmpq $0x0, 0x18(%rbp)
jle 0x13bce7... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
archive_read_format_cpio_skip | static int
archive_read_format_cpio_skip(struct archive_read *a)
{
struct cpio *cpio = (struct cpio *)(a->format->data);
int64_t to_skip = cpio->entry_bytes_remaining + cpio->entry_padding +
cpio->entry_bytes_unconsumed;
if (to_skip != __archive_read_consume(a, to_skip)) {
return (ARCHIVE_FATAL);
}
cpio->entr... | pushq %r14
pushq %rbx
pushq %rax
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x30(%r14), %rbx
addq 0x18(%r14), %rbx
addq 0x20(%r14), %rbx
movq %rbx, %rsi
callq 0x128915
movq %rax, %rcx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpq %rcx, %rbx
jne 0x13bd75
movq $0x0, 0x30(%r14)
addq $0x18, %r14
xorps %xmm0, %xmm... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
header_bin_be | static int
header_bin_be(struct archive_read *a, struct cpio *cpio,
struct archive_entry *entry, size_t *namelength, size_t *name_pad)
{
const void *h;
const unsigned char *header;
a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_BE;
a->archive.archive_format_name = "cpio (big-endian binary)";
/* Read fix... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10003, 0x10(%rdi) # imm = 0x10003
leaq 0x90585(%rip), %rax # 0x1ccd69
movq %rax, 0x18(%rdi)
movl $0x1a, %esi
xorl %edx, %edx
callq 0x12865f
testq %ra... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
is_afio_large | static int
is_afio_large(const char *h, size_t len)
{
if (len < afiol_header_size)
return (0);
if (h[afiol_ino_m_offset] != 'm'
|| h[afiol_mtime_n_offset] != 'n'
|| h[afiol_xsize_s_offset] != 's'
|| h[afiol_filesize_c_offset] != ':')
return (0);
if (!is_hex(h + afiol_dev_offset, afiol_ino_m_offset... | xorl %eax, %eax
cmpq $0x74, %rsi
jb 0x13cbfa
cmpb $0x6d, 0x1e(%rdi)
jne 0x13cbfa
cmpb $0x6e, 0x55(%rdi)
jne 0x13cbfa
cmpb $0x73, 0x62(%rdi)
jne 0x13cbfa
cmpb $0x3a, 0x73(%rdi)
jne 0x13cbfa
movq $-0x18, %rdx
movabsq $0x3f0000003f, %rcx # imm = 0x3F0000003F
movb 0x1e(%rdi,%rdx), %sil
leal -0x30(%rsi), %r8d
cmpb $0xa,... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
atol16 | static int64_t
atol16(const char *p, unsigned char_cnt)
{
uint64_t l;
int digit;
l = 0;
while (char_cnt-- > 0) {
if (*p >= 'a' && *p <= 'f')
digit = *p - 'a' + 10;
else if (*p >= 'A' && *p <= 'F')
digit = *p - 'A' + 10;
else if (*p >= '0' && *p <= '9')
digit = *p - '0';
else
return ((int64_t)l)... | testl %esi, %esi
je 0x13cc55
movl $0xffffffa9, %ecx # imm = 0xFFFFFFA9
movl %esi, %edx
xorl %esi, %esi
xorl %eax, %eax
movzbl (%rdi,%rsi), %r8d
leal -0x61(%r8), %r9d
cmpb $0x5, %r9b
ja 0x13cc1e
addq %rcx, %r8
jmp 0x13cc43
leal -0x41(%r8), %r9d
cmpb $0x5, %r9b
ja 0x13cc31
addq %rcx, %r8
addq $0x20, %r8
jmp 0x13cc4... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_cpio.c |
archive_read_format_iso9660_read_data | static int
archive_read_format_iso9660_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
ssize_t bytes_read;
struct iso9660 *iso9660;
iso9660 = (struct iso9660 *)(a->format->data);
if (iso9660->entry_bytes_unconsumed) {
__archive_read_consume(a, iso9660->entry_bytes_uncon... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0xe0(%r14), %rsi
testq %rsi, %rsi
je 0x13dc97
movq %r12, %rdi
callq 0x128915
movq $0x0, 0xe0(%r14)
cmpq $0x0, 0xd8(%r14)
jle 0x... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_iso9660.c |
build_pathname_utf16be | static int
build_pathname_utf16be(unsigned char *p, size_t max, size_t *len,
struct file_info *file)
{
if (file->parent != NULL && file->parent->utf16be_bytes > 0) {
if (build_pathname_utf16be(p, max, len, file->parent) != 0)
return (-1);
p[*len] = 0;
p[*len + 1] = '/';
*len += 2;
}
if (file->utf16be_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x13e6a6
cmpq $0x0, 0xc8(%rdx)
je 0x13e6a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13e65a
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x13e70f
movq (%rbx), %... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_iso9660.c |
toi | static unsigned int
toi(const void *p, int n)
{
const unsigned char *v = (const unsigned char *)p;
if (n > 1)
return v[0] + 256 * toi(v + 1, n - 1);
if (n == 1)
return v[0];
return (0);
} | pushq %rbx
movzbl (%rdi), %ebx
cmpl $0x1, %esi
jle 0x13eee2
incq %rdi
decl %esi
callq 0x13eeca
shll $0x8, %eax
orl %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
| /mmatuska[P]libarchive/libarchive/archive_read_support_format_iso9660.c |
isodate7_valid | static int
isodate7_valid(const unsigned char *v)
{
int year = v[0];
int month = v[1];
int day = v[2];
int hour = v[3];
int minute = v[4];
int second = v[5];
int gmt_off = (signed char)v[6];
/* ECMA-119 9.1.5 "If all seven values are zero, it shall mean
* that the date is unspecified" */
if (year == 0
... | movb 0x1(%rdi), %r9b
movb 0x2(%rdi), %r8b
movb 0x3(%rdi), %sil
movb 0x4(%rdi), %dl
movb 0x5(%rdi), %cl
movb 0x6(%rdi), %al
cmpb $0x0, (%rdi)
setne %dil
addb $-0x1, %r9b
setb %r10b
orb %dil, %r10b
addb $-0x1, %r8b
setb %dil
testb %sil, %sil
setne %r11b
orb %dil, %r11b
orb %r10b, %r11b
testb %dl, %dl
setne %dil
testb %cl... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_iso9660.c |
next_cache_entry | static int
next_cache_entry(struct archive_read *a, struct iso9660 *iso9660,
struct file_info **pfile)
{
struct file_info *file;
struct {
struct file_info *first;
struct file_info **last;
} empty_files;
int64_t number;
int count;
file = cache_get_entry(iso9660);
if (file != NULL) {
*pfile = file;
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r13
movq %rsi, %r14
leaq 0x80(%rsi), %r15
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0x13fc68
movq 0x10(%rax), %rcx
movq %rcx, (%r15)
testq %rcx, %rcx
jne 0x13fc58
movq %r15, 0x88(%r14)
testq %rax, %rax
je 0x13fc68
movq %rax, ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_format_lha_cleanup | static int
archive_read_format_lha_cleanup(struct archive_read *a)
{
struct lha *lha = (struct lha *)(a->format->data);
lzh_decode_free(&(lha->strm));
archive_string_free(&(lha->dirname));
archive_string_free(&(lha->filename));
archive_string_free(&(lha->uname));
archive_string_free(&(lha->gname));
archive_wstr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x198(%r14), %rax
testq %rax, %rax
je 0x142c3d
movq 0x10(%rax), %rdi
callq 0x14220
movq 0x198(%r14), %rdi
addq $0x38, %rdi
callq 0x143e16
movl $0xb8, %edi
addq 0x198(%r14), %rdi
callq 0x143e16
movq 0x198(%r14), %rdi
callq 0x1... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_lha.c |
lha_check_header_format | static size_t
lha_check_header_format(const void *h)
{
const unsigned char *p = h;
size_t next_skip_bytes;
switch (p[H_METHOD_OFFSET+3]) {
/*
* "-lh0-" ... "-lh7-" "-lhd-"
* "-lzs-" "-lz5-"
*/
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case 'd':
case 's':
next_skip_... | movzbl 0x5(%rdi), %ecx
cmpl $0x63, %ecx
jg 0x142d28
leal -0x30(%rcx), %eax
cmpl $0x8, %eax
jae 0x142d56
movl $0x4, %eax
cmpb $0x0, (%rdi)
je 0x142d55
cmpb $0x2d, 0x2(%rdi)
jne 0x142d55
cmpb $0x6c, 0x3(%rdi)
jne 0x142d55
cmpb $0x2d, 0x6(%rdi)
jne 0x142d55
movzbl 0x4(%rdi), %edx
cmpl $0x7a, %edx
je 0x142d07
cmpl $0x68, %... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_lha.c |
archive_read_support_format_mtree | int
archive_read_support_format_mtree(struct archive *_a)
{
static const struct archive_rb_tree_ops rb_ops = {
mtree_cmp_node, mtree_cmp_key,
};
struct archive_read *a = (struct archive_read *)_a;
struct mtree *mtree;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_supp... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x89e74(%rip), %rcx # 0x1cdcbc
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x143f25
movl $0x1, %edi
movl $0xb8, %esi
callq 0x14be0
testq %rax, ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_mtree_options | static int
archive_read_format_mtree_options(struct archive_read *a,
const char *key, const char *val)
{
struct mtree *mtree;
mtree = (struct mtree *)(a->format->data);
if (strcmp(key, "checkfs") == 0) {
/* Allows to read information missing from the mtree from the file system */
if (val == NULL || val[0] ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq 0x818(%rdi), %rcx
movq (%rcx), %r14
leaq 0x6c9a3(%rip), %rsi # 0x1b0946
movq %rax, %rdi
callq 0x14b40
movl %eax, %ecx
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
testl %ecx, %ecx
jne 0x143fce
xorl %eax, %eax
testq %rbx, %rbx
je 0x143fc5
cmpb ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
read_data | static int
read_data(struct archive_read *a, const void **buff, size_t *size,
int64_t *offset)
{
size_t bytes_to_read;
ssize_t bytes_read;
struct mtree *mtree;
mtree = (struct mtree *)(a->format->data);
if (mtree->fd < 0) {
*buff = NULL;
*offset = 0;
*size = 0;
return (ARCHIVE_EOF);
}
if (mtree->buf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq 0x818(%rdi), %rax
movq (%rax), %r13
movl 0x30(%r13), %ebp
testl %ebp, %ebp
js 0x144e3a
movq %rdi, %rbx
cmpq $0x0, 0x20(%r13)
jne 0x144df8
movq $0x10000, 0x18(%r13) # imm = 0x10000
movl $0... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
detect_form | static int
detect_form(struct archive_read *a, int *is_form_d)
{
const char *p;
ssize_t avail, ravail;
ssize_t len, nl;
int entry_cnt = 0, multiline = 0;
int form_D = 0;/* The archive is generated by `NetBSD mtree -D'
* (In this source we call it `form D') . */
if (is_form_d != NULL)
*is_form_d = 0;
p = __... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, 0x28(%rsp)
testq %rsi, %rsi
je 0x144fa9
movl $0x0, (%rbx)
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
movq 0x28(%rsp), %rdi
callq 0x12865f
testq %rax, %rax
je 0x145489
movq %rax, %rbp
movq %rbx, 0x30(%rsp)
movq $0x0,... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
remove_option | static void
remove_option(struct mtree_option **global, const char *value, size_t len)
{
struct mtree_option *iter, *last;
last = NULL;
for (iter = *global; iter != NULL; last = iter, iter = iter->next) {
if (strncmp(iter->value, value, len) == 0 &&
(iter->value[len] == '\0' ||
iter->value[len] == '=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x145ade
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rax, %r12
movq 0x8(%rax), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x142f0
testl %eax, %eax
jne 0x145ad2
mov... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
parse_device | static int
parse_device(dev_t *pdev, struct archive *a, char *val)
{
#define MAX_PACK_ARGS 3
unsigned long numbers[MAX_PACK_ARGS];
char *p, *dev;
int argc;
pack_t *pack;
dev_t result;
const char *error = NULL;
memset(pdev, 0, sizeof(*pdev));
if ((dev = strchr(val, ',')) != NULL) {
/*
* Device's major/mino... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, 0x18(%rsp)
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq %rdx, %rdi
movl $0x2c, %esi
callq 0x146b0
testq %rax, %rax
je 0x146496
movq %rax, %r13
movb $0x0, (%rax)
mo... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
mtree_atol | static int64_t
mtree_atol(char **p, int base)
{
int64_t l, limit;
int digit, last_digit_limit;
if (base == 0) {
if (**p != '0')
base = 10;
else if ((*p)[1] == 'x' || (*p)[1] == 'X') {
*p += 2;
base = 16;
} else {
base = 8;
}
}
if (**p == '-') {
limit = INT64_MIN / base;
last_digit_limit =... | pushq %rbx
testl %esi, %esi
jne 0x146565
movq (%rdi), %rax
movl $0xa, %esi
cmpb $0x30, (%rax)
jne 0x146565
movzbl 0x1(%rax), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x146560
addq $0x2, %rax
movq %rax, (%rdi)
movl $0x10, %esi
jmp 0x146565
movl $0x8, %esi
movq (%rdi), %r10
movsbl (%r10), %r9d
movl %esi, %r8d
cmpl $0x2d... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_rar_bid | static int
archive_read_format_rar_bid(struct archive_read *a, int best_bid)
{
const char *p;
/* If there's already a bid > 30, we'll never win. */
if (best_bid > 30)
return (-1);
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return (-1);
if (memcmp(p, RAR_SIGNATURE, 7) == 0)
return (30);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x1e, %esi
jg 0x146a15
movq %rdi, %rbx
movl $0x7, %esi
xorl %edx, %edx
callq 0x12865f
testq %rax, %rax
je 0x146a15
movl $0x21726152, %ecx # imm = 0x21726152
xorl (%rax), %ecx
movl $0x... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_header | static int
archive_read_format_rar_read_header(struct archive_read *a,
struct archive_entry *entry)
{
const void *h;
const char *p;
struct rar *rar;
size_t skip;
char head_type;
int ret;
unsigned flags;
unsigned long crc32_expected;
a->archive.archive_format = ARCH... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movl $0xd0000, 0x10(%rdi) # imm = 0xD0000
cmpq $0x0, 0x18(%rdi)
jne 0x146add
leaq 0x6e0da(%rip), %rax # 0x1b4bb3
movq %rax, 0x18(%r14)
movq 0x818(%r14), %rax
movq (%rax), %rax
movq %rax, (%rsp... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_seek_data | static int64_t
archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
int whence)
{
int64_t client_offset, ret;
unsigned int i;
struct rar *rar = (struct rar *)(a->format->data);
if (rar->compression_method == COMPRESS_METHOD_STORE)
{
/* Modify the offset for use with SEEK_SET */
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
cmpb $0x30, 0x17(%r15)
jne 0x1471f1
cmpl $0x1, %edx
je 0x147213
cmpl $0x2, %edx
jne 0x14721e
movl $0x28, %eax
jmp 0x147218
leaq 0x873e7(%rip), %rdx # 0x1ce5df
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xor... | /mmatuska[P]libarchive/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_LOCALTIME_S)
struct tm tmbuf;
#endif
if (p + 2 > endp)
return (-1);
flags = archive_le16d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x2(%rdi), %r8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rdx, 0x10(%rsp)
cmpq %rdx, %r8
ja 0x148302
movzwl (%rdi), %ebx
leaq 0x70(%rsi), %rax
movq %rax, 0x30(%rsp)
leaq 0x78(%rsi), %rax
movq %rax, 0x28(%rsp)
leaq 0x80(%r... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar.c |
copy_from_lzss_window_to_unp | static int
copy_from_lzss_window_to_unp(struct archive_read *a, const void **buffer,
int64_t startpos, size_t length)
{
int windowoffs, firstpart;
struct rar *rar = (struct rar *)(a->format->data);
if (length > rar->unp_buffer_size)
{
goto fatal;
}
if (!rar->unp_buffer)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbp
movl 0xd8(%rbp), %edi
cmpq %rcx, %rdi
jae 0x148e12
leaq 0x85623(%rip), %rdx # 0x1ce41c
movq %r15, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x1623e9
movl $0xffffffe2, %eax # ... | /mmatuska[P]libarchive/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x818(%rdi), %rax
movq (%rax), %r13
leaq 0x4f30(%r13), %r14
movq %rdi, (%rsp)
callq 0x14b088
movl 0x4f38(%r13), %eax
andl $-0x8, %eax
movl %eax, 0x4f38(%r13)
jg 0x148f5d
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x14ae52
testl %eax, %... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar.c |
expand | static int
expand(struct archive_read *a, int64_t *end)
{
static const unsigned char lengthbases[] =
{ 0, 1, 2, 3, 4, 5, 6,
7, 8, 10, 12, 14, 16, 20,
24, 28, 32, 40, 48, 56, 64,
80, 96, 112, 128, 160, 192, 224 };
static const unsigned char lengthbits[] =
{ 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %r13
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movq 0x3a8(%rbx), %rax
cmpq (%rsi), %rax
jge 0x1497bc
movq %rax, (%r14)
movq 0x360(%rbx), %rax
xorl %ebp, %ebp
cmpq (%r14), %rax
jge 0x149... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar.c |
execute_filter_e8 | static int
execute_filter_e8(struct rar_filter *filter, struct rar_virtual_machine *vm, size_t pos, int e9also)
{
uint32_t length = filter->initialregisters[4];
uint32_t filesize = 0x1000000;
uint32_t i;
if (length > PROGRAM_WORK_SIZE || length <= 4)
return 0;
for (i = 0; i <= length - 5; i++)
{
i... | movl 0x18(%rdi), %r8d
leal -0x3c001(%r8), %r9d
xorl %eax, %eax
cmpl $0xfffc4004, %r9d # imm = 0xFFFC4004
jb 0x14ae51
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, -0x8(%rsp)
leal -0x5(%r8), %eax
incl %edx
xorl %r9d, %r9d
testl %ecx, %ecx
setne %r10b
movl %r9d, %r11d
movb 0x20(%rsi,%r... | /mmatuska[P]libarchive/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 %r14
pushq %rbx
pushq %rax
movq 0x818(%rdi), %rax
movq (%rax), %r14
leaq 0x118(%r14), %rbx
movq 0x118(%r14), %rdi
callq 0x14220
movq 0x140(%r14), %rdi
callq 0x14220
movq 0x168(%r14), %rdi
callq 0x14220
movq 0x190(%r14), %rdi
callq 0x14220
movq 0x138(%r14), %rdi
callq 0x14220
movq 0x160(%r14), %rdi
callq 0x14220
m... | /mmatuska[P]libarchive/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 $0x38, %rsp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rsi)
movq %rsi, %rdi
callq 0x14b543
testl %eax, %eax
js 0x14b341
movq %rbx, 0x10(%rsp)
movl $0x1, 0x8(%r15)
movabsq $-0x7fffffff80000001, %rax # imm = 0x800... | /mmatuska[P]libarchive/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl %eax, 0xc(%rdi)
jne 0x14b57d
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x100, %r14d # imm = 0x100
cmovgl %ecx, %r14d
movq (%rbx), %rdi
leaq (,%r14,8), %rsi
callq 0x140e0
testq %rax, %rax
je 0x14b5a4
movq %rax, (%rbx)
movl %r14d, 0x... | /mmatuska[P]libarchive/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 0x14bac6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x30(%rbx), %r14
callq 0x14220
movq 0x10(%rbx), %rdi
callq 0x14220
movq %rbx, %rdi
callq 0x14220
movq %r14, %rbx
testq %r14, %r14
jne 0x14ba9a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmatuska[P]libarchive/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 0x82dbb(%rip), %rcx # 0x1ce897
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x18d4b2
xorl %ebp, %ebp
cmpl $-0x1e, %eax
cmovel %eax, %ebp
je 0x14bc0a
movl $0x5340, %edi # imm = 0x5340
ca... | /mmatuska[P]libarchive/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 && (rar->cstate.data_encrypted == 0)) {
/* 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 th... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
testb $0x1, 0x2c(%r15)
je 0x14c16f
testb $0x10, 0x38(%r15)
jne 0x14c16f
movq 0x4ba8(%r15), %r14
testq %r14, %r14
jle 0x14c168
incl 0x8(%r15)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14bf69
decl 0x8(%... | /mmatuska[P]libarchive/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)
{
int64_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 $0x2038, %rsp # imm = 0x2038
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x10(%rsp)
movq %rdx, %rdi
callq 0x12119c
testb $0x4, 0x38(%rbx)
jne 0x14c82b
leaq 0x4ba8(%rbx), ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar5.c |
uncompress_file | static int uncompress_file(struct archive_read* a) {
int ret;
while(1) {
/* Sometimes the uncompression function will return a
* 'retry' signal. If this will happen, we have to retry
* the function. */
ret = do_uncompress_file(a);
if(ret != ARCHIVE_RETRY)
return ret;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdi, %rbx
leaq 0xc(%rsp), %r13
movq %rdi, 0x10(%rsp)
movq 0x818(%rbx), %rax
movq (%rax), %r12
testb $0x1, 0x38(%r12)
jne 0x14dd6c
testb $0x1, 0x2c(%r12)
je 0x14dcb3
cmpq $0x0, 0x50(%r12)
jne 0x14dd66
movl ... | /mmatuska[P]libarchive/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 0x14f833
testl %eax, %eax
jne 0x14f829
movzwl 0xe(%rsp), %eax
andl $-0x2, %eax
movw %ax, 0xe(%rsp)
movl 0x84(%r14), %edx
cmpl %eax, 0x4(%r14,%rdx,4)
jle 0... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_rar5.c |
archive_read_format_tar_bid | static int
archive_read_format_tar_bid(struct archive_read *a, int best_bid)
{
int bid;
const char *h;
const struct archive_entry_header_ustar *header;
(void)best_bid; /* UNUSED */
bid = 0;
/* Now let's look at the actual header and see if it matches. */
h = __archive_read_ahead(a, 512, NULL);
if (h == NULL)... | pushq %rbp
pushq %r14
pushq %rbx
movl $0x200, %esi # imm = 0x200
xorl %edx, %edx
callq 0x12865f
testq %rax, %rax
je 0x15000d
movq %rax, %rbx
cmpb $0x0, (%rax)
jne 0x14fee0
xorl %eax, %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
jne 0x14fed8
leaq 0x1(%rax), %rdx
cmpl $0x1ff, %eax # imm = 0x1FF
movq %r... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
checksum | static int
checksum(struct archive_read *a, const void *h)
{
const unsigned char *bytes;
const struct archive_entry_header_ustar *header;
int check, sum;
size_t i;
(void)a; /* UNUSED */
bytes = (const unsigned char *)h;
header = (const struct archive_entry_header_ustar *)h;
/* Checksum field must hold an octa... | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movzbl 0x94(%rbx,%rax), %ecx
leal -0x30(%rcx), %edx
cmpl $0x8, %edx
jae 0x151395
incq %rax
cmpq $0x8, %rax
jne 0x15137a
jmp 0x1513a5
cmpl $0x20, %ecx
je 0x15138a
testl %ecx, %ecx
je 0x15138a
xorl %ecx, %ecx
jmp 0x151436
leaq 0x94(%rbx), %rdi
movl $0x8, %esi
callq 0x1514a3
xorl... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
header_pax_extension | static int
header_pax_extension(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h, size_t *unconsumed)
{
/* Sanity checks: The largest `x` body I've ever heard of was
* a little over 4MB. So I doubt there has ever been a
* well-formed archive with an `x` body over 1GiB. Simi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r13
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x7c(%rcx), %rdi
movl $0xc, %esi
callq 0x1514a3
movq %rax, %r15
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF... | /mmatuska[P]libarchive/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;
int r;
(void)tar; /* UNUSED */
header = (const struct archive_entry_header_ustar *)h;
size = tar_atol(header-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x7c(%rdx), %rdi
movl $0xc, %esi
callq 0x1514a3
movq %rax, %rbx
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, %rbx
jle 0x1520bc
movl %ebp, %... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
gnu_sparse_01_parse | static int
gnu_sparse_01_parse(struct archive_read *a, struct tar *tar, const char *p, size_t length)
{
const char *e;
int64_t offset = -1, size = -1;
for (;;) {
e = p;
while (length > 0 && *e != ',') {
if (*e < '0' || *e > '9')
return (ARCHIVE_WARN);
e++;
length--;
}
if (offset < 0) {
offse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq $-0x1, %r12
testq %r14, %r14
sete %bpl
je 0x1532cb
movb (%rdx), %cl
cmpb $0x2c, %cl
jne 0x153323
movq %rdx, %r13
movq %r13, %rsi
subq %rdx, %rsi
movq %rdx, %rdi
movl $0xa, %edx
callq 0x15155... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
pax_attribute_SCHILY_xattr | static int
pax_attribute_SCHILY_xattr(struct archive_entry *entry,
const char *name, size_t name_length, const char *value, size_t value_length)
{
if (name_length < 1 || name_length > 128) {
return 1;
}
char * null_terminated_name = malloc(name_length + 1);
if (null_terminated_name != NULL) {
memcpy(null_term... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq $0x80, %rdx
ja 0x153a1a
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq %r8, (%rsp)
leaq 0x1(%rdx), %rdi
callq 0x14cd0
xorl %ebx, %ebx
testq %rax, %rax
je 0x153a1a
movq %rax, %r14
movq %rax, %rdi
movq ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
pax_attribute_SUN_holesdata | static int
pax_attribute_SUN_holesdata(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const char *p, size_t length)
{
const char *e;
int64_t start, end;
int hole = 1;
(void)entry; /* UNUSED */
end = 0;
if (length <= 0)
return (ARCHIVE_WARN);
if (*p == ' ') {
p++;
length--;
} else... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffffec, 0x8(%rsp) # imm = 0xFFFFFFEC
testq %rcx, %rcx
je 0x153b56
movq %rdx, %r12
cmpb $0x20, (%rdx)
jne 0x153b56
movq %rcx, %r13
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
xorl %ebx, %ebx
leaq 0x1(%r12), %rdi
... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_tar.c |
warc_rdhdr | static int
_warc_rdhdr(struct archive_read *a, struct archive_entry *entry)
{
#define HDR_PROBE_LEN (12U)
struct warc_s *w = a->format->data;
unsigned int ver;
const char *buf;
ssize_t nrd;
const char *eoh;
char *tmp;
/* for the file name, saves some strndup()'ing */
warc_string_t fnam;
/* warc record type, n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, %r13
movq 0x818(%rdi), %rax
movq (%rax), %r12
leaq 0x40(%rsp), %rbx
movl $0xc, %esi
movq %rbx, %rdx
callq 0x12865f
movq (%rbx), %rsi
testq %rsi, %rsi
js 0x154a24
movq %rax, %r14
leaq 0x30(%r12), %rax
movq... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_warc.c |
xar_read_header | static int
xar_read_header(struct archive_read *a, struct archive_entry *entry)
{
struct xar *xar;
struct xar_file *file;
struct xattr *xattr;
int r;
xar = (struct xar *)(a->format->data);
r = ARCHIVE_OK;
if (xar->offset == 0) {
/* Create a character conversion object. */
if (xar->sconv == NULL) {
xar->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %rbp
cmpq $0x0, (%rbp)
movq %rdi, 0x8(%rsp)
je 0x155367
movl $0xf000, %ebx # imm = 0xF000
movl 0x1bc(%rbp), %ecx
testl %ecx, %ecx
jle 0x15528b
movq 0x1b0(%rbp)... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
xar_read_data | static int
xar_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
struct xar *xar;
size_t used = 0;
int r;
xar = (struct xar *)(a->format->data);
if (xar->entry_unconsumed) {
__archive_read_consume(a, xar->entry_unconsumed);
xar->entry_unconsumed = 0;
}
if (xar->end_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq $0x0, (%rsp)
movq 0x818(%rdi), %rax
movq (%rax), %r13
movq 0x1e8(%r13), %rsi
testq %rsi, %rsi
je 0x155ac0
movq %r12, %rdi
callq 0x128915
movq $0x0, 0x1e8(%r13)
movl $0x1, %eb... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
xar_cleanup | static int
xar_cleanup(struct archive_read *a)
{
struct xar *xar;
struct hdlink *hdlink;
int i;
int r;
xar = (struct xar *)(a->format->data);
checksum_cleanup(a);
r = decompression_cleanup(a);
hdlink = xar->hdlink_list;
while (hdlink != NULL) {
struct hdlink *next = hdlink->next;
free(hdlink);
hdlink =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
leaq 0xafb50(%rip), %r15 # 0x2057b0
movl 0x170(%r14), %eax
cmpl $0x1, %eax
je 0x155c7c
cmpl $0x2, %eax
jne 0x155c8d
leaq 0x10(%r15), %rax
movl $0x178, %edi # imm = 0x178
jmp 0x155c85
leaq... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
move_reading_point | static int
move_reading_point(struct archive_read *a, uint64_t offset)
{
struct xar *xar;
xar = (struct xar *)(a->format->data);
if (xar->offset - xar->h_base != offset) {
/* Seek forward to the start of file contents. */
int64_t step;
step = offset - (xar->offset - xar->h_base);
if (step > 0) {
step = ... | pushq %r15
pushq %r14
pushq %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
movq (%r15), %rdx
movq 0x10(%r15), %rax
subq %rax, %rdx
movq %rsi, %rcx
subq %rdx, %rcx
je 0x155eb5
movq %rdi, %rbx
testq %rcx, %rcx
jle 0x155e67
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x128915
testq %rax, %rax
js 0x155ea6
addq %rax, (%r15)
jmp 0x... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
rd_contents | static int
rd_contents(struct archive_read *a, const void **buff, size_t *size,
size_t *used, uint64_t remaining)
{
const unsigned char *b;
ssize_t bytes;
/* Get whatever bytes are immediately available. */
b = __archive_read_ahead(a, 1, &bytes);
if (bytes < 0)
return ((int)bytes);
if (bytes == 0) {
arch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x12865f
movq (%r15), %r15
testq %r15, %r15
js 0x15616e
je 0x156152
movq %rax, %rsi
movq %rbp, 0x8... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
xml2_read_toc | static int
xml2_read_toc(struct archive_read *a)
{
xmlTextReaderPtr reader;
struct xmlattr_list list;
int r;
reader = xmlReaderForIO(xml2_read_cb, xml2_close_cb, a, NULL, NULL, 0);
if (reader == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Couldn't allocate memory for xml parser");
return (ARCHIVE_FA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
leaq 0x14f2(%rip), %rdi # 0x157902
leaq 0x1565(%rip), %rsi # 0x15797c
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14f40
testq %rax, %rax
je 0x1578b2
movq %rax, %r14
leaq 0x1545(%rip),... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
xml_end | static void
xml_end(void *userData, const char *name)
{
struct archive_read *a;
struct xar *xar;
a = (struct archive_read *)userData;
xar = (struct xar *)(a->format->data);
#if DEBUG
fprintf(stderr, "xml_end:[%s]\n", name);
#endif
switch (xar->xmlsts) {
case INIT:
break;
case XAR:
if (strcmp(name, "xar") ... | pushq %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movl 0x28(%rbx), %eax
decl %eax
cmpl $0x4c, %eax
ja 0x157ea8
leaq 0x786f7(%rip), %rcx # 0x1d00b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6071e(%rip), %rax # 0x1b80eb
movq %rsi, %rdi
movq %rax, %rsi
callq 0x14b40
testl %eax, %eax
jne 0x157e... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
unknowntag_start | static int
unknowntag_start(struct archive_read *a, struct xar *xar, const char *name)
{
struct unknown_tag *tag;
tag = malloc(sizeof(*tag));
if (tag == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
tag->next = xar->unknowntags;
archive_string_init(&(tag->name));
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movl $0x20, %edi
callq 0x14cd0
testq %rax, %rax
je 0x157f09
movq %rax, %r14
movq 0x30(%rbx), %rax
movq %rax, (%r14)
movq %r14, %r12
addq $0x8, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
test... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
getencoding | static int
getencoding(struct xmlattr_list *list)
{
struct xmlattr *attr;
enum enctype encoding = NONE;
for (attr = list->first; attr != NULL; attr = attr->next) {
if (strcmp(attr->name, "style") == 0) {
if (strcmp(attr->value, "application/octet-stream") == 0)
encoding = NONE;
else if (strcmp(attr->val... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
xorl %ebx, %ebx
testq %r13, %r13
je 0x158385
leaq 0x78154(%rip), %r14 # 0x1d0431
leaq 0x78153(%rip), %r15 # 0x1d0437
leaq 0x78165(%rip), %r12 # 0x1d0450
movq 0x8(%r13), %rdi
movq %r14, %rsi
callq 0x14b40
testl %ea... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.c |
checksum_final | static int
_checksum_final(struct chksumwork *sumwrk, const void *val, size_t len)
{
unsigned char sum[MAX_SUM_SIZE];
int r = ARCHIVE_OK;
switch (sumwrk->alg) {
case CKSUM_NONE:
break;
case CKSUM_SHA1:
archive_sha1_final(&(sumwrk->sha1ctx), sum);
if (len != SHA1_SIZE ||
memcmp(val, sum, SHA1_SIZE) != ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movl (%rdi), %eax
xorl %ebx, %ebx
cmpl $0x2, %eax
je 0x158e03
cmpl $0x1, %eax
jne 0x158e34
leaq 0xac9dd(%rip), %rax # 0x2057b0
addq $0x10, %rdi
movq %rsp, %rsi
callq *0x40(%rax)
cmpq $0x14, %r15
jne 0x158e2f
movdqu (%r14), %xmm0
movd ... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_xar.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 0x15c1f8
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... | /mmatuska[P]libarchive/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
cmpb $0x0, 0x1f98(%rdi)
je 0x15c2c9
movq %rsi, %r14
leaq 0x20(%rsp), %rdx
movq $0x14, (%rdx)
leaq 0xab99d(%rip), %rax # 0x207bd0
addq $0x1f90, %rdi # imm = 0x1F90
movq %rsp, %rsi
callq *0x... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_zip.c |
read_decryption_header | static int
read_decryption_header(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
const char *p;
unsigned int remaining_size;
unsigned int ts;
/*
* Read an initialization vector data field.
*/
p = __archive_read_ahead(a, 2, NULL);
if (p == NULL)
goto truncated;
ts = zip->iv_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
movl $0x2, %esi
xorl %edx, %edx
callq 0x12865f
testq %rax, %rax
je 0x15c427
movl 0x1f9c(%r15), %ebp
movzwl (%rax), %eax
movl %eax, 0x1f9c(%r15)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x128915
cmpl 0x1f9c(%r15)... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_zip.c |
init_traditional_PKWARE_decryption | static int
init_traditional_PKWARE_decryption(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
const void *p;
int retry;
int r;
if (zip->tctx_valid)
return (ARCHIVE_OK);
/*
Read the 12 bytes encryption header stored at
the start of the data area.
*/
#define ENC_HEADER_SIZ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x818(%rdi), %rax
movq (%rax), %rbp
xorl %eax, %eax
cmpb $0x0, 0x1f2c(%rbp)
jne 0x15c9be
movq %rdi, %rbx
movq 0x70(%rbp), %rax
testb $0x8, 0x7e(%rax)
jne 0x15c82a
movq 0x78(%rbp), %rcx
cmpq $0xb, %rcx
jg 0x15c82a
leaq 0x74c5f(%rip),... | /mmatuska[P]libarchive/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
cmpq $0x0, 0x1ef8(%r14)
jne 0x15d4f5
movq %rdi, %rbx
movq $0x40000, 0x1f08(%r14) # imm = 0x40000
movl $0x40000, %edi # imm = 0x40000
callq 0x14cd0
movq %rax, 0x1ef8(%r14)
testq %rax, %rax
je 0x15d50d
movq 0x1ef8(%r14), %rax
movq %rax, 0x... | /mmatuska[P]libarchive/libarchive/archive_read_support_format_zip.c |
archive_wstring_append_from_mbs | int
archive_wstring_append_from_mbs(struct archive_wstring *dest,
const char *p, size_t len)
{
size_t r;
int ret_val = 0;
/*
* No single byte will be more than one wide character,
* so this length estimate will always be big enough.
*/
// size_t wcs_length = len;
size_t mbs_length = len;
const char *mbs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, (%rsp)
movq 0x8(%rdi), %rax
addq %rdx, %rax
leaq 0x4(,%rax,4), %rsi
callq 0x15d8c7
testq %rax, %rax
je 0x15dad4
movq 0x8(%rbx), %r14
shlq $0x2, %r14
addq (%rbx), %r14
cmpb $0x0, (%r12)... | /mmatuska[P]libarchive/libarchive/archive_string.c |
archive_string_append_from_wcs | int
archive_string_append_from_wcs(struct archive_string *as,
const wchar_t *w, size_t len)
{
/* We cannot use the standard wcstombs() here because it
* cannot tell us how big the output buffer should be. So
* I've built a loop around wcrtomb() or wctomb() that
* converts a character at a time and resizes t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq $0x0, 0x20(%rsp)
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x15d8c7
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x15dc92
movq (%rbx), %r14
mov... | /mmatuska[P]libarchive/libarchive/archive_string.c |
archive_mstring_get_mbs_l | int
archive_mstring_get_mbs_l(struct archive *a, struct archive_mstring *aes,
const char **p, size_t *length, struct archive_string_conv *sc)
{
int ret = 0;
#if defined(_WIN32) && !defined(__CYGWIN__)
int r;
/*
* Internationalization programming on Windows must use Wide
* characters because Windows platform... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
testb $0x1, 0x60(%rsi)
jne 0x15e8ea
movq %rsp, %rdx
movq %r14, %rsi
callq 0x15e766
testb $0x1, 0x60(%r14)
jne 0x15e903
movq $0x0, (%r15)
xorl %eax, %eax
testq %rbx, %rbx
je 0x15e955
xorl %edx, %edx
jmp ... | /mmatuska[P]libarchive/libarchive/archive_string.c |
strncat_from_utf8_to_utf8 | static int
strncat_from_utf8_to_utf8(struct archive_string *as, const void *_src,
size_t len, struct archive_string_conv *sc)
{
int ret = 0;
const char *src = _src;
(void)sc; /* UNUSED */
/* Pre-extend the destination */
if (archive_string_ensure(as, as->length + len + 1) == NULL)
return (-1);
/* Invarian... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
movq %rdi, 0x18(%rsp)
callq 0x15d8c7
testq %rax, %rax
je 0x161585
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %r15
movl $0xfffff800, %ebp # imm = 0xFFF... | /mmatuska[P]libarchive/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 0x16198c
testq %rsi, %rsi
je 0x1619ea
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
jmp 0x161a1b
cmpl $0x7ff, %ecx # imm = 0x7FF
ja 0x1619b2
cmpq $0x2, %rsi
jb 0x1619ea
movl %ecx, %eax
shrl... | /mmatuska[P]libarchive/libarchive/archive_string.c |
best_effort_strncat_from_utf16 | static int
best_effort_strncat_from_utf16(struct archive_string *as, const void *_p,
size_t bytes, struct archive_string_conv *sc, int be)
{
const char *utf16 = (const char *)_p;
char *mbs;
uint32_t uc;
int n, ret;
(void)sc; /* UNUSED */
/*
* Other case, we should do the best effort.
* If all character a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x15d8c7
testq %rax, %rax
je 0x161db9
movq (%r12), %rbx
movq %r12, 0x10(%rsp)
addq 0x8(%r12), %rbx
leaq 0xc(%rsp)... | /mmatuska[P]libarchive/libarchive/archive_string.c |
dos_to_unix | int64_t
dos_to_unix(uint32_t dos_time)
{
uint16_t msTime, msDate;
struct tm ts;
msTime = (0xFFFF & dos_time);
msDate = (dos_time >> 16);
ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
ts.tm_mday = msDate & 0x1f; /* Day of month. */
... | subq $0x38, %rsp
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %edx
shrl $0x19, %edx
addl $0x50, %edx
movq %rsp, %rax
movl %edx, 0x14(%rax)
movl %edi, %edx
shrl $0x15, %edx
andl $0xf, %edx
decl %edx
movl %edx, 0x10(%rax)
andl $0x1f, %ecx
movl %ecx, 0xc(%rax)
movl %edi, %ecx
shrl $0xb, %ecx
andl $0x1f, %ecx
movl %ecx, 0x8... | /mmatuska[P]libarchive/libarchive/archive_time.c |
archive_set_error | void
archive_set_error(struct archive *a, int error_number, const char *fmt, ...)
{
va_list ap;
a->archive_error_number = error_number;
if (fmt == NULL) {
a->error = NULL;
return;
}
archive_string_empty(&(a->error_string));
va_start(ap, fmt);
archive_string_vsprintf(&(a->error_string), fmt, ap);
va_end(ap... | pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x16243e
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(%rsp)
movaps %xm... | /mmatuska[P]libarchive/libarchive/archive_util.c |
_archive_errx | void
__archive_errx(int retvalue, const char *msg)
{
static const char msg1[] = "Fatal Internal Error in libarchive: ";
size_t s;
s = write(2, msg1, strlen(msg1));
(void)s; /* UNUSED */
s = write(2, msg, strlen(msg));
(void)s; /* UNUSED */
s = write(2, "\n", 1);
(void)s; /* UNUSED */
exit(retvalue);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x75a30(%rip), %rsi # 0x1d7f00
movl $0x24, %edx
movl $0x2, %edi
callq 0x14e20
movq %r14, %rdi
callq 0x14520
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x14e20
leaq 0x66e80(%rip), %rsi # 0x1c937e
movl $0x1, %edx
movl $0x2, %edi
call... | /mmatuska[P]libarchive/libarchive/archive_util.c |
archive_utility_string_sort_helper | static int
archive_utility_string_sort_helper(char **strings, unsigned int n)
{
unsigned int i, lesser_count, greater_count;
char **lesser, **greater, **tmp, *pivot;
int retval1, retval2;
/* A list of 0 or 1 elements is already sorted */
if (n <= 1)
return (ARCHIVE_OK);
lesser_count = greater_count = 0;
less... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
cmpl $0x2, %esi
jb 0x1627d8
movq %rdi, %rbx
movq (%rdi), %rbp
movl %esi, %eax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
movl $0x1, %r13d
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
mov... | /mmatuska[P]libarchive/libarchive/archive_util.c |
archive_liblz4_version | const char *
archive_liblz4_version(void)
{
#if HAVE_LZ4_H && HAVE_LIBLZ4
#if LZ4_VERSION_NUMBER > 10705
return LZ4_versionString();
#elif LZ4_VERSION_NUMBER > 10300
div_t major = div(LZ4_versionNumber(), 10000);
div_t minor = div(major.rem, 100);
static char lz4_version[9];
snprintf(lz4_version, 9, "%d.%d.%d", ma... | xorl %eax, %eax
retq
| /mmatuska[P]libarchive/libarchive/archive_version_details.c |
archive_write_data_block | la_ssize_t
archive_write_data_block(struct archive *a, const void *buff, size_t s,
la_int64_t o)
{
if (a->vtable->archive_write_data_block == NULL) {
archive_set_error(a, ARCHIVE_ERRNO_MISC,
"archive_write_data_block not supported");
a->state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
return ((... | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1629b3
movq %rbx, %rdi
popq %rbx
jmpq *%rax
leaq 0x755b7(%rip), %rdx # 0x1d7f71
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x1623e9
movl $0x8000, 0x4(%rbx) # imm = 0x8000
movq ... | /mmatuska[P]libarchive/libarchive/archive_virtual.c |
archive_write_new | struct archive *
archive_write_new(void)
{
struct archive_write *a;
unsigned char *nulls;
a = calloc(1, sizeof(*a));
if (a == NULL)
return (NULL);
a->archive.magic = ARCHIVE_WRITE_MAGIC;
a->archive.state = ARCHIVE_STATE_NEW;
a->archive.vtable = &archive_write_vtable;
/*
* The value 10240 here matches the t... | pushq %rbx
movl $0x1, %edi
movl $0x158, %esi # imm = 0x158
callq 0x14be0
testq %rax, %rax
je 0x162a68
movq %rax, %rbx
movabsq $0x1b0c5c0de, %rax # imm = 0x1B0C5C0DE
movq %rax, (%rbx)
leaq 0xa489d(%rip), %rax # 0x2072c0
movq %rax, 0x8(%rbx)
movabsq $-0xffffd800, %rax # imm = 0xFFFFFFFF00002800
m... | /mmatuska[P]libarchive/libarchive/archive_write.c |
_archive_write_output | int
__archive_write_output(struct archive_write *a, const void *buff, size_t length)
{
return (__archive_write_filter(a->filter_first, buff, length));
} | pushq %r14
pushq %rbx
pushq %rax
movq 0xe8(%rdi), %r14
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $0x2, 0x64(%r14)
jne 0x162c64
movq %rdx, %rbx
testq %rdx, %rdx
je 0x162c62
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x162c64
movq %r14, %rdi
movq %rbx, %rdx
callq *%rcx
addq %rbx, (%r14)
jmp 0x162c64
xorl %eax, ... | /mmatuska[P]libarchive/libarchive/archive_write.c |
archive_write_open2 | int
archive_write_open2(struct archive *_a, void *client_data,
archive_open_callback *opener, archive_write_callback *writer,
archive_close_callback *closer, archive_free_callback *freer)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *client_filter;
int ret, r1;
archiv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x7532e(%rip), %rcx # 0x1d8044
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp ... | /mmatuska[P]libarchive/libarchive/archive_write.c |
_archive_write_filters_free | void
__archive_write_filters_free(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r = ARCHIVE_OK, r1;
while (a->filter_first != NULL) {
struct archive_write_filter *next
= a->filter_first->next_filter;
if (a->filter_first->free != NULL) {
r1 = (*a->filter_first->free)(a-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8(%rdi), %rdi
testq %rdi, %rdi
je 0x1632b2
movq 0x10(%rdi), %r14
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x163297
callq *%rax
movq 0xe8(%rbx), %rdi
callq 0x14220
movq %r14, 0xe8(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x163288
movq $0x0, 0xf0(%rbx)
addq $0x8... | /mmatuska[P]libarchive/libarchive/archive_write.c |
archive_write_free | static int
_archive_write_free(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r = ARCHIVE_OK, r1;
if (_a == NULL)
return (ARCHIVE_OK);
/* It is okay to call free() in state FATAL. */
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FAT... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x163422
movq %rdi, %rbx
leaq 0x74cf3(%rip), %rcx # 0x1d806b
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0xffff, %edx # imm = 0xFFFF
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x163424
xorl %ebp, %ebp
c... | /mmatuska[P]libarchive/libarchive/archive_write.c |
archive_write_data | static ssize_t
_archive_write_data(struct archive *_a, const void *buff, size_t s)
{
struct archive_write *a = (struct archive_write *)_a;
const size_t max_write = INT_MAX;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_DATA, "archive_write_data");
/* In particular, this catches attempts ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x74aee(%rip), %rcx # 0x1d8101
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x4, %edx
callq 0x18d4b2
cmpl $-0x1e, %eax
jne 0x16363a
movq $-0x1e, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
pop... | /mmatuska[P]libarchive/libarchive/archive_write.c |
archive_filter_name | static struct archive_write_filter *
filter_lookup(struct archive *_a, int n)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = a->filter_first;
if (n == -1)
return a->filter_last;
if (n < 0)
return NULL;
while (n > 0 && f != NULL) {
f = f->next_filter;
--n;
}
retur... | cmpl $-0x1, %esi
je 0x16374f
testl %esi, %esi
js 0x163758
movq 0xe8(%rdi), %rax
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x16375a
movq 0x10(%rax), %rax
cmpl $0x2, %esi
jl 0x16375a
decl %esi
testq %rax, %rax
jne 0x16373d
jmp 0x16375a
movq 0xf0(%rdi), %rax
jmp 0x16375a
xorl %eax, %eax
testq %... | /mmatuska[P]libarchive/libarchive/archive_write.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 0x16377b
callq 0x163767
jmp 0x16377d
xorl %eax, %eax
testl %eax, %eax
jne 0x1637b5
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $0x1, 0x64(%rbx)
jne 0x1637b5
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1637ab
movq %rbx, %rdi
callq *%rax
testl ... | /mmatuska[P]libarchive/libarchive/archive_write.c |
archive_write_disk_gid | int64_t
archive_write_disk_gid(struct archive *_a, const char *name, la_int64_t id)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_ANY, "archive_write_disk_gid");
if (a->lookup_gid)
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x748f0(%rip), %rcx # 0x1d81fc
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x18d4b2
movl %eax, %ecx
movq $-0x1e, %rax
cmpl $-0x1e, %ecx
je 0x16394c
movq 0xd0(%r15), %rax
testq ... | /mmatuska[P]libarchive/libarchive/archive_write_disk_posix.c |
archive_write_disk_new | struct archive *
archive_write_disk_new(void)
{
struct archive_write_disk *a;
a = calloc(1, sizeof(*a));
if (a == NULL)
return (NULL);
a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC;
/* We're ready to write a header immediately. */
a->archive.state = ARCHIVE_STATE_HEADER;
a->archive.vtable = &archive_write_disk_... | pushq %rbx
movl $0x1, %edi
movl $0x328, %esi # imm = 0x328
callq 0x14be0
testq %rax, %rax
je 0x163a48
movq %rax, %rbx
movabsq $0x2c001b0c5, %rax # imm = 0x2C001B0C5
movq %rax, (%rbx)
leaq 0xa394b(%rip), %rax # 0x207328
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x149c0
movq %rax, 0xc8(%rbx)
xorl %ed... | /mmatuska[P]libarchive/libarchive/archive_write_disk_posix.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.