VMS Help  —  PEEK
   Peek & Spy allow a user to watch (and optinally control) another user's
   terminal. See the PEEK Subtopic: Watching.

   Peek & Spy also allow terminal-logging. See the PEEK Subtopic:
   Terminal-Logging.

   Allowing a non-privileged user to watch you with PEEK is done via the
   PEEK/ALLOW command. See the PEEK Subtopic: Commands ALLOW.

   For a full list of Peek/Spy commands, see the PEEK Subtopic: Commands.

1  –  Commands

   The Peek/Spy subcommands are:

   ALLOW         - Allow a non-privideged user to watch you with Peek.
   ATTACH        - Attach to another process in you job.
   DISALLOW      - Revoke previously issued ALLOW commands
   EXIT          - Exit interactive Peek/Spy prompting.
   FORMAT        - Format a log file.
   HELP          - Access on-line Peek/Spy help.
   INSTALL       - (Obsolete beginning in Peek/Spy version 4.5)
   LICENSE       - Enter Product Authorization Key.
   NODE_NAME_CHANGE - Update licensed nodename afer a nodename change.
   NOSAVE_SCREEN - End screen-saving (on AXP) and terminal-logging.
   PEEK          - (PEEK-Only) Same as WATCH.
   QUIT          - Exit interactive Peek/Spy prompting.
   REMOVE        - (Obsolete beginning in Peek/Spy version 4.5)
   RT_ENABLE     - (VAX-Only) Enable VAX Peek/Spy watching on an RTA unit.
   SAVE_SCREEN   - Start screen-saving (on AXP) and terminal-logging.
   SHOW          - Show various Peek/Spy and system data.
   SHUTDOWN      - Shut down Peek/Spy - Only use from PEEK_SHUTDOWN.COM.
   SPAWN         - Spawn a subprocess.
   SPY           - (SPY-Only) Same as WATCH.
   WATCH         - Watch another user.

   As shipped, subcommands may be used as verbs during interactive
   Peek/Spy command prompting (e.g. PEEK> ALLOW), but subcommands
   must be entered as qualifiers when used as part of a single-line
   DCL command (e.g. $ PEEK/ALLOW). This default behavior can be
   changed. See the PEEK Commands Subtopic: /COMMAND_MODE.

1.1  –  ALLOW

   (Peek-Only subcommand, not for use with the SPY program.)

   The ALLOW subcommand is used to allow non-privileged users to watch
   your terminal using PEEK. Non-privileged users may not watch your
   terminal unless you first ALLOW them by using this command.

   When PEEK/ALLOW is used, a parameter specifying one or more valid
   rights-list identifiers can be specified. In most cases, each
   username on the system has an identical rights-list identifier.

   Format:

     $ PEEK/ALLOW username-and-identifier-list
     $ PEEK
     PEEK> ALLOW username-and-identifier-list

1.1.1  –  Parameters

   username-and-rights-list-identifier-list

   Specify a list of usernames and/or rights-list identifiers whose
   holders may watch your terminal.

   Full * and % wildcards are supported for usernames, and the
   UIC:[ggg,mmm] syntax is also supported. It allows a * wildcard for
   the group or member portion of the UIC. Due to the embedded comma,
   the "UIC:[ggg,mmm]" syntax in a command must be enclosed in quotes.

   Each individual item in the list may be preceeded by a minus to
   reverse the sense of that one item so it disallows instead of allows.

   Rights-list identifiers held by a process are displayed by the DCL
   $ SHOW PROCESS/PRIVILEGE command. Once you issue a PEEK/ALLOW command
   specifying an identifier, any users who has been granted that
   identifier may watch your terminal.

   Example:  $ PEEK/ALLOW J_JONES,HELPERS,P_SMITH

   This command allows your terminal to be watched by users J_JONES and
   P_SMITH and all users with the rights-list identifier HELPERS.

   The list is checked from left to right, so

             $ PEEK/ALLOW -J_JONES,*

   would disallow J_JONES but allow anyone else to watch.

1.1.2  –  Qualifiers

1.1.2.1    /BACKGROUND

   AXP-Only...

   /[NO]BACKGROUND

   Synonymous with the /SINGLE_WINDOW and /WINDOW qualifiers. See the
   PEEK Commands ALLOW Subtopic: /SINGLE_WINDOW.

1.1.2.2    /BEEP_TERMINAL

   /BEEP_TERMINAL = "hot-key-defintion"

   Defines a hot-key sequence for use while being watched which, when
   pressed, will cause both the watcher's and user's terminal bells
   to ring.

   This may be used to get the watcher's attention while you are being
   watched. This is useful if the watcher walks away from his terminal.

   Example:      $ PEEK/ALLOW/BEEP_TERMINAL="<F6>" JONES

   This command allows JONES to watch you and it defines the F6 key as
   the hot-key which you can use, while being watched, to ring JONES'
   terminal bell.

   The default value for this hot-key is taken from the logical
   USER$BEEP_TERMINAL. This is usually defined system-wide by
   PEEK_DEFAULTS.COM. A user may supply his own default value in his
   own process or job or group logical name table, as an alternative
   to using this ALLOW command qualfier.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

1.1.2.3    /BP_OUTPUT

   /BP_OUTPUT   (default)
   /NOBP_OUTPUT

   Enables or disables an ALLOWed watcher from diverting the output from
   your terminal so it goes only to his own terminal. The watched screen
   appears to just "go dead" during bypass-output until bypass-output is
   turned back off again.

   Bypass-output mode is turned on and off through use of the
   BYPASS_OUTPUT_TOGGLE hot-key. BYPASS_OUTPUT_TOGGLE is used by
   watchers to watch disconnected terminal-server sessions and terminals
   which have gone into a hold-screen mode. (For more information, see
   the PEEK Commands ALLOW Subtopic: /BYPASS_OUTPUT_TOGGLE.)

   /BP_OUTPUT is a DCL positional qualifier. It can be used at the start
   of a PEEK/ALLOW command line, before any identifiers, in which case
   it applies to all identifiers on the command line. It can also be
   used on a PEEK/ALLOW command line after a particular identifier, in
   which case it will apply only to that one identifier in the list.

   Examples:

         $ PEEK/ALLOW/NOBP_OUTPUT J_JONES,J_DOE
         $! J_JONES and J_DOE may watch you but without BP_OUTPUT.

         $ PEEK/ALLOW J_JONES/NOBP_OUTPUT,J_DOE
         $! J_JONES and J_DOE may both watch you but only J_DOE may
         $! BP_OUTPUT (since BP_OUTPUT is the default).

   ALLOW/NOBP_OUTPUT has no effect on SPY, nor on privileged PEEK users.

1.1.2.4    /BYPASS_OUTPUT_TOGGLE

   /BYPASS_OUTPUT_TOGGLE = "hot-key-defintion"

   Defines a hot-key sequence for use while being watched which, when
   pressed, turns on and off bypass-output mode.

   Bypass-output mode causes output going to the terminal being watched
   to cease being displayed on that terminal. The output goes only to
   the watcher's terminal.

   This allows the watcher to watch terminal output despite the terminal
   having gone into an XOFF state due to being put on hold-screen.
   Bypass-output mode is particularly useful for watching disconnected
   sessions on a terminal server, which would otherwise be hung, waiting
   to be reconnected to a physical terminal.

   It can also be useful to a watcher when he is watching a terminal on
   a slow modem line since the watcher will not have to wait while the
   output goes out over the modem.

   A user can disable this feature when he issues a PEEK/ALLOW command
   to allow a non-privileged user to watch him with PEEK. See the PEEK
   Commands ALLOW Subtopic: /BP_OUTPUT.

   The default hot-key value for ALLOW/BYPASS_OUTPUT_TOGGLE is taken
   from the logcial USER$BYPASS_OUTPUT_TOGGLE, usually defined system-
   wide by PEEK_DEFAULTS.COM.

   Example:

         $ PEEK/ALLOW/BYPASS_OUTPUT_TOGGLE="<CTRL-K>" USER1

   The above command allows USER1 to watch the current user with PEEK.
   While being watched, the user may use the hot-key Control-K to turn
   on and off bypass-output mode.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

1.1.2.5    /CHAT_TOGGLE

   /CHAT_TOGGLE = "hot-key-defintion"

   Allows the watcher and user to chat, where they can type back and
   forth to each other, but the keystrokes typed are not entered as
   input to whatever program the user process currently is running.

   Specify a hot-key sequence which, when pressed while being watched,
   will cause Peek/Spy to enter/exit a mode which is similar to "local
   mode" on a standard terminal.

   The default hot-key value for ALLOW/CHAT_TOGGLE is taken from the
   logical USER$CHAT_TOGGLE, usually defined system-wide by
   PEEK_DEFAULTS.COM.

   While in chat mode, what the user and watcher type to each other is
   echoed on both terminals, but will NOT be placed into the user's
   typeahead buffer, or passed on to the user's running program. This
   prevents this type of chatting activity from causing program or
   command errors for the user being watched.

   Example:

         $ PEEK/ALLOW JONES /CHAT="<F14>"

   The above command allows user JONES to watch you with PEEK and
   defines F14 as the hot-key for entering and exiting chat mode.

   Whenever the user being watched presses F14, both terminals will go
   into chat mode until F14 is pressed again.

   While in chat mode, the watcher and user being watched may type
   whatever they wish, and it will be displayed on both screens.

   If chat mode appears not to work and your terminal just beeps when
   you type, this is because you do not have keyboard input control
   (see the PEEK Commands ALLOW Subtopic: /TOGGLE_INPUT, which is still
   active during chat mode unless /SIMULTANEOUS_INPUT is in effect).

   The keys which are useful while in chat mode are the alphanumeric
   keys, carriage-return, delete and the arrow keys.

   You should press carriage-return to end a line, since if the other
   terminal is not in auto-wrap mode, the other user may not be able
   to see what you are typing after you reach the margin and only your
   terminal does an autowrap.

1.1.2.6    /CUMULATIVE

   /[NO]CUMULATIVE

   Controls whether or not successive ALLOW commands are cumulative.

   /NOCUMULATIVE causes all prior ALLOW information to be erased, via
   an implicit DISALLOW, before the current ALLOW command is executed.

    Example:  $ PEEK/ALLOW/NOCUMULATIVE J_DOE

   The above command erases any and all existing ALLOW permissions
   before granting permission to J_DOE to watch you.

   The default value for this qualifier is taken from the logical
   USER$CUMULATIVE, usually defined by PEEK_DEFAULTS.COM.

   For /CUMULATIVE, the current qualifier value for /FIRST controls
   whether the current ALLOW defition is added at the beginning or
   at the end of any previously-defined ALLOW information.

   For /NOCUMULATIVE, the current value for the qualifer /KEYS_ERASE
   controls whether or not hot-key definitions previously defined via
   ALLOW commands are also erased as part of the implicit DISALLOW.

   Note that earlier versions of Peek/Spy did not have the /CUMULATIVE
   qualifier. The value for the ALLOW subcommand in these earlier
   versions was always /NOCUMULATIVE.

1.1.2.7    /END_WATCH

   /END_WATCH = "hot-key-defintion"

   Defines a hot-key sequence for use while being watched which, when
   pressed by the user, will cause a current watcher to stop watching.

   The default value for ALLOW/END_WATCH is taken from the logical
   USER$END_WATCH. This is usually defined system-wide by
   PEEK_DEFAULTS.COM. A user may supply his own default value in his
   own process or job or group logical name table, as an alternative
   to using this ALLOW command qualfier.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

   If this hot-key is not defined, then the user will not be able to
   stop a watcher who is watching him with PEEK, except by issuing a
   PEEK/DISALOW command from DCL.

   Example:      $ PEEK/ALLOW/END_WATCH="<F6>" JONES

   This command allows JONES to watch you and it defines the F6 key as
   the hot-key which you can use, while being watched, to terminate
   JONES' watching of you.

   Note that the ALLOW END_WATCH hot-key has no effect on someone who
   is watching the user with SPY.

1.1.2.8    /FIRST

   /[NO]FIRST

   Used with PEEK/ALLOW/CUMULATIVE to specify that the current ALLOW
   definition should be added to the front of any existing ALLOW list.

   Example: $ PEEK/ALLOW/FIRST J_DOE/BP_OUTPUT

   The above adds J_DOE/BP_OUTPUT to the beginning of any existing
   WATCHER$ALLOW list in one's LNM$JOB logical name table.

   The default value for /FIRST is taken from the logical USER$FIRST,
   usually defined system-wide by PEEK_DEFAULTS.COM.

1.1.2.9    /KB_CONTROL

   /KB_CONTROL  (default)
   /NOKB_CONTROL

   Enables (or disables) an ALLOWed watcher from supplying input for
   your terminal.

   /KB_CONTROL is a DCL positional qualifier. It can be used at the
   start of a PEEK/ALLOW command line, before any identifiers, in which
   case it applies to all identifiers on the command line. It can also
   be used on the PEEK/ALLOW command line after a particular identifier,
   in which case it will apply only to that one identifier in the list.

   Examples:

         $ PEEK/ALLOW/NOKB_CONTROL J_JONES,J_DOE
         $! J_JONES and J_DOE may watch you but without KB_CONTROL.

         $ PEEK/ALLOW J_JONES/NOKB_CONTROL,J_DOE
         $! J_JONES and J_DOE may watch you but only J_DOE may toggle
         $! input (since KB_CONTROL is the default).

   ALLOW/NOKB_CONTROL has no effect on SPY, nor on privileged PEEK users.

1.1.2.10    /KEYS_ERASE

   /[NO]KEYS_ERASE

   Controls whether any existing hot-key definitions are also erased
   as part of the implicit DISALLOW command which is done when
   /NOCUMULATIVE is in effect.

   Example:  $ PEEK/ALLOW/NOCUMULATIVE/NOKEYS_ERASE J_DOE

   All former PEEK/ALLOW permissions are cancelled prior to ALLOWing
   J_DOE to watch, but any hot-keys previously defined via PEEK/ALLOW
   are retained.

   The default value is taken from the logical USER$KEYS_ERASE, usually
   defined system-wide by PEEK_DEFAULTS.COM.

1.1.2.11    /ONCE

   /ONCE
   /NOONCE  (default)

   Limits ALLOWed watching to a single time. When watching by the
   ALLOWed user is terminated, he will not be able to watch your
   terminal again until you again do a PEEK/ALLOW command for him.

   /ONCE is a DCL positional qualifier. It can be used at the start of
   a PEEK/ALLOW command line, before any identifiers, in which case it
   applies to all identifiers on the command line. It can also be used
   on a PEEK/ALLOW command line after a particular identifier, in
   which case it will apply only to that one identifier in the list.

   Examples:

         $ PEEK/ALLOW/ONCE J_JONES,J_DOE
         $! J_JONES and J_DOE may watch you only once each.

         $ PEEK/ALLOW J_JONES,J_DOE/ONCE
         $! J_JONES and J_DOE may watch you but J_DOE only once.

   ALLOW/ONCE has no effect on SPY, nor on privileged PEEK users.

1.1.2.12    /PERMIT_INPUT

   /PERMIT_INPUT="hot-key-defintion"

   Hot-key used to permit a watcher (who is not normally able to have
   keyboard control) to acquire temporary keyboard control through
   use of his REQUEST_INPUT hot-key.

   PERMIT_INPUT can be issued by the user being watched, or by a
   primary watcher who currently has keyboard control.

   To successfully grant PERMIT_INPUT, the user granting it must
   currently have keyboard control (via either SIMULTANEOUS_INPUT
   or TOGGLE_INPUT).

   If a PERMIT_INPUT request is rejected (due to not currently having
   control of the keyboard) then the terminal bell will beep.

   Once PERMIT_INPUT has been enabled and a watcher then accepts it
   (by using his REQUEST_INPUT hot-key), the watcher and the user who
   permitted him may either toggle input between themselves using
   their TOGGLE_INPUT hot-keys, or may both type simultanously if the
   PSIMUL qualifier (or default) is in effect for the permitted
   watcher. (See also similar data for NOBEEP under /PNOBEEP.)

   Once granted, PERMIT_INPUT can be revoked again at any time by
   issuing another PERMIT_INPUT. (The PERMIT_INPUT key toggles
   PERMIT_INPUT on and back off.)

   A PERMIT_INPUT granted by the user being watched is also revoked
   whenever the primary watcher (if any) toggles input.

   Likewise, a PERMIT_INPUT granted by a primary watcher is revoked
   whenever the user being watched toggles input.

   Thus input-ability gained through PERMIT_INPUT/REQUEST_INPUT is
   very temporary.

   The logical USER$PERMIT_INPUT specifies the default hot-key value
   for use when being watched.

   Note that PERMIT_INPUT and REQUEST_INPUT may be used to temporarily
   grant input-ability to a watcher who otherwise would not be able to
   gain keyboard control due to keyboard-control licensing-option
   or ALLOW-command restrictions.

1.1.2.13    /QUOTE

   /QUOTE = "hot-key-defintion"

   Defines a hot-key sequence for use while being watched which, when
   recognized, tells PEEK that the user's next keystroke is NOT to be
   interpreted as a PEEK hot-key, but is to be passed through to
   the user's terminal instead.

   This allows the user to press the QUOTE hot-key and follow it with
   some other PEEK hot-key which he wishes to pass to his running
   program as input without it being intercepted by PEEK. (Whether or
   not it is passed to the program is still controlled by the
   /TOGGLE_INPUT sequence, unless SIMULTANEOUS_INPUT is in effect.
   See the PEEK Commands ALLOW Subtopic: /TOGGLE_INPUT.)

   The QUOTE hot-key sequence should be entered by the user immediately
   before a hot-key keystroke which he wishes to pass through to his
   terminal.

   The default value for ALLOW/QUOTE is taken from the logical
   USER$QUOTE, usually defined system-wide by PEEK_DEFAULTS.COM.

   Example:

         $ PEEK/ALLOW/QUOTE="<F7>"/BEEP_TERMINAL="<F6>" USER1
     or
         $ DEFINE USER$QUOTE "<F7>"
         $ DEFINE USER$BEEP_TERMINAL "<F6>"
         $ PEEK/ALLOW USER1

   In either case, if the watched user presses F6, the bell will be rung
   on the watcher's terminal. However, if he presses F7 followed by F6,
   then the F6 sequence will be passed to the user's process (if the
   user currently has keyboard control).

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

1.1.2.14    /SINGLE_WINDOW

   AXP-Only...

   /[NO]SINGLE_WINDOW

   Used with NDC's MultiSessions product on AXP to determines whether
   the ALLOW command applies to the MS Server of the process which
   issues the ALLOW command, or to the individual MultiSessions NDC-
   terminal windows from which the command is issued.

   Use ALLOW /NOSINGLE_WINDOW to allow someone to watch your MS Server
   process. This allows the watcher to follow you as you switch between
   individual NDC-terminal windows.

   Use ALLOW /SINGLE_WINDOW to allow someone to watch only the single
   NDC-terminal window from which you issue this command. The watcher
   will need to use /SINGLE_WINDOW on his WATCH command.

   /SINGLE_WINDOW is synonymous with /BACKGROUND and /WINDOW.

   The default value for an ALLOW command is determined by the logical
   USER$BACKGROUND usually defined by PEEK_DEFAULTS.COM. You can
   override the default by using this command qualifier.

   Examples:

   $ PEEK/ALLOW/SINGLE_WINDOW JOE    ! Allow JOE to watch only the
                                     ! NDC-terminal window from which
                                     ! this ALLOW command is issued.
   $ PEEK/ALLOW/NOSINGLE_WINDOW JOE  ! Allow JOE to watch your MS
                                     ! Server process, following you
                                     ! as you switch between NDC windows.

1.1.2.15    /TOGGLE_INPUT

   /TOGGLE_INPUT = "hot-key-defintion"
   /NOTOGGLE_INPUT

   Defines a hot-key sequence for use while being watched which, when
   pressed, switches control of the user's keyboard between the
   watcher and the user.

   If a watcher has taken control of the user's keyboard with PEEK,
   then when this hot-key is pressed by the user, it returns
   control of his keyboard back to him/her.

   The default value for this hot-key is taken from the logical
   USER$TOGGLE_INPUT, usually defined by PEEK_DFAULTS.COM.

   If SIMULTANEOUS_INPUT is in effect, both the watcher and the user
   will be able to provide input for the user at the same time.
   Pressing the TOGGLE_INPUT hot-key has no effect in this case.

   If this hot-key is NOT defined (either on the command line or
   as a logical name) then the user will not be able to regain
   keyboard control once it has been taken over by a watcher.

     NOTE:  There is a licensing option which will prevent the watcher
     from ever providing input to the user's terminal. This is for use
     in banking and other high-security environments. If the
     TOGGLE_INPUT feature appears not to work at your site, you
     should check to see if your license specifies NOKB_CONTROL. Use
     the $ PEEK/SHOW LICENSE command to check your license options.

   The remainder of this section will assume that SIMULTANEOUS_INPUT
   is not in effect.

   When a watcher first begins watching someone, the watcher is not
   allowed to enter input for the user's process. If he types anything
   (other than one of his defined hot-key sequences) PEEK throws away
   the watcher's input and rings the bell on his terminal to remind
   him that he does not currently have keyboard control.

   The watcher may press his TOGGLE_INPUT hot-key to swap keyboard
   control, taking it away from the user being watched. At this point,
   the bell on the terminal of the user being watched will ring if he
   attempts to type anything other than his defined hot-key sequences.

   The user being watched may then press his own TOGGLE_INPUT hot-key
   sequence to get control of his keyboard back from the watcher.

   For example, J_DOE issues the command:

         $ PEEK/ALLOW/TOGGLE_INPUT="<F10>" USER1

   After this ALLOW command is issued, USER1 can watch J_DOE with PEEK.

   While watching J_DOE, USER1 can press his hot-key to take over
   keyboard control from J_DOE. If J_DOE then tries to type, his
   terminal bell will just ring to inform him that USER1 currently
   has keyboard control.

   J_DOE can then press his F10 key to regain control of his keyboard.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

   The /TOGGLE_INPUT command qualifier may also be negated. This allows
   one to override a default TOGGLE_INPUT definition which has been
   placed in a logical name table.

   When specified as PEEK/ALLOW/NOTOGGLE_INPUT, this tells PEEK no
   hot-key should be defined to allow the user to toggle input control
   while being watched.

   /NOTOGGLE_INPUT is equivalent to specifying /TOGGLE_INPUT="" (null
   string).

   NOTE: The ALLOW/NOTOGGLE_INPUT qualifier prevents a user who issues
         the command containing it from toggling keyboard input. The
         ALLOW/NOKB_CONTROL qualifier refers to whether an ALLOWed
         watcher may take over control of the keyboard of the user
         being watched.

