ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/MISC/NETWORK/TEL23SRC.ZIP/INT14/INT14.ASM

Assembly Source File | 1991-07-01 | 32.2 KB | 1,043 lines

;
;  Int 14h support routines
;****************************************************************************
;*                                                                          *
;*                                                                          *
;*      part of NCSA Telnet                                                 *
;*      by Tim Krauskopf, VT100 by Gaige Paulsen, Tek by Aaron Contorer     *
;*          Kurt Mahan, Heeren Pathak, Quincey Koziol, & Chris Wilson       *
;*                                                                          *
;*      National Center for Supercomputing Applications                     *
;*      152 Computing Applications Building                                 *
;*      605 E. Springfield Ave.                                             *
;*      Champaign, IL  61820                                                *
;*                                                                          *
;****************************************************************************
;
    NAME    INT14
;Microsoft EQU 1
;Lattice EQU 1
    ifndef Microsoft
        ifndef Lattice
            if2
                %out
                %out ERROR: You have to specify "/DMicrosoft" or "/DLattice" on the
                %out         MASM command line to determine the type of assembly.
                %out
            endif
            end
        endif
    endif
;
;******************************************************************
;*
;*    We need to set up a stack for netsleep when we exit to DOS.

NEWSTACK SEGMENT PARA STACK 'STACK'
    dw 4096 dup(?)
STACKEND label far
NEWSTACK    ends

X   EQU     6
PORT    EQU 1
ifdef Microsoft
;DGROUP  group _DATA
;_DATA segment public 'DATA'
;    assume DS:DGROUP
.8086
.MODEL    LARGE
.DATA
    else
    INCLUDE    DOS.MAC
    SETX
    DSEG
endif

OLDSS           dw ?
OLDSP           dw ?

NUM_COMM_PORTS  EQU     4
NUM_SEGS        EQU     3360H

ifdef Microsoft
PUBLIC  _INITIALIZED_FLAGS,_CONNECTED_FLAGS,_OPENING_FLAGS       ; FOR DEBUGGING
PUBLIC  _PORT_BUFFER,_BUFFER_OFFSET       ; FOR DEBUGGING
PUBLIC  _PNUM,_DATA_BEGIN,_DATA_MAX,_DATA_END,_DATA_START
EXTRN   _PRINT_INT:PROC         ; FOR DEBUGGING
EXTRN   _PRINT_INT2:PROC        ; FOR DEBUGGING
EXTRN   _GET_COMM_CHAR:PROC     ; GET A CHARACTER FROM A COMM BUFFER
EXTRN   _NETCLOSE:PROC          ; EXTERNAL PROCEDURE TO CLOSE A CONNECTION
EXTRN   _NETWRITE:PROC          ; EXTERNAL PROCEDURE TO WRITE TO A CONNECTION
EXTRN   _INT14OPEN:PROC         ; EXTERNAL PROCEDURE TO OPEN A CONNECTION
_PNUM   DW NUM_COMM_PORTS DUP(0)    ; PORT WE ARE CONNECTED TO

_INITIALIZED_FLAGS DB 0         ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS INITIALIZED (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IF COMM. PORT 1, ETC..)
_CONNECTED_FLAGS DB 0           ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS CONNECTED (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IS COMM. PORT 1, ETC..)
_OPENING_FLAGS DB 0             ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS OPENING (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IS COMM. PORT 1, ETC..)
_PORT_BUFFER    DB  NUM_COMM_PORTS DUP (64 DUP (0)) ; SPECIFY THE FOUR BUFFERS FOR THE CONNECTION NAMES
_BUFFER_OFFSET  DB  NUM_COMM_PORTS DUP (0)   ; THE OFFSETS INTO THE FOUR PORT BUFFERS
_CHAR_TO_SEND   DB 0            ; SPACE TO STORE THE CHARACTER TO SEND ON THE NET
_DATA_BEGIN     DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE BEGINNING OF
                                ;   THE DATA BUFFER FOR EACH COMM. PORT
_DATA_END       DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE END OF
                                ;   THE DATA BUFFER FOR EACH COMM. PORT
_DATA_MAX       DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE MAX OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
_DATA_START     DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE START OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
else
PUBLIC  INITIALIZED_FLAGS,CONNECTED_FLAGS,OPENING_FLAGS       ; FOR DEBUGGING
PUBLIC  PORT_BUFFER,BUFFER_OFFSET       ; FOR DEBUGGING
PUBLIC  PNUM,DATA_BEGIN,DATA_MAX,DATA_END,DATA_START
EXTRN   PRINT_INT:PROC          ; FOR DEBUGGING
EXTRN   PRINT_INT2:PROC         ; FOR DEBUGGING
EXTRN   GET_COMM_CHAR:PROC      ; GET A CHARACTER FROM A COMM BUFFER
EXTRN   NETCLOSE:PROC           ; EXTERNAL PROCEDURE TO CLOSE A CONNECTION
EXTRN   NETWRITE:PROC           ; EXTERNAL PROCEDURE TO WRITE TO A CONNECTION
EXTRN   INT14OPEN:PROC          ; EXTERNAL PROCEDURE TO OPEN A CONNECTION
PNUM   DW NUM_COMM_PORTS DUP(0)             ; PORT WE ARE CONNECTED TO

