510 lines
15 KiB
PHP
510 lines
15 KiB
PHP
; Copyright (c) 2008-2009, diamond
|
|
; All rights reserved.
|
|
;
|
|
; Redistribution and use in source and binary forms, with or without
|
|
; modification, are permitted provided that the following conditions are met:
|
|
; * Redistributions of source code must retain the above copyright
|
|
; notice, this list of conditions and the following disclaimer.
|
|
; * Redistributions in binary form must reproduce the above copyright
|
|
; notice, this list of conditions and the following disclaimer in the
|
|
; documentation and/or other materials provided with the distribution.
|
|
; * Neither the name of the <organization> nor the
|
|
; names of its contributors may be used to endorse or promote products
|
|
; derived from this software without specific prior written permission.
|
|
;
|
|
; THIS SOFTWARE IS PROVIDED BY Alexey Teplov aka <Lrz> ''AS IS'' AND ANY
|
|
; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
; DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
|
|
; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
;*****************************************************************************
|
|
|
|
; in: ss:bp = 0:dat
|
|
; in: es:bx = address to load file
|
|
; in: ds:si -> ASCIIZ name
|
|
; in: cx = limit in sectors
|
|
; out: bx = status: bx=0 - ok, bx=1 - file is too big, only part of file has been loaded, bx=2 - file not found
|
|
; out: dx:ax = file size (0xFFFFFFFF if file not found)
|
|
load_file_fat:
|
|
mov eax, [bp + root_clus - dat]
|
|
mov [bp + cur_obj - dat], root_string
|
|
push es
|
|
push bx
|
|
push cx
|
|
.parse_dir_loop:
|
|
; convert name to FAT name
|
|
push [bp + cur_obj - dat]
|
|
push ax
|
|
mov [bp + cur_obj - dat], si
|
|
push ss
|
|
pop es
|
|
; convert ASCIIZ filename to FAT name
|
|
mov di, fat_filename
|
|
push di
|
|
mov cx, 8+3
|
|
mov al, ' '
|
|
rep stosb
|
|
pop di
|
|
mov cl, 8 ; 8 symbols per name
|
|
mov bl, 1
|
|
.nameloop:
|
|
lodsb
|
|
test al, al
|
|
jz .namedone
|
|
cmp al, '/'
|
|
jz .namedone
|
|
cmp al, '.'
|
|
jz .namedot
|
|
dec cx
|
|
js .badname
|
|
cmp al, 'a'
|
|
jb @f
|
|
cmp al, 'z'
|
|
ja @f
|
|
sub al, 'a'-'A'
|
|
@@:
|
|
stosb
|
|
jmp .nameloop
|
|
.namedot:
|
|
inc bx
|
|
jp .badname
|
|
add di, cx
|
|
mov cl, 3
|
|
jmp .nameloop
|
|
.badname:
|
|
mov si, badname_msg
|
|
jmp find_error_si
|
|
.namedone:
|
|
; scan directory
|
|
pop ax ; eax = cluster of directory
|
|
; high word of eax is preserved by operations above
|
|
push ds
|
|
push si
|
|
; read a folder sector-by-sector and scan
|
|
; first, try to use the cache
|
|
push ss
|
|
pop ds
|
|
mov bx, -2
|
|
mov cx, [bp + rootcache_size - dat]
|
|
cmp [bp + root_clus - dat], eax
|
|
jz .lookcache_root
|
|
mov di, foldcache_mark
|
|
xor bx, bx
|
|
mov cx, [bp + cachelimit - dat]
|
|
@@:
|
|
lea si, [di+bx]
|
|
mov edx, dword [foldcache_clus+si-foldcache_mark+bx]
|
|
cmp edx, eax
|
|
jz .cacheok
|
|
test edx, edx
|
|
jz .cacheadd ; the cache has place for new entry
|
|
inc bx
|
|
inc bx
|
|
dec cx
|
|
js @b
|
|
; the folder is not present in the cache, so add it
|
|
; the cache is full; find the oldest entry and replace it with the new one
|
|
mov bx, -2
|
|
mov dx, [bp + cachelimit - dat]
|
|
@@:
|
|
inc bx
|
|
inc bx
|
|
cmp word [di+bx], dx ; marks have values 0 through [cachelimit]
|
|
jnz @b
|
|
.cacheadd:
|
|
or word [di+bx], 0xFFFF ; very big value, it will be changed soon
|
|
and [foldcache_size+di-foldcache_mark+bx], 0 ; no folder items yet
|
|
lea si, [di+bx]
|
|
mov dword [foldcache_clus+si-foldcache_mark+bx], eax
|
|
.cacheok:
|
|
; update cache marks
|
|
mov dx, [di+bx]
|
|
mov cx, [foldcache_size+di-foldcache_mark+bx]
|
|
mov di, [bp + cachelimit - dat]
|
|
add di, di
|
|
.cacheupdate:
|
|
cmp [foldcache_mark+di], dx
|
|
adc [foldcache_mark+di], 0
|
|
dec di
|
|
dec di
|
|
jns .cacheupdate
|
|
and [foldcache_mark+bx], 0
|
|
; done, bx contains (position in cache)*2
|
|
.lookcache_root:
|
|
; bx = (position in cache)*2 for non-root folders; bx = -2 for root folder
|
|
;mov dx, bx
|
|
;shl dx, 8
|
|
;add dx, 0x9200
|
|
lea dx, [bx + 0x92]
|
|
xchg dl, dh
|
|
mov ds, dx
|
|
mov si, fat_filename ; ss:si -> filename in FAT style
|
|
call fat_scan_for_filename
|
|
jz .lookup_done
|
|
; cache miss, read folder data from disk
|
|
; we are reading parent directory, it can result in disk read errors; restore [cur_obj]
|
|
mov di, sp
|
|
mov bx, [bp + cur_obj - dat]
|
|
xchg bx, [ss:di+4]
|
|
mov [bp + cur_obj - dat], bx
|
|
mov bx, cx
|
|
add bx, 0xF
|
|
shr bx, 4
|
|
shl cx, 5
|
|
mov di, cx ; es:di -> free space in cache entry
|
|
; external loop: scan clusters
|
|
.folder_next_cluster:
|
|
; internal loop: scan sectors in cluster
|
|
movzx ecx, byte [ss:0x320D] ; BPB_SecPerClus
|
|
push eax
|
|
; FAT12/16 root - special handling
|
|
test eax, eax
|
|
jnz .folder_notroot
|
|
mov cx, [ss:0x3211] ; BPB_RootEntCnt
|
|
mov dx, cx
|
|
add cx, 0xF
|
|
rcr cx, 1
|
|
shr cx, 3
|
|
mov eax, [bp + root_start - dat]
|
|
jmp .folder_next_sector
|
|
.folder_notroot:
|
|
mul ecx
|
|
add eax, [bp + data_start - dat]
|
|
.folder_next_sector:
|
|
sub dx, 0x10
|
|
; skip first bx sectors
|
|
dec bx
|
|
jns .folder_skip_sector
|
|
push cx
|
|
push es di
|
|
push 0x8000
|
|
pop es
|
|
xor bx, bx
|
|
mov cx, 1
|
|
push es
|
|
call read
|
|
jc ..found_disk_error
|
|
; copy data to the cache...
|
|
pop ds
|
|
pop di es
|
|
cmp di, 0x2000 ; ...if there is free space, of course
|
|
jae @f
|
|
pusha
|
|
mov cx, 0x100
|
|
xor si, si
|
|
rep movsw
|
|
mov di, es
|
|
shr di, 8
|
|
cmp di, 0x90
|
|
jz .update_rootcache_size
|
|
add [ss:foldcache_size+di-0x92], 0x10 ; 0x10 new entries in the cache
|
|
jmp .updated_cachesize
|
|
.update_rootcache_size:
|
|
mov cl, 0x10
|
|
cmp cx, dx
|
|
jb @f
|
|
mov cx, dx
|
|
@@:
|
|
add [bp + rootcache_size - dat], cx
|
|
.updated_cachesize:
|
|
popa
|
|
@@:
|
|
push es
|
|
mov cl, 0x10 ; ch=0 at this point
|
|
cmp cx, dx
|
|
jb @f
|
|
mov cx, dx
|
|
@@:
|
|
call fat_scan_for_filename
|
|
pop es
|
|
pop cx
|
|
jz .lookup_done_pop
|
|
.folder_skip_sector:
|
|
inc eax
|
|
loop .folder_next_sector
|
|
pop eax ; eax = current cluster
|
|
test eax, eax
|
|
jz @f
|
|
call [bp + get_next_cluster_ptr - dat]
|
|
jc .folder_next_cluster
|
|
@@:
|
|
stc
|
|
push eax
|
|
.lookup_done_pop:
|
|
pop eax
|
|
.lookup_done:
|
|
pop si
|
|
; CF=1 <=> failed
|
|
jnc .found
|
|
pop ds
|
|
pop [bp + cur_obj - dat]
|
|
mov si, error_not_found
|
|
jmp find_error_si
|
|
.found:
|
|
mov eax, [di+20-2]
|
|
mov edx, [di+28]
|
|
mov ax, [di+26] ; get cluster
|
|
test byte [di+11], 10h ; directory?
|
|
pop ds
|
|
pop [bp + cur_obj - dat] ; forget old [cur_obj]
|
|
jz .regular_file
|
|
cmp byte [si-1], 0
|
|
jnz .parse_dir_loop
|
|
..directory_error:
|
|
mov si, directory_string
|
|
jmp find_error_si
|
|
.regular_file:
|
|
cmp byte [si-1], 0
|
|
jz @f
|
|
..notdir_error:
|
|
mov si, notdir_string
|
|
jmp find_error_si
|
|
@@:
|
|
; ok, we have found a regular file and the caller requested it
|
|
; parse FAT chunk
|
|
push ss
|
|
pop es
|
|
push ss
|
|
pop ds
|
|
mov di, 0x4005
|
|
mov byte [di-5], 1 ; non-resident attribute
|
|
mov dword [di-4], 1
|
|
stosd
|
|
pop cx
|
|
push cx
|
|
.parsefat:
|
|
call [bp + get_next_cluster_ptr - dat]
|
|
jnc .done
|
|
mov esi, [di-8]
|
|
add esi, [di-4]
|
|
cmp eax, esi
|
|
jz .contc
|
|
mov dword [di], 1
|
|
scasd
|
|
stosd
|
|
jmp @f
|
|
.contc:
|
|
inc dword [di-8]
|
|
@@:
|
|
sub cl, [0x320D]
|
|
sbb ch, 0
|
|
ja .parsefat
|
|
.done:
|
|
xor eax, eax
|
|
stosd
|
|
mov si, 0x4000
|
|
load_file_common_end:
|
|
xor ecx, ecx
|
|
pop cx
|
|
pop bx
|
|
pop es
|
|
mov [bp + filesize - dat], edx
|
|
mov [bp + sectors_read - dat], ecx
|
|
add edx, 0x1FF
|
|
shr edx, 9
|
|
mov [bp + filesize_sectors - dat], edx
|
|
cmp edx, ecx
|
|
seta al
|
|
mov ah, 0
|
|
push ax
|
|
call read_file_chunk
|
|
continue_load_common_end:
|
|
mov [bp + cur_chunk_ptr - dat], si
|
|
pop bx
|
|
mov ax, word [bp + filesize - dat]
|
|
mov dx, word [bp + filesize+2 - dat]
|
|
jnc @f
|
|
mov bl, 3 ; read error
|
|
@@:
|
|
ret
|
|
|
|
continue_load_file:
|
|
; es:bx -> buffer for output, ecx = cx = number of sectors
|
|
mov si, [bp + cur_chunk_ptr - dat]
|
|
push ecx
|
|
add ecx, [bp + sectors_read - dat]
|
|
mov [bp + sectors_read - dat], ecx
|
|
cmp [bp + filesize_sectors - dat], ecx
|
|
pop ecx
|
|
seta al
|
|
mov ah, 0
|
|
push ax
|
|
push continue_load_common_end
|
|
push ss
|
|
pop ds
|
|
cmp [bp + cur_chunk_resident - dat], ah
|
|
jnz .nonresident
|
|
.resident:
|
|
mov ax, word [bp + num_sectors - dat]
|
|
jmp read_file_chunk.resident.continue
|
|
.nonresident:
|
|
mov eax, [bp + cur_cluster - dat]
|
|
mov edx, [bp + num_sectors - dat]
|
|
add eax, [bp + cur_delta - dat]
|
|
jmp read_file_chunk.nonresident.continue
|
|
|
|
fat_scan_for_filename:
|
|
; in: ss:si -> 11-bytes FAT name
|
|
; in: ds:0 -> part of directory data
|
|
; in: cx = number of entries
|
|
; out: if found: CF=0, ZF=1, es:di -> directory entry
|
|
; out: if not found, but continue required: CF=1 and ZF=0
|
|
; out: if not found and zero item reached: CF=1 and ZF=1
|
|
push ds
|
|
pop es
|
|
xor di, di
|
|
push cx
|
|
jcxz .noent
|
|
.loop:
|
|
cmp byte [di], 0
|
|
jz .notfound
|
|
test byte [di+11], 8 ; volume label?
|
|
jnz .cont ; ignore volume labels
|
|
pusha
|
|
mov cx, 11
|
|
repz cmps byte [ss:si], byte [es:di]
|
|
popa
|
|
jz .done
|
|
.cont:
|
|
add di, 0x20
|
|
loop .loop
|
|
.noent:
|
|
inc cx ; clear ZF flag
|
|
.notfound:
|
|
stc
|
|
.done:
|
|
pop cx
|
|
ret
|
|
|
|
fat12_get_next_cluster:
|
|
; in: ax = cluster (high word of eax is zero)
|
|
; out: if there is next cluster: CF=1, ax = next cluster
|
|
; out: if there is no next cluster: CF=0
|
|
push si
|
|
push ds
|
|
push 0x6000
|
|
pop ds
|
|
mov si, ax
|
|
shr si, 1
|
|
add si, ax
|
|
test al, 1
|
|
lodsw
|
|
jz @f
|
|
shr ax, 4
|
|
@@:
|
|
and ax, 0xFFF
|
|
cmp ax, 0xFF7
|
|
pop ds si
|
|
ret
|
|
|
|
fat16_get_next_cluster:
|
|
; in: ax = cluster (high word of eax is zero)
|
|
; out: if there is next cluster: CF=1, ax = next cluster
|
|
; out: if there is no next cluster: CF=0
|
|
; each sector contains 200h bytes = 100h FAT entries
|
|
; so ah = # of sector, al = offset in sector
|
|
push si
|
|
mov si, ax
|
|
shr si, 8
|
|
; calculate segment for this sector of FAT table
|
|
; base for FAT table is 6000:0000, so the sector #si has to be loaded to (60000 + 200*si)
|
|
; segment = 6000 + 20*si, offset = 0
|
|
push es
|
|
push si
|
|
shl si, 5
|
|
add si, 0x6000
|
|
mov es, si
|
|
pop si
|
|
cmp byte [ss:0x3400+si], 0 ; sector already loaded?
|
|
jnz .noread
|
|
; load corresponding sector, try all FATs if disk read error detected
|
|
pusha
|
|
movzx di, byte [ss:0x3210] ; BPB_NumFATs
|
|
xor bx, bx
|
|
mov ax, [ss:0x320E] ; BPB_RsvdSecCnt
|
|
xor dx, dx
|
|
add ax, si
|
|
adc dx, bx
|
|
@@:
|
|
push es
|
|
push dx ax
|
|
pop eax
|
|
mov cx, 1 ; read 1 sector
|
|
call read
|
|
pop es
|
|
jnc @f
|
|
add ax, [ss:0x3216] ; BPB_FATSz16
|
|
adc dx, bx
|
|
dec di
|
|
jnz @b
|
|
..found_disk_error:
|
|
mov si, disk_error_msg
|
|
jmp find_error_si
|
|
@@:
|
|
popa
|
|
.noread:
|
|
mov si, ax
|
|
and si, 0xFF
|
|
add si, si
|
|
mov ax, [es:si]
|
|
pop es
|
|
cmp ax, 0xFFF7
|
|
pop si
|
|
ret
|
|
|
|
fat32_get_next_cluster:
|
|
; in: eax = cluster
|
|
; out: if there is next cluster: CF=1, eax = next cluster
|
|
; out: if there is no next cluster: CF=0
|
|
push di
|
|
push ax
|
|
shr eax, 7
|
|
; eax = FAT sector number; look in cache
|
|
push si
|
|
mov si, cache1head
|
|
call cache_lookup
|
|
pop si
|
|
jnc .noread
|
|
; read FAT, try all FATs if disk read error detected
|
|
push es
|
|
pushad
|
|
movzx edx, word [ss:0x320E] ; BPB_RsvdSecCnt
|
|
add eax, edx
|
|
movzx si, byte [ss:0x3210] ; BPB_NumFATs
|
|
@@:
|
|
lea cx, [di - 0x3400 + (0x6000 shr (9-3))]
|
|
shl cx, 9-3
|
|
mov es, cx
|
|
xor bx, bx
|
|
mov cx, 1
|
|
call read
|
|
jnc @f
|
|
add eax, [ss:0x3224] ; BPB_FATSz32
|
|
dec si
|
|
jnz @b
|
|
jmp ..found_disk_error
|
|
@@:
|
|
popad
|
|
pop es
|
|
.noread:
|
|
; get requested item
|
|
lea ax, [di - 0x3400 + (0x6000 shr (9-3))]
|
|
pop di
|
|
and di, 0x7F
|
|
shl di, 2
|
|
shl ax, 9-3
|
|
push ds
|
|
mov ds, ax
|
|
and byte [di+3], 0x0F
|
|
mov eax, [di]
|
|
pop ds
|
|
pop di
|
|
;and eax, 0x0FFFFFFF
|
|
cmp eax, 0x0FFFFFF7
|
|
ret
|