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


; 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
endg
 
file_system_lfn:
; in: eax->fileinfo block
; operation codes:
; 0 : read file
; 1 : read folder
; 2 : create/rewrite file
; 3 : write/append to file
; 4 : set end of file
; 5 : get file/directory attributes structure
; 6 : set file/directory attributes structure
; 7 : start application
; 8 : delete file
; 9 : create directory
 
   ;     add     eax, std_application_base_address
; parse file name
        xchg    ebx, eax
        lea     esi, [ebx+20]
        mov     ebp, esi        ; for 'start app' function full path must be known
        lodsb
        test    al, al
        jnz     @f
        mov     esi, [esi]
  ;      add     esi, std_application_base_address
        mov     ebp, esi
        lodsb
@@:
        cmp dword [ebx], 7
        jne @F
        mov edx, [ebx+4]
        mov ebx, [ebx+8]
        test ebx, ebx
        jz .l1
    ;    add ebx, new_app_base
.l1:
        call fs_execute  ; ebp, ebx, edx
        mov [esp+36], eax
        ret
@@:
        cmp     al, '/'
        jz      @f
.notfound:
        mov     dword [esp+36], 5       ; file not found
        ret
@@:
        cmp     byte [esi], 0
        jz      .rootdir
        mov     edi, rootdirs-8
        xor     ecx, ecx
        push    esi
.scan1:
        pop     esi
        add     edi, ecx
        scasd
        scasd
        mov     cl, byte [edi]
        jecxz   .notfound
        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:
        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
        mov     esi, [edi+4]
; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
        mov     edi, edx
        mov     ecx, 32/4
        rep     stosd
        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
        mov     ecx, 40/4-2
        rep     stosd
        pop     eax
        push    eax edx
; convert number in eax to decimal UNICODE string
        push    edi
        push    -'0'
        mov     cl, 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     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     [esp+36], eax
        mov     [esp+24], ebx
        ret
; directory /
.rootdir:
        cmp     dword [ebx], 1  ; read folder?
        jz      .readroot
.access_denied:
        mov     dword [esp+36], 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
        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], 1        ; 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     [esp+36], eax
        mov     [esp+24], ebx
        ret
 
.found1:
        pop     eax
        cmp     byte [esi], 0
        jz      .maindir
; 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      .notfound
        imul    ecx, 10
        add     ecx, eax
        jmp     @b
.done1:
        test    ecx, ecx
        jz      .notfound
        test    al, al
        jnz     @f
        dec     esi
@@:
; 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
; out: [esp+36]=image of eax, [esp+24]=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     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        mov     dword [esp+36], 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 ;fs_RamdiskExecute
        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     [esp+36], eax
        mov     [esp+24], 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 ;fs_FloppyExecute
        dd      fs_FloppyDelete
        dd      fs_FloppyCreateFolder
fs_NumFloppyServices = ($ - fs_FloppyServices)/4
 
fs_OnHd0:
        call    reserve_hd1
        mov     [hdbase], 0x1F0
        mov     [hdid], 0
        push    1
        jmp     fs_OnHd
fs_OnHd1:
        call    reserve_hd1
        mov     [hdbase], 0x1F0
        mov     [hdid], 0x10
        push    2
        jmp     fs_OnHd
fs_OnHd2:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0
        push    3
        jmp     fs_OnHd
fs_OnHd3:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0x10
        push    4
fs_OnHd:
        call    reserve_hd_channel
        pop     eax
        mov     [hdpos], eax
        cmp     ecx, 0x100
        jae     .nf
        cmp     cl, [DRIVE_DATA+1+eax]
        jbe     @f
.nf:
        call    free_hd_channel
        and     [hd1_status], 0
        mov     dword [esp+36], 5       ; not found
        ret
@@:
        mov     [fat32part], ecx
        push    ebx esi
        call    choice_necessity_partition_1
        pop     esi ebx
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
    ;    add     edx, std_application_base_address
        mov     eax, [ebx]
        cmp     eax, fs_NumHdServices
        jae     .not_impl
        add     ebx, 4
        call    dword [fs_HdServices + eax*4]
        call    free_hd_channel
        and     [hd1_status], 0
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        call    free_hd_channel
        and     [hd1_status], 0
        mov     dword [esp+36], 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 ;fs_HdExecute
        dd      fs_HdDelete
        dd      fs_HdCreateFolder
fs_NumHdServices = ($ - fs_HdServices)/4
 
;*******************************************************
fs_OnCd0:
        call    reserve_cd
        mov  [ChannelNumber],1
        mov  [DiskNumber],0
        push    6
        jmp     fs_OnCd
fs_OnCd1:
        call    reserve_cd
        mov  [ChannelNumber],1
        mov  [DiskNumber],1
        push    4
        jmp     fs_OnCd