1.1.2.16    /WINDOW

   AXP-Only...

   /[NO]WINDOW

   Synonymous with the /BACKGROUND and /SINGLE_WINDOW qualifiers. See
   the PEEK Commands ALLOW Subtopic: /SINGLE_WINDOW.

1.2  –  ATTACH

   PEEK> ATTACH process_name
   PEEK> ATTACH/IDENTIFICATION=nnn

   Used from the PEEK> prompt, the ATTACH subcommand allows one to attach
   back to another process in one's job, just as with the DCL ATTACH
   command.

   You must specify either the process name to attach to, or else you can
   provide the process ID to attach to with the /IDENTIFICATION=nnn syntax.

   Example:

   PEEK> ATTACH JBREWER       or PEEK> ATTACH/IDENTIFICATION=6D

1.3  –  DISALLOW

   $ PEEK /DISALLOW

   This subcommand performs the following functions:

    1.  Lets no other non-privileged users watch your terminal by
        revoking all permission to watch granted through previous
        PEEK/ALLOW commands.

    2.  Any user currently watching with PEEK is forced to stop watching.

    3.  If any hot-keys were defined with a previous PEEK/ALLOW
        command (as displayed by $ PEEK/SHOW KEYS), then these hot-key
        defintions may also be erased, depending on the /KEYS_ERASE
        value currently in effect.

   Format:
        $ PEEK/DISALLOW          $ PEEK
                                 PEEK> DISALLOW

1.3.1  –  Qualifiers

1.3.1.1    /BACKGROUND

   AXP Only...

   /[NO]BACKGROUND

   Synonymous with the /SINGLE_WINDOW and /WINDOW qualifiers. See
   the PEEK Commands DISALLOW Subtopic: /SINGLE_WINDOW.

1.3.1.2    /KEYS_ERASE

   /[NO]KEYS_ERASE

   Controls whether any existing hot-key definitions are also erased as
   part of a DISALLOW command.

   Example: $ PEEK/DISALLOW/NOKEYS_ERASE

   All previously granted PEEK/ALLOW permissions are revoked, but any
   hot-keys defined via previous PEEK/ALLOW commands are retained.

   The default value is taken from the logical USER$KEYS_ERASE, usually
   defined system-wide by PEEK_DEFAULTS.COM.

1.3.1.3    /SINGLE_WINDOW

   AXP-Only...

   /[NO]SINGLE_WINDOW

   Used with NDC's MultiSessions product on AXP to determines whether
   the DISALLOW command applies to the MS Server of the process which
   issues the DISALLOW command, or to the individual MultiSessions
   NDC-terminal windows from which the command is issued.

   Use DISALLOW/NOSINGLE_WINDOW to disallow someone to watch your MS
   Server process. This disallows the watcher from follow you as you
   switch between individual NDC-terminal windows.

   Use DISALLOW/SINGLE_WINDOW to disallow someone from watching only
   the single NDC-terminal window from which you issue the command.

   /SINGLE_WINDOW is synonymous with /BACKGROUND and /WINDOW.

   The default value for a DISALLOW command is determined by the
   logical USER$BACKGROUND usually defined by PEEK_DEFAULTS.COM. You
   can override the default by using this command qualifier.

   Examples:

   $ PEEK/DISALLOW/SINGLE_WINDOW   ! Disallow all prior ALLOW
                                   ! permissions granted for watching
                                   ! your single NDC-terminal window
                                   ! from which this DISALLOW command
                                   ! is issued.

   $ PEEK/DISALLOW/NOSINGLE_WINDOW ! Disallow all prior ALLOW
                                   ! permissions granted for watching
                                   ! your MS Server process, and thus
                                   ! from following you as you switch
                                   ! between NDC windows.

1.3.1.4    /WINDOW

   AXP Only...

   /[NO]WINDOW

   Synonymous with the /BACKGROUND and /SINGLE_WINDOW qualifiers. See the
   PEEK Commands DISALLOW Subtopic: /SINGLE_WINDOW.

1.4  –  EXIT

   PEEK> EXIT

   The EXIT command is used to exit back to DCL from the interactive
   command-prompting mode of PEEK.

1.5  –  FORMAT

   $ PEEK/FORMAT in_file out_file      PEEK> FORMAT in_file out_file

   The PEEK/FORMAT command may be used to convert the format of log
   files so that they may be more easily displayed or printed.

   The Peek/Spy FORMAT subcommand converts a log file containing
   terminal-control sequences (which might otherwise be difficult
   to display, print or analyze) into distinct pages of plain-text
   output, It also separates out redundant output (e.g., when a
   later output segment overlays an earlier output segment).

   Example:

    $ PEEK /USER=SMITH /LOG=SMITH.LOG   ! Make Peek log file.
    $! Watch SMITH for a while, then exit from PEEK.
    $ PEEK /FORMAT SMITH.LOG SMITH.FMT  ! Format log file.

   The output file (SMITH.FMT) will contain screens which are in
   a plain-text sequential format. This is useful for typing,
   printing, or searching.

   Each output screen is a series of 24 lines (by default, or as
   specified by /PAGE=n). The initial output-screen width can be
   specified with /WIDTH=n (the default is 80 columns).

   The actions of, and some qualfiers for, the FORMAT subcommand
   differ for AXP and VAX. See the PEEK Commands FORMAT Subtopics:
   AXP-Only and VAX-Only.

1.5.1  –  Overview

   There is an inherent problem in creating an ASCII-stream log file of
   terminal output, whether it is created by PEEK/LOG, SET HOST/LOG or
   KERMIT's LOG SESSION command, etc.

   The problem is that records in a stream output file either have an
   arbitrary length (as do those made by KERMIT) or no maximum length
   at all. In the case where an arbitrary length is imposed on the log
   file, you will see extra carriage-returns embedded in the file when
   it is typed. In the case of PEEK, which does NOT arbitrarily end a
   line after 256 bytes (or some such size), the TYPE command, EDT,
   TPU, etc., all have varying degrees of success in displaying the
   file's contents.

   VMS's TYPE command will usually abort if you attempt to type a
   file which has records longer than 2048 bytes. EDT and TPU have
   similar record-length limitations.

   Thus we have added a format command which will process an arbitrary
   sequence of text and escape and control sequences into a series of
   output screens.

1.5.2  –  AXP-Only

   With PEEK/FORMAT on AXP, a full, new, output screen is appended
   to the formatted output file whenever any one of the following
   conditions occurs:

     1.  A clear-screen sequence in found in the input file.
     2.  A selective-erase sequence in found in the input file.
     3.  The screen is cleared because the screen width is changed.
     4.  Enough lines are scrolled on the screen that some are about
         to be lost off of the top or bottom of the screen.

   The output-file format may be varied to take advantage of different
   printer formats. The default output format is plain text, but other
   formats are available through the /PRINTER_TYPE=keyword qualifier.

   The following PRINTER_TYPE keywords are currently defined for AXP:

       FILE        - For plain text into file (this is the default).
       VT100       - For paged output to a VTxxx type terminal.

   The output file will have form-feed characters inserted at the page
   breaks.

1.5.2.1  –  Qualifiers

1.5.2.1.1    /WIDTH

   /WIDTH = page_width

   Used to specify the initial page width.

   If /WIDTH is not specified, the default is 80 columns.

   If /WIDTH is specified without a value, the width of the current
   terminal is used.

1.5.3  –  VAX-Only

   With PEEK/FORMAT on VAX, a full, new, output screen is appended
   to the formatted output file whenever any one of the following
   conditions occurs:

     1.  A clear-screen sequence in found in the input file.
     2.  A selective-erase sequence in found in the input file.
     3.  The screen is cleared because the screen width is changed.
     4.  Enough lines are scrolled on the screen that some are about
         to be lost off of the top or bottom of the screen.
     5.  /CURSOR_FLUSH was specified as a negative number and the
         cursor moves up more than the specified number of lines.
     6.  /CURSOR_FLUSH was specified as a positive number and the
         cursor is positioned to the specified line number.

   These latter two options can be useful for formatting output from
   programs which don't erase the screen, but just re-position the
   cursor and overwrite existing text.

   The output file format may be varied to take advantage of several
   different printer formats. The default output format is plain text,
   but other formats are available which will display bolded and
   underlined sequences as they originally appeared in the file.

   The following PRINTER_TYPE keywords are currently defined on VAX
   for use with the /PRINTER_TYPE=keyword qualifier:

      FILE        - For plain text into file (this is the default).
      VT100       - For paged output to a VTxxx type terminal.
      DUMB_BS     - Overprint BOLD & underline using backspace.
      DUMB_CR     - Overprint BOLD & underline using carriage-returns.
      LA100, LA120, LA180, LA210, LA50, LA75, LN03,
      VT200, VT300, VT400

   The output file will have form-feed characters inserted at the page
   breaks.

   By default these form-feeds are inserted on a separate line, but
   one can get the form-feeds appended to the last line of text on a
   page by using the /[NO]CONTINUOUS_PAGES qualifier. This could be
   useful when one wants to use all lines of a page, but the form-
   feed on a separate line would cause a page to be skipped between
   each page of text.

1.5.3.1  –  Qualifiers

1.5.3.1.1    /CONTINUOUS_PAGES

   /[NO]CONTINUOUS_PAGES

   Specify /CONTINUOUS_PAGES if you want pages separated by a form
   feed appended to the end of the last line of the page. This is
   useful when one wants to use all lines of a page, where the
   form-feed on a separate line could cause a page to be skipped
   between each page of text.

   Specify /NOCONTINUOUS_PAGES if you want pages separated by a
   form feed which is on a line by itself. This is the default.

1.5.3.1.2    /CURSOR_FLUSH

   /CURSOR_FLUSH=n

   Specify a line number which, if the cursor is positioned back
   to that line after being on a different line, the current
   screen contents will be flushed to the output file.

   This is useful for formatting screens which display data over
   the top of prior data, rather than clearing the screen before
   displaying the new data.

   The default value is zero. This means the cursor position
   is ignored.

   If specified as a negative number, this indicates that, if the
   cursor moves up that number of lines, the current screen
   contents will be flushed to the output file.

   Example:

     $ KERMIT                           ! Start program.
     Kermit-32> LOG SESSION PRICES.LOG  ! Start log file.
     Kermit-32> CONNECT TXA6:           ! Connect to modem line.
     ATDT-1-800-234-1998                ! Dial DEC's store.
     etc.
     $ PEEK /FORMAT PRICES.LOG PRICES.LIS /CURSOR_FLUSH=3

   When DEC's Electronic Store is accessed to look up prices,
   it positions to line 3, outputs a line of price information,
   then positions to line 4, etc., until the screen is full.

   When you tell it to display the next screen, it repeats this
   process. Using /CURSOR_FLUSH=3 tells the FORMAT command to
   output the prior screen before figuring out what the next
   screen will be.

1.5.3.1.3    /FORM_FEED

   /[NO]FORM_FEED

   Specify /FORM_FEED if you wish to have output pages separated
   by a form feed character. This is the default.

   Specify /NOFORM_FEED if you do not wish to have output pages
   separated by a form feed character.

1.5.3.1.4    /RECORD_END

   /[NO]RECORD_END

   PEEK/FORMAT tries to intelligently cope with log files which
   have overly-long lines which have been arbitrary split into
   more than one log-file record. This is most commonly
   encountered with Kermit log files, as covered in the
   PEEK Commands FORMAT Subtopic: Overview.

   The FORMAT /RECORD_END qualifier specifies that newlines
   should be inserted between records in the input file.

   This is the default for all input files, except those with
   variable-length, maximum 256-byte records and CR carriage-
   control. Kermit log files have this latter file format. For
   such files only, the default is /NORECORD_END.

   Specifying /NORECORD_END directs the FORMAT command not to
   insert a newline between records if the previous line ends at
   or before the screen's right margin.

   This commonly has the effect of concatenating all records in
   the input file into one continuous stream of input characters,
   without the FORMAT command adding any newlines.

   The presumption here is that the log-file contains in it the
   needed carriage-control characters, and none need to be added
   at the end of each log-file record.

1.5.4  –  Qualifiers

1.5.4.1    /PAGE

   /PAGE = page_length

   Specify the height of the screen. This value is used to determine
   where to insert form feeds in the output file.

   The default value if /PAGE is not specified is 24 lines.

   If /PAGE is specified without a value, the value defaults to the
   length of the current terminal.

   This qualfier should be specified if you are using a 36 or 48 line
   screen on a VT420 or other terminal.

1.5.4.2    /PRINTER_TYPE

   /PRINTER_TYPE=keyword

   /PRINTER_TYPE is used to specify the printer type.

   The default PRINTER_TYPE is FILE. This produces a plain-text
   output file with all terminal-control sequences removed.

   PRINTER_TYPEs available differ for AXP and VAX. for details,
   see the PEEK Commands FORMAT Subtopics: AXP-Only and VAX-Only.

1.5.4.3    /SCREEN_SIZE

   /SCREEN_SIZE = page_length

   Synonymous for /PAGE. See PEEK Commands FORMAT Subtopic: /PAGE.

1.6  –  HELP

   $ PEEK /HELP [topic] [subtopic]      PEEK> HELP [topic] [subtopic]

   Displays on-line help on Peek/Spy usage.

   The help topic and subtopic specify aspects of Peek/Spy for which
   you want further information. You may use the standard VMS wildcard
   characters * and % (either by themselves or within a topic or subtopic).

1.7  –  LICENSE

   $ PEEK /LICENSE

   When you put a new version of a licensed NDC product on your system,
   you will be allowed to demo it for a period of time, after which the
   product will only continue to work if you are under support or make
   arrangements with NDC for an extension of the demo. (If you received
   the product through an NDC distributor then they will be able to help
   you with licensing.)

   The PEEK/LICENSE command is used when communicating with NDC
   concerning your license. NDC can give out license keys to extend
   demos or record support arrangements.

   The PEEK/LICENSE command gives you a license key which you pass on
   to NDC. NDC then gives you back a responding key which you enter,
   updating the NDC license database on your system for the product.

   The LMF$PEEK.LDB file in PEEK$LOCATION should not be deleted from your
   system. If it is, then you will need to get a license key from NDC in
   order to continue to use the product.

   If you change the PEEK$LOCATION directory on your system, then in
   order to continue to use the product, you will also need to rename
   the LMF$PEEK.LDB file into the new directory. (If you are not demoing,
   then you may alternately copy the file to the new directory, instead
   of renaming it there.)

   You must have SYSPRV as an authorized privilege to use the license
   command.

   The license command first asks you to enter your exact company name.

   The company name should be entered as you want it to display in the
   license message which goes to the terminal when running the product.
   The name, including all spacing and punctuation, must be communicated
   to NDC exactly or the license key will not be accepted. Once a company
   name has been exchanged with NDC, the company name cannot thereafter
   be changed without first consulting with NDC.

   After entering the company name, you will be given a license key to
   transmit to NDC. It should be communicated exactly, including the
   encoding-type, nodename, etc, as directed on the license screen.

   If you are not communicating the license key to NDC immediately,
   then you can exit the license screen by entering a Ctrl-Z at the
   prompt. You may, alternately, create the file KEY.LIS, containing
   the necessary licensing information for NDC, by pressing the PF4 key,
   instead of Ctrl-Z.

   When you receive a responding key from NDC, you should re-enter the
   company name exactly as before (if you have exited from the license
   screen meanwhile). Then enter the responding key, exactly as given
   by NDC. You will get a key-accepted message if all goes well.

   If there has been any miscommunication of the company name, license
   key or encoding type, or the responding key, then you will get an
   error message and will have to try again.

1.8  –  NODE_NAME_CHANGE

   $ PEEK /NODE_NAME_CHANGE

   If you should change the nodename of a node which is licensed for an
   NDC product (something we expect would be a very rare occurence) the
   product will no longer work on that node unless you then use the
   NODE_NAME_CHANGE command while running the product from that node. This
   records the nodename change in the NDC license database on your system.

   The NODE_NAME_CHANGE command cannot be used to put the product onto a
   different node than the one originally licensed.

   If you change a nodename and do not use this command, you will later
   receive a message telling you that you are running a demo version of
   the software and that it is about to expire.

   The NODE_NAME_CHANGE command will prompt you for the old name for the
   node you are running from, and will change the license record for the
   current node from the old name you give to the current (new) name for
   that node.

   The product may not be in use on the system when this command is used.
   SYSPRV as an authorized privilege is required to use the
   NODE_NAME_CHANGE command.

1.9  –  NOSAVE_SCREEN

   $ PEEK/NOSAVE_SCREEN                PEEK> NOSAVE_SCREEN

   The PEEK/NOSAVE_SCREEN subcommand is used on AXP to end
   screen-saving for a terminal.

   On AXP, terminals with the screen-saver feature turned on provide
   a full initial-screen-contents display for the watcher when they
   are watched with Peek/Spy.

   NOSAVE_SCREEN also ends any terminal-logging which is in progress.

   For more information, see the PEEK Commands Subtopic: SAVE_SCREEN.

1.10  –  PEEK

   PEEK> PEEK [/qualifier=] target_list [/qualifiers]

   (PEEK-Only, not for use with SPY.)

   The PEEK subcommand may be used to watch someone with PEEK (not SPY)
   when in interactive command-prompting mode.

   It is synonymous with the WATCH command.

   Examples:

   PEEK> PEEK JOE              ! Watch process JOE.
   PEEK> PEEK/TERMINAL=LTA5723 ! Watch terminal LTA5723.
   PEEK> PEEK/USER=JBREWER     ! Watch user JBREWER.

   For more information and a full list of PEEK command qualifiers,
   see the top-level PEEK Subtopic: Watching.

1.11  –  QUIT

   PEEK> QUIT

   The QUIT subcommand is used to exit back to DCL from the
   interactive command-prompting mode of PEEK.

   It is synonymous with the EXIT subcommand.

   Example:     $ PEEK
                PEEK> QUIT
                $

1.12  –  RT_ENABLE

   VAX Only

   $ PEEK/RT_ENABLE      ! VAX Only

   When an RTA unit logs in it must issue a PEEK/RT_ENABLE command before
   it can be watched with Peek/Spy. (This command must also be used before
   a VAX RTA can start NDC's VAX MultiSessions screen-saver which is used
   for the Peek/Spy initial screen refresh on VAX.)

   PEEK/RT_ENABLE enables watching of the single RTA terminal from which
   the command is issued, without affecting other RTAs on the system.

   Enabling watching of RTAs on AXP uses PEEK/SAVE_SCREEN instead of
   PEEK/RT_ENABLE.

1.13  –  SAVE_SCREEN

   $ PEEK/SAVE_SCREEN                PEEK> SAVE_SCREEN

   The PEEK/SAVE_SCREEN subcommand is used on AXP to start the
   screen-saver feature for a terminal. On AXP, SAVE_SCREEN also
   enables watching of RTA terminals.

   On AXP, terminals with the screen-saver feature turned on provide a
   full initial-screen-contents display for the watcher when they are
   watched with Peek/Spy.

   SAVE_SCREEN is also used on both AXP and VAX to start terminal-
   logging - the logging to a disk file of all the output sent to the
   terminal. See the PEEK Commands SAVE_SCREEN Subtopic: /OUTPUT_LOG_FILE.

   Examples for AXP:

   $ PEEK /SAVE_SCREEN         ! Start screen-saving for SYS$COMMAND.
   $ SPY  /SAVE_SCREEN LTA5059 ! Start screen-saving for LTA5059.

   Example for AXP or VAX:

   $ PEEK
   PEEK> SAVE_SCREEN/LOG       ! Start screen-saving with a log file.