INITIALIZED_FLAGS DB 0          ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS INITIALIZED (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IF COMM. PORT 1, ETC..)
CONNECTED_FLAGS DB 0            ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS CONNECTED (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IS COMM. PORT 1, ETC..)
OPENING_FLAGS DB 0              ; A FLAG IN EACH BIT POSITION TO INDICATE THAT
                                ; COMM. PORT IS OPENING (BIT 0 IS COMM PORT
                                ; 0, BIT 1 IS COMM. PORT 1, ETC..)
PORT_BUFFER     DB  NUM_COMM_PORTS DUP (64 DUP (0)) ; SPECIFY THE FOUR BUFFERS FOR THE CONNECTION NAMES
BUFFER_OFFSET   DB  NUM_COMM_PORTS DUP (0)   ; THE OFFSETS INTO THE FOUR PORT BUFFERS
CHAR_TO_SEND    DB 0             ; SPACE TO STORE THE CHARACTER TO SEND ON THE NET
DATA_BEGIN      DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE BEGINNING OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
DATA_END        DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE END OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
DATA_MAX        DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE MAX OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
DATA_START      DD NUM_COMM_PORTS DUP(0); ARRAY OF POINTERS TO THE START OF
                                ;   THE DATA BUFFERS FOR EACH COMM. PORT
endif

ifdef Microsoft
;_DATA ends
;
;_TEXT    segment public 'CODE'
;    assume CS:_TEXT
.CODE
else
    ENDDS
    PSEG
endif
;
;**************************************************************************
;
;  Routines to install and deinstall a routine which manages the
;       serial port
;
;
SERIALINT     EQU 4*14H       ; User hook to timer int

ifdef Microsoft
    PUBLIC  _INT14INST,_INT14DEINST
    PUBLIC  _INT14CHECK,_INT14RECEIVE
ifdef QAK
    PUBLIC  _INT65INST,_INT65DEINST
endif
    PUBLIC  _GO_TSR
    EXTRN   _int14netsleep:FAR   ; C routine which gets called from handler
    PUBLIC  _TIMEINST,_TIMEDEINST
else
    PUBLIC  INT14INST,INT14DEINST
    PUBLIC  INT14CHECK,INT14RECEIVE
ifdef QAK
    PUBLIC  INT65INST,INT65DEINST
endif
    PUBLIC  GO_TSR
    EXTRN   int14netsleep:FAR   ; C routine which gets called from handler
    PUBLIC  TIMEINST,TIMEDEINST
endif
;
;**************************************************************************
;
;  Routines to install and deinstall a timer routine which calls
;  netsleep(0);
;  The timer is set to go off every 1/2 second to check for packets
;  in the incoming packet buffer.  We use the user-hook into the system
;  timer which occurs every 1/18th of a second.
;
;
TIMEINT        EQU    4*1CH        ; User hook to timer int

;*************************************************************************
;
;  Take out the timer interrupt handler, restore previous value
;
ifdef Microsoft
_TIMEDEINST    PROC    FAR
else
TIMEDEINST PROC    FAR
endif
    MOV        CX,CS:TIP        ; GET OLD IP FROM SAVE SPOT
    MOV        DX,CS:TCS        ; GET OLD CS FROM SAVE SPOT
    MOV        BX,TIMEINT        ; INTERRUPT IN TABLE FOR TIMER
    PUSH    DS
    XOR        AX,AX            ; SYSTEM INTERRUPT TABLE
    MOV        DS,AX
    CLI
    MOV        [BX],CX            ; STORE OLD IP INTO THE TABLE
    INC        BX
    INC        BX                ; MOVE POINTER IN INTERRUPT TABLE
    MOV        [BX],DX            ; STORE OLD CS INTO THE TABLE
    STI
    POP        DS
    RET
ifdef Microsoft
_TIMEDEINST    ENDP
else
TIMEDEINST ENDP
endif

;
;
;  install the timer interrupt handler, the handler is technically
;  part of this procedure.
;
ifdef Microsoft
_TIMEINST  PROC    FAR
else
TIMEINST   PROC    FAR
endif
    XOR        AX,AX
    MOV     CS:INTENTER,AL    ; CLEAR THIS FLAG
    MOV        CS:TMYDS,DS        ; STORE FOR USE BY HANDLER
    MOV        BX,TIMEINT        ; INTERRUPT IN TABLE FOR TIMER (1c)
    PUSH    DS
    XOR        AX,AX            ; SYSTEM INTERRUPT TABLE
    MOV        DS,AX
    MOV        AX,OFFSET THAND    ; WHERE THE HANDLER IS
    CLI
    MOV        DX,[BX]            ; KEEP COPY OF THE IP
    MOV        [BX],AX            ; STORE IP INTO THE TABLE
    INC        BX
    INC        BX                ; MOVE POINTER IN INTERRUPT TABLE
    MOV        CX,[BX]            ; KEEP COPY OF THE CS, TOO
    MOV        AX,CS
    MOV        [BX],AX            ; STORE NEW CS INTO THE TABLE
    STI
    POP    DS
    MOV    CS:TIP,DX            ; STORE THEM AWAY
    MOV    CS:TCS,CX
    RET
