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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6502 $
 
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_FS_FAIL        = 9
ERROR_ACCESS_DENIED  = 10
ERROR_DEVICE         = 11
ERROR_OUT_OF_MEMORY  = 12
 
maxPathLength = 1000h
 
image_of_eax EQU esp+32
image_of_ebx EQU esp+20
 
; System function 70
 
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 -> parameter structure
;   operation codes:
; 0 = read file
; 1 = read folder
; 2 = create/rewrite file
; 3 = write/append to file
; 4 = set file end
; 5 = get file info
; 6 = set file info
; start application
; 8 = delete file/folder
; 9 = create folder
        lea     ebp, [ebx+20]
        cmp     byte [ebp], 0
        jnz     @f
        mov     ebp, [ebx+21]
@@:
        cmp     word [ebp], '/'
        jz      .rootdir
        cmp     byte [ebp], 4
        jnc     @f
        cmp     byte [ebp], 0
        jz      @f
        cmp     word [ebp+1], '/'
        jnz     @f
        cmp     byte [ebp], 2
        jnz     .rootdir
        cmp     word [ebp+3], 0
        jz      .rootdir
@@:
        cmp     dword[ebx], 7   ; start application
        jnz     @f
        mov     edx, [ebx+4]
        mov     ebx, [ebx+8]
        call    fs_execute      ; ebp, ebx, edx
        mov     [image_of_eax], eax
        ret
 
@@:
 
 
 
 
 
 
 
        stdcall kernel_alloc, maxPathLength
        push    ebx
        mov     ebx, ebp
        mov     ebp, eax
 
 
        stdcall get_full_file_name, eax, maxPathLength
        pop     ebx
        test    eax, eax
        jz      .notfound
        lea     esi, [ebp+2]
        mov     ax, [esi]
        or      ax, 2020h
        cmp     ax, 'cd'
        jz      .CD
        call    dyndisk_handler ; not returns if success
.notfound:
        stdcall kernel_free, ebp
        mov     dword[image_of_eax], ERROR_FILE_NOT_FOUND
        ret
 
.CD:
        add     esi, 2
        xor     eax, eax
        lodsb       ; disk number
        sub     eax, '0'
        cmp     eax, 10
        jnc     .notfound
        mov     edi, eax
        lodsb
        test    eax, eax
        jz      .maindir
        cmp     al, '/'
        jnz     .notfound
        lodsb       ; partition number
        test    eax, eax
        jz      .maindir
        cmp     al, '1'
        jnz     .notfound
        cmp     byte [esi], '/'
        jnz     @f
        inc     esi
@@:
        call    reserve_cd
        mov     eax, edi
        bt      eax, 0
        setc    [DiskNumber]
        bt      eax, 1
        setc    [ChannelNumber]
        inc     [ChannelNumber]
        inc     eax
        mov     [cdpos], eax
        call    reserve_cd_channel
        mov     eax, edi
        not     eax
        and     eax, 3
        shl     eax, 1
        inc     eax
        shr     edi, 2
        mov     dword[image_of_eax], ERROR_FILE_NOT_FOUND
        bt      [edi*5+DRIVE_DATA+1], ax
        jnc     @f
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        mov     eax, [ebx]
        mov     dword[image_of_eax], ERROR_UNSUPPORTED_FS
        cmp     eax, fs_NumCdServices
        jae     @f
        add     ebx, 4
        call    dword[fs_CdServices + eax*4]
        mov     [image_of_eax], eax
        mov     [image_of_ebx], ebx
@@:
        call    free_cd_channel
        and     [cd_status], 0
        stdcall kernel_free, ebp
        ret
 
.nextCD:
        test    eax, eax    ; partition number
        stc
        jnz     @f      ; no more partitions
        mov     al, 1   ; /cdX/1
        clc
@@:
        ret
 
.maindir:   ; list partitions
        mov     esi, .nextCD
.maindir_noesi:     ; backjump from dyndisk_handler
        push    ebp
        mov     ebp, ecx
        call    kernel_free
        cmp     dword[ebx], 1
        jnz     .access_denied  ; read folder?
        push    ebp
        pushd   [ebx+4]         ; first block
        mov     ebp, [ebx+12]   ; the number of blocks to read
        mov     edx, [ebx+16]   ; buffer
        mov     ebx, [ebx+8]    ; flags
        mov     ecx, 32/4
        mov     edi, edx
        xor     eax, eax
        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], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        push    eax
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        pop     eax
        push    eax edx edi
; convert number in eax to decimal string
        push    -'0'
        mov     ecx, 10
@@:
        xor     edx, edx
        div     ecx
        push    edx
        test    eax, eax
        jnz     @b
        cmp     ebx, 1
        jz      .uni
@@:
        pop     eax
        add     eax, '0'
        stosb
        test    eax, eax
        jnz     @b
        pop     edi edx eax
        add     edi, 264
        jmp     .maindir_loop
 
.uni:
        pop     eax
        add     eax, '0'
        stosw
        test    eax, eax
        jnz     .uni
        pop     edi edx eax
        add     edi, 520
        jmp     .maindir_loop
 
