WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-A/trunk/fs/fs_lfn.inc


;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3487 $
 
 
image_of_eax EQU esp+32
image_of_ebx EQU esp+20
 
; System function 70 - files with long names (LFN)
; diamond, 2006
 
iglobal
; in this table names must be in lowercase
rootdirs:
	db	2,'rd'
	dd	fs_OnRamdisk
	dd	fs_NextRamdisk
	db	7,'ramdisk'
	dd	fs_OnRamdisk
	dd	fs_NextRamdisk
 
 
 
 
 
 
	db	3,'hd0'
	dd	fs_OnHd0
	dd	fs_NextHd0
	db	3,'hd1'
	dd	fs_OnHd1
	dd	fs_NextHd1
	db	3,'hd2'
	dd	fs_OnHd2
	dd	fs_NextHd2
	db	3,'hd3'
	dd	fs_OnHd3
	dd	fs_NextHd3
	db	0
 
 
virtual_root_query:
	dd	fs_HasRamdisk
	db	'rd',0
	dd	fs_HasFloppy
	db	'fd',0
	dd	fs_HasHd0
	db	'hd0',0
	dd	fs_HasHd1
	db	'hd1',0
	dd	fs_HasHd2
	db	'hd2',0
	dd	fs_HasHd3
	db	'hd3',0
	dd	0
 
fs_additional_handlers:
        dd      biosdisk_handler, biosdisk_enum_root
; add new handlers here
        dd      0
 
endg
file_system_lfn:
; in: ebx->fileinfo block
; operation codes:
; 0 : read file
; 1 : read folder
; 2 : create/rewrite file
; 3 : write/append to file
; 4 : set end of file
; 5 : get file/directory attributes structure
; 6 : set file/directory attributes structure
; 7 : start application
; 8 : delete file
; 9 : create directory
 
; parse file name
	lea	esi, [ebx+20]
	lodsb
	test	al, al
	jnz	@f
	mov	esi, [esi]
	lodsb
@@:
	cmp	al, '/'
	jz	.notcurdir
	dec	esi
	mov	ebp, esi
	test	al, al
	jnz	@f
	xor	ebp, ebp
@@:
	mov	esi, [current_slot]
	mov	esi, [esi+APPDATA.cur_dir]
	jmp	.parse_normal
.notcurdir:
	cmp	byte [esi], 0
	jz	.rootdir
	call	process_replace_file_name
.parse_normal:
	cmp dword [ebx], 7
	jne @F
	mov edx, [ebx+4]
	mov ebx, [ebx+8]
	call fs_execute  ; esi+ebp, ebx, edx
	mov [image_of_eax], eax
	ret
@@:
	mov	edi, rootdirs-8
	xor	ecx, ecx
	push	esi
.scan1:
	pop	esi
	add	edi, ecx
	scasd
	scasd
	mov	cl, byte [edi]
	test	cl, cl
	jz	.notfound_try
	inc	edi
	push	esi
@@:
	lodsb
	or	al, 20h
	scasb
	loopz	@b
	jnz	.scan1
	lodsb
	cmp	al, '/'
	jz	.found1
	test	al, al
	jnz	.scan1
	pop	eax
; directory /xxx
.maindir:
	mov	esi, [edi+4]
.maindir_noesi:
	cmp	dword [ebx], 1
	jnz	.access_denied
	xor	eax, eax
	mov	ebp, [ebx+12]			;êîëè÷åñòâî áëîêîâ äëÿ ñ÷èòûâàíèÿ
	mov	edx, [ebx+16]			;êóäà çàïèñûâàòü ðóçåëüòàò
    ;    add     edx, std_application_base_address
	push	dword [ebx+4]	; first block
	mov	ebx, [ebx+8]	; flags
; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
	mov	edi, edx
	push    ecx
	mov	ecx, 32/4
	rep	stosd
	pop     ecx
	mov	byte [edx], 1	; version
.maindir_loop:
	call	esi
	jc	.maindir_done
	inc	dword [edx+8]
	dec	dword [esp]
	jns	.maindir_loop
	dec	ebp
	js	.maindir_loop
	inc	dword [edx+4]
	mov	dword [edi], 0x10	; attributes: folder
	mov	dword [edi+4], 1	; name type: UNICODE
	push	eax
	xor	eax, eax
	add	edi, 8
	push    ecx
	mov	ecx, 40/4-2
	rep	stosd
	pop     ecx
	pop	eax
	push	eax edx
; convert number in eax to decimal UNICODE string
	push	edi
	push    ecx
	push	-'0'
	mov	ecx, 10
@@:
	xor	edx, edx
	div	ecx
	push	edx
	test	eax, eax
	jnz	@b
@@:
	pop	eax
	add	al, '0'
	stosb
	test	bl, 1		; UNICODE name?
	jz	.ansi2
	mov	byte [edi], 0
	inc	edi
.ansi2:
	test	al, al
	jnz	@b
	mov	byte [edi-1], 0
	pop     ecx
	pop	edi
; UNICODE name length is 520 bytes, ANSI - 264
	add	edi, 520
	test	bl, 1
	jnz	@f
	sub	edi, 520-264
@@:
	pop	edx eax
	jmp	.maindir_loop
.maindir_done:
	pop	eax
	mov	ebx, [edx+4]
	xor	eax, eax
	dec	ebp
	js	@f
	mov	al, ERROR_END_OF_FILE
@@:
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
; directory /
.rootdir:
	cmp	dword [ebx], 1	; read folder?
	jz	.readroot
.access_denied:
	mov	dword [image_of_eax], 10      ; access denied
	ret
 
.readroot:
; virtual root folder - special handler
	mov	esi, virtual_root_query
	mov	ebp, [ebx+12]
	mov	edx, [ebx+16]
    ;    add     edx, std_application_base_address
	push	dword [ebx+4]	; first block
	mov	ebx, [ebx+8]	; flags
	xor	eax, eax
; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
	mov	edi, edx
	mov	ecx, 32/4
	rep	stosd
	mov	byte [edx], 1	; version
.readroot_loop:
	cmp	dword [esi], eax
	jz	.readroot_done_static
	call	dword [esi]
	add	esi, 4
	test	eax, eax
	jnz	@f
.readroot_next:
	or	ecx, -1
	xchg	esi, edi
	repnz	scasb
	xchg	esi, edi
	jmp	.readroot_loop
@@:
	xor	eax, eax
	inc	dword [edx+8]
	dec	dword [esp]
	jns	.readroot_next
	dec	ebp
	js	.readroot_next
	inc	dword [edx+4]
	mov	dword [edi], 0x10	; attributes: folder
	mov	dword [edi+4], ebx	; name type: UNICODE
	add	edi, 8
	mov	ecx, 40/4-2
	rep	stosd
	push	edi
@@:
	lodsb
	stosb
	test	bl, 1
	jz	.ansi
	mov	byte [edi], 0
	inc	edi
