*DECK NADOFF
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRFLS 
USETEXT COMRMEM 
USETEXT COMRNET 
USETEXT COMRQUE 
PROC NADOFF;
# TITLE NADOFF - PROCESS NAD OFF REQUESTS.  # 
  
      BEGIN  # NADOFF # 
  
# 
**    NADOFF - PROCESS NAD OFF REQUESTS.
* 
*     PROCESS ALL ENTRIES ON THE NAD OFF QUEUE. 
* 
*     PROC NADOFF.
* 
*     ENTRY   - THERE IS AT LEAST ONE ENTRY ON THE NAD OFF QUEUE. 
* 
*     EXIT    - ALL NAD OFF ENTRIES ARE PROCESSED.
* 
*     PROCESS - FOR EACH ENTRY ON THE NAD OFF QUEUE:  
*                 DEQUEUE ENTRY.
*                 IF PATH ERROR 
*                 THEN: 
*                  DISABLE PATH ENTRY.
*                  QUEUE PATH OFF MESSAGE ON FLASHING MESSAGE QUEUE.
*                   IF CONNECT NOT YET BROKEN 
*                   THEN: 
*                     INITIATE PATH DISCONNECT PROCESSING.
*                 ELSE: 
*                   FOR EACH APPLICATION TABLE: 
*                     FOR EACH CONNECTION WITH PATHID NE 0
*                       AND MATCHING NAD ORDINAL
*                       AND CONNECTION NOT YET BROKEN:  
*                       INITIATE PATH DISCONNECT PROCESSING.
*                     ISSUE NADOFF MESSAGE. 
*                     IF NAD STATE = AVAILABLE: 
*                       SET NAD STATE = REQUEST NAD DUMP. 
*                       CALL MHFMSG TO UPDATE MHF-S NDT (NAD-STATE).
*                 RELEASE ENTRY.
*               RETURN. 
* 
* 
****  PROC NADOFF - XREF LIST BEGIN.
# 
  
      XREF
        BEGIN 
        FUNC BINTODD C(10);          # CONVERT BINARY TO DISPLAY CODE  #
        PROC BRAKACN;                # PATH DISCONNECT PROCESSING # 
        PROC DEQUEUE;                # REMOVE ENTRY FROM QUEUE #
        ITEM FAPLADR  I;             # FIRST APPLICATION TABLE ADDRESS #
        PROC FREE;                   # RELEASE QUEUE ENTRY #
        PROC GETFREE;                # OBTAIN FREE QUEUE ENTRY  # 
        ITEM LAPLADR  I;             # LAST APPLICATION TABLE ADDRESS # 
        PROC MHFMSG;                 # UPDATE MHF-S NDT # 
        ITEM NADTBL  I;              # START OF LOCAL NAD TABLE # 
        PROC QUEUE;                  # ADD ENTRY TO QUEUE # 
        PROC RHFMSG;                 # SEND DAYFILE TO RHF CTL PT. #
        PROC UPDNWS;                 # UPDATE PID NETWORK STATUS  # 
        END 
  
# 
****  PROC NADOFF - XREF LIST END.
# 
  
  
      ITEM CONINDX    I;             # INDUCTION VARIABLE FOR CON LOOP #
      ITEM TEMPQ      I;             # TEMPORARY QUEUE POINTER #
      ITEM NADORD     I;             # SAVE NAD ORDINAL # 
      ITEM QUEADR     I;             # SAVE QUEUE ADDRESS # 
  
    CONTROL IFEQ OS$NOS;
      ITEM NADTYPE    B;             # NAD ORDINAL TYPE  #
      ITEM PATHORD    I;             # PATH ORDINAL  #
      ITEM UPDSTAT    I = NW$PTHSDIS;  # UPDATE NETWORK STATUS  # 
    CONTROL ENDIF;
CONTROL EJECT;
  
      TEMPQ = NADOFFQ;
      NADOFFQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        QUEADR = P<QU$ADDRESS>; 
        IF QU$PTHERR
        THEN
          BEGIN 
          P<APL$HEADER> = QU$APPL;
          P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                          (QU$ACN - APL$MINACN) * CON$LENGTH; 
          P<PTH$ENTRY> = CON$PATHAD;
          PTH$ENABLE = FALSE; 
          MSGPATHID = BINTODD(PTH$ORD,3); 
          GETFREE;
          QU$TYPE = QT$UCPDATA; 
          QU$DATA = MSG$PTHOFF; 
          QUEUE(LOC(FLSHMSGQ)); 
          RHFMSG(LOC(MSGPATHOFF),43); 
          P<QU$ADDRESS> = QUEADR; 
  
        CONTROL IFEQ OS$NOS;
          P<NET$HEADER> = PTH$PIDADR; 
          PATHORD = PTH$ORD;
          NADTYPE = FALSE;
          UPDNWS(UPDSTAT,PATHORD,NADTYPE);
        CONTROL ENDIF;
  
          IF NOT CON$BROKEN 
          THEN
            BEGIN 
            BRAKACN;
            END 
  
          END 
  
        ELSE
          BEGIN 
          NADORD = QU$NADORD; 
          IF QU$DAYF
          THEN
          BEGIN 
          P<APL$HEADER> = FAPLADR;
          ASLONGAS P<APL$HEADER> LE LAPLADR 
          DO
            BEGIN  # LOOP THRU APL HEADERS #
            P<CONNECTION> = P<APL$HEADER> + APL$LENGTH; 
            SLOWFOR CONINDX = 1 STEP 1 UNTIL APL$NUMCON 
            DO
              BEGIN  # LOOP THRU CONNECTIONS #
              IF CON$PATHID NE 0
                AND CON$NADORD EQ NADORD
                AND NOT CON$BROKEN
              THEN
                BEGIN 
                BRAKACN;
                END 
  
              P<CONNECTION> = P<CONNECTION> + CON$LENGTH; 
              END 
  
            P<APL$HEADER> = P<APL$HEADER> + APL$LENGTH +
                            (APL$NUMCON * CON$LENGTH);
            END 
  
  
          P<NAD$ENTRY> = NADTBL + (NADORD * NAD$LENGTH);
          MSGNADEST = (B<0,3>NAD$ESTORD * O"10000") 
                     +(B<3,3>NAD$ESTORD * O"100") 
                     +(B<6,3>NAD$ESTORD) + O"333333"; 
          RHFMSG(LOC(MSGNADOFF),40);
  
          P<NST$ENTRY> = LOC(NAD$NSTWD0);  # NAD STATUS ENTRY # 
          IF NST$STATE EQ NS$AVAIL
          THEN
            BEGIN 
            NST$STATE = NS$DMPREQ;  # REQUEST NAD DUMP #
            IF NST$DMPCTR LT 7
            THEN
              BEGIN 
              NST$DMPCTR = NST$DMPCTR + 1;  # INCREMENT DUMP COUNT #
              END 
  
            MHFMSG (LOC(NST$STATE));  # UPDATE MHF-S NDT (NST) #
            END 
  
          END 
  
        P<QU$ADDRESS> = QUEADR; 
        FREE; 
        CONTROL IFEQ OS$NOS;
          NADTYPE = TRUE; 
          UPDNWS(UPDSTAT,NADORD,NADTYPE); 
        CONTROL ENDIF;
  
          END 
  
        END 
  
      END  # NADOFF # 
  
      TERM