.maindir_done:
        pop     eax 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
 
.access_denied:
        mov     dword[image_of_eax], ERROR_ACCESS_DENIED
        ret
 
.rootdir:   ; / - virtual root folder
        cmp     dword[ebx], 1   ; read folder?
        jnz     .access_denied
        mov     ebp, [ebx+12]   ; number of blocks
        mov     edx, [ebx+16]   ; return area
        push    dword[ebx+4]    ; first block
        mov     ebx, [ebx+8]    ; flags
        mov     ecx, 32/4
        mov     edi, edx
        xor     eax, eax
        rep stosd
        mov     byte [edx], 1   ; version
        sub     esp, 16
.rootdir_loop:
        push    edi
        lea     edi, [esp+4]
        call    dyndisk_enum_root
        pop     edi
        test    eax, eax
        jz      .rootdirCD
        inc     dword[edx+8]
        dec     dword[esp+16]
        jns     .rootdir_loop
        dec     ebp
        js      .rootdir_loop
        inc     dword[edx+4]
        mov     dword[edi], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        push    eax
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        push    edi
        lea     esi, [esp+8]
        cmp     ebx, 1
        jz      .uni2
@@:
        lodsb
        stosb
        test    eax, eax
        jnz     @b
        pop     edi eax
        add     edi, 264
        jmp     .rootdir_loop
 
.uni2:
        lodsb
        stosw
        test    eax, eax
        jnz     .uni2
        pop     edi eax
        add     edi, 520
        jmp     .rootdir_loop
 
.rootdirCD:
        add     esp, 16
        or      esi, -1
.rootdirCD_loop:
        inc     esi
        cmp     esi, 10
        jnc     .rootdir_done
        mov     eax, esi
        not     eax
        and     eax, 3
        shl     eax, 1
        inc     eax
        mov     ecx, esi
        shr     ecx, 2
        bt      [ecx*5+DRIVE_DATA+1], ax
        jnc     .rootdirCD_loop
        inc     dword[edx+8]
        dec     dword[esp]
        jns     .rootdirCD_loop
        dec     ebp
        js      .rootdirCD_loop
        inc     dword[edx+4]
        mov     dword[edi], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        mov     eax, esi
        add     eax, '0'
        cmp     ebx, 1
        jz      @f
        mov     word [edi], 'cd'
        mov     [edi+2], ax
        add     edi, 264
        jmp     .rootdirCD_loop
 
@@:
        mov     dword[edi], 640063h
        mov     [edi+4], eax
        add     edi, 520
        jmp     .rootdirCD_loop
 
.rootdir_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
 
;-----------------------------------------------------------------------------
process_replace_file_name:
; in: [esi] = virtual path
; out: [esi]+[ebp] = physical path
        xor     edi, edi
        xor     ebp, ebp
.loop:
        cmp     edi, [full_file_name_table.size]
        jae     .notfound
        push    esi edi
        shl     edi, 7
        add     edi, [full_file_name_table]
@@:
        cmp     byte [edi], 0
        jz      .dest_done
        lodsb
        test    al, al
        jz      .cont
        or      al, 20h
        scasb
        jz      @b
.cont:
        pop     edi esi
        inc     edi
        jmp     .loop
 
.dest_done:
        cmp     byte [esi], 0
        jz      .found
        cmp     byte [esi], '/'
        jnz     .cont
.found:
        pop     edi eax
        shl     edi, 7
        add     edi, [full_file_name_table]
        mov     ebp, esi
        lea     esi, [edi+64]
.notfound:
        ret
 
;-----------------------------------------------------------------------------
uglobal
addDirSeal db  ?
endg
 
sys_current_directory:  ; sysfunction 30
        mov     eax, [current_slot]
        mov     edi, [eax+APPDATA.cur_dir]
        dec     ebx
        jz      .set
        dec     ebx
        jz      .get
        dec     ebx
        jz      .mount_additional_directory
        dec     ebx
        jz      .get16
@@:
        ret
 
.mount_additional_directory:
; in: ecx -> dir name+dir path (128)
        mov     al, 1
        xchg    [addDirSeal], al
        test    al, al
        jnz     @b
        mov     esi, ecx
        mov     edi, sysdir_name1
        mov     ecx, 63
        rep movsb   ; copying fake directory name
        inc     esi
        xor     eax, eax
        stosb       ; terminator of name, in case if we get the inlet trash
        mov     cl, 63
        cmp     word [esi], 2
        jz      .utf16
        call    cp866toUTF8_string
@@:
        mov     byte [edi], 0
        mov     [full_file_name_table.size], 2
        ret
 
.utf16:
        add     esi, 2
        call    UTF16to8_string
        jmp     @b
 
.get:       ; in: ecx -> buffer, edx = length
        mov     esi, edi
        mov     edi, ecx
        cmp     edx, maxPathLength
        jc      @f
        mov     edx, maxPathLength
@@:
        mov     al, '/'
        stosb
        mov     ecx, edx
        dec     ecx
@@:
        dec     ecx
        js      @f
        call    utf8to16
        call    uni2ansi_char
        stosb
        test    al, al
        jnz     @b
        sub     edx, ecx
        mov     ecx, edx