;
;  Code segment addressable data for keeping track of the interrupt handler
;  stuff
;
TMYDS        DW    00H            ; THE DATA SEGMENT FOR THIS ASSEMBLY CODE
TICNT        DB    0            ; COUNTER OF 1/18THS SEC
INTENTER      DB  00
TIP          DW  00
TCS          DW  00
;
;   The handler itself.
;
THAND:                           ; not a public name, only handles ints
    STI
    PUSH    DS
    PUSH     ES
    PUSH    AX
    PUSH    BX
    PUSH    CX
    PUSH    DX
    PUSH    DI
    PUSH    SI

    CLD                        ; ALL MOVES WILL BE FORWARD
    MOV     AL,CS:INTENTER
    OR        AL,AL
    JNZ        TIME2
    MOV        AL,1
    MOV     CS:INTENTER,AL    ; SET FLAG TO INDICATE BUSY
ifdef FAST
    INC     CS:TICNT
    MOV     AL,CS:TICNT     ; COUNTER FOR US
ifdef QAK
    AND        AL,7            ; SEE IF # MOD 8 = 0
else
    AND     AL,3            ; SEE IF # MOD 4 = 0
endif
    JNZ        TSKIP            ; SKIP 7 OUT OF 8 TIMES
endif
;
    MOV        AL,60H            ; EOI FOR TIMER INT
    OUT        20H,AL            ; LET LOWER INTERRUPTS IN
;
;  SET UP CORRECT DS
;
    MOV        DS,CS:TMYDS        ; GET CORRECT DS
;
;  do we have to set up our own stack here?
;
    MOV        AX,SS
    MOV        OLDSS,AX
    MOV        OLDSP,SP
    CLI
    MOV        AX,seg NEWSTACK
    MOV        SS,AX
    MOV        SP,OFFSET STACKEND
    STI
;    XOR     AX,AX
;    PUSH    AX
ifdef Microsoft
    CALL _int14netsleep
else
    CALL int14netsleep
endif
;    POP     AX
    CLI
    MOV        AX,OLDSS
    MOV        SS,AX
    MOV        SP,OLDSP
    STI
TSKIP:
    XOR        AL,AL
    MOV     CS:INTENTER,AL    ; REENTER FLAG, DONE NOW
ifdef QAK
MOV     AX,65               ; DEBUGGING
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
POP     AX
endif
TIME2:
    POP     SI
    POP        DI
    POP        DX
    POP        CX
    POP        BX
    POP        AX
    POP        ES
    POP        DS
;
;   forward to any other existing routines
;
ifndef QAK
    JMP     DWORD PTR CS:TIP
else
    IRET
endif
ifdef Microsoft
_TIMEINST      ENDP
else
TIMEINST       ENDP
endif

;*************************************************************************
;
;  Go into TSR mode
;
ifdef Microsoft
_GO_TSR    PROC    FAR
else
GO_TSR  PROC    FAR
endif
    MOV     AX,3100H            ; DOS TSR FUNCTION
    MOV     DX,NUM_SEGS            ; THIS IS REALLY, REALLY BAD, NEEDS TO NOT
                                ; BE A HARDWIRED NUMBER
    INT     21H                 ; GO TSR
ifdef Microsoft
_GO_TSR    ENDP
else
GO_TSR  ENDP
endif

;*************************************************************************
;
;  Check the int14 receive status
;
ifdef Microsoft
_INT14CHECK    PROC    FAR
else
INT14CHECK PROC    FAR
endif
    MOV     AH,3
    MOV     DX,PORT
    INT     14H
    XOR     AL,AL
    RET
ifdef Microsoft
_INT14CHECK    ENDP
else
INT14CHECK ENDP
endif

;*************************************************************************
;
;  Get a character from int14
;
ifdef Microsoft
_INT14RECEIVE    PROC    FAR
else
INT14RECEIVE PROC    FAR
endif
    MOV     AH,2
    MOV     DX,PORT
    INT     14H
    RET
ifdef Microsoft
_INT14RECEIVE   ENDP
else
INT14RECEIVE ENDP
endif

;*************************************************************************
;
;  Take out the serial interrupt handler, restore previous value
;
ifdef Microsoft
_INT14DEINST    PROC    FAR
else
INT14DEINST PROC    FAR
endif
ifdef DEBUG
MOV     AX,43               ; DEBUGGING
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
POP     AX
endif
    MOV     CX,CS:SIP       ; GET OLD IP FROM SAVE SPOT
    MOV     DX,CS:SCS       ; GET OLD CS FROM SAVE SPOT
    MOV     BX,SERIALINT    ; INTERRUPT IN TABLE FOR TIMER
    PUSH    DS
    XOR        AX,AX            ; SYSTEM INTERRUPT TABLE
    MOV        DS,AX
    CLI
    MOV        [BX],CX            ; STORE OLD IP INTO THE TABLE
    INC        BX
    INC        BX                ; MOVE POINTER IN INTERRUPT TABLE
    MOV        [BX],DX            ; STORE OLD CS INTO THE TABLE
    STI
    POP        DS
    RET
ifdef Microsoft
_INT14DEINST    ENDP
else
INT14DEINST ENDP
endif
;
;
;  install the serial interrupt handler, the handler is technically
;  part of this procedure.
;
ifdef Microsoft
_INT14INST  PROC    FAR
else
INT14INST   PROC    FAR
endif

