Google
 

Trailing-Edge - PDP-10 Archives - BB-X117B-SB_1986 - 10,7/nml/nmlrcv.bli
There are 2 other files named nmlrcv.bli in the archive. Click here to see a list.
! UPD ID= 306, SNARK:<6.1.NML>NMLRCV.BLI.6,  29-Apr-85 20:02:28 by GLINDELL
!   NCP$SEND_RESPONSE now has one more argument - add that to call.
!
! UPD ID= 252, SNARK:<6.1.NML>NMLRCV.BLI.5,   7-Feb-85 16:13:38 by GLINDELL
!  Fix a bug: the NML receiver would shut down a link after 60 seconds
!  without reading anything from it.  Howver, we may be writing on the
!  link.  Add flag PB_IN_USE to parameter block.

! UPD ID= 48, SNARK:<6.1.NML>NMLRCV.BLI.4,  29-May-84 17:31:01 by GLINDELL
! Always allow remote READ access
!
! UPD ID= 42, SNARK:<6.1.NML>NMLRCV.BLI.2,  24-May-84 16:32:41 by GLINDELL
! PH4:<HALPIN>NMLRCV.BLI.3 16-Feb-84 09:18:40, Edit by HALPIN
!
! Ident 15.
!   Send a NETWORK_REJECT when NMU$NETWORK_VALIDATE returns $false
!
!DSKC:NMLRCV.BLI[10,5665,SOURCE,TOPS10]  9-Oct-83 15:14:17, Edit by GROSSMAN
!
! Fix WAIT_FOR_CONNECT so that it resets the connect block correctly when 
! rejecting a connection.  This keeps NML from looping.
!
!<MCINTEE>NMLRCV.BLI.2,  5-Jul-83 12:10:28, Edit by MCINTEE
!
! Ident 14.
!   add use of debug flag NML_REMOTE_REQUEST
!
!<MCINTEE.WORK>NMLRCV.BLI.2, 15-Jun-83 13:08:53, Edit by MCINTEE
! 
! Ident 13.
!  Dot bug in CHECK_VERSION
!
! PH4:<PECKHAM>NMLRCV.BLI.6 13-Jun-83 15:07:08, Edit by PECKHAM
!
! Ident 12.
!   Fix CHECK_VERSION to return the remote version number in PB_VERSION,
!   and use NML$CNV_CHECK_VERSION to check if supported.  Store this version
!   number in the generated request blocks in READ_NICE_REQUESTS.  Use the
!   request block version number in DEQUEUE_REQUEST to translate responses
!   where necessary.
!
! NET:<PECKHAM.DEVELOPMENT>NMLRCV.BLI.8 25-Jun-82 19:43:17, Edit by PECKHAM
!
! Ident 11.
! Reduce NICE_BUFFER_LENGTH from 500 to 300 bytes.
! Define a parameter block so that access control can be passed from
! WAIT_FOR_CONNECT to READ_NICE_REQUEST (also good for code optimization). 
! Optimize linkages.
!
! NET:<PECKHAM.DEVELOPMENT>NMLRCV.BLI.3 23-Jun-82 11:04:21, Edit by PECKHAM
!
! Ident 10.
! Merge QUEUE_REQUEST into READ_NICE_REQUEST so that request block
! can be handled there.
! Set privledged bits on for now, later user info will be checked.
! Fix DEQUEUE_REQUEST to conditionally release memory from request block.
!
! <BRANDT.DEVELOPMENT>NMLRCV.BLI.2 7-Jun-82 11:21:45, Edit by BRANDT
!
! Ident 09.
!   1) In DEQUEUE_RESPONSE release memory allocated for node_id
!      in the request block.  Before this edit, this memory was
!      released in NML$NICE_EXECUTE.  Doing so allowed the memory to
!      be reallocated while still being referenced as a node_id.
!
! NET:<VOBA.NML.DEVELOPMENT>NMLRCV.BLI.3 30-Mar-82 10:48:02, Edit by VOBA
!
! Ident 08.
! Update copyright date and clean up code.
!
!NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NMLRCV.BLI.21 20-Nov-81 13:39:24, Edit by WEBBER
!
! Ident 07.
! Fix ident 06 to use only addresses, not pointers, in memory gets and
! retrieves.
!
!NET:<DECNET20-V3P1.NML>NMLRCV.BLI.2 21-Oct-81 09:49:14, Edit by WEBBER
!
! Ident 06.
! Add response buffer and its length as parameters to NETWORK_OPEN.
!
! NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NMLRCV.BLI.18  2-Oct-81 17:42:49, Edit by GUNN
!
! Ident 05.
! Fix typo in code returning $NICE$ERR_IID response code.
!
! NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NMLRCV.BLI.15 12-Aug-81 12:52:01, Edit by JENNESS
!   
! Ident 04.
! Fix CHECK_VERSION to properly use the CB_DATA pointer as a pointer
! not as the address of the data buffer.
!
! NET:<DECNET20-V3P1.NML>NMLRCV.BLI.2  1-Jun-81 15:14:49, Edit by GUNN
!
! Ident 03.
! Fix problem preventing completion of SHOW KNOWN xxx command to a
! remote node. Make DEQUEUE_RESPONSE not release RB until the command
! processing is complete as indicated by RB_STATE.
!
! NET:<DECNET20-V3P1.NML>NMLRCV.BLI.3  3-Mar-81 16:25:05, Edit by GUNN
!
! Remove references to RB_NICE_SIZE and RB_DATA_SIZE and replace with
! RB_aaa_ALLOCATION field references.
!
! NET:<DECNET20-V3P1.NMU>NMLRCV.BLI.5  3-Feb-81 10:04:32, Edit by JENNESS
!    Remove literal definition for NICE_OBJECT (now in NMARCH).
!    Remove DEBUG logical link descriptor (NMUNET now creates user name
!	descriptor if .135 neq 0).
!    Fix access control validation to work properly.  NMU$NETWORK_VALIDATE
!	returns $true/$false instead of 0/not 0.
!    Add error code for 'ACCESS NOT PERMITTED' on connect reject (SC$_ANP).
!
%title 'NMLRCV -- NICE Remote Message Receiver'
module NMLRCV	(
		ident = 'X03.15'
		) =
