Subversion Repositories Kolibri OS

Rev

Rev 133 | Rev 321 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                                      ;;
  3. ;; FAT12.INC                                                            ;;
  4. ;; (C) 2005 Mario79, License: GPL                                       ;;
  5. ;;                                                                      ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. n_sector    dd 0  ; temporary save for sector value
  9. flp_status  dd 0
  10. clust_tmp_flp dd 0  ; used by analyze_directory and analyze_directory_to_write
  11. path_pointer_flp dd 0
  12. pointer_file_name_flp dd 0
  13. save_root_flag db 0
  14. save_flag   db 0
  15. root_read   db 0  ; 0-necessary to load root, 1-not to load root
  16. flp_fat     db 0  ; 0-necessary to load fat, 1-not to load fat
  17. flp_number  db 0  ; 1- Floppy A, 2-Floppy B
  18. old_track   db 0  ; old value track
  19. flp_label   rb 15 ; Label and ID of inserted floppy disk
  20.  
  21. reserve_flp:
  22.  
  23.     cli
  24.     cmp   [flp_status],0
  25.     je    reserve_flp_ok
  26.  
  27.     sti
  28.     call  change_task
  29.     jmp   reserve_flp
  30.  
  31.   reserve_flp_ok:
  32.  
  33.     push  eax
  34.     mov   eax,[0x3000]
  35.     shl   eax,5
  36.     mov   eax,[eax+0x3000+TASKDATA.pid]
  37.     mov   [flp_status],eax
  38.     pop   eax
  39.     sti
  40.     ret
  41.  
  42. floppy_free_space:
  43. ;---------------------------------------------
  44. ;
  45. ; returns free space in edi
  46. ;
  47. ;---------------------------------------------
  48.     push   eax ebx ecx
  49.     call   read_flp_fat
  50.     cmp    [FDC_Status],0
  51.     jne    fdc_status_error_2
  52.     mov    eax,0x282004
  53.     xor    edi,edi
  54.     mov    ecx,2847   ;1448000/512
  55. rdfs1_1:
  56.     mov    ebx,[eax]
  57.     and    ebx,4095
  58.     jne    rdfs2_1
  59.     add    edi,512
  60. rdfs2_1:
  61.     add    eax,2
  62.     loop   rdfs1_1
  63. fdc_status_error_2:
  64.     pop    ecx ebx eax
  65.     ret
  66.  
  67.  
  68.  
  69.  
  70. floppy_fileread:
  71. ;----------------------------------------------------------------
  72. ;
  73. ;  fileread - sys floppy
  74. ;
  75. ;  eax  points to filename 11 chars  - for root directory
  76. ;  ebx  first wanted block       ; 1+ ; if 0 then set to 1
  77. ;  ecx  number of blocks to read ; 1+ ; if 0 then set to 1
  78. ;  edx  mem location to return data
  79. ;  esi  length of filename 12*X
  80. ;  edi  pointer to path   /fd/1/......  - for all files in nested directories
  81. ;
  82. ;  ret ebx = size or 0xffffffff file not found
  83. ;      eax = 0 ok read or other = errormsg
  84. ;            10 = access denied
  85. ;--------------------------------------------------------------
  86.  
  87.     mov    [save_flag],0
  88.     mov    [path_pointer_flp],edi
  89.     cmp    esi,0           ; return ramdisk root
  90.     jne    fr_noroot_1
  91.     cmp    ebx,224/16
  92.     jbe    fr_do_1
  93.     mov    eax,5
  94.     mov    ebx,0
  95.     mov   [flp_status],0
  96.     ret
  97.  
  98. fr_do_1:
  99.     push ebx ecx edx
  100.     call  read_flp_root
  101.     pop edx ecx ebx
  102.     cmp    [FDC_Status],0
  103.     jne    fdc_status_error_1
  104.     mov    edi,edx
  105.     dec    ebx
  106.     shl    ebx,9
  107.     mov    esi,0x8000
  108.     add    esi,ebx
  109.     shl    ecx,9
  110.     cld
  111.     rep    movsb
  112.     mov    eax,0 ; ok read
  113.     mov    ebx,0
  114.     mov   [flp_status],0
  115.     ret
  116. fdc_status_error_1:
  117.     mov   [flp_status],0
  118.     mov    eax,10
  119.     mov    ebx,-1
  120.     ret
  121.  
  122. fr_noroot_1:
  123.     sub    esp,32
  124.     call   expand_filename
  125. frfloppy_1:
  126.     cmp    ebx,0
  127.     jne    frfl5_1
  128.     mov    ebx,1
  129. frfl5_1:
  130.     cmp    ecx,0
  131.     jne    frfl6_1
  132.     mov    ecx,1
  133. frfl6_1:
  134.     dec    ebx
  135.     push   eax
  136.     push   eax ebx ecx edx esi edi
  137.     call   read_flp_fat
  138.     cmp    [FDC_Status],0
  139.     jne    fdc_status_error_3_1
  140.     mov    [FDD_Track],0      ; ╓шышэфЁ
  141.     mov    [FDD_Head],1      ; ╤ЄюЁюэр
  142.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  143.     call    SeekTrack
  144.     mov     dh,14
  145. l.20_1:
  146.     call    ReadSectWithRetr
  147.     cmp    [FDC_Status],0
  148.     jne    fdc_status_error_3_1
  149.     mov     dl,16
  150.     mov     edi,0xD000
  151.     inc     [FDD_Sector]
  152. l.21_1:
  153.     mov    esi,eax            ;Name of file we want
  154.     mov    ecx,11
  155.     cld
  156.     rep    cmpsb            ;Found the file?
  157.     je     fifound_1          ;Yes
  158.     add    ecx,21
  159.     add    edi, ecx         ;Advance to next entry
  160.     dec    dl
  161.     cmp    dl,0
  162.     jne    l.21_1
  163.     dec    dh
  164.     cmp    dh,0
  165.     jne    l.20_1
  166. fdc_status_error_3:
  167.     mov    eax,5            ; file not found ?
  168.     mov    ebx,-1
  169.     add    esp,32+28
  170.     mov   [flp_status],0
  171.     ret
  172. fdc_status_error_3_2:
  173.     cmp    [FDC_Status],0
  174.     je    fdc_status_error_3
  175. fdc_status_error_3_1:
  176.     add    esp,32+28
  177.     jmp    fdc_status_error_1
  178.  
  179. fifound_1:
  180.     mov    eax,[path_pointer_flp]
  181.     cmp    [eax+36],byte 0
  182.     je     fifound_2
  183.     add    edi,0xf
  184.     mov    eax,[edi]
  185.     and    eax,65535
  186.     mov    ebx,[path_pointer_flp]
  187.     add    ebx,36
  188.     call   get_cluster_of_a_path_flp
  189.     jc     fdc_status_error_3_2
  190.     mov    ebx,[ebx-11+28]        ;file size
  191.     mov    [esp+20],ebx
  192.     mov    [esp+24],ebx
  193.     jmp     fifound_3
  194. fifound_2:
  195.     mov    ebx,[edi-11+28]        ;file size
  196.     mov    [esp+20],ebx
  197.     mov    [esp+24],ebx
  198.     add    edi,0xf
  199.     mov    eax,[edi]
  200. fifound_3:
  201.     and    eax,65535
  202.     mov    [n_sector],eax            ;eax=cluster
  203. frnew_1:
  204.     add    eax,31            ;bootsector+2*fat+filenames
  205.     cmp    [esp+16],dword 0     ; wanted cluster ?
  206.     jne    frfl7_1
  207.     call   read_chs_sector
  208.     cmp    [FDC_Status],0
  209.     jne    fdc_status_error_5
  210.     mov    edi,[esp+8]
  211.     call    give_back_application_data_1
  212.     add    [esp+8],dword 512
  213.     dec    dword [esp+12]        ; last wanted cluster ?
  214.     cmp    [esp+12],dword 0
  215.     je     frnoread_1
  216.     jmp    frfl8_1
  217. frfl7_1:
  218.     dec    dword [esp+16]
  219. frfl8_1:
  220.     mov    edi,[n_sector]
  221.     shl    edi,1            ;find next cluster from FAT
  222.     add    edi,0x282000
  223.     mov    eax,[edi]
  224.     and    eax,4095
  225.     mov    edi,eax
  226.     mov    [n_sector],edi
  227.     cmp    edi,4095         ;eof  - cluster
  228.     jz     frnoread2_1
  229.     cmp    [esp+24],dword 512    ;eof  - size
  230.     jb     frnoread_1
  231.     sub    [esp+24],dword 512
  232.     jmp    frnew_1
  233.  
  234. read_chs_sector:
  235.     call    calculate_chs
  236.     call    ReadSectWithRetr
  237.     ret
  238.  
  239. frnoread2_1:
  240.     cmp    [esp+16],dword 0     ; eof without read ?
  241.     je     frnoread_1
  242.     mov    [fdc_irq_func],fdc_null
  243.     pop    edi esi edx ecx
  244.     add    esp,4
  245.     pop    ebx     ; ebx <- eax : size of file
  246.     add    esp,36
  247.     mov    eax,6   ; end of file
  248.     mov    [flp_status],0
  249.     ret
  250.  
  251. frnoread_1:
  252.     pop    edi esi edx ecx
  253.     add    esp,4
  254.     pop    ebx     ; ebx <- eax : size of file
  255.     add    esp,36
  256.     mov    eax,0
  257.     mov    [flp_status],0
  258.     ret
  259.  
  260. fdc_status_error_5:
  261.     pop    edi esi edx ecx
  262.     add    esp,4
  263.     pop    ebx     ; ebx <- eax : size of file
  264.     add    esp,36
  265.     jmp    fdc_status_error_1
  266.  
  267. read_flp_root:
  268.     pusha
  269.     call  check_label
  270.     cmp    [FDC_Status],0
  271.     jne    unnecessary_root_read
  272.     cmp   [root_read],1
  273.     je    unnecessary_root_read
  274.     mov    [FDD_Track],0      ; ╓шышэфЁ
  275.     mov    [FDD_Head],1      ; ╤ЄюЁюэр
  276.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  277.     mov    edi,0x8000
  278.     call   SeekTrack
  279. read_flp_root_1:
  280.     call   ReadSectWithRetr
  281.     cmp    [FDC_Status],0
  282.     jne    unnecessary_root_read
  283.     push   edi
  284.     call   give_back_application_data_1
  285.     pop    edi
  286.     add    edi,512
  287.     inc    [FDD_Sector]
  288.     cmp    [FDD_Sector],16
  289.     jne    read_flp_root_1
  290.     mov    [root_read],1
  291. unnecessary_root_read:
  292.     popa
  293.     ret
  294.  
  295.  
  296. read_flp_fat:
  297.     pusha
  298.     call  check_label
  299.     cmp    [FDC_Status],0
  300.     jne    unnecessary_flp_fat
  301.     cmp   [flp_fat],1
  302.     je    unnecessary_flp_fat
  303.     mov    [FDD_Track],0      ; ╓шышэфЁ
  304.     mov    [FDD_Head],0      ; ╤ЄюЁюэр
  305.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  306.     mov    edi,0x8000
  307.     call   SeekTrack
  308. read_flp_fat_1:
  309.     call   ReadSectWithRetr
  310.     cmp    [FDC_Status],0
  311.     jne    unnecessary_flp_fat
  312.     push   edi
  313.     call   give_back_application_data_1
  314.     pop    edi
  315.     add    edi,512
  316.     inc    [FDD_Sector]
  317.     cmp    [FDD_Sector],19
  318.     jne    read_flp_fat_1
  319.     mov    [FDD_Sector],1
  320.     mov    [FDD_Head],1
  321.     call   ReadSectWithRetr
  322.     cmp    [FDC_Status],0
  323.     jne    unnecessary_flp_fat
  324.     call   give_back_application_data_1
  325.     call   calculatefatchain_flp
  326.     mov    [root_read],0
  327.     mov    [flp_fat],1
  328. unnecessary_flp_fat:
  329.     popa
  330.     ret
  331.  
  332. calculatefatchain_flp:
  333.    pushad
  334.  
  335.    mov  esi,0x8000
  336.    mov  edi,0x282000
  337.  
  338.  fcnew_1:
  339.    mov  eax,dword [esi]
  340.    mov  ebx,dword [esi+4]
  341.    mov  ecx,dword [esi+8]
  342.    mov  edx,ecx
  343.    shr  edx,4   ;8 ok
  344.    shr  dx,4    ;7 ok
  345.    xor  ch,ch
  346.    shld ecx,ebx,20 ;6 ok
  347.    shr  cx,4     ;5 ok
  348.    shld ebx,eax,12
  349.    and  ebx,0x0fffffff  ;4 ok
  350.    shr  bx,4    ;3 ok
  351.    shl  eax,4
  352.    and  eax,0x0fffffff  ;2 ok
  353.    shr  ax,4  ;1 ok
  354.    mov dword [edi],eax
  355.    add  edi,4
  356.    mov dword [edi],ebx
  357.    add  edi,4
  358.    mov dword [edi],ecx
  359.    add  edi,4
  360.    mov dword [edi],edx
  361.    add  edi,4
  362.    add  esi,12
  363.  
  364.    cmp  edi,0x282000+2856*2   ;2849 clusters
  365.    jnz  fcnew_1
  366.  
  367.    popad
  368.    ret
  369.  
  370. check_label:
  371.     pushad
  372.     mov    [FDD_Track],0      ; ╓шышэфЁ
  373.     mov    [FDD_Head],0      ; ╤ЄюЁюэр
  374.     mov    [FDD_Sector],1      ; ╤хъЄюЁ
  375.     call   SetUserInterrupts
  376.     call   FDDMotorON
  377.     call   RecalibrateFDD
  378.     cmp    [FDC_Status],0
  379.     jne    fdc_status_error
  380.     call   SeekTrack
  381.     cmp    [FDC_Status],0
  382.     jne    fdc_status_error
  383.     call   ReadSectWithRetr
  384.     cmp    [FDC_Status],0
  385.     jne    fdc_status_error
  386.     mov    esi,flp_label
  387.     mov    edi,0xD000+39
  388.     mov    ecx,15
  389.     cld
  390.     rep    cmpsb
  391.     je     same_label
  392.     mov    [root_read],0
  393.     mov    [flp_fat],0
  394. same_label:
  395.     mov    esi,0xD000+39
  396.     mov    edi,flp_label
  397.     mov    ecx,15
  398.     cld
  399.     rep    movsb
  400.     popad
  401.     ret
  402. fdc_status_error:
  403.     popad
  404.     ret
  405.  
  406. save_flp_root:
  407.     pusha
  408.     call  check_label
  409.     cmp    [FDC_Status],0
  410.     jne    unnecessary_root_save
  411.     cmp   [root_read],0
  412.     je    unnecessary_root_save
  413.     mov    [FDD_Track],0      ; ╓шышэфЁ
  414.     mov    [FDD_Head],1      ; ╤ЄюЁюэр
  415.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  416.     mov    esi,0x8000
  417.     call   SeekTrack
  418. save_flp_root_1:
  419.     push   esi
  420.     call   take_data_from_application_1
  421.     pop    esi
  422.     add    esi,512
  423.     call   WriteSectWithRetr
  424.     cmp    [FDC_Status],0
  425.     jne    unnecessary_root_save
  426.     inc    [FDD_Sector]
  427.     cmp    [FDD_Sector],16
  428.     jne    save_flp_root_1
  429. unnecessary_root_save:
  430.     mov    [fdc_irq_func],fdc_null
  431.     popa
  432.     ret
  433.  
  434. save_flp_fat:
  435.     pusha
  436.     call  check_label
  437.     cmp    [FDC_Status],0
  438.     jne    unnecessary_flp_fat_save
  439.     cmp   [flp_fat],0
  440.     je    unnecessary_flp_fat_save
  441.     call   restorefatchain_flp
  442.     mov    [FDD_Track],0      ; ╓шышэфЁ
  443.     mov    [FDD_Head],0      ; ╤ЄюЁюэр
  444.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  445.     mov    esi,0x8000
  446.     call   SeekTrack
  447. save_flp_fat_1:
  448.     push   esi
  449.     call   take_data_from_application_1
  450.     pop    esi
  451.     add    esi,512
  452.     call   WriteSectWithRetr
  453.     cmp    [FDC_Status],0
  454.     jne    unnecessary_flp_fat_save
  455.     inc    [FDD_Sector]
  456.     cmp    [FDD_Sector],19
  457.     jne    save_flp_fat_1
  458.     mov    [FDD_Sector],1
  459.     mov    [FDD_Head],1
  460.     call   take_data_from_application_1
  461.     call   WriteSectWithRetr
  462.     cmp    [FDC_Status],0
  463.     jne    unnecessary_flp_fat_save
  464.     mov    [root_read],0
  465. unnecessary_flp_fat_save:
  466.     mov    [fdc_irq_func],fdc_null
  467.     popa
  468.     ret
  469.  
  470.  
  471. restorefatchain_flp:   ; restore fat chain
  472.    pushad
  473.  
  474.    mov  esi,0x282000
  475.    mov  edi,0x8000
  476.  
  477.   fcnew2_1:
  478.    mov  eax,dword [esi]
  479.    mov  ebx,dword [esi+4]
  480.    shl  ax,4
  481.    shl  eax,4
  482.    shl  bx,4
  483.    shr  ebx,4
  484.    shrd eax,ebx,8
  485.    shr  ebx,8
  486.    mov dword [edi],eax
  487.    add  edi,4
  488.    mov word [edi],bx
  489.    add  edi,2
  490.    add  esi,8
  491.  
  492.    cmp  edi,0x8000+0x1200     ;4274 bytes - all used FAT
  493.    jb   fcnew2_1
  494.  
  495.    mov  esi,0x8000           ; duplicate fat chain
  496.    mov  edi,0x8000+0x1200
  497.    mov  ecx,0x1200/4
  498.    cld
  499.    rep  movsd
  500.  
  501.    popad
  502.    ret
  503.  
  504.  
  505. floppy_filedelete:
  506. ;--------------------------------------------
  507. ;
  508. ; filedelete - sys floppy
  509. ; in:
  510. ; eax - filename 11 chars - for root directory
  511. ; edi  pointer to path   /fd/1/...... - for all files in nested directories
  512. ;
  513. ; out:
  514. ; eax - 0 = successful, 1 = file not found, 10 = access denied
  515. ;
  516. ;--------------------------------------------
  517.     mov    [path_pointer_flp],edi
  518.     mov    [save_flag],0
  519.     mov    ebp,1  ; file not found as default
  520. filedelete_newtry_1:
  521.     sub    esp,32
  522.     call   expand_filename
  523.     push   eax ebx ecx edx esi edi
  524.     call   read_flp_fat
  525.     cmp    [FDC_Status],0
  526.     jne    frnoreadd_1
  527.     mov    [FDD_Track],0      ; ╓шышэфЁ
  528.     mov    [FDD_Head],1      ; ╤ЄюЁюэр
  529.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  530.     call    SeekTrack
  531.     mov     dh,14
  532. l.20_2:
  533.     call    ReadSectWithRetr
  534.     cmp    [FDC_Status],0
  535.     jne    fdc_status_error_4
  536.     mov     dl,16
  537.     mov     edi,0xD000
  538.     inc     [FDD_Sector]
  539. l.21_2:
  540.     mov    esi,eax            ;Name of file we want
  541.     mov    ecx,11
  542.     cld
  543.     rep    cmpsb            ;Found the file?
  544.     je     fifoundd_1          ;Yes
  545.     add    ecx,21
  546.     add    edi, ecx         ;Advance to next entry
  547.     dec    dl
  548.     jne    l.21_2
  549.     dec    dh
  550.     jne    l.20_2
  551.     jmp    frnoreadd_1
  552.  
  553. fdc_status_error_4:
  554.     pop    edi esi edx ecx ebx eax
  555.     add    esp,32
  556.     jmp    fdc_status_error_1
  557.  
  558. fifoundd_1:
  559.     mov    eax,[path_pointer_flp]
  560.     cmp    [eax+36],byte 0
  561.     je    fifoundd_2
  562.     movzx  eax, word [edi+0xf]
  563.     mov    ebx,[path_pointer_flp]
  564.     add    ebx,36
  565.     call   get_cluster_of_a_path_flp
  566.     jc     frnoreadd_1_1
  567.     mov    edi,ebx
  568.     add    edi,11
  569.     jmp    fifoundd_2_1
  570. fifoundd_2:
  571.     dec    [FDD_Sector]
  572. fifoundd_2_1:
  573.     mov    [edi-11],byte 0xE5    ;mark filename deleted
  574.         movzx   edi, word [edi+0xf] ;edi = cluster
  575. frnewd_1:
  576.     shl    edi,1            ;find next cluster from FAT
  577.     add    edi,0x282000
  578.     mov    eax,[edi]
  579.     mov    [edi],word 0x0        ;clear fat chain cluster
  580.     and    eax,4095
  581.     mov    edi,eax
  582.     cmp    edi,dword 4095        ;last cluster ?
  583.     jz     frnoreadd2_1
  584.     jmp    frnewd_1
  585.  
  586. frnoreadd2_1:
  587.     call   WriteSectWithRetr
  588.     cmp    [FDC_Status],0
  589.     jne    fdc_status_error_4
  590.     call   save_flp_fat
  591.     cmp    [FDC_Status],0
  592.     jne    fdc_status_error_4
  593. ;    pop    edi esi edx ecx ebx eax
  594. ;    add    esp,32
  595.     mov    ebp,0       ; file found
  596. ;    jmp    filedelete_newtry_1
  597.     jmp    frnoreadd_1
  598.  
  599. frnoreadd_1_1:
  600.     cmp    [FDC_Status],0
  601.     jne    fdc_status_error_4
  602. frnoreadd_1:
  603.     pop    edi esi edx ecx ebx eax
  604.     add    esp,32
  605.     mov    eax,ebp
  606.     ret
  607.  
  608. floppy_filesave:
  609. ;----------------------------------------------------------
  610. ;
  611. ; filesave - sys floppy
  612. ;
  613. ; eax      ; pointer to file name 11 chars - for root directory
  614. ; ebx      ; buffer
  615. ; ecx      ; count to write in bytes
  616. ; edx      ; 0 create new , 1 append
  617. ; edi  pointer to path   /fd/1/......  - for all files in nested directories
  618. ;
  619. ; output : eax = 0 - ok
  620. ;                5 - file not found / directory not found
  621. ;                8 - disk full
  622. ;               10 - access denied
  623. ;-----------------------------------------------------------
  624.     mov    [path_pointer_flp],edi
  625.     sub  esp,32
  626.     call expand_filename
  627.     cmp  edx,0
  628.     jnz  fsdel_1
  629.     pusha
  630.     call floppy_filedelete
  631.     cmp    [FDC_Status],0
  632.     jne    fdc_status_error_6
  633.     popa
  634.     mov    [save_flag],1
  635. fsdel_1:
  636.     call   floppy_free_space
  637.     cmp    [FDC_Status],0
  638.     jne    fdc_status_error_6
  639.     cmp    ecx,edi
  640.     jb     rd_do_save_1
  641.     add    esp,32
  642.     mov    eax,8    ; not enough free space
  643.     mov   [flp_status],0
  644.     ret
  645.  
  646. fdc_status_error_6:
  647.     popa
  648.     add    esp,32
  649.     jmp    fdc_status_error_1
  650.  
  651. rd_do_save_1:
  652.     push   eax ebx ecx edx esi edi
  653.     call   read_flp_fat
  654.     cmp    [FDC_Status],0
  655.     jne    fdc_status_error_7
  656.     push   eax
  657.     mov    eax,[path_pointer_flp]
  658.     cmp    [eax+36],byte 0
  659.     jne    fifoundds_2
  660.     pop    eax
  661.     mov    [save_root_flag],1
  662.     call   read_flp_root
  663.     cmp    [FDC_Status],0
  664.     jne    fdc_status_error_7
  665.     mov    edi,0x8000   ;Point at directory
  666.     mov    edx,224 +1
  667.     ; find an empty spot for filename in the root dir
  668. l20ds_1:
  669.     sub    edx,1
  670.     jz     frnoreadds_1
  671. l21ds_1:
  672.     cmp    [edi],byte 0xE5
  673.     jz     fifoundds_1
  674.     cmp    [edi],byte 0x0
  675.     jz     fifoundds_1
  676.     add    edi,32            ; Advance to next entry
  677.     jmp    l20ds_1
  678.  
  679. fifoundds_2:
  680.     pop    eax
  681.     mov    [save_root_flag],0
  682.     mov    [FDD_Track],0      ; ╓шышэфЁ
  683.     mov    [FDD_Head],1       ; ╤ЄюЁюэр
  684.     mov    [FDD_Sector],2      ; ╤хъЄюЁ
  685.     call   SeekTrack
  686.     mov    dh,14
  687. l.20_3:
  688.     call    ReadSectWithRetr
  689.     cmp    [FDC_Status],0
  690.     jne    fdc_status_error_7
  691.     mov    dl,16
  692.     mov    edi,0xD000
  693.     inc     [FDD_Sector]
  694. l.21_3:
  695.     mov    esi,eax            ;Name of file we want
  696.     mov    ecx,11
  697.     cld
  698.     rep    cmpsb            ;Found the file?
  699.     je     fifoundds_3          ;Yes
  700.     add    ecx,21
  701.     add    edi, ecx         ;Advance to next entry
  702.     dec    dl
  703.     jne    l.21_3
  704.     dec    dh
  705.     jne    l.20_3
  706. fdc_status_error_8:
  707.     pop     edi esi edx ecx ebx eax
  708.     mov    eax,5            ; file not found ?
  709.     mov    ebx,-1
  710.     add    esp,32
  711.     mov    [flp_status],0
  712.     ret
  713.  
  714. fifoundds_3:
  715.     add    edi,0xf
  716.     mov    eax,[edi]
  717.     and    eax,65535
  718.     mov    ebx,[path_pointer_flp]
  719.     add    ebx,36
  720.     call   get_cluster_of_a_path_flp
  721.     jc     fdc_status_error_7_1
  722. found_directory_for_writing_flp:
  723.     call   analyze_directory_to_write_flp
  724.     jc     fdc_status_error_7_1
  725.     mov    edi,ebx
  726. fifoundds_1:
  727.     push   edi            ; move the filename to root dir
  728.     mov    esi,[esp+4+20]
  729.     cmp    [save_root_flag],0
  730.     jne    fifoundds_4
  731.     mov    esi,[pointer_file_name_flp]
  732. fifoundds_4:
  733.     mov    ecx,11
  734.     cld
  735.     rep    movsb
  736.     pop    edi
  737.     mov    edx,edi
  738.     add    edx,11+0xf        ; edx <- cluster save position
  739.     mov    ebx,[esp+12]        ; save file size
  740.     mov    [edi+28],ebx
  741.     mov    [edi+11],byte 0x20    ; attribute
  742.     call   get_date_for_file     ; from FAT32.INC
  743.     mov    [edi+24],ax      ; date
  744.     mov    [edi+18],ax      ; date
  745.     call   get_time_for_file     ; from FAT32.INC
  746.     mov    [edi+22],ax      ; time
  747.     xor    ax,ax
  748.     mov    [edi+20],ax
  749.     mov    ebx,1            ; first cluster
  750.     cmp    [save_root_flag],0
  751.     jne    frnewds_1
  752.     call   frnewds_2
  753.     pusha
  754.     call   WriteSectWithRetr
  755.     popa
  756.     cmp    [FDC_Status],0
  757.     jne    fdc_status_error_7
  758.     jmp    frnewds_3
  759.  
  760. frnewds_1:
  761.     call   frnewds_2
  762. frnewds_3:
  763.     pusha                ; move save to floppy cluster
  764.     add    ebx,31
  765.     mov    eax,ebx
  766.     mov    esi,[esp+32+16]
  767.     call   take_data_from_application_1
  768.     call   save_chs_sector
  769.     cmp    [FDC_Status],0
  770.     jne    fdc_status_error_7
  771.     popa
  772.     mov    eax,[esp+12]
  773.     cmp    eax,512
  774.     jb     flnsa_1
  775.     sub    eax,512
  776.     mov    [esp+12],eax
  777.     mov    eax,[esp+16]
  778.     add    eax,512
  779.     mov    [esp+16],eax
  780.     jmp    frnewds_1
  781.  
  782. frnewds_2:
  783.     add    ebx,1
  784.     mov    edi,ebx            ; find free cluster in FAT
  785.     shl    edi,1
  786.     add    edi,0x282000
  787.     mov    eax,[edi]
  788.     and    eax,4095
  789.     jnz    frnewds_2
  790.     mov    [edx],bx         ; save next cluster pos. to prev cl.
  791.     mov    edx,edi            ; next save pos abs mem add
  792.     ret
  793.  
  794. flnsa_1:
  795.     mov    [edi],word 4095        ; mark end of file - last cluster
  796.     cmp    [save_root_flag],1
  797.     jne    flnsa_2
  798.     call   save_flp_root
  799.     cmp    [FDC_Status],0
  800.     jne    fdc_status_error_7
  801. flnsa_2:
  802.     call   save_flp_fat
  803.     cmp    [FDC_Status],0
  804.     jne    fdc_status_error_7
  805. frnoreadds_1:
  806.     pop    edi esi edx ecx ebx eax
  807.     add    esp,32
  808.     mov    eax,0
  809.     mov   [flp_status],0
  810.     ret
  811.  
  812. fdc_status_error_7_1:
  813.     cmp    [FDC_Status],0
  814.     je    fdc_status_error_8
  815. fdc_status_error_7:
  816.     pop    edi esi edx ecx ebx eax
  817.     add    esp,32
  818.     jmp    fdc_status_error_1
  819.  
  820. save_chs_sector:
  821.     call    calculate_chs
  822.     call    WriteSectWithRetr
  823.     ret
  824.  
  825. calculate_chs:
  826.     mov    bl,[FDD_Track]
  827.     mov    [old_track],bl
  828.     mov    ebx,18
  829.     xor    edx,edx
  830.     div    ebx
  831.     inc    edx
  832.     mov    [FDD_Sector],dl
  833.     xor    edx,edx
  834.     mov    ebx,2
  835.     div    ebx
  836.     mov    [FDD_Track],al
  837.     mov    [FDD_Head],0
  838.     cmp    edx,0
  839.     je     no_head_2
  840.     inc    [FDD_Head]
  841. no_head_2:
  842.     mov     dl,[old_track]
  843.     cmp     dl,[FDD_Track]
  844.     je      no_seek_track_1
  845.     call    SeekTrack
  846. no_seek_track_1:
  847.     ret
  848.  
  849.  
  850. get_cluster_of_a_path_flp:
  851. ;---------------------------------------------------------
  852. ; input  : EBX = pointer to a path string
  853. ;          (example: the path "/files/data/document" become
  854. ;                             "files......data.......document...0"
  855. ;          '.' = space char
  856. ;          '0' = char(0) (ASCII=0) !!! )
  857. ; output : if (CARRY=1) -> ERROR in the PATH
  858. ;          if (CARRY=0) -> EAX=cluster
  859. ;---------------------------------------------------------
  860.  
  861.     push  edx
  862.     mov   edx,ebx
  863.  
  864. search_end_of_path_flp:
  865.     cmp   [save_flag],0
  866.     jne   search_end_of_path_flp_1
  867.     cmp   byte [edx],0
  868.     je    found_end_of_path_flp
  869.     jmp   search_end_of_path_flp_2
  870. search_end_of_path_flp_1:
  871.     cmp   byte [edx+12],0
  872.     je    found_end_of_path_flp
  873. search_end_of_path_flp_2:
  874.     inc   edx ; '/'
  875.     call  analyze_directory_flp
  876.     jc    directory_not_found_flp
  877.  
  878.     mov   eax,[ebx+20-2]        ; read the HIGH 16bit cluster field
  879.     mov   ax,[ebx+26]           ; read the LOW 16bit cluster field
  880.     and   eax,0xfff           ;[fatMASK]
  881.     add   edx,11                ; 8+3 (name+extension)
  882.     jmp   search_end_of_path_flp
  883.  
  884. found_end_of_path_flp:
  885.     inc   edx
  886.     mov   [pointer_file_name_flp],edx
  887.     pop   edx
  888.     clc                         ; no errors
  889.     ret
  890.  
  891. directory_not_found_flp:
  892.     pop   edx
  893.     stc                         ; errors occour
  894.     ret
  895.  
  896. analyze_directory_flp:
  897. ;--------------------------------
  898. ; input  : EAX = first cluster of the directory
  899. ;          EBX = pointer to filename
  900. ; output : IF CARRY=0 EAX = sector where th file is found
  901. ;                     EBX = pointer in buffer
  902. ;                     [buffer .. buffer+511]
  903. ;                     ECX,EDX,EDI,EDI not changed
  904. ;          IF CARRY=1
  905. ;--------------------------------
  906.    push ebx ;[esp+16]
  907.    push ecx
  908.    push edx
  909.    push esi
  910.    push edi
  911.  
  912.  
  913. adr56_flp:
  914.    mov [clust_tmp_flp],eax
  915.    add    eax,31
  916.    pusha
  917.    call   read_chs_sector
  918.    popa
  919.    cmp    [FDC_Status],0
  920.    jne    not_found_file_analyze_flp
  921.  
  922.    mov ecx,512/32
  923.    mov ebx,0xD000
  924.  
  925. adr1_analyze_flp:
  926.    mov esi,edx   ;[esp+16]
  927.    mov edi,ebx
  928.    cld
  929.    push ecx
  930.    mov ecx,11
  931.    rep cmpsb
  932.    pop ecx
  933.    je found_file_analyze_flp
  934.  
  935.    add ebx,32
  936.    loop adr1_analyze_flp
  937.  
  938.     mov eax,[clust_tmp_flp]
  939.     shl    eax,1            ;find next cluster from FAT
  940.     add    eax,0x282000
  941.     mov    eax,[eax]
  942.     and    eax,4095
  943.     cmp eax,0x0ff8
  944.     jb  adr56_flp
  945. not_found_file_analyze_flp:
  946.    pop edi
  947.    pop esi
  948.    pop edx
  949.    pop ecx
  950.    add esp,4
  951.    stc        ;file not found
  952.    ret
  953.  
  954. found_file_analyze_flp:
  955.    pop edi
  956.    pop esi
  957.    pop edx
  958.    pop ecx
  959.    add esp,4
  960.    clc        ;file found
  961.    ret
  962.  
  963.  
  964. analyze_directory_to_write_flp:
  965. ;--------------------------------
  966. ; input  : EAX = first cluster of the directory
  967. ; output : IF CARRY=0 EAX = sector where the file is found
  968. ;                     EBX = pointer in buffer
  969. ;                     [buffer .. buffer+511]
  970. ;                     ECX,EDX,EDI,EDI not changed
  971. ;          IF CARRY=1
  972. ;--------------------------------
  973.  
  974.    push ecx
  975.    push edx
  976.    push esi
  977.  
  978. adr561:
  979.    mov [clust_tmp_flp],eax
  980.    add    eax,31
  981.    pusha
  982.    call   read_chs_sector
  983.    popa
  984.    cmp    [FDC_Status],0
  985.    jne    error_found_file_analyze1
  986.  
  987.    mov ecx,512/32
  988.    mov ebx,0xD000
  989.  
  990. adr1_analyze1:
  991.    cmp byte [ebx],0x00
  992.    je  found_file_analyze1
  993.    cmp byte [ebx],0xe5
  994.    je  found_file_analyze1
  995.  
  996. avanti:
  997.    add ebx,32
  998.    loop adr1_analyze1
  999.  
  1000.    mov eax,[clust_tmp_flp]
  1001.    shl    eax,1            ;find next cluster from FAT
  1002.    add    eax,0x282000
  1003.    mov    eax,[eax]
  1004.    and    eax,4095
  1005.    cmp eax,0x0ff8
  1006.    jb  adr561
  1007.  
  1008.    call get_free_FAT               ;this block of code add a new cluster
  1009.                                    ;for the directory because the directory
  1010.                                    ;is full
  1011.  
  1012.    mov [edi],word 0x0fff
  1013.  
  1014.    mov eax,[clust_tmp_flp]
  1015.    shl    eax,1            ;find next cluster from FAT
  1016.    add    eax,0x282000
  1017.    sub    edi,0x282000
  1018.    mov    [eax],di
  1019.  
  1020.    pusha
  1021.    mov ecx,512/4
  1022.    xor eax,eax
  1023.    mov edi,0xD000
  1024.    cld
  1025.    rep stosd
  1026.    popa
  1027.  
  1028.    mov    eax,edi
  1029.    add    eax,31
  1030.    pusha
  1031.    call   save_chs_sector
  1032.    popa
  1033.    cmp    [FDC_Status],0
  1034.    jne    error_found_file_analyze1
  1035.    mov    ebx,0xD000
  1036.  
  1037. found_file_analyze1:
  1038.  
  1039.    pop esi
  1040.    pop edx
  1041.    pop ecx
  1042.    clc        ;file found
  1043.    ret
  1044.  
  1045. error_found_file_analyze1:
  1046.    pop esi
  1047.    pop edx
  1048.    pop ecx
  1049.    stc
  1050.    ret
  1051.  
  1052. get_free_FAT_flp:
  1053. ;------------------------------------------
  1054. ; input  :  EAX = # cluster for start the searching
  1055. ; output :  EAX = # first cluster found free
  1056. ;-------------------------------------------
  1057.    push ebx
  1058.  
  1059.     mov    ebx,1
  1060. check_new_flp:
  1061.     add    ebx,1
  1062.     mov    edi,ebx            ; find free cluster in FAT
  1063.     shl    edi,1
  1064.     add    edi,0x282000
  1065.     mov    eax,[edi]
  1066.     and    eax,4095
  1067.     cmp    eax,0x0
  1068.     jnz    check_new_flp
  1069.  
  1070.    pop ebx
  1071.    ret
  1072.  
  1073. ; \begin{diamond}
  1074. fat_find_lfn:
  1075. ; in: esi->name
  1076. ;     [esp+4] = next
  1077. ;     [esp+8] = first
  1078. ;     [esp+C]... - possibly parameters for first and next
  1079. ; out: CF=1 - file not found
  1080. ;      else CF=0, esi->next name component, edi->direntry
  1081.         pusha
  1082.         lea     eax, [esp+0Ch+20h]
  1083.         call    dword [eax-4]
  1084.         jc      .reterr
  1085.         sub     esp, 262*2      ; reserve place for LFN
  1086.         mov     ebp, esp
  1087.         push    0               ; for fat_get_name: read ASCII name
  1088. .l1:
  1089.         call    fat_get_name
  1090.         jc      .l2
  1091.         call    fat_compare_name
  1092.         jz      .found
  1093. .l2:
  1094.         lea     eax, [esp+0Ch+20h+262*2+4]
  1095.         call    dword [eax-8]
  1096.         jnc     .l1
  1097.         add     esp, 262*2+4
  1098. .reterr:
  1099.         stc
  1100.         popa
  1101.         ret
  1102. .found:
  1103.         add     esp, 262*2+4
  1104. ; if this is LFN entry, advance to true entry
  1105.         cmp     byte [edi+11], 0xF
  1106.         jnz     @f
  1107.         lea     eax, [esp+0Ch+20h]
  1108.         call    dword [eax-8]
  1109.         jc      .reterr
  1110. @@:
  1111.         add     esp, 8          ; CF=0
  1112.         push    esi
  1113.         push    edi
  1114.         popa
  1115.         ret
  1116.  
  1117. uglobal
  1118. ; this is for delete support
  1119. fd_prev_sector          dd      ?
  1120. fd_prev_prev_sector     dd      ?
  1121. endg
  1122.  
  1123. flp_root_next:
  1124.         cmp     edi, 0xD200-0x20
  1125.         jae     @f
  1126.         add     edi, 0x20
  1127.         ret     ; CF=0
  1128. @@:
  1129. ; read next sector
  1130.         inc     dword [eax]
  1131.         cmp     dword [eax], 14
  1132.         jae     flp_root_first.readerr
  1133.         push    [fd_prev_sector]
  1134.         pop     [fd_prev_prev_sector]
  1135.         push    eax
  1136.         mov     eax, [eax]
  1137.         add     eax, 19-1
  1138.         mov     [fd_prev_sector], eax
  1139.         pop     eax
  1140. flp_root_first:
  1141.         mov     eax, [eax]
  1142.         pusha
  1143.         add     eax, 19
  1144.         call    read_chs_sector
  1145.         popa
  1146.         cmp     [FDC_Status], 0
  1147.         jnz     .readerr
  1148.         mov     edi, 0xD000
  1149.         ret     ; CF=0
  1150. .readerr:
  1151.         stc
  1152.         ret
  1153.  
  1154. flp_rootmem_first:
  1155.         mov     edi, 0x8000
  1156.         clc
  1157.         ret
  1158. flp_rootmem_next:
  1159.         add     edi, 0x20
  1160.         cmp     edi, 0x8000+14*0x200
  1161.         cmc
  1162. flp_rootmem_next_write:
  1163. flp_rootmem_begin_write:
  1164. flp_rootmem_end_write:
  1165.         ret
  1166. flp_rootmem_extend_dir:
  1167.         stc
  1168.         ret
  1169.  
  1170. flp_notroot_next:
  1171.         cmp     edi, 0xD200-0x20
  1172.         jae     flp_notroot_next_sector
  1173.         add     edi, 0x20
  1174.         ret     ; CF=0
  1175. flp_notroot_next_sector:
  1176.         push    ecx
  1177.         mov     ecx, [eax]
  1178.         push    [fd_prev_sector]
  1179.         pop     [fd_prev_prev_sector]
  1180.         add     ecx, 31
  1181.         mov     [fd_prev_sector], ecx
  1182.         mov     ecx, [(ecx-31)*2+0x282000]
  1183.         and     ecx, 0xFFF
  1184.         cmp     ecx, 2849
  1185.         jae     flp_notroot_first.err2
  1186.         mov     [eax], ecx
  1187.         pop     ecx
  1188. flp_notroot_first:
  1189.         mov     eax, [eax]
  1190.         cmp     eax, 2
  1191.         jb      .err
  1192.         cmp     eax, 2849
  1193.         jae     .err
  1194.         pusha
  1195.         add     eax, 31
  1196.         call    read_chs_sector
  1197.         popa
  1198.         mov     edi, 0xD000
  1199.         cmp     [FDC_Status], 0
  1200.         jnz     .err
  1201.         ret     ; CF=0
  1202. .err2:
  1203.         pop     ecx
  1204. .err:
  1205.         stc
  1206.         ret
  1207. flp_notroot_begin_write:
  1208.         pusha
  1209.         mov     eax, [eax]
  1210.         add     eax, 31
  1211.         call    read_chs_sector
  1212.         popa
  1213.         ret
  1214. flp_notroot_end_write:
  1215.         pusha
  1216.         mov     eax, [eax]
  1217.         add     eax, 31
  1218.         call    save_chs_sector
  1219.         popa
  1220.         ret
  1221. flp_notroot_next_write:
  1222.         cmp     edi, 0xD200
  1223.         jae     @f
  1224.         ret
  1225. @@:
  1226.         call    flp_notroot_end_write
  1227.         jmp     flp_notroot_next_sector
  1228. flp_notroot_extend_dir:
  1229. ; find free cluster in FAT
  1230.         pusha
  1231.         xor     eax, eax
  1232.         mov     edi, 0x282000
  1233.         mov     ecx, 2849
  1234.         repnz   scasw
  1235.         jnz     .notfound
  1236.         mov     word [edi-2], 0xFFF     ; mark as last cluster
  1237.         sub     edi, 0x282000
  1238.         shr     edi, 1
  1239.         dec     edi
  1240.         mov     eax, [esp+28]
  1241.         mov     ecx, [eax]
  1242.         mov     [0x282000+ecx*2], di
  1243.         mov     [eax], edi
  1244.         xor     eax, eax
  1245.         mov     edi, 0xD000
  1246.         mov     ecx, 128
  1247.         rep     stosd
  1248.         popa
  1249.         call    flp_notroot_end_write
  1250.         mov     edi, 0xD000
  1251.         clc
  1252.         ret
  1253. .notfound:
  1254.         popa
  1255.         stc
  1256.         ret
  1257.  
  1258. fd_find_lfn:
  1259. ; in: esi->name
  1260. ; out: CF=1 - file not found
  1261. ;      else CF=0 and edi->direntry, eax=directory cluster (0 for root)
  1262.         push    esi edi
  1263.         push    0
  1264.         push    flp_root_first
  1265.         push    flp_root_next
  1266. .loop:
  1267.         call    fat_find_lfn
  1268.         jc      .notfound
  1269.         cmp     byte [esi], 0
  1270.         jz      .found
  1271.         test    byte [edi+11], 10h
  1272.         jz      .notfound
  1273.         movzx   eax, word [edi+26]      ; cluster
  1274.         mov     [esp+8], eax
  1275.         mov     dword [esp+4], flp_notroot_first
  1276.         mov     dword [esp], flp_notroot_next
  1277.         jmp     .loop
  1278. .notfound:
  1279.         add     esp, 12
  1280.         pop     edi esi
  1281.         stc
  1282.         ret
  1283. .found:
  1284.         mov     eax, [esp+8]
  1285.         add     eax, 31
  1286.         cmp     dword [esp], flp_root_next
  1287.         jnz     @f
  1288.         add     eax, -31+19
  1289. @@:
  1290.         add     esp, 16         ; CF=0
  1291.         pop     esi
  1292.         ret
  1293.  
  1294. ;----------------------------------------------------------------
  1295. ;
  1296. ;  fs_FloppyRead - LFN variant for reading floppy
  1297. ;
  1298. ;  esi  points to filename
  1299. ;  ebx  pointer to 64-bit number = first wanted byte, 0+
  1300. ;       may be ebx=0 - start from first byte
  1301. ;  ecx  number of bytes to read, 0+
  1302. ;  edx  mem location to return data
  1303. ;
  1304. ;  ret ebx = bytes read or 0xffffffff file not found
  1305. ;      eax = 0 ok read or other = errormsg
  1306. ;
  1307. ;--------------------------------------------------------------
  1308. fs_FloppyRead:
  1309.         call    read_flp_fat
  1310.         cmp     byte [esi], 0
  1311.         jnz     @f
  1312.         or      ebx, -1
  1313.         mov     eax, 10         ; access denied
  1314.         ret
  1315. @@:
  1316.         push    edi
  1317.         call    fd_find_lfn
  1318.         jnc     .found
  1319.         pop     edi
  1320.         or      ebx, -1
  1321.         mov     eax, 5          ; file not found
  1322.         ret
  1323. .found:
  1324.         test    ebx, ebx
  1325.         jz      .l1
  1326.         cmp     dword [ebx+4], 0
  1327.         jz      @f
  1328.         xor     ebx, ebx
  1329. .reteof:
  1330.         mov     eax, 6          ; EOF
  1331.         pop     edi
  1332.         ret
  1333. @@:
  1334.         mov     ebx, [ebx]
  1335. .l1:
  1336.         push    ecx edx
  1337.         push    0
  1338.         mov     eax, [edi+28]
  1339.         sub     eax, ebx
  1340.         jb      .eof
  1341.         cmp     eax, ecx
  1342.         jae     @f
  1343.         mov     ecx, eax
  1344.         mov     byte [esp], 6           ; EOF
  1345. @@:
  1346.         movzx   edi, word [edi+26]
  1347. .new:
  1348.         jecxz   .done
  1349.         test    edi, edi
  1350.         jz      .eof
  1351.         cmp     edi, 0xFF8
  1352.         jae     .eof
  1353.         sub     ebx, 512
  1354.         jae     .skip
  1355.         lea     eax, [edi+31]
  1356.         pusha
  1357.         call    read_chs_sector
  1358.         popa
  1359.         cmp     [FDC_Status], 0
  1360.         jnz     .err
  1361.         lea     eax, [0xD000+ebx+512]
  1362.         neg     ebx
  1363.         push    ecx
  1364.         cmp     ecx, ebx
  1365.         jbe     @f
  1366.         mov     ecx, ebx
  1367. @@:
  1368.         mov     ebx, edx
  1369.         call    memmove
  1370.         add     edx, ecx
  1371.         sub     [esp], ecx
  1372.         pop     ecx
  1373.         xor     ebx, ebx
  1374. .skip:
  1375.         movzx   edi, word [edi*2+0x282000]
  1376.         jmp     .new
  1377. .done:
  1378.         mov     ebx, edx
  1379.         pop     eax edx ecx edi
  1380.         sub     ebx, edx
  1381.         ret
  1382. .eof:
  1383.         mov     ebx, edx
  1384.         pop     eax edx ecx
  1385.         jmp     .reteof
  1386. .err:
  1387.         mov     ebx, edx
  1388.         pop     eax edx ecx edi
  1389.         sub     ebx, edx
  1390.         mov     al, 11
  1391.         ret
  1392.  
  1393. ;----------------------------------------------------------------
  1394. ;
  1395. ;  fs_FloppyReadFolder - LFN variant for reading floppy folders
  1396. ;
  1397. ;  esi  points to filename
  1398. ;  ebx  pointer to structure: 32-bit number = first wanted block, 0+
  1399. ;                           & flags (bitfields)
  1400. ; flags: bit 0: 0=ANSI names, 1=UNICODE names
  1401. ;  ecx  number of blocks to read, 0+
  1402. ;  edx  mem location to return data
  1403. ;
  1404. ;  ret ebx = blocks read or 0xffffffff folder not found
  1405. ;      eax = 0 ok read or other = errormsg
  1406. ;
  1407. ;--------------------------------------------------------------
  1408. fs_FloppyReadFolder:
  1409.         call    read_flp_fat
  1410.         push    edi
  1411.         cmp     byte [esi], 0
  1412.         jz      .root
  1413.         call    fd_find_lfn
  1414.         jnc     .found
  1415.         pop     edi
  1416.         or      ebx, -1
  1417.         mov     eax, ERROR_FILE_NOT_FOUND
  1418.         ret
  1419. .found:
  1420.         test    byte [edi+11], 0x10     ; do not allow read files
  1421.         jnz     .found_dir
  1422.         pop     edi
  1423.         or      ebx, -1
  1424.         mov     eax, ERROR_ACCESS_DENIED
  1425.         ret
  1426. .found_dir:
  1427.         movzx   eax, word [edi+26]
  1428.         add     eax, 31
  1429.         push    0
  1430.         jmp     .doit
  1431. .root:
  1432.         mov     eax, 19
  1433.         push    14
  1434. .doit:
  1435.         push    ecx ebp
  1436.         sub     esp, 262*2      ; reserve space for LFN
  1437.         mov     ebp, esp
  1438.         push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE names
  1439.         mov     ebx, [ebx]
  1440. ; init header
  1441.         push    eax ecx
  1442.         mov     edi, edx
  1443.         mov     ecx, 32/4
  1444.         xor     eax, eax
  1445.         rep     stosd
  1446.         pop     ecx eax
  1447.         mov     byte [edx], 1   ; version
  1448.         mov     esi, edi        ; esi points to BDFE
  1449. .main_loop:
  1450.         pusha
  1451.         call    read_chs_sector
  1452.         popa
  1453.         cmp     [FDC_Status], 0
  1454.         jnz     .error
  1455.         mov     edi, 0xD000
  1456.         push    eax
  1457. .l1:
  1458.         call    fat_get_name
  1459.         jc      .l2
  1460.         cmp     byte [edi+11], 0xF
  1461.         jnz     .do_bdfe
  1462.         add     edi, 0x20
  1463.         cmp     edi, 0xD200
  1464.         jb      .do_bdfe
  1465.         pop     eax
  1466.         inc     eax
  1467.         dec     byte [esp+262*2+12]
  1468.         jz      .done
  1469.         jns     @f
  1470. ; read next sector from FAT
  1471.         mov     eax, [(eax-31-1)*2+0x282000]
  1472.         and     eax, 0xFFF
  1473.         cmp     eax, 0xFF8
  1474.         jae     .done
  1475.         add     eax, 31
  1476.         mov     byte [esp+262*2+12], 0
  1477. @@:
  1478.         pusha
  1479.         call    read_chs_sector
  1480.         popa
  1481.         cmp     [FDC_Status], 0
  1482.         jnz     .error
  1483.         mov     edi, 0xD000
  1484.         push    eax
  1485. .do_bdfe:
  1486.         inc     dword [edx+8]   ; new file found
  1487.         dec     ebx
  1488.         jns     .l2
  1489.         dec     ecx
  1490.         js      .l2
  1491.         inc     dword [edx+4]   ; new file block copied
  1492.         call    fat_entry_to_bdfe
  1493. .l2:
  1494.         add     edi, 0x20
  1495.         cmp     edi, 0xD200
  1496.         jb      .l1
  1497.         pop     eax
  1498.         inc     eax
  1499.         dec     byte [esp+262*2+12]
  1500.         jz      .done
  1501.         jns     @f
  1502. ; read next sector from FAT
  1503.         mov     eax, [(eax-31-1)*2+0x282000]
  1504.         and     eax, 0xFFF
  1505.         cmp     eax, 0xFF8
  1506.         jae     .done
  1507.         add     eax, 31
  1508.         mov     byte [esp+262*2+12], 0
  1509. @@:
  1510.         jmp     .main_loop
  1511. .error:
  1512.         add     esp, 262*2+4
  1513.         pop     ebp ecx edi edi
  1514.         or      ebx, -1
  1515.         mov     eax, ERROR_FILE_NOT_FOUND
  1516.         ret
  1517. .done:
  1518.         add     esp, 262*2+4
  1519.         pop     ebp
  1520.         mov     ebx, [edx+4]
  1521.         xor     eax, eax
  1522.         dec     ecx
  1523.         js      @f
  1524.         mov     al, ERROR_END_OF_FILE
  1525. @@:
  1526.         pop     ecx edi edi
  1527.         ret
  1528.  
  1529. ;----------------------------------------------------------------
  1530. ;
  1531. ;  fs_FloppyRewrite - LFN variant for writing sys floppy
  1532. ;
  1533. ;  esi  points to filename
  1534. ;  ebx  ignored (reserved)
  1535. ;  ecx  number of bytes to write, 0+
  1536. ;  edx  mem location to data
  1537. ;
  1538. ;  ret ebx = number of written bytes
  1539. ;      eax = 0 ok read or other = errormsg
  1540. ;
  1541. ;--------------------------------------------------------------
  1542. @@:
  1543.         mov     eax, ERROR_ACCESS_DENIED
  1544.         xor     ebx, ebx
  1545.         ret
  1546. fsfrfe2:
  1547.         popad
  1548. fsfrfe:
  1549.         mov     eax, 11
  1550.         xor     ebx, ebx
  1551.         ret
  1552.  
  1553. fs_FloppyRewrite:
  1554.         cmp     byte [esi], 0
  1555.         jz      @b
  1556.         call    read_flp_fat
  1557.         cmp     [FDC_Status], 0
  1558.         jnz     fsfrfe
  1559.         pushad
  1560.         xor     ebp, ebp
  1561.         push    esi
  1562. @@:
  1563.         lodsb
  1564.         test    al, al
  1565.         jz      @f
  1566.         cmp     al, '/'
  1567.         jnz     @b
  1568.         lea     ebp, [esi-1]
  1569.         jmp     @b
  1570. @@:
  1571.         pop     esi
  1572.         test    ebp, ebp
  1573.         jnz     .noroot
  1574.         call    read_flp_root
  1575.         cmp     [FDC_Status], 0
  1576.         jnz     fsfrfe2
  1577.         push    flp_rootmem_extend_dir
  1578.         push    flp_rootmem_end_write
  1579.         push    flp_rootmem_next_write
  1580.         push    flp_rootmem_begin_write
  1581.         xor     ebp, ebp
  1582.         push    ebp
  1583.         push    flp_rootmem_first
  1584.         push    flp_rootmem_next
  1585.         jmp     .common1
  1586. .noroot:
  1587. ; check existence
  1588.         mov     byte [ebp], 0
  1589.         call    fd_find_lfn
  1590.         mov     byte [ebp], '/'
  1591.         lea     esi, [ebp+1]
  1592.         jnc     @f
  1593.         mov     eax, ERROR_FILE_NOT_FOUND
  1594. .ret1:
  1595.         mov     [esp+28], eax
  1596.         popad
  1597.         xor     ebx, ebx
  1598.         ret
  1599. @@:
  1600.         test    byte [edi+11], 0x10     ; must be directory
  1601.         mov     eax, ERROR_ACCESS_DENIED
  1602.         jz      .ret1
  1603.         movzx   ebp, word [edi+26]      ; ebp=cluster
  1604.         mov     eax, ERROR_FAT_TABLE
  1605.         cmp     ebp, 2
  1606.         jb      .ret1
  1607.         cmp     ebp, 2849
  1608.         jae     .ret1
  1609.         push    flp_notroot_extend_dir
  1610.         push    flp_notroot_end_write
  1611.         push    flp_notroot_next_write
  1612.         push    flp_notroot_begin_write
  1613.         push    ebp
  1614.         push    flp_notroot_first
  1615.         push    flp_notroot_next
  1616. .common1:
  1617.         call    fat_find_lfn
  1618.         jc      .notfound
  1619. ; found; must not be directory
  1620.         test    byte [edi+11], 10h
  1621.         jz      @f
  1622.         add     esp, 28
  1623.         popad
  1624.         mov     eax, ERROR_ACCESS_DENIED
  1625.         xor     ebx, ebx
  1626.         ret
  1627. @@:
  1628. ; delete FAT chain
  1629.         push    edi
  1630.         xor     eax, eax
  1631.         mov     dword [edi+28], eax     ; zero size
  1632.         xchg    ax, word [edi+26]       ; start cluster
  1633.         test    eax, eax
  1634.         jz      .done1
  1635. @@:
  1636.         cmp     eax, 0xFF8
  1637.         jae     .done1
  1638.         lea     edi, [0x282000 + eax*2] ; position in FAT
  1639.         xor     eax, eax
  1640.         xchg    ax, [edi]
  1641.         jmp     @b
  1642. .done1:
  1643.         pop     edi
  1644.         call    get_time_for_file
  1645.         mov     [edi+22], ax
  1646.         call    get_date_for_file
  1647.         mov     [edi+24], ax
  1648.         mov     [edi+18], ax
  1649.         or      byte [edi+11], 20h      ; set 'archive' attribute
  1650.         jmp     .doit
  1651. .notfound:
  1652. ; file is not found; generate short name
  1653.         call    fat_name_is_legal
  1654.         jc      @f
  1655.         add     esp, 28
  1656.         popad
  1657.         mov     eax, ERROR_FILE_NOT_FOUND
  1658.         xor     ebx, ebx
  1659.         ret
  1660. @@:
  1661.         sub     esp, 12
  1662.         mov     edi, esp
  1663.         call    fat_gen_short_name
  1664. .test_short_name_loop:
  1665.         push    esi edi ecx
  1666.         mov     esi, edi
  1667.         lea     eax, [esp+12+12+8]
  1668.         mov     [eax], ebp
  1669.         call    dword [eax-4]
  1670.         jc      .found
  1671. .test_short_name_entry:
  1672.         cmp     byte [edi+11], 0xF
  1673.         jz      .test_short_name_cont
  1674.         mov     ecx, 11
  1675.         push    esi edi
  1676.         repz    cmpsb
  1677.         pop     edi esi
  1678.         jz      .short_name_found
  1679. .test_short_name_cont:
  1680.         lea     eax, [esp+12+12+8]
  1681.         call    dword [eax-8]
  1682.         jnc     .test_short_name_entry
  1683.         jmp     .found
  1684. .short_name_found:
  1685.         pop     ecx edi esi
  1686.         call    fat_next_short_name
  1687.         jnc     .test_short_name_loop
  1688. .disk_full:
  1689.         add     esp, 12+28
  1690.         popa
  1691.         mov     eax, ERROR_DISK_FULL
  1692.         xor     ebx, ebx
  1693.         ret
  1694. .found:
  1695.         pop     ecx edi esi
  1696. ; now find space in directory
  1697. ; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
  1698.         mov     al, '~'
  1699.         push    ecx edi
  1700.         mov     ecx, 8
  1701.         repnz   scasb
  1702.         push    1
  1703.         pop     eax     ; 1 entry
  1704.         jnz     .notilde
  1705. ; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
  1706.         xor     eax, eax
  1707. @@:
  1708.         cmp     byte [esi], 0
  1709.         jz      @f
  1710.         inc     esi
  1711.         inc     eax
  1712.         jmp     @b
  1713. @@:
  1714.         sub     esi, eax
  1715.         add     eax, 12+13
  1716.         mov     ecx, 13
  1717.         push    edx
  1718.         cdq
  1719.         div     ecx
  1720.         pop     edx
  1721. .notilde:
  1722.         push    -1
  1723.         push    -1
  1724. ; find <eax> successive entries in directory
  1725.         xor     ecx, ecx
  1726.         push    eax
  1727.         lea     eax, [esp+12+8+12+8]
  1728.         mov     [eax], ebp
  1729.         call    dword [eax-4]
  1730.         pop     eax
  1731.         jnc     .scan_dir
  1732. .fsfrfe3:
  1733.         add     esp, 8+8+12+28
  1734.         popad
  1735.         mov     eax, 11
  1736.         xor     ebx, ebx
  1737.         ret
  1738. .scan_dir:
  1739.         cmp     byte [edi], 0
  1740.         jz      .free
  1741.         cmp     byte [edi], 0xE5
  1742.         jz      .free
  1743.         xor     ecx, ecx
  1744. .scan_cont:
  1745.         push    eax
  1746.         lea     eax, [esp+12+8+12+8]
  1747.         call    dword [eax-8]
  1748.         pop     eax
  1749.         jnc     .scan_dir
  1750.         cmp     [FDC_Status], 0
  1751.         jnz     .fsfrfe3
  1752.         push    eax
  1753.         lea     eax, [esp+12+8+12+8]
  1754.         call    dword [eax+16]          ; extend directory
  1755.         pop     eax
  1756.         jnc     .scan_dir
  1757.         add     esp, 8+8+12+28
  1758.         popad
  1759.         mov     eax, ERROR_DISK_FULL
  1760.         xor     ebx, ebx
  1761.         ret
  1762. .free:
  1763.         test    ecx, ecx
  1764.         jnz     @f
  1765.         mov     [esp], edi
  1766.         mov     ecx, [esp+8+8+12+8]
  1767.         mov     [esp+4], ecx
  1768.         xor     ecx, ecx
  1769. @@:
  1770.         inc     ecx
  1771.         cmp     ecx, eax
  1772.         jb      .scan_cont
  1773. ; found!
  1774. ; calculate name checksum
  1775.         push    esi ecx
  1776.         mov     esi, [esp+8+8]
  1777.         mov     ecx, 11
  1778.         xor     eax, eax
  1779. @@:
  1780.         ror     al, 1
  1781.         add     al, [esi]
  1782.         inc     esi
  1783.         loop    @b
  1784.         pop     ecx esi
  1785.         pop     edi
  1786.         pop     dword [esp+8+12+8]
  1787. ; edi points to first entry in free chunk
  1788.         dec     ecx
  1789.         jz      .nolfn
  1790.         push    esi
  1791.         push    eax
  1792.         lea     eax, [esp+8+8+12+8]
  1793.         call    dword [eax+4]         ; begin write
  1794.         mov     al, 40h
  1795. .writelfn:
  1796.         or      al, cl
  1797.         mov     esi, [esp+4]
  1798.         push    ecx
  1799.         dec     ecx
  1800.         imul    ecx, 13
  1801.         add     esi, ecx
  1802.         stosb
  1803.         mov     cl, 5
  1804.         call    fs_RamdiskRewrite.read_symbols
  1805.         mov     ax, 0xF
  1806.         stosw
  1807.         mov     al, [esp+4]
  1808.         stosb
  1809.         mov     cl, 6
  1810.         call    fs_RamdiskRewrite.read_symbols
  1811.         xor     eax, eax
  1812.         stosw
  1813.         mov     cl, 2
  1814.         call    fs_RamdiskRewrite.read_symbols
  1815.         pop     ecx
  1816.         lea     eax, [esp+8+8+12+8]
  1817.         call    dword [eax+8]         ; next write
  1818.         xor     eax, eax
  1819.         loop    .writelfn
  1820.         pop     eax
  1821.         pop     esi
  1822. ;        lea     eax, [esp+8+12+8]
  1823. ;        call    dword [eax+12]          ; end write
  1824. .nolfn:
  1825.         xchg    esi, [esp]
  1826.         mov     ecx, 11
  1827.         rep     movsb
  1828.         mov     word [edi], 20h         ; attributes
  1829.         sub     edi, 11
  1830.         pop     esi ecx
  1831.         add     esp, 12
  1832.         mov     byte [edi+13], 0        ; tenths of a second at file creation time
  1833.         call    get_time_for_file
  1834.         mov     [edi+14], ax            ; creation time
  1835.         mov     [edi+22], ax            ; last write time
  1836.         call    get_date_for_file
  1837.         mov     [edi+16], ax            ; creation date
  1838.         mov     [edi+24], ax            ; last write date
  1839.         mov     [edi+18], ax            ; last access date
  1840.         and     word [edi+20], 0        ; high word of cluster
  1841.         and     word [edi+26], 0        ; low word of cluster - to be filled
  1842.         and     dword [edi+28], 0       ; file size - to be filled
  1843. .doit:
  1844.         lea     eax, [esp+8]
  1845.         call    dword [eax+12]  ; flush directory
  1846.         push    ecx
  1847.         push    edi
  1848.         push    0
  1849.         mov     esi, edx
  1850.         jecxz   .done
  1851.         mov     ecx, 2849
  1852.         mov     edi, 0x282000
  1853.         push    0       ; first cluster
  1854. .write_loop:
  1855. ; allocate new cluster
  1856.         xor     eax, eax
  1857.         repnz   scasw
  1858.         mov     al, ERROR_DISK_FULL
  1859.         jnz     .ret
  1860.         dec     edi
  1861.         dec     edi
  1862.         lea     eax, [edi-0x282000]
  1863.         shr     eax, 1                  ; eax = cluster
  1864.         mov     word [edi], 0xFFF       ; mark as last cluster
  1865.         xchg    edi, [esp+4]
  1866.         cmp     dword [esp], 0
  1867.         jz      .first
  1868.         stosw
  1869.         jmp     @f
  1870. .first:
  1871.         mov     [esp], eax
  1872. @@:
  1873.         mov     edi, [esp+4]
  1874.         inc     ecx
  1875. ; write data
  1876.         push    ecx edi
  1877.         mov     ecx, 512
  1878.         cmp     dword [esp+20], ecx
  1879.         jae     @f
  1880.         mov     ecx, [esp+20]
  1881. @@:
  1882.         push    ecx
  1883.         mov     edi, 0xD000
  1884.         rep     movsb
  1885.         pop     ecx
  1886.         push    ecx
  1887.         sub     ecx, 512
  1888.         neg     ecx
  1889.         push    eax
  1890.         xor     eax, eax
  1891.         rep     stosb
  1892.         pop     eax
  1893.         add     eax, 31
  1894.         pusha
  1895.         call    save_chs_sector
  1896.         popa
  1897.         pop     ecx
  1898.         cmp     [FDC_Status], 0
  1899.         jnz     .diskerr
  1900.         sub     [esp+20], ecx
  1901.         pop     edi ecx
  1902.         jnz     .write_loop
  1903. .done:
  1904.         xor     eax, eax
  1905. .ret:
  1906.         pop     ebx edi edi ecx
  1907.         mov     [esp+28+28], eax
  1908.         lea     eax, [esp+8]
  1909.         call    dword [eax+4]
  1910.         mov     [edi+26], bx
  1911.         mov     ebx, esi
  1912.         sub     ebx, edx
  1913.         mov     [edi+28], ebx
  1914.         call    dword [eax+12]
  1915.         mov     [esp+28+16], ebx
  1916.         test    ebp, ebp
  1917.         jnz     @f
  1918.         call    save_flp_root
  1919. @@:
  1920.         add     esp, 28
  1921.         cmp     [FDC_Status], 0
  1922.         jnz     .err3
  1923.         call    save_flp_fat
  1924.         cmp     [FDC_Status], 0
  1925.         jnz     .err3
  1926.         popa
  1927.         ret
  1928. .err3:
  1929.         popa
  1930.         mov     al, 11
  1931.         xor     ebx, ebx
  1932.         ret
  1933. .diskerr:
  1934.         sub     esi, ecx
  1935.         mov     eax, 11
  1936.         pop     edi ecx
  1937.         jmp     .ret
  1938.  
  1939. ;----------------------------------------------------------------
  1940. ;
  1941. ;  fs_FloppyWrite - LFN variant for writing to floppy
  1942. ;
  1943. ;  esi  points to filename
  1944. ;  ebx  pointer to 64-bit number = first wanted byte, 0+
  1945. ;       may be ebx=0 - start from first byte
  1946. ;  ecx  number of bytes to write, 0+
  1947. ;  edx  mem location to data
  1948. ;
  1949. ;  ret ebx = bytes written (maybe 0)
  1950. ;      eax = 0 ok write or other = errormsg
  1951. ;
  1952. ;--------------------------------------------------------------
  1953.  
  1954. @@:
  1955.         push    ERROR_ACCESS_DENIED
  1956. fs_FloppyWrite.ret0:
  1957.         pop     eax
  1958.         xor     ebx, ebx
  1959.         ret
  1960.  
  1961. fs_FloppyWrite.ret11:
  1962.         push    11
  1963.         jmp     fs_FloppyWrite.ret0
  1964.  
  1965. fs_FloppyWrite:
  1966.         cmp     byte [esi], 0
  1967.         jz      @b
  1968.         call    read_flp_fat
  1969.         cmp     [FDC_Status], 0
  1970.         jnz     .ret11
  1971.         pushad
  1972.         call    fd_find_lfn
  1973.         jnc     .found
  1974.         popad
  1975.         push    ERROR_FILE_NOT_FOUND
  1976.         jmp     .ret0
  1977. .found:
  1978. ; FAT does not support files larger than 4GB
  1979.         test    ebx, ebx
  1980.         jz      .l1
  1981.         cmp     dword [ebx+4], 0
  1982.         jz      @f
  1983. .eof:
  1984.         popad
  1985.         push    ERROR_END_OF_FILE
  1986.         jmp     .ret0
  1987. @@:
  1988.         mov     ebx, [ebx]
  1989. .l1:
  1990. ; now edi points to direntry, ebx=start byte to write,
  1991. ; ecx=number of bytes to write, edx=data pointer
  1992.  
  1993. ; extend file if needed
  1994.         add     ecx, ebx
  1995.         jc      .eof    ; FAT does not support files larger than 4GB
  1996.         push    eax     ; save directory cluster
  1997.         push    0       ; return value=0
  1998.  
  1999.         call    get_time_for_file
  2000.         mov     [edi+22], ax            ; last write time
  2001.         call    get_date_for_file
  2002.         mov     [edi+24], ax            ; last write date
  2003.         mov     [edi+18], ax            ; last access date
  2004.  
  2005.         push    dword [edi+28]          ; save current file size
  2006.         cmp     ecx, [edi+28]
  2007.         jbe     .length_ok
  2008.         cmp     ecx, ebx
  2009.         jz      .length_ok
  2010.         call    floppy_extend_file
  2011.         jnc     .length_ok
  2012.         mov     [esp+4], eax
  2013. ; floppy_extend_file can return two error codes: FAT table error or disk full.
  2014. ; First case is fatal error, in second case we may write some data
  2015.         cmp     al, ERROR_DISK_FULL
  2016.         jz      .disk_full
  2017.         pop     eax
  2018.         pop     eax
  2019.         mov     [esp+4+28], eax
  2020.         pop     eax
  2021.         popad
  2022.         xor     ebx, ebx
  2023.         ret
  2024. .disk_full:
  2025. ; correct number of bytes to write
  2026.         mov     ecx, [edi+28]
  2027.         cmp     ecx, ebx
  2028.         ja      .length_ok
  2029. .ret:
  2030.         pop     eax
  2031.         pop     eax
  2032.         mov     [esp+4+28], eax ; eax=return value
  2033.         pop     eax
  2034.         sub     edx, [esp+20]
  2035.         mov     [esp+16], edx   ; ebx=number of written bytes
  2036.         popad
  2037.         ret
  2038. .length_ok:
  2039. ; save FAT & directory
  2040. ; note that directory must be saved first because save_flp_fat uses buffer at 0xD000
  2041.         mov     esi, [edi+28]
  2042.         movzx   edi, word [edi+26]      ; starting cluster
  2043.         mov     eax, [esp+8]
  2044.         pusha
  2045.         call    save_chs_sector
  2046.         popa
  2047.         cmp     [FDC_Status], 0
  2048.         jnz     .device_err
  2049.         call    save_flp_fat
  2050.         cmp     [FDC_Status], 0
  2051.         jz      @f
  2052. .device_err:
  2053.         mov     byte [esp+4], 11
  2054.         jmp     .ret
  2055. @@:
  2056.  
  2057. ; now ebx=start pos, ecx=end pos, both lie inside file
  2058.         sub     ecx, ebx
  2059.         jz      .ret
  2060.         call    SetUserInterrupts
  2061. .write_loop:
  2062.         lea     eax, [edi+31]   ; current sector
  2063. ; get length of data in current sector
  2064.         push    ecx
  2065.         sub     ebx, 0x200
  2066.         jb      .hasdata
  2067.         neg     ebx
  2068.         xor     ecx, ecx
  2069.         jmp     @f
  2070. .hasdata:
  2071.         neg     ebx
  2072.         cmp     ecx, ebx
  2073.         jbe     @f
  2074.         mov     ecx, ebx
  2075. @@:
  2076. ; load sector if needed
  2077.         cmp     dword [esp+4], 0        ; we don't need to read uninitialized data
  2078.         jz      .noread
  2079.         cmp     ecx, 0x200      ; we don't need to read sector if it is fully rewritten
  2080.         jz      .noread
  2081.         cmp     ecx, esi        ; (same for the last sector)
  2082.         jz      .noread
  2083.         pusha
  2084.         call    read_chs_sector
  2085.         popa
  2086.         cmp     [FDC_Status], 0
  2087.         jz      @f
  2088. .device_err2:
  2089.         pop     ecx
  2090.         jmp     .device_err
  2091. @@:
  2092. .noread:
  2093. ; zero uninitialized data if file was extended (because floppy_extend_file does not this)
  2094.         push    eax ecx edi
  2095.         xor     eax, eax
  2096.         mov     ecx, 0x200
  2097.         sub     ecx, [esp+4+12]
  2098.         jbe     @f
  2099.         mov     edi, 0xD000
  2100.         add     edi, [esp+4+12]
  2101.         rep     stosb
  2102. @@:
  2103. ; zero uninitialized data in the last sector
  2104.         mov     ecx, 0x200
  2105.         sub     ecx, esi
  2106.         jbe     @f
  2107.         mov     edi, 0xD000
  2108.         add     edi, esi
  2109.         rep     stosb
  2110. @@:
  2111.         pop     edi ecx eax
  2112. ; copy new data
  2113.         push    eax
  2114.         mov     eax, edx
  2115.         neg     ebx
  2116.         jecxz   @f
  2117.         add     ebx, 0xD000+0x200
  2118.         call    memmove
  2119.         xor     ebx, ebx
  2120. @@:
  2121.         pop     eax
  2122. ; save sector
  2123.         pusha
  2124.         call    save_chs_sector
  2125.         popa
  2126.         cmp     [FDC_Status], 0
  2127.         jnz     .device_err2
  2128.         add     edx, ecx
  2129.         sub     [esp], ecx
  2130.         pop     ecx
  2131.         jz      .done
  2132. .next_cluster:
  2133.         movzx   edi, word [edi*2+0x282000]
  2134.         sub     esi, 0x200
  2135.         jae     @f
  2136.         xor     esi, esi
  2137. @@:
  2138.         sub     dword [esp], 0x200
  2139.         jae     .write_loop
  2140.         and     dword [esp], 0
  2141.         jmp     .write_loop
  2142. .done:
  2143.         mov     [fdc_irq_func], fdc_null
  2144.         jmp     .ret
  2145.  
  2146. floppy_extend_file.zero_size:
  2147.         xor     eax, eax
  2148.         jmp     floppy_extend_file.start_extend
  2149.  
  2150. ; extends file on floppy to given size (new data area is undefined)
  2151. ; in: edi->direntry, ecx=new size
  2152. ; out: CF=0 => OK, eax=0
  2153. ;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL)
  2154. floppy_extend_file:
  2155.         push    ecx
  2156. ; find the last cluster of file
  2157.         movzx   eax, word [edi+26]      ; first cluster
  2158.         mov     ecx, [edi+28]
  2159.         jecxz   .zero_size
  2160. @@:
  2161.         sub     ecx, 0x200
  2162.         jbe     @f
  2163.         mov     eax, [eax*2+0x282000]
  2164.         and     eax, 0xFFF
  2165.         jz      .fat_err
  2166.         cmp     eax, 0xFF8
  2167.         jb      @b
  2168. .fat_err:
  2169.         pop     ecx
  2170.         push    ERROR_FAT_TABLE
  2171.         pop     eax
  2172.         stc
  2173.         ret
  2174. @@:
  2175.         push    eax
  2176.         mov     eax, [eax*2+0x282000]
  2177.         and     eax, 0xFFF
  2178.         cmp     eax, 0xFF8
  2179.         pop     eax
  2180.         jb      .fat_err
  2181. ; set length to full number of sectors
  2182.         sub     [edi+28], ecx
  2183. .start_extend:
  2184.         pop     ecx
  2185. ; now do extend
  2186.         push    edx esi
  2187.         mov     esi, 0x282000+2*2       ; start scan from cluster 2
  2188.         mov     edx, 2847               ; number of clusters to scan
  2189. .extend_loop:
  2190.         cmp     [edi+28], ecx
  2191.         jae     .extend_done
  2192. ; add new sector
  2193.         push    ecx
  2194.         push    edi
  2195. .scan:
  2196.         mov     ecx, edx
  2197.         mov     edi, esi
  2198.         jecxz   .disk_full
  2199.         push    eax
  2200.         xor     eax, eax
  2201.         repnz   scasw
  2202.         pop     eax
  2203.         jnz     .disk_full
  2204.         mov     word [edi-2], 0xFFF
  2205.         mov     esi, edi
  2206.         mov     edx, ecx
  2207.         sub     edi, 0x282000
  2208.         shr     edi, 1
  2209.         dec     edi     ; now edi=new cluster
  2210.         test    eax, eax
  2211.         jz      .first_cluster
  2212.         mov     [0x282000+eax*2], di
  2213.         jmp     @f
  2214. .first_cluster:
  2215.         pop     eax             ; eax->direntry
  2216.         push    eax
  2217.         mov     [eax+26], di
  2218. @@:
  2219.         mov     eax, edi        ; eax=new cluster
  2220.         pop     edi             ; edi->direntry
  2221.         pop     ecx             ; ecx=required size
  2222.         add     dword [edi+28], 0x200
  2223.         jmp     .extend_loop
  2224. .extend_done:
  2225.         mov     [edi+28], ecx
  2226.         pop     esi edx
  2227.         xor     eax, eax        ; CF=0
  2228.         ret
  2229. .disk_full:
  2230.         pop     edi ecx
  2231.         pop     esi edx
  2232.         stc
  2233.         push    ERROR_DISK_FULL
  2234.         pop     eax
  2235.         ret
  2236.  
  2237. ;----------------------------------------------------------------
  2238. ;
  2239. ;  fs_FloppySetFileEnd - set end of file on floppy
  2240. ;
  2241. ;  esi  points to filename
  2242. ;  ebx  points to 64-bit number = new file size
  2243. ;  ecx  ignored (reserved)
  2244. ;  edx  ignored (reserved)
  2245. ;
  2246. ;  ret eax = 0 ok or other = errormsg
  2247. ;
  2248. ;--------------------------------------------------------------
  2249. fs_FloppySetFileEnd:
  2250.         call    read_flp_fat
  2251.         cmp     [FDC_Status], 0
  2252.         jnz     ret11
  2253.         cmp     byte [esi], 0
  2254.         jnz     @f
  2255. .access_denied:
  2256.         push    ERROR_ACCESS_DENIED
  2257.         jmp     .ret
  2258. @@:
  2259.         push    edi
  2260.         call    fd_find_lfn
  2261.         jnc     @f
  2262.         pop     edi
  2263.         push    ERROR_FILE_NOT_FOUND
  2264. .ret:
  2265.         pop     eax
  2266.         jmp     .doret
  2267. @@:
  2268. ; must not be directory
  2269.         test    byte [edi+11], 10h
  2270.         jz      @f
  2271.         pop     edi
  2272.         jmp     .access_denied
  2273. @@:
  2274. ; file size must not exceed 4 Gb
  2275.         cmp     dword [ebx+4], 0
  2276.         jz      @f
  2277.         pop     edi
  2278.         push    ERROR_END_OF_FILE
  2279.         jmp     .ret
  2280. @@:
  2281.         push    eax
  2282. ; set file modification date/time to current
  2283.         call    fat_update_datetime
  2284.         mov     eax, [ebx]
  2285.         cmp     eax, [edi+28]
  2286.         jb      .truncate
  2287.         ja      .expand
  2288.         pop     eax
  2289.         pushad
  2290.         call    save_chs_sector
  2291.         popad
  2292.         pop     edi
  2293.         xor     eax, eax
  2294.         cmp     [FDC_Status], 0
  2295.         jz      @f
  2296.         mov     al, 11
  2297. @@:
  2298. .doret:
  2299.         mov     [fdc_irq_func], fdc_null
  2300.         ret
  2301. .expand:
  2302.         push    ecx
  2303.         push    dword [edi+28]  ; save old size
  2304.         mov     ecx, eax
  2305.         call    floppy_extend_file
  2306.         push    eax     ; return code
  2307.         jnc     .expand_ok
  2308.         cmp     al, ERROR_DISK_FULL
  2309.         jz      .disk_full
  2310.         pop     eax ecx ecx edi edi
  2311.         jmp     .doret
  2312. .device_err:
  2313.         pop     eax
  2314. .device_err2:
  2315.         pop     ecx ecx eax edi
  2316.         push    11
  2317.         jmp     .ret
  2318. .disk_full:
  2319. .expand_ok:
  2320. ; save directory & FAT
  2321.         mov     eax, [edi+28]
  2322.         xchg    eax, [esp+12]
  2323.         movzx   edi, word [edi+26]
  2324.         pusha
  2325.         call    save_chs_sector
  2326.         popa
  2327.         cmp     [FDC_Status], 0
  2328.         jnz     .device_err
  2329.         call    save_flp_fat
  2330.         cmp     [FDC_Status], 0
  2331.         jnz     .device_err
  2332.         call    SetUserInterrupts
  2333. ; now zero new data
  2334. ; edi = current cluster, [esp+12]=new size, [esp+4]=old size, [esp]=return code
  2335. .zero_loop:
  2336.         sub     dword [esp+4], 0x200
  2337.         jae     .next_cluster
  2338.         cmp     dword [esp+4], -0x200
  2339.         jz      .noread
  2340.         lea     eax, [edi+31]
  2341.         pusha
  2342.         call    read_chs_sector
  2343.         popa
  2344.         cmp     [FDC_Status], 0
  2345.         jnz     .err_next
  2346. .noread:
  2347.         mov     ecx, [esp+4]
  2348.         neg     ecx
  2349.         push    edi
  2350.         mov     edi, 0xD000+0x200
  2351.         add     edi, [esp+8]
  2352.         xor     eax, eax
  2353.         mov     [esp+8], eax
  2354.         rep     stosb
  2355.         pop     edi
  2356.         lea     eax, [edi+31]
  2357.         pusha
  2358.         call    save_chs_sector
  2359.         popa
  2360.         cmp     [FDC_Status], 0
  2361.         jz      .next_cluster
  2362. .err_next:
  2363.         mov     byte [esp], 11
  2364. .next_cluster:
  2365.         sub     dword [esp+12], 0x200
  2366.         jbe     .expand_done
  2367.         movzx   edi, word [0x282000+edi*2]
  2368.         jmp     .zero_loop
  2369. .expand_done:
  2370.         pop     eax ecx ecx edi edi
  2371.         jmp     .doret
  2372. .truncate:
  2373.         mov     [edi+28], eax
  2374.         push    ecx
  2375.         movzx   ecx, word [edi+26]
  2376.         test    eax, eax
  2377.         jz      .zero_size
  2378. ; find new last sector
  2379. @@:
  2380.         sub     eax, 0x200
  2381.         jbe     @f
  2382.         movzx   ecx, word [0x282000+ecx*2]
  2383.         jmp     @b
  2384. @@:
  2385. ; we will zero data at the end of last sector - remember it
  2386.         push    ecx
  2387. ; terminate FAT chain
  2388.         lea     ecx, [0x282000+ecx+ecx]
  2389.         push    dword [ecx]
  2390.         mov     word [ecx], 0xFFF
  2391.         pop     ecx
  2392.         and     ecx, 0xFFF
  2393.         jmp     .delete
  2394. .zero_size:
  2395.         and     word [edi+26], 0
  2396.         push    0
  2397. .delete:
  2398. ; delete FAT chain starting with ecx
  2399. ; mark all clusters as free
  2400.         cmp     ecx, 0xFF8
  2401.         jae     .deleted
  2402.         lea     ecx, [0x282000+ecx+ecx]
  2403.         push    dword [ecx]
  2404.         and     word [ecx], 0
  2405.         pop     ecx
  2406.         and     ecx, 0xFFF
  2407.         jmp     .delete
  2408. .deleted:
  2409.         mov     edi, [edi+28]
  2410. ; save directory & FAT
  2411.         mov     eax, [esp+8]
  2412.         pusha
  2413.         call    save_chs_sector
  2414.         popa
  2415.         cmp     [FDC_Status], 0
  2416.         jnz     .device_err2
  2417.         call    save_flp_fat
  2418.         cmp     [FDC_Status], 0
  2419.         jnz     .device_err2
  2420. ; zero last sector, ignore errors
  2421.         pop     eax
  2422.         add     eax, 31
  2423.         and     edi, 0x1FF
  2424.         jz      .truncate_done
  2425.         call    SetUserInterrupts
  2426.         pusha
  2427.         call    read_chs_sector
  2428.         popa
  2429.         add     edi, 0xD000
  2430.         mov     ecx, 0xD000+0x200
  2431.         sub     ecx, edi
  2432.         push    eax
  2433.         xor     eax, eax
  2434.         rep     stosb
  2435.         pop     eax
  2436.         pusha
  2437.         call    save_chs_sector
  2438.         popa
  2439. .truncate_done:
  2440.         pop     ecx eax edi
  2441.         xor     eax, eax
  2442.         jmp     .doret
  2443.  
  2444. fs_FloppyGetFileInfo:
  2445.         call    read_flp_fat
  2446.         cmp     [FDC_Status], 0
  2447.         jnz     ret11
  2448.         cmp     byte [esi], 0
  2449.         jnz     @f
  2450.         mov     eax, 2  ; unsupported
  2451.         ret
  2452. @@:
  2453.         push    edi
  2454.         call    fd_find_lfn
  2455.         jmp     fs_GetFileInfo_finish
  2456.  
  2457. ret11:
  2458.         mov     eax, 11
  2459.         ret
  2460.  
  2461. fs_FloppySetFileInfo:
  2462.         call    read_flp_fat
  2463.         cmp     [FDC_Status], 0
  2464.         jnz     ret11
  2465.         cmp     byte [esi], 0
  2466.         jnz     @f
  2467.         mov     eax, 2  ; unsupported
  2468.         ret
  2469. @@:
  2470.         push    edi
  2471.         call    fd_find_lfn
  2472.         jnc     @f
  2473.         pop     edi
  2474.         mov     eax, ERROR_FILE_NOT_FOUND
  2475.         ret
  2476. @@:
  2477.         push    eax
  2478.         call    bdfe_to_fat_entry
  2479.         pop     eax
  2480.         pusha
  2481.         call    save_chs_sector
  2482.         popa
  2483.         pop     edi
  2484.         xor     eax, eax
  2485.         cmp     [FDC_Status], 0
  2486.         jz      @f
  2487.         mov     al, 11
  2488. @@:
  2489.         ret
  2490.  
  2491. ;----------------------------------------------------------------
  2492. ;
  2493. ;  fs_FloppyExecute - LFN variant for executing from floppy
  2494. ;
  2495. ;  esi  points to floppy filename (e.g. 'dir1/name')
  2496. ;  ebp  points to full filename (e.g. '/fd/1/dir1/name')
  2497. ;  dword [ebx] = flags
  2498. ;  dword [ebx+4] = cmdline
  2499. ;
  2500. ;  ret ebx,edx destroyed
  2501. ;      eax > 0 - PID, < 0 - error
  2502. ;
  2503. ;--------------------------------------------------------------
  2504. fs_FloppyExecute:
  2505.         mov     edx, [ebx]
  2506.         mov     ebx, [ebx+4]
  2507.         test    ebx, ebx
  2508.         jz      @f
  2509.         add     ebx, std_application_base_address
  2510. @@:
  2511.  
  2512. ;----------------------------------------------------------------
  2513. ;
  2514. ; fs_FloppyExecute.flags - second entry
  2515. ;
  2516. ;  esi  points to floppy filename (kernel address)
  2517. ;  ebp  points to full filename
  2518. ;  edx  flags
  2519. ;  ebx  cmdline (kernel address)
  2520. ;
  2521. ;  ret  eax > 0 - PID, < 0 - error
  2522. ;
  2523. ;--------------------------------------------------------------
  2524.  
  2525. .flags:
  2526.         call    read_flp_fat
  2527.         cmp     byte [esi], 0
  2528.         jnz     @f
  2529. ; cannot execute root!
  2530.         mov     eax, -ERROR_ACCESS_DENIED
  2531.         ret
  2532. @@:
  2533.         push    edi
  2534.         call    fd_find_lfn
  2535.         jnc     .found
  2536.         pop     edi
  2537.         mov     eax, -ERROR_FILE_NOT_FOUND
  2538.         ret
  2539. .found:
  2540.         movzx   eax, word [edi+26]      ; cluster
  2541.         push    eax
  2542.         push    dword [edi+28]          ; size
  2543.         push    .DoRead
  2544.         call    fs_execute
  2545.         add     esp, 12
  2546.         pop     edi
  2547.         ret
  2548.  
  2549. .DoRead:
  2550. ; read next block
  2551. ; in: eax->parameters, edi->buffer
  2552. ; out: eax = error code
  2553.         pushad
  2554.         cmp     dword [eax], 0  ; file size
  2555.         jz      .eof
  2556.         mov     eax, [eax+4]    ; cluster
  2557.         add     eax, 31
  2558.         call    read_chs_sector
  2559.         cmp     [FDC_Status], 0
  2560.         jnz     .err
  2561.         pop     edi
  2562.         mov     esi, 0xD000
  2563.         push    edi
  2564.         mov     ecx, 512/4
  2565.         rep     movsd
  2566.         mov     eax, [esp+28]
  2567.         mov     ecx, [eax]
  2568.         sub     ecx, 512
  2569.         jae     @f
  2570.         add     edi, ecx
  2571.         neg     ecx
  2572.         push    eax
  2573.         xor     eax, eax
  2574.         rep     stosb
  2575.         pop     eax
  2576. @@:
  2577.         mov     [eax], ecx
  2578.         mov     edx, [eax+4]
  2579.         mov     dx, [edx*2+0x282000]
  2580.         mov     [eax+4], dx     ; high word is already zero
  2581.         popad
  2582.         xor     eax, eax
  2583.         ret
  2584. .eof:
  2585.         popad
  2586.         mov     eax, 6
  2587.         ret
  2588. .err:
  2589.         popad
  2590.         mov     eax, 11
  2591.         ret
  2592.  
  2593. ;----------------------------------------------------------------
  2594. ;
  2595. ;  fs_FloppyDelete - delete file or empty folder from floppy
  2596. ;
  2597. ;  esi  points to filename
  2598. ;
  2599. ;  ret  eax = 0 ok or other = errormsg
  2600. ;
  2601. ;--------------------------------------------------------------
  2602. fs_FloppyDelete:
  2603.         call    read_flp_fat
  2604.         cmp     [FDC_Status], 0
  2605.         jz      @f
  2606.         push    11
  2607.         jmp     .pop_ret
  2608. @@:
  2609.         cmp     byte [esi], 0
  2610.         jnz     @f
  2611. ; cannot delete root!
  2612. .access_denied:
  2613.         push    ERROR_ACCESS_DENIED
  2614. .pop_ret:
  2615.         pop     eax
  2616.         ret
  2617. @@:
  2618.         and     [fd_prev_sector], 0
  2619.         and     [fd_prev_prev_sector], 0
  2620.         push    edi
  2621.         call    fd_find_lfn
  2622.         jnc     .found
  2623.         pop     edi
  2624.         push    ERROR_FILE_NOT_FOUND
  2625.         jmp     .pop_ret
  2626. .found:
  2627.         cmp     dword [edi], '.   '
  2628.         jz      .access_denied2
  2629.         cmp     dword [edi], '..  '
  2630.         jz      .access_denied2
  2631.         test    byte [edi+11], 10h
  2632.         jz      .dodel
  2633. ; we can delete only empty folders!
  2634.         push    eax
  2635.         movzx   eax, word [edi+26]
  2636.         push    ebx
  2637.         pusha
  2638.         add     eax, 31
  2639.         call    read_chs_sector
  2640.         popa
  2641.         mov     ebx, FDD_DATA + 2*0x20
  2642. .checkempty:
  2643.         cmp     byte [ebx], 0
  2644.         jz      .empty
  2645.         cmp     byte [ebx], 0xE5
  2646.         jnz     .notempty
  2647.         add     ebx, 0x20
  2648.         cmp     ebx, FDD_DATA + 0x200
  2649.         jb      .checkempty
  2650.         movzx   eax, word [FLOPPY_FAT + eax*2]
  2651.         pusha
  2652.         add     eax, 31
  2653.         call    read_chs_sector
  2654.         popa
  2655.         mov     ebx, FDD_DATA
  2656.         jmp     .checkempty
  2657. .notempty:
  2658.         pop     ebx
  2659.         pop     eax
  2660. .access_denied2:
  2661.         pop     edi
  2662.         jmp     .access_denied
  2663. .empty:
  2664.         pop     ebx
  2665.         pop     eax
  2666.         pusha
  2667.         call    read_chs_sector
  2668.         popa
  2669. .dodel:
  2670.         push    eax
  2671.         movzx   eax, word [edi+26]
  2672.         xchg    eax, [esp]
  2673. ; delete folder entry
  2674.         mov     byte [edi], 0xE5
  2675. ; delete LFN (if present)
  2676. .lfndel:
  2677.         cmp     edi, FDD_DATA
  2678.         ja      @f
  2679.         cmp     [fd_prev_sector], 0
  2680.         jz      .lfndone
  2681.         push    [fd_prev_sector]
  2682.         push    [fd_prev_prev_sector]
  2683.         pop     [fd_prev_sector]
  2684.         and     [fd_prev_prev_sector], 0
  2685.         pusha
  2686.         call    save_chs_sector
  2687.         popa
  2688.         pop     eax
  2689.         pusha
  2690.         call    read_chs_sector
  2691.         popa
  2692.         mov     edi, FDD_DATA+0x200
  2693. @@:
  2694.         sub     edi, 0x20
  2695.         cmp     byte [edi], 0xE5
  2696.         jz      .lfndone
  2697.         cmp     byte [edi+11], 0xF
  2698.         jnz     .lfndone
  2699.         mov     byte [edi], 0xE5
  2700.         jmp     .lfndel
  2701. .lfndone:
  2702.         pusha
  2703.         call    save_chs_sector
  2704.         popa
  2705. ; delete FAT chain
  2706.         pop     eax
  2707.         test    eax, eax
  2708.         jz      .done
  2709. @@:
  2710.         lea     eax, [FLOPPY_FAT + eax*2]
  2711.         push    dword [eax]
  2712.         and     word [eax], 0
  2713.         pop     eax
  2714.         and     eax, 0xFFF
  2715.         jnz     @b
  2716. .done:
  2717.         call    save_flp_fat
  2718.         pop     edi
  2719.         xor     eax, eax
  2720.         ret
  2721.  
  2722. ; \end{diamond}
  2723.