ifdef DEBUG
MOV     AX,42               ; DEBUGGING
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
POP     AX
endif

    XOR        AX,AX
    MOV     CS:INTENTER,AL    ; CLEAR THIS FLAG
    MOV     CS:SMYDS,DS     ; STORE FOR USE BY HANDLER
    MOV     BX,SERIALINT    ; INTERRUPT IN TABLE FOR TIMER (1c)
    PUSH    DS
    XOR        AX,AX            ; SYSTEM INTERRUPT TABLE
    MOV        DS,AX
    MOV     AX,OFFSET SHAND ; WHERE THE HANDLER IS
    CLI
    MOV        DX,[BX]            ; KEEP COPY OF THE IP
    MOV        [BX],AX            ; STORE IP INTO THE TABLE
    INC        BX
    INC        BX                ; MOVE POINTER IN INTERRUPT TABLE
    MOV        CX,[BX]            ; KEEP COPY OF THE CS, TOO
    MOV        AX,CS
    MOV        [BX],AX            ; STORE NEW CS INTO THE TABLE
    STI
    POP    DS
    MOV CS:SIP,DX           ; STORE THEM AWAY
    MOV CS:SCS,CX
    RET
;
;  Code segment addressable data for keeping track of the interrupt handler
;  stuff
;
SMYDS       DW  00H         ; THE DATA SEGMENT FOR THIS ASSEMBLY CODE
SICNT       DB  0           ; COUNTER OF 1/18THS SEC
;SENTER      DB  00
SIP         DW  00
SCS         DW  00
;
;   The handler itself.
;
SHAND:                      ; not a public name, only handles ints
    STI
    PUSH    DS
    PUSH     ES
    PUSH    AX
    PUSH    BX
    PUSH    CX
    PUSH    DX
    PUSH    DI
    PUSH    SI

    CLD                        ; ALL MOVES WILL BE FORWARD
    MOV     BL,CS:INTENTER    ; CHECK FOR RE-ENTRY
    OR      BL,BL
    JZ      NO_RE_ENTRY     ;
    JMP     SERIAL2         ; DON'T RE-ENTER, WE ARE BUSY NOW
NO_RE_ENTRY:
    MOV     BL,1
    MOV     CS:INTENTER,BL    ; SET FLAG TO INDICATE BUSY

;
ifdef QAK
    MOV        AL,60H            ; EOI FOR TIMER INT
    OUT        20H,AL            ; LET LOWER INTERRUPTS IN
endif
;
;  SET UP CORRECT DS
;
    MOV     DS,CS:SMYDS     ; GET CORRECT DS
;
;  do we have to set up our own stack here?
;
    MOV     BX,SS
    MOV     OLDSS,BX
    MOV        OLDSP,SP
    CLI
    MOV     BX,seg NEWSTACK
    MOV     SS,BX
    MOV        SP,OFFSET STACKEND
    STI

ifdef DEBUG
PUSH    DX
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
POP     AX
POP     DX
endif
    MOV     CX,DX           ; MOVE THE COMM. PORT INTO THE CX REGISTER
    MOV     BL,1            ; MOVE A FLAG INTO THE BL REGISTER
    SHL     BL,CL           ; SHIFT THE FLAG TO LINE UP WITH THE CORRECT INITIALIZATION FLAG

    CMP     AH,03           ; CHECK FOR READ STATUS
    JNE     NOT_STATUS_CHECK; A COMMUNICATION REQUEST WHICH WE DON'T HANDLE

READ_STATUS:                ; CHECK FOR A CHARACTER
ifdef Microsoft
    TEST    BL,_CONNECTED_FLAGS; CHECK WHETHER THIS PORT IS CONNECTED
else
    TEST    BL,CONNECTED_FLAGS; CHECK WHETHER THIS PORT IN CONNECTED
endif
    JNE     GET_PORT_STATUS         ; GET THE PORT STATUS
;    MOV     AX,7ABFH                ; REPORT ERROR CONDITION
    MOV     AX,2000H                ; REPORT ERROR CONDITION
    JMP     SHORT STATUS_FINISHED   ;

GET_PORT_STATUS:
ifdef Microsoft
    MOV     SI,OFFSET _DATA_BEGIN   ; GET THE POINTER TO THE BEGINNING OF THE DATA BUFFER
    MOV     DI,OFFSET _DATA_END     ; GET THE POINTER TO THE END OF THE DATA BUFFER
else
    MOV     SI,OFFSET DATA_BEGIN    ; GET THE POINTER TO THE BEGINNING OF THE DATA BUFFER
    MOV     DI,OFFSET DATA_END      ; GET THE POINTER TO THE END OF THE DATA BUFFER
endif
    SHL     DX,1                    ; MULTIPLY THE PORT NUMBER BY 4 TO GET THE
    SHL     DX,1                    ;   OFFSET TO THE CORRECT ARRAY ELEMENT
    ADD     SI,DX                   ; INCREMENT TO THE CORRECT ARRAY ELEMENT
    ADD     DI,DX

    MOV     AX,DS:[SI]              ; GET THE OFFSET INTO THE DATA BUFFER OF THE BEGINNING
    CMP     AX,DS:[DI]              ; CHECK WHETHER THERE ARE CHARACTERS IN THE BUFFER
    JE      CHARACTER_NOT_READY     ; IF THE TWO POINTERS ARE THE SAME, THEN THERE IS NO DATA
    MOV     AX,2100h                ; SET THE DATA READY FLAG
