Subversion Repositories Kolibri OS

Rev

Rev 115 | Go to most recent revision | Blame | 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,0x282000
  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. flp_root_next:
  1118.         cmp     edi, 0xD200-0x20
  1119.         jae     @f
  1120.         add     edi, 0x20
  1121.         ret     ; CF=0
  1122. @@:
  1123. ; read next sector
  1124.         inc     dword [eax]
  1125.         cmp     dword [eax], 14
  1126.         jae     flp_root_first.readerr
  1127. flp_root_first:
  1128.         mov     eax, [eax]
  1129.         pusha
  1130.         add     eax, 19
  1131.         call    read_chs_sector
  1132.         popa
  1133.         cmp     [FDC_Status], 0
  1134.         jnz     .readerr
  1135.         mov     edi, 0xD000
  1136.         ret     ; CF=0
  1137. .readerr:
  1138.         stc
  1139.         ret
  1140.  
  1141. flp_rootmem_first:
  1142.         mov     edi, 0x8000
  1143.         clc
  1144.         ret
  1145. flp_rootmem_next:
  1146.         add     edi, 0x20
  1147.         cmp     edi, 0x8000+14*0x200
  1148.         cmc
  1149. flp_rootmem_next_write:
  1150. flp_rootmem_begin_write:
  1151. flp_rootmem_end_write:
  1152.         ret
  1153. flp_rootmem_extend_dir:
  1154.         stc
  1155.         ret
  1156.  
  1157. flp_notroot_next:
  1158.         cmp     edi, 0xD200-0x20
  1159.         jae     flp_notroot_next_sector
  1160.         add     edi, 0x20
  1161.         ret     ; CF=0
  1162. flp_notroot_next_sector:
  1163.         push    ecx
  1164.         mov     ecx, [eax]
  1165.         mov     ecx, [ecx*2+0x282000]
  1166.         and     ecx, 0xFFF
  1167.         cmp     ecx, 2849
  1168.         jae     flp_notroot_first.err2
  1169.         mov     [eax], ecx
  1170.         pop     ecx
  1171. flp_notroot_first:
  1172.         mov     eax, [eax]
  1173.         cmp     eax, 2
  1174.         jb      .err
  1175.         cmp     eax, 2849
  1176.         jae     .err
  1177.         pusha
  1178.         add     eax, 31
  1179.         call    read_chs_sector
  1180.         popa
  1181.         mov     edi, 0xD000
  1182.         cmp     [FDC_Status], 0
  1183.         jnz     .err
  1184.         ret     ; CF=0
  1185. .err2:
  1186.         pop     ecx
  1187. .err:
  1188.         stc
  1189.         ret
  1190. flp_notroot_begin_write:
  1191.         pusha
  1192.         mov     eax, [eax]
  1193.         add     eax, 31
  1194.         call    read_chs_sector
  1195.         popa
  1196.         ret
  1197. flp_notroot_end_write:
  1198.         pusha
  1199.         mov     eax, [eax]
  1200.         add     eax, 31
  1201.         call    save_chs_sector
  1202.         popa
  1203.         ret
  1204. flp_notroot_next_write:
  1205.         cmp     edi, 0xD200
  1206.         jae     @f
  1207.         ret
  1208. @@:
  1209.         call    flp_notroot_end_write
  1210.         jmp     flp_notroot_next_sector
  1211. flp_notroot_extend_dir:
  1212. ; find free cluster in FAT
  1213.         pusha
  1214.         xor     eax, eax
  1215.         mov     edi, 0x282000
  1216.         mov     ecx, 2849
  1217.         repnz   scasw
  1218.         jnz     .notfound
  1219.         mov     word [edi-2], 0xFFF     ; mark as last cluster
  1220.         sub     edi, 0x282000
  1221.         shr     edi, 1
  1222.         dec     edi
  1223.         mov     eax, [esp+28]
  1224.         mov     ecx, [eax]
  1225.         mov     [0x282000+ecx*2], di
  1226.         mov     [eax], edi
  1227.         xor     eax, eax
  1228.         mov     edi, 0xD000
  1229.         mov     ecx, 128
  1230.         rep     stosd
  1231.         popa
  1232.         call    flp_notroot_end_write
  1233.         mov     edi, 0xD000
  1234.         clc
  1235.         ret
  1236. .notfound:
  1237.         popa
  1238.         stc
  1239.         ret
  1240.  
  1241. fd_find_lfn:
  1242. ; in: esi->name
  1243. ; out: CF=1 - file not found
  1244. ;      else CF=0 and edi->direntry, eax=directory cluster (0 for root)
  1245.         push    esi edi
  1246.         push    0
  1247.         push    flp_root_first
  1248.         push    flp_root_next
  1249. .loop:
  1250.         call    fat_find_lfn
  1251.         jc      .notfound
  1252.         cmp     byte [esi], 0
  1253.         jz      .found
  1254.         test    byte [edi+11], 10h
  1255.         jz      .notfound
  1256.         movzx   eax, word [edi+26]      ; cluster
  1257.         mov     [esp+8], eax
  1258.         mov     dword [esp+4], flp_notroot_first
  1259.         mov     dword [esp], flp_notroot_next
  1260.         jmp     .loop
  1261. .notfound:
  1262.         add     esp, 12
  1263.         pop     edi esi
  1264.         stc
  1265.         ret
  1266. .found:
  1267.         mov     eax, [esp+8]
  1268.         add     eax, 31
  1269.         cmp     dword [esp], flp_root_next
  1270.         jnz     @f
  1271.         add     eax, -31+19
  1272. @@:
  1273.         add     esp, 16         ; CF=0
  1274.         pop     esi
  1275.         ret
  1276.  
  1277. ;----------------------------------------------------------------
  1278. ;
  1279. ;  fs_FloppyRead - LFN variant for reading floppy
  1280. ;
  1281. ;  esi  points to filename
  1282. ;  ebx  pointer to 64-bit number = first wanted byte, 0+
  1283. ;       may be ebx=0 - start from first byte
  1284. ;  ecx  number of bytes to read, 0+
  1285. ;  edx  mem location to return data
  1286. ;
  1287. ;  ret ebx = bytes read or 0xffffffff file not found
  1288. ;      eax = 0 ok read or other = errormsg
  1289. ;
  1290. ;--------------------------------------------------------------
  1291. fs_FloppyRead:
  1292.         call    read_flp_fat
  1293.         cmp     byte [esi], 0
  1294.         jnz     @f
  1295.         or      ebx, -1
  1296.         mov     eax, 10         ; access denied
  1297.         ret
  1298. @@:
  1299.         push    edi
  1300.         call    fd_find_lfn
  1301.         jnc     .found
  1302.         pop     edi
  1303.         or      ebx, -1
  1304.         mov     eax, 5          ; file not found
  1305.         ret
  1306. .found:
  1307.         test    ebx, ebx
  1308.         jz      .l1
  1309.         cmp     dword [ebx+4], 0
  1310.         jz      @f
  1311.         xor     ebx, ebx
  1312. .reteof:
  1313.         mov     eax, 6          ; EOF
  1314.         pop     edi
  1315.         ret
  1316. @@:
  1317.         mov     ebx, [ebx]
  1318. .l1:
  1319.         push    ecx edx
  1320.         push    0
  1321.         mov     eax, [edi+28]
  1322.         sub     eax, ebx
  1323.         jb      .eof
  1324.         cmp     eax, ecx
  1325.         jae     @f
  1326.         mov     ecx, eax
  1327.         mov     byte [esp], 6           ; EOF
  1328. @@:
  1329.         movzx   edi, word [edi+26]
  1330. .new:
  1331.         jecxz   .done
  1332.         test    edi, edi
  1333.         jz      .eof
  1334.         cmp     edi, 0xFF8
  1335.         jae     .eof
  1336.         sub     ebx, 512
  1337.         jae     .skip
  1338.         lea     eax, [edi+31]
  1339.         pusha
  1340.         call    read_chs_sector
  1341.         popa
  1342.         cmp     [FDC_Status], 0
  1343.         jnz     .err
  1344.         lea     eax, [0xD000+ebx+512]
  1345.         neg     ebx
  1346.         push    ecx
  1347.         cmp     ecx, ebx
  1348.         jbe     @f
  1349.         mov     ecx, ebx
  1350. @@:
  1351.         mov     ebx, edx
  1352.         call    memmove
  1353.         add     edx, ecx
  1354.         sub     [esp], ecx
  1355.         pop     ecx
  1356.         xor     ebx, ebx
  1357. .skip:
  1358.         movzx   edi, word [edi*2+0x282000]
  1359.         jmp     .new
  1360. .done:
  1361.         mov     ebx, edx
  1362.         pop     eax edx ecx edi
  1363.         sub     ebx, edx
  1364.         ret
  1365. .eof:
  1366.         mov     ebx, edx
  1367.         pop     eax edx ecx
  1368.         jmp     .reteof
  1369. .err:
  1370.         mov     ebx, edx
  1371.         pop     eax edx ecx edi
  1372.         sub     ebx, edx
  1373.         mov     al, 11
  1374.         ret
  1375.  
  1376. ;----------------------------------------------------------------
  1377. ;
  1378. ;  fs_FloppyReadFolder - LFN variant for reading floppy folders
  1379. ;
  1380. ;  esi  points to filename
  1381. ;  ebx  pointer to structure: 32-bit number = first wanted block, 0+
  1382. ;                           & flags (bitfields)
  1383. ; flags: bit 0: 0=ANSI names, 1=UNICODE names
  1384. ;  ecx  number of blocks to read, 0+
  1385. ;  edx  mem location to return data
  1386. ;
  1387. ;  ret ebx = blocks read or 0xffffffff folder not found
  1388. ;      eax = 0 ok read or other = errormsg
  1389. ;
  1390. ;--------------------------------------------------------------
  1391. fs_FloppyReadFolder:
  1392.         call    read_flp_fat
  1393.         push    edi
  1394.         cmp     byte [esi], 0
  1395.         jz      .root
  1396.         call    fd_find_lfn
  1397.         jnc     .found
  1398.         pop     edi
  1399.         or      ebx, -1
  1400.         mov     eax, ERROR_FILE_NOT_FOUND
  1401.         ret
  1402. .found:
  1403.         test    byte [edi+11], 0x10     ; do not allow read files
  1404.         jnz     .found_dir
  1405.         pop     edi
  1406.         or      ebx, -1
  1407.         mov     eax, ERROR_ACCESS_DENIED
  1408.         ret
  1409. .found_dir:
  1410.         movzx   eax, word [edi+26]
  1411.         add     eax, 31
  1412.         push    0
  1413.         jmp     .doit
  1414. .root:
  1415.         mov     eax, 19
  1416.         push    14
  1417. .doit:
  1418.         push    ecx ebp
  1419.         sub     esp, 262*2      ; reserve space for LFN
  1420.         mov     ebp, esp
  1421.         push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE names
  1422.         mov     ebx, [ebx]
  1423. ; init header
  1424.         push    eax ecx
  1425.         mov     edi, edx
  1426.         mov     ecx, 32/4
  1427.         xor     eax, eax
  1428.         rep     stosd
  1429.         pop     ecx eax
  1430.         mov     byte [edx], 1   ; version
  1431.         mov     esi, edi        ; esi points to BDFE
  1432. .main_loop:
  1433.         pusha
  1434.         call    read_chs_sector
  1435.         popa
  1436.         cmp     [FDC_Status], 0
  1437.         jnz     .error
  1438.         mov     edi, 0xD000
  1439.         push    eax
  1440. .l1:
  1441.         call    fat_get_name
  1442.         jc      .l2
  1443.         cmp     byte [edi+11], 0xF
  1444.         jnz     .do_bdfe
  1445.         add     edi, 0x20
  1446.         cmp     edi, 0xD200
  1447.         jb      .do_bdfe
  1448.         pop     eax
  1449.         inc     eax
  1450.         dec     byte [esp+262*2+12]
  1451.         jz      .done
  1452.         jns     @f
  1453. ; read next sector from FAT
  1454.         mov     eax, [(eax-31-1)*2+0x282000]
  1455.         and     eax, 0xFFF
  1456.         cmp     eax, 0xFF8
  1457.         jae     .done
  1458.         add     eax, 31
  1459.         mov     byte [esp+262*2+12], 0
  1460. @@:
  1461.         pusha
  1462.         call    read_chs_sector
  1463.         popa
  1464.         cmp     [FDC_Status], 0
  1465.         jnz     .error
  1466.         mov     edi, 0xD000
  1467.         push    eax
  1468. .do_bdfe:
  1469.         inc     dword [edx+8]   ; new file found
  1470.         dec     ebx
  1471.         jns     .l2
  1472.         dec     ecx
  1473.         js      .l2
  1474.         inc     dword [edx+4]   ; new file block copied
  1475.         call    fat_entry_to_bdfe
  1476. .l2:
  1477.         add     edi, 0x20
  1478.         cmp     edi, 0xD200
  1479.         jb      .l1
  1480.         pop     eax
  1481.         inc     eax
  1482.         dec     byte [esp+262*2+12]
  1483.         jz      .done
  1484.         jns     @f
  1485. ; read next sector from FAT
  1486.         mov     eax, [(eax-31-1)*2+0x282000]
  1487.         and     eax, 0xFFF
  1488.         cmp     eax, 0xFF8
  1489.         jae     .done
  1490.         add     eax, 31
  1491.         mov     byte [esp+262*2+12], 0
  1492. @@:
  1493.         jmp     .main_loop
  1494. .error:
  1495.         add     esp, 262*2+4
  1496.         pop     ebp ecx edi edi
  1497.         or      ebx, -1
  1498.         mov     eax, ERROR_FILE_NOT_FOUND
  1499.         ret
  1500. .done:
  1501.         add     esp, 262*2+4
  1502.         pop     ebp
  1503.         mov     ebx, [edx+4]
  1504.         xor     eax, eax
  1505.         dec     ecx
  1506.         js      @f
  1507.         mov     al, ERROR_END_OF_FILE
  1508. @@:
  1509.         pop     ecx edi edi
  1510.         ret
  1511.  
  1512. ;----------------------------------------------------------------
  1513. ;
  1514. ;  fs_FloppyRewrite - LFN variant for writing sys floppy
  1515. ;
  1516. ;  esi  points to filename
  1517. ;  ebx  ignored (reserved)
  1518. ;  ecx  number of bytes to write, 0+
  1519. ;  edx  mem location to data
  1520. ;
  1521. ;  ret ebx = number of written bytes
  1522. ;      eax = 0 ok read or other = errormsg
  1523. ;
  1524. ;--------------------------------------------------------------
  1525. @@:
  1526.         mov     eax, ERROR_ACCESS_DENIED
  1527.         xor     ebx, ebx
  1528.         ret
  1529. fsfrfe2:
  1530.         popad
  1531. fsfrfe:
  1532.         mov     eax, 11
  1533.         xor     ebx, ebx
  1534.         ret
  1535.  
  1536. fs_FloppyRewrite:
  1537.         cmp     byte [esi], 0
  1538.         jz      @b
  1539.         call    read_flp_fat
  1540.         cmp     [FDC_Status], 0
  1541.         jnz     fsfrfe
  1542.         pushad
  1543.         xor     ebp, ebp
  1544.         push    esi
  1545. @@:
  1546.         lodsb
  1547.         test    al, al
  1548.         jz      @f
  1549.         cmp     al, '/'
  1550.         jnz     @b
  1551.         lea     ebp, [esi-1]
  1552.         jmp     @b
  1553. @@:
  1554.         pop     esi
  1555.         test    ebp, ebp
  1556.         jnz     .noroot
  1557.         call    read_flp_root
  1558.         cmp     [FDC_Status], 0
  1559.         jnz     fsfrfe2
  1560.         push    flp_rootmem_extend_dir
  1561.         push    flp_rootmem_end_write
  1562.         push    flp_rootmem_next_write
  1563.         push    flp_rootmem_begin_write
  1564.         xor     ebp, ebp
  1565.         push    ebp
  1566.         push    flp_rootmem_first
  1567.         push    flp_rootmem_next
  1568.         jmp     .common1
  1569. .noroot:
  1570. ; check existence
  1571.         mov     byte [ebp], 0
  1572.         call    fd_find_lfn
  1573.         mov     byte [ebp], '/'
  1574.         lea     esi, [ebp+1]
  1575.         jnc     @f
  1576.         mov     eax, ERROR_FILE_NOT_FOUND
  1577. .ret1:
  1578.         mov     [esp+28], eax
  1579.         popad
  1580.         xor     ebx, ebx
  1581.         ret
  1582. @@:
  1583.         test    byte [edi+11], 0x10     ; must be directory
  1584.         mov     eax, ERROR_ACCESS_DENIED
  1585.         jz      .ret1
  1586.         movzx   ebp, word [edi+26]      ; ebp=cluster
  1587.         mov     eax, ERROR_FAT_TABLE
  1588.         cmp     ebp, 2
  1589.         jb      .ret1
  1590.         cmp     ebp, 2849
  1591.         jae     .ret1
  1592.         push    flp_notroot_extend_dir
  1593.         push    flp_notroot_end_write
  1594.         push    flp_notroot_next_write
  1595.         push    flp_notroot_begin_write
  1596.         push    ebp
  1597.         push    flp_notroot_first
  1598.         push    flp_notroot_next
  1599. .common1:
  1600.         call    fat_find_lfn
  1601.         jc      .notfound
  1602. ; found; must not be directory
  1603.         test    byte [edi+11], 10h
  1604.         jz      @f
  1605.         add     esp, 28
  1606.         popad
  1607.         mov     eax, ERROR_ACCESS_DENIED
  1608.         xor     ebx, ebx
  1609.         ret
  1610. @@:
  1611. ; delete FAT chain
  1612.         push    edi
  1613.         xor     eax, eax
  1614.         mov     dword [edi+28], eax     ; zero size
  1615.         xchg    ax, word [edi+26]       ; start cluster
  1616.         test    eax, eax
  1617.         jz      .done1
  1618. @@:
  1619.         cmp     eax, 0xFF8
  1620.         jae     .done1
  1621.         lea     edi, [0x282000 + eax*2] ; position in FAT
  1622.         xor     eax, eax
  1623.         xchg    ax, [edi]
  1624.         jmp     @b
  1625. .done1:
  1626.         pop     edi
  1627.         call    get_time_for_file
  1628.         mov     [edi+22], ax
  1629.         call    get_date_for_file
  1630.         mov     [edi+24], ax
  1631.         mov     [edi+18], ax
  1632.         or      byte [edi+11], 20h      ; set 'archive' attribute
  1633.         jmp     .doit
  1634. .notfound:
  1635. ; file is not found; generate short name
  1636.         call    fat_name_is_legal
  1637.         jc      @f
  1638.         add     esp, 28
  1639.         popad
  1640.         mov     eax, ERROR_FILE_NOT_FOUND
  1641.         xor     ebx, ebx
  1642.         ret
  1643. @@:
  1644.         sub     esp, 12
  1645.         mov     edi, esp
  1646.         call    fat_gen_short_name
  1647. .test_short_name_loop:
  1648.         push    esi edi ecx
  1649.         mov     esi, edi
  1650.         lea     eax, [esp+12+12+8]
  1651.         mov     [eax], ebp
  1652.         call    dword [eax-4]
  1653.         jc      .found
  1654. .test_short_name_entry:
  1655.         cmp     byte [edi+11], 0xF
  1656.         jz      .test_short_name_cont
  1657.         mov     ecx, 11
  1658.         push    esi edi
  1659.         repz    cmpsb
  1660.         pop     edi esi
  1661.         jz      .short_name_found
  1662. .test_short_name_cont:
  1663.         lea     eax, [esp+12+12+8]
  1664.         call    dword [eax-8]
  1665.         jnc     .test_short_name_entry
  1666.         jmp     .found
  1667. .short_name_found:
  1668.         pop     ecx edi esi
  1669.         call    fat_next_short_name
  1670.         jnc     .test_short_name_loop
  1671. .disk_full:
  1672.         add     esp, 12+28
  1673.         popa
  1674.         mov     eax, ERROR_DISK_FULL
  1675.         xor     ebx, ebx
  1676.         ret
  1677. .found:
  1678.         pop     ecx edi esi
  1679. ; now find space in directory
  1680. ; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
  1681.         mov     al, '~'
  1682.         push    ecx edi
  1683.         mov     ecx, 8
  1684.         repnz   scasb
  1685.         push    1
  1686.         pop     eax     ; 1 entry
  1687.         jnz     .notilde
  1688. ; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
  1689.         xor     eax, eax
  1690. @@:
  1691.         cmp     byte [esi], 0
  1692.         jz      @f
  1693.         inc     esi
  1694.         inc     eax
  1695.         jmp     @b
  1696. @@:
  1697.         sub     esi, eax
  1698.         add     eax, 12+13
  1699.         mov     ecx, 13
  1700.         push    edx
  1701.         cdq
  1702.         div     ecx
  1703.         pop     edx
  1704. .notilde:
  1705.         push    -1
  1706.         push    -1
  1707. ; find <eax> successive entries in directory
  1708.         xor     ecx, ecx
  1709.         push    eax
  1710.         lea     eax, [esp+12+8+12+8]
  1711.         mov     [eax], ebp
  1712.         call    dword [eax-4]
  1713.         pop     eax
  1714.         jnc     .scan_dir
  1715. .fsfrfe3:
  1716.         add     esp, 8+8+12+28
  1717.         popad
  1718.         mov     eax, 11
  1719.         xor     ebx, ebx
  1720.         ret
  1721. .scan_dir:
  1722.         cmp     byte [edi], 0
  1723.         jz      .free
  1724.         cmp     byte [edi], 0xE5
  1725.         jz      .free
  1726.         xor     ecx, ecx
  1727. .scan_cont:
  1728.         push    eax
  1729.         lea     eax, [esp+12+8+12+8]
  1730.         call    dword [eax-8]
  1731.         pop     eax
  1732.         jnc     .scan_dir
  1733.         cmp     [FDC_Status], 0
  1734.         jnz     .fsfrfe3
  1735.         push    eax
  1736.         lea     eax, [esp+12+8+12+8]
  1737.         call    dword [eax+16]          ; extend directory
  1738.         pop     eax
  1739.         jnc     .scan_dir
  1740.         add     esp, 8+8+12+28
  1741.         popad
  1742.         mov     eax, ERROR_DISK_FULL
  1743.         xor     ebx, ebx
  1744.         ret
  1745. .free:
  1746.         test    ecx, ecx
  1747.         jnz     @f
  1748.         mov     [esp], edi
  1749.         mov     ecx, [esp+8+8+12+8]
  1750.         mov     [esp+4], ecx
  1751.         xor     ecx, ecx
  1752. @@:
  1753.         inc     ecx
  1754.         cmp     ecx, eax
  1755.         jb      .scan_cont
  1756. ; found!
  1757. ; calculate name checksum
  1758.         push    esi ecx
  1759.         mov     esi, [esp+8+8]
  1760.         mov     ecx, 11
  1761.         xor     eax, eax
  1762. @@:
  1763.         ror     al, 1
  1764.         add     al, [esi]
  1765.         inc     esi
  1766.         loop    @b
  1767.         pop     ecx esi
  1768.         pop     edi
  1769.         pop     dword [esp+8+12+8]
  1770. ; edi points to first entry in free chunk
  1771.         dec     ecx
  1772.         jz      .nolfn
  1773.         push    esi
  1774.         push    eax
  1775.         lea     eax, [esp+8+8+12+8]
  1776.         call    dword [eax+4]         ; begin write
  1777.         mov     al, 40h
  1778. .writelfn:
  1779.         or      al, cl
  1780.         mov     esi, [esp+4]
  1781.         push    ecx
  1782.         dec     ecx
  1783.         imul    ecx, 13
  1784.         add     esi, ecx
  1785.         stosb
  1786.         mov     cl, 5
  1787.         call    fs_RamdiskRewrite.read_symbols
  1788.         mov     ax, 0xF
  1789.         stosw
  1790.         mov     al, [esp+4]
  1791.         stosb
  1792.         mov     cl, 6
  1793.         call    fs_RamdiskRewrite.read_symbols
  1794.         xor     eax, eax
  1795.         stosw
  1796.         mov     cl, 2
  1797.         call    fs_RamdiskRewrite.read_symbols
  1798.         pop     ecx
  1799.         lea     eax, [esp+8+8+12+8]
  1800.         call    dword [eax+8]         ; next write
  1801.         xor     eax, eax
  1802.         loop    .writelfn
  1803.         pop     eax
  1804.         pop     esi
  1805. ;        lea     eax, [esp+8+12+8]
  1806. ;        call    dword [eax+12]          ; end write
  1807. .nolfn:
  1808.         xchg    esi, [esp]
  1809.         mov     ecx, 11
  1810.         rep     movsb
  1811.         mov     word [edi], 20h         ; attributes
  1812.         sub     edi, 11
  1813.         pop     esi ecx
  1814.         add     esp, 12
  1815.         mov     byte [edi+13], 0        ; tenths of a second at file creation time
  1816.         call    get_time_for_file
  1817.         mov     [edi+14], ax            ; creation time
  1818.         mov     [edi+22], ax            ; last write time
  1819.         call    get_date_for_file
  1820.         mov     [edi+16], ax            ; creation date
  1821.         mov     [edi+24], ax            ; last write date
  1822.         mov     [edi+18], ax            ; last access date
  1823.         and     word [edi+20], 0        ; high word of cluster
  1824.         and     word [edi+26], 0        ; low word of cluster - to be filled
  1825.         and     dword [edi+28], 0       ; file size - to be filled
  1826. .doit:
  1827.         lea     eax, [esp+8]
  1828.         call    dword [eax+12]  ; flush directory
  1829.         push    ecx
  1830.         push    edi
  1831.         add     edi, 26         ; edi points to low word of cluster
  1832.         push    edi
  1833.         mov     esi, edx
  1834.         jecxz   .done
  1835.         mov     ecx, 2849
  1836.         mov     edi, 0x282000
  1837.         push    0       ; first cluster
  1838. .write_loop:
  1839. ; allocate new cluster
  1840.         xor     eax, eax
  1841.         repnz   scasw
  1842.         mov     al, ERROR_DISK_FULL
  1843.         jnz     .ret
  1844.         dec     edi
  1845.         dec     edi
  1846.         lea     eax, [edi-0x282000]
  1847.         shr     eax, 1                  ; eax = cluster
  1848.         mov     word [edi], 0xFFF       ; mark as last cluster
  1849.         cmp     dword [esp], 0
  1850.         jz      .first
  1851.         xchg    edi, [esp+4]
  1852.         stosw
  1853.         mov     edi, [esp+4]
  1854.         jmp     @f
  1855. .first:
  1856.         mov     [esp], eax
  1857. @@:
  1858.         inc     ecx
  1859. ; write data
  1860.         push    ecx edi
  1861.         mov     ecx, 512
  1862.         cmp     dword [esp+20], ecx
  1863.         jae     @f
  1864.         mov     ecx, [esp+20]
  1865. @@:
  1866.         push    ecx
  1867.         mov     edi, 0xD000
  1868.         rep     movsb
  1869.         pop     ecx
  1870.         push    ecx
  1871.         sub     ecx, 512
  1872.         neg     ecx
  1873.         push    eax
  1874.         xor     eax, eax
  1875.         rep     stosb
  1876.         pop     eax
  1877.         add     eax, 31
  1878.         pusha
  1879.         call    save_chs_sector
  1880.         popa
  1881.         pop     ecx
  1882.         cmp     [FDC_Status], 0
  1883.         jnz     .diskerr
  1884.         sub     [esp+20], ecx
  1885.         pop     edi ecx
  1886.         jnz     .write_loop
  1887. .done:
  1888.         xor     eax, eax
  1889. .ret:
  1890.         pop     ebx edi edi ecx
  1891.         mov     [esp+28+28], eax
  1892.         lea     eax, [esp+8]
  1893.         call    dword [eax+4]
  1894.         mov     [edi+26], bx
  1895.         mov     ebx, esi
  1896.         sub     ebx, edx
  1897.         mov     [edi+28], ebx
  1898.         call    dword [eax+12]
  1899.         mov     [esp+28+16], ebx
  1900.         test    ebp, ebp
  1901.         jnz     @f
  1902.         call    save_flp_root
  1903. @@:
  1904.         add     esp, 28
  1905.         cmp     [FDC_Status], 0
  1906.         jnz     .err3
  1907.         call    save_flp_fat
  1908.         cmp     [FDC_Status], 0
  1909.         jnz     .err3
  1910.         popa
  1911.         ret
  1912. .err3:
  1913.         popa
  1914.         mov     al, 11
  1915.         xor     ebx, ebx
  1916.         ret
  1917. .diskerr:
  1918.         sub     esi, ecx
  1919.         mov     eax, 11
  1920.         pop     edi ecx
  1921.         jmp     .ret
  1922.  
  1923. ;----------------------------------------------------------------
  1924. ;
  1925. ;  fs_FloppyWrite - LFN variant for writing to floppy
  1926. ;
  1927. ;  esi  points to filename
  1928. ;  ebx  pointer to 64-bit number = first wanted byte, 0+
  1929. ;       may be ebx=0 - start from first byte
  1930. ;  ecx  number of bytes to write, 0+
  1931. ;  edx  mem location to data
  1932. ;
  1933. ;  ret ebx = bytes written (maybe 0)
  1934. ;      eax = 0 ok write or other = errormsg
  1935. ;
  1936. ;--------------------------------------------------------------
  1937.  
  1938. @@:
  1939.         push    ERROR_ACCESS_DENIED
  1940. fs_FloppyWrite.ret0:
  1941.         pop     eax
  1942.         xor     ebx, ebx
  1943.         ret
  1944.  
  1945. fs_FloppyWrite.ret11:
  1946.         push    11
  1947.         jmp     fs_FloppyWrite.ret0
  1948.  
  1949. fs_FloppyWrite:
  1950.         cmp     byte [esi], 0
  1951.         jz      @b
  1952.         call    read_flp_fat
  1953.         cmp     [FDC_Status], 0
  1954.         jnz     .ret11
  1955.         pushad
  1956.         call    fd_find_lfn
  1957.         jnc     .found
  1958.         popad
  1959.         push    ERROR_FILE_NOT_FOUND
  1960.         jmp     .ret0
  1961. .found:
  1962. ; FAT does not support files larger than 4GB
  1963.         test    ebx, ebx
  1964.         jz      .l1
  1965.         cmp     dword [ebx+4], 0
  1966.         jz      @f
  1967. .eof:
  1968.         popad
  1969.         push    ERROR_END_OF_FILE
  1970.         jmp     .ret0
  1971. @@:
  1972.         mov     ebx, [ebx]
  1973. .l1:
  1974. ; now edi points to direntry, ebx=start byte to write,
  1975. ; ecx=number of bytes to write, edx=data pointer
  1976.  
  1977. ; extend file if needed
  1978.         add     ecx, ebx
  1979.         jc      .eof    ; FAT does not support files larger than 4GB
  1980.         push    eax     ; save directory cluster
  1981.         push    0       ; return value=0
  1982.  
  1983.         call    get_time_for_file
  1984.         mov     [edi+22], ax            ; last write time
  1985.         call    get_date_for_file
  1986.         mov     [edi+24], ax            ; last write date
  1987.         mov     [edi+18], ax            ; last access date
  1988.  
  1989.         push    dword [edi+28]          ; save current file size
  1990.         cmp     ecx, [edi+28]
  1991.         jbe     .length_ok
  1992.         cmp     ecx, ebx
  1993.         jz      .length_ok
  1994.         call    floppy_extend_file
  1995.         jnc     .length_ok
  1996.         mov     [esp+4], eax
  1997. ; floppy_extend_file can return two error codes: FAT table error or disk full.
  1998. ; First case is fatal error, in second case we may write some data
  1999.         cmp     al, ERROR_DISK_FULL
  2000.         jz      .disk_full
  2001.         pop     eax
  2002.         pop     eax
  2003.         mov     [esp+4+28], eax
  2004.         pop     eax
  2005.         popad
  2006.         xor     ebx, ebx
  2007.         ret
  2008. .disk_full:
  2009. ; correct number of bytes to write
  2010.         mov     ecx, [edi+28]
  2011.         cmp     ecx, ebx
  2012.         ja      .length_ok
  2013. .ret:
  2014.         pop     eax
  2015.         pop     eax
  2016.         mov     [esp+4+28], eax ; eax=return value
  2017.         pop     eax
  2018.         sub     edx, [esp+20]
  2019.         mov     [esp+16], edx   ; ebx=number of written bytes
  2020.         popad
  2021.         ret
  2022. .length_ok:
  2023. ; save FAT & directory
  2024. ; note that directory must be saved first because save_flp_fat uses buffer at 0xD000
  2025.         mov     esi, [edi+28]
  2026.         movzx   edi, word [edi+26]      ; starting cluster
  2027.         mov     eax, [esp+8]
  2028.         pusha
  2029.         call    save_chs_sector
  2030.         popa
  2031.         cmp     [FDC_Status], 0
  2032.         jnz     .device_err
  2033.         call    save_flp_fat
  2034.         cmp     [FDC_Status], 0
  2035.         jz      @f
  2036. .device_err:
  2037.         mov     byte [esp+4], 11
  2038.         jmp     .ret
  2039. @@:
  2040.  
  2041. ; now ebx=start pos, ecx=end pos, both lie inside file
  2042.         sub     ecx, ebx
  2043.         jz      .ret
  2044.         call    SetUserInterrupts
  2045. .write_loop:
  2046.         lea     eax, [edi+31]   ; current sector
  2047. ; get length of data in current sector
  2048.         push    ecx
  2049.         sub     ebx, 0x200
  2050.         jb      .hasdata
  2051.         neg     ebx
  2052.         xor     ecx, ecx
  2053.         jmp     @f
  2054. .hasdata:
  2055.         neg     ebx
  2056.         cmp     ecx, ebx
  2057.         jbe     @f
  2058.         mov     ecx, ebx
  2059. @@:
  2060. ; load sector if needed
  2061.         cmp     dword [esp+4], 0        ; we don't need to read uninitialized data
  2062.         jz      .noread
  2063.         cmp     ecx, 0x200      ; we don't need to read sector if it is fully rewritten
  2064.         jz      .noread
  2065.         cmp     ecx, esi        ; (same for the last sector)
  2066.         jz      .noread
  2067.         pusha
  2068.         call    read_chs_sector
  2069.         popa
  2070.         cmp     [FDC_Status], 0
  2071.         jz      @f
  2072. .device_err2:
  2073.         pop     ecx
  2074.         jmp     .device_err
  2075. @@:
  2076. .noread:
  2077. ; zero uninitialized data if file was extended (because floppy_extend_file does not this)
  2078.         push    eax ecx edi
  2079.         xor     eax, eax
  2080.         mov     ecx, 0x200
  2081.         sub     ecx, [esp+4+12]
  2082.         jbe     @f
  2083.         mov     edi, 0xD000
  2084.         add     edi, [esp+4+12]
  2085.         rep     stosb
  2086. @@:
  2087. ; zero uninitialized data in the last sector
  2088.         mov     ecx, 0x200
  2089.         sub     ecx, esi
  2090.         jbe     @f
  2091.         mov     edi, 0xD000
  2092.         add     edi, esi
  2093.         rep     stosb
  2094. @@:
  2095.         pop     edi ecx eax
  2096. ; copy new data
  2097.         push    eax
  2098.         mov     eax, edx
  2099.         neg     ebx
  2100.         jecxz   @f
  2101.         add     ebx, 0xD000+0x200
  2102.         call    memmove
  2103.         xor     ebx, ebx
  2104. @@:
  2105.         pop     eax
  2106. ; save sector
  2107.         pusha
  2108.         call    save_chs_sector
  2109.         popa
  2110.         cmp     [FDC_Status], 0
  2111.         jnz     .device_err2
  2112.         add     edx, ecx
  2113.         sub     [esp], ecx
  2114.         pop     ecx
  2115.         jz      .done
  2116. .next_cluster:
  2117.         movzx   edi, word [edi*2+0x282000]
  2118.         sub     esi, 0x200
  2119.         jae     @f
  2120.         xor     esi, esi
  2121. @@:
  2122.         sub     dword [esp], 0x200
  2123.         jae     .write_loop
  2124.         and     dword [esp], 0
  2125.         jmp     .write_loop
  2126. .done:
  2127.         mov     [fdc_irq_func], fdc_null
  2128.         jmp     .ret
  2129.  
  2130. floppy_extend_file.zero_size:
  2131.         xor     eax, eax
  2132.         jmp     floppy_extend_file.start_extend
  2133.  
  2134. ; extends file on floppy to given size (new data area is undefined)
  2135. ; in: edi->direntry, ecx=new size
  2136. ; out: CF=0 => OK, eax destroyed
  2137. ;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL)
  2138. floppy_extend_file:
  2139.         push    ecx
  2140. ; find the last cluster of file
  2141.         movzx   eax, word [edi+26]      ; first cluster
  2142.         mov     ecx, [edi+28]
  2143.         jecxz   .zero_size
  2144. @@:
  2145.         sub     ecx, 0x200
  2146.         jbe     @f
  2147.         mov     eax, [eax*2+0x282000]
  2148.         and     eax, 0xFFF
  2149.         jz      .fat_err
  2150.         cmp     eax, 0xFF8
  2151.         jb      @b
  2152. .fat_err:
  2153.         pop     ecx
  2154.         push    ERROR_FAT_TABLE
  2155.         pop     eax
  2156.         stc
  2157.         ret
  2158. @@:
  2159.         push    eax
  2160.         mov     eax, [eax*2+0x282000]
  2161.         and     eax, 0xFFF
  2162.         cmp     eax, 0xFF8
  2163.         pop     eax
  2164.         jb      .fat_err
  2165. ; set length to full number of sectors
  2166.         sub     [edi+28], ecx
  2167. .start_extend:
  2168.         pop     ecx
  2169. ; now do extend
  2170.         push    edx esi
  2171.         mov     esi, 0x282000+2*2       ; start scan from cluster 2
  2172.         mov     edx, 2847               ; number of clusters to scan
  2173. .extend_loop:
  2174.         cmp     [edi+28], ecx
  2175.         jae     .extend_done
  2176. ; add new sector
  2177.         push    ecx
  2178.         push    edi
  2179. .scan:
  2180.         mov     ecx, edx
  2181.         mov     edi, esi
  2182.         jecxz   .disk_full
  2183.         push    eax
  2184.         xor     eax, eax
  2185.         repnz   scasw
  2186.         pop     eax
  2187.         jnz     .disk_full
  2188.         mov     word [edi-2], 0xFFF
  2189.         mov     esi, edi
  2190.         mov     edx, ecx
  2191.         sub     edi, 0x282000
  2192.         shr     edi, 1
  2193.         dec     edi     ; now edi=new cluster
  2194.         test    eax, eax
  2195.         jz      .first_cluster
  2196.         mov     [0x282000+eax*2], di
  2197.         jmp     @f
  2198. .first_cluster:
  2199.         pop     eax             ; eax->direntry
  2200.         push    eax
  2201.         mov     [eax+26], di
  2202. @@:
  2203.         mov     eax, edi        ; eax=new cluster
  2204.         pop     edi             ; edi->direntry
  2205.         pop     ecx             ; ecx=required size
  2206.         add     dword [edi+28], 0x200
  2207.         jmp     .extend_loop
  2208. .extend_done:
  2209.         mov     [edi+28], ecx
  2210.         pop     esi edx
  2211.         clc
  2212.         ret
  2213. .disk_full:
  2214.         pop     edi ecx
  2215.         pop     esi edx
  2216.         stc
  2217.         push    ERROR_DISK_FULL
  2218.         pop     eax
  2219.         ret
  2220.  
  2221. fs_FloppyGetFileInfo:
  2222.         call    read_flp_fat
  2223.         cmp     [FDC_Status], 0
  2224.         jnz     ret11
  2225.         cmp     byte [esi], 0
  2226.         jnz     @f
  2227.         mov     eax, 2  ; unsupported
  2228.         ret
  2229. @@:
  2230.         push    edi
  2231.         call    fd_find_lfn
  2232.         jmp     fs_GetFileInfo_finish
  2233.  
  2234. ret11:
  2235.         mov     eax, 11
  2236.         ret
  2237.  
  2238. fs_FloppySetFileInfo:
  2239.         call    read_flp_fat
  2240.         cmp     [FDC_Status], 0
  2241.         jnz     ret11
  2242.         cmp     byte [esi], 0
  2243.         jnz     @f
  2244.         mov     eax, 2  ; unsupported
  2245.         ret
  2246. @@:
  2247.         push    edi
  2248.         call    fd_find_lfn
  2249.         jnc     @f
  2250.         pop     edi
  2251.         mov     eax, ERROR_FILE_NOT_FOUND
  2252.         ret
  2253. @@:
  2254.         push    eax
  2255.         call    bdfe_to_fat_entry
  2256.         pop     eax
  2257.         pusha
  2258.         call    save_chs_sector
  2259.         popa
  2260.         pop     edi
  2261.         xor     eax, eax
  2262.         cmp     [FDC_Status], 0
  2263.         jz      @f
  2264.         mov     al, 11
  2265. @@:
  2266.         ret
  2267.  
  2268. ;----------------------------------------------------------------
  2269. ;
  2270. ;  fs_FloppyExecute - LFN variant for executing from floppy
  2271. ;
  2272. ;  esi  points to floppy filename (e.g. 'dir1/name')
  2273. ;  ebp  points to full filename (e.g. '/fd/1/dir1/name')
  2274. ;  dword [ebx] = flags
  2275. ;  dword [ebx+4] = cmdline
  2276. ;
  2277. ;  ret ebx,edx destroyed
  2278. ;      eax > 0 - PID, < 0 - error
  2279. ;
  2280. ;--------------------------------------------------------------
  2281. fs_FloppyExecute:
  2282.         mov     edx, [ebx]
  2283.         mov     ebx, [ebx+4]
  2284.         test    ebx, ebx
  2285.         jz      @f
  2286.         add     ebx, std_application_base_address
  2287. @@:
  2288.  
  2289. ;----------------------------------------------------------------
  2290. ;
  2291. ; fs_FloppyExecute.flags - second entry
  2292. ;
  2293. ;  esi  points to floppy filename (kernel address)
  2294. ;  ebp  points to full filename
  2295. ;  edx  flags
  2296. ;  ebx  cmdline (kernel address)
  2297. ;
  2298. ;  ret  eax > 0 - PID, < 0 - error
  2299. ;
  2300. ;--------------------------------------------------------------
  2301.  
  2302. .flags:
  2303.         call    read_flp_fat
  2304.         cmp     byte [esi], 0
  2305.         jnz     @f
  2306. ; cannot execute root!
  2307.         mov     eax, -ERROR_ACCESS_DENIED
  2308.         ret
  2309. @@:
  2310.         push    edi
  2311.         call    fd_find_lfn
  2312.         jnc     .found
  2313.         pop     edi
  2314.         mov     eax, -ERROR_FILE_NOT_FOUND
  2315.         ret
  2316. .found:
  2317.         movzx   eax, word [edi+26]      ; cluster
  2318.         push    eax
  2319.         push    dword [edi+28]          ; size
  2320.         push    .DoRead
  2321.         call    fs_execute
  2322.         add     esp, 12
  2323.         pop     edi
  2324.         ret
  2325.  
  2326. .DoRead:
  2327. ; read next block
  2328. ; in: eax->parameters, edi->buffer
  2329. ; out: eax = error code
  2330.         pushad
  2331.         cmp     dword [eax], 0  ; file size
  2332.         jz      .eof
  2333.         mov     eax, [eax+4]    ; cluster
  2334.         add     eax, 31
  2335.         call    read_chs_sector
  2336.         cmp     [FDC_Status], 0
  2337.         jnz     .err
  2338.         pop     edi
  2339.         mov     esi, 0xD000
  2340.         push    edi
  2341.         mov     ecx, 512/4
  2342.         rep     movsd
  2343.         mov     eax, [esp+28]
  2344.         mov     ecx, [eax]
  2345.         sub     ecx, 512
  2346.         jae     @f
  2347.         add     edi, ecx
  2348.         neg     ecx
  2349.         push    eax
  2350.         xor     eax, eax
  2351.         rep     stosb
  2352.         pop     eax
  2353. @@:
  2354.         mov     [eax], ecx
  2355.         mov     edx, [eax+4]
  2356.         mov     dx, [edx*2+0x282000]
  2357.         mov     [eax+4], dx     ; high word is already zero
  2358.         popad
  2359.         xor     eax, eax
  2360.         ret
  2361. .eof:
  2362.         popad
  2363.         mov     eax, 6
  2364.         ret
  2365. .err:
  2366.         popad
  2367.         mov     eax, 11
  2368.         ret
  2369.  
  2370. ; \end{diamond}
  2371.