path: root/v2.0/source/XENIX2.ASM

;
; xenix file calls for MSDOS
;

INCLUDE DOSSEG.ASM

IFNDEF  KANJI
KANJI   EQU     0       ;FALSE
ENDIF

CODE    SEGMENT BYTE PUBLIC  'CODE'
        ASSUME  SS:DOSGROUP,CS:DOSGROUP

.xlist
.xcref
INCLUDE DOSSYM.ASM
INCLUDE DEVSYM.ASM
.cref
.list

TITLE   XENIX - IO system to mimic UNIX
NAME    XENIX

        i_need  NoSetDir,BYTE
        i_need  CURDRV,BYTE
        i_need  IOCALL,BYTE
        i_need  IOMED,BYTE
        i_need  IOSCNT,WORD
        i_need  IOXAD,DWORD
        i_need  DIRSTART,WORD
        i_need  ATTRIB,BYTE
        i_need  THISFCB,DWORD
        i_need  AuxStack,BYTE
        i_need  Creating,BYTE
        i_need  ThisDRV,BYTE
        i_need  NAME1,BYTE
        i_need  LastEnt,WORD
        i_need  ThisDPB,DWORD
        i_need  EntLast,WORD
        i_need  CurrentPDB,WORD
        i_need  sft_addr,DWORD              ; pointer to head of table
        i_need  CURBUF,DWORD                ; pointer to current buffer
        i_need  DMAADD,DWORD                ; pointer to current dma address

BREAK <Local data>

CODE        ENDS
DATA        SEGMENT BYTE PUBLIC 'DATA'


PushSave    DW      ?
PushES      DW      ?
PushBX      DW      ?

xenix_count     DW      ?

DATA        ENDS
CODE        SEGMENT BYTE PUBLIC 'CODE'


BREAK <get_sf_from_sfn - translate a sfn into sf pointer>
;
; get_sf_from_sfn
; input:    AX has sfn (0 based)
;           DS is DOSGROUP
; output:   JNC <found>
;               ES:DI is sf entry
;           JC  <error>
;               ES,DI indeterminate
;
        procedure   get_sf_from_sfn,NEAR
        ASSUME  DS:DOSGROUP,ES:NOTHING
        PUSH    AX                      ; we trash AX in process
        LES     DI,[sft_addr]

get_sfn_loop:
        CMP     DI,-1                   ; end of chain of tables?
        JZ      get_sf_invalid          ; I guess so...
        SUB     AX,ES:[DI].sft_count    ; chop number of entries in this table
        JL      get_sf_gotten           ; sfn is in this table
        LES     DI,ES:[DI].sft_link     ; step to next table
        JMP     get_sfn_loop

get_sf_gotten:
        ADD     AX,ES:[DI].sft_count    ; reset to index in this table
        PUSH    BX
        MOV     BX,SIZE sf_entry
        MUL     BL                      ; number of bytes offset into table
        POP     BX
        ADD     AX,sft_table            ; offset into sf table structure
        ADD     DI,AX                   ; offset into memory
        CLC
        JMP     SHORT get_sf_ret

get_sf_jfn_invalid:
get_sf_invalid:
        STC

get_sf_jfn_ret:
get_sf_ret:
        POP     AX                      ; remember him?
        RET
get_sf_from_sfn ENDP

BREAK <get_sf_from_jfn - translate a jfn into sf pointer>
;
; get_sf_from_jfn
; input:    BX is jfn 0 based
;           DS is DOSGROUP
; output:   JNC <found>
;               ES:DI is sf entry
;           JC  <error>
;               ES,DI is indeterminate
;
        procedure   get_sf_from_jfn,NEAR
        ASSUME  DS:DOSGROUP,ES:NOTHING
        PUSH    AX                      ; save him
        invoke  get_jfn_pointer
        JC      get_sf_jfn_invalid
        MOV     AL,ES:[DI]              ; get sfn
        CMP     AL,0FFh                 ; is it free?
        JZ      get_sf_jfn_invalid      ; yep... error
        XOR     AH,AH
        invoke  get_sf_from_sfn         ; check this sfn out...
        JMP     SHORT get_sf_jfn_ret    ; condition codes are properly set

