*DECK RECNAD
USETEXT COMCBEG 
USETEXT COMMCOM 
USETEXT COMMGET 
USETEXT COMRNET 
    PROC RECNAD;
#TITLE  RECNAD - RECOVER NAD (DUMP NAD LOAD CONTROLWARE) #
      BEGIN  # RECNAD # 
  
# 
**    RECNAD - RECOVER NAD (DUMP AND LOAD CONTROLWARE)
* 
*     ENTRY      DLCHKNDT = TRUE (CHECK-NDT FLAG).
*                <NDT$HEADER> = NDTBUF
*                NDTBIAS = NDTBUF + 1 - NDT$FWA 
* 
*     EXIT       DLCHKNDT  = TRUE, IF NDT SEARCH REQUIRED 
*                          = FALSE, IF NO IMMEDIATE SEARCH REQUIRED.
*                DLDELAY   = CURRENT TIME, IF DELAYED NDT SEARCH. 
*                          = 0, IF NO NDT SEARCH REQUIRED.
*                NAD$STATE = 00 (LOAD COMPLETE) 
*                          = 01 (LOAD IN PROGRESS)
*                          = 03 (DUMP IN PROGRESS)
*                          = 77B (NAD DISABLED) 
* 
*     PROCESS    SET DLCHKNDT = FALSE 
*                SET DLDELAY = 0
*                WHILE NOT (DLCHKNDT OR END-OF-NADS)
*                  CALL CHKNST TO FIND NAD NEEDING DUMP/LOAD
*                IF DLCHKNDT (NAD FOUND, NO DELAY)
*                  CALL NADDUMP OR NADLOAD
*                  IF DUMP OR LOAD INCOMPLETE 
*                    DECREMENT RETRY COUNT
*                    IF RETRIES EXHAUSTED 
*                      SET NAD STATE = DISABLED 
*                      SEND DAYFILE MESSAGE "AUTO DUMP/LOAD FAILED" 
*                    ELSE 
*                      SET NAD DELAY TIME 
*                  IF DUMP OR LOAD COMPLETE OR NAD DISABLED 
*                    CALL PUTNDTM TO SEND STATE TO RHF
*                    SEND DAYFILE MESSAGE 
*                ELSE (NO NAD DUMP/LOAD)
*                  IF NAD-ERROR-LOG TIME
*                    CALL NADLOG TO EXTRACT NAD ERROR LOG 
*                    CALL PUTNDTM TO SEND TIME TO RHF 
# 
  
# 
****  PROC RECNAD - XREF LIST BEGIN 
# 
      XREF
        BEGIN 
        PROC CALLCVL;              # CALL CVL (NAD ACCESS) #
        PROC CALLNLD;              # CALL NLD # 
        PROC CALLSYS;              # CALL SYSTEM VIA RA+1 # 
        PROC CHKNST;               # CHECK NAD STATE #
        PROC DBGNAME;              # DEBUG - DAYFILE MESSAGE #
        PROC ERRNLD;               # PROCESS NLD ERROR #
        FUNC HEXCHF     C(10);     # VALUE TO HEX DISPLAY # 
        PROC NADDUMP;              # DUMP NAD MEMORY #
        PROC NADLOAD;              # LOAD NAD CONTROLWARE # 
        PROC NADLOG;               # EXTRACT NAD ERROR LOG #
        FUNC OCTCHF     C(10);     # VALUE TO OCTAL DISPLAY # 
        PROC PUTNDTM;              # SEND NDT WORD TO RHF # 
        END 
# 
****  PROC RECNAD - XREF LIST END 
# 
  
      ITEM DONE       B;           # SCRATCH #
      ITEM I          I;           # SCRATCH #
