*DECK CONREQN 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRNAM 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRRTN 
PROC CONREQN; 
# TITLE CONREQN - PROCESS CON/REQ/N SUPERVISORY MSG. #
  
      BEGIN  # CONREQN #
  
# 
**    CONREQN - PROCESS CON/REQ/N SUPERVISORY MESSAGE,
* 
*     PROCESSES ACCEPT CONNECT ASYNCHRONOUS SUPERVISORY MESSAGE 
*     (CON/REQ/N).
* 
*     PROC CONREQN. 
* 
*     ENTRY   -  APL$HEADER IS BASED ARRAY FOR APPLICATION TABLE HEADER.
*                QU$ADDRESS IS BASED ARRAY FOR CON/REQ/N SUPR MSG.
*                CONNECTION IS BASED ARRAY FOR ACN. 
* 
*     EXIT    -  CON/REQ/N SUPERVISORY MESSAGE IS PROCESSED.
* 
*     PROCESS -  IF CON/REQ/R NOT SENT
*                   OR CON/REQ/N ALREADY SENT 
*                THEN:  
*                  PUT REQUEST ON ERR/LGL QUEUE.
*                  FREE QUEUE ENTRY.
*                ELSE:  
*                  REMOVE CONNECTION REQUEST ENTRY FROM DELAY Q 
*                  BUILD ACCEPT CONNECT DAYFILE MESSAGE USING CONNECT 
*                    REQUEST ENTRY
*                  FREE CONNECTION REQUEST
*                  SEND ACCEPT CONNECT DAYFILE MSG TO UCP 
*                  GET FREE QUEUE ENTRY 
*                  IF CONNECTION BROKEN 
*                  THEN:  
*                    INITIATE CONCBR. 
*                  ELSE:  
*                  BUILD FC/INIT/R SUPERVISORY MESSAGE
*                  MOVE FC/INIT/R MESSAGE TO QUEUE ENTRY
*                  QUEUE MESSAGE FOR APPLICATION
*                  UPDATE NSUP AND COMPLETE UCP CON/REQ/N REQUEST 
*                RETURN 
* 
* 
****  PROC CONREQN - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        FUNC BINTODD C(10); 
        FUNC BINTOHD C(10);          # CONVERT TO HEX DISPLAY CODE #
        FUNC BINTOOD C(10);          # CONVERT TO OCTAL DISPLAY CODE #
        PROC CONCBR;
        PROC DEQUEUE; 
        PROC FREE;
        PROC GETFREE; 
        ITEM NADTBL  I;              # NAD TABLE ADDRESS #
        PROC QERRLGL;                # QUEUE ON ERR/LGL QUEUE # 
        PROC RHFMSGJ;                # ISSUE RHF DAYFILE MESSAGE #
        PROC RTNNSUP; 
        PROC SUPRPLY; 
        END 
  
# 
****  PROC CONREQN - XREF LIST END. 
# 
  
  
      ITEM ACN    I;                 # ACN ASSOCIATED WITH CON/REQ/N #
      ITEM QUEADR I;                 # TEMP CELL - CON/REQ/N ENTRY #
  
  
      ARRAY MSG$CNACPT [0:0] S(6);
        BEGIN 
        ITEM MSGCA      C(00,00,55) = 
          ["CONNECTED TO XXXXXXX LID=XXX PID=XXX ACNXXXX PTHXX CHXX"];
        ITEM MSGCAAPPL  C(01,18,07);
        ITEM MSGCALID   C(02,30,03);
        ITEM MSGCAPID   C(03,18,03);
        ITEM MSGCAACN   C(04,00,04);
        ITEM MSGCAPTHID C(04,48,02);
        ITEM MSGCACH    C(05,18,02);
        END 
  
      ARRAY [0:0] S(1); 
        BEGIN  # PRE FORMATTED FC/INIT/R MSG #
        ITEM $SUPWD1    U(00,00,60) = [0];
        ITEM $SUPPFCSFC U(00,00,16) = [$FCINIT];
        ITEM $SUPACN    U(00,24,12);
        END 
  
CONTROL EJECT;
  
      ACN = QU$SUPACN;
  
      IF CON$REQ$N
        OR NOT CON$REQ$R
        OR CON$PATHID EQ 0
      THEN
        BEGIN  # PROTOCOL ERROR # 
        QERRLGL(LGL$PROTCL,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
        FREE; 
        END 
  
      ELSE
        BEGIN  # CONNECTION IN PROPER STATE # 
  
        IF QU$NUALN GT APL$NUMCON 
        THEN
          BEGIN  # INVALID ALN VALUE #
          QERRLGL(LGL$BADALN,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
          FREE; 
          END 
  
        ELSE
          BEGIN  # ALN IS VALID # 
  
          IF   QU$CONACT LT 1 
            OR QU$CONACT GT 4 
          THEN
            BEGIN  # INVALID ACT VALUE #
            QERRLGL(LGL$BADACT,0,QU$UCPA,QU$BLKHDR,QU$SUPWD1,0,0);
            FREE; 
            END 
  
          ELSE
            BEGIN  # CON/REQ/N ACCEPTABLE # 
            CON$ACT = QU$CONACT;
            CON$ALN = QU$NUALN; 
            CON$REQ$N = TRUE; 
  
# 
*     BUILD ACCEPT CONNECT MESSAGE. 
# 
  
            MSGCAPTHID = BINTOHD(CON$PATHID,2); 
            P<NAD$ENTRY> = NADTBL + CON$NADORD * NAD$LENGTH;
            MSGCACH    = BINTOOD(NAD$CHAN,2); 
            MSGCAACN  = BINTODD(ACN,4); 
            P<PTH$ENTRY> = CON$PATHAD;
            P<NET$HEADER> = PTH$PIDADR; 
            MSGCAPID  = NET$PID;
            QUEADR    = P<QU$ADDRESS>;
            DEQUEUE(LOC(CON$DELAYQ)); 
  
            IF QU$TYPE EQ QT$CONWAIT
            THEN
              BEGIN  # CONNECTION REMOTELY INITIATED #
              MSGCAAPPL = QU$ANAME2;
              MSGCALID   = QU$LIDREQ; 
              END 
  
            ELSE
              BEGIN  # CONNECTION LOCALLY INITIATED # 
              MSGCAAPPL = QU$APLNAME; 
  
              IF QU$LIDI EQ 0 
              THEN
                BEGIN  # NO LID IN REQUEST #
                MSGCALID = "   "; 
                END 
  
              ELSE
                BEGIN  # LID SPECIFIED #
                MSGCALID = QU$LID;
                END 
  
              END 
  
            FREE;                    # FREE LOCAL OR REMOTE CON REQUEST#
            RHFMSGJ(APL$JOBID,LOC(MSG$CNACPT),55);
  
  
            IF CON$BROKEN 
            THEN
              BEGIN 
              CONCBR; 
              END 
            ELSE
              BEGIN 
            GETFREE;                 # BUILD SUPR MSG FC/INIT/R # 
            $SUPTLC = 1;             # NUMBER OF WORDS IN FC/INIT MSG # 
            QU$BLKHDR = $SUPHDR;
            $SUPACN = ACN;
            QU$SUPWD1 = $SUPWD1;
            SUPRPLY;                 # SEND FC/INIT-R # 
              END 
  
            P<QU$ADDRESS> = QUEADR;  # SEND NSUP REPLY #
            RTNNSUP;
            END  # CON/REQ/N ACCEPTABLE # 
  
          END  # ALN IS VALID # 
  
        END  # CONNECTION IN PROPER STATE # 
  
      RETURN; 
      END  # CONREQN #
  
      TERM
  
