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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1304 $
 
 
image_of_eax EQU esp+36
image_of_ebx EQU esp+24
 
; 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	2,'fd'
	dd	fs_OnFloppy
	dd	fs_NextFloppy
	db	10,'floppydisk'
	dd	fs_OnFloppy
	dd	fs_NextFloppy
	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	3,'cd0'
	dd	fs_OnCd0
	dd	fs_NextCd
	db	3,'cd1'
	dd	fs_OnCd1
	dd	fs_NextCd
	db	3,'cd2'
	dd	fs_OnCd2
	dd	fs_NextCd
	db	3,'cd3'
	dd	fs_OnCd3
	dd	fs_NextCd
;***********************************************
	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	fs_HasCd0
	db	'cd0',0
	dd	fs_HasCd1
	db	'cd1',0
	dd	fs_HasCd2
	db	'cd2',0
	dd	fs_HasCd3
	db	'cd3',0
;**********************************************
	dd	0
 
fs_additional_handlers:
        dd      biosdisk_handler, biosdisk_enum_root
; add new handlers here
        dd      0
 
endg
 
file_system_lfn:
; in: eax->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
	xchg	ebx, eax
	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_OnFloppy:
	cmp	ecx, 2
	ja	file_system_lfn.notfound
	mov	eax, [ebx]
	cmp	eax, fs_NumFloppyServices
	jae	fs_OnRamdisk.not_impl
	call	reserve_flp
	mov	[flp_number], cl
	mov	ecx, [ebx+12]
	mov	edx, [ebx+16]
   ;     add     edx, std_application_base_address
	add	ebx, 4
	call	dword [fs_FloppyServices + eax*4]
	and	[flp_status], 0
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
 
fs_FloppyServices:
	dd	fs_FloppyRead
	dd	fs_FloppyReadFolder
	dd	fs_FloppyRewrite
	dd	fs_FloppyWrite
	dd	fs_FloppySetFileEnd
	dd	fs_FloppyGetFileInfo
	dd	fs_FloppySetFileInfo
	dd	0
	dd	fs_FloppyDelete
	dd	fs_FloppyCreateFolder
fs_NumFloppyServices = ($ - fs_FloppyServices)/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	[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_OnCd0:
	call	reserve_cd
	mov  [ChannelNumber],1
	mov  [DiskNumber],0
	push	6
	push	1
	jmp	fs_OnCd
fs_OnCd1:
	call	reserve_cd
	mov  [ChannelNumber],1
	mov  [DiskNumber],1
	push	4
	push	2
	jmp	fs_OnCd
fs_OnCd2:
	call	reserve_cd
	mov  [ChannelNumber],2
	mov  [DiskNumber],0
	push	2
	push	3
	jmp	fs_OnCd
fs_OnCd3:
	call	reserve_cd
	mov  [ChannelNumber],2
	mov  [DiskNumber],1
	push	0
	push	4
fs_OnCd:
	call	reserve_cd_channel
	pop	eax
	mov	[cdpos], eax
	pop	eax
	cmp	ecx, 0x100
	jae	.nf
	push	ecx ebx
	mov	cl,al
	mov	bl,[DRIVE_DATA+1]
	shr	bl,cl
	test	bl,2
	pop	ebx ecx
 
	jnz	@f
.nf:
	call	free_cd_channel
	and    [cd_status], 0
	mov	dword [image_of_eax], 5       ; not found
	ret
@@:
	mov	ecx, [ebx+12]
	mov	edx, [ebx+16]
    ;    add     edx, std_application_base_address
	mov	eax, [ebx]
	cmp	eax,fs_NumCdServices
	jae	 .not_impl
	add	ebx, 4
	call	dword [fs_CdServices + eax*4]
	call	free_cd_channel
	and	[cd_status], 0
	mov	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	call	free_cd_channel
	and	[cd_status], 0
	mov	dword [image_of_eax], 2       ; not implemented
	ret
 
fs_CdServices:
	dd	fs_CdRead
	dd	fs_CdReadFolder
	dd	fs_NotImplemented
	dd	fs_NotImplemented
	dd	fs_NotImplemented
	dd	fs_CdGetFileInfo
	dd	fs_NotImplemented
	dd	0
	dd	fs_NotImplemented
	dd	fs_NotImplemented
fs_NumCdServices = ($ - fs_CdServices)/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
        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     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 lenght 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
;get lenght string of appdata.cur_dir
	mov	eax, [current_slot]
	mov	edi, [eax+APPDATA.cur_dir]
 
	mov	ebx,edi
 
	push	ecx
	push	edi
 
	xor	eax,eax
	mov	ecx,max_cur_dir
 
	repne	scasb		;find zerro at and string
	jcxz    .error		;ecx=0 and destination buffer is too small.
 
	sub	edi,ebx		;lenght for copy
	inc	edi
        mov	[esp+32+8],edi	;return in eax
 
	cmp	edx,edi		;edi must have more than 2 (for / and 0x0)  
;sourse string
	pop	esi
;destination string
	pop	edi
	jb	.ret
 
	mov	al,'/'		;start string with '/'
	stosb
	mov	ecx,edx
	rep	movsb           ;copy string
	xor	eax,eax
	mov	byte [edi],al   ;set zerro
.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

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc @ 1289 – Rev 1289 → 1304