1.13.1  –  Description

   Screen-saving begins on AXP after a SAVE_SCREEN command has been
   done.

   (On VAX, screen-saving is begun by turning on NDC's MultiSessions.)

   On AXP, RTA terminals may ONLY be watched after they've done a
   PEEK/SAVE_SCREEN. (The command on VAX is PEEK/RT_ENABLE.)

   On AXP it is wise, therefore, to do a PEEK/SAVE_SCREEN ahead of
   time, such as from SYLOGIN.COM or LOGIN.COM, so enough time
   elapses before watching begins for a full screen to be saved for
   display when watching begins.

   On AXP, if screen-saving has not yet been started when watching
   begins, then PEEK automatically turns on the screen-saver (this
   does not apply to RTA terminals which must issue a
   PEEK/SAVE_SCREEN on AXP in order to be watched with Peek/Spy), but
   in this case there hasn't yet been enough time to save a full
   screen, so only a partial screen is initially displayed for the
   watcher, or even no screen at all if nothing has been sent to the
   terminal since screen-saving started.

   For VAX, terminal-logging is now begun by using PEEK/SAVE_SCREEN/LOG.

   Screen-saving and any terminal-logging are both turned off by the
   NOSAVE_SCREEN command. Terminal-logging alone is turned off with
   the SAVE_SCREEN/CLOSE_FILE command, without also turning off
   screen-saving.

   If a screen-saver is on without a log file, then a log file can
   be started using the SAVE_SCREEN/LOG[=file] command.

   When logging is in progress, a new log file can be started with
   PEEK/SAVE_SCREEN/LOG/NEW_FILE. This closes any existing log file
   and starts terminal-logging to a new log file.

1.13.2  –  Parameters

   AXP-Only...

   For the SPY program only, you can specify the name of a terminal
   other than your own for which the screen-saver is to be turned on.

   You cannot, however, use SPY to start screen-saving with logging
   for some other terminal than your own. Terminal-logging can only
   be started from the terminal itself which is to be logged. (You
   can, of course, watch the terminal with $ SPY/LOG and make a log
   file that way.)

   Example:

   $ SPY /SAVE_SCREEN LTA5059 ! Start screen-saving for LTA5059.

   You can use the above command to start up screen-saving for
   LTA5059 before watching it, so you will have an initial full-
   screen display available when you do start watching LTA5059.

1.13.3  –  Qualifiers

1.13.3.1    /CLOSE_FILE

   $ PEEK/SAVE_SCREEN /CLOSE_FILE

   The /CLOSE_FILE qualifier closes any existing log file turned on with
   PEEK/SAVE_SCREEN/LOG, without interrupting the ongoing screen-saving.

   This means a watcher will still be able to get an initial full-screen
   display when starting to watch the terminal. Only any on-going
   terminal-logging is ended with SAVE_SCREEN/CLOSE_FILE.

   Example: PEEK> SAVE_SCREEN/CLOSE_FILE    ! Close current log file.

1.13.3.2    /LOG_FILE

   $ PEEK/SAVE_SCREEN /LOG_FILE [=file_spec]

   This a synonymous with the /OUTPUT_LOG_FILE qualifier.

   See the PEEK Commands SAVE_SCREEN Subtopic: /OUTPUT_LOG_FILE.

1.13.3.3    /MAX_REOPEN

   $ PEEK/SAVE_SCREEN/LOG/REOPEN /MAX_REOPEN = blocks
                                 /NOMAX_REOPEN

   Specifies the approximate maximum number of blocks to which a
   terminal-logging file may grow before a new version of the log file
   is started, when /REOPEN is in effect.

   Use /NOMAX_REOPEN to specify that any default /MAX_REOPEN value
   should be ignored.

   The default value for /MAX_REOPEN is taken from the logical
   SAVE$MAX_REOPEN, usually defined by PEEK_DEFAULTS.COM.

   Example: $ PEEK/SAVE_SCREEN/LOG/REOPEN/MAX_REOPEN=100

   For more information, see the PEEK Commands SAVE_SCREEN Subtopic:
   /REOPEN.

1.13.3.4    /MIN_REOPEN

   $ PEEK/SAVE_SCREEN/LOG/REOPEN /MIN_REOPEN = blocks
                                 /NOMIN_REOPEN

   Specifies the minimum number of blocks to which a terminal-
   logging file must grow before a new version of the log file is
   started, when /REOPEN is in effect.

   Use /NOMIN_REOPEN to specify that any default /MIN_REOPEN value
   should be ignored.

   The default value for /MIN_REOPEN is taken from the logical
   SAVE$MIN_REOPEN, usually defined by PEEK_DEFAULTS.COM.

   Example: $ PEEK/SAVE_SCREEN/LOG/REOPEN/MIN_REOPEN=10

   /MIN_REOPEN is ignored for reopens done as a result of
   a /TIME_OF_DAY specification.

   For more information, see the PEEK Commands SAVE_SCREEN Subtopic:
   /REOPEN

1.13.3.5    /NEW_FILE

   $ PEEK/SAVE_SCREEN/LOG /[NO]NEW_FILE

   Used to specify that a new terminal-logging file should be started.
   Any current terminal-logging file is closed.

   Example:

   $ PEEK/SAVE_SCREEN/LOG=LOG.LOG     ! Start logging to LOG.LOG.

   $ PEEK/SAVE_SCREEN/LOG=NEWLOG.LOG/NEW_FILE
                                      ! Close LOG.LOG and start
                                      ! logging to NEWLOG.LOG.

   The new file will contain the full initial contents of the screen
   at the time the command is executed.

1.13.3.6    /OUTPUT_LOG_FILE

   $ PEEK/SAVE_SCREEN /OUTPUT_LOG_FILE [=file_spec]

   SAVE_SCREEN/OUTPUT_LOG_FILE[=file] is used to create a log file
   containing everything output to the terminal while the screen-
   saving is in effect.

   The default filespec is taken from the logical SAVE$OUTPUT_LOG_FILE.
   This logical may be defined system-wide by PEEK_DEFAULTS.COM, or it
   may be defined in any of the logical-name tables specified in
   LNM$PEEK_TABLE_SEARCH_LIST, which is defined by PEEK_DEFAULTS.COM.
   See the top-level PEEK Subtopic: Defaults.

   If this logical is not defined and if /OUTPUT_LOG_FILE is specified
   without the optional file-spec, then PEEK will generate a log file
   in the current default directory using a default log-file name of:

       PEEK_TRMLOG_username_terminalname.LOG

   If a log file is already being made, then it can be closed with a
   $ PEEK/SAVE_SCREEN/CLOSE_FILE command.

   To close the current log file and start logging to a new log file
   use a $ PEEK/SAVE_SCREEN/LOG/NEW_FILE command.

   The /REOPEN qualifier also affects PEEK/SAVE_SCREEN/LOG.

   Terminal logging with /SAVE_SCREEN/LOG is terminated by a
   PEEK/SAVE_SCREEN/CLOSE_FILE command, or a PEEK/NOSAVE_SCREEN command.

   Example:

        $ PEEK/SAVE /OUTPUT=SAVE_OUTPUT

   Note that /LOG and /OUTPUT_LOG are synonymous.

1.13.3.7    /PERMANENT

   $ PEEK/SAVE_SCREEN /PERMANENT
                      /NOPERMANENT  (default)

   Used to specify that the screen-saving (on AXP) or terminal-logging
   (on AXP or VAX) cannot be shut off for the terminal concerned.

   Example: $ PEEK/SAVE_SCREEN/PERMANENT       ! (AXP-Only)

   Also applies to terminal-logging on both VAX and AXP. E.g.

     PEEK> SAVE_SCREEN /LOG=PERMANENT.LOG /PERMANENT

   The PERMANENT qualifier disallows turning off screen-saving with the
   NOSAVE_SCREEN command. If there is a log file for the screen-saving,
   then the logging cannot be turned off if /PERMANENT is used.

   A permanent screen-saver only goes away when the terminal itself goes
   away (for LTAs etc which are deleted when the user logs off) or when
   the system is shut down (for permanent terminals such as TTAs, etc.).

   The /PERMANENT qualifier should be used with EXTREME CAUTION with
   logging on direct-connect terminal such as TTA's, TXA's or OPA's
   since with these terminals the log file will just continue to grow
   and can't be turned off without rebooting the system.

   /PERMANENT is mainly intended for security use on such things as
   dial-up lines, where a log file of the terminal output is desired
   and the system manager doesn't want the user to be able to stop
   the logging by doing a NOSAVE_SCREEN or SAVE/CLOSE_FILE command.

1.13.3.8    /REOPEN

   $ PEEK/SAVE_SCREEN/LOG /[NO]REOPEN

   Used to specify that new versions of a terminal-logging file
   should [not] be periodically opened.

   Example: $ PEEK/SAVE_SCREEN/LOG/REOPEN

   /REOPEN re-opens a new version of the log file whenever it
   reaches a certain number of disk blocks, or whenever a certain
   time of day or span of time has elapsed, providing at least a certain
   minimum number of blocks have been written to the file.

   The maximum and minimum blocks and the time of day and time span are
   specified using the /MAX_REOPEN, /MIN_REOPEN, /SPAN and /TIME_OF_DAY
   qualifiers, or by defaults for these which are specified in logical
   names.

   Each reopened log files has a copy of the initial full-screen at the
   time the log file was reopened.

   The default /REOPEN value is taken from the logical SAVE$REOPEN.

   /NOREOPEN is used on the command line to override a default
   /REOPEN value.

   (Note: /APPEND is ignored for PEEK/SAVE/LOG when /REOPEN is
   in effect.)

1.13.3.9    /SPAN

   $ PEEK/SAVE_SCREEN/LOG/REOPEN /SPAN = minutes
                                 /NOSPAN

   Specifies the approximate time period which should elapse before
   a new version of a terminal-logging file should be started, when
   /REOPEN is in effect.

   Use /NOSPAN to specify that any default /SPAN value should
   be ignored.

   The default value for this qualifier is taken from the logical
   name SAVE$SPAN.

   Example: $ PEEK/SAVE_SCREEN/LOG/REOPEN/SPAN=10

   The number of minutes can contain a decimal point. The minimum
   acceptable value is 1 minute.

   For more information, see the PEEK Commands SAVE_SCREEN Subtopic:
   /REOPEN

1.13.3.10    /TIME_OF_DAY

   $ PEEK/SAVE_SCREEN/LOG/REOPEN /TIME_OF_DAY = hh:mm
                                 /NOTIME_OF_DAY

   Specifies the approximate time of day when a new version of a
   terminal-logging file should be started (when /REOPEN is in
   effect).

   Use /NOTIME_OF_DAY to specify that any default /TIME_OF_DAY
   value should be ignored.

   The default value for this qualifier is taken from the logical
   name SAVE$TIME_OF_DAY.

   Example: $ PEEK/SAVE_SCREEN/LOG/REOPEN/TIME_OF_DAY=23:59

   The above command specifies that a new log file version should
   be created at 1 minute before midnight each day.

   Valid values for /TIME_OF_DAY are 00:00 through 23:59.

   Note that all 5 characters of the hh:mm syntax are required
   in all cases. Midnight would be specfied as 00:00. (The
   special value /TIME_OF_DAY=-1 is the equivalent of
   /NOTIME_OF_DAY and causes the qualifier to be ignored.)

   Examples:             The log file will be reopened at:

   /TIME_OF_DAY=00:00    12:00 AM
   /TIME_OF_DAY=00:01	12:01 AM
   /TIME_OF_DAY=01:00 	 1:00 AM
   /TIME_OF_DAY=12:00 	12:00 PM
   /TIME_OF_DAY=14:03	 2:03 PM

   Any /MIN_REOPEN value is ignored when reopening a file at
   the /TIME_OF_DAY specified.

   For more information, see the PEEK Commands SAVE_SCREEN
   Subtopic:

   /REOPEN

1.14  –  SHOW

   $ PEEK /SHOW [ALL] (default)      PEEK> SHOW [ALL] (default)
   $ PEEK /SHOW ALLOWS               PEEK> SHOW ALLOWS
   $ PEEK /SHOW KEYS                 PEEK> SHOW KEYS
   $ PEEK /SHOW LICENSE              PEEK> SHOW LICENSE
   $ PEEK /SHOW PEEK                 PEEK> SHOW PEEK
   $ PEEK /SHOW USERS                PEEK> SHOW USERS
   $ PEEK /SHOW VERSION              PEEK> SHOW VERSION
   $ PEEK /SHOW WATCHER              PEEK> SHOW WATCHER

   Displays PEEK-related information.

1.14.1  –  ALL

   $ PEEK /SHOW [ALL] (default)      PEEK> SHOW [ALL] (default)

   Displays PEEK-related information which includes the version
   of PEEK, licensing information, ALLOW information, and hot-key
   information (hot-keys for use both when being watched and when
   watching another).

   The /SINGLE_WINDOW qualifier is used in conjuction with NDC's
   MultiSessions product to show information for either the MS Server
   process or for just the single NDC-terminal window which issues
   the SHOW command. See the PEEK Commands SHOW Subtopic:
   /SINGLE_WINDOW.

1.14.2  –  ALLOWS

   $ PEEK/SHOW ALLOWS          PEEK> SHOW ALLOWS

   Displays the list of identifiers and usernames which you have
   allowed to watch your process with the ALLOW subcommand. (For
   more information about the PEEK ALLOW subcommand, see the
   top-level PEEK Subtopic: Commands ALLOW.)

   The display also tell you whether or not permission to watch
   was granted on a once-only basis or as many times as desired,
   and whether bypassing output or keyboard control were
   disallowed for the ALLOWed users.

   This command will also display any hot-key sequences which have been
   defined for use while you are being watched by another.

   The /SINGLE_WINDOW qualifier is used in conjuction with NDC's
   MultiSessions product to show information for either the MS Server
   process or for just the single NDC-terminal window which issues
   the SHOW command. See the PEEK Commands SHOW Subtopic:
   /SINGLE_WINDOW.

   Format:

     $ PEEK/SHOW ALLOWS        PEEK> SHOW ALLOWS

1.14.3  –  KEYS

   $ PEEK /SHOW KEYS                 PEEK> SHOW KEYS

   Displays information on the hot-keys which are defined for use
   when being watched and when watching another.

   The /SINGLE_WINDOW qualifier is used in conjuction with NDC's
   MultiSessions product to show information for either the MS Server
   process or for just the single NDC-terminal window which issues
   the SHOW command. See the PEEK Commands SHOW Subtopic:
   /SINGLE_WINDOW.

1.14.4  –  LICENSE

   $ PEEK /SHOW LICENSE              PEEK> SHOW LICENSE

   Displays license information.

1.14.5  –  PEEK

   $ PEEK /SHOW PEEK                 PEEK> SHOW PEEK

   Displays any other nodes in the cluster which have started PEEK.

1.14.6  –  USERS

   $ PEEK /SHOW USERS [node::][spec,spec,...]

   PEEK> SHOW USERS [node::][spec,spec,...]

   Displays data about current users on the system. This helps you more
   easily isolate the users whom you want to watch.

   A parameter, or list of parameters, can be used to qualify which
   users are displayed.

   These parameters take the standard VMS wildcards * and %.

   A nodename can be prefixed before the first user specification in
   the list. In this case, any users on that node matching any of the
   user specifications are displayed. E.g.

     $ PEEK/SHOW USERS ALPHA::SYS,P*USER

   will display any users on node ALPHA that either begin with SYS or
   else start with a 'P' and also contain the string 'USER'.

   (Note that the use of nodenames for the SHOW USERS command differs
   from the use of nodenames in other Peek commands. For SHOW USERS,
   only the first specification in the list may have a nodename
   prepended to it. That nodename applies to all of the subsequent
   user specs in the list.)

   The data shown, and the format of the /SHOW USERS display, are
   user-definable; see the PEEK manual for details on how you can
   customize the /SHOW USERS display to your liking.

   The default format for /SHOW USERS is a look-alike for the VMS
   Version 5.1 DCL SHOW USERS display.

1.14.7  –  VERSION

   $ PEEK /SHOW VERSION              PEEK> SHOW VERSION

   Display the version of PEEK which is currently running.

1.14.8  –  WATCHER

   $ PEEK /SHOW WATCHER              PEEK> SHOW WATCHER

   Displays the hot-keys defined for use when watching another.

1.14.9  –  Qualifiers

1.14.9.1    /BACKGROUND

   AXP Only...

   /[NO]BACKGROUND

   Synonymous with the /SINGLE_WINDOW and /WINDOW qualifiers. See the
   PEEK Commands SHOW Subtopic: /SINGLE_WINDOW.

1.14.9.2    /SINGLE_WINDOW

   AXP-Only...

   /[NO]SINGLE_WINDOW

   Used with NDC's MultiSessions product on AXP to determines whether
   the SHOW command applies to the MS Server of the process which
   issues the SHOW command, or to the individual MultiSessions NDC-
   terminal windows from which the command is issued.

   Use SHOW/NOSINGLE_WINDOW to show the ALLOW and hot-key infomation
   for your MS Server process.

   Use SHOW/SINGLE_WINDOW to show the ALLOW and hot-key information for
   the single NDC-terminal window from which you issue the command.

   /SINGLE_WINDOW is synonymous with /BACKGROUND and /WINDOW.

   The default /SINGLE_WINDOW value for a SHOW command is determined by
   the logical USER$BACKGROUND usually defined by PEEK_DEFAULTS.COM.
   You can override this default by using this command qualifier.

   Examples:

   $ PEEK/SHOW/SINGLE_WINDOW     ! Show ALLOW and hot-key information
                                 ! for the single NDC-terminal window
                                 ! from which this command is issued.
   $ PEEK/SHOW/NOSINGLE_WINDOW   ! Show ALLOW and hot-key information
                                 ! for your MS Server process.

1.14.9.3    /WINDOW

   AXP Only...

   /[NO]WINDOW

   Synonymous with the /BACKGROUND and /SINGLE_WINDOW qualifiers. See
   the PEEK Commands SHOW Subtopic: /SINGLE_WINDOW.

1.15  –  SHUTDOWN

   $ PEEK /SHUTDOWN                  PEEK> SHUTDOWN

   This subcommand is normally only issued from PEEK_SHUTDOWN.COM.

   The subcommand handles part of shutting down Peek/Spy on the system,
   but does not completely shut Peek/Spy down.

   Therefore, PEEK/SHUTDOWN should only normally be done by
   PEEK_SHUTDOWN.COM.

   Doing a PEEK/SHUTDOWN without doing the rest of PEEK_SHUTDOWN.COM can
   leave Peek/Spy in an inoperable state.

1.16  –  SPAWN

   PEEK> SPAWN
   This command can be used from the PEEK> prompt to spawn a subprocess.

   The optional parameter is a command string to be executed by the
   spawned subprocess.

   The SPAWN command also takes the following qualifiers:

    /CARRIAGE_CONTROL  - Controls subprocess prompt string format.
    /CLI               - To specify a command line interpreter
                         other than DCL.
    /INPUT             - Where the subprocess gets its input commands.
    /KEYPAD            - Whether DEFINE/KEY settings are inherited.
    /LOG               - Display process name when re-attaching to process.
    /LOGICAL_NAMES     - Whether logical names are inherited.
    /NOTIFY            - If a message is received when subprocess finishes.
    /OUTPUT            - Where subprocess sends its output.
    /PROCESS           - Name of the subprocess to be created.
    /PROMPT            - The prompt string to use for subprocess.
    /SYMBOLS           - Whether symbol definitions are inherited.
    /WAIT              - Does parent wait for subprocess (default=yes).

   For further details, use VMS's HELP on SPAWN, or see the description of
   LIB$SPAWN in the VAX/VMS Run-Time Library Routines Reference Manual.

   Examples:

     PEEK> SPAWN SHOW TIME
       20-FEB-1992 17:13:04
     %PEEK-I-RETURNED, control returned to process D_STROM
     PEEK> SPAWN
     $ SHOW TIME
       20-FEB-1992 17:13:19
     $ LOG
       Process D_STROM_1 logged out at 20-FEB-1992 17:13:21.54
     %PEEK-I-RETURNED, control returned to process D_STROM
     PEEK>
     PEEK> SPAWN/NOWAIT/INPUT=MGR$:CHECK.COM/OUTPUT=MGR$:CHECK.LOG
     %PEEK-I-SPAWNED, process D_STROM_1 spawned
     PEEK>

1.17  –  SPY

   SPY> SPY [/qualifier=] target_list [/qualifiers]

   (SPY-Only, not for use with PEEK.)

   The SPY subcommand may be used to watch someone with SPY (not PEEK)
   when in interactive command-prompting mode.

   It is synonymous with the WATCH command.

   Examples:

   SPY> SPY JOE              ! Watch process JOE.
   SPY> SPY/TERMINAL=LTA5723 ! Watch terminal LTA5723.
   SPY> SPY/USER=JBREWER     ! Watch user JBREWER.

   For more information and a full list of SPY command qualifiers,
   see the top-level PEEK Subtopic: Watching.

1.18  –  WATCH

   PEEK> WATCH [/qualifier=] target_list [/qualifiers]
   SPY>  WATCH [/qualifier=] target_list [/qualifiers]

   The WATCH command is used to watch someone when in the interactive
   command-prompting mode of Peek/Spy.

   Examples:

   PEEK> WATCH JOE              ! Watch process JOE.
   PEEK> WATCH/TERMINAL=LTA5723 ! Watch terminal LTA5723.
   SPY>  WATCH/USER=JBREWER     ! Watch user JBREWER.

   For more information and a full list of WATCH command qualifiers,
   see the top-level PEEK Subtopic: Watching.

1.19    /COMMAND_MODE

   Command mode allows subcommands to be issued as verbs instead of
   as command qualifiers.

   As shipped, command mode is the default mode used during Peek/Spy
   interactive command prompting, and non-command mode is used for
   single-line DCL Peek/Spy commands.

   As shipped:

     In single-line DCL commands, subcommands are qualifiers:

       $ PEEK /ALLOW PETE      ! Allow PETE to watch you.
       $ PEEK /SHOW  USERS     ! Show users on system.
       $ PEEK JOE              ! Watch process JOE.

     During interactive command-prompting, subcommands are verbs:

       $ PEEK                  ! Enter command-prompting mode.
       PEEK> ALLOW PETE        ! Allow PETE to watch you.
       PEEK> SHOW  USERS       ! Show users on system.
       PEEK> WATCH JOE         ! Watch process JOE.

   The subcommands which are accepted as verbs in command mode are:

   ALLOW, ATTACH, DISALLOW, EXIT, FORMAT, HELP, LICENSE,
   NODE_NAME_CHANGE, NOSAVE_SCREEN, PEEK (for PEEK), QUIT,
   RT_ENABLE (VAX-only), SAVE_SCREEN, SHOW, SHUTDOWN, SPAWN,
   SPY (for SPY), and WATCH.

   When in command mode, you must use the WATCH (or PEEK for Peek,
   or SPY for Spy) verb when you want to watch someone. E.g.

     PEEK> WATCH JOE        ! Not  PEEK> JOE.

   The qualifier form of all the above subcommands is also still accepted
   when in command mode, e.g. "PEEK> /WATCH JOE" is accepted.

1.19.1  –  Disabling Command Mode

   If desired, you can disable command mode, so subcommands must always
   be entered as command qualifiers, even during interacive command
   prompting.

   To disable command mode during Peek/Spy command prompting, define
   the logical name WATCHER$COMMAND_MODE_PROMPT as False.

   This logical name can be defined system-wide by PEEK_DEFAULTS.COM,
   or it can be locally defined in any of the logical-name tables
   specified by LNM$PEEK_TABLE_SEARCH_LIST, which is defined by
   PEEK_DEFAULTS.COM.

   When WATCHER$COMMAND_MODE_PROMPT is FALSE, subcommands must always
   be entered as command qualifiers, even during command prompting.

   Example:  $ PEEK
             PEEK> /ALLOW JOE    ! Not  PEEK> ALLOW JOE
             PEEK> /WATCH *      ! Not  PEEK> WATCH *

1.19.2  –  Forcing Command Mode

   The /COMMAND_MODE qualifier can be used to force command-mode.

   After entering the /COMMAND_MODE qualifier, you will not need to
   use a slash on the command line, but can enter the various
   subcommands as verbs.

   You can force command-mode syntax, even for single-line DCL
   Peek/Spy commands by changing the Peek/Spy foreign command
   defintions to include the /COMMAND_MODE qualifier.

   Change the DCL definitions of the PEEK and SPY symbols from:
   (The _Vx should be replaced with _V5 or _V6 or _V7.)

     $ PEEK :== $ PEEK$LOCATION:PEEK_Vx
     $ SPY  :== $ PEEK$LOCATION:SPY_Vx
   to
     $ PEEK :== $ PEEK$LOCATION:PEEK_Vx/COMMNAD_MODE
     $ SPY  :== $ PEEK$LOCATION:SPY_Vx/COMMAND_MODE

   Once the PEEK and SPY symbols are so defined, Peek/Spy
   subcommands may be used as verbs in single-line DCL commands.

   Example:

         $ PEEK ALLOW JOE     ! Instead of $ PEEK /ALLOW JOE.
         $ PEEK WATCH *       ! Instead of $ PEEK /WATCH *.

   Note that in command mode, the WATCH verb is required.
   Wrong in command mode:

        $ PEEK JOE            ! Not accepted in command mode.

   Right in command mode:

        $ PEEK WATCH JOE      ! WATCH verb is required syntax.

2  –  Watching

   Peek/Spy allows a user to watch another user's screen and
   (optionally) type keyboard input for the user being watched.

   Terminals to be watched may be specified by process-name.
   process-id, terminal-name, or username.

   Nodenames and wildcard characters may be used. (See the PEEK
   Watching Subtopics: Node_Names and Wildcards.)

   Command Format:                      Example:

    $ PEEK process_name_list            $ PEEK PROCESS12,PROCESS3%
    $ PEEK/IDENTIFIER=pid_list          $ PEEK /ID=(12%,5F8,345)
    $ PEEK/TERMINAL=terminal_name_list  $ PEEK /TERM=(LTA1262,TXA*)
    $ PEEK/USERNAME=user_name_list      $ PEEK /USERNAME=(JONES*,BREWERJ)

    $ PEEK                              ! Enter command-prompting mode.
    PEEK> WATCH NODEA::*                ! Watch all processes on NODEA.
    PEEK> WATCH/IDENTIFIER=NODEB::5F8   ! Watch PID 5F8 on NODEB.
    PEEK> WATCH/TERMINAL=*::LTA*        ! Watch all LTA's on all nodes.
    PEEK> WATCH/USERNAME=*::VISITOR_*   ! Watch users VISTOR_* on all nodes.

2.1  –  Description

   Peek/Spy allow one user to watch another user. Anything output to the
   terminal being watched will also be sent to the watcher's terminal.

   The watcher may also optionally enter keyboard input for the user he
   is watching. See the PEEK Watching Subtopic: /TOGGLE_INPUT.

   You may not watch another user unless you have SYSPRV and SECURITY
   privileges, or the system manager has specifically authorized you to
   watch that user, or the user himself has authorized you to watch him
   via the PEEK/ALLOW command (see the top-level PEEK Subtopic:
   Commands ALLOW).

2.2  –  Ending Watching

   To stop watching another terminal and return to the command prompt,
   enter the END_WATCH hot-key sequence.

   The END_WATCH hot-key sequence is displayed briefly on your screen
   just before you start watching someone.

   The END_WATCH hot-key value can be specified using the /END_WATCH
   qualifier on a PEEK, SPY or WATCH command. See the PEEK Watching
   Subtopic: /END_WATCH.

   The default values for hot-keys are taken from logical names. See
   the top-level PEEK Subtopic: Defaults.

   When the END_WATCH hot-key sequence is pressed while watching someone,
   the following message will be displayed on the watcher's terminal:

      %PEEK-I-ENDWATCH, you are no longer watching user <username>

   The following message will also be displayed on the terminal of the
   user who was being watched (if you were watching with PEEK, not SPY).

      %PEEK-I-WATCHEND, user <username> is no longer watching you

   If a list of targets was specified in the PEEK, SPY or WATCH
   command, or if wildcards were used, you can end watching one target
   and start watching the next or previous terminal through use of the
   NEXT or PREVIOUS hot-key sequences. See the PEEK Watching Subtopics:
   /NEXT and /PREVIOUS.

2.3  –  Node Names

   DECnet nodenames may be prefixed to the targets of a PEEK, SPY or
   WATCH command. Peek/Spy will attempt to watch the target on the
   specified DECnet node.

   A nodename may be prefixed to a process name parameter. For example:

     $ PEEK BOSTON::J_DOE.    ! Watch process J_DOE on node BOSTON.

   Nodenames may also be prefixed to process-id or terminal- or user-
   name target specifications. Examples:

   $ PEEK/IDENTIFIER=NODEA::124  ! Watch PID 124 on NODEA.
   $ SPY/TERMINAL=NODEA::LTA*    ! Watch all LTA terminals on NODEA.
   $ PEEK/USERNAME=NODEA::D*     ! Watch all users named D* on NODEA.

   Peek/Spy must be running on the target node, and the PEEK and SPY
   objects/applications must be defined for DECnet on the target
   nodes. See the top-level PEEK Subtopic: Node_Names Set-up.

   Standard VMS % and * wildcards can be used in nodenames providing
   PEEK has been configured to use wildcards in nodenames. See the
   top-level PEEK Subtopic: Node_Names Wildcards.

   Different nodenames can be prepended to each target specification
   in a list. A prepended nodename applies only to the one target
   specification in a list to which it is prepended. For example:

     $ PEEK BOSTON::J_DOE,PHOENIX::B_SMITH,M_JONES

   The above command causes PEEK to attempt to watch the process
   J_DOE on node BOSTON, then the process B_SMITH on node PHOENIX,
   and then the process M_JONES on the current node.

   For more information, see the top-level PEEK Subtopic: Node_Names.

2.4  –  Wildcards

   If wildcards are used, or more than one process name is specified in
   the process-name list, then PEEK will begin watching the terminal
   which is owned by the first process found in the list. If watching of
   this terminal is terminated by the hot-key for NEXT or PREVIOUS then
   Peek will attempt to watch the terminal owned by the next or previous
   process found in the list.

   If the END_WATCH sequence is pressed, or if there is no next or
   previous processes to be watched, PEEK will stop watching.

2.5  –  Parameters

  process-name

   The name of the process which you wish to watch. The process name can
   have from 1 to 15 alphanumeric characters and may contain the standard
   VMS * and % wildcard characters.

   The process-name parameter and the /IDENTIFICATION, /TERMINAL and
   /USERNAME qualifiers are all mutually exclusive.

2.6  –  Qualifiers

2.6.1    /APPEND

   /[NO]APPEND

   This qualifier controls whether a new log file is created or whether
   an existing log file is appended to. The logical WATCHER$APPEND
   specifies the default value for a PEEK, SPY or WATCH command.

   Example:

         $ PEEK JONES /OUTPUT_LOG=JONES.LOG /APPEND
     or
         $ DEFINE WATCHER$APPEND TRUE
         $ PEEK JONES /OUTPUT_LOG=JONES.LOG

   In this example, a process named JONES will be watched, and a log
   file called JONES.LOG will be created if nonexistent, or appended
   to if already extant.

2.6.2    /AXPRTA_WATCHONLY

   AXP-Only...

   It is possible on AXP to watch an RTA which has not done a
   PEEK/SAVE_SCREEN. This is accomplished by using the earlier,
   version-4.4 RTA feature.

   This feature is invoked for watching an unconverted RTA by using
   the /AXPRTA_WATCHONLY qualifier (or making /AXPRTA_WATCHONLY
   the default in PEEK_DEFAULTS.COM, or one of the default logical-
   name tables defined by PEEK_DEFAULTS.COM).

   You must first also enable use of this feature in PEEK_DEFAULTS.COM
   by setting ALLOW_EARLIER_AXP_RTA_INTERFACE to TRUE. (See the warnings
   in PEEK_DEFAULTS.COM before enabling this feature.)

   When using this EARLIER_AXP_RTA_INTERFACE, you will not get an
   initial-screen display.

   With this EARLIER_AXP_RTA_INTERFACE you can only watch the RTA, you
   cannot take over the keyboard. Bypass-output, chat-mode, etc, also
   do not work when watching RTAs with the EARLIER_AXP_RTA_INTERFACE.

   Because of the interface used by the EARLIER_AXP_RTA_INTERFACE, you
   will not see input characters typed by the user being watched until he
   completes his input with a carriage return or other input terminator.

   The tracking of the victim's screen is not always perfect with this
   EARLIER_AXP_RTA_INTERFACE. In particular, when the victim interrupts
   output with Ctrl-Y, the watcher's screen is liable have a somewhat
   different amount of interrupted output displayed than the victim's did.

   The watcher may also sometimes get more or less linefeed characters
   displayed than the victim, especially on broadcast messages.

   Because of the interface used by the EARLIER_AXP_RTA_INTERFACE, the
   victim's End-Watch hot-key must be a function-key, keypad-key or
   escape sequence. Control characters other than Escape (such as Ctrl-P)
   are not recognized for an RTA victim when that victim is being watched
   with the EARLIER_AXP_RTA_INTERFACE (the VMS RTA interface filters out
   control characters on the remote system before Peek/Spy gets to see them.)

2.6.3    /BACKGROUND

   AXP-Only...

   /[NO]BACKGROUND

   /BACKGROUND is synonymous with the /SINGLE_WINDOW and /WINDOW
   qualifiers. See the PEEK Watching Subtopic: /SINGLE_WINDOW.

2.6.4    /BEEP_TERMINAL

   /BEEP_TERMINAL = "hot-key-defintion"

   Defines a hot-key sequence which when pressed will cause both the
   watcher's and watchee's terminals to ring their bells. This may be
   used to get the other user's attention while watching him.

   The default value is defined in the logical WATCHER$BEEP_TERMINAL.

   With PEEK, the user being watched can also beep both terminals if he
   has input control. With SPY, only the watcher can beep both terminals.

   Example:

         $ PEEK/BEEP_TERMINAL="<F6>" USER1
      or
         $ DEFINE WATCHER$BEEP_TERMINAL "<F6>"
         $ PEEK USER1

   In either case, pressing the F6 function key will cause the bell to
   be rung on both terminals.

2.6.5    /BYPASS_OUTPUT_TOGGLE

   /BYPASS_OUTPUT_TOGGLE = "hot-key-defintion"

   Defines a hot-key sequence which, when pressed by the watcher, causes
   output going to the terminal being watched to cease being displayed
   on that terminal. The output does, however, continue to go to the
   watcher's terminal, only.

   This allows one to watch output to a terminal despite it having gone
   into an XOFF state due to being put on hold-screen. This is particu-
   larly useful for watching disconnected sessions on a terminal server,
   which would otherwise be hung, waiting to be reconnected to a
   physical terminal.

   It can also be useful when watching a terminal on a slow modem line as
   one does not have to wait while the output goes out over the modem.

   The logical WATCHER$BYPASS_OUTPUT defines the default hot-key value.

   A user can disable this feature when he issues a PEEK/ALLOW command
   to allow a non-privileged user to watch him. See the top-level PEEK
   Subtopic: Commands ALLOW /BP_OUTPUT.

   Caution should be used when enabling BYPASS_OUTPUT as it may violate
   the security standards at your installation. However, BYPASS_OUTPUT
   may be turned off on a per-user or system-wide basis by defining
   the logical WATCHER$BP_OUTPUT as FALSE in the appropriate logical
   name table. See the top-level PEEK Subtopic: Defaults.

   Example:

         $ PEEK/BYPASS_OUTPUT_TOGGLE="<CTRL-K>" USER1
     or
         $ DEFINE WATCHER$BYPASS_OUTPUT_TOGGLE "<CTRL-K>"
         $ PEEK USER1

   In either case when the watcher presses Control-K, Peek/Spy will cause
   output to the terminal of the person being watched to cease going to
   that terminal, but to go only to the watcher's terminal instead. This
   cessation of output to the watched terminal continues until Control-K
   is pressed a second time.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

   When the BYPASS_OUTPUT feature is used while watching a MultiSessions
   terminal (or a terminal on which the PEEK_ONLY screen-saver has been
   activated), output which has been sent to the terminal prior to
   invoking BYPASS_OUTPUT will not be seen until some new non-broadcast
   output is sent to the terminal. This may be done by the watcher if he
   has keyboard control of the user's process (see the PEEK Watching
   Subtopics: /TOGGLE_INPUT and /SIMULTANEOUS_INPUT).

