*DECK SUPRMSG 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRNAM 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRRTN 
PROC SUPRMSG; 
# TITLE SUPRMSG - PROCESS INCOMING SUPERVISORY MESSAGES # 
  
      BEGIN  # SUPRMSG #
  
# 
**    SUPRMSG - PROCESS INCOMING SUPERVISORY MESSAGES.
* 
*     PROCESSES ASYNCHRONOUS SUPERVISORY REQUESTS FROM A UCP. THESE 
*     REQUESTS ARE QUEUED ON THE INCOMING SUPERVISORY MESSAGE QUEUE 
*     BY RHF RESIDENT CODE. 
* 
*     PROC SUPRMSG. 
* 
*     ENTRY   -  SUPERVISORY MESSAGE QUEUE HAS AN ENTRY ON IT.
*                RHF RESIDENT CODE HAS PERFORMED SOME VALIDATION OF ALL 
*                    UCP REQUESTS.
* 
*     EXIT   -  ALL INCOMING SUPERVISORY MESSAGES PROCESSED.
* 
*     PROCESS -  FOR EACH ENTRY ON SUPERVISORY MSG QUEUE: 
*                    DEQUEUE ENTRY
*                    IF ACN IS INVALID
*                    THEN:  
*                      QUEUE REQUEST ON ERROR-LOGICAL Q - RC=LGL$BADACN.
*                      FREE QUEUE ENTRY.
*                    ELSE:  
*                      TRANSLATE SUPERVISORY MESSAGE PFC/SFC CODE 
*                        INTO AN ORDINAL
*                      IF PFC/SFC NOT RECOGNIZED
*                      THEN:  
*                      QUEUE REQUEST ON ERR LGL Q - RC= LGL$PROTCL. 
*                      FREE QUEUE ENTRY.
*                    ELSE:  
*                      IF FC/INIT/N MUST HAVE BEEN RECEIVED BEFORE
*                        THIS SUPER MSG IS VALID
*                        AND FC/INIT/N NOT YET RECEIVED 
*                      THEN:  
*                        QUEUE REQUEST ON ERR LGL Q- RC= LGL$PROTCL.
*                        FREE QUEUE ENTRY.
*                      ELSE:  
*                        DEPENDING ON WHICH CASE: 
*                          SUPERVISORY MSG IS LST/OFF/R:  
*                            TURN LIST PROCESSING OFF 
*                            INITIATE NSUP REPLY. 
*                          SUPERVISORY MSG IS LST/ON/R: 
*                            TURN LIST PROCESSING ON
*                            INITIATE NSUP REPLY. 
*                          SUPERVISORY MSG IS LST/SWH/R:  
*                            IF THE NEW ALN REQUESTED IS VALID
*                            THEN:  
*                              CHANGE TO NEW ALN
*                              INITIATE NSUP REPLY. 
*                            ELSE:  
*                              QUEUE REQUEST ON ERR LGL Q-RC=LGL$BADALN.
*                              FREE QUEUE ENTRY.
*                          SUPERVISORY MSG IS DC/CICT/R:  
*                            IF THE NEW ACT REQUESTED IS VALID
*                            THEN:  
*                              CHANGE TO NEW ACT
*                              INITIATE NSUP REPLY. 
*                            ELSE:  
*                              QUEUE REQUEST ON ERR LGL Q-RC=LGL$BADACT.
*                              FREE QUEUE ENTRY.
*                          SUPERVISORY MSG IS FC/INIT/N:  
*                            IF FC/INIT/N ALREADY RECEIVED
*                              OR FC/INIT/R NOT SENT TO APPLICATION 
*                            THEN:  
*                              QUEUE REQUEST ON ERR/LGL Q-RC=LGL$PROTCL.
*                              FREE QUEUE ENTRY.
*                          SUPERVISORY MSG IS CTRL/INFO/R:  
*                            INITIATE CTRL/INFO PROCESSING. 
*                          SUPERVISORY MSG IS CON/ACRQ/R: 
*                            INITIATE CON/ACRQ/R PROCESSING.
*                          SUPERVISORY MSG IS CON/END/R:  
*                            INITIATE CON/END/R PROCESSING. 
*                          SUPERVISORY MSG IS CON/REQ/A:  
*                           INITIATE CON/REQ/A PROCESSING.
*                          SUPERVISORY MSG IS CON/REQ/N:  
*                            INITIATE CON/REQ/N PROCESSING. 
*                          SUPERVISORY MSG IS FC/BRK/R: 
*                           INITIATE FC/BRK/R PROCESSING. 
*                          SUPERVISORY MSG IS CM/SEL/R: 
*                            INITIATE CM/SEL/R PROCESSING.
*                          SUPERVIRSOY MSG IS CM/EXIT/R:  
*                            INITIATE CM/EXIT/R PROCESSING. 
*                          SUPERVISORY MSG IS STAT/NDT/R
*                            INITIATE STAT/NDT/R PROCESSING.
*                          SUPERVISORY MSG IS STAT/NDT/N
*                            INITIATE STAT/NDT/N PROCESSING.
*                          SUPERVISORY MSG IS STAT/NDT/A
*                            INITIATE STAT/NDT/A PROCESSING.
*                RETURN.
* 
* 
****  PROC SUPRMSG - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC CMEXITR;                # PROCESS CM/EXIT/R REQUEST #
        PROC CMSELR;                 # PROCESS CM/SEL/R REQUEST # 
        PROC CONARQR;                # PROCESS CON/ACRQ/R REQUEST # 
        PROC CONENDR;                # PROCESS CON/END/R  REQUEST # 
        PROC CONREQA;                # PROCESS CON/REQ/A  REQUEST # 
        PROC CONREQN;                # PROCESS CON/REQ/N  REQUEST # 
        PROC CTRLNFO;                # PROCESS CTRL/INFO/N REQUEST #
        PROC DEQUEUE;                # REMOVE ENTRY FROM QUEUE #
        PROC FCBRKR;                 # PROCESS FC/BRK/R REQUEST # 
        PROC FCRSTR;                 # PROCESS FC/RST/R REQUEST # 
        PROC QERRLGL;                # QUEUE ON ERR/LGL QUEUE # 
        PROC FREE;                   # FREE QUEUE ENTRY # 
        PROC RTNNSUP;                # INITIATE NSUP UPDATE AND REPLY # 
        PROC STATNDT;                # PROCESS STAT/NDT/R/N/A # 
        END 
  
