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.
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 – 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.
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.
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.
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.
6 – Qualifiers
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.
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.)
6.3 /BACKGROUND
AXP-Only... /[NO]BACKGROUND /BACKGROUND is synonymous with the /SINGLE_WINDOW and /WINDOW qualifiers. See the PEEK Watching Subtopic: /SINGLE_WINDOW.
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.
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).
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.
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
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.
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.
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.
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.
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
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 *::*
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
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.
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
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
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
6.36 /WINDOW
AXP-Only... /[NO]WINDOW /WINDOW is synonymous with the /BACKGROUND and /SINGLE_WINDOW qualifiers. See the PEEK Watching Subtopic: /SINGLE_WINDOW.
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.
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.
7.1.1 – 132COLUMN
Outputs "<ESC>[?3h"
7.1.2 – 80COLUMN
Outputs "<ESC>[?3l"
7.1.3 – APPLICATION
Outputs "<ESC>="
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.
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>}"
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>}"
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>\|\".
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>|".
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>}".
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")
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=">")
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".
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>|".
7.1.14 – CLEAR
Outputs "<ESC>[H<ESC>[J"
7.1.15 – EIGHT_BIT
Outputs "<ESC> G"
7.1.16 – INSERT
Outputs "<ESC>[4h"
7.1.17 – NOINSERT
Outputs "<ESC>[4l"
7.1.18 – INVERSE
Outputs "<ESC>[?5h"
7.1.19 – NOINVERSE
Outputs "<ESC>[?5l"
7.1.20 – NATIONAL
Outputs "<CSI>?42h"
7.1.21 – NONATIONAL
Outputs "<CSI>?42l"
7.1.22 – NONE
The keyword NONE is used to specify that there is no /INIT or /FINISH sequence.
7.1.23 – NUMERIC
Outputs "<ESC>>"
7.1.24 – ORIGIN
Outputs "<ESC>[?6h"
7.1.25 – NOORIGIN
Outputs "<ESC>[?6l"
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")
7.1.27 – PREF_DEC
Outputs "<DCS>0!u%5<ST>"
7.1.28 – PREF_ISO
Outputs "<DCS>1!uA<ST>"
7.1.29 – REGIS
Outputs "<ESC>Pp"
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".
7.1.31 – NOSCROLL
Outputs "<ESC>[r"
7.1.32 – SEVEN_BIT
Outputs "<ESC> F"
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")
7.1.34 – STATUS_INDICATOR
Outputs "<ESC>[1$~"
7.1.35 – STATUS_LINE
Outputs "<ESC>[2$~"
7.1.36 – NOSTATUS_LINE
Outputs "<ESC>[0$~"
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.
7.1.38 – STATUS_END
Outputs "<ESC>[0$}"
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")
7.1.40 – TEKTRONIX
Outputs "<ESC>[?38h"
7.1.41 – NOTEKTRONIX
Outputs "<ESC>[?38l"
7.1.42 – TEKTRONIX2
Outputs "<ESC>%!0"
7.1.43 – NOTEKTRONIX2
Outputs "<ESC>%!2"
7.1.44 – VT100
Outputs "<ESC><"
7.1.45 – VT200
Outputs "<ESC><<ESC>["62;1p"
7.1.46 – VT300
Outputs "<ESC><<ESC>["63;1p"
7.1.47 – VT400
Outputs "<ESC><<ESC>["64;1p"
7.1.48 – VT52
Outputs "<ESC>[?2l<ESC>\"
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.
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.