2.6.6    /CHAT_TOGGLE

   /CHAT_TOGGLE = "hot-key-defintion"

   Allows the watcher and user to enter a chat, where they can type back
   and forth to each other, but the keystrokes typed are not entered as
   input to whatever program the user process is running.

   Specify a sequence which when pressed by the watcher will cause
   Peek/Spy to enter a mode which is similar to "local mode" on a
   standard terminal. In other words, what the watcher types while
   watching a user will be echoed on both terminals, but will NOT
   be placed into the typeahead buffer or passed to any other program.
   This prevents this type of activity from causing program or command
   errors.

   The logical WATCHER$CHAT_TOGGLE defines the default hot-key value.

   Example:

         $ PEEK JONESIE /CHAT="<F14>"
     or
         $ DEFINE WATCHER$CHAT_TOGGLE "<F14>"
         $ PEEK JONESIE

   Whenever the watcher presses F14, both terminals will go into chat
   mode. You may at this point type whatever you wish, and it will be
   displayed on both screens.

   If it appears not to work and your terminal just beeps when you type,
   this is because you do not have keyboard input control (see the PEEK
   Watching Subtopic: /TOGGLE_INPUT, which is still active during chat
   mode unless /SIMULTANEOUS_INPUT is in effect).

   The keys which are useful while in chat mode are the alphanumeric
   keys, carriage-return, delete and the arrow keys.

   You should press carriage-return to end a line, since if the other
   terminal is not in auto-wrap mode, the other user may not be able to
   see what you are typing after you reach the margin and your terminal
   does do an autowrap.

   If your terminal displays "hieroglyphics" in chat mode, it is likely
   that the terminal has the line-drawing character set selected. In this
   case, pressing the shift lock key will cause subsequent characters to
   be displayed normally.

2.6.7    /CLEAR

   /[NO]CLEAR

   The /CLEAR qualifier clears the watcher's screen just after the
   STARTWATCH message is displayed, and /NOCLEAR specifies that the
   screen should not be cleared. The logical WATCHER$CLEAR specifies
   the default value.

   AXP Only -

   If the user being watched has the PEEK/SAVE_SCREEN feature enabled
   then this qualifier is ignored as the watcher's screen is always
   cleared prior to displaying what is currently on the user's screen.

   VAX Only -

   If the user being watched has MultiSessions enabled (with or without
   the PEEK_ONLY option) then the watcher's screen will be cleared
   regardless of the /NOCLEAR option, before the user's initial-screen
   contents are displayed on the watcher's terminal.

   Example: $ PEEK/CLEAR */CONFIRM

2.6.8    /CONFIRM

   /NOCONFIRM (default)

   This qualifier causes PEEK or SPY to ask the watcher for a confirmation
   before it starts watching a user.

   This allows the watcher to decide, after reviewing the initial-data
   screen displayed by PEEK, if he really wants to watch that user.
   (The initial-data screen shows the user's name, process, image name
   and the number of open files.)

   The default value is defined in the logical WATCHER$CONFIRM.

   Example:

     $ PEEK/CONFIRM *

     PEEK Version 2.2.00 Demo.
     Copyright (c) 1988-1993. An unpublished and proprietary
     software product of Networking Dynamics Corporation (NDC).
     All rights reserved.

     In a moment you will begin watching:      19-FEB-1992 15:59:48.95
       Username:   JJONES
       Process:    JJONES__LTA2341
       Terminal:   LTA2341:       (VT300_Series)
       Image name: DUA0:[SYS0.SYSCOMMON.SYSEXE]TPU.EXE;1
       Open files: 1
     END_WATCH sequence to stop watching:                 "<CTRL-P>X"
     TOGGLE_INPUT sequence to take over keyboard control: "<BS>"
     Begin watching user? (Yes/No/Quit) [N] _

   This qualifier is most useful with Peek/Spy's wildcard options, as
   it will allow you to skip watching users you do not want to watch.

   CTRL-Z is equivalent to the Quit answer, and will return you to
   the DCL or PEEK> prompt.

2.6.9    /DISPLAY_TYPE

   /DISPLAY_TYPE=keyword

   Used with /INPUT_ONLY to chose the format in which control characters
   are displayed on the watcher's screen, or in the input-keystroke log
   file.

   CHARACTER   - Displays control-characters as-is.
   DISPLAY     - Displays control characters in a reverse-video character
                 format. 8-bit control characters are displayed in
                 reverse-video and underlined. The Delete character is
                 displayed as a bold, reverse-video lower-case d.
   HEXIDECIMAL - Displays control characters in a reverse video <xx>
                 format.
   PLAIN_HEX   - Displays control characters in <xx> format. (Default).

   A default keyword-value may be specified in the logical
   WATCHER$DISPLAY_TYPE.

   Example:  $ SPY/INPUT_ONLY/DISPLAY_TYPE=DISPLAY J_DOE

   The above command watches process J_DOE but displays only the input
   keystrokes entered at the terminal. Any control characters produced
   by a keystroke are displayed in reverse video on the watcher's screen.

   For more information, see the PEEK Watching Subtopic: /INPUT_ONLY.

2.6.10    /END_WATCH

   /END_WATCH = "hot-key-defintion"

   Defines a hot-key sequence which when pressed by the watcher will
   cause Peek/Spy to stop watching and exit back to the prompt.

   The default value for the END_WATCH hot-key is taken from the
   logical name WATCHER$END_WATCH, usually defined system-wide by
   PEEK_DEFAULTS.COM.

   An END_WATCH hot-key must be defined before Peek/Spy will begin
   watching.

   Example:

         $ PEEK/END_WATCH="<CTRL-]>" USER1
     or
         $ DEFINE WATCHER$END_WATCH "<CTRL-]>"
         $ PEEK USER1

   In either case when the watcher presses Control-], the PEEK session
   will be terminated.

   (For information on the user being watched (with PEEK) also using
   END_WATCH, see the top-level PEEK Subtopic: Commands ALLOW /END_WATCH.)

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