get_sf_from_jfn ENDP

BREAK <get_jfn_pointer - map a jfn into a pointer to jfn>
;
; get_jfn_pointer
; input:    BX is jfn
;           DS is DOSGROUP
; output:   JNC <found>
;               ES:DI is pointer to jfn
;           JC  <bad jfn>
;
        procedure   Get_jfn_pointer,NEAR
        ASSUME  DS:DOSGROUP,ES:NOTHING
        CMP     BX,FilPerProc
        JAE     get_jfn_bad
        MOV     ES,[CurrentPDB]
        MOV     DI,BX
        ADD     DI,PDB_JFN_Table
        CLC
        RET

get_jfn_bad:
        STC
        RET
get_jfn_pointer ENDP


BREAK <$Close - release a handle>
;
;   Assembler usage:
;           MOV     BX, handle
;           MOV     AH, Close
;           INT     int_command
;
;   Error return:
;           AX = error_invalid_handle
;
        procedure   $Close,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING

        context DS

        invoke  get_jfn_pointer         ; get jfn loc
        JNC     close_jfn
close_bad_handle:
        error   error_invalid_handle

close_jfn:
        MOV     AL,BYTE PTR ES:[DI]
        CMP     AL,0FFh
        JE      close_bad_handle
        MOV     BYTE PTR ES:[DI],0FFh;
        XOR     AH,AH
        invoke  get_sf_from_sfn
        JC      close_bad_handle
        PUSH    ES
        POP     DS
        ASSUME  DS:NOTHING
        DEC     [DI].sf_ref_count       ; no more reference
        LEA     DX,[DI].sf_fcb
;
; need to restuff Attrib if we are closing a protected file
;
        TEST    [DI.sf_fcb.fcb_DevID],devid_file_clean+devid_device
        JNZ     close_ok
        PUSH    WORD PTR [DI].sf_attr
        invoke  MOVNAMENOSET
        POP     BX
        MOV     [Attrib],BL
        invoke  FCB_CLOSE_INNER
        CMP     AL,0FFh                 ; file not found error?
        JNZ     close_ok
        error   error_file_not_found
close_ok:
        transfer    SYS_RET_OK

$Close  ENDP


BREAK <PushDMA, PopDMA, ptr_normalize - set up local dma and save old>
; PushDMA
; input:    DS:DX is DMA
; output:   DS:DX is normalized , ES:BX destroyed
;           [DMAADD] is now set up to DS:DX
;           old DMA is pushed

        procedure   PushDMA,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING

        MOV     PushES,ES
        MOV     PushBX,BX
        POP     PushSave
        LES     BX,DWORD PTR [DMAADD]   ; get old dma
        PUSH    ES
        PUSH    BX
        PUSH    PushSave
        invoke  ptr_normalize           ; get new dma
        MOV     WORD PTR [DMAADD],DX    ; save IT!
        MOV     WORD PTR [DMAADD+2],DS
        MOV     ES,PushES
        MOV     BX,PushBX
        RET
PushDMA ENDP

; PopDMA
; input:    old DMA under ret address on stack
; output:   [DMAADD] set to old version and stack popped
        procedure   PopDMA,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING

        POP     PushSave
        POP     WORD PTR [DMAADD]
        POP     WORD PTR [DMAADD+2]
        PUSH    PushSave
        RET
PopDMA  ENDP

; ptr_normalize
; input:    DS:DX is a pointer
; output:   DS:DX is normalized (DX < 10h)
        procedure   ptr_normalize,NEAR
        PUSH    CX                      ; T1 = CX
        PUSH    DX                      ; T2 = DX
        MOV     CL,4
        SHR     DX,CL                   ; DX = (DX >> 4)    (using CX)
        MOV     CX,DS
        ADD     CX,DX
        MOV     DS,CX                   ; DS = DS + DX      (using CX)
        POP     DX
        AND     DX,0Fh                  ; DX = T2 & 0Fh
        POP     CX                      ; CX = T1

