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: 1378 $
 
 
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
	cmp	dword [eax], 1
	jne	@F
	;xchg	bx,bx
@@:
	;up to file_system_lfn - TEMP!!!
	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	[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_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 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


Rev 1305	Rev 1378
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: 1305 $	8	$Revision: 1378 $
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	cmp dword [eax], 1
-		109	jne @F
-		110	;xchg bx,bx
-		111	@@:
-		112	;up to file_system_lfn - TEMP!!!
108	xchg ebx, eax	113	xchg ebx, eax
109	lea esi, [ebx+20]	114	lea esi, [ebx+20]
110	lodsb	115	lodsb
111	test al, al	116	test al, al
112	jnz @f	117	jnz @f
113	mov esi, [esi]	118	mov esi, [esi]
114	lodsb	119	lodsb
115	@@:	120	@@:
116	cmp al, '/'	121	cmp al, '/'
117	jz .notcurdir	122	jz .notcurdir
118	dec esi	123	dec esi
119	mov ebp, esi	124	mov ebp, esi
120	test al, al	125	test al, al
121	jnz @f	126	jnz @f
122	xor ebp, ebp	127	xor ebp, ebp
123	@@:	128	@@:
124	mov esi, [current_slot]	129	mov esi, [current_slot]
125	mov esi, [esi+APPDATA.cur_dir]	130	mov esi, [esi+APPDATA.cur_dir]
126	jmp .parse_normal	131	jmp .parse_normal
127	.notcurdir:	132	.notcurdir:
128	cmp byte [esi], 0	133	cmp byte [esi], 0
129	jz .rootdir	134	jz .rootdir
130	call process_replace_file_name	135	call process_replace_file_name
131	.parse_normal:	136	.parse_normal:
132	cmp dword [ebx], 7	137	cmp dword [ebx], 7
133	jne @F	138	jne @F
134	mov edx, [ebx+4]	139	mov edx, [ebx+4]
135	mov ebx, [ebx+8]	140	mov ebx, [ebx+8]
136	call fs_execute ; esi+ebp, ebx, edx	141	call fs_execute ; esi+ebp, ebx, edx
137	mov [image_of_eax], eax	142	mov [image_of_eax], eax
138	ret	143	ret
139	@@:	144	@@:
140	mov edi, rootdirs-8	145	mov edi, rootdirs-8
141	xor ecx, ecx	146	xor ecx, ecx
142	push esi	147	push esi
143	.scan1:	148	.scan1:
144	pop esi	149	pop esi
145	add edi, ecx	150	add edi, ecx
146	scasd	151	scasd
147	scasd	152	scasd
148	mov cl, byte [edi]	153	mov cl, byte [edi]
149	test cl, cl	154	test cl, cl
150	jz .notfound_try	155	jz .notfound_try
151	inc edi	156	inc edi
152	push esi	157	push esi
153	@@:	158	@@:
154	lodsb	159	lodsb
155	or al, 20h	160	or al, 20h
156	scasb	161	scasb
157	loopz @b	162	loopz @b
158	jnz .scan1	163	jnz .scan1
159	lodsb	164	lodsb
160	cmp al, '/'	165	cmp al, '/'
161	jz .found1	166	jz .found1
162	test al, al	167	test al, al
163	jnz .scan1	168	jnz .scan1
164	pop eax	169	pop eax
165	; directory /xxx	170	; directory /xxx
166	.maindir:	171	.maindir:
167	mov esi, [edi+4]	172	mov esi, [edi+4]
168	.maindir_noesi:	173	.maindir_noesi:
169	cmp dword [ebx], 1	174	cmp dword [ebx], 1
170	jnz .access_denied	175	jnz .access_denied
171	xor eax, eax	176	xor eax, eax
172	mov ebp, [ebx+12]	177	mov ebp, [ebx+12] ;количество блоков для считывания
173	mov edx, [ebx+16]	178	mov edx, [ebx+16] ;куда записывать рузельтат
174	; add edx, std_application_base_address	179	; add edx, std_application_base_address
175	push dword [ebx+4] ; first block	180	push dword [ebx+4] ; first block
176	mov ebx, [ebx+8] ; flags	181	mov ebx, [ebx+8] ; flags
177	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler	182	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
178	mov edi, edx	183	mov edi, edx
179	push ecx	184	push ecx
180	mov ecx, 32/4	185	mov ecx, 32/4
181	rep stosd	186	rep stosd
182	pop ecx	187	pop ecx
183	mov byte [edx], 1 ; version	188	mov byte [edx], 1 ; version
184	.maindir_loop:	189	.maindir_loop:
185	call esi	190	call esi ;!!!!!!!!!!!!!!!!!!
186	jc .maindir_done	191	jc .maindir_done
187	inc dword [edx+8]	192	inc dword [edx+8]
188	dec dword [esp]	193	dec dword [esp]
189	jns .maindir_loop	194	jns .maindir_loop
190	dec ebp	195	dec ebp
191	js .maindir_loop	196	js .maindir_loop
192	inc dword [edx+4]	197	inc dword [edx+4]
193	mov dword [edi], 0x10 ; attributes: folder	198	mov dword [edi], 0x10 ; attributes: folder
194	mov dword [edi+4], 1 ; name type: UNICODE	199	mov dword [edi+4], 1 ; name type: UNICODE
195	push eax	200	push eax
196	xor eax, eax	201	xor eax, eax
197	add edi, 8	202	add edi, 8
198	push ecx	203	push ecx
199	mov ecx, 40/4-2	204	mov ecx, 40/4-2
200	rep stosd	205	rep stosd
201	pop ecx	206	pop ecx
202	pop eax	207	pop eax
203	push eax edx	208	push eax edx
204	; convert number in eax to decimal UNICODE string	209	; convert number in eax to decimal UNICODE string
205	push edi	210	push edi
206	push ecx	211	push ecx
207	push -'0'	212	push -'0'
208	mov ecx, 10	213	mov ecx, 10
209	@@:	214	@@:
210	xor edx, edx	215	xor edx, edx
211	div ecx	216	div ecx
212	push edx	217	push edx
213	test eax, eax	218	test eax, eax
214	jnz @b	219	jnz @b
215	@@:	220	@@:
216	pop eax	221	pop eax
217	add al, '0'	222	add al, '0'
218	stosb	223	stosb
219	test bl, 1 ; UNICODE name?	224	test bl, 1 ; UNICODE name?
220	jz .ansi2	225	jz .ansi2
221	mov byte [edi], 0	226	mov byte [edi], 0
222	inc edi	227	inc edi
223	.ansi2:	228	.ansi2:
224	test al, al	229	test al, al
225	jnz @b	230	jnz @b
226	mov byte [edi-1], 0	231	mov byte [edi-1], 0
227	pop ecx	232	pop ecx
228	pop edi	233	pop edi
229	; UNICODE name length is 520 bytes, ANSI - 264	234	; UNICODE name length is 520 bytes, ANSI - 264
230	add edi, 520	235	add edi, 520
231	test bl, 1	236	test bl, 1
232	jnz @f	237	jnz @f
233	sub edi, 520-264	238	sub edi, 520-264
234	@@:	239	@@:
235	pop edx eax	240	pop edx eax
236	jmp .maindir_loop	241	jmp .maindir_loop
237	.maindir_done:	242	.maindir_done:
238	pop eax	243	pop eax
239	mov ebx, [edx+4]	244	mov ebx, [edx+4]
240	xor eax, eax	245	xor eax, eax
241	dec ebp	246	dec ebp
242	js @f	247	js @f
243	mov al, ERROR_END_OF_FILE	248	mov al, ERROR_END_OF_FILE
244	@@:	249	@@:
245	mov [image_of_eax], eax	250	mov [image_of_eax], eax
246	mov [image_of_ebx], ebx	251	mov [image_of_ebx], ebx
247	ret	252	ret
248	; directory /	253	; directory /
249	.rootdir:	254	.rootdir:
250	cmp dword [ebx], 1 ; read folder?	255	cmp dword [ebx], 1 ; read folder?
251	jz .readroot	256	jz .readroot
252	.access_denied:	257	.access_denied:
253	mov dword [image_of_eax], 10 ; access denied	258	mov dword [image_of_eax], 10 ; access denied
254	ret	259	ret
255		260
256	.readroot:	261	.readroot:
257	; virtual root folder - special handler	262	; virtual root folder - special handler
258	mov esi, virtual_root_query	263	mov esi, virtual_root_query
259	mov ebp, [ebx+12]	264	mov ebp, [ebx+12]
260	mov edx, [ebx+16]	265	mov edx, [ebx+16]
261	; add edx, std_application_base_address	266	; add edx, std_application_base_address
262	push dword [ebx+4] ; first block	267	push dword [ebx+4] ; first block
263	mov ebx, [ebx+8] ; flags	268	mov ebx, [ebx+8] ; flags
264	xor eax, eax	269	xor eax, eax
265	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area	270	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
266	mov edi, edx	271	mov edi, edx
267	mov ecx, 32/4	272	mov ecx, 32/4
268	rep stosd	273	rep stosd
269	mov byte [edx], 1 ; version	274	mov byte [edx], 1 ; version
270	.readroot_loop:	275	.readroot_loop:
271	cmp dword [esi], eax	276	cmp dword [esi], eax
272	jz .readroot_done_static	277	jz .readroot_done_static
273	call dword [esi]	278	call dword [esi]
274	add esi, 4	279	add esi, 4
275	test eax, eax	280	test eax, eax
276	jnz @f	281	jnz @f
277	.readroot_next:	282	.readroot_next:
278	or ecx, -1	283	or ecx, -1
279	xchg esi, edi	284	xchg esi, edi
280	repnz scasb	285	repnz scasb
281	xchg esi, edi	286	xchg esi, edi
282	jmp .readroot_loop	287	jmp .readroot_loop
283	@@:	288	@@:
284	xor eax, eax	289	xor eax, eax
285	inc dword [edx+8]	290	inc dword [edx+8]
286	dec dword [esp]	291	dec dword [esp]
287	jns .readroot_next	292	jns .readroot_next
288	dec ebp	293	dec ebp
289	js .readroot_next	294	js .readroot_next
290	inc dword [edx+4]	295	inc dword [edx+4]
291	mov dword [edi], 0x10 ; attributes: folder	296	mov dword [edi], 0x10 ; attributes: folder
292	mov dword [edi+4], ebx ; name type: UNICODE	297	mov dword [edi+4], ebx ; name type: UNICODE
293	add edi, 8	298	add edi, 8
294	mov ecx, 40/4-2	299	mov ecx, 40/4-2
295	rep stosd	300	rep stosd
296	push edi	301	push edi
297	@@:	302	@@:
298	lodsb	303	lodsb
299	stosb	304	stosb
300	test bl, 1	305	test bl, 1
301	jz .ansi	306	jz .ansi
302	mov byte [edi], 0	307	mov byte [edi], 0
303	inc edi	308	inc edi
304	.ansi:	309	.ansi:
305	test eax, eax	310	test eax, eax
306	jnz @b	311	jnz @b
307	pop edi	312	pop edi
308	add edi, 520	313	add edi, 520
309	test bl, 1	314	test bl, 1
310	jnz .readroot_loop	315	jnz .readroot_loop
311	sub edi, 520-264	316	sub edi, 520-264
312	jmp .readroot_loop	317	jmp .readroot_loop
313	.readroot_done_static:	318	.readroot_done_static:
314	mov esi, fs_additional_handlers-8	319	mov esi, fs_additional_handlers-8
315	sub esp, 16	320	sub esp, 16
316	.readroot_ah_loop:	321	.readroot_ah_loop:
317	add esi, 8	322	add esi, 8
318	cmp dword [esi], 0	323	cmp dword [esi], 0
319	jz .readroot_done	324	jz .readroot_done
320	xor eax, eax	325	xor eax, eax
321	.readroot_ah_loop2:	326	.readroot_ah_loop2:
322	push edi	327	push edi
323	lea edi, [esp+4]	328	lea edi, [esp+4]
324	call dword [esi+4]	329	call dword [esi+4]
325	pop edi	330	pop edi
326	test eax, eax	331	test eax, eax
327	jz .readroot_ah_loop	332	jz .readroot_ah_loop
328	inc dword [edx+8]	333	inc dword [edx+8]
329	dec dword [esp+16]	334	dec dword [esp+16]
330	jns .readroot_ah_loop2	335	jns .readroot_ah_loop2
331	dec ebp	336	dec ebp
332	js .readroot_ah_loop2	337	js .readroot_ah_loop2
333	push eax	338	push eax
334	xor eax, eax	339	xor eax, eax
335	inc dword [edx+4]	340	inc dword [edx+4]
336	mov dword [edi], 0x10 ; attributes: folder	341	mov dword [edi], 0x10 ; attributes: folder
337	mov dword [edi+4], ebx	342	mov dword [edi+4], ebx
338	add edi, 8	343	add edi, 8
339	mov ecx, 40/4-2	344	mov ecx, 40/4-2
340	rep stosd	345	rep stosd
341	push esi edi	346	push esi edi
342	lea esi, [esp+12]	347	lea esi, [esp+12]
343	@@:	348	@@:
344	lodsb	349	lodsb
345	stosb	350	stosb
346	test bl, 1	351	test bl, 1
347	jz .ansi3	352	jz .ansi3
348	mov byte [edi], 0	353	mov byte [edi], 0
349	inc edi	354	inc edi
350	.ansi3:	355	.ansi3:
351	test al, al	356	test al, al
352	jnz @b	357	jnz @b
353	pop edi esi eax	358	pop edi esi eax
354	add edi, 520	359	add edi, 520
355	test bl, 1	360	test bl, 1
356	jnz .readroot_ah_loop2	361	jnz .readroot_ah_loop2
357	sub edi, 520-264	362	sub edi, 520-264
358	jmp .readroot_ah_loop2	363	jmp .readroot_ah_loop2
359	.readroot_done:	364	.readroot_done:
360	add esp, 16	365	add esp, 16
361	pop eax	366	pop eax
362	mov ebx, [edx+4]	367	mov ebx, [edx+4]
363	xor eax, eax	368	xor eax, eax
364	dec ebp	369	dec ebp
365	js @f	370	js @f
366	mov al, ERROR_END_OF_FILE	371	mov al, ERROR_END_OF_FILE
367	@@:	372	@@:
368	mov [image_of_eax], eax	373	mov [image_of_eax], eax
369	mov [image_of_ebx], ebx	374	mov [image_of_ebx], ebx
370	ret	375	ret
371	.notfound_try:	376	.notfound_try:
372	mov edi, fs_additional_handlers	377	mov edi, fs_additional_handlers
373	@@:	378	@@:
374	cmp dword [edi], 0	379	cmp dword [edi], 0
375	jz .notfound	380	jz .notfound
376	call dword [edi]	381	call dword [edi]
377	scasd	382	scasd
378	scasd	383	scasd
379	jmp @b	384	jmp @b
380	.notfound:	385	.notfound:
381	mov dword [image_of_eax], ERROR_FILE_NOT_FOUND	386	mov dword [image_of_eax], ERROR_FILE_NOT_FOUND
382	and dword [image_of_ebx], 0	387	and dword [image_of_ebx], 0
383	ret	388	ret
384		389
385	.notfounda:	390	.notfounda:
386	cmp edi, esp	391	cmp edi, esp
387	jnz .notfound	392	jnz .notfound
388	add esp, 8	393	add esp, 8
389	jmp .notfound	394	jmp .notfound
390		395
391	.found1:	396	.found1:
392	pop eax	397	pop eax
393	cmp byte [esi], 0	398	cmp byte [esi], 0
394	jz .maindir	399	jz .maindir
395	.found2:	400	.found2:
396	; read partition number	401	; read partition number
397	xor ecx, ecx	402	xor ecx, ecx
398	xor eax, eax	403	xor eax, eax
399	@@:	404	@@:
400	lodsb	405	lodsb
401	cmp al, '/'	406	cmp al, '/'
402	jz .done1	407	jz .done1
403	test al, al	408	test al, al
404	jz .done1	409	jz .done1
405	sub al, '0'	410	sub al, '0'
406	cmp al, 9	411	cmp al, 9
407	ja .notfounda	412	ja .notfounda
408	lea ecx, [ecx*5]	413	lea ecx, [ecx*5]
409	lea ecx, [ecx*2+eax]	414	lea ecx, [ecx*2+eax]
410	jmp @b	415	jmp @b
411	.done1:	416	.done1:
412	jecxz .notfounda	417	jecxz .notfounda
413	test al, al	418	test al, al
414	jnz @f	419	jnz @f
415	dec esi	420	dec esi
416	@@:	421	@@:
417	cmp byte [esi], 0	422	cmp byte [esi], 0
418	jnz @f	423	jnz @f
419	test ebp, ebp	424	test ebp, ebp
420	jz @f	425	jz @f
421	mov esi, ebp	426	mov esi, ebp
422	xor ebp, ebp	427	xor ebp, ebp
423	@@:	428	@@:
424	; now [edi] contains handler address, ecx - partition number,	429	; now [edi] contains handler address, ecx - partition number,
425	; esi points to ASCIIZ string - rest of name	430	; esi points to ASCIIZ string - rest of name
426	jmp dword [edi]	431	jmp dword [edi]
427		432
428	; handlers for devices	433	; handlers for devices
429	; in: ecx = 0 => query virtual directory /xxx	434	; in: ecx = 0 => query virtual directory /xxx
430	; in: ecx = partition number	435	; in: ecx = partition number
431	; esi -> relative (for device) name	436	; esi -> relative (for device) name
432	; ebx -> fileinfo	437	; ebx -> fileinfo
433	; ebp = 0 or pointer to rest of name from folder addressed by esi	438	; 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	439	; out: [image_of_eax]=image of eax, [image_of_ebx]=image of ebx
435		440
436	fs_OnRamdisk:	441	fs_OnRamdisk:
437	cmp ecx, 1	442	cmp ecx, 1
438	jnz file_system_lfn.notfound	443	jnz file_system_lfn.notfound
439	mov eax, [ebx]	444	mov eax, [ebx]
440	cmp eax, fs_NumRamdiskServices	445	cmp eax, fs_NumRamdiskServices
441	jae .not_impl	446	jae .not_impl
442	mov ecx, [ebx+12]	447	mov ecx, [ebx+12]
443	mov edx, [ebx+16]	448	mov edx, [ebx+16]
444	; add edx, std_application_base_address	449	; add edx, std_application_base_address
445	add ebx, 4	450	add ebx, 4
446	call dword [fs_RamdiskServices + eax*4]	451	call dword [fs_RamdiskServices + eax*4]
447	mov [image_of_eax], eax	452	mov [image_of_eax], eax
448	mov [image_of_ebx], ebx	453	mov [image_of_ebx], ebx
449	ret	454	ret
450	.not_impl:	455	.not_impl:
451	mov dword [image_of_eax], 2 ; not implemented	456	mov dword [image_of_eax], 2 ; not implemented
452	ret	457	ret
453		458
454	fs_NotImplemented:	459	fs_NotImplemented:
455	mov eax, 2	460	mov eax, 2
456	ret	461	ret
457		462
458	fs_RamdiskServices:	463	fs_RamdiskServices:
459	dd fs_RamdiskRead	464	dd fs_RamdiskRead
460	dd fs_RamdiskReadFolder	465	dd fs_RamdiskReadFolder
461	dd fs_RamdiskRewrite	466	dd fs_RamdiskRewrite
462	dd fs_RamdiskWrite	467	dd fs_RamdiskWrite
463	dd fs_RamdiskSetFileEnd	468	dd fs_RamdiskSetFileEnd
464	dd fs_RamdiskGetFileInfo	469	dd fs_RamdiskGetFileInfo
465	dd fs_RamdiskSetFileInfo	470	dd fs_RamdiskSetFileInfo
466	dd 0	471	dd 0
467	dd fs_RamdiskDelete	472	dd fs_RamdiskDelete
468	dd fs_RamdiskCreateFolder	473	dd fs_RamdiskCreateFolder
469	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4	474	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
470		475
471	fs_OnFloppy:	476	fs_OnFloppy:
472	cmp ecx, 2	477	cmp ecx, 2
473	ja file_system_lfn.notfound	478	ja file_system_lfn.notfound
474	mov eax, [ebx]	479	mov eax, [ebx]
475	cmp eax, fs_NumFloppyServices	480	cmp eax, fs_NumFloppyServices
476	jae fs_OnRamdisk.not_impl	481	jae fs_OnRamdisk.not_impl
477	call reserve_flp	482	call reserve_flp
478	mov [flp_number], cl	483	mov [flp_number], cl
479	mov ecx, [ebx+12]	484	mov ecx, [ebx+12]
480	mov edx, [ebx+16]	485	mov edx, [ebx+16]
481	; add edx, std_application_base_address	486	; add edx, std_application_base_address
482	add ebx, 4	487	add ebx, 4
483	call dword [fs_FloppyServices + eax*4]	488	call dword [fs_FloppyServices + eax*4]
484	and [flp_status], 0	489	and [flp_status], 0
485	mov [image_of_eax], eax	490	mov [image_of_eax], eax
486	mov [image_of_ebx], ebx	491	mov [image_of_ebx], ebx
487	ret	492	ret
488		493
489	fs_FloppyServices:	494	fs_FloppyServices:
490	dd fs_FloppyRead	495	dd fs_FloppyRead
491	dd fs_FloppyReadFolder	496	dd fs_FloppyReadFolder
492	dd fs_FloppyRewrite	497	dd fs_FloppyRewrite
493	dd fs_FloppyWrite	498	dd fs_FloppyWrite
494	dd fs_FloppySetFileEnd	499	dd fs_FloppySetFileEnd
495	dd fs_FloppyGetFileInfo	500	dd fs_FloppyGetFileInfo

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc – Rev 1305 → 1378