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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc @ 4277 – Rev 3742 → 4273