name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
archive_read_format_rar_cleanup
|
static int
archive_read_format_rar_cleanup(struct archive_read *a)
{
struct rar *rar;
rar = (struct rar *)(a->format->data);
free_codes(a);
clear_filters(&rar->filters);
free(rar->filename);
free(rar->filename_save);
free(rar->dbo);
free(rar->unp_buffer);
free(rar->lzss.window);
__archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
free(rar);
(a->format->data) = NULL;
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x52ca98
movq 0x3a0(%r14), %rdi
callq 0x52c762
movq 0x398(%r14), %rdi
callq 0x52d41d
movq 0x390(%r14), %rdi
callq 0x41e70
movq 0x48(%r14), %rdi
callq 0x41e70
movq 0x50(%r14), %rdi
callq 0x41e70
movq 0x100(%r14), %rdi
callq 0x41e70
movq 0xe0(%r14), %rdi
callq 0x41e70
movq 0x350(%r14), %rdi
callq 0x41e70
leaq 0x333988(%rip), %rax # 0x85d430
leaq 0x3d8(%r14), %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0x41e70
movq 0x818(%rbx), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
read_exttime
|
static int
read_exttime(const char *p, struct rar *rar, const char *endp)
{
unsigned rmode, flags, rem, j, count;
int ttime, i;
struct tm *tm;
time_t t;
long nsec;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE__LOCALTIME64_S)
struct tm tmbuf;
#endif
#if defined(HAVE__LOCALTIME64_S)
errno_t terr;
__time64_t tmptime;
#endif
if (p + 2 > endp)
return (-1);
flags = archive_le16dec(p);
p += 2;
for (i = 3; i >= 0; i--)
{
t = 0;
if (i == 3)
t = rar->mtime;
rmode = flags >> i * 4;
if (rmode & 8)
{
if (!t)
{
if (p + 4 > endp)
return (-1);
ttime = archive_le32dec(p);
t = get_time(ttime);
p += 4;
}
rem = 0;
count = rmode & 3;
if (p + count > endp)
return (-1);
for (j = 0; j < count; j++)
{
rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8);
p++;
}
#if defined(HAVE_LOCALTIME_R)
tm = localtime_r(&t, &tmbuf);
#elif defined(HAVE__LOCALTIME64_S)
tmptime = t;
terr = _localtime64_s(&tmbuf, &tmptime);
if (terr)
tm = NULL;
else
tm = &tmbuf;
#else
tm = localtime(&t);
#endif
nsec = tm->tm_sec + rem / NS_UNIT;
if (rmode & 4)
{
tm->tm_sec++;
t = mktime(tm);
}
if (i == 3)
{
rar->mtime = t;
rar->mnsec = nsec;
}
else if (i == 2)
{
rar->ctime = t;
rar->cnsec = nsec;
}
else if (i == 1)
{
rar->atime = t;
rar->ansec = nsec;
}
else
{
rar->arctime = t;
rar->arcnsec = nsec;
}
}
}
return (0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
leaq 0x2(%rdi), %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rbx, %rdx
ja 0x52a721
movzwl (%rdi), %r14d
leaq 0x30(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsi), %rax
movq %rax, 0x38(%rsp)
leaq 0x78(%rsi), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rsi), %rax
movq %rax, 0x48(%rsp)
leaq 0x88(%rsi), %rax
movq %rax, 0x40(%rsp)
leaq 0x90(%rsi), %rax
movq %rax, 0x28(%rsp)
leaq 0x98(%rsi), %rax
movq %rax, 0x20(%rsp)
addq $0x38, %rsi
movq %rsi, 0x50(%rsp)
movl %r14d, %eax
shrl $0xc, %eax
movl %eax, 0x14(%rsp)
movl $0x3, %r13d
movq %rbx, 0x58(%rsp)
movq $0x0, 0x8(%rsp)
cmpl $0x3, %r13d
jne 0x52a61e
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
testw %r14w, %r14w
jns 0x52a631
movl 0x14(%rsp), %ebp
testq %rcx, %rcx
je 0x52a639
movl 0x14(%rsp), %ebp
movq %rdx, %r12
jmp 0x52a652
leal (,%r13,4), %ecx
movl %r14d, %ebp
shrl %cl, %ebp
testb $0x8, %bpl
jne 0x52a639
movq %rdx, %r12
jmp 0x52a70b
leaq 0x4(%rdx), %r12
cmpq %rbx, %r12
ja 0x52a71c
movl (%rdx), %edi
callq 0x52a4fd
movq %rax, 0x8(%rsp)
movl %ebp, %ecx
andl $0x3, %ecx
leaq (%r12,%rcx), %rax
cmpq %rbx, %rax
ja 0x52a71c
testq %rcx, %rcx
je 0x52a691
xorl %edx, %edx
xorl %esi, %esi
movzbl (%r12,%rdx), %edi
shll $0x10, %edi
shrl $0x8, %esi
orl %edi, %esi
incq %rdx
cmpl %edx, %ecx
jne 0x52a66d
xorl %ebx, %ebx
cmpl $0x989680, %esi # imm = 0x989680
setae %bl
movq %rax, %r12
jmp 0x52a693
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3f460
movl (%rax), %r15d
testb $0x4, %bpl
je 0x52a6be
leal 0x1(%r15), %ecx
movl %ecx, (%rax)
movq %rax, %rdi
callq 0x3fd30
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x50(%rsp), %rdx
cmpl $0x3, %r13d
je 0x52a6fd
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %rdx
cmpl $0x2, %r13d
je 0x52a6fd
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
cmpl $0x1, %r13d
je 0x52a6fd
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdx
addl %ebx, %r15d
movq %rax, (%rcx)
movq %r15, (%rdx)
movq 0x58(%rsp), %rbx
movq %r12, %rdx
subl $0x1, %r13d
jae 0x52a5ea
xorl %eax, %eax
jmp 0x52a721
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
execute_filter
|
static int
execute_filter(struct archive_read *a, struct rar_filter *filter, struct rar_virtual_machine *vm, size_t pos)
{
if (filter->prog->fingerprint == 0x1D0E06077D)
return execute_filter_delta(filter, vm);
if (filter->prog->fingerprint == 0x35AD576887)
return execute_filter_e8(filter, vm, pos, 0);
if (filter->prog->fingerprint == 0x393CD7E57E)
return execute_filter_e8(filter, vm, pos, 1);
if (filter->prog->fingerprint == 0x951C2C5DC8)
return execute_filter_rgb(filter, vm);
if (filter->prog->fingerprint == 0xD8BC85E701)
return execute_filter_audio(filter, vm);
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "No support for RAR VM program filter");
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rsi), %rax
movq 0x20(%rax), %rax
movabsq $0x393cd7e57d, %r8 # imm = 0x393CD7E57D
cmpq %r8, %rax
jle 0x52c570
movabsq $0x393cd7e57e, %r8 # imm = 0x393CD7E57E
cmpq %r8, %rax
je 0x52c5a3
movabsq $0x951c2c5dc8, %rcx # imm = 0x951C2C5DC8
cmpq %rcx, %rax
je 0x52c5c7
movabsq $0xd8bc85e701, %rcx # imm = 0xD8BC85E701
cmpq %rcx, %rax
jne 0x52c6e1
movl 0x18(%rsi), %ecx
movq %rcx, 0x10(%rsp)
cmpq $0x1e000, %rcx # imm = 0x1E000
ja 0x52c6dd
movq %rsi, 0x18(%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x52c55b
movq 0x10(%rsp), %rax
addq %rdx, %rax
addq $0x20, %rax
movq %rax, 0x80(%rsp)
addq $0x20, %rdx
xorl %r14d, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x0, 0x70(%rsp)
cmpl 0x10(%rsp), %r14d
movl %r14d, 0x2c(%rsp)
jae 0x52c548
pxor %xmm1, %xmm1
xorl %esi, %esi
xorl %ebx, %ebx
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r15d, %r15d
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r9d, %r9d
xorl %r10d, %r10d
movl $0x0, 0x4(%rsp)
movl %r8d, 0x20(%rsp)
movl %r13d, %r8d
movl %edi, %r11d
movsbl (%rdx), %ecx
movw %r10w, 0x3a(%rsp)
movsbl %r9b, %r13d
movzwl %r10w, %r9d
movl %r13d, %r10d
subl %r8d, %r10d
movzbl %r12b, %eax
movsbl 0x4(%rsp), %edi
imull %r13d, %edi
movl %ebp, 0x8(%rsp)
movsbl %bpl, %r8d
imull %r10d, %r8d
movl %r15d, %ebp
movsbl %r15b, %r12d
imull %r9d, %r12d
leal (%r12,%rax,8), %r12d
addl %r8d, %r12d
addl %edi, %r12d
shrl $0x3, %r12d
subb %cl, %r12b
leal (,%rcx,8), %r8d
leal (%r13,%rcx,8), %edi
movswl %r10w, %r15d
movd %edi, %xmm2
movl %r8d, %edi
subl %r15d, %edi
movd %edi, %xmm3
movl %r8d, %edi
subl %r13d, %edi
movd %edi, %xmm4
leal (%r15,%rcx,8), %r15d
movl %r15d, %edi
negl %edi
cmovsl %r15d, %edi
movdqa %xmm1, %xmm5
movl %ebx, %r15d
movd %r8d, %xmm1
addl %r11d, %edi
movswl %r9w, %r9d
subl %r9d, %r8d
movl %r8d, %ebx
negl %ebx
cmovsl %r8d, %ebx
addl %r15d, %ebx
movl %esi, %r8d
leal (%r9,%rcx,8), %ecx
movl %ecx, %esi
negl %esi
cmovsl %ecx, %esi
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movw %r10w, 0x38(%rsp)
movw %r13w, 0x36(%rsp)
punpckldq %xmm4, %xmm1 # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
punpcklqdq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movdqa %xmm1, %xmm2
psrad $0x1f, %xmm2
pxor %xmm2, %xmm1
psubd %xmm2, %xmm1
paddd %xmm5, %xmm1
movdqa %xmm1, 0x40(%rsp)
movl %edi, 0x50(%rsp)
movl %ebx, 0x54(%rsp)
addl %r8d, %esi
movl %esi, 0x58(%rsp)
movl %r12d, %r9d
subb %al, %r9b
movb %r9b, 0x3e(%rsp)
movb %r12b, 0x70(%rsp)
movl %r14d, %eax
movq 0x80(%rsp), %rcx
movb %r12b, (%rcx,%rax)
movl 0x20(%rsp), %eax
testb $0x1f, %al
leal 0x1(%rax), %r8d
movl %r8d, 0x6c(%rsp)
je 0x52c483
movl %ebp, %r15d
movl 0x8(%rsp), %ebp
jmp 0x52c535
movl $0x5, %eax
xorl %ecx, %ecx
movl %ebp, %r15d
movl 0x8(%rsp), %ebp
movl 0x30(%rsp,%rax,4), %esi
movzbl %cl, %ecx
cmpl 0x40(%rsp,%rcx,4), %esi
jge 0x52c4a4
leal -0x4(%rax), %ecx
movzbl %cl, %ecx
incq %rax
cmpq $0xb, %rax
jne 0x52c491
leaq 0x40(%rsp), %rax
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movzbl %cl, %eax
pxor %xmm1, %xmm1
xorl %esi, %esi
decl %eax
cmpl $0x5, %eax
ja 0x52c531
leaq 0x1906ec(%rip), %rcx # 0x6bcbc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%rsp), %eax
cmpb $-0x10, %al
jl 0x52c531
decb %al
jmp 0x52c519
cmpb $-0x10, %r15b
jl 0x52c531
decb %r15b
jmp 0x52c52c
cmpb $-0x10, %bpl
jl 0x52c531
decb %bpl
jmp 0x52c508
cmpb $0xf, %bpl
jg 0x52c531
incb %bpl
movb %bpl, 0x31(%rsp)
jmp 0x52c531
movl 0x4(%rsp), %eax
cmpb $0xf, %al
jg 0x52c531
incb %al
movl %eax, 0x4(%rsp)
movb %al, 0x30(%rsp)
jmp 0x52c531
cmpb $0xf, %r15b
jg 0x52c531
incb %r15b
movb %r15b, 0x32(%rsp)
xorl %ebx, %ebx
xorl %edi, %edi
incq %rdx
addl 0xc(%rsp), %r14d
cmpl 0x10(%rsp), %r14d
jb 0x52c348
movl 0x2c(%rsp), %r14d
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x52c2f6
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl %ecx, 0x44(%rax)
movl %ecx, 0x48(%rax)
jmp 0x52c749
movabsq $0x1d0e06077d, %r8 # imm = 0x1D0E06077D
cmpq %r8, %rax
je 0x52c6d2
movabsq $0x35ad576887, %r8 # imm = 0x35AD576887
cmpq %r8, %rax
jne 0x52c6e1
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
jmp 0x52c5b1
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x1, %ecx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x52c793
movl 0x8(%rsi), %eax
movl 0x18(%rsi), %r8d
cmpl $0x1e001, %r8d # imm = 0x1E001
setae %cl
cmpl %r8d, %eax
seta %dil
orb %cl, %dil
jne 0x52c6dd
movq %rsi, 0x18(%rsp)
movl 0xc(%rsi), %ecx
movq %rcx, 0x20(%rsp)
movl %eax, %eax
movl %r8d, 0x4(%rsp)
movl %r8d, 0x8(%rsp)
movl %r8d, %r8d
leaq 0x20(%rdx), %r9
leaq (%rdx,%r8), %rdi
addq $0x20, %rdi
movq %rdi, %r10
subq %rax, %r10
movq %r8, %r11
subq %rax, %r11
addq %rdx, %r11
xorl %edx, %edx
movl $0xff, %ebx
cmpq %r8, %rdx
jae 0x52c69f
xorl %ebp, %ebp
movq %rdx, %r14
leaq (%r11,%r14), %rax
addq $0x20, %rax
cmpq %rdi, %rax
jb 0x52c68c
movzbl 0x3(%r10,%r14), %r15d
movzbl (%r10,%r14), %r12d
movl %r15d, %ecx
subl %r12d, %ecx
movl %ecx, %r13d
negl %r13d
cmovsl %ecx, %r13d
andl %ebx, %r13d
movzbl %bpl, %eax
subl %r12d, %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
andl %ebx, %esi
addl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %esi, %r13d
ja 0x52c67e
cmpl %ecx, %r13d
jbe 0x52c68c
cmpl %ecx, %esi
ja 0x52c688
movzbl %r15b, %ebp
jmp 0x52c68c
movzbl %r12b, %ebp
subb (%r9), %bpl
incq %r9
movb %bpl, (%rdi,%r14)
addq $0x3, %r14
cmpq %r8, %r14
jb 0x52c630
incq %rdx
cmpq $0x3, %rdx
jne 0x52c626
movl 0x8(%rsp), %edx
addl $-0x2, %edx
movq 0x20(%rsp), %rsi
cmpl %edx, %esi
jae 0x52c6f8
leal 0x1(%rsi), %eax
movb (%rdi,%rax), %al
movl %esi, %ecx
addb %al, (%rdi,%rcx)
leal 0x2(%rsi), %ecx
addb %al, (%rdi,%rcx)
addl $0x3, %esi
jmp 0x52c6b8
movl 0x18(%rsi), %eax
cmpq $0x1e000, %rax # imm = 0x1E000
jbe 0x52c709
xorl %ebx, %ebx
jmp 0x52c74e
leaq 0x190a84(%rip), %rdx # 0x6bd16c
xorl %ebx, %ebx
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52c74e
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x44(%rax)
movl %ecx, 0x48(%rax)
jmp 0x52c749
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
je 0x52c743
leaq (%rdx,%rax), %r11
addq $0x20, %r11
addq $0x20, %rdx
xorl %edi, %edi
cmpl %eax, %edi
jae 0x52c73d
xorl %r8d, %r8d
movl %edi, %r9d
subb (%rdx), %r8b
incq %rdx
movl %r9d, %r10d
movb %r8b, (%r11,%r10)
addl %ecx, %r9d
cmpl %eax, %r9d
jb 0x52c728
incl %edi
cmpl %ecx, %edi
jne 0x52c71e
movl %eax, 0x44(%rsi)
movl %eax, 0x48(%rsi)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
ppmd_read
|
static Byte
ppmd_read(void *p)
{
struct archive_read *a = ((IByteIn*)p)->a;
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
Byte b;
if (!rar_br_read_ahead(a, br, 8))
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated RAR file data");
rar->valid = 0;
return 0;
}
b = rar_br_bits(br, 8);
rar_br_consume(br, 8);
return b;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r15
movl 0x4f38(%r15), %ecx
cmpl $0x7, %ecx
jg 0x52cb5f
leaq 0x4f30(%r15), %rsi
movq %rbx, %rdi
callq 0x52c83c
testl %eax, %eax
setne %al
movl 0x4f38(%r15), %ecx
cmpl $0x8, %ecx
setge %dl
orb %al, %dl
je 0x52cb75
movq 0x4f30(%r15), %r14
addl $-0x8, %ecx
shrq %cl, %r14
movl %ecx, 0x4f38(%r15)
jmp 0x52cb96
leaq 0x190543(%rip), %rdx # 0x6bd0bf
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movb $0x0, 0xd0(%r15)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
create_code
|
static int
create_code(struct archive_read *a, struct huffman_code *code,
unsigned char *lengths, int numsymbols, char maxlength)
{
int i, j, codebits = 0, symbolsleft = numsymbols;
code->numentries = 0;
code->numallocatedentries = 0;
if (new_node(code) < 0) {
archive_set_error(&a->archive, ENOMEM,
"Unable to allocate memory for node data.");
return (ARCHIVE_FATAL);
}
code->numentries = 1;
code->minlength = INT_MAX;
code->maxlength = INT_MIN;
codebits = 0;
for(i = 1; i <= maxlength; i++)
{
for(j = 0; j < numsymbols; j++)
{
if (lengths[j] != i) continue;
if (add_value(a, code, j, codebits, i) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
codebits++;
if (--symbolsleft <= 0)
break;
}
if (symbolsleft <= 0)
break;
codebits <<= 1;
}
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rsi)
movq %rsi, %rdi
callq 0x52cf2a
testl %eax, %eax
js 0x52cd31
movq %rbx, 0x8(%rsp)
movl $0x1, 0x8(%r15)
movabsq $-0x7fffffff80000001, %rax # imm = 0x800000007FFFFFFF
movq %rax, 0x10(%r15)
movl %ebp, %ecx
movl $0x1, (%rsp)
xorl %ebx, %ebx
movl $0x2, 0x4(%rsp)
movl %ebp, %edx
movl %ebp, 0x10(%rsp)
movq %r12, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
testl %ebp, %ebp
jle 0x52ccfb
xorl %r14d, %r14d
movzbl (%r12,%r14), %eax
movl (%rsp), %r13d
cmpl %eax, %r13d
jne 0x52ccef
movl %edx, 0x14(%rsp)
movq 0x20(%r15), %rdi
callq 0x41e70
movq $0x0, 0x20(%r15)
cmpl %r13d, 0x14(%r15)
jge 0x52cc4a
movl %r13d, 0x14(%r15)
cmpl %r13d, 0x10(%r15)
jle 0x52cc54
movl %r13d, 0x10(%r15)
movq (%r15), %rax
xorl %ecx, %ecx
movl 0x4(%rsp), %edx
movl %edx, %ebp
movslq %ecx, %r12
movl (%rax,%r12,8), %ecx
cmpl 0x4(%rax,%r12,8), %ecx
je 0x52cd1e
leal -0x2(%rbp), %ecx
leaq (%rax,%r12,8), %rdx
xorl %r13d, %r13d
btl %ecx, %ebx
setb %r13b
movl (%rdx,%r13,4), %ecx
testl %ecx, %ecx
jns 0x52ccb0
movq %r15, %rdi
callq 0x52cf2a
testl %eax, %eax
js 0x52cd3d
movl 0x8(%r15), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x8(%r15)
movq (%r15), %rax
leaq (%rax,%r12,8), %rdx
movl %ecx, (%rdx,%r13,4)
decl %ebp
cmpl $0x1, %ebp
ja 0x52cc5f
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,8)
movl 0x14(%rsp), %edx
jne 0x52cd1e
cmpl $-0x2, 0x4(%rax,%rcx,8)
jne 0x52cd1e
movl %r14d, (%rax,%rcx,8)
movl %r14d, 0x4(%rax,%rcx,8)
cmpl $0x2, %edx
jl 0x52cd69
incl %ebx
decl %edx
movl 0x10(%rsp), %ebp
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %rcx
incq %r14
cmpq %rcx, %r14
jne 0x52cc19
xorl %eax, %eax
testl %edx, %edx
jle 0x52cd5a
addl %ebx, %ebx
movl %edx, %esi
movl (%rsp), %edx
incl %edx
incl 0x4(%rsp)
movl %edx, (%rsp)
cmpl $0x10, %edx
movl %esi, %edx
jne 0x52cc0e
jmp 0x52cd5a
leaq 0x190531(%rip), %rdx # 0x6bd256
movq 0x8(%rsp), %rdi
movl $0x54, %esi
jmp 0x52cd4e
leaq 0x1904f5(%rip), %rdx # 0x6bd22d
movq %rbx, %rdi
jmp 0x52cd49
leaq 0x1904e9(%rip), %rdx # 0x6bd22d
movq 0x8(%rsp), %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x52cd5a
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
read_next_symbol
|
static int
read_next_symbol(struct archive_read *a, struct huffman_code *code)
{
unsigned char bit;
unsigned int bits;
int length, value, node;
struct rar *rar;
struct rar_br *br;
if (!code->table)
{
if (make_table(a, code) != (ARCHIVE_OK))
return -1;
}
rar = (struct rar *)(a->format->data);
br = &(rar->br);
/* Look ahead (peek) at bits */
if (!rar_br_read_ahead(a, br, code->tablesize)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated RAR file data");
rar->valid = 0;
return -1;
}
bits = rar_br_bits(br, code->tablesize);
length = code->table[bits].length;
value = code->table[bits].value;
if (length < 0)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid prefix code in bitstream");
return -1;
}
if (length <= code->tablesize)
{
/* Skip length bits */
rar_br_consume(br, length);
return value;
}
/* Skip tablesize bits */
rar_br_consume(br, code->tablesize);
node = value;
while (!(code->tree[node].branches[0] ==
code->tree[node].branches[1]))
{
if (!rar_br_read_ahead(a, br, 1)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated RAR file data");
rar->valid = 0;
return -1;
}
bit = rar_br_bits(br, 1);
rar_br_consume(br, 1);
if (code->tree[node].branches[bit] < 0)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid prefix code in bitstream");
return -1;
}
node = code->tree[node].branches[bit];
}
return code->tree[node].branches[0];
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rsi)
je 0x52ceb5
movq 0x818(%rbx), %rax
movq (%rax), %r12
leaq 0x4f30(%r12), %r15
movl 0x4f38(%r12), %edx
movl 0x18(%r14), %esi
cmpl %esi, %edx
jge 0x52cdf7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52c83c
testl %eax, %eax
sete %al
movl 0x4f38(%r12), %edx
movl 0x18(%r14), %esi
cmpl %esi, %edx
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x52cdf7
leaq 0x1902e5(%rip), %rdx # 0x6bd0bf
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movb $0x0, 0xd0(%r12)
jmp 0x52ceae
movq (%r15), %rax
movl %edx, %ecx
subl %esi, %ecx
shrq %cl, %rax
movslq %esi, %rdi
leaq 0x18fe15(%rip), %r8 # 0x6bcc20
andl (%r8,%rdi,4), %eax
movq 0x20(%r14), %r8
movl (%r8,%rax,8), %edi
testl %edi, %edi
js 0x52ce98
movl 0x4(%r8,%rax,8), %eax
cmpl %esi, %edi
jle 0x52cf11
movl %ecx, 0x4f38(%r12)
movq (%r14), %rdx
movslq %eax, %r13
movl (%rdx,%r13,8), %eax
cmpl 0x4(%rdx,%r13,8), %eax
je 0x52cf1b
testl %ecx, %ecx
jg 0x52ce6e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52c83c
testl %eax, %eax
setne %al
movl 0x4f38(%r12), %ecx
testl %ecx, %ecx
setg %dl
orb %al, %dl
je 0x52cdd3
movq 0x4f30(%r12), %rax
decl %ecx
xorl %esi, %esi
btq %rcx, %rax
setb %sil
movl %ecx, 0x4f38(%r12)
movq (%r14), %rdx
leaq (%rdx,%r13,8), %rax
movl (%rax,%rsi,4), %eax
testl %eax, %eax
jns 0x52ce33
leaq 0x1903c4(%rip), %rdx # 0x6bd263
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x52cf1b
movl 0x14(%r14), %eax
movl $0xa, %ecx
cmpl %ecx, %eax
movl $0xa, %ebp
cmovll %eax, %ebp
cmpl 0x10(%r14), %eax
cmovll %ecx, %ebp
movl %ebp, 0x18(%r14)
movl $0x8, %esi
movl %ebp, %ecx
shlq %cl, %rsi
movl $0x1, %edi
callq 0x41eb8
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x52cf96
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x52cf1b
jmp 0x52cd89
subl %edi, %edx
movl %edx, 0x4f38(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
rar_decode_byte
|
static int
rar_decode_byte(struct archive_read *a, uint8_t *byte)
{
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
if (!rar_br_read_ahead(a, br, 8))
return 0;
*byte = (uint8_t)rar_br_bits(br, 8);
rar_br_consume(br, 8);
return 1;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movl 0x4f38(%r14), %ecx
cmpl $0x7, %ecx
jg 0x52d12b
leaq 0x4f30(%r14), %rsi
callq 0x52c83c
testl %eax, %eax
setne %al
movl 0x4f38(%r14), %ecx
cmpl $0x8, %ecx
setge %dl
orb %al, %dl
xorl %eax, %eax
cmpb $0x1, %dl
jne 0x52d147
movq 0x4f30(%r14), %rax
addb $-0x8, %cl
shrq %cl, %rax
movb %al, (%rbx)
addl $-0x8, 0x4f38(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
delete_program_code
|
static void
delete_program_code(struct rar_program_code *prog)
{
while (prog)
{
struct rar_program_code *next = prog->next;
free(prog->staticdata);
free(prog->globalbackup);
free(prog);
prog = next;
}
}
|
testq %rdi, %rdi
je 0x52d455
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x30(%rbx), %r14
callq 0x41e70
movq 0x10(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
movq %r14, %rbx
testq %r14, %r14
jne 0x52d429
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c
|
archive_read_support_format_rar5
|
int archive_read_support_format_rar5(struct archive *_a) {
struct archive_read* ar;
int ret;
struct rar5* rar;
if(ARCHIVE_OK != (ret = get_archive_read(_a, &ar)))
return ret;
rar = malloc(sizeof(*rar));
if(rar == NULL) {
archive_set_error(&ar->archive, ENOMEM,
"Can't allocate rar5 data");
return ARCHIVE_FATAL;
}
if(ARCHIVE_OK != rar5_init(rar)) {
archive_set_error(&ar->archive, ENOMEM,
"Can't allocate rar5 filter buffer");
free(rar);
return ARCHIVE_FATAL;
}
ret = __archive_read_register_format(ar,
rar,
"rar5",
rar5_bid,
rar5_options,
rar5_read_header,
rar5_read_data,
rar5_read_data_skip,
rar5_seek_data,
rar5_cleanup,
rar5_capabilities,
rar5_has_encrypted_entries);
if(ret != ARCHIVE_OK) {
(void) rar5_cleanup(ar);
}
return ret;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18ff5e(%rip), %rcx # 0x6bd3cb
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x52d572
movl $0x1, %edi
movl $0x5330, %esi # imm = 0x5330
callq 0x41eb8
testq %rax, %rax
je 0x52d538
movq %rax, %r14
movw $0x1fff, 0x4b3c(%rax) # imm = 0x1FFF
movl $0x10000, %edi # imm = 0x10000
callq 0x41ec0
movq %rax, 0x4b40(%r14)
testq %rax, %rax
je 0x52d550
leaq 0x197e(%rip), %rax # 0x52ee4d
leaq 0x1974(%rip), %r10 # 0x52ee4a
leaq 0x1905(%rip), %r11 # 0x52ede2
leaq 0x18f6(%rip), %r15 # 0x52edda
leaq 0x1879(%rip), %r12 # 0x52ed64
leaq 0x327(%rip), %r13 # 0x52d819
leaq 0x18feee(%rip), %rdx # 0x6bd3e7
leaq 0x83(%rip), %rcx # 0x52d583
leaq 0x194(%rip), %r8 # 0x52d69b
leaq 0x193(%rip), %r9 # 0x52d6a1
movq %rbx, %rdi
movq %r14, %rsi
pushq %rax
pushq %r10
pushq %r11
pushq %r15
pushq %r12
pushq %r13
callq 0x511964
addq $0x30, %rsp
testl %eax, %eax
je 0x52d570
movl %eax, %ebp
movq %rbx, %rdi
callq 0x52ede2
jmp 0x52d572
leaq 0x18fe51(%rip), %rdx # 0x6bd390
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52d572
leaq 0x18fe52(%rip), %rdx # 0x6bd3a9
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movq %r14, %rdi
callq 0x41e70
jmp 0x52d572
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
rar5_read_data
|
static int rar5_read_data(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset) {
int ret;
struct rar5* rar = get_context(a);
if (size)
*size = 0;
if(rar->file.dir > 0) {
/* Don't process any data if this file entry was declared
* as a directory. This is needed, because entries marked as
* directory doesn't have any dictionary buffer allocated, so
* it's impossible to perform any decompression. */
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Can't decompress an entry marked as a directory");
return ARCHIVE_FAILED;
}
if(!rar->skip_mode && (rar->cstate.last_write_ptr > rar->file.unpacked_size)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Unpacker has written too many bytes");
return ARCHIVE_FATAL;
}
ret = use_data(rar, buff, size, offset);
if(ret == ARCHIVE_OK) {
return ret;
}
if(rar->file.eof == 1) {
return ARCHIVE_EOF;
}
ret = do_unpack(a, rar, buff, size, offset);
if(ret != ARCHIVE_OK) {
return ret;
}
if(rar->file.bytes_remaining == 0 &&
rar->cstate.last_write_ptr == rar->file.unpacked_size)
{
/* If all bytes of current file were processed, run
* finalization.
*
* Finalization will check checksum against proper values. If
* some of the checksums will not match, we'll return an error
* value in the last `archive_read_data` call to signal an error
* to the user. */
rar->file.eof = 1;
return verify_global_checksums(a);
}
return ARCHIVE_OK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rcx, %r8
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x818(%rdi), %rcx
movq (%rcx), %r14
testq %rax, %rax
je 0x52d84c
movq $0x0, (%rax)
movb 0x4bc8(%r14), %cl
testb $0x8, %cl
jne 0x52d889
cmpl $0x0, 0x8(%r14)
jne 0x52d8a6
movq 0x78(%r14), %rsi
cmpq 0x4bb0(%r14), %rsi
jle 0x52d8a6
leaq 0x18fe8a(%rip), %rdx # 0x6bd6fd
movq %rbx, %rdi
movl $0x16, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x52d8f4
leaq 0x18fe3d(%rip), %rdx # 0x6bd6cd
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %ebp # imm = 0xFFFFFFE7
jmp 0x52d8f4
cmpb $0x0, 0x4b68(%r14)
je 0x52d8b9
addq $0x4b68, %r14 # imm = 0x4B68
jmp 0x52d8ca
cmpb $0x0, 0x4b88(%r14)
je 0x52d908
addq $0x4b88, %r14 # imm = 0x4B88
testq %rdx, %rdx
je 0x52d8d6
movq 0x8(%r14), %rcx
movq %rcx, (%rdx)
testq %rax, %rax
je 0x52d8e2
movq 0x10(%r14), %rcx
movq %rcx, (%rax)
testq %r8, %r8
je 0x52d8ee
movq 0x18(%r14), %rax
movq %rax, (%r8)
movb $0x0, (%r14)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebp
testb $0x4, %cl
jne 0x52d8f4
testb $0x2, %cl
jne 0x52e7aa
movl 0x40(%r14), %ecx
leal -0x1(%rcx), %esi
cmpl $0x5, %esi
jae 0x52e7a6
movq %rbx, 0x30(%rsp)
movq 0x818(%rbx), %rax
movq (%rax), %r13
movb 0x38(%r13), %al
testb $0x1, %al
jne 0x52d9e8
testb $0x1, 0x2c(%r13)
movq 0x50(%r13), %rdi
je 0x52d95c
testq %rdi, %rdi
jne 0x52d9e2
xorl %edi, %edi
movl $0x0, 0x4bf0(%r13)
movq 0x48(%r13), %rax
subq $0x1, %rax
movl $0x0, %ecx
cmovbq %rcx, %rax
movq %rax, 0x68(%r13)
callq 0x41e70
movq 0x58(%r13), %rdi
callq 0x41e70
movq 0x48(%r13), %r12
movl $0x0, %r15d
movl $0x0, %eax
testq %r12, %r12
jle 0x52d9bb
movl $0x1, %edi
movq %r12, %rsi
callq 0x41eb8
movq %rax, %r15
movl $0x1, %edi
movq %r12, %rsi
callq 0x41eb8
movq %r15, 0x50(%r13)
movq %rax, 0x58(%r13)
leaq 0x9c(%r13), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r13)
movl $0x4a9c, %edx # imm = 0x4A9C
xorl %esi, %esi
callq 0x3fa90
movb 0x38(%r13), %al
orb $0x1, %al
movb %al, 0x38(%r13)
cmpq $0x0, 0x48(%r13)
je 0x52e834
testb $0x2, %al
jne 0x52da8b
movq 0x818(%rbx), %rax
movq (%rax), %r15
movb 0x38(%r15), %al
movl %eax, %ecx
andb $-0x3, %cl
movb %cl, 0x38(%r15)
cmpw $0x0, 0x4b3e(%r15)
je 0x52da4f
movzwl 0x4b38(%r15), %ecx
movq 0x4b40(%r15), %rdx
movq (%rdx,%rcx,8), %r12
movq 0x70(%r15), %rdx
movq 0x10(%r12), %rcx
cmpq %rcx, %rdx
jle 0x52da4f
movq 0x18(%r12), %rsi
addq %rcx, %rsi
cmpq %rsi, %rdx
jge 0x52e8b8
orb $0x2, %al
movb %al, 0x38(%r15)
cmpw $0x0, 0x4b3e(%r13)
je 0x52e785
movzwl 0x4b38(%r13), %eax
movq 0x4b40(%r13), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
movq 0x70(%r13), %r15
cmpq %r15, %rax
cmovlq %rax, %r15
jmp 0x52e789
movq %r13, 0x10(%rsp)
movq 0x818(%rbx), %rax
movq (%rax), %r12
testb $0x2, 0x2c(%r12)
je 0x52daad
cmpq $0x0, 0x4ba8(%r12)
je 0x52db22
testb $0x8, 0x38(%r12)
movq %r12, 0x18(%rsp)
jne 0x52dac4
movq 0x60(%r12), %rbp
jmp 0x52dd46
movq $-0x1, 0x90(%rsp)
movl $0x6, %esi
movq %rbx, %rdi
leaq 0x90(%rsp), %rdx
callq 0x511af8
testq %rax, %rax
je 0x52d8f4
movzwl (%rax), %ecx
movw %cx, 0x5328(%r12)
movl %ecx, %edx
shrb $0x3, %dl
andb $0x7, %dl
movzbl %dl, %r8d
cmpb $0x3, %dl
jae 0x52e848
movl %ecx, %esi
cmpb $0x2, %dl
je 0x52db37
cmpl $0x1, %r8d
jne 0x52db42
movzwl 0x2(%rax), %edi
jmp 0x52db46
movq %rbx, %rdi
callq 0x53063f
testl %eax, %eax
jne 0x52e768
jmp 0x52daad
movl 0x2(%rax), %edi
andl $0xffffff, %edi # imm = 0xFFFFFF
jmp 0x52db46
movzbl 0x2(%rax), %edi
shrl $0x8, %ecx
xorb $0x5a, %sil
movzbl %sil, %eax
movl %edi, %esi
shrl $0x8, %esi
xorl %eax, %esi
movl %edi, %eax
shrl $0x10, %eax
xorl %edi, %eax
xorl %esi, %eax
movzbl %al, %r8d
cmpl %ecx, %r8d
jne 0x52e866
movq %rdi, 0x28(%rsp)
addb $0x3, %dl
movzbl %dl, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x511e26
cmpq %r15, %rax
jne 0x52d8f4
movq 0x4ba8(%r12), %rax
subq %r15, %rax
movq %rax, 0x4ba8(%r12)
movq 0x28(%rsp), %r15
cmpq %rax, %r15
jle 0x52dcdd
movq 0x818(%rbx), %rax
movq (%rax), %r13
cmpl $0x0, 0xc(%r13)
jne 0x52e898
orb $0x4, 0x38(%r13)
movq 0x5320(%r13), %rdi
testq %rdi, %rdi
je 0x52dbda
callq 0x41e70
leaq 0x8(%r15), %rdi
callq 0x41ec0
movq %rax, 0x5320(%r13)
testq %rax, %rax
je 0x52e8a4
movq $0x0, (%rax,%r15)
movq 0x4ba8(%r13), %rbx
cmpq %r15, %rbx
cmovgeq %r15, %rbx
testq %rbx, %rbx
je 0x52e815
xorl %r12d, %r12d
movq $-0x1, 0x90(%rsp)
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
leaq 0x90(%rsp), %rdx
callq 0x511af8
testq %rax, %rax
je 0x52e7fa
leaq (%rbx,%r12), %rbp
cmpq %rbp, %r15
jl 0x52e823
addq 0x5320(%r13), %r12
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3f250
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x511e26
cmpq %rbx, %rax
jne 0x52e7fa
movq 0x4ba8(%r13), %rcx
movq %rcx, %rax
subq %rbx, %rax
movq %rax, 0x4ba8(%r13)
subq %rbp, %r15
je 0x52e6b1
cmpq %rbx, %rcx
jne 0x52dcbd
incl 0xc(%r13)
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x53063f
decl 0xc(%r13)
testl %eax, %eax
jne 0x52e75e
movq 0x4ba8(%r13), %rax
cmpq %r15, %rax
cmovlq %rax, %r15
movq %r15, %rbx
movq %rbp, %r12
testq %r15, %r15
movq 0x28(%rsp), %r15
jne 0x52dc15
jmp 0x52e815
andb $-0x5, 0x38(%r12)
leaq 0x4(%r15), %rsi
movq $-0x1, 0x90(%rsp)
movq %rbx, %rdi
leaq 0x90(%rsp), %rdx
callq 0x511af8
testq %rax, %rax
je 0x52d8f4
movq %rax, 0x60(%r12)
movq %r15, 0x90(%r12)
andb $-0x9, 0x38(%r12)
movl $0x0, 0x5314(%r12)
movb $0x0, 0x5310(%r12)
cmpb $0x0, 0x5328(%r12)
movq %rax, %rbp
js 0x52e323
movq 0x818(%rbx), %rax
movq (%rax), %r13
movq 0x48(%r13), %rax
movq 0x70(%r13), %rcx
subq 0x78(%r13), %rcx
sarq %rax
cmpq %rax, %rcx
jg 0x52e2b2
movq 0x68(%r13), %rax
movq %rax, 0x20(%rsp)
movb 0x5328(%r13), %al
andb $0x7, %al
movb %al, 0x28(%rsp)
leaq 0xf88(%r13), %r15
leaq 0x3c4c(%r13), %rax
movq %rax, 0x48(%rsp)
leaq 0x1e74(%r13), %rax
movq %rax, 0x50(%rsp)
leaq 0x2d60(%r13), %rax
movq %rax, 0x88(%rsp)
movq %r15, 0x38(%rsp)
movslq 0x5314(%r13), %rax
movq 0x90(%r13), %rcx
cmpq %rax, %rcx
jle 0x52e2ad
decq %rcx
cmpq %rax, %rcx
jne 0x52dde1
movb 0x28(%rsp), %al
cmpb %al, 0x5310(%r13)
jg 0x52e2ad
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x46(%rsp), %rcx
callq 0x5309be
testl %eax, %eax
jne 0x52e693
movzwl 0x46(%rsp), %eax
cmpq $0xff, %rax
ja 0x52de2d
movq 0x50(%r13), %rcx
movq 0x70(%r13), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x70(%r13)
addq 0x88(%r13), %rdx
andq 0x20(%rsp), %rdx
movb %al, (%rcx,%rdx)
jmp 0x52e293
cmpl $0x106, %eax # imm = 0x106
jb 0x52de8b
addl $0xfffffefa, %eax # imm = 0xFFFFFEFA
movzwl %ax, %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x530b0b
cmpl $-0x1, %eax
je 0x52e6ee
movl %eax, %r15d
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %rbp, %rdx
leaq 0x60(%rsp), %rcx
callq 0x5309be
testl %eax, %eax
jne 0x52e6cc
movzwl 0x60(%rsp), %r12d
cmpl $0x3, %r12d
ja 0x52e066
incl %r12d
jmp 0x52e21c
cmpq $0x101, %rax # imm = 0x101
je 0x52e129
cmpl $0x100, %eax # imm = 0x100
jne 0x52e15b
movq 0x818(%rbx), %rax
movq (%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x90(%rsp), %rcx
callq 0x530c15
testl %eax, %eax
jne 0x52e75e
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x60(%rsp), %rcx
callq 0x530c15
testl %eax, %eax
jne 0x52e75e
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0xe(%rsp), %rcx
callq 0x530aae
testl %eax, %eax
jne 0x52e75e
movzwl 0xe(%rsp), %edi
movsbl 0x5310(%r15), %eax
addl $0x3, %eax
movl %eax, %ecx
sarl $0x3, %ecx
addl %ecx, 0x5314(%r15)
andb $0x7, %al
movb %al, 0x5310(%r15)
movl 0x60(%rsp), %r8d
leal -0x400001(%r8), %eax
cmpl $0xffc00003, %eax # imm = 0xFFC00003
jb 0x52e6ff
testw %di, %di
js 0x52e6ff
movl 0x90(%rsp), %r9d
movq 0x4b48(%r15), %rax
movq 0x4b50(%r15), %rcx
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0x52df80
movq 0x70(%r15), %rdx
addq %r9, %rdx
addq %rax, %rcx
cmpq %rcx, %rdx
jl 0x52e6ff
movq %r9, 0x78(%rsp)
movq %r8, 0x80(%rsp)
movl %edi, 0x5c(%rsp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x41eb8
testq %rax, %rax
je 0x52e710
movq %rax, %r12
movzwl 0x4b3e(%r15), %eax
movzwl 0x4b3c(%r15), %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %edx
je 0x52dfec
movq 0x4b40(%r15), %rdx
movzwl 0x4b3a(%r15), %esi
movq %r12, (%rdx,%rsi,8)
incl %esi
andl %esi, %ecx
movw %cx, 0x4b3a(%r15)
incl %eax
movw %ax, 0x4b3e(%r15)
movl 0x5c(%rsp), %ecx
movl %ecx, %eax
shrl $0xd, %eax
movl %eax, (%r12)
movq 0x78(%rsp), %rdx
addq 0x70(%r15), %rdx
movq %rdx, 0x10(%r12)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%r12)
movq %rdx, 0x4b48(%r15)
movq %rax, 0x4b50(%r15)
movzwl %cx, %eax
cmpl $0x1fff, %eax # imm = 0x1FFF
ja 0x52e057
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movl $0x5, %ecx
leaq 0x40(%rsp), %r8
callq 0x530b55
testl %eax, %eax
jne 0x52e75e
movl 0x40(%rsp), %eax
incl %eax
movl %eax, 0x4(%r12)
movq 0x18(%rsp), %r12
movq 0x38(%rsp), %r15
jmp 0x52e293
movl %r12d, %edx
shrl %edx
leal -0x1(%rdx), %ecx
andl $0x1, %r12d
orl $0x2, %r12d
shll %cl, %r12d
incl %r12d
cmpl $0x4, %ecx
jb 0x52e1f6
je 0x52e0e6
movslq 0x5314(%r13), %rdi
cmpq %rdi, 0x90(%r13)
jle 0x52e743
movl (%rbp,%rdi), %r8d
bswapl %r8d
movsbl 0x5310(%r13), %eax
movl %eax, %ecx
shll %cl, %r8d
movzbl 0x4(%rbp,%rdi), %esi
movb $0x8, %cl
subb %al, %cl
shrl %cl, %esi
orl %r8d, %esi
addl %edx, %eax
addl $-0x5, %eax
movl %eax, %ecx
sarl $0x3, %ecx
addl %edi, %ecx
movl %ecx, 0x5314(%r13)
movb $0x25, %cl
subb %dl, %cl
shrl %cl, %esi
andb $0x7, %al
movb %al, 0x5310(%r13)
shll $0x4, %esi
addl %esi, %r12d
movq %rbx, %rdi
movq 0x88(%rsp), %rsi
movq %rbp, %rdx
leaq 0x90(%rsp), %rcx
callq 0x5309be
testl %eax, %eax
jne 0x52e6cc
movzwl 0x90(%rsp), %eax
movl $0x7ffffffe, %ecx # imm = 0x7FFFFFFE
subl %eax, %ecx
cmpl %ecx, %r12d
jge 0x52e732
addl %eax, %r12d
jmp 0x52e21c
movl 0x98(%r13), %esi
testl %esi, %esi
je 0x52e293
movl 0x4b58(%r13), %edx
movq 0x818(%rbx), %rax
movq (%rax), %rdi
callq 0x530bba
testl %eax, %eax
je 0x52e293
jmp 0x52e759
movl $0xfffffefe, %ecx # imm = 0xFFFFFEFE
addl %eax, %ecx
movl 0x4b58(%r13,%rcx,4), %r15d
cmpl $0x103, %eax # imm = 0x103
jb 0x52e18e
movl 0x4b54(%r13,%rcx,4), %eax
movl %eax, 0x4b58(%r13,%rcx,4)
leaq -0x1(%rcx), %rax
cmpq $0x1, %rcx
movq %rax, %rcx
ja 0x52e171
movl %r15d, 0x4b58(%r13)
movq %rbx, %rdi
movq 0x48(%rsp), %rsi
movq %rbp, %rdx
leaq 0x90(%rsp), %rcx
callq 0x5309be
testl %eax, %eax
jne 0x52e759
movzwl 0x90(%rsp), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x530b0b
cmpl $-0x1, %eax
je 0x52e759
movl %eax, 0x98(%r13)
movq 0x818(%rbx), %rcx
movq (%rcx), %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0x530bba
testl %eax, %eax
jmp 0x52e288
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
leaq 0x90(%rsp), %r8
callq 0x530b55
testl %eax, %eax
jne 0x52e75e
addl 0x90(%rsp), %r12d
cmpl $0x101, %r12d # imm = 0x101
jl 0x52e242
cmpl $0x2001, %r12d # imm = 0x2001
jb 0x52e23f
cmpl $0x40001, %r12d # imm = 0x40001
sbbl $-0x1, %r15d
addl $0x2, %r15d
jmp 0x52e242
incl %r15d
movl 0x4b60(%r13), %eax
movl %eax, 0x4b64(%r13)
movq 0x4b58(%r13), %rax
movq %rax, 0x4b5c(%r13)
movl %r12d, 0x4b58(%r13)
movl %r15d, 0x98(%r13)
movq 0x818(%rbx), %rax
movq (%rax), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x530bba
testl %eax, %eax
movq 0x18(%rsp), %r12
movq 0x38(%rsp), %r15
jne 0x52e759
movq 0x48(%r13), %rax
movq 0x70(%r13), %rcx
subq 0x78(%r13), %rcx
sarq %rax
cmpq %rax, %rcx
jle 0x52ddb1
jmp 0x52e2b2
orb $0x8, 0x38(%r13)
movb 0x38(%r12), %al
movl %eax, %ecx
andb $0xc, %cl
cmpb $0x8, %cl
jne 0x52e305
movq 0x90(%r12), %r15
testq %r15, %r15
movl $0x1, %ebp
movq 0x10(%rsp), %r13
jle 0x52e772
movq %rbx, %rdi
movq %r15, %rsi
callq 0x511e26
cmpq %r15, %rax
jne 0x52d882
movq 0x90(%r12), %rax
subq %rax, 0x4ba8(%r12)
jmp 0x52e772
testb $0x4, %al
movl $0x1, %ebp
movq 0x10(%rsp), %r13
je 0x52e772
andb $-0x5, %al
movb %al, 0x38(%r12)
jmp 0x52e772
xorl %eax, %eax
movl $0xf0, %r13d
movb $0x4, %r8b
xorl %r12d, %r12d
movq %rbp, 0x20(%rsp)
movslq %r12d, %r12
cmpq %r12, %r15
jle 0x52e69d
movzbl (%rbp,%r12), %edx
andl %r13d, %edx
movl %r8d, %ecx
shrl %cl, %edx
movl $0xff, %esi
andl %esi, %r13d
xorl %ecx, %ecx
cmpl $0xf, %r13d
sete %cl
addl %ecx, %r12d
movq %rbp, %rdi
movl %r13d, %ebp
xorl %esi, %ebp
movl %r8d, %ecx
xorb $0x4, %cl
movslq %eax, %r15
cmpl $0xf, %edx
jne 0x52e3d9
movslq %r12d, %r12
movzbl (%rdi,%r12), %eax
andl %eax, %ebp
shrl %cl, %ebp
xorl %eax, %eax
cmpl $0xf0, %r13d
sete %al
addl %eax, %r12d
testl %ebp, %ebp
je 0x52e3ea
leaq (%rsp,%r15), %rdi
addq $0x60, %rdi
incl %ebp
movl $0x13, %edx
subl %r15d, %edx
cmpl %edx, %ebp
cmovbl %ebp, %edx
incl %edx
xorl %esi, %esi
movb %r8b, 0x38(%rsp)
callq 0x3fa90
movb 0x38(%rsp), %r8b
movl $0x13, %eax
subq %r15, %rax
cmpq %rbp, %rax
cmovaeq %rbp, %rax
addl %r15d, %eax
incl %eax
jmp 0x52e3f4
leal 0x1(%r15), %eax
movb %dl, 0x60(%rsp,%r15)
movl %ebp, %r13d
movl %ecx, %r8d
jmp 0x52e3f4
leal 0x1(%r15), %eax
movb $0xf, 0x60(%rsp,%r15)
cmpl $0x14, %eax
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %r15
jl 0x52e336
movq 0x18(%rsp), %rax
movl %r12d, 0x5314(%rax)
xorb $0x4, %r8b
movb %r8b, 0x5310(%rax)
leaq 0x9c(%rax), %r13
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
movl $0x14, %edx
callq 0x5307f1
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
leaq 0x40(%rsp), %rcx
callq 0x5309be
testl %eax, %eax
jne 0x52e6dd
movzwl 0x40(%rsp), %r12d
cmpw $0xf, %r12w
ja 0x52e47a
movslq %r15d, %rax
movb %r12b, 0x90(%rsp,%rax)
incl %r15d
movq 0x18(%rsp), %r12
jmp 0x52e619
movq %rbx, %rdi
cmpw $0x11, %r12w
ja 0x52e569
movq 0x18(%rsp), %rbp
movq %rbp, %rsi
movq 0x20(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x530aae
testl %eax, %eax
jne 0x52e75e
xorl %ecx, %ecx
cmpw $0x10, %r12w
setne %cl
movzwl 0xe(%rsp), %eax
movsbl 0x5310(%rbp), %edx
leal (%rdx,%rcx,4), %ecx
addl $0x3, %ecx
movl %ecx, %edx
sarl $0x3, %edx
addl %edx, 0x5314(%rbp)
andb $0x7, %cl
movb %cl, 0x5310(%rbp)
testl %r15d, %r15d
jle 0x52e721
cmpl $0x1ad, %r15d # imm = 0x1AD
ja 0x52e60f
xorl %edx, %edx
cmpw $0x10, %r12w
setne %dl
sete %cl
movzwl %ax, %esi
shlb $0x2, %cl
orb $0x9, %cl
shrl %cl, %esi
movl %r15d, %ecx
leaq (%rsp,%rcx), %rax
addq $0x90, %rax
movl $0xfffffefe, %edi # imm = 0xFFFFFEFE
addq %rdi, %rcx
addq $0x101, %rcx # imm = 0x101
leal (%rsi,%rdx,8), %edx
addl $0x2, %edx
xorl %esi, %esi
movq 0x18(%rsp), %r12
movq 0x20(%rsp), %rbp
movl %r15d, %edi
leal (%rcx,%rsi), %r8d
movb 0x90(%rsp,%r8), %r8b
movb %r8b, (%rax,%rsi)
leal 0x1(%rdi), %r15d
cmpl $0x1ac, %edi # imm = 0x1AC
jg 0x52e619
movq %rsi, %rdi
incq %rdi
cmpw %si, %dx
movq %rdi, %rsi
jne 0x52e533
jmp 0x52e619
movq 0x18(%rsp), %rbp
movq %rbp, %rsi
movq 0x20(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x530aae
testl %eax, %eax
jne 0x52e75e
xorl %eax, %eax
cmpw $0x12, %r12w
sete %cl
setne %al
movzwl 0xe(%rsp), %edx
shlb $0x2, %cl
orb $0x9, %cl
shrl %cl, %edx
movsbl 0x5310(%rbp), %ecx
leal (%rcx,%rax,4), %ecx
addl $0x3, %ecx
movl %ecx, %esi
sarl $0x3, %esi
addl %esi, 0x5314(%rbp)
andb $0x7, %cl
movb %cl, 0x5310(%rbp)
leal (%rdx,%rax,8), %ebx
addl $0x2, %ebx
movslq %r15d, %r15
leaq (%rsp,%r15), %rdi
addq $0x90, %rdi
movl $0x1ad, %edx # imm = 0x1AD
subl %r15d, %edx
cmpq %rbx, %rdx
cmovaeq %rbx, %rdx
incq %rdx
xorl %esi, %esi
callq 0x3fa90
movl $0x1ad, %eax # imm = 0x1AD
subq %r15, %rax
cmpq %rbx, %rax
cmovaeq %rbx, %rax
movq 0x30(%rsp), %rbx
addl %eax, %r15d
incl %r15d
movq %rbp, %r12
jmp 0x52e614
movq 0x18(%rsp), %r12
movq 0x20(%rsp), %rbp
cmpl $0x1ae, %r15d # imm = 0x1AE
jl 0x52e43a
leaq 0xf88(%r12), %rsi
leaq 0x90(%rsp), %rdi
movl $0x132, %edx # imm = 0x132
callq 0x5307f1
leaq 0x1e74(%r12), %rsi
leaq 0x1c2(%rsp), %rdi
movl $0x40, %edx
callq 0x5307f1
leaq 0x2d60(%r12), %rsi
leaq 0x202(%rsp), %rdi
movl $0x10, %edx
callq 0x5307f1
leaq 0x3c4c(%r12), %rsi
leaq 0x212(%rsp), %rdi
movl $0x2c, %edx
callq 0x5307f1
jmp 0x52dd46
movl $0x1, %eax
jmp 0x52e75e
movq %rbx, %rdi
movl $0x54, %esi
leaq 0x18f1f0(%rip), %rdx # 0x6bd89c
jmp 0x52e752
movq 0x5320(%r13), %rax
movq 0x30(%rsp), %rbx
movq 0x18(%rsp), %r12
movq 0x28(%rsp), %r15
jmp 0x52dd0c
movq %rbx, %rdi
movl $0x16, %esi
leaq 0x18f287(%rip), %rdx # 0x6bd962
jmp 0x52e752
movq %rbx, %rdi
movl $0x54, %esi
leaq 0x18f1d1(%rip), %rdx # 0x6bd8bd
jmp 0x52e752
movq %rbx, %rdi
movl $0x16, %esi
leaq 0x18f244(%rip), %rdx # 0x6bd941
jmp 0x52e752
movq %rbx, %rdi
movl $0x54, %esi
leaq 0x18f2c8(%rip), %rdx # 0x6bd9d6
jmp 0x52e752
movq %rbx, %rdi
movl $0xc, %esi
leaq 0x18f2d2(%rip), %rdx # 0x6bd9f1
jmp 0x52e752
movq %rbx, %rdi
movl $0x54, %esi
leaq 0x18f1ac(%rip), %rdx # 0x6bd8dc
jmp 0x52e752
movq %rbx, %rdi
movl $0x54, %esi
leaq 0x18f244(%rip), %rdx # 0x6bd985
jmp 0x52e752
movq %rbx, %rdi
movl $0x16, %esi
leaq 0x18f24d(%rip), %rdx # 0x6bd99f
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
movl $0x1, %ebp
movq 0x10(%rsp), %r13
cmpl $-0x1e, %eax
je 0x52e79b
cmpl $0x1, %eax
je 0x52e79b
movq 0x78(%r13), %rax
cmpq 0x70(%r13), %rax
je 0x52da90
jmp 0x52d9fb
movq 0x70(%r13), %r15
movq 0x78(%r13), %rdx
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
cmpq %rdx, %r15
jne 0x52e881
cmpl $-0xa, %eax
je 0x52d930
jmp 0x52e7b8
testl %ecx, %ecx
jne 0x52e804
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x530504
movl %eax, %ebp
testl %eax, %eax
jne 0x52d8f4
xorl %ebp, %ebp
cmpq $0x0, 0x4ba8(%r14)
jne 0x52d8f4
movq 0x78(%r14), %rax
cmpq 0x4bb0(%r14), %rax
jne 0x52d8f4
orb $0x4, 0x4bc8(%r14)
movq %rbx, %rdi
callq 0x530445
movl %eax, %ebp
jmp 0x52d8f4
movl $0x1, %ebp
jmp 0x52d8f4
leaq 0x18ef16(%rip), %rdx # 0x6bd721
movq %rbx, %rdi
movl $0x54, %esi
jmp 0x52e85a
leaq 0x18f025(%rip), %rdx # 0x6bd841
movq 0x30(%rsp), %rdi
jmp 0x52e83e
leaq 0x18f046(%rip), %rdx # 0x6bd870
movq 0x30(%rsp), %rdi
jmp 0x52d876
leaq 0x18ef2b(%rip), %rdx # 0x6bd766
movq %rbx, %rdi
movl $0x54, %esi
jmp 0x52d87b
leaq 0x18ef44(%rip), %rdx # 0x6bd793
movq %rbx, %rdi
movl $0x54, %esi
movl %r8d, %ecx
xorl %eax, %eax
callq 0x53e204
jmp 0x52d882
leaq 0x18ef57(%rip), %rdx # 0x6bd7c4
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52d882
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x53074d
movq %r15, 0x78(%r13)
jmp 0x52e7c2
leaq 0x18ef53(%rip), %rdx # 0x6bd7f2
jmp 0x52d873
leaq 0x18ef66(%rip), %rdx # 0x6bd811
movq %rbx, %rdi
movl $0xc, %esi
jmp 0x52d87b
movq 0x78(%r15), %rdx
cmpq %rcx, %rdx
jne 0x52e987
movq 0x818(%rbx), %rax
movq (%rax), %r13
movq 0x58(%r13), %rdi
callq 0x41e70
movq 0x18(%r12), %rbp
movq %rbp, %rdi
callq 0x41ec0
movq %rax, 0x58(%r13)
testq %rax, %rax
je 0x52e997
movq %rax, %rdi
movl (%r12), %eax
movq %rax, 0x28(%rsp)
decl %eax
cmpl $0x2, %eax
jb 0x52e9a8
cmpl $0x3, 0x28(%rsp)
je 0x52ea05
cmpl $0x0, 0x28(%rsp)
jne 0x52ebbf
movl 0x4(%r12), %edx
testl %edx, %edx
jle 0x52ece5
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rbp
jle 0x52e977
xorl %esi, %esi
movq %rax, %rdi
movq 0x88(%r13), %rdx
addq 0x10(%r12), %rdx
addq %rcx, %rdx
andq 0x68(%r13), %rdx
movq 0x50(%r13), %r8
subb (%r8,%rdx), %sil
movq 0x58(%r13), %rdx
movb %sil, (%rdx,%rdi)
incq %rcx
movl 0x4(%r12), %edx
movslq %edx, %r8
addq %r8, %rdi
movq 0x18(%r12), %rbp
cmpq %rbp, %rdi
jl 0x52e93a
jmp 0x52e97a
movslq %edx, %r8
incq %rax
cmpq %r8, %rax
jl 0x52e930
jmp 0x52ece5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53074d
jmp 0x52e7c2
leaq 0x18f082(%rip), %rdx # 0x6bda20
movq 0x30(%rsp), %rdi
jmp 0x52e8ae
movq 0x50(%r13), %rax
movq 0x68(%r13), %rbx
movq 0x10(%r12), %rsi
addq 0x88(%r13), %rsi
leaq (%rsi,%rbp), %rcx
andq %rbx, %rsi
andq %rbx, %rcx
movq %rcx, 0x20(%rsp)
cmpq %rcx, %rsi
jbe 0x52ea65
subq %rsi, %rbx
leaq 0x1(%rbx), %rdx
movq %rax, 0x38(%rsp)
addq %rax, %rsi
movq %rdi, 0x18(%rsp)
callq 0x3f250
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rdi
incq %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
jmp 0x52ea6e
movq 0x50(%r13), %rax
movq 0x68(%r13), %rbx
movq 0x10(%r12), %rsi
addq 0x88(%r13), %rsi
leaq (%rsi,%rbp), %rcx
andq %rbx, %rsi
andq %rbx, %rcx
movq %rcx, 0x28(%rsp)
cmpq %rcx, %rsi
jbe 0x52ebda
subq %rsi, %rbx
leaq 0x1(%rbx), %rdx
movq %rax, 0x20(%rsp)
addq %rax, %rsi
movq %rdi, 0x18(%rsp)
callq 0x3f250
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rdi
incq %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
jmp 0x52ebe3
addq %rsi, %rax
movq %rax, %rsi
movq %rbp, %rdx
callq 0x3f250
cmpq $0x5, %rbp
jl 0x52ece5
xorl %ebx, %ebx
cmpl $0x2, 0x28(%rsp)
sete %al
movq 0x50(%r13), %r9
movq 0x68(%r13), %r10
movq 0x10(%r12), %r8
movq 0x88(%r13), %rdx
addq %r8, %rdx
leaq 0x1(%rbx), %rdi
leaq (%rdx,%rbx), %rcx
andq %r10, %rcx
movb (%r9,%rcx), %sil
cmpb $-0x17, %sil
sete %cl
cmpb $-0x18, %sil
je 0x52eac6
andb %cl, %al
jne 0x52eac6
movq %rdi, %rbx
jmp 0x52ebad
addq %rdi, %r8
leal 0xffffff(%r8), %eax
testq %r8, %r8
movq %r8, 0x18(%rsp)
cmovnsl %r8d, %eax
movl %eax, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
addq %rdi, %rdx
andq %r10, %rdx
movl %edx, %esi
addl $0x4, %edx
movl %r10d, %eax
andl %edx, %eax
movq %rax, 0x10(%rsp)
cmpq %rax, %rsi
jbe 0x52eb3c
subq %rsi, %r10
movq %r10, 0x48(%rsp)
leaq 0x1(%r10), %rdx
addq %r9, %rsi
leaq 0x90(%rsp), %rdi
movq %r9, 0x50(%rsp)
callq 0x3f250
movq 0x48(%rsp), %rax
leaq (%rsp,%rax), %rdi
addq $0x91, %rdi
movq 0x50(%rsp), %rsi
movq 0x10(%rsp), %rdx
jmp 0x52eb4d
addq %rsi, %r9
subq %rsi, %rdx
leaq 0x90(%rsp), %rdi
movq %r9, %rsi
callq 0x3f250
movl 0x20(%rsp), %eax
andl $0xff000000, %eax # imm = 0xFF000000
movq 0x18(%rsp), %rcx
subl %eax, %ecx
movl 0x90(%rsp), %eax
testl %eax, %eax
js 0x52eb7a
cmpl $0xffffff, %eax # imm = 0xFFFFFF
ja 0x52eba6
subl %ecx, %eax
movl %eax, %ecx
jmp 0x52eb84
addl %eax, %ecx
js 0x52eba6
leal 0x1000000(%rax), %ecx
movq 0x58(%r13), %rdx
movl 0x38(%rsp), %esi
movb %al, (%rdx,%rsi)
movb %ah, 0x1(%rdx,%rsi)
shrl $0x10, %eax
movb %al, 0x2(%rdx,%rsi)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx,%rsi)
movq 0x18(%r12), %rbp
addq $0x5, %rbx
movq %rbx, %rdi
leaq -0x4(%rbp), %rax
cmpq %rax, %rdi
jl 0x52ea7f
jmp 0x52ece5
leaq 0x18ee81(%rip), %rdx # 0x6bda47
movq 0x30(%rsp), %rdi
movl $0x54, %esi
movq 0x28(%rsp), %rcx
jmp 0x52e813
addq %rsi, %rax
movq %rax, %rsi
movq %rbp, %rdx
callq 0x3f250
cmpq $0x4, %rbp
jl 0x52ece5
xorl %ebx, %ebx
movq 0x50(%r13), %rsi
movq 0x68(%r13), %rdi
movq 0x10(%r12), %rax
movq 0x88(%r13), %rdx
movq %rax, 0x28(%rsp)
addq %rax, %rdx
leaq (%rbx,%rdx), %rax
addq $0x3, %rax
andq %rdi, %rax
cmpb $-0x15, (%rsi,%rax)
jne 0x52ecd4
movq %rsi, %rcx
addq %rbx, %rdx
andq %rdi, %rdx
movl %edx, %esi
addl $0x4, %edx
movl %edi, %ebp
andl %edx, %ebp
cmpq %rbp, %rsi
jbe 0x52ec7a
movq %rdi, %rax
subq %rsi, %rax
movq %rax, 0x20(%rsp)
leaq 0x1(%rax), %rdx
movq %rcx, 0x18(%rsp)
addq %rcx, %rsi
leaq 0x90(%rsp), %rdi
callq 0x3f250
movq 0x20(%rsp), %rax
leaq (%rsp,%rax), %rdi
addq $0x91, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
jmp 0x52ec8e
movq %rcx, %rax
addq %rsi, %rax
subq %rsi, %rdx
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x3f250
movq 0x28(%rsp), %rax
addq %rbx, %rax
leaq 0x3(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
movl 0x90(%rsp), %eax
shrq $0x2, %rcx
subl %ecx, %eax
movq 0x58(%r13), %rcx
movl %ebx, %edx
andl $-0x4, %edx
movb %al, (%rcx,%rdx)
movb %ah, 0x1(%rcx,%rdx)
shrl $0x10, %eax
movb %al, 0x2(%rcx,%rdx)
movb $-0x15, 0x3(%rcx,%rdx)
movq 0x18(%r12), %rbp
addq $0x4, %rbx
leaq -0x3(%rbp), %rax
cmpq %rax, %rbx
jl 0x52ebf4
movq 0x58(%r13), %rdx
movq 0x78(%r13), %r8
movq 0x30(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rcx
callq 0x530cca
testl %eax, %eax
je 0x52ed0d
leaq 0x18ed5d(%rip), %rdx # 0x6bda65
jmp 0x52e82a
movq 0x18(%r12), %rax
addq %rax, 0x78(%r13)
movzwl 0x4b3e(%r15), %eax
testw %ax, %ax
je 0x52ed52
movq 0x4b40(%r15), %rcx
movzwl 0x4b38(%r15), %edx
movq (%rcx,%rdx,8), %r12
incl %edx
andw 0x4b3c(%r15), %dx
movw %dx, 0x4b38(%r15)
decl %eax
movw %ax, 0x4b3e(%r15)
movq %r12, %rdi
callq 0x41e70
movq 0x30(%rsp), %rbx
jmp 0x52e7c2
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
rar5_read_data_skip
|
static int rar5_read_data_skip(struct archive_read *a) {
struct rar5* rar = get_context(a);
if(rar->main.solid) {
/* In solid archives, instead of skipping the data, we need to
* extract it, and dispose the result. The side effect of this
* operation will be setting up the initial window buffer state
* needed to be able to extract the selected file. */
int ret;
/* Make sure to process all blocks in the compressed stream. */
while(rar->file.bytes_remaining > 0) {
/* Setting the "skip mode" will allow us to skip
* checksum checks during data skipping. Checking the
* checksum of skipped data isn't really necessary and
* it's only slowing things down.
*
* This is incremented instead of setting to 1 because
* this data skipping function can be called
* recursively. */
rar->skip_mode++;
/* We're disposing 1 block of data, so we use triple
* NULLs in arguments. */
ret = rar5_read_data(a, NULL, NULL, NULL);
/* Turn off "skip mode". */
rar->skip_mode--;
if(ret < 0 || ret == ARCHIVE_EOF) {
/* Propagate any potential error conditions
* to the caller. */
return ret;
}
}
} else {
/* In standard archives, we can just jump over the compressed
* stream. Each file in non-solid archives starts from an empty
* window buffer. */
if(ARCHIVE_OK != consume(a, rar->file.bytes_remaining)) {
return ARCHIVE_FATAL;
}
rar->file.bytes_remaining = 0;
}
return ARCHIVE_OK;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
testb $0x1, 0x2c(%r15)
jne 0x52edaf
movq 0x4ba8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x511e26
movq %rax, %rcx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpq %r14, %rcx
jne 0x52eda9
movq $0x0, 0x4ba8(%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x4ba8(%r15)
jle 0x52eda7
incl 0x8(%r15)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52d819
decl 0x8(%r15)
testl %eax, %eax
js 0x52eda9
cmpl $0x1, %eax
jne 0x52edaf
jmp 0x52eda9
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
rar5_cleanup
|
static int rar5_cleanup(struct archive_read *a) {
struct rar5* rar = get_context(a);
free(rar->cstate.window_buf);
free(rar->cstate.filtered_buf);
free(rar->vol.push_buf);
free_filters(rar);
cdeque_free(&rar->cstate.filters);
free(rar);
a->format->data = NULL;
return ARCHIVE_OK;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x50(%r14), %rdi
callq 0x41e70
movq 0x58(%r14), %rdi
callq 0x41e70
movq 0x5320(%r14), %rdi
callq 0x41e70
movq %r14, %rdi
callq 0x53033e
movq 0x4b40(%r14), %rdi
testq %rdi, %rdi
je 0x52ee2a
callq 0x41e70
movq %r14, %rdi
callq 0x41e70
movq 0x818(%rbx), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
process_base_block
|
static int process_base_block(struct archive_read* a,
struct archive_entry* entry)
{
const size_t SMALLEST_RAR5_BLOCK_SIZE = 3;
struct rar5* rar = get_context(a);
uint32_t hdr_crc, computed_crc;
size_t raw_hdr_size = 0, hdr_size_len, hdr_size;
size_t header_id = 0;
size_t header_flags = 0;
const uint8_t* p;
int ret;
enum HEADER_TYPE {
HEAD_MARK = 0x00, HEAD_MAIN = 0x01, HEAD_FILE = 0x02,
HEAD_SERVICE = 0x03, HEAD_CRYPT = 0x04, HEAD_ENDARC = 0x05,
HEAD_UNKNOWN = 0xff,
};
/* Skip any unprocessed data for this file. */
ret = skip_unprocessed_bytes(a);
if(ret != ARCHIVE_OK)
return ret;
/* Read the expected CRC32 checksum. */
if(!read_u32(a, &hdr_crc)) {
return ARCHIVE_EOF;
}
/* Read header size. */
if(!read_var_sized(a, &raw_hdr_size, &hdr_size_len)) {
return ARCHIVE_EOF;
}
hdr_size = raw_hdr_size + hdr_size_len;
/* Sanity check, maximum header size for RAR5 is 2MB. */
if(hdr_size > (2 * 1024 * 1024)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Base block header is too large");
return ARCHIVE_FATAL;
}
/* Additional sanity checks to weed out invalid files. */
if(raw_hdr_size == 0 || hdr_size_len == 0 ||
hdr_size < SMALLEST_RAR5_BLOCK_SIZE)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Too small block encountered (%zu bytes)",
raw_hdr_size);
return ARCHIVE_FATAL;
}
/* Read the whole header data into memory, maximum memory use here is
* 2MB. */
if(!read_ahead(a, hdr_size, &p)) {
return ARCHIVE_EOF;
}
/* Verify the CRC32 of the header data. */
computed_crc = (uint32_t) crc32(0, p, (int) hdr_size);
if(computed_crc != hdr_crc) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Header CRC error");
return ARCHIVE_FATAL;
}
/* If the checksum is OK, we proceed with parsing. */
if(ARCHIVE_OK != consume(a, hdr_size_len)) {
return ARCHIVE_EOF;
}
if(!read_var_sized(a, &header_id, NULL))
return ARCHIVE_EOF;
if(!read_var_sized(a, &header_flags, NULL))
return ARCHIVE_EOF;
rar->generic.split_after = (header_flags & HFL_SPLIT_AFTER) > 0;
rar->generic.split_before = (header_flags & HFL_SPLIT_BEFORE) > 0;
rar->generic.size = (int)hdr_size;
rar->generic.last_header_id = (int)header_id;
rar->main.endarc = 0;
/* Those are possible header ids in RARv5. */
switch(header_id) {
case HEAD_MAIN:
ret = process_head_main(a, rar, entry, header_flags);
/* Main header doesn't have any files in it, so it's
* pointless to return to the caller. Retry to next
* header, which should be HEAD_FILE/HEAD_SERVICE. */
if(ret == ARCHIVE_OK)
return ARCHIVE_RETRY;
return ret;
case HEAD_SERVICE:
ret = process_head_service(a, rar, entry, header_flags);
return ret;
case HEAD_FILE:
ret = process_head_file(a, rar, entry, header_flags);
return ret;
case HEAD_CRYPT:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Encryption is not supported");
return ARCHIVE_FATAL;
case HEAD_ENDARC:
rar->main.endarc = 1;
/* After encountering an end of file marker, we need
* to take into consideration if this archive is
* continued in another file (i.e. is it part01.rar:
* is there a part02.rar?) */
if(rar->main.volume) {
/* In case there is part02.rar, position the
* read pointer in a proper place, so we can
* resume parsing. */
ret = scan_for_signature(a);
if(ret == ARCHIVE_FATAL) {
return ARCHIVE_EOF;
} else {
if(rar->vol.expected_vol_no ==
UINT_MAX) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Header error");
return ARCHIVE_FATAL;
}
rar->vol.expected_vol_no =
rar->main.vol_no + 1;
return ARCHIVE_OK;
}
} else {
return ARCHIVE_EOF;
}
case HEAD_MARK:
return ARCHIVE_EOF;
default:
if((header_flags & HFL_SKIP_IF_UNKNOWN) == 0) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Header type error");
return ARCHIVE_FATAL;
} else {
/* If the block is marked as 'skip if unknown',
* do as the flag says: skip the block
* instead on failing on it. */
return ARCHIVE_RETRY;
}
}
#if !defined WIN32
// Not reached.
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Internal unpacker error");
return ARCHIVE_FATAL;
#endif
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x4ba8(%r14), %r12
testq %r12, %r12
je 0x52eebc
cmpl $0x0, 0xc(%r14)
je 0x52eeaa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x511e26
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpq %r12, %rax
jne 0x52ef4f
movq $0x0, 0x4ba8(%r14)
jmp 0x52eebc
movq %rbx, %rdi
callq 0x52ed64
movl %eax, %ebp
testl %eax, %eax
jne 0x52ef4f
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x52f0d2
movl $0x1, %ebp
testl %eax, %eax
je 0x52ef4f
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x52f892
testl %eax, %eax
je 0x52ef4f
movq (%rsp), %rcx
movq 0x10(%rsp), %r13
leaq (%rcx,%r13), %r12
cmpq $0x200001, %r12 # imm = 0x200001
jb 0x52ef1b
leaq 0x18e4e7(%rip), %rdx # 0x6bd3f1
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52ef4a
testq %rcx, %rcx
setne %al
testq %r13, %r13
setne %dl
andb %al, %dl
cmpq $0x3, %r12
setae %al
testb %al, %dl
jne 0x52ef60
leaq 0x18e4d5(%rip), %rdx # 0x6bd410
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdx
movq $-0x1, (%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x511af8
testq %rax, %rax
je 0x52ef4f
xorl %edi, %edi
movq %rax, %rsi
movl %r12d, %edx
callq 0x62f0bd
cmpl %eax, 0xc(%rsp)
jne 0x52f038
movq %rbx, %rdi
movq %r13, %rsi
callq 0x511e26
cmpq %r13, %rax
jne 0x52ef4f
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52ef4f
movq %rsp, %rsi
movq (%rsi), %r13
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52ef4f
movq (%rsp), %rcx
movl %ecx, %edx
shrb $0x4, %dl
andb $0x1, %dl
movb 0x20(%r14), %sil
movb 0x2c(%r14), %al
andb $-0x4, %sil
orb %dl, %sil
movl %ecx, %edx
shrb $0x2, %dl
andb $0x2, %dl
orb %sil, %dl
movb %dl, 0x20(%r14)
movl %r12d, 0x24(%r14)
movl %r13d, 0x28(%r14)
movl %eax, %edx
andb $-0x5, %dl
movb %dl, 0x2c(%r14)
cmpq $0x5, %r13
ja 0x52f0ac
leaq 0x18e352(%rip), %rdx # 0x6bd364
movslq (%rdx,%r13,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %rbx, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0x52f11f
testl %eax, %eax
movl $0xfffffff6, %ebp # imm = 0xFFFFFFF6
cmovnel %eax, %ebp
jmp 0x52ef4f
leaq 0x18dee2(%rip), %rdx # 0x6bcf21
jmp 0x52ef0a
leaq 0x18e3ed(%rip), %rdx # 0x6bd438
jmp 0x52ef0a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x52f2a3
jmp 0x52f06e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x52f26c
movl %eax, %ebp
jmp 0x52ef4f
movl %eax, %ecx
orb $0x4, %cl
movb %cl, 0x2c(%r14)
testb $0x2, %al
je 0x52ef4f
movq %rbx, %rdi
callq 0x52f7f9
cmpl $-0x1, 0x5318(%r14)
je 0x52f0c6
movl 0x30(%r14), %eax
incl %eax
movl %eax, 0x5318(%r14)
xorl %ebp, %ebp
jmp 0x52ef4f
movl $0xfffffff6, %ebp # imm = 0xFFFFFFF6
testb $0x4, %cl
jne 0x52ef4f
leaq 0x18e3a0(%rip), %rdx # 0x6bd461
jmp 0x52ef0a
leaq 0x18e387(%rip), %rdx # 0x6bd454
jmp 0x52ef0a
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
read_u32
|
static int read_u32(struct archive_read* a, uint32_t* pvalue) {
const uint8_t* p;
if(!read_ahead(a, 4, &p))
return 0;
*pvalue = archive_le32dec(p);
return ARCHIVE_OK == consume(a, 4) ? 1 : 0;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl $0x4, %esi
callq 0x511af8
testq %rax, %rax
je 0x52f115
movl (%rax), %eax
movl %eax, (%r14)
movl $0x4, %esi
movq %rbx, %rdi
callq 0x511e26
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x4, %rcx
sete %al
jmp 0x52f117
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
process_head_main
|
static int process_head_main(struct archive_read* a, struct rar5* rar,
struct archive_entry* entry, size_t block_flags)
{
int ret;
size_t extra_data_size = 0;
size_t extra_field_size = 0;
size_t extra_field_id = 0;
size_t archive_flags = 0;
enum MAIN_FLAGS {
VOLUME = 0x0001, /* multi-volume archive */
VOLUME_NUMBER = 0x0002, /* volume number, first vol doesn't
* have it */
SOLID = 0x0004, /* solid archive */
PROTECT = 0x0008, /* contains Recovery info */
LOCK = 0x0010, /* readonly flag, not used */
};
enum MAIN_EXTRA {
// Just one attribute here.
LOCATOR = 0x01,
};
(void) entry;
if(block_flags & HFL_EXTRA_DATA) {
if(!read_var_sized(a, &extra_data_size, NULL))
return ARCHIVE_EOF;
} else {
extra_data_size = 0;
}
if(!read_var_sized(a, &archive_flags, NULL)) {
return ARCHIVE_EOF;
}
rar->main.volume = (archive_flags & VOLUME) > 0;
rar->main.solid = (archive_flags & SOLID) > 0;
if(archive_flags & VOLUME_NUMBER) {
size_t v = 0;
if(!read_var_sized(a, &v, NULL)) {
return ARCHIVE_EOF;
}
if (v > UINT_MAX) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid volume number");
return ARCHIVE_FATAL;
}
rar->main.vol_no = (unsigned int) v;
} else {
rar->main.vol_no = 0;
}
if(rar->vol.expected_vol_no > 0 &&
rar->main.vol_no != rar->vol.expected_vol_no)
{
/* Returning EOF instead of FATAL because of strange
* libarchive behavior. When opening multiple files via
* archive_read_open_filenames(), after reading up the whole
* last file, the __archive_read_ahead function wraps up to
* the first archive instead of returning EOF. */
return ARCHIVE_EOF;
}
if(extra_data_size == 0) {
/* Early return. */
return ARCHIVE_OK;
}
if(!read_var_sized(a, &extra_field_size, NULL)) {
return ARCHIVE_EOF;
}
if(!read_var_sized(a, &extra_field_id, NULL)) {
return ARCHIVE_EOF;
}
if(extra_field_size == 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid extra field size");
return ARCHIVE_FATAL;
}
switch(extra_field_id) {
case LOCATOR:
ret = process_main_locator_extra_block(a, rar);
if(ret != ARCHIVE_OK) {
/* Error while parsing main locator extra
* block. */
return ret;
}
break;
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Unsupported extra type (0x%x)",
(int) extra_field_id);
return ARCHIVE_FATAL;
}
return ARCHIVE_OK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %bpl
testb $0x1, %dl
je 0x52f152
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
cmpq $0x0, (%rsp)
sete %bpl
xorl %r15d, %r15d
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
movq (%rsp), %rax
movb 0x2c(%r14), %cl
leal (%rax,%rax), %edx
andb $0x2, %dl
andb $-0x4, %cl
orb %dl, %cl
movl %eax, %edx
shrb $0x2, %dl
andb $0x1, %dl
orb %cl, %dl
movb %dl, 0x2c(%r14)
testb $0x2, %al
je 0x52f1bd
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
movq (%rsp), %r15
movq %r15, %rax
shrq $0x20, %rax
je 0x52f1bd
leaq 0x18e2bb(%rip), %rdx # 0x6bd473
jmp 0x52f23e
movl %r15d, 0x30(%r14)
movl 0x5318(%r14), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x52f1e1
cmpl %ecx, %r15d
setne %cl
orb %cl, %bpl
testb $0x1, %bpl
je 0x52f1e6
movb %cl, %al
jmp 0x52f22c
testb %bpl, %bpl
jne 0x52f22c
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
movq %rsp, %rsi
movq (%rsi), %r15
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f227
testq %r15, %r15
je 0x52f237
movq (%rsp), %rcx
cmpq $0x1, %rcx
jne 0x52f254
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52f950
jmp 0x52f22c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18e24b(%rip), %rdx # 0x6bd489
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x52f22c
leaq 0x18e247(%rip), %rdx # 0x6bd4a2
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52f24d
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
process_head_file
|
static int process_head_file(struct archive_read* a, struct rar5* rar,
struct archive_entry* entry, size_t block_flags)
{
ssize_t extra_data_size = 0;
size_t data_size = 0;
size_t file_flags = 0;
size_t file_attr = 0;
size_t compression_info = 0;
size_t host_os = 0;
size_t name_size = 0;
uint64_t unpacked_size, window_size;
uint32_t mtime = 0, crc = 0;
int c_method = 0, c_version = 0;
char name_utf8_buf[MAX_NAME_IN_BYTES];
const uint8_t* p;
enum FILE_FLAGS {
DIRECTORY = 0x0001, UTIME = 0x0002, CRC32 = 0x0004,
UNKNOWN_UNPACKED_SIZE = 0x0008,
};
enum FILE_ATTRS {
ATTR_READONLY = 0x1, ATTR_HIDDEN = 0x2, ATTR_SYSTEM = 0x4,
ATTR_DIRECTORY = 0x10,
};
enum COMP_INFO_FLAGS {
SOLID = 0x0040,
};
enum HOST_OS {
HOST_WINDOWS = 0,
HOST_UNIX = 1,
};
archive_entry_clear(entry);
/* Do not reset file context if we're switching archives. */
if(!rar->cstate.switch_multivolume) {
reset_file_context(rar);
}
if(block_flags & HFL_EXTRA_DATA) {
size_t edata_size = 0;
if(!read_var_sized(a, &edata_size, NULL))
return ARCHIVE_EOF;
/* Intentional type cast from unsigned to signed. */
extra_data_size = (ssize_t) edata_size;
}
if(block_flags & HFL_DATA) {
if(!read_var_sized(a, &data_size, NULL))
return ARCHIVE_EOF;
rar->file.bytes_remaining = data_size;
} else {
rar->file.bytes_remaining = 0;
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"no data found in file/service block");
return ARCHIVE_FATAL;
}
if(!read_var_sized(a, &file_flags, NULL))
return ARCHIVE_EOF;
if(!read_var(a, &unpacked_size, NULL))
return ARCHIVE_EOF;
if(file_flags & UNKNOWN_UNPACKED_SIZE) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Files with unknown unpacked size are not supported");
return ARCHIVE_FATAL;
}
rar->file.dir = (uint8_t) ((file_flags & DIRECTORY) > 0);
if(!read_var_sized(a, &file_attr, NULL))
return ARCHIVE_EOF;
if(file_flags & UTIME) {
if(!read_u32(a, &mtime))
return ARCHIVE_EOF;
}
if(file_flags & CRC32) {
if(!read_u32(a, &crc))
return ARCHIVE_EOF;
}
if(!read_var_sized(a, &compression_info, NULL))
return ARCHIVE_EOF;
c_method = (int) (compression_info >> 7) & 0x7;
c_version = (int) (compression_info & 0x3f);
/* RAR5 seems to limit the dictionary size to 64MB. */
window_size = (rar->file.dir > 0) ?
0 :
g_unpack_window_size << ((compression_info >> 10) & 15);
rar->cstate.method = c_method;
rar->cstate.version = c_version + 50;
rar->file.solid = (compression_info & SOLID) > 0;
/* Archives which declare solid files without initializing the window
* buffer first are invalid. */
if(rar->file.solid > 0 && rar->cstate.window_buf == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Declared solid file, but no window buffer "
"initialized yet.");
return ARCHIVE_FATAL;
}
/* Check if window_size is a sane value. Also, if the file is not
* declared as a directory, disallow window_size == 0. */
if(window_size > (64 * 1024 * 1024) ||
(rar->file.dir == 0 && window_size == 0))
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Declared dictionary size is not supported.");
return ARCHIVE_FATAL;
}
if(rar->file.solid > 0) {
/* Re-check if current window size is the same as previous
* window size (for solid files only). */
if(rar->file.solid_window_size > 0 &&
rar->file.solid_window_size != (ssize_t) window_size)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Window size for this solid file doesn't match "
"the window size used in previous solid file. ");
return ARCHIVE_FATAL;
}
}
if(rar->cstate.window_size < (ssize_t) window_size &&
rar->cstate.window_buf)
{
/* If window_buf has been allocated before, reallocate it, so
* that its size will match new window_size. */
uint8_t* new_window_buf =
realloc(rar->cstate.window_buf, window_size);
if(!new_window_buf) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Not enough memory when trying to realloc the window "
"buffer.");
return ARCHIVE_FATAL;
}
rar->cstate.window_buf = new_window_buf;
}
/* Values up to 64M should fit into ssize_t on every
* architecture. */
rar->cstate.window_size = (ssize_t) window_size;
if(rar->file.solid > 0 && rar->file.solid_window_size == 0) {
/* Solid files have to have the same window_size across
whole archive. Remember the window_size parameter
for first solid file found. */
rar->file.solid_window_size = rar->cstate.window_size;
}
init_window_mask(rar);
rar->file.service = 0;
if(!read_var_sized(a, &host_os, NULL))
return ARCHIVE_EOF;
if(host_os == HOST_WINDOWS) {
/* Host OS is Windows */
__LA_MODE_T mode;
if(file_attr & ATTR_DIRECTORY) {
if (file_attr & ATTR_READONLY) {
mode = 0555 | AE_IFDIR;
} else {
mode = 0755 | AE_IFDIR;
}
} else {
if (file_attr & ATTR_READONLY) {
mode = 0444 | AE_IFREG;
} else {
mode = 0644 | AE_IFREG;
}
}
archive_entry_set_mode(entry, mode);
if (file_attr & (ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM)) {
char *fflags_text, *ptr;
/* allocate for "rdonly,hidden,system," */
fflags_text = malloc(22 * sizeof(char));
if (fflags_text != NULL) {
ptr = fflags_text;
if (file_attr & ATTR_READONLY) {
strcpy(ptr, "rdonly,");
ptr = ptr + 7;
}
if (file_attr & ATTR_HIDDEN) {
strcpy(ptr, "hidden,");
ptr = ptr + 7;
}
if (file_attr & ATTR_SYSTEM) {
strcpy(ptr, "system,");
ptr = ptr + 7;
}
if (ptr > fflags_text) {
/* Delete trailing comma */
*(ptr - 1) = '\0';
archive_entry_copy_fflags_text(entry,
fflags_text);
}
free(fflags_text);
}
}
} else if(host_os == HOST_UNIX) {
/* Host OS is Unix */
archive_entry_set_mode(entry, (__LA_MODE_T) file_attr);
} else {
/* Unknown host OS */
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Unsupported Host OS: 0x%x", (int) host_os);
return ARCHIVE_FATAL;
}
if(!read_var_sized(a, &name_size, NULL))
return ARCHIVE_EOF;
if(!read_ahead(a, name_size, &p))
return ARCHIVE_EOF;
if(name_size > (MAX_NAME_IN_CHARS - 1)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Filename is too long");
return ARCHIVE_FATAL;
}
if(name_size == 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"No filename specified");
return ARCHIVE_FATAL;
}
memcpy(name_utf8_buf, p, name_size);
name_utf8_buf[name_size] = 0;
if(ARCHIVE_OK != consume(a, name_size)) {
return ARCHIVE_EOF;
}
archive_entry_update_pathname_utf8(entry, name_utf8_buf);
if(extra_data_size > 0) {
int ret = process_head_file_extra(a, entry, rar,
extra_data_size);
/*
* TODO: rewrite or remove useless sanity check
* as extra_data_size is not passed as a pointer
*
if(extra_data_size < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"File extra data size is not zero");
return ARCHIVE_FATAL;
}
*/
if(ret != ARCHIVE_OK)
return ret;
}
if((file_flags & UNKNOWN_UNPACKED_SIZE) == 0) {
rar->file.unpacked_size = (ssize_t) unpacked_size;
if(rar->file.redir_type == REDIR_TYPE_NONE)
archive_entry_set_size(entry, unpacked_size);
}
if(file_flags & UTIME) {
archive_entry_set_mtime(entry, (time_t) mtime, 0);
}
if(file_flags & CRC32) {
rar->file.stored_crc32 = crc;
}
if(!rar->cstate.switch_multivolume) {
/* Do not reinitialize unpacking state if we're switching
* archives. */
rar->cstate.block_parsing_finished = 1;
rar->cstate.all_filters_applied = 1;
rar->cstate.initialized = 0;
}
if(rar->generic.split_before > 0) {
/* If now we're standing on a header that has a 'split before'
* mark, it means we're standing on a 'continuation' file
* header. Signal the caller that if it wants to move to
* another file, it must call rar5_read_header() function
* again. */
return ARCHIVE_RETRY;
} else {
return ARCHIVE_OK;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp # imm = 0x2028
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %rdx, %rdi
callq 0x50bfd0
testb $0x4, 0x38(%rbx)
jne 0x52f33b
leaq 0x4ba8(%rbx), %rdi
movl $0x768, %edx # imm = 0x768
xorl %esi, %esi
callq 0x3fa90
leaq 0x4c18(%rbx), %rdi
movl $0x20, %esi
callq 0x559484
testb $0x1, 0x2c(%rbx)
jne 0x52f30f
movq $0x0, 0x88(%rbx)
jmp 0x52f31a
movq 0x70(%rbx), %rax
addq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movq $0x0, 0x80(%rbx)
movups %xmm0, 0x52f8(%rbx)
movq %rbx, %rdi
callq 0x53033e
testb $0x1, %r13b
jne 0x52f346
xorl %r12d, %r12d
jmp 0x52f362
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f628
movq 0x20(%rsp), %r12
testb $0x2, %r13b
jne 0x52f393
movq $0x0, 0x4ba8(%rbx)
leaq 0x18e146(%rip), %rdx # 0x6bd4c0
movq %r14, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x52f62d
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f628
leaq 0x20(%rsp), %rsi
movq (%rsi), %rax
movq %rax, 0x4ba8(%rbx)
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f628
movq 0x20(%rsp), %r13
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
movl $0x1, %ebp
testl %eax, %eax
je 0x52f62d
testb $0x8, %r13b
jne 0x52f641
movb 0x4bc8(%rbx), %al
leal (,%r13,8), %ecx
andb $0x8, %cl
andb $-0x9, %al
orb %cl, %al
movb %al, 0x4bc8(%rbx)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f62d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
testb $0x2, %r13b
je 0x52f44c
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x52f0d2
testl %eax, %eax
je 0x52f62d
testb $0x4, %r13b
je 0x52f467
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x52f0d2
testl %eax, %eax
je 0x52f62d
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f62d
movq 0x20(%rsp), %rdx
movl %edx, %r9d
shrl $0x7, %r9d
andl $0x7, %r9d
movl %edx, %edi
andl $0x3f, %edi
movb 0x4bc8(%rbx), %al
movl %edx, %ecx
shrl $0xa, %ecx
andb $0xf, %cl
movl $0x20000, %r8d # imm = 0x20000
shlq %cl, %r8
xorl %esi, %esi
testb $0x8, %al
cmoveq %r8, %rsi
movl %r9d, 0x40(%rbx)
addl $0x32, %edi
movl %edi, 0x44(%rbx)
shrb $0x6, %dl
andb $0x1, %dl
andb $-0x2, %al
orb %dl, %al
movb %al, 0x4bc8(%rbx)
testb %dl, %dl
jne 0x52f655
cmpq $0x4000000, %rsi # imm = 0x4000000
ja 0x52f665
cmpq %rsi, 0x48(%rbx)
jge 0x52f512
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x52f512
movq %rsi, 0x10(%rsp)
callq 0x41e68
testq %rax, %rax
je 0x52f71d
movq %rax, 0x50(%rbx)
movb 0x4bc8(%rbx), %al
movq 0x10(%rsp), %rsi
movq %rsi, 0x48(%rbx)
testb $0x1, %al
je 0x52f52b
cmpq $0x0, 0x5308(%rbx)
jne 0x52f52b
movq %rsi, 0x5308(%rbx)
xorl %ecx, %ecx
subq $0x1, %rsi
cmovbq %rcx, %rsi
movq %rsi, 0x68(%rbx)
andb $-0x3, %al
movb %al, 0x4bc8(%rbx)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f62d
movq 0x20(%rsp), %rcx
cmpq $0x1, %rcx
je 0x52f6a2
testq %rcx, %rcx
jne 0x52f702
xorl %eax, %eax
movq (%rsp), %rcx
testb $0x1, %cl
sete %al
shll $0x7, %eax
testb $0x10, %cl
movl $0x8124, %ecx # imm = 0x8124
movl $0x416d, %esi # imm = 0x416D
cmovel %ecx, %esi
orl %eax, %esi
movq %r15, %rdi
callq 0x50d41b
testb $0x7, (%rsp)
je 0x52f6ae
movl $0x16, %edi
callq 0x41ec0
testq %rax, %rax
je 0x52f6ae
movq %rax, %rdx
testb $0x1, (%rsp)
je 0x52f5d0
movabsq $0x2c796c6e6f6472, %rcx # imm = 0x2C796C6E6F6472
movq %rcx, (%rax)
leaq 0x7(%rax), %rdx
testb $0x2, (%rsp)
je 0x52f5e7
movabsq $0x2c6e6564646968, %rcx # imm = 0x2C6E6564646968
movq %rcx, (%rdx)
addq $0x7, %rdx
testb $0x4, (%rsp)
je 0x52f5fe
movabsq $0x2c6d6574737973, %rcx # imm = 0x2C6D6574737973
movq %rcx, (%rdx)
addq $0x7, %rdx
cmpq %rax, %rdx
jbe 0x52f61b
movb $0x0, -0x1(%rdx)
movq %r15, %rdi
movq %rax, (%rsp)
movq (%rsp), %rsi
callq 0x50cc21
movq (%rsp), %rax
movq %rax, %rdi
callq 0x41e70
jmp 0x52f6ae
movl $0x1, %ebp
movl %ebp, %eax
addq $0x2028, %rsp # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18de9c(%rip), %rdx # 0x6bd4e4
movq %r14, %rdi
movl $0x16, %esi
jmp 0x52f382
cmpq $0x0, 0x50(%rbx)
je 0x52f671
cmpq $0x4000001, %rsi # imm = 0x4000001
jb 0x52f67d
leaq 0x18dee6(%rip), %rdx # 0x6bd552
jmp 0x52f37a
leaq 0x18de9f(%rip), %rdx # 0x6bd517
jmp 0x52f37a
movq 0x5308(%rbx), %rcx
testq %rcx, %rcx
jle 0x52f4e1
cmpq %rsi, %rcx
je 0x52f4e1
leaq 0x18dee0(%rip), %rdx # 0x6bd57d
jmp 0x52f37a
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x50d41b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f62d
leaq 0x20(%rsp), %rdx
movq (%rdx), %rsi
movq $-0x1, (%rdx)
movq %r14, %rdi
movq %rsi, (%rsp)
callq 0x511af8
testq %rax, %rax
je 0x52f62d
movq (%rsp), %rcx
cmpq $0x800, %rcx # imm = 0x800
jb 0x52f729
leaq 0x18df32(%rip), %rdx # 0x6bd62f
jmp 0x52f37a
leaq 0x18df0c(%rip), %rdx # 0x6bd615
movq %r14, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
jmp 0x52f389
leaq 0x18deb5(%rip), %rdx # 0x6bd5d9
jmp 0x52f648
testq %rcx, %rcx
je 0x52f7ed
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x3f250
movq (%rsp), %rsi
movb $0x0, 0x20(%rsp,%rsi)
movq %r14, %rdi
callq 0x511e26
cmpq (%rsp), %rax
jne 0x52f62d
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x50d4d6
testq %r12, %r12
jle 0x52f78a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x52f9bb
movl %eax, %ebp
testl %eax, %eax
jne 0x52f62d
movq 0x18(%rsp), %rsi
movq %rsi, 0x4bb0(%rbx)
cmpq $0x0, 0x52f8(%rbx)
jne 0x52f7a8
movq %r15, %rdi
callq 0x50d589
testb $0x2, %r13b
je 0x52f7bc
movl 0xc(%rsp), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x50d429
testb $0x4, %r13b
je 0x52f7cc
movl 0x8(%rsp), %eax
movl %eax, 0x4bec(%rbx)
movb 0x38(%rbx), %al
testb $0x4, %al
jne 0x52f7da
andb $-0x10, %al
orb $0xa, %al
movb %al, 0x38(%rbx)
xorl %eax, %eax
testb $0x2, 0x20(%rbx)
movl $0xfffffff6, %ebp # imm = 0xFFFFFFF6
cmovel %eax, %ebp
jmp 0x52f62d
leaq 0x18de50(%rip), %rdx # 0x6bd644
jmp 0x52f37a
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
read_var
|
static int read_var(struct archive_read* a, uint64_t* pvalue,
uint64_t* pvalue_len)
{
uint64_t result = 0;
size_t shift, i;
const uint8_t* p;
uint8_t b;
/* We will read maximum of 8 bytes. We don't have to handle the
* situation to read the RAR5 variable-sized value stored at the end of
* the file, because such situation will never happen. */
if(!read_ahead(a, 8, &p))
return 0;
for(shift = 0, i = 0; i < 8; i++, shift += 7) {
b = p[i];
/* Strip the MSB from the input byte and add the resulting
* number to the `result`. */
result += (b & (uint64_t)0x7F) << shift;
/* MSB set to 1 means we need to continue decoding process.
* MSB set to 0 means we're done.
*
* This conditional checks for the second case. */
if((b & 0x80) == 0) {
if(pvalue) {
*pvalue = result;
}
/* If the caller has passed the `pvalue_len` pointer,
* store the number of consumed bytes in it and do NOT
* consume those bytes, since the caller has all the
* information it needs to perform */
if(pvalue_len) {
*pvalue_len = 1 + i;
} else {
/* If the caller did not provide the
* `pvalue_len` pointer, it will not have the
* possibility to advance the file pointer,
* because it will not know how many bytes it
* needs to consume. This is why we handle
* such situation here automatically. */
if(ARCHIVE_OK != consume(a, 1 + i)) {
return 0;
}
}
/* End of decoding process, return success. */
return 1;
}
}
/* The decoded value takes the maximum number of 8 bytes.
* It's a maximum number of bytes, so end decoding process here
* even if the first bit of last byte is 1. */
if(pvalue) {
*pvalue = result;
}
if(pvalue_len) {
*pvalue_len = 9;
} else {
if(ARCHIVE_OK != consume(a, 9)) {
return 0;
}
}
return 1;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl $0x8, %esi
callq 0x511af8
testq %rax, %rax
je 0x52f942
movl $0x1, %r12d
xorl %ecx, %ecx
xorl %edx, %edx
movq %rdx, %rsi
movzbl -0x1(%rax,%r12), %edi
movl %edi, %edx
andl $0x7f, %edx
shlq %cl, %rdx
addq %rsi, %rdx
testb %dil, %dil
jns 0x52f906
addq $0x7, %rcx
incq %r12
cmpq $0x9, %r12
jne 0x52f8ca
testq %r15, %r15
je 0x52f8f8
movq %rdx, (%r15)
testq %r14, %r14
je 0x52f92f
movq $0x9, (%r14)
jmp 0x52f928
testq %r15, %r15
je 0x52f90e
movq %rdx, (%r15)
testq %r14, %r14
je 0x52f918
movq %r12, (%r14)
jmp 0x52f928
movq %rbx, %rdi
movq %r12, %rsi
callq 0x511e26
cmpq %r12, %rax
jne 0x52f942
movl $0x1, %eax
jmp 0x52f944
movl $0x9, %esi
movq %rbx, %rdi
callq 0x511e26
cmpq $0x9, %rax
je 0x52f928
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
process_main_locator_extra_block
|
static int process_main_locator_extra_block(struct archive_read* a,
struct rar5* rar)
{
uint64_t locator_flags;
enum LOCATOR_FLAGS {
QLIST = 0x01, RECOVERY = 0x02,
};
if(!read_var(a, &locator_flags, NULL)) {
return ARCHIVE_EOF;
}
if(locator_flags & QLIST) {
if(!read_var(a, &rar->qlist_offset, NULL)) {
return ARCHIVE_EOF;
}
/* qlist is not used */
}
if(locator_flags & RECOVERY) {
if(!read_var(a, &rar->rr_offset, NULL)) {
return ARCHIVE_EOF;
}
/* rr is not used */
}
return ARCHIVE_OK;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x52f892
movl $0x1, %ebx
testl %eax, %eax
je 0x52f9af
movq 0x8(%rsp), %rax
testb $0x1, %al
je 0x52f994
leaq 0x10(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f9af
movq 0x8(%rsp), %rax
testb $0x2, %al
je 0x52f9ad
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x52f892
testl %eax, %eax
je 0x52f9af
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
skip_base_block
|
static int skip_base_block(struct archive_read* a) {
int ret;
struct rar5* rar = get_context(a);
/* Create a new local archive_entry structure that will be operated on
* by header reader; operations on this archive_entry will be discarded.
*/
struct archive_entry* entry = archive_entry_new();
ret = process_base_block(a, entry);
/* Discard operations on this archive_entry structure. */
archive_entry_free(entry);
if(ret == ARCHIVE_FATAL)
return ret;
if(rar->generic.last_header_id == 2 && rar->generic.split_before > 0)
return ARCHIVE_OK;
if(ret == ARCHIVE_OK)
return ARCHIVE_RETRY;
else
return ret;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
callq 0x50c361
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52ee53
movl %eax, %ebx
movq %r14, %rdi
callq 0x50c34f
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ebx
je 0x530747
cmpl $0x2, 0x28(%r15)
jne 0x53073d
xorl %eax, %eax
testb $0x2, 0x20(%r15)
jne 0x530747
testl %ebx, %ebx
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
cmovnel %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
push_window_data
|
static void push_window_data(struct archive_read* a, struct rar5* rar,
int64_t idx_begin, int64_t idx_end)
{
push_data(a, rar, rar->cstate.window_buf, idx_begin, idx_end);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %r12
movq 0x50(%rsi), %r15
movq 0x68(%rsi), %rcx
movq 0x88(%rsi), %rsi
movq 0x78(%r14), %r8
leaq (%r8,%rsi), %rdx
andq %rcx, %rdx
addq %rsi, %rax
addq %rsi, %rbx
movq %rax, %rsi
andq %rcx, %rsi
movq %rbx, %r13
andq %rcx, %r13
cmpq %r13, %rsi
jbe 0x5307c8
movq 0x48(%r14), %rbx
subq %rsi, %rbx
addq %r15, %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x530cca
movq 0x78(%r14), %r8
addq %rbx, %r8
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x530cca
addq %r13, %rbx
jmp 0x5307df
addq %rdx, %r15
subq %rax, %rbx
andq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x530cca
addq 0x78(%r14), %rbx
movq %rbx, 0x78(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
create_decode_tables
|
static int create_decode_tables(uint8_t* bit_length,
struct decode_table* table, int size)
{
int code, upper_limit = 0, i, lc[16];
uint32_t decode_pos_clone[rar5_countof(table->decode_pos)];
ssize_t cur_len, quick_data_size;
memset(&lc, 0, sizeof(lc));
memset(table->decode_num, 0, sizeof(table->decode_num));
table->size = size;
table->quick_bits = size == HUFF_NC ? 10 : 7;
for(i = 0; i < size; i++) {
lc[bit_length[i] & 15]++;
}
lc[0] = 0;
table->decode_pos[0] = 0;
table->decode_len[0] = 0;
for(i = 1; i < 16; i++) {
upper_limit += lc[i];
table->decode_len[i] = upper_limit << (16 - i);
table->decode_pos[i] = table->decode_pos[i - 1] + lc[i - 1];
upper_limit <<= 1;
}
memcpy(decode_pos_clone, table->decode_pos, sizeof(decode_pos_clone));
for(i = 0; i < size; i++) {
uint8_t clen = bit_length[i] & 15;
if(clen > 0) {
int last_pos = decode_pos_clone[clen];
table->decode_num[last_pos] = i;
decode_pos_clone[clen]++;
}
}
quick_data_size = (int64_t)1 << table->quick_bits;
cur_len = 1;
for(code = 0; code < quick_data_size; code++) {
int bit_field = code << (16 - table->quick_bits);
int dist, pos;
while(cur_len < rar5_countof(table->decode_len) &&
bit_field >= table->decode_len[cur_len]) {
cur_len++;
}
table->quick_len[code] = (uint8_t) cur_len;
dist = bit_field - table->decode_len[cur_len - 1];
dist >>= (16 - cur_len);
pos = table->decode_pos[cur_len & 15] + dist;
if(cur_len < rar5_countof(table->decode_pos) && pos < size) {
table->quick_num[code] = table->decode_num[pos];
} else {
table->quick_num[code] = 0;
}
}
return ARCHIVE_OK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
leaq 0xc88(%rsi), %r15
xorl %ebp, %ebp
movl $0x264, %edx # imm = 0x264
movq %r15, %rdi
xorl %esi, %esi
callq 0x3fa90
movl %ebx, (%r14)
xorl %eax, %eax
cmpl $0x132, %ebx # imm = 0x132
sete %al
leal (%rax,%rax,2), %eax
addl $0x7, %eax
movl %eax, 0x84(%r14)
movl %ebx, %eax
testl %ebx, %ebx
jle 0x53086e
xorl %ecx, %ecx
movzbl (%r12,%rcx), %edx
andl $0xf, %edx
incl 0x40(%rsp,%rdx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x53085a
leaq 0x44(%r14), %rdx
movl %ebp, 0x44(%r14)
movl %ebp, 0x4(%r14)
movl $0x1, %esi
movl $0xf, %ecx
xorl %edi, %edi
xorl %r8d, %r8d
addl %ebp, %edi
movl 0x40(%rsp,%rsi,4), %ebp
addl %ebp, %r8d
movl %r8d, %r9d
shll %cl, %r9d
movl %r9d, 0x4(%r14,%rsi,4)
movl %edi, 0x44(%r14,%rsi,4)
addl %r8d, %r8d
incq %rsi
decq %rcx
jne 0x530889
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x30(%rdx), %xmm3
movaps %xmm3, 0x30(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
testl %ebx, %ebx
jle 0x5308f6
xorl %ecx, %ecx
movzbl (%r12,%rcx), %edx
andq $0xf, %rdx
je 0x5308ee
movslq (%rsp,%rdx,4), %rsi
movw %cx, (%r15,%rsi,2)
incl %esi
movl %esi, (%rsp,%rdx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x5308d5
movl 0x84(%r14), %ecx
cmpq $0x3f, %rcx
je 0x5309ae
movl $0x1, %edx
shlq %cl, %rdx
movl $0x1, %esi
movl $0x10, %eax
subl %ecx, %eax
cmpq $0x2, %rdx
cmovlq %rsi, %rdx
xorl %edi, %edi
movl %edi, %r8d
movl %eax, %ecx
shll %cl, %r8d
cmpq $0xf, %rsi
jg 0x530953
movb $0x1, %r9b
cmpl 0x4(%r14,%rsi,4), %r8d
jl 0x530965
movq %rsi, %rcx
cmpq $0xf, %rsi
je 0x530958
leaq 0x1(%rcx), %rsi
cmpl 0x8(%r14,%rcx,4), %r8d
jge 0x53093d
jmp 0x53095d
xorl %r9d, %r9d
jmp 0x530965
movl $0x10, %esi
cmpq $0xf, %rcx
setl %r9b
movb %sil, 0x88(%r14,%rdi)
subl (%r14,%rsi,4), %r8d
movb $0x10, %cl
subb %sil, %cl
sarl %cl, %r8d
xorl %ecx, %ecx
testb %r9b, %r9b
je 0x530999
movl %esi, %r9d
andl $0xf, %r9d
addl 0x44(%r14,%r9,4), %r8d
cmpl %ebx, %r8d
jge 0x530999
movslq %r8d, %rcx
movzwl (%r15,%rcx,2), %ecx
movw %cx, 0x488(%r14,%rdi,2)
incq %rdi
cmpq %rdx, %rdi
jne 0x530925
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
decode_number
|
static int decode_number(struct archive_read* a, struct decode_table* table,
const uint8_t* p, uint16_t* num)
{
int i, bits, dist, ret;
uint16_t bitfield;
uint32_t pos;
struct rar5* rar = get_context(a);
if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &bitfield))) {
return ret;
}
bitfield &= 0xfffe;
if(bitfield < table->decode_len[table->quick_bits]) {
int code = bitfield >> (16 - table->quick_bits);
skip_bits(rar, table->quick_len[code]);
*num = table->quick_num[code];
return ARCHIVE_OK;
}
bits = 15;
for(i = table->quick_bits + 1; i < 15; i++) {
if(bitfield < table->decode_len[i]) {
bits = i;
break;
}
}
skip_bits(rar, bits);
dist = bitfield - table->decode_len[bits - 1];
dist >>= (16 - bits);
pos = table->decode_pos[bits] + dist;
if(pos >= table->size)
pos = 0;
*num = table->decode_num[pos];
return ARCHIVE_OK;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r15
leaq 0xe(%rsp), %rcx
movq %r15, %rsi
callq 0x530aae
testl %eax, %eax
jne 0x530aa4
movzwl 0xe(%rsp), %eax
andl $-0x2, %eax
movl 0x84(%r14), %edx
cmpl %eax, 0x4(%r14,%rdx,4)
jle 0x530a3e
movb $0x10, %cl
subb %dl, %cl
shrq %cl, %rax
movzbl 0x88(%r14,%rax), %ecx
movsbl 0x5310(%r15), %edx
addl %ecx, %edx
movl %edx, %ecx
sarl $0x3, %ecx
addl %ecx, 0x5314(%r15)
andb $0x7, %dl
movb %dl, 0x5310(%r15)
leaq (%r14,%rax,2), %rax
addq $0x488, %rax # imm = 0x488
jmp 0x530a9c
incl %edx
cmpl $0xe, %edx
jg 0x530a51
movslq %edx, %rcx
cmpl %eax, 0x4(%r14,%rcx,4)
jle 0x530a3e
jmp 0x530a56
movl $0xf, %edx
movsbl 0x5310(%r15), %ecx
addl %edx, %ecx
movl %ecx, %esi
sarl $0x3, %esi
addl %esi, 0x5314(%r15)
andb $0x7, %cl
movb %cl, 0x5310(%r15)
movslq %edx, %rdx
movl (%r14,%rdx,4), %ecx
subl %ecx, %eax
movb $0x10, %cl
subb %dl, %cl
sarl %cl, %eax
addl 0x44(%r14,%rdx,4), %eax
xorl %ecx, %ecx
cmpl (%r14), %eax
cmovbl %eax, %ecx
leaq (%r14,%rcx,2), %rax
addq $0xc88, %rax # imm = 0xC88
movzwl (%rax), %eax
movw %ax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
read_bits_16
|
static int read_bits_16(struct archive_read* a, struct rar5* rar,
const uint8_t* p, uint16_t* value)
{
if(rar->bits.in_addr >= rar->cstate.cur_block_size) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_PROGRAMMER,
"Premature end of stream during extraction of data (#2)");
return ARCHIVE_FATAL;
}
int bits = (int) ((uint32_t) p[rar->bits.in_addr]) << 16;
bits |= (int) p[rar->bits.in_addr + 1] << 8;
bits |= (int) p[rar->bits.in_addr + 2];
bits >>= (8 - rar->bits.bit_addr);
*value = bits & 0xffff;
return ARCHIVE_OK;
}
|
movq %rcx, %rax
movslq 0x5314(%rsi), %rcx
cmpq %rcx, 0x90(%rsi)
jle 0x530aed
movzbl (%rdx,%rcx), %edi
shll $0x10, %edi
movzbl 0x1(%rdx,%rcx), %r8d
shll $0x8, %r8d
orl %edi, %r8d
movzbl 0x2(%rdx,%rcx), %edx
orl %r8d, %edx
movb $0x8, %cl
subb 0x5310(%rsi), %cl
shrl %cl, %edx
movw %dx, (%rax)
xorl %eax, %eax
retq
pushq %rax
leaq 0x18ce15(%rip), %rdx # 0x6bd90a
movl $0x16, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
addq $0x8, %rsp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
archive_read_format_raw_read_header
|
static int
archive_read_format_raw_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct raw_info *info;
info = (struct raw_info *)(a->format->data);
if (info->end_of_file)
return (ARCHIVE_EOF);
a->archive.archive_format = ARCHIVE_FORMAT_RAW;
a->archive.archive_format_name = "raw";
archive_entry_set_pathname(entry, "data");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
/* I'm deliberately leaving most fields unset here. */
/* Let the filter fill out any fields it might have. */
return __archive_read_header(a, entry);
}
|
movq 0x818(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x530e76
movl $0x1, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x90000, 0x10(%rdi) # imm = 0x90000
leaq 0x115e68(%rip), %rax # 0x646cf6
movq %rax, 0x18(%rdi)
leaq 0x18abae(%rip), %rsi # 0x6bba47
movq %rbx, %rdi
callq 0x50d4a6
movq %rbx, %rdi
movl $0x8000, %esi # imm = 0x8000
callq 0x50cbd2
movq %rbx, %rdi
movl $0x1a4, %esi # imm = 0x1A4
callq 0x50d523
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5115de
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_raw.c
|
archive_read_format_tar_read_header
|
static int
archive_read_format_tar_read_header(struct archive_read *a,
struct archive_entry *entry)
{
/*
* When converting tar archives to cpio archives, it is
* essential that each distinct file have a distinct inode
* number. To simplify this, we keep a static count here to
* assign fake dev/inode numbers to each tar entry. Note that
* pax format archives may overwrite this with something more
* useful.
*
* Ideally, we would track every file read from the archive so
* that we could assign the same dev/ino pair to hardlinks,
* but the memory required to store a complete lookup table is
* probably not worthwhile just to support the relatively
* obscure tar->cpio conversion case.
*/
static int default_inode;
static int default_dev;
struct tar *tar;
const char *p;
const wchar_t *wp;
int r;
size_t l, unconsumed = 0;
/* Assign default device/inode values. */
archive_entry_set_dev(entry, 1 + default_dev); /* Don't use zero. */
archive_entry_set_ino(entry, ++default_inode); /* Don't use zero. */
/* Limit generated st_ino number to 16 bits. */
if (default_inode >= 0xffff) {
++default_dev;
default_inode = 0;
}
tar = (struct tar *)(a->format->data);
tar->entry_offset = 0;
gnu_clear_sparse_list(tar);
tar->realsize = -1; /* Mark this as "unset" */
tar->realsize_override = 0;
/* Setup default string conversion. */
tar->sconv = tar->opt_sconv;
if (tar->sconv == NULL) {
if (!tar->init_default_conversion) {
tar->sconv_default =
archive_string_default_conversion_for_read(&(a->archive));
tar->init_default_conversion = 1;
}
tar->sconv = tar->sconv_default;
}
r = tar_read_header(a, tar, entry, &unconsumed);
tar_flush_unconsumed(a, &unconsumed);
/*
* "non-sparse" files are really just sparse files with
* a single block.
*/
if (tar->sparse_list == NULL) {
if (gnu_add_sparse_entry(a, tar, 0, tar->entry_bytes_remaining)
!= ARCHIVE_OK)
return (ARCHIVE_FATAL);
} else {
struct sparse_block *sb;
for (sb = tar->sparse_list; sb != NULL; sb = sb->next) {
if (!sb->hole)
archive_entry_sparse_add_entry(entry,
sb->offset, sb->remaining);
}
}
if (r == ARCHIVE_OK && archive_entry_filetype(entry) == AE_IFREG) {
/*
* "Regular" entry with trailing '/' is really
* directory: This is needed for certain old tar
* variants and even for some broken newer ones.
*/
if ((wp = archive_entry_pathname_w(entry)) != NULL) {
l = wcslen(wp);
if (l > 0 && wp[l - 1] == L'/') {
archive_entry_set_filetype(entry, AE_IFDIR);
tar->entry_bytes_remaining = 0;
tar->entry_padding = 0;
}
} else if ((p = archive_entry_pathname(entry)) != NULL) {
l = strlen(p);
if (l > 0 && p[l - 1] == '/') {
archive_entry_set_filetype(entry, AE_IFDIR);
tar->entry_bytes_remaining = 0;
tar->entry_padding = 0;
}
}
}
return (r);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movslq 0x33a371(%rip), %rsi # 0x86b714
incq %rsi
movq %rbx, %rdi
callq 0x50d2cc
movslq 0x33a35b(%rip), %rsi # 0x86b710
incq %rsi
movl %esi, 0x33a352(%rip) # 0x86b710
movq %rbx, %rdi
callq 0x50cfd1
cmpl $0xffff, 0x33a340(%rip) # imm = 0xFFFF
jl 0x5313e2
incl 0x33a33c(%rip) # 0x86b714
movl $0x0, 0x33a32e(%rip) # 0x86b710
movq 0x818(%r15), %rax
movq (%rax), %r14
movq $0x0, 0x118(%r14)
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0x531414
movq (%rdi), %rax
movq %rax, 0x140(%r14)
callq 0x41e70
jmp 0x5313f7
movq $0x0, 0x148(%r14)
movq $-0x1, 0x130(%r14)
movl $0x0, 0x1b8(%r14)
movq 0x188(%r14), %rax
movq %rax, 0x190(%r14)
testq %rax, %rax
jne 0x53147c
cmpl $0x0, 0x1a8(%r14)
je 0x53145b
movq 0x1a0(%r14), %rax
jmp 0x531475
movq %r15, %rdi
callq 0x53a695
movq %rax, 0x1a0(%r14)
movl $0x1, 0x1a8(%r14)
movq %rax, 0x190(%r14)
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x531bb5
movl %eax, %ebp
movq (%r12), %rsi
testq %rsi, %rsi
je 0x5314a5
movq %r15, %rdi
callq 0x511e26
movq 0x140(%r14), %r12
testq %r12, %r12
je 0x531514
cmpl $0x0, 0x18(%r12)
jne 0x5314cb
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x50dba5
movq (%r12), %r12
testq %r12, %r12
jne 0x5314b1
movl %ebp, %r15d
testl %ebp, %ebp
jne 0x531532
movq %rbx, %rdi
callq 0x50c423
xorl %r15d, %r15d
cmpl $0x8000, %eax # imm = 0x8000
jne 0x531532
movq %rbx, %rdi
callq 0x50c87f
testq %rax, %rax
je 0x531542
movq %rax, %r12
movq %rax, %rdi
callq 0x40820
testq %rax, %rax
je 0x531532
cmpl $0x2f, -0x4(%r12,%rax,4)
jne 0x531532
jmp 0x531567
movq 0x110(%r14), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x532521
movl $0xffffffe2, %r15d # imm = 0xFFFFFFE2
testl %eax, %eax
je 0x5314d4
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x50c801
testq %rax, %rax
je 0x531532
movq %rax, %r12
movq %rax, %rdi
callq 0x3fd60
testq %rax, %rax
je 0x531532
cmpb $0x2f, -0x1(%r12,%rax)
jne 0x531532
movq %rbx, %rdi
movl $0x4000, %esi # imm = 0x4000
callq 0x50cbd2
xorl %r15d, %r15d
movq %r15, 0x110(%r14)
movq %r15, 0x120(%r14)
jmp 0x531532
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
archive_read_format_tar_cleanup
|
static int
archive_read_format_tar_cleanup(struct archive_read *a)
{
struct tar *tar;
tar = (struct tar *)(a->format->data);
gnu_clear_sparse_list(tar);
archive_string_free(&tar->acl_text);
archive_string_free(&tar->entry_pathname);
archive_string_free(&tar->entry_pathname_override);
archive_string_free(&tar->entry_linkpath);
archive_string_free(&tar->entry_uname);
archive_string_free(&tar->entry_gname);
archive_string_free(&tar->line);
archive_string_free(&tar->pax_global);
archive_string_free(&tar->pax_header);
archive_string_free(&tar->longname);
archive_string_free(&tar->longlink);
archive_string_free(&tar->localname);
free(tar);
(a->format->data) = NULL;
return (ARCHIVE_OK);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0x5317e0
movq (%rdi), %rax
movq %rax, 0x140(%r14)
callq 0x41e70
jmp 0x5317c3
xorl %r15d, %r15d
movq %r15, 0x148(%r14)
movq %r14, %rdi
callq 0x539f3f
leaq 0x18(%r14), %rdi
callq 0x539f3f
leaq 0x30(%r14), %rdi
callq 0x539f3f
leaq 0x48(%r14), %rdi
callq 0x539f3f
leaq 0x60(%r14), %rdi
callq 0x539f3f
leaq 0x78(%r14), %rdi
callq 0x539f3f
leaq 0xf0(%r14), %rdi
callq 0x539f3f
leaq 0xd8(%r14), %rdi
callq 0x539f3f
leaq 0xc0(%r14), %rdi
callq 0x539f3f
leaq 0xa8(%r14), %rdi
callq 0x539f3f
leaq 0x90(%r14), %rdi
callq 0x539f3f
leaq 0x170(%r14), %rdi
callq 0x539f3f
movq %r14, %rdi
callq 0x41e70
movq 0x818(%rbx), %rax
movq %r15, (%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
tar_atol_base_n
|
static int64_t
tar_atol_base_n(const char *p, size_t char_cnt, int base)
{
int64_t l, maxval, limit, last_digit_limit;
int digit, sign;
maxval = INT64_MAX;
limit = INT64_MAX / base;
last_digit_limit = INT64_MAX % base;
/* the pointer will not be dereferenced if char_cnt is zero
* due to the way the && operator is evaluated.
*/
while (char_cnt != 0 && (*p == ' ' || *p == '\t')) {
p++;
char_cnt--;
}
sign = 1;
if (char_cnt != 0 && *p == '-') {
sign = -1;
p++;
char_cnt--;
maxval = INT64_MIN;
limit = -(INT64_MIN / base);
last_digit_limit = -(INT64_MIN % base);
}
l = 0;
if (char_cnt != 0) {
digit = *p - '0';
while (digit >= 0 && digit < base && char_cnt != 0) {
if (l>limit || (l == limit && digit >= last_digit_limit)) {
return maxval; /* Truncate on overflow. */
}
l = (l * base) + digit;
digit = *++p - '0';
char_cnt--;
}
}
return (sign < 0) ? -l : l;
}
|
movl %edx, %ecx
movl %edx, %r10d
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movq %r8, %rax
xorl %edx, %edx
divq %r10
xorl %r9d, %r9d
testq %rsi, %rsi
je 0x531bb1
pushq %r14
pushq %rbx
xorl %r9d, %r9d
xorl %r11d, %r11d
movzbl (%rdi,%r11), %ebx
cmpl $0x9, %ebx
je 0x531af6
cmpl $0x20, %ebx
jne 0x531b03
incq %r11
cmpq %r11, %rsi
jne 0x531ae7
jmp 0x531bae
cmpl $0x2d, %ebx
jne 0x531b19
leaq -0x1(%rsi), %rax
cmpq %r11, %rax
jne 0x531b27
xorl %r9d, %r9d
jmp 0x531bae
subq %r11, %rsi
addq %r11, %rdi
xorl %r11d, %r11d
movq %rsi, %r9
jmp 0x531b5d
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cqto
idivq %r10
movq %r11, %r9
notq %r9
addq %rsi, %r9
negq %rdx
negq %rax
addq %r11, %rdi
incq %rdi
movb (%rdi), %bl
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
incq %r8
movb $0x1, %r11b
cmpb $0x30, %bl
jl 0x531b9a
xorl %r14d, %r14d
xorl %esi, %esi
movzbl %bl, %ebx
addl $-0x30, %ebx
cmpl %ecx, %ebx
jge 0x531b9c
cmpq %r14, %r9
je 0x531b9c
cmpq %rax, %rsi
jg 0x531bab
movl %ebx, %ebx
jne 0x531b84
cmpq %rbx, %rdx
jle 0x531bab
imulq %r10, %rsi
addq %rbx, %rsi
movb 0x1(%rdi,%r14), %bl
incq %r14
cmpb $0x2f, %bl
jg 0x531b67
jmp 0x531b9c
xorl %esi, %esi
movq %rsi, %r9
negq %r9
testb %r11b, %r11b
cmoveq %rsi, %r9
jmp 0x531bae
movq %r8, %r9
popq %rbx
popq %r14
movq %r9, %rax
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
tar_read_header
|
static int
tar_read_header(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, size_t *unconsumed)
{
ssize_t bytes;
int err, eof_vol_header;
const char *h;
const struct archive_entry_header_ustar *header;
const struct archive_entry_header_gnutar *gnuheader;
eof_vol_header = 0;
/* Loop until we find a workable header record. */
for (;;) {
tar_flush_unconsumed(a, unconsumed);
/* Read 512-byte header record */
h = __archive_read_ahead(a, 512, &bytes);
if (bytes < 0)
return ((int)bytes);
if (bytes == 0) { /* EOF at a block boundary. */
/* Some writers do omit the block of nulls. <sigh> */
return (ARCHIVE_EOF);
}
if (bytes < 512) { /* Short block at EOF; this is bad. */
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated tar archive");
return (ARCHIVE_FATAL);
}
*unconsumed = 512;
/* Header is workable if it's not an end-of-archive mark. */
if (h[0] != 0 || !archive_block_is_null(h))
break;
/* Ensure format is set for archives with only null blocks. */
if (a->archive.archive_format_name == NULL) {
a->archive.archive_format = ARCHIVE_FORMAT_TAR;
a->archive.archive_format_name = "tar";
}
if (!tar->read_concatenated_archives) {
/* Try to consume a second all-null record, as well. */
tar_flush_unconsumed(a, unconsumed);
h = __archive_read_ahead(a, 512, NULL);
if (h != NULL && h[0] == 0 && archive_block_is_null(h))
__archive_read_consume(a, 512);
archive_clear_error(&a->archive);
return (ARCHIVE_EOF);
}
/*
* We're reading concatenated archives, ignore this block and
* loop to get the next.
*/
}
/*
* Note: If the checksum fails and we return ARCHIVE_RETRY,
* then the client is likely to just retry. This is a very
* crude way to search for the next valid header!
*
* TODO: Improve this by implementing a real header scan.
*/
if (!checksum(a, h)) {
tar_flush_unconsumed(a, unconsumed);
archive_set_error(&a->archive, EINVAL, "Damaged tar archive");
return (ARCHIVE_RETRY); /* Retryable: Invalid header */
}
if (++tar->header_recursion_depth > 32) {
tar_flush_unconsumed(a, unconsumed);
archive_set_error(&a->archive, EINVAL, "Too many special headers");
return (ARCHIVE_WARN);
}
/* Determine the format variant. */
header = (const struct archive_entry_header_ustar *)h;
switch(header->typeflag[0]) {
case 'A': /* Solaris tar ACL */
a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
a->archive.archive_format_name = "Solaris tar";
err = header_Solaris_ACL(a, tar, entry, h, unconsumed);
break;
case 'g': /* POSIX-standard 'g' header. */
a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
a->archive.archive_format_name = "POSIX pax interchange format";
err = header_pax_global(a, tar, entry, h, unconsumed);
if (err == ARCHIVE_EOF)
return (err);
break;
case 'K': /* Long link name (GNU tar, others) */
err = header_longlink(a, tar, entry, h, unconsumed);
break;
case 'L': /* Long filename (GNU tar, others) */
err = header_longname(a, tar, entry, h, unconsumed);
break;
case 'V': /* GNU volume header */
err = header_volume(a, tar, entry, h, unconsumed);
if (err == ARCHIVE_EOF)
eof_vol_header = 1;
break;
case 'X': /* Used by SUN tar; same as 'x'. */
a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
a->archive.archive_format_name =
"POSIX pax interchange format (Sun variant)";
err = header_pax_extensions(a, tar, entry, h, unconsumed);
break;
case 'x': /* POSIX-standard 'x' header. */
a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
a->archive.archive_format_name = "POSIX pax interchange format";
err = header_pax_extensions(a, tar, entry, h, unconsumed);
break;
default:
gnuheader = (const struct archive_entry_header_gnutar *)h;
if (memcmp(gnuheader->magic, "ustar \0", 8) == 0) {
a->archive.archive_format = ARCHIVE_FORMAT_TAR_GNUTAR;
a->archive.archive_format_name = "GNU tar format";
err = header_gnutar(a, tar, entry, h, unconsumed);
} else if (memcmp(header->magic, "ustar", 5) == 0) {
if (a->archive.archive_format != ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE) {
a->archive.archive_format = ARCHIVE_FORMAT_TAR_USTAR;
a->archive.archive_format_name = "POSIX ustar format";
}
err = header_ustar(a, tar, entry, h);
} else {
a->archive.archive_format = ARCHIVE_FORMAT_TAR;
a->archive.archive_format_name = "tar (non-POSIX)";
err = header_old_tar(a, tar, entry, h);
}
}
if (err == ARCHIVE_FATAL)
return (err);
tar_flush_unconsumed(a, unconsumed);
h = NULL;
header = NULL;
--tar->header_recursion_depth;
/* Yuck. Apple's design here ends up storing long pathname
* extensions for both the AppleDouble extension entry and the
* regular entry.
*/
if ((err == ARCHIVE_WARN || err == ARCHIVE_OK) &&
tar->header_recursion_depth == 0 &&
tar->process_mac_extensions) {
int err2 = read_mac_metadata_blob(a, tar, entry, h, unconsumed);
if (err2 < err)
err = err2;
}
/* We return warnings or success as-is. Anything else is fatal. */
if (err == ARCHIVE_WARN || err == ARCHIVE_OK) {
if (tar->sparse_gnu_pending) {
if (tar->sparse_gnu_major == 1 &&
tar->sparse_gnu_minor == 0) {
ssize_t bytes_read;
tar->sparse_gnu_pending = 0;
/* Read initial sparse map. */
bytes_read = gnu_sparse_10_read(a, tar, unconsumed);
if (bytes_read < 0)
return ((int)bytes_read);
tar->entry_bytes_remaining -= bytes_read;
} else {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"Unrecognized GNU sparse file format");
return (ARCHIVE_WARN);
}
tar->sparse_gnu_pending = 0;
}
return (err);
}
if (err == ARCHIVE_EOF) {
if (!eof_vol_header) {
/* EOF when recursively reading a header is bad. */
archive_set_error(&a->archive, EINVAL,
"Damaged tar archive");
} else {
/* If we encounter just a GNU volume header treat
* this situation as an empty archive */
return (ARCHIVE_EOF);
}
}
return (ARCHIVE_FATAL);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rcx), %rsi
leaq 0x20(%rsp), %rbp
leaq 0x194ce6(%rip), %r14 # 0x6c68c6
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
je 0x531bf9
movq %r12, %rdi
callq 0x511e26
movq $0x0, (%rbx)
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
movq %rbp, %rdx
callq 0x511af8
movq %rax, %r13
movq 0x20(%rsp), %rax
testq %rax, %rax
js 0x531ea3
movl $0x1, %r12d
je 0x5323ea
cmpq $0x1ff, %rax # imm = 0x1FF
jbe 0x531eab
movq $0x200, (%rbx) # imm = 0x200
cmpb $0x0, (%r13)
jne 0x531cdc
movl $0x1, %eax
cmpl $0x200, %eax # imm = 0x200
je 0x531c5e
cmpb $0x0, (%r13,%rax)
leaq 0x1(%rax), %rax
je 0x531c49
jmp 0x531cdc
movq 0x8(%rsp), %r12
cmpq $0x0, 0x18(%r12)
jne 0x531c79
movl $0x30000, 0x10(%r12) # imm = 0x30000
movq %r14, 0x18(%r12)
movl $0x200, %esi # imm = 0x200
cmpl $0x0, 0x1b4(%r15)
jne 0x531be5
movq %r12, %rdi
callq 0x511e26
movq $0x0, (%rbx)
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x532312
cmpb $0x0, (%rax)
jne 0x532312
movl $0x1, %ecx
cmpl $0x200, %ecx # imm = 0x200
je 0x532305
cmpb $0x0, (%rax,%rcx)
leaq 0x1(%rcx), %rcx
je 0x531cc1
jmp 0x532312
movq %r13, %rdi
callq 0x531881
testl %eax, %eax
je 0x531d38
movl 0x10c(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10c(%r15)
cmpl $0x20, %eax
jl 0x531d72
movl $0x200, %esi # imm = 0x200
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x511e26
movq $0x0, (%rbx)
leaq 0x18c00b(%rip), %rdx # 0x6bdd29
movq %r14, %rdi
movl $0x16, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, %r12d # imm = 0xFFFFFFEC
jmp 0x5323ea
movl $0x200, %esi # imm = 0x200
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x511e26
movq $0x0, (%rbx)
leaq 0x18bfbd(%rip), %rdx # 0x6bdd15
movq %r14, %rdi
movl $0x16, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xfffffff6, %r12d # imm = 0xFFFFFFF6
jmp 0x5323ea
movzbl 0x9c(%r13), %eax
cmpl $0x55, %eax
jle 0x531db5
cmpl $0x66, %eax
jg 0x531e5f
cmpl $0x56, %eax
je 0x53201f
cmpl $0x58, %eax
movq %rbx, %r14
jne 0x531fbd
movq 0x8(%rsp), %rdi
movl $0x30002, 0x10(%rdi) # imm = 0x30002
leaq 0x18bfbb(%rip), %rax # 0x6bdd6b
jmp 0x531e87
cmpl $0x41, %eax
je 0x531ec1
cmpl $0x4b, %eax
je 0x53209b
cmpl $0x4c, %eax
movq %rbx, %r14
jne 0x531fbd
leaq 0xa8(%r15), %rsi
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x533d7b
movb $0x1, %r13b
testl %eax, %eax
jne 0x5320c4
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
movq %r14, %rcx
callq 0x531bb5
movl %eax, %ebp
testl %eax, %eax
je 0x531e1d
cmpl $-0x14, %ebp
jne 0x53215f
movq 0xa8(%r15), %rsi
movq 0xb0(%r15), %rdx
movq 0x190(%r15), %rcx
movq %r12, %rdi
callq 0x50d517
testl %eax, %eax
je 0x5322fd
movq 0x190(%r15), %rsi
leaq 0x18955f(%rip), %rdx # 0x6bb3af
movq 0x8(%rsp), %rdi
callq 0x533e48
jmp 0x53215a
cmpl $0x67, %eax
je 0x532042
cmpl $0x78, %eax
movq %rbx, %r14
jne 0x531fbd
movq 0x8(%rsp), %rdi
movl $0x30002, 0x10(%rdi) # imm = 0x30002
leaq 0x18bec7(%rip), %rax # 0x6bdd4e
movq %rax, 0x18(%rdi)
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x5325d2
jmp 0x53215a
movl %eax, %r12d
jmp 0x5323ea
leaq 0x18be4d(%rip), %rdx # 0x6bdcff
movq 0x8(%rsp), %rdi
movl $0x54, %esi
jmp 0x5323a9
movq 0x8(%rsp), %r12
movl $0x30002, 0x10(%r12) # imm = 0x30002
leaq 0x18be6c(%rip), %rax # 0x6bdd42
movq %rax, 0x18(%r12)
movq %r13, %rdi
addq $0x7c, %rdi
movl $0xc, %esi
callq 0x531a01
movq %rax, 0x18(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %r14
movq %rbx, %rcx
callq 0x533d7b
movb $0x1, %r13b
testl %eax, %eax
jne 0x5320c4
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x531bb5
testl %eax, %eax
je 0x531f32
movl %eax, %ebp
cmpl $-0x14, %eax
jne 0x53215f
movq (%r15), %rax
movb (%rax), %dl
testb %dl, %dl
setne %cl
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
setg %sil
andb %cl, %sil
xorl %ecx, %ecx
cmpb $0x1, %sil
jne 0x5322e0
addq %rax, %rdi
xorl %ecx, %ecx
movq %rax, %r13
leal -0x38(%rdx), %eax
cmpb $-0x9, %al
jbe 0x5323fc
addb $-0x30, %dl
movzbl %dl, %eax
leaq (%rax,%rcx,8), %rcx
cmpq $0x1000000, %rcx # imm = 0x1000000
jge 0x532408
leaq 0x1(%r13), %rax
movb 0x1(%r13), %dl
testb %dl, %dl
je 0x531f92
cmpq %rdi, %rax
jb 0x531f5c
movl %ecx, %edx
andl $0xfffc0000, %edx # imm = 0xFFFC0000
cmpl $0x40000, %edx # imm = 0x40000
je 0x532414
cmpl $0xc0000, %edx # imm = 0xC0000
jne 0x5322e0
movl $0x3c00, %r12d # imm = 0x3C00
jmp 0x53241a
movabsq $0x20207261747375, %rax # imm = 0x20207261747375
cmpq %rax, 0x101(%r13)
je 0x5320cb
movl $0x61747375, %eax # imm = 0x61747375
xorl 0x101(%r13), %eax
movzbl 0x105(%r13), %ecx
xorl $0x72, %ecx
orl %eax, %ecx
movq 0x10(%rsp), %rdx
je 0x53212f
movq 0x8(%rsp), %rdi
movl $0x30000, 0x10(%rdi) # imm = 0x30000
leaq 0x18bdad(%rip), %rax # 0x6bddb8
movq %rax, 0x18(%rdi)
movq %r15, %rsi
movq %r13, %rcx
callq 0x533bb2
jmp 0x53215a
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x531bb5
movl %eax, %ebp
cmpl $0x1, %eax
setne %r13b
jmp 0x53215f
movq 0x8(%rsp), %r14
movl $0x30002, 0x10(%r14) # imm = 0x30002
leaq 0x18bcf8(%rip), %rax # 0x6bdd4e
movq %rax, 0x18(%r14)
leaq 0xd8(%r15), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rbx, %r13
movq %rbx, %rcx
callq 0x533d7b
testl %eax, %eax
jne 0x53215a
movq %r14, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
callq 0x531bb5
cmpl $0x1, %eax
jne 0x53215a
jmp 0x5323ea
leaq 0x90(%r15), %rsi
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rsi, 0x18(%rsp)
movq %r13, %rdx
movq %rbx, %r14
movq %rbx, %rcx
callq 0x533d7b
movb $0x1, %r13b
testl %eax, %eax
je 0x5320f7
movl %eax, %ebp
jmp 0x53215f
movq 0x8(%rsp), %rdi
movl $0x30004, 0x10(%rdi) # imm = 0x30004
leaq 0x18bcb8(%rip), %rax # 0x6bdd96
movq %rax, 0x18(%rdi)
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x533729
jmp 0x53215a
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
movq %r14, %rcx
callq 0x531bb5
testl %eax, %eax
je 0x532118
movl %eax, %ebp
cmpl $-0x14, %eax
jne 0x53215f
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x50d368
movb $0x1, %r13b
xorl %ebp, %ebp
jmp 0x53216e
movq 0x8(%rsp), %rdi
cmpl $0x30002, 0x10(%rdi) # imm = 0x30002
je 0x53214f
movl $0x30001, 0x10(%rdi) # imm = 0x30001
leaq 0x18bc5a(%rip), %rax # 0x6bdda5
movq %rax, 0x18(%rdi)
movq %r15, %rsi
movq %r13, %rcx
callq 0x5339ef
movl %eax, %ebp
movb $0x1, %r13b
movl $0xffffffe2, %r12d # imm = 0xFFFFFFE2
cmpl $-0x1e, %ebp
je 0x5323ea
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x532187
movq 0x8(%rsp), %rdi
callq 0x511e26
movq $0x0, (%rbx)
movl 0x10c(%r15), %eax
decl %eax
movl %eax, 0x10c(%r15)
testl %ebp, %ebp
je 0x5321a4
cmpl $-0x14, %ebp
jne 0x53233d
testl %eax, %eax
movq 0x10(%rsp), %r14
jne 0x53233d
cmpl $0x0, 0x1b0(%r15)
je 0x53233d
movq %r14, %rdi
callq 0x50c87f
testq %rax, %rax
je 0x53220a
movq %rax, %rcx
addq $0x4, %rax
movl -0x4(%rax), %edx
cmpl $0x2f, %edx
je 0x5321e1
testl %edx, %edx
jne 0x5321cf
jmp 0x5321ea
cmpl $0x0, (%rax)
cmovneq %rax, %rcx
jmp 0x5321cf
xorl %eax, %eax
cmpl $0x2e, (%rcx)
jne 0x532338
cmpl $0x5f, 0x4(%rcx)
jne 0x532338
cmpl $0x0, 0x8(%rcx)
jne 0x532258
jmp 0x532338
movq %r14, %rdi
callq 0x50c801
testq %rax, %rax
je 0x532325
movq %rax, %rcx
incq %rax
movzbl -0x1(%rax), %edx
cmpl $0x2f, %edx
je 0x532230
testl %edx, %edx
jne 0x53221e
jmp 0x532239
cmpb $0x0, (%rax)
cmovneq %rax, %rcx
jmp 0x53221e
xorl %eax, %eax
cmpb $0x2e, (%rcx)
jne 0x532338
cmpb $0x5f, 0x1(%rcx)
jne 0x532338
cmpb $0x0, 0x2(%rcx)
je 0x532338
movq %r14, %rdi
callq 0x50c953
testq %rax, %rax
js 0x53232c
movq %rax, %r12
movq 0x8(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x53232c
movb %r13b, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x50c081
addq $0x1ff, %r12 # imm = 0x1FF
andq $-0x200, %r12 # imm = 0xFE00
movq %rbx, %r14
movq %r12, (%rbx)
movq 0x8(%rsp), %r13
je 0x5322c6
movq %r13, %rdi
movq %r12, %rsi
callq 0x511e26
movq $0x0, (%r14)
movq %r13, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x531bb5
movb 0x18(%rsp), %r13b
jmp 0x532338
leaq 0x18bb67(%rip), %rdx # 0x6bde4e
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
jmp 0x5324f7
movb $0x1, %r13b
jmp 0x53216e
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
callq 0x511e26
movq %r12, %rdi
callq 0x53e1f2
movl $0x1, %r12d
jmp 0x5323ea
movl $0xffffffe7, %eax # imm = 0xFFFFFFE7
jmp 0x532338
movq $0x0, (%rbx)
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl $-0x14, %ebp
je 0x532355
cmpl $0x1, %ebp
je 0x53238d
movl $0xffffffe2, %r12d # imm = 0xFFFFFFE2
testl %ebp, %ebp
jne 0x5323ea
cmpb $0x0, 0x168(%r15)
je 0x5323e7
cmpl $0x1, 0x160(%r15)
jne 0x532377
cmpl $0x0, 0x164(%r15)
je 0x5323b8
leaq 0x18ba4a(%rip), %rdx # 0x6bddc8
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jmp 0x531d26
movl $0x1, %r12d
testb %r13b, %r13b
je 0x5323ea
leaq 0x18b976(%rip), %rdx # 0x6bdd15
movq 0x8(%rsp), %rdi
movl $0x16, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %r12d # imm = 0xFFFFFFE2
jmp 0x5323ea
movb $0x0, 0x168(%r15)
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x533c4a
movq %rax, %r12
testq %rax, %rax
js 0x5323ea
subq %r12, 0x110(%r15)
movb $0x0, 0x168(%r15)
movl %ebp, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18b9e9(%rip), %rdx # 0x6bddec
jmp 0x5324e6
leaq 0x18ba0d(%rip), %rdx # 0x6bde1c
jmp 0x5324e6
movl $0x100, %r12d # imm = 0x100
addq $0x2, %r13
cmpq %rdi, %r13
jae 0x5324df
movl $0x1, %ecx
leaq 0x1(%rcx), %rbp
cmpb $0x0, (%rax,%rcx)
je 0x532441
addq %rax, %rcx
cmpq %rdi, %rcx
movq %rbp, %rcx
jb 0x53242c
cmpq $0x0, 0x198(%r15)
movq 0x10(%rsp), %r14
jne 0x532476
leaq 0x18bda4(%rip), %rsi # 0x6be1fb
movq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x53a664
movq %rax, 0x198(%r15)
testq %rax, %rax
je 0x5323b0
leaq 0x170(%r15), %rdi
movq $0x0, 0x178(%r15)
addq $-0x2, %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0x53a01f
movq %r14, %rdi
callq 0x50d912
movq 0x170(%r15), %rsi
movq 0x198(%r15), %rcx
movq %rax, %rdi
movl %r12d, %edx
callq 0x55d262
testl %eax, %eax
je 0x532128
movl %eax, %ebp
callq 0x415e0
cmpl $0xc, (%rax)
jne 0x532504
leaq 0x18b9e1(%rip), %rdx # 0x6bdeb4
movq 0x8(%rsp), %rdi
movl $0xc, %esi
jmp 0x532515
leaq 0x18b99e(%rip), %rdx # 0x6bde84
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movb $0x1, %r13b
movl $0xffffffec, %ebp # imm = 0xFFFFFFEC
jmp 0x53216e
leaq 0x18b9c7(%rip), %rdx # 0x6bded2
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
jmp 0x53215c
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
gnu_add_sparse_entry
|
static int
gnu_add_sparse_entry(struct archive_read *a, struct tar *tar,
int64_t offset, int64_t remaining)
{
struct sparse_block *p;
p = (struct sparse_block *)calloc(1, sizeof(*p));
if (p == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
if (tar->sparse_last != NULL)
tar->sparse_last->next = p;
else
tar->sparse_list = p;
tar->sparse_last = p;
if (remaining < 0 || offset < 0 || offset > INT64_MAX - remaining) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Malformed sparse map data");
return (ARCHIVE_FATAL);
}
p->offset = offset;
p->remaining = remaining;
return (ARCHIVE_OK);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x41eb8
testq %rax, %rax
je 0x53259f
movq 0x148(%r12), %rcx
leaq 0x140(%r12), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %rax, 0x148(%r12)
movq %r14, %rcx
orq %r15, %rcx
sets %cl
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
xorq %r14, %rdx
cmpq %r15, %rdx
setl %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x5325bc
leaq 0x18bd2b(%rip), %rdx # 0x6be2c0
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jmp 0x5325ae
leaq 0x13176f(%rip), %rdx # 0x663d15
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x5325c6
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
header_ustar
|
static int
header_ustar(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h)
{
const struct archive_entry_header_ustar *header;
struct archive_string *as;
int err = ARCHIVE_OK, r;
header = (const struct archive_entry_header_ustar *)h;
/* Copy name into an internal buffer to ensure null-termination. */
as = &(tar->entry_pathname);
if (header->prefix[0]) {
archive_strncpy(as, header->prefix, sizeof(header->prefix));
if (as->s[archive_strlen(as) - 1] != '/')
archive_strappend_char(as, '/');
archive_strncat(as, header->name, sizeof(header->name));
} else {
archive_strncpy(as, header->name, sizeof(header->name));
}
if (archive_entry_copy_pathname_l(entry, as->s, archive_strlen(as),
tar->sconv) != 0) {
err = set_conversion_failed_error(a, tar->sconv, "Pathname");
if (err == ARCHIVE_FATAL)
return (err);
}
/* Handle rest of common fields. */
r = header_common(a, tar, entry, h);
if (r == ARCHIVE_FATAL)
return (r);
if (r < err)
err = r;
/* Handle POSIX ustar fields. */
if (archive_entry_copy_uname_l(entry,
header->uname, sizeof(header->uname), tar->sconv) != 0) {
err = set_conversion_failed_error(a, tar->sconv, "Uname");
if (err == ARCHIVE_FATAL)
return (err);
}
if (archive_entry_copy_gname_l(entry,
header->gname, sizeof(header->gname), tar->sconv) != 0) {
err = set_conversion_failed_error(a, tar->sconv, "Gname");
if (err == ARCHIVE_FATAL)
return (err);
}
/* Parse out device numbers only for char and block specials. */
if (header->typeflag[0] == '3' || header->typeflag[0] == '4') {
archive_entry_set_rdevmajor(entry, (dev_t)
tar_atol(header->rdevmajor, sizeof(header->rdevmajor)));
archive_entry_set_rdevminor(entry, (dev_t)
tar_atol(header->rdevminor, sizeof(header->rdevminor)));
}
tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
return (err);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18(%rsi), %r13
cmpb $0x0, 0x159(%rcx)
movq $0x0, 0x20(%rsi)
je 0x533a4b
leaq 0x159(%r15), %rsi
movl $0x9b, %edx
movq %r13, %rdi
callq 0x53a01f
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x533a4b
movq %r13, %rdi
movl $0x2f, %esi
callq 0x53a0ad
movl $0x64, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x53a01f
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq 0x190(%rbx), %rcx
movq %r14, %rdi
callq 0x50d517
testl %eax, %eax
je 0x533a9e
movq 0x190(%rbx), %rsi
leaq 0x18792b(%rip), %rdx # 0x6bb3af
movq %r12, %rdi
callq 0x533e48
movl %eax, %ebp
movl $0xffffffe2, %r13d # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
jne 0x533aa0
jmp 0x533ba0
xorl %ebp, %ebp
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x53425a
movl $0xffffffe2, %r13d # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x533ba0
cmpl %ebp, %eax
cmovll %eax, %ebp
leaq 0x109(%r15), %rsi
movq 0x190(%rbx), %rcx
movl $0x20, %edx
movq %r14, %rdi
callq 0x50d7fe
testl %eax, %eax
je 0x533b05
movq 0x190(%rbx), %rsi
leaq 0x192e2e(%rip), %rdx # 0x6c6920
movq %r12, %rdi
callq 0x533e48
movl %eax, %ebp
cmpl $-0x1e, %eax
je 0x533ba0
leaq 0x129(%r15), %rsi
movq 0x190(%rbx), %rcx
movl $0x20, %edx
movq %r14, %rdi
callq 0x50cfc5
testl %eax, %eax
je 0x533b41
movq 0x190(%rbx), %rsi
leaq 0x192e2f(%rip), %rdx # 0x6c6961
movq %r12, %rdi
callq 0x533e48
movl %eax, %ebp
cmpl $-0x1e, %eax
je 0x533ba0
movb 0x9c(%r15), %al
addb $-0x33, %al
cmpb $0x1, %al
ja 0x533b89
leaq 0x149(%r15), %rdi
movl $0x8, %esi
callq 0x531a01
movq %r14, %rdi
movq %rax, %rsi
callq 0x50d557
addq $0x151, %r15 # imm = 0x151
movl $0x8, %esi
movq %r15, %rdi
callq 0x531a01
movq %r14, %rdi
movq %rax, %rsi
callq 0x50d570
xorl %eax, %eax
subl 0x110(%rbx), %eax
andl $0x1ff, %eax # imm = 0x1FF
movq %rax, 0x120(%rbx)
movl %ebp, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
header_old_tar
|
static int
header_old_tar(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h)
{
const struct archive_entry_header_ustar *header;
int err = ARCHIVE_OK, err2;
/* Copy filename over (to ensure null termination). */
header = (const struct archive_entry_header_ustar *)h;
if (archive_entry_copy_pathname_l(entry,
header->name, sizeof(header->name), tar->sconv) != 0) {
err = set_conversion_failed_error(a, tar->sconv, "Pathname");
if (err == ARCHIVE_FATAL)
return (err);
}
/* Grab rest of common fields */
err2 = header_common(a, tar, entry, h);
if (err > err2)
err = err2;
tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
return (err);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x190(%rsi), %rcx
movl $0x64, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x50d517
xorl %r13d, %r13d
movl $0x0, %ebp
testl %eax, %eax
je 0x533c10
movq 0x190(%rbx), %rsi
leaq 0x1877b5(%rip), %rdx # 0x6bb3af
movq %r12, %rdi
callq 0x533e48
movl %eax, %ebp
cmpl $-0x1e, %eax
jne 0x533c10
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x533c3b
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x53425a
cmpl %eax, %ebp
cmovll %ebp, %eax
subl 0x110(%rbx), %r13d
andl $0x1ff, %r13d # imm = 0x1FF
movq %r13, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
read_body_to_string
|
static int
read_body_to_string(struct archive_read *a, struct tar *tar,
struct archive_string *as, const void *h, size_t *unconsumed)
{
int64_t size;
const struct archive_entry_header_ustar *header;
const void *src;
(void)tar; /* UNUSED */
header = (const struct archive_entry_header_ustar *)h;
size = tar_atol(header->size, sizeof(header->size));
if ((size > 1048576) || (size < 0)) {
archive_set_error(&a->archive, EINVAL,
"Special header too large");
return (ARCHIVE_FATAL);
}
/* Fail if we can't make our buffer big enough. */
if (archive_string_ensure(as, (size_t)size+1) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory");
return (ARCHIVE_FATAL);
}
tar_flush_unconsumed(a, unconsumed);
/* Read the body into the string. */
*unconsumed = (size_t)((size + 511) & ~ 511);
src = __archive_read_ahead(a, *unconsumed, NULL);
if (src == NULL) {
*unconsumed = 0;
return (ARCHIVE_FATAL);
}
memcpy(as->s, src, (size_t)size);
as->s[size] = '\0';
as->length = (size_t)size;
return (ARCHIVE_OK);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x7c(%rdx), %rdi
movl $0xc, %esi
callq 0x531a01
cmpq $0x100001, %rax # imm = 0x100001
jb 0x533db4
leaq 0x18a155(%rip), %rdx # 0x6bdeff
movq %r12, %rdi
movl $0x16, %esi
jmp 0x533e25
movq %rax, %r15
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x539f80
testq %rax, %rax
je 0x533e16
movq (%r14), %rsi
testq %rsi, %rsi
je 0x533dd8
movq %r12, %rdi
callq 0x511e26
leal 0x1ff(%r15), %esi
andl $0x3ffe00, %esi # imm = 0x3FFE00
movq %rsi, (%r14)
xorl %r13d, %r13d
movq %r12, %rdi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x533e3f
movq (%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3f250
movq (%rbx), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%rbx)
jmp 0x533e32
leaq 0x185157(%rip), %rdx # 0x6b8f74
movq %r12, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %r13d # imm = 0xFFFFFFE2
movl %r13d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq $0x0, (%r14)
jmp 0x533e2c
|
/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)))
!= ARCHIVE_OK)
return (ARCHIVE_FATAL);
sparse++;
length--;
}
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x5345d8
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
incl %ebp
cmpb $0x0, (%r14)
je 0x5345d8
movl $0xc, %esi
movq %r14, %rdi
callq 0x531a01
movq %rax, %r13
addq $0xc, %r14
movl $0xc, %esi
movq %r14, %rdi
callq 0x531a01
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x532521
testl %eax, %eax
jne 0x5345d3
decl %ebp
addq $0xc, %r14
cmpl $0x1, %ebp
jg 0x53458a
jmp 0x5345d8
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c
|
warc_read
|
static int
_warc_read(struct archive_read *a, const void **buf, size_t *bsz, int64_t *off)
{
struct warc_s *w = a->format->data;
const char *rab;
ssize_t nrd;
if (w->cntoff >= w->cntlen) {
eof:
/* it's our lucky day, no work, we can leave early */
*buf = NULL;
*bsz = 0U;
*off = w->cntoff + 4U/*for \r\n\r\n separator*/;
w->unconsumed = 0U;
return (ARCHIVE_EOF);
}
if (w->unconsumed) {
__archive_read_consume(a, w->unconsumed);
w->unconsumed = 0U;
}
rab = __archive_read_ahead(a, 1U, &nrd);
if (nrd < 0) {
*bsz = 0U;
/* big catastrophe */
return (int)nrd;
} else if (nrd == 0) {
goto eof;
} else if ((size_t)nrd > w->cntlen - w->cntoff) {
/* clamp to content-length */
nrd = w->cntlen - w->cntoff;
}
*off = w->cntoff;
*bsz = nrd;
*buf = rab;
w->cntoff += nrd;
w->unconsumed = (size_t)nrd;
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x818(%rdi), %rax
movq (%rax), %rbp
movq 0x8(%rbp), %rax
cmpq (%rbp), %rax
jae 0x535078
movq %rdi, %r12
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x535030
movq %r12, %rdi
callq 0x511e26
movq $0x0, 0x10(%rbp)
movq %rsp, %r13
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x511af8
movq %rax, %rcx
movq (%r13), %rax
testq %rax, %rax
js 0x535096
je 0x535078
movq (%rbp), %rdx
movq 0x8(%rbp), %rsi
subq %rsi, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %rsi, (%rbx)
movq %rdx, (%r14)
movq %rcx, (%r15)
addq %rdx, 0x8(%rbp)
movq %rdx, 0x10(%rbp)
xorl %eax, %eax
jmp 0x53509d
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r14)
movq 0x8(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, (%rbx)
movq %rax, 0x10(%rbp)
movl $0x1, %eax
jmp 0x53509d
movq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c
|
warc_cleanup
|
static int
_warc_cleanup(struct archive_read *a)
{
struct warc_s *w = a->format->data;
if (w->pool.len > 0U) {
free(w->pool.str);
}
archive_string_free(&w->sver);
free(w);
a->format->data = NULL;
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x5350ee
movq 0x20(%r14), %rdi
callq 0x41e70
leaq 0x30(%r14), %rdi
callq 0x539f3f
movq %r14, %rdi
callq 0x41e70
movq 0x818(%rbx), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c
|
archive_read_format_zip_streamable_read_header
|
static int
archive_read_format_zip_streamable_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct zip *zip;
a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
if (a->archive.archive_format_name == NULL)
a->archive.archive_format_name = "ZIP";
zip = (struct zip *)(a->format->data);
/*
* It should be sufficient to call archive_read_next_header() for
* a reader to determine if an entry is encrypted or not. If the
* encryption of an entry is only detectable when calling
* archive_read_data(), so be it. We'll do the same check there
* as well.
*/
if (zip->has_encrypted_entries ==
ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW)
zip->has_encrypted_entries = 0;
/* Make sure we have a zip_entry structure to use. */
if (zip->zip_entries == NULL) {
zip->zip_entries = malloc(sizeof(struct zip_entry));
if (zip->zip_entries == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Out of memory");
return ARCHIVE_FATAL;
}
}
zip->entry = zip->zip_entries;
memset(zip->entry, 0, sizeof(struct zip_entry));
if (zip->cctx_valid)
archive_decrypto_aes_ctr_release(&zip->cctx);
if (zip->hctx_valid)
archive_hmac_sha1_cleanup(&zip->hctx);
zip->tctx_valid = zip->cctx_valid = zip->hctx_valid = 0;
__archive_read_reset_passphrase(a);
/* Search ahead for the next local file header. */
__archive_read_consume(a, zip->unconsumed);
zip->unconsumed = 0;
for (;;) {
int64_t skipped = 0;
const char *p, *end;
ssize_t bytes;
p = __archive_read_ahead(a, 4, &bytes);
if (p == NULL)
return (ARCHIVE_FATAL);
end = p + bytes;
while (p + 4 <= end) {
if (p[0] == 'P' && p[1] == 'K') {
if (p[2] == '\003' && p[3] == '\004') {
/* Regular file entry. */
__archive_read_consume(a, skipped);
return zip_read_local_file_header(a,
entry, zip);
}
/*
* TODO: We cannot restore permissions
* based only on the local file headers.
* Consider scanning the central
* directory and returning additional
* entries for at least directories.
* This would allow us to properly set
* directory permissions.
*
* This won't help us fix symlinks
* and may not help with regular file
* permissions, either. <sigh>
*/
if (p[2] == '\001' && p[3] == '\002') {
return (ARCHIVE_EOF);
}
/* End of central directory? Must be an
* empty archive. */
if ((p[2] == '\005' && p[3] == '\006')
|| (p[2] == '\006' && p[3] == '\006'))
return (ARCHIVE_EOF);
}
++p;
++skipped;
}
__archive_read_consume(a, skipped);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50000, 0x10(%rdi) # imm = 0x50000
cmpq $0x0, 0x18(%rdi)
jne 0x535ac7
leaq 0x185355(%rip), %rax # 0x6bae18
movq %rax, 0x18(%rbx)
movq 0x818(%rbx), %rax
movq (%rax), %r15
cmpl $-0x1, 0x38(%r15)
jne 0x535ae0
movl $0x0, 0x38(%r15)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
jne 0x535b03
movl $0x90, %edi
callq 0x41ec0
movq %rax, %rdi
movq %rax, 0x40(%r15)
testq %rax, %rax
je 0x535c33
movq %rdi, 0x70(%r15)
movl $0x90, %edx
xorl %esi, %esi
callq 0x3fa90
cmpb $0x0, 0x1fe0(%r15)
je 0x535b2e
leaq 0x3265d4(%rip), %rax # 0x85c0f8
leaq 0x1f88(%r15), %rdi
callq *0x18(%rax)
cmpb $0x0, 0x1ff0(%r15)
je 0x535b49
leaq 0x3277a1(%rip), %rax # 0x85d2e0
leaq 0x1fe8(%r15), %rdi
callq *0x18(%rax)
xorl %eax, %eax
movb %al, 0x1ff0(%r15)
movb %al, 0x1fe0(%r15)
movb %al, 0x1f84(%r15)
movq %rbx, %rdi
callq 0x564493
movq 0x68(%r15), %rsi
movq %rbx, %rdi
callq 0x511e26
movq $0x0, 0x68(%r15)
movq %rsp, %rdx
movl $0x4, %esi
movq %rbx, %rdi
callq 0x511af8
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testq %rax, %rax
je 0x535c68
movq %rsp, %r12
leaq 0x1888dc(%rip), %r13 # 0x6be480
movq (%rsp), %rcx
cmpq $0x4, %rcx
jge 0x535bb2
xorl %esi, %esi
jmp 0x535c09
addq %rax, %rcx
addq $0x3, %rax
xorl %esi, %esi
cmpb $0x50, -0x3(%rax,%rsi)
jne 0x535bf5
cmpb $0x4b, -0x2(%rax,%rsi)
jne 0x535bf5
movzbl -0x1(%rax,%rsi), %edx
decl %edx
cmpl $0x5, %edx
ja 0x535bf5
movslq (%r13,%rdx,4), %rdx
addq %r13, %rdx
jmpq *%rdx
cmpb $0x6, (%rax,%rsi)
jne 0x535bf5
jmp 0x535c2c
cmpb $0x2, (%rax,%rsi)
jne 0x535bf5
jmp 0x535c2c
cmpb $0x4, (%rax,%rsi)
je 0x535c50
leaq (%rax,%rsi), %rdx
addq $-0x3, %rdx
incq %rsi
addq $0x5, %rdx
cmpq %rcx, %rdx
jbe 0x535bbb
movq %rbx, %rdi
callq 0x511e26
movl $0x4, %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x511af8
testq %rax, %rax
jne 0x535ba4
jmp 0x535c68
movl $0x1, %ebp
jmp 0x535c68
leaq 0x188955(%rip), %rdx # 0x6be58f
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x535c68
movq %rbx, %rdi
callq 0x511e26
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x536e29
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
zip_read_local_file_header
|
static int
zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry,
struct zip *zip)
{
const char *p;
const void *h;
const wchar_t *wp;
const char *cp;
size_t len, filename_length, extra_length;
struct archive_string_conv *sconv;
struct zip_entry *zip_entry = zip->entry;
struct zip_entry zip_entry_central_dir;
int ret = ARCHIVE_OK;
char version;
/* Save a copy of the original for consistency checks. */
zip_entry_central_dir = *zip_entry;
zip->decompress_init = 0;
zip->end_of_entry = 0;
zip->entry_uncompressed_bytes_read = 0;
zip->entry_compressed_bytes_read = 0;
zip->entry_crc32 = zip->crc32func(0, NULL, 0);
/* Setup default conversion. */
if (zip->sconv == NULL && !zip->init_default_conversion) {
zip->sconv_default =
archive_string_default_conversion_for_read(&(a->archive));
zip->init_default_conversion = 1;
}
if ((p = __archive_read_ahead(a, 30, NULL)) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP file header");
return (ARCHIVE_FATAL);
}
if (memcmp(p, "PK\003\004", 4) != 0) {
archive_set_error(&a->archive, -1, "Damaged Zip archive");
return ARCHIVE_FATAL;
}
version = p[4];
zip_entry->system = p[5];
zip_entry->zip_flags = archive_le16dec(p + 6);
if (zip_entry->zip_flags & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)) {
zip->has_encrypted_entries = 1;
archive_entry_set_is_data_encrypted(entry, 1);
if (zip_entry->zip_flags & ZIP_CENTRAL_DIRECTORY_ENCRYPTED &&
zip_entry->zip_flags & ZIP_ENCRYPTED &&
zip_entry->zip_flags & ZIP_STRONG_ENCRYPTED) {
archive_entry_set_is_metadata_encrypted(entry, 1);
return ARCHIVE_FATAL;
}
}
zip->init_decryption = (zip_entry->zip_flags & ZIP_ENCRYPTED);
zip_entry->compression = (char)archive_le16dec(p + 8);
zip_entry->mtime = zip_time(p + 10);
zip_entry->crc32 = archive_le32dec(p + 14);
if (zip_entry->zip_flags & ZIP_LENGTH_AT_END)
zip_entry->decdat = p[11];
else
zip_entry->decdat = p[17];
zip_entry->compressed_size = archive_le32dec(p + 18);
zip_entry->uncompressed_size = archive_le32dec(p + 22);
filename_length = archive_le16dec(p + 26);
extra_length = archive_le16dec(p + 28);
__archive_read_consume(a, 30);
/* Read the filename. */
if ((h = __archive_read_ahead(a, filename_length, NULL)) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP file header");
return (ARCHIVE_FATAL);
}
if (zip_entry->zip_flags & ZIP_UTF8_NAME) {
/* The filename is stored to be UTF-8. */
if (zip->sconv_utf8 == NULL) {
zip->sconv_utf8 =
archive_string_conversion_from_charset(
&a->archive, "UTF-8", 1);
if (zip->sconv_utf8 == NULL)
return (ARCHIVE_FATAL);
}
sconv = zip->sconv_utf8;
} else if (zip->sconv != NULL)
sconv = zip->sconv;
else
sconv = zip->sconv_default;
if (archive_entry_copy_pathname_l(entry,
h, filename_length, sconv) != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Pathname cannot be converted "
"from %s to current locale.",
archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
__archive_read_consume(a, filename_length);
/* Read the extra data. */
if ((h = __archive_read_ahead(a, extra_length, NULL)) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP file header");
return (ARCHIVE_FATAL);
}
if (ARCHIVE_OK != process_extra(a, entry, h, extra_length,
zip_entry)) {
return ARCHIVE_FATAL;
}
__archive_read_consume(a, extra_length);
/* Work around a bug in Info-Zip: When reading from a pipe, it
* stats the pipe instead of synthesizing a file entry. */
if ((zip_entry->mode & AE_IFMT) == AE_IFIFO) {
zip_entry->mode &= ~ AE_IFMT;
zip_entry->mode |= AE_IFREG;
}
/* If the mode is totally empty, set some sane default. */
if (zip_entry->mode == 0) {
zip_entry->mode |= 0664;
}
/* Windows archivers sometimes use backslash as the directory
* separator. Normalize to slash. */
if (zip_entry->system == 0 &&
(wp = archive_entry_pathname_w(entry)) != NULL) {
if (wcschr(wp, L'/') == NULL && wcschr(wp, L'\\') != NULL) {
size_t i;
struct archive_wstring s;
archive_string_init(&s);
archive_wstrcpy(&s, wp);
for (i = 0; i < archive_strlen(&s); i++) {
if (s.s[i] == '\\')
s.s[i] = '/';
}
archive_entry_copy_pathname_w(entry, s.s);
archive_wstring_free(&s);
}
}
/* Make sure that entries with a trailing '/' are marked as directories
* even if the External File Attributes contains bogus values. If this
* is not a directory and there is no type, assume a regular file. */
if ((zip_entry->mode & AE_IFMT) != AE_IFDIR) {
int has_slash;
wp = archive_entry_pathname_w(entry);
if (wp != NULL) {
len = wcslen(wp);
has_slash = len > 0 && wp[len - 1] == L'/';
} else {
cp = archive_entry_pathname(entry);
len = (cp != NULL)?strlen(cp):0;
has_slash = len > 0 && cp[len - 1] == '/';
}
/* Correct file type as needed. */
if (has_slash) {
zip_entry->mode &= ~AE_IFMT;
zip_entry->mode |= AE_IFDIR;
zip_entry->mode |= 0111;
} else if ((zip_entry->mode & AE_IFMT) == 0) {
zip_entry->mode |= AE_IFREG;
}
}
/* Make sure directories end in '/' */
if ((zip_entry->mode & AE_IFMT) == AE_IFDIR) {
wp = archive_entry_pathname_w(entry);
if (wp != NULL) {
len = wcslen(wp);
if (len > 0 && wp[len - 1] != L'/') {
struct archive_wstring s;
archive_string_init(&s);
archive_wstrcat(&s, wp);
archive_wstrappend_wchar(&s, L'/');
archive_entry_copy_pathname_w(entry, s.s);
archive_wstring_free(&s);
}
} else {
cp = archive_entry_pathname(entry);
len = (cp != NULL)?strlen(cp):0;
if (len > 0 && cp[len - 1] != '/') {
struct archive_string s;
archive_string_init(&s);
archive_strcat(&s, cp);
archive_strappend_char(&s, '/');
archive_entry_set_pathname(entry, s.s);
archive_string_free(&s);
}
}
}
if (zip_entry->flags & LA_FROM_CENTRAL_DIRECTORY) {
/* If this came from the central dir, its size info
* is definitive, so ignore the length-at-end flag. */
zip_entry->zip_flags &= ~ZIP_LENGTH_AT_END;
/* If local header is missing a value, use the one from
the central directory. If both have it, warn about
mismatches. */
if (zip_entry->crc32 == 0) {
zip_entry->crc32 = zip_entry_central_dir.crc32;
} else if (!zip->ignore_crc32
&& zip_entry->crc32 != zip_entry_central_dir.crc32) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Inconsistent CRC32 values");
ret = ARCHIVE_WARN;
}
if (zip_entry->compressed_size == 0) {
zip_entry->compressed_size
= zip_entry_central_dir.compressed_size;
} else if (zip_entry->compressed_size
!= zip_entry_central_dir.compressed_size) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Inconsistent compressed size: "
"%jd in central directory, %jd in local header",
(intmax_t)zip_entry_central_dir.compressed_size,
(intmax_t)zip_entry->compressed_size);
ret = ARCHIVE_WARN;
}
if (zip_entry->uncompressed_size == 0 ||
zip_entry->uncompressed_size == 0xffffffff) {
zip_entry->uncompressed_size
= zip_entry_central_dir.uncompressed_size;
} else if (zip_entry->uncompressed_size
!= zip_entry_central_dir.uncompressed_size) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Inconsistent uncompressed size: "
"%jd in central directory, %jd in local header",
(intmax_t)zip_entry_central_dir.uncompressed_size,
(intmax_t)zip_entry->uncompressed_size);
ret = ARCHIVE_WARN;
}
}
/* Populate some additional entry fields: */
archive_entry_set_mode(entry, zip_entry->mode);
archive_entry_set_uid(entry, zip_entry->uid);
archive_entry_set_gid(entry, zip_entry->gid);
archive_entry_set_mtime(entry, zip_entry->mtime, 0);
archive_entry_set_ctime(entry, zip_entry->ctime, 0);
archive_entry_set_atime(entry, zip_entry->atime, 0);
if ((zip->entry->mode & AE_IFMT) == AE_IFLNK) {
size_t linkname_length;
if (zip_entry->compressed_size > 64 * 1024) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Zip file with oversized link entry");
return ARCHIVE_FATAL;
}
linkname_length = (size_t)zip_entry->compressed_size;
archive_entry_set_size(entry, 0);
// take into account link compression if any
size_t linkname_full_length = linkname_length;
if (zip->entry->compression != 0)
{
// symlink target string appeared to be compressed
int status = ARCHIVE_FATAL;
const void *uncompressed_buffer = NULL;
switch (zip->entry->compression)
{
#if HAVE_ZLIB_H
case 8: /* Deflate compression. */
zip->entry_bytes_remaining = zip_entry->compressed_size;
status = zip_read_data_deflate(a, &uncompressed_buffer,
&linkname_full_length, NULL);
break;
#endif
#if HAVE_LZMA_H && HAVE_LIBLZMA
case 14: /* ZIPx LZMA compression. */
/*(see zip file format specification, section 4.4.5)*/
zip->entry_bytes_remaining = zip_entry->compressed_size;
status = zip_read_data_zipx_lzma_alone(a, &uncompressed_buffer,
&linkname_full_length, NULL);
break;
#endif
default: /* Unsupported compression. */
break;
}
if (status == ARCHIVE_OK)
{
p = uncompressed_buffer;
}
else
{
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Unsupported ZIP compression method "
"during decompression of link entry (%d: %s)",
zip->entry->compression,
compression_name(zip->entry->compression));
return ARCHIVE_FAILED;
}
}
else
{
p = __archive_read_ahead(a, linkname_length, NULL);
}
if (p == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Truncated Zip file");
return ARCHIVE_FATAL;
}
sconv = zip->sconv;
if (sconv == NULL && (zip->entry->zip_flags & ZIP_UTF8_NAME))
sconv = zip->sconv_utf8;
if (sconv == NULL)
sconv = zip->sconv_default;
if (archive_entry_copy_symlink_l(entry, p, linkname_full_length,
sconv) != 0) {
if (errno != ENOMEM && sconv == zip->sconv_utf8 &&
(zip->entry->zip_flags & ZIP_UTF8_NAME))
archive_entry_copy_symlink_l(entry, p,
linkname_full_length, NULL);
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Symlink");
return (ARCHIVE_FATAL);
}
/*
* Since there is no character-set regulation for
* symlink name, do not report the conversion error
* in an automatic conversion.
*/
if (sconv != zip->sconv_utf8 ||
(zip->entry->zip_flags & ZIP_UTF8_NAME) == 0) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Symlink cannot be converted "
"from %s to current locale.",
archive_string_conversion_charset_name(
sconv));
ret = ARCHIVE_WARN;
}
}
zip_entry->uncompressed_size = zip_entry->compressed_size = 0;
if (__archive_read_consume(a, linkname_length) < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Read error skipping symlink target name");
return ARCHIVE_FATAL;
}
} else if (0 == (zip_entry->zip_flags & ZIP_LENGTH_AT_END)
|| zip_entry->uncompressed_size > 0) {
/* Set the size only if it's meaningful. */
archive_entry_set_size(entry, zip_entry->uncompressed_size);
}
zip->entry_bytes_remaining = zip_entry->compressed_size;
/* If there's no body, force read_data() to return EOF immediately. */
if (0 == (zip_entry->zip_flags & ZIP_LENGTH_AT_END)
&& zip->entry_bytes_remaining < 1)
zip->end_of_entry = 1;
/* Set up a more descriptive format name. */
archive_string_empty(&zip->format_name);
archive_string_sprintf(&zip->format_name, "ZIP %d.%d (%s)",
version / 10, version % 10,
compression_name(zip->entry->compression));
a->archive.archive_format_name = zip->format_name.s;
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x70(%rdx), %r15
movq 0x28(%r15), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%r15), %rbp
movl 0x78(%r15), %eax
movl %eax, 0x20(%rsp)
movw $0x0, 0xa1(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdx)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq *0x98(%r14)
movq %rax, 0x90(%r14)
cmpq $0x0, 0x1f28(%r14)
jne 0x536eae
cmpl $0x0, 0x1f40(%r14)
jne 0x536eae
movq %rbx, %rdi
callq 0x53a695
movq %rax, 0x1f30(%r14)
movl $0x1, 0x1f40(%r14)
movl $0x1e, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x5370fe
movq %rax, %r13
cmpl $0x4034b50, (%rax) # imm = 0x4034B50
je 0x536ee5
leaq 0x1876e5(%rip), %rdx # 0x6be5bd
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jmp 0x53710d
movq %rbp, 0x30(%rsp)
movb 0x4(%r13), %bpl
movb 0x5(%r13), %al
movb %al, 0x81(%r15)
movzbl 0x6(%r13), %ecx
movzbl 0x7(%r13), %eax
shll $0x8, %eax
orl %ecx, %eax
movw %ax, 0x7e(%r15)
testb $0x41, %cl
je 0x536f4a
movl $0x1, 0x38(%r14)
movq %r12, %rdi
movl $0x1, %esi
callq 0x50d7cc
movzwl 0x7e(%r15), %eax
movl %eax, %ecx
notl %ecx
testl $0x2041, %ecx # imm = 0x2041
jne 0x536f4a
movq %r12, %rdi
movl $0x1, %esi
callq 0x50d7e4
jmp 0x537114
movq %r12, 0x10(%rsp)
movb %bpl, 0xf(%rsp)
andb $0x1, %al
movb %al, 0x1f48(%r14)
movb 0x8(%r13), %al
movb %al, 0x80(%r15)
leaq 0xa(%r13), %rdi
callq 0x5377c4
movq %rax, 0x60(%r15)
movl 0xe(%r13), %eax
movl %eax, 0x78(%r15)
movzwl 0x7e(%r15), %eax
leaq 0xb(%r13), %rcx
movq %r13, %rdx
addq $0x11, %rdx
testb $0x8, %al
cmovneq %rcx, %rdx
movb (%rdx), %al
movb %al, 0x83(%r15)
movl 0x12(%r13), %eax
movq %rax, 0x28(%r15)
movl 0x16(%r13), %eax
movq %rax, 0x30(%r15)
movzwl 0x1a(%r13), %ebp
movzwl 0x1c(%r13), %r13d
movl $0x1e, %esi
movq %rbx, %rdi
callq 0x511e26
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x5370fe
movq %rax, %r12
movq %r13, 0x18(%rsp)
testb $0x8, 0x7f(%r15)
jne 0x536ffd
movq 0x1f28(%r14), %r13
testq %r13, %r13
jne 0x537030
movq 0x1f30(%r14), %r13
jmp 0x537030
movq 0x1f38(%r14), %r13
testq %r13, %r13
jne 0x537030
leaq 0x1871eb(%rip), %rsi # 0x6be1fb
movq %rbx, %rdi
movl $0x1, %edx
callq 0x53a664
movq %rax, %r13
movq %rax, 0x1f38(%r14)
testq %rax, %rax
je 0x537114
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x50d517
testl %eax, %eax
je 0x537065
callq 0x415e0
cmpl $0xc, (%rax)
jne 0x53706a
leaq 0x18433d(%rip), %rdx # 0x6bb395
movq %rbx, %rdi
movl $0xc, %esi
jmp 0x53710d
xorl %r12d, %r12d
jmp 0x537091
movq %r13, %rdi
callq 0x53a706
leaq 0x18433f(%rip), %rdx # 0x6bb3b8
movq %rbx, %rdi
movl $0x54, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, %r12d # imm = 0xFFFFFFEC
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x511e26
movq %rbx, %rdi
movq 0x18(%rsp), %r13
movq %r13, %rsi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
movq 0x10(%rsp), %rsi
je 0x5370fe
movq %rbx, %rdi
movq %rax, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x53783e
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testl %eax, %eax
jne 0x537119
movq %rbx, %rdi
movq %r13, %rsi
callq 0x511e26
movzwl 0x7c(%r15), %eax
movl %eax, %ecx
andl $0xf000, %ecx # imm = 0xF000
cmpl $0x1000, %ecx # imm = 0x1000
jne 0x53712a
andl $0xfff, %eax # imm = 0xFFF
orl $0x8000, %eax # imm = 0x8000
jmp 0x537133
leaq 0x187499(%rip), %rdx # 0x6be59e
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testw %ax, %ax
jne 0x537138
movw $0x1b4, %ax # imm = 0x1B4
movw %ax, 0x7c(%r15)
movl %r12d, 0x18(%rsp)
cmpb $0x0, 0x81(%r15)
je 0x53719b
movzwl 0x7c(%r15), %eax
movl %eax, %ecx
andl $0xf000, %ecx # imm = 0xF000
cmpl $0x4000, %ecx # imm = 0x4000
je 0x537289
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x50c87f
testq %rax, %rax
je 0x53723d
movq %rax, %r12
movq %rax, %rdi
callq 0x40820
testq %rax, %rax
je 0x537273
cmpl $0x2f, -0x4(%r12,%rax,4)
je 0x537262
jmp 0x537273
movq 0x10(%rsp), %rdi
callq 0x50c87f
testq %rax, %rax
je 0x537147
movq %rax, %r12
movq %rax, %rdi
movl $0x2f, %esi
callq 0x40fc0
testq %rax, %rax
jne 0x537147
movq %r12, %rdi
movl $0x5c, %esi
callq 0x40fc0
testq %rax, %rax
je 0x537147
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r12, %rdi
callq 0x40820
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x53a05c
movq (%r13), %rsi
movq 0x8(%r13), %rax
testq %rax, %rax
movq 0x10(%rsp), %rdi
je 0x537229
xorl %ecx, %ecx
cmpl $0x5c, (%rsi,%rcx,4)
jne 0x537221
movl $0x2f, (%rsi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x537214
callq 0x50d4ca
leaq 0x40(%rsp), %rdi
callq 0x539f5b
jmp 0x537147
movq %r13, %rdi
callq 0x50c801
testq %rax, %rax
je 0x537273
movq %rax, %r12
movq %rax, %rdi
callq 0x3fd60
testq %rax, %rax
je 0x537273
cmpb $0x2f, -0x1(%r12,%rax)
jne 0x537273
movzwl 0x7c(%r15), %eax
andl $0xfb6, %eax # imm = 0xFB6
orl $0x4049, %eax # imm = 0x4049
jmp 0x537284
movzwl 0x7c(%r15), %eax
cmpl $0xfff, %eax # imm = 0xFFF
ja 0x537289
orl $0x8000, %eax # imm = 0x8000
movw %ax, 0x7c(%r15)
andl $0xf000, %eax # imm = 0xF000
cmpl $0x4000, %eax # imm = 0x4000
jne 0x537378
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x50c87f
testq %rax, %rax
je 0x537310
movq %rax, %r12
movq %rax, %rdi
callq 0x40820
testq %rax, %rax
je 0x537378
cmpl $0x2f, -0x4(%r12,%rax,4)
je 0x537378
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r13, %rdi
movq %r12, %rsi
callq 0x53a0a3
movq %r13, %rdi
movl $0x2f, %esi
callq 0x53a0db
movq (%r13), %rsi
movq 0x10(%rsp), %rdi
callq 0x50d4ca
movq %r13, %rdi
callq 0x539f5b
jmp 0x537378
movq %r13, %rdi
callq 0x50c801
testq %rax, %rax
je 0x537378
movq %rax, %r12
movq %rax, %rdi
callq 0x3fd60
testq %rax, %rax
je 0x537378
cmpb $0x2f, -0x1(%r12,%rax)
je 0x537378
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r13, %rdi
movq %r12, %rsi
callq 0x53a099
movq %r13, %rdi
movl $0x2f, %esi
callq 0x53a0ad
movq (%r13), %rsi
movq 0x10(%rsp), %rdi
callq 0x50d4a6
movq %r13, %rdi
callq 0x539f3f
leaq 0x28(%r15), %r13
testb $0x2, 0x82(%r15)
jne 0x537390
movq 0x10(%rsp), %r12
jmp 0x53743c
andb $-0x9, 0x7e(%r15)
movl 0x78(%r15), %eax
testl %eax, %eax
movq 0x10(%rsp), %r12
je 0x5373d8
cmpb $0x0, 0xa0(%r14)
setne %cl
cmpl 0x20(%rsp), %eax
sete %al
orb %cl, %al
jne 0x5373e0
leaq 0x187212(%rip), %rdx # 0x6be5d1
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, 0x18(%rsp) # imm = 0xFFFFFFEC
jmp 0x5373e0
movl 0x20(%rsp), %eax
movl %eax, 0x78(%r15)
movq (%r13), %r8
testq %r8, %r8
je 0x537413
movq 0x28(%rsp), %rcx
cmpq %rcx, %r8
je 0x53741c
leaq 0x1871f1(%rip), %rdx # 0x6be5eb
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, 0x18(%rsp) # imm = 0xFFFFFFEC
jmp 0x53741c
movq 0x28(%rsp), %rax
movq %rax, (%r13)
movq 0x30(%r15), %r8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r8
je 0x537433
testq %r8, %r8
jne 0x5375e5
movq 0x30(%rsp), %rax
movq %rax, 0x30(%r15)
movzwl 0x7c(%r15), %esi
movq %r12, %rdi
callq 0x50d41b
movq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x50d74f
movq 0x38(%r15), %rsi
movq %r12, %rdi
callq 0x50cf48
movq 0x60(%r15), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x50d429
movq 0x70(%r15), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x50d25a
movq 0x68(%r15), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x50d176
movq 0x70(%r14), %rax
movzwl 0x7c(%rax), %eax
andl $0xf000, %eax # imm = 0xF000
cmpl $0xa000, %eax # imm = 0xA000
jne 0x5374cb
movq (%r13), %r12
cmpq $0x10001, %r12 # imm = 0x10001
jl 0x537592
leaq 0x1871ce(%rip), %rdx # 0x6be685
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
jmp 0x537119
testb $0x8, 0x7e(%r15)
sete %al
movq 0x30(%r15), %rsi
testq %rsi, %rsi
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5374ec
movq %r12, %rdi
callq 0x50d589
movl 0x18(%rsp), %ebp
movq 0x28(%r15), %rax
movq %rax, 0x78(%r14)
testb $0x8, 0x7e(%r15)
sete %cl
testq %rax, %rax
setle %al
andb %cl, %al
cmpb $0x1, %al
jne 0x537514
movb $0x1, 0xa2(%r14)
movq $0x0, 0x8(%r14)
movsbl 0xf(%rsp), %eax
imull $0x67, %eax, %ecx
movzwl %cx, %edx
shrl $0xa, %ecx
shrl $0xf, %edx
addb %cl, %dl
movsbl %dl, %edx
movzbl %dl, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subb %cl, %al
movsbl %al, %ecx
movq 0x70(%r14), %rax
movzbl 0x80(%rax), %esi
movl $0x8, %eax
leaq 0x32460a(%rip), %rdi # 0x85bb60
leaq 0x10a7c7(%rip), %r8 # 0x641d24
cmpl %esi, -0x8(%rax,%rdi)
je 0x537571
addq $0x10, %rax
cmpq $0x1a8, %rax # imm = 0x1A8
jne 0x53755d
jmp 0x537575
movq (%rax,%rdi), %r8
leaq 0x18720f(%rip), %rsi # 0x6be78b
movq %r14, %rdi
xorl %eax, %eax
callq 0x53dd88
movq (%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x537119
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x50d589
movq %r12, 0x40(%rsp)
movq 0x70(%r14), %rax
movzbl 0x80(%rax), %eax
testl %eax, %eax
je 0x537616
movq $0x0, 0x38(%rsp)
cmpl $0xe, %eax
je 0x537625
cmpl $0x8, %eax
jne 0x53764d
movq (%r13), %rax
movq %rax, 0x78(%r14)
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x537ed8
jmp 0x53763f
movq 0x30(%rsp), %rcx
cmpq %rcx, %r8
je 0x53743c
leaq 0x18703d(%rip), %rdx # 0x6be637
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, 0x18(%rsp) # imm = 0xFFFFFFEC
jmp 0x53743c
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x511af8
jmp 0x5376a0
movq (%r13), %rax
movq %rax, 0x78(%r14)
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x5381e2
testl %eax, %eax
je 0x53769b
movq 0x70(%r14), %rax
movb 0x80(%rax), %al
movzbl %al, %ecx
movl $0x8, %eax
leaq 0x324504(%rip), %rdx # 0x85bb60
leaq 0x10a6c1(%rip), %r8 # 0x641d24
cmpl %ecx, -0x8(%rax,%rdx)
je 0x537677
addq $0x10, %rax
cmpq $0x1a8, %rax # imm = 0x1A8
jne 0x537663
jmp 0x53767b
movq (%rax,%rdx), %r8
leaq 0x187026(%rip), %rdx # 0x6be6a8
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %ebp # imm = 0xFFFFFFE7
jmp 0x537119
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x53771a
movq 0x1f28(%r14), %rcx
testq %rcx, %rcx
jne 0x5376ce
movq 0x70(%r14), %rcx
testb $0x8, 0x7f(%rcx)
je 0x5376c7
movq 0x1f38(%r14), %rcx
testq %rcx, %rcx
jne 0x5376ce
movq 0x1f30(%r14), %rcx
movq 0x40(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rax, %rsi
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
callq 0x50d70d
testl %eax, %eax
je 0x53779c
callq 0x415e0
cmpl $0xc, (%rax)
movq 0x28(%rsp), %rdi
jne 0x537726
leaq 0x186ffd(%rip), %rdx # 0x6be70a
movq %rbx, %rdi
movl $0xc, %esi
jmp 0x5374bf
leaq 0x186fd6(%rip), %rdx # 0x6be6f7
jmp 0x5374b7
cmpq 0x1f38(%r14), %rdi
jne 0x537763
movq 0x70(%r14), %rcx
testb $0x8, 0x7f(%rcx)
je 0x537763
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, 0x20(%rsp)
xorl %ecx, %ecx
callq 0x50d70d
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
cmpl $0xc, (%rax)
je 0x537706
cmpq 0x1f38(%r14), %rdi
jne 0x537776
movq 0x70(%r14), %rax
testb $0x8, 0x7f(%rax)
jne 0x53779c
callq 0x53a706
leaq 0x186faa(%rip), %rdx # 0x6be72c
movq %rbx, %rdi
movl $0x54, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, 0x18(%rsp) # imm = 0xFFFFFFEC
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x511e26
testq %rax, %rax
jns 0x5374ec
leaq 0x186fa4(%rip), %rdx # 0x6be763
jmp 0x5374b7
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
zip_time
|
static time_t
zip_time(const char *p)
{
int msTime, msDate;
struct tm ts;
msTime = (0xff & (unsigned)p[0]) + 256 * (0xff & (unsigned)p[1]);
msDate = (0xff & (unsigned)p[2]) + 256 * (0xff & (unsigned)p[3]);
memset(&ts, 0, sizeof(ts));
ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
ts.tm_mday = msDate & 0x1f; /* Day of month. */
ts.tm_hour = (msTime >> 11) & 0x1f;
ts.tm_min = (msTime >> 5) & 0x3f;
ts.tm_sec = (msTime << 1) & 0x3e;
ts.tm_isdst = -1;
return mktime(&ts);
}
|
subq $0x38, %rsp
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %edx
movl %edx, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %esi
movzbl 0x3(%rdi), %r8d
movl %r8d, %r9d
shll $0x8, %r9d
orl %esi, %r9d
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
shrl %r8d
addl $0x50, %r8d
movl %r8d, 0x14(%rdi)
shrl $0x5, %r9d
andl $0xf, %r9d
decl %r9d
movl %r9d, 0x10(%rdi)
andl $0x1f, %esi
movl %esi, 0xc(%rdi)
shrl $0x3, %edx
movl %edx, 0x8(%rdi)
shrl $0x5, %ecx
andl $0x3f, %ecx
movl %ecx, 0x4(%rdi)
addl %eax, %eax
andl $0x3e, %eax
movl %eax, (%rdi)
movl $0xffffffff, 0x20(%rdi) # imm = 0xFFFFFFFF
callq 0x3fd30
addq $0x38, %rsp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
trad_enc_decrypt_update
|
static void
trad_enc_decrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in,
size_t in_len, uint8_t *out, size_t out_len)
{
unsigned i, max;
max = (unsigned)((in_len < out_len)? in_len: out_len);
for (i = 0; i < max; i++) {
uint8_t t = in[i] ^ trad_enc_decrypt_byte(ctx);
out[i] = t;
trad_enc_update_keys(ctx, t);
}
}
|
cmpq %r8, %rdx
cmovbq %rdx, %r8
testl %r8d, %r8d
je 0x53863c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %r8d, %r12d
xorl %r13d, %r13d
movl 0x8(%r15), %eax
orl $0x2, %eax
movl %eax, %ecx
xorl $0x1, %ecx
imull %eax, %ecx
shrl $0x8, %ecx
xorb (%r14,%r13), %cl
movb %cl, (%rbx,%r13)
movzbl %cl, %esi
movq %r15, %rdi
callq 0x538803
incq %r13
cmpq %r13, %r12
jne 0x538606
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
check_authentication_code
|
static int
check_authentication_code(struct archive_read *a, const void *_p)
{
struct zip *zip = (struct zip *)(a->format->data);
/* Check authentication code. */
if (zip->hctx_valid) {
const void *p;
uint8_t hmac[20];
size_t hmac_len = 20;
int cmp;
archive_hmac_sha1_final(&zip->hctx, hmac, &hmac_len);
if (_p == NULL) {
/* Read authentication code. */
p = __archive_read_ahead(a, AUTH_CODE_SIZE, NULL);
if (p == NULL) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP file data");
return (ARCHIVE_FATAL);
}
} else {
p = _p;
}
cmp = memcmp(hmac, p, AUTH_CODE_SIZE);
__archive_read_consume(a, AUTH_CODE_SIZE);
if (cmp != 0) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"ZIP bad Authentication code");
return (ARCHIVE_WARN);
}
}
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rdi
xorl %ebp, %ebp
cmpb $0x0, 0x1ff0(%rdi)
je 0x538701
movq %rsi, %r14
leaq 0x20(%rsp), %rdx
movq $0x14, (%rdx)
leaq 0x324c67(%rip), %rax # 0x85d2e0
addq $0x1fe8, %rdi # imm = 0x1FE8
movq %rsp, %rsi
callq *0x10(%rax)
testq %r14, %r14
jne 0x5386a2
movl $0xa, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x511af8
movq %rax, %r14
testq %rax, %rax
je 0x5386e6
movq (%rsp), %r15
xorq (%r14), %r15
movzwl 0x8(%rsp), %eax
xorw 0x8(%r14), %ax
movzwl %ax, %r14d
movl $0xa, %esi
movq %rbx, %rdi
callq 0x511e26
orq %r15, %r14
je 0x538701
leaq 0x18629d(%rip), %rdx # 0x6be96d
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, %ebp # imm = 0xFFFFFFEC
jmp 0x538701
leaq 0x186268(%rip), %rdx # 0x6be955
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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-of-file record");
return (ARCHIVE_FATAL);
}
/* Consume the optional PK\007\010 marker. */
if (p[0] == 'P' && p[1] == 'K' &&
p[2] == '\007' && p[3] == '\010') {
p += 4;
zip->unconsumed = 4;
}
if (zip->entry->flags & LA_USED_ZIP64) {
uint64_t compressed, uncompressed;
zip->entry->crc32 = archive_le32dec(p);
compressed = archive_le64dec(p + 4);
uncompressed = archive_le64dec(p + 12);
if (compressed > INT64_MAX ||
uncompressed > INT64_MAX) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Overflow of 64-bit file sizes");
return ARCHIVE_FAILED;
}
zip->entry->compressed_size = compressed;
zip->entry->uncompressed_size = uncompressed;
zip->unconsumed += 20;
} else {
zip->entry->crc32 = archive_le32dec(p);
zip->entry->compressed_size = archive_le32dec(p + 4);
zip->entry->uncompressed_size = archive_le32dec(p + 8);
zip->unconsumed += 12;
}
}
return (ARCHIVE_OK);
}
|
xorl %eax, %eax
cmpb $0x0, 0xa2(%rsi)
je 0x538802
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x70(%rsi), %rcx
testb $0x8, 0x7e(%rcx)
je 0x5387fb
movq %rdi, %r14
movl $0x18, %esi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x538790
cmpb $0x50, (%rax)
jne 0x538769
cmpb $0x4b, 0x1(%rax)
jne 0x538769
cmpb $0x7, 0x2(%rax)
jne 0x538769
cmpb $0x8, 0x3(%rax)
jne 0x538769
addq $0x4, %rax
movq $0x4, 0x68(%rbx)
movq 0x70(%rbx), %rcx
testb $0x1, 0x82(%rcx)
movl (%rax), %edx
movl %edx, 0x78(%rcx)
jne 0x5387ad
movl 0x4(%rax), %edx
movq %rdx, 0x28(%rcx)
movl 0x8(%rax), %eax
movq %rax, 0x30(%rcx)
addq $0xc, 0x68(%rbx)
jmp 0x5387dc
leaq 0x1861f2(%rip), %rdx # 0x6be989
movq %r14, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x5387fb
movl 0x8(%rax), %esi
movl 0x10(%rax), %edx
shlq $0x20, %rsi
shlq $0x20, %rdx
movq %rsi, %rdi
orq %rdx, %rdi
js 0x5387e0
movl 0x4(%rax), %edi
movl 0xc(%rax), %eax
orq %rax, %rdx
orq %rdi, %rsi
movq %rsi, 0x28(%rcx)
movq %rdx, 0x30(%rcx)
addq $0x14, 0x68(%rbx)
xorl %eax, %eax
jmp 0x5387fb
leaq 0x1861c3(%rip), %rdx # 0x6be9aa
movq %r14, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %eax # imm = 0xFFFFFFE7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
init_WinZip_AES_decryption
|
static int
init_WinZip_AES_decryption(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
const void *p;
const uint8_t *pv;
size_t key_len, salt_len;
uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE];
int retry;
int r;
if (zip->cctx_valid || zip->hctx_valid)
return (ARCHIVE_OK);
switch (zip->entry->aes_extra.strength) {
case 1: salt_len = 8; key_len = 16; break;
case 2: salt_len = 12; key_len = 24; break;
case 3: salt_len = 16; key_len = 32; break;
default: goto corrupted;
}
p = __archive_read_ahead(a, salt_len + 2, NULL);
if (p == NULL)
goto truncated;
for (retry = 0;; retry++) {
const char *passphrase;
passphrase = __archive_read_next_passphrase(a);
if (passphrase == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
(retry > 0)?
"Incorrect passphrase":
"Passphrase required for this entry");
return (ARCHIVE_FAILED);
}
memset(derived_key, 0, sizeof(derived_key));
r = archive_pbkdf2_sha1(passphrase, strlen(passphrase),
p, salt_len, 1000, derived_key, key_len * 2 + 2);
if (r != 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Decryption is unsupported due to lack of "
"crypto library");
return (ARCHIVE_FAILED);
}
/* Check password verification value. */
pv = ((const uint8_t *)p) + salt_len;
if (derived_key[key_len * 2] == pv[0] &&
derived_key[key_len * 2 + 1] == pv[1])
break;/* The passphrase is OK. */
if (retry > 10000) {
/* Avoid infinity loop. */
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Too many incorrect passphrases");
return (ARCHIVE_FAILED);
}
}
r = archive_decrypto_aes_ctr_init(&zip->cctx, derived_key, key_len);
if (r != 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Decryption is unsupported due to lack of crypto library");
return (ARCHIVE_FAILED);
}
r = archive_hmac_sha1_init(&zip->hctx, derived_key + key_len, key_len);
if (r != 0) {
archive_decrypto_aes_ctr_release(&zip->cctx);
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to initialize HMAC-SHA1");
return (ARCHIVE_FAILED);
}
zip->cctx_valid = zip->hctx_valid = 1;
__archive_read_consume(a, salt_len + 2);
zip->entry_bytes_remaining -= salt_len + 2 + AUTH_CODE_SIZE;
if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END)
&& zip->entry_bytes_remaining < 0)
goto corrupted;
zip->entry_compressed_bytes_read += salt_len + 2 + AUTH_CODE_SIZE;
zip->decrypted_bytes_remaining = 0;
zip->entry->compression = zip->entry->aes_extra.compression;
return (zip_alloc_decryption_buffer(a));
truncated:
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP file data");
return (ARCHIVE_FATAL);
corrupted:
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Corrupted ZIP file data");
return (ARCHIVE_FATAL);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x818(%rdi), %rax
movq (%rax), %r12
xorl %eax, %eax
cmpb $0x0, 0x1fe0(%r12)
jne 0x538cbd
cmpb $0x0, 0x1ff0(%r12)
jne 0x538cbd
movq %rdi, %rbx
movq 0x70(%r12), %rax
movl 0x88(%rax), %eax
cmpl $0x1, %eax
je 0x538ab3
cmpl $0x3, %eax
je 0x538aa0
cmpl $0x2, %eax
jne 0x538ca2
leaq 0x58(%rsp), %r13
movl $0xc, %r14d
movl $0x18, %r15d
jmp 0x538ac4
leaq 0x60(%rsp), %r13
movl $0x10, %r14d
movl $0x20, %r15d
jmp 0x538ac4
leaq 0x50(%rsp), %r13
movl $0x8, %r14d
movl $0x10, %r15d
movq %r14, %rsi
orq $0x2, %rsi
movq %rbx, %rdi
movq %rsi, 0x18(%rsp)
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x538bd2
movq %rax, %rbp
movq %r15, 0x8(%rsp)
movq %rbx, %rdi
callq 0x56449e
testq %rax, %rax
je 0x538bde
movq %rax, %r15
movq %r13, 0x10(%rsp)
leaq 0x3235ed(%rip), %rax # 0x85c0f8
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
leal (%rax,%rax), %ecx
movq %rcx, %rax
orq $0x2, %rax
movq %rax, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
leaq 0x1(%rcx), %rax
movq %rax, 0x20(%rsp)
movl $0x2712, %r13d # imm = 0x2712
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movw $0x0, 0x80(%rsp)
movq %r15, %rdi
callq 0x3fd60
movq 0x30(%rsp), %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %rax, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movl $0x3e8, %r8d # imm = 0x3E8
leaq 0x40(%rsp), %r9
callq *0x38(%rsp)
testl %eax, %eax
jne 0x538c16
movq 0x28(%rsp), %rax
movb 0x40(%rsp,%rax), %al
cmpb (%rbp,%r14), %al
jne 0x538bb0
movq 0x20(%rsp), %rax
movb 0x40(%rsp,%rax), %al
cmpb 0x1(%rbp,%r14), %al
je 0x538bf0
decl %r13d
je 0x538be7
movq %rbx, %rdi
callq 0x56449e
movq %rax, %r15
testq %rax, %rax
jne 0x538b3b
leaq 0x1860ee(%rip), %rdx # 0x6becbe
jmp 0x538c1d
leaq 0x185d7c(%rip), %rdx # 0x6be955
jmp 0x538ca9
leaq 0x1860ee(%rip), %rdx # 0x6becd3
jmp 0x538c1d
leaq 0x186140(%rip), %rdx # 0x6bed2e
jmp 0x538c1d
leaq 0x1f88(%r12), %r15
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rdx
leaq 0x3234e9(%rip), %rbp # 0x85c0f8
callq *0x8(%rbp)
testl %eax, %eax
je 0x538c36
leaq 0x1860d9(%rip), %rdx # 0x6becf6
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %eax # imm = 0xFFFFFFE7
jmp 0x538cbd
leaq 0x3246a3(%rip), %rax # 0x85d2e0
leaq 0x1fe8(%r12), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq *(%rax)
testl %eax, %eax
je 0x538c62
movq %r15, %rdi
callq *0x18(%rbp)
leaq 0x1860ed(%rip), %rdx # 0x6bed4d
jmp 0x538c1d
movb $0x1, %al
movb %al, 0x1ff0(%r12)
movb %al, 0x1fe0(%r12)
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x511e26
addq $0xc, %r14
movq 0x70(%r12), %rax
movq 0x78(%r12), %rcx
subq %r14, %rcx
movq %rcx, 0x78(%r12)
testb $0x8, 0x7e(%rax)
jne 0x538ccf
testq %rcx, %rcx
jns 0x538ccf
leaq 0x185fe0(%rip), %rdx # 0x6bec89
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, 0x80(%r12)
movq $0x0, 0x1f68(%r12)
movb 0x8c(%rax), %cl
movb %cl, 0x80(%rax)
movq %rbx, %rdi
callq 0x539c4b
jmp 0x538cbd
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
zip_read_data_zipx_zstd
|
static int
zip_read_data_zipx_zstd(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip *zip = (struct zip *)(a->format->data);
ssize_t bytes_avail = 0, in_bytes, to_consume;
const void *compressed_buff;
int r;
size_t ret;
uint64_t total_out;
ZSTD_outBuffer out;
ZSTD_inBuffer in;
(void) offset; /* UNUSED */
/* Initialize decompression context if we're here for the first time. */
if(!zip->decompress_init) {
r = zipx_zstd_init(a, zip);
if(r != ARCHIVE_OK)
return r;
}
/* Fetch more compressed bytes */
compressed_buff = __archive_read_ahead(a, 1, &bytes_avail);
if(bytes_avail < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated zstd file body");
return (ARCHIVE_FATAL);
}
in_bytes = zipmin(zip->entry_bytes_remaining, bytes_avail);
if(in_bytes < 1) {
/* zstd doesn't complain when caller feeds avail_in == 0.
* It will actually return success in this case, which is
* undesirable. This is why we need to make this check
* manually. */
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated zstd file body");
return (ARCHIVE_FATAL);
}
/* Setup buffer boundaries */
in.src = compressed_buff;
in.size = in_bytes;
in.pos = 0;
out = (ZSTD_outBuffer) { zip->uncompressed_buffer, zip->uncompressed_buffer_size, 0 };
/* Perform the decompression. */
ret = ZSTD_decompressStream(zip->zstdstream, &out, &in);
if (ZSTD_isError(ret)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Error during zstd decompression: %s",
ZSTD_getErrorName(ret));
return (ARCHIVE_FATAL);
}
/* Check end of the stream. */
if (ret == 0) {
if ((in.pos == in.size) && (out.pos < out.size)) {
zip->end_of_entry = 1;
ZSTD_freeDStream(zip->zstdstream);
zip->zstdstream_valid = 0;
}
}
/* Update the pointers so decompressor can continue decoding. */
to_consume = in.pos;
__archive_read_consume(a, to_consume);
total_out = out.pos;
zip->entry_bytes_remaining -= to_consume;
zip->entry_compressed_bytes_read += to_consume;
zip->entry_uncompressed_bytes_read += total_out;
/* Give libarchive its due. */
*size = total_out;
*buff = zip->uncompressed_buffer;
/* Seek for optional marker, like in other entries. */
r = consume_optional_marker(a, zip);
if(r != ARCHIVE_OK)
return r;
return ARCHIVE_OK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq $0x0, (%rsp)
cmpb $0x0, 0xa1(%r14)
je 0x5397da
movq %rsp, %r13
movl $0x1, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x511af8
movq (%r13), %rcx
testq %rcx, %rcx
js 0x5397ba
movq 0x78(%r14), %rdx
cmpq %rcx, %rdx
cmovlq %rdx, %rcx
testq %rcx, %rcx
jle 0x5397ba
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
xorl %eax, %eax
movq %rax, 0x10(%rdx)
movups 0xa8(%r14), %xmm0
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rax, 0x10(%rsi)
movq 0x218(%r14), %rdi
callq 0x60a6da
movq %rax, %rbp
movq %rax, %rdi
callq 0x58c8ce
testl %eax, %eax
je 0x53988b
movq %rbp, %rdi
callq 0x58c8d8
leaq 0x18574e(%rip), %rdx # 0x6beef4
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rax, %rcx
xorl %eax, %eax
callq 0x53e204
jmp 0x5397d0
leaq 0x18571a(%rip), %rdx # 0x6beedb
movq %rbx, %rdi
movl $0x54, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x539904
cmpb $0x0, 0x220(%r14)
je 0x5397f8
movq 0x218(%r14), %rdi
callq 0x609fe0
movb $0x0, 0x220(%r14)
callq 0x609f73
movq %rax, 0x218(%r14)
movq %rax, %rdi
callq 0x60a1bb
movq %rax, %r13
movq %rax, %rdi
callq 0x58c8ce
testl %eax, %eax
je 0x539846
movq %r13, %rdi
callq 0x58c8d8
leaq 0x181738(%rip), %rdx # 0x6baf62
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rax, %rcx
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %eax # imm = 0xFFFFFFE7
jmp 0x539904
movb $0x1, 0x220(%r14)
movq 0xa8(%r14), %rdi
callq 0x41e70
callq 0x609feb
movq %rax, 0xb0(%r14)
movq %rax, %rdi
callq 0x41ec0
movq %rax, 0xa8(%r14)
testq %rax, %rax
je 0x539913
movb $0x1, 0xa1(%r14)
jmp 0x539726
movq 0x18(%rsp), %r13
testq %rbp, %rbp
jne 0x5398c9
cmpq 0x10(%rsp), %r13
jne 0x5398c9
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x5398c9
movb $0x1, 0xa2(%r14)
movq 0x218(%r14), %rdi
callq 0x609fe0
movb $0x0, 0x220(%r14)
movq 0x18(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x511e26
movq 0x30(%rsp), %rax
subq %r13, 0x78(%r14)
addq %r13, 0x80(%r14)
addq %rax, 0x88(%r14)
movq %rax, (%r12)
movq 0xa8(%r14), %rax
movq %rax, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53870e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1855fe(%rip), %rdx # 0x6bef18
movq %rbx, %rdi
movl $0xc, %esi
jmp 0x5397c9
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
zip_alloc_decryption_buffer
|
static int
zip_alloc_decryption_buffer(struct archive_read *a)
{
struct zip *zip = (struct zip *)(a->format->data);
size_t bs = 256 * 1024;
if (zip->decrypted_buffer == NULL) {
zip->decrypted_buffer_size = bs;
zip->decrypted_buffer = malloc(bs);
if (zip->decrypted_buffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for ZIP decryption");
return (ARCHIVE_FATAL);
}
}
zip->decrypted_ptr = zip->decrypted_buffer;
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq 0x1f50(%r14), %rax
testq %rax, %rax
jne 0x539c89
movq %rdi, %rbx
movq $0x40000, 0x1f60(%r14) # imm = 0x40000
movl $0x40000, %edi # imm = 0x40000
callq 0x41ec0
movq %rax, 0x1f50(%r14)
testq %rax, %rax
je 0x539c9a
movq %rax, 0x1f58(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x185000(%rip), %rdx # 0x6beca1
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x539c92
|
/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) {
zip->ppmd8_stream_failed = 1;
return 0;
}
__archive_read_consume(a, 1);
/* Increment the counter. */
++zip->zipx_ppmd_read_compressed;
/* Return the next compressed byte. */
return data[0];
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r12
movq %rsp, %r15
movq $0x0, (%r15)
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x511af8
cmpq $0x0, (%r15)
jle 0x539d09
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x511e26
incq 0x238(%r12)
movb (%r14), %al
jmp 0x539d14
movb $0x1, 0x1f21(%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c
|
archive_strncat
|
struct archive_string *
archive_strncat(struct archive_string *as, const void *_p, size_t n)
{
size_t s;
const char *p, *pp;
p = (const char *)_p;
/* Like strlen(p), except won't examine positions beyond p[n]. */
s = 0;
pp = p;
while (s < n && *pp) {
pp++;
s++;
}
if ((as = archive_string_append(as, p, s)) == NULL)
__archive_errx(1, "Out of memory");
return (as);
}
|
pushq %rax
testq %rdx, %rdx
je 0x53a03d
movq %rdx, %rax
xorl %edx, %edx
cmpb $0x0, (%rsi,%rdx)
je 0x53a03f
incq %rdx
cmpq %rdx, %rax
jne 0x53a02a
movq %rax, %rdx
jmp 0x53a03f
xorl %edx, %edx
callq 0x539e36
testq %rax, %rax
je 0x53a04b
popq %rcx
retq
leaq 0x129cc3(%rip), %rsi # 0x663d15
movl $0x1, %edi
callq 0x53e2db
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
free_sconv_object
|
static void
free_sconv_object(struct archive_string_conv *sc)
{
free(sc->from_charset);
free(sc->to_charset);
archive_string_free(&sc->utftmp);
#if HAVE_ICONV
if (sc->cd != (iconv_t)-1)
iconv_close(sc->cd);
if (sc->cd_w != (iconv_t)-1)
iconv_close(sc->cd_w);
#endif
free(sc);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x41e70
movq 0x10(%rbx), %rdi
callq 0x41e70
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
popq %rbx
jmp 0x41e70
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
archive_mstring_copy_utf8
|
int
archive_mstring_copy_utf8(struct archive_mstring *aes, const char *utf8)
{
if (utf8 == NULL) {
aes->aes_set = 0;
return (0);
}
aes->aes_set = AES_SET_UTF8;
archive_string_empty(&(aes->aes_mbs));
archive_string_empty(&(aes->aes_wcs));
archive_strncpy(&(aes->aes_utf8), utf8, strlen(utf8));
return (int)strlen(utf8);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x53aee5
movq %rsi, %rbx
movl $0x2, 0x60(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x38(%r14)
movq %rax, 0x20(%r14)
addq $0x18, %r14
movq %rsi, %rdi
callq 0x3fd60
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x53a01f
movq %rbx, %rdi
callq 0x3fd60
jmp 0x53aeef
movl $0x0, 0x60(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
strncat_from_utf8_libarchive2
|
static int
strncat_from_utf8_libarchive2(struct archive_string *as,
const void *_p, size_t len, struct archive_string_conv *sc)
{
const char *s;
int n;
char *p;
char *end;
uint32_t unicode;
#if HAVE_WCRTOMB
mbstate_t shift_state;
memset(&shift_state, 0, sizeof(shift_state));
#else
/* Clear the shift state before starting. */
wctomb(NULL, L'\0');
#endif
(void)sc; /* UNUSED */
/*
* Allocate buffer for MBS.
* We need this allocation here since it is possible that
* as->s is still NULL.
*/
if (archive_string_ensure(as, as->length + len + 1) == NULL)
return (-1);
s = (const char *)_p;
p = as->s + as->length;
end = as->s + as->buffer_length - MB_CUR_MAX -1;
while ((n = _utf8_to_unicode(&unicode, s, len)) != 0) {
wchar_t wc;
if (p >= end) {
as->length = p - as->s;
/* Re-allocate buffer for MBS. */
if (archive_string_ensure(as,
as->length + max(len * 2,
(size_t)MB_CUR_MAX) + 1) == NULL)
return (-1);
p = as->s + as->length;
end = as->s + as->buffer_length - MB_CUR_MAX -1;
}
/*
* As libarchive 2.x, translates the UTF-8 characters into
* wide-characters in the assumption that WCS is Unicode.
*/
if (n < 0) {
n *= -1;
wc = L'?';
} else
wc = (wchar_t)unicode;
s += n;
len -= n;
/*
* Translates the wide-character into the current locale MBS.
*/
#if HAVE_WCRTOMB
n = (int)wcrtomb(p, wc, &shift_state);
#else
n = (int)wctomb(p, wc);
#endif
if (n == -1)
return (-1);
p += n;
}
as->length = p - as->s;
as->s[as->length] = '\0';
return (0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, 0x18(%rsp)
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
movq %rdi, 0x8(%rsp)
callq 0x539f80
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x53b2b2
movq 0x8(%rsp), %rax
movq (%rax), %rbx
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %r12
addq %rbx, %r12
callq 0x401e0
movq %rax, %r13
leaq 0x14(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x53d683
testl %eax, %eax
je 0x53b295
movl %eax, %ebp
addq 0x20(%rsp), %rbx
notq %r13
addq %rbx, %r13
movq %r13, %rax
leaq 0x18(%rsp), %r13
cmpq %rax, %r12
jb 0x53b246
movq 0x8(%rsp), %rax
subq (%rax), %r12
movq %r12, 0x8(%rax)
leaq (%r14,%r14), %r13
callq 0x401e0
cmpq %rax, %r13
ja 0x53b209
callq 0x401e0
movq %rax, %r13
leaq (%r12,%r13), %rsi
incq %rsi
movq 0x8(%rsp), %rdi
callq 0x539f80
testq %rax, %rax
je 0x53b2ad
movq 0x8(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
addq %rbx, %r12
addq 0x10(%rax), %rbx
callq 0x401e0
notq %rax
addq %rbx, %rax
leaq 0x18(%rsp), %r13
movq %rax, %rbx
movl $0x3f, %esi
testl %ebp, %ebp
js 0x53b256
movl 0x14(%rsp), %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x3f160
cmpl $-0x1, %eax
je 0x53b2ad
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
subq %rcx, %r14
addq %rcx, %r15
cltq
addq %rax, %r12
leaq 0x14(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x53d683
movl %eax, %ebp
testl %eax, %eax
movq %rbx, %rax
jne 0x53b1e2
movq %r12, %rax
movq 0x8(%rsp), %rcx
subq (%rcx), %rax
movq %rax, 0x8(%rcx)
movb $0x0, (%r12)
xorl %ecx, %ecx
jmp 0x53b2b2
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
archive_string_append_unicode
|
static int
archive_string_append_unicode(struct archive_string *as, const void *_p,
size_t len, struct archive_string_conv *sc)
{
const char *s;
char *p, *endp;
uint32_t uc;
size_t w;
int n, ret = 0, ts, tm;
int (*parse)(uint32_t *, const char *, size_t);
size_t (*unparse)(char *, size_t, uint32_t);
if (sc->flag & SCONV_TO_UTF16BE) {
unparse = unicode_to_utf16be;
ts = 2;
} else if (sc->flag & SCONV_TO_UTF16LE) {
unparse = unicode_to_utf16le;
ts = 2;
} else if (sc->flag & SCONV_TO_UTF8) {
unparse = unicode_to_utf8;
ts = 1;
} else {
/*
* This case is going to be converted to another
* character-set through iconv.
*/
if (sc->flag & SCONV_FROM_UTF16BE) {
unparse = unicode_to_utf16be;
ts = 2;
} else if (sc->flag & SCONV_FROM_UTF16LE) {
unparse = unicode_to_utf16le;
ts = 2;
} else {
unparse = unicode_to_utf8;
ts = 1;
}
}
if (sc->flag & SCONV_FROM_UTF16BE) {
parse = utf16be_to_unicode;
tm = 1;
} else if (sc->flag & SCONV_FROM_UTF16LE) {
parse = utf16le_to_unicode;
tm = 1;
} else {
parse = cesu8_to_unicode;
tm = ts;
}
if (archive_string_ensure(as, as->length + len * tm + ts) == NULL)
return (-1);
s = (const char *)_p;
p = as->s + as->length;
endp = as->s + as->buffer_length - ts;
while ((n = parse(&uc, s, len)) != 0) {
if (n < 0) {
/* Use a replaced unicode character. */
n *= -1;
ret = -1;
}
s += n;
len -= n;
while ((w = unparse(p, endp - p, uc)) == 0) {
/* There is not enough output buffer so
* we have to expand it. */
as->length = p - as->s;
if (archive_string_ensure(as,
as->buffer_length + len * tm + ts) == NULL)
return (-1);
p = as->s + as->length;
endp = as->s + as->buffer_length - ts;
}
p += w;
}
as->length = p - as->s;
as->s[as->length] = '\0';
if (ts == 2)
as->s[as->length+1] = '\0';
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl 0x24(%rcx), %eax
leaq 0x25ba(%rip), %rcx # 0x53d8a0
movq %rcx, 0x8(%rsp)
movl $0x2, %r15d
movb $0x1, %r14b
btl $0xa, %eax
jb 0x53b35a
btl $0xc, %eax
jb 0x53b337
btl $0x8, %eax
jb 0x53b345
btl $0xb, %eax
jb 0x53b35a
movl %eax, %r14d
shrl $0xd, %r14d
andl $0x1, %r14d
leaq 0x1(%r14), %r15
leaq 0x25d4(%rip), %rcx # 0x53d8f6
leaq 0x2626(%rip), %rdx # 0x53d94f
testl %r14d, %r14d
cmovneq %rcx, %rdx
movq %rdx, 0x8(%rsp)
jmp 0x53b35a
leaq 0x25b8(%rip), %rcx # 0x53d8f6
movq %rcx, 0x8(%rsp)
jmp 0x53b35a
leaq 0x2603(%rip), %rcx # 0x53d94f
movq %rcx, 0x8(%rsp)
movl $0x1, %r15d
xorl %r14d, %r14d
btl $0xd, %eax
leaq 0x26b1(%rip), %rcx # 0x53da16
leaq 0x26a3(%rip), %rdx # 0x53da0f
cmovaeq %rcx, %rdx
testl $0x2800, %eax # imm = 0x2800
movl $0x1, %esi
cmoveq %r15, %rsi
btl $0xb, %eax
leaq 0x267c(%rip), %r12 # 0x53da05
cmovaeq %rdx, %r12
movq %rsi, 0x38(%rsp)
imulq %r13, %rsi
addq %r15, %rsi
addq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x539f80
testq %rax, %rax
je 0x53b4a7
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq (%rbx), %rbp
movq 0x10(%rbx), %r15
movq %r12, %rax
movq 0x8(%rbx), %r12
addq %rbp, %r12
leaq 0x4(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rax, 0x40(%rsp)
callq *%rax
testl %eax, %eax
je 0x53b4bd
movq 0x20(%rsp), %r14
negq %r14
addq %r15, %rbp
addq %r14, %rbp
xorl %edx, %edx
movl %eax, %r15d
negl %r15d
cmovsl %eax, %r15d
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovsl %eax, %edx
movl %edx, 0x1c(%rsp)
subq %r15, %r13
movq %rbp, %rsi
subq %r12, %rsi
movl 0x4(%rsp), %edx
movq %r12, %rdi
callq *0x8(%rsp)
testq %rax, %rax
jne 0x53b47d
movq %r13, 0x30(%rsp)
imulq 0x38(%rsp), %r13
addq 0x20(%rsp), %r13
subq (%rbx), %r12
movq %r12, 0x8(%rbx)
movq 0x10(%rbx), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x539f80
testq %rax, %rax
je 0x53b4a7
movq (%rbx), %rbp
movq 0x8(%rbx), %r12
addq %rbp, %r12
addq 0x10(%rbx), %rbp
addq %r14, %rbp
movq %rbp, %rsi
subq %r12, %rsi
movl 0x4(%rsp), %edx
movq %r12, %rdi
callq *0x8(%rsp)
testq %rax, %rax
je 0x53b436
movq 0x30(%rsp), %r13
addq %rax, %r12
movq 0x10(%rsp), %rsi
addq %r15, %rsi
leaq 0x4(%rsp), %rdi
movq %rsi, 0x10(%rsp)
movq %r13, %rdx
callq *0x40(%rsp)
testl %eax, %eax
movl 0x1c(%rsp), %edx
jne 0x53b3f5
jmp 0x53b4bf
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %edx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
movq %r12, %rax
subq (%rbx), %rax
movq %rax, 0x8(%rbx)
movb $0x0, (%r12)
cmpb $0x0, 0x28(%rsp)
je 0x53b4ac
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x0, 0x1(%rax,%rcx)
jmp 0x53b4ac
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
strncat_from_utf8_to_utf8
|
static int
strncat_from_utf8_to_utf8(struct archive_string *as, const void *_p,
size_t len, struct archive_string_conv *sc)
{
const char *s;
char *p, *endp;
int n, ret = 0;
(void)sc; /* UNUSED */
if (archive_string_ensure(as, as->length + len + 1) == NULL)
return (-1);
s = (const char *)_p;
p = as->s + as->length;
endp = as->s + as->buffer_length -1;
do {
uint32_t uc;
const char *ss = s;
size_t w;
/*
* Forward byte sequence until a conversion of that is needed.
*/
while ((n = utf8_to_unicode(&uc, s, len)) > 0) {
s += n;
len -= n;
}
if (ss < s) {
if (p + (s - ss) > endp) {
as->length = p - as->s;
if (archive_string_ensure(as,
as->buffer_length + len + 1) == NULL)
return (-1);
p = as->s + as->length;
endp = as->s + as->buffer_length -1;
}
memcpy(p, ss, s - ss);
p += s - ss;
}
/*
* If n is negative, current byte sequence needs a replacement.
*/
if (n < 0) {
if (n == -3 && IS_SURROGATE_PAIR_LA(uc)) {
/* Current byte sequence may be CESU-8. */
n = cesu8_to_unicode(&uc, s, len);
}
if (n < 0) {
ret = -1;
n *= -1;/* Use a replaced unicode character. */
}
/* Rebuild UTF-8 byte sequence. */
while ((w = unicode_to_utf8(p, endp - p, uc)) == 0) {
as->length = p - as->s;
if (archive_string_ensure(as,
as->buffer_length + len + 1) == NULL)
return (-1);
p = as->s + as->length;
endp = as->s + as->buffer_length -1;
}
p += w;
s += n;
len -= n;
}
} while (n > 0);
as->length = p - as->s;
as->s[as->length] = '\0';
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x539f80
testq %rax, %rax
je 0x53d56b
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x8(%rbx), %r13
addq %rax, %r13
leaq (%rax,%rcx), %r15
decq %r15
movl $0x0, 0xc(%rsp)
movq %rbp, %r12
movq %rbp, %rax
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x53d683
movl %eax, %ebp
cmpl $0x3, %eax
jne 0x53d3fc
movl 0x8(%rsp), %eax
movl $0xfffff800, %ecx # imm = 0xFFFFF800
andl %ecx, %eax
cmpl $0xd800, %eax # imm = 0xD800
jne 0x53d400
jmp 0x53d40a
testl %ebp, %ebp
jle 0x53d40f
movl %ebp, %eax
addq %rax, %r12
subq %rax, %r14
jmp 0x53d3d1
movl $0xfffffffd, %ebp # imm = 0xFFFFFFFD
movq 0x18(%rsp), %rsi
cmpq %r12, %rsi
jae 0x53d47f
movq %r12, %rcx
subq %rsi, %rcx
leaq (%rcx,%r13), %rax
cmpq %r15, %rax
movq %rcx, 0x10(%rsp)
jbe 0x53d46f
subq (%rbx), %r13
movq %r13, 0x8(%rbx)
movq 0x10(%rbx), %rax
leaq (%r14,%rax), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x539f80
testq %rax, %rax
je 0x53d56b
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x8(%rbx), %r13
addq %rax, %r13
leaq (%rax,%rcx), %r15
decq %r15
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %r13, %rdi
movq %rcx, %rdx
callq 0x3f250
addq 0x10(%rsp), %r13
testl %ebp, %ebp
jns 0x53d556
movl %ebp, %eax
xorl $-0x3, %eax
movl 0x8(%rsp), %edx
movl %edx, %ecx
andl $0xfffff800, %ecx # imm = 0xFFFFF800
xorl $0xd800, %ecx # imm = 0xD800
orl %eax, %ecx
jne 0x53d4b8
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x53da16
movl %eax, %ebp
movl 0x8(%rsp), %edx
movl %ebp, %eax
negl %eax
cmovsl %ebp, %eax
movl %eax, 0x24(%rsp)
testl %ebp, %ebp
movl 0xc(%rsp), %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovsl %ecx, %eax
movl %eax, 0xc(%rsp)
movq %r15, %rsi
subq %r13, %rsi
movq %r13, %rdi
movl %edx, 0x18(%rsp)
callq 0x53d94f
testq %rax, %rax
jne 0x53d53e
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rsp)
subq (%rbx), %r13
movq %r13, 0x8(%rbx)
movq 0x10(%rbx), %rsi
addq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x539f80
testq %rax, %rax
je 0x53d56b
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x8(%rbx), %r13
addq %rax, %r13
leaq (%rax,%rcx), %r15
decq %r15
movq %r15, %rsi
subq %r13, %rsi
movq %r13, %rdi
movl 0x18(%rsp), %edx
callq 0x53d94f
testq %rax, %rax
je 0x53d4f5
addq %rax, %r13
movl 0x24(%rsp), %eax
addq %rax, %r12
subq %rax, %r14
movq %r12, %rax
testl %ebp, %ebp
jne 0x53d3cc
movq %r13, %rax
subq (%rbx), %rax
movq %rax, 0x8(%rbx)
movb $0x0, (%r13)
movl 0xc(%rsp), %eax
jmp 0x53d570
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
best_effort_strncat_in_locale
|
static int
best_effort_strncat_in_locale(struct archive_string *as, const void *_p,
size_t length, struct archive_string_conv *sc)
{
size_t remaining;
const uint8_t *itp;
int return_value = 0; /* success */
/*
* If both from-locale and to-locale is the same, this makes a copy.
* And then this checks all copied MBS can be WCS if so returns 0.
*/
if (sc->same) {
if (archive_string_append(as, _p, length) == NULL)
return (-1);/* No memory */
return (invalid_mbs(_p, length, sc));
}
/*
* If a character is ASCII, this just copies it. If not, this
* assigns '?' character instead but in UTF-8 locale this assigns
* byte sequence 0xEF 0xBD 0xBD, which are code point U+FFFD,
* a Replacement Character in Unicode.
*/
remaining = length;
itp = (const uint8_t *)_p;
while (*itp && remaining > 0) {
if (*itp > 127) {
// Non-ASCII: Substitute with suitable replacement
if (sc->flag & SCONV_TO_UTF8) {
if (archive_string_append(as, utf8_replacement_char, sizeof(utf8_replacement_char)) == NULL) {
__archive_errx(1, "Out of memory");
}
} else {
archive_strappend_char(as, '?');
}
return_value = -1;
} else {
archive_strappend_char(as, *itp);
}
++itp;
}
return (return_value);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x0, 0x20(%rcx)
je 0x53d5fa
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x539e36
testq %rax, %rax
je 0x53d66f
movq $0x0, (%rsp)
xorl %ebp, %ebp
testq %r12, %r12
je 0x53d674
leaq 0xc(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x41840
cmpq $-0x2, %rax
jae 0x53d66f
testq %rax, %rax
je 0x53d674
addq %rax, %rbx
subq %rax, %r12
jne 0x53d5cc
jmp 0x53d674
movq %rcx, %r14
testq %r12, %r12
sete %cl
movb (%rbx), %al
testb %al, %al
sete %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0x53d674
incq %rbx
xorl %ebp, %ebp
leaq 0x188188(%rip), %r12 # 0x6c57a4
testb %al, %al
jns 0x53d62e
testb $0x1, 0x25(%r14)
jne 0x53d644
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movb $0x3f, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x53a0ad
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x53d61c
jmp 0x53d674
movl $0x3, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x539e36
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rax, %rax
jne 0x53d639
leaq 0x1266b0(%rip), %rsi # 0x663d15
movl $0x1, %edi
callq 0x53e2db
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
utf8_to_unicode
|
static int
_utf8_to_unicode(uint32_t *pwc, const char *s, size_t n)
{
static const char utf8_count[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 00 - 0F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 10 - 1F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 20 - 2F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 30 - 3F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 40 - 4F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 50 - 5F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 60 - 6F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 70 - 7F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 80 - 8F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 90 - 9F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* A0 - AF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* B0 - BF */
0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,/* C0 - CF */
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,/* D0 - DF */
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,/* E0 - EF */
4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* F0 - FF */
};
int ch, i;
int cnt;
uint32_t wc;
/* Sanity check. */
if (n == 0)
return (0);
/*
* Decode 1-4 bytes depending on the value of the first byte.
*/
ch = (unsigned char)*s;
if (ch == 0)
return (0); /* Standard: return 0 for end-of-string. */
cnt = utf8_count[ch];
/* Invalid sequence or there are not plenty bytes. */
if ((int)n < cnt) {
cnt = (int)n;
for (i = 1; i < cnt; i++) {
if ((s[i] & 0xc0) != 0x80) {
cnt = i;
break;
}
}
goto invalid_sequence;
}
/* Make a Unicode code point from a single UTF-8 sequence. */
switch (cnt) {
case 1: /* 1 byte sequence. */
*pwc = ch & 0x7f;
return (cnt);
case 2: /* 2 bytes sequence. */
if ((s[1] & 0xc0) != 0x80) {
cnt = 1;
goto invalid_sequence;
}
*pwc = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
return (cnt);
case 3: /* 3 bytes sequence. */
if ((s[1] & 0xc0) != 0x80) {
cnt = 1;
goto invalid_sequence;
}
if ((s[2] & 0xc0) != 0x80) {
cnt = 2;
goto invalid_sequence;
}
wc = ((ch & 0x0f) << 12)
| ((s[1] & 0x3f) << 6)
| (s[2] & 0x3f);
if (wc < 0x800)
goto invalid_sequence;/* Overlong sequence. */
break;
case 4: /* 4 bytes sequence. */
if ((s[1] & 0xc0) != 0x80) {
cnt = 1;
goto invalid_sequence;
}
if ((s[2] & 0xc0) != 0x80) {
cnt = 2;
goto invalid_sequence;
}
if ((s[3] & 0xc0) != 0x80) {
cnt = 3;
goto invalid_sequence;
}
wc = ((ch & 0x07) << 18)
| ((s[1] & 0x3f) << 12)
| ((s[2] & 0x3f) << 6)
| (s[3] & 0x3f);
if (wc < 0x10000)
goto invalid_sequence;/* Overlong sequence. */
break;
default: /* Others are all invalid sequence. */
if (ch == 0xc0 || ch == 0xc1)
cnt = 2;
else if (ch >= 0xf5 && ch <= 0xf7)
cnt = 4;
else if (ch >= 0xf8 && ch <= 0xfb)
cnt = 5;
else if (ch == 0xfc || ch == 0xfd)
cnt = 6;
else
cnt = 1;
if ((int)n < cnt)
cnt = (int)n;
for (i = 1; i < cnt; i++) {
if ((s[i] & 0xc0) != 0x80) {
cnt = i;
break;
}
}
goto invalid_sequence;
}
/* The code point larger than 0x10FFFF is not legal
* Unicode values. */
if (wc > UNICODE_MAX)
goto invalid_sequence;
/* Correctly gets a Unicode, returns used bytes. */
*pwc = wc;
return (cnt);
invalid_sequence:
*pwc = UNICODE_R_CHAR;/* set the Replacement Character instead. */
return (cnt * -1);
}
|
xorl %eax, %eax
testq %rdx, %rdx
je 0x53d6d4
movzbl (%rsi), %ecx
testl %ecx, %ecx
je 0x53d6d4
leaq 0x181b58(%rip), %rax # 0x6bf1f0
movsbl (%rcx,%rax), %eax
cmpl %eax, %edx
jge 0x53d6d5
cmpl $0x2, %edx
jl 0x53d6c5
movl %edx, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl $0x1, %r8d
movb (%rsi,%r8), %cl
andb $-0x40, %cl
negb %cl
jno 0x53d6c8
incq %r8
cmpq %r8, %rax
jne 0x53d6b2
movl %edx, %r8d
movl $0xfffd, (%rdi) # imm = 0xFFFD
negl %r8d
movl %r8d, %eax
retq
movzbl %al, %r8d
decl %r8d
cmpl $0x3, %r8d
ja 0x53d82e
leaq 0x181af3(%rip), %rdx # 0x6bf1e0
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
andl $0x7f, %ecx
movl %ecx, (%rdi)
movl $0x1, %eax
retq
movsbl 0x1(%rsi), %r9d
movl %r9d, %edx
andl $0xc0, %edx
movl $0x1, %r8d
cmpl $0x80, %edx
jne 0x53d6c8
movzbl 0x2(%rsi), %edx
movl %edx, %esi
andl $-0x40, %esi
movl $0x2, %r8d
cmpl $0x80, %esi
jne 0x53d6c8
shll $0xc, %ecx
movzwl %cx, %ecx
andl $0x3f, %r9d
shll $0x6, %r9d
orl %ecx, %r9d
movl $0x3, %r8d
cmpl $0x800, %r9d # imm = 0x800
jb 0x53d6c8
andl $0x3f, %edx
orl %r9d, %edx
jmp 0x53d7fd
movsbl 0x1(%rsi), %r9d
movl %r9d, %edx
andl $0xc0, %edx
movl $0x1, %r8d
cmpl $0x80, %edx
jne 0x53d6c8
movsbl 0x2(%rsi), %r10d
movl %r10d, %edx
andl $0xc0, %edx
movl $0x2, %r8d
cmpl $0x80, %edx
jne 0x53d6c8
movzbl 0x3(%rsi), %edx
movl %edx, %esi
andl $-0x40, %esi
movl $0x3, %r8d
cmpl $0x80, %esi
jne 0x53d6c8
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r9d
shll $0xc, %r9d
leal (%r9,%rcx), %esi
addl $0xffef0000, %esi # imm = 0xFFEF0000
movl $0x4, %r8d
cmpl $0xfff00000, %esi # imm = 0xFFF00000
jb 0x53d6c8
orl %ecx, %r9d
andl $0x3f, %r10d
shll $0x6, %r10d
andl $0x3f, %edx
orl %r10d, %edx
orl %r9d, %edx
movl %edx, (%rdi)
retq
movzbl 0x1(%rsi), %eax
movl %eax, %edx
andl $-0x40, %edx
movl $0x1, %r8d
cmpl $0x80, %edx
jne 0x53d6c8
andl $0x1f, %ecx
shll $0x6, %ecx
andl $0x3f, %eax
orl %ecx, %eax
movl %eax, (%rdi)
movl $0x2, %eax
retq
movl %ecx, %eax
andb $-0x2, %al
movl $0x2, %r8d
cmpb $-0x40, %al
je 0x53d868
leal 0xb(%rcx), %r9d
movl $0x4, %r8d
cmpb $0x3, %r9b
jb 0x53d868
andb $-0x4, %cl
movl $0x5, %r8d
cmpb $-0x8, %cl
je 0x53d868
xorl %ecx, %ecx
cmpb $-0x4, %al
sete %cl
leal (%rcx,%rcx,4), %r8d
incl %r8d
cmpl %edx, %r8d
cmovgel %edx, %r8d
cmpl $0x2, %r8d
jl 0x53d6c8
movl %r8d, %ecx
movl $0x1, %eax
movb (%rsi,%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x53d898
incq %rax
cmpq %rax, %rcx
jne 0x53d881
jmp 0x53d6c8
movl %eax, %r8d
jmp 0x53d6c8
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
unicode_to_utf8
|
static size_t
unicode_to_utf8(char *p, size_t remaining, uint32_t uc)
{
char *_p = p;
/* Invalid Unicode char maps to Replacement character */
if (uc > UNICODE_MAX)
uc = UNICODE_R_CHAR;
/* Translate code point to UTF8 */
if (uc <= 0x7f) {
if (remaining == 0)
return (0);
*p++ = (char)uc;
} else if (uc <= 0x7ff) {
if (remaining < 2)
return (0);
*p++ = 0xc0 | ((uc >> 6) & 0x1f);
*p++ = 0x80 | (uc & 0x3f);
} else if (uc <= 0xffff) {
if (remaining < 3)
return (0);
*p++ = 0xe0 | ((uc >> 12) & 0x0f);
*p++ = 0x80 | ((uc >> 6) & 0x3f);
*p++ = 0x80 | (uc & 0x3f);
} else {
if (remaining < 4)
return (0);
*p++ = 0xf0 | ((uc >> 18) & 0x07);
*p++ = 0x80 | ((uc >> 12) & 0x3f);
*p++ = 0x80 | ((uc >> 6) & 0x3f);
*p++ = 0x80 | (uc & 0x3f);
}
return (p - _p);
}
|
cmpl $0x110000, %edx # imm = 0x110000
movl $0xfffd, %ecx # imm = 0xFFFD
cmovbl %edx, %ecx
cmpl $0x7f, %ecx
ja 0x53d972
testq %rsi, %rsi
je 0x53d9d0
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
jmp 0x53da01
cmpl $0x7ff, %ecx # imm = 0x7FF
ja 0x53d998
cmpq $0x2, %rsi
jb 0x53d9d0
movl %ecx, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
leaq 0x2(%rdi), %rax
movb %cl, 0x1(%rdi)
jmp 0x53da01
cmpl $0xffff, %ecx # imm = 0xFFFF
ja 0x53d9ca
cmpq $0x3, %rsi
jb 0x53d9d0
movl %ecx, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rdi)
movl %ecx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
leaq 0x3(%rdi), %rax
movb %cl, 0x2(%rdi)
jmp 0x53da01
cmpq $0x4, %rsi
jae 0x53d9d3
xorl %eax, %eax
retq
movl %ecx, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rdi)
movl %ecx, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
movl %ecx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
leaq 0x4(%rdi), %rax
movb %cl, 0x3(%rdi)
subq %rdi, %rax
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
_archive_write_open_filter
|
static int
__archive_write_open_filter(struct archive_write_filter *f)
{
int ret;
ret = ARCHIVE_OK;
if (f->next_filter != NULL)
ret = __archive_write_open_filter(f->next_filter);
if (ret != ARCHIVE_OK)
return (ret);
if (f->state != ARCHIVE_WRITE_FILTER_STATE_NEW)
return (ARCHIVE_FATAL);
if (f->open == NULL) {
f->state = ARCHIVE_WRITE_FILTER_STATE_OPEN;
return (ARCHIVE_OK);
}
ret = (f->open)(f);
if (ret == ARCHIVE_OK)
f->state = ARCHIVE_WRITE_FILTER_STATE_OPEN;
else
f->state = ARCHIVE_WRITE_FILTER_STATE_FATAL;
return (ret);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x53f40e
callq 0x53f3f8
testl %eax, %eax
jne 0x53f442
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $0x1, 0x5c(%rbx)
jne 0x53f442
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x53f438
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
movl $0x2, %edx
movl $0x8000, %ecx # imm = 0x8000
cmovel %edx, %ecx
jmp 0x53f43f
xorl %eax, %eax
movl $0x2, %ecx
movl %ecx, 0x5c(%rbx)
popq %rbx
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write.c
|
archive_write_disk_set_acls
|
int
archive_write_disk_set_acls(struct archive *a, int fd, const char *name,
struct archive_acl *abstract_acl, __LA_MODE_T mode)
{
(void)a; /* UNUSED */
(void)fd; /* UNUSED */
(void)name; /* UNUSED */
(void)abstract_acl; /* UNUSED */
(void)mode; /* UNUSED */
return (ARCHIVE_OK);
}
|
xorl %eax, %eax
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c
|
archive_write_disk_free
|
static int
_archive_write_disk_free(struct archive *_a)
{
struct archive_write_disk *a;
int ret;
if (_a == NULL)
return (ARCHIVE_OK);
archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
a = (struct archive_write_disk *)_a;
ret = _archive_write_disk_close(&a->archive);
archive_write_disk_set_group_lookup(&a->archive, NULL, NULL, NULL);
archive_write_disk_set_user_lookup(&a->archive, NULL, NULL, NULL);
archive_entry_free(a->entry);
archive_string_free(&a->_name_data);
archive_string_free(&a->_tmpname_data);
archive_string_free(&a->archive.error_string);
archive_string_free(&a->path_safe);
a->archive.magic = 0;
__archive_clean(&a->archive);
free(a->decmpfs_header_p);
free(a->resource_fork);
free(a->compressed_buffer);
free(a->uncompressed_buffer);
#if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
&& defined(HAVE_ZLIB_H)
if (a->stream_valid) {
switch (deflateEnd(&a->stream)) {
case Z_OK:
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to clean up compressor");
ret = ARCHIVE_FATAL;
break;
}
}
#endif
free(a);
return (ret);
}
|
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x53f9f6
movq %rdi, %rbx
leaq 0x1862a5(%rip), %rcx # 0x6c5bd3
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0xffff, %edx # imm = 0xFFFF
callq 0x55de18
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x53f9f8
movq %rbx, %rdi
callq 0x53f6d1
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53f49e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53f511
movq 0x1b0(%rbx), %rdi
callq 0x50c34f
leaq 0x1c0(%rbx), %rdi
callq 0x539f3f
leaq 0x1e0(%rbx), %rdi
callq 0x539f3f
leaq 0x30(%rbx), %rdi
callq 0x539f3f
leaq 0x100(%rbx), %rdi
callq 0x539f3f
movl $0x0, (%rbx)
movq %rbx, %rdi
callq 0x53e198
movq 0x248(%rbx), %rdi
callq 0x41e70
movq 0x258(%rbx), %rdi
callq 0x41e70
movq 0x278(%rbx), %rdi
callq 0x41e70
movq 0x298(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
movl %ebp, %eax
jmp 0x53f9f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c
|
archive_write_disk_finish_entry
|
static int
_archive_write_disk_finish_entry(struct archive *_a)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
int ret = ARCHIVE_OK;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_write_finish_entry");
if (a->archive.state & ARCHIVE_STATE_HEADER)
return (ARCHIVE_OK);
archive_clear_error(&a->archive);
/* Pad or truncate file to the right size. */
if (a->fd < 0) {
/* There's no file. */
} else if (a->filesize < 0) {
/* File size is unknown, so we can't set the size. */
} else if (a->fd_offset == a->filesize) {
/* Last write ended at exactly the filesize; we're done. */
/* Hopefully, this is the common case. */
#if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
} else if (a->todo & TODO_HFS_COMPRESSION) {
char null_d[1024];
ssize_t r;
if (a->file_remaining_bytes)
memset(null_d, 0, sizeof(null_d));
while (a->file_remaining_bytes) {
if (a->file_remaining_bytes > sizeof(null_d))
r = hfs_write_data_block(
a, null_d, sizeof(null_d));
else
r = hfs_write_data_block(
a, null_d, a->file_remaining_bytes);
if (r < 0)
return ((int)r);
}
#endif
} else {
#if HAVE_FTRUNCATE
if (ftruncate(a->fd, a->filesize) == -1 &&
a->filesize == 0) {
archive_set_error(&a->archive, errno,
"File size could not be restored");
return (ARCHIVE_FAILED);
}
#endif
/*
* Not all platforms implement the XSI option to
* extend files via ftruncate. Stat() the file again
* to see what happened.
*/
a->pst = NULL;
if ((ret = lazy_stat(a)) != ARCHIVE_OK)
return (ret);
/* We can use lseek()/write() to extend the file if
* ftruncate didn't work or isn't available. */
if (a->st.st_size < a->filesize) {
const char nul = '\0';
if (lseek(a->fd, a->filesize - 1, SEEK_SET) < 0) {
archive_set_error(&a->archive, errno,
"Seek failed");
return (ARCHIVE_FATAL);
}
if (write(a->fd, &nul, 1) < 0) {
archive_set_error(&a->archive, errno,
"Write to restore size failed");
return (ARCHIVE_FATAL);
}
a->pst = NULL;
}
}
/* Restore metadata. */
/*
* This is specific to Mac OS X.
* If the current file is an AppleDouble file, it should be
* linked with the data fork file and remove it.
*/
if (a->todo & TODO_APPLEDOUBLE) {
int r2 = fixup_appledouble(a, a->name);
if (r2 == ARCHIVE_EOF) {
/* The current file has been successfully linked
* with the data fork file and removed. So there
* is nothing to do on the current file. */
goto finish_metadata;
}
if (r2 < ret) ret = r2;
}
/*
* Look up the "real" UID only if we're going to need it.
* TODO: the TODO_SGID condition can be dropped here, can't it?
*/
if (a->todo & (TODO_OWNER | TODO_SUID | TODO_SGID)) {
a->uid = archive_write_disk_uid(&a->archive,
archive_entry_uname(a->entry),
archive_entry_uid(a->entry));
}
/* Look up the "real" GID only if we're going to need it. */
/* TODO: the TODO_SUID condition can be dropped here, can't it? */
if (a->todo & (TODO_OWNER | TODO_SGID | TODO_SUID)) {
a->gid = archive_write_disk_gid(&a->archive,
archive_entry_gname(a->entry),
archive_entry_gid(a->entry));
}
/*
* Restore ownership before set_mode tries to restore suid/sgid
* bits. If we set the owner, we know what it is and can skip
* a stat() call to examine the ownership of the file on disk.
*/
if (a->todo & TODO_OWNER) {
int r2 = set_ownership(a);
if (r2 < ret) ret = r2;
}
/*
* HYPOTHESIS:
* If we're not root, we won't be setting any security
* attributes that may be wiped by the set_mode() routine
* below. We also can't set xattr on non-owner-writable files,
* which may be the state after set_mode(). Perform
* set_xattrs() first based on these constraints.
*/
if (a->user_uid != 0 &&
(a->todo & TODO_XATTR)) {
int r2 = set_xattrs(a);
if (r2 < ret) ret = r2;
}
/*
* set_mode must precede ACLs on systems such as Solaris and
* FreeBSD where setting the mode implicitly clears extended ACLs
*/
if (a->todo & TODO_MODE) {
int r2 = set_mode(a, a->mode);
if (r2 < ret) ret = r2;
}
/*
* Security-related extended attributes (such as
* security.capability on Linux) have to be restored last,
* since they're implicitly removed by other file changes.
* We do this last only when root.
*/
if (a->user_uid == 0 &&
(a->todo & TODO_XATTR)) {
int r2 = set_xattrs(a);
if (r2 < ret) ret = r2;
}
/*
* Some flags prevent file modification; they must be restored after
* file contents are written.
*/
if (a->todo & TODO_FFLAGS) {
int r2 = set_fflags(a);
if (r2 < ret) ret = r2;
}
/*
* Time must follow most other metadata;
* otherwise atime will get changed.
*/
if (a->todo & TODO_TIMES) {
int r2 = set_times_from_entry(a);
if (r2 < ret) ret = r2;
}
/*
* Mac extended metadata includes ACLs.
*/
if (a->todo & TODO_MAC_METADATA) {
const void *metadata;
size_t metadata_size;
metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
if (metadata != NULL && metadata_size > 0) {
int r2 = set_mac_metadata(a, archive_entry_pathname(
a->entry), metadata, metadata_size);
if (r2 < ret) ret = r2;
}
}
/*
* ACLs must be restored after timestamps because there are
* ACLs that prevent attribute changes (including time).
*/
if (a->todo & TODO_ACLS) {
int r2;
r2 = archive_write_disk_set_acls(&a->archive, a->fd,
archive_entry_pathname(a->entry),
archive_entry_acl(a->entry),
archive_entry_mode(a->entry));
if (r2 < ret) ret = r2;
}
finish_metadata:
/* If there's an fd, we can close it now. */
if (a->fd >= 0) {
close(a->fd);
a->fd = -1;
if (a->tmpname) {
if (rename(a->tmpname, a->name) == -1) {
archive_set_error(&a->archive, errno,
"Failed to rename temporary file");
ret = ARCHIVE_FAILED;
unlink(a->tmpname);
}
a->tmpname = NULL;
}
}
/* If there's an entry, we can release it now. */
archive_entry_free(a->entry);
a->entry = NULL;
a->archive.state = ARCHIVE_STATE_HEADER;
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1854a0(%rip), %rcx # 0x6c5a4a
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x6, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x540cbc
xorl %ebp, %ebp
testb $0x2, 0x4(%rbx)
jne 0x540cbc
movq %rbx, %rdi
callq 0x53e1f2
movl 0x204(%rbx), %edi
testl %edi, %edi
js 0x5405fe
movq 0x220(%rbx), %rsi
testq %rsi, %rsi
js 0x5405fe
cmpq %rsi, 0x210(%rbx)
jne 0x5407b8
movl 0x1f8(%rbx), %eax
testl $0x14000001, %eax # imm = 0x14000001
je 0x54067e
movq 0x1b0(%rbx), %rdi
callq 0x50cad8
movq %rax, %r14
movq 0x1b0(%rbx), %rdi
callq 0x50cad3
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x53f5df
movq %rax, 0x230(%rbx)
movl 0x1f8(%rbx), %eax
testl $0x14000001, %eax # imm = 0x14000001
je 0x54067e
movq 0x1b0(%rbx), %rdi
callq 0x50c5ee
movq %rax, %r14
movq 0x1b0(%rbx), %rdi
callq 0x50c5e9
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x53f584
movq %rax, 0x238(%rbx)
movl 0x1f8(%rbx), %eax
xorl %ebp, %ebp
testb $0x1, %al
je 0x54070e
movl 0x204(%rbx), %edi
testl %edi, %edi
js 0x5406a7
movl 0x230(%rbx), %esi
movl 0x238(%rbx), %edx
callq 0x40ad0
testl %eax, %eax
je 0x5406fd
movq 0x1b8(%rbx), %rdi
movl 0x230(%rbx), %esi
movl 0x238(%rbx), %edx
callq 0x3f170
testl %eax, %eax
je 0x5406fd
callq 0x415e0
movl (%rax), %esi
movq 0x1b8(%rbx), %r9
movq 0x230(%rbx), %rcx
movq 0x238(%rbx), %r8
leaq 0x185863(%rip), %rdx # 0x6c5f49
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53e204
movl 0x1f8(%rbx), %eax
movl $0xffffffec, %ebp # imm = 0xFFFFFFEC
jmp 0x54070e
movl $0xf5fffffe, %eax # imm = 0xF5FFFFFE
andl 0x1f8(%rbx), %eax
movl %eax, 0x1f8(%rbx)
cmpq $0x0, 0xa8(%rbx)
je 0x540735
movl %eax, %ecx
andl $0x80, %ecx
je 0x540735
movq %rbx, %rdi
callq 0x541d53
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0x1f8(%rbx), %eax
testl $0x34000000, %eax # imm = 0x34000000
je 0x5409b5
movl 0x22c(%rbx), %r12d
movl %r12d, %r15d
andl $0xfff, %r15d # imm = 0xFFF
btl $0x19, %eax
jb 0x540783
xorl %r14d, %r14d
btl $0x1b, %eax
jae 0x540921
movq 0xa8(%rbx), %rcx
xorl %r14d, %r14d
cmpq 0x230(%rbx), %rcx
jne 0x54084d
movl %r15d, %r12d
jmp 0x54087f
movq %rbx, %rdi
callq 0x541cda
movl %eax, %r14d
testl %eax, %eax
jne 0x5409a8
movq 0x1a8(%rbx), %rax
movl 0x20(%rax), %ecx
xorl %r14d, %r14d
cmpq %rcx, 0x238(%rbx)
jne 0x540889
movl %r15d, %r12d
jmp 0x5408bc
callq 0x41d40
cmpl $-0x1, %eax
jne 0x5407d0
cmpq $0x0, 0x220(%rbx)
je 0x540cd4
movq $0x0, 0x1a8(%rbx)
movq %rbx, %rdi
callq 0x541cda
movl %eax, %ebp
testl %eax, %eax
jne 0x540cbc
movq 0x220(%rbx), %rsi
cmpq %rsi, 0x148(%rbx)
jge 0x5405fe
movb $0x0, 0x8(%rsp)
movl 0x204(%rbx), %edi
decq %rsi
xorl %edx, %edx
callq 0x3f980
testq %rax, %rax
js 0x540cfd
movl 0x204(%rbx), %edi
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x41690
testq %rax, %rax
js 0x540d06
movq $0x0, 0x1a8(%rbx)
jmp 0x5405fe
andl $0x7ff, %r12d # imm = 0x7FF
testb $0x1, 0x200(%rbx)
je 0x54087f
leaq 0x185769(%rip), %rdx # 0x6c5fcd
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl 0x1f8(%rbx), %eax
movl $0xffffffec, %r14d # imm = 0xFFFFFFEC
andl $0xf7ffffff, %eax # imm = 0xF7FFFFFF
jmp 0x540911
andl $0xbff, %r12d # imm = 0xBFF
testb $0x1, 0x200(%rbx)
je 0x5408bc
leaq 0x1856ff(%rip), %rdx # 0x6c5f9f
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movq 0x1a8(%rbx), %rax
movl $0xffffffec, %r14d # imm = 0xFFFFFFEC
movl 0x1c(%rax), %eax
cmpq %rax, 0x230(%rbx)
sete %cl
movl 0x1f8(%rbx), %eax
btl $0x1c, %eax
setae %dl
orb %cl, %dl
jne 0x54090c
andl $0x7ff, %r12d # imm = 0x7FF
testb $0x1, 0x200(%rbx)
je 0x54090c
leaq 0x1856c5(%rip), %rdx # 0x6c5fb6
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl 0x1f8(%rbx), %eax
movl $0xffffffec, %r14d # imm = 0xFFFFFFEC
andl $0xf5ffffff, %eax # imm = 0xF5FFFFFF
movl %r12d, %r15d
movl %eax, 0x1f8(%rbx)
movl 0x22c(%rbx), %r12d
andl $0xf000, %r12d # imm = 0xF000
cmpl $0x4000, %r12d # imm = 0x4000
je 0x5409a8
cmpl $0xa000, %r12d # imm = 0xA000
jne 0x540960
movq 0x1b8(%rbx), %rdi
movl %r15d, %esi
callq 0x41bf0
testl %eax, %eax
je 0x5409a8
callq 0x415e0
movl (%rax), %esi
cmpl $0x26, %esi
je 0x5409a8
cmpl $0x5f, %esi
je 0x5409a8
jmp 0x54098e
movl 0x204(%rbx), %edi
testl %edi, %edi
js 0x540974
movl %r15d, %esi
callq 0x405a0
jmp 0x540983
movq 0x1b8(%rbx), %rdi
movl %r15d, %esi
callq 0x3f390
testl %eax, %eax
je 0x5409a8
callq 0x415e0
movl (%rax), %esi
leaq 0x18564d(%rip), %rdx # 0x6c5fe2
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, %r14d # imm = 0xFFFFFFEC
cmpl %ebp, %r14d
cmovll %r14d, %ebp
movl 0x1f8(%rbx), %eax
cmpq $0x0, 0xa8(%rbx)
jne 0x5409dc
movl %eax, %ecx
andl $0x80, %ecx
je 0x5409dc
movq %rbx, %rdi
callq 0x541d53
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0x1f8(%rbx), %eax
testb $0x40, %al
je 0x540abd
movq 0x1b0(%rbx), %rdi
callq 0x50c7e3
testb $0x40, 0x1f8(%rbx)
je 0x540ab0
movl %eax, %r14d
movq 0x1b0(%rbx), %rdi
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x50c42f
movq (%r15), %r8
testl $0x4030, %r8d # imm = 0x4030
je 0x540a8f
movq 0xa0(%rbx), %r15
testq %r15, %r15
jne 0x540a53
movq 0x1b8(%rbx), %rsi
movq %rbx, %rdi
callq 0x5417bd
movq %rax, %r15
movq %rax, 0xa0(%rbx)
testq %rax, %rax
je 0x540cf3
movq 0x1b0(%rbx), %rdi
callq 0x50c423
movl %eax, 0x44(%r15)
movl 0xa0(%r15), %eax
movl %eax, %ecx
orl $0x40, %ecx
movl %ecx, 0xa0(%r15)
movq 0x8(%rsp), %rcx
movq %rcx, 0x88(%r15)
testl $0x34000000, %eax # imm = 0x34000000
jne 0x540ab0
movl %r14d, 0x40(%r15)
jmp 0x540ab0
movl 0x204(%rbx), %esi
movq 0x1b8(%rbx), %rdx
movq 0x10(%rsp), %r9
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x541015
testl %eax, %eax
jne 0x540ab2
xorl %eax, %eax
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0x1f8(%rbx), %eax
testb $0x4, %al
je 0x540bd6
movq 0xc8(%rbx), %r14
movq 0x1b0(%rbx), %rdi
callq 0x50c379
testl %eax, %eax
jne 0x540af0
movq 0x1b0(%rbx), %rdi
callq 0x50c7f3
testl %eax, %eax
je 0x540ccd
movq 0x1b0(%rbx), %rdi
callq 0x50c379
testl %eax, %eax
je 0x540b20
movq 0x1b0(%rbx), %rdi
callq 0x50c370
movq %rax, %r15
movq 0x1b0(%rbx), %rdi
callq 0x50c375
movq %rax, %r12
jmp 0x540b26
xorl %r12d, %r12d
movq %r14, %r15
movq 0x1b0(%rbx), %rdi
callq 0x50c38c
testl %eax, %eax
je 0x540b4e
movq 0x1b0(%rbx), %rdi
callq 0x50c383
movq 0x1b0(%rbx), %rdi
callq 0x50c388
movq 0x1b0(%rbx), %rdi
callq 0x50c7f3
testl %eax, %eax
je 0x540b7e
movq 0x1b0(%rbx), %rdi
callq 0x50c7ea
movq %rax, %r14
movq 0x1b0(%rbx), %rdi
callq 0x50c7ef
movq %rax, %r13
jmp 0x540b81
xorl %r13d, %r13d
movq 0x1b0(%rbx), %rdi
callq 0x50c39b
testl %eax, %eax
je 0x540ba9
movq 0x1b0(%rbx), %rdi
callq 0x50c396
movq 0x1b0(%rbx), %rdi
callq 0x50c3a5
movl 0x204(%rbx), %esi
movq 0x1b8(%rbx), %rdx
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %r14, %r9
callq 0x540fa2
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0x1f8(%rbx), %eax
btl $0xd, %eax
jae 0x540c0c
movq 0x1b0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x50c33d
testq %rax, %rax
je 0x540c06
cmpq $0x0, 0x8(%rsp)
je 0x540c06
movq 0x1b0(%rbx), %rdi
callq 0x50c801
movl 0x1f8(%rbx), %eax
testb $0x20, %al
je 0x540c34
movq 0x1b0(%rbx), %rdi
callq 0x50c801
movq 0x1b0(%rbx), %rdi
callq 0x50d912
movq 0x1b0(%rbx), %rdi
callq 0x50c7e3
movl 0x204(%rbx), %edi
testl %edi, %edi
js 0x540c9e
callq 0x3f770
movl $0xffffffff, 0x204(%rbx) # imm = 0xFFFFFFFF
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x540c9e
movq 0x1b8(%rbx), %rsi
callq 0x41b50
cmpl $-0x1, %eax
jne 0x540c93
callq 0x415e0
movl (%rax), %esi
leaq 0x18529e(%rip), %rdx # 0x6c5f16
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53e204
movq 0x1d8(%rbx), %rdi
callq 0x3f780
movl $0xffffffe7, %ebp # imm = 0xFFFFFFE7
movq $0x0, 0x1d8(%rbx)
movq 0x1b0(%rbx), %rdi
callq 0x50c34f
movq $0x0, 0x1b0(%rbx)
movl $0x2, 0x4(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x540bcb
callq 0x415e0
movl (%rax), %esi
leaq 0x1851eb(%rip), %rdx # 0x6c5ecd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %ebp # imm = 0xFFFFFFE7
jmp 0x540cbc
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x540ab2
leaq 0x1851e9(%rip), %r14 # 0x6c5eed
jmp 0x540d0d
leaq 0x1851ec(%rip), %r14 # 0x6c5ef9
callq 0x415e0
movl (%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x540cbc
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c
|
archive_write_disk_data_block
|
static ssize_t
_archive_write_disk_data_block(struct archive *_a,
const void *buff, size_t size, int64_t offset)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
ssize_t r;
archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
ARCHIVE_STATE_DATA, "archive_write_data_block");
a->offset = offset;
if (a->todo & TODO_HFS_COMPRESSION)
r = hfs_write_data_block(a, buff, size);
else
r = write_data_block(a, buff, size);
if (r < ARCHIVE_OK)
return (r);
if ((size_t)r < size) {
archive_set_error(&a->archive, 0,
"Too much data: Truncating file at %ju bytes",
(uintmax_t)a->filesize);
return (ARCHIVE_WARN);
}
#if ARCHIVE_VERSION_NUMBER < 3999000
return (ARCHIVE_OK);
#else
return (size);
#endif
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1852a2(%rip), %rcx # 0x6c602e
movl $0xc001b0c5, %esi # imm = 0xC001B0C5
movl $0x4, %edx
callq 0x55de18
movl %eax, %ecx
movq $-0x1e, %rax
cmpl $-0x1e, %ecx
je 0x540ded
movq %r12, 0x208(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x541d98
testq %rax, %rax
js 0x540ded
cmpq %r14, %rax
jae 0x540deb
movq 0x220(%rbx), %rcx
leaq 0x185271(%rip), %rdx # 0x6c6047
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x53e204
movq $-0x14, %rax
jmp 0x540ded
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c
|
set_times
|
static int
set_times(struct archive_write_disk *a,
int fd, int mode, const char *name,
time_t atime, long atime_nanos,
time_t birthtime, long birthtime_nanos,
time_t mtime, long mtime_nanos,
time_t cctime, long ctime_nanos)
{
/* Note: set_time doesn't use libarchive return conventions!
* It uses syscall conventions. So 0 here instead of ARCHIVE_OK. */
int r1 = 0, r2 = 0;
#ifdef F_SETTIMES
/*
* on Tru64 try own fcntl first which can restore even the
* ctime, fall back to default code path below if it fails
* or if we are not running as root
*/
if (a->user_uid == 0 &&
set_time_tru64(fd, mode, name,
atime, atime_nanos, mtime,
mtime_nanos, cctime, ctime_nanos) == 0) {
return (ARCHIVE_OK);
}
#else /* Tru64 */
(void)cctime; /* UNUSED */
(void)ctime_nanos; /* UNUSED */
#endif /* Tru64 */
#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
/*
* If you have struct stat.st_birthtime, we assume BSD
* birthtime semantics, in which {f,l,}utimes() updates
* birthtime to earliest mtime. So we set the time twice,
* first using the birthtime, then using the mtime. If
* birthtime == mtime, this isn't necessary, so we skip it.
* If birthtime > mtime, then this won't work, so we skip it.
*/
if (birthtime < mtime
|| (birthtime == mtime && birthtime_nanos < mtime_nanos))
r1 = set_time(fd, mode, name,
atime, atime_nanos,
birthtime, birthtime_nanos);
#else
(void)birthtime; /* UNUSED */
(void)birthtime_nanos; /* UNUSED */
#endif
r2 = set_time(fd, mode, name,
atime, atime_nanos,
mtime, mtime_nanos);
if (r1 != 0 || r2 != 0) {
archive_set_error(&a->archive, errno,
"Can't restore time");
return (ARCHIVE_WARN);
}
return (ARCHIVE_OK);
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rsp), %rax
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rsp, %rax
testl %esi, %esi
js 0x540fd5
movl %esi, %edi
movq %rax, %rsi
callq 0x3f550
jmp 0x540fea
movl $0xffffff9c, %edi # imm = 0xFFFFFF9C
movq %rdx, %rsi
movq %rax, %rdx
movl $0x100, %ecx # imm = 0x100
callq 0x40830
testl %eax, %eax
je 0x54100d
callq 0x415e0
movl (%rax), %esi
leaq 0x184bab(%rip), %rdx # 0x6c5ba7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
jmp 0x54100f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
|
/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_bzip2");
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 9; /* default */
f->data = data;
f->options = &archive_compressor_bzip2_options;
f->close = &archive_compressor_bzip2_close;
f->free = &archive_compressor_bzip2_free;
f->open = &archive_compressor_bzip2_open;
f->code = ARCHIVE_FILTER_BZIP2;
f->name = "bzip2";
#if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
return (ARCHIVE_OK);
#else
data->pdata = __archive_write_program_allocate("bzip2");
if (data->pdata == NULL) {
free(data);
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 0;
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Using external bzip2 program");
return (ARCHIVE_WARN);
#endif
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x53e895
movq %rax, %rbx
leaq 0x1840db(%rip), %rcx # 0x6c6073
movq %r14, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x54202a
movl $0x1, %edi
movl $0x70, %esi
callq 0x41eb8
testq %rax, %rax
je 0x542014
movl $0x9, (%rax)
movq %rax, 0x40(%rbx)
leaq 0x58(%rip), %rax # 0x542031
movq %rax, 0x18(%rbx)
leaq 0xa8(%rip), %rax # 0x54208c
movq %rax, 0x30(%rbx)
leaq 0x108(%rip), %rax # 0x5420f7
movq %rax, 0x38(%rbx)
leaq 0x12b(%rip), %rax # 0x542125
movq %rax, 0x20(%rbx)
movl $0x2, 0x50(%rbx)
leaq 0x184080(%rip), %rax # 0x6c608c
movq %rax, 0x48(%rbx)
xorl %ebp, %ebp
jmp 0x54202a
leaq 0x121cfa(%rip), %rdx # 0x663d15
movq %r14, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_compressor_bzip2_open
|
static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
data->compressed_buffer_size = bs;
data->compressed
= (char *)malloc(data->compressed_buffer_size);
if (data->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
}
memset(&data->stream, 0, sizeof(data->stream));
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
f->write = archive_compressor_bzip2_write;
/* Initialize compression library */
ret = BZ2_bzCompressInit(&(data->stream),
data->compression_level, 0, 30);
if (ret == BZ_OK) {
f->data = data;
return (ARCHIVE_OK);
}
/* Library setup failed: clean up. */
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library");
/* Override the error message if we know what really went wrong. */
switch (ret) {
case BZ_PARAM_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"invalid setup parameter");
break;
case BZ_MEM_ERROR:
archive_set_error(f->archive, ENOMEM,
"Internal error initializing compression library: "
"out of memory");
break;
case BZ_CONFIG_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"mis-compiled library");
break;
}
return (ARCHIVE_FATAL);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r15
movq 0x60(%r15), %rax
testq %rax, %rax
je 0x542142
movq 0x68(%r15), %r14
jmp 0x542199
movq 0x8(%rbx), %rdi
movl $0x10000, %r14d # imm = 0x10000
cmpl $0xb0c5c0de, (%rdi) # imm = 0xB0C5C0DE
jne 0x542180
callq 0x53e7ac
movslq %eax, %rcx
cmpl $0x10000, %ecx # imm = 0x10000
jbe 0x542169
movq %rcx, %r14
jmp 0x542180
testl %eax, %eax
je 0x542180
movl $0x10000, %r14d # imm = 0x10000
movl $0x10000, %eax # imm = 0x10000
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0x68(%r15)
movq %r14, %rdi
callq 0x41ec0
movq %rax, 0x60(%r15)
testq %rax, %rax
je 0x542225
leaq 0x8(%r15), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x8(%r15)
movq %rax, 0x20(%r15)
movl %r14d, 0x28(%r15)
leaq 0xb1(%rip), %rax # 0x542279
movq %rax, 0x28(%rbx)
movl (%r15), %esi
xorl %ebp, %ebp
xorl %edx, %edx
movl $0x1e, %ecx
callq 0x56c65e
testl %eax, %eax
je 0x54221f
movl %eax, %r14d
movq 0x8(%rbx), %rdi
leaq 0x183ece(%rip), %rdx # 0x6c60bd
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x9, %r14d
je 0x542255
cmpl $-0x3, %r14d
je 0x542243
cmpl $-0x2, %r14d
jne 0x54226c
movq 0x8(%rbx), %rdi
leaq 0x178225(%rip), %rdx # 0x6ba442
jmp 0x542260
movq %r15, 0x40(%rbx)
jmp 0x54226c
movq 0x8(%rbx), %rdi
leaq 0x183e62(%rip), %rdx # 0x6c6092
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x54226c
movq 0x8(%rbx), %rdi
leaq 0x17823d(%rip), %rdx # 0x6ba48b
movl $0xc, %esi
jmp 0x542265
movq 0x8(%rbx), %rdi
leaq 0x183e8d(%rip), %rdx # 0x6c60ed
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_compressor_bzip2_write
|
static int
archive_compressor_bzip2_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *data = (struct private_data *)f->data;
/* Update statistics */
data->total_in += length;
/* Compress input data to output buffer */
SET_NEXT_IN(data, buff);
data->stream.avail_in = length;
if (drive_compressor(f, data, 0))
return (ARCHIVE_FATAL);
return (ARCHIVE_OK);
}
|
pushq %rax
movq 0x40(%rdi), %rax
addq %rdx, 0x58(%rax)
movq %rsi, 0x8(%rax)
movl %edx, 0x10(%rax)
movq %rax, %rsi
xorl %edx, %edx
callq 0x54229f
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c
|
archive_write_add_filter_compress
|
int
archive_write_add_filter_compress(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_compress");
f->open = &archive_compressor_compress_open;
f->code = ARCHIVE_FILTER_COMPRESS;
f->name = "compress";
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x53e895
movq %rax, %rbx
leaq 0x183e1c(%rip), %rcx # 0x6c6188
movq %r14, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x5423a9
leaq 0x20(%rip), %rax # 0x5423b1
movq %rax, 0x20(%rbx)
movl $0x3, 0x50(%rbx)
leaq 0x183dfe(%rip), %rax # 0x6c61a1
movq %rax, 0x48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c
|
zisofs_detect_magic
|
static void
zisofs_detect_magic(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file = iso9660->cur_file;
const unsigned char *p, *endp;
const unsigned char *magic_buff;
uint32_t uncompressed_size;
unsigned char header_size;
unsigned char log2_bs;
size_t _ceil, doff;
uint32_t bst, bed;
int magic_max;
int64_t entry_size;
entry_size = archive_entry_size(file->entry);
if ((int64_t)sizeof(iso9660->zisofs.magic_buffer) > entry_size)
magic_max = (int)entry_size;
else
magic_max = sizeof(iso9660->zisofs.magic_buffer);
if (iso9660->zisofs.magic_cnt == 0 && s >= (size_t)magic_max)
/* It's unnecessary we copy buffer. */
magic_buff = buff;
else {
if (iso9660->zisofs.magic_cnt < magic_max) {
size_t l;
l = sizeof(iso9660->zisofs.magic_buffer)
- iso9660->zisofs.magic_cnt;
if (l > s)
l = s;
memcpy(iso9660->zisofs.magic_buffer
+ iso9660->zisofs.magic_cnt, buff, l);
iso9660->zisofs.magic_cnt += (int)l;
if (iso9660->zisofs.magic_cnt < magic_max)
return;
}
magic_buff = iso9660->zisofs.magic_buffer;
}
iso9660->zisofs.detect_magic = 0;
p = magic_buff;
/* Check the magic code of zisofs. */
if (memcmp(p, zisofs_magic, sizeof(zisofs_magic)) != 0)
/* This is not zisofs file which made by mkzftree. */
return;
p += sizeof(zisofs_magic);
/* Read a zisofs header. */
uncompressed_size = archive_le32dec(p);
header_size = p[4];
log2_bs = p[5];
if (uncompressed_size < 24 || header_size != 4 ||
log2_bs > 30 || log2_bs < 7)
return;/* Invalid or not supported header. */
/* Calculate a size of Block Pointers of zisofs. */
_ceil = (uncompressed_size +
(ARCHIVE_LITERAL_LL(1) << log2_bs) -1) >> log2_bs;
doff = (_ceil + 1) * 4 + 16;
if (entry_size < (int64_t)doff)
return;/* Invalid data. */
/* Check every Block Pointer has valid value. */
p = magic_buff + 16;
endp = magic_buff + magic_max;
while (_ceil && p + 8 <= endp) {
bst = archive_le32dec(p);
if (bst != doff)
return;/* Invalid data. */
p += 4;
bed = archive_le32dec(p);
if (bed < bst || bed > entry_size)
return;/* Invalid data. */
doff += bed - bst;
_ceil--;
}
file->zisofs.uncompressed_size = uncompressed_size;
file->zisofs.header_size = header_size;
file->zisofs.log2_bs = log2_bs;
/* Disable making a zisofs image. */
iso9660->zisofs.making = 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %r13
movq 0x20(%r13), %rdi
callq 0x50c953
movq %rax, %r14
cmpq $0x40, %rax
movl $0x40, %ebp
cmovlq %rax, %rbp
movslq 0x21c(%rbx), %rax
movslq %ebp, %r10
testq %rax, %rax
jne 0x54a103
cmpq %r12, %r10
jbe 0x54a156
cmpl %ebp, %eax
jge 0x54a14f
movq %r13, (%rsp)
movl $0x40, %r13d
subq %rax, %r13
cmpq %r12, %r13
cmovaeq %r12, %r13
leaq 0x1d9(%rbx,%rax), %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r10, %r15
callq 0x3f250
movq %r15, %r10
addl 0x21c(%rbx), %r13d
movl %r13d, 0x21c(%rbx)
cmpl %ebp, %r13d
movq (%rsp), %r13
jl 0x54a211
leaq 0x1d9(%rbx), %r15
andb $-0x2, 0x1d8(%rbx)
movabsq $0x7d6dbc99653e437, %rax # imm = 0x7D6DBC99653E437
cmpq %rax, (%r15)
jne 0x54a211
movl 0x8(%r15), %eax
cmpq $0x18, %rax
setb %cl
movb 0xd(%r15), %dl
cmpb $0x4, 0xc(%r15)
setne %sil
leal -0x1f(%rdx), %edi
cmpb $-0x18, %dil
setb %dil
orb %cl, %sil
orb %dil, %sil
jne 0x54a211
movzbl %dl, %ecx
leaq -0x1(%rax), %rsi
shrq %cl, %rsi
leaq 0x18(,%rsi,4), %rcx
cmpq %rcx, %r14
jl 0x54a211
cmpq $0x18, %r10
jl 0x54a1f4
addq %r15, %r10
movl 0x10(%r15), %edi
addq $0x1c, %r15
movl %edi, %r8d
cmpq %r8, %rcx
jne 0x54a211
movl -0x8(%r15), %r8d
movl %r8d, %r9d
subl %edi, %r9d
jb 0x54a211
cmpq %r8, %r14
jb 0x54a211
addq $-0x1, %rsi
jae 0x54a1f4
addq %r9, %rcx
leaq 0x4(%r15), %r9
movl %r8d, %edi
cmpq %r10, %r15
movq %r9, %r15
jbe 0x54a1c3
movl %eax, 0xc4(%r13)
movb $0x4, 0xc0(%r13)
movb %dl, 0xc1(%r13)
andb $-0x3, 0x1d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
wb_write_to_temp
|
static int
wb_write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
const char *xp = buff;
size_t xs = s;
/*
* If a written data size is big enough to use system-call
* and there is no waiting data, this calls write_to_temp() in
* order to reduce a extra memory copy.
*/
if (wb_remaining(a) == wb_buffmax() && s > (1024 * 16)) {
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
xs = s % LOGICAL_BLOCK_SIZE;
iso9660->wbuff_offset += s - xs;
if (write_to_temp(a, buff, s - xs) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
if (xs == 0)
return (ARCHIVE_OK);
xp += s - xs;
}
while (xs) {
size_t size = xs;
if (size > wb_remaining(a))
size = wb_remaining(a);
memcpy(wb_buffptr(a), xp, size);
if (wb_consume(a, size) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
xs -= size;
xp += size;
}
return (ARCHIVE_OK);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x4001, %rdx # imm = 0x4001
jb 0x54a519
movq 0xf8(%r15), %rax
cmpq $0x10000, 0x102e0(%rax) # imm = 0x10000
jne 0x54a519
movq %rbx, %r12
andq $-0x800, %r12 # imm = 0xF800
addq %r12, 0x102f0(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x549e0d
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %ecx, %ecx
jne 0x54a569
andl $0x7ff, %ebx # imm = 0x7FF
je 0x54a567
addq %r12, %r14
testq %rbx, %rbx
je 0x54a567
movq 0xf8(%r15), %rdi
movq 0x102e0(%rdi), %rax
cmpq %rax, %rbx
movq %rax, %r12
cmovbq %rbx, %r12
subq %rax, %rdi
addq $0x102dc, %rdi # imm = 0x102DC
movq %r14, %rsi
movq %r12, %rdx
callq 0x3f250
movq %r15, %rdi
movq %r12, %rsi
callq 0x549ce8
subq %r12, %rbx
addq %r12, %r14
testl %eax, %eax
je 0x54a519
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x54a569
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
wb_set_offset
|
static int
wb_set_offset(struct archive_write *a, int64_t off)
{
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
int64_t used, ext_bytes;
if (iso9660->wbuff_type != WB_TO_TEMP) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal Programming error: iso9660:wb_set_offset()");
return (ARCHIVE_FATAL);
}
used = sizeof(iso9660->wbuff) - iso9660->wbuff_remaining;
if (iso9660->wbuff_offset + used > iso9660->wbuff_tail)
iso9660->wbuff_tail = iso9660->wbuff_offset + used;
if (iso9660->wbuff_offset < iso9660->wbuff_written) {
if (used > 0 &&
write_to_temp(a, iso9660->wbuff, (size_t)used) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
iso9660->wbuff_offset = iso9660->wbuff_written;
lseek(iso9660->temp_fd, iso9660->wbuff_offset, SEEK_SET);
iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
used = 0;
}
if (off < iso9660->wbuff_offset) {
/*
* Write out waiting data.
*/
if (used > 0) {
if (wb_write_out(a) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
lseek(iso9660->temp_fd, off, SEEK_SET);
iso9660->wbuff_offset = off;
iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
} else if (off <= iso9660->wbuff_tail) {
iso9660->wbuff_remaining = (size_t)
(sizeof(iso9660->wbuff) - (off - iso9660->wbuff_offset));
} else {
ext_bytes = off - iso9660->wbuff_tail;
iso9660->wbuff_remaining = (size_t)(sizeof(iso9660->wbuff)
- (iso9660->wbuff_tail - iso9660->wbuff_offset));
while (ext_bytes >= (int64_t)iso9660->wbuff_remaining) {
if (write_null(a, (size_t)iso9660->wbuff_remaining)
!= ARCHIVE_OK)
return (ARCHIVE_FATAL);
ext_bytes -= iso9660->wbuff_remaining;
}
if (ext_bytes > 0) {
if (write_null(a, (size_t)ext_bytes) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
}
return (ARCHIVE_OK);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r12
cmpl $0x1, 0x102e8(%r12)
jne 0x54a651
movq %rsi, %r14
movq 0x102e0(%r12), %rax
movq 0x102f0(%r12), %rsi
movl $0x10000, %edx # imm = 0x10000
movq %rax, %rcx
negq %rcx
leaq (%rsi,%rcx), %rdi
addq $0x10000, %rdi # imm = 0x10000
movq 0x10300(%r12), %rcx
cmpq %rcx, %rdi
jle 0x54a5d7
movq %rdi, 0x10300(%r12)
movq %rdi, %rcx
subq %rax, %rdx
movq 0x102f8(%r12), %rax
cmpq %rax, %rsi
jge 0x54a671
testq %rdx, %rdx
jle 0x54a617
leaq 0x2dc(%r12), %rsi
movq %rbx, %rdi
callq 0x549e0d
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %ecx, %ecx
jne 0x54a6f8
movq 0x102f8(%r12), %rax
movq %rax, 0x102f0(%r12)
movl 0x8(%r12), %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3f980
movq $0x10000, 0x102e0(%r12) # imm = 0x10000
movq 0x102f0(%r12), %rsi
cmpq %r14, %rsi
jg 0x54a68e
movq 0x10300(%r12), %rcx
jmp 0x54a6ac
leaq 0x17cd5b(%rip), %rdx # 0x6c73b3
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x54a6f8
cmpq %r14, %rsi
jle 0x54a6ac
testq %rdx, %rdx
jle 0x54a68e
movq %rbx, %rdi
callq 0x549d40
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %ecx, %ecx
jne 0x54a6f8
movl 0x8(%r12), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3f980
movq %r14, 0x102f0(%r12)
movl $0x10000, %esi # imm = 0x10000
jmp 0x54a6ee
movq %r14, %r15
subq %rcx, %r15
jle 0x54a6e4
subq %rcx, %rsi
addq $0x10000, %rsi # imm = 0x10000
movq %rsi, 0x102e0(%r12)
cmpq %rsi, %r15
jl 0x54a704
movq %rbx, %rdi
callq 0x549c0e
testl %eax, %eax
jne 0x54a667
movq 0x102e0(%r12), %rsi
subq %rsi, %r15
jmp 0x54a6c6
subq %r14, %rsi
addq $0x10000, %rsi # imm = 0x10000
movq %rsi, 0x102e0(%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r15, %r15
jle 0x54a6f6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x549c0e
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %ecx, %ecx
jne 0x54a6f8
jmp 0x54a6f6
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
write_VD
|
static int
write_VD(struct archive_write *a, struct vdd *vdd)
{
struct iso9660 *iso9660;
unsigned char *bp;
uint16_t volume_set_size = 1;
char identifier[256];
enum VD_type vdt;
enum vdc vdc;
unsigned char vd_ver, fst_ver;
int r;
iso9660 = a->format_data;
switch (vdd->vdd_type) {
case VDD_JOLIET:
vdt = VDT_SUPPLEMENTARY;
vd_ver = fst_ver = 1;
vdc = VDC_UCS2;
break;
case VDD_ENHANCED:
vdt = VDT_SUPPLEMENTARY;
vd_ver = fst_ver = 2;
vdc = VDC_LOWERCASE;
break;
case VDD_PRIMARY:
default:
vdt = VDT_PRIMARY;
vd_ver = fst_ver = 1;
#ifdef COMPAT_MKISOFS
vdc = VDC_LOWERCASE;
#else
vdc = VDC_STD;
#endif
break;
}
bp = wb_buffptr(a) -1;
/* Volume Descriptor Type */
set_VD_bp(bp, vdt, vd_ver);
/* Unused Field */
set_unused_field_bp(bp, 8, 8);
/* System Identifier */
get_system_identitier(identifier, sizeof(identifier));
r = set_str_a_characters_bp(a, bp, 9, 40, identifier, vdc);
if (r != ARCHIVE_OK)
return (r);
/* Volume Identifier */
r = set_str_d_characters_bp(a, bp, 41, 72,
iso9660->volume_identifier.s, vdc);
if (r != ARCHIVE_OK)
return (r);
/* Unused Field */
set_unused_field_bp(bp, 73, 80);
/* Volume Space Size */
set_num_733(bp+81, iso9660->volume_space_size);
if (vdd->vdd_type == VDD_JOLIET) {
/* Escape Sequences */
bp[89] = 0x25;/* UCS-2 Level 3 */
bp[90] = 0x2F;
bp[91] = 0x45;
memset(bp + 92, 0, 120 - 92 + 1);
} else {
/* Unused Field */
set_unused_field_bp(bp, 89, 120);
}
/* Volume Set Size */
set_num_723(bp+121, volume_set_size);
/* Volume Sequence Number */
set_num_723(bp+125, iso9660->volume_sequence_number);
/* Logical Block Size */
set_num_723(bp+129, LOGICAL_BLOCK_SIZE);
/* Path Table Size */
set_num_733(bp+133, vdd->path_table_size);
/* Location of Occurrence of Type L Path Table */
set_num_731(bp+141, vdd->location_type_L_path_table);
/* Location of Optional Occurrence of Type L Path Table */
set_num_731(bp+145, 0);
/* Location of Occurrence of Type M Path Table */
set_num_732(bp+149, vdd->location_type_M_path_table);
/* Location of Optional Occurrence of Type M Path Table */
set_num_732(bp+153, 0);
/* Directory Record for Root Directory(BP 157 to 190) */
set_directory_record(bp+157, 190-157+1, vdd->rootent,
iso9660, DIR_REC_VD, vdd->vdd_type);
/* Volume Set Identifier */
r = set_str_d_characters_bp(a, bp, 191, 318, "", vdc);
if (r != ARCHIVE_OK)
return (r);
/* Publisher Identifier */
r = set_file_identifier(bp, 319, 446, vdc, a, vdd,
&(iso9660->publisher_identifier),
"Publisher File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Data Preparer Identifier */
r = set_file_identifier(bp, 447, 574, vdc, a, vdd,
&(iso9660->data_preparer_identifier),
"Data Preparer File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Application Identifier */
r = set_file_identifier(bp, 575, 702, vdc, a, vdd,
&(iso9660->application_identifier),
"Application File", 1, A_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Copyright File Identifier */
r = set_file_identifier(bp, 703, 739, vdc, a, vdd,
&(iso9660->copyright_file_identifier),
"Copyright File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Abstract File Identifier */
r = set_file_identifier(bp, 740, 776, vdc, a, vdd,
&(iso9660->abstract_file_identifier),
"Abstract File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Bibliographic File Identifier */
r = set_file_identifier(bp, 777, 813, vdc, a, vdd,
&(iso9660->bibliographic_file_identifier),
"Bibliongraphic File", 0, D_CHAR);
if (r != ARCHIVE_OK)
return (r);
/* Volume Creation Date and Time */
set_date_time(bp+814, iso9660->birth_time);
/* Volume Modification Date and Time */
set_date_time(bp+831, iso9660->birth_time);
/* Volume Expiration Date and Time(obsolete) */
set_date_time_null(bp+848);
/* Volume Effective Date and Time */
set_date_time(bp+865, iso9660->birth_time);
/* File Structure Version */
bp[882] = fst_ver;
/* Reserved */
bp[883] = 0;
/* Application Use */
memset(bp + 884, 0x20, 1395 - 884 + 1);
/* Reserved */
set_unused_field_bp(bp, 1396, LOGICAL_BLOCK_SIZE);
return (wb_consume(a, LOGICAL_BLOCK_SIZE));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq 0xf8(%rdi), %rcx
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
je 0x54a95d
cmpl $0x2, %eax
jne 0x54a969
movl $0x1, %r13d
movb $0x2, %al
movb $0x2, %dl
jmp 0x54a970
movb $0x1, %dl
movl $0x2, %r13d
movb $0x2, %al
jmp 0x54a970
xorl %r13d, %r13d
movb $0x1, %al
movb $0x1, %dl
movb %dl, 0x7(%rsp)
movq %rcx, %rbp
subq 0x102e0(%rcx), %rbp
leaq 0x102db(%rbp), %r15
movb %al, 0x102dc(%rbp)
movl $0x30304443, 0x102dd(%rbp) # imm = 0x30304443
movb $0x31, 0x102e1(%rbp)
movb %dl, 0x102e2(%rbp)
movq %rcx, 0x10(%rsp)
xorl %ebx, %ebx
movb %bl, 0x102e3(%rbp)
leaq 0x122(%rsp), %r14
movq %r14, %rdi
callq 0x3f130
leaq 0x20(%rsp), %r12
movl $0xff, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3f440
movb %bl, 0xff(%r12)
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x9, %edx
movl $0x28, %ecx
movq %r12, %r8
movl %r13d, %r9d
callq 0x54e57e
testl %eax, %eax
jne 0x54ada6
movq 0x10(%rsp), %rbx
movq 0x128(%rbx), %r8
movq %r14, %rdi
movq %r15, %rsi
movl $0x29, %edx
movl $0x48, %ecx
movl %r13d, %r9d
callq 0x54e5e6
testl %eax, %eax
jne 0x54ada6
movq %r15, %r12
movq %rbx, %r15
addq $0x102dc, %rbp # imm = 0x102DC
movq $0x0, 0x48(%rbp)
movl 0x118(%rbx), %eax
movb %al, 0x50(%rbp)
movl %eax, %ecx
shrl $0x8, %ecx
movb %cl, 0x51(%rbp)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, 0x52(%rbp)
movl %eax, %esi
shrl $0x18, %esi
movb %sil, 0x53(%rbp)
movb %sil, 0x54(%rbp)
movb %dl, 0x55(%rbp)
movb %cl, 0x56(%rbp)
movb %al, 0x57(%rbp)
movq 0x8(%rsp), %rbx
cmpl $0x1, 0x8(%rbx)
jne 0x54aa96
movw $0x2f25, 0x58(%rbp) # imm = 0x2F25
movb $0x45, 0x5a(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x5b(%rbp)
movups %xmm0, 0x68(%rbp)
jmp 0x54aaa4
leaq 0x58(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1000001, 0x78(%rbp) # imm = 0x1000001
movl 0x11c(%r15), %eax
movb %al, 0x7c(%rbp)
movl %eax, %ecx
shrl $0x8, %ecx
movb %cl, 0x7d(%rbp)
movb %cl, 0x7e(%rbp)
movb %al, 0x7f(%rbp)
movl $0x80800, 0x80(%rbp) # imm = 0x80800
movl 0x20(%rbx), %eax
movb %al, 0x84(%rbp)
movl %eax, %ecx
shrl $0x8, %ecx
movb %cl, 0x85(%rbp)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, 0x86(%rbp)
movl %eax, %esi
shrl $0x18, %esi
movb %sil, 0x87(%rbp)
movb %sil, 0x88(%rbp)
movb %dl, 0x89(%rbp)
movb %cl, 0x8a(%rbp)
movb %al, 0x8b(%rbp)
movl 0x24(%rbx), %eax
movb %al, 0x8c(%rbp)
movb %ah, 0x8d(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x8e(%rbp)
shrl $0x18, %eax
movb %al, 0x8f(%rbp)
xorl %ecx, %ecx
movl %ecx, 0x90(%rbp)
movl 0x28(%rbx), %eax
movl %eax, %edx
shrl $0x18, %edx
movb %dl, 0x94(%rbp)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, 0x95(%rbp)
movb %ah, 0x96(%rbp)
movb %al, 0x97(%rbp)
leaq 0x9c(%rbp), %rdi
movl %ecx, 0x98(%rbp)
movq (%rbx), %rdx
movl 0x8(%rbx), %r9d
movl $0x22, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x54d158
leaq 0x1744bd(%rip), %r8 # 0x6bf049
movq %r14, %rdi
movq %r12, %rsi
movl $0xbf, %edx
movl $0x13e, %ecx # imm = 0x13E
movl %r13d, %r9d
callq 0x54e5e6
testl %eax, %eax
jne 0x54ada6
leaq 0x140(%r15), %rax
leaq 0x17c972(%rip), %r10 # 0x6c752c
movq %r12, %rdi
movl $0x13f, %esi # imm = 0x13F
movl $0x1be, %edx # imm = 0x1BE
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x0
pushq $0x1
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x158(%r15), %rax
leaq 0x17c945(%rip), %r10 # 0x6c753b
movq %r12, %rdi
movl $0x1bf, %esi # imm = 0x1BF
movl $0x23e, %edx # imm = 0x23E
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x0
pushq $0x1
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x170(%r15), %rax
leaq 0x17c91c(%rip), %r10 # 0x6c754e
movq %r12, %rdi
movl $0x23f, %esi # imm = 0x23F
movl $0x2be, %edx # imm = 0x2BE
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x0
pushq $0x1
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x188(%r15), %rax
leaq 0x17c8f1(%rip), %r10 # 0x6c755f
movq %r12, %rdi
movl $0x2bf, %esi # imm = 0x2BF
movl $0x2e3, %edx # imm = 0x2E3
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x1
pushq $0x0
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x1a0(%r15), %rax
leaq 0x17c8c4(%rip), %r10 # 0x6c756e
movq %r12, %rdi
movl $0x2e4, %esi # imm = 0x2E4
movl $0x308, %edx # imm = 0x308
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x1
pushq $0x0
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x1b8(%r15), %rax
leaq 0x17c896(%rip), %r10 # 0x6c757c
movq %r12, %rdi
movl $0x309, %esi # imm = 0x309
movl $0x32d, %edx # imm = 0x32D
movl %r13d, %ecx
movq %r14, %r8
movq %rbx, %r9
pushq $0x1
pushq $0x0
pushq %r10
pushq %rax
callq 0x54e64e
addq $0x20, %rsp
testl %eax, %eax
jne 0x54ada6
leaq 0x32d(%rbp), %rdi
movq (%r15), %rsi
callq 0x54e810
leaq 0x33e(%rbp), %rdi
movq (%r15), %rsi
callq 0x54e810
movaps 0x17bf27(%rip), %xmm0 # 0x6c6c60
movups %xmm0, 0x34f(%rbp)
movq %r14, %rbx
xorl %r14d, %r14d
movb %r14b, 0x35f(%rbp)
leaq 0x360(%rbp), %rdi
movq (%r15), %rsi
callq 0x54e810
movb 0x7(%rsp), %al
movb %al, 0x371(%rbp)
movb %r14b, 0x372(%rbp)
leaq 0x373(%rbp), %rdi
movl $0x200, %edx # imm = 0x200
movl $0x20, %esi
callq 0x3fa90
addq $0x573, %rbp # imm = 0x573
movl $0x28d, %edx # imm = 0x28D
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3fa90
movl $0x800, %esi # imm = 0x800
movq %rbx, %rdi
callq 0x549ce8
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_gen_joliet_identifier
|
static int
isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
unsigned char *p;
size_t l;
int r;
size_t ffmax, parent_len;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node_joliet, isoent_cmp_key_joliet
};
if (isoent->children.cnt == 0)
return (0);
iso9660 = a->format_data;
if (iso9660->opt.joliet == OPT_JOLIET_LONGNAME)
ffmax = 206;
else
ffmax = 128;
r = idr_start(a, idr, isoent->children.cnt, (int)ffmax, 6, 2, &rb_ops);
if (r < 0)
return (r);
parent_len = 1;
for (np = isoent; np->parent != np; np = np->parent)
parent_len += np->mb_len + 1;
for (np = isoent->children.first; np != NULL; np = np->chnext) {
unsigned char *dot;
int ext_off, noff, weight;
size_t lt;
if ((l = np->file->basename_utf16.length) > ffmax)
l = ffmax;
p = malloc((l+1)*2);
if (p == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIVE_FATAL);
}
memcpy(p, np->file->basename_utf16.s, l);
p[l] = 0;
p[l+1] = 0;
np->identifier = (char *)p;
lt = l;
dot = p + l;
weight = 0;
while (lt > 0) {
if (!joliet_allowed_char(p[0], p[1]))
archive_be16enc(p, 0x005F); /* '_' */
else if (p[0] == 0 && p[1] == 0x2E) /* '.' */
dot = p;
p += 2;
lt -= 2;
}
ext_off = (int)(dot - (unsigned char *)np->identifier);
np->ext_off = ext_off;
np->ext_len = (int)l - ext_off;
np->id_len = (int)l;
/*
* Get a length of MBS of a full-pathname.
*/
if (np->file->basename_utf16.length > ffmax) {
if (archive_strncpy_l(&iso9660->mbs,
(const char *)np->identifier, l,
iso9660->sconv_from_utf16be) != 0 &&
errno == ENOMEM) {
archive_set_error(&a->archive, errno,
"No memory");
return (ARCHIVE_FATAL);
}
np->mb_len = (int)iso9660->mbs.length;
if (np->mb_len != (int)np->file->basename.length)
weight = np->mb_len;
} else
np->mb_len = (int)np->file->basename.length;
/* If a length of full-pathname is longer than 240 bytes,
* it violates Joliet extensions regulation. */
if (parent_len > 240
|| np->mb_len > 240
|| parent_len + np->mb_len > 240) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"The regulation of Joliet extensions;"
" A length of a full-pathname of `%s' is "
"longer than 240 bytes, (p=%d, b=%d)",
archive_entry_pathname(np->file->entry),
(int)parent_len, (int)np->mb_len);
return (ARCHIVE_FATAL);
}
/* Make an offset of the number which is used to be set
* hexadecimal number to avoid duplicate identifier. */
if (l == ffmax)
noff = ext_off - 6;
else if (l == ffmax-2)
noff = ext_off - 4;
else if (l == ffmax-4)
noff = ext_off - 2;
else
noff = ext_off;
/* Register entry to the identifier resolver. */
idr_register(idr, np, weight, noff);
}
/* Resolve duplicate identifier with Joliet Volume. */
idr_resolve(idr, idr_set_num_beutf16);
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl 0x38(%rsi), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x54c4ae
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %rcx
movl $0x60000, %eax # imm = 0x60000
movq %rcx, 0x18(%rsp)
andl 0x10370(%rcx), %eax
cmpl $0x40000, %eax # imm = 0x40000
movl $0xce, %eax
movl $0x80, %ecx
cmoveq %rax, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30fde5(%rip), %r9 # 0x85c000
movq %r12, %rsi
movl $0x6, %ecx
movl $0x2, %r8d
callq 0x54c9e5
testl %eax, %eax
js 0x54c4ae
movq 0x20(%rbx), %rax
cmpq %rbx, %rax
movq %r14, 0x10(%rsp)
movl $0x1, %r15d
je 0x54c269
movq %rbx, %rcx
movslq 0xbc(%rcx), %rcx
movq %rax, %rdx
addq %rcx, %r15
incq %r15
movq 0x20(%rax), %rax
movq %rdx, %rcx
cmpq %rdx, %rax
jne 0x54c24d
movq 0x28(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x54c440
movq 0x18(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
leaq -0x2(%rax), %rcx
movq %rcx, 0x30(%rsp)
addq $-0x4, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %r13
movq %r12, 0x40(%rsp)
movq 0x18(%r13), %rbp
movq 0x60(%rbp), %r14
movq 0x8(%rsp), %r12
cmpq %r12, %r14
cmovbq %r14, %r12
movl %r12d, %eax
leaq 0x2(,%rax,2), %rdi
callq 0x41ec0
testq %rax, %rax
je 0x54c453
movq %rax, %rbx
movq 0x58(%rbp), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x3f250
movq %rbx, %rbp
addq %r12, %rbp
movw $0x0, (%rbx,%r12)
movq %rbx, 0xa8(%r13)
testq %r14, %r14
je 0x54c355
movq %r12, %rax
movabsq $0x4000000230021, %rdi # imm = 0x4000000230021
movzbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
movl %edx, %esi
shll $0x8, %esi
orl %ecx, %esi
cmpl $0x20, %esi
jb 0x54c330
addl $-0x2a, %esi
cmpl $0x32, %esi
ja 0x54c341
btq %rsi, %rdi
jae 0x54c341
movw $0x5f00, (%rbx) # imm = 0x5F00
addq $0x2, %rbx
addq $-0x2, %rax
jne 0x54c30f
jmp 0x54c34e
testb %dl, %dl
jne 0x54c335
cmpb $0x2e, %cl
cmoveq %rbx, %rbp
jmp 0x54c335
movq 0xa8(%r13), %rbx
subl %ebx, %ebp
movl %ebp, 0xb0(%r13)
movl %r12d, %eax
subl %ebp, %eax
movl %eax, 0xb4(%r13)
movl %r12d, 0xb8(%r13)
movq 0x18(%r13), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, 0x60(%rax)
jbe 0x54c3d0
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
movq 0x38(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x53a8ad
testl %eax, %eax
je 0x54c3ae
callq 0x415e0
cmpl $0xc, (%rax)
je 0x54c491
movq 0x18(%rsp), %rax
movl 0x68(%rax), %ecx
movl %ecx, 0xbc(%r13)
movq 0x18(%r13), %rax
cmpl 0x48(%rax), %ecx
movl %ecx, %edx
movl $0x0, %esi
cmovel %esi, %edx
jmp 0x54c3dc
movl 0x48(%rax), %ecx
movl %ecx, 0xbc(%r13)
xorl %edx, %edx
cmpq $0xf0, %r15
ja 0x54c45c
cmpl $0xf0, %ecx
jg 0x54c461
movslq %ecx, %rcx
addq %r15, %rcx
cmpq $0xf1, %rcx
jae 0x54c461
cmpq %r14, 0x8(%rsp)
jbe 0x54c40f
cmpq 0x30(%rsp), %r12
jne 0x54c414
addl $-0x4, %ebp
jmp 0x54c421
addl $-0x6, %ebp
jmp 0x54c421
leal -0x2(%rbp), %eax
cmpq 0x28(%rsp), %r12
cmovnel %ebp, %eax
movl %eax, %ebp
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %ecx
callq 0x54ca83
movq 0x70(%r13), %r13
testq %r13, %r13
jne 0x54c2aa
leaq 0x785(%rip), %rsi # 0x54cbcc
movq %r12, %rdi
callq 0x54cb0b
xorl %eax, %eax
jmp 0x54c4ae
leaq 0x16db07(%rip), %rdx # 0x6b9f61
jmp 0x54c498
movq 0x20(%rsp), %r13
movq 0x20(%rax), %rdi
callq 0x50c801
movl 0xbc(%r13), %r9d
leaq 0x17b028(%rip), %rdx # 0x6c74a0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rax, %rcx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x53e204
jmp 0x54c4a9
leaq 0x16cadc(%rip), %rdx # 0x6b8f74
movq 0x10(%rsp), %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
idr_start
|
static int
idr_start(struct archive_write *a, struct idr *idr, int cnt, int ffmax,
int num_size, int null_size, const struct archive_rb_tree_ops *rbt_ops)
{
int r;
(void)ffmax; /* UNUSED */
r = idr_ensure_poolsize(a, idr, cnt);
if (r != ARCHIVE_OK)
return (r);
__archive_rb_tree_init(&(idr->rbtree), rbt_ops);
idr->wait_list.first = NULL;
idr->wait_list.last = &(idr->wait_list.first);
idr->pool_idx = 0;
idr->num_size = num_size;
idr->null_size = null_size;
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r14
cmpl %edx, 0x28(%rsi)
jge 0x54ca29
movl %edx, %r12d
movq %rdi, %r13
addl $0x7f, %r12d
andl $-0x80, %r12d
movq (%r14), %rdi
movslq %r12d, %rsi
shlq $0x6, %rsi
callq 0x41e68
testq %rax, %rax
je 0x54ca66
movq %rax, (%r14)
movl %r12d, 0x28(%r14)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x5105b0
leaq 0x18(%r14), %rax
movq $0x0, 0x18(%r14)
movq %rax, 0x20(%r14)
movl $0x0, 0x2c(%r14)
movl %ebp, 0x30(%r14)
movl %ebx, 0x34(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16d4f4(%rip), %rdx # 0x6b9f61
movq %r13, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x54ca57
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
idr_set_num
|
static void
idr_set_num(unsigned char *p, int num)
{
static const char xdig[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z'
};
num %= sizeof(xdig) * sizeof(xdig) * sizeof(xdig);
p[0] = xdig[(num / (sizeof(xdig) * sizeof(xdig)))];
num %= sizeof(xdig) * sizeof(xdig);
p[1] = xdig[ (num / sizeof(xdig))];
num %= sizeof(xdig);
p[2] = xdig[num];
}
|
movslq %esi, %rcx
movabsq $-0x4c33f8fa07b9c44d, %rdx # imm = 0xB3CC0705F8463BB3
movq %rcx, %rax
mulq %rdx
shrq $0xf, %rdx
imull $0xb640, %edx, %eax # imm = 0xB640
subl %eax, %ecx
imull $0x6523, %ecx, %eax # imm = 0x6523
shrl $0x19, %eax
leaq 0x17a02a(%rip), %rdx # 0x6c6e40
movb (%rax,%rdx), %sil
movb %sil, (%rdi)
imull $0x510, %eax, %eax # imm = 0x510
subl %eax, %ecx
movl $0xffff, %eax # imm = 0xFFFF
movl %ecx, %esi
andl %eax, %esi
imull $0x71d, %esi, %esi # imm = 0x71D
shrl $0x10, %esi
movb (%rsi,%rdx), %r8b
movb %r8b, 0x1(%rdi)
shll $0x2, %esi
leal (%rsi,%rsi,8), %esi
subl %esi, %ecx
andl %eax, %ecx
movb (%rcx,%rdx), %al
movb %al, 0x2(%rdi)
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_cmp_iso9660_identifier
|
static int
isoent_cmp_iso9660_identifier(const struct isoent *p1, const struct isoent *p2)
{
const char *s1, *s2;
int cmp;
int l;
s1 = p1->identifier;
s2 = p2->identifier;
/* Compare File Name */
l = p1->ext_off;
if (l > p2->ext_off)
l = p2->ext_off;
cmp = memcmp(s1, s2, l);
if (cmp != 0)
return (cmp);
if (p1->ext_off < p2->ext_off) {
s2 += l;
l = p2->ext_off - p1->ext_off;
while (l--)
if (0x20 != *s2++)
return (0x20
- *(const unsigned char *)(s2 - 1));
} else if (p1->ext_off > p2->ext_off) {
s1 += l;
l = p1->ext_off - p2->ext_off;
while (l--)
if (0x20 != *s1++)
return (*(const unsigned char *)(s1 - 1)
- 0x20);
}
/* Compare File Name Extension */
if (p1->ext_len == 0 && p2->ext_len == 0)
return (0);
if (p1->ext_len == 1 && p2->ext_len == 1)
return (0);
if (p1->ext_len <= 1)
return (-1);
if (p2->ext_len <= 1)
return (1);
l = p1->ext_len;
if (l > p2->ext_len)
l = p2->ext_len;
s1 = p1->identifier + p1->ext_off;
s2 = p2->identifier + p2->ext_off;
if (l > 1) {
cmp = memcmp(s1, s2, l);
if (cmp != 0)
return (cmp);
}
if (p1->ext_len < p2->ext_len) {
s2 += l;
l = p2->ext_len - p1->ext_len;
while (l--)
if (0x20 != *s2++)
return (0x20
- *(const unsigned char *)(s2 - 1));
} else if (p1->ext_len > p2->ext_len) {
s1 += l;
l = p1->ext_len - p2->ext_len;
while (l--)
if (0x20 != *s1++)
return (*(const unsigned char *)(s1 - 1)
- 0x20);
}
/* Compare File Version Number */
/* No operation. The File Version Number is always one. */
return (cmp);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
movq 0xa8(%rsi), %r15
movslq 0xb0(%r14), %r12
movslq 0xb0(%rsi), %rbp
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movslq %eax, %r13
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r13, %rdx
callq 0x41980
testl %eax, %eax
je 0x54ceab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %r9
movq %r15, %rsi
movq (%rsp), %r14
cmpl %ebp, %r12d
movq %rbp, %rdi
movq %r12, %r8
jge 0x54cee5
addq %rsi, %r13
movl %edi, %eax
subl %r8d, %eax
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x54cf0b
movzbl (%r13,%rcx), %edx
incq %rcx
cmpl $0x20, %edx
je 0x54ceca
movl $0x20, %eax
subl %edx, %eax
jmp 0x54ce9c
cmpl %edi, %r8d
jle 0x54cf0b
addq %r14, %r13
movl %r8d, %ecx
subl %edi, %ecx
xorl %edx, %edx
cmpl %edx, %ecx
je 0x54cf0b
movzbl (%r13,%rdx), %eax
incq %rdx
cmpl $0x20, %eax
je 0x54cef4
addl $-0x20, %eax
jmp 0x54ce9c
movl 0xb4(%r9), %r12d
cmpl $0x1, %r12d
je 0x54cf28
testl %r12d, %r12d
jne 0x54cf42
cmpl $0x0, 0xb4(%rbx)
jne 0x54cf38
jmp 0x54cf31
cmpl $0x1, 0xb4(%rbx)
jne 0x54cf38
xorl %eax, %eax
jmp 0x54ce9c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x54ce9c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x2, %r12d
jl 0x54ce9c
movl 0xb4(%rbx), %r13d
movl $0x1, %eax
cmpl $0x2, %r13d
jl 0x54ce9c
cmpl %r13d, %r12d
movl %r13d, %r15d
cmovbl %r12d, %r15d
movq %r14, %rbp
addq %r8, %rbp
movq %rsi, %rbx
addq %rdi, %rbx
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x41980
testl %eax, %eax
jne 0x54ce9c
cmpl %r13d, %r12d
jae 0x54cfbc
addq %r15, %rbx
subl %r12d, %r13d
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ecx, %r13d
je 0x54ce9c
movzbl (%rbx,%rcx), %edx
incq %rcx
cmpl $0x20, %edx
je 0x54cfa2
jmp 0x54cedc
subl %r13d, %r12d
jbe 0x54cf31
addq %r15, %rbp
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %ecx, %r12d
je 0x54ce9c
movzbl (%rbp,%rcx), %edx
incq %rcx
cmpl $0x20, %edx
je 0x54cfcc
addl $-0x20, %edx
movl %edx, %eax
jmp 0x54ce9c
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
set_time_915
|
static void
set_time_915(unsigned char *p, time_t t)
{
struct tm tm;
get_tmfromtime(&tm, &t);
set_num_711(p+0, tm.tm_year);
set_num_711(p+1, tm.tm_mon+1);
set_num_711(p+2, tm.tm_mday);
set_num_711(p+3, tm.tm_hour);
set_num_711(p+4, tm.tm_min);
set_num_711(p+5, tm.tm_sec);
set_num_712(p+6, (char)(get_gmoffset(&tm)/(60*15)));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
callq 0x40f90
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f460
movb 0x14(%r15), %al
movb %al, (%rbx)
movb 0x10(%r15), %al
incb %al
movb %al, 0x1(%rbx)
movb 0xc(%r15), %al
movb %al, 0x2(%rbx)
movb 0x8(%r15), %al
movb %al, 0x3(%rbx)
movb 0x4(%r15), %al
movb %al, 0x4(%rbx)
movb (%r15), %al
movb %al, 0x5(%rbx)
movabsq $0x48d159e26af37c05, %rax # imm = 0x48D159E26AF37C05
imulq 0x28(%r15)
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x8, %edx
addl %eax, %edx
movb %dl, 0x6(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
set_SUSP_CE
|
static int
set_SUSP_CE(unsigned char *p, int location, int offset, int size)
{
unsigned char *bp = p -1;
/* Extend the System Use Area
* "CE" Format:
* len ver
* +----+----+----+----+-----------+-----------+
* | 'C'| 'E'| 1C | 01 | LOCATION1 | LOCATION2 |
* +----+----+----+----+-----------+-----------+
* 0 1 2 3 4 12 20
* +-----------+
* | LOCATION3 |
* +-----------+
* 20 28
* LOCATION1 : Location of Continuation of System Use Area.
* LOCATION2 : Offset to Start of Continuation.
* LOCATION3 : Length of the Continuation.
*/
bp[1] = 'C';
bp[2] = 'E';
bp[3] = RR_CE_SIZE; /* length */
bp[4] = 1; /* version */
set_num_733(bp+5, location);
set_num_733(bp+13, offset);
set_num_733(bp+21, size);
return (RR_CE_SIZE);
}
|
movl $0x11c4543, (%rdi) # imm = 0x11C4543
movb %sil, 0x4(%rdi)
movl %esi, %eax
shrl $0x8, %eax
movb %al, 0x5(%rdi)
movl %esi, %r8d
shrl $0x10, %r8d
movb %r8b, 0x6(%rdi)
movl %esi, %r9d
shrl $0x18, %r9d
movb %r9b, 0x7(%rdi)
movb %r9b, 0x8(%rdi)
movb %r8b, 0x9(%rdi)
movb %al, 0xa(%rdi)
movb %sil, 0xb(%rdi)
movb %dl, 0xc(%rdi)
movl %edx, %eax
shrl $0x8, %eax
movb %al, 0xd(%rdi)
movl %edx, %esi
shrl $0x10, %esi
movb %sil, 0xe(%rdi)
movl %edx, %r8d
shrl $0x18, %r8d
movb %r8b, 0xf(%rdi)
movb %r8b, 0x10(%rdi)
movb %sil, 0x11(%rdi)
movb %al, 0x12(%rdi)
movb %dl, 0x13(%rdi)
movb %cl, 0x14(%rdi)
movl %ecx, %eax
shrl $0x8, %eax
movb %al, 0x15(%rdi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x16(%rdi)
movl %ecx, %esi
shrl $0x18, %esi
movb %sil, 0x17(%rdi)
movb %sil, 0x18(%rdi)
movb %dl, 0x19(%rdi)
movb %al, 0x1a(%rdi)
movb %cl, 0x1b(%rdi)
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
set_str_a_characters_bp
|
static int
set_str_a_characters_bp(struct archive_write *a, unsigned char *bp,
int from, int to, const char *s, enum vdc vdc)
{
int r;
switch (vdc) {
case VDC_STD:
set_str(bp+from, s, to - from + 1, 0x20,
a_characters_map);
r = ARCHIVE_OK;
break;
case VDC_LOWERCASE:
set_str(bp+from, s, to - from + 1, 0x20,
a1_characters_map);
r = ARCHIVE_OK;
break;
case VDC_UCS2:
case VDC_UCS2_DIRECT:
r = set_str_utf16be(a, bp+from, s, to - from + 1,
0x0020, vdc);
break;
default:
r = ARCHIVE_FATAL;
}
return (r);
}
|
leal -0x2(%r9), %eax
cmpl $0x2, %eax
jb 0x54e5ad
pushq %rax
cmpl $0x1, %r9d
je 0x54e5c4
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %r9d, %r9d
jne 0x54e5e4
movl %edx, %eax
addq %rax, %rsi
subl %edx, %ecx
incl %ecx
movslq %ecx, %rdx
leaq 0x178945(%rip), %rcx # 0x6c6ef0
jmp 0x54e5d7
movl %edx, %eax
addq %rax, %rsi
subl %edx, %ecx
incl %ecx
movslq %ecx, %rcx
movq %r8, %rdx
movl %r9d, %r8d
jmp 0x54ea3a
movl %edx, %eax
addq %rax, %rsi
subl %edx, %ecx
incl %ecx
movslq %ecx, %rdx
leaq 0x178899(%rip), %rcx # 0x6c6e70
movq %rsi, %rdi
movq %r8, %rsi
callq 0x54e9a7
xorl %eax, %eax
popq %rcx
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
set_option_info
|
static void
set_option_info(struct archive_string *info, int *opt, const char *key,
enum keytype type, ...)
{
va_list ap;
char prefix;
const char *s;
int d;
prefix = (*opt==0)? ' ':',';
va_start(ap, type);
switch (type) {
case KEY_FLG:
d = va_arg(ap, int);
archive_string_sprintf(info, "%c%s%s",
prefix, (d == 0)?"!":"", key);
break;
case KEY_STR:
s = va_arg(ap, const char *);
archive_string_sprintf(info, "%c%s=%s",
prefix, key, s);
break;
case KEY_INT:
d = va_arg(ap, int);
archive_string_sprintf(info, "%c%s=%d",
prefix, key, d);
break;
case KEY_HEX:
d = va_arg(ap, int);
archive_string_sprintf(info, "%c%s=%x",
prefix, key, d);
break;
}
va_end(ap);
*opt = 1;
}
|
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rbx
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x54ebdd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x0, (%rsi)
movl $0x20, %esi
movl $0x2c, %eax
cmovel %esi, %eax
movq %rdx, 0x10(%rsp)
leaq 0xe0(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movabsq $0x3000000020, %rdx # imm = 0x3000000020
movq %rdx, (%rsp)
movl $0x20, %edx
movl %ecx, %ecx
leaq 0x1780bd(%rip), %rsi # 0x6c6cd8
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
cmpl $0x28, %edx
ja 0x54ecd2
movl $0x20, %ecx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x54ece0
cmpl $0x28, %edx
ja 0x54ec8e
movl $0x20, %ecx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x54ec9c
cmpl $0x28, %edx
ja 0x54ecab
movl $0x20, %ecx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x54ecb9
cmpl $0x28, %edx
ja 0x54ed04
movl $0x20, %ecx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x54ed12
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movl (%rcx), %r8d
movzbl %al, %edx
leaq 0x178924(%rip), %rsi # 0x6c75cd
jmp 0x54ecc6
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movl (%rcx), %r8d
movzbl %al, %edx
leaq 0x17890f(%rip), %rsi # 0x6c75d5
movq %r10, %rcx
xorl %eax, %eax
callq 0x53dd88
jmp 0x54ed29
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movzbl %al, %edx
cmpl $0x0, (%rcx)
leaq 0x16cc57(%rip), %rax # 0x6bb944
leaq 0x170355(%rip), %rcx # 0x6bf049
cmoveq %rax, %rcx
leaq 0x15a69a(%rip), %rsi # 0x6a9399
movq %r10, %r8
jmp 0x54ed22
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx), %r8
movzbl %al, %edx
leaq 0x1788a6(%rip), %rsi # 0x6c75c5
movq %r10, %rcx
xorl %eax, %eax
callq 0x53dd88
movl $0x1, (%rbx)
addq $0xd0, %rsp
popq %rbx
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
isoent_free_all
|
static void
isoent_free_all(struct isoent *isoent)
{
struct isoent *np, *np_temp;
if (isoent == NULL)
return;
np = isoent;
for (;;) {
if (np->dir) {
if (np->children.first != NULL) {
/* Enter to sub directories. */
np = np->children.first;
continue;
}
}
for (;;) {
np_temp = np;
if (np->chnext == NULL) {
/* Return to the parent directory. */
np = np->parent;
_isoent_free(np_temp);
if (np == np_temp)
return;
} else {
np = np->chnext;
_isoent_free(np_temp);
break;
}
}
}
}
|
testq %rdi, %rdi
je 0x54ee24
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r14, %rbx
testb $0x2, 0xe8(%r14)
je 0x54edf4
movq 0x28(%rbx), %r14
testq %r14, %r14
jne 0x54edde
movq 0x70(%rbx), %r14
testq %r14, %r14
jne 0x54ee13
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x549b0d
cmpq %rbx, %r14
movq %r14, %rbx
jne 0x54edf4
jmp 0x54ee1d
movq %rbx, %rdi
callq 0x549b0d
jmp 0x54edde
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c
|
archive_write_set_format_mtree_default
|
static int
archive_write_set_format_mtree_default(struct archive *_a, const char *fn)
{
struct archive_write *a = (struct archive_write *)_a;
struct mtree_writer *mtree;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, fn);
if (a->format_free != NULL)
(a->format_free)(a);
if ((mtree = calloc(1, sizeof(*mtree))) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate mtree data");
return (ARCHIVE_FATAL);
}
mtree->mtree_entry = NULL;
mtree->first = 1;
memset(&(mtree->set), 0, sizeof(mtree->set));
mtree->keys = DEFAULT_KEYS;
mtree->dironly = 0;
mtree->indent = 0;
archive_string_init(&mtree->ebuf);
archive_string_init(&mtree->buf);
mtree_entry_register_init(mtree);
a->format_data = mtree;
a->format_free = archive_write_mtree_free;
a->format_name = "mtree";
a->format_options = archive_write_mtree_options;
a->format_write_header = archive_write_mtree_header;
a->format_close = archive_write_mtree_close;
a->format_write_data = archive_write_mtree_data;
a->format_finish_entry = archive_write_mtree_finish_entry;
a->archive.archive_format = ARCHIVE_FORMAT_MTREE;
a->archive.archive_format_name = "mtree";
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x54ef7a
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x54eeb8
movq %rbx, %rdi
callq *%rax
movl $0x1, %edi
movl $0x130, %esi # imm = 0x130
callq 0x41eb8
testq %rax, %rax
je 0x54ef64
movl $0x1, 0x70(%rax)
movl $0x3d863a, 0x120(%rax) # imm = 0x3D863A
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x38(%rax)
movq %rax, 0xf8(%rbx)
leaq 0xb7(%rip), %rax # 0x54efb1
movq %rax, 0x138(%rbx)
leaq 0x16d9dd(%rip), %rax # 0x6bc8e5
movq %rax, 0x100(%rbx)
leaq 0x107(%rip), %rcx # 0x54f01d
movq %rcx, 0x110(%rbx)
leaq 0x50c(%rip), %rcx # 0x54f430
movq %rcx, 0x120(%rbx)
leaq 0xda1(%rip), %rcx # 0x54fcd3
movq %rcx, 0x130(%rbx)
leaq 0x132c(%rip), %rcx # 0x55026c
movq %rcx, 0x128(%rbx)
leaq 0x148a(%rip), %rcx # 0x5503d8
movq %rcx, 0x118(%rbx)
movl $0x80000, 0x10(%rbx) # imm = 0x80000
movq %rax, 0x18(%rbx)
xorl %ebp, %ebp
jmp 0x54ef7a
leaq 0x16d957(%rip), %rdx # 0x6bc8c2
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
archive_write_mtree_data
|
static ssize_t
archive_write_mtree_data(struct archive_write *a, const void *buff, size_t n)
{
struct mtree_writer *mtree= a->format_data;
if (n > mtree->entry_bytes_remaining)
n = (size_t)mtree->entry_bytes_remaining;
mtree->entry_bytes_remaining -= n;
/* We don't need to compute a regular file sum */
if (mtree->mtree_entry == NULL)
return (n);
if (mtree->mtree_entry->filetype == AE_IFREG)
sum_update(mtree, buff, n);
return (n);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0xf8(%rdi), %r15
movq 0x78(%r15), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rbx
movq (%r15), %rax
subq %rbx, %rcx
movq %rcx, 0x78(%r15)
testq %rax, %rax
je 0x5503cf
cmpl $0x8000, 0xe4(%rax) # imm = 0x8000
jne 0x5503cf
movq %rsi, %r14
movl 0xe0(%r15), %eax
testb $0x1, %al
je 0x5502f8
testq %rbx, %rbx
je 0x5502f1
movl 0xe4(%r15), %edi
xorl %ecx, %ecx
leaq 0x1775a4(%rip), %rdx # 0x6c7870
movl %edi, %esi
shll $0x8, %esi
shrl $0x18, %edi
movzbl (%r14,%rcx), %r8d
xorl %edi, %r8d
xorl (%rdx,%r8,4), %esi
movl %esi, 0xe4(%r15)
incq %rcx
movl %esi, %edi
cmpq %rcx, %rbx
jne 0x5502ce
addq %rbx, 0xe8(%r15)
btl $0x8, %eax
jae 0x55031c
leaq 0x30be2b(%rip), %rax # 0x85c130
leaq 0xf0(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x8(%rax)
movl 0xe0(%r15), %eax
btl $0xd, %eax
jae 0x550340
leaq 0x30be07(%rip), %rax # 0x85c130
leaq 0xf8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x20(%rax)
movl 0xe0(%r15), %eax
btl $0xe, %eax
jae 0x550364
leaq 0x30bde3(%rip), %rax # 0x85c130
leaq 0x100(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x38(%rax)
movl 0xe0(%r15), %eax
btl $0x17, %eax
jae 0x550388
leaq 0x30bdbf(%rip), %rax # 0x85c130
leaq 0x108(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x50(%rax)
movl 0xe0(%r15), %eax
btl $0x18, %eax
jae 0x5503ac
leaq 0x30bd9b(%rip), %rax # 0x85c130
leaq 0x110(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x68(%rax)
movl 0xe0(%r15), %eax
btl $0x19, %eax
jae 0x5503cf
leaq 0x30bd77(%rip), %rax # 0x85c130
addq $0x118, %r15 # imm = 0x118
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x80(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
attr_counter_set_free
|
static void
attr_counter_set_free(struct mtree_writer *mtree)
{
struct att_counter_set *acs = &mtree->acs;
attr_counter_free(&acs->uid_list);
attr_counter_free(&acs->gid_list);
attr_counter_free(&acs->mode_list);
attr_counter_free(&acs->flags_list);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
testq %rdi, %rdi
je 0x550565
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r14
jne 0x550549
movq $0x0, 0xb8(%rbx)
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x55058d
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r14
jne 0x550571
movq $0x0, 0xc0(%rbx)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x5505b5
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r14
jne 0x550599
movq $0x0, 0xc8(%rbx)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5505dd
movq 0x8(%rdi), %r14
callq 0x41e70
movq %r14, %rdi
testq %r14, %r14
jne 0x5505c1
movq $0x0, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
mtree_entry_free
|
static void
mtree_entry_free(struct mtree_entry *me)
{
archive_string_free(&me->parentdir);
archive_string_free(&me->basename);
archive_string_free(&me->pathname);
archive_string_free(&me->symlink);
archive_string_free(&me->uname);
archive_string_free(&me->gname);
archive_string_free(&me->fflags_text);
free(me->dir_info);
free(me->reg_info);
free(me);
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x539f3f
leaq 0x50(%rbx), %rdi
callq 0x539f3f
leaq 0x68(%rbx), %rdi
callq 0x539f3f
leaq 0x80(%rbx), %rdi
callq 0x539f3f
leaq 0x98(%rbx), %rdi
callq 0x539f3f
leaq 0xb0(%rbx), %rdi
callq 0x539f3f
leaq 0xc8(%rbx), %rdi
callq 0x539f3f
movq 0x28(%rbx), %rdi
callq 0x41e70
movq 0x30(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
popq %rbx
jmp 0x41e70
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
write_mtree_entry
|
static int
write_mtree_entry(struct archive_write *a, struct mtree_entry *me)
{
struct mtree_writer *mtree = a->format_data;
struct archive_string *str;
int keys, ret;
if (me->dir_info) {
if (mtree->classic) {
/*
* Output a comment line to describe the full
* pathname of the entry as mtree utility does
* while generating classic format.
*/
if (!mtree->dironly)
archive_strappend_char(&mtree->buf, '\n');
if (me->parentdir.s)
archive_string_sprintf(&mtree->buf,
"# %s/%s\n",
me->parentdir.s, me->basename.s);
else
archive_string_sprintf(&mtree->buf,
"# %s\n",
me->basename.s);
}
if (mtree->output_global_set)
write_global(mtree);
}
archive_string_empty(&mtree->ebuf);
str = (mtree->indent || mtree->classic)? &mtree->ebuf : &mtree->buf;
if (!mtree->classic && me->parentdir.s) {
/*
* If generating format is not classic one(v1), output
* a full pathname.
*/
mtree_quote(str, me->parentdir.s);
archive_strappend_char(str, '/');
}
mtree_quote(str, me->basename.s);
keys = get_global_set_keys(mtree, me);
if ((keys & F_NLINK) != 0 &&
me->nlink != 1 && me->filetype != AE_IFDIR)
archive_string_sprintf(str, " nlink=%u", me->nlink);
if ((keys & F_GNAME) != 0 && archive_strlen(&me->gname) > 0) {
archive_strcat(str, " gname=");
mtree_quote(str, me->gname.s);
}
if ((keys & F_UNAME) != 0 && archive_strlen(&me->uname) > 0) {
archive_strcat(str, " uname=");
mtree_quote(str, me->uname.s);
}
if ((keys & F_FLAGS) != 0) {
if (archive_strlen(&me->fflags_text) > 0) {
archive_strcat(str, " flags=");
mtree_quote(str, me->fflags_text.s);
} else if (mtree->set.processing &&
(mtree->set.keys & F_FLAGS) != 0)
/* Overwrite the global parameter. */
archive_strcat(str, " flags=none");
}
if ((keys & F_TIME) != 0)
archive_string_sprintf(str, " time=%jd.%jd",
(intmax_t)me->mtime, (intmax_t)me->mtime_nsec);
if ((keys & F_MODE) != 0)
archive_string_sprintf(str, " mode=%o", (unsigned int)me->mode);
if ((keys & F_GID) != 0)
archive_string_sprintf(str, " gid=%jd", (intmax_t)me->gid);
if ((keys & F_UID) != 0)
archive_string_sprintf(str, " uid=%jd", (intmax_t)me->uid);
if ((keys & F_INO) != 0)
archive_string_sprintf(str, " inode=%jd", (intmax_t)me->ino);
if ((keys & F_RESDEV) != 0) {
archive_string_sprintf(str,
" resdevice=native,%ju,%ju",
(uintmax_t)me->devmajor,
(uintmax_t)me->devminor);
}
switch (me->filetype) {
case AE_IFLNK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=link");
if ((keys & F_SLINK) != 0) {
archive_strcat(str, " link=");
mtree_quote(str, me->symlink.s);
}
break;
case AE_IFSOCK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=socket");
break;
case AE_IFCHR:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=char");
if ((keys & F_DEV) != 0) {
archive_string_sprintf(str,
" device=native,%ju,%ju",
(uintmax_t)me->rdevmajor,
(uintmax_t)me->rdevminor);
}
break;
case AE_IFBLK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=block");
if ((keys & F_DEV) != 0) {
archive_string_sprintf(str,
" device=native,%ju,%ju",
(uintmax_t)me->rdevmajor,
(uintmax_t)me->rdevminor);
}
break;
case AE_IFDIR:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=dir");
break;
case AE_IFIFO:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=fifo");
break;
case AE_IFREG:
default: /* Handle unknown file types as regular files. */
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=file");
if ((keys & F_SIZE) != 0)
archive_string_sprintf(str, " size=%jd",
(intmax_t)me->size);
break;
}
/* Write a bunch of sum. */
if (me->reg_info)
sum_write(str, me->reg_info);
archive_strappend_char(str, '\n');
if (mtree->indent || mtree->classic)
mtree_indent(mtree);
if (mtree->buf.length > 32768) {
ret = __archive_write_output(
a, mtree->buf.s, mtree->buf.length);
archive_string_empty(&mtree->buf);
} else
ret = ARCHIVE_OK;
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0xf8(%rdi), %rbx
cmpq $0x0, 0x28(%rsi)
je 0x550cf2
cmpl $0x0, 0xd8(%rbx)
je 0x550ce1
cmpl $0x0, 0x124(%rbx)
jne 0x550cad
leaq 0x58(%rbx), %rdi
movl $0xa, %esi
callq 0x53a0ad
movq 0x38(%r12), %rdx
movq 0x50(%r12), %rcx
leaq 0x58(%rbx), %rdi
testq %rdx, %rdx
je 0x550cd0
leaq 0x177085(%rip), %rsi # 0x6c7d4c
xorl %eax, %eax
callq 0x53dd88
jmp 0x550ce1
leaq 0x17707e(%rip), %rsi # 0x6c7d55
movq %rcx, %rdx
xorl %eax, %eax
callq 0x53dd88
cmpl $0x0, 0x12c(%rbx)
je 0x550cf2
movq %rbx, %rdi
callq 0x5512ac
movq $0x0, 0x48(%rbx)
movl 0xd8(%rbx), %eax
leaq 0x40(%rbx), %r15
leaq 0x58(%rbx), %rcx
movl 0x128(%rbx), %edx
orl %eax, %edx
cmoveq %rcx, %r15
testl %eax, %eax
jne 0x550d37
movq 0x38(%r12), %rsi
testq %rsi, %rsi
je 0x550d37
movq %r15, %rdi
callq 0x551894
movq %r15, %rdi
movl $0x2f, %esi
callq 0x53a0ad
movq 0x50(%r12), %rsi
movq %r15, %rdi
callq 0x551894
movl 0x88(%rbx), %eax
movl 0x120(%rbx), %ebp
testl %eax, %eax
je 0x550e06
testb $0x30, %al
je 0x550d73
movq 0x98(%rbx), %rcx
movl %ebp, %edx
andl $-0x31, %edx
cmpq 0x100(%r12), %rcx
cmovel %edx, %ebp
testl $0x300000, %eax # imm = 0x300000
je 0x550d94
movq 0x90(%rbx), %rcx
movl %ebp, %edx
andl $0xffcfffff, %edx # imm = 0xFFCFFFFF
cmpq 0xf8(%r12), %rcx
cmovel %edx, %ebp
testb $0x8, %al
je 0x550dc0
movq 0xa8(%rbx), %rcx
cmpq 0x118(%r12), %rcx
jne 0x550dc0
movq 0xb0(%rbx), %rcx
movl %ebp, %edx
andl $-0x9, %edx
cmpq 0x120(%r12), %rcx
cmovel %edx, %ebp
btl $0x9, %eax
jae 0x550ddf
movl 0xa0(%rbx), %ecx
movl %ebp, %edx
andl $0xfffffdff, %edx # imm = 0xFFFFFDFF
cmpl 0xe8(%r12), %ecx
cmovel %edx, %ebp
movl $0xfffff000, %ecx # imm = 0xFFFFF000
addl 0xe4(%r12), %ecx
roll $0x14, %ecx
cmpl $0xb, %ecx
ja 0x551288
movl $0xa23, %edx # imm = 0xA23
btl %ecx, %edx
jae 0x55127c
btl $0xa, %ebp
jae 0x550e38
movl 0xe0(%r12), %edx
cmpl $0x1, %edx
je 0x550e38
cmpl $0x4000, 0xe4(%r12) # imm = 0x4000
je 0x550e38
leaq 0x176f2d(%rip), %rsi # 0x6c7d5b
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
testb $0x20, %bpl
je 0x550e68
cmpq $0x0, 0xb8(%r12)
je 0x550e68
leaq 0x176f15(%rip), %rsi # 0x6c7d65
movq %r15, %rdi
callq 0x53a099
movq 0xb0(%r12), %rsi
movq %r15, %rdi
callq 0x551894
btl $0x15, %ebp
jae 0x550e98
cmpq $0x0, 0xa0(%r12)
je 0x550e98
leaq 0x176eed(%rip), %rsi # 0x6c7d6d
movq %r15, %rdi
callq 0x53a099
movq 0x98(%r12), %rsi
movq %r15, %rdi
callq 0x551894
testb $0x8, %bpl
je 0x550ecc
cmpq $0x0, 0xd0(%r12)
je 0x550fd2
leaq 0x176ec1(%rip), %rsi # 0x6c7d75
movq %r15, %rdi
callq 0x53a099
movq 0xc8(%r12), %rsi
movq %r15, %rdi
callq 0x551894
btl $0x12, %ebp
jae 0x550ef3
movq 0x108(%r12), %rdx
movq 0x110(%r12), %rcx
leaq 0x176ea0(%rip), %rsi # 0x6c7d89
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
btl $0x9, %ebp
jae 0x550f12
movl 0xe8(%r12), %edx
leaq 0x176e8f(%rip), %rsi # 0x6c7d97
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
testb $0x10, %bpl
je 0x550f31
movq 0x100(%r12), %rdx
leaq 0x176e79(%rip), %rsi # 0x6c7da0
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
btl $0x14, %ebp
jae 0x550f50
movq 0xf8(%r12), %rdx
leaq 0x176e63(%rip), %rsi # 0x6c7da9
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
btl $0x1a, %ebp
jae 0x550f6f
movq 0x148(%r12), %rdx
leaq 0x176e4d(%rip), %rsi # 0x6c7db2
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
btl $0x1b, %ebp
jae 0x550f96
movq 0x138(%r12), %rdx
movq 0x140(%r12), %rcx
leaq 0x176e31(%rip), %rsi # 0x6c7dbd
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
movl $0xfffff000, %eax # imm = 0xFFFFF000
addl 0xe4(%r12), %eax
roll $0x14, %eax
cmpl $0xb, %eax
ja 0x551031
leaq 0x17677e(%rip), %rcx # 0x6c7734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
btl $0x13, %ebp
jae 0x5510f4
leaq 0x176e5e(%rip), %rsi # 0x6c7e2e
jmp 0x551024
cmpl $0x0, 0x80(%rbx)
je 0x550ecc
testb $0x8, 0x88(%rbx)
je 0x550ecc
leaq 0x176d8a(%rip), %rsi # 0x6c7d7d
movq %r15, %rdi
callq 0x53a099
jmp 0x550ecc
btl $0x13, %ebp
jae 0x5510f4
leaq 0x176e13(%rip), %rsi # 0x6c7e24
jmp 0x551024
btl $0x13, %ebp
jae 0x5510f4
leaq 0x176dc5(%rip), %rsi # 0x6c7de9
movq %r15, %rdi
callq 0x53a099
jmp 0x5510f4
btl $0x13, %ebp
jae 0x551046
leaq 0x176dfb(%rip), %rsi # 0x6c7e39
movq %r15, %rdi
callq 0x53a099
testw %bp, %bp
jns 0x5510f4
movq 0xf0(%r12), %rdx
leaq 0x176de6(%rip), %rsi # 0x6c7e44
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
jmp 0x5510f4
btl $0x13, %ebp
jae 0x551091
leaq 0x176d7c(%rip), %rsi # 0x6c7df6
jmp 0x551089
btl $0x13, %ebp
jae 0x551091
leaq 0x176d8f(%rip), %rsi # 0x6c7e18
movq %r15, %rdi
callq 0x53a099
testb $0x2, %bpl
je 0x5510f4
movq 0x128(%r12), %rdx
movq 0x130(%r12), %rcx
leaq 0x176d53(%rip), %rsi # 0x6c7e01
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
jmp 0x5510f4
btl $0x13, %ebp
jae 0x5510cf
leaq 0x176d10(%rip), %rsi # 0x6c7dd7
movq %r15, %rdi
callq 0x53a099
btl $0x10, %ebp
jae 0x5510f4
leaq 0x176d06(%rip), %rsi # 0x6c7de2
movq %r15, %rdi
callq 0x53a099
movq 0x80(%r12), %rsi
movq %r15, %rdi
callq 0x551894
movq 0x30(%r12), %r12
testq %r12, %r12
je 0x551227
movl (%r12), %eax
testb $0x1, %al
je 0x551124
movl 0x4(%r12), %edx
leaq 0x176d38(%rip), %rsi # 0x6c7e4e
movq %r15, %rdi
xorl %eax, %eax
callq 0x53dd88
movl (%r12), %eax
btl $0x8, %eax
jae 0x55114f
leaq 0x176d28(%rip), %rsi # 0x6c7e59
movq %r15, %rdi
callq 0x53a099
leaq 0x8(%r12), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x551c09
movl (%r12), %eax
btl $0xd, %eax
jae 0x55117a
leaq 0x176d09(%rip), %rsi # 0x6c7e65
movq %r15, %rdi
callq 0x53a099
leaq 0x18(%r12), %rsi
movq %r15, %rdi
movl $0x14, %edx
callq 0x551c09
movl (%r12), %eax
btl $0xe, %eax
jae 0x5511a5
leaq 0x176ced(%rip), %rsi # 0x6c7e74
movq %r15, %rdi
callq 0x53a099
leaq 0x2c(%r12), %rsi
movq %r15, %rdi
movl $0x14, %edx
callq 0x551c09
movl (%r12), %eax
btl $0x17, %eax
jae 0x5511d0
leaq 0x176ccf(%rip), %rsi # 0x6c7e81
movq %r15, %rdi
callq 0x53a099
leaq 0x40(%r12), %rsi
movq %r15, %rdi
movl $0x20, %edx
callq 0x551c09
movl (%r12), %eax
btl $0x18, %eax
jae 0x5511fb
leaq 0x176cb3(%rip), %rsi # 0x6c7e90
movq %r15, %rdi
callq 0x53a099
leaq 0x60(%r12), %rsi
movq %r15, %rdi
movl $0x30, %edx
callq 0x551c09
movl (%r12), %eax
btl $0x19, %eax
jae 0x551227
leaq 0x176c97(%rip), %rsi # 0x6c7e9f
movq %r15, %rdi
callq 0x53a099
addq $0x90, %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x40, %edx
callq 0x551c09
movq %r15, %rdi
movl $0xa, %esi
callq 0x53a0ad
cmpl $0x0, 0x128(%rbx)
jne 0x551246
cmpl $0x0, 0xd8(%rbx)
je 0x55124e
movq %rbx, %rdi
callq 0x551952
movq 0x60(%rbx), %rdx
cmpq $0x8001, %rdx # imm = 0x8001
jb 0x551271
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x53e917
movq $0x0, 0x60(%rbx)
jmp 0x551273
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %ecx
jne 0x551288
movl $0x4000, %ecx # imm = 0x4000
jmp 0x55128d
movl $0x8000, %ecx # imm = 0x8000
btl $0x13, %eax
jae 0x550e06
movl %ebp, %eax
andl $0xfff7ffff, %eax # imm = 0xFFF7FFFF
cmpl %ecx, 0x84(%rbx)
cmovel %eax, %ebp
jmp 0x550e06
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
mtree_quote
|
static void
mtree_quote(struct archive_string *s, const char *str)
{
const char *start;
char buf[4];
unsigned char c;
for (start = str; *str != '\0'; ++str) {
if (safe_char[*(const unsigned char *)str])
continue;
if (start != str)
archive_strncat(s, start, str - start);
c = (unsigned char)*str;
buf[0] = '\\';
buf[1] = (c / 64) + '0';
buf[2] = (c / 8 % 8) + '0';
buf[3] = (c % 8) + '0';
archive_strncat(s, buf, 4);
start = str + 1;
}
if (start != str)
archive_strncat(s, start, str - start);
}
|
movb (%rsi), %al
testb %al, %al
je 0x551951
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1(%rsi), %r12
leaq 0x175eb9(%rip), %r13 # 0x6c7770
leaq 0x4(%rsp), %r15
movq %rsi, %r14
movzbl %al, %ecx
cmpb $0x0, (%rcx,%r13)
jne 0x55191f
leaq -0x1(%r12), %rbp
cmpq %rsi, %rbp
je 0x5518e4
movq %r14, %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x53a01f
movb (%rbp), %al
movb $0x5c, 0x4(%rsp)
movl %eax, %ecx
shrb $0x6, %cl
orb $0x30, %cl
movb %cl, 0x5(%rsp)
movl %eax, %ecx
shrb $0x3, %cl
andb $0x7, %cl
orb $0x30, %cl
movb %cl, 0x6(%rsp)
andb $0x7, %al
orb $0x30, %al
movb %al, 0x7(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53a01f
movq %r12, %rsi
movb (%r12), %al
incq %r12
incq %r14
testb %al, %al
jne 0x5518bf
decq %r12
cmpq %rsi, %r12
je 0x551943
subq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x53a01f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c
|
archive_write_set_format_pax_restricted
|
int
archive_write_set_format_pax_restricted(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_pax_restricted");
r = archive_write_set_format_pax(&a->archive);
a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
a->archive.archive_format_name = "restricted POSIX pax interchange";
return (r);
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x176264(%rip), %rcx # 0x6c7ed7
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
cmpl $-0x1e, %eax
jne 0x551c8e
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
popq %rbx
retq
movq %rbx, %rdi
callq 0x551caa
movl $0x30003, 0x10(%rbx) # imm = 0x30003
leaq 0x17625b(%rip), %rcx # 0x6c7eff
movq %rcx, 0x18(%rbx)
popq %rbx
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
archive_write_pax_data
|
static ssize_t
archive_write_pax_data(struct archive_write *a, const void *buff, size_t s)
{
struct pax *pax;
size_t ws;
size_t total;
int ret;
pax = (struct pax *)a->format_data;
/*
* According to GNU PAX format 1.0, write a sparse map
* before the body.
*/
if (archive_strlen(&(pax->sparse_map))) {
ret = __archive_write_output(a, pax->sparse_map.s,
archive_strlen(&(pax->sparse_map)));
if (ret != ARCHIVE_OK)
return (ret);
ret = __archive_write_nulls(a, pax->sparse_map_padding);
if (ret != ARCHIVE_OK)
return (ret);
archive_string_empty(&(pax->sparse_map));
}
total = 0;
while (total < s) {
const unsigned char *p;
while (pax->sparse_list != NULL &&
pax->sparse_list->remaining == 0) {
struct sparse_block *sb = pax->sparse_list->next;
free(pax->sparse_list);
pax->sparse_list = sb;
}
if (pax->sparse_list == NULL)
return (total);
p = ((const unsigned char *)buff) + total;
ws = s - total;
if (ws > pax->sparse_list->remaining)
ws = (size_t)pax->sparse_list->remaining;
if (pax->sparse_list->is_hole) {
/* Current block is hole thus we do not write
* the body. */
pax->sparse_list->remaining -= ws;
total += ws;
continue;
}
ret = __archive_write_output(a, p, ws);
pax->sparse_list->remaining -= ws;
total += ws;
if (ret != ARCHIVE_OK)
return (ret);
}
return (total);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rbp
movq 0x48(%rbp), %rdx
testq %rdx, %rdx
je 0x5533ee
movq 0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x53e917
testl %eax, %eax
jne 0x5533e1
movq 0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x53e956
testl %eax, %eax
je 0x5533e6
movslq %eax, %r12
jmp 0x553462
movq $0x0, 0x48(%rbp)
testq %rbx, %rbx
je 0x55345f
movq 0x60(%rbp), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x553462
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0x55341e
movq (%rdi), %r13
callq 0x41e70
movq %r13, 0x60(%rbp)
movq %r13, %rdi
testq %r13, %r13
jne 0x5533ff
jmp 0x553462
movq %rbx, %r13
subq %r12, %r13
cmpq %rax, %r13
cmovaeq %rax, %r13
cmpl $0x0, 0x8(%rdi)
je 0x55343a
subq %r13, %rax
movq %rax, 0x18(%rdi)
jmp 0x553455
leaq (%r14,%r12), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x53e917
movq 0x60(%rbp), %rdi
subq %r13, 0x18(%rdi)
testl %eax, %eax
jne 0x5533e1
addq %r13, %r12
cmpq %rbx, %r12
jb 0x5533fa
jmp 0x553462
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
archive_write_pax_free
|
static int
archive_write_pax_free(struct archive_write *a)
{
struct pax *pax;
pax = (struct pax *)a->format_data;
if (pax == NULL)
return (ARCHIVE_OK);
archive_string_free(&pax->pax_header);
archive_string_free(&pax->sparse_map);
archive_string_free(&pax->l_url_encoded_name);
sparse_list_clear(pax);
free(pax);
a->format_data = NULL;
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq 0xf8(%rdi), %r14
testq %r14, %r14
je 0x5534d6
movq %rdi, %rbx
leaq 0x28(%r14), %rdi
callq 0x539f3f
leaq 0x40(%r14), %rdi
callq 0x539f3f
leaq 0x10(%r14), %rdi
callq 0x539f3f
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x5534c3
movq (%rdi), %rax
movq %rax, 0x60(%r14)
callq 0x41e70
jmp 0x5534ac
movq %r14, %rdi
callq 0x41e70
movq $0x0, 0xf8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
archive_write_pax_finish_entry
|
static int
archive_write_pax_finish_entry(struct archive_write *a)
{
struct pax *pax;
uint64_t remaining;
int ret;
pax = (struct pax *)a->format_data;
remaining = pax->entry_bytes_remaining;
if (remaining == 0) {
while (pax->sparse_list) {
struct sparse_block *sb;
if (!pax->sparse_list->is_hole)
remaining += pax->sparse_list->remaining;
sb = pax->sparse_list->next;
free(pax->sparse_list);
pax->sparse_list = sb;
}
}
ret = __archive_write_nulls(a, (size_t)(remaining + pax->entry_padding));
pax->entry_bytes_remaining = pax->entry_padding = 0;
return (ret);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
movq (%r15), %r14
testq %r14, %r14
jne 0x553524
movq 0x60(%r15), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x553524
cmpl $0x0, 0x8(%rdi)
jne 0x553510
addq 0x18(%rdi), %r14
movq (%rdi), %r12
callq 0x41e70
movq %r12, 0x60(%r15)
movq %r12, %rdi
testq %r12, %r12
jne 0x553506
addq 0x8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53e956
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
add_pax_attr_int
|
static void
add_pax_attr_int(struct archive_string *as, const char *key, int64_t value)
{
char tmp[1 + 3 * sizeof(value)];
tmp[sizeof(tmp) - 1] = 0;
add_pax_attr(as, key, format_int(tmp + sizeof(tmp) - 1, value));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x17(%rsp), %r14
movb $0x0, 0x1(%r14)
movq %rdx, %rsi
negq %rsi
cmovsq %rdx, %rsi
leaq 0x14c630(%rip), %rdi # 0x69ff9b
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rsi, %r9
subq %rax, %r9
movb (%rdi,%r9), %al
movb %al, (%r14)
decq %r14
cmpq $0x9, %rsi
movq %rdx, %rsi
ja 0x553975
testq %rcx, %rcx
js 0x5539aa
incq %r14
jmp 0x5539ae
movb $0x2d, (%r14)
movq %r14, %rdi
callq 0x3fd60
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x554182
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
sparse_list_add
|
static int
sparse_list_add(struct pax *pax, int64_t offset, int64_t length)
{
int64_t last_offset;
int r;
if (pax->sparse_tail == NULL)
last_offset = 0;
else {
last_offset = pax->sparse_tail->offset +
pax->sparse_tail->remaining;
}
if (last_offset < offset) {
/* Add a hole block. */
r = _sparse_list_add_block(pax, last_offset,
offset - last_offset, 1);
if (r != ARCHIVE_OK)
return (r);
}
/* Add data block. */
return (_sparse_list_add_block(pax, offset, length, 0));
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x553c8b
movq 0x18(%rax), %rsi
addq 0x10(%rax), %rsi
jmp 0x553c8d
xorl %esi, %esi
movq %r14, %rdx
subq %rsi, %rdx
jle 0x553cac
movq %r15, %rdi
movl $0x1, %ecx
callq 0x554294
testl %eax, %eax
je 0x553cac
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x554294
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
archive_write_pax_header_xattrs
|
static int
archive_write_pax_header_xattrs(struct archive_write *a,
struct pax *pax, struct archive_entry *entry)
{
int i = archive_entry_xattr_reset(entry);
while (i--) {
const char *name;
const void *value;
char *url_encoded_name = NULL, *encoded_name = NULL;
size_t size;
int r;
archive_entry_xattr_next(entry, &name, &value, &size);
url_encoded_name = url_encode(name);
if (url_encoded_name != NULL) {
/* Convert narrow-character to UTF-8. */
r = archive_strcpy_l(&(pax->l_url_encoded_name),
url_encoded_name, pax->sconv_utf8);
free(url_encoded_name); /* Done with this. */
if (r == 0)
encoded_name = pax->l_url_encoded_name.s;
else if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
return (ARCHIVE_FATAL);
}
}
archive_write_pax_header_xattr(pax, encoded_name,
value, size);
}
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbp
movq %rdi, %rbx
movq %rdx, 0x58(%rsp)
movq %rdx, %rdi
callq 0x50df28
testl %eax, %eax
je 0x554087
movq %rbx, 0x48(%rsp)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x50(%rsp)
leaq 0x28(%rbp), %rcx
movq %rcx, 0x40(%rsp)
movl $0x3, %r13d
leaq 0x157075(%rip), %r15 # 0x6aad83
movq %rbp, 0x8(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x50df45
movq 0x70(%rsp), %r14
movb (%r14), %bpl
testb %bpl, %bpl
je 0x553dd3
incq %r14
xorl %edi, %edi
movq %r14, %rax
movl %ebp, %ecx
leal -0x7f(%rcx), %edx
xorl %esi, %esi
cmpb $-0x5e, %dl
setb %sil
cmpb $0x25, %cl
leal 0x1(%rsi,%rsi), %edx
cmovel %r13d, %edx
cmpb $0x3d, %cl
cmovel %r13d, %edx
addl %edx, %edi
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x553d4b
incl %edi
callq 0x41ec0
movq %rax, %rbx
testq %rax, %rax
je 0x553e31
movzbl %bpl, %ecx
cmpb $0x21, %bpl
jge 0x553dbb
movb $0x25, (%rax)
movl %ecx, %edx
shrl $0x4, %edx
movb (%rdx,%r15), %dl
movb %dl, 0x1(%rax)
andl $0xf, %ecx
movb (%rcx,%r15), %cl
movb %cl, 0x2(%rax)
addq $0x3, %rax
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x553d87
jmp 0x553de5
cmpb $0x25, %bpl
je 0x553d91
cmpl $0x7f, %ecx
je 0x553d91
cmpl $0x3d, %ecx
je 0x553d91
movb %bpl, (%rax)
incq %rax
jmp 0x553dae
movl $0x1, %edi
callq 0x41ec0
movq %rax, %rbx
testq %rax, %rax
je 0x553e31
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x3fd60
movq 0x8(%rsp), %rcx
movq %rcx, %r12
movq 0x70(%rcx), %rcx
movq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x53a8ad
movl %eax, %r14d
movq %rbx, %rdi
callq 0x41e70
testl %r14d, %r14d
je 0x553e3a
callq 0x415e0
cmpl $0xc, (%rax)
je 0x554098
xorl %ebx, %ebx
jmp 0x553e3e
xorl %ebx, %ebx
movq 0x8(%rsp), %rbp
jmp 0x553e41
movq (%rbp), %rbx
movq %r12, %rbp
movq 0x68(%rsp), %r12
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x7c(%rbp), %eax
testb $0x2, %al
je 0x554020
movq 0x10(%rsp), %rax
leaq 0x2(,%rax,4), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
leaq 0x1(%rdx), %rdi
callq 0x41ec0
movq %rax, %r14
testq %rax, %rax
je 0x554015
movq %r12, %rcx
movq 0x10(%rsp), %rsi
movq %rsi, %rdx
movq %r14, %rax
cmpq $0x3, %rsi
leaq 0x17428a(%rip), %r10 # 0x6c8130
jb 0x553f21
movq %r14, %rax
movq 0x10(%rsp), %rdx
movq %r12, %rcx
movsbl (%rcx), %r8d
movl %r8d, %edi
shll $0x10, %edi
movsbl 0x1(%rcx), %esi
shll $0x8, %esi
movl %esi, %r9d
andl $0xf000, %r9d # imm = 0xF000
orl %edi, %r9d
movzbl 0x2(%rcx), %edi
orl %edi, %esi
addq $0x3, %rcx
addq $-0x3, %rdx
shrl $0x2, %r8d
andl $0x3f, %r8d
movb (%r8,%r10), %r8b
movb %r8b, (%rax)
shrl $0xc, %r9d
andl $0x3f, %r9d
movb (%r9,%r10), %r8b
movb %r8b, 0x1(%rax)
shrl $0x6, %esi
andl $0x3f, %esi
movb (%rsi,%r10), %sil
movb %sil, 0x2(%rax)
andl $0x3f, %edi
movb (%rdi,%r10), %sil
movb %sil, 0x3(%rax)
addq $0x4, %rax
cmpq $0x2, %rdx
ja 0x553eb3
cmpq $0x2, %rdx
je 0x553f50
cmpq $0x1, %rdx
jne 0x553f9d
movsbl (%rcx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
andl $0x3f, %edx
movb (%rdx,%r10), %sil
leaq 0x1(%rax), %rdx
movb %sil, (%rax)
shll $0x4, %ecx
andl $0x30, %ecx
movl $0x2, %esi
jmp 0x553f92
movsbl (%rcx), %edx
movl %edx, %esi
shll $0x10, %esi
movsbl 0x1(%rcx), %ecx
movl %ecx, %edi
shll $0x8, %edi
andl $0xf000, %edi # imm = 0xF000
orl %esi, %edi
shrl $0x2, %edx
andl $0x3f, %edx
movb (%rdx,%r10), %dl
movb %dl, (%rax)
shrl $0xc, %edi
andl $0x3f, %edi
movb (%rdi,%r10), %sil
leaq 0x2(%rax), %rdx
movb %sil, 0x1(%rax)
shll $0x2, %ecx
andl $0x3c, %ecx
movl $0x3, %esi
movl %ecx, %ecx
movb (%rcx,%r10), %cl
addq %rsi, %rax
movb %cl, (%rdx)
movb $0x0, (%rax)
testq %rbx, %rbx
je 0x554015
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x11, %edx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
leaq 0x16a134(%rip), %rsi # 0x6be0fe
callq 0x53a01f
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x53a099
movq %r12, %rbp
movq %rbx, %r12
movq 0x20(%rsp), %rbx
movq %r14, %rdi
callq 0x3fd60
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rbx
movq %rbp, %r12
movq %r14, %rdx
movq %rax, %rcx
callq 0x554182
leaq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rbp
callq 0x539f3f
movq %r14, %rdi
callq 0x41e70
movl 0x7c(%rbp), %eax
testb $0x1, %al
je 0x55407b
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0xd, %edx
movq %rbx, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
leaq 0x16a16e(%rip), %rsi # 0x6be1ba
callq 0x53a01f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53a099
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq 0x554182
movq %rbx, %rdi
callq 0x539f3f
movl 0x1c(%rsp), %eax
decl %eax
jne 0x553d13
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x167842(%rip), %rdx # 0x6bb8e1
movq 0x48(%rsp), %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
jmp 0x554089
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
build_pax_attribute_name
|
static char *
build_pax_attribute_name(char *dest, const char *src)
{
char buff[64];
const char *p;
/* Handle the null filename case. */
if (src == NULL || *src == '\0') {
strcpy(dest, "PaxHeader/blank");
return (dest);
}
/* Prune final '/' and other unwanted final elements. */
p = src + strlen(src);
for (;;) {
/* Ends in "/", remove the '/' */
if (p > src && p[-1] == '/') {
--p;
continue;
}
/* Ends in "/.", remove the '.' */
if (p > src + 1 && p[-1] == '.'
&& p[-2] == '/') {
--p;
continue;
}
break;
}
/* Pathological case: After above, there was nothing left.
* This includes "/." "/./." "/.//./." etc. */
if (p == src) {
strcpy(dest, "/PaxHeader/rootdir");
return (dest);
}
/* Convert unadorned "." into a suitable filename. */
if (*src == '.' && p == src + 1) {
strcpy(dest, "PaxHeader/currentdir");
return (dest);
}
/*
* TODO: Push this string into the 'pax' structure to avoid
* recomputing it every time. That will also open the door
* to having clients override it.
*/
#if HAVE_GETPID && 0 /* Disable this for now; see above comment. */
sprintf(buff, "PaxHeader.%d", getpid());
#else
/* If the platform can't fetch the pid, don't include it. */
strcpy(buff, "PaxHeader");
#endif
/* General case: build a ustar-compatible name adding
* "/PaxHeader/". */
build_ustar_entry_name(dest, src, p - src, buff);
return (dest);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x554134
movq %rsi, %r14
movb (%rsi), %bpl
testb %bpl, %bpl
je 0x554134
movq %r14, %rdi
callq 0x3fd60
testq %rax, %rax
jle 0x554109
movb -0x1(%r14,%rax), %cl
cmpb $0x2f, %cl
je 0x5540fc
cmpq $0x1, %rax
je 0x55415d
cmpb $0x2e, %cl
jne 0x55410e
cmpb $0x2f, -0x2(%r14,%rax)
jne 0x55410e
decq %rax
leaq 0x1(%rax), %rcx
cmpq $0x1, %rcx
ja 0x5540df
testq %rax, %rax
je 0x55414a
movabsq $0x6564616548786150, %rdx # imm = 0x6564616548786150
movq %rsp, %rcx
movq %rdx, (%rcx)
movw $0x72, 0x8(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5536eb
jmp 0x55413e
movups 0x173fab(%rip), %xmm0 # 0x6c80e6
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movups 0x173fa5(%rip), %xmm0 # 0x6c80f6
movups %xmm0, (%rbx)
movl $0x726964, 0xf(%rbx) # imm = 0x726964
jmp 0x55413e
movl $0x1, %eax
cmpb $0x2e, %bpl
jne 0x55410e
movups 0x173f9a(%rip), %xmm0 # 0x6c8109
movups %xmm0, (%rbx)
movabsq $0x726964746e6572, %rax # imm = 0x726964746E6572
movq %rax, 0xd(%rbx)
jmp 0x55413e
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
add_pax_attr_binary
|
static void
add_pax_attr_binary(struct archive_string *as, const char *key,
const char *value, size_t value_len)
{
int digits, i, len, next_ten;
char tmp[1 + 3 * sizeof(int)]; /* < 3 base-10 digits per byte */
/*-
* PAX attributes have the following layout:
* <len> <space> <key> <=> <value> <nl>
*/
len = 1 + (int)strlen(key) + 1 + (int)value_len + 1;
/*
* The <len> field includes the length of the <len> field, so
* computing the correct length is tricky. I start by
* counting the number of base-10 digits in 'len' and
* computing the next higher power of 10.
*/
next_ten = 1;
digits = 0;
i = len;
while (i > 0) {
i = i / 10;
digits++;
next_ten = next_ten * 10;
}
/*
* For example, if string without the length field is 99
* chars, then adding the 2 digit length "99" will force the
* total length past 100, requiring an extra digit. The next
* statement adjusts for this effect.
*/
if (len + digits >= next_ten)
digits++;
/* Now, we have the right length so we can build the line. */
tmp[sizeof(tmp) - 1] = 0; /* Null-terminate the work area. */
archive_strcat(as, format_int(tmp + sizeof(tmp) - 1, len + digits));
archive_strappend_char(as, ' ');
archive_strcat(as, key);
archive_strappend_char(as, '=');
archive_array_append(as, value, value_len);
archive_strappend_char(as, '\n');
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3fd60
leal (%r14,%rax), %ecx
addl $0x3, %ecx
testl %ecx, %ecx
jle 0x5541d6
xorl %eax, %eax
movl $0x1, %edx
movl $0xcccccccd, %esi # imm = 0xCCCCCCCD
movl %ecx, %edi
movl %edi, %r8d
imulq %rsi, %r8
shrq $0x23, %r8
incl %eax
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
cmpl $0x9, %edi
movl %r8d, %edi
ja 0x5541ba
jmp 0x5541dd
movl $0x1, %edx
xorl %eax, %eax
addl %ecx, %eax
xorl %edi, %edi
cmpl %edx, %eax
setge %dil
leaq 0x16(%rsp), %rsi
movb $0x0, 0x1(%rsi)
addl %eax, %edi
movl %edi, %ecx
negl %ecx
cmovsl %edi, %ecx
leaq 0x14bd9b(%rip), %r8 # 0x69ff9b
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r10
subq %rax, %r10
movb (%r8,%r10), %al
movb %al, (%rsi)
decq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x55420a
testl %edi, %edi
js 0x55423d
incq %rsi
jmp 0x554240
movb $0x2d, (%rsi)
movq %rbx, %rdi
callq 0x53a099
movq %rbx, %rdi
movl $0x20, %esi
callq 0x53a0ad
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53a099
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x53a0ad
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x539e34
movq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0ad
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c
|
archive_write_set_format_raw
|
int
archive_write_set_format_raw(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct raw *raw;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_raw");
/* If someone else was already registered, unregister them. */
if (a->format_free != NULL)
(a->format_free)(a);
raw = (struct raw *)calloc(1, sizeof(*raw));
if (raw == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate raw data");
return (ARCHIVE_FATAL);
}
raw->entries_written = 0;
a->format_data = raw;
a->format_name = "raw";
/* no options exist for this format */
a->format_options = NULL;
a->format_write_header = archive_write_raw_header;
a->format_write_data = archive_write_raw_data;
a->format_finish_entry = NULL;
/* nothing needs to be done on closing */
a->format_close = NULL;
a->format_free = archive_write_raw_free;
a->archive.archive_format = ARCHIVE_FORMAT_RAW;
a->archive.archive_format_name = "RAW";
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x173e5b(%rip), %rcx # 0x6c8170
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x5543d7
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x554343
movq %rbx, %rdi
callq *%rax
movl $0x1, %edi
movl $0x4, %esi
callq 0x41eb8
testq %rax, %rax
je 0x5543c1
movq %rax, 0xf8(%rbx)
leaq 0xf2991(%rip), %rax # 0x646cf6
movq %rax, 0x100(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%rbx)
leaq 0x63(%rip), %rax # 0x5543e0
movq %rax, 0x120(%rbx)
leaq 0xae(%rip), %rax # 0x554439
movq %rax, 0x128(%rbx)
movq $0x0, 0x130(%rbx)
leaq 0xab(%rip), %rax # 0x55444f
movq %rax, 0x138(%rbx)
movl $0x90000, 0x10(%rbx) # imm = 0x90000
leaq 0x173dec(%rip), %rax # 0x6c81a5
movq %rax, 0x18(%rbx)
xorl %ebp, %ebp
jmp 0x5543d7
leaq 0x173dc5(%rip), %rdx # 0x6c818d
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_raw.c
|
archive_write_raw_header
|
static int
archive_write_raw_header(struct archive_write *a, struct archive_entry *entry)
{
struct raw *raw = (struct raw *)a->format_data;
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_set_error(&a->archive, ERANGE,
"Raw format only supports filetype AE_IFREG");
return (ARCHIVE_FATAL);
}
if (raw->entries_written > 0) {
archive_set_error(&a->archive, ERANGE,
"Raw format only supports one entry per archive");
return (ARCHIVE_FATAL);
}
raw->entries_written++;
return (ARCHIVE_OK);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r14
movq %rsi, %rdi
callq 0x50c423
cmpl $0x8000, %eax # imm = 0x8000
jne 0x55440d
movl (%r14), %eax
testl %eax, %eax
jle 0x554430
leaq 0x173dc9(%rip), %rdx # 0x6c81d4
jmp 0x554414
leaq 0x173d95(%rip), %rdx # 0x6c81a9
movq %rbx, %rdi
movl $0x22, %esi
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incl %eax
movl %eax, (%r14)
xorl %eax, %eax
jmp 0x554428
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_raw.c
|
archive_write_shar_data_sed
|
static ssize_t
archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
{
static const size_t ensured = 65533;
struct shar *shar;
const char *src;
char *buf, *buf_end;
int ret;
size_t written = n;
shar = (struct shar *)a->format_data;
if (!shar->has_data || n == 0)
return (0);
src = (const char *)buff;
/*
* ensure is the number of bytes in buffer before expanding the
* current character. Each operation writes the current character
* and optionally the start-of-new-line marker. This can happen
* twice before entering the loop, so make sure three additional
* bytes can be written.
*/
if (archive_string_ensure(&shar->work, ensured + 3) == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
if (shar->work.length > ensured) {
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
}
buf = shar->work.s + shar->work.length;
buf_end = shar->work.s + ensured;
if (shar->end_of_line) {
*buf++ = 'X';
shar->end_of_line = 0;
}
while (n-- != 0) {
if ((*buf++ = *src++) == '\n') {
if (n == 0)
shar->end_of_line = 1;
else
*buf++ = 'X';
}
if (buf >= buf_end) {
shar->work.length = buf - shar->work.s;
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
buf = shar->work.s;
}
}
shar->work.length = buf - shar->work.s;
return (written);
}
|
xorl %eax, %eax
testq %rdx, %rdx
je 0x554ba7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xf8(%rdi), %r13
cmpl $0x0, 0x10(%r13)
je 0x554b99
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x60(%r13), %r12
movl $0x10000, %esi # imm = 0x10000
movq %r12, %rdi
callq 0x539f80
testq %rax, %rax
je 0x554b7c
movq 0x68(%r13), %rdx
cmpq $0xfffe, %rdx # imm = 0xFFFE
jb 0x554adf
movq (%r12), %rsi
movq %r14, %rdi
callq 0x53e917
movl %eax, %ecx
movq $-0x1e, %rax
testl %ecx, %ecx
jne 0x554b99
movq $0x0, 0x68(%r13)
xorl %edx, %edx
movq 0x60(%r13), %r12
addq %r12, %rdx
cmpl $0x0, 0x4(%r13)
movq %r14, (%rsp)
je 0x554aff
movb $0x58, (%rdx)
incq %rdx
movl $0x0, 0x4(%r13)
addq $0xfffd, %r12 # imm = 0xFFFD
leaq -0x1(%rbx), %rbp
xorl %r14d, %r14d
movb (%r15,%r14), %cl
leaq 0x1(%rdx), %rax
movb %cl, (%rdx)
cmpb $0xa, %cl
jne 0x554b36
cmpq %r14, %rbp
jne 0x554b2b
movl $0x1, 0x4(%r13)
jmp 0x554b36
movb $0x58, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %rax
cmpq %r12, %rax
jae 0x554b40
movq %rax, %rdx
jmp 0x554b67
movq 0x60(%r13), %rsi
subq %rsi, %rax
movq %rax, 0x68(%r13)
movq (%rsp), %rdi
movq %rax, %rdx
callq 0x53e917
testl %eax, %eax
jne 0x554b92
movq $0x0, 0x68(%r13)
movq 0x60(%r13), %rdx
incq %r14
cmpq %r14, %rbx
jne 0x554b0d
subq 0x60(%r13), %rdx
movq %rdx, 0x68(%r13)
movq %rbx, %rax
jmp 0x554b99
leaq 0x10f192(%rip), %rdx # 0x663d15
movq %r14, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movq $-0x1e, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
archive_write_shar_data_uuencode
|
static ssize_t
archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
size_t length)
{
struct shar *shar;
const char *src;
size_t n;
int ret;
shar = (struct shar *)a->format_data;
if (!shar->has_data)
return (ARCHIVE_OK);
src = (const char *)buff;
if (shar->outpos != 0) {
n = 45 - shar->outpos;
if (n > length)
n = length;
memcpy(shar->outbuff + shar->outpos, src, n);
if (shar->outpos + n < 45) {
shar->outpos += n;
return length;
}
uuencode_line(a, shar, shar->outbuff, 45);
src += n;
n = length - n;
} else {
n = length;
}
while (n >= 45) {
uuencode_line(a, shar, src, 45);
src += 45;
n -= 45;
if (shar->work.length < 65536)
continue;
ret = __archive_write_output(a, shar->work.s,
shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
}
if (n != 0) {
memcpy(shar->outbuff, src, n);
shar->outpos = n;
}
return (length);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xf8(%rdi), %r14
cmpl $0x0, 0x10(%r14)
je 0x554e8e
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x554e92
movl $0x2d, %ebp
subq %rax, %rbp
cmpq %rbx, %rbp
cmovaeq %rbx, %rbp
leaq (%r14,%rax), %rdi
addq $0x20, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f250
movq 0x50(%r14), %r13
addq %rbp, %r13
cmpq $0x2d, %r13
jb 0x554f06
movq %rbx, %r13
leaq 0x20(%r14), %rdx
movl $0x2d, %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x554fc2
movq $-0x1e, %rbx
testl %eax, %eax
jne 0x554f0a
addq %rbp, %r15
movq %r13, %rbx
subq %rbp, %r13
jmp 0x554e95
xorl %ebx, %ebx
jmp 0x554f0a
movq %rbx, %r13
movq %rbx, %rbp
cmpq $0x2d, %r13
jb 0x554eef
movq $-0x1e, %rbx
movl $0x2d, %ecx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x554fc2
testl %eax, %eax
jne 0x554f0a
movq 0x68(%r14), %rdx
cmpq $0x10000, %rdx # imm = 0x10000
jb 0x554ee1
movq 0x60(%r14), %rsi
movq %r12, %rdi
callq 0x53e917
testl %eax, %eax
jne 0x554f0a
movq $0x0, 0x68(%r14)
addq $0x2d, %r15
addq $-0x2d, %r13
cmpq $0x2c, %r13
ja 0x554ea5
testq %r13, %r13
je 0x554f1c
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3f250
movq %rbp, %rbx
movq %r13, 0x50(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rbx
jmp 0x554f0a
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
uuencode_group
|
static void
uuencode_group(const char _in[3], char out[4])
{
const unsigned char *in = (const unsigned char *)_in;
int t;
t = (in[0] << 16) | (in[1] << 8) | in[2];
out[0] = UUENC( 0x3f & (t >> 18) );
out[1] = UUENC( 0x3f & (t >> 12) );
out[2] = UUENC( 0x3f & (t >> 6) );
out[3] = UUENC( 0x3f & t );
}
|
movzbl (%rdi), %ecx
movl %ecx, %r8d
shll $0x10, %r8d
movzbl 0x1(%rdi), %r9d
shll $0x8, %r9d
movzbl 0x2(%rdi), %eax
leal (%r9,%rax), %edx
orl %r8d, %r9d
movl %ecx, %edi
shrb $0x2, %dil
addb $0x20, %dil
cmpb $0x4, %cl
movzbl %dil, %edi
movl $0x60, %ecx
cmovbl %ecx, %edi
movb %dil, (%rsi)
shrl $0xc, %r9d
andl $0x3f, %r9d
leal 0x20(%r9), %edi
testl %r9d, %r9d
movzbl %dil, %edi
cmovel %ecx, %edi
movb %dil, 0x1(%rsi)
shrl $0x6, %edx
andl $0x3f, %edx
leal 0x20(%rdx), %edi
testl %edx, %edx
movzbl %dil, %edx
cmovel %ecx, %edx
movb %dl, 0x2(%rsi)
andl $0x3f, %eax
leal 0x20(%rax), %edx
testl %eax, %eax
movzbl %dl, %eax
cmovel %ecx, %eax
movb %al, 0x3(%rsi)
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c
|
archive_write_set_format_ustar
|
int
archive_write_set_format_ustar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct ustar *ustar;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_ustar");
/* If someone else was already registered, unregister them. */
if (a->format_free != NULL)
(a->format_free)(a);
/* Basic internal sanity test. */
if (sizeof(template_header) != 512) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal: template_header wrong size: %zu should be 512",
sizeof(template_header));
return (ARCHIVE_FATAL);
}
ustar = (struct ustar *)calloc(1, sizeof(*ustar));
if (ustar == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return (ARCHIVE_FATAL);
}
a->format_data = ustar;
a->format_name = "ustar";
a->format_options = archive_write_ustar_options;
a->format_write_header = archive_write_ustar_header;
a->format_write_data = archive_write_ustar_data;
a->format_close = archive_write_ustar_close;
a->format_free = archive_write_ustar_free;
a->format_finish_entry = archive_write_ustar_finish_entry;
a->archive.archive_format = ARCHIVE_FORMAT_TAR_USTAR;
a->archive.archive_format_name = "POSIX ustar";
return (ARCHIVE_OK);
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1734e3(%rip), %rcx # 0x6c8630
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x555224
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x55517b
movq %rbx, %rdi
callq *%rax
movl $0x1, %edi
movl $0x28, %esi
callq 0x41eb8
testq %rax, %rax
je 0x55520e
movq %rax, 0xf8(%rbx)
leaq 0x1734b8(%rip), %rax # 0x6c8655
movq %rax, 0x100(%rbx)
leaq 0x82(%rip), %rax # 0x55522d
movq %rax, 0x110(%rbx)
leaq 0xfd(%rip), %rax # 0x5552b6
movq %rax, 0x120(%rbx)
leaq 0x2e7(%rip), %rax # 0x5554ae
movq %rax, 0x128(%rbx)
leaq 0x309(%rip), %rax # 0x5554de
movq %rax, 0x130(%rbx)
leaq 0x305(%rip), %rax # 0x5554e8
movq %rax, 0x138(%rbx)
leaq 0x316(%rip), %rax # 0x555507
movq %rax, 0x118(%rbx)
movl $0x30001, 0x10(%rbx) # imm = 0x30001
leaq 0x173449(%rip), %rax # 0x6c864f
movq %rax, 0x18(%rbx)
xorl %ebp, %ebp
jmp 0x555224
leaq 0x1716b5(%rip), %rdx # 0x6c68ca
movq %rbx, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c
|
archive_write_ustar_header
|
static int
archive_write_ustar_header(struct archive_write *a, struct archive_entry *entry)
{
char buff[512];
int ret, ret2;
struct ustar *ustar;
struct archive_entry *entry_main;
struct archive_string_conv *sconv;
ustar = (struct ustar *)a->format_data;
/* Setup default string conversion. */
if (ustar->opt_sconv == NULL) {
if (!ustar->init_default_conversion) {
ustar->sconv_default =
archive_string_default_conversion_for_write(&(a->archive));
ustar->init_default_conversion = 1;
}
sconv = ustar->sconv_default;
} else
sconv = ustar->opt_sconv;
/* Sanity check. */
if (archive_entry_pathname(entry) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't record entry in tar file without pathname");
return (ARCHIVE_FAILED);
}
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[0] != '\0' && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pathname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
ret = __archive_write_format_header_ustar(a, buff, entry, -1, 1, sconv);
if (ret < ARCHIVE_WARN) {
archive_entry_free(entry_main);
return (ret);
}
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
archive_entry_free(entry_main);
return (ret2);
}
if (ret2 < ret)
ret = ret2;
ustar->entry_bytes_remaining = archive_entry_size(entry);
ustar->entry_padding = 0x1ff & (-(int64_t)ustar->entry_bytes_remaining);
archive_entry_free(entry_main);
return (ret);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %r13
movq 0x10(%r13), %r15
testq %r15, %r15
jne 0x555301
cmpl $0x0, 0x20(%r13)
je 0x5552ea
movq 0x18(%r13), %r15
jmp 0x555301
movq %r14, %rdi
callq 0x53a698
movq %rax, %r15
movq %rax, 0x18(%r13)
movl $0x1, 0x20(%r13)
movq %rbx, %rdi
callq 0x50c801
testq %rax, %rax
je 0x555433
movq %rbx, %rdi
callq 0x50c6c6
testq %rax, %rax
jne 0x55533b
movq %rbx, %rdi
callq 0x50c9c5
testq %rax, %rax
jne 0x55533b
movq %rbx, %rdi
callq 0x50c423
cmpl $0x8000, %eax # imm = 0x8000
je 0x555345
movq %rbx, %rdi
xorl %esi, %esi
callq 0x50d589
movq %rbx, %rdi
callq 0x50c423
cmpl $0x4000, %eax # imm = 0x4000
jne 0x5553ec
movq %rbx, %rdi
callq 0x50c801
testq %rax, %rax
je 0x5553ec
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x5553ec
movq %r12, %rdi
callq 0x3fd60
cmpb $0x2f, -0x1(%r12,%rax)
je 0x5553ec
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r12, %rdi
callq 0x3fd60
movq %rax, %rbp
leaq 0x2(%rax), %rsi
movq %rsp, %rdi
callq 0x539f80
testq %rax, %rax
je 0x555489
movq %rsp, %rdi
movq $0x0, 0x8(%rdi)
movq %r12, %rsi
movq %rbp, %rdx
callq 0x53a01f
movq %rsp, %r12
movq %r12, %rdi
movl $0x2f, %esi
callq 0x53a0ad
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x50d4be
movq %r12, %rdi
callq 0x539f3f
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0x1, %r8d
movq %r15, %r9
callq 0x555523
movl %eax, %ebp
cmpl $-0x15, %eax
jle 0x55546e
movq %rsp, %rsi
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
callq 0x53e917
movl %eax, %r14d
cmpl $-0x15, %eax
jg 0x555450
xorl %edi, %edi
callq 0x50c34f
movl %r14d, %ebp
jmp 0x555475
leaq 0x172bd8(%rip), %rdx # 0x6c8012
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x53e204
movl $0xffffffe7, %ebp # imm = 0xFFFFFFE7
jmp 0x555475
cmpl %ebp, %r14d
cmovll %r14d, %ebp
movq %rbx, %rdi
callq 0x50c953
movq %rax, (%r13)
negl %eax
andl $0x1ff, %eax # imm = 0x1FF
movq %rax, 0x8(%r13)
xorl %edi, %edi
callq 0x50c34f
movl %ebp, %eax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17143a(%rip), %rdx # 0x6c68ca
movq %r14, %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x53e204
movq %rsp, %rdi
callq 0x539f3f
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
jmp 0x555475
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c
|
format_number
|
static int
format_number(int64_t v, char *p, int s, int maxsize, int strict)
{
int64_t limit;
limit = ((int64_t)1 << (s*3));
/* "Strict" only permits octal values with proper termination. */
if (strict)
return (format_octal(v, p, s));
/*
* In non-strict mode, we allow the number to overwrite one or
* more bytes of the field termination. Even old tar
* implementations should be able to handle this with no
* problem.
*/
if (v >= 0) {
while (s <= maxsize) {
if (v < limit)
return (format_octal(v, p, s));
s++;
limit <<= 3;
}
}
/* Base-256 can handle any number, positive or negative. */
return (format_256(v, p, maxsize));
}
|
testl %r8d, %r8d
je 0x555ca0
jmp 0x555cfc
movl %ecx, %eax
testq %rdi, %rdi
sets %cl
cmpl %eax, %edx
setg %r8b
orb %cl, %r8b
jne 0x555cd1
leal (%rdx,%rdx,2), %ecx
movl $0x1, %r8d
shlq %cl, %r8
leal 0x1(%rax), %ecx
cmpq %rdi, %r8
jg 0x555c9e
incl %edx
shlq $0x3, %r8
cmpl %edx, %ecx
jne 0x555cc2
movl %eax, %ecx
addq %rcx, %rsi
testl %eax, %eax
jle 0x555cf2
incl %eax
movl %edi, %ecx
movb %dil, -0x1(%rsi)
decq %rsi
sarq $0x8, %rdi
decl %eax
cmpl $0x1, %eax
ja 0x555cdc
jmp 0x555cf4
movb (%rsi), %cl
orb $-0x80, %cl
movb %cl, (%rsi)
xorl %eax, %eax
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.