@@:
        mov     [esp+32], ecx
        ret
 
.get16:
        mov     esi, edi
        mov     edi, ecx
        cmp     edx, maxPathLength
        jc      @f
        mov     edx, maxPathLength
@@:
        shr     edx, 1
        mov     ax, '/'
        stosw
        mov     ecx, edx
        dec     ecx
@@:
        dec     ecx
        js      @f
        call    utf8to16
        stosw
        test    ax, ax
        jnz     @b
        sub     edx, ecx
        mov     ecx, edx
@@:
        mov     [esp+32], ecx
        ret
 
.set:
        pop     eax
        push    maxPathLength
        push    edi
        push    eax
        mov     ebx, ecx
get_full_file_name:
; in: ebx -> file name, [esp+4] -> destination, [esp+8] = max length
; out: UTF-8 string, eax=0 -> out of length
        push    ebp ebx
        cmp     byte [ebx], 0
        jz      .set_relative
        mov     esi, ebx
        cmp     byte [ebx], 4
        jnc     @f
        inc     esi
@@:
        cmp     byte [esi], '/'
        jnz     .set_relative
        inc     esi
        cmp     byte [ebx], 2
        jnz     @f
        inc     esi
@@:
        call    process_replace_file_name
        mov     edi, [esp+12]
        mov     ecx, [esp+16]
        mov     al, 3
        mov     ah, '/'
        stosw
        sub     ecx, 2
        test    ebp, ebp
        jz      .absolute
@@:
        lodsb
        stosb
        dec     ecx
        test    al, al
        jnz     @b
        mov     esi, ebp
        dec     edi
.absolute:
        cmp     byte [ebx], 2
        jz      .utf16
        cmp     byte [ebx], 3
        jz      .utf8
        call    cp866toUTF8_string
        jns     .ret
        jmp     .fail
 
.utf8:
        dec     ecx
        js      .fail
        lodsb
        stosb
        test    al, al
        jz      .ret
        jmp     .utf8
 
.utf16:
        call    UTF16to8_string
        jns     .ret
.fail:
        mov     byte [edi], 0
        xor     eax, eax
        pop     ebx ebp
        ret     8
 
.set_relative:
        mov     edi, [current_slot]
        mov     edi, [edi+APPDATA.cur_dir]
        mov     edx, edi
        mov     ecx, [esp+16]
        xor     eax, eax
        repnz scasb
        mov     esi, edi
        dec     esi
        mov     edi, [esp+12]
        jecxz   .fail
        cmp     byte [ebx], 0
        jz      .set_ok
        cmp     byte [ebx], 4
        jnc     .relative
        inc     ebx
        cmp     byte [ebx-1], 2
        jz      .relative16
.relative:
        cmp     byte [ebx], 0
        jz      .set_ok
        cmp     word [ebx], '.'
        jz      .set_ok
        cmp     word [ebx], './'
        jz      .next
        cmp     word [ebx], '..'
        jnz     .doset_relative
        cmp     byte [ebx+2], 0
        jz      @f
        cmp     byte [ebx+2], '/'
        jnz     .doset_relative
        inc     ebx
@@:
        dec     esi
        cmp     byte [esi], '/'
        jnz     @b
.next:
        add     ebx, 2
        jmp     .relative
 
.set_ok:
        cmp     edx, edi    ; is destination equal to cur_dir?
        jz      @f
        mov     ecx, esi
        sub     ecx, edx
        mov     esi, edx
        rep movsb
        mov     byte [edi], 0
.ret:
        mov     al, 1
        pop     ebx ebp
        ret     8
 
@@:
        mov     byte [esi], 0
        jmp     .ret
 
.doset_relative:
        cmp     edx, edi    ; is destination equal to cur_dir?
        mov     edi, esi
        jz      @f
        mov     edi, [esp+12]
        mov     ecx, esi
        sub     ecx, edx
        mov     esi, edx
        mov     edx, edi
        rep movsb
@@:
        mov     byte [edi], '/'
        inc     edi
        mov     esi, ebx
        mov     ecx, edx
        add     ecx, [esp+16]
        sub     ecx, edi
        mov     ebx, [esp]
        jmp     .absolute
 
.relative16:
        cmp     word [ebx], 0
        jz      .set_ok
        cmp     word [ebx], '.'
        jnz     .doset_relative
        cmp     word [ebx+2], 0
        jz      .set_ok
        cmp     word [ebx+2], '/'
        jz      .next16
        cmp     word [ebx+2], '.'
        jnz     .doset_relative
        cmp     word [ebx+4], 0
        jz      @f
        cmp     word [ebx+4], '/'
        jnz     .doset_relative
        add     ebx, 2
@@:
        dec     esi
        cmp     byte [esi], '/'
        jnz     @b
.next16:
        add     ebx, 4
        jmp     .relative16
 
include "parse_fn.inc"
include "fs_common.inc"
include "iso9660.inc"   ; read for CD filesystem
include "fat.inc"
include "ntfs.inc"
include "ext.inc"
include "xfs.asm"

