kolibrios/programs/hd_load/9x2klbr/mtldr_code/ntfs.inc

restore_usa:
; Update Sequence Array restore
	mov	bx, [di+4]
	mov	cx, [di+6]
	inc	bx
	add	bx, di
	inc	bx
	add	di, 1feh
	dec	cx
@@:
	mov	ax, [bx]
	stosw
	inc	bx
	inc	bx
	add	di, 1feh
	loop	@b
	ret

find_attr:
; in: di->file record, ax=attribute
; out: di->attribute or di=0 if not found
	add	di, [di+14h]
.1:
; attributes codes are formally dwords, but all they fit in word
	cmp	word [di], -1
	jz	.notfound
	cmp	word [di], ax
	jnz	.continue
; for $DATA attribute, scan only unnamed
	cmp	ax, 80h
	jnz	.found
	cmp	byte [di+9], 0
	jz	.found
.continue:
	add	di, [di+4]
	jmp	.1
.notfound:
	xor	di, di
.found:
	ret

process_mcb_nonres:
; in: si->attribute, es:di->buffer
; out: di->buffer end
	add	si, [si+20h]
	xor	ebx, ebx
.loop:
	lodsb
	test	al, al
	jz	.done
	push	invalid_read_request_string
	movzx	cx, al
	shr	cx, 4
	jz	find_error_sp
	xchg	ax, dx
	and	dx, 0Fh
	jz	find_error_sp
	add	si, cx
	add	si, dx
	pop	ax
	push	si
	dec	si
	movsx	eax, byte [si]
	dec	cx
	jz	.l1e
.l1:
	dec	si
	shl	eax, 8
	mov	al, [si]
	loop	.l1
.l1e:
	xchg	ebp, eax
	dec	si
	movsx	eax, byte [si]
	mov	cx, dx
	dec	cx
	jz	.l2e
.l2:
	dec	si
	shl	eax, 8
	mov	al, byte [si]
	loop	.l2
.l2e:
	pop	si
	add	ebx, ebp
; eax=length, ebx=disk block
	stosd
	mov	eax, ebx
	stosd
	jmp	.loop
.done:
	xor	eax, eax
	stosd
	ret

load_attr:
; in: ax=attribute, es:bx->buffer, di->base record
; out: bx->buffer end; CF set if not found
	push	di
	push	ax
	mov	byte [es:bx], 1
	inc	bx
	push	bx
	mov	[ofs], bx
; scan for attrubute
	add	di, [di+14h]
@@:
	call	find_attr.1
	test	di, di
	jz	.notfound1
	cmp	byte [di+8], 0
	jnz	.nonresident
; resident attribute
	mov	si, di
	pop	di
	dec	di
	mov	al, 0
	stosb
	mov	ax, [si+10h]
	stosw
	xchg	ax, cx
	add	si, [si+14h]
	rep	movsb
	mov	bx, di
	pop	ax
	pop	di
	ret
.nonresident:
; nonresident attribute
	cmp	dword [di+10h], 0
	jnz	@b
; read start of data
	mov	si, di
	pop	di
	call	process_mcb_nonres
	push	di
.notfound1:
; $ATTRIBUTE_LIST is always in base file record
	cmp	word [esp+2], 20h
	jz	.nofragmented
; scan for $ATTRIBUTE_LIST = 20h
	mov	di, [esp+4]
	mov	ax, 20h
	call	find_attr
	test	di, di
	jz	.nofragmented
; load $ATTRIBUTE_LIST itself
	push	es
	mov	bx, 0C000h
	mov	di, [esp+6]
	push	bx
	push	[ofs]
	push	ds
	pop	es
	call	load_attr
	pop	[ofs]
	pop	si
	mov	bx, 8000h
	push	bx
	push	si
	call	read_attr_full
	pop	si
	pop	bx
	add	dx, bx
	mov	ax, [esp+4]
	pop	es
.1:
	cmp	[bx], ax
	jnz	.continue1
; only unnamed $DATA attributes!
	cmp	ax, 80h
	jnz	@f
	cmp	byte [bx+6], 0
	jnz	.continue1
@@:
	cmp	dword [bx+10h], 0
	jz	.continue1
	cmp	dword [bx+8], 0
	jnz	@f
	push	ax
	mov	ax, [esp+2]
	cmp	ax, [ofs]
	pop	ax
	jnz	.continue1