begin

!                     COPYRIGHT (c) 1981, 1982 BY
!	      DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
! ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
! INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
! COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
! OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
! TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
! AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
! CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!

!++
! FACILITY:	DECnet-10/20 V3.0 Network Management Layer (NML)
!
! ABSTRACT:
!
!	This module performs the NML NICE remote request receive function.
!
! ENVIRONMENT:	TOPS-10/20 & MCB/RSX11 User mode under NML
!
! AUTHOR: Dale C. Gunn , CREATION DATE: 20-Jan-81
!
! MODIFIED BY:
!
!	, : VERSION
! 01	-
!--
!
! INCLUDE FILES:
!

library 'NMLLIB';                       ! All required definitions
require 'NMLEXT';                       ! NML External routines

!
! TABLE OF CONTENTS
!

%if %bliss (bliss16)
%then linkage NML_LKG_PB = jsr (register = 5);
%else macro NML_LKG_PB = bliss36c %;
%fi

forward routine
        NML$RECEIVE_NICE : novalue;

forward routine
	SET_ACCESS_PRIVS: novalue,	! Set privs from NM$NETWORK_OPEN access code
        WAIT_FOR_CONNECT : NML_LKG_PB,  ! Wait for connection to target task
        CHECK_VERSION : NML_LKG_PB,     ! Validate network management version
        READ_NICE_REQUEST : NML_LKG_PB novalue, ! Read a NICE request message
        DEQUEUE_REQUEST : novalue;      ! Remove completed request from queue

!
! MACROS:
!

!
! EQUATED SYMBOLS:
!

