WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/fs/fs_lfn.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 897 $
 
 
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
 
    cmp dword [eax], 7
    je .do_exec
 
; 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:
 
 
 
 
 
 
 
 
	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      @f
        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]
 
.do_exec:
          lea ebx, [eax+20]
          cmp byte [ebx],0
          jnz @F
 
          mov ebx, [ebx+1]
@@:
          push  dword [eax+4]
          push  dword [eax+8]
          push  ebx
 
          call _sys_exec
          mov [image_of_eax], eax
          add esp, 12
 
          ret
 
; 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
	dec	eax
	jz	.set
	dec	eax
	jz	.get
	ret
.get:
; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len
; for our code: ebx->buffer,ecx=len
@@:
	lodsb
	test	al, al
	jnz	@b
	sub	esi, edx
	inc	esi
	mov	[esp+36], esi
	cmp	ecx, esi
	jbe	@f
	mov	ecx, esi
@@:
	cmp	ecx, 1
	jbe	.ret
	mov	esi, edx
	mov	edi, ebx
	mov	al, '/'
	stosb
	dec	ecx
	dec	ecx
	rep	movsb
	mov	byte [edi], 0
.ret:
	ret
.set:
; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string
; for our code: ebx->string to set
@@:
	inc	esi
	cmp	byte [esi-1], 0
	jnz	@b
	dec	esi
	cmp	byte [ebx], '/'
	jz	.set_absolute
; string gives relative path
.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
	mov	byte [esi], 0
	add	ebx, 3
	jmp	.relative
.doset_relative:
	add	edx, 0x1000
	mov	byte [esi], '/'
	inc	esi
	cmp	esi, edx
	jae	.overflow_esi
@@:
	mov	al, [ebx]
	inc	ebx
	mov	[esi], al
	inc	esi
	test	al, al
	jz	.set_ok
	cmp	esi, edx
	jb	@b
.overflow_esi:
	mov	byte [esi-1], 0 	; force null-terminated string
.set_ok:
	ret
.set_absolute:
	lea	esi, [ebx+1]
	call	process_replace_file_name
	mov	edi, edx
	add	edx, 0x1000
.set_copy:
	lodsb
	stosb
	test	al, al
	jz	.set_part2
.set_copy_cont:
	cmp	edi, edx
	jb	.set_copy
.overflow_edi:
	mov	byte [edi-1], 0
	ret
.set_part2:
	mov	esi, ebp
	xor	ebp, ebp
	test	esi, esi
	jz	.set_ok
	mov	byte [edi-1], '/'
	jmp	.set_copy_cont

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/fs/fs_lfn.inc – Rev 837 → 897