;       PUSH    AX
;       PUSH    DX
;       MOV     AX,DS
;       PUSH    CX
;       MOV     CL,4
;       SHR     DX,CL                   ; get upper part of dx
;       POP     CX
;       ADD     AX,DX                   ; add into seg address
;       MOV     DS,AX
;       POP     DX
;       AND     DX,0Fh                  ; save low part
;       POP     AX

        RET
ptr_normalize   ENDP

BREAK <$Read - Do file/device I/O>
;
;   Assembler usage:
;           LDS     DX, buf
;           MOV     CX, count
;           MOV     BX, handle
;           MOV     AH, Read
;           INT     int_command
;         AX has number of bytes read
;   Errors:
;           AX = read_invalid_handle
;              = read_access_denied
;

        procedure   $Read,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING

        invoke  PushDMA
        CALL    IO_setup
        JC      IO_err
        CMP     ES:[DI].sf_mode,open_for_write
        JNE     read_setup
IO_bad_mode:
        MOV     AL,read_access_denied
IO_err:
        invoke  PopDMA
        transfer    SYS_RET_ERR

read_setup:
        invoke  $FCB_RANDOM_READ_BLOCK  ; do read
IO_done:
        invoke  get_user_stack          ; get old frame
        MOV     AX,[SI].user_CX         ; get returned CX
        MOV     CX,xenix_count
        MOV     [SI].user_CX,CX         ; stash our CX
        invoke  PopDMA                  ; get old DMA
        transfer    SYS_RET_OK
$Read   ENDP

BREAK <$Write - Do file/device I/O>
;
;   Assembler usage:
;           LDS     DX, buf
;           MOV     CX, count
;           MOV     BX, handle
;           MOV     AH, Write
;           INT     int_command
;         AX has number of bytes written
;   Errors:
;           AX = write_invalid_handle
;              = write_access_denied
;

        procedure   $Write,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING

        invoke  PushDMA
        CALL    IO_setup
        JC      IO_err
        CMP     ES:[DI].sf_mode,open_for_read
        JE      IO_bad_mode
        invoke  $FCB_RANDOM_WRITE_BLOCK ; do write
        JMP     IO_done

$write  ENDP

IO_setup:
        ASSUME  DS:NOTHING,ES:NOTHING
        context DS
        MOV     xenix_count,CX
        invoke  Get_sf_from_jfn
        ; ES:DI is sf pointer
        MOV     AL,read_invalid_handle          ;Assume an error
        MOV     CX,xenix_count
        LEA     DX,[DI].sf_fcb
        PUSH    ES
        POP     DS
        ASSUME  DS:NOTHING
        RET

BREAK <$LSEEK - set random record field>
;
;   Assembler usage:
;           MOV     DX, offsetlow
;           MOV     CX, offsethigh
;           MOV     BX, handle
;           MOV     AL, method
;           MOV     AH, LSeek
;           INT     int_command
;         DX:AX has the new location of the pointer
;   Error returns:
;           AX = error_invalid_handle
;              = error_invalid_function
        procedure   $LSEEK,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING
        CMP     AL,3
        JB      lseek_get_sf
        error   error_invalid_function

lseek_get_sf:
        context DS
        invoke  get_sf_from_jfn
        PUSH    ES
        POP     DS
        ASSUME  DS:NOTHING
        JC      lseek_bad
;
; don't seek device
;
        TEST    [DI.sf_fcb+fcb_devid],devid_device
        JZ      lseek_dispatch
        XOR     AX,AX
        XOR     DX,DX
        JMP     SHORT lseek_ret
lseek_dispatch:
        DEC     AL
        JL      lseek_beginning
        DEC     AL
        JL      lseek_current
; move from end of file
; first, get end of file
        XCHG    AX,DX               ; AX <- low
        XCHG    DX,CX               ; DX <- high
        ASSUME  DS:NOTHING
        ADD     AX,[DI+sf_fcb+fcb_FILSIZ]
        ADC     DX,[DI+sf_fcb+fcb_FILSIZ+2]
        JMP     SHORT lseek_ret

