*DECK STATEVT 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMREVN 
USETEXT COMRQUE 
USETEXT COMRRTN 
PROC STATEVT; 
# TITLE STATEVT - PROCESS STATUS EVENTS. #
  
      BEGIN  # STATEVT #
  
# 
**    STATEVT - PROCESS STATUS EVENTS.
* 
*     PROCESS ALL ENTRIES ON THE STATUS EVENT QUEUE.
* 
*     PROC STATEVT. 
* 
*     ENTRY   -  THERE IS AT LEAST ONE ENTRY ON THE STATUS EVENT QUEUE. 
* 
*     EXIT    -  ALL STATUS EVENT ENTRIES ARE PROCESSED.
* 
*     PROCESS -  FOR EACH ENTRY ON THE STATUS EVENT QUEUE:  
*                  DEQUEUE ENTRY
*                  SETUP EVENT, APPLICATION AND CONNECTION BASED ARRAYS 
*                  SAVE EVENT TYPE AND RHF REJECT CODE
*                  RELEASE STATUS EVENT QUEUE ENTRY 
*                  IF STATUS EVENT WAS PATH ABORTED 
*                  THEN:  
*                    INITIATE PATH DISCONNECT PROCESSING. 
*                  ELSE:  
*                    IF ACN IS NOT IN PROCESS OF CONNECTING 
*                    THEN:  
*                      IGNORE STATUS EVENT. 
*                    ELSE:  
*                      DEQUEUE CONNECTION REQUEST ON DELAY Q. 
*                      IF REMOTE CONNECTION REQUEST 
*                      THEN:  
*                        IGNORE STATUS EVENT ENTRY. 
*                      ELSE :  "LOCAL CONNECTION REQUEST "
*                        DEPENDING ON WHICH CASE: 
*                          STATUS EVENT IS CONNECTED: 
*                            INITIATE CON/REQ/R TRANSMITTAL TO APPL.
*                          STATUS EVENT IS NETWORK REJECT:  
*                            INITIATE CON/ACRQ/A TRANSMITTAL TO APPL. 
*                            MAKE ACN AVAILABLE AGAIN.
*                          STATUS EVENT IS REMOTE RHF REJECT: 
*                            INITIATE CON/ACRQ/A TRANSMITTAL WITH 
*                                    CORRECT RETRUN CODE
*                            MAKE ACN AVAILABLE AGAIN.
*                RETURN 
* 
* 
****  PROC STATEVT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC ACRQA;                  # INITIATE CON/ACRQ/A SUPR. REPLY# 
        PROC BRAKACN;                # PATH DISCONNECT PROCESSING # 
        PROC CONREQR;                # INITIATE CON/REQ/R SUPR REPLY #
        PROC DEQUEUE;                # REMOVE ENTRY FROM QUEUE #
        PROC FREE;                   # RELEASE QUEUE ENTRY #
        PROC FREEACN;                # MAKE ACN AVAILABLE AGAIN # 
        PROC QUEUE;                  # ADD ENTRY TO QUEUE # 
        END 
  
# 
****  PROC STATEVT - XREF LIST END. 
# 
  
  
      DEF MAP$LENGTH #11#;           # LARGEST REMOTE REJECT CODE # 
  
      ITEM EVENTYPE   I;             # STATUS EVENT TYPE #
      ITEM EVNTREJECT I;             # REMOTE RHF REJECT CODE # 
      ITEM REJCODE    I;           # REJECT CODE FOR ACRQA #
      ITEM TEMPQ      I;             # TEMPORARY POINTER TO STATUS Q #
  
      ARRAY MAPTOLOCAL [1:MAP$LENGTH] S(1); 
        BEGIN  # MAPS REMOTE REJECT CODE TO LOCAL CODE (ACRQ$XXXXX) # 
        ITEM MAPLOCAL  I(00,00,60) = [ACRQ$ANAME, 
                                      ACRQ$RSHUT, 
                                      ACRQ$ILIDD, 
                                      ACRQ$ILIDD, 
                                      ACRQ$PSWRD, 
                                      ACRQ$ANAME, 
                                      ACRQ$ANAME, 
                                      ACRQ$ILIDD, 
                                      ACRQ$PSWRD, 
                                      ACRQ$ANAME, 
                                      ACRQ$ANAME];
        END 
  
      SWITCH EVENT
             CONNECTED,              # STATUS EVENT - CONNECTED # 
             ,                       # STATUS EVENT - DISCONNECTED #
             NETREJECT,              # STATUS EVENT - NETWORK REJECT# 
             RHFREJECT,              # STATUS EVENT -REMOTE RHF REJECT# 
             ;
  
