*DECK FREEACN 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRRHH 
USETEXT COMRRTN 
PROC FREEACN((FUNCTION)); 
# TITLE FREEACN - FREE ACN ENTRY. # 
  
      BEGIN  # FREEACN #
  
# 
**    FREEACN - FREE ACN ENTRY. 
* 
*     THIS PROCEDURE RELEASES A CONNECTION TABLE ENTRY AND RELEASES 
*     THE ASSOCIATED NAD PATH.
* 
*     PROC FREEACN(FUNCTION). 
* 
*     ENTRY   -  CONNECTION IS BASED ARRAY FOR CONNECTION ENTRY TO
*                  BE RELEASED. 
*                APL$HEADER IS BASED ARRAY FOR APPLICATION HEADER.
*                FUNCTION:  
*                  QT$FLUSH - FLUSH NAD PATH. 
*                  QT$DISCON -DISCONNECT NAD PATH.
* 
*     EXIT    -  CONNECTION ENTRY IS RELEASED.
* 
*     PROCESS -  IF CONNECTION ENTRY IS IN USE
*                THEN:  
*                  SET CONNECTION BROKEN AND CONNECTION SHUTDOWN BITS 
*                  CLEAR FC/INIT/N RECEIVED BIT 
*                  GET FREE QUEUE ENTRY 
*                  SET UP DISCONNECT OR FLUSH QUEUE ENTRY 
*                  ISSUE DISCONNECT OR FLUSH NAD REQUEST
*                  WAIT FOR COMPLETION OF NAD REQUEST 
*                  SET UP DISCONNECT MESSAGE
*                  SEND DISCONNECT MESSAGE TO UCP 
*                  ZERO CONNECTION PATH ID
*                  DECREMENT LOCAL AND REMOTE CONNECTION COUNTS 
*                  WAIT FOR ACN QUIET 
*                  IF LOCAL NAD COUNT IS ZERO 
*                  THEN:  
*                    CALL RHH TO CLEAR RHF ACTIVE IN EST. 
*                  PROCESS ALL CONNECTION-RELATED QUEUE ENTRIES.
*                  ZERO ALL CONNECTION FLAGS. 
*                RETURN.
* 
* 
# 
  
      ITEM FUNCTION I;               # INPUT PARM - "DISCON$"OR"FLUSH$"#
  
# 
*     PROC FREEACN - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        FUNC BINTODD C(10);          # CONVERT TO DECIMAL DISPLAY CODE #
        FUNC BINTOHD C(10);          # CONVERT TO HEX DISPLAY CODE #
        FUNC BINTOOD C(10);          # CONVERT TO OCTAL DISPLAY CODE #
        PROC CALLSYS;                # MAKE RA + 1 REQUEST #
        PROC GETFREE;                # OBTAIN FREE QUEUE ENTRY #
        PROC MOPQACN;                # PROCESS ALL ACN-RELATED Q ENTRYS#
        ITEM NADTBL  I;              # NAD TABLE ADDRESS #
        PROC NADREQ;                 # ISSUE NAD REQUEST #
        PROC RHFMSGJ;                # ISSUE RHF DAYFILE MESSAGE #
        PROC WAIT;                   # WAIT FOR REQUEST COMPLETION #
        PROC WAITACN;                # WAIT FOR ACN QUIET # 
        END 
  
# 
*     PROC FREEACN - XREF LIST END. 
# 
  
  
      ITEM ACN I;                    # TEMP CELL-ACN FOR THIS CONNECTN# 
      ITEM COMPSTAT I;               # COMPLETION STATUS WORD # 
      ITEM JOBNAME  C(7);            # NAME OF JOB DISCONNECTING #
  
      ARRAY MSG$DISC1 [0:0] S(6); 
        BEGIN 
        ITEM MSGDS      C(00,00,52) = 
          ["ACNXXXX DISCONNECT. BLOCKS SENT=XXXXX RECEIVED=XXXXX"]; 
        ITEM MSGDSACN   C(00,18,04);
        ITEM MSGDSBLKST C(03,12,05);
        ITEM MSGDSBLKRC C(04,42,05);
        END 
  
      ARRAY MSG$DISC2 [0:0] S(5); 
        BEGIN 
        ITEM MSGDS2     C(00,00,47) = 
          ["ACKS SENT=XXXXX RECEIVED=XXXXX PATH ID=XX CH=XX"];
        ITEM MSGDSACKST C(01,00,05);
        ITEM MSGDSACKRC C(02,30,05);
        ITEM MSGDSPTHID C(03,54,02);
        ITEM MSGDSCH    C(04,30,02);
        END 
  
CONTROL EJECT;
  
      IF CON$PATHID NE 0
      THEN
        BEGIN  # RELEASE ACN #
        CON$BROKEN = TRUE;
        CON$SHUT   = TRUE;
        CON$INIT$N = FALSE; 
        CON$INPUT  = FALSE; 
        GETFREE;
        QU$PATHID  = CON$PATHID;
        COMPSTAT   = 0; 
        QU$CMPST   = LOC(COMPSTAT); 
        QU$APPL    = P<APL$HEADER>; 
        ACN        = (P<CONNECTION> - P<APL$HEADER> - APL$LENGTH )
                       / CON$LENGTH  +  APL$MINACN; 
        QU$ACN     = ACN; 
        QU$TYPE    = FUNCTION;
  
        NADREQ(CON$NADORD); 
        WAIT(LOC(COMPSTAT));
  
        IF APL$NETON
        THEN
          BEGIN  # USE APPLICATION JOB NAME # 
          JOBNAME = APL$JOBNAM; 
          END 
  
        ELSE
          BEGIN  # USE *REMOTE FOR JOB NAME # 
          JOBNAME = "*REMOTE";
          END 
  
        MSGDSACN   = BINTODD(ACN,4);
        MSGDSBLKST = BINTODD(CON$BLKWRT,5); 
        MSGDSBLKRC = BINTODD(CON$BLKRD,5);
        MSGDSACKST = BINTODD(CON$ACKWRT,5); 
        MSGDSACKRC = BINTODD(CON$ACKRD,5);
        MSGDSPTHID = BINTOHD(CON$PATHID,2); 
        P<NAD$ENTRY> = NADTBL + CON$NADORD * NAD$LENGTH;
        IF CON$CM NE BINARY 
        THEN
          BEGIN 
          NAD$CMPA = NAD$CMPA + 1;
          CON$CM = BINARY;
          END 
  
        MSGDSCH    = BINTOOD(NAD$CHAN,2); 
  
        RHFMSGJ(JOBNAME,LOC(MSG$DISC1),52); 
        RHFMSGJ(JOBNAME,LOC(MSG$DISC2),47); 
        CON$PATHID = 0; 
  
        P<PTH$ENTRY> = CON$PATHAD;
        P<RMT$ENTRY> = PTH$RMTNAD;
        NAD$CCOUNT   = NAD$CCOUNT - 1;
        IF NAD$CCOUNT EQ 0
        THEN
          BEGIN 
          RHH$PARAM = 0;
          RHH$ESTORD = NAD$ESTORD;
          RHHPARMAD = LOC(RHH$PARAM); 
          RHHFUNCTN = RH$CLEAR; 
          CALLSYS(RHHCALL); 
          WAIT(LOC(RHH$PARAM)); 
          END 
  
        RMT$CCOUNT   = RMT$CCOUNT - 1;
        ACTIVECONS = ACTIVECONS - 1;
        MOPQACN;
        WAITACN;
        MOPQACN;
        CON$FLAGS    = 0; 
        END 
  
      RETURN; 
      END  # FREEACN #
  
      TERM
