*DECK NETGETF 
USETEXT AIPDEF
USETEXT NP$GETS 
USETEXT NP$MODE 
USETEXT NP$NWL
USETEXT NP$STAT 
USETEXT NP$TAA
*IF,DEF,DEBUG 
USETEXT NP$DB 
*ENDIF
PROC NETGETF((ADR),HA,(NA),TAAA); 
*IF DEF,IMS 
 #
*1DC  NETGETF 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        NETGETF             J.C. LEE            78/10/10 
*        NETGTFL
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE BUILDS A NETGETF OR A NETGTFL REQUEST IN THE
*        NWL WORKLIST, FOR A BLOCK FROM THE SPECIFIED CONNECTION OR 
*        LIST. REQUESTS FOR SUPERVISORY MESSAGES MAY BE MADE ON 
*        CONNECTION / LIST ZERO.
* 
*     3. METHOD USED
*        IF THE APPLICATION IS USING THE UPLINE DATA QUEUE FEATURE, OR
*        THE DOWNLINE BUFFERING FEATURE, THIS PROGRAM CANNOT BE CALLED. 
*        A NETGETF ENTRY IS BUILT IN THE WORKLIST FOR A NON-ZERO ACN. 
*        A NETGTFL IS BUILT IN THE WORKLIST FOR ALL ALN.
*        A NETGTFL MAY HAVE ONE OF THE FOLLOWING FORMAT:  
* 
*         1. I-----------------------------------------------------I
*            I OP CODE WORD WITH A NON-ZERO LOC OF TEXT AREA ARRAY I
*            I-----------------------------------------------------I
*            I ABH WORD CONTAINING TLMAX AND THE CONNECTION NO     I
*            I-----------------------------------------------------I
* 
*         2. I-----------------------------------------------------I
*            I OP CODE WORD WITH A ZERO LOC OF TEXT AREA ARRAY     I
*            I-----------------------------------------------------I
*            I ABH WORD CONTAINING TLMAX AND THE CONNECTION NO     I
*            I-----------------------------------------------------I
*            I A NULL WORD - SO THAT NIP DOES NOT NEED ALLOCATE    I
*            I ANOTHER BUFFER TO SF.LIST THE TEXT AREA ARRAY. (AN  I
*            I SF.LIST REQUIRES TWO SUBSYSTEM FUNCTION PARAMETER   I
*            I WORDS PLUS A WORD FOR NIP"S BUFFER HEADER.          I
*            I-----------------------------------------------------I
*            I TEXT AREA ARRAY CONTAINING SIZES AND LOCATIONS OF   I
*            I EACH FRAGMENTED BUFFERS.                            I
*            I-----------------------------------------------------I
* 
*        THE TEXT AREA ARRAY CONTAINING SIZES AND LOCATIONS OF BUFFER 
*        FRAGMENTS, IS COPIED TO THE NWL IF THERE IS ENOUGH ROOM: 
*        2 HEADER WORDS (OP, ABH) + A NULL WORD + LTAA + 2 WORDS FOR A
*        GSM ENTRY. FOR A GETF/GTFL ON A ZERO ACN/ALN, A MESSAGE IS 
*        DELIVERED FROM THE SMB, VIA NP$GSM.
* 
*     4. ENTRY CONDITIONS 
*        ADR - APPLICATION CONNECTION NUMBER / APPLICATION LIST NUMBER
*        HA - HEADER AREA 
*        NEXT - NEXT AVAILABLE SPACE POINTER FOR WORKLIST 
*        SPACE$LEFT - NUMBER OF CELLS AVAILABLE IN NWL
*        NA - NUMBER OF FRAGMENTED BUFFERS
*        TAA - TEXT AREA ARRAY
* 
*     5. EXIT CONDITIONS
*        DEFER$GSM - TRUE FOR ADR=0 IF SMB IS EMPTY 
*        LTAA - RESET TO ZERO 
*        NEXT - NEXT AVAILABLE SPACE POINTER, RESET TO INITIAL VALUE
*        SPACE$LEFT - NUMBER OF CELLS AVAILABLE IN WORKLIST, RESET TO 
*        INITIAL VALUE. 
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
*        AIPDEF    NP$CRT    NP$DB     NP$GETS
*        NP$NWL    NP$STAT   NP$TAA 
*        NP$MODE
* 
*     7. ROUTINES CALLED
*        NP$GET - PROCESS A GET REQUEST.
* 
*     8. DAYFILE MESSAGES 
*        * NETWORK APPLICATION ABORTED, RC = 55. *
*        * NETGETF: REQUEST INVALID FOR DATA QUEUE. * 
* 
*        * NETWORK APPLICATION ABORTED, RC = 56. *
*        * NETGTFL: REQUEST INVALID FOR DATA QUEUE. * 
* 
 #
*ENDIF
  
   BEGIN
  
*CALL NP$CRT
      CONTROL LIST; 
# 
      ROUTINES CALLED 
# 
    XREF
      BEGIN 
      PROC NP$ERR;                      # ISSUE ERR MSG AND ABORT APP  #
      PROC NP$GET;
      END 
# 
      LOCAL VARIABLES 
# 
      ITEM
        ADR             I,              # APP CONNECTION / LIST NO     #
        HA              I,              # HEADER ADDRESS               #
        NA              I,              # NO OF FRAGMENTED BUFFERS     #
        NAA             I,              # TEMPORARY VARIABLE           #
        TAAA            I,              # TEXT ARRAY AREA ADDRESS      #
        I               I,              # TEMPORARY VARIABLE           #
        J               I;              # TEMPORARY VARIABLE           #
#**********************************************************************#
# 
      NETGETF EXECUTION BEGINS HERE 
# 
      OPCODE = OP$GETF; 
*IF,DEF,STAT
      IAM = TYPE"GETF"; 
      IF GMBUSE OR DOWNUSE              # UPLINE DATA QUEUE OR DOWNLINE#
      THEN                              # BUFFER FEATURE BEING USED.   #
        BEGIN 
        NP$ERR("55");                   # ABORT APP WITH ERROR MESSAGE #
        END 
      LIST = FALSE;                     # SET FLAG FOR NOT LIST PROCESS#
*ENDIF
      GOTO NETGTF1; 
  
      ENTRY PROC NETGTFL((ADR),HA,(NA),TAAA); 
      OPCODE = OP$GTFL; 
*IF,DEF,STAT
      IAM = TYPE"GTFL"; 
      IF GMBUSE OR DOWNUSE              # UPLINE DATA QUEUE OR DOWNLINE#
      THEN                              # BUFFER FEATURE BEING USED    #
        BEGIN 
        NP$ERR("56");                   # ABORT APP WITH ERROR MESSAGE #
        END 
      LIST = TRUE;                      # SET FLAG FOR LIST PROCESSING #
*ENDIF
  
NETGTF1:  
      NAA = NA; 
# 
      STORE INPUT PARAMETERS IN COMMON BLOCK
# 
      ACLN = ADR; 
      LOC$HA = LOC(HA); 
      LOC$TA = LOC(TAAA); 
      TLMX = 0; 
      LTAA = NAA; 
*IF DEF,DEBUG 
      NP$NA = NA; 
*ENDIF
      P<TAA> = LOC$TA;
      FOR I=1 STEP 1 UNTIL NA DO
        TLMX = TLMX + TAASIZE[I]; 
*IF DEF,DEBUG 
  
# 
      SET UP PARAMETERS FOR DEBUG MESSAGE LOGGING 
# 
      IF OPCODE EQ OP$GETF
      THEN
        DB$CALL = LOC(NETGETF); 
      ELSE
        DB$CALL = LOC(NETGTFL); 
  
*ENDIF
# 
      SET UP GETF OR GTFL NWL ENTRY 
# 
      NWL[NEXT] = 0;                    # CLEAR NWL OPCODE WORD        #
      BS = OPABHSIZ;                    # INITIALIZE NWL ENTRY SIZE    #
      NWL$LTAA[NEXT] = NAA;             # LENGTH OF TEXT AREA ARRAY    #
      IF NA LQ (SPACE$LEFT - GMMESIZE - NTRYSIZ3 - OPABHSIZ) AND
         NAA LQ MAXNA 
      THEN                              # SPACE AVAILABLE IN NWL FOR   #
        BEGIN                           # TEXT AREA ARRAY              #
        BS = NA + NTRYSIZ3;             # RESET NWL ENTRY SIZE         #
        I = NEXT + NTRYSIZ3 - 1;
        FOR J=1 STEP 1 UNTIL NA DO      # COPY TAA TO NWL              #
          NWL[I+J] = TAAWORD[J];
        END 
      ELSE
        NWL$TA[NEXT] = LOC$TA;          # TAA CANNOT FIT INTO NWL      #
  
      NP$GET;                           # VALIDATE CALL AND SET UP     #
  
      RETURN; 
   END # NETGETF #
TERM