*DECK,GETDATA 
USETEXT IP$COM
USETEXT MISC$ 
USETEXT TCH$COM 
USETEXT TSB$COM 
USETEXT ABH$COM 
USETEXT ACN$COM 
USETEXT GLOBALI 
USETEXT SMDEF 
USETEXT SM$COM
USETEXT TCB$COM 
USETEXT UCB$COM 
      PROC GETDATA; 
      BEGIN # GETDATA # 
*IF DEF,IMS 
 #
*1DC  GETDATA 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        GETDATA             SEYUNG OH           NOV 19,1979
* 
*     2. FUNCTIONAL DESCRIPTION.
*        ACQUIRES DATA AND SUPERVISORY MESSAGES FROM THE NETWORK. 
* 
*     3. METHOD USED. 
*        GETDATA ATTEMPTS TO GET DATA FROM THE NETWORK AS LONG AS THERE 
*        IS BUFFER SPACE AVAILABLE AND DATA TO RECEIVE. 
* 
*        DATA AND SM IS CHAINED TO ITS CONNECTIONS CONTROL BLOCK. 
* 
* 
*        IF AN ILLEGAL ACN IS DETECTED THEN THE BUFFER IS RETURNED AND A
*        DAYFILE MESSAGE IS ISSUED. 
* 
*     4. ENTRY PARAMETERS.
*        NON. 
* 
*     5. EXIT PARAMETERS. NONE. 
* 
*     6. COMDECKS CALLED. 
* 
*        RBF$COM
*        TSBMDEFS 
*        TSBMBASE 
*        TCB$COM
*        UCB$COM
*        ABH$COM
* 
*     7. ROUTINES CALLED. 
* 
*        SMP
*        MOVEOK 
*        CHGSIZE
*        NETGETL
*        SETACN 
*        GETBUF 
*        MESSAGE
*        RETTSB 
* 
*     8. DAYFILE MESSAGES.
* 
*         "DATA RECEIVED ON NON-OPERATIONAL ACN"
* 
 #
*ENDIF
  
      XDEF PROC FREEBUFFER;            # FREE ALL BUFFER SPACE         #
      XREF PROC MOVEOK;      # MAKE BUFFER MOVEABLE                    #
      XREF PROC CHGSIZE;     # CHANGE SIZE OF BUFFER                   #
      XREF PROC NETGETL;     # GET DATA ON LIST FROM NETWORK           #
      XREF PROC SETUPACN;    # SET UP CONTROL BLOCKS                # 
      XREF FUNC GETBUF U;    # GET BUFFER SPACE                        #
      XREF PROC MESSAGE;     # ISSUES DAYFILE MESSAGE                  #
      XREF PROC RETTSB;      # FREE BUFFER SPACE                       #
      XREF PROC NETPUT; 
      XDEF PROC LINKBLOCK;   # CHAIN BUFFER SPACE                      #
      XDEF ITEM SMCOUNT I = 0;                   # NUMBER OF SM RECVED #
      ITEM I I;              # INDEX VARIABLE                          #
      ITEM BLOCK U;          # BLOCK ORDINAL                           #
      ITEM TYPE U;           # BLOCK TYPE VARIABLE                     #
      ITEM FINISHED B;
      XREF PROC NETGET; 
      ARRAY NONOPACN S(4);
        ITEM NONOPMACMMSG C (0,0,38) =
            ["DATA MESSAGE DISCARDED "],
             NONOPACNEND U (3,48,12) = [O"0000"]; 
      CONTROL EJECT;
      DEF #DC,H,C2#        DC      #X"C2"#; 
      DEF #CICT,H,00#      CICT    #X"00"#; 
      DEF #DCCICT,H,C200#  DCCICT  #X"C200"#; 