;    JMP     STATUS_FINISHED
    JMP     SSKIP2                  ; JUMP TO THE END OF THE ROUTINE
CHARACTER_NOT_READY:
    MOV     AX,2000H                ; RESET THE DATA READY FLAG

STATUS_FINISHED:
    JMP     SSKIP2                  ; JUMP TO THE END OF THE ROUTINE

NOT_STATUS_CHECK:
    CMP     AH,02           ; CHECK FOR RECEIVING CHARACTER
    JNE     NOT_RECEIVE_CHARACTER;  JUMP AROUND RECEIVING A CHARACTER

RECEIVE_CHARACTER:          ; GET A CHARACTER
ifdef Microsoft
    TEST    BL,_CONNECTED_FLAGS; CHECK WHETHER THIS PORT IN CONNECTED
else
    TEST    BL,CONNECTED_FLAGS; CHECK WHETHER THIS PORT IN CONNECTED
endif
    JNE     GET_PORT_CHARACTER; GET A CHARACTER FROM THE PORT
    MOV     AH,80H          ; REPORT ERROR CONDITION
    JMP     SHORT RECEIVE_FINISHED   ;

GET_PORT_CHARACTER:
ifdef QAK
    PUSH    DX                      ; PUSH THE PORT NUMBER
ifdef Microsoft
    CALL    _GET_COMM_CHAR          ; CALL A C ROUTINE TO GET THE CHARACTER
else
    CALL    GET_COMM_CHAR           ; CALL A C ROUTINE TO GET THE CHARACTER
endif
    ADD     SP,2                    ; REMOVE PARAMETER
else
ifdef Microsoft
    MOV     SI,OFFSET _DATA_BEGIN   ; GET THE POINTER TO THE BEGINNING OF THE DATA BUFFER
    MOV     DI,OFFSET _DATA_END     ; GET THE POINTER TO THE END OF THE DATA BUFFER
else
    MOV     SI,OFFSET DATA_BEGIN    ; GET THE POINTER TO THE BEGINNING OF THE DATA BUFFER
    MOV     DI,OFFSET DATA_END      ; GET THE POINTER TO THE END OF THE DATA BUFFER
endif
    SHL     DX,1                    ; MULTIPLY THE PORT NUMBER BY 4 TO GET THE
    SHL     DX,1                    ;   OFFSET TO THE CORRECT ARRAY ELEMENT
    ADD     SI,DX                   ; INCREMENT TO THE CORRECT ARRAY ELEMENT
    ADD     DI,DX
WAIT_FOR_CHARACTER:
    MOV     AX,DS:[SI]              ; GET THE OFFSET INTO THE DATA BUFFER OF THE BEGINNING
    CMP     AX,DS:[DI]              ; CHECK WHETHER THERE ARE CHARACTERS IN THE BUFFER
    JE      WAIT_FOR_CHARACTER      ; IF THE TWO POINTERS ARE THE SAME, THEN WAIT FOR DATA

    PUSH    DS
    MOV     DI,AX                   ; SAVE THE OFFSET OF THE BEGINING POINTER
    MOV     AX,DS:[SI+2]            ; GET THE SEGMENT OF THE BEGINNING POINTER
    MOV     DS,AX
    MOV     AL,BYTE PTR DS:[DI]     ; GET THE CHARACTER FROM THE BEGINNING OF THE QUEUE
    POP     DS                      ; RECOVER THE DATA SEGMENT
ifdef Microsoft
    MOV     DI,OFFSET _DATA_MAX     ; GET THE POINTER TO THE MAX OF THE DATA BUFFER
else
    MOV     DI,OFFSET DATA_MAX      ; GET THE POINTER TO THE MAX OF THE DATA BUFFER
endif
    ADD     DI,DX                   ; INCREMENT TO THE CORRECT ARRAY ELEMENT
    INC     WORD PTR DS:[SI]        ; INCREMENT THE BEGINNING OF THE QUEUE
    MOV     CX,DS:[SI]              ; GET THE BEGINNING OF THE QUEUE
    CMP     CX,DS:[DI]              ; CHECK FOR WRAPPING AROUND
    JL      NOT_WRAPPED             ; JUMP AROUND WRAP-AROUND FIX
ifdef Microsoft
    MOV     DI,OFFSET _DATA_START   ; GET THE POINTER TO THE MAX OF THE DATA BUFFER
else
    MOV     DI,OFFSET DATA_START    ; GET THE POINTER TO THE MAX OF THE DATA BUFFER
endif
    ADD     DI,DX                   ; INCREMENT TO THE CORRECT ARRAY ELEMENT
    MOV     CX,DS:[DI]              ; GET THE START OF THE QUEUE
    MOV     DS:[SI],CX              ; MOVE THE BEGINNING OF THE QUEUE AROUND
endif

NOT_WRAPPED:
    MOV     AH,21                   ; REPORT SUCCESS