CONTROL EJECT;
  
      $BEGIN
      DBGNAME ("RECNAD");          # DEBUG MESSAGE #
      $END
  
      DLCHKNDT = FALSE;            # CLEAR CHECK-NDT FLAG # 
      ELGETLOG = FALSE;            # CLEAR NAD-ERROR-LOG FLAG # 
      ELDELAY = 0;                 # SET NAD-ERROR-LOG DELAY #
      DLDELAY = ELIDLEDLY;         # SET NAD-DUMP/LOAD DELAY #
      P<NAD$ENTRY> = NDTLNT - NAD$LENGTH;  # SET LOCAL NAD ADDR # 
      DLRMTNAD = FALSE;            # CHECK LOCAL NADS # 
  
      SLOWFOR I = 1 STEP 1 WHILE (I LE NDT$NUMLN  # SEARCH NDT #
                                  AND NOT DLCHKNDT) 
      DO
        BEGIN 
        P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
        P<NST$ENTRY> = LOC(NAD$NSTWD0);  # NAD STATE ENTRY #
        CHKNST;                    # CHECK LOCAL NAD STATE #
        END 
  
      IF NOT DLCHKNDT              # IF NO LOCAL DUMP/LOAD REQUEST #
      THEN
        BEGIN 
        P<NET$HEADER> = NDT$FWA + NDTBIAS;  # 1ST PID ENTRY # 
        DLRMTNAD = TRUE;           # CHECK REMOTE NADS #
        DONE = FALSE; 
        ASLONGAS NOT DONE 
        DO
          BEGIN 
          IF NET$PID NE HOSTPID 
          THEN
            BEGIN 
            P<PTH$ENTRY> = NET$PATHAD + NDTBIAS - PTH$LENGTH; 
            SLOWFOR I = 1 STEP 1 WHILE (I LE NET$NMPATH)
                                        AND NOT DLCHKNDT
            DO
              BEGIN 
              P<PTH$ENTRY> = P<PTH$ENTRY> + PTH$LENGTH;  # NEXT PATH #
              P<NAD$ENTRY> = NDTLNT + (PTH$NADORD * NAD$LENGTH);
              P<NST$ENTRY> = LOC(NAD$NSTWD0);  # NAD STATUS ENTRY # 
  
              IF NST$STATE EQ NS$AVAIL  # IF LOCAL NAD AVAILABLE #
              THEN
                BEGIN 
                P<RMT$ENTRY> = PTH$RMTNAD + NDTBIAS;  # REMOTE NAD #
                P<NST$ENTRY> = LOC(RMT$NSTWD0);  # NAD STATUS ENTRY # 
                CHKNST;            # CHECK REMOTE NAD STATE # 
                END 
  
              END 
  
            END 
  
          IF NOT DLCHKNDT          # IF NADS OK SO FAR #
             AND NET$NXTPID NE 0   # AND NOT DONE # 
          THEN
            BEGIN 
            P<NET$HEADER> = NET$NXTPID + NDTBIAS;  # NEXT PID ENTRY # 
            END 
  
          ELSE
            BEGIN 
            DONE = TRUE;
            END 
  
          END 
  
        END 
  
      IF DLCHKNDT                  # IF DUMP/LOAD REQUEST FOUND # 
      THEN
        BEGIN 
        IF DLRMTNAD                # IF REMOTE NAD #
        THEN
          BEGIN 
          RECNADMSGB = " (REMOTE) ";  # REMOTE NAD #
          RECNADMSGC = HEXCHF (RMT$NAD,2);  # NAD ADDR #
          NDNAM$5 = "R";           # REMOTE # 
          END 
  
        ELSE
          BEGIN 
          RECNADMSGB = "ON CHANNEL";  # LOCAL NAD # 
          RECNADMSGC = OCTCHF (NAD$CHAN,2);  # NAD CHANNEL #
          NDNAM$5 = "L";           # LOCAL #
          END 
  
        NDNAM$67 = RECNADMSGC;     # NAD ADDR OR CHANNEL #
  
        IF DLSTATE EQ NS$LDCW      # IF LOAD-IN-PROGRESS #
        THEN
          BEGIN 
          NADLOAD;                 # LOAD NAD C/W # 
          END 
  
        ELSE
          BEGIN 
          IF DLSTATE EQ NS$DMPCW   # IF DUMP-IN-PROGRESS #
          THEN
            BEGIN 
            NADDUMP;               # DUMP NAD MEMORY #
            END 
          END 
  
        IF DLSTATE EQ NST$STATE    # IF DUMP/LOAD INCOMPLETE #
        THEN
          BEGIN 
          IF DLRETRY GT DLRTYLIM   # IF RETRY LIMIT # 
          THEN
            BEGIN 
            I = 0;
            IF NOT DLRMTNAD        # IF LOCAL NAD # 
            THEN
              BEGIN 
              IF NOT DLCVLR        # IF NAD NOT RESERVED BY CVL # 
              THEN
                BEGIN 
                CALLCVL(I);        # OBTAIN CVL ACCESS TO NAD # 
                END 
  
              IF I EQ 0            # IF ACCESS OBTAINED # 
              THEN
                BEGIN 
                NLD$FC = NLD$FCESTE;
                PB$SUBFCN = 1;     # TAKE NAD OUT OF SERVICE #
                PB$FIRST= O"100"; 
                PB$IN = PB$FIRST; 
                PB$OUT = PB$FIRST;
                PB$LIMIT = PB$FIRST + O"101"; 
                CALLNLD (DLRMTNAD); 
                I = PB$RC;
                IF I NE 0          # IF NLD ERROR # 
                THEN
                  BEGIN 
                  ERRNLD;          # PROCESS NLD ERROR #
                  END 
  
                END 
  
              END 
  
            IF I EQ 0              # REMOTE NAD OR LOCAL NAD DISABLED # 
            THEN
              BEGIN 
              RECNADMSGD = "DISABLED";
              MSG$BUFADR = LOC(RECNADMSG);
              MSG$STATUS = 0; 
              CALLSYS (MSGCALL);   # DAYFILE MESSAGE #
              DLSTATE = NS$DISAB;  # DISABLE NAD #
              END 
  
            END 
  
          ELSE
            BEGIN 
            NST$DLRTY = DLRETRY + 1;  # SAVE RETRY COUNT #
            NST$DLDLY = DLDELAY;   # SAVE DELAY # 
            NST$TIMCHK = CURRTIM;  # SAVE CURRENT TIME #
            END 
          END 
  
        IF DLCVLR                  # IF NAD RESERVED BY CVL # 
        THEN
          BEGIN 
          CALLCVL(I);              # RELEASE NAD #
          END 
  
        IF DLSTATE NE NST$STATE    # IF NOT IN PROGRESS # 
        THEN
          BEGIN 
  
          IF DLSTATE EQ (NST$STATE - 1)  # IF DUMP/LOAD DONE #
          THEN
            BEGIN 
            DLRETRY = 0;           # RESET RETRY COUNT #
            END 
  
          NST$STATE = DLSTATE;     # RESET NAD STATE #
          NST$TIMCHK = CURRTIM;    # RESET CHECK TIME # 
          NST$TIMCHG = CURRTIM;    # RESET CHANGE TIME #
          NST$DLDLY = 0;           # RESET DELAY #
          NST$DLRTY = DLRETRY;     # RESET RETRY COUNT #
          P<BUF1> = P<NST$ENTRY>; 
          PUTNDTM (1);             # SEND NEW NDT WORD TO RHF # 
          END 
  
        DLPARAM0 = 0;              # CLEAR COUNTERS # 
        DLPARAM1 = 0;              # CLEAR DELAY #
        END 
  
      ELSE                         # IF NO DUMP/LOAD REQUEST #
        BEGIN 
        IF ELGETLOG                # IF TIME TO GET NAD ERROR LOG # 
        THEN
          BEGIN 
          P<NAD$ENTRY> = ELNADADR; # LOCAL NAD ENTRY ADDR # 
          NADLOG (ELRMTNAD);       # EXTRACT NAD ERROR LOG #
          NST$TIMCHK = CURRTIM;    # RESET TIME # 
          P<BUF1> = P<NST$ENTRY>; 
          PUTNDTM (1);             # SEND NEW NDT WORD TO RHF # 
          ELPARAM0 = 0;            # CLEAR POINTERS # 
          ELPARAM1 = 0;            # CLEAR DELAY #
          DLCHKNDT = TRUE;         # SET CHECK-NDT FLAG # 
          END 
  
        END 
  
      END  # RECNAD # 
  
    TERM
