Software development, photography, jokes, ....

Sites by me

 
tas-logoTransportation Administration System
snoezelkussen-logo-kleinstSnoezelkussens voor verstandelijk gehandicapten
ikzoekeenbegeleider-logoBegeleiders voor gehandicapten
Laat uw hond het jaarlijkse vuurwerk overwinnen
logo 50x50Hey Vos! Je eigen naam@vos.net emailadres?
Kunst in huis? Nicole Karrèr maakt echt bijzonder mooie dingen
nettylogo2Kunst in huis? Netty Franssen maakt ook bijzonder mooie dingen
Salarisadministratie en belastingadvies bij De Zaak Loont
Zutphense Bomenstichting

Hosting Favorites

 
ANU Internet Services
XelMedia .internet Services
register.com

Blogroll

 
Bomenstichting
LassoSoft
MacFreak
Quality that computes
The Economy of Motion
Wheel 2.0
IntrAktv



Website Hosting bij Xel Media

Marc's Place

1 PEEK

Allows one user to watch another user. Anything output to the terminal being watched will also be sent to the terminal of the watcher. The watcher may also enter input for the user he is watching. See the /TOGGLE_INPUT parameter for details. 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 it by using the PEEK/ALLOW qualifier. Format: Example: $ PEEK process_name_list $ PEEK PROCESS1,PROCESS2,PROCESS3 $ PEEK/IDENTIFIER=pid_list $ PEEK /ID=(12A,5F8,345) $ PEEK/TERMINAL=terminal_name_list $ PEEK /TERM=(LTA1262,TXA6) $ PEEK/USERNAME=user_name_list $ PEEK /USERNAME=(JONESJ,BREWERJ) 2 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. A node name may be prefixed to a process name (e.g. BOSTON::J_DOE), in which case PEEK attempts to watch the specified process on the specified network node. (PEEK must also be running on the target node.) Different node names can be prepended to each process name in the list, and standard VMS % and * wildcards can be used in node names providing PEEK has been configured to use wildcards in node names. (See the help on Node_Specifications.) A prepended node name applies only to the one process-name parameter 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. The process-name parameter may not be specified with the /IDENTIFICATION, /TERMINAL or /USERNAME qualifiers. 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. Any of the hot-keys specified by NEXT, PREVIOUS or END_WATCH may be pressed to cause the program to stop watching the current terminal. If NEXT or PREVIOUS is pressed then PEEK will attempt to start watching a next or previous terminal out of the list which was specified. If the END_WATCH sequence is pressed, or if there are no other processes to be watched, PEEK will stop watching. 2 Qualifiers /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 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. (Note: For Axp systems /APPEND is ignored for PEEK/SAVE/LOG when the /REOPEN feature is used.) /BACKGROUND AXP-Only... /[NO]BACKGROUND Determines whether background MS30 NDC terminal units can be watched. The default is determined by WATCHER$BACKGROUND in PEEK_DEFAULTS.COM. You can override that default with this qualifier. If NDC* terminals are excluded from wildcard operations per PEEK_DEFAULTS.COM or /EXCLUDE, then to watch NDC background units during wildcard operations you must additionally specify /NOEXCLUDE to override the exclusion of NDC units during wildcard operations. Note that the default behavior without /BACKGROUND is to see only the current foreground MS30 NDC unit whether or not wildcards are used. Examples: $ PEEK /TERM-NDC11 /BACKGROUND ! Watch terminal NDC11: $ PEEK /TERM=NDC* /NOEXCLUDE /BACKGROUND ! Watch all NDC terminals. /BEEP_TERMINAL /BEEP_TERMINAL = "string" 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. 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. For 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. /BYPASS_OUTPUT_TOGGLE /BYPASS_OUTPUT_TOGGLE = "string" 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 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 when watching a terminal on a slow modem line as one does not have to wait while the output goes out over the modem. A user can disable this feature when he issues the PEEK/ALLOW command to allow someone to watch him. See the /NOBP_OUTPUT qualifier for the PEEK/ALLOW command. 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 (PROCESS or JOB or GROUP or SYSTEM or PEEK_DEFAULT tables). For 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. See Appendix A of the PEEK manual for a more complete description of string syntax for use in specifying hot-key definitions. 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 TOGGLE_INPUT and/or SIMULTANEOUS_INPUT qualifiers). /CHAT_TOGGLE /CHAT_TOGGLE = "string" 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. For 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 TOGGLE_INPUT, which is still active during chat mode unless SIMULTANEOUS_INPUT is in use). 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. /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 - With the PEEK/SAVE_SCREEN feature added to PEEK 4.1 for AXP this qualifier is rendered obsolete for AXP 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. /COMMAND The /COMMAND qualifier can be used to switch into command mode when using the interactive prompting mode of PEEK and your system is not set up to use command mode as the default prompting mode. After entering the /COMMAND qualifier, you will not need to use the slash on the command line, but can enter the various commands as verbs. The qualifiers that are accepted as verbs in command mode are: ALLOW, ATTACH, DISALLOW, EXIT, FORMAT, HELP, INSTALL, LICENSE, NODE, PEEK, QUIT, REMOVE, SAVE_SCREEN, SHOW, SPAWN, WATCH. When in command mode you must use either the PEEK or WATCH verbs when you want to watch someone, e.g. "PEEK> WATCH JOE" not "PEEK> JOE". The qualifier form of all the above commands is also still accepted when in command mode, e.g. "PEEK> /WATCH JOE" is accepted. /CONFIRM /NOCONFIRM (default) This qualifier causes PEEK or SPY to ask the watcher for a confirmation before it starts watching any particular 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.) For example: 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 DCL or the PEEK> prompt. /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-only log file. CHARACTER displays just the input character as-is. DISPLAY displays control characters in reverse video character format. HEXIDECIMAL displays control characters in a reverse video <xx> format. PLAIN_HEX displays control characters in <xx> format. /END_WATCH /END_WATCH = "string" Defines a hot-key sequence which when pressed by the watcher will cause Peek/Spy to stop watching and exit back to the prompt. This is a required qualifier and must be specified either on the command line or in a logical name table (see below) or Peek/Spy will give an error message instead of starting to watch. For 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. See the section PEEK/ALLOW/END_WATCH for information relating to how a user may give a command to stop being watched. See Appendix A of the PEEK manual for a more complete description of string syntax for use in specifying hot-key definitions. /EXCLUDE_LIST /EXCLUDE_LIST = (terminal-name [,terminal-name ,... ,terminal_name]) /NOEXCLUDE Used to specify terminals which should be skipped over during a wildcard operation. You can override the defaults defined in PEEK_DEFAULTS.COM by specifying /NOEXCLUDE. 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 the default behavior without also specifying /BACKGROUND is to see only the current foreground MS30 NDC unit. /FINISH_SEQUENCE 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. See the help topic Init_and_Finish_Sequences for more information. /FORCE_NETWORK_ACCESS /[NO]FORCE_NETWORK_ACCESS When using wildcards in node names, PEEK 4.2.06 will skip accessing the network to watch processes on the current node. (PEEK 4.1.04 would go across the network to access the local node during a wildcarded nodename operation.) 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 user name. In this case, because the access requests a different user name to do the watching, PEEK will use network access to PEEK on the local node. One can also 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 in watcher's PROCESS,JOB, GROUP, or the SYSTEM or LNM$PEEK_DEFAULT logical name tables. /IDENTIFICATION /IDENTIFICATION = (process-ID [,process-ID ,... ,process-ID]) This qualifier may be used to specify either a process identification code (PID) to be watched, or in parenthesis a list of PIDs to be watched, one at a time in sequence, when the /NEXT and /PREVIOUS hot-key sequences are entered. Node names may also be prefixed to process-IDs using the :: syntax. Different node names can be used for different process-IDs in the list, and standard VMS * and % wildcards are supported in node names. Node names apply only to the single PID in a list to which they are prepended. (See the help on Node_Specifications.) For 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 network node BOSTON which has the PID 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 network 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 the PID. Note: On Alpha, with MS30, you can watch each individual NDC session, or you can track with the user as he switches sessions by watching the "MS Server*" process for that user. /INIT_SEQUENCE 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. When initial-screen-display is in use, the terminal-control sequences output by this qualifier have no real 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. See the help topic Init_and_Finish_Sequences for more information. /INPUT_ONLY Used with /SAVE_SCREEN/LOG with PEEK or SPY to start input-only terminal logging, where only the input keystrokes are logged. E.g. PEEK/SAVE_SCREEN/LOG/INPUT_ONLY or SPY/SAVE_SCREEN/LOG/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 Your site must be licensed to use input-only and any watcher and the 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 of the input-only control character display by using the /DISPLAY_TYPE qualifier. See the help topic INPUT-ONLY_watching_and_logging for more information. /LOG_FILE /LOG_FILE [= file_spec] This a synonymous with the /OUTPUT_LOG_FILE qualifier. See /OUTPUT_LOG_FILE. /NEXT /NEXT="string" This qualifier is used to define a hot-key sequence which when pressed by the watcher will cause PEEK to stop watching the current user and to watch the next user (if there is another user which matches the list that was specified). If wild cards were not used, or if a list of users was specified but there was only one user to be watched, then PEEK will exit. Thus, this causes Peek/Spy to do the END_WATCH function and then attempt to start watching the next user, if wild cards or a list of users were specified. For example: $ PEEK/NEXT="<CTRL-P>N" USER1 or $ DEFINE WATCHER$NEXT "<CTRL-P>N" $ PEEK USER1 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. /NOBEEP This qualifier prevents the bell from being rung on the terminal of the person being watched if you take over control of his keyboard when SIMULTANEOUS_INPUT has not been selected. When used with the SPY program the user will not be able to tell that his keyboard is being controlled, it will just appear to "go dead" (unless, of course, you enter some commands for him). /OUTPUT_LOG_FILE /OUTPUT_LOG_FILE [= file_spec] This specifies whether PEEK 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 specified by WATCHER$OUTPUT_LOG_FILE. If nothing is specified by this value 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 the watching is terminated by one of the END_WATCH, NEXT or PREVIOUS sequences. For example: $ PEEK /OUTPUT=SAVE_OUTPUT JONES AXP-Only... /OUTPUT[=file] can also be used with the /SAVE_SCREEN qualifier to create a log file containing everything output while screen-saving is in effect. If a log file is already being made then it can be closed with the PEEK/SAVE_SCREEN/CLOSE command. To close the current log file and start logging to a new log file the command PEEK/SAVE_SCREEN/LOG/NEW_FILE should be used. See also the REOPEN qualifier for PEEK/SAVE_SCREEN/LOG. If no file name is given in the /OUTPUT_LOG qualifier then PEEK will generate a file in the current default directory with a file name in one of these formats: PEEK_TRMLOG_username_terminal_name.LOG (for PEEK/SAVE_SCREEN/LOG) PEEK_TRMLOG_terminal_name.LOG (for PEEK/SAVE_SCREEN/LOG) The second name-format is used as a default file name format when SPY is used to turn on screen-saving for an unowned terminal. Terminal logging on AXP with /SAVE_SCREEN/OUTPUT is terminated by the PEEK/NOSAVE_SCREEN command, or the PEEK/SAVE_SCREEN/CLOSE command. For example: $ PEEK /SAVE/OUTPUT=SAVE_OUTPUT /PREVIOUS /PREVIOUS="string" This qualifier is used to define a hot-key sequence which when pressed by the watcher will cause PEEK to stop watching the current user and watch the prior user, if there is another user which matches the list or wildcard that was specified. If wildcards were not used, or if a list of users was specified but there was only one user to be watched, then PEEK will exit. Thus, this causes Peek/Spy to do the END_WATCH function and then attempt to start watching the prior user, if wildcards or a list of users were specified. For example: $ PEEK/PREVIOUS="<CTRL-P>P" USER1 or $ DEFINE WATCHER$PREVIOUS "<CTRL-P>P" $ PEEK USER1 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 prior user. See Appendix A of the PEEK manual for a more complete description of string syntax for use in specifying hot-key definitions. /PROCESS_NAME /PROCESS_NAME=(process_name [,process_name ,... ,proccess_name]) This parameter may be used to specify either a single process name whose terminal is to be watched, or a list of processes in parenthesis whose terminals are to be watched, in sequence, when the /NEXT and /PREVIOUS hot-key sequences are entered. The standard VMS * and % wildcard characters may be used in the process name(s). Standard VMS Node names may also be prefixed to the process names for watching processes on other nodes. (See the help on Node_Specifications.) Different node names can be used with different process names in the list. Standard VMS * and % wildcards are supported in node names. A prepended node name applies only to the one process-name parameter 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 watch each individual NDC session, or you can track with the user as he switches sessions by watching the "MS Server*" process for that user. /QUOTE /QUOTE = "string" The parameter /QUOTE="<string>" specifies a string which when recognized will tell PEEK that the following keystroke is NOT to be interpreted as a PEEK command, but is to be passed through to the terminal. This allows the user to press this key and follow it with some other PEEK command 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 the /TOGGLE_INPUT sequence, if input is not simultaneous.) This string should be entered by the watcher immediately before the the hot-key sequence he wishes to pass to the user's process. For 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 input has been enabled (see the /NOKB_CONTROL and /TOGGLE_INPUT qualifiers). See Appendix A of the PEEK manual for a more complete description of string syntax for use in specifying hot-key definitions. /SIMULTANEOUS_INPUT /[NO]SIMULTANEOUS_INPUT Specifying /SIMULTANEOUS_INPUT allows both the watcher and the watchee to enter keyboard input to the user'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 allowed, the TOGGLE_INPUT hot-key will have no effect, and both users will still be able to type at the same time. 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 as controlled by the TOGGLE_INPUT hot-key sequence. /TERMINAL /TERMINAL=(terminal_name [,terminal_name ,... ,terminal_name]) This qualifier may be used to specify either a single terminal name to be watched, or in parenthesis a list of terminal names to be watched, in sequence, when the /NEXT and /PREVIOUS hot-key sequences are entered. The terminal names may be any which are associated with the physical terminal, and thus may include 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. The standard VMS wildcards (* and %) may be specified for any part of the terminal name, if desired. For example: $ 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. Standard VMS node names may also be prefixed to the terminal names for watching terminals on other nodes. (See the help on Node_Specifications.) Different node names can be used for different terminal names in the list, and standard VMS * and % wildcards are supported in node names. A node name prepended to a terminal name applies only to that one terminal name in the list. For example: $ PEEK/TERMINAL=TXA5 In the above example, the watcher will watch the process which is signed onto terminal TXA5. Note: On Alpha, with MS30, you can watch each individual NDC session, or you can track with the user as he switches sessions by watching the "MS Server*" process for that user. /TIME_LIMIT /TIME_LIMIT=nnn The use of this qualifier causes the END_WATCH hot-key sequence to be simulated when the specified time duration expires. The "nnn" time value is specified in seconds. /TOGGLE_INPUT /TOGGLE_INPUT = "string" /NOTOGGLE_INPUT Defines a hot-key sequence which, when pressed will switch control of the user's process from the user's keyboard to the watcher's keyboard. When this hot-key is pressed a second time it will cause control of the keyboard to be switched back to the user being watched. 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. If SIMULTANEOUS_INPUT has been specified pressing the TOGGLE_INPUT hot-key will have no effect and the watcher and the user will be able to input at the same time. 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 NOSIMULTANEOUS_INPUT has 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 a hot-key sequence which has been specified in PEEK_DEFAULTS.COM, a logical name table, or on the command line, then PEEK will throw the watcher's input away and just ring the bell on his terminal. 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 than the hot-key sequences which have been specified for his use in the PEEK_DEFAULTS.COM file, in one of the logical name tables or which the user has specified using the PEEK/ALLOW qualifiers. For example: $ PEEK/TOGGLE_INPUT="<F10>" USER1 or $ DEFINE WATCHER$TOGGLE_INPUT "<F10>" $ PEEK USER1 In this case, if the watcher presses F10, then he will take over keyboard control (or give it back if he already has control of the user's keyboard). See Appendix A of the PEEK manual for a more complete description of string syntax for use in specifying hot-key definitions. The command qualifier called /TOGGLE_INPUT may be negated to allow one to override a TOGGLE_INPUT control string which has been placed in a logical name table. When specified as PEEK/ALLOW/NOTOGGLE_INPUT, it will tell PEEK not to allow that user to enter a TOGGLE_INPUT command. When entered by the watcher (i.e., without the /ALLOW), it tells PEEK or SPY not to allow the watcher to take control of the user's keyboard input. This qualifier was implemented for VMS compatibility; it is equivalent to specifying /TOGGLE_INPUT="" (null string). NOTE: The /NOTOGGLE_INPUT qualifier prevents the user who has issued it from toggling keyboard input, whereas the /NOKB_CONTROL always refers to whether the watcher may ever pass his keyboard input to the user's process. /USERNAME /USERNAME=(user_name [,user_name ,... ,user_name]) This parameter may be used to specify either a single user-name whose terminals are to be watched, or a list of user-names in parenthesis whose terminals are to be watched (in PID index sequence) when the /NEXT and /PREVIOUS hot-key sequences are entered. Usernames may contain the standard VMS * and % wildcard characters. Standard VMS Node names may also be prefixed to the user-names for watching users on other nodes. (See the help on Node_Specifications.) Different node names can be used for each different user names in the list, and standard VMS * and % wildcards are supported in node names. A node name applies only to the one user-name in the list to which it is prepended. For example: $ 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. $ 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. /WAIT_TIME /WAIT_TIME=nn.n This qualifier specifies the time in seconds which elapses before starting to watch the user. This allows time for one to read the "In a moment ...." message. The "nn.n" time value is specified in seconds, and can contain a decimal point. More control over how long this message displays may be achieved by using the /CONFIRM qualifier instead. 2 ALLOW Allows another user to watch your process. The /ALLOW qualifier is required. No user may watch your process unless you let them by using this command (or they have SYSPRV and SECURITY privileges). When /ALLOW is specified, a parameter specifying a valid rights list identifier must also be specified. In most cases each username on the system has an identical rights list identifier. Format: $ PEEK/ALLOW identifier-list PEEK> ALLOW identifier-list $ PEEK/ALLOW username-list PEEK> ALLOW username-list 3 Parameters username rights-list-identifier The name of a user who may watch your terminal. You may also specify a rights list identifier in place of a username. (Rights list identifiers held by a process are displayed by the SHOW PROCESS/PRIVILEGE command.) Any users who possess the identifier may watch your terminal after you issue a PEEK/ALLOW command specifying the identifier. 3 Qualifiers /BEEP_TERMINAL This specifies an optional string parameter, which if it is specified by the user and then entered from the user's terminal while the user is being watched with PEEK, it will cause the bell to be rung on the watcher's terminal. This is useful to get his attention if he walks away from his terminal. Example: $ PEEK/ALLOW/BEEP_TERMINAL="<F6>" JONES This will cause the bell to be rung on the watcher's terminal when- ever the user presses the F6 function key while he is being watched. If the watcher has the logical name USER$BEEP_TERMINAL defined, then the user need not specify this qualifier but may still use this function. /END_WATCH This specifies an optional string parameter which if it is specified by the user and then entered while he is being watched with PEEK, will cause the watcher to be forced to stop watching him. If this string is omitted, then the user will not be able to stop the watcher from watching him, except by issuing a PEEK/DISALOW command from DCL, unless the watcher has the logical name USER$END_WATCH defined. Example: $ PEEK/END_WATCH="<CTRL-]>" JONES In this case when the user presses Control-], the PEEK session will be terminated. /ONCE /NOONCE (default) Grants permission to watch your terminal only once. When the watch is terminated, the user will not be able to watch your terminal again until you again do a PEEK/ALLOW command, unless the watcher has SYSPRV and SECURITY privileges. /NOBP_OUTPUT /BP_OUTPUT (default) Grants permission to watch your terminal but without the ability to cause output to skip going to your terminal (going only to the watcher's terminal), unless the watcher has SYSPRV and SECURITY privileges. Examples: $ PEEK/ALLOW DAVID ! Allows user DAVID to watch your process. $ PEEK/ALLOW WATCHERS ! Users holding the rights identifier WATCHERS ! may watch your job. $ PEEK/ALLOW WATCHERS,DAVID/ONCE/NOKB_CONTROL/NOBP_OUTPUT ! Users with the rights list identifer WATCHERS ! may watch your job as many times as they wish, ! and bypass output or control your keyboard, ! but DAVID may only watch your process once ! and may not bypass or control your terminal. /KB_CONTROL (default) /NOKB_CONTROL Grants permission to watch your terminal but without the ability to take over your keyboard and enter input for you, unless the watcher has SYSPRV and SECURITY privileges. /QUOTE This specifies an optional string parameter which, if it is specified by the user and then entered while he is being watched with PEEK, will cause PEEK to pass the next sequence that is entered directly to the user process without checking to see if it is a PEEK control sequence. This string should be entered by the user immediately before the sequence which has been defined for the /END_WATCH, /BEEP_TERMINAL, or the /QUOTE sequence in order to pass any of those sequences to his process. Example: $ PEEK/QUOTE="<F7>"/BEEP_TERMINAL="<F6>" USER1 In this 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 will be passed to the user's process, if input has been enabled (see the /TOGGLE_INPUT qualifier). If the watcher has the logical name USER$QUOTE defined, then the user need not specify this qualifier but may still use this function. /TOGGLE_INPUT This specifies an optional string parameter which, if it is specified by the user and then entered while he is being watched with PEEK, will cause PEEK to switch who is allowed to enter input. When PEEK is first run, the watcher is not allowed to enter input to the user's process. If he types anything other than a sequence which PEEK recognizes (i.e., /END_WATCH, /XON_SIMULATE, /BEEP_TERMINAL, /QUOTE or /TOGGLE_INPUT), PEEK will throw the input away and just ring the bell on his terminal. The user may press his TOGGLE_INPUT sequence to switch keyboard control to the watcher. From this point until TOGGLE_INPUT is done again, the user's terminal will just beep if he attempts to type anything other than the TOGGLE_INPUT sequence which he specified using PEEK/ALLOW. Example: $ PEEK/ALLOW/TOGGLE_INPUT="<F10>" JONES In this case, if the useer presses F10, he give up keyboard control to the watcher (or take it back if he no longer has control). 2 ATTACH PEEK> ATTACH process_name PEEK> ATTACH/IDENTIFICATION=nnn Used from the PEEK> prompt, the ATTACH qualifier 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 2 DISALLOW $ PEEK /DISALLOW This command performs the following functions: 1. Lets no other non-privileged users watch your terminal. 2. Revokes permission granted by all previous PEEK/ALLOW commands. 3. Any users who are currently watching are forced to stop watching. 4. If any control sequences were specified as part of the PEEK/ALLOW command (as displayed by a PEEK/SHOW command), these sequences will also be revoked by the PEEK/DISALLOW command. Format: $ PEEK/DISALLOW 2 EXIT PEEK> EXIT The EXIT command is used to exit back to DCL from the interactive prompting command mode of PEEK. 2 FORMAT $ PEEK/FORMAT in_file out_file PEEK> FORMAT in_file out_file The PEEK/FORMAT command may be used for converting the format of output log files so that they may be displayed or printed. Since this command converts streams of escape sequences into distinct pages of output, this command is also useful for displaying a log file which otherwise is difficult to display, print or analyze. For example: $ PEEK /USER=SMITH /OUTPUT_LOG=SMITH.LOG $ PEEK /FORMAT SMITH.LOG SMITH.FMT 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 default screen width is 80, or as specified by /WIDTH=n. The FORMAT command actions and qualifiers differ between PEEK for AXP and PEEK for VAX. 3 Description There is an inherent problem in creating an ASCII stream log file of terminal output, whether it is created by PEEK/OUTPUT, SET HOST/LOG or KERMIT's LOG SESSION command. The problem is that records in a stream output file either have an arbitrary length (as do those output by KERMIT) or no maximum length at all. In the case where an arbitrary length is imposed on the log file, you will get extra carriage returns embedded into the file when it is typed. In the case of PEEK which does NOT arbitrarily end a line after 256 bytes (or some other size), the TYPE command, EDT, TPU, etc. have varying degrees of success in displaying the file's contents. The VMS type command will abort if you attempt to type a file which has records longer than 2048 bytes, and EDT and TPU have the same or larger limitations. Thus we have added a format command which will process an arbitrary sequence of escape and control strings into a series of output screens. 3 AXP An new output-screen is appended to the formatted output file whenever any 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 several different printer formats. The default output format is plain text, but other formats are available. The following printer types are currently defined: FILE - For plain text into file (this is the default). VT100 - For paged output to a VTxxx type terminal. 3 VAX A new output-screen is appended to the formatted output file whenever any 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. If /CURSOR_FLUSH was specified as a negative number and the cursor moves up more than the specified number of lines. 6. If /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 the output from programs which don't erase the screen, but just reposition the cursor and overwrite it. 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 types are currently defined: 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 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 want to use all lines of page, where the form-feed on a separate line would cause a page to be skipped between each page of text. 2 HELP $ PEEK /HELP [help-topic] [subtopic] PEEK> HELP [help-topic] [subtopic] Displays online help on Peek/Spy commands. Help-topic and subtopic specify a command or command qualifier about which you want further information. You may specify *, either by itself or within a name. 2 INSTALL VAX Only - INSTALL not yet implemented for version 4.1 on AXP. $ PEEK/INSTALL ! VAX Only The INSTALL command is used when starting up PEEK on VAX when one wants all RTA terminals on the system to be watchable by PEEK. It enables PEEK to access all RTA units which are created after the PEEK/INSTALL command has been issued. It can also be used after a PEEK/REMOVE has been done, in which case /INSTALL will re-enable watching of any new RTA units created after the /INSTALL is done. 2 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 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 LICENSE command gives you a license key which you pass on to NDC, and then NDC gives you back a responding key which you enter, updating the NDC license data base 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 location of PEEK$LOCATION on your system you will also need to rename the LMF$PEEK.LDB file into the new directory to continue to use the product. You must have SYSPRV 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 during startup of 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 should not thereafter be changed. 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. If you are not communicating the license key to NDC immediately, then you can exit the license screen by entering Ctrl-Z at the prompt. You may, alternately, create a file KEY.LIS containing the necessary licensing information for faxing to 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), and should then enter the responding key exactly as given by NDC. You should get a key-accepted message. 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. 2 LOAD $ PEEK /LOAD When PEEK is first run it automatically loads the PEEKIMG Executive Image. Using the LOAD command forces a re-load of PEEKIMG Executive Image. You would only do this if you received a patched image of PEEKIMG and wanted to start using the patched version. The LOAD command cannot be used if PEEK is currently being run by anyone else on the system. When a LOAD is done, any terminals with the screen-saver feature currently running automatically have the screen-saver turned off before the reload is done, and then have the screen-saver turned back on again when the new copy of PEEKIMG has been loaded. If there were any log files being made, then the log files are automatically closed and a new file with the same name is opened after the new PEEKIMG has been loaded. Some output can be lost from the log file during the time it is closed and the new version is opened. 2 NODE_NAME_CHANGE $ PEEK /NODE_NAME_CHANGE If you should change the node name of a cluster 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 use the NODE_NAME_CHANGE command while running the product from that node. This records the node name 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 node name 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 node from the old name you give to the new name for that node. The product must not be in use on the system when this command is used. SYSPRV is required to use the NODE_NAME_CHANGE command. 2 PEEK PEEK> PEEK user_spec/quals The PEEK command is used (in the interactive prompting command mode of PEEK only) to watch someone. It is synonymous with the WATCH command. Examples: PEEK> PEEK JBREWER* PEEK> PEEK/TERMINAL=LTA57 PEEK> PEEK/USER=JBREWER 2 QUIT PEEK> QUIT The QUIT command is used to exit back to DCL from the interactive prompting command mode of PEEK. 2 REMOVE VAX Only - REMOVE command is not yet implemented in version 4.1 for AXP. $ PEEK/REMOVE ! VAX Only The REMOVE command can be used to remove the capability of watching RTA units on VAX. Any RTA units created before the PEEK/INSTALL command or after the PEEK/REMOVE command will not be available to be watched with PEEK. 2 SHOW $ PEEK /SHOW [ALL] (default) PEEK> SHOW [ALL] (default) $ PEEK /SHOW ALLOWS PEEK> SHOW ALLOWS $ PEEK /SHOW KEY PEEK> SHOW KEY $ 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. 3 ALL $ PEEK /SHOW [ALL] (default) PEEK> SHOW [ALL] (default) Displays PEEK-related information which includes the version of PEEK, licensing information, ALLOW information, and key information for both being watched and watching another. 3 ALLOWS $ PEEK/SHOW [ALLOWS] PEEK> SHOW [ALLOWS] Displays the list of identifiers and usernames that you have allowed to watch your process with the /ALLOW qualifier. (See the section on the allow qualifier for more details.) The display will also tell you whether or not permission to watch will be granted on a once-only basis or as many times as desired, and whether bypassing output or keyboard control will be disallowed. This command will also display any key sequences which have been defined for use while you are being watched or watching another. Format: $ PEEK/SHOW [ALLOWS] PEEK> SHOW [ALLOWS] 3 KEY $ PEEK /SHOW KEY PEEK> SHOW KEY Displays information on the hot-keys which are defined for use when being watched by another. 3 LICENSE $ PEEK /SHOW LICENSE PEEK> SHOW LICENSE Displays license information. 3 PEEK $ PEEK /SHOW PEEK PEEK> SHOW PEEK Displays any other nodes in the cluster which have started PEEK. 3 USERS $PEEK /SHOW USERS [spec,spec,...] PEEK> SHOW USERS [spec,spec,...] Displays data about the current users on the system. This helps you more easily isolate the users 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 node name can be prefixed before the first user specification in the list. In this case any users on that node matching any of the following list of user specification 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 node names for the SHOW USERS command differs from the use of node names in other Peek commands. For SHOW USERS only, the first specification in a list may have a node name prepended to it, and that node name applies to all the subsequent user specs in the list. The data shown and the display format for /SHOW USERS are user- definable; see the PEEK manual for details on how you can customize your /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. 3 VERSION $ PEEK /SHOW VERSION PEEK> SHOW VERSION Display the version of PEEK which is currently running. 3 WATCHER $ PEEK /SHOW WATCHER PEEK> SHOW WATCHER Displays the hot-keys defined for use when watching another. 2 SPAWN PEEK> SPAWN This command can be used from the PEEK> prompt to spawn a subprocess. The optional parameter is a command 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 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> 2 SAVE_SCREEN AXP-Only... PEEK> SAVE_SCREEN ! Start screen-saving for SYS$COMMAND. SPY> SAVE_SCREEN LTA5059 ! Start screen-saving for LTA5059. The SAVE_SCREEN command starts up the screen-saver feature for the current user's terminal. 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. See below.) Terminals with the screen-saver feature turned on allow a full initial-screen-contents display when they are watched with Peek/Spy. Screen-saving only begins after a SAVE_SCREEN command has been done, so it is wise to do this ahead of time, such as from LOGIN.COM, so that there has been time for a full screen to be saved before PEEKing begins. If screen-saving has not yet been started when PEEKing begins, then PEEK automatically turns on the screen-saver, but there hasn't yet been time to save a full screen prior to PEEKing, so only a partial screen is initially displayed by PEEK, or even no screen at all if nothing has been sent to the terminal since screen-saving was started. Logging is also possible with the screen-saver feature using the /LOG_FILE or /OUTPUT_LOG_FILE qualifiers. This records in the log file everything which is output to the terminal. Screen-saving/logging is turned off by the NOSAVE_SCREEN command, or the SAVE_SCREEN/CLOSE command. If the screen-saver is on without a log file, then a log file can be started using the SAVE_SCREEN/LOG[=file] command. If the screen-saver is already making a log file then the NOSAVE_SCREEN command or the SAVE_SCREEN/CLOSE command can be used to close the log file, PEEK/SAVE_SCREEN/CLOSE meerly turns off the logging. PEEK/NOSAVE turns off both the logging and the screen-saving. When logging a new log file can be started with PEEK/SAVE/LOG/NEW_FILE. This closes any existing log file and starts a new log file. 3 /CLOSE AXP-Only... PEEK> SAVE_SCREEN /CLOSE The CLOSE qualifier closes any existing log file turned on with PEEK/SAVE_SCREEN/LOG, without turning off the screen-saving. This means PEEK will still be able to view the full initial screen, but the terminal-logging will end. 3 /NEW_FILE AXP-Only... PEEK> SAVE_SCREEN /LOG[=file_spec] /NEW_FILE The NEW_FILE qualifier is used to close an existing terminal-logger log file and open a new terminal-logger file. The new file will contain the full initial contents of the screen at the time this command is done. 3 /PERMANENT AXP-Only... PEEK> SAVE_SCREEN [ /LOG[=file_spec] ] /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 goes away only when the terminal itself goes away, as with LTAs etc which are deleted when the user logs off. 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 command. 3 /REOPEN AXP-Only... PEEK/SAVE_SCREEN/LOG/[NO]REOPEN Reopens a new version of the log file being created whenever the log file reaches a certain number of disk blocks, or whenever a certain 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 span are specified using the /MAX_REOPEN, /MIN_REOPEN and /SPAN qualifiers, or by the defaults for these specified as logical names in the PEEK_DEFAULTS.COM file. e.g. PEEK/SAVE_SCREEN/LOG/REOPEN/MAX=100/SPAN=5.0/MIN=10 This specifies a new version of the log file should be reopened every 100 blocks, or every 5 minutes as long as at least 10 blocks have been written to the file. Each reopened log files has a copy of the initial full-screen at the time the log file was reopened. 2 WATCH PEEK> WATCH user_spec/quals The WATCH command is used to watch someone when in the interactive prompting command mode of PEEK. It is synonymous with the PEEK command. Examples: PEEK> WATCH JJONES* PEEK> WATCH/TERMINAL=LTA5 PEEK> WATCH/USER=JJONES 2 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. 3 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.1 for 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.1 for 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. 3 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. 2 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. 3 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 help for SAVE_SCREEN. 3 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. 2 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, in order to make the output display correctly. This is not a problem when using the 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 that terminal. The PEEK and SPY /INIT_SEQUENCE=() qualifier may be used to specify an initial modes-setting sequence which is sent to your terminal before you start watching, whereas the /FINISH_SEQUENCE=() qualifier specifies a modes-setting sequence which is sent to your terminal after you finish watching someone. Each of these qualifiers accepts a list of keywords. Each of these key- words causes a particular sequence to be sent to the watcher's terminal. 3 Keywords These are the keywords available for either /INIT_SEQUENCE or /FINISH_SEQUENCE. Each of these keywords 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 in the command. For information on the fixed ordering of these sequences see the help on Init_and_Finish_Sequences Sequence_Ordering. 4 132COLUMN Outputs "<ESC>[?3h" 4 80COLUMN Outputs "<ESC>[?3l" 4 APPLICATION Outputs "<ESC>=" 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. 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>}" 5 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>}" 5 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>\|\". 5 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>|". 5 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>}". 5 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 KOREAN Hanji (Korean terminals) 4 KS_ROMAN KS Roman (Korean terminals) %? JIS_KATAKANA JIS-Katakana (Japanese term) I JIS_ROMAN JIS-Roman (Jap terminals) J KANJI DEC Kanji (Jap terminals) "0 (or 1 or 3) 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") 5 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=">") 5 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". 5 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>|". 4 CLEAR Outputs "<ESC>[H<ESC>[J" 4 EIGHT_BIT Outputs "<ESC> G" 4 INSERT Outputs "<ESC>[4h" 4 NOINSERT Outputs "<ESC>[4l" 4 INVERSE Outputs "<ESC>[?5h" 4 NOINVERSE Outputs "<ESC>[?5l" 4 NATIONAL Outputs "<CSI>?42h" 4 NONATIONAL Outputs "<CSI>?42l" 4 NONE The keyword NONE is used to specify that there is no /INIT or /FINISH sequence. 4 NUMERIC Outputs "<ESC>>" 4 ORIGIN Outputs "<ESC>[?6h" 4 NOORIGIN Outputs "<ESC>[?6l" 4 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") 4 PREF_DEC Outputs "<DCS>0!u%5<ST>" 4 PREF_ISO Outputs "<DCS>1!uA<ST>" 4 REGIS Outputs "<ESC>Pp" 4 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". 4 NOSCROLL Outputs "<ESC>[r" 4 SEVEN_BIT Outputs "<ESC> F" 4 STRING="string" The string specified with /INIT=(STRING="string") or /FINISH=(STRING="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=(STRING="<ESC>[2J") 4 STATUS_LINE Outputs "<ESC>[2$~" 4 NOSTATUS_LINE Outputs "<ESC>[0$~" 4 STATUS_OFF Outputs "<ESC>[0$}" 4 STATUS_ON Outputs "<ESC>[1$}" 4 TEKTRONIX Outputs "<ESC>[?38h" 4 NOTEKTRONIX Outputs "<ESC>[?38l" 4 TEKTRONIX2 Outputs "<ESC>%!0" 4 NOTEKTRONIX2 Outputs "<ESC>%!2" 4 VT100 Outputs "<ESC><" 4 VT200 Outputs "<ESC><<ESC>["62;1p" 4 VT300 Outputs "<ESC><<ESC>["63;1p" 4 VT400 Outputs "<ESC><<ESC>["64;1p" 4 VT52 Outputs "<ESC>[?2l<ESC>\" 3 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_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 REGIS <ESC>Pp TEKTRONIX <ESC>[?38h NOTEKTRONIX <ESC>[?38l TEKTRONIX2 <ESC>%!0 NOTEKTRONIX2 <ESC>%!2 VT52 <ESC>[?2l<ESC>\ STRING="string" user specified string in "hot-key" format. 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 USASCII. 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. 2 INPUT-ONLY_watching_and_logging /INPUT_ONLY can be used with /SAVE_SCREEN/LOG with PEEK or SPY to start input-only terminal logging, where only the input keystrokes are logged. /INPUT_ONLY can be used with SPY to skip watching terminal output and instead watch only the user's input keystrokes, Your site must be licensed to use input-only and any watcher and the 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. The /DISPLAY_TYPE qualifier allows you to chose the format in which control characters are displayed on the watcher's screen, or in the input-only log file. See the help on /INPUT_ONLY and /DISPLAY_TYPE for command formats and examples. 3 MS30-Interaction There is a situation which can occur on an AXP system using both MS30 and input-logging. If the terminal-logging is started before MS30 is turned on, then it is difficult to turn off the input-logging, because the original terminal gets taken over by the MS30 server process and is thus not easily accessible. This can affect normal PEEKing because an initial-screen-refresh is not available during input-logging. Currently the only handlings for this are to disconnect the MS30 session and then re-connect to it from a terminal that is not doing input- logging; or else use a command like SPY/NOSAV LTA8085: on the original server terminal to turn off its input-only terminal logging. 3 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. See the HELP topic INPUT-ONLY Rights-IDs for more information. 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. 3 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 PEEK/SAVE_SCREEN/LOG/INPUT_ONLY the rights ID is PEEK$INPUT_LOGGING. 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 PEEK$INPUT_LOGGING, 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 OR LOGGING OF PASSWORDS AND OTHER NON-ECHOED INPUT. 2 Node_Specifications PEEK version 4.1 accepts node names as part of the specification of who is to be watched. A node name can be prepended to a process name or terminal name or process-ID or username in a PEEK command. The node specification is a standard VMS node specification ending with a double colon. Example: $ PEEK NODEA::J_DOE Standard VMS * and % wildcards are allowed in the node-name portion of a specification of who is to be watched, providing PEEK has been configured for wildcards in node names. (See subtopic Wildcarded_Node_Names.) In a list of specifications, different node names can be prepended to each specification in the list. The node name, if present, applies only to the single specification to which it is prepended. Example: $ PEEK/TERMINAL=(TTA1:,NODEA::TTA1:,TTA2:) In this example, first TTA1 on the current network node is watched. Then TTA1 on NODEA is watched. Then TTA2 on the current node is watched. 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"UserA PassA"::j_doe 3 Set-up PEEK 4.1 must have been started on the target node, and PEEK must have been added via NCP to the network database on the target node as a KNOWN OBJECT. 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 command to add PEEK permanently is: NCP> DEFINE OBJECT PEEK NUMBER 0 FILE PEEK$LOCATION:PEEK_Vx.EXE For SPY use: NCP> DEFINE OBJECT SPY NUMBER 0 FILE PEEK$LOCATION:SPY_Vx.EXE To permanently enable both incoming and outgoing proxy access to PEEK use: NCP> DEF OBJ PEEK NUMBER 0 FILE PEEK$LOCATION:PEEK_Vx.EXE PROXY BOTH For SPY use: NCP> DEF OBJ SPY NUMBER 0 FILE PEEK$LOCATION:SPY_Vx.EXE PROXY BOTH Note that the correct VMS version number for your system (_V5 _V6 _V7) must replace the _Vx in the file specification. Also note that the .EXE is required syntax on the file specification. Use SET instead of DEFINE in the above commands if you don't want PEEK/SPY added to the network datebase 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. 3 Wildcarded_Node_Names Use of standard VMS * and % wildcards within PEEK node-name specifications is based on the correct configuration of the logical name PEEK_WILDCARD_NODES. This logical name is used by PEEK to determine what nodes are available to be checked against for a wildcard match during a wildcarded node-name operation. This multi-valued logical should equate to the actual node names available to be checked, in order, during a wildcarded node-name 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 wildcarded node-names. The PEEK_WILDCARD_NODES logical name as defined in PEEK_DEFAULTS can also be superceded in one's PROCESS, JOB, GROUP or the SYSTEM logical name tables (in that order). This allows customization, for individual users or groups of users, of the nodes which are used during wildcard operations for those particular users. E.g. Placing the following command into one's LOGIN.COM would direct PEEK to check the nodes NODEA, NODEF and NODEC, in that order, during a wildcarded node-name operation, should they match the wildcard specified in the node name given in the PEEK command. $ DEFINE PEEK_WILDCARD_NODES NODEA,NODEC,NODEF 4 Forcing_Network_Access When using wildcards in node names, PEEK 4.2.06 will skip accessing the network to watch processes on the current node. (PEEK 4.1.04 would go across the network to access the local node during a wildcarded nodename operation.) 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 user name. In this case, because the access requests a different user name to do the watching, PEEK will use network access to PEEK on the local node. One can also 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 in watcher's PROCESS,JOB, GROUP, or the SYSTEM or LNM$PEEK_DEFAULT logical name tables. 2 Overview Peek/Spy have been designed to have the following features: + Peek always warns a user if he is being watched. Peek will periodically remind a user while he is being watched. + Spy never warns a user and 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 the system manager before they are allowed to watch another user. + Spy users normally must have system privileges (SYSPRV and SECURITY) and 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 one to browse thru a list of terminals, processes, usernames, or everyone on the system. Wildcards may be used in these lists. + Keyboard control, 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). + Allows the user being watched to stop the watcher from watching him by pressing a hot-key. (Only with PEEK.) + An output log-file may be created which records what happened while the user was being watched, or just everything 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" (on VAX only) as created by SET HOST. These same types of terminals may also be watched by PEEK, with the exception that DECnet "remote terminals" may not be watched yet on the AXP version of Peek/Spy. + 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. + Node names are supported, including standard wildcards, for watching other terminals across a DECNET network, providing the target system is also running Peek/Spy. 2 Termination To stop watching another process, enter the sequence which you have specified using the /END_WATCH sequence or which is specified in the WATCHER$END_WATCH logical name. When this is done, the following message will be displayed on the watcher's terminal: %PEEK-I-ENDWATCH, you are no longer watching user JONES Also, the following message will be displayed on the terminal of the user who was being watched: %PEEK-I-WATCHEND, user SYSTEM is no longer watching you These messages will also be displayed when the NEXT or PREVIOUS sequence is entered by the watcher. However in these cases PEEK will attempt to start watching the next process which matches the selection specification. 2 Version This help is for version 4.2.06 of PEEK.

© 1997- Marc Vos (and others) Contact Me