RECEIVE_FINISHED:
    JMP     SSKIP2                  ; JUMP TO THE END OF THE ROUTINE

NOT_RECEIVE_CHARACTER:
    CMP     AH,01           ; CHECK FOR SEND CHARACTER
    JE      SEND_CHARACTER  ; JUMP TO SENDING THE CHARACTER
    JMP     NOT_SEND_CHARACTER; JUMP AROUND SENDING THE CHARACTER

SEND_CHARACTER:             ; SEND A CHARACTER
ifdef Microsoft
    TEST    BL,_CONNECTED_FLAGS; CHECK WHETHER THIS PORT IN CONNECTED
    JE      DONT_NET_SEND   ; CONNECTION NOT OPEN YET, DON'T SEND THE CHARACTER
    JMP     NET_SEND        ; OK, THE CONNECTION IS INITIALIZED, SEND THE CHARACTER
DONT_NET_SEND:
    TEST    BL,_OPENING_FLAGS; IF THE OPENING FLAG IS SET FOR THE PORT, CACHE THE CHARACTER IN A BUFFER
else
    TEST    BL,CONNECTED_FLAGS; CHECK WHETHER THIS PORT IN CONNECTED
    JE      DONT_NET_SEND   ; CONNECTION NOT OPEN YET, DON'T SEND THE CHARACTER
    JMP     NET_SEND        ; OK, THE CONNECTION IS INITIALIZED, SEND THE CHARACTER
DONT_NET_SEND:
    TEST    BL,OPENING_FLAGS; IF THE OPENING FLAG IS SET FOR THE PORT, CACHE THE CHARACTER IN A BUFFER
endif
    JNE     CACHE_PORT_NAME ; GO CACHE THE CHARACTER
    CMP     AL,02           ; CHECK WHETHER THIS IS THE BEGINNING OF A PORT NAME
    JE      START_PORT_NAME ; START CACHING THE PORT NAME
ifdef DEBUG
.286
PUSH    2048h
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
.8086
endif
ifdef DEBUG
PUSH    BX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
endif
ifdef DEBUG
MOV     AL,_OPENING_FLAGS
XOR     AH,AH
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
endif
    MOV     AH,80H          ; REPORT ERROR CONDITION
    JMP     SEND_FINISHED   ;

START_PORT_NAME:            ; INITIALIZE THE PORT NAME CACHING
ifdef Microsoft
    OR      _OPENING_FLAGS,BL; SET THE OPENING FLAG
else
    OR      OPENING_FLAGS,BL; SET THE OPENING FLAG
endif
ifdef DEBUG
.286
PUSH    2047h
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
.8086
endif
ifdef DEBUG
PUSH    BX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
endif
ifdef DEBUG
MOV     AL,_OPENING_FLAGS
XOR     AH,AH
PUSH    AX
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
endif
    JMP     SEND_DONE       ; INDICATE A SUCCESSFUL CHARACTER SEND, BUT DON'T REALLY

CACHE_PORT_NAME:            ; STUFF THE CHARACTER INTO A BUFFER, OR OPEN A CONNECTION
    CMP     AL,03H          ; CHECK WHETHER THIS IS THE TERMINATING CHARACTER IN A PORT NAME
    JE      NET_OPEN        ; GO, OPEN THE CONNECTION
ifdef Microsoft
    MOV     DI,OFFSET _BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    MOV     DI,OFFSET BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    ADD     DI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    MOV     CL,AL           ; SAVE THE CHARACTER TEMPORARILY
    MOV     AL,64           ; MOVE THE SIZE OF THE PORT NAME BUFFER INTO AL
    MUL     DL              ; GET THE OFFSET OF THE PORT BUFFER TO USE
    ADD     AX,DS:[DI]      ; GET THE OFFSET TO STORE THE CHARACTER AT
    INC     BYTE PTR DS:[DI]    ; INCREMENT THE BUFFER OFFSET FOR THE COMM. PORT
    CMP     BYTE PTR DS:[DI],64 ; CHECK WHETHER WE HAVE TOO LONG OF A NAME
    JE      NAME_TOO_LONG   ; JUMP FOR TOO LONG OF A NAME
ifdef Microsoft
    MOV     SI,OFFSET _PORT_BUFFER; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    MOV     SI,OFFSET PORT_BUFFER; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    ADD     SI,AX           ; GET THE CORRECT OFFSET TO STORE THIS CHARACTER AT
    MOV     AL,CL           ; RESTORE THE CHARACTER TO STORE
    MOV     [SI],AL         ; APPEND THE CHARACTER TO THE PORT NAME
ifdef DEBUG
.286
PUSH    2044h
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
.8086
endif
    JMP     SEND_DONE       ; INDICATE A GOOD TRANSFER

NAME_TOO_LONG:              ; THE PORT NAME WAS TOO LONG
    MOV     BYTE PTR DS:[DI],0  ; RESET THE LENGTH OF THE PORT NAME
    NOT     BL              ;
ifdef Microsoft
    AND     _OPENING_FLAGS,BL; RESET THE OPENING FLAG
else
    AND     OPENING_FLAGS,BL; RESET THE OPENING FLAG
endif
    MOV     AL,CL           ; RESTORE THE CHARACTER TO SEND