@@:
	pushad
	mov	eax, [bx+10h]
	mov	bx, dx
	push	[ofs]
	push	es
	push	ds
	pop	es
	call	read_file_record
	pop	es
	pop	[ofs]
	popad
	pushad
	mov	di, dx
	add	di, [di+14h]
.2:
	call	find_attr.1
	mov	eax, [bx+8]
	cmp	eax, [di+10h]
	jnz	.2
	mov	si, di
	mov	di, [esp+20h]
	sub	di, 4
	call	process_mcb_nonres
	mov	[esp+20h], di
	popad
.continue1:
	add	bx, [bx+4]
	cmp	bx, dx
	jb	.1
.nofragmented:
	pop	bx
	pop	ax
	pop	di
	cmp	bx, [ofs]
	jnz	@f
	dec	bx
	stc
@@:
	ret

read_attr_full:
; in: si->decoded attribute data, bx->buffer
; out: edx=length in bytes
	lodsb
	cmp	al, 0
	jnz	.nonresident
; resident
	lodsw
	movzx	edx, ax
	xchg	ax, cx
	mov	di, bx
	rep	movsb
	ret
.nonresident:
; nonresident :-)
	xor	edx, edx
.loop:
	lodsd
	xchg	ecx, eax
	jecxz	.loopend
	lodsd
	xchg	edi, eax
; read ecx clusters from cluster edi to es:bx
.intloop:
	push	ecx
; read 1 cluster from physical cluster edi to es:bx
	mov	ecx, [cluster_size]
	mov	eax, edi
	mul	ecx
	push	bx
	call	relative_read
	pop	bx
	pop	ecx
	inc	edi
	mov	eax, [cluster_size]
	add	edx, eax
	shr	eax, 4
	mov	bp, es
	add	bp, ax
	mov	es, bp
	loop	.intloop
	jmp	.loop
.loopend:
	mov	es, cx
	ret

read_file_record:
; in: eax=index of record, bx=buffer
	mov	si, 700h
	mov	ecx, [frs_size]
	mul	ecx
	push	bx
	push	[cur_obj]
	mov	[cur_obj], mft_string
	call	read_attr
	pop	[cur_obj]
	pop	di
	call	restore_usa
	ret
read_attr:
; in: edx:eax=offset in bytes, ecx=size in bytes, bx=buffer, si=attribute
	push	invalid_read_request_string
	cmp	byte [si], 0
	jnz	.nonresident
	test	edx, edx
	jnz	find_error_sp
	cmp	eax, 10000h
	jae	find_error_sp
	cmp	ecx, 10000h
	jae	find_error_sp
	cmp	ax, [si+2]
	jae	find_error_sp
	cmp	cx, [si+2]
	ja	find_error_sp
	add	si, 3
	add	si, ax
	mov	di, bx
	rep	movsb
	pop	ax
	ret
.nonresident:
	mov	edi, [cluster_size]
	div	edi
	mov	[ofs], dx
	add	cx, dx
	push	eax
	xchg	eax, ecx
	xor	edx, edx
	dec	eax
	div	edi
	inc	eax
	xchg	eax, ecx
	pop	eax
	add	si, 1
	xor	edx, edx
	push	bx
; eax=offset in clusters, ecx=size in clusters
.scan:
	mov	ebx, [si]
	test	ebx, ebx
	jz	.notfound
	add	edx, ebx
	add	si, 8
	cmp	eax, edx
	jae	.scan
	mov	edi, [si-4]
; now edx=end of block, ebx=length of block, edi=start of block on disk
; eax=required offset, ecx=required length
	push	edx
	push	edi
	sub	edx, eax
	add	edi, ebx
	sub	edi, edx
	cmp	edx, ecx
	jb	@f
	mov	edx, ecx
@@:
; read (edx) clusters from (edi=disk offset in clusters) to ([esp+8])
	cmp	[ofs], 0
	jnz	.ofs_read
.cont:
	pushad
	movzx	ebx, byte [50Dh]
;       xchg    eax, edx
;       mul     ebx
	xchg	ax, dx
	mul	bx
	xchg	cx, ax
	xchg	eax, edi
	mul	ebx
	mov	bx, [esp+8+20h]
	call	relative_read
	mov	[esp+8+20h], bx
	popad