lseek_beginning:
        XCHG    AX,DX               ; AX <- low
        XCHG    DX,CX               ; DX <- high

lseek_ret:
        MOV     WORD PTR [DI+sf_fcb+fcb_RR],AX
        MOV     WORD PTR [DI+sf_fcb+fcb_RR+2],DX
        invoke  get_user_stack
        MOV     [SI.user_DX],DX
        MOV     [SI.user_AX],AX
        transfer    SYS_RET_OK

lseek_current:
; ES:DI is pointer to sf... need to invoke  set random record for place
        XCHG    AX,DX               ; AX <- low
        XCHG    DX,CX               ; DX <- high
        ADD     AX,WORD PTR [DI+sf_fcb+fcb_RR]
        ADC     DX,WORD PTR [DI+sf_fcb+fcb_RR+2]
        JMP     lseek_ret

lseek_bad:
        error   error_invalid_handle
$lseek  ENDP


BREAK <$IOCTL - return/set device dependent stuff>
;
;   Assembler usage:
;           MOV     BX, Handle
;           MOV     DX, Data
;
;       (or LDS     DX,BUF
;           MOV     CX,COUNT)
;
;           MOV     AH, Ioctl
;           MOV     AL, Request
;           INT     21h
;
;   Error returns:
;           AX = error_invalid_handle
;              = error_invalid_function
;              = error_invalid_data

        procedure   $IOCTL,NEAR
        ASSUME  DS:NOTHING,ES:NOTHING
        MOV     SI,DS                   ;Stash DS for calls 2,3,4 and 5
        context DS
        CMP     AL,3
        JA      ioctl_check_block       ;Block device
        PUSH    DX
        invoke  get_sf_from_jfn
        POP     DX                      ;Restore DATA
        JNC     ioctl_check_permissions ; have valid handle
        error   error_invalid_handle

ioctl_check_permissions:
        CMP     AL,2
        JAE     ioctl_control_string
        CMP     AL,0
        MOV     AL,BYTE PTR ES:[DI+sf_fcb+fcb_devid]
        JZ      ioctl_read              ; read the byte
        OR      DH,DH
        JZ      ioctl_check_device      ; can I set with this data?
        error   error_invalid_data      ; no DH <> 0

ioctl_check_device:
        TEST    AL,devid_ISDEV          ; can I set this handle?
        JZ      ioctl_bad_fun           ; no, it is a file.
        MOV     BYTE PTR ES:[DI+sf_fcb+fcb_devid],DL
        transfer    SYS_RET_OK

ioctl_read:
        XOR     AH,AH
        TEST    AL,devid_ISDEV          ; Should I set high byte
        JZ      ioctl_no_high           ; no
        LES     DI,DWORD PTR ES:[DI+sf_fcb+fcb_FIRCLUS]  ;Get device pointer
        MOV     AH,BYTE PTR ES:[DI.SDEVATT+1]   ;Get high byte
ioctl_no_high:
        invoke  get_user_stack
        MOV     DX,AX
        MOV     [SI.user_DX],DX
        transfer    SYS_RET_OK

ioctl_control_string:
        TEST    BYTE PTR ES:[DI+sf_fcb+fcb_devid],devid_ISDEV   ; can I?
        JZ      ioctl_bad_fun           ; no, it is a file.
        LES     DI,DWORD PTR ES:[DI+sf_fcb+fcb_FIRCLUS]  ;Get device pointer
        XOR     BL,BL           ; Unit number of char dev = 0
        JMP     SHORT ioctl_do_string

ioctl_check_block:
        DEC     AL
        DEC     AL                      ;4=2,5=3,6=4,7=5
        CMP     AL,3
        JBE     ioctl_get_dev

        MOV     AH,1
        SUB     AL,4                    ;6=0,7=1
        JZ      ioctl_get_status
        MOV     AH,3
        DEC     AL
        JNZ     ioctl_bad_fun