fs_OnCd2:
        call    reserve_cd
        mov  [ChannelNumber],2
        mov  [DiskNumber],0
        push    2
        jmp     fs_OnCd
fs_OnCd3:
        call    reserve_cd
        mov  [ChannelNumber],2
        mov  [DiskNumber],1
        push    0
fs_OnCd:
        call    reserve_cd_channel
        pop     eax
        mov     [hdpos], 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 [esp+36], 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     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        call    free_cd_channel
        and     [cd_status], 0
        mov     dword [esp+36], 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      fs_CdExecute
fs_NumCdServices = ($ - fs_CdServices)/4
 
;*******************************************************
 
fs_HasRamdisk:
        mov     al, 1   ; we always have ramdisk
        ret
 
fs_HasFloppy:
        cmp     byte [DRIVE_DATA], 0
        setnz   al
        ret
 
fs_HasHd0:
        mov     al, [DRIVE_DATA+1]
        and     al, 11000000b
        cmp     al, 01000000b
        setz    al
        ret
fs_HasHd1:
        mov     al, [DRIVE_DATA+1]
        and     al, 00110000b
        cmp     al, 00010000b
        setz    al
        ret
fs_HasHd2:
        mov     al, [DRIVE_DATA+1]
        and     al, 00001100b
        cmp     al, 00000100b
        setz    al
        ret
fs_HasHd3:
        mov     al, [DRIVE_DATA+1]
        and     al, 00000011b
        cmp     al, 00000001b
        setz    al
        ret
 
;*******************************************************
fs_HasCd0:
        mov     al, [DRIVE_DATA+1]
        and     al, 11000000b
        cmp     al, 10000000b
        setz    al
        ret
fs_HasCd1:
        mov     al, [DRIVE_DATA+1]
        and     al, 00110000b
        cmp     al, 00100000b
        setz    al
        ret
fs_HasCd2:
        mov     al, [DRIVE_DATA+1]
        and     al, 00001100b
        cmp     al, 00001000b
        setz    al
        ret
fs_HasCd3:
        mov     al, [DRIVE_DATA+1]
        and     al, 00000011b
        cmp     al, 00000010b
        setz    al
        ret
;*******************************************************
 
; fs_NextXXX functions:
; in: eax = partition number, from which start to scan
; out: CF=1 => no more partitions
;      CF=0 => eax=next partition number
 
fs_NextRamdisk:
; we always have /rd/1
        test    eax, eax
        stc
        jnz     @f
        mov     al, 1
        clc
@@:
        ret
 
fs_NextFloppy:
; we have /fd/1 iff (([DRIVE_DATA] and 0xF0) != 0) and /fd/2 iff (([DRIVE_DATA] and 0x0F) != 0)
        test    byte [DRIVE_DATA], 0xF0
        jz      .no1
        test    eax, eax
        jnz     .no1
        inc     eax
        ret     ; CF cleared
.no1:
        test    byte [DRIVE_DATA], 0x0F
        jz      .no2
        cmp     al, 2
        jae     .no2
        mov     al, 2
        clc
        ret
.no2:
        stc
        ret
 
; on hdx, we have partitions from 1 to [0x40002+x]
fs_NextHd0:
        push    0
        jmp     fs_NextHd
fs_NextHd1:
        push    1
        jmp     fs_NextHd
fs_NextHd2:
        push    2
        jmp     fs_NextHd
fs_NextHd3:
        push    3
fs_NextHd:
        pop     ecx
        movzx   ecx, byte [DRIVE_DATA+2+ecx]
        cmp     eax, ecx
        jae     fs_NextFloppy.no2
        inc     eax
        clc
        ret
 
;*******************************************************
fs_NextCd:
; we always have /cdX/1
        test    eax, eax
        stc
        jnz     @f
        mov     al, 1
        clc
@@:
        ret
;*******************************************************

