*DECK REQCON
USETEXT COMCBEG 
USETEXT COMRCON 
USETEXT COMRFLS 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRSTA 
PROC REQCON(RETURNCODE);
# TITLE REQCON - MAKE CONNECTION REQUEST. # 
  
      BEGIN  # REQCON # 
  
# 
**    REQCON - MAKE CONNECTION REQUEST. 
* 
*     REPEATEDLY MAKES CONNECTION REQUEST THROUGH A GIVEN LOCAL NAD TO
*     A GIVEN REMOTE NAD. 
* 
*     PROC REQCON(RETURNCODE).
* 
*     ENTRY    - QU$ADDRESS IS BASED ARRAY CONTAINING CON/ACRQ/R. 
*                NET$HEADER IS BASED ARRAY FOR PID TO WHICH REQUEST 
*                  WILL BE MADE.
*                LIDINDX IS ITEM DEFINING LID TO WHICH REQUEST WILL 
*                  BE MADE. 
*                PTH$ENTRY IS BASED ARRAY DEFINING PATH TO PID TO 
*                  WHICH REQUEST WILL BE MADE.
*                NAD$ENTRY IS BASED ARRAY FOR LOCAL NAD THROUGH WHICH 
*                  REQUEST WILL BE MADE.
*                RMT$ENTRY IS BASED ARRAY FOR REMOTE NAD TO WHICH 
*                  REQUEST IS DIRECTED. 
* 
*     EXIT     - RETURNCODE = 0 - REQUEST ACCEPTED BY LOCAL NAD.
*                           = 1 - NAD OR PATH OFF - NADOFF REQUEST
*                                   QUEUED
*                           = 2 - LOCAL NAD REJECT - RESOURCE LIMIT 
*                                   REACHED - PATH REJECT BIT SET.
* 
*     PROCESS  - BUILD CONNECTION MESSAGE 
*                FOR EACH OF 10 ATTEMPTS WHILE THE LOCAL NAD REJECTS
*                              THE CONNECTION REQUEST:  
*                  GET FREE QUEUE ENTRY 
*                  BUILD CONNECT REQUEST QUEUE ENTRY
*                  BUILD COMPLETION STATUS WORD 
*                  INITIATE NAD CONNECTION REQUEST
*                  WAIT FOR NID COMPLETION. 
*                DEPENDING ON WHICH CASE: 
*                  *LOCAL NAD ACCEPTS REQUEST.
*                    DO NOTHING.
*                  *LOCAL NAD OFF:  
*                    SET PATH REJECT BIT
*                    QUEUE NAD OFF REQUEST. 
*                  *LOCAL NAD REJECT: 
*                    SET PATH REJECT BIT..
*                  *BAD PATH TCU
*                    SET PATH DISABLED. 
*                    QUEUE FLASHING MESSAGE TO OPERATOR.
*                    SEND FLASHING MESSAGE TO B-DISPLAY.
*                RETURN.
* 
* 
# 
  
      ITEM RETURNCODE I;             # REQCON RETURN CODE(NDR RTN CODE)#
  
# 
****  PROC REQCON - XREF LIST BEGIN.
# 
      XREF
        BEGIN 
        PROC BLDRMSG;                # BUILD CONNECT REQUEST MESSAGE #
        PROC GETFREE;                # GET FREE QUEUE ENTRY # 
        PROC NADREQ;                 # INITIATE NAD REQUEST # 
        PROC RHFMSG;                 # SEND DAYFILE TO RHF CTL PT. #
        FUNC BINTODD C(10);          # CONVERT BINARY TO DISPLAY CODE # 
        PROC QUEUE;                  # ADD ENTRY TO QUEUE # 
      PROC UPDNWS;                   # UPDATE NETWORKD STATUS # 
        PROC WAIT;                   # WAIT FOR COMPLETION #
        END 
  
# 
****  PROC REQCON - XREF LIST END.
# 
  
  
      DEF RC$NADREJ  #3#;            # NAD REJECT RETURN CODE # 
  
  
      ITEM COMPSTAT I;               # COMPLETION STATUS WORD # 
      ITEM LOOPCOUNT I;              # LOOP CONTROL INDEX # 
      ITEM QUADDR    I;              # TEMP CELL FOR QU$ADDRESS POINTER#
  
    CONTROL  IFEQ OS$NOS; 
      ITEM NADTYPE   B = FALSE;      # ORDINAL TYPE  #
      ITEM PATHORD   I;              # PATH ORDINAL  #
      ITEM UPDSTAT   I = NW$PTHSDIS; # UPDATE NETWORK STATUS  # 
    CONTROL  ENDIF; 
  
  
      SWITCH NDRRTN 
             OK,                     # LABEL FOR LOCAL NAD ACCEPT # 
             NADOFF,                 # LABEL FOR LOCAL NAD OFF #
             ESTUNUSABL,             # EST DOES NOT ALLOW OPERATION # 
             NADREJ,                 # LABEL FOR LOCAL NAD REJECT # 
             BADPATH,                # LABEL FOR BAD PATH TCU # 
             ;
  
CONTROL EJECT;
  
      BLDRMSG;                       # BUILD CONNECT MESSAGE #
      QUADDR = P<QU$ADDRESS>; 
      RETURNCODE = RC$NADREJ;        # LOCAL NAD REJECT # 
  
      SLOWFOR LOOPCOUNT = 1 STEP 1
        WHILE RETURNCODE EQ RC$NADREJ AND LOOPCOUNT LE 10 
      DO
        BEGIN  # MAKE CONNECTION REQUEST #
        GETFREE;
        QU$TYPE = QT$REQCON;
        QU$CMPST= LOC(COMPSTAT);
        QU$MSGADR = LOC(CONREQUEST);
        COMPSTAT  = 0;
        NADREQ(PTH$NADORD); 
        WAIT(LOC(COMPSTAT));
        P<CST$ADDR> = LOC(COMPSTAT);
        RETURNCODE  = CST$RTNCOD; 
        END 
  
# 
*     PROCESS NDR RETURN CODE THRU SIMULATED CASE STMT. 
# 
      GOTO NDRRTN[RETURNCODE];
  
OK:   GOTO ENDCASE;                  # CONNECT REQUEST ACCEPTED # 
  
NADOFF: 
      PTH$REJ = TRUE; 
      GOTO ENDCASE; 
  
ESTUNUSABL:                          # EST DOES NOT ALLOW OPERATION # 
      PTH$REJ = TRUE; 
      GOTO ENDCASE; 
  
NADREJ: 
      PTH$REJ = TRUE; 
      GOTO ENDCASE; 
  
BADPATH:  
      PTH$ENABLE = FALSE; 
      MSGPATHID = BINTODD(PTH$ORD,3); 
      GETFREE;
      QU$TYPE = QT$UCPDATA; 
      QU$DATA = MSG$PTHOFF; 
      QUEUE(LOC(FLSHMSGQ)); 
      RHFMSG(LOC(MSGPATHOFF),43); 
    CONTROL  IFEQ OS$NOS; 
      P<QU$ADDRESS> = QUADDR; 
      P<NET$HEADER> = PTH$PIDADR; 
      PATHORD = PTH$ORD;
      UPDNWS(UPDSTAT,PATHORD,NADTYPE);
    CONTROL ENDIF;
      GOTO ENDCASE; 
  
ENDCASE:  
  
# 
*     END OF SIMULATED CASE STATEMENT.
# 
  
      P<QU$ADDRESS> = QUADDR; 
      RETURN; 
      END  # REQCON # 
  
      TERM
