name string | code string | asm string | file string |
|---|---|---|---|
pax_time | static void
pax_time(const char *p, int64_t *ps, long *pn)
{
char digit;
int64_t s;
unsigned long l;
int sign;
int64_t limit, last_digit_limit;
limit = INT64_MAX / 10;
last_digit_limit = INT64_MAX % 10;
s = 0;
sign = 1;
if (*p == '-') {
sign = -1;
p++;
}
while (*p >= '0' && *p <= '9') {
digit = *p -... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movabsq $0xccccccccccccccc, %rax # imm = 0xCCCCCCCCCCCCCCC
movq %rax, -0x40(%rbp)
movq $0x7, -0x48(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9fe04
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
pax_attribute_acl | static int
pax_attribute_acl(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const char *value, int type)
{
int r;
const char* errstr;
switch (type) {
case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
errstr = "SCHILY.acl.access";
break;
case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
errstr = "SCHILY.acl.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x100, %eax # imm = 0x100
je 0xa00a3
jmp 0xa008b
movl -0x3c(%rbp), %eax
subl $0x200, %eax ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
solaris_sparse_parse | static int
solaris_sparse_parse(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const char *p)
{
const char *e;
int64_t start, end;
int hole = 1;
(void)entry; /* UNUSED */
end = 0;
if (*p == ' ')
p++;
else
return (ARCHIVE_WARN);
for (;;) {
e = p;
while (*e != '\0' && *e != ' ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x44(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xa0291
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
url_decode | static char *
url_decode(const char *in)
{
char *out, *d;
const char *s;
out = (char *)malloc(strlen(in) + 1);
if (out == NULL)
return (NULL);
for (s = in, d = out; *s != '\0'; ) {
if (s[0] == '%' && s[1] != '\0' && s[2] != '\0') {
/* Try to convert % escape */
int digit1 = tohex(s[1]);
int digit2 = ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x109c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x116e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa03f9
movq $0x0, -0x8(%rbp)
jmp 0xa04d0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
gnu_sparse_old_read | static int
gnu_sparse_old_read(struct archive_read *a, struct tar *tar,
const struct archive_entry_header_gnutar *header, size_t *unconsumed)
{
ssize_t bytes_read;
const void *data;
struct extended {
struct gnu_sparse sparse[21];
char isextended[1];
char padding[7];
};
const struct extended *ext;
if (g... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x182, %rdx # imm = 0x182
movl $0x4, %ecx
callq 0xa0dd0
cmpl $0x0, %eax
je 0xa0cc6
movl $0xffffffe... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
gnu_sparse_old_parse | static int
gnu_sparse_old_parse(struct archive_read *a, struct tar *tar,
const struct gnu_sparse *sparse, int length)
{
while (length > 0 && sparse->offset[0] != 0) {
if (gnu_add_sparse_entry(a, tar,
tar_atol(sparse->offset, sizeof(sparse->offset)),
tar_atol(sparse->numbytes, sizeof(sparse->numbytes)... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x25(%rbp)
jle 0xa0e02
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %a... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
gnu_sparse_10_atol | static int64_t
gnu_sparse_10_atol(struct archive_read *a, struct tar *tar,
int64_t *remaining, size_t *unconsumed)
{
int64_t l, limit, last_digit_limit;
const char *p;
ssize_t bytes_read;
int base, digit;
base = 10;
limit = INT64_MAX / base;
last_digit_limit = INT64_MAX % base;
/*
* Skip any lines start... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xa, -0x54(%rbp)
movslq -0x54(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movslq -0x54(%rbp), %rcx
movabsq $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
archive_read_support_format_warc | int
archive_read_support_format_warc(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct warc_s *w;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_warc");
if ((w = calloc(1, sizeof(*w))) == NULL) {
archive_set_error(&a->archi... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x214f60(%rip), %rcx # 0x2b6209
callq 0xe9670
movl %eax, -0x28(%rbp)
cmpl $-0x1e, -0x28(%rbp)
jne 0xa12c3
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.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;
/* for the file name, saves some strndup()'ing */
warc_string_t fnam;
/* warc record type, not that we r... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
leaq -0x38(%rbp), %rdx
callq 0x66710
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0xa1485
movq -0x1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
warc_cleanup | static int
_warc_cleanup(struct archive_read *a)
{
struct warc_s *w = a->format->data;
if (w->pool.len > 0U) {
free(w->pool.str);
}
archive_string_free(&w->sver);
free(w);
a->format->data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0xa1af6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xaaa1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
warc_rdtyp | static unsigned int
_warc_rdtyp(const char *buf, size_t bsz)
{
static const char _key[] = "\r\nWARC-Type:";
const char *val, *eol;
if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) {
/* no bother */
return WT_NONE;
}
val += sizeof(_key) - 1U;
if ((eol = _warc_find_eol(val, buf + bsz - val)) == ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2143c3(%rip), %rdx # 0x2b6312
movl $0xc, %ecx
callq 0xa2340
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa1f6f
movl $0x0, -0x4(%rbp)
jmp 0xa2061
movq -0x20(%rbp), %rax
addq $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
warc_rdmtm | static time_t
_warc_rdmtm(const char *buf, size_t bsz)
{
static const char _key[] = "\r\nLast-Modified:";
const char *val, *eol;
char *on = NULL;
time_t res;
if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) {
/* no bother */
return (time_t)-1;
}
val += sizeof(_key) - 1U;
if ((eol = _warc_fin... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x214099(%rip), %rdx # 0x2b6340
movl $0x10, %ecx
callq 0xa2340
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa22c5
movq $-0x1, -0x8(%rbp)
jmp 0xa232a
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
xstrpisotime | static time_t
xstrpisotime(const char *s, char **endptr)
{
/** like strptime() but strictly for ISO 8601 Zulu strings */
struct tm tm;
time_t res = (time_t)-1;
/* make sure tm is clean */
memset(&tm, 0, sizeof(tm));
/* as a courtesy to our callers, and since this is a non-standard
* routine, we skip leading wh... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $-0x1, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10810
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x51(%rbp)
je 0xa25b9
movq -0x8(%rbp), %rax
movsbl (... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
archive_read_support_format_xar | int
archive_read_support_format_xar(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_xar");
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Xar not supported on this platform");
return... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x213a98(%rip), %rcx # 0x2b6351
callq 0xe9670
movl %eax, -0x1c(%rbp)
cmpl $-0x1e, -0x1c(%rbp)
jne 0xa28d0
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_xar.c |
archive_read_support_format_zip_streamable | int
archive_read_support_format_zip_streamable(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct zip *zip;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_zip");
zip = (struct zip *)calloc(1, sizeof(*zip));
if (zip == NULL) {... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x213a54(%rip), %rcx # 0x2b63c0
callq 0xe9670
movl %eax, -0x38(%rbp)
cmpl $-0x1e, -0x38(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_read_support_format_zip_seekable | int
archive_read_support_format_zip_seekable(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct zip *zip;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_zip_seekable");
zip = (struct zip *)calloc(1, sizeof(*zip));
if (zip == ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x21393c(%rip), %rcx # 0x2b63f8
callq 0xe9670
movl %eax, -0x38(%rbp)
cmpl $-0x1e, -0x38(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_read_format_zip_streamable_bid | static int
archive_read_format_zip_streamable_bid(struct archive_read *a, int best_bid)
{
const char *p;
(void)best_bid; /* UNUSED */
if ((p = __archive_read_ahead(a, 4, NULL)) == NULL)
return (-1);
/*
* Bid of 29 here comes from:
* + 16 bits for "PK",
* + next 16-bit field has 6 options so contributes... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa2c37
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa2d0a
movq -0x20(%rbp), %rax
movsbl (%ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_read_format_zip_options | static int
archive_read_format_zip_options(struct archive_read *a,
const char *key, const char *val)
{
struct zip *zip;
int ret = ARCHIVE_FAILED;
zip = (struct zip *)(a->format->data);
if (strcmp(key, "compat-2x") == 0) {
/* Handle filenames as libarchive 2.x */
zip->init_default_conversion = (val != NULL... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffe7, -0x2c(%rbp) # imm = 0xFFFFFFE7
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2104c4(%rip), %rsi # 0x2b321c
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_read_format_zip_seekable_read_header | static int
archive_read_format_zip_seekable_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct zip *zip = (struct zip *)a->format->data;
struct zip_entry *rsrc;
int64_t offset;
int r, ret = ARCHIVE_OK;
/*
* It should be sufficient to call archive_read_next_header() for
* a reader to de... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x38(%rax)
jne 0xa3e1e
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_data_deflate | static int
zip_read_data_deflate(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip *zip;
ssize_t bytes_avail;
const void *compressed_buff, *sp;
int r;
(void)offset; /* UNUSED */
zip = (struct zip *)(a->format->data);
/* If the buffer hasn't been allocated, allocate it ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0xa5de8
movq -0x30(%rbp), %rax
movq $0x40000, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
compression_name | static const char *
compression_name(const int compression)
{
static const int num_compression_methods =
sizeof(compression_methods)/sizeof(compression_methods[0]);
int i=0;
while(compression >= 0 && i < num_compression_methods) {
if (compression_methods[i].id == compression)
return compression_methods[i].na... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0xa6643
cmpl $0x1a, -0x10(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa664c
jmp 0xa668c
movslq -0x10(%rbp), %rcx
leaq 0x27e589(%rip), %rax # 0x32... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
consume_optional_marker | static int
consume_optional_marker(struct archive_read *a, struct zip *zip)
{
if (zip->end_of_entry && (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) {
const char *p;
if (NULL == (p = __archive_read_ahead(a, 24, NULL))) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP end-... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xa2(%rax), %eax
cmpl $0x0, %eax
je 0xa6b54
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movzwl 0x7e(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa6b54
movq -0x10(%rbp), %rdi
movl $0x18, %esi
xorl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_data_none | static int
zip_read_data_none(struct archive_read *a, const void **_buff,
size_t *size, int64_t *offset)
{
struct zip *zip;
const char *buff;
ssize_t bytes_avail;
int r;
(void)offset; /* UNUSED */
zip = (struct zip *)(a->format->data);
if (zip->entry->zip_flags & ZIP_LENGTH_AT_END) {
const char *p;
ss... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rax
movzwl 0x7e(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
ppmd_read | static Byte
ppmd_read(void* p) {
/* Get the handle to current decompression context. */
struct archive_read *a = ((IByteIn*)p)->a;
struct zip *zip = (struct zip*) a->format->data;
ssize_t bytes_avail = 0;
/* Fetch next byte. */
const uint8_t* data = __archive_read_ahead(a, 1, &bytes_avail);
if(bytes_avail < 1) ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x66710
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
read_zip64_eocd | static int
read_zip64_eocd(struct archive_read *a, struct zip *zip, const char *p)
{
int64_t eocd64_offset;
int64_t eocd64_size;
/* Sanity-check the locator record. */
/* Central dir must be on first volume. */
if (archive_le32dec(p + 4) != 0)
return 0;
/* Must be only a single volume. */
if (archive_le32dec... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0xa5160
cmpl $0x0, %eax
je 0xa96b2
movl $0x0, -0x4(%rbp)
jmp 0xa981b
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xa5160
cmpl $0x1, %eax
je 0xa96d0
movl $0x0, -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_mac_metadata | static int
zip_read_mac_metadata(struct archive_read *a, struct archive_entry *entry,
struct zip_entry *rsrc)
{
struct zip *zip = (struct zip *)a->format->data;
unsigned char *metadata, *mp;
int64_t offset = archive_filter_bytes(&a->archive, 0);
size_t remaining_bytes, metadata_bytes;
ssize_t hsize;
int ret =... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb2ec0
movq %rax, -0x40(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x20(%rbp), %ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
expose_parent_dirs | static void
expose_parent_dirs(struct zip *zip, const char *name, size_t name_length)
{
struct archive_string str;
struct zip_entry *dir;
char *s;
archive_string_init(&str);
archive_strncpy(&str, name, name_length);
for (;;) {
s = strrchr(str.s, '/');
if (s == NULL)
break;
*s = '\0';
/* Transfer the p... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xaac10
movq -0x30(%rbp), %rdi
movl $0x2f... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_strcat | struct archive_string *
archive_strcat(struct archive_string *as, const void *p)
{
/* strcat is just strncat without an effective limit.
* Assert that we'll never get called with a source
* string over 16MB.
* TODO: Review all uses of strcat in the source
* and try to replace them with strncat().
*/
return... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000000, %edx # imm = 0x1000000
callq 0xaac10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_string_normalize_C | static int
archive_string_normalize_C(struct archive_string *as, const void *_p,
size_t len, struct archive_string_conv *sc)
{
const char *s = (const char *)_p;
char *p, *endp;
uint32_t uc, uc2;
size_t w;
int always_replace, n, n2, ret = 0, spair, ts, tm;
int (*parse)(uint32_t *, const char *, size_t);
size_... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x60(%rbp)
movl $0x1, -0x54(%rbp)
movl $0x1, -0x68(%rbp)
movq -0x28(%rbp), %rax
movl 0x24(%rax), %ea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
utf16_to_unicode | static int
utf16_to_unicode(uint32_t *pwc, const char *s, size_t n, int be)
{
const char *utf16 = s;
unsigned uc;
if (n == 0)
return (0);
if (n == 1) {
/* set the Replacement Character instead. */
*pwc = UNICODE_R_CHAR;
return (-1);
}
if (be)
uc = archive_be16dec(utf16);
else
uc = archive_le16dec(u... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb14e2
movl $0x0, -0x4(%rbp)
jmp 0xb160f
cmpq $0x1, -0x20(%rbp)
jne 0xb14ff
movq -0x10(%rbp), %rax
movl $0xfff... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
append_int | static void
append_int(struct archive_string *as, intmax_t d, unsigned base)
{
uintmax_t ud;
if (d < 0) {
archive_strappend_char(as, '-');
ud = (d == INTMAX_MIN) ? (uintmax_t)(INTMAX_MAX) + 1 : (uintmax_t)(-d);
} else
ud = d;
append_uint(as, ud, base);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xb256c
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0xaadc0
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jne 0xb2558
movabsq $-0x80000000000... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string_sprintf.c |
_archive_write_allocate_filter | struct archive_write_filter *
__archive_write_allocate_filter(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f;
f = calloc(1, sizeof(*f));
f->archive = _a;
f->state = ARCHIVE_WRITE_FILTER_STATE_NEW;
if (a->filter_first == NULL)
a->filter_first = f;
els... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0x11580
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x5c(%rax)
movq -0x10(%rbp), %rax
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write.c |
_archive_write_nulls | int
__archive_write_nulls(struct archive_write *a, size_t length)
{
if (length == 0)
return (ARCHIVE_OK);
while (length > 0) {
size_t to_write = length < a->null_length ? length : a->null_length;
int r = __archive_write_output(a, a->nulls, to_write);
if (r < ARCHIVE_OK)
return (r);
length -= to_write;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb3690
movl $0x0, -0x4(%rbp)
jmp 0xb370c
jmp 0xb3692
cmpq $0x0, -0x18(%rbp)
jbe 0xb3705
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xb0(%rcx), %rax
jae 0xb36b4
movq -0x18(%rbp), %rax
movq %rax, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write.c |
archive_write_client_close | static int
archive_write_client_close(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
struct archive_none *state = (struct archive_none *)f->data;
ssize_t block_length;
ssize_t target_block_length;
ssize_t bytes_written;
size_t to_write;
char *p;
int ret = ARCHIVE... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xb3e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write.c |
archive_write_disk_data_block | static ssize_t
_archive_write_disk_data_block(struct archive *_a,
const void *buff, size_t size, int64_t offset)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
ssize_t r;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_DATA, "archive_write_data_block");
a->offs... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x4, %edx
leaq 0x207b69(%rip), %rcx # 0x2be07e
callq 0xe96... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
set_time | static int
set_time(int fd, int mode, const char *name,
time_t atime, long atime_nsec,
time_t mtime, long mtime_nsec)
{
/* Select the best implementation for this platform. */
#if defined(HAVE_UTIMENSAT) && defined(HAVE_FUTIMENS)
/*
* utimensat() and futimens() are defined in
* POSIX.1-2008. They support ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
cleanup_pathname | static int
cleanup_pathname(struct archive_write_disk *a)
{
struct archive_string error_string;
int error_number;
int rc;
archive_string_init(&error_string);
rc = cleanup_pathname_fsobj(a->name, &error_number, &error_string,
a->flags);
if (rc != ARCHIVE_OK) {
archive_set_error(&a->archive, error_number, "%... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x200(%rax), %ecx
leaq -0x24(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xb74e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
clear_nochange_fflags | static int
clear_nochange_fflags(struct archive_write_disk *a)
{
mode_t mode = archive_entry_mode(a->entry);
const int nochange_flags = 0
#ifdef SF_IMMUTABLE
| SF_IMMUTABLE
#endif
#ifdef UF_IMMUTABLE
| UF_IMMUTABLE
#endif
#ifdef SF_APPEND
| SF_APPEND
#endif
#ifdef UF_APPEND
| UF_APPEND
#endif
#if... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
callq 0x5c990
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x204(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rdx
movl -0xc(%rbp), %ecx
xorl %eax, %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
create_filesystem_object | static int
create_filesystem_object(struct archive_write_disk *a)
{
/* Create the entry. */
const char *linkname;
mode_t final_mode, mode;
int r;
/* these for check_symlinks_fsobj */
char *linkname_copy; /* non-const copy of linkname */
struct stat st;
struct archive_string error_string;
int error_number;
/*... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rdi
callq 0x5c730
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb8564
jmp 0xb82e0
movq $0x0, -0xd8(%rbp)
movq $0x0, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
callq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
create_parent_dir | static int
create_parent_dir(struct archive_write_disk *a, char *path)
{
char *slash;
int r;
/* Remove tail element to obtain parent name. */
slash = strrchr(path, '/');
if (slash == NULL)
return (ARCHIVE_OK);
*slash = '\0';
r = create_dir(a, path);
*slash = '/';
return (r);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x117d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb88e2
movl $0x0, -0x4(%rbp)
jmp 0xb8906
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
set_ownership | static int
set_ownership(struct archive_write_disk *a)
{
#if !defined(__CYGWIN__) && !defined(__linux__)
/*
* On Linux, a process may have the CAP_CHOWN capability.
* On Windows there is no 'root' user with uid 0.
* Elsewhere we can skip calling chown if we are not root and the desired
* user id does not match the ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x204(%rax)
jl 0xb8d59
movq -0x10(%rbp), %rax
movl 0x204(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x238(%rax), %rax
movl %eax, %edx
callq 0x112b0
cmpl $0x0, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
set_times_from_entry | static int
set_times_from_entry(struct archive_write_disk *a)
{
time_t atime, birthtime, mtime, cctime;
long atime_nsec, birthtime_nsec, mtime_nsec, ctime_nsec;
/* Suitable defaults. */
atime = birthtime = mtime = cctime = a->start_time;
atime_nsec = birthtime_nsec = mtime_nsec = ctime_nsec = 0;
/* If no time w... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
write_data_block | static ssize_t
write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
{
uint64_t start_size = size;
ssize_t bytes_written = 0;
ssize_t block_size = 0, bytes_to_write;
if (size == 0)
return (ARCHIVE_OK);
if (a->filesize == 0 || a->fd < 0) {
archive_set_error(&a->archive, 0,
"Attem... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb9500
movq $0x0, -0x8(%rbp)
jmp 0xb97f6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x220(%rax)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_write_add_filter_bzip2 | int
archive_write_add_filter_bzip2(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_bzi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb3510
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x20485d(%rip), %rcx # 0x2be0c3
callq 0xe9670
movl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_compressor_compress_write | static int
archive_compressor_compress_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *state = (struct private_data *)f->data;
int i;
int ratio;
int c, disp, ret;
const unsigned char *bp;
if (length == 0)
return ARCHIVE_OK;
bp = buff;
if (state->in_count ==... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xba1e3
movl $0x0, -0x4(%rbp)
jmp 0xba500
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c |
output_byte | static int
output_byte(struct archive_write_filter *f, unsigned char c)
{
struct private_data *state = f->data;
state->compressed[state->compressed_offset++] = c;
++state->out_count;
if (state->compressed_buffer_size == state->compressed_offset) {
int ret = __archive_write_filter(f->next_filter,
state->co... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movq 0x65178(%rax), %rax
movq -0x20(%rbp), %rsi
movq 0x65188(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rd... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c |
archive_write_add_filter_gzip | int
archive_write_add_filter_gzip(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_gzip"... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb3510
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x203831(%rip), %rcx # 0x2be227
callq 0xe9670
movl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
archive_compressor_gzip_options | static int
archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
const char *value)
{
struct private_data *data = (struct private_data *)f->data;
if (strcmp(key, "compression-level") == 0) {
if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
value[1] != '\0')
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1f432c(%rip), %rsi # 0x2af1c7
callq 0x114f0
cmpl $0x0, %eax
jne 0xbaef3
cmpq $0x0, -0x20(%rbp)
je 0xbaed1
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
archive_compressor_gzip_free | static int
archive_compressor_gzip_free(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
#ifdef HAVE_ZLIB_H
free(data->compressed);
#else
__archive_write_program_free(data->pdata);
#endif
free(data);
f->data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
archive_compressor_gzip_write | static int
archive_compressor_gzip_write(struct archive_write_filter *f, const void *buff,
size_t length)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
/* Update statistics */
data->crc = crc32(data->crc, (const Bytef *)buff, (uInt)length);
data->total_in += length;
/* Compress inpu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
callq 0x29ee30
movq %rax, %rcx
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
drive_compressor | static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing)
{
int ret;
for (;;) {
if (data->stream.avail_out == 0) {
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size);
if (ret != ARCHIVE_OK)
return (ARC... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xbb23c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdx
callq 0xb35a0
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
archive_write_add_filter_lzip | int
archive_write_add_filter_lzip(struct archive *_a)
{
struct archive_write_filter *f;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_lzip");
f = __archive_write_allocate_filter(_a);
r = common_setup(f);
if (r == ARCHIVE_OK) {
f->code = ARCHIVE_FILTER_LZI... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x202f59(%rip), %rcx # 0x2be2ba
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0xbb378
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_write_add_filter_lzma | int
archive_write_add_filter_lzma(struct archive *_a)
{
struct archive_write_filter *f;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_lzma");
f = __archive_write_allocate_filter(_a);
r = common_setup(f);
if (r == ARCHIVE_OK) {
f->code = ARCHIVE_FILTER_LZM... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x202e7b(%rip), %rcx # 0x2be29c
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0xbb438
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_write_add_filter_xz | int
archive_write_add_filter_xz(struct archive *_a)
{
struct archive_write_filter *f;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_xz");
f = __archive_write_allocate_filter(_a);
r = common_setup(f);
if (r == ARCHIVE_OK) {
f->code = ARCHIVE_FILTER_XZ;
f... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x202d9f(%rip), %rcx # 0x2be280
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0xbb4f8
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
common_setup | static int
common_setup(struct archive_write_filter *f)
{
struct private_data *data;
struct archive_write *a = (struct archive_write *)f->archive;
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
f->data = data;
data->comp... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x148, %esi # imm = 0x148
callq 0x11580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbb5a2
movq -0x20(%rbp), %rdi
movl $0xc, %esi
leaq 0x1f3780(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_compressor_xz_open | static int
archive_compressor_xz_open(struct archive_write_filter *f)
{
struct private_data *data = f->data;
int ret;
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performa... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x128(%rax)
jne 0xbb6ff
movq $0x10000, -0x28(%rbp) # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb0c5c0de, (%rax) # imm = 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_compressor_xz_close | static int
archive_compressor_xz_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
data->total_out +=
data->compressed_buffer_size - data->stream.avail_out;
ret = __archive_write_filter... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0xbbf90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xbb9dc
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_compressor_xz_write | static int
archive_compressor_xz_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
/* Update statistics */
data->total_in += length;
if (f->code == ARCHIVE_FILTER_LZIP)
data->crc32 = lzma_crc32(buff, length, data->cr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x120(%rax), %rcx
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
cmpl $0x9, 0x50(%rax)
jn... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
drive_compressor | static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing)
{
int ret;
for (;;) {
if (data->stream.avail_out == 0) {
data->total_out += data->compressed_buffer_size;
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buf... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xbc029
movq -0x18(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x138(%rax), %rcx
movq %rcx, 0x138(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_write_add_filter_zstd | int
archive_write_add_filter_zstd(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_zstd"... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb3510
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x2022ca(%rip), %rcx # 0x2be530
callq 0xe9670
movl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_compressor_zstd_open | static int
archive_compressor_zstd_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
if (data->out.dst == NULL) {
size_t bs = ZSTD_CStreamOutSize(), bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of
* the of ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xbc47a
callq 0x1415a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb0c5c0de, (%rax) # imm = 0xB0C5C0D... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_compressor_zstd_options | static int
archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
const char *value)
{
struct private_data *data = (struct private_data *)f->data;
if (strcmp(key, "compression-level") == 0) {
int level = atoi(value);
/* If we don't have the library, hard-code the max level */
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1f2c9c(%rip), %rsi # 0x2af1c7
callq 0x114f0
cmpl $0x0, %eax
jne 0xbc5cb
movq -0x20(%rbp), %rdi
callq 0x108... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_compressor_zstd_free | static int
archive_compressor_zstd_free(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR
ZSTD_freeCStream(data->cstream);
free(data->out.dst);
#else
__archive_write_program_free(data->pdata);
#endif
free(data);
f->data = NULL;... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x141570
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq $0x0,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
string_is_numeric | static int string_is_numeric (const char* value)
{
size_t len = strlen(value);
size_t i;
if (len == 0) {
return (ARCHIVE_WARN);
}
else if (len == 1 && !(value[0] >= '0' && value[0] <= '9')) {
return (ARCHIVE_WARN);
}
else if (!(value[0] >= ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x109c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbc6fc
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
jmp 0xbc7b8
cmpq $0x1, -0x18(%rbp)
jne 0xbc727
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_compressor_zstd_write | static int
archive_compressor_zstd_write(struct archive_write_filter *f, const void *buff,
size_t length)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
/* Update statistics */
data->total_in += length;
if ((ret = drive_compressor(f, data, 0, buff, length)) != ARCHIVE_OK)
return (re... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
drive_compressor | static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing, const void *src, size_t length)
{
ZSTD_inBuffer in = (ZSTD_inBuffer) { src, length, 0 };
for (;;) {
if (data->out.pos == data->out.size) {
const int ret = __archive_write_filter(f->next_filter,
data-... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_write_binary_free | static int
archive_write_binary_free(struct archive_write *a)
{
struct cpio *cpio;
cpio = (struct cpio *)a->format_data;
free(cpio->ino_list);
free(cpio);
a->format_data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
get_sconv | static struct archive_string_conv *
get_sconv(struct archive_write *a)
{
struct cpio *cpio;
struct archive_string_conv *sconv;
cpio = (struct cpio *)a->format_data;
sconv = cpio->opt_sconv;
if (sconv == NULL) {
if (!cpio->init_default_conversion) {
cpio->sconv_default =
archive_string_default_conversi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbd083
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0xbd077
movq -0x8(%rbp), %rdi
callq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
write_header | static int
write_header(struct archive_write *a, struct archive_entry *entry)
{
struct cpio *cpio;
const char *p, *path;
int pathlength, ret, ret_final;
int64_t ino;
struct cpio_binary_header h;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
size_t len;
cpio = (struct cpio *)a->format_da... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd020
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rcx
leaq -0x28(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
la_swap32 | static uint32_t la_swap32(uint32_t in) {
union {
uint32_t l;
uint16_t s[2];
uint8_t c[4];
} U;
U.l = 1;
if (U.c[0]) { /* Little-endian */
uint16_t t;
U.l = in;
t = U.s[0];
U.s[0] = U.s[1];
U.s[1] = t;
} else if (U.c[3]) { /* Big-endian */
U.l = in;
U.s[0] = la_swap16(U.s[0]);
U.s[1] = la_swa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpb $0x0, -0x8(%rbp)
je 0xbd868
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movw -0x8(%rbp), %ax
movw %ax, -0xa(%rbp)
movw -0x6(%rbp), %ax
movw %ax, -0x8(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x6(%rbp)
jmp 0xbd898
cmpb $0x0, -0x5(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
archive_write_set_format_cpio_newc | int
archive_write_set_format_cpio_newc(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct cpio *cpio;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_cpio_newc");
/* If someone else was already registered, unregister them. */
if (a->f... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x200fad(%rip), %rcx # 0x2be886
callq 0xe9670
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0xbd8f3
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
archive_write_newc_options | static int
archive_write_newc_options(struct archive_write *a, const char *key,
const char *val)
{
struct cpio *cpio = (struct cpio *)a->format_data;
int ret = ARCHIVE_FAILED;
if (strcmp(key, "hdrcharset") == 0) {
if (val == NULL || val[0] == 0)
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"%... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffe7, -0x2c(%rbp) # imm = 0xFFFFFFE7
movq -0x18(%rbp), %rdi
leaq 0x1f5303(%rip), %rsi # 0x2b2d48
callq 0x114f0
cmpl $0x0, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
archive_write_newc_header | static int
archive_write_newc_header(struct archive_write *a, struct archive_entry *entry)
{
const char *path;
size_t len;
if (archive_entry_filetype(entry) == 0 && archive_entry_hardlink(entry) == NULL) {
archive_set_error(&a->archive, -1, "Filetype required");
return (ARCHIVE_FAILED);
}
if (archive_entry_p... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5c1c0
cmpl $0x0, %eax
jne 0xbdb30
movq -0x18(%rbp), %rdi
callq 0x5c730
cmpq $0x0, %rax
jne 0xbdb30
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x200b9b(%rip), %rdx ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
archive_write_newc_close | static int
archive_write_newc_close(struct archive_write *a)
{
int er;
struct archive_entry *trailer;
trailer = archive_entry_new();
archive_entry_set_nlink(trailer, 1);
archive_entry_set_size(trailer, 0);
archive_entry_set_pathname(trailer, "TRAILER!!!");
/* Bypass the required data checks. */
er = write_head... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5bf70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5e460
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5e710
movq -0x18(%rbp), %rdi
leaq 0x1f55f8(%rip), %rsi # 0x2b3333
callq 0x5e490
movq -0x8(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
write_header | static int
write_header(struct archive_write *a, struct archive_entry *entry)
{
int64_t ino;
struct cpio *cpio;
const char *p, *path;
int pathlength, ret, ret_final;
char h[c_header_size];
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
size_t len;
int pad;
cpio = (struct cpio *)a->forma... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbddb0
movq %rax, -0xb8(%rbp)
movq $0x0, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
movq -0xb8... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
format_hex | static int
format_hex(int64_t v, void *p, int digits)
{
int64_t max;
int ret;
max = (((int64_t)1) << (digits * 4)) - 1;
if (v >= 0 && v <= max) {
format_hex_recursive(v, (char *)p, digits);
ret = 0;
} else {
format_hex_recursive(max, (char *)p, digits);
ret = -1;
}
return (ret);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0xbe487
movq -0x8(%rbp), %rax
cmpq -0x20(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
archive_write_set_format_cpio_odc | int
archive_write_set_format_cpio_odc(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct cpio *cpio;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_cpio_odc");
/* If someone else was already registered, unregister them. */
if (a->for... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x2003e7(%rip), %rcx # 0x2be930
callq 0xe9670
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0xbe563
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_odc_data | static ssize_t
archive_write_odc_data(struct archive_write *a, const void *buff, size_t s)
{
struct cpio *cpio;
int ret;
cpio = (struct cpio *)a->format_data;
if (s > cpio->entry_bytes_remaining)
s = (size_t)cpio->entry_bytes_remaining;
ret = __archive_write_output(a, buff, s);
cpio->entry_bytes_remaining -= ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xbe8cb
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_odc_close | static int
archive_write_odc_close(struct archive_write *a)
{
int er;
struct archive_entry *trailer;
trailer = archive_entry_new2(NULL);
/* nlink = 1 here for GNU cpio compat. */
archive_entry_set_nlink(trailer, 1);
archive_entry_set_size(trailer, 0);
archive_entry_set_pathname(trailer, "TRAILER!!!");
er = wri... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5beb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5e460
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5e710
movq -0x18(%rbp), %rdi
leaq 0x1f4994(%rip), %rsi # 0x2b3333
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_odc_free | static int
archive_write_odc_free(struct archive_write *a)
{
struct cpio *cpio;
cpio = (struct cpio *)a->format_data;
free(cpio->ino_list);
free(cpio);
a->format_data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10470
movq -0x10(%rbp), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
get_sconv | static struct archive_string_conv *
get_sconv(struct archive_write *a)
{
struct cpio *cpio;
struct archive_string_conv *sconv;
cpio = (struct cpio *)a->format_data;
sconv = cpio->opt_sconv;
if (sconv == NULL) {
if (!cpio->init_default_conversion) {
cpio->sconv_default =
archive_string_default_conversi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbea83
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0xbea77
movq -0x8(%rbp), %rdi
callq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
format_octal | static int
format_octal(int64_t v, void *p, int digits)
{
int64_t max;
int ret;
max = (((int64_t)1) << (digits * 3)) - 1;
if (v >= 0 && v <= max) {
format_octal_recursive(v, (char *)p, digits);
ret = 0;
} else {
format_octal_recursive(max, (char *)p, digits);
ret = -1;
}
return (ret);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0xbeff5
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
synthesize_ino_value | static int
synthesize_ino_value(struct cpio *cpio, struct archive_entry *entry)
{
int64_t ino = archive_entry_ino64(entry);
int ino_new;
size_t i;
/*
* If no index number was given, don't assign one. In
* particular, this handles the end-of-archive marker
* correctly by giving it a zero index value. (This ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5c970
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbf050
movl $0x0, -0x4(%rbp)
jmp 0xbf1bd
movq -0x18(%rbp), %rdi
callq 0x5ca10
cmpl $0x2, %eax
jae 0xbf076
movq -0x10(%rbp), %rcx
movq 0x8(%rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_gnutar_header | static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
gnutar = (struct gnutar *)a->format_data;
/* Setup default... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x22c(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xbf4a3
movq -0x238(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_gnutar_data | static ssize_t
archive_write_gnutar_data(struct archive_write *a, const void *buff, size_t s)
{
struct gnutar *gnutar;
int ret;
gnutar = (struct gnutar *)a->format_data;
if (s > gnutar->entry_bytes_remaining)
s = (size_t)gnutar->entry_bytes_remaining;
ret = __archive_write_output(a, buff, s);
gnutar->entry_byt... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xbfedb
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_gnutar_finish_entry | static int
archive_write_gnutar_finish_entry(struct archive_write *a)
{
struct gnutar *gnutar;
int ret;
gnutar = (struct gnutar *)a->format_data;
ret = __archive_write_nulls(a, (size_t)
(gnutar->entry_bytes_remaining + gnutar->entry_padding));
gnutar->entry_bytes_remaining = gnutar->entry_padding = 0;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rsi
callq 0xb3670
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
format_octal | static int
format_octal(int64_t v, char *p, int s)
{
int len = s;
/* Octal values can't be negative, so use 0. */
if (v < 0)
v = 0;
p += s; /* Start at the end and work backwards. */
while (s-- > 0) {
*--p = (char)('0' + (v & 7));
v >>= 3;
}
if (v == 0)
return (0);
/* If it overflowed, fill field w... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xc0444
movq $0x0, -0x10(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_set_format_iso9660 | int
archive_write_set_format_iso9660(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct iso9660 *iso9660;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_iso9660");
/* If another format was already registered, unregister it. */
if (a-... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x1feb6f(%rip), %rcx # 0x2bf158
callq 0xe9670
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0xc0603
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
iso9660_write_header | static int
iso9660_write_header(struct archive_write *a, struct archive_entry *entry)
{
struct iso9660 *iso9660;
struct isofile *file;
struct isoent *isoent;
int r, ret = ARCHIVE_OK;
iso9660 = a->format_data;
iso9660->cur_file = NULL;
iso9660->bytes_remaining = 0;
iso9660->need_multi_extent = 0;
if (archive_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x40(%rax)
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
iso9660_write_data | static ssize_t
iso9660_write_data(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
ssize_t r;
if (iso9660->cur_file == NULL)
return (0);
if (archive_entry_filetype(iso9660->cur_file->entry) != AE_IFREG)
return (0);
if (s > iso9660->bytes_remaining)
s = (size_t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc205b
movq $0x0, -0x8(%rbp)
jmp 0xc20df
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
get_num_opt | static int
get_num_opt(struct archive_write *a, int *num, int high, int low,
const char *key, const char *value)
{
const char *p = value;
int data = 0;
int neg = 0;
if (p == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Invalid value(empty) for option ``%s''", key);
return (ARCHIVE_FATA... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xc2dc2
movq -0x10(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isofile_new | static struct isofile *
isofile_new(struct archive_write *a, struct archive_entry *entry)
{
struct isofile *file;
file = calloc(1, sizeof(*file));
if (file == NULL)
return (NULL);
if (entry != NULL)
file->entry = archive_entry_clone(entry);
else
file->entry = archive_entry_new2(&a->archive);
if (file->ent... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x11580
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc2f17
movq $0x0, -0x8(%rbp)
jmp 0xc3022
cmpq $0x0, -0x18(%rbp)
je 0xc2f34
movq -0x18(%rbp), %rdi
callq 0x5bb50
movq %rax, %rcx
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isofile_free | static void
isofile_free(struct isofile *file)
{
struct content *con, *tmp;
con = file->content.next;
while (con != NULL) {
tmp = con;
con = con->next;
free(tmp);
}
archive_entry_free(file->entry);
archive_string_free(&(file->parentdir));
archive_string_free(&(file->basename));
archive_string_free(&(file... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc3971
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10470
jm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_new | static struct isoent *
isoent_new(struct isofile *file)
{
struct isoent *isoent;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node, isoent_cmp_key,
};
isoent = calloc(1, sizeof(*isoent));
if (isoent == NULL)
return (NULL);
isoent->file = file;
isoent->children.first = NULL;
isoent->childre... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0xf0, %esi
callq 0x11580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc3a43
movq $0x0, -0x8(%rbp)
jmp 0xc3b01
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_tree | static int
isoent_tree(struct archive_write *a, struct isoent **isoentpp)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
char name[_MAX_FNAME];/* Included null terminator size. */
#elif defined(NAME_MAX) && NAME_MAX >= 255
char name[NAME_MAX+1];
#else
char name[256];
#endif
struct iso9660 *iso9660 = a->format_data;
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x128(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x130(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isofile_register_hardlink | static int
isofile_register_hardlink(struct archive_write *a, struct isofile *file)
{
struct iso9660 *iso9660 = a->format_data;
struct hardlink *hl;
const char *pathname;
archive_entry_set_nlink(file->entry, 1);
pathname = archive_entry_hardlink(file->entry);
if (pathname == NULL) {
/* This `file` is a hardlin... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0x5e460
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5c730
movq %rax, -0x30(%rbp)
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_init | static int
zisofs_init(struct archive_write *a, struct isofile *file)
{
struct iso9660 *iso9660 = a->format_data;
#ifdef HAVE_ZLIB_H
uint64_t tsize;
size_t _ceil, bpsize;
int r;
#endif
iso9660->zisofs.detect_magic = 0;
iso9660->zisofs.making = 0;
if (!iso9660->opt.rr || !iso9660->opt.zisofs)
return (ARCHIVE... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x1d8(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x1d8(%rax)
movq -0x20(%rbp), %rax
movb 0x1d8(%rax), %cl
andb $-0x3, %cl
orb ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_add_child_tail | static int
isoent_add_child_tail(struct isoent *parent, struct isoent *child)
{
if (!__archive_rb_tree_insert_node(
&(parent->rbtree), (struct archive_rb_node *)child))
return (0);
child->chnext = NULL;
*parent->children.last = child;
parent->children.last = &(child->chnext);
parent->children.cnt++;
child... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x63f80
cmpl $0x0, %eax
jne 0xc47a2
movl $0x0, -0x4(%rbp)
jmp 0xc4849
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
get_path_component | static int
get_path_component(char *name, size_t n, const char *fn)
{
char *p;
size_t l;
p = strchr(fn, '/');
if (p == NULL) {
if ((l = strlen(fn)) == 0)
return (0);
} else
l = p - fn;
if (l > n -1)
return (-1);
memcpy(name, fn, l);
name[l] = '\0';
return ((int)l);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2f, %esi
callq 0x10d60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc48ab
movq -0x20(%rbp), %rdi
callq 0x109c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc48a9
movl $0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_free | static void
_isoent_free(struct isoent *isoent)
{
struct extr_rec *er, *er_next;
free(isoent->children_sorted);
free(isoent->identifier);
er = isoent->extr_rec_list.first;
while (er != NULL) {
er_next = er->next;
free(er);
er = er_next;
}
free(isoent);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc4971
movq -0x10(%rbp), %rax
movq 0x808(%ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.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.