ifdef DEBUG
.286
PUSH    2045h
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
.8086
endif
    MOV     AH,80H          ; INDICATE ERROR CONDITION
    JMP     SHORT SEND_FINISHED   ; JUMP TO THE END OF THE ROUTINE

NET_OPEN:                   ; OPEN THE CONNECTION TO THE NETWORK
    NOT     BL              ;
ifdef Microsoft
    AND     _OPENING_FLAGS,BL; RESET THE OPENING FLAG
    MOV     DI,OFFSET _BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    AND     OPENING_FLAGS,BL; RESET THE OPENING FLAG
    MOV     DI,OFFSET BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    ADD     DI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    MOV     CL,AL           ; SAVE THE CHARACTER TEMPORARILY
    MOV     AL,64           ; MOVE THE SIZE OF THE PORT NAME BUFFER INTO AL
    MUL     DL              ; GET THE OFFSET OF THE PORT BUFFER TO USE
    ADD     AX,DS:[DI]      ; GET THE OFFSET TO STORE THE CHARACTER AT
ifdef Microsoft
    MOV     SI,OFFSET _PORT_BUFFER; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    MOV     SI,OFFSET PORT_BUFFER; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    PUSH    BX              ; SAVE THE COMM. PORT FLAGS
    ADD     SI,AX           ; GET THE CORRECT OFFSET TO STORE THIS CHARACTER AT
    MOV     AL,CL           ; RESTORE THE CHARACTER TO STORE
    MOV     BYTE PTR [SI],0 ; APPEND THE TERMINATING ZERO
    PUSH    DX              ; PUSH THE COMM. PORT WE ARE OPENING
ifdef Microsoft
    CALL    _INT14OPEN      ; OPEN THE CONNECTION
else
    CALL    INT14OPEN       ; OPEN THE CONNECTION
endif
    POP     DX              ; RECOVER THE COMM. PORT WE USED
    POP     BX              ; RECOVER THE COMM. PORT FLAGS
    CMP     AX,1            ; CHECK FOR GOOD OPENING
    JNE     BAD_NET_OPEN    ; CONNECTION DIDN'T OPEN

    NOT     BL              ;
ifdef Microsoft
    OR      _CONNECTED_FLAGS,BL; SET THE CONNECTED FLAG
    MOV     SI,OFFSET _BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    OR      CONNECTED_FLAGS,BL; SET THE CONNECTED FLAG
    MOV     SI,OFFSET BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    ADD     SI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    MOV     BYTE PTR [SI],0     ; ZERO OUT THE BUFFER OFFSET FOR THE COMM. PORT
    JMP     SHORT SEND_DONE       ; INDICATE A SUCCESSFUL CONNECTION OPENING

BAD_NET_OPEN:
ifdef DEBUG
.286
PUSH    2046h
ifdef Microsoft
CALL    _PRINT_INT
else
CALL    PRINT_INT
endif
ADD     SP,2
.8086
endif
    MOV     AX,80           ; INDICATE A BAD NETWORK OPEN
    JMP     SHORT SEND_FINISHED   ; RETURN FROM THE INTERRUPT

NET_SEND:                   ; SEND THE CHARACTER IN AL ONTO THE NET
ifdef Microsoft
    MOV     _CHAR_TO_SEND,AL ; STORE THE CHARACTER TO SEND ON THE NET
else
    MOV     CHAR_TO_SEND,AL ; STORE THE CHARACTER TO SEND ON THE NET
endif
    MOV     AX,1            ; THE NUMBER OF CHARACTERS TO DROP ONTO THE NET
    PUSH    AX
    PUSH    DS              ; PUSH THE SEGMENT ADDRESS OF THE CHARACTER TO SEND
    MOV     AX,OFFSET _CHAR_TO_SEND ; PUSH THE ADDRESS OF THE CHARACTER TO SEND
    PUSH    AX
ifdef Microsoft
    MOV     SI,OFFSET _PNUM ; GET THE OFFSET INTO THE COMM. PORT NETWORK PORT NUMBERS
else
    MOV     SI,OFFSET PNUM  ; GET THE OFFSET INTO THE COMM. PORT NETWORK PORT NUMBERS
endif
    ADD     SI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    ADD     SI,DX           ; TWICE BECAUSE THESE ARE INTEGERS, NOT BYTES
    PUSH    [SI]            ; PUSH THE NETWORK PORT NUMBER
ifdef Microsoft
    CALL    _NETWRITE       ; CLOSE THE CONNECTION
else
    CALL    NETWRITE        ; CLOSE THE CONNECTION
endif
    ADD     SP,8            ; RESTORE THE STACK FRAME
;   JMP     SEND_DONE       ; INDICATE A SUCCESSFUL DATA SEND

SEND_DONE:                  ; INDICATE A SUCCESSFUL CHARACTER SEND
    MOV     AH,060h         ; INDICATE A HAPPY CHARACTER SEND
SEND_FINISHED:
    JMP     SSKIP2          ; JUMP TO THE END OF THE ROUTINE

NOT_SEND_CHARACTER:
    CMP     AH,00           ; CHECK FOR PORT INITIALIZATION
    JNE     SSKIP           ; A COMMUNICATIONS REQUEST WHICH WE DON'T HANDLE