# 
# 
      ITEM XPT$ACN U; 
      ITEM XPT$TLC I; 
      CONTROL EJECT;
      PROC LINKBLOCK (CHAIN$BLOCK,BLOCKORD);
      BEGIN # LINKBLOCK # 
      ITEM CHAIN$BLOCK U;    # CHIAN TO BE ADDED TO                    #
      ITEM BLOCKORD U;       # ORDINAL OF BLOCK TO BE CHAINED          #
      BASED ARRAY PTR S(1); 
        BEGIN 
        ITEM LASTPTR U (0,36,12), 
             POINTER U (0,48,12); 
        END 
# 
      PLACES INCOMING BLOCK POINTED TO BY BLOCKORD ON TO THE CHAIN OF 
      INPUTTED BLOCKS POINTED TO BY CHAIN$BLOCK 
  
      CHAINING OF INPUTTED BLOCKS USES ABH$NEXT FIELD TO POINT TO THE 
      NEXT BLOCK ON THE CHAIN 
# 
      P<ABH> = ADDRESS [BLOCKORD];
      ABH$ABN = 0;
# 
      IS THE CHAIN EMPTY
# 
      P<PTR> = CHAIN$BLOCK; 
      IF POINTER EQ 0 
      THEN
        BEGIN # EMPTY CHAIN # 
        POINTER = BLOCKORD; 
        LASTPTR = BLOCKORD; 
        END   # EMPTY CHAIN # 
      ELSE
        BEGIN # NON-EMPTY CHAIN # 
        P<ABH> = ADDRESS[LASTPTR];
        ABH$NEXT = BLOCKORD;
        LASTPTR = BLOCKORD; 
        END   # NON-EMPTY CHAIN # 
      RETURN; 
      END   # LINKBLOCK # 
      CONTROL EJECT;
#                                                                      #
      PROC FREEBUFFER (POINTER);
      BEGIN                                      # FREE BUFFERS        #
      ITEM POINTER U; 
      ITEM NXTBUF U;
      BASED ARRAY PT S(1);
        BEGIN 
        ITEM LSTPT U (0,36,12), 
             FSTPT U (0,48,12); 
        END 
      P<PT> = POINTER;
      FOR I=I WHILE FSTPT NQ ZERO DO
        BEGIN 
        P<ABH> = ADDRESS [FSTPT]; 
        NXTBUF = ABH$NEXT;
        RETTSB (FSTPT); 
        SETUPACN (ACN); 
        FSTPT = NXTBUF; 
        END 
      LSTPT = ZERO; 
      RETURN; 
      END                                        # FREE BUFFERS        #
      CONTROL EJECT;
      PROC CHG$CHTYP (CH$TYP,CH$ACN) ;
      BEGIN #CHG$CHTYP# 
      ITEM CH$ACN U;
      ITEM CH$TYP U;
      ITEM ABHPTR$SAVE U; 
      ITEM ABHBUF U = 0;
      ITEM TXTBUF U = 0;
# 
      BUILD DC/CICT MSG AND SEND OFF TO NIP 
# 
      ABHPTR$SAVE = P<ABH>;  #SAVE ABH PTR OF CALLER OVER RTN#
      P<ABH> = LOC(ABHBUF); 
      P<SM$> = LOC(TXTBUF); 
      PFCSFC = DCCICT;
      DCACN = CH$ACN; 
      DCACT = CH$TYP; 
      ABH$ABT = 3;
      ABH$ADR = 0;
      ABH$ACT = 1;
      ABH$TLC = 1;
      NETPUT(ABH,SM$);
      P<ABH> = ABHPTR$SAVE;  #RESTORE ABH PTR OF CALLER#
      RETURN; 
      END #CHG$CHTYP# 
      CONTROL EJECT;
# 
      GETDATA MAIN LOOP 
# 
  
# 
      LOOP ON GETTING DATA UNTIL EITHER A NULL BLOCK IS RECEIVED OR 
      NO MORE BUFFER SPACE AVAILABLE
  
# 
      FINISHED = FALSE; 
      FOR I=I WHILE NOT FINISHED DO 
        BEGIN                                    # GET DATA LOOP       #
# 
        GET A BLOCK BIG ENOUGH TO ACCEPT THE LARGEST BLOCK OF DATA
        POSSBILE