.ansi:
	test	eax, eax
	jnz	@b
	pop	edi
	add	edi, 520
	test	bl, 1
	jnz	.readroot_loop
	sub	edi, 520-264
	jmp	.readroot_loop
.readroot_done_static:
        mov     esi, fs_additional_handlers-8
        sub     esp, 16
.readroot_ah_loop:
        add     esi, 8
        cmp     dword [esi], 0
        jz      .readroot_done
        xor     eax, eax
.readroot_ah_loop2:
        push    edi
        lea     edi, [esp+4]
        call    dword [esi+4]
        pop     edi
        test    eax, eax
        jz      .readroot_ah_loop
        inc     dword [edx+8]
        dec     dword [esp+16]
        jns     .readroot_ah_loop2
        dec     ebp
        js      .readroot_ah_loop2
        push    eax
        xor     eax, eax
        inc     dword [edx+4]
        mov     dword [edi], 0x10       ; attributes: folder
        mov     dword [edi+4], ebx
        add     edi, 8
        mov     ecx, 40/4-2
        rep     stosd
        push    esi edi
        lea     esi, [esp+12]
@@:
        lodsb
        stosb
        test    bl, 1
        jz      .ansi3
        mov     byte [edi], 0
        inc     edi
.ansi3:
        test    al, al
        jnz     @b
        pop     edi esi eax
        add     edi, 520
        test    bl, 1
        jnz     .readroot_ah_loop2
        sub     edi, 520-264
        jmp     .readroot_ah_loop2
.readroot_done:
        add     esp, 16
	pop	eax
	mov	ebx, [edx+4]
	xor	eax, eax
	dec	ebp
	js	@f
	mov	al, ERROR_END_OF_FILE
@@:
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.notfound_try:
        mov     edi, fs_additional_handlers
@@:
        cmp     dword [edi], 0
        jz      .notfound
        call    dword [edi]
        scasd
        scasd
        jmp     @b
.notfound:
	mov	dword [image_of_eax], ERROR_FILE_NOT_FOUND
	and	dword [image_of_ebx], 0
	ret
 
.notfounda:
        cmp     edi, esp
        jnz     .notfound
        add     esp, 8
        jmp     .notfound
 
.found1:
	pop	eax
	cmp	byte [esi], 0
	jz	.maindir
.found2:
; read partition number
	xor	ecx, ecx
	xor	eax, eax
@@:
	lodsb
	cmp	al, '/'
	jz	.done1
	test	al, al
	jz	.done1
	sub	al, '0'
	cmp	al, 9
	ja	.notfounda
	lea	ecx, [ecx*5]
	lea	ecx, [ecx*2+eax]
	jmp	@b
.done1:
	jecxz	.notfounda
	test	al, al
	jnz	@f
	dec	esi
@@:
	cmp	byte [esi], 0
	jnz	@f
	test	ebp, ebp
	jz	@f
	mov	esi, ebp
	xor	ebp, ebp
@@:
; now [edi] contains handler address, ecx - partition number,
; esi points to ASCIIZ string - rest of name
	jmp	dword [edi]
 
; handlers for devices
; in: ecx = 0 => query virtual directory /xxx
; in: ecx = partition number
;     esi -> relative (for device) name
;     ebx -> fileinfo
;     ebp = 0 or pointer to rest of name from folder addressed by esi
; out: [image_of_eax]=image of eax, [image_of_ebx]=image of ebx
 
fs_OnRamdisk:
	cmp	ecx, 1
	jnz	file_system_lfn.notfound
	mov	eax, [ebx]
	cmp	eax, fs_NumRamdiskServices
	jae	.not_impl
	mov	ecx, [ebx+12]
	mov	edx, [ebx+16]
   ;     add     edx, std_application_base_address
	add	ebx, 4
	call	dword [fs_RamdiskServices + eax*4]
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	mov	dword [image_of_eax], 2       ; not implemented
	ret
 
fs_NotImplemented:
	mov	eax, 2
	ret
 
fs_RamdiskServices:
	dd	fs_RamdiskRead
	dd	fs_RamdiskReadFolder
	dd	fs_RamdiskRewrite
	dd	fs_RamdiskWrite
	dd	fs_RamdiskSetFileEnd
	dd	fs_RamdiskGetFileInfo
	dd	fs_RamdiskSetFileInfo
	dd	0
	dd	fs_RamdiskDelete
	dd	fs_RamdiskCreateFolder
fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fs_OnHd0:
	call	reserve_hd1
	mov	[hdbase], 0x1F0
	mov	[hdid], 0
	push	1
	jmp	fs_OnHd
fs_OnHd1:
	call	reserve_hd1
	mov	[hdbase], 0x1F0
	mov	[hdid], 0x10
	push	2
	jmp	fs_OnHd
fs_OnHd2:
	call	reserve_hd1
	mov	[hdbase], 0x170
	mov	[hdid], 0
	push	3
	jmp	fs_OnHd
fs_OnHd3:
	call	reserve_hd1
	mov	[hdbase], 0x170
	mov	[hdid], 0x10
	push	4
fs_OnHd:
	call	reserve_hd_channel
	pop	eax
	mov	[hdpos], eax
	cmp	ecx, 0x100
	jae	fs_OnHdAndBd.nf
	cmp	cl, [DRIVE_DATA+1+eax]
fs_OnHdAndBd:
	jbe	@f
.nf:
	call	free_hd_channel
	and	[hd1_status], 0
	mov	dword [image_of_eax], 5       ; not found
	ret
@@:
	mov	[known_part], ecx ;	mov	[fat32part], ecx
	push	ebx esi
	call	choice_necessity_partition_1
	pop	esi ebx
	mov	ecx, [ebx+12]
	mov	edx, [ebx+16]
    ;    add     edx, std_application_base_address
	mov	eax, [ebx]
	cmp	eax, fs_NumHdServices
	jae	.not_impl
	add	ebx, 4
	call	dword [fs_HdServices + eax*4]
	call	free_hd_channel
	and	[hd1_status], 0
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	call	free_hd_channel
	and	[hd1_status], 0
	mov	dword [image_of_eax], 2       ; not implemented
	ret
 
fs_HdServices:
	dd	fs_HdRead
	dd	fs_HdReadFolder
	dd	fs_HdRewrite
	dd	fs_HdWrite
	dd	fs_HdSetFileEnd
	dd	fs_HdGetFileInfo
	dd	fs_HdSetFileInfo
	dd	0
	dd	fs_HdDelete
	dd	fs_HdCreateFolder
fs_NumHdServices = ($ - fs_HdServices)/4
 
 
fs_HasRamdisk:
	mov	al, 1	; we always have ramdisk
	ret
 
fs_HasFloppy:
	cmp	byte [DRIVE_DATA], 0
	setnz	al
	ret
 
