Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
KERMIT(1)		     General Commands Manual		       KERMIT(1)

NAME
     kermit - C-Kermit 10.0: transport- and platform-independent interactive and
     scriptable communications software.

	    This  document  is intended to give the beginner sufficient informa-
	    tion to make basic use of  C-Kermit  10.0.	 Although  it  might  be
	    rather  long for a Unix manual page, it's still far shorter than the
	    C-Kermit manual, which should be consulted for advanced topics  such
	    as customization, character-sets, scripting, etc. We also attempt to
	    provide a clear structural overview of C-Kermit's many capabilities,
	    functional	areas,	states,  and modes and their interrelation, that
	    should be helpful to beginners and veterans alike,	as  well  as  to
	    those upgrading to version 10.0 from earlier releases.

     This document is also available as a Web page at:

	    https://kermitproject.org/ckututor.html

DESCRIPTION
     C-Kermit  is an all-purpose communications software package originally from
     the Kermit Project at Columbia University and now from the independent Open
     Source Kermit Project that:

     *	  Is portable to many platforms, Unix and non-Unix alike.
     *	  Can make both serial and network connections.
     *	  Can conduct interactive terminal sessions over its connection.
     *	  Can transfer text or binary files over the same connection.
     *	  Can convert character sets in the terminal session.
     *	  Can convert character sets during text-file file transfer.
     *	  Is customizable in every aspect of its operation.

     C-Kermit is a modem program, a Telnet client, an SSH client, an FTP client,
     an HTTP client, and on selected platforms, also an X.25 client. It can make
     its own secure Internet connections using	IETF-approved  security  methods
     including	Kerberos  IV,  Kerberos V, SSL/TLS, and SRP and it can also make
     SSH connections through your external SSH client application. It can be the
     far-end file-transfer or  client/server  partner  of  your  desktop  Kermit
     client. It can also accept incoming dialed and network connections.  It can
     even  be  installed  as an Internet service on its own standard TCP socket,
     1649 [RFC2839, RFC2840].

     And perhaps most important, everything you can do "by hand" (interactively)
     with C-Kermit, can be "scripted" (automated) using its built-in cross-plat-
     form transport-independent script programming language, which happens to be
     identical to its interactive command language.

     This manual page offers an overview of C-Kermit 10.0 for Unix ("Unix" is an
     operating system family that includes AIX,  DG/UX,  FreeBSD,  HP-UX,  IRIX,
     Linux,  Mac  OS  X,  NetBSD, OpenBSD, Open Server, Open Unix, QNX, Solaris,
     SunOS, System V R3, System V R4, Tru64 Unix, Unixware, Xenix, and many oth-
     ers). For thorough coverage, please consult the published	C-Kermit  manual
     and supplements (see DOCUMENTATION below). For further information about C-
     Kermit,  Kermit software for other platforms, and Kermit manuals, visit the
     Kermit Project website:

       https://kermitproject.org/

     This is a longer-than-average manual page, and yet it barely scratches  the
     surface.  Don't be daunted. C-Kermit is a large and complex package, evolv-
     ing over decades of practice and experience, but  that  doesn't  mean  it's
     hard  to  learn or use. Its most commonly used functions are explained here
     with pointers to additional information elsewhere.

SYNOPSIS
     kermit [ filename ] [ options ] [ {=,--,+} text ] ]

     or:

     kermit URL

     If the first command-line argument is the name of a file,	interactive-mode
     commands  are executed from the file. The '=' (or "--") argument tells Ker-
     mit not to parse the remainder of the command line, but to make  the  words
     following	'=' available as \%1, \%2, ... \%9. The "+" argument is like "="
     but for use in "kerbang scripts" (explained below). A  second  command-line
     format  allows the one and only argument to be a Telnet, FTP, HTTP, or IKSD
     URL.

     Order of execution:

      1.    The command file (if any).

      2.    The initialization file, if any, unless suppressed with -Y.

      3.    The customization file (if it  is  executed  by  the  initialization
	    file).

      4.    The command-line URL (if any, and if so, execution stops here).

      5.    Command-line options (if any).

      6.    Interactive commands.

     Some  command-line  options  can cause actions (such as -s to send a file);
     others just set parameters. If any action options are included on the  com-
     mand line, Kermit exits when finished unless also given the -S ("stay") op-
     tion.  If	no  action options are given, no initialization or command files
     contained an EXIT or QUIT command, and no fatal errors occurred, Kermit is-
     sues its prompt and waits for you to type commands.

	    Bear in mind that C-Kermit can be built with selected features  dis-
	    abled, and also that certain features are not available on all plat-
	    forms. For example, C-Kermit can't be built with TCP/IP support on a
	    platform  that  does not have TCP/IP header files and libraries (and
	    even if Kermit does include TCP/IP support, it can't be used to make
	    TCP/IP connections on a computer that does not have a  TCP/IP  stack
	    installed).  If  your  version of C-Kermit lacks a feature mentioned
	    here, use its SHOW FEATURES command to see what might have been  ex-
	    cluded.

     C-Kermit  has  three  kinds of commands: regular single-letter command-line
     options, extended-format command-line options, and interactive commands.

     Like most Unix commands, C-Kermit can be given options on the command line.
     But C-Kermit also can be used interactively by giving it commands	composed
     of  words,  which are more intuitive than cryptic command-line options, and
     more flexible too. In other words, you don't have to  use	C-Kermit's  com-
     mand-line	options, but they are available if you want to. (By the same to-
     ken, you don't have to use its interactive commands either -- you	can  use
     either or both in any combination.)

     C-Kermit  is  generally installed in the PATH as "kermit", and therefore is
     invoked by typing the word "kermit" (lowercase) at the  shell  prompt,  and
     then  pressing the Return or Enter key. If you wish to include command-line
     options, put them after the word "kermit" but before pressing Return or En-
     ter, separated by spaces, for example:

       $ kermit -s ckermit.tar.gz

     ('$' is the shell prompt; "kermit -s ckermit.tar.gz" is what you type, fol-
     lowed by Return or Enter.)

