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


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

Subversion Repositories Kolibri OS

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