(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 – 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.
2 – Qualifiers
2.1 /BACKGROUND
AXP-Only... /[NO]BACKGROUND Synonymous with the /SINGLE_WINDOW and /WINDOW qualifiers. See the PEEK Commands ALLOW Subtopic: /SINGLE_WINDOW.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
2.16 /WINDOW
AXP-Only... /[NO]WINDOW Synonymous with the /BACKGROUND and /SINGLE_WINDOW qualifiers. See the PEEK Commands ALLOW Subtopic: /SINGLE_WINDOW.