INIT_COM_PORT:              ; INITIALIZE THE COMM. PORT
ifdef QAK
ifdef Microsoft
    TEST    BL,_INITIALIZED_FLAGS; CHECK WHETHER THIS CONNECTION HAS BEEN INITIALIZED
    JNE     PORT_ALREADY_INIT   ; JUMP TO THE CHECK FOR CLOSING THE PORT
    OR      _INITIALIZED_FLAGS,BL; SET THE INITIALIZED FLAG FOR THIS PORT
else
    TEST    BL,INITIALIZED_FLAGS; CHECK WHETHER THIS CONNECTION HAS BEEN INITIALIZED
    JNE     PORT_ALREADY_INIT   ; JUMP TO THE CHECK FOR CLOSING THE PORT
    OR      INITIALIZED_FLAGS,BL; SET THE INITIALIZED FLAG FOR THIS PORT
endif
    JMP     SHORT RESET_INIT      ; JUMP TO RESETING THE COMM. PORT BUFFER
endif

PORT_ALREADY_INIT:          ; THE PORT HAS ALREADY BEEN INITIALIZED
ifdef Microsoft
    TEST    BL,_CONNECTED_FLAGS; CHECK WHETHER WE WERE CONNECTED
else
    TEST    BL,CONNECTED_FLAGS; CHECK WHETHER WE WERE CONNECTED
endif
    JE      RESET_INIT      ; IGNORE RE-INITIALIZATION IF NOT CONNECTED
    NOT     BL              ; INVERT AL IN PREPERATION FOR TURNING OFF THE FLAGS
ifdef Microsoft
    AND     _INITIALIZED_FLAGS,BL; RESET THE INITIALIZATION FLAG FOR THIS PORT
    AND     _CONNECTED_FLAGS,BL  ; RESET THE CONNECTED FLAG FOR THIS PORT
else
    AND     INITIALIZED_FLAGS,BL; RESET THE INITIALIZATION FLAG FOR THIS PORT
    AND     CONNECTED_FLAGS,BL  ; RESET THE CONNECTED FLAG FOR THIS PORT
endif

ifdef Microsoft
    MOV     SI,OFFSET _PNUM ; GET THE OFFSET INTO THE COMM. PORT NETWORK PORT NUMBERS
else
    MOV     SI,OFFSET PNUM  ; GET THE OFFSET INTO THE COMM. PORT NETWORK PORT NUMBERS
endif
    ADD     SI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    ADD     SI,DX           ; TWICE BECAUSE THESE ARE INTEGERS, NOT BYTES
    PUSH    DX
    PUSH    [SI]            ; PUSH THE NETWORK PORT NUMBER
ifdef Microsoft
    CALL    _NETCLOSE       ; CLOSE THE CONNECTION
else
    CALL    NETCLOSE        ; CLOSE THE CONNECTION
endif
    ADD     SP,2            ; GET RID OF THE PARAMETER WE PASSED
    POP     DX

RESET_INIT:
ifdef Microsoft
    MOV     SI,OFFSET _BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
else
    MOV     SI,OFFSET BUFFER_OFFSET; GET THE OFFSET INTO THE COMM. PORT BUFFER
endif
    ADD     SI,DX           ; INCREMENT TO THE CORRECT COMM. PORT OFFSET
    MOV     BYTE PTR [SI],0     ; ZERO OUT THE BUFFER OFFSET FOR THE COMM. PORT

INIT_FINISHED:
    MOV     AX,61B0H        ; MOVE THE RS-232 CONNECTED FLAGS INTO THE RETURN VALUE
    JMP     SSKIP2          ; JUMP TO THE END OF THE ROUTINE

SSKIP:

ifdef DEBUG
PUSH    AX                  ; DEBUGGING
ifdef Microsoft
CALL    _PRINT_INT2
else
CALL    PRINT_INT2
endif
POP     AX
endif

    XOR     BL,BL
    MOV     CS:INTENTER,BL    ; REENTER FLAG, DONE NOW
    CLI
    MOV     BX,OLDSS        ; restore the old stack
    MOV     SS,BX
    MOV     SP,OLDSP
    STI
SERIAL2:
    POP     SI
    POP        DI
    POP        DX
    POP        CX
    POP        BX
    POP        AX
    POP        ES
    POP        DS
    JMP     SHORT LEAVE_SERIAL    ; JUMP TO THE END OF THE SERIAL ROUTINES

SSKIP2:
    XOR     BL,BL
    MOV     CS:INTENTER,BL    ; REENTER FLAG, DONE NOW
    CLI
    MOV     BX,OLDSS        ; restore the old stack
    MOV     SS,BX
    MOV        SP,OLDSP
    STI
SERIAL3:
    POP     SI
    POP        DI
    POP        DX
    POP        CX
    POP        BX
    POP     ES              ; POP AX INTO ES TO PRESERVE THE RETURN VALUE IN AX
    POP        ES
    POP        DS
;
;
;   forward to any other existing routines
;
LEAVE_SERIAL:
ifdef QAK
    JMP     DWORD PTR CS:SIP
else
    IRET
endif
ifdef Microsoft
_INT14INST      ENDP
else
INT14INST       ENDP
endif
ifdef Microsoft
;_TEXT ends

else
    ENDPS
endif
    END