literal
       NICE_BUFFER_LENGTH = 300,        ! NICE request buffer length in bytes
       NICE_BUFFER_SIZE = ch$allocation (NICE_BUFFER_LENGTH,8), ! In words
       NICE_BUFFER_ALLOCATION = NICE_BUFFER_SIZE * %upval; ! In addr units

!
! Parameter Block
!

$show (fields);                         ! Turn on XPORT field display
$show (literals);                       ! Turn on XPORT literal display

$field
    PARAMETER_FIELDS =
        set
        PB_BASE = [$sub_block (0)],
        PB_LINK_HANDLE = [$short_integer],
        PB_CBLK = [$address],
        PB_OPTD_PTR = [$pointer],
        PB_OPTD_CNT = [$short_integer],
        PB_VERSION = [$short_integer],
        PB_ACCESS = [$tiny_integer],
        PB_OBJECT = [$byte],
        PB_IN_USE = [$bits(1)]
        tes;

literal
    PARAMETER_BLOCK_SIZE = $field_set_size,
    PARAMETER_BLOCK_ALLOCATION = $field_set_units;

macro
     PARAMETER_BLOCK = block [PARAMETER_BLOCK_SIZE] field (PARAMETER_FIELDS) %;

$show (none);                           ! Turn off XPORT display

!
! OWN STORAGE:
!

own
    BUGPID;				! Poked for use by debug flag NML_REMOTE_REQUEST

!
! EXTERNAL REFERENCES:
!


external routine
	 NCP$SEND_RESPONSE,
         NML$CNV_CHECK_VERSION,
         NML$CNV_RESPONSE,
	 PUTBUF,
  	 NMU$PAGE_GET,
	 NMU$PAGE_RELEASE,
         NMU$NETWORK_UTILITIES;

external
        NMLVER,                         ! Network Managment version number
        DECECO,                         ! Digital ECO number
        USRECO;                         ! User ECO number

external %debug_data_base;		! Debugging flags used in this module

%global_routine ('NML$RECEIVE_NICE', TASK, RESOURCE) : novalue =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine is the top level of the Network Management
!	NICE request listener. The listener is responsible for
!       accepting connections from remote NMLs, verifying their
!       privilege to perform NM functions based on access control
!       information provided with the connection.
!
! FORMAL PARAMETERS
!
!	TASK	 - Address of task block for this task
!	RESOURCE - Address of cell for this task to use as
!                  a resource variable.
!
! IMPLICIT INPUTS
!
!	NONE.
!
! ROUTINE VALUE:
!
!	NONE.
!
! SIDE EFFECTS:
!
!	NONE.
!
!--

    begin

    local
         PB : ref PARAMETER_BLOCK,
         PBA,
         BUFFER_PTR,                    ! Pointer to acceptance data buffer
         BUFFER : ch$sequence (3,8);    ! Acceptance data buffer, NM Version

!
! Allocate a parameter block
!
    if (PB = NMU$MEMORY_GET (PARAMETER_BLOCK_ALLOCATION)) eql 0 then return;

!
! Put our Network Management version number into the buffer
! to send as the optional data on a link connect acceptance.
!

    PB [PB_OBJECT] = NICE_OBJECT;
    PB [PB_OPTD_PTR] = ch$ptr (BUFFER,, 8);
    BUFFER_PTR = .PB [PB_OPTD_PTR];     ! Point to connect accept buffer
    PUTB (.NMLVER, BUFFER_PTR);         ! Store NM major version
    PUTB (.DECECO, BUFFER_PTR);         ! Store our minor (ECO) version
    PUTB (.USRECO, BUFFER_PTR);         ! Store customer ECO number
    PB [PB_OPTD_CNT] = ch$diff (.BUFFER_PTR, .PB [PB_OPTD_PTR]);

