520 lines
8.1 KiB
PHP
520 lines
8.1 KiB
PHP
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
|