Enter your search terms Submit search form
	Web pdp-10.trailing-edge.com

                     Telnet User Guide

User Telnet (hereafter called  Telnet)  provides  facilities  for
communicating  with host computers via the ARPA network utilizing
the TELNET protocol.   The  purpose  of  the  Telnet  program  is
threefold.  It converts various terminals connected to TENEX into
a standard type of terminal called  a  network  virtual  terminal
(NVT)  by  interposing  programs in the character streams between
the terminal keyboard and printer and the terminal  port  on  the
host  computer.   Secondly,  it  provides  information  about the
network to assist a user in establishing  connections.   Thirdly,
it multiplexes the terminal among several remote jobs.

Telnet Command-Interpreter

Instructions to the Telnet  program  are  given  via  the  Telnet
Command   Interpreter.    When   in  command  mode  (see  below),
characters typed on the user's terminal are read  by  the  Telnet
command  interpreter  and  decoded as commands to perform various
actions by Telnet.

The Telnet command interpreter  has  two  unique  features.   The
command  interpreter  will  refuse  to  hear anything it does not
understand.  With full-duplex terminals, this means that no  echo
will  appear for characters which are not valid successors of the
previous input.  In any case, the character is ignored and a bell
is  typed  out.   The input stream that has already been typed is
not forgotten however.  Therefore, it is only necessary  to  type
the correct character and not the complete command.  This feature
may be turned off with the "no fancy.command.interpret" command.

The other unique feature of the Telnet command interpreter is the
use  of  question  mark  to discover what the command interpreter
expects next.  Typing a "?" at any  time  in  command  mode  will
elicit  a  list  of  words  the command interpreter is expecting.
Thus, typing a "?" when nothing has been typed will yield a  list
of  all  possible  top-level commands.  Typing "co?" will yield a
list of all commands starting with "co".   Typing  "connection.to
?" will yield a list of possible arguments to the "connection.to"
command.

The command interpreter provides command  completion  whenever  a
terminator  is  typed  (full-duplex  terminals only) and an exact
match is achieved with some command or a unique initial substring
is   typed.   Command  completion  may  be  suppressed  with  the
"concise" command.  Terminators are space, comma,  alt-mode,  and
carriage return.  Terminators are often not distinguished and are
thus equivalent.  Where necessary, comma is used to separate list
items,  space  terminates  a  command  or  option and signals the
desire to specify more options, carriage return  ends  a  command
unless  more  information  is  necessary.  Altmode is the same as
space except that it will cause command completion in those modes
where it is normally suppressed.


Command/Remote-Mode

As mentioned above, characters typed on the terminal keyboard may
be used in two ways: either as commands to Telnet, or as input to
the remote host.  The choice is made  on  the  basis  of  whether
Telnet  is  in  remote  mode  or  command mode.  In command mode,
characters typed on the terminal keyboard are read by the  Telnet
command  interpreter  and  decoded as commands to perform various
actions.  TELNET is initially in command mode and will revert  to
command  mode whenever the Telnet escape character (see below) is
typed.

The opposite of command mode is remote  mode.   In  remote  mode,
characters  typed  on  the keyboard (with certain exceptions) are
not examined by Telnet at all, but are merely passed  on  to  the
remote  host computer.  Remote mode is normally entered after any
command is executed when  the  current  connection  exists.   The
"local.mode"  command  may be used to defeat this.  The effect of
the  "local.mode"  command  is  cancelled  by  the  "remote.mode"
command   or  by  the  "connection.to"  or  "retrieve.connection"
commands.


Escaping Back to Command Mode

At any  time,  typing  the  Telnet  escape  character  (initially
control-Z  (SUB))  will cause Telnet to stop whatever it is doing
and return to command mode.  Occasionally, a slight delay may  be
experienced due to the need to clean up whatever was happening at
the time.  Telnet announces the switch to  command  mode  by  the
appearance  of  a sharp sign "#" at the left margin.  Telnet also
indicates the transition out of command mode by the appearance of
another sharp sign followed by a new line.

WARNING: If you have control-Z anywhere in your programming,  you
should  change  your  escape  character  for Telnet to other than
control-Z to avoid mishaps.


Making-a-Connection

