*DECK NS$RPV
USETEXT COM$NS
USETEXT NAT$NS
USETEXT NPT$NS
USETEXT PFC$NS
USETEXT SMB$NS
USETEXT SMD$NS
  
PROC NS$RPV;                           # REPRIEVE PROCESSOR            #
  
# TITLE NS$RPV - REPRIEVE PROCESSOR.                                   #
  
      BEGIN    # NS$RPV # 
# 
**    NS$RPV - REPRIEVE PROCESSOR.
* 
*     J.C. LEE    1981
* 
*     THIS ROUTINE DOES REPRIEVE PROCESSING.
* 
*     PROC NS$RPV 
* 
*     ENTRY:  
*       NONE. 
* 
*     EXIT: 
*       NONE. 
* 
*     METHOD: 
*       SET DUMP RECORD NUMBER FOR REPRIEVE DUMP. 
*       DUMP FL/EXC PACKAGE 
*       IF NS INITIALIZATION NOT COMPLETE:  
*         DO NOT RESTART NS.
*       ELSE
*         CLEAN UP NATS.
*         IF LOADING REMOTE NPU:  
*         SEND NPU/IN/N 
*       IF NS ALREADY NETTED-ON:  
*         FLUSH AIP TRACE FILE. 
* 
# 
  
      $BEGIN
      XREF
        BEGIN 
        PROC NS$DBG;                   # TRACE PROCEDURE CALL          #
        END 
      $END
  
      XREF
        BEGIN 
        PROC NETDMB;         # BINARY DUMP FL/EXCHANGE PACKAGE         #
        PROC NETPUT;                   # AIP NETPUT                    #
        PROC NETSETF;                  # GET ZZZZZDN FILE FWA          #
        PROC NS$FBH;                   # FORMAT ABH                    #
        PROC RSJCR;          # RESET JOB CONTROL REGISTER              #
        PROC TSBINFO;                  # LOCATE TSB                    #
        PROC WRITER;                   # FLUSH TRACE FILE ZZZZZDN      #
        END 
  
      ITEM I          I;               # LOOP VARIABLE                 #
      ITEM NATFWA     U;               # NAT TSB FWA                   #
      ITEM NATSIZE    U;               # NAT SIZE                      #
      ITEM NEXTNATTSB U;               # NEXT NAT IN NAT LIST          #
      ITEM ZZDNFWA    I;               # FWA OF AIP TRACE FILE ZZZZZDN #
  
      BASED ARRAY ZZDNFET [0:0] P(1); 
        BEGIN 
        ITEM ZZDNWORDS  U(00,00,60);
        END 
  
CONTROL EJECT;
  
      $BEGIN
      NS$DBG("RPV");                   # TRACE CALL                    #
      $END
  
      ZDMBID$DN[0] = 7; # SET DUMP RECORD NUMBER FOR REPRIEVE DUMP     #
      NETDMB(ZDMBID[0],0); # DUMP FL/EXC PACKAGE                       #
  
      IF NOT NSINITDONE 
      THEN                   # INITIALIZATION NOT COMPLETE             #
        BEGIN                # DO NOT RESTART NS                       #
        RSJCR(1,1,0);        # SET CONROL REG 1 TO 0                   #
        END 
  
      ELSE
  
      BEGIN 
  
      NEXTNATTSB = NPT$NLHEAD[0];      # HEAD PTR OF NAT LIST          #
  
      FOR I = 0 WHILE NEXTNATTSB NQ 0 
      DO                               # MORE NAT TO CLEAN UP          #
        BEGIN 
        TSBINFO(NATSIZE,NATFWA,NEXTNATTSB);  # LOCATE NAT              #
        P<NAT> = NATFWA;               # FWA OF NAT                    #
        NEXTNATTSB = NAT$NLFP[0];      # NEXT NAT IN LIST              #
  
        IF NAT$F$RMTL[0]
        THEN                           # LOADING REMOTE NPU            #
          BEGIN                        # SEND NPU/IN/N                 #
          NS$FBH(LNPUIN,TRUE);         # FORMAT ABH                    #
          PFCSFC[0] = NPUINN;          # SET PFC/SFC                   #
          NPUPO[0] = NAT$PN[0];        # SET PORT NUMBER               #
          NPUSP[0] = NAT$SPN[0];       # SET SUBPORT NUMBER            #
          NPULT[0] = LOADTYPE"LT$REMOT"; # SET LOAD TYPE               #
          NETPUT(ABH$WORD,SMB$BUFFER); # SEND NPU/IN/N                 #
          END 
        END                            # END FOR LOOP                  #
      END 
  
  
      IF NSNETON
      THEN                   # NETON WAS SUCCESSFUL                    #
        BEGIN 
        NETSETF(FALSE,ZZDNFWA); # GET TRACE FILE FWA                   #
        P<ZZDNFET> = ZZDNFWA; 
        IF P<ZZDNFET> NQ 0
        THEN # ZZZZZDN FILE EXISTS     #
          WRITER(ZZDNFET); # FLUSH AIP TRACE FILE                      #
        END 
  
      RETURN; 
      END   # NS$RPV #
      TERM