CONTROL EJECT;
  
      TEMPQ = STATUSQ;
      STATUSQ = 0;
      ASLONGAS TEMPQ   NE 0 
      DO
        BEGIN  # PROCESS STATUS EVENT # 
        DEQUEUE(LOC(TEMPQ));
        P<EVNT$ENTRY> = P<QU$ADDRESS> + 1;
        P<APL$HEADER> = EVNT$APPL;
        P<CONNECTION> = P<APL$HEADER> + APL$LENGTH
                        + (EVNT$ACN - APL$MINACN) * CON$LENGTH; 
        EVENTYPE = EVNT$TYPE; 
        EVNTREJECT=EVNT$REJCD;
        FREE; 
  
        IF EVENTYPE EQ EVTP$DISC
          AND P<APL$HEADER> NE 0
        THEN
          BEGIN  # PATH DISCONNECT RECEIVED # 
          BRAKACN;
          END 
  
        ELSE
          BEGIN  # PROCESS REST OF EVENTS # 
  
# 
*     REMAINDER OF EVENTS ARE ALL ASSOCIATED WITH CONNECTION PROCESSING.
*     THEREFORE, PRELIMINARY CHECKS VERIFY THAT CONNECTION IS IN A
*     STATE OF INITIALIZATION. IF NOT, THE EVENT ENTRY IS IGNORED.
# 
  
          IF CON$PATHID NE 0 AND NOT CON$REQ$R
          THEN
            BEGIN  # CONNECTION IN PROPER STATE # 
            DEQUEUE(LOC(CON$DELAYQ)); 
  
            IF QU$TYPE NE QT$UCPMSGI
            THEN
              BEGIN  # REMOTE CONNECTION REQUEST ON DELAY Q - ERROR # 
              QUEUE(LOC(CON$DELAYQ));  # IGNORE EVENT ENTRY # 
              END 
  
            ELSE
              BEGIN  # CON/ACRQ/R ON DELAY Q #
  
# 
*     SIMULATED CASE STATEMENT FOR PROCESSING EVENT.
# 
  
              GOTO EVENT[EVENTYPE-EVTP$CON];
  
CONNECTED:                           # STATUS HAS GONE TO CONEECTED # 
              CONREQR;               # ISSUE CON/REQ/R #
              GOTO ENDEVENT;
  
NETREJECT:                           # NETWORK REJECT # 
              REJCODE = ACRQ$NORES;  # "NOT RESPONDING" # 
              GOTO SENDACRQA; 
  
RHFREJECT:                           # REMOTE RHF REJECT #
              REJCODE = EVNTREJECT * 16;  # SET ACTUAL REJECT # 
              IF (EVNTREJECT LE MAP$LENGTH) 
                AND (EVNTREJECT GT 0) 
              THEN
                BEGIN  # ADD MAP CODE TO ACTUAL REJECT CODE # 
                REJCODE = REJCODE + MAPLOCAL[EVNTREJECT]; 
                END 
  
#             GOTO SENDACRQA #
  
SENDACRQA:                         # SEND REJECT TO APPLICATION # 
              ACRQA(REJCODE); 
              FREEACN(QT$FLUSH);
              GOTO ENDEVENT;
  
ENDEVENT: 
  
# 
*     END OF EVENT SIMULATED CASE STMT. 
# 
  
              END  # CON/ACRQ/R ON DELAY Q #
  
            END  # CONNECTION IN PROPER STATE # 
  
          END  # PROCESS REST OF EVENTS # 
  
        END  # PROCESS STATUS EVENT # 
  
      RETURN; 
      END  # STATEVT #
  
      TERM