There are two ways to make a connection.   Typing  "connection.to
<host>  [<qualifiers>]"  or simply typing "<host> [<qualifiers>]"
will cause a connection attempt to be made.  If  successful,  the
connection  will  be said to be complete and the terminal will be
placed in remote mode.  If unsuccessful, the connection  will  be
said  to be "incomplete because ---" with a reason given; also if
the remote host is down, a line is typed telling why and for  how
long.   By  terminating  the  host name with a space, one or more
qualifiers may be specified.  Ordinarily  socket  1  is  assumed.
Thus  without  a  qualifier,  the  connection will be made to the
"logger" on the remote system.  By using an  octal  number  as  a
qualifier,   the  connection  will  be  made  to  the  socket  so
specified.  A set of names is available for specifying the socket
desired.   This  set  consists  of  names  for  all  the standard
sockets.


The "wait" qualifier may be used to camp-on the connection.  This
qualifier  causes  Telnet to repeat the attempt to connect in the
event of a failure until it finally succeeds.  An initial failure
causes  a message to that effect to be printed.  When the attempt
finally succeeds, bells are typed out to wake the user  up.   The
attempt  to  connect  may  be aborted by typing the Telnet escape
character.

The "load.settings.from..." qualifier  (possibly  qualified  with
"no")  may  be  used  to  cause  (inhibit)  the  mode flags to be
initialized from the mode  file.   When  inhibited,  the  current
modes are used.

The "name.for.connection" qualifier may be used to specify a name
for  this  connection  other  than the one assigned by Telnet.  A
name  for  the  connection  may  also  be  given  later  by   the
"name.for.current.connection" command.


Disconnecting

The "disconnect" command is used to close the current connection.
This will not necessarily log you out from the remote host so you
should  perform  the  logout  procedure  for  that  host   before
disconnecting.  The disconnect command takes an optional argument
specifying  the  name  of   a   particular   connection   to   be
disconnected.   See  multiple  connections  and  connection names
below.

In the event that  the  network  connections  are  severed  by  a
network  failure, the message "IO error for connection <name>" is
printed, the connection is disconnected, and  Telnet  reverts  to
command  mode.   This  may  happen  even if the error occurs on a
connection which is not current.  If the remote host initiates  a
disconnect,  a  message  to  that  effect is printed and the same
action is taken.

If the remote host on the  current  connection  stops  responding
when  input  is being sent, a line is typed, "Host not responding
on connection xxx." (In this case the connection  is  NOT  lost.)
When  the  remote  host  resumes operating, the user is informed:
"Service restored on connection xxx."


Echo-Control

Telnet allows several options concerned with echoing.  Echos  may
be  generated  by the terminal, by Telnet, or by the remote host.
Telnet determines if  the  terminal  is  generating  echoes  when
started  by  examining  the  mode  word  for  the  terminal.  The
"terminal.type.is" command may be used to change this.

If the terminal  is  echoing,  then  Telnet  will  do  everything
possible  to  cause  the  remote host to not generate echoes, and
Telnet will not generate echoes itself.  If the terminal  is  not
generating  echoes, then Telnet determines whether it should echo
or not by information in the mode file (if any) or by  the  "echo
remote"/"echo  local"  commands,  or by information sent from the
remote host.

Telnet keeps the remote host informed about how echoing is  being
done  and if the remote host is suitably equipped, it will follow
along.  If not, then the user will have to give commands  to  the
remote  host  to  achieve  the  proper echoing.  Telnet also will
respond to commands from the remote host concerning who should be
echoing.   If  Telnet  believes  the  terminal  is  doing its own
echoing, it will respond to any request from the remote  host  to
not echo by an "I'll echo" command.


Line-Buffering and End of Line Conventions

Telnet  provides  an  optional   line   buffer   for   use   with
line-oriented  operating systems.  In this mode, characters typed
in remote mode are stored in a local buffer up through an end  of
line.   Prior to the end of line, the currently buffered line may
be edited using control-A  (SOH)  or  control-H  (BS)  to  delete
characters,  control-X  (CAN) to delete everything, and control-R
(DC2) to retype the current contents.  Telnet always converts the
TENEX  EOL  into  the NVT EOL.  TENEX in turn converts a carriage
return into the TENEX EOL.  Thus typing a  carriage  return  will
cause  the buffered line to be transmitted.  Linefeed may also be
used to terminate a line.  In this  case,  the  transmitted  line
will end with only linefeed, not the NVT EOL.

