kpack64.asm

; kpack = Kolibri Packer
; Written by diamond in 2006 specially for KolibriOS

; Uses LZMA compression library by Igor Pavlov
; (for more information on LZMA and 7-Zip visit http://www.7-zip.org)
; (plain-C packer and ASM unpacker are ported by diamond)

;freebsd = 1 ;uncomment for FreeBSD-specific changes

	format ELF64
	public _start
.data? fix section ".bss" writeable align 4
.data  fix section ".data" writeable align 4
.const fix section ".const" align 4
.code  fix section ".text" executable align 16
offset fix
ptr fix
struc label type {
  label . type }

extrn lzma_compress
extrn lzma_set_dict_size

.data?
infilename	dq	?
outfilename	dq	?
infile		dq	?
outfile1	dq	?
outfile2	dq	?
outfile		dq	?
outfilebest	dq	?
workmem		dq	?
insize		dd	?
outsize		dd	?
lzma_dictsize	dd	?
		dd	?
strucstat	rq	18

if defined freebsd
st_atime_offset = 24
st_mtime_offset = 40
st_birthtime_offset = 104
st_size_offset = 72
else
st_atime_offset = 72
st_mtime_offset = 88
;st_birthtime_offset not defined
st_size_offset = 48
end if

timeval		rq	2*2
public environ
environ		dq	?
public __progname
__progname	dq	?
ct1		db	256 dup (?)
ctn		dd	?
cti		db	?

.const
info_str	db	'KPack - Kolibri Packer, version 0.11',13,10
		db	'Uses LZMA v4.32 compression library',13,10,13,10
info_len	=	$ - offset info_str
usage_str	db	'Written by diamond in 2006, 2007 specially for KolibriOS',13,10
		db	'LZMA compression library is copyright (c) 1999-2005 by Igor Pavlov',13,10
		db	13,10
		db	'Usage: kpack [--nologo] <infile> [<outfile>]',13,10
usage_len	=	$ - offset usage_str
errload_str	db	'Cannot load input file',13,10
errload_len	=	$ - offset errload_str
outfileerr_str	db	'Cannot save output file',13,10
outfileerr_len	=	$ - offset outfileerr_str
nomem_str	db	'No memory',13,10
nomem_len	=	$ - offset nomem_str
too_big_str	db	'failed, output is greater than input.',13,10
too_big_len	=	$ - too_big_str
compressing_str	db	'Compressing ... '
compressing_len = $ - compressing_str

.data
bNoLogo         db      0
done_str	db	'OK! Compression ratio: '
ratio		dw	'00'
		db	'%',13,10,13,10
done_len	=	$ - done_str

use_lzma	=	1

use_no_calltrick =	0
use_calltrick1	=	40h
use_calltrick2	=	80h

method			db	1

.code
; Write string from [rsi] of rdx bytes.
write_string:
; 1. Align stack on 16 bytes.
	push	rdi
; 2. Set rdi to 1 = descriptor for stdout.
	xor	edi, edi
	inc	edi
; 3. Do system call.
	call	write
; 4. Restore stack and return.
	pop	rdi
	ret

; Write string from [rsi] of rdx bytes and exit. Note that main code jumps (not calls) here,
; so we should not align the stack.
write_exit:
; 1. Call prev func.
	call	write_string
; 2. Do system call for exit.
; Note that this can be used as independent proc jumped (not called) to.
doexit:
	xor	edi, edi
	call	exit

; Main procedure.
_start:
; 1. Parse command line.
; Linux: [rsp] = argc, rsp+8 = argv
; FreeBSD: [rdi] = argc, rdi+8 = argv
; 1a. Load argc and argv to registers,
; skip first argument (which is always program name)
if defined freebsd
	mov	ecx, [rdi]	; ecx = argc
	add	rdi, 16		; rdi = &argv[1]
else
	mov	ecx, [rsp]	; ecx = argc
	lea	rdi, [rsp+16]	; rdi = &argv[1]
end if
; 1b. Test for first filename parameter. If no, goto step 2.
	call	get_file_name
	jz	usage
; 1c. We got input file name, save it.
; Assume that output file name is the same; if no, we will rewrite it in step 1d.
	mov	[infilename], rax
	mov	[outfilename], rax
; 1d. Test for second filename parameter. If yes, rewrite assumption in step 1c and check that there are no 3rd parameter.
	call	get_file_name
	jz	@f
	mov	[outfilename], rax
	call	get_file_name
	jnz	usage
@@:
; 1e. Parsing is done, process to step 3.
	jmp	short cont
; 2. No arguments or too many arguments given; write message and exit.
usage:
        cmp     [bNoLogo], 0
        jnz     doexit
	push	info_len + usage_len
	pop	rdx
	mov	rsi, offset info_str;usage_str
	jmp	write_exit
; 3. Say hello unless disabled with --nologo.
cont:
        cmp     [bNoLogo], 0
        jnz     @f
	push	info_len
	pop	rdx
	mov	rsi, info_str
	call	write_string
@@:
; 4. Load the input file.
; 4a. Do system call for stat - get file times and file size.
	mov	rdi, [infilename]
	mov	rsi, offset strucstat
	mov	r13, rsi
	call	stat
; 4b. Test result; if not 0 (0 is OK), goto 4e.
	test	rax, rax
	jnz	short infileerr
; 4c. Do system call for open.
	mov	rdi, [infilename]
	mov	rsi, offset open_mode
	call	fopen
; 4d. Test result; if not NULL, goto 4f.
	test	rax, rax
	jnz	short inopened
infileerr:
; 4e. Say error and abort.
	push	errload_len
	pop	rdx
	mov	rsi, offset errload_str
	jmp	write_exit
inopened:
	mov	r12, rax
; 4f. Check that the size is nonzero and less than 4G.
	mov	edi, [r13+st_size_offset]
	test	edi, edi
	jz	short infileerr
	cmp	dword [r13+st_size_offset+4], 0
	jnz	short infileerr
; 4g. Allocate memory for the input file.
	mov	[insize], edi
	call	malloc
	test	rax, rax
	jz	nomem
	mov	[infile], rax
; 4g. Read the input file to the allocated memory.
	mov	rdi, rax
	push	1
	pop	rsi
	mov	edx, [r13+st_size_offset]
	mov	rcx, r12
	call	fread
; 4h. Test result; must be equal to file size.
	cmp	eax, [r13+st_size_offset]
	jnz	infileerr
; 4i. Close the input file.
	mov	rdi, r12
	call	fclose
; 5. Calculate maximum size of the output.
	mov	edi, [insize]
	shr	edi, 3
	add	edi, [insize]
	add	edi, 400h	; should be enough for header
	mov	r12d, edi
; 6. Allocate memory for two copies of maximum output.
; 6a. Do system call.
	add	edi, edi
	call	malloc
; 6b. Test return value. If ok, goto 6d.
	test	rax, rax
	jnz	short outmemok
; 6c. No memory; say error and exit.
nomem:
	push	nomem_len
	pop	rdx
	mov	rsi, offset nomem_str
	jmp	write_exit
; 6d. Remember allocated memory address.
outmemok:
	mov	[outfile], rax
	mov	[outfile1], rax
	mov	[outfilebest], rax
	add	rax, r12
	mov	[outfile2], rax
	sub	rax, r12
; 7. Initialize KPCK header.
	mov	dword ptr [rax], 'KPCK'
	mov	ecx, [insize]
	mov     dword ptr [rax+4], ecx
; 8. Determine and set lzma_dict_size.
	dec	ecx
	bsr	eax, ecx
	inc	eax
	cmp	eax, 28
	jb	short @f
	mov	eax, 28
@@:
	push	rax
	mov	edi, eax
	call	lzma_set_dict_size
	pop	rcx
	mov	edi, 1
	shl	edi, cl
	mov	[lzma_dictsize], edi
; 9. Allocate lzma_workmem.
	imul	edi, 19
	shr	edi, 1
	add	edi, 509000h
	call	malloc
	test	rax, rax
	jz	nomem
	mov	[workmem], rax
; 10. Say another 'hi'.
	push	compressing_len
	pop	rdx
	mov	rsi, offset compressing_str
	call	write_string
; 11. Do work.
	mov	rax, [outfile2]
	mov	[outfile], rax
	xchg	rax, rdi
	mov	rsi, [outfile1]
	movsd
	movsd
	call	pack_lzma
	mov	[outsize], eax
	mov	rax, [outfile]
	mov	[outfilebest], rax
	mov	[method], use_lzma
	call	preprocess_calltrick
	test	eax, eax
	jz	short noct1
	call	set_outfile
	call	pack_lzma
	add     eax, 5
	cmp	eax, [outsize]
	jae	short @f
	mov	[outsize], eax
	mov	rax, [outfile]
	mov	[outfilebest], rax
	mov	[method], use_lzma or use_calltrick1
@@:
noct1:
	call	set_outfile
	push	qword ptr [ctn]
	push	qword ptr [cti]
	call	preprocess_calltrick2
	test	eax, eax
	jz	noct2
	call	set_outfile
	call	pack_lzma
	add     eax, 5
	cmp	eax, [outsize]
	jae	short @f
	mov	[outsize], eax
	mov	rax, [outfile]
	mov	[outfilebest], rax
	mov	[method], use_lzma or use_calltrick2
	pop	rcx
	pop	rcx
	push	qword ptr [ctn]
	push	qword ptr [cti]
@@:
noct2:
	pop	rax
	mov	[cti], al
	pop	rax
	mov	[ctn], eax
	add     [outsize], 12
	mov     eax, [outsize]
	cmp     eax, [insize]
	jb      short packed_ok
	push	too_big_len
	pop	rdx
	mov	rsi, offset too_big_str
	jmp	write_exit
packed_ok:
; 12. Main work is done. Free lzma_workmem.
	mov	rdi, [workmem]
	call	free
; 13. Set header
        movzx   eax, [method]
	mov	rdi, [outfilebest]
	mov     [rdi+8], eax
	test    al, use_calltrick1 or use_calltrick2
	jz      short @f
	mov     ecx, [outsize]
	add     rcx, rdi
	mov     eax, [ctn]
	mov     [rcx-5], eax
	mov     al, [cti]
	mov     [rcx-1], al
@@:
	mov     eax, [outsize]
	mov	ecx, 100
	mul	ecx
	div	[insize]
	mov	cl, 10
	div	cl
	add	ax, '00'
	mov	[ratio], ax
	push	done_len
	pop	rdx
	cmp     [bNoLogo], 0
	jz      @f
	sub     dl, 2
@@:
	mov	rsi, offset done_str
	call	write_string
; 14. Save the output file.
; 14a. Do system call for open.
	mov	rdi, [outfilename]
	mov	rsi, create_mode
	call	fopen
; 14b. Test for success; if yes, goto 14d.
	test	rax, rax
	jnz	short @f
; 14c. Say error and exit.
outerr:
	push	outfileerr_len
	pop	rdx
	mov	rsi, offset outfileerr_str
	jmp	write_exit
; 14d. Do system call for write.
@@:
	mov	r12, rax
	mov	rdi, [outfilebest]
	mov	esi, [outsize]
	push	1
	pop	rdx
	mov	rcx, r12
	call	fwrite
	test	eax, eax
	jz	short outerr
; 14e. Close output file.
	mov	rdi, r12
	call	fclose
; 14f. Set output file time from the input file.
; Do two system calls, one for birth time, one for modification time.
	mov	rdi, [outfilename]
	mov	rsi, timeval
	mov	rax, [r13+st_atime_offset]
	mov	[rsi], rax
	mov	rax, [r13+st_atime_offset+8]
	mov	[rsi+8], rax
if defined st_birthtime_offset
	mov	rax, [r13+st_birthtime_offset]
	mov	[rsi+16], rax
	mov	rax, [r13+st_birthtime_offset+8]
	mov	[rsi+24], rax
	call	utimes
	mov	rdi, [outfilename]
	mov	rsi, timeval
end if
	mov	rax, [r13+st_mtime_offset]
	mov	[rsi+16], rax
	mov	rax, [r13+st_mtime_offset+8]
	mov	[rsi+24], rax
	call	utimes
; 15. Exit.
	xor	edi, edi
	call	exit

; Scan command line, skipping possible options, and return first non-option
; ecx is number of arguments left, rdi points to first new argument (updated by func)
; After the call: ZF set if no arguments left, otherwise rax points to the arg.
get_file_name:
; 1. Test whether there are still arguments. If no, goto 5; note ZF is set.
	dec	ecx
	jz	@@end
; 2. Get the new arg, advance rdi (ecx was decreased in step 1).
	mov	rax, [rdi]
	add	rdi, 8
; 3. Test for --nologo option. If no, goto 5; note ZF is cleared.
	cmp	dword [rax], '--no'
	jnz	@@end
	cmp	dword [rax+4], 'logo'
	jnz	@@end
; 4. Remember that --nologo was given and continue from the beginning.
	mov	[bNoLogo], 1
	jmp	get_file_name
; 5. No arguments (ZF set) or normal argument (ZF cleared); return.
@@end:
	ret

set_outfile:
	mov	rax, [outfilebest]
	xor	rax, [outfile1]
	xor	rax, [outfile2]
	mov	[outfile], rax
	ret

pack_calltrick_fail:
	xor	eax, eax
	xor	ebx, ebx
	mov	[ctn], eax
	ret
preprocess_calltrick:
; input preprocessing
	push	rax
	mov	edi, [insize]
	add	edi, edi
	call	malloc
	pop	rcx
	test	rax, rax
	jz	pack_calltrick_fail
	push	rax
	xor	eax, eax
	mov	rdi, offset ct1
	mov	ecx, 256/4
	push	rdi
	rep	stosd
	pop	rdi
	mov	ecx, [insize]
	mov	rsi, [infile]
	xchg	eax, edx
	pop	rax
	xchg	rax, rbx
	push	rbx
input_pre:
	lodsb
	sub	al, 0E8h
	cmp	al, 1
	ja	short input_pre_cont
	cmp	ecx, 5
	jb	short input_pre_done
	lodsd
	add	eax, esi
	sub	eax, dword ptr [infile]
	cmp	eax, [insize]
	jae	short xxx
	cmp	eax, 1000000h
	jae	short xxx
	sub	ecx, 4
	bswap	eax
	mov	[rsi-4], eax
	inc	edx
	mov	[rbx], rsi
	add	rbx, 8
	jmp	short input_pre_cont
xxx:	sub	rsi, 4
	movzx	eax, byte ptr [rsi]
	mov	byte ptr [rax+rdi], 1
input_pre_cont:
	loop	input_pre
input_pre_done:
	mov	[ctn], edx
	pop	rdx
	xor	eax, eax
	mov	ecx, 256
	repnz	scasb
	jnz	pack_calltrick_fail
	not	cl
	mov	[cti], cl
@@:
	cmp	rbx, rdx
	jz	@f
	sub	rbx, 8
	mov	rax, [rbx]
	mov	[rax-4], cl
	jmp	@b
@@:
	push	rax
	mov	rdi, rbx
	call	free
	pop	rax
	ret

pack_lzma:
	push	rcx
	mov	rdi, [infile]
	mov	rsi, [outfile]
	add	rsi, 11
	mov	edx, [insize]
	mov	rcx, [workmem]
	call	lzma_compress
	pop	rcx
	mov	rcx, [outfile]
	mov     edx, [rcx+12]
	bswap	edx
	mov     [rcx+12], edx
	dec     eax
	ret

preprocess_calltrick2:
; restore input
	mov	rsi, [infile]
	mov	ecx, [ctn]
	jecxz	pc2l2
pc2l1:
	lodsb
	sub	al, 0E8h
	cmp	al, 1
	ja	short pc2l1
	mov	al, [cti]
	cmp	[rsi], al
	jnz	short pc2l1
	lodsd
	mov	al, 0
	bswap	eax
	sub	eax, esi
	add	eax, dword ptr [infile]
	mov	[rsi-4], eax
	loop	pc2l1
pc2l2:
; input preprocessing
	push	rax
	mov	edi, [insize]
	add	edi, edi
	call	malloc
	pop	rcx
	test	rax, rax
	jz	pack_calltrick_fail
	mov	rdi, offset ct1
	xchg	rax, rbx
	xor	eax, eax
	push	rdi
	mov	ecx, 256/4
	rep	stosd
	pop	rdi
	mov	ecx, [insize]
	mov	rsi, [infile]
	xchg	eax, edx
	push	rbx
input_pre2:
	lodsb
@@:
	cmp	al, 0Fh
	jnz	short ip1
	dec	ecx
	jz	short input_pre_done2
	lodsb
	cmp	al, 80h
	jb	short @b
	cmp	al, 90h
	jb	short @f
ip1:
	sub	al, 0E8h
	cmp	al, 1
	ja	short input_pre_cont2
@@:
	cmp	ecx, 5
	jb	short input_pre_done2
	lodsd
	add	eax, esi
	sub	eax, dword ptr [infile]
	cmp	eax, [insize]
	jae	short xxx2
	cmp	eax, 1000000h
	jae	short xxx2
	sub	ecx, 4
	bswap	eax
	mov	[rsi-4], eax
	inc	edx
	mov	[rbx], rsi
	add	rbx, 8
	jmp	short input_pre_cont2
xxx2:	sub	rsi, 4
	movzx	eax, byte ptr [rsi]
	mov	byte ptr [rax+rdi], 1
input_pre_cont2:
	loop	input_pre2
input_pre_done2:
	mov	[ctn], edx
	pop	rdx
	xor	eax, eax
	mov	ecx, 256
	repnz	scasb
	jnz	pack_calltrick_fail
	not	cl
	mov	[cti], cl
@@:
	cmp	rbx, rdx
	jz	@f
	sub	rbx, 8
	mov	rax, [rbx]
	mov	[rax-4], cl
	jmp	@b
@@:
	push	rax
	mov	rdi, rbx
	call	free
	pop	rax
	ret

extrn exit
extrn fopen
extrn fread
extrn fwrite
extrn fclose
extrn fseek
extrn ftell
extrn malloc
extrn free
extrn write
extrn utimes
extrn stat

open_mode	db	"rb",0
create_mode	db	"wb",0