.cont2:
	add	eax, edx
	sub	ecx, edx
.cont3:
	pop	edi
	pop	edx
	jnz	.scan
	pop	bx
	pop	ax
	ret
.ofs_read:
	push	ecx
	movzx	ecx, byte [50Dh]	; bpb_sects_per_clust
	mov	eax, edi
	push	edx
	mul	ecx
	push	1000h
	pop	es
	xor	bx, bx
	call	relative_read
	mov	cx, bx
	push	si
	push	di
	mov	si, [ofs]
	mov	di, [esp+8+12]
	sub	cx, si
	push	ds
	push	es
	pop	ds
	pop	es
	rep	movsb
	mov	[esp+8+12], di
	push	es
	pop	ds
	pop	di
	pop	si
	pop	edx
	pop	ecx
	inc	edi
	mov	[ofs], 0
	inc	eax
	dec	ecx
	jz	.cont3
	dec	edx
	jnz	.cont
	jmp	.cont2
.notfound:
	mov	si, invalid_read_request_string
	jmp	find_error_si

ntfs_parse_dir:
; in: eax=directory iRecord, [word sp+2]=filename
; out: si=$DATA attribute of file
	mov	bx, [free]
	mov	[dir], bx
	push	bx
	call	read_file_record
	mov	ax, word [frs_size]
	add	[free], ax
	pop	di
; find attributes $INDEX_ROOT, $INDEX_ALLOCATION, $BITMAP
	mov	ax, 90h 	; $INDEX_ROOT
	push	di
	mov	bx, [free]
	mov	[index_root], bx
	call	load_attr
	mov	si, noindex_string
	jc	find_error_si
	mov	[free], bx
	pop	di
	mov	ax, 0A0h	; $INDEX_ALLOCATION
	mov	bx, [free]
	mov	[index_alloc], bx
	call	load_attr
	jnc	@f
	mov	[index_alloc], 0
@@:
	mov	[free], bx
; search for entry
	mov	si, [index_root]
	mov	bx, [free]
	call	read_attr_full
	mov	ebp, [bx+8]	; subnode_size
	add	bx, 10h
.scan_record:
	add	bx, [bx]
.scan:
	test	byte [bx+0Ch], 2
	jnz	.not_found
	mov	si, [esp+2]
	movzx	cx, byte [bx+50h]	; namelen
	lea	di, [bx+52h]		; name
	xor	ax, ax
@@:
	lodsb
	cmp	al, 'a'
	jb	.notletter
	cmp	al, 'z'
	ja	.notletter
	or	byte [di], 20h
.notletter:
	scasw
	loopz	@b
	jb	.not_found
	ja	@f
	cmp	byte [esi], 0
	jz	.file_found
@@:
	add	bx, [bx+8]
	jmp	.scan
.not_found:
	test	byte [bx+0Ch], 1
	jz	file_not_found
	cmp	[index_alloc], 0
	jz	file_not_found
	add	bx, [bx+8]
	mov	eax, [bx-8]
	mul	[cluster_size]
	mov	si, [index_alloc]
	mov	ecx, ebp
	mov	bx, [free]
	call	read_attr
	mov	di, [free]
	call	restore_usa
	mov	bx, [free]
	add	bx, 18h
	jmp	.scan_record
.file_found:
	mov	si, [esp+2]
	mov	[cur_obj], si
	cmp	byte [esp+4], 0
	jz	.need_file
	mov	si, notdir_string
	test	byte [bx+48h+3], 10h
	jz	find_error_si
	mov	eax, [bx]
	mov	bx, [dir]
	mov	[free], bx
	ret	2
.need_file:
	mov	si, directory_string
	test	byte [bx+48h+3], 10h	; directory?
	jnz	find_error_si
; read entry
	mov	eax, [bx]
	mov	bx, [dir]
	mov	[free], bx
	mov	bx, 4000h
	push	bx
	call	read_file_record
	pop	di
	mov	ax, 80h
	push	2000h
	pop	es
	xor	bx, bx
	call	load_attr
	mov	si, nodata_string
	jz	find_error_si
	mov	[free], bx
	ret	2