# 
****  PROC SUPRMSG - XREF LIST END. 
# 
  
      DEF MSGLMT     #16#;           # NUMBER OF MSG PROCESSED -1 # 
      DEF FCINITREQ  #6#;            # ALL SUPERVISORY MSGS WITH
                                       ORDINALS LESS THAN FCINITREQ 
                                       REQUIRE FC/INIT/N RECEIPT
                                       BEFORE THEY ARE LEGAL #
  
  
      ITEM MSGORD   I;               # SUPR MSG ORDINAL # 
      ITEM ORDFOUND B;               # SUPERVISORY MSG ORD FOUND FLAG # 
  
  
      ARRAY [0:MSGLMT] S(1);
        BEGIN 
        ITEM MSGCODE I= [$LSTOFF,    # LST/OFF/R SUPERVISORY MESSAGE #
                         $LSTON,     # LST/ON/R  SUPERVISORY MESSAGE #
                         $LSTSWH,    # LST/SWH/R SUPERVISORY MESSAGE #
                         $DCCICT,    # DC/CICT/R SUPERVISORY MESSAGE #
                         $CMSELR,    # CM/SEL/R SUPERVISORY MESSAGE # 
                         $CMEXITR,   # CM/EXIT/R SUPERVISORY MESSAGE #
                         $FCINITN,   # FC/INIT/N SUPERVISORY MESSAGE #
                         $CTRINF,    # CTRL/INFO/R SUPERVISORY MESSAGE #
                         $CONACR,    # CON/ACRQ/R  SUPERVISORY MESSAGE #
                         $CONEND,    # CON/END/R   SUPERVISORY MESSAGE #
                         $CONREQA,   # CON/REQ/A   SUPERVISORY MESSAGE #
                         $CONREQN,   # CON/REQ/N   SUPERVISORY MESSAGE #
                         $FCBRK,     # FC/BRK/R SUPERVISORY MESSAGE # 
                         $FCRST,     # FC/RST/R SUPERVISORY MESSAGE # 
                         $STATNDTR,  # STAT/NDT/R SUPERVISORY MESSAGE # 
                         $STATNDTN,  # STAT/NDT/N SUPERVISORY MESSAGE # 
                         $STATNDTA]; # STAT/NDT/A SUPERVISORY MESSAGE # 
        END 
  
      SWITCH SUPERMSG 
             LSTOFF,                 # LABEL FOR LST/OFF/R #
             LSTON,                  # LABEL FOR LST/ON/R # 
             LSTSWH,                 # LABEL FOR LST/SWH/R #
             DCCICT,                 # LABEL FOR DC/CICT/R #
             CMSEL,                  # LABEL FOR CM/SEL/R # 
             CMEXIT,                 # LABEL FOR CM/EXIT/R #
             FCINITN,                # LABEL FOR FC/INIT/N #
             CTRLINFO,               # LABEL FOR CTRL/INFO/R #
             CONACRQ,                # LABEL FOR CON/ACRQ/R # 
             CONEND,                 # LABEL FOR CON/END/R #
             CONREQABT,              # LABEL FOR CON/REQ/A #
             CONREQNORM,             # LABEL FOR CON/REQ/N #
             FCBRK,                  # LABEL FOR FC/BRK/R  #
             FCRST,                  # LABEL FOR FC/RST/R # 
             STATNDTR,               # LABEL FOR STAT/NDT/R # 
             STATNDTN,               # LABEL FOR STAT/NDT/N # 
             STATNDTA,               # LABEL FOR STAT/NDT/A # 
             ;
  