!
! Loop forever, wait for link connected, read requests until disconnected.
!

    PBA = PB [PB_BASE];                 ! For BLISS-16 optimization

    while $TRUE
    do begin
       WAIT_FOR_CONNECT (.PBA);
       READ_NICE_REQUEST (.PBA);
       NMU$NETWORK_CLOSE (.PB [PB_LINK_HANDLE], 0, 0);
       end;

    end;				! End of NML$RECEIVE_NICE
%routine ('WAIT_FOR_CONNECT', PB : ref PARAMETER_BLOCK) : NML_LKG_PB =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine opens a target link for connection by
!	another task.  When a connect is attempted the user
!	access rights are checked and the source task's version
!	number is checked.  If all checks are ok, then the
!	link is accepted (sending the optional acceptance data)
!	and the LINK_ID is returned.  If any check fails,
!	a reject is sent with the appropriate error code.
!
! FORMAL PARAMETERS
!
!	PB - Parameter block
!
! IMPLICIT INPUTS
!
!	NONE.
!
! ROUTINE VALUE:
!
!	The LINK_ID of the opened link.
!
! SIDE EFFECTS:
!
!	NONE.
!
!--

    begin

    local
         CBLK: CONNECT_BLOCK,           ! Link connection block
         REASON;                        ! Link rejection reason

    while $true                         ! Loop until the link is connected
    do begin

!
! Set the object code and clear the task name and descriptor.
!

       PB [PB_CBLK] = CBLK;
       CBLK[CB_OBJECT] = .PB [PB_OBJECT];
       CBLK[CB_TASK_LENGTH] = 0;
       CBLK[CB_DESCRIPTOR_LENGTH] = 0;
       CBLK[CB_HOST_LENGTH] = 0;
       CBLK[CB_USERID_LENGTH] = 0;
       CBLK[CB_PASSWORD_LENGTH] = 0;
       CBLK[CB_ACCOUNT_LENGTH] = 0;
       CBLK[CB_DATA_LENGTH] = 0;

       REASON = 0;
       PB [PB_LINK_HANDLE] = NMU$NETWORK_OPEN (TARGET_LINK, CBLK, 0, 0, 0);

!
! Check for user access and version number ok
!

	if (.PB [PB_LINK_HANDLE] gtr 0)
        and ((REASON = CHECK_VERSION (PB [PB_BASE])) eql 0)
        and ((PB [PB_ACCESS] = NMU$NETWORK_VALIDATE (CBLK)) geq 0)
	then begin
             NMU$NETWORK_ACCEPT (.PB [PB_LINK_HANDLE], .PB [PB_OPTD_CNT], .PB [PB_OPTD_PTR]);
             exitloop;
             end
	else begin
             local REJECT_BUFFER;
             ch$wchar (.REASON, ch$ptr (REJECT_BUFFER,,8));
             NMU$NETWORK_REJECT (.PB [PB_LINK_HANDLE],
                                 SC$_ANP,
                                 1,
                                 ch$ptr (REJECT_BUFFER,,8));
             NMU$NETWORK_CLOSE (.PB [PB_LINK_HANDLE], 0, 0);
             end;
	end;
!
! Return handle (id) of link that was opened and accepted.
!

    return .PB [PB_LINK_HANDLE];
    end;				! End of WAIT_FOR_CONNECT
%routine ('CHECK_VERSION', PB : ref PARAMETER_BLOCK) : NML_LKG_PB =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine checks to see if the Network Management
!	version match.  If they don't, an error code is returned.
!
! FORMAL PARAMETERS
!
!	PB - Parameter block
!
! IMPLICIT INPUTS
!
!	NONE.
!
! ROUTINE VALUE:
!
!	Zero if ok, a non-zero error code if failed test
!
! SIDE EFFECTS:
!
!	NONE.
!
!--

    begin

    bind
       CBLK = .PB [PB_CBLK] : CONNECT_BLOCK;

    local
         VERSION;

    selectone .CBLK[CB_DATA_LENGTH] of
        set
        [0] : VERSION = 2;              ! Default to 2
        [3] : VERSION = ch$rchar (.CBLK[CB_DATA]);
        [otherwise] : return $NICE$ERR_IID; ! Is this the right code to return?
        tes;

    PB [PB_VERSION] = .VERSION;

    if not NML$CNV_CHECK_VERSION (.VERSION)
    then $NICE$ERR_IMV
    else 0
    end;				! End of CHECK_VERSION