Rev 6471	Rev 6502
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2016. 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: 6471 $	8	$Revision: 6502 $
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_FS_FAIL = 9	19	ERROR_FS_FAIL = 9
20	ERROR_ACCESS_DENIED = 10	20	ERROR_ACCESS_DENIED = 10
21	ERROR_DEVICE = 11	21	ERROR_DEVICE = 11
22	ERROR_OUT_OF_MEMORY = 12	22	ERROR_OUT_OF_MEMORY = 12
23		23
24	maxPathLength = 1000h	24	maxPathLength = 1000h
25		25
26	image_of_eax EQU esp+32	26	image_of_eax EQU esp+32
27	image_of_ebx EQU esp+20	27	image_of_ebx EQU esp+20
28		28
29	; System function 70	29	; System function 70
30		30
31	file_system_lfn_protected:	31	file_system_lfn_protected:
32	pushad	32	pushad
33	call protect_from_terminate	33	call protect_from_terminate
34	call file_system_lfn	34	call file_system_lfn
35	call unprotect_from_terminate	35	call unprotect_from_terminate
36	popad	36	popad
37	mov [image_of_eax], eax	37	mov [image_of_eax], eax
38	mov [image_of_ebx], ebx	38	mov [image_of_ebx], ebx
39	ret	39	ret
40		40
41	file_system_lfn:	41	file_system_lfn:
42	; in: ebx -> parameter structure	42	; in: ebx -> parameter structure
43	; operation codes:	43	; operation codes:
44	; 0 = read file	44	; 0 = read file
45	; 1 = read folder	45	; 1 = read folder
46	; 2 = create/rewrite file	46	; 2 = create/rewrite file
47	; 3 = write/append to file	47	; 3 = write/append to file
48	; 4 = set file end	48	; 4 = set file end
49	; 5 = get file info	49	; 5 = get file info
50	; 6 = set file info	50	; 6 = set file info
51	; start application	51	; start application
52	; 8 = delete file/folder	52	; 8 = delete file/folder
53	; 9 = create folder	53	; 9 = create folder
54	lea ebp, [ebx+20]	54	lea ebp, [ebx+20]
55	cmp byte [ebp], 0	55	cmp byte [ebp], 0
56	jnz @f	56	jnz @f
57	mov ebp, [ebx+21]	57	mov ebp, [ebx+21]
58	@@:	58	@@:
-		59	cmp word [ebp], '/'
-		60	jz .rootdir
-		61	cmp byte [ebp], 4
-		62	jnc @f
-		63	cmp byte [ebp], 0
-		64	jz @f
-		65	cmp word [ebp+1], '/'
-		66	jnz @f
-		67	cmp byte [ebp], 2
-		68	jnz .rootdir
-		69	cmp word [ebp+3], 0
-		70	jz .rootdir
-		71	@@:
59	cmp dword[ebx], 7 ; start application	72	cmp dword[ebx], 7 ; start application
60	jne @f	73	jnz @f
61	mov edx, [ebx+4]	74	mov edx, [ebx+4]
62	mov ebx, [ebx+8]	75	mov ebx, [ebx+8]
63	call fs_execute ; ebp, ebx, edx	76	call fs_execute ; ebp, ebx, edx
64	mov [image_of_eax], eax	77	mov [image_of_eax], eax
65	ret	78	ret
66		79
67	@@:	80	@@:
68	cmp word [ebp], '/'	-
69	jz .rootdir	-
70	cmp byte [ebp], 2	-
71	jnz @f	-
72	cmp dword[ebp+1], '/'	-
73	jz .rootdir	-
74	@@:	-
75	stdcall kernel_alloc, maxPathLength	81	stdcall kernel_alloc, maxPathLength
76	push ebx	82	push ebx
77	mov ebx, ebp	83	mov ebx, ebp
78	mov ebp, eax	84	mov ebp, eax
79	push maxPathLength	-
80	push eax	-
81	call get_full_file_name	85	stdcall get_full_file_name, eax, maxPathLength
82	pop ebx	86	pop ebx
83	test eax, eax	87	test eax, eax
84	jz .notfound	88	jz .notfound
85	mov esi, ebp	89	lea esi, [ebp+2]
86	mov ax, [ebp]	90	mov ax, [esi]
87	or ax, 2020h	91	or ax, 2020h
88	cmp ax, 'cd'	92	cmp ax, 'cd'
89	jz .CD	93	jz .CD
90	call dyndisk_handler ; not returns if success	94	call dyndisk_handler ; not returns if success
91	.notfound:	95	.notfound:
92	stdcall kernel_free, ebp	96	stdcall kernel_free, ebp
93	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND	97	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND
94	ret	98	ret
95		99
96	.CD:	100	.CD:
97	add esi, 2	101	add esi, 2
98	xor eax, eax	102	xor eax, eax
99	lodsb ; disk number	103	lodsb ; disk number
100	sub eax, '0'	104	sub eax, '0'
101	cmp eax, 10	105	cmp eax, 10
102	jnc .notfound	106	jnc .notfound
103	mov edi, eax	107	mov edi, eax
104	lodsb	108	lodsb
105	test eax, eax	109	test eax, eax
106	jz .maindir	110	jz .maindir
107	cmp al, '/'	111	cmp al, '/'
108	jnz .notfound	112	jnz .notfound
109	lodsb ; partition number	113	lodsb ; partition number
110	test eax, eax	114	test eax, eax
111	jz .maindir	115	jz .maindir
112	cmp al, '1'	116	cmp al, '1'
113	jnz .notfound	117	jnz .notfound
114	cmp byte [esi], '/'	118	cmp byte [esi], '/'
115	jnz @f	119	jnz @f
116	inc esi	120	inc esi
117	@@:	121	@@:
118	call reserve_cd	122	call reserve_cd
119	mov eax, edi	123	mov eax, edi
120	bt eax, 0	124	bt eax, 0
121	setc [DiskNumber]	125	setc [DiskNumber]
122	bt eax, 1	126	bt eax, 1
123	setc [ChannelNumber]	127	setc [ChannelNumber]
124	inc [ChannelNumber]	128	inc [ChannelNumber]
125	inc eax	129	inc eax
126	mov [cdpos], eax	130	mov [cdpos], eax
127	call reserve_cd_channel	131	call reserve_cd_channel
128	mov eax, edi	132	mov eax, edi
129	not eax	133	not eax
130	and eax, 3	134	and eax, 3
131	shl eax, 1	135	shl eax, 1
132	inc eax	136	inc eax
133	shr edi, 2	137	shr edi, 2
134	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND	138	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND
135	bt [edi*5+DRIVE_DATA+1], ax	139	bt [edi*5+DRIVE_DATA+1], ax
136	jnc @f	140	jnc @f
137	mov ecx, [ebx+12]	141	mov ecx, [ebx+12]
138	mov edx, [ebx+16]	142	mov edx, [ebx+16]
139	mov eax, [ebx]	143	mov eax, [ebx]
140	mov dword[image_of_eax], ERROR_UNSUPPORTED_FS	144	mov dword[image_of_eax], ERROR_UNSUPPORTED_FS
141	cmp eax, fs_NumCdServices	145	cmp eax, fs_NumCdServices
142	jae @f	146	jae @f
143	add ebx, 4	147	add ebx, 4
144	call dword[fs_CdServices + eax*4]	148	call dword[fs_CdServices + eax*4]
145	mov [image_of_eax], eax	149	mov [image_of_eax], eax
146	mov [image_of_ebx], ebx	150	mov [image_of_ebx], ebx
147	@@:	151	@@:
148	call free_cd_channel	152	call free_cd_channel
149	and [cd_status], 0	153	and [cd_status], 0
150	stdcall kernel_free, ebp	154	stdcall kernel_free, ebp
151	ret	155	ret
152		156
153	.nextCD:	157	.nextCD:
154	test eax, eax ; partition number	158	test eax, eax ; partition number
155	stc	159	stc
156	jnz @f ; no more partitions	160	jnz @f ; no more partitions
157	mov al, 1 ; /cdX/1	161	mov al, 1 ; /cdX/1
158	clc	162	clc
159	@@:	163	@@:
160	ret	164	ret
161		165
162	.maindir: ; list partitions	166	.maindir: ; list partitions
163	mov esi, .nextCD	167	mov esi, .nextCD
164	.maindir_noesi: ; backjump from dyndisk_handler	168	.maindir_noesi: ; backjump from dyndisk_handler
165	push ebp	169	push ebp
166	mov ebp, ecx	170	mov ebp, ecx
167	call kernel_free	171	call kernel_free
168	cmp dword[ebx], 1	172	cmp dword[ebx], 1
169	jnz .access_denied ; read folder?	173	jnz .access_denied ; read folder?
170	push ebp	174	push ebp
171	pushd [ebx+4] ; first block	175	pushd [ebx+4] ; first block
172	mov ebp, [ebx+12] ; the number of blocks to read	176	mov ebp, [ebx+12] ; the number of blocks to read
173	mov edx, [ebx+16] ; buffer	177	mov edx, [ebx+16] ; buffer
174	mov ebx, [ebx+8] ; flags	178	mov ebx, [ebx+8] ; flags
175	mov ecx, 32/4	179	mov ecx, 32/4
176	mov edi, edx	180	mov edi, edx
177	xor eax, eax	181	xor eax, eax
178	rep stosd	182	rep stosd
179	mov byte [edx], 1 ; version	183	mov byte [edx], 1 ; version
180	.maindir_loop:	184	.maindir_loop:
181	call esi	185	call esi
182	jc .maindir_done	186	jc .maindir_done
183	inc dword[edx+8]	187	inc dword[edx+8]
184	dec dword[esp]	188	dec dword[esp]
185	jns .maindir_loop	189	jns .maindir_loop
186	dec ebp	190	dec ebp
187	js .maindir_loop	191	js .maindir_loop
188	inc dword[edx+4]	192	inc dword[edx+4]
189	mov dword[edi], 16 ; attributes: folder	193	mov dword[edi], 16 ; attributes: folder
190	mov dword[edi+4], ebx ; name encoding	194	mov dword[edi+4], ebx ; name encoding
191	push eax	195	push eax
192	mov ecx, 32/4	196	mov ecx, 32/4
193	add edi, 8	197	add edi, 8
194	xor eax, eax	198	xor eax, eax
195	rep stosd	199	rep stosd
196	pop eax	200	pop eax
197	push eax edx edi	201	push eax edx edi
198	; convert number in eax to decimal string	202	; convert number in eax to decimal string
199	push -'0'	203	push -'0'
200	mov ecx, 10	204	mov ecx, 10
201	@@:	205	@@:
202	xor edx, edx	206	xor edx, edx
203	div ecx	207	div ecx
204	push edx	208	push edx
205	test eax, eax	209	test eax, eax
206	jnz @b	210	jnz @b
207	cmp ebx, 1	211	cmp ebx, 1
208	jz .uni	212	jz .uni
209	@@:	213	@@:
210	pop eax	214	pop eax
211	add eax, '0'	215	add eax, '0'
212	stosb	216	stosb
213	test eax, eax	217	test eax, eax
214	jnz @b	218	jnz @b
215	pop edi edx eax	219	pop edi edx eax
216	add edi, 264	220	add edi, 264
217	jmp .maindir_loop	221	jmp .maindir_loop
218		222
219	.uni:	223	.uni:
220	pop eax	224	pop eax
221	add eax, '0'	225	add eax, '0'
222	stosw	226	stosw
223	test eax, eax	227	test eax, eax
224	jnz .uni	228	jnz .uni
225	pop edi edx eax	229	pop edi edx eax
226	add edi, 520	230	add edi, 520
227	jmp .maindir_loop	231	jmp .maindir_loop
228		232
229	.maindir_done:	233	.maindir_done:
230	pop eax eax	234	pop eax eax
231	mov ebx, [edx+4]	235	mov ebx, [edx+4]
232	xor eax, eax	236	xor eax, eax
233	dec ebp	237	dec ebp
234	js @f	238	js @f
235	mov al, ERROR_END_OF_FILE	239	mov al, ERROR_END_OF_FILE
236	@@:	240	@@:
237	mov [image_of_eax], eax	241	mov [image_of_eax], eax
238	mov [image_of_ebx], ebx	242	mov [image_of_ebx], ebx
239	ret	243	ret
240		244
241	.access_denied:	245	.access_denied:
242	mov dword[image_of_eax], ERROR_ACCESS_DENIED	246	mov dword[image_of_eax], ERROR_ACCESS_DENIED
243	ret	247	ret
244		248
245	.rootdir: ; / - virtual root folder	249	.rootdir: ; / - virtual root folder
246	cmp dword[ebx], 1 ; read folder?	250	cmp dword[ebx], 1 ; read folder?
247	jnz .access_denied	251	jnz .access_denied
248	mov ebp, [ebx+12] ; number of blocks	252	mov ebp, [ebx+12] ; number of blocks
249	mov edx, [ebx+16] ; return area	253	mov edx, [ebx+16] ; return area
250	push dword[ebx+4] ; first block	254	push dword[ebx+4] ; first block
251	mov ebx, [ebx+8] ; flags	255	mov ebx, [ebx+8] ; flags
252	mov ecx, 32/4	256	mov ecx, 32/4
253	mov edi, edx	257	mov edi, edx
254	xor eax, eax	258	xor eax, eax
255	rep stosd	259	rep stosd
256	mov byte [edx], 1 ; version	260	mov byte [edx], 1 ; version
257	sub esp, 16	261	sub esp, 16
258	.rootdir_loop:	262	.rootdir_loop:
259	push edi	263	push edi
260	lea edi, [esp+4]	264	lea edi, [esp+4]
261	call dyndisk_enum_root	265	call dyndisk_enum_root
262	pop edi	266	pop edi
263	test eax, eax	267	test eax, eax
264	jz .rootdirCD	268	jz .rootdirCD
265	inc dword[edx+8]	269	inc dword[edx+8]
266	dec dword[esp+16]	270	dec dword[esp+16]
267	jns .rootdir_loop	271	jns .rootdir_loop
268	dec ebp	272	dec ebp
269	js .rootdir_loop	273	js .rootdir_loop
270	inc dword[edx+4]	274	inc dword[edx+4]
271	mov dword[edi], 16 ; attributes: folder	275	mov dword[edi], 16 ; attributes: folder
272	mov dword[edi+4], ebx ; name encoding	276	mov dword[edi+4], ebx ; name encoding
273	push eax	277	push eax
274	mov ecx, 32/4	278	mov ecx, 32/4
275	add edi, 8	279	add edi, 8
276	xor eax, eax	280	xor eax, eax
277	rep stosd	281	rep stosd
278	push edi	282	push edi
279	lea esi, [esp+8]	283	lea esi, [esp+8]
280	cmp ebx, 1	284	cmp ebx, 1
281	jz .uni2	285	jz .uni2
282	@@:	286	@@:
283	lodsb	287	lodsb
284	stosb	288	stosb
285	test eax, eax	289	test eax, eax
286	jnz @b	290	jnz @b
287	pop edi eax	291	pop edi eax
288	add edi, 264	292	add edi, 264
289	jmp .rootdir_loop	293	jmp .rootdir_loop
290		294
291	.uni2:	295	.uni2:
292	lodsb	296	lodsb
293	stosw	297	stosw
294	test eax, eax	298	test eax, eax
295	jnz .uni2	299	jnz .uni2
296	pop edi eax	300	pop edi eax
297	add edi, 520	301	add edi, 520
298	jmp .rootdir_loop	302	jmp .rootdir_loop
299		303
300	.rootdirCD:	304	.rootdirCD:
301	add esp, 16	305	add esp, 16
302	or esi, -1	306	or esi, -1
303	.rootdirCD_loop:	307	.rootdirCD_loop:
304	inc esi	308	inc esi
305	cmp esi, 10	309	cmp esi, 10
306	jnc .rootdir_done	310	jnc .rootdir_done
307	mov eax, esi	311	mov eax, esi
308	not eax	312	not eax
309	and eax, 3	313	and eax, 3
310	shl eax, 1	314	shl eax, 1
311	inc eax	315	inc eax
312	mov ecx, esi	316	mov ecx, esi
313	shr ecx, 2	317	shr ecx, 2
314	bt [ecx*5+DRIVE_DATA+1], ax	318	bt [ecx*5+DRIVE_DATA+1], ax
315	jnc .rootdirCD_loop	319	jnc .rootdirCD_loop
316	inc dword[edx+8]	320	inc dword[edx+8]
317	dec dword[esp]	321	dec dword[esp]
318	jns .rootdirCD_loop	322	jns .rootdirCD_loop
319	dec ebp	323	dec ebp
320	js .rootdirCD_loop	324	js .rootdirCD_loop
321	inc dword[edx+4]	325	inc dword[edx+4]
322	mov dword[edi], 16 ; attributes: folder	326	mov dword[edi], 16 ; attributes: folder
323	mov dword[edi+4], ebx ; name encoding	327	mov dword[edi+4], ebx ; name encoding
324	mov ecx, 32/4	328	mov ecx, 32/4
325	add edi, 8	329	add edi, 8
326	xor eax, eax	330	xor eax, eax
327	rep stosd	331	rep stosd
328	mov eax, esi	332	mov eax, esi
329	add eax, '0'	333	add eax, '0'
330	cmp ebx, 1	334	cmp ebx, 1
331	jz @f	335	jz @f
332	mov word [edi], 'cd'	336	mov word [edi], 'cd'
333	mov [edi+2], ax	337	mov [edi+2], ax
334	add edi, 264	338	add edi, 264
335	jmp .rootdirCD_loop	339	jmp .rootdirCD_loop
336		340
337	@@:	341	@@:
338	mov dword[edi], 640063h	342	mov dword[edi], 640063h
339	mov [edi+4], eax	343	mov [edi+4], eax
340	add edi, 520	344	add edi, 520
341	jmp .rootdirCD_loop	345	jmp .rootdirCD_loop
342		346
343	.rootdir_done:	347	.rootdir_done:
344	pop eax	348	pop eax
345	mov ebx, [edx+4]	349	mov ebx, [edx+4]
346	xor eax, eax	350	xor eax, eax
347	dec ebp	351	dec ebp
348	js @f	352	js @f
349	mov al, ERROR_END_OF_FILE	353	mov al, ERROR_END_OF_FILE
350	@@:	354	@@:
351	mov [image_of_eax], eax	355	mov [image_of_eax], eax
352	mov [image_of_ebx], ebx	356	mov [image_of_ebx], ebx
353	ret	357	ret
354		358
355	;-----------------------------------------------------------------------------	359	;-----------------------------------------------------------------------------
356	process_replace_file_name:	360	process_replace_file_name:
357	; in: [esi] = virtual path	361	; in: [esi] = virtual path
358	; out: [esi]+[ebp] = physical path	362	; out: [esi]+[ebp] = physical path
359	xor edi, edi	363	xor edi, edi
360	xor ebp, ebp	364	xor ebp, ebp
361	.loop:	365	.loop:
362	cmp edi, [full_file_name_table.size]	366	cmp edi, [full_file_name_table.size]
363	jae .notfound	367	jae .notfound
364	push esi edi	368	push esi edi
365	shl edi, 7	369	shl edi, 7
366	add edi, [full_file_name_table]	370	add edi, [full_file_name_table]
367	@@:	371	@@:
368	cmp byte [edi], 0	372	cmp byte [edi], 0
369	jz .dest_done	373	jz .dest_done
370	lodsb	374	lodsb
371	test al, al	375	test al, al
372	jz .cont	376	jz .cont
373	or al, 20h	377	or al, 20h
374	scasb	378	scasb
375	jz @b	379	jz @b
376	.cont:	380	.cont:
377	pop edi esi	381	pop edi esi
378	inc edi	382	inc edi
379	jmp .loop	383	jmp .loop
380		384
381	.dest_done:	385	.dest_done:
382	cmp byte [esi], 0	386	cmp byte [esi], 0
383	jz .found	387	jz .found
384	cmp byte [esi], '/'	388	cmp byte [esi], '/'
385	jnz .cont	389	jnz .cont
386	.found:	390	.found:
387	pop edi eax	391	pop edi eax
388	shl edi, 7	392	shl edi, 7
389	add edi, [full_file_name_table]	393	add edi, [full_file_name_table]
390	mov ebp, esi	394	mov ebp, esi
391	lea esi, [edi+64]	395	lea esi, [edi+64]
392	.notfound:	396	.notfound:
393	ret	397	ret
394		398
395	;-----------------------------------------------------------------------------	399	;-----------------------------------------------------------------------------
396	uglobal	400	uglobal
397	addDirSeal db ?	401	addDirSeal db ?
398	endg	402	endg
399		403
400	sys_current_directory: ; sysfunction 30	404	sys_current_directory: ; sysfunction 30
401	mov eax, [current_slot]	405	mov eax, [current_slot]
402	mov edi, [eax+APPDATA.cur_dir]	406	mov edi, [eax+APPDATA.cur_dir]
403	dec ebx	407	dec ebx
404	jz .set	408	jz .set
405	dec ebx	409	dec ebx
406	jz .get	410	jz .get
407	dec ebx	411	dec ebx
408	jz .mount_additional_directory	412	jz .mount_additional_directory
409	dec ebx	413	dec ebx
410	jz .get16	414	jz .get16
411	@@:	415	@@:
412	ret	416	ret
413		417
414	.mount_additional_directory:	418	.mount_additional_directory:
415	; in: ecx -> dir name+dir path (128)	419	; in: ecx -> dir name+dir path (128)
416	mov al, 1	420	mov al, 1
417	xchg [addDirSeal], al	421	xchg [addDirSeal], al
418	test al, al	422	test al, al
419	jnz @b	423	jnz @b
420	mov esi, ecx	424	mov esi, ecx
421	mov edi, sysdir_name1	425	mov edi, sysdir_name1
422	mov ecx, 63	426	mov ecx, 63
423	rep movsb ; copying fake directory name	427	rep movsb ; copying fake directory name
424	inc esi	428	inc esi
425	xor eax, eax	429	xor eax, eax
426	stosb ; terminator of name, in case if we get the inlet trash	430	stosb ; terminator of name, in case if we get the inlet trash
427	mov cl, 63	431	mov cl, 63
428	cmp word [esi], 2	432	cmp word [esi], 2
429	jz .utf16	433	jz .utf16
430	call cp866toUTF8_string	434	call cp866toUTF8_string
431	@@:	435	@@:
432	mov byte [edi], 0	436	mov byte [edi], 0
433	mov [full_file_name_table.size], 2	437	mov [full_file_name_table.size], 2
434	ret	438	ret
435		439
436	.utf16:	440	.utf16:
437	add esi, 2	441	add esi, 2
438	call UTF16to8_string	442	call UTF16to8_string
439	jmp @b	443	jmp @b
440		444
441	.get: ; in: ecx -> buffer, edx = length	445	.get: ; in: ecx -> buffer, edx = length
442	mov esi, edi	446	mov esi, edi
443	mov edi, ecx	447	mov edi, ecx
444	cmp edx, maxPathLength	448	cmp edx, maxPathLength
445	jc @f	449	jc @f
446	mov edx, maxPathLength	450	mov edx, maxPathLength
447	@@:	451	@@:
448	mov al, '/'	452	mov al, '/'
449	stosb	453	stosb
450	mov ecx, edx	454	mov ecx, edx
451	dec ecx	455	dec ecx
452	@@:	456	@@:
453	dec ecx	457	dec ecx
454	js @f	458	js @f
455	call utf8to16	459	call utf8to16
456	call uni2ansi_char	460	call uni2ansi_char
457	stosb	461	stosb
458	test al, al	462	test al, al
459	jnz @b	463	jnz @b
460	sub edx, ecx	464	sub edx, ecx
461	mov ecx, edx	465	mov ecx, edx
462	@@:	466	@@:
463	mov [esp+32], ecx	467	mov [esp+32], ecx
464	ret	468	ret
465		469
466	.get16:	470	.get16:
467	mov esi, edi	471	mov esi, edi
468	mov edi, ecx	472	mov edi, ecx
469	cmp edx, maxPathLength	473	cmp edx, maxPathLength
470	jc @f	474	jc @f
471	mov edx, maxPathLength	475	mov edx, maxPathLength
472	@@:	476	@@:
473	shr edx, 1	477	shr edx, 1
474	mov ax, '/'	478	mov ax, '/'
475	stosw	479	stosw
476	mov ecx, edx	480	mov ecx, edx
477	dec ecx	481	dec ecx
478	@@:	482	@@:
479	dec ecx	483	dec ecx
480	js @f	484	js @f
481	call utf8to16	485	call utf8to16
482	stosw	486	stosw
483	test ax, ax	487	test ax, ax
484	jnz @b	488	jnz @b
485	sub edx, ecx	489	sub edx, ecx
486	mov ecx, edx	490	mov ecx, edx
487	@@:	491	@@:

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc – Rev 6471 → 6502