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


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/fs/fs_lfn.inc – Rev 3626 → 3725