OPTIONS
     Here is a list of	C-Kermit's  single-letter  command-line  options,  which
     start  with  a single dash (-), in ASCII ("alphabetical") order. Alphabetic
     case is significant (-A is not the same as -a).  Action options are  tagged
     "ACTION".

     -0     (digit zero)  100% transparent Connect state for "in-the-middle" op-
	    eration:  8  bits, no parity, no escape character, everything passes
	    through.

     -8     (digit eight)  Connection is 8-bit clean (this is the default in  C-
	    Kermit  8.0 and later). Equivalent to the EIGHTBIT command, which in
	    turn is a shortcut for SET TERMINAL BYTESIZE 8, SET COMMAND BYTESIZE
	    8, SET PARITY NONE.

     -9 arg
	    (digit nine)  Make a connection to an FTP server.  Equivalent to the
	    FTP OPEN command.	Argument:  IP-address-or-hostname[:optional-TCP-
	    port].   NOTE: C-Kermit also has a separate FTP command-line person-
	    ality, with regular FTP-like command-line syntax.  More  about  this
	    below.

     -A     Kermit is to be started as an Internet service (IKSD) (only from in-
	    etd.conf).

     -B     Kermit  is running in Batch or Background (no controlling terminal).
	    To be used in case Kermit doesn't automatically sense its background
	    status.  Equivalent to the SET BACKGROUND ON command.

     -C arg
	    Interactive-mode Commands to be executed.  Argument: Commands  sepa-
	    rated by commas, list in doublequotes.

     -D arg
	    Delay before starting to send in Remote mode.  Equivalent to the SET
	    DELAY command.  Argument: Number of seconds.

     -E     Exit  automatically  when  connection closes. Equivalent to SET EXIT
	    ON-DISCONNECT ON.

     -F arg
	    Use an open TCP connection.  Argument: Numeric  file  descriptor  of
	    open TCP connection.  Also see: -j, -J.

     -G arg
	    (ACTION)  Get file(s) from server, send contents to standard output,
	    which normally would be piped to another process.  Argument:  Remote
	    file  specification,  in quotes if it contains metacharacters.  Also
	    see: -g, -k.

     -H     Suppress program startup Herald and greeting.

     -I     Tell Kermit it has a reliable connection, to force streaming  to  be
	    used where it normally would not be.  Equivalent to the SET RELIABLE
	    ON command.

     -J arg
	    (ACTION)  "Be  like  Telnet."  Like -j but implies -E.  Argument: IP
	    hostname/address optionally followed  by  service.	 NOTE:	C-Kermit
	    also  has  a  separate Telnet command-line personality, with regular
	    Telnet-like command-line syntax. More about this below.

     -L     Recursive directory descent for files in -s option.

     -M arg
	    My user name (for use with Telnet, SSH, FTP,  etc).   Equivalent  to
	    the SET LOGIN USER command.  Argument: Username string.

     -O     (ACTION)  (Uppercase  letter  O)  Be  a server for One command only.
	    Also see: -x.

     -P     Don't convert file (Path) names of transferred files.  Equivalent to
	    SET FILE NAMES LITERAL.

     -Q     Quick Kermit protocol settings. Equivalent to the FAST command. This
	    is the default in C-Kermit 7.0 and later.

     -R     Remote-only (this just makes IF REMOTE true).

     -S     Stay (enter command parser after action options).

     -T     Force Text mode for file transfer; implies -V.   Equivalent  to  SET
	    TRANSFER MODE MANUAL, SET FILE TYPE TEXT.

     -V     Disable automatic per-file text/binary switching.  Equivalent to SET
	    TRANSFER MODE MANUAL.

     -Y     Skip (don't execute) the initialization file.

     -a arg
	    As-name for file(s) in -s, -r, or -g.  Argument: As-name string (al-
	    ternative  filename).  When receiving files, this can be a directory
	    name.

     -b arg
	    Speed for serial device. Equivalent to SET SPEED.  Argument: Numeric
	    Bits per second for serial connections.

     -c     (ACTION) Enter Connect state before transferring files.

     -d     Create a debug.log file with detailed debugging information (a  sec-
	    ond  -d  adds  timestamps). Equivalent to LOG DEBUG but takes effect
	    sooner.

     -e arg
	    Maximum length for incoming Kermit file-transfer packets. Equivalent
	    to SET RECEIVE PACKET-LENGTH.  Argument: Length in bytes.

     -f     (ACTION) Send a FINISH command to a Kermit server.

     -g arg
	    Get file(s) from a Kermit server.  Argument: File  specification  on
	    other  computer, in quotes if it contains metacharacters. Equivalent
	    to GET. Also see: -a, -G, -r.

     -h     (ACTION) Print Help  text  for  single-letter  command-line  options
	    (pipe thru 'more' to prevent scrolling).

     -i     Force  binary (Image) mode for file transfer; implies -V. Equivalent
	    to SET TRANSFER MODE MANUAL, SET FILE TYPE BINARY.

     -j arg
	    Make a TCP/IP connection.  Argument: IP host  name/address	and  op-
	    tional  service  name  or  number. Equivalent to the TELNET command.
	    Also see: -J, -F.

     -k     (ACTION) Receive file(s) to standard output, which normally would be
	    piped to another process.  Also see: -r, -G.

     -l arg
	    (Lowercase letter L) Make a connection on the given serial	communi-
	    cations  device. Equivalent to the SET LINE (SET PORT) command.  Ar-
	    gument: Serial device name, e.g. /dev/ttyS0.

     -m arg
	    Modem type for use with the -l device. Equivalent to the  SET  MODEM
	    TYPE  command.   Argument:	Modem name as in SET MODEM TYPE command,
	    e.g. "usrobotics".

     -n     (ACTION) Enter Connect state after transferring files (historical).

     -p arg
	    Parity. Equivalent to the SET PARITY command.  Argument: One of  the
	    following: e(ven), o(dd), m(ark), n(one), s(pace).

     -q     Quiet (suppress most messages). Equivalent to SET QUIET ON.

     -r     (ACTION)  Receive file(s). Equivalent to the RECEIVE command.  Argu-
	    ment: (none, but see -a)

     -s arg
	    Send file(s).  Argument: One  or  more  local  file  specifications.
	    Equivalent to the SEND command.  Also see: -a.

     -t     (Historical)  Xon (Ctrl-Q) Turnaround character for half-duplex con-
	    nections (used on serial linemode connections  to  old  mainframes).
	    Equivalent to SET DUPLEX HALF, SET HANDSHAKE XON.

     -v arg
	    Window size for Kermit protocol (ignored when streaming). Equivalent
	    to SET WINDOW-SIZE.  Argument: Number, 1 to 32.

     -w     Incoming  files  Write  over  existing files. Equivalent to SET FILE
	    COLLISION OVERWRITE.

     -x     (ACTION) Enter server mode. Equivalent to the SERVER command.   Also
	    see: -O.

     -y arg
	    Alternative initialization file.  Argument: Filename.

     -z     Force  foreground  behavior. To be used in case Kermit doesn't auto-
	    matically sense its foreground status.  Equivalent to the SET  BACK-
	    GROUND OFF command.

     Extended  command-line  options  (necessary  because single-letter ones are
     about used up) start with two dashes (--), with words  rather  than  single
     letters  as  option  names.  If an extended option takes an argument, it is
     separated from the option word by a colon (:). Extended options include:

      --bannerfile:filename
	    File to display upon startup or IKSD login.

      --cdfile:filename
	    File to be sent for display to the client when server changes direc-
	    tory (filename is relative to the changed-to directory).

      --cdmessage:{on,off}
	    Enable/disable the server CD message feature.

      --help
	    Prints usage message for extended options.

      --helpfile:filename
	    Designates a file containing custom text to  replace  the  top-level
	    HELP command.

      --nointerrupts
	    Disables keyboard interrupts.

      --noperms
	    Disables  the Kermit protocol file Permissions attribute, to prevent
	    transmission of file permissions (protection)  from  sender  to  re-
	    ceiver.

      --version
	    (ACTION) C-Kermit prints its version number.

     Plus several other IKSD-Only options described at:

       https://kermitproject.org/iksd.html

     See the file-transfer section for examples of command-line invocation.

COMMAND LANGUAGE
     C-Kermit's  interactive  command language is the subject of a 622-page book
     and another several hundred pages of updates, far too  much  for  a  manual
     page.  But  it's  not  hard  to get started. At the shell prompt, just type
     "kermit" to get C-Kermit's interactive command prompt:

       $ kermit
       (/current/directory) C-Kermit>

     Begin by typing "help" (and then press the Return or Enter key) for a  top-
     level  overview,  read  it,  and  go from there. Your second command should
     probably be "intro" (introduction). Note the prompt shows your current  di-
     rectory (unless you tell Kermit to prompt you with something else).

     Interactive  commands are composed mainly of regular English words, usually
     in the form of imperative sentences, such as:

       send somefile.txt

     which tells Kermit to send (transfer) the file whose name is  somefile.txt,
     or:

       set transfer mode automatic

     which sets Kermit's "transfer mode" to "automatic" (whatever that means).

     While  typing  commands,  you can abbreviate, ask for help (by pressing the
     "?" key anywhere in a command), complete keywords or  filenames  (with  the
     Tab  or  Esc  key),  and edit your typing with Backspace or Delete, Ctrl-W,
     Ctrl-U, etc. You can also recall previous commands, save your command  his-
     tory, and who knows what else. Give the INTRO command for details.

     C-Kermit has hundreds of commands, and they can be issued in infinite vari-
     ety and combinations, including commands for:

     *	  Making connections (SET LINE, DIAL, TELNET, SSH, FTP, ...)
     *	  Breaking connections (HANGUP, CLOSE)
     *	  Transferring files (SEND, GET, RECEIVE, MOVE, RESEND, ...)
     *	  Establishing preferences (SET)
     *	  Displaying preferences (SHOW)
     *	  Managing local files (CD, DELETE, MKDIR, DIR, RENAME, TYPE, ...)
     *	  Managing remote files (RCD, RDEL, RMKDIR, RDIR, ...)
     *	  Using local files (FOPEN, FCLOSE, FREAD, FWRITE)
     *	  Programming (TAKE, DEFINE, IF, FOR, WHILE, SWITCH, DECLARE, ...)
     *	  Interacting with the user (ECHO, ASK, ...)
     *	  Interacting with a remote computer (INPUT, OUTPUT, ...)
     *	  Interacting with local programs (RUN, EXEC, PTY, ...)
     *	  Logging things (LOG SESSION, LOG PACKETS, LOG DEBUG, ...)

     And  of  course  QUIT or EXIT to get out and HELP to get help, and for pro-
     grammers: loops, decision making, variables,  arrays,  associative  arrays,
     integer  and  floating  point arithmetic, macros, built-in and user-defined
     functions, string manipulation, pattern matching, block structure, scoping,
     recursion, and even a built-in LISP regular expression interpreter.  To get
     a list of all C-Kermit's commands, type a question mark (?) at the  prompt.
     To  get a description of any command, type HELP followed by the name of the
     command, for example:

       help send

     The command interruption character is Ctrl-C (hold down the  Ctrl	key  and
     press the C key).

     The  command language "escape character", used to introduce variable names,
     function invocations, and so on, is backslash (\). If you need to include a
     literal backslash in a command, type two of them, e.g.:

       get c:\\k95\\k95custom.ini

   Command Files, Macros, and Scripts
     A file containing Kermit commands is called a Kermit command file or Kermit
     script. It can be executed with Kermit's TAKE command:

       (/current/dir) C-Kermit> take commandfile

     (where "commandfile" is the name of the command file).

     In Unix only, a Kermit command file can also be executed  directly  by  in-
     cluding a "kerbang" line as the first line of the file:

       #!/usr/local/bin/kermit +

     That is, a top line that starts with "#!", followed immediately by the full
     path  of  the  Kermit  executable,  and then, if the Kermit script is to be
     given arguments on the command line, a space and a plus  sign.  The  script
     file must also have execute permission:

       chmod +x commandfile

     Except  for  the  " +" part, this is exactly the same as you would do for a
     shell script, a Perl script, etc.	Here's	a  simple  but	useless  example
     script that regurgitates its arguments (up to three of them):

       #!/usr/local/bin/kermit +
       if defined \%1 echo "Argument 1: \%1"
       if defined \%2 echo "Argument 2: \%2"
       if defined \%3 echo "Argument 3: \%3"
       if defined \%4 echo "etc..."
       exit

     If this file is stored in your current directory as "commandfile", then:

       ./commandfile one two three four five

     prints:

       Argument 1: one
       Argument 2: two
       Argument 3: three
       etc...

     This  illustrates	the  basic  structure of a standalone Kermit script: the
     "kerbang line", then some commands. It should end with  "exit"  unless  you
     want  the Kermit prompt to appear when it is finished. \%1 is the first ar-
     gument, \%2 the second, and so on.

     You can also create your own commands by defining named macros composed  of
     other Kermit commands (or macros). For example:

       define mydelete {
	   local trash
	   assign trash \v(home)trashcan/
	   if not defined \%1 end 1 "Delete what?"
	   if wild \%1 {
	       end 1 "Deleting multiple files is too scary"
	   }
	   if not exist \%1 end 1 "I can't find \%1"
	   if not directory \m(trash) {
	       mkdir \m(trash)
	       if fail end 1 "No trash can"
	   }
	   rename /list \%1 \m(trash)
       }
       define myundelete {
	   local trash
	   assign trash \v(home)trashcan/
	   if not defined \%1 end 1 "Undelete what?"
	   if wild \%1 {
	       end 1 "Undeleting multiple files is too hard"
	   }
	   if not directory \m(trash) end 1 "No trash can"
	   if not exist \m(trash)\%1 {
	       end 1 "I can't find \%1 in trash can"
	   }
	   rename /list \m(trash)\%1 .
       }

     These  sample  macros are not exactly production quality (they don't handle
     filenames that include path segments, they  don't	handle	multiple  files,
     etc),  but you get the idea: you can pass arguments to macros, and they can
     check them and make other kinds of decisions. If you put  the  above  lines
     into  your  initialization  or customization file (explained below), you'll
     have MYDELETE and MYUNDELETE commands available every time you  start  Ker-
     mit, at least as long as you don't suppress execution of the initialization
     file.  (Exercise for the reader: Make these macros generally useful: remove
     limitations, add trashcan display, browsing, emptying, etc.)

     Kerbang scripts execute without the initialization file. This to keep  them
     portable  and  also to make them start faster. If you want to write Kerbang
     scripts that depend on the initialization file, include the command

       take \v(home).kermrc

     at the desired spot in the script. By the way, \v(xxx) is a built-in  vari-
     able  (xxx is the variable name, "home" in this case). To see what built-in
     variables are available, type "show variables" at the C-Kermit  prompt.  To
     see  what else you can show, type "show ?". \m(xxx) is a user defined vari-
     able (strictly speaking, it is a macro used as a variable).

   Command List
     C-Kermit has more than 200 top-level commands, and some of these,	such  as
     SET,  branch  off	into  hundreds	of subcommands of their own, so it's not
     practical to describe them all here. Instead, here's a concise list of  the
     most  commonly used top-level commands, grouped by category. To learn about
     each command, type "help" followed by the command name,  e.g.  "help  set".
     Terms  such  as Command state and Connect state are explained in subsequent
     sections.

     Optional fields are shown in [ brackets ].  "filename" means the name of  a
     single file. filespec means a file specification that is allowed to contain
     wildcard  characters  like  '*'  to match groups of files. options are (op-
     tional) switches like /PAGE, /NOPAGE, /QUIET, etc, listed in the HELP  text
     for each command. Example:

       send /recursive /larger:10000 /after:-1week /except:*.txt *

     which can be read as "send all the files in this directory and all the ones
     underneath  it that are larger than 10000 bytes, no more than one week old,
     and whose names don't end with ".txt".

   Basic Commands
	    HELP   Requests top-level help.

	    HELP command
		   Requests help about the given command.

	    INTRODUCTION
		   Requests a brief introduction to C-Kermit.

	    LICENSE
		   Displays the C-Kermit software copyright and license.

	    VERSION
		   Displays C-Kermit's version number.

	    EXIT [ number ]
		   Exits from Kermit with the given status code  (0  =	success,
		   nonzero = failure).	Synonyms: QUIT, E, Q.

	    TAKE filename [ parameters... ]
		   Executes commands from the given file.

	    LOG item [ filename ]
		   Keeps  a  log of the given item (DEBUG, TRANSACTIONS, etc) in
		   the given file.

	    [ DO ] macro [ parameters... ]
		   Executes commands from the given macro.

	    SET parameter value
		   Sets the given parameter to the given value.

	    SHOW category
		   Shows settings in a given category.

	    STATUS
		   Tells whether previous command succeeded or failed.

	    DATE [ date-and/or-time ]
		   Shows current date-time or interprets given date-time.

	    RUN [ extern-command [ parameters... ]
		   Runs the given external command. Synonym: !.

	    EXEC [ extern-command [ params... ]
		   Kermit overlays itself with the given command.

	    SUSPEND
		   Stops Kermit and puts it in the background. Synonym: Z.

   Local File Management
	    TYPE [ options ] filename
		   Displays the contents of the given file.

	    MORE [ options ] filename
		   Equivalent to TYPE /PAGE (pause after each screenful).

	    CAT [ options ] filename
		   Equivalent to TYPE /NOPAGE.

	    HEAD [ options ] filename
		   Displays the first few lines of a given file.

	    TAIL [ options ] filename
		   Displays the last few lines of a given file.

	    GREP [ options ] pattern filespec
		   Displays lines from files that match  the  pattern.	Synonym:
		   FIND.

	    DIRECTORY [ options ] [filespec ]
		   Lists files (built-in, many options).

	    LS [ options ] [ filespec ]
		   Lists files (runs external "ls" command).

	    DELETE [ options ] [ filespec ]
		   Deletes files. Synonym: RM.

	    PURGE [ options ] [ filespec ]
		   Removes backup (*.~n~) files.

	    COPY [ options ] [ filespecs... ]
		   Copies files. Synonym: CP.

	    RENAME [ options ] [ filespecs... ]
		   Renames files. Synonym: MV.

	    CHMOD [ options ] [ filespecs... ]
		   Changes permissions of files.

	    TRANSLATE filename charsets [ filename ]
		   Converts file's character set. Synonym: XLATE.

	    CD	   Changes your working directory to your home directory.

	    CD directory
		   Changes your working directory to the one given.

	    CDUP   Changes your working directory one level up.

	    PWD    Displays your working directory.

	    BACK   Returns to your previous working directory.

	    MKDIR [ directory ]
		   Creates a directory.

	    RMDIR [ directory ]
		   Removes a directory.

   Making Connections
	    SET LINE [ options ] devicename
		   Opens the named serial port. Synonym: SET PORT.

	    OPEN LINE [ options ] devicename
		   Same as SET LINE. Synonym: OPEN PORT.

	    SET MODEM TYPE [ name ]
		   Tells Kermit what kind of modem is on the port.

	    DIAL [ number ]
		   Tells Kermit to dial the given phone number with the modem.

	    REDIAL
		   Redials the most recently dialed phone number.

	    ANSWER
		   Waits for and answers an incoming call on the modem.

	    AUTHENTICATE [ parameters... ]
		   Performs secure authentication on a TCP/IP connection.

	    SET NETWORK TYPE { TCP/IP, X.25, ... }
		   Selects network type for subsequent SET HOST commands.

	    SET HOST [ options ] host [ port ]
		   Opens a network connection to the given host and port.

	    SET HOST * port
		   Waits for an incoming TCP/IP connection on the given port.

	    SSH [ options ] host
		   Opens  a secure SSH connection to the host and enters Connect
		   state.

	    TELNET [ options ] host
		   Opens a Telnet connection to  the  host  and  enters  Connect
		   state.

	    RLOGIN [ options ] host
		   Opens  an  Rlogin  connection  to the host and enters Connect
		   state.

	    IKSD [ options ] host
		   Opens a connection to an Internet Kermit Service.

	    FTP OPEN host [ options ]
		   Opens an FTP connection to the host.

	    HTTP [ options ] OPEN host
		   Opens an HTTP connection to the host.

	    PTY external-command
		   Runs the command on a pseudoterminal as if it were a  connec-
		   tion.

	    PIPE external-command
		   Runs the command through a pipe as if it were a connection.

   Using Connections
	    CONNECT [ options ]
		   Enters Connect (terminal) state.  Synonym: C.

	    REDIRECT command
		   Redirects the given external command over the connection.

	    TELOPT command
		   Sends a Telnet protocol command (Telnet connections only).

	    Ctrl-\C
		   "Escapes back" from Connect state to Command state.

	    Ctrl-\B
		   (In Connect state) Sends a BREAK signal (serial or Telnet).

	    Ctrl-\!
		   (In Connect state) Enters inferior shell; "exit" to return.

	    Ctrl-\?
		   (In	Connect  state)  Shows	a menu of other escape-level op-
		   tions.

	    Ctrl-\Ctrl-\
		   (In Connect state) Type two Ctrl-Backslashes to send  one  of
		   them.

	    SET ESCAPE [ character ]
		   Changes Kermit's Connect-state escape character.

   Closing Connections
	    HANGUP
		   Hangs  up  the  currently open serial-port or network connec-
		   tion.

	    CLOSE  Closes the currently open serial-port or network connection.

	    SET LINE (with no devicename)
		   Closes the currently open serial-port or network connection.

	    SET HOST (with no hostname)
		   Closes the currently open serial-port or network connection.

	    FTP CLOSE
		   Closes the currently open FTP connection.

	    HTTP CLOSE
		   Closes the currently open HTTP connection.

	    EXIT   Also closes all connections. Synonym: QUIT.

	    SET EXIT WARNING OFF
		   Suppresses warning about open connections on exit or close.

   File Transfer
	    SEND [ options ] filename [ as-name ]
		   Sends the given file. Synonym: S.

	    SEND [ options ] filespec
		   Sends all files that match.

	    RESEND [ options ] filespec
		   Resumes an interrupted SEND from the point of failure.

	    RECEIVE [ options ] [ as-name ]
		   Waits passively for files to arrive. Synonym: R.

	    LOG TRANSACTIONS [ filename ]
		   Keeps a record of file transfers.

	    FAST   Use fast file-transfer settings (default).

	    CAUTIOUS
		   Use cautious and less fast file-transfer settings.

	    ROBUST
		   Use ultra-conservative and slow file-transfer settings.

	    STATISTICS [ options ]
		   Gives statistics about the most recent file transfer.

	    WHERE  After transfer: "Where did my files go?".

	    TRANSMIT [ options ] [ofilename ]
		   Sends file without protocol. Synonym: XMIT.

	    LOG SESSION [ filename ]
		   Captures remote text or files without protocol.

	    SET PROTOCOL [ name... ]
		   Tells Kermit to use an external file-transfer protocol.

	    FTP { PUT, MPUT, GET, MGET, ... }
		   FTP client commands.

	    HTTP { PUT, GET, HEAD, POST, ... }
		   HTTP client commands.

   Kermit Server
	    ENABLE, DISABLE
		   Controls which server features can be used by clients.

	    SET SERVER
		   Sets parameters prior to entering Server state.

	    SERVER
		   Enters Server state.

   Client of Kermit or FTP Server
	    [ REMOTE ] LOGIN [ user password ]
		   Logs in to a Kermit server or IKSD that requires it.

	    [ REMOTE ] LOGOUT
		   Logs out from a Kermit server or IKSD.

	    SEND [ options ] filename [ as-name ]
		   Sends the given file to the server. Synonyms: S, PUT.

	    SEND [ options ] filespec
		   Sends all files that match.

	    RESEND [ options ] filespec
		   Resumes an interrupted SEND from the point of failure.

	    GET [ options ] remote-filespec
		   Asks the server to send the given files. Synonym: G.

	    REGET [ options ] remote-filespec
		   Resumes an interrupted GET from the point of failure.

	    REMOTE CD [ directory ]
		   Asks server to change its working directory. Synonym: RCD.

	    REMOTE PWD [ directory ]
		   Asks server to display its working directory. Synonym: RPWD.

	    REMOTE DIRECTORY [ filespec... ]
		   Asks server to send a directory listing. Synonym: RDIR.

	    REMOTE DELETE [ filespec... ]
		   Asks server to delete files. Synonym: RDEL.

	    REMOTE [ command... ]
		   (Many other commands: "remote ?" for a list).

	    MAIL [ options ] filespec
		   Sends file(s) to be delivered as e-mail (Kermit only).

	    FINISH
		   Asks the server to exit server state (Kermit only).

	    BYE    Asks the server to log out and close the connection.

   Script Programming
	    DEFINE, DECLARE, UNDEFINE, UNDECLARE, ASSIGN, EVALUATE, SEXPRESSION,
	    ARRAY, SORT, INPUT, OUTPUT, IF, FOR, WHILE, SWITCH, GOTO, ECHO, ASK,
	    GETC, GETOK, ASSERT, WAIT,	SLEEP,	FOPEN,	FREAD,	FWRITE,  FCLOSE,
	    STOP,  END, RETURN, LEARN, SHIFT, TRACE, VOID, INCREMENT, DECREMENT,
	    ... For these and many more you'll need to consult	the  manual  and
	    supplements,  and/or visit the Kermit Script Library, which also in-
	    cludes a brief tutorial. Hint: HELP LEARN to find  out  how  to  get
	    Kermit to write simple scripts for you.

     Many  of  Kermit's  commands have synonyms, variants, relatives, and so on.
     For example, MSEND is a version of SEND that accepts a list of file  speci-
     fications	to be sent, rather than just one file specification, and MPUT is
     a synonym of MSEND. MOVE means to SEND and then DELETE the source	file  if
     successful. MMOVE is like MOVE, but accepts a list of filespecs, and so on.
     These are described in the full documentation.

     Use  question  mark  to  feel your way through an unfamiliar command, as in
     this example:

       C-Kermit> remote ? One of the following:
	assign	   directory  kermit	 print	    rmdir
	cd	   exit       login	 pwd	    set
	copy	   help       logout	 query	    space
	delete	   host       mkdir	 rename     type
       C-Kermit> remote set ? One of the following:
	attributes   file	  retry        transfer
	block-check  receive	  server       window
       C-Kermit> remote set file ? One of the following:
	character-set  incomplete     record-length
	collision      names	      type
       C-Kermit> remote set file names ? One of the following:
	converted  literal
       C-Kermit> remote set file names literal
       C-Kermit>

     This is called menu on demand: you get a menu when you want one, but  menus
     are  not  forced on you even when know what you're doing. Note that you can
     also abbreviate most keywords, and you can complete them with  the  Tab  or
     Esc  key. Also note that ? works for filenames too, and that you can use it
     in the middle of a keyword or filename, not just at the beginning. For  ex-
     ample,  "send  x?" lists all the files in the current directory whose names
     start with 'x'.

INITIALIZATION FILE
     In its default configuration, C-Kermit executes commands from a file called
     .kermrc in your home directory when it starts, unless it is given the -Y or
     -y command-line option. Custom configurations  might  substitute  a  shared
     system-wide  initialization file. The SHOW FILE command tells what initial-
     ization file, if any, was used. The standard initialization  file	"chains"
     to  an  individual  customization file, .mykermc, in the home directory, in
     which each user can establish her/his own preferences, define  macros,  and
     so on.

     Since  execution  of  the	initialization	file (at least the standard one)
     makes C-Kermit take longer to start, it might be better not to have an ini-
     tialization file, especially now that Kermit's default  startup  configura-
     tion  is well attuned to modern computing and networking -- in other words,
     you no longer have do anything special to make Kermit transfers go fast. So
     instead of having an initialization file that is executed every time Kermit
     starts, you might consider making one or more kerbang scripts  (with  names
     other that .kermrc) that do NOT include an "exit" command, and invoke those
     when you need the settings, macro definitions, and/or scripted actions they
     contain, and invoke C-Kermit directly when you don't.

MODES OF OPERATION
     Kermit  is  said to be in Local mode if it has made a connection to another
     computer, e.g. by dialing it or establishing a Telnet connection to it. The
     other computer is remote, so if you start another copy of Kermit on the re-
     mote computer, it is said to be in Remote mode (as long as it has not  made
     any  connections of its own). The local Kermit communicates over the commu-
     nications device or network connection, acting as a conduit between the re-
     mote computer and your keyboard and screen. The remote Kermit is the  file-
     transfer  partner	to  the  local	Kermit and communicates only through its
     standard input and output.

     At any moment, a Kermit program can be in any of the following states. It's
     important to know what they are and how to change from one to the other.

     Command state
	    In this state, Kermit reads commands from:

	    *	 Your keyboard; or:
	    *	 A file, or:
	    *	 A macro definition.

	    You can exit from Command state back to Unix with the EXIT	or  QUIT
	    command  (same thing). You can enter Connect state with any of vari-
	    ous commands (CONNECT, DIAL, TELNET, etc). You can enter file trans-
	    fer state with commands like SEND, RECEIVE, and GET. You  can  enter
	    Server  state with the SERVER command. The TAKE command tells Kermit
	    to read and execute commands from a file. The (perhaps  implied)  DO
	    command tells Kermit to read and execute commands from a macro defi-
	    nition.   While  in  Command  state,  you can interrupt any command,
	    macro, or command file by typing Ctrl-C (hold down the Ctrl key  and
	    press the C key); this normally brings you back to the prompt.

     Shell state
	    You can invoke an inferior shell or external command from the Kermit
	    command  prompt by using the PUSH, RUN (!), EDIT, or BROWSE command.
	    While the inferior shell or command is active, Kermit  is  suspended
	    and does nothing. Return to Kermit Command state by exiting from the
	    inferior shell or application.

     Connect state
	    In	this  state,  which can be entered only when in Local mode (i.e.
	    when Kermit has made a connection to another  computer),  Kermit  is
	    acting  as	a  terminal  to the remote computer. Your keystrokes are
	    sent to the remote computer and characters that arrive over the com-
	    munication connection are displayed on your screen.  This  state  is
	    entered when you give a CONNECT, DIAL, TELNET, SSH, or IKSD command.
	    You  can  return  to command state by logging out of the remote com-
	    puter, or by typing:

	      Ctrl-\c

	    That is: Hold down the Ctrl key and press the  backslash  key,  then
	    let  go of the Ctrl key and press the C key. This is called escaping
	    back.  Certain other escape-level commands are also  provided;  type
	    Ctrl-\?  for a list. For example, you can enter Shell state with:

	      Ctrl-\!

	    To	send  a  Ctrl-\  to the host while in Connect state, type two of
	    them in a row. See HELP CONNECT and HELP SET ESCAPE for more info.

     Local file-transfer state
	    In this state, Kermit is sending packets back  and	forth  with  the
	    other  computer in order to transfer a file or accomplish some other
	    file-related task. And at  the  same  time,  it  is  displaying  its
	    progress  on  your	screen	and watching your keyboard for interrup-
	    tions. In this state, the following  single-keystroke  commands  are
	    accepted:

	    X	   Interrupt the current file and go on to the next (if any).

	    Z	   Interrupt the current file and skip all the rest.

	    E	   Like  Z  but  uses a "stronger" protocol (use if X or Z don't
		   work).

	    Ctrl-C
		   Interrupt file-transfer mode (use if Z or E don't work).

     Kermit returns to its previous state (Command or Connect) when the transfer
     is complete or when interrupted successfully by X, Z, E,  or  Ctrl-C  (hold
     down the Ctrl key and press the C key).

     Remote file-transfer state
	    In	this  state, Kermit is exchanging file-transfer packets with its
	    local partner over its standard i/o. It leaves this state  automati-
	    cally  when  the  transfer	is complete. In case you find your local
	    Kermit in Connect state and the remote one	in  File-transfer  state
	    (in  which	it seems to ignore your keystrokes), you can usually re-
	    turn it to command state by typing three Ctrl-C's in a row. If  that
	    doesn't  work,  return your local Kermit to Command state (Ctrl-\ C)
	    and type "e-packet" and then press the Return  or  Enter  key;  this
	    forces a fatal Kermit protocol error.

     Remote Server state
	    This is like Remote File-transfer state, except it never returns au-
	    tomatically to Command state. Rather, it awaits further instructions
	    from  the  client  program; that is, from your Local Kermit program.
	    You can return the Remote Server to its previous state by issuing  a
	    "finish"  command  to the client, or if you are in Connect state, by
	    typing three Ctrl-C's in a row. You can tell the server job  to  log
	    out  and  break  the  connection  by  issuing a "bye" command to the
	    client.

     Local Server state
	    Like Remote-Server state, but in local mode, and therefore with  its
	    file-transfer  display  showing,  and  listening for single-key com-
	    mands, as in Local File-transfer state. Usually this  state  is  en-
	    tered  automatically  when	a remote Kermit program gives a GET com-
	    mand.

	    C-Kermit, Kermit 95, and MS-DOS Kermit all can switch  automatically
	    from  Connect state to Local File-transfer state when you initiate a
	    file transfer from	the  remote  computer  by  starting  Kermit  and
	    telling  it  to  send or get a file, in which case, Connect state is
	    automatically resumed after the file transfer is finished.

	    Note that C-Kermit is not a terminal emulator. It  is  a  communica-
	    tions application that you run in a terminal window (e.g. console or
	    Xterm). The specific emulation, such as VT100, VT220, Linux Console,
	    or	Xterm,	is provided by the terminal window in which you are run-
	    ning C-Kermit. Kermit 95 and MS-DOS Kermit, on the other  hand,  are
	    true  terminal  emulators.	Why is C-Kermit not a terminal emulator?
	    CLICK HERE to read about it.

MAKING CONNECTIONS
     Here is how to make different kinds of connections using interactive Kermit
     commands (as noted above, you can also make connections  with  command-line
     options).	Note that you don't have to make connections with Kermit. It can
     also be used on the far end of a connection as the remote file transfer and
     management partner of your local communications software.

     Making a Telnet Connection
	    At the C-Kermit command prompt, simply type:

	      telnet foo.bar.com

	    (substituting desired hostname or address).  You can also include  a
	    port number:

	      telnet xyzcorp.com 3000 ;

	    If	the  connection is successful, Kermit automically enters Connect
	    state. When you logout from the remote  host,  Kermit  automatically
	    returns to its prompt. More info: HELP TELNET, HELP SET TELNET, HELP
	    SET TELOPT. Also see the IKSD section below.

     Making an Rlogin connection
	    This  is  just  like Telnet, except you have to be root to do it be-
	    cause Rlogin uses a privileged TCP port:

	      rlogin foo.bar.com

	    More info: HELP RLOGIN.

     Making an SSH Connection
	    Unlike Telnet and Rlogin, SSH connections are not built-in, but han-
	    dled by running your external SSH client through  a  pseudoterminal.
	    Using  C-Kermit  to control the SSH client gives you all of Kermit's
	    features (file transfer, character-set conversion,	scripting,  etc)
	    over SSH.

	      ssh foo.bar.com

	    More info: HELP SSH, HELP SET SSH.

     Dialing with a Modem
	    If it's an external modem, make sure it is connected to a usable se-
	    rial  port	on your computer with a regular (straight-through) modem
	    cable, and to the telephone jack with a telephone  cable,  and  that
	    it's turned on. Then use these commands:

	      set modem type usrobotics  ; Or other supported type
	      set line /dev/ttyS0	 ; Specify device name
	      set speed 57600		 ; Or other desired speed
	      set flow rts/cts		 ; Most modern modems support this
	      set dial method tone	 ; (or pulse)
	      dial 7654321		 ; Dial the desired number

	    Type  "set modem type ?" for a list of supported modem types. If you
	    omit the SET MODEM TYPE command, the default type is  "generic-high-
	    speed",  which should work for most modern AT-command-set modems. If
	    the line is busy, Kermit redials automatically. If the call does not
	    succeed, use "set dial display on" and try it again  to  watch  what
	    happens. If the call succeeds, Kermit enters Connect state automati-
	    cally  and returns to its prompt automatically when you log out from
	    the remote computer or the connection is otherwise lost.

	    You can also dial from a modem that is accessible by Telnet, e.g. to
	    a reverse terminal server. In this case the command sequence is:

	      set host ts.xxx.com 2000	 ; Terminal-server and port
	      set modem type usrobotics  ; Or other supported type
	      set dial method tone	 ; (or pulse)
	      dial 7654321		 ; Dial the desired number

	    If the terminal server supports the  Telnet  Com  Port  Option,  RFC
	    2217,  you	can  also  give serial-port related commands such as SET
	    SPEED, SET PARITY, and so on, and Kermit relays them to the terminal
	    server using the protocol specified in the RFC.

	    More info: HELP SET MODEM, HELP SET LINE, HELP SET SPEED,  HELP  SET
	    FLOW,  HELP  DIAL,	HELP  SET  DIAL,  HELP	SET MODEM, HELP SET CAR-
	    RIER-WATCH, SHOW COMMUNICATIONS, SHOW MODEM, SHOW DIAL.

     Direct Serial Port
	    Connect the two computers, A and B, with a null modem cable (or  two
	    modem cables interconnected with a null-modem adapter or modem elim-
	    inator). From Computer A:

	      set modem type none   ; There is no modem
	      set line /dev/ttyS0   ; Specify device name
	      set carrier-watch off ; If DTR CD are not cross-connected
	      set speed 57600	    ; Or other desired speed
	      set flow rts/cts	    ; If RTS and CTS are cross-connected
	      set parity even	    ; (or "mark" or "space", if necessary)
	      set stop-bits 2	    ; (rarely necessary)
	      set flow xon/xoff     ; If you can't use RTS/CTS
	      connect		    ; Enter Connect (terminal) state

	    This  assumes  Computer  B is set up to let you log in. If it isn't,
	    you can run a copy of Kermit on Computer B and follow  approximately
	    the same directions. More info: As above plus HELP CONNECT.

     With  modems or direct serial connections, you might also have to "set par-
     ity even" (or "mark" or "space") if it's a 7-bit connection.

     Of the connection types listed above, only one can be open at a time.  How-
     ever, any one of these can be open concurrently with an FTP  or  HTTP  ses-
     sion.  Each  connection  type  can  be  customized  to  any desired degree,
     scripted, logged, you name it. See the manual.

     NOTE: On selected platforms, C-Kermit also can make X.25  connections.  See
     the manual for details.

TRANSFERRING FILES WITH KERMIT
     There is a widespread and persistent belief that Kermit is a slow protocol.
     This  is because, until recently, it used conservative tuning by default to
     make sure file transfers succeeded, rather than failing because they  over-
     loaded  the  connection. Some extra commands (or command-line options, like
     -Q) were needed to make it go fast, but nobody bothered to find  out  about
     them.  Also, it takes two to tango: most non-Kermit-Project Kermit protocol
     implementations really ARE slow. The best file-transfer partners for C-Ker-
     mit are: another copy of C-Kermit (7.0 or later) on Unix, (Open)VMS, or Mi-
     crosoft Windows (formerly known as Kermit 95 or K95, now in Open Source re-
     lease as C-Kermit 10.0 for Windows or CKW).  These combinations  work  well
     and  they	work fast by default. MS-DOS Kermit is good too, but you have to
     tell it to go fast (by giving it the FAST command).

     Furthermore, all three of these Kermit programs support "autodownload"  and
     "autoupload",  meaning  that  when  they  are in Connect state and a Kermit
     packet comes in from the remote, they automatically switch into file trans-
     fer mode.

     And plus, C-Kermit switches automatically between text and binary mode  for
     each  file, so there is no need to "set file type binary" or "set file type
     text", or to worry about files being corrupted  because  they  were  trans-
     ferred in the wrong mode.

     What all of these words add up to is that now, when you use up-to-date Ker-
     mit  software from the Kermit Project, file transfer is not only fast, it's
     ridiculously easy. You barely have to give any commands at all.

Downloading Files
     Let's say you have C-Kermit for Unix or VMS, CKW  for  Windows,  or  MS-DOS
     Kermit  on your desktop computer, with a connection to a Unix computer that
     has C-Kermit installed as "kermit". To download a file (send it  from  Unix
     to  your  desktop	computer),  just type the following command at your Unix
     shell prompt:

       kermit -s somefile.txt

     (where somefile.txt is the filename). If you want to  send  more  than  one
     file,  you  can  put as many filenames as you want on the command line, and
     they can be any combination of text and binary:

       kermit -s somefile.txt somefile.zip somefile.html somefile.tar.gz

     and/or you can use wildcards to send groups of files:

       kermit -s somefile.*

     If you want to send a file under an assumed name, use:

       kermit -s friday.txt -a today.txt

     This sends the file friday.txt but tells the receiving Kermit that its name
     is today.txt. In all cases, as noted, when the file transfer  is  finished,
     your  desktop  Kermit  returns  automatically to Connect state.  No worries
     about escaping back, re-connecting, text/binary mode switching. Almost  too
     easy, right?

Uploading Files
     To  upload  files	(send them from your desktop computer to the remote Unix
     computer) do the same thing, but use the -g (GET) option instead of -s:

       kermit -g somefile.txt

     This causes your local Kermit to enter server mode; then the remote  Kermit
     program  requests	the named file and the local Kermit sends it and returns
     automatically to Connect state when done.

     If you want to upload multiple files, you have to use shell quoting  rules,
     since these aren't local files:

       kermit -g "somefile.txt somefile.zip somefile.html somefile.tar.gz"
       kermit -g "somefile.*"

     If you want to upload a file but store it under a different name, use:

       kermit -g friday.txt -a today.txt

Kermit Transfers the Old-Fashioned Way
     If  your  desktop	communications	software  does not support autoupload or
     autodownload, or it does not include Kermit server mode, the procedure  re-
     quires more steps.

     To download a file, type:

       kermit -s filename

     on  the host as before, but if nothing happens automatically in response to
     this command, you have to switch your desktop communications software  into
     Kermit  Receive  state.  This might be done by escaping back using keyboard
     characters or hot keys (Alt-x is typical) and/or with a command  (like  RE-
     CEIVE)  or  a menu. When the file transfer is complete, you have to go back
     to Connect state, Terminal emulation, or whatever	terminology  applies  to
     your desktop communications software.

     To upload a file, type:

       kermit -r

     on  the  host  (rather  than "kermit -g"). This tells C-Kermit to wait pas-
     sively for a file to start arriving. Then	regain	the  attention	of  your
     desktop  software	(Alt-x	or whatever) and instruct it to send the desired
     file(s) with Kermit protocol. When the transfer is finished, return to  the
     Connect or Terminal screen.

If File Transfer Fails
     Although  every aspect of Kermit's operation can be finely tuned, there are
     also three short and simple "omnibus tuning" commands you can use for trou-
     bleshooting:

	    FAST   Use fast file-transfer settings. This has  been  the  default
		   since C-Kermit 7.0 now that most modern computers and connec-
		   tions support it. If transfers fail with fast settings, try .
		   . .

	    CAUTIOUS
		   Use	cautious  but  not paranoid settings. File transfers, if
		   they work, will go at medium speed. If not, try . . .

	    ROBUST
		   Use the most robust, resilient, conservative, safe, and reli-
		   able settings. File transfers will almost certainly work, but
		   they will be quite slow (of course this is a  classic  trade-
		   off; ROBUST was C-Kermit's default tuning in versions 6.0 and
		   earlier,  which  made  everybody  think  Kermit  protocol was
		   slow). If ROBUST doesn't do the trick,  try	again  with  SET
		   PARITY SPACE first in case it's not an 8-bit connection.

     Obviously the success and performance of a file transfer also depends on C-
     Kermit's  file  transfer  partner. Up-to-date, real Kermit Project partners
     are recommended because they contain the best Kermit  protocol  implementa-
     tions and because we can support them in case of trouble.

     If  you  still  have trouble, consult Chapter 10 of Using C-Kermit, or send
     email to upport@kermitproject.org.

Advanced Kermit File-Transfer Features
     Obviously there is a lot more to Kermit file transfer, including all  sorts
     of  interactive  commands,  preferences, options, logging, debugging, trou-
     bleshooting, and anything else you can imagine but that's what  the  manual
     and updates are for. Here are a few topics you can explore if you're inter-
     ested by Typing HELP for the listed commands:

	    Logging transfers:
		   LOG TRANSACTIONS (HELP LOG)

	    Automatic per-file text/binary mode switching:
		   SET TRANSFER MODE { AUTOMATIC, MANUAL } (HELP SET TRANSFER).

	    Cross-platform recursive directory tree transfer:
		   SEND /RECURSIVE, GET /RECURSIVE (HELP SEND, HELP GET).

	    File collision options:
		   SET	FILE COLLISION { OVERWRITE, BACKUP, DISCARD, ... } (HELP
		   SET FILE).

	    Update: Transfer only files that changed since last time:
		   SET FILE COLLISION UPDATE (HELP SET FILE).

	    Filename selection patterns:
		   (HELP WILDCARD).

	    Flexible file selection:
		   SEND (or GET) /BEFORE /AFTER /LARGER /SMALLER /TYPE	/EXCEPT,
		   ...

	    Character-set conversion:
		   SET { FILE, TRANSFER } CHARACTER-SET, ASSOCIATE, ...

	    File/Pathname control:
		   SET { SEND, RECEIVE } PATHNAMES, SET FILE NAMES.

	    Atomic file movement:
		   SEND (or GET) /DELETE /RENAME /MOVE-TO

	    Transferring to/from standard i/o of other commands:
		   SEND (or GET) /COMMAND

	    Recovery of interrupted transfer from point of failure:
		   RESEND, REGET (HELP RESEND, HELP REGET).

Non-Kermit File Transfer
     You  can also use C-Kermit to transfer files with FTP or HTTP Internet pro-
     tocols; see below.

     On a regular serial or Telnet connection where the other  computer  doesn't
     support  Kermit  protocol at all, you have several options. For example, if
     your desktop communications software supports Zmodem, use "rz" and "sz"  on
     the  host	rather	than Kermit. But if Kermit is your desktop software, and
     you are using it to make calls or network connections  to	other  computers
     that  don't  support Kermit protocol (or that don't have a good implementa-
     tion of it), then if your computer also has external X, Y, or  Zmodem  pro-
     grams  that  are  redirectable,  Kermit can use them as external protocols.
     HELP SET PROTOCOL for details.

     You can also capture "raw" data streams from the other  computer  with  LOG
     SESSION (HELP LOG and HELP SET SESSION-LOG for details), and you can upload
     files  without  any  protocol at all with TRANSMIT (HELP TRANSMIT, HELP SET
     TRANSMIT).

KERMIT'S BUILT-IN FTP AND HTTP CLIENTS
     Kermit's FTP client is like the regular Unix FTP client  that  you're  used
     to, but with some differences:

     *	    It has lots more commands and features.

     *	    Each  FTP  command	must  be  prefixed  with "ftp", for example "ftp
	    open", "ftp get", "ftp bye", etc (this is not strictly true, but un-
	    til you're more familiar with it, it's best to follow this rule).

     *	    Commands like "cd", "directory", etc, execute locally,  not  on  the
	    server.  Use  "ftp	cd",  "ftp  dir",  etc,  to have them act on the
	    server.

     *	    You can have an FTP session and a regular Kermit  serial  or  Telnet
	    session open at the same time.

     *	    FTP sessions can be fully automated.

     The  Kermit  FTP client is thoroughly documented at the Kermit Project web-
     site:

       https://kermitproject.org/ftpclient.html

     You also can use HELP FTP and HELP SET FTP to get descriptions of	Kermit's
     FTP-related commands.

     The  HTTP	client is similar to the FTP one, except you prefix each command
     with HTTP instead of FTP: HTTP OPEN, HTTP GET, HTTP PUT, HTTP  CLOSE,  etc.
     Type  HELP  HTTP  for details, or visit the to view the manual supplements.
     HTTP connections can be open at the same time as regular serial  or  Telnet
     connections  and  FTP  connections.  So Kermit can manage up to three types
     connections simultaneously.

INTERNET KERMIT SERVICE
     C-Kermit can be configured and run as an Internet	service  (called  IKSD),
     similar to an FTP server (FTPD) except you can (but need not) interact with
     it  directly,  plus  it  does a lot more than an FTP server can do. The TCP
     port for IKSD is 1649. It uses Telnet protocol. C-Kermit can be an Internet
     Kermit Server, or it can be a client of an IKSD. You can  make  connections
     from C-Kermit to an IKSD with any of the following commands:

       telnet foo.bar.edu 1649
       telnet foo.bar.edu kermit   ; if "kermit" is listed in /etc/services
       iksd foo.bar.edu

     The  IKSD	command  is equivalent to a TELNET command specifying port 1649.
     For more information about making and using connections to an IKSD, see:

       https://kermitproject.org/cuiksd.html

     You can run an Internet Kermit Service on your own computer too (if you are
     the system administrator). For instructions, see:

       https://kermitproject.org/iksd.html

SECURITY
     All of C-Kermit's built-in TCP/IP networking methods (Telnet, Rlogin, IKSD,
     FTP, and HTTP) can be secured by one or more of the following IETF-approved
     methods:

     *	  MIT Kerberos IV
     *	  MIT Kerberos V
     *	  SSL/TLS
     *	  Stanford SRP

     The Windows version of C-Kermit 10.0 (CKW) has its own built-in SSH client;
     the Unix version makes SSH connections through the external SSH client.

     For complete instructions see:

       https://kermitproject.org/security.html

ALTERNATIVE COMMAND-LINE PERSONALITIES
     When invoked as "kermit" or any other name besides "ftp"  or  "telnet",  C-
     Kermit has the command-line options described above in the OPTIONS section.
     However,  if  you invoke C-Kermit as "telnet" or "ftp", it changes its com-
     mand-line personality to match. This can be done (among  other  ways)  with
     symbolic  links  (symlinks).  For	example, if you want C-Kermit to be your
     regular Telnet client, or the Telnet helper of your Web  browser,	you  can
     create  a	link  like  the  following in a directory that lies in your PATH
     ahead of the regular telnet program:

       ln -s /usr/local/bin/kermit telnet

     Now when you give a "telnet" command, you are invoking Kermit instead,  but
     with its Telnet command-line personality so, for example:

       telnet xyzcorp.com

     Makes  a  Telnet  connection to xyzcorp.com, and Kermit exits automatically
     when the connection is closed (just like the regular Telnet  client).  Type
     "telnet  -h"  to get a list of Kermit's Telnet-personality command-line op-
     tions, which are intended to be as compatible as possible with the  regular
     Telnet client.

     Similarly for FTP:

       ln -s /usr/local/bin/kermit ftp

     And  now  type  "ftp -h" to see its command-line options, and command lines
     just like you would give your regular FTP client:

       ftp xyzcorp.com

     but with additional options allowing an entire session to be  specified  on
     the  command line. Finally, if Kermit's first command-line option is a Tel-
     net, FTP, IKSD, or HTTP URL, Kermit  automatically  makes	the  appropriate
     kind of connection and, if indicated by the URL, takes the desired action:

     kermit telnet:xyzcorp.com
	    Opens a Telnet session

     kermit telnet://olga@xyzcorp.com
	    Ditto for user olga

     kermit ftp://olga@xyzcorp.com/public/somefile.zip
	    Downloads a file

     kermit https://kermitproject.org/index.html
	    Grabs a web page

LICENSE
     As  of version 9.0 C-Kermit carries the Revised 3-Clause BSD License, which
     is 100% Open Source.  C-Kermit's LICENSE command displays the license,  and
     it is also available on the Kermit Project website:

     kermit https://kermitproject.org/ck10license.html

OTHER TOPICS
     There's way more to C-Kermit than we've touched on here -- troubleshooting,
     customization,  character	sets, dialing directories, sending pages, script
     writing, and on and on, all of which are covered in the manual and  updates
     and  supplements.	For the most up-to-date information on documentation (or
     updated documentation itself) visit the Kermit Project website:

       https://kermitproject.org/

     There you will also find Kermit software packages for other platforms: dif-
     ferent Unix varieties, Windows, DOS, VMS, IBM mainframes, and many  others:
     over 40 years' worth at this writing (2022).

DOCUMENTATION AND UPDATES
     The manual for C-Kermit is:

     Using C-Kermit
	    Frank  da  Cruz  and  Christine  M. Gianone, Second Edition, Digital
	    Press / Butterworth-Heinemann, Woburn, MA,	1997,  622  pages,  ISBN
	    1-55558-164-1.  This  is a printed book. It covers C-Kermit 6.0.  As
	    of 2016 it is also available online in PDF form:

	    https://www.kermitproject.org/onlinebooks/usingckermit3e.pdf

     The C-Kermit 7.0 Supplement
	    https://kermitproject.org/ckermit70.html

     The C-Kermit 8.0 Supplement
	    https://kermitproject.org/ckermit80.html

     The C-Kermit 9.0 Supplement
	    https://kermitproject.org/ckermit90.html

     The C-Kermit 10.0 Specifications
	    https://kermitproject.org/ck10specs.html

     The C-Kermit 10.0 Complete Command List
	    https://kermitproject.org/ck10commandref.html

     Visit the C-Kermit home page:

       https://kermitproject.org/ckermit.html

     to learn about new versions, Beta tests, and other news; to read case stud-
     ies and tutorials; to download source code, install packages, and	prebuilt
     binaries for many platforms. Also visit:

     https://kermitproject.org/ckscripts.html
	    The Kermit script library and tutorial

     https://kermitproject.org/ckfaq.html
	    The C-Kermit FAQ (Frequently Asked Questions about C-Kermit)

     https://kermitproject.org/telnet.html
	    C-Kermit Telnet client documentation

     https://kermitproject.org/security.html
	    C-Kermit security documentation (Kerberos, SSL/TLS, etc)

     https://kermitproject.org/cuiksd.html
	    Internet Kermit Service user documentation

     https://kermitproject.org/iksd.html
	    Internet Kermit Service administrator documentation

     https://kermitproject.org/studies.html
	    Case studies.

     https://kermitproject.org/support.html
	    Technical support.

     https://kermitproject.org/ckuins.html.
	    Installation instructions for Unix.

     https://kermitproject.org/ckcbwr.html.
	    General C-Kermit bugs, hints, tips.

     https://kermitproject.org/ckubwr.html.
	    Unix-specific C-Kermit bugs, hints, tips.

     https://kermitproject.org/ckcplm.html.
	    C-Kermit program logic manual.

     https://kermitproject.org/ckccfg.html.
	    C-Kermit compile-time configuration options.

     /var/spool/locks (or whatever)
	    UUCP lockfile for dialing out (see installation instructions).

     ca_certs.pem
	    Certificate Authority certifcates used for SSL connections.

AUTHORS
     Software
	    Frank da Cruz and Jeffrey E Altman,
	    1985-present,  with  contributions	from hundreds of others all over
	    the world, notably David Goodwin for converting the 2001 edition  of
	    Kermit 95 to Open Source C-Kermit 10.0 for Windows.

     Documentation
	    Frank da Cruz

     Address
	    The Open Source Kermit Project
	    Bronx NY
	    USA

     E-Mail
	    kermit@kermitproject.org

     Web    https://kermitproject.org/

User Manuals			  NOVEMBER 2022 		       KERMIT(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=kermit&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help