Rev 419	Rev 432
1	; System function 70 - files with long names (LFN)	1	; System function 70 - files with long names (LFN)
2	; diamond, 2006	2	; diamond, 2006
3		3
4	iglobal	4	iglobal
5	; in this table names must be in lowercase	5	; in this table names must be in lowercase
6	rootdirs:	6	rootdirs:
7	db 2,'rd'	7	db 2,'rd'
8	dd fs_OnRamdisk	8	dd fs_OnRamdisk
9	dd fs_NextRamdisk	9	dd fs_NextRamdisk
10	db 7,'ramdisk'	10	db 7,'ramdisk'
11	dd fs_OnRamdisk	11	dd fs_OnRamdisk
12	dd fs_NextRamdisk	12	dd fs_NextRamdisk
13	db 2,'fd'	13	db 2,'fd'
14	dd fs_OnFloppy	14	dd fs_OnFloppy
15	dd fs_NextFloppy	15	dd fs_NextFloppy
16	db 10,'floppydisk'	16	db 10,'floppydisk'
17	dd fs_OnFloppy	17	dd fs_OnFloppy
18	dd fs_NextFloppy	18	dd fs_NextFloppy
19	db 3,'hd0'	19	db 3,'hd0'
20	dd fs_OnHd0	20	dd fs_OnHd0
21	dd fs_NextHd0	21	dd fs_NextHd0
22	db 3,'hd1'	22	db 3,'hd1'
23	dd fs_OnHd1	23	dd fs_OnHd1
24	dd fs_NextHd1	24	dd fs_NextHd1
25	db 3,'hd2'	25	db 3,'hd2'
26	dd fs_OnHd2	26	dd fs_OnHd2
27	dd fs_NextHd2	27	dd fs_NextHd2
28	db 3,'hd3'	28	db 3,'hd3'
29	dd fs_OnHd3	29	dd fs_OnHd3
30	dd fs_NextHd3	30	dd fs_NextHd3
31	;**********************************************	31	;**********************************************
32	db 3,'cd0'	32	db 3,'cd0'
33	dd fs_OnCd0	33	dd fs_OnCd0
34	dd fs_NextCd	34	dd fs_NextCd
35	db 3,'cd1'	35	db 3,'cd1'
36	dd fs_OnCd1	36	dd fs_OnCd1
37	dd fs_NextCd	37	dd fs_NextCd
38	db 3,'cd2'	38	db 3,'cd2'
39	dd fs_OnCd2	39	dd fs_OnCd2
40	dd fs_NextCd	40	dd fs_NextCd
41	db 3,'cd3'	41	db 3,'cd3'
42	dd fs_OnCd3	42	dd fs_OnCd3
43	dd fs_NextCd	43	dd fs_NextCd
44	;***********************************************	44	;***********************************************
45	db 0	45	db 0
46		46
47		47
48	virtual_root_query:	48	virtual_root_query:
49	dd fs_HasRamdisk	49	dd fs_HasRamdisk
50	db 'rd',0	50	db 'rd',0
51	dd fs_HasFloppy	51	dd fs_HasFloppy
52	db 'fd',0	52	db 'fd',0
53	dd fs_HasHd0	53	dd fs_HasHd0
54	db 'hd0',0	54	db 'hd0',0
55	dd fs_HasHd1	55	dd fs_HasHd1
56	db 'hd1',0	56	db 'hd1',0
57	dd fs_HasHd2	57	dd fs_HasHd2
58	db 'hd2',0	58	db 'hd2',0
59	dd fs_HasHd3	59	dd fs_HasHd3
60	db 'hd3',0	60	db 'hd3',0
61	;**********************************************	61	;**********************************************
62	dd fs_HasCd0	62	dd fs_HasCd0
63	db 'cd0',0	63	db 'cd0',0
64	dd fs_HasCd1	64	dd fs_HasCd1
65	db 'cd1',0	65	db 'cd1',0
66	dd fs_HasCd2	66	dd fs_HasCd2
67	db 'cd2',0	67	db 'cd2',0
68	dd fs_HasCd3	68	dd fs_HasCd3
69	db 'cd3',0	69	db 'cd3',0
70	;**********************************************	70	;**********************************************
71	dd 0	71	dd 0
72	endg	72	endg
73		73
74	file_system_lfn:	74	file_system_lfn:
75	; in: eax->fileinfo block	75	; in: eax->fileinfo block
76	; operation codes:	76	; operation codes:
77	; 0 : read file	77	; 0 : read file
78	; 1 : read folder	78	; 1 : read folder
79	; 2 : create/rewrite file	79	; 2 : create/rewrite file
80	; 3 : write/append to file	80	; 3 : write/append to file
81	; 4 : set end of file	81	; 4 : set end of file
82	; 5 : get file/directory attributes structure	82	; 5 : get file/directory attributes structure
83	; 6 : set file/directory attributes structure	83	; 6 : set file/directory attributes structure
84	; 7 : start application	84	; 7 : start application
85	; 8 : delete file	85	; 8 : delete file
86	; 9 : create directory	86	; 9 : create directory
87		87
88	; add eax, std_application_base_address	88	; add eax, std_application_base_address
89	; parse file name	89	; parse file name
90	xchg ebx, eax	90	xchg ebx, eax
91	lea esi, [ebx+20]	91	lea esi, [ebx+20]
92	mov ebp, esi ; for 'start app' function full path must be known	92	mov ebp, esi ; for 'start app' function full path must be known
93	lodsb	93	lodsb
94	test al, al	94	test al, al
95	jnz @f	95	jnz @f
96	mov esi, [esi]	96	mov esi, [esi]
97	; add esi, std_application_base_address	97	; add esi, std_application_base_address
98	mov ebp, esi	98	mov ebp, esi
99	lodsb	99	lodsb
100	@@:	100	@@:
101	cmp dword [ebx], 7	101	cmp dword [ebx], 7
102	jne @F	102	jne @F
103	mov edx, [ebx+4]	103	mov edx, [ebx+4]
104	mov ebx, [ebx+8]	104	mov ebx, [ebx+8]
105	test ebx, ebx	105	test ebx, ebx
106	jz .l1	106	jz .l1
107	; add ebx, new_app_base	107	; add ebx, new_app_base
108	.l1:	108	.l1:
109	call fs_execute ; ebp, ebx, edx	109	call fs_execute ; ebp, ebx, edx
110	mov [esp+36], eax	110	mov [esp+36], eax
111	ret	111	ret
112	@@:	112	@@:
113	cmp al, '/'	113	cmp al, '/'
114	jz @f	114	jz @f
115	.notfound:	115	.notfound:
116	mov dword [esp+36], 5 ; file not found	116	mov dword [esp+36], 5 ; file not found
117	ret	117	ret
118	@@:	118	@@:
119	cmp byte [esi], 0	119	cmp byte [esi], 0
120	jz .rootdir	120	jz .rootdir
121	mov edi, rootdirs-8	121	mov edi, rootdirs-8
122	xor ecx, ecx	122	xor ecx, ecx
123	push esi	123	push esi
124	.scan1:	124	.scan1:
125	pop esi	125	pop esi
126	add edi, ecx	126	add edi, ecx
127	scasd	127	scasd
128	scasd	128	scasd
129	mov cl, byte [edi]	129	mov cl, byte [edi]
130	jecxz .notfound	130	jecxz .notfound
131	inc edi	131	inc edi
132	push esi	132	push esi
133	@@:	133	@@:
134	lodsb	134	lodsb
135	or al, 20h	135	or al, 20h
136	scasb	136	scasb
137	loopz @b	137	loopz @b
138	jnz .scan1	138	jnz .scan1
139	lodsb	139	lodsb
140	cmp al, '/'	140	cmp al, '/'
141	jz .found1	141	jz .found1
142	test al, al	142	test al, al
143	jnz .scan1	143	jnz .scan1
144	pop eax	144	pop eax
145	; directory /xxx	145	; directory /xxx
146	.maindir:	146	.maindir:
147	cmp dword [ebx], 1	147	cmp dword [ebx], 1
148	jnz .access_denied	148	jnz .access_denied
149	xor eax, eax	149	xor eax, eax
150	mov ebp, [ebx+12]	150	mov ebp, [ebx+12]
151	mov edx, [ebx+16]	151	mov edx, [ebx+16]
152	; add edx, std_application_base_address	152	; add edx, std_application_base_address
153	push dword [ebx+4] ; first block	153	push dword [ebx+4] ; first block
154	mov ebx, [ebx+8] ; flags	154	mov ebx, [ebx+8] ; flags
155	mov esi, [edi+4]	155	mov esi, [edi+4]
156	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler	156	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
157	mov edi, edx	157	mov edi, edx
158	mov ecx, 32/4	158	mov ecx, 32/4
159	rep stosd	159	rep stosd
160	mov byte [edx], 1 ; version	160	mov byte [edx], 1 ; version
161	.maindir_loop:	161	.maindir_loop:
162	call esi	162	call esi
163	jc .maindir_done	163	jc .maindir_done
164	inc dword [edx+8]	164	inc dword [edx+8]
165	dec dword [esp]	165	dec dword [esp]
166	jns .maindir_loop	166	jns .maindir_loop
167	dec ebp	167	dec ebp
168	js .maindir_loop	168	js .maindir_loop
169	inc dword [edx+4]	169	inc dword [edx+4]
170	mov dword [edi], 0x10 ; attributes: folder	170	mov dword [edi], 0x10 ; attributes: folder
171	mov dword [edi+4], 1 ; name type: UNICODE	171	mov dword [edi+4], 1 ; name type: UNICODE
172	push eax	172	push eax
173	xor eax, eax	173	xor eax, eax
174	add edi, 8	174	add edi, 8
175	mov ecx, 40/4-2	175	mov ecx, 40/4-2
176	rep stosd	176	rep stosd
177	pop eax	177	pop eax
178	push eax edx	178	push eax edx
179	; convert number in eax to decimal UNICODE string	179	; convert number in eax to decimal UNICODE string
180	push edi	180	push edi
181	push -'0'	181	push -'0'
182	mov cl, 10	182	mov cl, 10
183	@@:	183	@@:
184	xor edx, edx	184	xor edx, edx
185	div ecx	185	div ecx
186	push edx	186	push edx
187	test eax, eax	187	test eax, eax
188	jnz @b	188	jnz @b
189	@@:	189	@@:
190	pop eax	190	pop eax
191	add al, '0'	191	add al, '0'
192	stosb	192	stosb
193	test bl, 1 ; UNICODE name?	193	test bl, 1 ; UNICODE name?
194	jz .ansi2	194	jz .ansi2
195	mov byte [edi], 0	195	mov byte [edi], 0
196	inc edi	196	inc edi
197	.ansi2:	197	.ansi2:
198	test al, al	198	test al, al
199	jnz @b	199	jnz @b
200	mov byte [edi-1], 0	200	mov byte [edi-1], 0
201	pop edi	201	pop edi
202	; UNICODE name length is 520 bytes, ANSI - 264	202	; UNICODE name length is 520 bytes, ANSI - 264
203	add edi, 520	203	add edi, 520
204	test bl, 1	204	test bl, 1
205	jnz @f	205	jnz @f
206	sub edi, 520-264	206	sub edi, 520-264
207	@@:	207	@@:
208	pop edx eax	208	pop edx eax
209	jmp .maindir_loop	209	jmp .maindir_loop
210	.maindir_done:	210	.maindir_done:
211	pop eax	211	pop eax
212	mov ebx, [edx+4]	212	mov ebx, [edx+4]
213	xor eax, eax	213	xor eax, eax
214	dec ebp	214	dec ebp
215	js @f	215	js @f
216	mov al, ERROR_END_OF_FILE	216	mov al, ERROR_END_OF_FILE
217	@@:	217	@@:
218	mov [esp+36], eax	218	mov [esp+36], eax
219	mov [esp+24], ebx	219	mov [esp+24], ebx
220	ret	220	ret
221	; directory /	221	; directory /
222	.rootdir:	222	.rootdir:
223	cmp dword [ebx], 1 ; read folder?	223	cmp dword [ebx], 1 ; read folder?
224	jz .readroot	224	jz .readroot
225	.access_denied:	225	.access_denied:
226	mov dword [esp+36], 10 ; access denied	226	mov dword [esp+36], 10 ; access denied
227	ret	227	ret
228		228
229	.readroot:	229	.readroot:
230	; virtual root folder - special handler	230	; virtual root folder - special handler
231	mov esi, virtual_root_query	231	mov esi, virtual_root_query
232	mov ebp, [ebx+12]	232	mov ebp, [ebx+12]
233	mov edx, [ebx+16]	233	mov edx, [ebx+16]
234	; add edx, std_application_base_address	234	; add edx, std_application_base_address
235	push dword [ebx+4] ; first block	235	push dword [ebx+4] ; first block
236	mov ebx, [ebx+8] ; flags	236	mov ebx, [ebx+8] ; flags
237	xor eax, eax	237	xor eax, eax
238	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area	238	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
239	mov edi, edx	239	mov edi, edx
240	mov ecx, 32/4	240	mov ecx, 32/4
241	rep stosd	241	rep stosd
242	mov byte [edx], 1 ; version	242	mov byte [edx], 1 ; version
243	.readroot_loop:	243	.readroot_loop:
244	cmp dword [esi], eax	244	cmp dword [esi], eax
245	jz .readroot_done	245	jz .readroot_done
246	call dword [esi]	246	call dword [esi]
247	add esi, 4	247	add esi, 4
248	test eax, eax	248	test eax, eax
249	jnz @f	249	jnz @f
250	.readroot_next:	250	.readroot_next:
251	or ecx, -1	251	or ecx, -1
252	xchg esi, edi	252	xchg esi, edi
253	repnz scasb	253	repnz scasb
254	xchg esi, edi	254	xchg esi, edi
255	jmp .readroot_loop	255	jmp .readroot_loop
256	@@:	256	@@:
257	xor eax, eax	257	xor eax, eax
258	inc dword [edx+8]	258	inc dword [edx+8]
259	dec dword [esp]	259	dec dword [esp]
260	jns .readroot_next	260	jns .readroot_next
261	dec ebp	261	dec ebp
262	js .readroot_next	262	js .readroot_next
263	inc dword [edx+4]	263	inc dword [edx+4]
264	mov dword [edi], 0x10 ; attributes: folder	264	mov dword [edi], 0x10 ; attributes: folder
265	mov dword [edi+4], 1 ; name type: UNICODE	265	mov dword [edi+4], 1 ; name type: UNICODE
266	add edi, 8	266	add edi, 8
267	mov ecx, 40/4-2	267	mov ecx, 40/4-2
268	rep stosd	268	rep stosd
269	push edi	269	push edi
270	@@:	270	@@:
271	lodsb	271	lodsb
272	stosb	272	stosb
273	test bl, 1	273	test bl, 1
274	jz .ansi	274	jz .ansi
275	mov byte [edi], 0	275	mov byte [edi], 0
276	inc edi	276	inc edi
277	.ansi:	277	.ansi:
278	test eax, eax	278	test eax, eax
279	jnz @b	279	jnz @b
280	pop edi	280	pop edi
281	add edi, 520	281	add edi, 520
282	test bl, 1	282	test bl, 1
283	jnz .readroot_loop	283	jnz .readroot_loop
284	sub edi, 520-264	284	sub edi, 520-264
285	jmp .readroot_loop	285	jmp .readroot_loop
286	.readroot_done:	286	.readroot_done:
287	pop eax	287	pop eax
288	mov ebx, [edx+4]	288	mov ebx, [edx+4]
289	xor eax, eax	289	xor eax, eax
290	dec ebp	290	dec ebp
291	js @f	291	js @f
292	mov al, ERROR_END_OF_FILE	292	mov al, ERROR_END_OF_FILE
293	@@:	293	@@:
294	mov [esp+36], eax	294	mov [esp+36], eax
295	mov [esp+24], ebx	295	mov [esp+24], ebx
296	ret	296	ret
297		297
298	.found1:	298	.found1:
299	pop eax	299	pop eax
300	cmp byte [esi], 0	300	cmp byte [esi], 0
301	jz .maindir	301	jz .maindir
302	; read partition number	302	; read partition number
303	xor ecx, ecx	303	xor ecx, ecx
304	xor eax, eax	304	xor eax, eax
305	@@:	305	@@:
306	lodsb	306	lodsb
307	cmp al, '/'	307	cmp al, '/'
308	jz .done1	308	jz .done1
309	test al, al	309	test al, al
310	jz .done1	310	jz .done1
311	sub al, '0'	311	sub al, '0'
312	cmp al, 9	312	cmp al, 9
313	ja .notfound	313	ja .notfound
314	imul ecx, 10	314	imul ecx, 10
315	add ecx, eax	315	add ecx, eax
316	jmp @b	316	jmp @b
317	.done1:	317	.done1:
318	test ecx, ecx	318	test ecx, ecx
319	jz .notfound	319	jz .notfound
320	test al, al	320	test al, al
321	jnz @f	321	jnz @f
322	dec esi	322	dec esi
323	@@:	323	@@:
324	; now [edi] contains handler address, ecx - partition number,	324	; now [edi] contains handler address, ecx - partition number,
325	; esi points to ASCIIZ string - rest of name	325	; esi points to ASCIIZ string - rest of name
326	jmp dword [edi]	326	jmp dword [edi]
327		327
328	; handlers for devices	328	; handlers for devices
329	; in: ecx = 0 => query virtual directory /xxx	329	; in: ecx = 0 => query virtual directory /xxx
330	; in: ecx = partition number	330	; in: ecx = partition number
331	; esi -> relative (for device) name	331	; esi -> relative (for device) name
332	; ebx -> fileinfo	332	; ebx -> fileinfo
333	; out: [esp+36]=image of eax, [esp+24]=image of ebx	333	; out: [esp+36]=image of eax, [esp+24]=image of ebx
334		334
335	fs_OnRamdisk:	335	fs_OnRamdisk:
336	cmp ecx, 1	336	cmp ecx, 1
337	jnz file_system_lfn.notfound	337	jnz file_system_lfn.notfound
338	mov eax, [ebx]	338	mov eax, [ebx]
339	cmp eax, fs_NumRamdiskServices	339	cmp eax, fs_NumRamdiskServices
340	jae .not_impl	340	jae .not_impl
341	mov ecx, [ebx+12]	341	mov ecx, [ebx+12]
342	mov edx, [ebx+16]	342	mov edx, [ebx+16]
343	; add edx, std_application_base_address	343	; add edx, std_application_base_address
344	add ebx, 4	344	add ebx, 4
345	call dword [fs_RamdiskServices + eax*4]	345	call dword [fs_RamdiskServices + eax*4]
346	mov [esp+36], eax	346	mov [esp+36], eax
347	mov [esp+24], ebx	347	mov [esp+24], ebx
348	ret	348	ret
349	.not_impl:	349	.not_impl:
350	mov dword [esp+36], 2 ; not implemented	350	mov dword [esp+36], 2 ; not implemented
351	ret	351	ret
352		352
353	fs_NotImplemented:	353	fs_NotImplemented:
354	mov eax, 2	354	mov eax, 2
355	ret	355	ret
356		356
357	fs_RamdiskServices:	357	fs_RamdiskServices:
358	dd fs_RamdiskRead	358	dd fs_RamdiskRead
359	dd fs_RamdiskReadFolder	359	dd fs_RamdiskReadFolder
360	dd fs_RamdiskRewrite	360	dd fs_RamdiskRewrite
361	dd fs_RamdiskWrite	361	dd fs_RamdiskWrite
362	dd fs_RamdiskSetFileEnd	362	dd fs_RamdiskSetFileEnd
363	dd fs_RamdiskGetFileInfo	363	dd fs_RamdiskGetFileInfo
364	dd fs_RamdiskSetFileInfo	364	dd fs_RamdiskSetFileInfo
365	dd 0 ;fs_RamdiskExecute	365	dd 0 ;fs_RamdiskExecute
366	dd fs_RamdiskDelete	366	dd fs_RamdiskDelete
367	dd fs_RamdiskCreateFolder	367	dd fs_RamdiskCreateFolder
368	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4	368	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
369		369
370	fs_OnFloppy:	370	fs_OnFloppy:
371	cmp ecx, 2	371	cmp ecx, 2
372	ja file_system_lfn.notfound	372	ja file_system_lfn.notfound
373	mov eax, [ebx]	373	mov eax, [ebx]
374	cmp eax, fs_NumFloppyServices	374	cmp eax, fs_NumFloppyServices
375	jae fs_OnRamdisk.not_impl	375	jae fs_OnRamdisk.not_impl
376	call reserve_flp	376	call reserve_flp
377	mov [flp_number], cl	377	mov [flp_number], cl
378	mov ecx, [ebx+12]	378	mov ecx, [ebx+12]
379	mov edx, [ebx+16]	379	mov edx, [ebx+16]
380	; add edx, std_application_base_address	380	; add edx, std_application_base_address
381	add ebx, 4	381	add ebx, 4
382	call dword [fs_FloppyServices + eax*4]	382	call dword [fs_FloppyServices + eax*4]
383	and [flp_status], 0	383	and [flp_status], 0
384	mov [esp+36], eax	384	mov [esp+36], eax
385	mov [esp+24], ebx	385	mov [esp+24], ebx
386	ret	386	ret
387		387
388	fs_FloppyServices:	388	fs_FloppyServices:
389	dd fs_FloppyRead	389	dd fs_FloppyRead
390	dd fs_FloppyReadFolder	390	dd fs_FloppyReadFolder
391	dd fs_FloppyRewrite	391	dd fs_FloppyRewrite
392	dd fs_FloppyWrite	392	dd fs_FloppyWrite
393	dd fs_FloppySetFileEnd	393	dd fs_FloppySetFileEnd
394	dd fs_FloppyGetFileInfo	394	dd fs_FloppyGetFileInfo
395	dd fs_FloppySetFileInfo	395	dd fs_FloppySetFileInfo
396	dd 0 ;fs_FloppyExecute	396	dd 0 ;fs_FloppyExecute
397	dd fs_FloppyDelete	397	dd fs_FloppyDelete
398	dd fs_FloppyCreateFolder	398	dd fs_FloppyCreateFolder
399	fs_NumFloppyServices = ($ - fs_FloppyServices)/4	399	fs_NumFloppyServices = ($ - fs_FloppyServices)/4
400		400
401	fs_OnHd0:	401	fs_OnHd0:
402	call reserve_hd1	402	call reserve_hd1
403	mov [hdbase], 0x1F0	403	mov [hdbase], 0x1F0
404	mov [hdid], 0	404	mov [hdid], 0
405	push 1	405	push 1
406	jmp fs_OnHd	406	jmp fs_OnHd
407	fs_OnHd1:	407	fs_OnHd1:
408	call reserve_hd1	408	call reserve_hd1
409	mov [hdbase], 0x1F0	409	mov [hdbase], 0x1F0
410	mov [hdid], 0x10	410	mov [hdid], 0x10
411	push 2	411	push 2
412	jmp fs_OnHd	412	jmp fs_OnHd
413	fs_OnHd2:	413	fs_OnHd2:
414	call reserve_hd1	414	call reserve_hd1
415	mov [hdbase], 0x170	415	mov [hdbase], 0x170
416	mov [hdid], 0	416	mov [hdid], 0
417	push 3	417	push 3
418	jmp fs_OnHd	418	jmp fs_OnHd
419	fs_OnHd3:	419	fs_OnHd3:
420	call reserve_hd1	420	call reserve_hd1
421	mov [hdbase], 0x170	421	mov [hdbase], 0x170
422	mov [hdid], 0x10	422	mov [hdid], 0x10
423	push 4	423	push 4
424	fs_OnHd:	424	fs_OnHd:
425	call reserve_hd_channel	425	call reserve_hd_channel
426	pop eax	426	pop eax
427	mov [hdpos], eax	427	mov [hdpos], eax
428	cmp ecx, 0x100	428	cmp ecx, 0x100
429	jae .nf	429	jae .nf
430	cmp cl, [DRIVE_DATA+eax]	430	cmp cl, [DRIVE_DATA+1+eax]
431	jbe @f	431	jbe @f
432	.nf:	432	.nf:
433	call free_hd_channel	433	call free_hd_channel
434	and [hd1_status], 0	434	and [hd1_status], 0
435	mov dword [esp+36], 5 ; not found	435	mov dword [esp+36], 5 ; not found
436	ret	436	ret
437	@@:	437	@@:
438	mov [fat32part], ecx	438	mov [fat32part], ecx
439	push ebx esi	439	push ebx esi
440	call choice_necessity_partition_1	440	call choice_necessity_partition_1
441	pop esi ebx	441	pop esi ebx
442	mov ecx, [ebx+12]	442	mov ecx, [ebx+12]
443	mov edx, [ebx+16]	443	mov edx, [ebx+16]
444	; add edx, std_application_base_address	444	; add edx, std_application_base_address
445	mov eax, [ebx]	445	mov eax, [ebx]
446	cmp eax, fs_NumHdServices	446	cmp eax, fs_NumHdServices
447	jae .not_impl	447	jae .not_impl
448	add ebx, 4	448	add ebx, 4
449	call dword [fs_HdServices + eax*4]	449	call dword [fs_HdServices + eax*4]
450	call free_hd_channel	450	call free_hd_channel
451	and [hd1_status], 0	451	and [hd1_status], 0
452	mov [esp+36], eax	452	mov [esp+36], eax
453	mov [esp+24], ebx	453	mov [esp+24], ebx
454	ret	454	ret
455	.not_impl:	455	.not_impl:
456	call free_hd_channel	456	call free_hd_channel
457	and [hd1_status], 0	457	and [hd1_status], 0
458	mov dword [esp+36], 2 ; not implemented	458	mov dword [esp+36], 2 ; not implemented
459	ret	459	ret
460		460
461	fs_HdServices:	461	fs_HdServices:
462	dd fs_HdRead	462	dd fs_HdRead
463	dd fs_HdReadFolder	463	dd fs_HdReadFolder
464	dd fs_HdRewrite	464	dd fs_HdRewrite
465	dd fs_HdWrite	465	dd fs_HdWrite
466	dd fs_HdSetFileEnd	466	dd fs_HdSetFileEnd
467	dd fs_HdGetFileInfo	467	dd fs_HdGetFileInfo
468	dd fs_HdSetFileInfo	468	dd fs_HdSetFileInfo
469	dd 0 ;fs_HdExecute	469	dd 0 ;fs_HdExecute
470	dd fs_HdDelete	470	dd fs_HdDelete
471	dd fs_HdCreateFolder	471	dd fs_HdCreateFolder
472	fs_NumHdServices = ($ - fs_HdServices)/4	472	fs_NumHdServices = ($ - fs_HdServices)/4
473		473
474	;*******************************************************	474	;*******************************************************
475	fs_OnCd0:	475	fs_OnCd0:
476	call reserve_cd	476	call reserve_cd
477	mov [ChannelNumber],1	477	mov [ChannelNumber],1
478	mov [DiskNumber],0	478	mov [DiskNumber],0
479	push 6	479	push 6
480	jmp fs_OnCd	480	jmp fs_OnCd
481	fs_OnCd1:	481	fs_OnCd1:
482	call reserve_cd	482	call reserve_cd
483	mov [ChannelNumber],1	483	mov [ChannelNumber],1
484	mov [DiskNumber],1	484	mov [DiskNumber],1
485	push 4	485	push 4
486	jmp fs_OnCd	486	jmp fs_OnCd
487	fs_OnCd2:	487	fs_OnCd2:
488	call reserve_cd	488	call reserve_cd
489	mov [ChannelNumber],2	489	mov [ChannelNumber],2
490	mov [DiskNumber],0	490	mov [DiskNumber],0
491	push 2	491	push 2
492	jmp fs_OnCd	492	jmp fs_OnCd
493	fs_OnCd3:	493	fs_OnCd3:
494	call reserve_cd	494	call reserve_cd
495	mov [ChannelNumber],2	495	mov [ChannelNumber],2
496	mov [DiskNumber],1	496	mov [DiskNumber],1
497	push 0	497	push 0
498	fs_OnCd:	498	fs_OnCd:
499	call reserve_cd_channel	499	call reserve_cd_channel
500	pop eax	500	pop eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/fs/fs_lfn.inc – Rev 419 → 432