*DECK NS$SMP
USETEXT COM$NS
USETEXT ERR$NS
USETEXT DEF$NS
USETEXT SMB$NS
USETEXT SMD$NS
 
PROC NS$SMP;                 # SUPERVISORY MESSAGE PROCESSOR           #
 
# TITLE NS$SMP - SM PROCESSOR.                                         #
 
      BEGIN    # NS$SMP # 
# 
**    NS$SMP - SM PROCESSOR.
* 
*     J.C. LEE    1981
* 
*     THIS ROUTINE PROCESSES SMS. 
* 
*     PROC NS$SMP 
* 
*     ENTRY:  
*       NONE. 
* 
*     EXIT: 
*       NONE. 
* 
*     METHOD: 
*       CHECK NSUP WORD.
*       FOR SM AVAILABLE: 
*         IF SM-REISSUED-BIT SET: 
*           SKIP NETGET CALL. 
*         ELSE
*           NETGET SM INTO SM BUFFER
*         SWITCH TO APPROPRIATE PARAGRAPH BASED ON ABT. 
*         IF ABT EQ "HOST-SM", PROCESS HOST SM. 
*         IF ABT EQ "NETWORK-SM", PROCESS NETWORK SM. 
*         ELSE, FLAG ERRCODE. 
*         IF ERRCODE NQ 0, CALL ERROR PROCESSOR.
*         IF MC IN NS CONTROL CARD IS NONZERO, AND THE
*         NUMBER OF TRACE MESSAGES ACCUMULATED ON THE 
*         DEBUG LOG FILE REACHES MC:  
*           CALL NETREL TO RELEASE CURRENT TRACE FILE.
* 
# 
 
      $BEGIN
      XREF
        BEGIN 
        PROC NS$DBG;         # TRACE PROCEDURE CALL                    #
        END 
      $END
 
      XREF
        BEGIN 
        PROC NDLOVLD;        # OVERLAY LOADER                          #
        PROC NETGET;         # AIP NETGET PROCEDURE                    #
        PROC NETREL;         # AIP NETREL PROCEDURE                    #
        FUNC NS$FEC U;       # FORMAT ERROR CODE                       #
        PROC NS$NSM;         # NETWORK SUPERVISORY MESSAGE PROCESSOR   #
        END 
 
      ITEM ABT        U;     # APPLICATION BLOCK TYPE                  #
      ITEM ERRCODE    U;     # ERROR CODE                              #
      ITEM I          I;     # LOOP VARIABLE                           #
      ITEM IDLE       B;     # SMP STATE                               #
      ARRAY HSM$OVLY [0:0] S(1);
        BEGIN                # HOST INTERFACE OVERLAY NAME AND LEVEL   #
        ITEM HO$NAM     C(00,00,07) = ["HSMOVLY"];
        ITEM HO$LV1     U(00,42,09) = [2];
        ITEM HO$LV2     U(00,51,09) = [0];
        END 
      ARRAY ERR$OVLY [0:0] S(1);
        BEGIN                # ERROR PROCESSOR OVERLAY NAME AND LEVEL  #
        ITEM EO$NAM     C(00,00,07) = ["ERROVLY"];
        ITEM EO$LV1     U(00,42,09) = [5];
        ITEM EO$LV2     U(00,51,09) = [0];
        END 
      ARRAY MKD$OVLY [0:0] S(1);
        BEGIN                # K-DISPLAY MANAGER OVERLAY NAME AND LEVEL#
        ITEM MO$NAM     C(00,00,07) = ["MKDOVLY"];
        ITEM MO$LV1     U(00,42,09) = [3];
        ITEM MO$LV2     U(00,51,09) = [0];
        END 
 
 
      SWITCH ABTCASE         # SWITCH FOR APPLICATION BLOCK TYPES      #
        SMP00,               # NULL BLOCK, ERROR                       #
        SMP00,               # BLK BLOCK, ERROR                        #
        SMP00,               # MSG BLOCK, ERROR                        #
        SMP01,               # SM BLOCK ORIGINATED FROM NAM            #
        SMP02,               # SM BLOCK ORIGINATED FROM PIP/NPU        #
        ; 
CONTROL EJECT;
 
      $BEGIN
      NS$DBG("SMP");         # TRACE CALL                              #
      $END
 
      IDLE = FALSE; 
      SM$REISSUE = FALSE; 
 
      FOR I = 0 WHILE NOT IDLE
      DO # CHECK IF THERE IS A SUPERVISORY MESSAGE TO PROCESS          #
        BEGIN 
 
        IF NOT SM$REISSUE 
        THEN                 # NO SUPERVISORY MESSAGE GOT REISSUED     #
          BEGIN 
 
          IF NSU$S[0] 
          THEN               # SUPERVISORY MESSAGE IS AVAILABLE        #
            NETGET(0,ABH$WORD,SMB$BUFFER,MAX$SMSIZE); # GET SM         #
 
          ELSE               # SUPERVISORY MESSAGE NOT AVAILABLE       #
            BEGIN            # EXIT FOR LOOP                           #
            IDLE = TRUE;
            TEST I; 
            END 
          END 
 
        ELSE                 # SUPERVISORY MESSAGE IS REISSUED         #
          SM$REISSUE = FALSE;          # CLEAR SM REISSUE FLAG         #
 
        ERRCODE = 0;
        ABT = ABHABT[0];               # APPLICATION BLOCK TYPE        #
 
        GOTO ABTCASE[ABT];             # CASE ON ABT                   #
 
SMP00:                       # SM BLOCK TYPE ERROR                     #
        ERRCODE = NS$FEC(EC"ERR$SM",SMEC"HSM$ABH"); 
        GOTO SMP03; 
 
SMP01:                       # SM FROM NAM                             #
        NDLOVLD(HSM$OVLY,ERRCODE);
        GOTO SMP03; 
 
SMP02:                       # SM FROM NETWORK                         #
        NS$NSM(ERRCODE);
 
SMP03:  
        IF ERRCODE NQ 0 
        THEN                 # CALL ERROR PROCESSOR                    #
          NDLOVLD(ERR$OVLY,ERRCODE);
 
        IF DCW$F$SKD[0] 
        THEN                 # K-DISPLAY DATA TO SEND                  #
          NDLOVLD(MKD$OVLY); # CALL K-DISPLAY MANAGER                  #
 
        $BEGIN
# 
        IF A NON-ZERO MC COUNT IS SPECIFIED AND THE NUMBER OF TRACE 
        MESSAGES ACCUMULATED ON THE DEBUG LOG FILE ZZZZZDN REACHES MC,
        CALL AIP PROCEDURE -NETREL- TO RELEASE, SAVE AND PROCESS THE
        CURRENT INFORMATION IN THE DEBUG LOG FILE.
# 
        IF MC NQ 0           # PERIODIC RELEASE OF ZZZZZDN SPECIFIED   #
          AND NSU$MC[0] GQ MC # SPECIFIED MESSAGE COUNT REACHED        #
        THEN                 # RELEASE CURRENT INFORMATION ON ZZZZZDN  #
          NETREL(NRF1$LFN,MAX$TMSGSZ,0);
        $END
 
        END                  # END FOR LOOP                            #
 
      RETURN; 
      END   # NS$SMP #
      TERM