2.6.11    /EXCLUDE_LIST

   /EXCLUDE_LIST = (terminal-name [,terminal-name ,... ,terminal_name])
   /NOEXCLUDE

   Used to specify terminals which should be skipped over during a
   wildcard operation.

   The default is specified via the logical WATCHER$EXCLUDE_LIST.

   You can override the defaults by specifying /NOEXCLUDE.

   Example: $ PEEK /EXCLUDE=NTY* */CONFIRM

   AXP Only...

   /NOEXCLUDE is used mainly to allow watching MS30 NDC terminals,
   which are skipped by default during wildcard operations so that
   only the MS30 Server, which tracks the current session, is watched.

   Note that /SINGLE_WINDOW acts as an implicit, temporary /NOEXCLUDE
   for _NDC*: terminals.

2.6.12    /FINISH_SEQUENCE

   /FINISH_SEQUENCE=(keyword[,keyword,...,keyword])

   Used to specify terminal-control sequences which will be sent to the
   watcher's terminal when he has finished watching someone.

   This can be used to reset the watcher's terminal to some particular
   state after he has finished watching someone.

   The default value is taken from the logical WATCHER$FINISH_SEQUENCE.
   This logical name may be specified in any of the logical-name tables
   specified in LNM$PEEK_TABLE_SEARCH_LIST which is defined by
   PEEK_DEFAULTS.COM. See the top-level PEEK Subtopic: Defaults. The
   PEEK_DEFAULTS.COM file contains an example of specifying a default
   value for WATCHER$FINISH_SEQUENCE.

   For more information, see the PEEK Watching Subtopic:
   Init_and_Finish_Sequences

   Example:  $ PEEK/FINISH_SEQUENCE=NOINVERSE */CONF

2.6.13    /FORCE_NETWORK_ACCESS

   /[NO]FORCE_NETWORK_ACCESS

   When using wildcards in nodenames, PEEK will skip accessing
   the network to watch processes on the current node.

   (An exception to skipping network access for the local node is when
   there is an access control string in the wildcarded nodename
   specification which does not match the current username. In this
   case, because the access requests a different username to do the
   watching, PEEK will use network access to PEEK on the local node.)

   One can force access across the network for the local node
   during a wildcarded nodename operation by specifying
   /FORCE_NETWORK_ACCESS on the command line or by specifying the
   logical name WATCHER$FORCE_NETWORK_ACCESS as TRUE. This logical
   may be defined system-wide by PEEK_DEFAULTS.COM, or may be locally
   defined in any of the logical-name tables specified by
   LNM$PEEK_TABLE_SEARCH_LIST, which is defined in PEEK_DEFAULTS.COM.
   See the top-level PEEK Subtopic: Defaults.

   Example:  $ PEEK/FORCE_NETWORK_ACCESS *::*

2.6.14    /HANGUP

   /[NO]HANGUP   (Spy-Only WATCH command qualifier)

   /NOHANGUP has been discontinued in PEEK 5.1. Most of the equivalent
   functionality can be achieved by invoking PEEK_LOGIN.COM from
   SYLOGIN.COM.

   /HANGUP remains the default and causes SPY to stop watching when
   the user being watched logs off the system.

   The /NOHANGUP qualifier caused SPY to continue watching a terminal
   even after it had been logged off (or after there were no more
   channels opened to it). One could then view or log the next
   login which occurs on the terminal.

   /NOHANGUP had no effect on terminals which are deleted at logout
   such as LTAs or FTAs, etc.

   Example:  $ SPY/TERMINAL=TTA1/NOHANGUP/LOG=TTA1.LOG

2.6.15    /IDENTIFICATION

   /IDENTIFICATION = (process-ID [,process-ID ,... ,process-ID])

   This qualifier is used to specify processes to watch by their process
   identifications (PIDs). If more than one PID is specified, parentheses
   must be used.

   When more than one process is specified, either in a list or by
   wildcards, the processes are watched one at a time in sequence, by
   using the /NEXT and /PREVIOUS hot-keys.

   A DECnet nodename may also be prefixed to each process-ID using the
   :: syntax.

   Different nodenames can be used for different process-IDs in the list,
   and standard VMS * and % wildcards are supported in nodenames. Node
   names apply only to the single PID in a list to which they are
   prepended. (See the PEEK Watching Subtopic: Node_Names.)

   Example:

         $ PEEK/ID=6A

   In this example, the watcher will watch the terminal connected to the
   process whose PID is 0000006A.

         $ PEEK/ID=BOSTON::6A

   The above command attempts to watch a process on DECnet node BOSTON
   which has a PID of 6A.

         $ PEEK/ID=(BOSTON::6A,71B, ... ,PHOENIX::9AC)

   In this example the watcher would watch the processes, in sequence,
   based on the list of PIDs. First PID 6A on node BOSTON, then PID 71B
   on the current node, and finally PID 9AC on DECnet node PHOENIX would
   be watched.

   The process ID of any process may be obtained using the PEEK/SHOW USERS
   command. PID's of processes on other nodes can be gotten using a node
   name in the PEEK/SHOW USERS command.

   E.g. PEEK/SHOW USERS NODEA:: or PEEK/SHOW USERS NODEB::G%X etc.

   You can omit any leading zeros in specifying a PID.

   Note: On Alpha with MS30 you can (by watching the MS Server process
   for a user) track with the user as he switches NDC sessions, or you
   can watch an individual NDC session by using the Peek/Spy
   /SINGLE_WINDOW qualifier.

2.6.16    /INIT_SEQUENCE

   /INIT_SEQUENCE=(keyword[,keyword,...,keyword])

   Used (when the initial-screen-display feature is not in use) to
   specify terminal-control sequences which will be sent to the
   watcher's terminal before he starts watching someone.

   A default value may be specified in the logical WATCHER$INIT_SEQUENCE.
   This logical may be defined in any of the logical-name tables specified
   by LNM$PEEK_TABLE_SEARCH_LIST which is defined by PEEK_DEFAULTS.COM.

   PEEK_DEFAULTS.COM contains an example of specifying a default value
   via WATCHER$INIT_SEQUENCE.

   /INIT_SEQUENCE is really only useful when the Peek/Spy initial-screen-
   display feature is not in use.

   When initial-screen-display is in use, the terminal-control
   sequences output by most of the keywords have little effect since
   they are immediately superceded by the control sequences which put
   the watcher's terminal into a state matching that of the terminal
   being watched.

   For more information, see the PEEK Watching Subtopic:
   Init_and_Finish_Sequences

   Example: $ PEEK/INIT_SEQ=132COLUM */CONFIRM

2.6.17    /INPUT_ONLY

   /[NO]INPUT_ONLY

   Used with SPY to skip watching terminal output and instead watch only
   the user's input keystrokes, E.g.

     SPY/INPUT_ONLY/TERMINAL=FTA10 or SPY/INPUT_ONLY/USER=J_JONES

   The default value is taken from the logical WATCHER$INPUT_ONLY.

   Your site must be licensed for Input-Only. Any watcher and any user
   being watched or logged must have been authorized by the system
   manager for input-only watching or logging since passwords and other
   non-echoed input are displayed during input watching or logging.

   You can specify the format in which control characters are
   displayed by using the /DISPLAY_TYPE qualifier.

   For more information, see the top-level PEEK Subtopic:
   INPUT_ONLY_watching_and_logging

2.6.18    /LOG_FILE

   /LOG_FILE [= file_spec]

   This a synonymous with the /OUTPUT_LOG_FILE qualifier.

   See the PEEK Watching Subtopic: /OUTPUT_LOG_FILE.

2.6.19    /NEXT

   /NEXT="hot-key-defintion"

   This qualifier is used to define a hot-key sequence which causes PEEK
   to stop watching the current target and start watching the next target
   (if there is another target which matches the specification(s) given).

   If there is no next targets to watch, the NEXT hot-key performs an
   END_WATCH.

   The default hot-key value is taken from the logical WATCHER$NEXT.

   Example:

         $ PEEK/NEXT="<CTRL-P>N" GROUP1*
     or
         $ DEFINE WATCHER$NEXT "<CTRL-P>N"
         $ PEEK GROUP1*

   In either case when the watcher presses Control-P followed by the
   letter N, PEEK will stop watching the current user and try to watch
   a next user, if any.

2.6.20    /NOBEEP

   Normally if a user being watched tries to type when he does not have
   keyboard control, Peek/Spy will ring his terminal bell to inform
   him that the watcher currently has control of his keyboard.

   /NOBEEP keeps this warning bell from ringing on the terminal being
   watched.

   A default value can be specified in the logical WATCHER$NOBEEP.

   With NOBEEP, when the user being watched does not have keyboard
   control, his keyboard will just appear to "go dead" instead of
   beeping when he tries to type.

2.6.21    /OUTPUT_LOG_FILE

   /OUTPUT_LOG_FILE [ = file_spec ]  (WATCH and SAVE_SCREEN qualifier)

   This qualifier creates a log file of the Peek/Spy session. It can
   be used with the PEEK, SPY and WATCH verbs.

   It can also be used with the SAVE_SCREEN command to start terminal
   logging. See the top-level PEEK Subtopic: Commands SAVE_SCREEN
   /OUTPUT_LOG_FILE.

   When used with the WATCH subcommand, this qualifier specifies that
   Peek/Spy should create an output log file containing everything which
   is output during the period of time in which the watcher is
   observing the user's screen.

   The default file spec is taken from the logical WATCHER$OUTPUT_LOG_FILE.
   If nothing is specified by this default and if /OUTPUT_LOG_FILE is
   specified without the optional file_spec, then PEEK will generate
   a log file in the current default directory using a default
   log-file name in one of the following formats:

         PEEK_username_terminal_name.LOG
         PEEK_terminal_name.LOG

   The first of these is used when you begin watching a terminal which
   is owned by some process. The second format is used by SPY only
   when watching an unowned terminal.

   Logging is continued until watching is terminated by one of the
   END_WATCH, NEXT or PREVIOUS sequences.

   /LOG and /OUTPUT_LOG are synonymous.

   Examples:
     $ PEEK  JONES  /OUTPUT=SAVE_OUTPUT.JONES
     - or -
     $ DEFINE  WATCHER$OUTPUT_LOG_FILE  SAVE_OUTPUT.JONES
     $ PEEK  JONES /LOG

2.6.22    /PERMIT_INPUT

   /PERMIT_INPUT="hot-key-defintion"

   Hot-key used to permit a watcher (who is not normally able to have
   keyboard control) to acquire temporary keyboard control through
   use of his REQUEST_INPUT hot-key.

   PERMIT_INPUT can be issued by the user being watched, or by a primary
   watcher who currently has keyboard control.

   To successfully grant PERMIT_INPUT, the user granting it must
   currently have keyboard control (via either SIMULTANEOUS_INPUT
   or TOGGLE_INPUT).

   If a PERMIT_INPUT request is rejected (due to not currently having
   control of the keyboard) then the terminal bell will beep.

   Once PERMIT_INPUT has been enabled and a watcher then accepts it (by
   using his REQUEST_INPUT hot-key), the watcher and the user who
   permitted him may either toggle input between themselves using their
   TOGGLE_INPUT hot-keys, or may both type simultanously if the PSIMUL
   qualifier (or default) is in effect for the permitted watcher. (See
   also PNOBEEP.)

   Once granted, PERMIT_INPUT can be revoked again at any time by
   issuing another PERMIT_INPUT. (The PERMIT_INPUT key toggles
   PERMIT_INPUT on and back off.)

   A PERMIT_INPUT granted by the user being watched is also revoked
   whenever the primary watcher (if any) toggles input.

   Likewise, a PERMIT_INPUT granted by a primary watcher is revoked
   whenever the user being watched toggles input.

   Thus input-ability gained through PERMIT_INPUT/REQUEST_INPUT is very
   temporary.

   The logical WATCHER$PERMIT_INPUT specifies the default hot-key value
   for a primary watcher, and the logical USER$PERMIT_INPUT specifies
   the default hot-key value for use when being watched.

   Note that PERMIT_INPUT and REQUEST_INPUT may be used to temporarily
   grant input-ability to a watcher who otherwise would not be able to
   gain keyboard control due to keyboard-control licensing-option
   or ALLOW-command restrictions.

2.6.23    /PNOBEEP

   This qualifier is for use with the PERMIT_INPUT and REQUEST_INPUT
   hot-keys which temporarily grant keyboard control to a watcher who
   would not otherwise be able to have it. (See the PEEK Watching
   Subtopics: /PERMIT_INPUT and /REQUEST_INPUT.)

   When a watcher has been permitted temporary keyboard control, this
   qualifier determines whether or not the bell is rung on the terminal
   of the person being watched when he tries to type after control of his
   keyboard has been taken over (and PSIMUL_INPUT has not been specified).

   As with NOBEEP, when the user being watched does not have keyboard
   control, his keyboard will just appear to "go dead" instead of
   beeping when he tries to type.

   The logical WATCHER$PNOBEEP specifies the default value for this
   qualifier.

   /PNOBEEP is provided in addition to /NOBEEP to make it possible to
   have a different nobeep value which applies only when one is a
   permitted-input watcher.

2.6.24    /PREVIOUS

   /PREVIOUS="hot-key-defintion"

   This qualifier is used to define a hot-key sequence which causes PEEK
   to stop watching the current target and start watching the previous
   target.

   If there is no previous, matching target specification then PREVIOUS
   is equivalent to END_WATCH.

   The default hot-key value is taken from the logical WATCHER$PREVIOUS.

   Example:

         $ PEEK/PREVIOUS="<CTRL-P>P" GROUP1*
     or
         $ DEFINE WATCHER$PREVIOUS "<CTRL-P>P"
         $ PEEK GROUP1*

   In either case when the watcher presses Control-P followed by the
   letter P, PEEK will stop watching the current user and try to watch
   a previous user.

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

2.6.25    /PROCESS_NAME

   /PROCESS_NAME=(process_name [,process_name ,... ,proccess_name])

   This parameter specifies targets to watch by their process names.

   Parentheses are required if more than one process name is specified.

   If a list is given or wildcards are used then the NEXT and PREVIOUS
   hot-keys are used to end watching the current process and start
   watching the next or previous one.

   The standard VMS * and % wildcard characters may be used in the
   process name(s).

   Standard VMS DECnet nodenames may also be prefixed to the process
   names for watching processes on other nodes. (See the PEEK Watching
   Subtopic: Node_Names.)

   Different nodenames can be used with different process names in the
   list. Standard VMS * and % wildcards are supported in nodenames.

   A prepended nodename applies only to the one process-name in the list
   to which it is prepended. For example the command:

     $ PEEK BOSTON::J_DOE,PHOENIX::B_SMITH,M_JONES

   causes PEEK to attempt to watch the process J_DOE on node BOSTON,
   then the process B_SMITH on node PHOENIX, and then the process
   M_JONES on the current node.

   Note that the following two syntaxes will produce identical results:

         $ PEEK USER1
         $ PEEK /PROCESS_NAME=USER1

         In either case USER1 will be watched.

   In this example a list of users is specified:

         $ PEEK USER1,USER2,USER3
         $ PEEK/PROCESS_NAME=(USER1,USER2,USER3)

   Note: On Alpha with MS30 you can (by watching the "MS Server*" process
   for a user) track with the user as he switches NDC sessions, or you
   can watch an individual NDC session by using the Peek/Spy
   /SINGLE_WINDOW qualifier.

2.6.26    /PSIMUL_INPUT

   /[NO]PSIMUL_INPUT

   This qualifier is for use with the PERMIT_INPUT and REQUEST_INPUT
   hot-keys which temporarily grant keyboard control to a watcher who
   would not otherwise have it. (See the PEEK Watching Subtopics:
   /PERMIT_INPUT and /REQUEST_INPUT.)

   When a watcher has been permitted temporary keyboard control,
   the /PSIMUL_INPUT qualifier specifies whether or not both the
   watcher and watchee will be able to enter keyboard input to the
   user's process simultaneously, without having to use the
   TOGGLE_INPUT hot-key.

   The logical WATCHER$PSIMUL_INPUT specifies the default value.

   When simultaneous input is allowed, the TOGGLE_INPUT hot-key will
   have no effect on the user being watched. TOGGLE_INPUT's by the
   watcher will just enable/disable his own keyboard input.

   The watcher starts with keyboard input enabled when simultaneous
   input is in effect.

   The logical WATCHER$PSIMUL specifies the default value for this
   qualifier.

   For examples see /SIMULTANEOUS_INPUT.

   /PSIMUL_INPUT is provided in addition to /SIMULTANEOUS_INPUT to make
   it possible to have a different simultaneous value which applies only
   when one is a permitted-input watcher.

2.6.27    /QUOTE

   /QUOTE = "hot-key-defintion"

   /QUOTE is used to specify a hot-key which when recognized tells
   Peek/Spy that the following keystroke is NOT to be interpreted as part
   of a hot-key sequence, but is to be passed through to the terminal as
   normal input.

   This allows the user to enter this hot-key and follow it with some
   other Peek/Spy hot-key keystroke which he wishes to pass to the program
   as input. (Of course whether or not it is passed to the user's program
   is still controlled by TOGGLE_INPUT, if input is not simultaneous.)

   The QUOTE hot-key should be entered by the watcher immediately before
   the hot-key keystroke which he wishes to pass to the user's process.

   The default hot-key value is taken from the logical WATCHER$QUOTE.

   Example:

         $ PEEK/QUOTE="<F7>"/BEEP_TERMINAL="<F6>" USER1
     or
         $ DEFINE WATCHER$QUOTE "<F7>"
         $ PEEK/BEEP_TERMINAL="<F6>" USER1

   In either case, if the watcher presses F6, the bell will be rung
   on the user's terminal. However, if he presses F7 followed by F6,
   then the F6 sequence will be passed to the user's process (if
   watcher keyboard input is enabled, see the PEEK Watching
   Subtopics: /SIMULTANEOUS_INPUT and /TOGGLE_INPUT, and the
   top-level PEEK Subtopic: Commands ALLOW /NOKB_CONTROL).

   For a complete description of the syntax used for specifying
   hot-key definitions, see the top-level PEEK Subtopic: Hot-Keys.

2.6.28    /REQUEST_INPUT

   /REQUEST_INPUT="hot-key-defintion"

   Hot-key used to gain temporary ability to control the keyboard of
   the user being watched when the watcher wouldn't normally be able to
   gain keyboard control due to licensing or ALLOW-command restrictions.

   Use of the REQUEST_INPUT hot-key by a watcher only succeeds if the user
   being watched (or primary watcher) has first successfully issued a
   PERMIT_INPUT by using his PERMIT_INPUT hot-key.

   A second REQUEST_INPUT issued by the watcher after his REQUEST_INPUT
   has been granted, toggles his REQUEST_INPUT back off again.

   A REQUEST_INPUT request will fail if another watcher has already
   accepted the PERMIT_INPUT, or if REQUEST_INPUT hasn't first been
   permitted by a successful PERMIT_INPUT issued by the user being
   watched or primary watcher.

   If a REQUEST_INPUT is unsuccessful, the terminal will just beep.

   When a REQUEST_INPUT is successful, the watcher who did the successful
   REQUEST_INPUT may temporarily provide input. The TOGGLE_INPUT key may
   need to be used, unless the PSIMUL qualifier (or default) is in effect.

   The user (or primary watcher) who issued the PERMIT_INPUT may revoke it
   again at any time by again typing his PERMIT_INPUT hot-key sequence.

   A PERMIT_INPUT by the user being watched is also revoked if a primary
   watcher does a TOGGLE_INPUT to take keyboard control from the user.

   Likewise, a PERMIT_INPUT by the primary watcher is revoked if the user
   being watched does a TOGGLE_INPUT to take keyboard control back from
   the primary watcher.

   Thus input-ability gain through REQUEST_INPUT is very temporary.

   Note that PERMIT_INPUT and REQUEST_INPUT may be used to temporarily
   grant input-ability to a watcher who otherwise would not be able to
   gain keyboard control due to licensing option or ALLOW-command
   restrictions.

   The logical WATCHER$REQUEST_INPUT specifies the default hot-key value.

2.6.29    /SIMULTANEOUS_INPUT

   /[NO]SIMULTANEOUS_INPUT

   Specifying /SIMULTANEOUS_INPUT allows both the watcher and the
   watchee to enter keyboard input to the watchee's process at the same
   time without having to switch back and forth by using the
   TOGGLE_INPUT hot-key.

   The logical WATCHER$SIMULTANEOUS_INPUT specifies the default value.

   When simultaneous input is in effect, the TOGGLE_INPUT hot-key will
   have no effect on the user being watched. TOGGLE_INPUT's by the
   watcher will just enable/disable his own keyboard input.

   The watcher starts with keyboard input enabled when simultaneous
   input is in effect.

     NOTE:  There is a licensing option which will prevent the
     watcher from ever providing input to the user's terminal,
     for use in banking and other high-security environments.

     Thus if the SIMULTANEOUS_INPUT feature appears not to work
     for your site, you should check to see if your license
     specifies NOKB_CONTROL.

   Example 1:

         $ PEEK JONES /SIMULTANEOUS_INPUT
     or
         $ DEFINE WATCHER$SIMULTANEOUS_INPUT TRUE
         $ PEEK JONES

   This will allow both the watcher and the user being watched (JONES)
   to be able to do keyboard input at the same time.

   Example 2:

         $ PEEK JONES /NOSIMULTANEOUS_INPUT
     or
         $ DEFINE WATCHER$SIMULTANEOUS_INPUT FALSE
         $ PEEK JONES

   This will allow only one of either the watcher or the user being
   watched (JONES) to be able to do keyboard input. They must take
   turns typing by using the TOGGLE_INPUT hot-key sequence.

2.6.30    /SINGLE_WINDOW

   AXP-Only...

   /[NO]SINGLE_WINDOW

   Determines whether an MS Server process or individual MultiSessions
   NDC-terminal windows will be watched.

   The default for a PEEK, SPY or WATCH command is determined by the
   logical WATCHER$BACKGROUND usually defined by PEEK_DEFAULTS.COM. You
   can override the default by using this command qualifier.

   Note that the default behavior without /SINGLE_WINDOW is to see the
   screen of the MS Server process, whether or not wildcards are used.

   Examples:

   $ PEEK/TERM=-NDC21 /SINGLE_WINDOW ! Watch terminal NDC21:
   $ PEEK/TERM=NDC* /SINGLE_WINDOW   ! Watch all NDC terminals.
   $ PEEK * /NOSINGLE_WINDOW         ! Only watch MS Servers, don't
                                     ! watch any NDC terminals.

2.6.31    /TERMINAL

   /TERMINAL=(terminal_name [,terminal_name ,... ,terminal_name])

   This qualifier is used to specify targets to be watched by using their
   terminal names.

   If more than one terminal name is specified then the list must be
   enclosed in parenthesis.

   The standard VMS wildcards (* and %) may be specified for any part of
   the terminal name, if desired.

   Standard DECnet nodenames may also be prefixed to the terminal names
   for watching terminals on other nodes. (See the PEEK Watching
   Subtopic: Node_Names.)

   Different nodenames can be used for different terminal names in the
   list, and standard VMS * and % wildcards are supported in nodenames.
   A nodename prepended to a terminal name applies only to that one
   terminal name in the list.

   The /NEXT and /PREVIOUS hot-keys are used to end watching one target
   and start watching the next or previous one.

   The terminal names used may be any of the names which are associated
   with the physical terminal: the physical terminal name (e.g. LTA3451:
   or TXA5:) or the virtual terminal name (e.g., VTA127:).

   If MultiSessions is in use, then the terminal name may be any of the
   MultiSessions pseudo-terminal units (e.g., NDC22:) which are currently
   active on that terminal, or the physical terminal being used by
   MultiSessions.

   Examples:  $ PEEK/TERMINAL=LTA*.

   In the above example, the lowest numbered terminal with the name LTA
   will be watched. When the /NEXT hot-key sequence is entered, then
   the next LTA terminal unit will be watched, etc.

              $ PEEK/TERMINAL=TXA5

   In the above example, the watcher will watch the process which is
   connected with terminal TXA5.

   Note: On Alpha with MS30 you can (by watching the physical terminal
   associated with the MS Server process) track with the user as he
   switches NDC sessions, or you can watch individual NDC sessions by
   using the Peek/Spy /SINGLE_WINDOW qualifier.

2.6.32    /TIME_LIMIT

   /TIME_LIMIT=nnn

   Using this qualifier causes the NEXT hot-key sequence to
   be simulated when the specified time duration expires.

   The "nnn" time value is specified in seconds.

   The default value is taken from the logical WATCHER$TIME_LIMIT.

2.6.33    /TOGGLE_INPUT

   /TOGGLE_INPUT = "hot-key-defintion"
   /NOTOGGLE_INPUT

   Defines a hot-key sequence which will toggle control of the keyboard
   of the user being watched between the user and the watcher.

   If this command qualifier is NOT specified (either on the command
   line or as a WATCHER$TOGGLE_INPUT logical), then the watcher will
   not be able to enter any input for the user unless /SIMULTANEOUS_INPUT
   is in effect.

   If SIMULTANEOUS_INPUT has been specified, pressing the TOGGLE_INPUT
   hot-key will have no effect on the user being watched, but will toggle
   on and off the watcher's ability to type for the user.

     NOTE:  There is a licensing option which will prevent the
     watcher from ever providing input to the user's terminal,
     for use in banking and other high-security environments.

     Thus if the TOGGLE_INPUT feature appears not to work
     for your site, you should check to see if your license
     specifies NOKB_CONTROL.

   The rest of this section will assume that SIMULTANEOUS_INPUT has not
   been specified.

   When PEEK is run, at first the watcher is not allowed to enter input
   to the user's process. If he types anything other than one of his
   hot-key sequences, then PEEK will throw the watcher's attempted input
   away and just ring the bell on his terminal instead.

   The watcher may press TOGGLE_INPUT to switch keyboard control,
   taking it away from the user being watched. At this point, the bell
   on the terminal of the user being watched will ring if he attempts
   to type anything other his defined hot-key sequences. (For defining
   hot-keys for use when being watched, see the top-level PEEK Subtopic:
   Commands ALLOW.)

   Example:

         $ PEEK/TOGGLE_INPUT="<F10>" USER1
     or
         $ DEFINE WATCHER$TOGGLE_INPUT "<F10>"
         $ PEEK USER1

   In this case, if the watcher presses F10 while watching, then he will
   take over keyboard control from USER1 (or give it back, if he already
   has control of the USER1's keyboard).

   For a complete description of the syntax used for specifying hot-key
   definitions, see the top-level PEEK Subtopic: Hot-Keys.

   If you don't want a TOGGLE_INPUT hot-key defined then /NOTOGGLE_INPUT
   may be used to override the existence of a default TOGGLE_INPUT hot-key.

   NOTE:  Use of the /NOTOGGLE_INPUT qualifier means there will be no
          TOGGLE_INPUT hot-key defined for whoever issues the command
          containing the /NOTOGGLE_INPUT. The PEEK ALLOW-command's
          /NOKB_CONTROL qualifier refers to whether an ALLOWed watcher
          will be able to have keyboard control.

2.6.34    /USERNAME

   /USERNAME=(user_name [,user_name ,... ,user_name])

   This qualifier is used to specify targets to be watched by username.

   If more than one username is specified, the list must be enclosed in
   parenthesis.

   Usernames may contain the standard VMS * and % wildcard characters.

   Standard DECnet nodenames may also be prefixed to the usernames, for
   watching users on other nodes. (See the PEEK Watching Subtopic:
   Node_Names.)

   Different nodenames can be used for each different username in the
   list, and standard VMS * and % wildcards are supported in nodenames.

   A nodename applies only to the one username in the list to which it
   is prepended.

   The NEXT and PREVIOUS hot-keys are used to end watching one process and
   start watching the next or previous one matching the specifications.

   Examples:

         $ PEEK /USERNAME=(JONES,NODEA::SMITH,BROWN)

   In this example, a process belonging to the first user in the list
   will be watched first. When the /NEXT hot-key sequence is entered,
   watching will begin on the next process belonging to that user (if
   any). After all the first user's processes have been watched, PEEK
   will begin watching the first process for the next user in the list,
   in this case on DECnet node NODEA. When all of SMITH's processes on
   NODEA have been watched, the first process for user BROWN on the
   current node will be watched.

         $ PEEK /USERNAME=D*

   In this example, a process will be watched whose username starts with
   the letter "D". When the /NEXT hot-key sequence is entered, watching
   will begin on the next process beginning with the letter "D", if any,
   etc.

   Note: On Alpha with MS30 you can (by watching the MS Server process
   for a user) track with the user as he switches NDC sessions, or you
   can watch an individual NDC session by using the Peek/Spy
   /SINGLE_WINDOW qualifier.

2.6.35    /WAIT_TIME

   /WAIT_TIME=nn.n

   This qualifier specifies the time in seconds which will elapse before
   starting to watch a user. This allows time for one to read the
   "In a moment you will begin watching...." message.

   The "nn.n" time value is specified in seconds, and can contain a
   decimal point.

   Interactive control over how long this message displays may be achieved
   by using the /CONFIRM qualifier instead of /WAIT_TIME.

   The default value is taken from the logical WATCHER$WAIT_TIME.

2.6.36    /WINDOW

   AXP-Only...

   /[NO]WINDOW

   /WINDOW is synonymous with the /BACKGROUND and /SINGLE_WINDOW
   qualifiers. See the PEEK Watching Subtopic: /SINGLE_WINDOW.

2.7  –  Init and Finish Sequences

  When watching a terminal, it is desirable to set the proper modes on the
  watcher's terminal before displaying output from the watched terminal.

  Ideally, the watcher's terminal should have the same modes set as the
  terminal which is being watched. This ensures the output will display
  correctly.

  This is not a problem when using Peek/Spy's initial-screen-display
  feature since the correct initial settings for the watcher's terminal
  will be output to it as part of the initial-screen display.

  However when the screen-saver is NOT in use by the person being
  watched, it may be desirable to set some initial terminal modes on
  your terminal before you begin watching. In addition you may also
  want to restore your own terminal modes when finished watching another
  terminal.

  The Peek/Spy /INIT_SEQUENCE=() qualifier may be used to specify
  an initial modes-setting sequence which is sent to your terminal just
  before you start watching. The /FINISH_SEQUENCE=() qualifier
  specifies a modes-setting sequence which will be sent to your terminal
  after you finish watching someone.

  Each of these qualifiers accepts a list of keywords. Each keyword
 causes a particular sequence to be sent to the watcher's terminal.

2.7.1  –  Keywords

  These are the keywords available for /INIT_SEQUENCE and
  /FINISH_SEQUENCE.

  Each keyword causes a particular sequence to be sent to
  the watcher's terminal.

  The order in which these sequences are output is fixed and does not
  depend on the order in which they appear on the command line.

  For information on the fixed-ordering of these sequences, see the
  PEEK Watching Init_and_Finish_Sequences Subtopic: Sequence_Ordering.

2.7.1.1  –  132COLUMN

  Outputs "<ESC>[?3h"

2.7.1.2  –  80COLUMN

  Outputs "<ESC>[?3l"

2.7.1.3  –  APPLICATION

  Outputs "<ESC>="

2.7.1.4  –  CHARACTER_SET=()

  CHARACTER_SET takes a list of the keywords HANJI, KANJI, KATAKANA,
  MULTINATIONAL, STANDARD, or G0=keyword, G1=keyword, G2=keyword,
  G3=keyword, GL=keyword, GR=keyword.

  The fixed order in which these terminal control sequences are output
  allows one to use the STANDARD, MULTINATIONAL, KANJI, or KATAKANA
  keywords and then customize that settings using one of the G0, G1,
  G2, G3, GL, GR keywords.

2.7.1.5  –  MULTINATIONAL

  The keyword STANDARD or MULTINATIONAL equates to the command:

   CHARACTER_SET=(G0=ASCII,G1=ASCII,G2=DECSUPGR,G3=DECSUPGR,-
                  GL=G0,GR=G2)

  It outputs "<ESC>(B<ESC>)B<ESC>*%5<ESC>+%5<SI><ESC>}"

2.7.1.6  –  STANDARD

  The keyword STANDARD or MULTINATIONAL equates to the command:

   CHARACTER_SET=(G0=ASCII,G1=ASCII,G2=DECSUPGR,G3=DECSUPGR,-
                  GL=G0,GR=G2)

  It outputs "<ESC>(B<ESC>)B<ESC>*%5<ESC>+%5<SI><ESC>}"

2.7.1.7  –  HANJI

  The keyword HANJI equates to the following command which might be
  used on a Korean HANJI terminal:

   CHARACTER_SET=(G0=KS_ROMAN,G1=DECSPEC,G2=KOREAN,G3=KOREAN,-
                        GL=G0,GR=G3)

  It outputs "<ESC>\(%?\<ESC>\)0\<ESC>\*4\<ESC>\+4\<SI><ESC>\|\".

2.7.1.8  –  KANJI

  The keyword KANJI equates to the following command which might be
  used on a Japanese fullset KANJI terminal:

   CHARACTER_SET=(G0=JIS_ROMAN,G1=DECSPEC,G2=JIS_KATAKANA,-
                  G3=DEC_KANJI,GL=G0,GR=G3)

  It outputs "<ESC>(J<ESC>)0<ESC>*I<ESC>+"0<SI><ESC>|".

2.7.1.9  –  KATAKANA

  The keyword KATAKANA equates to the following command which might
  be used on a Japanese KATAKANA terminal:

         CHARACTER_SET=(G0=JIS_ROMAN,G1=JIS_KATAKANA,-
                        G2=JIS_KATAKANA,G3=DECSPEC,GL=G0,GR=G2)

  It outputs "<ESC>(J<ESC>)I<ESC>*I<ESC>+0<SI><ESC>}".

2.7.1.10  –  G0-G3_KEYWORDS

  The G0, G1, G2, G3 keywords take one of the following character-set
  keywords:

         Keyword         Character set description        Internal name
         ------          -------------------------        -------------
         ASCII           ASCII character set              B
         DECSPEC         DEC Special Graphic              0
         DECSUPGR        DEC Supplemental Graphic         %5
         DECTECH         DEC Technical                    >
         ISOLATIN1       ISO Latin-1 supplemental         A
         JIS_KATAKANA    JIS-Katakana (Japanese terminal) I
         JIS_ROMAN       JIS-Roman (Japanese terminal)    J
         KANJI           DEC Kanji (Japanese terminal)    "0 (or 1 or 3)
         KOREAN          Hanji    (Korean terminal)       4
         KS_ROMAN        KS Roman (Korean terminal)       %?
         LINEDRAWING     DEC Line Drawing                 0
         USERPREF        User-preferred supplemental      <

  Or you can specify your own G0, G1, G2, or G3 94-character set
  final sequence by using the STRING= keyword.

  G0=STRING="xx" outputs "<ESC>(xx".
  G1=STRING="xx" outputs "<ESC>)xx".
  G2=STRING="xx" outputs "<ESC>*xx".
  G3=STRING="xx" outputs "<ESC>+xx".

  E.g. CHARACTER_SET=(G0=STRING="B") would be the same as
       CHARACTER_SET=(G0=ASCII)

  and  CHARACTER_SET=(G0=DECSUPGR) would be the same as
       CHARACTER_SET=(G0=STRING="%5")

2.7.1.11  –  G1-G3_96_KEYWORDS

  The G1, G2, G3 keywords can also take one of the following
  additional 96-character-set keywords:

         BRITISH         British national                A
         CANADIAN        French Canadian national        9 (or Q)
         DANISH          Danish/Norwegian national       ` (or E or 6)
         DECTECH         DEC Technical                   >
         DUTCH           Dutch national                  4
         FINNISH         Finnish national                5 (or C)
         FRENCH          French national                 R
         GERMAN          German national                 K
         ITALIAN         Italian national                Y
         NORWEGIAN       Norwegian/Danish national       ` (or E or 6)
         PORTUGESE       Portugese national              %6
         SPANISH         Spanish national                Z
         SWEDISH         Swedish national                7 (or H)
         SWISS           Swiss national                  =

  Or you can specify your own G1, G2, or G3 96-character set final
  sequence by using the 96STRING= keyword.

  G1=96STRING="xx" outputs "<ESC>-xx".
  G2=96STRING="xx" outputs "<ESC>.xx".
  G3=96STRING="xx" outputs "<ESC>/xx".

  E.g.  CHARACTER_SET=(G1=96STRING=7) would be the same as
        CHARACTER_SET=(G1=SWEDISH)

  and   CHARACTER_SET=(G2=DECTECH) would be the same as
        CHARACTER_SET=(G2=96STRING=">")

2.7.1.12  –  GL

  The GL and GR keywords take one of the following keyword values:

     G0, G1, G2, G3.           E.g. CHARACTER_SET=(GL=G0,GR=G2).

  GL=G0 outputs "<SI>".
  GL=G1 outputs "<SO>".
  GL=G2 outputs "<ESC>n".
  GL=G3 outputs "<ESC>o".

2.7.1.13  –  GR

  The GL and GR keywords take one of the following keyword values:

     G0, G1, G2, G3.           E.g. CHARACTER_SET=(GL=G0,GR=G2).

  GR=G1 outputs "<ESC>~".
  GR=G2 outputs "<ESC>}".
  GR=G3 outputs "<ESC>|".

2.7.1.14  –  CLEAR

  Outputs "<ESC>[H<ESC>[J"

2.7.1.15  –  EIGHT_BIT

  Outputs "<ESC> G"

2.7.1.16  –  INSERT

  Outputs "<ESC>[4h"

2.7.1.17  –  NOINSERT

  Outputs "<ESC>[4l"

2.7.1.18  –  INVERSE

  Outputs "<ESC>[?5h"

2.7.1.19  –  NOINVERSE

  Outputs "<ESC>[?5l"

2.7.1.20  –  NATIONAL

  Outputs "<CSI>?42h"

2.7.1.21  –  NONATIONAL

  Outputs "<CSI>?42l"

2.7.1.22  –  NONE

   The keyword NONE is used to specify that there is no /INIT or
   /FINISH sequence.

2.7.1.23  –  NUMERIC

  Outputs "<ESC>>"

2.7.1.24  –  ORIGIN

  Outputs "<ESC>[?6h"

2.7.1.25  –  NOORIGIN

  Outputs "<ESC>[?6l"

2.7.1.26  –  PREFIX="string"

  PREFIX takes a string parameter and outputs it before
  any other sequences.

  Parameter is a user specified string in "hot-key" format.

  E.g. /INIT=(PREFIX="<ESC>[2J")

2.7.1.27  –  PREF_DEC

  Outputs "<DCS>0!u%5<ST>"

2.7.1.28  –  PREF_ISO

  Outputs "<DCS>1!uA<ST>"

2.7.1.29  –  REGIS

  Outputs "<ESC>Pp"

2.7.1.30  –  SCROLL=(top row,bottom row)

  SCROLL takes two numeric parameters, top_row and bottom_row.

  These are substituted into the "$[t;br" escape sequence exactly as
  they are given on the command line.

  E.g. /INIT=(SCROLL=(5,20)) generates "<ESC>[5;20r".

2.7.1.31  –  NOSCROLL

  Outputs "<ESC>[r"

2.7.1.32  –  SEVEN_BIT

  Outputs "<ESC> F"

2.7.1.33  –  STRING="string"

  The string specified with /INIT=(STRING="string") or
  /FINISH=(STRING="string") is output after all the
  other sequences specified have been output, except for
  the REGIS, TEXTRONIX and VT52 sequences.

  The parameter is a user specified string in "hot-key" format.

  E.g. /INIT=(STRING="<ESC>[2J")

2.7.1.34  –  STATUS_INDICATOR

  Outputs "<ESC>[1$~"

2.7.1.35  –  STATUS_LINE

  Outputs "<ESC>[2$~"

2.7.1.36  –  NOSTATUS_LINE

  Outputs "<ESC>[0$~"

2.7.1.37  –  STATUS START[="string"]

  Outputs "<ESC>[1$}" then the optional string.

  This may be used to put text on the status line.

  It should be followed by a STATUS_END to return the cursor to the
  main display.

2.7.1.38  –  STATUS_END

  Outputs "<ESC>[0$}"

2.7.1.39  –  SUFFIX="string"

  The string specified with /INIT=(SUFFIX="string") or
  /FINISH=(SUFFIX="string") is output after all the
  other sequences specified have been output.

  The parameter is a user specified string in "hot-key" format.

  E.g. /INIT=(SUFFIX="<ESC>[2J")

2.7.1.40  –  TEKTRONIX

  Outputs "<ESC>[?38h"

2.7.1.41  –  NOTEKTRONIX

  Outputs "<ESC>[?38l"

2.7.1.42  –  TEKTRONIX2

  Outputs "<ESC>%!0"

2.7.1.43  –  NOTEKTRONIX2

  Outputs "<ESC>%!2"

2.7.1.44  –  VT100

  Outputs "<ESC><"

2.7.1.45  –  VT200

  Outputs "<ESC><<ESC>["62;1p"

2.7.1.46  –  VT300

  Outputs "<ESC><<ESC>["63;1p"

2.7.1.47  –  VT400

  Outputs "<ESC><<ESC>["64;1p"

2.7.1.48  –  VT52

  Outputs "<ESC>[?2l<ESC>\"

2.7.2  –  Sequence Ordering

  The sequences are output as follows and in the following order
  regardless of the sequence of the keywords on the command line:

  PREFIX="string"                user specified string in "hot-key"
                                 format.
  SCROLL=(5,20)                  <ESC>[5;20r
  VT100                          <ESC><
  VT200                          <ESC><<ESC>["62;1p
  VT300                          <ESC><<ESC>["63;1p
  VT400                          <ESC><<ESC>["64;1p
  SEVEN_BIT                      <ESC> F
  EIGHT_BIT                      <ESC> G
  STATUS_INDICATOR               <ESC>[1$~
  STATUS_LINE                    <ESC>[2$~
  NOSTATUS_LINE                  <ESC>[0$~
  STATUS_START                   <ESC>[1$}
  STATUS_END                     <ESC>[0$}
  PREF_DEC                       <DCS>0!u%5<ST>
  PREF_ISO                       <DCS>1!uA<ST>
  CHARACTER_SET=MULTINATIONAL    <ESC>(B<ESC>)B<ESC>*%5<ESC>+%5<SI><ESC>}
  CHARACTER_SET=STANDARD         <ESC>(B<ESC>)B<ESC>*%5<ESC>+%5<SI><ESC>}
  CHARACTER_SET=KATAKANA         <ESC>(J<ESC>)I<ESC>*I<ESC>+0<SI><ESC>}
  CHARACTER_SET=KANJI            <ESC>(J<ESC>)0<ESC>*I<ESC>+"0<SI><ESC>|
  CHARACTER_SET=G0=STRING="xx"   <ESC>(xx
  CHARACTER_SET=G1=STRING="xx"   <ESC>)xx
  CHARACTER_SET=G2=STRING="xx"   <ESC>*xx
  CHARACTER_SET=G3=STRING="xx"   <ESC>+xx
  CHARACTER_SET=G1=96STRING="xx" <ESC>-xx
  CHARACTER_SET=G2=96STRING="xx" <ESC>.xx
  CHARACTER_SET=G3=96STRING="xx" <ESC>/xx
  CHARACTER_SET=G0=94_charset_kw <ESC>(<94-charset-final>
  CHARACTER_SET=G1=94_charset_kw <ESC>)<94-charset-final>
  CHARACTER_SET=G2=94_charset_kw <ESC>*<94-charset-final>
  CHARACTER_SET=G3=94_charset_kw <ESC>+<94-charset-final>
  NATIONAL                       <CSI>?42h
  NONATIONAL                     <CSI>?42l
  CHARACTER_SET=G1=96_charset_kw <ESC>-<96-charset-final>
  CHARACTER_SET=G2=96_charset_kw <ESC>.<96-charset-final>
  CHARACTER_SET=G3=96_charset_kw <ESC>/<96-charset-final>
  CHARACTER_SET=GL=G0            <SI>
  CHARACTER_SET=GL=G1            <SO>
  CHARACTER_SET=GL=G2            <ESC>n
  CHARACTER_SET=GL=G3            <ESC>o
  CHARACTER_SET=GR=G1            <ESC>~
  CHARACTER_SET=GR=G2            <ESC>}
  CHARACTER_SET=GR=G3            <ESC>|
  APPLICATION                    <ESC>=
  NUMERIC                        <ESC>>
  INSERT                         <ESC>[4h
  NOINSERT                       <ESC>[4l
  132COLUMN                      <ESC>[?3h
  80COLUMN                       <ESC>[?3l
  INVERSE                        <ESC>[?5h
  NOINVERSE                      <ESC>[?5l
  ORIGIN                         <ESC>[?6h
  NOORIGIN                       <ESC>[?6l
  NOSCROLL                       <ESC>[r
  CLEAR                          <ESC>[H<ESC>[J
  STRING="string"                user specified string in "hot-key"
                                 format.
  REGIS                          <ESC>Pp
  TEKTRONIX                      <ESC>[?38h
  NOTEKTRONIX                    <ESC>[?38l
  TEKTRONIX2                     <ESC>%!0
  NOTEKTRONIX2                   <ESC>%!2
  VT52                           <ESC>[?2l<ESC>\
  SUFFIX="string"                user specified string in "hot-key"
                                 format.

2.7.3  –  Default

  The following sequences are sent to the watcher's terminal to reset
  its state before the /FINISH_SEQUENCE (if any) is output:

     VT200/300/400:
                 1       ESC \           String terminator for DCS.
                 2       ESC <           Switch into ANSI mode.
                 3       ESC [ ! p       Reset everything.
                 4       ESC [ 1 3 2 H   Go to bottom of screen.
                 5a      ESC >           Turn off application keypad.
                 5b      ESC =           Turn on application keypad.
                 6a      ESC [ ? 3 l     Switch to 80 column mode.
                 6b      ESC [ ? 3 h     Switch to 132 column mode.
     VT100:
                 1       ESC \           String terminator for DCS.
                 2       ESC <           Switch into ANSI mode.
                 3       ESC ( B         Set G0 to US ASCII.
                 4       SI              Switch into G0.
                 5       ESC [ r         Reset scrolling region.
                 6       ESC [ m         Turn off graphic rendition.
                 7       ESC [ 1 3 2 H   Go to bottom of screen.
                 8a      ESC >           Turn off application keypad.
                 8b      ESC =           Turn on application keypad.
                 9a      ESC [ ? 3 l     Switch to 80 column mode.
                 9b      ESC [ ? 3 h     Switch to 132 column mode.

     VT52 mode:          As above based on type of terminal (VT100 vs
                         VT200/300/400) plus the following:

                 ESC [ ? 2 l     Switch from ANSI mode into VT52 mode

     Where there is an (a) or (b) choice, just the one which corresponds
     to the terminal driver setting when Peek was started will be output.

3  –  Terminal-Logging

   Peek/Spy allows terminal-logging.

   Terminal-logging makes a disk log file of all output sent to the terminal.

   Terminal-logging on both VAX and AXP is done using the SAVE_SCREEN
   subcommand. See the PEEK Subtopic: Commands SAVE_SCREEN.

   Terminal-log files can be made permanent so the user cannot turn off
   the logging. See the PEEK Subtopic: Commands SAVE_SCREEN /PERMANENT.

4  –  Overview

   Peek/Spy have been designed to have the following features:

   + Peek always warns a user that he is being watched. Peek will also
     periodically remind a user of this while he is being watched.

   + Spy does not warn a user; the user will not know he is being
     watched.

   + Peek users normally must have system privileges (SYSPRV and SECURITY)
     or explicit permission from the user being watched (or from the system
     manager) before they are allowed to watch another user.

   + Spy users normally must have system privileges (SYSPRV and SECURITY);
     users do not grant permission to be watched by Spy.

   + Users who do not have SYSPRV and SECURITY can use Peek/Spy if Peek or
     Spy has been installed with SYSPRV and SECURITY. In this case an
     Access Control List may be used to restrict access.

   + Peek/Spy displays various status information relating to the target
     process and terminal before starting to watch a user.

   + Peek/Spy allows a watcher to browse thru a list of terminals,
     processes, usernames, or everyone on the system. Wildcards may be
     used in these these lists, including wildcards in DECnet nodenames.

   + Keyboard control with Peek/Spy:

         + may be simultaneously shared between both terminals
         + may be passed back and forth between the two terminals
           with only one keyboard active at a time.
         + may be locked so that the watcher may NOT change any
           of the user's data (only with Peek).
         + All keyboard control can optionally be disallowed for
           high security installations (with both Peek and Spy).

   + Peek allows a user being watched to terminate the watching by pressing
     a hot-key. (Only for PEEK, not for SPY.)

   + An output log-file may be created which records all output sent
     to the user's screen.

   + Peek/Spy may be run from a terminal which is connected directly to
     the computer, or thru a terminal server, or from a DECwindows DECterm
     window, or from a DECnet "remote terminal" as created by SET HOST.

     These same types of terminals may also be watched with Peek/Spy.
     (For RTA terminals to be watched, an AXP Peek/Spy $ PEEK/SAVE_SCREEN
     command, or a VAX Peek/Spy $ PEEK/RT_ENABLE command, must first be
     issued from the RTA terminal).

   + A variety of other features allow users and system managers to
     configure PEEK's options to their liking.

   + A journal file keeps track of who's watching who, when the watching
     starts and stops, what terminals are used, etc.

   + Nodenames are supported, including standard VMS wildcards, for
     watching other terminals across a DECnet network, providing the
     target system is also running Peek/Spy.

5  –  Defaults

   Many of the Peek/Spy command qualifiers may have default values supplied
   for them via logical names.

   These logical-name default values are usually defined system-wide by the
   PEEK_DEFAULTS.COM file.

   It is also possible to customize these logical-name default values in
   ones own logical name tables.

   PEEK_DEFAULTS.COM defines the logical name table search list
   LNM$PEEK_TABLE_SEARCH_LIST. This table search list specifies the
   tables which are searched for logical-name default values. These
   tables are searched in the order specified by this logical name.

   As shipped, PEEK_DEFAULTS.COM defines LNM$PEEK_TABLE_SEARCH_LIST to
   search the LNM$PROCESS, LNM$JOB and LNM$GROUP logical name tables,
   in that order, before checking for a system-wide default value in
   the table LNM$PEEK_DEFAULT.

   See the PEEK_DEFAULTS.COM file for more information.

6  –  Full Initial Screen Display

   PEEK and SPY have a "screen-saver" feature that may be used to allow
   the watcher to see the initial contents of a user's screen when watching
   begins.

   Since VMS does NOT store the screen contents, and since the VMS terminal
   driver just "throws away" output buffers when its done with them,
   normally there is no way to see what is currently on a user's screen
   when one first begins watching.

   Peek/Spy could, however, be used to take control of the user's screen
   and keyboard, and then enter a refresh-screen sequence to the active
   program to tell it to redisplay the screen's current contents.

   The drawback with this approach is that there are many VMS programs
   (including DCL and many home-grown menu systems) which do NOT have
   any screen-refresh command programmed into them, so this technique
   doesn't ALWAYS work.

   Thus for version 2.0 and upward of Peek/Spy we have added the capability
   of saving the screen contents for selected users on your system so one
   gets a full intial-screen display when one starts watching the user.

   The way this is done differs for the VAX and the ALPHA.

6.1  –  ALPHA

     For the ALPHA screen-saving is done as follows:

       For each user for whom you wish to save the screen contents,
       issue the following commands in his LOGIN.COM command file:

               $ PEEK :== $ PEEK$LOCATION:PEEK_V6
               $ PEEK /SAVE_SCREEN

       These same commands may be added to the SYS$MANAGER:SYLOGIN.COM
       file instead, if you wish to save the screens for everybody.

       The /SAVE_SCREEN can also take a /LOG_FILE qualifier to make
       a log file of everything that is sent to the screen. See the
       top-level PEEK Subtopic: Commands SAVE_SCREEN.

6.2  –  VAX

     For the VAX screen-saving is done as follows:

       A) Install MultiSessions from the same distribution tape as PEEK
          was shipped on. See the quick installation sheet for that
          product or use the following command:

               $ @SYS$UPDATE:VMSINSTAL MS MSA0:

       B) Start MultiSessions, using the following command:

               $ @SYS$SYSDEVICE:[MULTISESSIONS]MS_STARTUP

       C) For each user for whom you wish to save his screen contents,
          issue the following commands in his LOGIN.COM command file:

          $ MS*UTIL :== $ MS$LOCATION:MSUTIL_V5
            (or MSUTIL_V4 If you are using VMS version 4)
          $ MS PEEK_ONLY /OPTIONS=(BROADCAST_REFRESH,ORIG_TERM,NOSTATUS)

          These same commands may be added to the SYS$MANAGER:SYLOGIN.COM
          file instead, if you wish to save the screens for everybody.

   If a user is already using MultiSessions, these steps should be
   skipped as Peek/Spy will already be able to display his initial
   screen contents.

   Note that the PEEK_ONLY mode of starting MultiSessions does NOT allow
   the user to create extra sessions, or allow him to print his screen.
   It merely saves his screen for Peek/Spy to display when you first
   start watching his terminal. PEEK_ONLY may be issued by licensed users
   of Peek/Spy without having to receive any extra license keys for
   MultiSessions.

7  –  Hot-Keys

   Hot-keys are used to control Peek/Spy while watching or being watched.
   They are used to end watching, toggle input control, etc.

   Hot-keys can be defined as logical names or on a Peek/Spy command line.

   The Peek/Spy SHOW KEYS command displays currently defined hot-keys.

7.1  –  Syntax

   Hot-Key String Syntax

   Hot-key definitions are composed of one or more keystrokes. The first
   character of a hot-key string may not be alphanumeric.

   For a hot-key definition which consists of more than one keystroke,
   the first keystroke will usually be a control character, a function
   key, or some other infrequently used key on your keyboard.

   The syntax for specifying a control character is to enclose the control
   character name in angle brackets. For instance, "<ESC>" is used for an
   escape character, and "<CTRL-D>" is used for a Control-D character.

   For a full list of available character names, see the PEEK Hot-Keys
   Subtopic: Character-Codes.

   Hot-key strings may be up to 16 characters long.

   Note: "<ESC>" would be counted as one character, whereas, "<F6>" is
   counted as 5 characters since it actually generates the string
   "<ESC>{17".

   All hot-key strings should be surrounded by double quotes. If you wish
   to put a double quote into a string, you must enter two double quotes
   within the enclosing double quotes. E.g. /END_WATCH="<CTRL-A>"""

   The above means that watching will be terminated when the user types a
   Control A followed by a double quote character.

   Hot-key strings which include alphabetic characters are handled in such
   a way that the case of the alphabetic character is ignored. For example,
   the recognition string "<ESC>A" will also be recognized as "<ESC>a".

   To make hot-key definitions case-sensitive, precede the character with
   a backwards slash. For example, "<ESC>\a" will be recognized ONLY when
   an escape is followed by a lowercase letter A.

   In order to place a backslash ("\" or a less-than symbol  ("<") into a
   string, enter two of them in a row. E.g. END_WATCH="<CTRL-P>\\".

7.2  –  Character-Codes

   Character name(s) accepted                     Hex value

   <SOH>                           <CTRL-A>          01
   <STX>                           <CTRL-B>          02
   <ETX>                           <CTRL-C>          03
   <EOT>                           <CTRL-D>          04
   <ENQ>                           <CTRL-E>          05
   <ACK>                           <CTRL-F>          06
   <BEL> or <BELL>                 <CTRL-G>          07
   <BS>                            <CTRL-H>          08
   <TAB> or <HT>                   <CTRL-I>          09
   <LF>                            <CTRL-J>          0A
   <VT>                            <CTRL-K>          0B
   <FF>                            <CTRL-L>          0C
   <CR>                            <CTRL-M>          0D
   <SO>                            <CTRL-N>          0E
   <SI>                            <CTRL-O>          0F
   <DLE>                           <CTRL-P>          10
   <DC2>                           <CTRL-R>          12
   <DC4>                           <CTRL-T>          14
   <NAK>                           <CTRL-U>          15
   <SYN>                           <CTRL-V>          16
   <ETB>                           <CTRL-W>          17
   <CAN>                           <CTRL-X>          18
   <EM>                            <CTRL-Y>          19
   <SUB>                           <CTRL-Z>          1A
   <ESC> or <CTRL-LEFT-BRACKET>    <CTRL-[>          1B
   <FS>  or <CTRL-BACKSLASH>       <CTRL-\>          1C
   <GS>  or <CTRL-RIGHT-BRACKET>   <CTRL-]>          1D
   <US>  or <CTRL-CARET>           <CTRL-^>          1E
   <RS>  or <CTRL-UNDERSCORE>      <CTRL-_>          1F
   <DEL>                                             7F

   The minus characters ("-") after "CTRL" may be replaced by a "/"
   characters. For example, "<CTRL-LEFT-BRACKET>" is equivalent to
   "<CTRL/LEFT-BRACKET>".

7.3  –  Tips

   Control Characters to Avoid In PEEK & SPY Hot-Key Sequences

   Different control characters have special functions on a standard
   VT-series terminal. Some of these should not be used as part of
   hot-key sequences for PEEK & SPY.

   The following table lists control characters which have a special
   meaning to VMS. If any of these characters are used by PEEK & SPY,
   then you may have trouble activating the corresponding VMS or program
   function while using PEEK & SPY. Note that some of these may be used
   in the PEEK_DEFAULTS.COM file as supplied on the software distribution.
   If they conflict with other key usage on your system you will most
   likey want to change the definitions in PEEK_DEFAULTS.COM.

   The NULL, XON and XOFF characters will NOT be recognized in
   PEEK & SPY hot-key sequences and should not be specified.

   Other characters from this list MAY be used, but may create
   undesirable effects.

   Not Recommended:

   Control  Character    Function

   CTRL-@   NULL         Ignored by most programs including PEEK & SPY.
                         (Always ignored in hot-key sequences).
   CTRL-A                VMS line editing - toggle insert/overtype modes.
   CTRL-B                VMS line editing - recall prior command line.
   CTRL-C                Used by VMS to cancel input for most programs.
   CTRL-D                VMS line editing - move cursor one position to
                         the left.
   CTRL-E                VMS line editing - move cursor to end of line.
   CTRL-F                VMS line editing - move cursor one position to
                         the right.
   CTRL-H   BACKSPACE    VMS line editing - move cursor to the beginning
                         of the line.
   CTRL-I   TAB          Horizontal tab character.
   CTRL-J   LINE-FEED    VMS line editing - delete prior word.
   CTRL-M   RETURN       Carriage-return - used to end an input sequence.
   CTRL-O                Tells VMS to discard terminal output.
   CTRL-P                Used to halt certain CPUs when entered at the
                         OPA0 console terminal. (NOTE: If the CPU halts
                         when CTRL-P is pressed, the CONTINUE command
                         should be entered at the >>> prompt which is
                         displayed while the CPU is halted.)
   CTRL-Q   XON or DC1   Transmit on  - for terminal flow control.
                         (Always ignored in hot-key sequences).
   CTRL-R                VMS line editing - Re-displays current input.
   CTRL-S   XOFF or DC3  Transmit off - for terminal flow control.
                         (Always ignored in hot-key sequences).
   CTRL-T                Displays a line of statistics if a DCL
                         $ SET CONTROL=T command was done earlier.
   CTRL-U                Used by VMS to discard current line of typeahead.
   CTRL-V                Used by DCL to enable quoting of following
                         keystroke.
   CTRL-X                Used by VMS to discard all current typeahead.
   CTRL-Y                Used by VMS to interrupt program operation.
   CTRL-Z                Used as an end-of-file or exit command for many
                         VMS programs.
   CTRL-[   ESCAPE       Used as part of the sequences generated by any
                         of the function and keypad keys. Escape may be
                         used as part of a complete sequence, but in
                         general should not be used by itself as a
                         single character control sequence.
   CTRL-\                Used to tell SET HOST/DTE to end a connection to
                         a remote system.
   DEL      DELETE       VMS line editing - delete prior character.

   The following characters currently are not used by DCL and may be
   employed in PEEK & SPY control sequences:

   Recommended:

   CTRL-G  CTRL-K  CTRL-L  CTRL-N  CTRL-W  CTRL-\
   CTRL-]          CTRL-_          CTRL-~

   Printable text characters may be used as part of a hot-key sequence
   but should NOT be used as the initial character in such a sequence.

7.4  –  Illegal Key Defintions

   Certain keyboard function keys do NOT send anything to
   the computer. Thus NONE of the following should be used
   as part of a hot-key string: F2, F3, F4, F5.

   In addition, there are certain keys which do NOT have a
   CTRL value associated with them. The numeric keys are like
   this, as are many of the punctuation and keypad keys.

   Here is a list of ILLEGAL key definitions:

         CTRL-0  CTRL-1  CTRL-2  CTRL-3  CTRL-4  CTRL-5  CTRL-6
         CTRL-7  CTRL-8  CTRL-9  CTRL-!  CTRL-@  CTRL-#  CTRL-$
         CTRL-%  CTRL-&  CTRL-*  CTRL-(  CTRL-)  CTRL--  CTRL-+
         CTRL-=  CTRL-.  CTRL-,  CTRL-> CTRL-<

8  –  INPUT ONLY watching

   /INPUT_ONLY can be used with SPY to skip watching terminal output and
   instead watch only the user's input keystrokes.

   The /DISPLAY_TYPE qualifier allows you to chose the format in which
   control characters are displayed during input-only watching or logging.

   Your site must be licensed to use input-only and any watcher and the user
   being watched must have been authorized by the system manager for
   input-only watching since passwords and other non-echoed input are
   displayed during input watching.

   Rights-list Identifiers are used to specify who may watch, or be watched,
   with /INPUT_ONLY. The Rights-list Identifiers used are
   SPY$INPUT_WATCHER and SPY$INPUT_WATCHEE.

   Any user using the input-watching feature to watch another with SPY
   must have been granted the Rights-list Identifier SPY$INPUT_WATCHER.

   Any user who is going to be watched /INPUT_ONLY with SPY must have been
   granted the Rights-list Identifier SPY$INPUT_WATCHEE.

   For help on /INPUT_ONLY watching, see the top-level PEEK Subtopic:
   Watching /INPUT_ONLY.

   INPUT_ONLY terminal-logging is done using NDC's KeyCapture product.

8.1  –  License-Option

   You must get a special license key from NDC in order to do input
   watching or logging.

   A PEEK/SHOW LICENSE command will display whether your site has enabled
   the input-only watching/logging feature in PEEK or SPY.

   If your site is licensed for INPUT_ONLY, then to use this feature both
   any watcher and the user/logger must have been granted the proper
   rights-ids.

   For more information, see the PEEK INPUT_ONLY_watching_and_logging
   Subtopic: Rights-IDs.

   GREAT CARE SHOULD BE USED WHEN LICENSING THE INPUT-ONLY FEATURE SINCE
   IT ALLOWS THE WATCHING OR LOGGING OF PASSWORDS AND OTHER NON-ECHOED
   INPUT.

8.2  –  Rights-IDs

   If your site is licensed to use the Input-Only feature then input-only
   watching/logging can be authorized for specific users by granting them
   the proper rights-ids.

   For being watched by SPY with /INPUT_ONLY the ID is SPY$INPUT_WATCHEE.

   For watching with SPY using /INPUT_ONLY the ID is SPY$INPUT_WATCHER.

   To add these identifiers to the system rights database use the
   AUTHORIZE commands ADD/IDENTIFIER SPY$INPUT_WATCHER, and
   ADD/IDENTIFIER SPY$INPUT_WATCHEE.

   To then grant these identifiers to specific users, use an AUTHORIZE
   command in the form of GRANT /IDENTIFIER PEEK$INPUT_WATCHER J_JONES

   GREAT CARE SHOULD BE USED WHEN GRANTING THESE IDENTIFIERS SINCE THEY
   ALLOW THE WATCHING OF PASSWORDS AND OTHER NON-ECHOED INPUT.

9  –  Node Names

   Peek/Spy accepts nodenames in the targets of its PEEK, SPY, WATCH
   and SHOW USERS commands.

   Use a standard VMS DECnet node specification ending with a double colon.
   This may contain an accesss control string per standard VMS DECnet rules.

   Peek/Spy must be running on the target node, and the PEEK and SPY
   objects/applications must be defined for DECnet on the target nodes.
   See the PEEK Node_Names Subtopic: Set-up.

   Examples:

   $ PEEK NODEA::J_DOE                     ! Watch process J_DOE on NODEA.
   $ SPY NODEA"SYSTEM SYSPASS"::J_DOE      ! SPY via SYSTEM account on NODEA.
   $ SPY/TERM=(NODEA::LTA*,NODEB::LTA*)    ! Watch LTAs on NODEA and NODEB.
   $ PEEK/SHOW USERS NODEA::J_DOE,P_SMITH  ! Show these two users on NODEA.

   Standard VMS * and % wildcards are allowed in the nodename portion of
   a target specification (providing PEEK has been configured for use of
   wildcards in nodenames). See the PEEK Node_Names Subtopic: Wildcards.

9.1  –  Watching

   In a list of target specifications on a PEEK, SPY or WATCH command,
   different nodenames can be prepended to each target in the list. A
   nodename, if present, applies only to the single target specification
   to which it is prepended.

   Examples:

     $ PEEK/TERMINAL=(TTA1:,NODEA::TTA1:,TTA2:)

   In this example, first TTA1 on the current network node will be
   watched. Then TTA1 on NODEA will be watched. Then TTA2 on the
   current node will be watched.

     $ PEEK/USERNAME=(NODEA::*,P_SMITH)

   In this example, first users on NODEA will be watched. Then user
   P_SMITH on the current node will be watched.

   For more information, see the top-level PEEK Subtopic:
   Watching Node_Names.

9.2  –  Showing Users

   For PEEK/SHOW USERS, only a single leading nodename may be used.

   This single leading nodename applies to all of the following user
   specifications on the SHOW USERS command line.

   Example: $ PEEK/SHOW USERS NODEA::J_DOE,P_SMITH

   In this example, Peek will show users J_DOE and P_SMITH on NODEA.

   Wildcards may still be used in the single leading nodename in a
   SHOW USERS command. See the top-level PEEK Subtopic:
   Commands SHOW USERS.

9.3  –  Security

   All of the standard DECnet security features are supported, including
   access-control strings within node specifications, incoming and
   outgoing proxy login access, etc.

   Example of an access-control string in a node specificiation:

          $ PEEK NODEA"USERB PASSWORDB"::J_DOE

   Peek will be run from the account USERB on NODEA and will watch
   process J_DOE on NODEA.

9.4  –  Set-up

   Peek/Spy must have been started on the target DECnet node, and PEEK
   and/or SPY must have been added to the DECnet network database on
   the target node as a known network objects/applications.

   The commands to define Peek/Spy as network objects/applications
   are different for DECnet Phase IV and DECnet Phase V.

9.4.1  –  IV-Phase-DECnet-Setup

   PEEK can be added as a known object via NCP on a target node either
   permanently or temporarily using the NCP DEFINE or SET command.

   The basic NCP commands to add the PEEK object on a target node
   permanently are:

    $ RUN SYS$SYSTEM:NCP
    NCP> DEFINE OBJECT PEEK NUMBER 0 FILE PEEK$LOCATION:PEEKNET_Vx.EXE

   For SPY use:

    NCP> DEFINE OBJECT SPY NUMBER 0 FILE PEEK$LOCATION:SPYNET_Vx.EXE

   To permanently enable both incoming and outgoing proxy access to PEEK
   and SPY on a target node use:

    NCP> DEFINE OBJECT PEEK NUMBER 0 -
                FILE PEEK$LOCATION:PEEKNET_Vx.EXE PROXY BOTH
    NCP> DEF OBJECT SPY  NUMBER 0 -
                FILE PEEK$LOCATION:SPYNET_Vx.EXE  PROXY BOTH

   Note that the correct VMS version number for your system (_V5 _V6 _V7)
   must replace the _Vx in the file specifications above. Also note that
   the .EXE suffix is required syntax on the file specification.

   Use SET instead of DEFINE in the above NCP commands if you only want
   the PEEK/SPY objects added to the network datebase temporarily, not
   permanently.

   See the appropriate VMS Networking manual for more information about
   granting access to PEEK as a network object, and for the appropriate
   NCP commands for doing this, based on the security considerations of
   your site.

9.4.2  –  V-Phase-DECnet-Setup

   The following is a typical DECnet Phase V application setup for
   PEEK and SPY. These commands were generated by the conversion of
   the Phase IV NCP commands listed in the PEEK Node_Names Set-up
   Subtopic: IV-Phase-DECnet-Setup.

    $ RUN SYS$SYSTEM:NCL.EXE
    CREATE NODE 0 SESSION CONTROL APPLICATION PEEK
    SET NODE 0 SESSION CONTROL APPLICATION PEEK NODE SYNONYM TRUE
    SET NODE 0 SESSION CONTROL APPLICATION PEEK INCOMING PROXY TRUE , -
        OUTGOING PROXY TRUE
    SET NODE 0 SESSION CONTROL APPLICATION PEEK IMAGE NAME -
        PEEK$LOCATION:PEEKNET_V7.EXE
    SET NODE 0 SESSION CONTROL APPLICATION PEEK ADDRESSES { NAME = PEEK }
    CREATE NODE 0 SESSION CONTROL APPLICATION SPY
    SET NODE 0 SESSION CONTROL APPLICATION SPY NODE SYNONYM TRUE
    SET NODE 0 SESSION CONTROL APPLICATION SPY INCOMING PROXY TRUE , -
         OUTGOING PROXY TRUE
    SET NODE 0 SESSION CONTROL APPLICATION SPY IMAGE NAME -
         PEEK$LOCATION:SPYNET_V7.EXE
    SET NODE 0 SESSION CONTROL APPLICATION SPY ADDRESSES { NAME = SPY }
    $ EXIT

   These commands are in the file PEEK_SPY_NET$NCP_APPLICATIONS.COM
   which is included with your Peek/Spy distribution.

   You can enable this typical application setup for DECnet Phase V
   by executing this command file. You may also add this to your
   SYSTARTUP_VMS.COM if you always want to have the PEEK/SPY
   applications defined for DECnet Phase V. NET$CONFIGURE.COM may
   also be used to add the PEEK/SPY applications to DECnet.

   See the appropriate VMS Networking manual for more information about
   granting access to PEEK as a network application, and for the
   appropriate commands for doing this, based on the security
   considerations of your site.

9.5  –  Wildcards

   Use of the standard VMS * and % wildcards within Peek/Spy nodename
   specifications is based on the correct configuration of the
   logical name PEEK_WILDCARD_NODES.

   This logical name is used by Peek/Spy to determine which DECnet
   nodes are available to be checked for a wildcard match during a
   wildcarded nodename operation.

   The multi-valued logical PEEK_WILDCARD_NODES should equate to
   the actual nodenames available to be checked, in the order they
   should be accessed, during a wildcarded nodename operation.

   The logical name PEEK_WILDCARD_NODES can be defined by the
   PEEK_DEFAULTS.COM file when starting up PEEK. PEEK_DEFAULTS.COM
   contains an example of the use of this logical name to control
   use of wildcarded nodenames.

   The PEEK_WILDCARD_NODES logical name as defined by PEEK_DEFAULTS.COM
   can also be superceded in any of the logical-name tables specified in
   LNM$PEEK_TABLE_SEARCH_LIST which is defined in PEEK_DEFAULTS.COM.
   This allows customization, for individual users or groups of users,
   of the nodes which are checked during wildcarded nodename operations.

   Example: $ DEFINE PEEK_WILDCARD_NODES NODE_A,NODE_F,NODE_C

   Placing the above command into one's LOGIN.COM would direct PEEK
   to check the nodes NODE_A, NODE_F and NODE_C, in that order,
   during a wildcarded nodename operation, to see if they match the
   wildcarded nodename specified in a PEEK command.

9.5.1  –  Forcing Network Access

   When using wildcards in nodenames, PEEK will skip accessing
   the network to watch processes on the current node.

   An exception to skipping network access for the local node occurs
   when there is an access control string in the wildcarded nodename
   specification, which does not match the current username.

   In this case, because the access control string requests a
   different username to do the watching, PEEK will use DECnet
   network access to PEEK on the local node.

   One can also force network access for the local node during a
   wildcarded nodename operation by specifying /FORCE_NETWORK_ACCESS
   on the command line, or by specifying the logical name
   WATCHER$FORCE_NETWORK_ACCESS as TRUE in any of the logical-name
   tables specified in LNM$PEEK_TABLE_SEARCH_LIST which is defined
   in PEEK_DEFAULTS.COM.

10  –  Version

   This help is for version 5.5.17 of PEEK.

   PROPRIETARY RIGHTS NOTICE:  All rights reserved.  This material
   contains the valuable properties and trade secrets of Networking
   Dynamics Corp. of Clearwater, Florida, United States of America
   (NDC) embodying substantial creative effort and confidential
   information, ideas and expressions, no part of which may be
   reproduced or transmitted in any form or by any means, electronic,
   mechanical, or otherwise, including photocopying and recording or
   in connection with any information storage or retrieval system
   without the permission in writing from NDC.

    COPYRIGHT NOTICE:
   Copyright (c) 1983, 1987-2011 an unpublished work by Networking
   Dynamics Corporation. All rights reserved.

11  –  Callable Interface

   The PEEK.EXE program as distributed with this version is a very simple
   program which just gets the command line with a call to LIB$GET_FOREIGN
   and then passes it to PEEKSHR, a sharable runtime library.

   You may use this interface to integrate PEEK into your own applications,
   making PEEK a part of your product. By specifying the facility name
   parameter, you may customize the error messages to use your product
   name as a prefix.

11.1  –  PEEKSHR

   PEEKSHR is a callable entry point in a protected shared image which
   allows you to call PEEK as a subroutine, from your own programs and
   menus. Note that PEEK.EXE calls this PEEKSHR passing it the command
   line which was entered as a DCL foreign command.

      Format:

        CALLS #5,G^PEEKSHR peekcmd ,actrtn ,facnam ,actprm ,outlen

      Arguments:

   peekcmd

   VMS usage: char_string
   type: character string
   access: read only
   mechanism: by descriptor--fixed length string descriptor

   Character string containing the PEEK command to be executed. The
   peekcmd argument is the address of a descriptor specifying the command
   string being passed to PEEKSHR. It must begin with the verb PEEK. The
   syntax rules for this command string are the same as for any command
   which PEEK would process from the DCL command prompt.

   peekcmd may not be passed as zero but the length in the descriptor of
   the command may be 0 which will cause PEEKSHR to prompt for a command
   interactively.

   actrtn

   CALLING OF THE USER'S ACTRTN IS NOT YET IMPLEMENTED FOR VERSION 4
   on AXP.

   VMS usage: procedure
   type: procedure entry mask
   access: call without stack unwinding
   mechanism: by reference

   User-supplied action routine to be executed during message
   processing. The actrtn argument is the address of the entry mask of
   this routine. If an actrtn is specified and the actrtn returns a
   success status (the low bit of R0 is set) then the message is output
   using $PUTMSG. If the actrtn returns a failure status, (the low bit
   of R0 clear) then no message is output. If specified as 0 then no
   actrtn is called and the messages are output by $PUTMSG.

   facnam

   VMS usage: char_string
   type: character-coded text string
   access: read only
   mechanism: by descriptor--fixed length string descriptor

   Facility prefix to be used in the first or only message written by
   $PUTMSG. The facnam argument is the address of a character string
   descriptor pointing to this facility prefix. If passed as 0 then
   PEEK is used as the facility name.

   actprm

   CALLING OF THE USER'S ACTRTN IS NOT YET IMPLEMENTED FOR VERSION 4
   on AXP.

   VMS usage: user_arg
   type: longword (unsigned)
   access: read only
   mechanism: by value

   Parameter to be passed to the action routine. The actprm is a
   longword value containing this parameter. If there is no
   parameter to pass then actprm should be specified as 0.

   outlen

   VMS usage: word_unsigned
   type: word (unsigned)
   access: write only
   mechanism: by reference

   The number of bytes in the command passed to PEEKSHR/SPYSHR is
   returned here unless the command passed was only "PEEK/COMMAND" or
   "SPY/COMMAND" in which case outlen is returned as zero indicating
   that there was no actual command passed and that a command was
   prompted for interactively and executed.  This is useful for
   determining whether or not to call PEEKSHR again in prompting mode.

   This argument must be passed as the address of a word in the calling
   program for which there is write access.

11.2  –  SPYSHR

   SPYSHR is a callable entry point in a protected shared image which
   allows you to call SPY as a subroutine, from your own programs and
   menus. Note that SPY.EXE calls this SPYSHR passing it the command
   line which was entered as a DCL foreign command.

   The arguments are the same as those for PEEKSHR except that commands
   passed to SPYSHR must begin with the verb SPY in the PEEKCMD argument.

12  –  Multiple-Watchers

   Beginning in Peek/Spy Version 4.6, more than one watcher is allowed
   to watch the same terminal, all at the same time.

   The first watcher who starts watching a particular terminal is
   designated the primary watcher.

   Any and all additional watchers who then start watching that same
   terminal are designated secondary watchers.

   A primary watcher has all of the normal Peek/Spy capabilities and
   hot-keys etc which a Peek/Spy watcher has always had in the past.

   Secondary watchers are passive. They may watch and end watching, but
   other hot-keys are disabled and keyboard control is not usually
   allowed, except via PERMIT_INPUT and REQUEST_INPUT. (See the
   top-level PEEK Subtopic: Permit-Input|Request-Input.)

   If there are additional (secondary) watchers also watching when a
   primary watcher ends watching, then the earliest secondary watcher
   becomes the new primary watcher.

   Any hot-keys, keyboard control, etc, which were disabled for the
   watcher as a secondary watcher, become functional when a secondary
   watcher becomes the new primary watcher.

13  –  Permit-Input|Request-Input

   It is now possible to temporarily permit a watcher to control your
   keyboard while you are being watched, even when the watcher would
   not normally be allowed keyboard control due to licensing or ALLOW
   command restrictions.

   Keyboard control can also be temporary permitted in this same way for
   a secondary watcher (who normally isn't permitted keyboard control).

   A primary watcher may also temporarily permit keyboard control by
   a secondary watcher.

   Several new hot-keys and qualifiers have been added which support
   this new feature.

   1. A PERMIT_INPUT hot-key for permitting a watcher to temporarily
      provide input when that watcher wouldn't otherwise be allowed to
      control the watched-user's keyboard. See the top-level PEEK
      Subtopics: Commands ALLOW /PERMIT_INPUT and Watching /PERMIT_INPUT.

   2. A REQUEST_INPUT hot-key for use by a watcher to request this
      ability to provide input. See the top-level PEEK Subtopic:
      Watching /REQUEST_INPUT.

   3. Special permitted-input versions of the WATCH-command qualifiers
      /SIMULTANEOUS_INPUT and /NOBEEP. The /PSIMUL and /PNOBEEP
      qualifiers (and their defaults) control the simultaneous-input
      and nobeep settings which apply as a permitted watcher. These
      qualifiers were added so the behaviors of simultaneous-input and
      nobeep can be specified as different when one is a permitted watcher
      vs when one is a full watcher. See the top-level PEEK Subtopics:
      Watching /PNOBEEP and Watching /PSIMUL_INPUT.

   These new hot-keys and qualifiers are usually assigned system-wide
   default values by PEEK_DEFAULTS.COM. The Peek/Spy command
   SHOW KEYS displays all of the currently-defined hot-key values.

   The guidelines to follow when temporarily permitting keyboard
   control are listed separately below for a user being watched
   and for a primary watcher.

13.1  –  User-being-watched

   For a person being watched to temporarily permit keyboard control by
   a watcher who could not otherwise have it:

   1. To successfully use the PERMIT_INPUT hot-key to temporarily permit
      a watcher to have keyboard control, the user being watched must
      currently have control of his keyboard.

   2. Enter the PERMIT_INPUT hot-key.

      As shipped, the default hot-key value for PERMIT_INPUT is
      <CTRL-P>A. (The obvious choice, <CTRL-P>P, is already in
      use for /PREVIOUS, so <CTRL-P>A was chosen instead. The
      "A" stands for ALLOW which is a synonym for PERMIT.)

   3. If the hot-key is accepted, this means the PERMIT_INPUT was
      successful and a watcher will now be able to do a REQUEST_INPUT.

      The hot-key will just beep if the PERMIT_INPUT isn't accepted.

      (PERMIT_INPUT will not be accepted if the hot-key is not defined,
      or if you are currently being watched with Peek/Spy and the
      watcher currently has control of your keyboard.)

   4. After a successful PERMIT_INPUT has been done by the user being
      watched, a watcher who wants temporary keyboard control can use
      his REQUEST_INPUT hot-key to request it.

   5. If the REQUEST_INPUT by the watcher is accepted, he will be able
      to use his TOGGLE_INPUT key to toggle input with the user he is
      watching.

      Or if the permitted watcher has PSIMUL, then both the permitted-
      watcher and the user being watched will be able to type at the
      same time. (See the top-level PEEK Subtopic: Watching
      /PSIMUL_INPUT.)

   6. If the REQUEST_INPUT hot-key entered by the watcher just beeps,
      this means his REQUEST_INPUT wasn't successful.

      This could mean that another watcher has already requested, and
      been granted, temporary keyboard control. (Only one watcher at
      a time may have REQUEST_INPUT.)

      Or it could mean that the PERMIT_INPUT has been revoked.

   7. PERMIT_INPUT is revoked when the user being watched toggles
      his PERMIT_INPUT back off again by entering his PERMIT_INPUT
      hot-key a second time.

      If there is a primary watcher, PERMIT_INPUT granted by the user
      being watched is also revoked whenever the primary watcher takes
      over keyboard control.

   8. A permitted watcher who currently has REQUEST_INPUT can
      relinquish it at any time by entering his REQUEST_INPUT
      hot-key a second time.

      This would allow another watcher to then do a REQUEST_INPUT in
      order to gain temporary keyboard control.

13.2  –  Primary-watcher

   For a primary watcher to temporarily permit keyboard control by a
   secondary watcher:

   1. To successfully use the PERMIT_INPUT hot-key to temporarily permit
      keyboard control by a secondary watcher, the primary watcher must
      currently have control of the keyboard of the user being watched.

   2. Enter the PERMIT_INPUT hot-key.

      As shipped, the default hot-key value for PERMIT_INPUT is
      <CTRL-P>A. (The obvious choice, <CTRL-P>P, is already in
      use for /PREVIOUS, so <CTRL-P>A was chosen instead. The
      "A" stands for ALLOW which is a synonym for PERMIT.)

   3. If the hot-key is accepted this means the PERMIT_INPUT was
      successful and a secondary watcher will now be able to do
      a REQUEST_INPUT.

      The PERMIT_INPUT hot-key will just beep if it isn't accepted.

      (PERMIT_INPUT will not be accepted if the hot-key is not defined,
      or if the primary watcher doesn't currently have keyboard control.)

   4. After a successful PERMIT_INPUT has been done by the primary
      watcher, a secondary watcher who wants temporary keyboard
      control can use his REQUEST_INPUT hot-key to request it.

   5. If a REQUEST_INPUT by a secondary watcher is accepted, he
      will be able to use his TOGGLE_INPUT key to toggle input with
      the primary watcher.

      Or if the permitted watcher has PSIMUL, then both the permitted-
      watcher and the primary watcher will be able to type at the same
      time. (See the top-level PEEK Subtopics: Watching /PSIMUL_INPUT.)

   6. If the REQUEST_INPUT hot-key entered by the secondary watcher
      just beeps, this means his REQUEST_INPUT wasn't successful.

      This could mean that another secondary watcher has already
      requested, and been granted, temporary keyboard control.
      (Only one secondary watcher at a time may have REQUEST_INPUT.)

      Or it could mean that the PERMIT_INPUT has been revoked.

   7. PERMIT_INPUT is revoked when the primary watcher toggles his
      PERMIT_INPUT back off again by entering his PERMIT_INPUT
      hot-key a second time.

      A PERMIT_INPUT done by the primary watcher is also revoked
      whenever the user being watched takes back control of the
      keyboard from the primary watcher.

   8. A permitted watcher who currently has REQUEST_INPUT can
      relinquish it at any time by entering his REQUEST_INPUT
      hot-key a second time.

      This would allow another secondary watcher to then do a
      REQUEST_INPUT in order to gain temporary keyboard control.
Close Help