| 3,6 → 3,7 |
|---|
| ;; RAMDISK functions ;; |
| ;; (C) 2004 Ville Turjanmaa, License: GPL ;; |
| ;; Addings by M.Lisovin ;; |
| ;; LFN support by diamond ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| ; calculate fat chain |
| 379,7 → 380,6 |
|---|
| ; find an empty spot for filename in the root dir |
| l20ds: |
| dec edx |
| test edx,edx |
| jz frnoreadds |
| l21ds: |
| cmp [edi],byte 0xE5 |
| 1076,4 → 1076,522 |
|---|
| pop ecx edi esi |
| ret |
| |
| iglobal |
| label fat_legal_chars byte |
| ; 0 = not allowed |
| ; 1 = allowed only in long names |
| ; 3 = allowed |
| times 32 db 0 |
| ; ! " # $ % & ' ( ) * + , - . / |
| db 1,3,0,3,3,3,3,3,3,3,0,1,1,3,3,0 |
| ; 0 1 2 3 4 5 6 7 8 9 : ; < = > ? |
| db 3,3,3,3,3,3,3,3,3,3,0,1,0,1,0,0 |
| ; @ A B C D E F G H I J K L M N O |
| db 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3 |
| ; P Q R S T U V W X Y Z [ \ ] ^ _ |
| db 3,3,3,3,3,3,3,3,3,3,3,1,0,1,3,3 |
| ; ` a b c d e f g h i j k l m n o |
| db 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3 |
| ; p q r s t u v w x y z { | } ~ |
| db 3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,0 |
| endg |
| |
| fat_name_is_legal: |
| ; in: esi->(long) name |
| ; out: CF set <=> legal |
| ; destroys eax |
| push esi |
| xor eax, eax |
| @@: |
| lodsb |
| test al, al |
| jz .done |
| cmp al, 80h |
| jae .big |
| test [fat_legal_chars+eax], 1 |
| jnz @b |
| .err: |
| pop esi |
| clc |
| ret |
| .big: |
| ; 0x80-0xAF, 0xE0-0xEF |
| cmp al, 0xB0 |
| jb @b |
| cmp al, 0xE0 |
| jb .err |
| cmp al, 0xF0 |
| jb @b |
| jmp .err |
| .done: |
| sub esi, [esp] |
| cmp esi, 257 |
| pop esi |
| ret |
| |
| fat_next_short_name: |
| ; in: edi->8+3 name |
| ; out: name corrected |
| ; CF=1 <=> error |
| pushad |
| mov ecx, 8 |
| mov al, '~' |
| std |
| push edi |
| add edi, 7 |
| repnz scasb |
| pop edi |
| cld |
| jz .tilde |
| ; tilde is not found, insert "~1" at end |
| add edi, 6 |
| cmp word [edi], ' ' |
| jnz .insert_tilde |
| @@: dec edi |
| cmp byte [edi], ' ' |
| jz @b |
| inc edi |
| .insert_tilde: |
| mov word [edi], '~1' |
| popad |
| ; clc ; CF already cleared |
| ret |
| .tilde: |
| push edi |
| add edi, 7 |
| xor ecx, ecx |
| @@: |
| ; after tilde may be only digits and trailing spaces |
| cmp byte [edi], '~' |
| jz .break |
| cmp byte [edi], ' ' |
| jz .space |
| cmp byte [edi], '9' |
| jnz .found |
| dec edi |
| jmp @b |
| .space: |
| dec edi |
| inc ecx |
| jmp @b |
| .found: |
| inc byte [edi] |
| .succ: |
| pop edi |
| popad |
| clc |
| ret |
| .break: |
| jecxz .noplace |
| inc edi |
| mov al, '1' |
| @@: |
| xchg al, [edi] |
| inc edi |
| cmp al, ' ' |
| mov al, '0' |
| jnz @b |
| jmp .succ |
| .noplace: |
| dec edi |
| cmp edi, [esp] |
| jz .err |
| add dword [esp], 8 |
| mov word [edi], '~1' |
| inc edi |
| inc edi |
| @@: |
| mov byte [edi], '0' |
| inc edi |
| cmp edi, [esp] |
| jb @b |
| pop edi |
| popad |
| ;clc ; automatically |
| ret |
| .err: |
| pop edi |
| popad |
| stc |
| ret |
| |
| fat_gen_short_name: |
| ; in: esi->long name |
| ; edi->buffer (8+3=11 chars) |
| ; out: buffer filled |
| pushad |
| mov eax, ' ' |
| push edi |
| stosd |
| stosd |
| stosd |
| pop edi |
| xor eax, eax |
| push 8 |
| pop ebx |
| lea ecx, [edi+8] |
| .loop: |
| lodsb |
| test al, al |
| jz .done |
| call char_toupper |
| cmp al, ' ' |
| jz .space |
| cmp al, 80h |
| ja .big |
| test [fat_legal_chars+eax], 2 |
| jnz .symbol |
| .inv_symbol: |
| mov al, '_' |
| or bh, 1 |
| .symbol: |
| cmp al, '.' |
| jz .dot |
| .normal_symbol: |
| dec bl |
| jns .store |
| mov bl, 0 |
| .space: |
| or bh, 1 |
| jmp .loop |
| .store: |
| stosb |
| jmp .loop |
| .big: |
| cmp al, 0xB0 |
| jb .normal_symbol |
| cmp al, 0xE0 |
| jb .inv_symbol |
| cmp al, 0xF0 |
| jb .normal_symbol |
| jmp .inv_symbol |
| .dot: |
| test bh, 2 |
| jz .firstdot |
| pop ebx |
| add ebx, edi |
| sub ebx, ecx |
| push ebx |
| cmp edi, ecx |
| jbe .skip |
| @@: |
| dec edi |
| mov al, ' ' |
| xchg al, [edi] |
| dec ebx |
| mov [ebx], al |
| cmp edi, ecx |
| ja @b |
| .skip: |
| mov bh, 3 |
| jmp @f |
| .firstdot: |
| cmp bl, 8 |
| jz .space |
| push edi |
| or bh, 2 |
| @@: |
| mov edi, ecx |
| mov bl, 3 |
| jmp .loop |
| .done: |
| test bh, 2 |
| jz @f |
| pop edi |
| @@: |
| lea edi, [ecx-8] |
| test bh, 1 |
| jz @f |
| call fat_next_short_name |
| @@: |
| popad |
| ret |
| |
| ;---------------------------------------------------------------- |
| ; |
| ; fs_RamdiskRewrite - LFN variant for writing sys floppy |
| ; |
| ; esi points to filename |
| ; ebx ignored (reserved) |
| ; ecx number of bytes to write, 0+ |
| ; edx mem location to data |
| ; |
| ; ret ebx = number of written bytes |
| ; eax = 0 ok read or other = errormsg |
| ; |
| ;-------------------------------------------------------------- |
| @@: |
| mov eax, ERROR_ACCESS_DENIED |
| xor ebx, ebx |
| ret |
| |
| fs_RamdiskRewrite: |
| cmp byte [esi], 0 |
| jz @b |
| ; ramdisk doesn't support folders |
| push esi |
| @@: |
| lodsb |
| test al, al |
| jz @f |
| cmp al, '/' |
| jnz @b |
| pop esi |
| .err5: |
| mov eax, 5 ; file not found |
| xor ebx, ebx |
| ret |
| @@: |
| pop esi |
| ; check existence |
| push edi |
| call rd_find_lfn |
| jc .notfound |
| ; found, delete FAT chain |
| push edi |
| xor eax, eax |
| mov dword [edi+28], eax ; zero size |
| xchg ax, word [edi+26] ; start cluster |
| test eax, eax |
| jz .done1 |
| @@: |
| cmp eax, 0xFF8 |
| jae .done1 |
| lea edi, [0x280000 + eax*2] ; position in FAT |
| xor eax, eax |
| xchg ax, [edi] |
| jmp @b |
| .done1: |
| pop edi |
| call get_time_for_file |
| mov [edi+22], ax |
| call get_date_for_file |
| mov [edi+24], ax |
| mov [edi+18], ax |
| or byte [edi+11], 20h ; set 'archive' attribute |
| jmp .doit |
| .notfound: |
| ; file is not found; generate short name |
| call fat_name_is_legal |
| jc @f |
| pop edi |
| jmp .err5 |
| @@: |
| sub esp, 12 |
| mov edi, esp |
| call fat_gen_short_name |
| .test_short_name_loop: |
| push esi ecx |
| mov esi, 0x100000+512*19 |
| .test_short_name_entry: |
| cmp byte [esi+11], 0xF |
| jz .test_short_name_cont |
| mov ecx, 11 |
| push esi edi |
| repz cmpsb |
| pop edi esi |
| jz .short_name_found |
| .test_short_name_cont: |
| add esi, 20h |
| cmp esi, 0x100000+512*33 |
| jb .test_short_name_entry |
| pop ecx esi |
| jmp .found |
| .short_name_found: |
| call fat_next_short_name |
| pop ecx esi |
| jnc .test_short_name_loop |
| .disk_full: |
| add esp, 12 |
| pop edi |
| mov eax, ERROR_DISK_FULL |
| xor ebx, ebx |
| ret |
| .found: |
| ; now find space in directory |
| ; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~' |
| mov al, '~' |
| push ecx edi |
| mov ecx, 8 |
| repnz scasb |
| push 1 |
| pop eax ; 1 entry |
| jnz .notilde |
| ; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total |
| xor eax, eax |
| @@: |
| cmp byte [esi], 0 |
| jz @f |
| inc esi |
| inc eax |
| jmp @b |
| @@: |
| sub esi, eax |
| add eax, 12+13 |
| mov ecx, 13 |
| push edx |
| cdq |
| div ecx |
| pop edx |
| .notilde: |
| ; find <eax> successive entries in directory |
| xor ecx, ecx |
| mov edi, 0x100000+512*19 |
| .scan_dir: |
| cmp byte [edi], 0 |
| jz .free |
| cmp byte [edi], 0xE5 |
| jz .free |
| xor ecx, ecx |
| .scan_cont: |
| add edi, 0x20 |
| cmp edi, 0x100000+512*33 |
| jb .scan_dir |
| pop edi ecx |
| jmp .disk_full |
| .free: |
| inc ecx |
| cmp ecx, eax |
| jb .scan_cont |
| ; found! |
| ; calculate name checksum |
| push esi ecx |
| mov esi, [esp+8] |
| mov ecx, 11 |
| xor eax, eax |
| @@: |
| ror al, 1 |
| add al, [esi] |
| inc esi |
| loop @b |
| pop ecx esi |
| ; edi points to last entry in free chunk |
| dec ecx |
| jz .nolfn |
| push esi |
| push edi |
| .writelfn: |
| sub edi, 20h |
| push ecx eax |
| mov eax, [esp+8] |
| sub eax, edi |
| shr eax, 5 |
| cmp ecx, 1 |
| jnz @f |
| or al, 40h |
| @@: |
| stosb |
| mov cl, 5 |
| call .read_symbols |
| mov ax, 0xF |
| stosw |
| pop eax |
| stosb |
| push eax |
| mov cl, 6 |
| call .read_symbols |
| xor eax, eax |
| stosw |
| mov cl, 2 |
| call .read_symbols |
| pop eax ecx |
| sub edi, 0x20 |
| loop .writelfn |
| pop edi |
| pop esi |
| .nolfn: |
| xchg esi, [esp] |
| mov ecx, 11 |
| rep movsb |
| mov word [edi], 20h ; attributes |
| sub edi, 11 |
| pop esi ecx |
| add esp, 12 |
| mov byte [edi+13], 0 ; tenths of a second at file creation time |
| call get_time_for_file |
| mov [edi+14], ax ; creation time |
| mov [edi+22], ax ; last write time |
| call get_date_for_file |
| mov [edi+16], ax ; creation date |
| mov [edi+24], ax ; last write date |
| mov [edi+18], ax ; last access date |
| and word [edi+20], 0 ; high word of cluster |
| and word [edi+26], 0 ; low word of cluster - to be filled |
| and dword [edi+28], 0 ; file size - to be filled |
| .doit: |
| push ecx edx |
| push ecx |
| push edi |
| add edi, 26 ; edi points to low word of cluster |
| push edi |
| jecxz .done |
| mov ecx, 2849 |
| mov edi, 0x280000 |
| .write_loop: |
| ; allocate new cluster |
| xor eax, eax |
| repnz scasw |
| jnz .disk_full2 |
| dec edi |
| dec edi |
| lea eax, [edi-0x280000] |
| shr eax, 1 ; eax = cluster |
| mov word [edi], 0xFFF ; mark as last cluster |
| xchg edi, [esp] |
| stosw |
| pop edi |
| push edi |
| inc ecx |
| ; write data |
| shl eax, 9 |
| add eax, 0x100000+31*512 |
| mov ebx, edx |
| xchg eax, ebx |
| push ecx |
| mov ecx, 512 |
| cmp dword [esp+12], ecx |
| jae @f |
| mov ecx, [esp+12] |
| @@: |
| call memmove |
| add edx, ecx |
| sub [esp+12], ecx |
| pop ecx |
| jnz .write_loop |
| .done: |
| mov ebx, edx |
| pop edi edi ecx edx ecx |
| sub ebx, edx |
| mov [edi+28], ebx |
| pop edi |
| xor eax, eax |
| ret |
| .disk_full2: |
| mov ebx, edx |
| pop edi edi ecx edx ecx |
| sub ebx, edx |
| mov [edi+28], ebx |
| pop edi |
| push ERROR_DISK_FULL |
| pop eax |
| ret |
| |
| .read_symbol: |
| or ax, -1 |
| test esi, esi |
| jz .retFFFF |
| lodsb |
| test al, al |
| jnz ansi2uni_char |
| xor eax, eax |
| xor esi, esi |
| .retFFFF: |
| ret |
| |
| .read_symbols: |
| call .read_symbol |
| stosw |
| loop .read_symbols |
| ret |
| |
| ; \end{diamond} |