CONTROL EJECT;
  
      ASLONGAS SUPERMSGQ NE 0 
      DO
        BEGIN  # PROCESS INCOMING SUPERVISORY MESSAGES #
        DEQUEUE(LOC(SUPERMSGQ));
        P<APL$HEADER> = QU$SUPAPAD; 
        P<CONNECTION> = P<APL$HEADER>+ APL$LENGTH 
                        + (QU$SUPACN - APL$MINACN) * CON$LENGTH;
  
        IF  QU$PFCSFC NE $CTRINF
            AND QU$PFCSFC NE $CONACR
            AND QU$PFCSFC NE $STATNDTR
            AND QU$PFCSFC NE $STATNDTN
            AND QU$PFCSFC NE $STATNDTA
            AND ((QU$SUPACN LT APL$MINACN 
                    OR QU$SUPACN GT APL$MAXACN) 
                  OR (CON$PATHID EQ 0)) 
        THEN
          BEGIN  # INVALID ACN #
          QERRLGL(LGL$BADACN,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
          FREE; 
          END 
  
        ELSE
          BEGIN  # ACN VALID #
  
# 
*     MAP PFC/SFC INTO AN ORDINAL FOR USE BY THE SIMULATED CASE STMT. 
# 
  
          ORDFOUND = FALSE; 
  
          SLOWFOR MSGORD = 0 STEP 1 UNTIL MSGLMT
          DO
            BEGIN  # FIND PFC/SFC ORDINAL # 
  
            IF MSGCODE[MSGORD] EQ QU$PFCSFC 
            THEN
              BEGIN  # FOUND MATCHING PFC/SFC # 
              ORDFOUND = TRUE;
              EXIT FINDORD; 
              END 
  
            END FINDORD:  
  
          IF NOT ORDFOUND 
          THEN
            BEGIN  # SUPERVISORY MESSAGE UNKNOWN/INVALID #
            QERRLGL(LGL$PROTCL,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
            FREE; 
            END 
  
          ELSE
            BEGIN  # SUPERVISORY MSG RECOGNIZED # 
  
            IF MSGORD LT FCINITREQ
              AND NOT CON$INIT$N
            THEN
              BEGIN  # FC/INIT/N REQUIRED, BUT NOT RECEIVED # 
              QERRLGL(LGL$PROTCL,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
              FREE; 
              END 
  
            ELSE
              BEGIN  # FC/INIT/N RECEIVED IF REQUIRED # 
  
# 
*     USE SIMULATED CASE STMT TO PROCESS SUPERVISORY MESSAGE. 
# 
  
              GOTO SUPERMSG[MSGORD];
  
LSTOFF:                              # LST/OFF/R REQUEST #
              CON$LST$ON = FALSE; 
              RTNNSUP;
              GOTO ENDCASE; 
  
LSTON:                               # LST/ON/R REQUEST # 
              CON$LST$ON = TRUE;
              RTNNSUP;
              GOTO ENDCASE; 
  
LSTSWH:                              # LST/SWH/R REQUEST #
              IF QU$NUALN LT APL$NUMCON 
              THEN
                BEGIN  # NEW ALN VALID #
                CON$ALN = QU$NUALN; 
                RTNNSUP;
                END 
  
              ELSE
                BEGIN  # INVALID ALN #
                QERRLGL(LGL$BADALN,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
                FREE; 
                END 
  
              GOTO ENDCASE; 
  
DCCICT:                              # DC/CICT/R REQUEST #
              IF QU$NUACT LT 1
                OR QU$NUACT GT 4
              THEN
                BEGIN  # INVALID ACT REQUESTED #
                QERRLGL(LGL$BADACT,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
                FREE; 
                END 
  
              ELSE
                BEGIN  # ACT VALID #
                CON$ACT = QU$NUACT; 
                RTNNSUP;
                END 
  
              GOTO ENDCASE; 
  
CMSEL:  
              CMSELR; 
              GOTO ENDCASE; 
  
CMEXIT: 
              CMEXITR;
              GOTO ENDCASE; 
  
  
FCINITN:                             # FC/INIT/N REQUEST #
              IF CON$INIT$N 
                OR NOT CON$REQ$N
              THEN
                BEGIN  # CONNECTION IN INCORRECT STATE #
                QERRLGL(LGL$PROTCL,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
                FREE; 
                END 
  
              ELSE
                BEGIN  # FC/INIT/N ACCEPTABLE # 
                CON$LST$ON = TRUE;
                CON$INIT$N = TRUE;
                RTNNSUP;
                END 
  
              GOTO ENDCASE; 
  
CTRLINFO:                            # CTRL/INFO/R REQUEST #
              CTRLNFO;
              GOTO ENDCASE; 
  
CONACRQ:                             # CON/ACRQ/R REQUEST # 
              CONARQR;
              GOTO ENDCASE; 
  
CONEND:                              # CON/END/R REQUEST #
              CONENDR;
              GOTO ENDCASE; 
  
CONREQABT:                           # CON/REQ/A REQUEST #
              CONREQA;
              GOTO ENDCASE; 
  
CONREQNORM:                          # CON/REQ/N REQUEST #
              CONREQN;
              GOTO ENDCASE; 
  
FCBRK:                               # FC/BRK/R REQUEST # 
              FCBRKR; 
              GOTO ENDCASE; 
  
FCRST:                               # FC/RST/R REQUEST # 
              FCRSTR; 
              GOTO ENDCASE; 
  
STATNDTR:                            # STAT/NDT/R REQUEST # 
STATNDTN:                            # STAT/NDT/N REQUEST # 
STATNDTA:                            # STAT/NDT/A REQUEST # 
              STATNDT;
              GOTO ENDCASE; 
  
ENDCASE:  
  
# 
*     END OF SIMULATED CASE STMT. 
# 
  
              END  # FC/INIT/N RECEIVED IF REQUIRED # 
  
            END  # SUPERVISORY MSG RECOGNIZED # 
  
          END  # ACN VALID #
  
        END  # PROCESS INCOMING SUPERVISORY MSG # 
  
      RETURN; 
      END  # SUPPMSG #
  
      TERM
  
