name string | code string | asm string | file string |
|---|---|---|---|
cJSON_Minify | CJSON_PUBLIC(void) cJSON_Minify(char *json)
{
char *into = json;
if (json == NULL)
{
return;
}
while (json[0] != '\0')
{
switch (json[0])
{
case ' ':
case '\t':
case '\r':
case '\n':
json++;
... | testq %rdi, %rdi
je 0x52ac
movabsq $0x100002600, %rax # imm = 0x100002600
movq %rdi, %rcx
movq %rdi, %rdx
movzbl (%rdi), %esi
cmpq $0x2f, %rsi
ja 0x520b
btq %rsi, %rax
jae 0x51d1
incq %rdx
movq %rdx, %rdi
jmp 0x51b7
cmpq $0x22, %rsi
je 0x5221
cmpq $0x2f, %rsi
jne 0x520b
movzbl 0x1(%rdx), %esi
cmpl $0x2a, %esi
je 0... | /FSMaxB[P]cJSON/tests/../cJSON.c |
ensure | static unsigned char* ensure(printbuffer * const p, size_t needed)
{
unsigned char *newbuffer = NULL;
size_t newsize = 0;
if ((p == NULL) || (p->buffer == NULL))
{
return NULL;
}
if ((p->length > 0) && (p->offset >= p->length))
{
/* make sure that offset is valid */
... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x5c10
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5bf0
movq 0x10(%r14), %rcx
cmpq %rax, %rcx
setae %dl
cmpq $0x7fffffff, %rsi # imm = 0x7FFFFFFF
seta %dil
orb %dl, %dil
je 0x5bfd
jmp 0x5c10
cmpq $0x7fffffff, %rsi # imm = ... | /FSMaxB[P]cJSON/tests/../cJSON.c |
UnityAssertEqualFloatArray | void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
const UNITY_UINT32 num_elements,
const char* msg,
const UNITY_LI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq 0x53e6(%rip), %rax # 0xc140
orq 0x53d7(%rip), %rax # 0xc138
jne 0x6dd3
movq %r8, %r12
movl %edx, %ebp
testl %edx, %edx
je 0x6e56
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, %rdi
je 0x6dd3
movl %r9d, %r13d
movq %... | /FSMaxB[P]cJSON/tests/unity/src/unity.c |
UnityFail | void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
{
RETURN_IF_FAIL_OR_IGNORE;
UnityTestResultsBegin(Unity.TestFile, line);
UnityPrint(UnityStrFail);
if (msg != NULL)
{
UNITY_OUTPUT_CHAR(':');
#ifndef UNITY_EXCLUDE_DETAILS
if (Unity.CurrentDetail1)
{
Un... | movq 0x45d0(%rip), %rax # 0xc140
orq 0x45c1(%rip), %rax # 0xc138
je 0x7b7a
retq
pushq %rbx
movq %rdi, %rbx
movq 0x4573(%rip), %rdi # 0xc0f8
callq 0x682f
leaq 0xa88(%rip), %rdi # 0x8619
callq 0x61d2
testq %rbx, %rbx
je 0x7c0c
movl $0x3a, %edi
callq 0x3030
cmpq $0x0, 0x455b(%rip) # 0xc108
je 0x7... | /FSMaxB[P]cJSON/tests/unity/src/unity.c |
test_archive_read_add_passphrase_incorrect_sequance | DEFINE_TEST(test_archive_read_add_passphrase_incorrect_sequance)
{
struct archive* a = archive_read_new();
struct archive_read *ar = (struct archive_read *)a;
assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
/* No call of __archive_read_reset_passphrase() leads to
* get NULL even if a user h... | pushq %r15
pushq %r14
pushq %rbx
callq 0x12777c
movq %rax, %rbx
leaq 0x177555(%rip), %rsi # 0x19f235
movq %rax, %rdi
callq 0x12935d
movslq %eax, %r8
subq $0x8, %rsp
xorl %r15d, %r15d
leaq 0x1774ba(%rip), %r14 # 0x19f1b3
leaq 0x18e61c(%rip), %rcx # 0x1b631c
leaq 0x177534(%rip), %r9 # 0x19f23b
movq %r14, %rd... | /mmatuska[P]libarchive/libarchive/test/test_archive_read_add_passphrase.c |
file_skip | static int64_t
file_skip(struct archive *a, void *data, int64_t request)
{
struct mydata *mydata = (struct mydata *)data;
int64_t result = lseek(mydata->fd, SEEK_CUR, request);
if (result >= 0)
return result;
archive_set_error(a, errno, "Error seeking in '%s'", mydata->filename);
return -1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %edi
movl $0x1, %esi
callq 0x143e0
testq %rax, %rax
jns 0x2a357
callq 0x14de0
movl (%rax), %esi
movq (%r14), %rcx
leaq 0x17582f(%rip), %rdx # 0x19fb75
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1623e9
movq $-0x1, %rax
addq $0x8, %rsp
popq... | /mmatuska[P]libarchive/libarchive/test/test_archive_read_multiple_data_objects.c |
test_archive_set_error | DEFINE_TEST(test_archive_set_error)
{
struct archive* a = archive_read_new();
/* unlike printf("%s", NULL),
* archive_set_error(a, code, "%s", NULL)
* segfaults, so it's not tested here */
test(a, 12, "abcdefgh");
test(a, 0, "123456");
test(a, -1, "tuvw");
test(a, 34, "XYZ");
archive_read_free(a);
} | pushq %rbx
callq 0x12777c
movq %rax, %rbx
leaq 0x16dfb7(%rip), %rdx # 0x19a232
movq %rax, %rdi
movl $0xc, %esi
callq 0x2c2ca
leaq 0x17a647(%rip), %rdx # 0x1a68d6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c2ca
leaq 0x174946(%rip), %rdx # 0x1a0be6
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
ca... | /mmatuska[P]libarchive/libarchive/test/test_archive_set_error.c |
test_archive_string_conversion_utf8_utf16 | DEFINE_TEST(test_archive_string_conversion_utf8_utf16)
{
#if !defined(_WIN32) || defined(__CYGWIN__)
skipping("This test is meant to verify unicode string handling on Windows");
#else
struct archive_mstring mstr;
const wchar_t* wcs_string;
memset(&mstr, 0, sizeof(mstr));
assertEqualInt(6,
archive_mstring_co... | pushq %rax
leaq 0x170758(%rip), %rdi # 0x1a13b2
movl $0x38f, %esi # imm = 0x38F
callq 0x15722
leaq 0x17083c(%rip), %rdi # 0x1a14a7
xorl %eax, %eax
popq %rcx
jmp 0x15730
| /mmatuska[P]libarchive/libarchive/test/test_archive_string_conversion.c |
check_string | static void
check_string(struct archive *a, struct archive_mstring *mstr, struct archive_string_conv *sc,
const char *exp, const wchar_t *wexp)
{
/* Do all the tests on a copy so that we can have a clear initial state every time */
struct archive_mstring mstr2;
const char *p = NULL;
const wchar_t *wp = NULL;
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, %rbp
xorl %r12d, %r12d
leaq 0x18(%rsp), %rbx
movq %r12, (%rbx)
leaq 0x48(%rsp), %rax
movq %r12, (%rax)
leaq 0x40(%rsp), %rax
movq %r12, (%rax)
xorps %xmm0, %xmm0... | /mmatuska[P]libarchive/libarchive/test/test_archive_string_conversion.c |
test_compat_gtar | static void
test_compat_gtar_1(void)
{
char name[] = "test_compat_gtar_1.tar";
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
ex... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps 0x16e8d0(%rip), %xmm0 # 0x1a3940
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movabsq $0x7261742e315f72, %rax # imm = 0x7261742E315F72
movq %rax, 0xf(%r15)
callq 0x12777c
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
... | /mmatuska[P]libarchive/libarchive/test/test_compat_gtar.c |
test_compat_solaris_tar_acl | DEFINE_TEST(test_compat_solaris_tar_acl)
{
char name[] = "test_compat_solaris_tar_acl.tar";
struct archive *a;
struct archive_entry *ae;
/* Read archive file */
assert(NULL != (a = archive_read_new()));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps 0x16b443(%rip), %xmm0 # 0x1a54b0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps 0x16b422(%rip), %xmm0 # 0x1a54a0
movaps %xmm0, (%r15)
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x16b4... | /mmatuska[P]libarchive/libarchive/test/test_compat_solaris_tar_acl.c |
test_compat_star_acl_posix1e | DEFINE_TEST(test_compat_star_acl_posix1e)
{
char name[] = "test_compat_star_acl_posix1e.tar";
struct archive *a;
struct archive_entry *ae;
/* Read archive file */
assert(NULL != (a = archive_read_new()));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps 0x16b13e(%rip), %xmm0 # 0x1a5620
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movaps 0x16b11c(%rip), %xmm0 # 0x1a5610
movaps %xmm0, (%r12)
movb $0x0, 0x20(%r12)
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax... | /mmatuska[P]libarchive/libarchive/test/test_compat_star_acl.c |
test_read_filter_lrzip | DEFINE_TEST(test_read_filter_lrzip)
{
const char *name = "test_read_filter_lrzip.tar.lrz";
/* lrzip tracks directories as files, ensure that we list everything */
const char *n[] = {
"d1/", "d1/f1", "d1/f2", "d1/f3", "f1", "f2", "f3", NULL };
struct archive_entry *ae;
struct archive *a;
int i;
if (!canLrzip()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x17b09
testl %eax, %eax
je 0x575d6
callq 0x12777c
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x153d81(%rip), %r14 # 0x1ab0b9
leaq 0x147d22(%rip), %rcx # 0x19f061
movq %r14, %rdi
movl $0x2a, %esi
xorl %r8... | /mmatuska[P]libarchive/libarchive/test/test_read_filter_lrzip.c |
test_read_filter_uudecode_raw | DEFINE_TEST(test_read_filter_uudecode_raw)
{
struct archive_entry *ae;
struct archive *a;
const char *name = "test_read_filter_uudecode_raw.uu";
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x1531a5(%rip), %rbx # 0x1abcb0
leaq 0x14654f(%rip), %rcx # 0x19f061
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x22, %esi
xorl %r8d, %r8d
callq 0x15960
movq... | /mmatuska[P]libarchive/libarchive/test/test_read_filter_uudecode_raw.c |
test_read_format_cab | DEFINE_TEST(test_read_format_cab)
{
/* Verify Cabinet file in no compression. */
verify("test_read_format_cab_1.cab", STORE);
verify2("test_read_format_cab_1.cab", STORE);
verify3("test_read_format_cab_1.cab", STORE);
/* Verify Cabinet file in MSZIP. */
verify("test_read_format_cab_2.cab", MSZIP);
verify2("test_... | pushq %rbx
leaq 0x14b516(%rip), %rbx # 0x1ad33f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x61ea4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x62983
movq %rbx, %rdi
xorl %esi, %esi
callq 0x62f6e
leaq 0x14b50c(%rip), %rbx # 0x1ad35a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x61ea4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x62983... | /mmatuska[P]libarchive/libarchive/test/test_read_format_cab.c |
test_read_format_rar5_multiarchive_skip_all_but_first | DEFINE_TEST(test_read_format_rar5_multiarchive_skip_all_but_first)
{
const char* reffiles[] = {
"test_read_format_rar5_multiarchive.part01.rar",
"test_read_format_rar5_multiarchive.part02.rar",
"test_read_format_rar5_multiarchive.part03.rar",
"test_read_format_rar5_multiarchive.part04.rar",
"test_read_format... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x16a893(%rip), %rsi # 0x2050f0
leaq 0x10(%rsp), %r15
movl $0x9, %ecx
movq %r15, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
callq 0x18252
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x11a638(%rip), %rbx # ... | /mmatuska[P]libarchive/libarchive/test/test_read_format_rar5.c |
test_read_format_rar5_stored_skip_all | DEFINE_TEST(test_read_format_rar5_stored_skip_all)
{
const char* fname = "test_read_format_rar5_stored_manyfiles.rar";
PROLOGUE(fname);
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("make_uue.tcl", archive_entry_pathname(ae));
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x11a605(%rip), %r15 # 0x1b5743
movq %r15, %rdi
callq 0x17ead
callq 0x12777c
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x119d67(%rip), %r14 # 0x1b4ec4
leaq 0x103efd(%rip), %rcx # 0x19f061
xorl %ebp, %ebp
mov... | /mmatuska[P]libarchive/libarchive/test/test_read_format_rar5.c |
test_read_format_rar5_data_ready_pointer_leak | DEFINE_TEST(test_read_format_rar5_data_ready_pointer_leak)
{
/* oss fuzz 70024 */
char buf[4096];
PROLOGUE("test_read_format_rar5_data_ready_pointer_leak.rar");
/* Return codes of those calls are ignored, because this sample file
* is invalid. However, the unpacker shouldn't produce any SIGSEGV
* errors durin... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
leaq 0x1144f3(%rip), %r15 # 0x1b6b44
movq %r15, %rdi
callq 0x17ead
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x112854(%rip), %rbx # 0x1b4ec4
leaq 0xfc9ea(%rip), %rcx # 0x19f061
movq %rb... | /mmatuska[P]libarchive/libarchive/test/test_read_format_rar5.c |
test_read_format_zip_winzip_aes256_large | DEFINE_TEST(test_read_format_zip_winzip_aes256_large)
{
const char *refname = "test_read_format_zip_winzip_aes256_large.zip";
struct archive_entry *ae;
struct archive *a;
char buff[512];
/* Check if running system has cryptographic functionality. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x1629f7
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xfbfe1(%rip), %r14 # 0x1ba137
leaq 0xe44a7(%rip), %rcx # 0x1a2604
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x25, %esi
xorl %r8... | /mmatuska[P]libarchive/libarchive/test/test_read_format_zip_winzip_aes_large.c |
verify_file0_seek | static void
verify_file0_seek(struct archive *a)
{
struct archive_entry *ae;
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("-", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG | 0660, archive_entry_mode(ae));
assertEqualInt(6, archive_entry_size(ae));
#ifdef HAVE_ZLIB_H
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x1629d9
movslq %eax, %r8
movq %rbx, (%rsp)
leaq 0xfaad9(%rip), %r15 # 0x1ba1f8
leaq 0xf6bf6(%rip), %rcx # 0x1b631c
leaq 0xe42eb(%rip), %r9 # 0x1a3a18
xorl %r14d, %... | /mmatuska[P]libarchive/libarchive/test/test_read_format_zip_zip64.c |
test_read_pax_xattr_rht_security_selinux | DEFINE_TEST(test_read_pax_xattr_rht_security_selinux)
{
struct archive *a;
struct archive_entry *ae;
const char *refname = "test_read_pax_xattr_rht_security_selinux.tar";
const char *xname; /* For xattr tests. */
const void *xval; /* For xattr tests. */
size_t xsize; /* For xattr tests. */
const char *string;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0x12777c
movq %rax, %r14
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xfa17b(%rip), %rbx # 0x1ba5f9
leaq 0xdebdc(%rip), %rcx # 0x19f061
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x29, %esi
xorl %r8d, %r8d
callq 0x15960
mo... | /mmatuska[P]libarchive/libarchive/test/test_read_pax_xattr_rht_security_selinux.c |
test_read_pax_truncated | DEFINE_TEST(test_read_pax_truncated)
{
struct archive_entry *ae;
struct archive *a;
size_t used, i, buff_size = 1000000;
size_t filedata_size = 100000;
char *buff = malloc(buff_size);
char *buff2 = malloc(buff_size);
char *filedata = malloc(filedata_size);
/* Create a new archive in memory. */
assert((a = arc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %r15
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, 0x30(%rsp)
movl $0x186a0, %edi # imm = 0x186A0
callq 0x14cd0
movq %rax, %rbp
callq ... | /mmatuska[P]libarchive/libarchive/test/test_read_pax_truncated.c |
test_read_position | DEFINE_TEST(test_read_position)
{
struct archive *a;
struct archive_entry *ae;
size_t write_pos;
size_t i;
/* Sanity test */
assert(sizeof(nulls) + 512 + 1024 <= sizeof(buff));
/* Create an archive. */
assert(NULL != (a = archive_write_new()));
assertA(0 == archive_write_set_format_pax_restricted(a));
asser... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xf8e1c(%rip), %r14 # 0x1ba9c6
leaq 0xf8e89(%rip), %rcx # 0x1baa3a
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x4b, %esi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x15960
callq 0x1629f7
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %ra... | /mmatuska[P]libarchive/libarchive/test/test_read_position.c |
test_read_set_format | DEFINE_TEST(test_read_set_format)
{
char buff[64];
const char reffile[] = "test_read_format_rar.rar";
const char test_txt[] = "test text document\r\n";
int size = sizeof(test_txt)-1;
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movups 0xf20f1(%rip), %xmm0 # 0x1b4259
leaq 0x40(%rsp), %r15
movups %xmm0, 0x9(%r15)
movaps 0xf20d7(%rip), %xmm0 # 0x1b4250
movaps %xmm0, (%r15)
movaps 0xdda3c(%rip), %xmm0 # 0x19fbc0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
m... | /mmatuska[P]libarchive/libarchive/test/test_read_set_format.c |
test_short_writes | DEFINE_TEST(test_short_writes)
{
struct checker *checker;
uint16_t test_data[16384];
int i;
for (i = 0; i < 16384; i++)
test_data[i] = i;
/* Write a file smaller than the default buffer size (10 * 1024);
* this will be written out at close.
*/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8000, %rsp # imm = 0x8000
xorl %eax, %eax
movw %ax, (%rsp,%rax,2)
incq %rax
cmpq $0x4000, %rax # imm = 0x4000
jne 0xc42f9
movl $0x1, %edi
callq 0xc442b
movq %rax, %r12
movq %rsp, %rbx
movl $0x400, %edx # imm = 0x400
movq %rax,... | /mmatuska[P]libarchive/libarchive/test/test_short_writes.c |
test_sparse_basic | static void
test_sparse_whole_file_data(void)
{
struct archive_entry *ae;
int64_t offset;
int i;
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_size(ae, 1024*10);
/*
* Add sparse block data up to the file size.
*/
offset = 0;
for (i = 0; i < 10; i++) {
archive_entry_sparse_add_entry(ae, o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x12153c
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xf6f97(%rip), %rdi # 0x1bb8f1
leaq 0xd4177(%rip), %rcx # 0x198ad8
xorl %r14d, %r14d
movl $0x1e7, %esi # imm = 0x1E7
xorl %r8d, %r8d
callq 0x1596... | /mmatuska[P]libarchive/libarchive/test/test_sparse_basic.c |
test_write_disk_lookup | DEFINE_TEST(test_write_disk_lookup)
{
struct archive *a;
int gmagic = 0x13579, umagic = 0x1234;
int64_t id;
assert((a = archive_write_disk_new()) != NULL);
/* Default uname/gname lookups always return ID. */
assertEqualInt(0, archive_write_disk_gid(a, "", 0));
assertEqualInt(12, archive_write_disk_gid(a, "root... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rax
movl $0x13579, (%rax) # imm = 0x13579
leaq 0x10(%rsp), %rax
movl $0x1234, (%rax) # imm = 0x1234
callq 0x1639ad
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xf2a56(%rip), %r15 #... | /mmatuska[P]libarchive/libarchive/test/test_write_disk_lookup.c |
searchgid | static void
searchgid(void)
{
static int _searched = 0;
uid_t uid = getuid();
gid_t gid = 0;
unsigned int n;
struct stat st;
int fd;
/* If we've already looked this up, we're done. */
if (_searched)
return;
_searched = 1;
/* Create a file on disk in the current default dir. */
fd = open("test_gid", O_C... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
callq 0x144b0
cmpb $0x0, 0x3f0ee2e(%rip) # 0x3fdad60
je 0xcbf42
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
movb $0x1, 0x3f0ee15(%rip) # 0x3fdad60
leaq 0xf15ec(%rip), %rdi # 0x1bd53e
movl $0x40, %esi
movl $0x1b4, %edx... | /mmatuska[P]libarchive/libarchive/test/test_write_disk_perms.c |
test_format | static void
test_format(int (*set_format)(struct archive *))
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
char *p;
size_t used;
size_t buffsize = 1000000;
char *buff;
int damaged = 0;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NUL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %r12
movq %rax, 0x20(%rsp)
callq 0x1629f7
movq %rax, %r15
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xdc5db(%rip), %r14 # 0x1c12cb
leaq 0xbd9... | /mmatuska[P]libarchive/libarchive/test/test_write_format_cpio.c |
test_write_format_gnutar | DEFINE_TEST(test_write_format_gnutar)
{
size_t buffsize = 1000000;
char *buff;
struct archive_entry *ae;
struct archive *a;
size_t used;
buff = malloc(buffsize); /* million bytes of work area */
assert(buff != NULL);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
movq %rax, 0x20(%rsp)
setne %dl
leaq 0xd9318(%rip), %r14 # 0x1c1c8a
leaq 0xd55e2(%rip), %rcx # 0x1bdf5b
movq %r14, %rdi
m... | /mmatuska[P]libarchive/libarchive/test/test_write_format_gnutar.c |
add_entry | static void
add_entry(struct archive *a, const char *fname, const char *sym)
{
struct archive_entry *ae;
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_birthtime(ae, 2, 20);
archive_entry_set_atime(ae, 3, 30);
archive_entry_set_ctime(ae, 4, 40);
archive_entry_set_mtime(ae, 5, 50);
archive_entry_c... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x12153c
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xcfa88(%rip), %rdi # 0x1c3c48
leaq 0xa4911(%rip), %rcx # 0x198ad8
movl $0x23, %esi
xorl %r8d, %r8d
callq 0x15960
movl $0x2, %esi
... | /mmatuska[P]libarchive/libarchive/test/test_write_format_iso9660_filename.c |
test_write_format_tar_ustar | DEFINE_TEST(test_write_format_tar_ustar)
{
struct archive *a;
struct archive_entry *entry;
char *buff, *e;
size_t buffsize = 100000;
size_t used;
int i;
char f99[100];
char f100[101];
char f256[257];
for (i = 0; i < 99; ++i)
f99[i] = 'a' + i % 26;
f99[99] = '\0';
for (i = 0; i < 100; ++i)
f100[i] = 'A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movb $0x61, %al
xorl %ecx, %ecx
xorl %edx, %edx
movl %ecx, %esi
imulq $0x4ec4ec4f, %rsi, %rsi # imm = 0x4EC4EC4F
shrq $0x23, %rsi
leal (%rsi,%rsi,4), %edi
leal (%rdi,%rdi,4), %edi
addl %esi, %edi
movl %eax, %esi... | /mmatuska[P]libarchive/libarchive/test/test_write_format_tar_ustar.c |
test_xar | static void
test_xar(const char *option)
{
char buff2[64];
size_t buffsize = 1500;
char *buff;
struct archive_entry *ae;
struct archive *a;
size_t used;
const char *name;
const void *value;
size_t size;
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
if (archive_write_set_f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
callq 0x1629f7
movq %rax, %rbx
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xc200e(%rip), %rdi # 0x1c6830
leaq 0x9dddb(%rip), %rcx # 0x1a2604
movl $0x2c, %esi
xorl %r8d, %r8d
callq 0x15960
movq %rbx, %rdi
call... | /mmatuska[P]libarchive/libarchive/test/test_write_format_xar.c |
test_write_format_zip64_stream | DEFINE_TEST(test_write_format_zip64_stream)
{
struct archive *a;
struct archive_entry *ae;
size_t used, buffsize = 1000000;
unsigned long crc;
unsigned long compressed_size = 0;
int file_perm = 00644;
int zip_version = 45;
int zip_compression = 8;
short file_uid = 10, file_gid = 20;
unsigned char *buff, *buff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movabsq $0x3837363534333231, %rax # imm = 0x3837363534333231
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %rbx
callq 0x1629f7
movq %rax, %r15
xorl %edx, %edx
testq %rax, %r... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip64_stream.c |
test_write_format_zip_empty | DEFINE_TEST(test_write_format_zip_empty)
{
struct archive *a;
struct archive_entry *ae;
char buff[256];
size_t used;
/* Zip format: Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
callq 0x1629f7
movq %rax, %r15
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xb43b9(%rip), %rbx # 0x1c8052
leaq 0x8e964(%rip), %rcx # 0x1a2604
movq %rbx, %rdi
movl $0x28, %esi
xorl %r8d, %r8d
callq 0x... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip_empty.c |
test_write_format_zip_empty_zip64 | DEFINE_TEST(test_write_format_zip_empty_zip64)
{
struct archive *a;
struct archive_entry *ae;
char buff[256];
size_t used;
/* Zip format: Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
callq 0x1629f7
movq %rax, %r15
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xb405e(%rip), %rbx # 0x1c8185
leaq 0x8e4d6(%rip), %rcx # 0x1a2604
movq %rbx, %rdi
movl $0x28, %esi
xorl %r8d, %r8d
callq 0x... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip_empty_zip64.c |
write_archive | static void write_archive(struct archive *a)
{
struct archive_entry *entry = archive_entry_new();
assert(entry != NULL);
/* Does not set size for file entry */
archive_entry_set_pathname(entry, file_name);
archive_entry_set_mode(entry, S_IFREG | 0644);
archive_entry_set_uid(entry, file_uid);
archive_entry_set_g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x12153c
movq %rax, %r13
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xb3a42(%rip), %r14 # 0x1c8423
leaq 0x96076(%rip), %rcx # 0x1aaa5e
movq %r14, %rdi
movl $0x30, %esi
xorl %r8d, %r8d
callq 0x15960
leaq 0xb43b0(%r... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip_entry_size_unset.c |
test_write_format_zip_file | DEFINE_TEST(test_write_format_zip_file)
{
struct archive *a;
struct archive_entry *ae;
time_t t = 1234567890;
struct tm *tm;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE_LOCALTIME_S)
struct tm tmbuf;
#endif
size_t used, buffsize = 1000000;
unsigned long crc;
int file_perm = 00644;
int zip_version = 20;
int z... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x28(%rsp), %rdi
movq $0x499602d2, (%rdi) # imm = 0x499602D2
movabsq $0x3837363534333231, %rax # imm = 0x3837363534333231
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x70(%rsp), %rsi
callq 0x141e0
movq %rax, 0x20(%rsp)
movl $0x... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip_file.c |
test_write_format_zip_file_zip64 | DEFINE_TEST(test_write_format_zip_file_zip64)
{
struct archive *a;
struct archive_entry *ae;
time_t t = 1234567890;
struct tm *tm;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE_LOCALTIME_S)
struct tm tmbuf;
#endif
size_t used, buffsize = 1000000;
unsigned long crc;
int file_perm = 00644;
int zip_version = 45;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x28(%rsp), %rdi
movq $0x499602d2, (%rdi) # imm = 0x499602D2
movabsq $0x3837363534333231, %rax # imm = 0x3837363534333231
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x70(%rsp), %rsi
callq 0x141e0
movq %rax, 0x18(%rsp)
movl $0x... | /mmatuska[P]libarchive/libarchive/test/test_write_format_zip_file_zip64.c |
verify_contents | static void
verify_contents(struct archive *a, int seeking, int improved_streaming)
{
char filedata[64];
struct archive_entry *ae;
/*
* Default compression options:
*/
/* Read and verify first file. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, %rsi
callq 0x1629d9
movslq %eax, %r8
movq %r14, 0x28(%rsp)
movq %r14, (%rsp)
leaq 0xad92a(%rip), %r15 # 0x1c9856
leaq 0x9a3e9(%rip), %rcx # 0x1b631c... | /mmatuska[P]libarchive/libarchive/test/test_write_read_format_zip.c |
test_write_read_format_zip_improved_streaming | DEFINE_TEST(test_write_read_format_zip_improved_streaming)
{
struct archive *a;
size_t used;
size_t buffsize = 1000000;
char *buff;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
assert... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %rbx
callq 0x1629f7
movq %rax, %r13
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xab511(%rip), %r14 # 0x1c9856
leaq 0x842b8(%rip), %rcx # 0x1a2604
movq %r1... | /mmatuska[P]libarchive/libarchive/test/test_write_read_format_zip.c |
test_write_read_format_zip64_improved_streaming | DEFINE_TEST(test_write_read_format_zip64_improved_streaming)
{
struct archive *a;
size_t used;
size_t buffsize = 1000000;
char *buff;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
asse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xf4240, %edi # imm = 0xF4240
callq 0x14cd0
movq %rax, %rbx
callq 0x1629f7
movq %rax, %r13
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0xaae54(%rip), %r14 # 0x1c9856
leaq 0x83bfb(%rip), %rcx # 0x1a2604
movq %r1... | /mmatuska[P]libarchive/libarchive/test/test_write_read_format_zip.c |
test_zip_filename_encoding_UTF8 | DEFINE_TEST(test_zip_filename_encoding_UTF8)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
skipping("en_US.UTF-8 locale not available on this system.");
return;
}
/*
* Verify that UTF-8 filenames are correctly stored wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
leaq 0x8234d(%rip), %rsi # 0x1a1539
movl $0x6, %edi
callq 0x14a70
testq %rax, %rax
je 0x11f286
callq 0x1629f7
movq %rax, %r15
movq %rax, %rdi
callq 0x184eb1
movslq %eax, %r8
movq $0x0, (%rsp)
leaq 0xaa825(%... | /mmatuska[P]libarchive/libarchive/test/test_zip_filename_encoding.c |
test_zip_filename_encoding_CP932 | DEFINE_TEST(test_zip_filename_encoding_CP932)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
skipping("CP932/SJIS locale not available on this system.");
return;
}
/*
* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
leaq 0x87f5f(%rip), %rsi # 0x1a8610
movl $0x6, %edi
callq 0x14a70
testq %rax, %rax
jne 0x1206da
leaq 0x87f58(%rip), %rsi # 0x1a861f
movl $0x6, %edi
callq 0x14a70
testq %rax, %rax
je 0x120a68
callq 0x162... | /mmatuska[P]libarchive/libarchive/test/test_zip_filename_encoding.c |
_archive_cmdline_parse | int
__archive_cmdline_parse(struct archive_cmdline *data, const char *cmd)
{
struct archive_string as;
const char *p;
ssize_t al;
int r;
archive_string_init(&as);
/* Get first argument as a command path. */
al = get_argument(&as, cmd);
if (al < 0) {
r = ARCHIVE_FAILED;/* Invalid sequence. */
goto exit_fun... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x120d13
testq %rax, %rax
js 0x120cf5
cmpq $0x0, 0x8(%rsp)
je 0x120cf5
movq %rax, %r15
movq (%rsp), %r12
movq (%r14), %r1... | /mmatuska[P]libarchive/libarchive/archive_cmdline.c |
cmdline_add_arg | static int
cmdline_add_arg(struct archive_cmdline *data, const char *arg)
{
char **newargv;
if (data->path == NULL)
return (ARCHIVE_FAILED);
newargv = realloc(data->argv, (data->argc + 2) * sizeof(char *));
if (newargv == NULL)
return (ARCHIVE_FATAL);
data->argv = newargv;
data->argv[data->argc] = strdup(ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x120e60
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movslq 0x10(%rbx), %rax
leaq 0x10(,%rax,8), %rsi
callq 0x140e0
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testq %rax, %rax
je 0x120e65
movq %rax, %r14
movq %rax, 0x8(%rbx)
movq ... | /mmatuska[P]libarchive/libarchive/archive_cmdline.c |
_archive_md5final | static int
__archive_md5final(archive_md5_ctx *ctx, void *md)
{
/* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
* this is meant to cope with that. Real fix is probably to fix
* archive_write_set_format_xar.c
*/
if (*ctx) {
EVP_DigestFinal(*ctx, md, NULL);
EVP_MD_CTX_free(*c... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x120f4f
xorl %edx, %edx
callq 0x14110
movq (%rbx), %rdi
callq 0x146c0
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
| /mmatuska[P]libarchive/libarchive/archive_digest.c |
archive_entry_clone | struct archive_entry *
archive_entry_clone(struct archive_entry *entry)
{
struct archive_entry *entry2;
struct ae_xattr *xp;
struct ae_sparse *sp;
size_t s;
const void *p;
/* Allocate new structure and copy over all of the fields. */
/* TODO: Should we copy the archive over? Or require a new archive
* as an ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r15
movl $0x1, %edi
movl $0x498, %esi # imm = 0x498
callq 0x14be0
testq %rax, %rax
je 0x1212e1
movq %rax, %rbx
movq %r15, (%rax)
movl $0x0, 0x494(%rax)
jmp 0x1212e3
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1214e2
leaq 0x18(%rbx), %rdi
leaq 0x18(%r14... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_fflags_text | const char *
archive_entry_fflags_text(struct archive_entry *entry)
{
const char *f;
char *p;
if (archive_mstring_get_mbs(entry->archive,
&entry->ae_fflags_text, &f) == 0) {
if (f != NULL)
return (f);
} else if (errno == ENOMEM)
__archive_errx(1, "No memory");
if (entry->ae_fflags_set == 0 && entry... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xc8(%r14), %rbx
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x15e766
testl %eax, %eax
je 0x121775
callq 0x14de0
cmpl $0xc, (%rax)
je 0x1217db
movq 0x130(%r14), %r12
testq %r12, %r12
jne 0x121692
cmpq $0x... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_gname_utf8 | const char *
archive_entry_gname_utf8(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_utf8(entry->archive, &entry->ae_gname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x140(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e69c
testl %eax, %eax
je 0x121864
callq 0x14de0
cmpl $0xc, (%rax)
je 0x12186a
xorl %eax, %eax
jmp 0x121868
movq (%rsp), %rax
popq %rcx
retq
leaq 0x7711f(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_gname_w | const wchar_t *
archive_entry_gname_w(struct archive_entry *entry)
{
const wchar_t *p;
if (archive_mstring_get_wcs(entry->archive, &entry->ae_gname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x140(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e848
testl %eax, %eax
je 0x1218a3
callq 0x14de0
cmpl $0xc, (%rax)
je 0x1218a9
xorl %eax, %eax
jmp 0x1218a7
movq (%rsp), %rax
popq %rcx
retq
leaq 0x770e0(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_pathname_utf8 | const char *
archive_entry_pathname_utf8(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_utf8(
entry->archive, &entry->ae_pathname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x210(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e69c
testl %eax, %eax
je 0x121acf
callq 0x14de0
cmpl $0xc, (%rax)
je 0x121ad5
xorl %eax, %eax
jmp 0x121ad3
movq (%rsp), %rax
popq %rcx
retq
leaq 0x76eb4(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_sourcepath | const char *
archive_entry_sourcepath(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_mbs(
entry->archive, &entry->ae_sourcepath, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x2e0(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e766
testl %eax, %eax
je 0x121c2d
callq 0x14de0
cmpl $0xc, (%rax)
je 0x121c33
xorl %eax, %eax
jmp 0x121c31
movq (%rsp), %rax
popq %rcx
retq
leaq 0x76d56(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_uname | const char *
archive_entry_uname(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_mbs(entry->archive, &entry->ae_uname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x278(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e766
testl %eax, %eax
je 0x121da6
callq 0x14de0
cmpl $0xc, (%rax)
je 0x121dac
xorl %eax, %eax
jmp 0x121daa
movq (%rsp), %rax
popq %rcx
retq
leaq 0x76bdd(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_uname_w | const wchar_t *
archive_entry_uname_w(struct archive_entry *entry)
{
const wchar_t *p;
if (archive_mstring_get_wcs(entry->archive, &entry->ae_uname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x278(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x15e848
testl %eax, %eax
je 0x121e24
callq 0x14de0
cmpl $0xc, (%rax)
je 0x121e2a
xorl %eax, %eax
jmp 0x121e28
movq (%rsp), %rax
popq %rcx
retq
leaq 0x76b5f(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_copy_fflags_text_w | const wchar_t *
archive_entry_copy_fflags_text_w(struct archive_entry *entry,
const wchar_t *flags)
{
archive_mstring_copy_wcs(&entry->ae_fflags_text, flags);
return (ae_wcstofflags(flags,
&entry->ae_fflags_set, &entry->ae_fflags_clear));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
addq $0xc8, %rdi
callq 0x15e9eb
movl (%r14), %eax
cmpl $0x1f, %eax
jle 0x122144
cmpl $0x20, %eax
je 0x122149
cmpl $0x2c, %eax
je 0x122149
jmp 0x12216c
cmpl $0x9, %eax
jne 0x12214f
addq $0x4, %r14
jmp... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_update_hardlink_utf8 | int
archive_entry_update_hardlink_utf8(struct archive_entry *entry, const char *target)
{
if (target == NULL && (entry->ae_set & AE_SET_SYMLINK))
return (0);
if (target != NULL)
entry->ae_set |= AE_SET_HARDLINK;
else
entry->ae_set &= ~AE_SET_HARDLINK;
if (archive_mstring_update_utf8(entry->archive,
&entr... | pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
testq %rdx, %rdx
je 0x122530
orb $0x1, 0xc0(%rsi)
movq (%rsi), %rdi
addq $0x1a8, %rsi # imm = 0x1A8
callq 0x15eb16
testl %eax, %eax
je 0x12254e
callq 0x14de0
cmpl $0xc, (%rax)
jne 0x12254a
leaq 0x7646a(%rip), %rsi # 0x198990
movl $0x1, %edi
callq 0x1624c0
movl 0... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_set_rdev | void
archive_entry_set_rdev(struct archive_entry *entry, __LA_DEV_T m)
{
entry->stat_valid = 0;
entry->ae_stat.aest_rdev = m;
entry->ae_stat.aest_rdev_is_broken_down = 0;
entry->ae_stat.aest_rdevmajor = 0;
entry->ae_stat.aest_rdevminor = 0;
entry->ae_set |= AE_SET_RDEV;
} | xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rsi, 0xa8(%rdi)
movl %eax, 0xa0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rdi)
orb $0x20, 0xc1(%rdi)
retq
| /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_set_symlink_utf8 | void
archive_entry_set_symlink_utf8(struct archive_entry *entry, const char *linkname)
{
if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
return;
archive_mstring_copy_utf8(&entry->ae_linkname, linkname);
entry->ae_set &= ~AE_SET_HARDLINK;
if (linkname == NULL)
entry->ae_set &= ~AE_SET_SYMLINK;
else
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x122a42
testb $0x1, 0xc0(%rbx)
jne 0x122a69
leaq 0x1a8(%rbx), %rdi
movq %r14, %rsi
callq 0x15ea7b
movl 0xc0(%rbx), %eax
andl $-0x4, %eax
leal 0x2(%rax), %ecx
testq %r14, %r14
cmovel %eax, %ecx
movl %ecx, 0xc0(%rbx)
addq $0x8, %rsp
po... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_update_symlink_utf8 | int
archive_entry_update_symlink_utf8(struct archive_entry *entry, const char *linkname)
{
if (linkname == NULL && (entry->ae_set & AE_SET_HARDLINK))
return (0);
entry->ae_set &= ~AE_SET_HARDLINK;
if (linkname == NULL)
entry->ae_set &= ~AE_SET_SYMLINK;
else
entry->ae_set |= AE_SET_SYMLINK;
if (archive_mstrin... | pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
testq %rdx, %rdx
jne 0x122b14
testb $0x1, 0xc0(%rsi)
jne 0x122b49
movl 0xc0(%rsi), %eax
andl $-0x4, %eax
leal 0x2(%rax), %ecx
testq %rdx, %rdx
cmovel %eax, %ecx
movl %ecx, 0xc0(%rsi)
movq (%rsi), %rdi
addq $0x1a8, %rsi # imm = 0x1A8
callq 0x15eb16
testl %eax, %eax
j... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_set_digest | int
archive_entry_set_digest(struct archive_entry *entry, int type,
const unsigned char *digest)
{
#define copy_digest(_e, _t, _d)\
memcpy(_e->digest._t, _d, sizeof(_e->digest._t))
switch (type) {
case ARCHIVE_ENTRY_DIGEST_MD5:
copy_digest(entry, md5, digest);
break;
case ARCHIVE_ENTRY_DIGEST_RMD160:
cop... | decl %esi
cmpl $0x5, %esi
ja 0x122d86
leaq 0xa6ebf(%rip), %rax # 0x1c9b9c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movups (%rdx), %xmm0
movups %xmm0, 0x360(%rdi)
jmp 0x122d83
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x3d8(%rdi)
movups %xmm1, 0x3c8(%rdi)
movup... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_acl_next | int
archive_entry_acl_next(struct archive_entry *entry, int want_type, int *type,
int *permset, int *tag, int *id, const char **name)
{
int r;
r = archive_acl_next(entry->archive, &entry->acl, want_type, type,
permset, tag, id, name);
if (r == ARCHIVE_FATAL && errno == ENOMEM)
__archive_errx(1, "No memory");... | pushq %rbx
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %edx
movq (%rdi), %r10
leaq 0x428(%rdi), %rsi
movq %r10, %rdi
pushq 0x10(%rsp)
pushq %rax
callq 0x18aa9e
addq $0x10, %rsp
movl %eax, %ebx
cmpl $-0x1e, %eax
jne 0x122e0b
callq 0x14de0
cmpl $0xc, (%rax)
je 0x122e0f
movl %ebx, %eax
popq %rbx... | /mmatuska[P]libarchive/libarchive/archive_entry.c |
archive_entry_linkify | void
archive_entry_linkify(struct archive_entry_linkresolver *res,
struct archive_entry **e, struct archive_entry **f)
{
struct links_entry *le;
struct archive_entry *t;
*f = NULL; /* Default: Don't return a second entry. */
if (*e == NULL) {
le = next_entry(res, NEXT_ENTRY_DEFERRED);
if (le != NULL) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rdx)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x123131
movq %rdx, %r15
callq 0x121a31
cmpl $0x1, %eax
je 0x123152
movq (%rbx), %rdi
callq 0x12161b
cmpl $0x4000, %eax # imm = 0x4000
je 0x123152
movq (%rbx), %rdi
ca... | /mmatuska[P]libarchive/libarchive/archive_entry_link_resolver.c |
find_entry | static struct links_entry *
find_entry(struct archive_entry_linkresolver *res,
struct archive_entry *entry)
{
struct links_entry *le;
size_t hash, bucket;
dev_t dev;
int64_t ino;
/* Free a held entry. */
if (res->spare != NULL) {
archive_entry_free(res->spare->canonical);
archive_entry_free(res-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x123278
movq 0x10(%rax), %rdi
callq 0x12152a
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x12152a
movq 0x8(%rbx), %rdi
callq 0x14220
movq $0x0, 0x8(%rbx)
movq %r14,... | /mmatuska[P]libarchive/libarchive/archive_entry_link_resolver.c |
archive_entry_sparse_count | int
archive_entry_sparse_count(struct archive_entry *entry)
{
struct ae_sparse *sp;
int count = 0;
for (sp = entry->sparse_head; sp != NULL; sp = sp->next)
count++;
/*
* Sanity check if this entry is exactly sparse.
* If amount of sparse blocks is just one and it indicates the whole
* file data, we should... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x470(%rdi), %r14
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %r14, %rax
movq (%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x123581
cmpl $0x1, %ebp
jne 0x1235d8
movq (%r14), %rax
movl $0x1, %ebp
cmpq $0x0, 0x8(%rax)
jne 0x1235d8
movq 0x... | /mmatuska[P]libarchive/libarchive/archive_entry_sparse.c |
archive_entry_sparse_next | int
archive_entry_sparse_next(struct archive_entry * entry,
la_int64_t *offset, la_int64_t *length)
{
if (entry->sparse_p) {
*offset = entry->sparse_p->offset;
*length = entry->sparse_p->length;
entry->sparse_p = entry->sparse_p->next;
return (ARCHIVE_OK);
} else {
*offset = 0;
*length = 0;
return (A... | movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x12361f
movq 0x8(%rax), %rcx
movq %rcx, (%rsi)
movq 0x10(%rax), %rcx
movq %rcx, (%rdx)
movq (%rax), %rax
movq %rax, 0x480(%rdi)
xorl %eax, %eax
retq
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdx)
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
retq
| /mmatuska[P]libarchive/libarchive/archive_entry_sparse.c |
_archive_get_date | time_t
__archive_get_date(time_t now, const char *p)
{
struct token tokens[256];
struct gdstate _gds;
struct token *lasttoken;
struct gdstate *gds;
struct tm local, *tm;
struct tm gmt, *gmt_ptr;
time_t Start;
time_t tod;
long tzone;
/* Clear out the parsed token array. */
memset(tokens, 0, sizeof(tokens)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1158, %rsp # imm = 0x1158
movq %rsi, %r14
leaq 0x68(%rsp), %r15
movq %rdi, (%r15)
leaq 0x150(%rsp), %rdi
movl $0x1000, %edx # imm = 0x1000
xorl %esi, %esi
callq 0x14460
leaq 0x90(%rsp), %rsi
movq %r15, %rdi
callq 0x141e0
testq... | /mmatuska[P]libarchive/libarchive/archive_getdate.c |
RelativeDate | static time_t
RelativeDate(time_t Start, time_t zone, int dstmode,
time_t DayOrdinal, time_t DayNumber)
{
struct tm *tm;
time_t t, now;
#if defined(HAVE_GMTIME_R) || defined(HAVE_GMTIME_S)
struct tm tmbuf;
#endif
t = Start - zone;
#if defined(HAVE_GMTIME_S)
tm = gmtime_s(&tmbuf, &t) ? NULL : &tmbuf;
#elif def... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
movq %rdi, %rax
subq %rsi, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
callq 0x14ab0
movslq 0x18(%rax), %rax
subq %rax, %r15
leaq 0x7(%r15), %rax
movabsq $0x4924924924924925,... | /mmatuska[P]libarchive/libarchive/archive_getdate.c |
archive_match_new | struct archive *
archive_match_new(void)
{
struct archive_match *a;
a = calloc(1, sizeof(*a));
if (a == NULL)
return (NULL);
a->archive.magic = ARCHIVE_MATCH_MAGIC;
a->archive.state = ARCHIVE_STATE_NEW;
a->recursive_include = 1;
match_list_init(&(a->inclusions));
match_list_init(&(a->exclusions));
__archive... | pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x1f8, %esi # imm = 0x1F8
callq 0x14be0
xorl %r14d, %r14d
testq %rax, %rax
je 0x124bb4
movq %rax, %rbx
movabsq $0x10cad11c9, %rax # imm = 0x10CAD11C9
movq %rax, (%rbx)
movl $0x1, 0x94(%rbx)
leaq 0xc0(%rbx), %rax
movq %r14, 0xc0(%rbx)
movq %rax, 0xc8... | /mmatuska[P]libarchive/libarchive/archive_match.c |
match_list_free | static void
match_list_free(struct match_list *list)
{
struct match *p, *q;
for (p = list->first; p != NULL; ) {
q = p;
p = p->next;
archive_mstring_clean(&(q->pattern));
free(q);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x124c9d
movq (%rbx), %r14
leaq 0x10(%rbx), %rdi
callq 0x15e5eb
movq %rbx, %rdi
callq 0x14220
movq %r14, %rbx
testq %r14, %r14
jne 0x124c81
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmatuska[P]libarchive/libarchive/archive_match.c |
add_pattern_wcs | static int
add_pattern_wcs(struct archive_match *a, struct match_list *list,
const wchar_t *pattern)
{
struct match *match;
size_t len;
match = calloc(1, sizeof(*match));
if (match == NULL)
return (error_nomem(a));
/* Both "foo/" and "foo" should match "foo/bar". */
len = wcslen(pattern);
if (len && patte... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x78, %esi
callq 0x14be0
testq %rax, %rax
je 0x125442
movq %rax, %r12
movq %r15, %rdi
callq 0x148c0
xorl %r13d, %r13d
testq %rax, %rax
je 0x125467
xorl %ecx, %ecx
cmpl $0x2f, -0x4(%r15,%rax,4)
se... | /mmatuska[P]libarchive/libarchive/archive_match.c |
add_pattern_from_file | static int
add_pattern_from_file(struct archive_match *a, struct match_list *mlist,
int mbs, const void *pathname, int nullSeparator)
{
struct archive *ar;
struct archive_entry *ae;
struct archive_string as;
const void *buff;
size_t size;
int64_t offset;
int r;
ar = archive_read_new();
if (ar == NULL) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, 0x40(%rsp)
movq %rdi, %r12
callq 0x12777c
testq %rax, %rax
je 0x125556
movq %rax, %rbx
movq %rax, %rdi
callq 0x14fb5b
movl %eax, %r14d
testl %eax, %eax
jne 0x12553a
movq %rbx, %... | /mmatuska[P]libarchive/libarchive/archive_match.c |
archive_match_include_pattern | int
archive_match_include_pattern(struct archive *_a, const char *pattern)
{
struct archive_match *a;
int r;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_include_pattern");
a = (struct archive_match *)_a;
if (pattern == NULL || *pattern == '\0') {
archive_set_error(&(a->a... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa4a58(%rip), %rcx # 0x1ca24a
movl $0xcad11c9, %esi # imm = 0xCAD11C9
movl $0x1, %edx
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x12584c
testq %r14, %r14
je 0x125831
cmpb $0x0, (%r... | /mmatuska[P]libarchive/libarchive/archive_match.c |
archive_match_path_unmatched_inclusions_next | int
archive_match_path_unmatched_inclusions_next(struct archive *_a,
const char **_p)
{
struct archive_match *a;
const void *v;
int r;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_unmatched_inclusions_next");
a = (struct archive_match *)_a;
r = match_list_unmatched_inc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa491a(%rip), %rcx # 0x1ca33f
movl $0xcad11c9, %esi # imm = 0xCAD11C9
movl $0x1, %edx
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x125a62
leaq 0xc0(%r14), %rsi
leaq... | /mmatuska[P]libarchive/libarchive/archive_match.c |
archive_match_include_file_time | int
archive_match_include_file_time(struct archive *_a, int flag,
const char *pathname)
{
int r;
r = validate_time_flag(_a, flag, "archive_match_include_file_time");
if (r != ARCHIVE_OK)
return (r);
return set_timefilter_pathname_mbs((struct archive_match *)_a,
flag, pathname);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xa4459(%rip), %rdx # 0x1ca3e4
callq 0x125c75
testl %eax, %eax
je 0x125f99
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x125faa
| /mmatuska[P]libarchive/libarchive/archive_match.c |
archive_match_exclude_entry | int
archive_match_exclude_entry(struct archive *_a, int flag,
struct archive_entry *entry)
{
struct archive_match *a;
int r;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_time_include_entry");
a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa4275(%rip), %rcx # 0x1ca426
movl $0xcad11c9, %esi # imm = 0xCAD11C9
movl $0x1, %edx
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, ... | /mmatuska[P]libarchive/libarchive/archive_match.c |
add_owner_name | static int
add_owner_name(struct archive_match *a, struct match_list *list,
int mbs, const void *name)
{
struct match *match;
match = calloc(1, sizeof(*match));
if (match == NULL)
return (error_nomem(a));
if (mbs)
archive_mstring_copy_mbs(&(match->pattern), name);
else
archive_mstring_copy_wcs(&(match->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x78, %esi
callq 0x14be0
testq %rax, %rax
je 0x126623
movq %rax, %r15
movq %rax, %rdi
addq $0x10, %rdi
movq %r12, %rsi
testl %ebp, %ebp
je 0x126647
callq 0x15e961
jmp 0x12664c
lea... | /mmatuska[P]libarchive/libarchive/archive_match.c |
cmp_node_mbs | static int
cmp_node_mbs(const struct archive_rb_node *n1,
const struct archive_rb_node *n2)
{
struct match_file *f1 = (struct match_file *)(uintptr_t)n1;
struct match_file *f2 = (struct match_file *)(uintptr_t)n2;
const char *p1, *p2;
archive_mstring_get_mbs(NULL, &(f1->pathname), &p1);
archive_mstring_get_mb... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x20(%rdi), %rsi
leaq 0x10(%rsp), %r14
xorl %edi, %edi
movq %r14, %rdx
callq 0x15e766
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x15e766
movq (%r14), %rdi
testq %rdi, %rdi
je 0x126815
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0... | /mmatuska[P]libarchive/libarchive/archive_match.c |
archive_read_open2 | int
archive_read_open2(struct archive *a, void *client_data,
archive_open_callback *client_opener,
archive_read_callback *client_reader,
archive_skip_callback *client_skipper,
archive_close_callback *client_closer)
{
/* Old archive_read_open2() is just a thin shell around
* archive_read_open1. */
ar... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
xorl %edx, %edx
callq 0x127e55
leaq 0xa2927(%rip), %rcx # 0x1ca627
movq %r14, %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x18d4b2
cmpl $-0x1e, %eax
je 0x... | /mmatuska[P]libarchive/libarchive/archive_read.c |
client_switch_proxy | static int
client_switch_proxy(struct archive_read_filter *self, unsigned int iindex)
{
int r1 = ARCHIVE_OK, r2 = ARCHIVE_OK;
void *data2 = NULL;
/* Don't do anything if already in the specified data node */
if (self->archive->client.cursor == iindex)
return (ARCHIVE_OK);
self->archive->client.cursor = iindex... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
cmpl %esi, 0xe4(%rdi)
jne 0x1280f9
xorl %eax, %eax
jmp 0x128170
movl %esi, 0xe4(%rdi)
movq 0xd8(%rdi), %rax
movq 0xf0(%rdi), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rcx,%rdx,8), %r14
testq %rax, %rax
je 0x12812... | /mmatuska[P]libarchive/libarchive/archive_read.c |
_archive_read_register_bidder | int
__archive_read_register_bidder(struct archive_read *a,
void *bidder_data,
const char *name,
const struct archive_read_filter_bidder_vtable *vtable)
{
struct archive_read_filter_bidder *bidder;
int i, number_slots;
archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "__archive_read_re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa2275(%rip), %rcx # 0x1ca840
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x128654
movl $... | /mmatuska[P]libarchive/libarchive/archive_read.c |
get_filter | static struct archive_read_filter *
get_filter(struct archive *_a, int n)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_filter *f = a->filter;
/* We use n == -1 for 'the last filter', which is always the
* client proxy. */
if (n == -1 && f != NULL) {
struct archive_read_filter *last ... | movq 0x278(%rdi), %rcx
cmpl $-0x1, %esi
sete %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x129312
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x129304
jmp 0x129339
testl %esi, %esi
js 0x12933a
setne %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
movq %rcx, %rax
cmpb $0x1, %dl
jne 0x1293... | /mmatuska[P]libarchive/libarchive/archive_read.c |
archive_read_append_filter_program_signature | int
archive_read_append_filter_program_signature(struct archive *_a,
const char *cmd, const void *signature, size_t signature_len)
{
int r, number_bidders, i;
struct archive_read_filter_bidder *bidder;
struct archive_read_filter *filter;
struct archive_read *a = (struct archive_read *)_a;
if (archive_read_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x12efb7
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
testl %eax, %eax
jne 0x1298ed
leaq 0x278(%r14), %r15
movl $0xf8, %eax
cmpq $0x0, (%r14,%rax)
je 0x129867
cmpq $0x0, 0x8(%r14,%rax)
je 0x129874
addq $0x18, %rax
cmpl $0x278, %eax # imm = 0x278
jne 0... | /mmatuska[P]libarchive/libarchive/archive_read_append_filter.c |
archive_read_disk_uname | const char *
archive_read_disk_uname(struct archive *_a, la_int64_t uid)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_disk_uname"))
return (NULL);
if (a->lookup_uname == NULL)
return (NULL);... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa0555(%rip), %rcx # 0x1cad78
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x18d4b2
testl %eax, %eax
je 0x12a840
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe0(%r14), %rax
t... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
archive_read_disk_set_uname_lookup | int
archive_read_disk_set_uname_lookup(struct archive *_a,
void *private_data,
const char * (*lookup_uname)(void *private, la_int64_t uid),
void (*cleanup_uname)(void *private))
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
A... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa04c6(%rip), %rcx # 0x1cadb3
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0x... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
archive_read_disk_set_behavior | int
archive_read_disk_set_behavior(struct archive *_a, int flags)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
int r = ARCHIVE_OK;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_disk_honor_nodump");
a->flags = flags;
if (flags & ARCHIVE_READDISK_RESTORE... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa0367(%rip), %rcx # 0x1cae68
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x12ab3a
movl %ebp, 0xc0... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
archive_read_disk_set_metadata_filter_callback | int
archive_read_disk_set_metadata_filter_callback(struct archive *_a,
int (*_metadata_filter_func)(struct archive *, void *,
struct archive_entry *), void *_client_data)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_ANY,
"... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa02e9(%rip), %rcx # 0x1caea6
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x12abe8... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
archive_read_disk_can_descend | int
archive_read_disk_can_descend(struct archive *_a)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
struct tree *t = a->tree;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_read_disk_can_descend");
return (t->visit_type == TREE_REGU... | pushq %rbx
movq 0xa0(%rdi), %rbx
leaq 0xa02d8(%rip), %rcx # 0x1caed5
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x6, %edx
callq 0x18d4b2
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x12ac2c
xorl %eax, %eax
cmpl $0x1, 0x24(%rbx)
jne 0x12ac2c
xorl %eax, %eax
cmpl $0x... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
archive_read_disk_descend | int
archive_read_disk_descend(struct archive *_a)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
struct tree *t = a->tree;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_read_disk_descend");
if (!archive_read_disk_can_descend(_a))
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xa0(%rdi), %rbx
leaq 0xa02b0(%rip), %rcx # 0x1caef3
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x6, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x12ad01
movq %r14, %rdi
callq 0x12abee
xorl %ebp, %ebp
testl ... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
tree_current_is_dir | static int
tree_current_is_dir(struct tree *t)
{
const struct stat *st;
/*
* If we already have lstat() info, then try some
* cheap tests to determine if this is a dir.
*/
if (t->flags & hasLstat) {
/* If lstat() says it's a dir, it must be a dir. */
st = tree_current_lstat(t);
if (st == NULL)
return ... | pushq %rbx
movq %rdi, %rbx
testb $0x20, 0x20(%rdi)
jne 0x12aea9
movq %rbx, %rdi
callq 0x12c4ef
testq %rax, %rax
je 0x12aed5
movl $0xf000, %ecx # imm = 0xF000
andl 0x18(%rax), %ecx
xorl %eax, %eax
cmpl $0x4000, %ecx # imm = 0x4000
sete %al
jmp 0x12aede
movq %rbx, %rdi
callq 0x12c4bb
movq %rax, %rcx
x... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
tree_append | static void
tree_append(struct tree *t, const char *name, size_t name_length)
{
size_t size_needed;
t->path.s[t->dirname_length] = '\0';
t->path.length = t->dirname_length;
/* Strip trailing '/' from name, unless entire name is "/". */
while (name_length > 1 && name[name_length - 1] == '/')
name_length--;
/* ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
movq 0x30(%rdi), %rax
movq 0x50(%rdi), %rcx
movb $0x0, (%rax,%rcx)
movq 0x50(%rdi), %rax
movq %rax, 0x38(%rdi)
cmpq $0x2, %rdx
jb 0x12c678
cmpb $0x2f, -0x1(%r15,%r14)
jne 0x12c678
decq %r14
cmpq ... | /mmatuska[P]libarchive/libarchive/archive_read_disk_posix.c |
cleanup | static void
cleanup(void *data)
{
struct name_cache *cache = (struct name_cache *)data;
size_t i;
if (cache != NULL) {
for (i = 0; i < cache->size; i++) {
if (cache->cache[i].name != NULL &&
cache->cache[i].name != NO_NAME)
free((void *)(uintptr_t)cache->cache[i].name);
}
free(cache->buff);
fr... | testq %rdi, %rdi
je 0x12ca69
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x12ca4d
leaq 0x30(%rbx), %r14
xorl %r15d, %r15d
leaq 0x9e6a8(%rip), %r12 # 0x1cb0d0
movq (%r14), %rdi
testq %rdi, %rdi
sete %al
cmpq %r12, %rdi
sete %cl
orb %al, %cl
jne 0x12ca40
callq 0x142... | /mmatuska[P]libarchive/libarchive/archive_read_disk_set_standard_lookup.c |
lookup_gname_helper | static const char *
lookup_gname_helper(struct name_cache *cache, id_t id)
{
struct group grent, *result;
char * nbuff;
size_t nbuff_size;
int r;
if (cache->buff_size == 0) {
cache->buff_size = 256;
cache->buff = malloc(cache->buff_size);
}
if (cache->buff == NULL)
return (NULL);
for (;;) {
result = &g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x12cc1f
movq $0x100, 0x10(%r14) # imm = 0x100
movl $0x100, %edi # imm = 0x100
callq 0x14cd0
movq %rax, 0x8(%r14)
cmpq $0x0, 0x8(%r14)
je 0x12ccb0
leaq 0x8(%rsp), ... | /mmatuska[P]libarchive/libarchive/archive_read_disk_set_standard_lookup.c |
_archive_read_get_extract | struct archive_read_extract *
__archive_read_get_extract(struct archive_read *a)
{
if (a->extract == NULL) {
a->extract = calloc(1, sizeof(*a->extract));
if (a->extract == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't extract");
return (NULL);
}
a->cleanup_archive_extract = archive_read_extract_c... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x820(%rdi)
jne 0x12cd7e
movl $0x1, %edi
movl $0x18, %esi
callq 0x14be0
movq %rax, 0x820(%rbx)
testq %rax, %rax
je 0x12cd90
leaq 0x34(%rip), %rax # 0x12cdab
movq %rax, 0x828(%rbx)
movq 0x820(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r1... | /mmatuska[P]libarchive/libarchive/archive_read_extract2.c |
archive_read_extract2 | int
archive_read_extract2(struct archive *_a, struct archive_entry *entry,
struct archive *ad)
{
struct archive_read *a = (struct archive_read *)_a;
int r, r2;
/* Set up for this particular entry. */
if (a->skip_file_set)
archive_write_disk_set_skip_file(ad,
a->skip_file_dev, a->skip_file_ino);
r = ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x98(%rdi)
je 0x12ce21
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
movq %rbx, %rdi
callq 0x1637c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16297e
testl %eax, %eax
je 0x12ce8b
cmpl... | /mmatuska[P]libarchive/libarchive/archive_read_extract2.c |
file_seek | static int64_t
file_seek(struct archive *a, void *client_data, int64_t request, int whence)
{
struct read_fd_data *mine = (struct read_fd_data *)client_data;
int64_t r;
/* We use off_t here because lseek() is declared that way. */
/* See above for notes about when off_t is less than 64 bits. */
r = lseek(mine->fd... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x143e0
testq %rax, %rax
jns 0x12d1e0
callq 0x14de0
movl (%rax), %esi
movl (%r14), %ecx
cmpl $0x1d, %esi
jne 0x12d1c8
leaq 0x9dfa3(%rip), %rdx # 0x1cb153
movq %rbx, %rdi
movl $0x1d, %esi
xorl %ea... | /mmatuska[P]libarchive/libarchive/archive_read_open_fd.c |
FILE_read | static ssize_t
FILE_read(struct archive *a, void *client_data, const void **buff)
{
struct read_FILE_data *mine = (struct read_FILE_data *)client_data;
size_t bytes_read;
*buff = mine->buffer;
bytes_read = fread(mine->buffer, 1, mine->block_size, mine->f);
if (bytes_read < mine->block_size && ferror(mine->f)) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, (%rdx)
movq 0x10(%rsi), %rdi
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl $0x1, %esi
callq 0x146d0
movq %rax, %r14
cmpq 0x8(%r15), %rax
jae 0x12d382
movq (%r15), %rdi
callq 0x14a40
testl %eax, %eax
je 0x12d382
callq 0x14de0... | /mmatuska[P]libarchive/libarchive/archive_read_open_file.c |
file_seek | static int64_t
file_seek(struct archive *a, void *client_data, int64_t request, int whence)
{
struct read_file_data *mine = (struct read_file_data *)client_data;
int64_t r;
/* We use off_t here because lseek() is declared that way. */
/* See above for notes about when off_t is less than 64 bits. */
r = lseek(mine... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %edi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x143e0
testq %rax, %rax
jns 0x12d95b
movl 0x20(%rbx), %ebp
callq 0x14de0
movl (%rax), %esi
cmpl $0x1, %ebp
je 0x12d92f
testl %ebp, %ebp
jne 0x12d93c
leaq 0x9d98c(%rip), %rdx # 0x1cb2af
movq %r14... | /mmatuska[P]libarchive/libarchive/archive_read_open_filename.c |
file_close2 | static int
file_close2(struct archive *a, void *client_data)
{
struct read_file_data *mine = (struct read_file_data *)client_data;
(void)a; /* UNUSED */
/* Only flush and close if open succeeded. */
if (mine->fd >= 0) {
/*
* Sometimes, we should flush the input before closing.
* Regular files: faster to... | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
js 0x12db76
movl $0xf000, %eax # imm = 0xF000
andl 0x18(%rbx), %eax
cmpl $0x2000, %eax # imm = 0x2000
je 0x12db69
cmpl $0x6000, %eax # imm = 0x6000
je 0x12db69
cmpl $0x8000, %eax # imm = 0x8000
je 0x12db69
movl (%rbx), %edi
movq 0x10(%... | /mmatuska[P]libarchive/libarchive/archive_read_open_filename.c |
archive_set_format_option | static int
archive_set_format_option(struct archive *_a, const char *m, const char *o,
const char *v)
{
struct archive_read *a = (struct archive_read *)_a;
size_t i;
int r, rv = ARCHIVE_WARN, matched_modules = 0;
for (i = 0; i < sizeof(a->formats)/sizeof(a->formats[0]); i++) {
struct archive_format_descripto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x298(%rdi), %r13
movl $0xffffffec, (%rsp) # imm = 0xFFFFFFEC
movl $0x0, 0x4(%rsp)
movl $0x10, %ebp
movq 0x18(%r13), %r15
movl $0x4, %r14d
testq %r15, %r... | /mmatuska[P]libarchive/libarchive/archive_read_set_options.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.