ioctl_get_status:
        PUSH    AX
        invoke  GET_IO_FCB
        POP     AX
        JC      ioctl_acc_err
        invoke  IOFUNC
        MOV     AH,AL
        MOV     AL,0FFH
        JNZ     ioctl_status_ret
        INC     AL
ioctl_status_ret:
        transfer SYS_RET_OK

ioctl_bad_fun:
        error   error_invalid_function

ioctl_acc_err:
        error   error_access_denied

ioctl_get_dev:
        PUSH    CX
        PUSH    DX
        PUSH    AX
        PUSH    SI              ;DS in disguise
        MOV     AL,BL           ;Drive
        invoke  GETTHISDRV
        JC      ioctl_bad_drv
        invoke  FATREAD         ;"get" the drive
        MOV     BL,ES:[BP.dpb_UNIT]     ; Unit number
        LES     DI,ES:[BP.dpb_driver_addr]
        CLC                     ;Make sure error jump not taken
ioctl_bad_drv:
        POP     SI
        POP     AX
        POP     DX
        POP     CX
        JC      ioctl_acc_err
ioctl_do_string:
        TEST    ES:[DI.SDEVATT],DEVIOCTL        ;See if device accepts control
        JZ      ioctl_bad_fun                   ;NO
        DEC     AL
        DEC     AL
        JZ      ioctl_control_read
        MOV     [IOCALL.REQFUNC],DEVWRIOCTL
        JMP     SHORT ioctl_control_call
ioctl_control_read:
        MOV     [IOCALL.REQFUNC],DEVRDIOCTL
ioctl_control_call:
        MOV     AL,DRDWRHL
        MOV     AH,BL                           ;Unit number
        MOV     WORD PTR [IOCALL.REQLEN],AX
        XOR     AX,AX
        MOV     [IOCALL.REQSTAT],AX
        MOV     [IOMED],AL
        MOV     [IOSCNT],CX
        MOV     WORD PTR [IOXAD],DX
        MOV     WORD PTR [IOXAD+2],SI
        PUSH    ES
        POP     DS
ASSUME  DS:NOTHING
        MOV     SI,DI                   ;DS:SI -> driver
        PUSH    SS
        POP     ES
        MOV     BX,OFFSET DOSGROUP:IOCALL       ;ES:BX -> Call header
        invoke  DEVIOCALL2
        MOV     AX,[IOSCNT]             ;Get actual bytes transferred
        transfer    SYS_RET_OK

$IOCTL  ENDP

BREAK <File_Times - modify write times on a handle>
;
;   Assembler usage:
;           MOV AH, FileTimes
;           MOV AL, func
;           MOV BX, handle
;       ; if AL = 1 then then next two are mandatory
;           MOV CX, time
;           MOV DX, date
;           INT 21h
;       ; if AL = 0 then CX/DX has the last write time/date
;       ; for the handle.
;
;   Error returns:
;           AX = error_invalid_function
;              = error_invalid_handle
;
procedure   $File_times,near
        CMP     AL,2
        JB      filetimes_ok
        error   error_invalid_function

filetimes_ok:
        PUSH    SS
        POP     DS
        CALL    Get_sf_from_jfn
        JNC     filetimes_disp
        error   error_invalid_handle

filetimes_disp:
        OR      AL,AL
        JNZ     filetimes_set
        MOV     CX,ES:[DI.sf_fcb.fcb_FTIME]
        MOV     DX,ES:[DI.sf_fcb.fcb_FDATE]
        invoke  Get_user_stack
        MOV     [SI.user_CX],CX
        MOV     [SI.user_DX],DX
        transfer    SYS_RET_OK

filetimes_set:
        MOV     ES:[DI.sf_fcb.fcb_FTIME],CX
        MOV     ES:[DI.sf_fcb.fcb_FDATE],DX
        AND     ES:[DI.sf_fcb.fcb_DEVID],NOT devid_file_clean
        transfer    SYS_RET_OK
$file_times ENDP

do_ext

CODE    ENDS
    END