%routine ('READ_NICE_REQUEST', PB : ref PARAMETER_BLOCK) : NML_LKG_PB novalue =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine performs the NICE request receive function on 
!	a logical link that has already been opened. The looping 
!	continues until the task at the other end of the link closes 
!	it (or some other nefarious glitch takes it down).
!
! FORMAL PARAMETERS
!
!	PB - Parameter block
!
! IMPLICIT INPUTS
!
!	NONE.
!
! ROUTINE VALUE:
!
!	NONE.
!
! SIDE EFFECTS:
!
!	NONE.
!
!--

    begin

    while $true                         ! Loop through reading NICE requests
    do begin                            ! as long as link stays up.

       literal
           TEXT_BUFFER_LENGTH = 80;	! A line's worth.

       local
           BYTE_COUNT,                  ! Received NICE request message length
           REQ : ref REQUEST_BLOCK;

       !
       ! Allocate storage for NICE request block
       !

       REQ = NMU$MEMORY_GET (REQUEST_BLOCK_ALLOCATION);
       REQ[RB_EXECUTOR] = 0;            ! Initialize to process locally
       REQ[RB_DATA] = .PB;               ! Save PB address
       REQ[RB_DATA_ALLOCATION] = 0;     ! No block allocated

       REQ[RB_VERSION] = .PB [PB_VERSION];

       SET_ACCESS_PRIVS (.PB [PB_ACCESS], .REQ); ! Set up privileges

       ! Get a buffer for the NICE message and store its address

       REQ[RB_NICE_ALLOCATION] = NICE_BUFFER_ALLOCATION; ! Units allocated
       REQ[RB_NICE] = NMU$MEMORY_GET (.REQ[RB_NICE_ALLOCATION]);
       REQ[RB_NICE_POINTER] = ch$ptr (.REQ[RB_NICE],0,8);

       ! Attempt to read a NICE request message

       PB[PB_IN_USE] = $false;          ! Clear used flag
       BYTE_COUNT = NMU$NETWORK_READ (.PB [PB_LINK_HANDLE],
                                      NICE_BUFFER_LENGTH,
                                      .REQ[RB_NICE_POINTER]);

       ! Check if we received a message, or read completed for some
       ! other reason. (Maybe the link was disconnected.)

       if .BYTE_COUNT gtr 0             ! Put the NICE request on the queue
       then begin                       ! to be processed.
            REQ[RB_NICE_LENGTH] = .BYTE_COUNT;
            REQ[RB_COMPLETION] = DEQUEUE_REQUEST; ! Completion routine

            !
            ! Enter the request into the NICE request queue.
            !

            NML$REQUEST_ENTER (.REQ);   ! Enter request in queue
	    %debug (NML_REMOTE_REQUEST, ! Print the content of the NICE
                   (begin               ! message buffer as an ASCII text
                    builtin LSH;
                    local PAGE, PTR, TMP;
                    
                    PAGE = NMU$PAGE_GET ();
                    PTR = TMP = ch$ptr (LSH (.PAGE,9));
                    $NMU$TEXT (TMP, TEXT_BUFFER_LENGTH,
                               '%/[NICE Remote Request Message]%/%N');
                    PUTBUF (TMP, 0, .REQ [RB_NICE], .REQ [RB_NICE_LENGTH]);
                    NCP$SEND_RESPONSE (0, .PTR, .BUGPID, 0);
                    NMU$PAGE_RELEASE (.PAGE);
                    end));

	    end
       else begin
            ! See if timeout and we are using link (long response)
            if not ((.BYTE_COUNT eql -1) and (.PB[PB_IN_USE]))
            then begin
                 
                 ! The link has been disconnected. Release the NICE buffer and
                 ! and and indicate no longer connected.
                 
                 REQ[RB_STATE] = RB$DONE;
                 DEQUEUE_REQUEST (.REQ);
                 exitloop;
                 end;
            end;
       end;

    end;				! End of READ_NICE_REQUEST