fs_HasHd0:
	mov	al, [DRIVE_DATA+1]
	and	al, 11000000b
	cmp	al, 01000000b
	setz	al
	ret
fs_HasHd1:
	mov	al, [DRIVE_DATA+1]
	and	al, 00110000b
	cmp	al, 00010000b
	setz	al
	ret
fs_HasHd2:
	mov	al, [DRIVE_DATA+1]
	and	al, 00001100b
	cmp	al, 00000100b
	setz	al
	ret
fs_HasHd3:
	mov	al, [DRIVE_DATA+1]
	and	al, 00000011b
	cmp	al, 00000001b
	setz	al
	ret
 
;*******************************************************
fs_HasCd0:
	mov	al, [DRIVE_DATA+1]
	and	al, 11000000b
	cmp	al, 10000000b
	setz	al
	ret
fs_HasCd1:
	mov	al, [DRIVE_DATA+1]
	and	al, 00110000b
	cmp	al, 00100000b
	setz	al
	ret
fs_HasCd2:
	mov	al, [DRIVE_DATA+1]
	and	al, 00001100b
	cmp	al, 00001000b
	setz	al
	ret
fs_HasCd3:
	mov	al, [DRIVE_DATA+1]
	and	al, 00000011b
	cmp	al, 00000010b
	setz	al
	ret
;*******************************************************
 
; fs_NextXXX functions:
; in: eax = partition number, from which start to scan
; out: CF=1 => no more partitions
;      CF=0 => eax=next partition number
 
fs_NextRamdisk:
; we always have /rd/1
	test	eax, eax
	stc
	jnz	@f
	mov	al, 1
	clc
@@:
	ret
 
fs_NextFloppy:
; we have /fd/1 iff (([DRIVE_DATA] and 0xF0) != 0) and /fd/2 iff (([DRIVE_DATA] and 0x0F) != 0)
	test	byte [DRIVE_DATA], 0xF0
	jz	.no1
	test	eax, eax
	jnz	.no1
	inc	eax
	ret	; CF cleared
.no1:
	test	byte [DRIVE_DATA], 0x0F
	jz	.no2
	cmp	al, 2
	jae	.no2
	mov	al, 2
	clc
	ret
.no2:
	stc
	ret
 
; on hdx, we have partitions from 1 to [0x40002+x]
fs_NextHd0:
	push	0
	jmp	fs_NextHd
fs_NextHd1:
	push	1
	jmp	fs_NextHd
fs_NextHd2:
	push	2
	jmp	fs_NextHd
fs_NextHd3:
	push	3
fs_NextHd:
	pop	ecx
	movzx	ecx, byte [DRIVE_DATA+2+ecx]
	cmp	eax, ecx
	jae	fs_NextFloppy.no2
	inc	eax
	clc
	ret
 
;*******************************************************
fs_NextCd:
; we always have /cdX/1
	test	eax, eax
	stc
	jnz	@f
	mov	al, 1
	clc
@@:
	ret
;*******************************************************
 
; Additional FS handlers.
; This handler gets the control each time when fn 70 is called
; with unknown item of root subdirectory.
; in: esi -> name
;     ebp = 0 or rest of name relative to esi
; out: if the handler processes path, he must not return in file_system_lfn,
;      but instead pop return address and return directly to the caller
;      otherwise simply return
 
; here we test for /bd/... - BIOS disks
biosdisk_handler:
        cmp     [NumBiosDisks], 0
        jz      .ret
        mov     al, [esi]
        or      al, 20h
        cmp     al, 'b'
        jnz     .ret
        mov     al, [esi+1]
        or      al, 20h
        cmp     al, 'd'
        jnz     .ret
        push    esi
        inc     esi
        inc     esi
        cmp     byte [esi], '0'
        jb      .ret2
        cmp     byte [esi], '9'
        ja      .ret2
        xor     edx, edx
@@:
        lodsb
        test    al, al
        jz      .ok
        cmp     al, '/'
        jz      .ok
        sub     al, '0'
        cmp     al, 9
        ja      .ret2
        lea     edx, [edx*5]
        lea     edx, [edx*2+eax]
        jmp     @b
.ret2:
        pop     esi
.ret:
        ret
.ok:
        cmp     al, '/'
        jz      @f
        dec     esi
@@:
        add     dl, 80h
        xor     ecx, ecx
@@:
        cmp     dl, [BiosDisksData+ecx*4]
        jz      .ok2
        inc     ecx
        cmp     ecx, [NumBiosDisks]
        jb      @b
        jmp     .ret2
.ok2:
        add     esp, 8
        test    al, al
        jnz     @f
        mov     esi, fs_BdNext
        jmp     file_system_lfn.maindir_noesi
@@:
        push    ecx
        push    fs_OnBd
        mov     edi, esp
        jmp     file_system_lfn.found2
 
fs_BdNext:
        cmp     eax, [BiosDiskPartitions+ecx*4]
	inc	eax
	cmc
	ret
 
fs_OnBd:
        pop     edx edx
; edx = disk number, ecx = partition number
; esi+ebp = name
	call	reserve_hd1
	add     edx, 0x80
	mov     [hdpos], edx
	cmp     ecx, [BiosDiskPartitions+(edx-0x80)*4]
	jmp     fs_OnHdAndBd
 
; This handler is called when virtual root is enumerated
; and must return all items which can be handled by this.
; It is called several times, first time with eax=0
; in: eax = 0 for first call, previously returned value for subsequent calls
; out: eax = 0 => no more items
;      eax != 0 => buffer pointed to by edi contains name of item
 
; here we enumerate existing BIOS disks /bd
biosdisk_enum_root:
        cmp     eax, [NumBiosDisks]
        jae     .end
        push    eax
        movzx   eax, byte [BiosDisksData+eax*4]
        sub     al, 80h
        push    eax
        mov     al, 'b'
        stosb
        mov     al, 'd'
        stosb
        pop     eax
        cmp     al, 10
        jae     .big
        add     al, '0'
        stosb
        mov     byte [edi], 0
        pop     eax
        inc     eax
        ret
.end:
        xor     eax, eax
        ret
.big:
        push    ecx edx
        push    -'0'
        mov     ecx, 10
@@:
        xor     edx, edx
        div     ecx
        push    edx
        test    eax, eax
        jnz     @b
        xchg    eax, edx
@@:
        pop     eax
        add     al, '0'
        stosb
        jnz     @b
        pop     edx ecx
        pop     eax
        inc     eax
        ret
 
process_replace_file_name:
	mov	ebp, [full_file_name_table]
	mov	edi, [full_file_name_table.size]
	dec	edi
	shl	edi, 7
	add	edi, ebp
.loop:
	cmp	edi, ebp
	jb	.notfound
	push	esi edi
@@:
	cmp	byte [edi], 0
	jz	.dest_done
	lodsb
	test	al, al
	jz	.cont
	or	al, 20h
	scasb
	jz	@b
	jmp	.cont
.dest_done:
	cmp	byte [esi], 0
	jz	.found
	cmp	byte [esi], '/'
	jnz	.cont
	inc	esi
	jmp	.found
.cont:
	pop	edi esi
	sub	edi, 128
	jmp	.loop
.found:
	pop	edi eax
	mov	ebp, esi
	cmp	byte [esi], 0
	lea	esi, [edi+64]
	jnz	.ret
.notfound:
	xor	ebp, ebp
.ret:
	ret
 
sys_current_directory:
;	mov	esi, [current_slot]
;	mov	esi, [esi+APPDATA.cur_dir]
;	mov	edx, esi
 
;get length string of appdata.cur_dir
	mov	eax, [current_slot]
	mov	edi, [eax+APPDATA.cur_dir]
 
	dec	ebx
	jz	.set
	dec	ebx
	jz	.get
	ret
.get:
; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len
; for our code: ebx->buffer,ecx=len
max_cur_dir	equ	0x1000
 
	mov	ebx,edi
 
	push	ecx
	push	edi
 
	xor	eax,eax
	mov	ecx,max_cur_dir
 
	repne	scasb		;find zerro at and string
	jnz     .error		; no zero in cur_dir: internal error, should not happen
 
	sub	edi,ebx		;lenght for copy
	inc	edi
        mov	[esp+32+8],edi	;return in eax
 
	cmp	edx, edi
	jbe     @f
	mov     edx, edi
@@:
;source string
	pop	esi
;destination string
	pop	edi
	cmp	edx, 1
	jbe	.ret
 
	mov	al,'/'		;start string with '/'
	stosb
	mov	ecx,edx
	rep	movsb           ;copy string
.ret:	ret
 
.error: add	esp,8
	or	dword [esp+32],-1	;error not found zerro at string ->[eax+APPDATA.cur_dir]
	ret
.set:
; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string
; for our code: ebx->string to set
; use generic resolver with APPDATA.cur_dir as destination
	push	max_cur_dir	;0x1000
	push	edi	;destination
	mov	ebx,ecx
	call	get_full_file_name
	ret
 
; in: ebx = file name, [esp+4] = destination, [esp+8] = sizeof destination
; destroys all registers except ebp,esp
get_full_file_name:
	push	ebp
	mov	esi, [current_slot]
	mov	esi, [esi+APPDATA.cur_dir]
	mov	edx, esi
@@:
	inc	esi
	cmp	byte [esi-1], 0
	jnz	@b
	dec	esi
	cmp	byte [ebx], '/'
	jz	.set_absolute
; string gives relative path
	mov	edi, [esp+8]	; destination
.relative:
	cmp	byte [ebx], 0
	jz	.set_ok
	cmp	word [ebx], '.'
	jz	.set_ok
	cmp	word [ebx], './'
	jnz	@f
	add	ebx, 2
	jmp	.relative
@@:
	cmp	word [ebx], '..'
	jnz	.doset_relative
	cmp	byte [ebx+2], 0
	jz	@f
	cmp	byte [ebx+2], '/'
	jnz	.doset_relative
@@:
	dec	esi
	cmp	byte [esi], '/'
	jnz	@b
	add	ebx, 3
	jmp	.relative
.set_ok:
	cmp	edx, edi	; is destination equal to APPDATA.cur_dir?
	jz	.set_ok.cur_dir
	sub	esi, edx
	cmp	esi, [esp+12]
	jb	.set_ok.copy
.fail:
	mov	byte [edi], 0
	xor	eax, eax	; fail
	pop	ebp
	ret	8
.set_ok.copy:
	mov	ecx, esi
	mov	esi, edx
	rep	movsb
	mov	byte [edi], 0
.ret.ok:
	mov	al, 1	; ok
	pop	ebp
	ret	8
.set_ok.cur_dir:
	mov	byte [esi], 0
	jmp	.ret.ok
.doset_relative:
	cmp	edx, edi
	jz	.doset_relative.cur_dir
	sub	esi, edx
	cmp	esi, [esp+12]
	jae	.fail
	mov	ecx, esi
	mov	esi, edx
	mov	edx, edi
	rep	movsb
	jmp	.doset_relative.copy
.doset_relative.cur_dir:
	mov	edi, esi
.doset_relative.copy:
	add	edx, [esp+12]
	mov	byte [edi], '/'
	inc	edi
	cmp	edi, edx
	jae	.overflow
@@:
	mov	al, [ebx]
	inc	ebx
	stosb
	test	al, al
	jz	.ret.ok
	cmp	edi, edx
	jb	@b
.overflow:
	dec	edi
	jmp	.fail
.set_absolute:
	lea	esi, [ebx+1]
	call	process_replace_file_name
	mov	edi, [esp+8]
	mov	edx, [esp+12]
	add	edx, edi
.set_copy:
	lodsb
	stosb
	test	al, al
	jz	.set_part2
.set_copy_cont:
	cmp	edi, edx
	jb	.set_copy
	jmp	.overflow
.set_part2:
	mov	esi, ebp
	xor	ebp, ebp
	test	esi, esi
	jz	.ret.ok
	mov	byte [edi-1], '/'
	jmp	.set_copy_cont
 
; ===============  moved from fs/iso9660.inc
 
char_todown:
; convert character to uppercase, using cp866 encoding
; in: al=symbol
; out: al=converted symbol
	cmp	al, 'A'
	jb	.ret
	cmp	al, 'Z'
	jbe	.az
	cmp	al, ''
	jb	.ret
	cmp	al, ''
	jb	.rus1
	cmp	al, ''
	ja	.ret
; 0x90-0x9F -> 0xE0-0xEF
	add	al, 'à'-''
.ret:
	ret
.rus1:
; 0x80-0x8F -> 0xA0-0xAF
.az:
	add	al, 0x20
	ret
 
uni2ansi_char:
; convert UNICODE character in al to ANSI character in ax, using cp866 encoding
; in: ax=UNICODE character
; out: al=converted ANSI character
	cmp	ax, 0x80
	jb	.ascii
	cmp	ax, 0x401
	jz	.yo1
	cmp	ax, 0x451
	jz	.yo2
	cmp	ax, 0x410
	jb	.unk
	cmp	ax, 0x440
	jb	.rus1
	cmp	ax, 0x450
	jb	.rus2
.unk:
	mov	al, '_'
	jmp	.doit
.yo1:
	mov	al, 'ð'
	jmp	.doit
.yo2:
	mov	al, 'ñ'
	jmp	.doit
.rus1:
; 0x410-0x43F -> 0x80-0xAF
	add	al, 0x70
	jmp	.doit
.rus2:
; 0x440-0x44F -> 0xE0-0xEF
	add	al, 0xA0
.ascii:
.doit:
	ret