# 
        BLOCK = GETBUF (MAXBLOCK + 1,NOT$MOVEABLE); 
        IF BLOCK EQ ZERO
        THEN
          BEGIN                                  # NO MORE CM SPACE    #
          FINISHED = TRUE;
          END                                    # NO MORE CM SPACE    #
        ELSE
          BEGIN                                  #INPUT SPACE AVAILABLE#
          P<ABH> = ADDRESS [BLOCK]; 
          P<TXT> = ADDRESS [BLOCK] + 1; 
          NETGETL (ALN,ABH,TXT,MAXBLOCK); 
          IF ABH$IBU                             # INPUT NOT DELIVERED #
          THEN
            BEGIN 
            IF ABH$XPT                           # TRANSPARENT DATA    #
            THEN
              BEGIN                              # CHANGE ACT TO ASCII8#
              XPT$ACN = ABH$ADR;
              XPT$TLC =MAXBLOCK/7.5 + 1;
              CHG$CHTYP ( ACT"ASCII8", XPT$ACN ); 
              NETGET (XPT$ACN,ABH,TXT,XPT$TLC); 
              CHG$CHTYP (ACT"DISPLAYCODE", XPT$ACN);
              ABH$TLC = (ABH$TLC / 7.5 + 1) * 10; 
              END                                # CHANGE ACT TO ASCII8#
            END 
          IF ABH$ABT EQ BLOCKTYPE"NULL" 
          THEN
            BEGIN                                # NO MORE DATA FM NAM #
            FINISHED = TRUE;
            RETTSB (BLOCK); 
            SETUPACN (ACN); 
            END 
          ELSE
            BEGIN                                # DATA AVAILABLE      #
            TYPE = ABH$ABT; 
            ACN = ABH$ADR;
            IF ACN EQ ZERO
            THEN
              BEGIN                              # SM RECEIVED         #
              SMCOUNT = SMCOUNT + 1;             # COUNT NUMBER OF SM  #
              CHGSIZE (BLOCK,ABH$TLC + 1,1);  # SET NOT MOVABLE        #
              P<TCB>=ADDRESS [ACN$CB [SMPACN]]; 
              LINKBLOCK (LOC(TCB$INPUT),BLOCK); 
              END                                # SM RECEIVED         #
            ELSE
              BEGIN 
              IF ACN$CB [ACN] EQ ZERO OR
                 ACN$DEVTYPE [ACN] NQ S"CONSOLE"
              THEN
                BEGIN                            #DATA ON NON OPERATION#
                                                 #AL OR BATCH DEVICE   #
                                                 #CONNECTION NUMBER    #
*IF DEF,DEBUG 
                MESSAGE (NONOPACN,3); 
*ENDIF
                RETTSB (BLOCK);                  # DUMP BLOCK          #
                SETUPACN (ACN); 
                END 
              ELSE
                BEGIN                            #DATA ON CONSOLE ACN  #
                IF TYPE EQ BLOCKTYPE"SM"
                THEN
                  BEGIN                          # SM ON CONSOLE ACN   #
                  SMCOUNT = SMCOUNT + 1;         # COUNT NUMBER OF SM  #
                  CHGSIZE (BLOCK,ABH$TLC + 1,0);
                  P<TCB>=ADDRESS [ACN$CB [SMPACN]]; 
                  LINKBLOCK (LOC(TCB$INPUT),BLOCK); 
                  END                            # SM ON CONSOLE ACN   #
                ELSE
                  BEGIN                          # COMMAND RECEIVED    #
                  SETUPACN (ACN); 
                  CHGSIZE (BLOCK,ABH$TLC/10 + 2,0); 
                  LINKBLOCK (LOC(TCB$INPUT),BLOCK); 
                  END                            # COMMAND RECEIVED    #
                END                              # DATA ON CONSOLE ACN #
              END                                #                     #
            END                                  # DATA AVAIALBLE      #
          END                                    #INPUT SPACE AVAILABLE#
        END                                      # GET DATA LOOP       #
      RETURN; 
      END   # GETDATA # 
      TERM; 