%routine ('SET_ACCESS_PRIVS', ACCESS, REQ: ref REQUEST_BLOCK): novalue =

!++
! Functional description:
!
!	This routine converts the access code from NMU$NETWORK_OPEN
!	into a set of privilege bits in the request block.
!
! Formal parameters:
!
!	ACCESS		Access code from NMU$NETWORK_OPEN
!			-2 if JSYS or UUO error
!			-1 if invalid access information
!			 0 if unprivileged user
!			 1 if WHEEL (POKE) privileged user
!			 2 if OPERATOR privileged user
!	REQ		Request block address
!
! Routine value:
!
!	None
!--

begin

    REQ [RB_PRV_READ] = (.ACCESS geq 0);
    REQ [RB_PRV_CHANGE] = (.ACCESS geq 1);
    REQ [RB_PRV_SYSTEM] = (.ACCESS geq 1);
    REQ [RB_PRV_SERVICE] = (.ACCESS geq 2);
    REQ [RB_PRV_TEST] = (.ACCESS geq 2);

end;
%routine ('DEQUEUE_REQUEST', REQ) : novalue =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine handles the completion processing of remote NICE
!       requests when called by the NML request queue manager. It transmits
!       the NICE repsonse message back to the requestor and releases
!       all resources obtained when the request was created.
!
! FORMAL PARAMETERS
!
!	REQ - Address of the NML Request Block.
!
! IMPLICIT INPUTS
!
!	NONE.
!
! ROUTINE VALUE:
!
!	NONE.
!
! SIDE EFFECTS:
!
!	NONE.
!
!--

    begin

    map
       REQ: ref REQUEST_BLOCK;

    local
       PB : ref PARAMETER_BLOCK;

    if .REQ[RB_RESPONSE] neq 0
    then begin

         !
         ! Translate response message where necessary.
         !

         NML$CNV_RESPONSE (.REQ);

         !
         ! Attempt to transmit the NICE response message back to requestor.
         !

         PB = .REQ[RB_DATA];            ! Get PB address
         NMU$NETWORK_WRITE (.PB[PB_LINK_HANDLE], ! Link ID
                            $TRUE,      ! Complete message
                            .REQ[RB_RESPONSE_LENGTH], ! Message length in bytes
                            ch$ptr (.REQ[RB_RESPONSE],,8)); ! NICE response pointer
         PB[PB_IN_USE] = $true;         ! Using PB block
         end;

    !
    ! Release all memory resources when done.
    !

    if .REQ[RB_STATE] eql RB$DONE
    then begin
	 if .REQ[RB_NICE_ENTITY_ADR] neq 0 ! Release node id buffer
	 then NMU$MEMORY_RELEASE (.REQ[RB_NICE_ENTITY_ADR],
				  NODE_ID_BUFFER_ALLOCATION);
         if .REQ[RB_NICE] neq 0
         then NMU$MEMORY_RELEASE (.REQ[RB_NICE], .REQ[RB_NICE_ALLOCATION]);
         if .REQ[RB_RESPONSE] neq 0
         then NMU$MEMORY_RELEASE (.REQ[RB_RESPONSE], .REQ[RB_RESPONSE_ALLOCATION]);
         NMU$MEMORY_RELEASE (.REQ, REQUEST_BLOCK_ALLOCATION);
         end;

    end;				! End of DEQUEUE_REQUEST
end                                     ! End of Module NMLRCV
eludom
! Local Modes:
! Mode:BLISS
! Auto Save Mode:2
! Comment Column:40
! Comment Rounding:+1
! End: