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.