Rev 1689	Rev 3487
1	;; ;;	1	;; ;;
2	;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;	2	;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
3	;; Distributed under terms of the GNU General Public License ;;	3	;; Distributed under terms of the GNU General Public License ;;
4	;; ;;	4	;; ;;
5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6		6
7	$Revision: 1689 $	7	$Revision: 3487 $
8		8
9		9
10	image_of_eax EQU esp+32	10	image_of_eax EQU esp+32
11	image_of_ebx EQU esp+20	11	image_of_ebx EQU esp+20
12		12
13	; System function 70 - files with long names (LFN)	13	; System function 70 - files with long names (LFN)
14	; diamond, 2006	14	; diamond, 2006
15		15
16	iglobal	16	iglobal
17	; in this table names must be in lowercase	17	; in this table names must be in lowercase
18	rootdirs:	18	rootdirs:
19	db 2,'rd'	19	db 2,'rd'
20	dd fs_OnRamdisk	20	dd fs_OnRamdisk
21	dd fs_NextRamdisk	21	dd fs_NextRamdisk
22	db 7,'ramdisk'	22	db 7,'ramdisk'
23	dd fs_OnRamdisk	23	dd fs_OnRamdisk
24	dd fs_NextRamdisk	24	dd fs_NextRamdisk
25	db 2,'fd'	-
26	dd fs_OnFloppy	-
27	dd fs_NextFloppy	-
28	db 10,'floppydisk'	-
29	dd fs_OnFloppy	-
30	dd fs_NextFloppy	-
31	db 3,'hd0'	25	db 3,'hd0'
32	dd fs_OnHd0	26	dd fs_OnHd0
33	dd fs_NextHd0	27	dd fs_NextHd0
34	db 3,'hd1'	28	db 3,'hd1'
35	dd fs_OnHd1	29	dd fs_OnHd1
36	dd fs_NextHd1	30	dd fs_NextHd1
37	db 3,'hd2'	31	db 3,'hd2'
38	dd fs_OnHd2	32	dd fs_OnHd2
39	dd fs_NextHd2	33	dd fs_NextHd2
40	db 3,'hd3'	34	db 3,'hd3'
41	dd fs_OnHd3	35	dd fs_OnHd3
42	dd fs_NextHd3	36	dd fs_NextHd3
43	db 0	37	db 0
44		38
45		39
46	virtual_root_query:	40	virtual_root_query:
47	dd fs_HasRamdisk	41	dd fs_HasRamdisk
48	db 'rd',0	42	db 'rd',0
49	dd fs_HasFloppy	43	dd fs_HasFloppy
50	db 'fd',0	44	db 'fd',0
51	dd fs_HasHd0	45	dd fs_HasHd0
52	db 'hd0',0	46	db 'hd0',0
53	dd fs_HasHd1	47	dd fs_HasHd1
54	db 'hd1',0	48	db 'hd1',0
55	dd fs_HasHd2	49	dd fs_HasHd2
56	db 'hd2',0	50	db 'hd2',0
57	dd fs_HasHd3	51	dd fs_HasHd3
58	db 'hd3',0	52	db 'hd3',0
59	dd 0	53	dd 0
60		54
61	fs_additional_handlers:	55	fs_additional_handlers:
62	dd biosdisk_handler, biosdisk_enum_root	56	dd biosdisk_handler, biosdisk_enum_root
63	; add new handlers here	57	; add new handlers here
64	dd 0	58	dd 0
65		59
66	endg	60	endg
67	file_system_lfn:	61	file_system_lfn:
68	; in: ebx->fileinfo block	62	; in: ebx->fileinfo block
69	; operation codes:	63	; operation codes:
70	; 0 : read file	64	; 0 : read file
71	; 1 : read folder	65	; 1 : read folder
72	; 2 : create/rewrite file	66	; 2 : create/rewrite file
73	; 3 : write/append to file	67	; 3 : write/append to file
74	; 4 : set end of file	68	; 4 : set end of file
75	; 5 : get file/directory attributes structure	69	; 5 : get file/directory attributes structure
76	; 6 : set file/directory attributes structure	70	; 6 : set file/directory attributes structure
77	; 7 : start application	71	; 7 : start application
78	; 8 : delete file	72	; 8 : delete file
79	; 9 : create directory	73	; 9 : create directory
80		74
81	; parse file name	75	; parse file name
82	lea esi, [ebx+20]	76	lea esi, [ebx+20]
83	lodsb	77	lodsb
84	test al, al	78	test al, al
85	jnz @f	79	jnz @f
86	mov esi, [esi]	80	mov esi, [esi]
87	lodsb	81	lodsb
88	@@:	82	@@:
89	cmp al, '/'	83	cmp al, '/'
90	jz .notcurdir	84	jz .notcurdir
91	dec esi	85	dec esi
92	mov ebp, esi	86	mov ebp, esi
93	test al, al	87	test al, al
94	jnz @f	88	jnz @f
95	xor ebp, ebp	89	xor ebp, ebp
96	@@:	90	@@:
97	mov esi, [current_slot]	91	mov esi, [current_slot]
98	mov esi, [esi+APPDATA.cur_dir]	92	mov esi, [esi+APPDATA.cur_dir]
99	jmp .parse_normal	93	jmp .parse_normal
100	.notcurdir:	94	.notcurdir:
101	cmp byte [esi], 0	95	cmp byte [esi], 0
102	jz .rootdir	96	jz .rootdir
103	call process_replace_file_name	97	call process_replace_file_name
104	.parse_normal:	98	.parse_normal:
105	cmp dword [ebx], 7	99	cmp dword [ebx], 7
106	jne @F	100	jne @F
107	mov edx, [ebx+4]	101	mov edx, [ebx+4]
108	mov ebx, [ebx+8]	102	mov ebx, [ebx+8]
109	call fs_execute ; esi+ebp, ebx, edx	103	call fs_execute ; esi+ebp, ebx, edx
110	mov [image_of_eax], eax	104	mov [image_of_eax], eax
111	ret	105	ret
112	@@:	106	@@:
113	mov edi, rootdirs-8	107	mov edi, rootdirs-8
114	xor ecx, ecx	108	xor ecx, ecx
115	push esi	109	push esi
116	.scan1:	110	.scan1:
117	pop esi	111	pop esi
118	add edi, ecx	112	add edi, ecx
119	scasd	113	scasd
120	scasd	114	scasd
121	mov cl, byte [edi]	115	mov cl, byte [edi]
122	test cl, cl	116	test cl, cl
123	jz .notfound_try	117	jz .notfound_try
124	inc edi	118	inc edi
125	push esi	119	push esi
126	@@:	120	@@:
127	lodsb	121	lodsb
128	or al, 20h	122	or al, 20h
129	scasb	123	scasb
130	loopz @b	124	loopz @b
131	jnz .scan1	125	jnz .scan1
132	lodsb	126	lodsb
133	cmp al, '/'	127	cmp al, '/'
134	jz .found1	128	jz .found1
135	test al, al	129	test al, al
136	jnz .scan1	130	jnz .scan1
137	pop eax	131	pop eax
138	; directory /xxx	132	; directory /xxx
139	.maindir:	133	.maindir:
140	mov esi, [edi+4]	134	mov esi, [edi+4]
141	.maindir_noesi:	135	.maindir_noesi:
142	cmp dword [ebx], 1	136	cmp dword [ebx], 1
143	jnz .access_denied	137	jnz .access_denied
144	xor eax, eax	138	xor eax, eax
145	mov ebp, [ebx+12] ;êîëè÷åñòâî áëîêîâ äëÿ ñ÷èòûâàíèÿ	139	mov ebp, [ebx+12] ;êîëè÷åñòâî áëîêîâ äëÿ ñ÷èòûâàíèÿ
146	mov edx, [ebx+16] ;êóäà çàïèñûâàòü ðóçåëüòàò	140	mov edx, [ebx+16] ;êóäà çàïèñûâàòü ðóçåëüòàò
147	; add edx, std_application_base_address	141	; add edx, std_application_base_address
148	push dword [ebx+4] ; first block	142	push dword [ebx+4] ; first block
149	mov ebx, [ebx+8] ; flags	143	mov ebx, [ebx+8] ; flags
150	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler	144	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
151	mov edi, edx	145	mov edi, edx
152	push ecx	146	push ecx
153	mov ecx, 32/4	147	mov ecx, 32/4
154	rep stosd	148	rep stosd
155	pop ecx	149	pop ecx
156	mov byte [edx], 1 ; version	150	mov byte [edx], 1 ; version
157	.maindir_loop:	151	.maindir_loop:
158	call esi	152	call esi
159	jc .maindir_done	153	jc .maindir_done
160	inc dword [edx+8]	154	inc dword [edx+8]
161	dec dword [esp]	155	dec dword [esp]
162	jns .maindir_loop	156	jns .maindir_loop
163	dec ebp	157	dec ebp
164	js .maindir_loop	158	js .maindir_loop
165	inc dword [edx+4]	159	inc dword [edx+4]
166	mov dword [edi], 0x10 ; attributes: folder	160	mov dword [edi], 0x10 ; attributes: folder
167	mov dword [edi+4], 1 ; name type: UNICODE	161	mov dword [edi+4], 1 ; name type: UNICODE
168	push eax	162	push eax
169	xor eax, eax	163	xor eax, eax
170	add edi, 8	164	add edi, 8
171	push ecx	165	push ecx
172	mov ecx, 40/4-2	166	mov ecx, 40/4-2
173	rep stosd	167	rep stosd
174	pop ecx	168	pop ecx
175	pop eax	169	pop eax
176	push eax edx	170	push eax edx
177	; convert number in eax to decimal UNICODE string	171	; convert number in eax to decimal UNICODE string
178	push edi	172	push edi
179	push ecx	173	push ecx
180	push -'0'	174	push -'0'
181	mov ecx, 10	175	mov ecx, 10
182	@@:	176	@@:
183	xor edx, edx	177	xor edx, edx
184	div ecx	178	div ecx
185	push edx	179	push edx
186	test eax, eax	180	test eax, eax
187	jnz @b	181	jnz @b
188	@@:	182	@@:
189	pop eax	183	pop eax
190	add al, '0'	184	add al, '0'
191	stosb	185	stosb
192	test bl, 1 ; UNICODE name?	186	test bl, 1 ; UNICODE name?
193	jz .ansi2	187	jz .ansi2
194	mov byte [edi], 0	188	mov byte [edi], 0
195	inc edi	189	inc edi
196	.ansi2:	190	.ansi2:
197	test al, al	191	test al, al
198	jnz @b	192	jnz @b
199	mov byte [edi-1], 0	193	mov byte [edi-1], 0
200	pop ecx	194	pop ecx
201	pop edi	195	pop edi
202	; UNICODE name length is 520 bytes, ANSI - 264	196	; UNICODE name length is 520 bytes, ANSI - 264
203	add edi, 520	197	add edi, 520
204	test bl, 1	198	test bl, 1
205	jnz @f	199	jnz @f
206	sub edi, 520-264	200	sub edi, 520-264
207	@@:	201	@@:
208	pop edx eax	202	pop edx eax
209	jmp .maindir_loop	203	jmp .maindir_loop
210	.maindir_done:	204	.maindir_done:
211	pop eax	205	pop eax
212	mov ebx, [edx+4]	206	mov ebx, [edx+4]
213	xor eax, eax	207	xor eax, eax
214	dec ebp	208	dec ebp
215	js @f	209	js @f
216	mov al, ERROR_END_OF_FILE	210	mov al, ERROR_END_OF_FILE
217	@@:	211	@@:
218	mov [image_of_eax], eax	212	mov [image_of_eax], eax
219	mov [image_of_ebx], ebx	213	mov [image_of_ebx], ebx
220	ret	214	ret
221	; directory /	215	; directory /
222	.rootdir:	216	.rootdir:
223	cmp dword [ebx], 1 ; read folder?	217	cmp dword [ebx], 1 ; read folder?
224	jz .readroot	218	jz .readroot
225	.access_denied:	219	.access_denied:
226	mov dword [image_of_eax], 10 ; access denied	220	mov dword [image_of_eax], 10 ; access denied
227	ret	221	ret
228		222
229	.readroot:	223	.readroot:
230	; virtual root folder - special handler	224	; virtual root folder - special handler
231	mov esi, virtual_root_query	225	mov esi, virtual_root_query
232	mov ebp, [ebx+12]	226	mov ebp, [ebx+12]
233	mov edx, [ebx+16]	227	mov edx, [ebx+16]
234	; add edx, std_application_base_address	228	; add edx, std_application_base_address
235	push dword [ebx+4] ; first block	229	push dword [ebx+4] ; first block
236	mov ebx, [ebx+8] ; flags	230	mov ebx, [ebx+8] ; flags
237	xor eax, eax	231	xor eax, eax
238	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area	232	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
239	mov edi, edx	233	mov edi, edx
240	mov ecx, 32/4	234	mov ecx, 32/4
241	rep stosd	235	rep stosd
242	mov byte [edx], 1 ; version	236	mov byte [edx], 1 ; version
243	.readroot_loop:	237	.readroot_loop:
244	cmp dword [esi], eax	238	cmp dword [esi], eax
245	jz .readroot_done_static	239	jz .readroot_done_static
246	call dword [esi]	240	call dword [esi]
247	add esi, 4	241	add esi, 4
248	test eax, eax	242	test eax, eax
249	jnz @f	243	jnz @f
250	.readroot_next:	244	.readroot_next:
251	or ecx, -1	245	or ecx, -1
252	xchg esi, edi	246	xchg esi, edi
253	repnz scasb	247	repnz scasb
254	xchg esi, edi	248	xchg esi, edi
255	jmp .readroot_loop	249	jmp .readroot_loop
256	@@:	250	@@:
257	xor eax, eax	251	xor eax, eax
258	inc dword [edx+8]	252	inc dword [edx+8]
259	dec dword [esp]	253	dec dword [esp]
260	jns .readroot_next	254	jns .readroot_next
261	dec ebp	255	dec ebp
262	js .readroot_next	256	js .readroot_next
263	inc dword [edx+4]	257	inc dword [edx+4]
264	mov dword [edi], 0x10 ; attributes: folder	258	mov dword [edi], 0x10 ; attributes: folder
265	mov dword [edi+4], ebx ; name type: UNICODE	259	mov dword [edi+4], ebx ; name type: UNICODE
266	add edi, 8	260	add edi, 8
267	mov ecx, 40/4-2	261	mov ecx, 40/4-2
268	rep stosd	262	rep stosd
269	push edi	263	push edi
270	@@:	264	@@:
271	lodsb	265	lodsb
272	stosb	266	stosb
273	test bl, 1	267	test bl, 1
274	jz .ansi	268	jz .ansi
275	mov byte [edi], 0	269	mov byte [edi], 0
276	inc edi	270	inc edi
277	.ansi:	271	.ansi:
278	test eax, eax	272	test eax, eax
279	jnz @b	273	jnz @b
280	pop edi	274	pop edi
281	add edi, 520	275	add edi, 520
282	test bl, 1	276	test bl, 1
283	jnz .readroot_loop	277	jnz .readroot_loop
284	sub edi, 520-264	278	sub edi, 520-264
285	jmp .readroot_loop	279	jmp .readroot_loop
286	.readroot_done_static:	280	.readroot_done_static:
287	mov esi, fs_additional_handlers-8	281	mov esi, fs_additional_handlers-8
288	sub esp, 16	282	sub esp, 16
289	.readroot_ah_loop:	283	.readroot_ah_loop:
290	add esi, 8	284	add esi, 8
291	cmp dword [esi], 0	285	cmp dword [esi], 0
292	jz .readroot_done	286	jz .readroot_done
293	xor eax, eax	287	xor eax, eax
294	.readroot_ah_loop2:	288	.readroot_ah_loop2:
295	push edi	289	push edi
296	lea edi, [esp+4]	290	lea edi, [esp+4]
297	call dword [esi+4]	291	call dword [esi+4]
298	pop edi	292	pop edi
299	test eax, eax	293	test eax, eax
300	jz .readroot_ah_loop	294	jz .readroot_ah_loop
301	inc dword [edx+8]	295	inc dword [edx+8]
302	dec dword [esp+16]	296	dec dword [esp+16]
303	jns .readroot_ah_loop2	297	jns .readroot_ah_loop2
304	dec ebp	298	dec ebp
305	js .readroot_ah_loop2	299	js .readroot_ah_loop2
306	push eax	300	push eax
307	xor eax, eax	301	xor eax, eax
308	inc dword [edx+4]	302	inc dword [edx+4]
309	mov dword [edi], 0x10 ; attributes: folder	303	mov dword [edi], 0x10 ; attributes: folder
310	mov dword [edi+4], ebx	304	mov dword [edi+4], ebx
311	add edi, 8	305	add edi, 8
312	mov ecx, 40/4-2	306	mov ecx, 40/4-2
313	rep stosd	307	rep stosd
314	push esi edi	308	push esi edi
315	lea esi, [esp+12]	309	lea esi, [esp+12]
316	@@:	310	@@:
317	lodsb	311	lodsb
318	stosb	312	stosb
319	test bl, 1	313	test bl, 1
320	jz .ansi3	314	jz .ansi3
321	mov byte [edi], 0	315	mov byte [edi], 0
322	inc edi	316	inc edi
323	.ansi3:	317	.ansi3:
324	test al, al	318	test al, al
325	jnz @b	319	jnz @b
326	pop edi esi eax	320	pop edi esi eax
327	add edi, 520	321	add edi, 520
328	test bl, 1	322	test bl, 1
329	jnz .readroot_ah_loop2	323	jnz .readroot_ah_loop2
330	sub edi, 520-264	324	sub edi, 520-264
331	jmp .readroot_ah_loop2	325	jmp .readroot_ah_loop2
332	.readroot_done:	326	.readroot_done:
333	add esp, 16	327	add esp, 16
334	pop eax	328	pop eax
335	mov ebx, [edx+4]	329	mov ebx, [edx+4]
336	xor eax, eax	330	xor eax, eax
337	dec ebp	331	dec ebp
338	js @f	332	js @f
339	mov al, ERROR_END_OF_FILE	333	mov al, ERROR_END_OF_FILE
340	@@:	334	@@:
341	mov [image_of_eax], eax	335	mov [image_of_eax], eax
342	mov [image_of_ebx], ebx	336	mov [image_of_ebx], ebx
343	ret	337	ret
344	.notfound_try:	338	.notfound_try:
345	mov edi, fs_additional_handlers	339	mov edi, fs_additional_handlers
346	@@:	340	@@:
347	cmp dword [edi], 0	341	cmp dword [edi], 0
348	jz .notfound	342	jz .notfound
349	call dword [edi]	343	call dword [edi]
350	scasd	344	scasd
351	scasd	345	scasd
352	jmp @b	346	jmp @b
353	.notfound:	347	.notfound:
354	mov dword [image_of_eax], ERROR_FILE_NOT_FOUND	348	mov dword [image_of_eax], ERROR_FILE_NOT_FOUND
355	and dword [image_of_ebx], 0	349	and dword [image_of_ebx], 0
356	ret	350	ret
357		351
358	.notfounda:	352	.notfounda:
359	cmp edi, esp	353	cmp edi, esp
360	jnz .notfound	354	jnz .notfound
361	add esp, 8	355	add esp, 8
362	jmp .notfound	356	jmp .notfound
363		357
364	.found1:	358	.found1:
365	pop eax	359	pop eax
366	cmp byte [esi], 0	360	cmp byte [esi], 0
367	jz .maindir	361	jz .maindir
368	.found2:	362	.found2:
369	; read partition number	363	; read partition number
370	xor ecx, ecx	364	xor ecx, ecx
371	xor eax, eax	365	xor eax, eax
372	@@:	366	@@:
373	lodsb	367	lodsb
374	cmp al, '/'	368	cmp al, '/'
375	jz .done1	369	jz .done1
376	test al, al	370	test al, al
377	jz .done1	371	jz .done1
378	sub al, '0'	372	sub al, '0'
379	cmp al, 9	373	cmp al, 9
380	ja .notfounda	374	ja .notfounda
381	lea ecx, [ecx*5]	375	lea ecx, [ecx*5]
382	lea ecx, [ecx*2+eax]	376	lea ecx, [ecx*2+eax]
383	jmp @b	377	jmp @b
384	.done1:	378	.done1:
385	jecxz .notfounda	379	jecxz .notfounda
386	test al, al	380	test al, al
387	jnz @f	381	jnz @f
388	dec esi	382	dec esi
389	@@:	383	@@:
390	cmp byte [esi], 0	384	cmp byte [esi], 0
391	jnz @f	385	jnz @f
392	test ebp, ebp	386	test ebp, ebp
393	jz @f	387	jz @f
394	mov esi, ebp	388	mov esi, ebp
395	xor ebp, ebp	389	xor ebp, ebp
396	@@:	390	@@:
397	; now [edi] contains handler address, ecx - partition number,	391	; now [edi] contains handler address, ecx - partition number,
398	; esi points to ASCIIZ string - rest of name	392	; esi points to ASCIIZ string - rest of name
399	jmp dword [edi]	393	jmp dword [edi]
400		394
401	; handlers for devices	395	; handlers for devices
402	; in: ecx = 0 => query virtual directory /xxx	396	; in: ecx = 0 => query virtual directory /xxx
403	; in: ecx = partition number	397	; in: ecx = partition number
404	; esi -> relative (for device) name	398	; esi -> relative (for device) name
405	; ebx -> fileinfo	399	; ebx -> fileinfo
406	; ebp = 0 or pointer to rest of name from folder addressed by esi	400	; ebp = 0 or pointer to rest of name from folder addressed by esi
407	; out: [image_of_eax]=image of eax, [image_of_ebx]=image of ebx	401	; out: [image_of_eax]=image of eax, [image_of_ebx]=image of ebx
408		402
409	fs_OnRamdisk:	403	fs_OnRamdisk:
410	cmp ecx, 1	404	cmp ecx, 1
411	jnz file_system_lfn.notfound	405	jnz file_system_lfn.notfound
412	mov eax, [ebx]	406	mov eax, [ebx]
413	cmp eax, fs_NumRamdiskServices	407	cmp eax, fs_NumRamdiskServices
414	jae .not_impl	408	jae .not_impl
415	mov ecx, [ebx+12]	409	mov ecx, [ebx+12]
416	mov edx, [ebx+16]	410	mov edx, [ebx+16]
417	; add edx, std_application_base_address	411	; add edx, std_application_base_address
418	add ebx, 4	412	add ebx, 4
419	call dword [fs_RamdiskServices + eax*4]	413	call dword [fs_RamdiskServices + eax*4]
420	mov [image_of_eax], eax	414	mov [image_of_eax], eax
421	mov [image_of_ebx], ebx	415	mov [image_of_ebx], ebx
422	ret	416	ret
423	.not_impl:	417	.not_impl:
424	mov dword [image_of_eax], 2 ; not implemented	418	mov dword [image_of_eax], 2 ; not implemented
425	ret	419	ret
426		420
427	fs_NotImplemented:	421	fs_NotImplemented:
428	mov eax, 2	422	mov eax, 2
429	ret	423	ret
430		424
431	fs_RamdiskServices:	425	fs_RamdiskServices:
432	dd fs_RamdiskRead	426	dd fs_RamdiskRead
433	dd fs_RamdiskReadFolder	427	dd fs_RamdiskReadFolder
434	dd fs_RamdiskRewrite	428	dd fs_RamdiskRewrite
435	dd fs_RamdiskWrite	429	dd fs_RamdiskWrite
436	dd fs_RamdiskSetFileEnd	430	dd fs_RamdiskSetFileEnd
437	dd fs_RamdiskGetFileInfo	431	dd fs_RamdiskGetFileInfo
438	dd fs_RamdiskSetFileInfo	432	dd fs_RamdiskSetFileInfo
439	dd 0	433	dd 0
440	dd fs_RamdiskDelete	434	dd fs_RamdiskDelete
441	dd fs_RamdiskCreateFolder	435	dd fs_RamdiskCreateFolder
442	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4	436	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
443		-
444	fs_OnFloppy:	-
445	cmp ecx, 2	-
446	ja file_system_lfn.notfound	-
447	mov eax, [ebx]	-
448	cmp eax, fs_NumFloppyServices	-
449	jae fs_OnRamdisk.not_impl	-
450	call reserve_flp	-
451	mov [flp_number], cl	-
452	mov ecx, [ebx+12]	-
453	mov edx, [ebx+16]	-
454	; add edx, std_application_base_address	-
455	add ebx, 4	-
456	call dword [fs_FloppyServices + eax*4]	-
457	and [flp_status], 0	-
458	mov [image_of_eax], eax	-
459	mov [image_of_ebx], ebx	-
460	ret	-
461		-
462	fs_FloppyServices:	-
463	dd fs_FloppyRead	-
464	dd fs_FloppyReadFolder	-
465	dd fs_FloppyRewrite	-
466	dd fs_FloppyWrite	-
467	dd fs_FloppySetFileEnd	-
468	dd fs_FloppyGetFileInfo	-
469	dd fs_FloppySetFileInfo	-
470	dd 0	-
471	dd fs_FloppyDelete	-
472	dd fs_FloppyCreateFolder	-
473	fs_NumFloppyServices = ($ - fs_FloppyServices)/4	-
474		437
475	fs_OnHd0:	438	fs_OnHd0:
476	call reserve_hd1	439	call reserve_hd1
477	mov [hdbase], 0x1F0	440	mov [hdbase], 0x1F0
478	mov [hdid], 0	441	mov [hdid], 0
479	push 1	442	push 1
480	jmp fs_OnHd	443	jmp fs_OnHd
481	fs_OnHd1:	444	fs_OnHd1:
482	call reserve_hd1	445	call reserve_hd1
483	mov [hdbase], 0x1F0	446	mov [hdbase], 0x1F0
484	mov [hdid], 0x10	447	mov [hdid], 0x10
485	push 2	448	push 2
486	jmp fs_OnHd	449	jmp fs_OnHd
487	fs_OnHd2:	450	fs_OnHd2:
488	call reserve_hd1	451	call reserve_hd1
489	mov [hdbase], 0x170	452	mov [hdbase], 0x170
490	mov [hdid], 0	453	mov [hdid], 0
491	push 3	454	push 3
492	jmp fs_OnHd	455	jmp fs_OnHd
493	fs_OnHd3:	456	fs_OnHd3:
494	call reserve_hd1	457	call reserve_hd1
495	mov [hdbase], 0x170	458	mov [hdbase], 0x170
496	mov [hdid], 0x10	459	mov [hdid], 0x10
497	push 4	460	push 4
498	fs_OnHd:	461	fs_OnHd:
499	call reserve_hd_channel	462	call reserve_hd_channel
500	pop eax	463	pop eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-A/trunk/fs/fs_lfn.inc – Rev 1689 → 3487