Telnet provides an optional linefeed echo  for  carriage  return.
If  the  remote  host  provides  a  linefeed  also, then the echo
generated by Telnet  should  be  suppressed  with  the  "echo  no
linefeed.for.carriage.return"  command.   In  remote  echo  mode,
Telnet generates no echos whatsoever.  In this  mode,  all  echos
must be provided by the remote host.


Status-Commands

Several status commands are available for discovering facts about
the network.  None of these commands will affect the state of the
current connection.   The  status  commands  include  where.am.I,
status.of,   netstatus,   and  socket.map.   These  commands  are
summarized below.




Special-Characters

Several commands are available to send characters  which  do  not
appear  on  the  terminal.   "Code"  takes  an  octal (decimal if
precede by "D", hexadecimal if  preceded  by  "H")  argument  and
sends  the  character  with  that  code.   The word "code" may be
omitted and just the argument typed.  "Control" takes a character
argument  and  sends the corresponding control character (the low
order five bits of the character) is sent.  The "!break!" command
sends  the  NVT  break  character which is mapped by some systems
into the equivalent of the attention, quit  or  break  key  which
appears on some terminals.

To facilitate operation with systems requiring  frequent  use  of
special   characters   or   lower/upper  case  graphics  which  a
particular terminal may lack (e.g.  33 Teletypes  have  no  lower
case),  case  shift  characters  may  be  defined for upper/lower
character/lock shifts  and  characters  may  defined  which  will
translate  into  attention  or  break  (NVT  201),  and the synch
sequence.  The  "case.shift.prefix.for",  "attention.character=",
and  "synch.character="  commands  are available to independently
set each of these characters.  In addition, a  character  may  be
defined  ("quote.prefix" command) to be a single character quote.
The character following this character is always sent  regardless
of any special action it may otherwise have.

If possible, case shift characters will be used to  indicate  the
case  of  both  input and output.  Thus the case shift characters
may not be echoed when typed but rather before the output.

All special characters  are  listed  by  the  "current.modes.are"
command.  This includes the escape character and the clear output
buffer character.


Leaving-Telnet

To leave Telnet, it is first necessary to return to command  mode
by  typing the escape character.  This is because while in remote
mode all characters except the escape character are passed on  to
the  remote  host or modify characters passed to the remote host.
Once in command mode, you  may  return  to  the  EXEC  by  typing
control-C  (ETX) or by using the "quit" command.  Continuing from
the EXEC will resume with no loss.   The  "logout"  command  will
disconnect  from  any  remote job and logout your local job.  The
"exec" command will start up an inferior EXEC under Telnet.  From
this  inferior  EXEC, it is possible to perform assemblies or any
other task  involving  the  running  of  subsystems.   The  "run"
command allows an arbitrary program to be run in an inferior fork
of Telnet.  The "run" may be interrupted  by  the  Telnet  escape
character.


Multiple-Connections

Telnet provides a facility for  multiplexing  a  user's  terminal
among  several  remote  jobs  thus  allowing several simultaneous
activities.  This is done by giving a name for each connection as
it  is  created.   The  user may specify the name, or Telnet will
default the  name  to  a  number.   The  "retrieve.connection..."
command causes the named connection to be made current and remote
mode to be entered.  Non-current connections remain  active,  but
any  output  received  is  buffered  until  that connection again
becomes active.  Terminal input goes only to the currently active
connection.

Telnet may be made  to  announce  the  receipt  of  output  on  a
non-current  connection with the "signal.waiting.output" command;
it may also be caused to  hunt  for  and  switch  to  any  active
connection--     see     "wait.for.any.active.connection"     and
"auto.switch.to.active.connection" commands.

The name of the current connection may be  changed  after  it  is
established   by   means   of  the  "name.for.current.connection"
command.  The name so specified may be  up  to  6  characters  in
length and must be unique.


Typescript-File

Telnet provides a means of  saving  on  a  file  a  copy  of  the
typescript for a session.  This is useful for producing hard copy
of the session when using  a  scope  terminal  or  for  producing
documentation of procedures or demonstrations.  Telnet is started
with  no  typescript  file  assigned.   The  "typescript.to.file"
command  may  be used to assign one, either the default temporary
file TELNET.TYPESCRIPT;S in the LOGIN directory, or one named  by
the user.  The typescript consists of a nearly exact copy of what
appears on the terminal with the exception of that  which  occurs
during  the  execution  of the "exec" or "run" or "ddt" commands.
"Nearly" refers to slight differences in  the  spelling  of  file
names  in  certain  Telnet commands.  For privacy, the typescript
file is given a protection that allows no access  to  anyone  but
"self".


Diverting-Output

The output stream may be diverted to some  other  file  with  the
"divert.output.to.file"  command.  While diverting output, Telnet
sends all output to the indicated file and sends a  line  to  the
terminal  only  when the terminal's output buffer is empty.  Thus
the terminal monitors the transmission of the stream to the file.
The  diverted  output consists only of characters from the remote
host.  Telnet  commands  and  responses  do  not  appear  in  the
diverted  information.   This  mode is useful as a primitive file
transfer mechanism or to  allow  printing  of  large  amounts  of
terminal output to be done with the lineprinter.  It is cancelled
by "no divert.output ...".



Input-from-a-File

The input stream to a remote job may be taken from a file instead
of    the    local    terminal    by   means   of   the   command
"take.input.stream.from.file".  Telnet blocks terminal  input  to
the  connection current when the file is specified, and transmits
characters from the named file (echoing  as  usual  according  to
current  modes).   However,  input  to  other  connections and in
command mode is from the user's terminal.  When  the  given  file
reaches EOF the file is closed and released, and input reverts to
the terminal.  The user may also manually cancel  file  input  by
escaping  to  command  mode and giving "no take.input ...".  This
mode is useful for routine sequences performed in the remote job.
Note that a connection must be established and current when input
to it is diverted to a file.


              Telnet Command Summary


Connection.to <host> or host name

Performs ICP to connect  to  the  indicated  host.
Options   are  available  for  specifying  initial
connection socket name or number, and initializing
modes   from  the  mode  file  via  the  following
subcommands.  Note that if <host name> is used  as
a  command,  only the NAME of a SERVER host may be
given  (e.g.,  BBN-TENEX).    The   argument   for
"Connection.to"  may  be any host name or an octal
host number.


     <octal number>

     An ICP is performed to  connect  to  the
     indicated   service   socket.   Normally
     socket 1 is assumed.


     Logger

     Sets socket to 1.


     Wait

     The connection attempt is repeated until
     successful.


     Name.for.connection.is <name>

     Sets the name  for  this  connection  as
     specified.


     [no] load.settings

     Determines whether to use  current  mode
     settings  or  to  load new ones from the
     mode file.


Disconnect <cr>

Disconnects the current connection.  This will not
necessarily  log  you  out  from  the remote host.
Perform   the    necessary    operations    before
disconnecting.


Disconnect <name>

Disconnects  the  connection  with  the  specified
name.


Net.exec

Connects  to  BBN  socket  15600031  where-in  the
RSEXEC (Resource-Sharing Executive) is found.


Status.of <host>

Performs ICP with the indicated  host  and  prints
its status.


Echo.mode.is

Sets  echo  mode  according   to   the   following
subcommand.


     [no] remote

     Turns off echoes generated by Telnet and
     signals  the remote computer to generate
     echoes.  Some hosts are not yet equipped
     to  handle  this  signal and may require
     additional action to  cause  the  remote
     computer  to generate echoes.  If Telnet
     believes it  is  connected  to  a  local
     half-duplex  terminal,  it will complain
     about remote echoes but do it anyway.


     [no] local

     Turns on  Telnet  generated  echoes  and
     signal   the   remote  computer  to  not
     generate echoes.  Note that Telnet never
     generates   echoes   for   terminals  it
     believes have local echo of their own.


     [no] linefeed.for.carriage.return

     TENEX translates carriage return to EOL,
     Telnet  sends  the EOL as the TELNET EOL
     (i.e.  carriage  return-linefeed).   For
     some   systems,   the   TELNET   EOL  is
     translated into  carriage  return.   For
     these  systems,  the appropriate echo is
     carriage    return.     Other    systems
     translate  the  TELNET EOL into carriage
     return-linefeed.  For these systems  the
     appropriate     echo     is     carriage
     return-linefeed.  This subcommand causes
     the latter echo to be generated.


     [no] control.character.echo.for <list of
     characters>

     Turns on local echoes for the  indicated
     control   characters.    Normally   only
     control-G,J, and M (bell, linefeed,  and
     carriage return) are enabled.


Terminal.type.is

Allows the user to change Telnet's opinion of  his
terminal  according  to the following subcommands.
Each command may be preceded by the word  "no"  to
negate its meaning.


     Half-duplex

     Terminal generates its own echoes.


     Full-duplex

     Terminal  does  not  generate  its   own
     echoes.


     [no] lower.case

     The terminal has lower case characters.


Local.mode

If connected, this command  prevents  Telnet  from
returning to remote mode after each command.


Remote.mode

If connected, this command causes Telnet to return
to   remote  mode  after  each  command.   If  not
connected, it does nothing.


No

May appear before some commands to  reverse  their
action.


Current.modes.are

Prints  the  state  of  connection  terminal  mode
flags, and all special characters.


[no] character.mode

Causes each character typed to be  transmitted  as
it is typed.


[no] line.buffer

Causes Telnet to accumulate a line of text  before
transmitting.   A  line ends on linefeed or EOL or
altmode  (esc).   The  line  may  be  edited  with
control-A, X, and R.


[no] raise

Causes lower case letters  to  be  transmitted  as
their upper case equivalents.


[no] lower

Causes upper case letters  to  be  transmitted  as
their lower case equivalents.


[no] transparent.mode

Causes all characters to pass through  Telnet  and
TENEX  untouched.   This  is  needed  for  special
terminals  such  as  the   IMLAC   using   special
character stream protocols.


[no] case.shift.prefix.for

Allows the specification of the  four  case  shift
characters    according    the    following   four
subcommands.


     Lock.lower.case

     Same as the "Lower" command.  Subsequent
     upper  case  input  will be converted to
     lower case.


     Char.lower.case

     Converts the following letter  to  lower
     case.


     Lock.upper.case

     Same  as  "Raise"  command.   Subsequent
     lower  case  input  will be converted to
     upper case.


     Char.upper.case

     Converts  the  following  character   to
     upper case.


[no] unshift.prefix

Causes all following characters to  be  unshifted.
I.e.   undoes  both an upper case lock and a lower
case lock.


[no] quote.prefix

Causes the following character to  be  transmitted
without  regard to any special significance it may
have.


[no] synch.character

The specified character will be converted  to  the
TELNET  synch sequence.  The TELNET synch sequence
is used to cause the remote host examine its input
stream  to  the  current  point  for  any  special
characters  (interrupts,  attentions  etc.).   All
non-special may be thrown away.


[no] attention.character

The specified character will be converted  to  the
TELNET   break   or   attention  character.   This
character is equivalent to the attention, quit, or
break   key   on  certain  terminals  and  may  be
necessary for using  some  systems.   The  !Break!
command generates the same character.


Concise

Turns off  automatic  command  completion.   Saves
typeout at the expense of readability.


Verbose

The opposite of concise.


[no] fancy.command.interpret

Commands are checked character by character.  If a
character  does  not  fit,  it  is ignored and not
echoed (full duplex terminals only).


[no] divert.output.stream.to.file

Causes  all  subsequent  output  from  the  remote
computer to be written on the specified file.  Use
"No divert..." to stop this.


[no] take.input.stream.from.file

Causes subsequent input to the remote host on  the
current  connection  to be read from the specified
file; input to other connections  and  in  command
mode  is  still from the user's terminal.  File is
automatically closed and released at EOF; user may
force  this  by "No take.input...", after escaping
to command mode.


[no] typescript.to.file

A  record  of  the  session  is  kept  on  a  file
including  both  input and output.  This is useful
for providing hard copy with scope terminals.


     typescript.to.file <cr>

     The file kept is TELNET.TYPESCRIPT;S  in
     the LOGIN (not connected) directory.


     typescript.to.file <filename> <cr>

     The named file receives the typescript.


     no typescript.to.file

     The typescript file (if any)  is  closed
     and    released;   subsequent   terminal
     activity is not saved.


Escape.character=

The specified character becomes the Telnet  escape
character.    This   character  must  be  a  TENEX
interrupt character.  "?"  will  type  what  these
are.

WARNING: If you have anywhere in your  programming
a   control-Z   you   should  change  your  escape
character in TELNET to  other  than  control-Z  to
avoid mishaps.


Clear.output.character=

The specified character becomes the  clear  output
buffer character.  Typing this character generates
an interrupt  which  causes  the  terminal  output
buffer and any accumulated output to be cleared.


Help

Prints the file <SYSTEM>TELNET.HELP on the  user's
terminal.


Describe <identifier>

Looks up the given identifier in the Help file and
prints  the accompanying description; an efficient
way to read the Help text.  Type "describe  ?"  to
get  a  list  of  identifiers; command recognition
operates on input of identifier.


Netstatus

Runs <SUBSYS>NETSTAT.SAV.


Socket.map

Prints a list of all  current  connection  on  the
system.   Optional arguments may be used to select
a particular  host  and  a  particular  connection
state.


Run

Runs the specified  file.   Like  the  EXEC's  run
command.


Quit

Returns from Telnet to the superior fork  (usually
the EXEC).  May be continued with no loss.


Logout

Logs out the  local  job  (not  the  remote  one).
Requires confirmation with a carriage return.


Reset

Re-initializes  Telnet  producing  an  essentially
virgin copy.


Ddt

Enters ddt.  If  ddt  is  not  loaded,  this  will
result  in  an  unexpected  interrupt.  No harm is
done if this happens.


Exec

Starts up an inferior  EXEC  under  Telnet.   This
EXEC  may  be  used  like  an ordinary EXEC to run
subsystems etc  without  disturbing  any  existing
connections.   The  Telnet  escape  character will
return to Telnet however.


Code

Transmits the character specified by the argument.
The  argument is a taken as an octal number unless
preceded  by  "d"   for   decimal   or   "h"   for
hexadecimal.   The argument may be preceded by "o"
for octal.


The "code" command  argument  may  be  used  as  a
command  by  itself  and  will cause the indicated
code to be transmitted.


!break!

Transmits the TELNET break character.


!synch!

Transmits the TELNET synch sequence.  Occasionally
the  "!synch!"  command  will work where the synch
character will not since the command bypasses  the
buffering  which may interfere with the use of the
synch character.


Write.modes.for.host

Causes the current mode flags to be saved  on  the
<SYSTEM>TELNET.MODES   file  under  the  specified
host.  Requires write access to the  file  and  is
thus not available to ordinary users.


Retrieve.connection.under.name

Retrieves the connection  previously  saved  under
the specified name.


Wait.for.any.active.connection

Used with multiple connections  to  wait  for  and
switch  attention  to the next connection that has
any   output   waiting.    Useful   when   several
independent  tasks  are  being run and you wish to
know when one completes and switch to that task.


[no] auto.switch.to.active.connection

Used  to   switch   between   tasks   on   several
connections  which  may  each be inactive for long
periods.  If the current connection is inactive on
both  input  and  output  for  a  given  number of
minutes, Telnet will begin to hunt for  any  other
active  connection.   If and only if one is found,
that connection is made current.  The  "inactivity
time  constant"  may  be specified as any positive
integral number of minutes if the "auto.switch..."
command   is   terminated  by  a  space.   A  <cr>
terminator invokes the default value of 2 minutes.
"No auto.switch..." disables this feature (current
connection   remains   current   until    manually
changed.)


Where.am.I

Prints a summary of the local job,  system,  user,
terminal and the remote host and socket.


[no] Signal.waiting.output

Causes all  non-current  connections  to  print  a
message when output becomes available.


Host.names

Lists all current host  names  with  corresponding
octal host numbers.


List.connections

Lists the name, local socket,  foreign  host,  and
foreign socket of all connections.


Flush.host

Marks all connections to  the  specified  host  as
dead  and  sends  a  reset to that host.  Requires
wheel or operator special capability.


Comments

An initial semi-colon causes the remainder of  the
line to be ignored.  Useful for comments or typing
to links.