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

FreeBSD Manual Pages

  
 
  

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

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

	      This document is intended	to give	the beginner sufficient	infor-
	      mation to	make basic (if not advanced) use of C-Kermit 9.0.  Al-
	      though it	might be rather	long for a Unix	manual page, it's
	      still far	shorter	than the C-Kermit manual, which	should be con-
	      sulted for advanced topics such as customization,	character-
	      sets, scripting, etc. We also attempt to provide a clear struc-
	      tural overview of	C-Kermit's many	capabilities, functional ar-
	      eas, states, and modes and their interrelation, that should be
	      helpful to beginners and veterans	alike, as well as to those up-
	      grading to version 9.0 from earlier releases.

       This document is	also available as a Web	page at:

	      http://www.columbia.edu/kermit/ckututor.html

DESCRIPTION
       C-Kermit	is an all-purpose communications software package from the
       Kermit Project at Columbia University that:

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

       C-Kermit	is a modem program, a Telnet client, an	Rlogin 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 se-
       curity methods including	Kerberos IV, Kerberos V, SSL/TLS, and SRP and
       it can also make	SSH connections	through	your external SSH client ap-
       plication. 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" (interac-
       tively) with C-Kermit, can be "scripted"	(automated) using its built-in
       cross-platform transport-independent script programming language, which
       happens to be identical to its interactive command language.

       This manual page	offers an overview of C-Kermit 9.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	others). 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:

	 http://www.columbia.edu/kermit/

       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,
       evolving	over decades of	practice and experience, but that doesn't mean
       it's hard to learn or use. Its most commonly used functions are ex-
       plained 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 Kermit 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	be-
       low). 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 command line, Kermit exits when finished unless also given the
       -S ("stay") option. If no action	options	are given, no initialization
       or command files	contained an EXIT or QUIT command, and no fatal	errors
       occurred, Kermit	issues its prompt and waits for	you to type commands.

	      Bear in mind that	C-Kermit can be	built with selected features
	      disabled,	and also that certain features are not available on
	      all platforms. 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 excluded.

       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	be given options on the	com-
       mand line. But C-Kermit also can	be used	interactively by giving	it
       commands	composed of words, which are more intuitive than cryptic com-
       mand-line options, and more flexible too. In other words, you don't
       have to use C-Kermit's command-line options, but	they are available if
       you want	to. (By	the same token,	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 com-
       mand-line options, put them after the word "kermit" but before pressing
       Return or Enter,	separated by spaces, for example:

	 $ kermit -s ckermit.tar.gz

       ('$' is the shell prompt; "kermit -s ckermit.tar.gz" is what you	type,
       followed	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. Alpha-
       betic 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"
	      operation: 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[:op-
	      tional-TCP-port].	 NOTE: C-Kermit	also has a separate FTP	com-
	      mand-line	personality, with regular FTP-like command-line	syn-
	      tax. More	about this below.

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

       -B     Kermit is	running	in Batch or Background (no controlling termi-
	      nal). 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
	      separated	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 out-
	      put, which normally would	be piped to another process.  Argu-
	      ment: 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	regu-
	      lar 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, Rlogin, FTP, etc).  Equiva-
	      lent 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.  Equiva-
	      lent 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
	      (alternative filename). When receiving files, this can be	a di-
	      rectory name.

       -b arg Speed for	serial device. Equivalent to SET SPEED.	 Argument: Nu-
	      meric 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
	      second -d	adds timestamps). Equivalent to	LOG DEBUG but takes
	      effect sooner.

       -e arg Maximum length for incoming Kermit file-transfer packets.	Equiv-
	      alent 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. Equiva-
	      lent to SET TRANSFER MODE	MANUAL,	SET FILE TYPE BINARY.

       -j arg Make a TCP/IP connection.	 Argument: IP host name/address	and
	      optional service name or number. Equivalent to the TELNET	com-
	      mand.  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 com-
	      munications device. Equivalent to	the SET	LINE (SET PORT)	com-
	      mand.  Argument: Serial device name, e.g.	/dev/ttyS0.

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

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

       -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.
	      Argument:	(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
	      connections (used	on serial linemode connections to old main-
	      frames). Equivalent to SET DUPLEX	HALF, SET HANDSHAKE XON.

       -v arg Window size for Kermit protocol (ignored when streaming).	Equiv-
	      alanet 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 au-
	      tomatically sense	its foreground status.	Equivalent to the SET
	      BACKGROUND OFF command.

       Extended	command-line options (necessary	because	single-letter ones are
       about used up) start with two dashes (--), with words rather than sin-
       gle 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
	      directory	(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 pre-
	      vent transmission	of file	permissions (protection) from sender
	      to receiver.

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

       Plus several other IKSD-Only options described at:

	 http://www.columbia.edu/kermit/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 directory (unless you tell Kermit to prompt you with something
       else).

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

	 send oofa.txt

       which tells Kermit to send (transfer) the file whose name is oofa.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 history, and who knows	what else. Give	the INTRO com-
       mand for	details.

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

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

       And of course QUIT or EXIT to get out and HELP to get help, and for
       programmers: loops, decision making, variables, arrays, associative ar-
       rays, integer and floating point	arithmetic, macros, built-in and user-
       defined functions, string manipulation, pattern matching, block struc-
       ture, scoping, recursion, and all the rest. To get a list of all	C-Ker-
       mit's commands, type a question mark (?)	at the prompt. To get a	de-
       scription of any	command, type HELP followed by the name	of the com-
       mand, 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). Please don't
       pipe a command file into	Kermit's standard input	(which might or	might
       not work); if you have Kermit commands in a file, tell Kermit to	TAKE
       the file.

       In Unix only, a Kermit command file can also be executed	directly by
       including 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 argument, \%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 han-
       dle 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 (ex-
       plained below), you'll have MYDELETE and	MYUNDELETE commands available
       every time you start Kermit, at least as	long as	you don't suppress ex-
       ecution of the initialization file. (Exercise for the reader: Make
       these macros generally useful: remove limitations, add trashcan dis-
       play, 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
       variable	(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 variable	(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 ex-
       plained 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. op-
       tions are (optional) 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. Synonyms:
		     QUIT, E, Q.

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

	      LOG item [ filename ]
		     Keeps a log of the	given item 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. Syn-
		     onym: 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 mo-
		     dem.

	      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.

	      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.

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

	      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 con-
		     nection.

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

   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	Tel-
		     net).

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

	      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	con-
		     nection.

	      CLOSE  Closes the	currently open serial-port or network connec-
		     tion.

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

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

	      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, SEXPRES-
	      SION, 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 includes 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 specifications to be sent, rather than just	one file specifica-
       tion, 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 documen-
       tation.

       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 example, "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 com-
       mand tells what initialization file, if any, was	used. The standard
       initialization file "chains" to an individual customization file, .myk-
       ermc, 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
       initialization file, especially now that	Kermit's default startup con-
       figuration 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	in-
       clude 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.

       To put it another way...	We still distribute the	standard initializa-
       tion file since it's featured in	the manual and backwards compatibility
       is important to us. But there's no harm in not using it if you don't
       need the	stuff that's in	it (services directory,	dialing	directory,
       network directory, and associated macro definitions). On	the other
       hand, if	there are settings or macros you want in effect	EVERY time you
       use Kermit, the initialization file (or the customization file it
       chains to) is the place to put them, because that's the only place Ker-
       mit looks for them automatically	each time you start it.

MODES OF OPERATION
       Kermit is said to be in Local mode if it	has made a connection to an-
       other 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 remote computer, it is said to be in Remote mode (as long
       as it has not made any connections of its own). The local Kermit	commu-
       nicates over the	communications device or network connection, acting as
       a conduit between the the remote	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:

	      o	   Your	keyboard; or:
	      o	   A file, or:
	      o	   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 various commands (CONNECT, DIAL, TELNET, etc).	You can	enter
	      file transfer 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	exe-
	      cute commands from a macro definition.  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	nor-
	      mally 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 key-
	      strokes are sent to the remote computer and characters that ar-
	      rive over	the communication connection are displayed on your
	      screen. This state is entered when you give a CONNECT, DIAL,
	      TELNET, RLOGIN, or IKSD command. You can return to command state
	      by logging out of	the remote computer, 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 in-
	      terruptions. In this state, the following	single-keystroke com-
	      mands 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
	      automatically 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 return it	to command state by typing three
	      Ctrl-C's in a row. If that doesn't work, return your local Ker-
	      mit to Command state (Ctrl-\ C) and type "e-packet" and then
	      press the	Return or Enter	key; this forces a fatal Kermit	proto-
	      col error.

       Remote Server state
	      This is like Remote File-transfer	state, except it never returns
	      automatically to Command state. Rather, it awaits	further	in-
	      structions 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 issu-
	      ing 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
	      commands,	as in Local File-transfer state. Usually this state is
	      entered automatically when a remote Kermit program gives a GET
	      command.

	      C-Kermit,	Kermit 95, and MS-DOS Kermit all can switch automati-
	      cally 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, Con-
	      nect state is automatically resumed after	the file transfer is
	      finished.

	      Note that	C-Kermit is not	a terminal emulator. It	is a communi-
	      cations application that you run in a terminal window (e.g. con-
	      sole or Xterm). The specific emulation, such as VT100, VT220,
	      Linux Console, or	Xterm, is provided by the terminal window in
	      which you	are running 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 communica-
       tions 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	in-
	      clude a port number:

		telnet xyzcorp.com 3000	;

	      If the connection	is successful, Kermit automically enters Con-
	      nect state. When you logout from the remote host,	Kermit auto-
	      matically	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
	      because 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
	      handled by running your external SSH client through a pseudoter-
	      minal.  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
	      serial 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-com-
	      mand-set modems. If the line is busy, Kermit redials automati-
	      cally. 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 automatically	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 se-
	      quence 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 ter-
	      minal 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
	      CARRIER-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 mo-
	      dem eliminator). 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 ap-
	      proximately the same directions. More info: As above plus	HELP
	      CONNECT.

       With modems or direct serial connections, you might also	have to	"set
       parity 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.
       However,	any one	of these can be	open concurrently with an FTP or HTTP
       session.	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 pro-
       tocol.  This is because,	until recently,	it used	conservative tuning by
       default to make sure file transfers succeeded, rather than failing be-
       cause they overloaded the connection. Some extra	commands (or command-
       line options, like -Q) were needed to make it go	fast, but nobody both-
       ered to find out	about them. Also, it takes two to tango: most non-Ker-
       mit-Project Kermit protocol implementations really ARE slow. The	best
       file-transfer partners for C-Kermit are:	another	copy of	C-Kermit (7.0
       or later) and Kermit 95.	 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 transfer mode.

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

       What all	of these words add up to is that now, when you use up-to-date
       Kermit 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 Kermit	95, C-Kermit, 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 oofa.txt

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

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

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

		kermit -s oofa.*

	      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 automati-
	      cally to Connect state.  No worries about	escaping back, re-con-
	      necting, text/binary mode	switching. Almost too easy, right?

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

		kermit -g oofa.txt

	      This causes your local Kermit to enter server mode; then the re-
	      mote 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 have use shell
	      quoting rules, since these aren't	local files:

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

	      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 autou-
	      pload or autodownload, or	it does	not include Kermit server
	      mode, the	procedure requires 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	commu-
	      nications	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 RECEIVE) 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 passively for a file	to start arriving. Then	regain the at-
	      tention of your desktop software (Alt-x or whatever) and in-
	      struct 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 troubleshooting:

	      FAST   Use fast file-transfer settings. This has been the	de-
		     fault since C-Kermit 7.0 now that most modern computers
		     and connections 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
		     reliable settings.	File transfers will almost certainly
		     work, but they will be quite slow (of course this is a
		     classic tradeoff; ROBUST was C-Kermit's default tuning in
		     versions 6.0 and earlier, which made everybody think Ker-
		     mit 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
       implementations 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 kermit-support@columbia.edu.

       Advanced	Kermit File-Transfer Features
	      Obviously	there is a lot more to Kermit file transfer, including
	      all sorts	of interactive commands, preferences, options, log-
	      ging, debugging, troubleshooting,	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 interested	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 TRANS-
		     FER).

	      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 /EX-
		     CEPT, ...

	      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 In-
	      ternet protocols;	see below.

	      On a regular serial or Telnet connection where the other com-
	      puter 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 Ker-
	      mit. 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 imple-
	      mentation	of it),	then if	your computer also has external	X, Y,
	      or Zmodem	programs 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 de-
	      tails), 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:

       o      It has lots more commands	and features.

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

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

       o      You can have an FTP session and a	regular	Kermit serial or Tel-
	      net session open at the same time.

       o      FTP sessions can be fully	automated.

       Pending publication of the next edition of the manual, the Kermit FTP
       client is thoroughly documented at the Kermit Project website:

	 http://www.columbia.edu/kermit/ftpclient.html

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

       The HTTP	client is similar to the FTP one, except you prefix each com-
       mand 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 man-
       ual supplements.	 HTTP connections can be open at the same time as reg-
       ular 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-Ker-
       mit 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 fol-
       lowing 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:

	 http://www.columbia.edu/kermit/cuiksd.html

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

	 http://www.columbia.edu/kermit/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:

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

       For complete instructions see:

	 http://www.columbia.edu/kermit/security.html

       And as noted previously,	you can	also make SSH connections with C-Ker-
       mit if you already have an SSH client installed.

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 command-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 automati-
       cally 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 options, which are intended	to be as compatible as possi-
       ble 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 Telnet, FTP, IKSD, or HTTP URL, Kermit	automatically makes the	appro-
       priate kind of connection and, if indicated by the URL, takes the de-
       sired action:

       kermit telnet:xyzcorp.com
	      Opens a Telnet session

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

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

       kermit kermit://kermit.columbia.edu/kermit/f/READ.ME
	      Ditto for	IKSD

       kermit iksd://kermit.columbia.edu/kermit/f/READ.ME
	      (This works too)

       kermit http://www.columbia.edu/kermit/index.html
	      Grabs a web page

LICENSE
       C-Kermit	has an unusual license,	but a fair and sensible	one since the
       Kermit Project must support itself out of revenue: it's not a BSD li-
       cense, not GPL, not Artistic, not commercial, not shareware, not	free-
       ware. It	can be summed up like this: if you want	C-Kermit for your own
       use, you	can download and use it	without	cost or	license	(but we'd ap-
       preciate	it if you would	purchase the manual). But if you want to sell
       C-Kermit	or bundle it with a product or otherwise distribute it in a
       commercial setting EXCEPT WITH AN OPEN-SOURCE OPERATING SYSTEM DISTRI-
       BUTION such as Linux, FreeBSD, NetBSD, or OpenBSD, you must license it.
       To see the complete license, give the LICENSE command at	the prompt, or
       see the COPYING.TXT file	distributed with C-Kermit 7.0 or later,	or
       download	it from

	 ftp://kermit.columbia.edu/kermit/c-kermit/COPYING.TXT

       Send licensing inquiries	to kermit@columbia.edu.

BUGS
       See the following files for listings of known bugs, limitations,	work-
       arounds,	hints and tips:

       ckcbwr.txt
	      General C-Kermit bugs, hints, tips.

       ckubwr.txt
	      Unix-specific C-Kermit bugs, hints, tips.

       Report bugs and problems	by email to:

	  kermit-support@columbia.edu.

       Before requesting technical support, please read	the hints here:

	 http://www.columbia.edu/kermit/support.html

       and also	read the C-Kermit Frequently Asked Questions:

	 http://www.columbia.edu/kermit/ckfaq.html

OTHER TOPICS
       There's way more	to C-Kermit than we've touched on here -- trou-
       bleshooting, customization, character sets, dialing directories,	send-
       ing 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 infor-
       mation on documentation (or updated documentation itself) visit the
       Kermit Project website:

	 http://www.columbia.edu/kermit/

       There you will also find	Kermit software	packages for other platforms:
       different Unix varieties, Windows, DOS, VMS, IBM	mainframes, and	many
       others: 20+ years' worth.

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.

       The C-Kermit 7.0	Supplement
	      http://www.columbia.edu/kermit/ckermit70.html

       The C-Kermit 8.0	Supplement
	      http://www.columbia.edu/kermit/ckermit80.html

       The C-Kermit 9.0	Supplement
	      http://www.columbia.edu/kermit/ckermit90.html

       Visit C-Kermit home page:

	 http://www.columbia.edu/kermit/ckermit.html

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

       http://www.columbia.edu/kermit/scriptlib.html
	      The Kermit script	library	and tutorial

       http://www.columbia.edu/kermit/newfaq.html
	      The Kermit FAQ (Frequently Asked Questions about Kermit)

       http://www.columbia.edu/kermit/ckfaq.html
	      The C-Kermit FAQ (Frequently Asked Questions about C-Kermit)

       http://www.columbia.edu/kermit/telnet.html
	      C-Kermit Telnet client documentation

       http://www.columbia.edu/kermit/security.html
	      C-Kermit security	documentation (Kerberos, SSL/TLS, etc)

       http://www.columbia.edu/kermit/cuiksd.html
	      Internet Kermit Service user documentation

       http://www.columbia.edu/kermit/iksd.html
	      Internet Kermit Service administrator documentation

       http://www.columbia.edu/kermit/studies.html
	      Case studies.

       http://www.columbia.edu/kermit/support.html
	      Technical	support.

       http://www.columbia.edu/kermit/k95tutorial.html
	      Kermit 95	tutorial.

       comp.protocols.kermit.misc
	      The Kermit newsgroup (unmoderated).

FILES
       COPYING.TXT
	      C-Kermit license.

       ~/.kermrc
	      Initialization file.

       ~/.mykermrc
	      Customization file.

       ~/.kdd Kermit dialing directory (see manual).

       ~/.knd Kermit network directory (see manual).

       ~/.ksd Kermit services directory	(see manual).

       ca_certs.pem
	      Certificate Authority certifcates	used for SSL connections.

       ckuins.txt
	      Installation instructions	for Unix.  Also	at http://www.colum-
	      bia.edu/kermit/ckuins.html.

       ckcbwr.txt
	      General C-Kermit bugs, hints, tips.

       ckubwr.txt
	      Unix-specific C-Kermit bugs, hints, tips.

       ckcplm.txt
	      C-Kermit program logic manual.

       ckccfg.txt
	      C-Kermit compile-time configuration options.

       ssh    (in your PATH) SSH connection helper.

       rz, sz, etc.
	      (in your PATH) external protocols	for XYZmodem.

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

AUTHORS
       Software
	      Frank da Cruz and	Jeffrey	E Altman,
	      1985-present, with contributions from hundreds of	others all
	      over the world.

       Documentation
	      Frank da Cruz

       Address
	      The Kermit Project - Columbia Univerity
	      612 West 115th Street
	      New York NY 10025-7799
	      USA

       E-Mail kermit@columbia.edu

       Web    http://www.columbia.edu/kermit/

User Manuals			   JULY	2011			     KERMIT(1)

NAME | DESCRIPTION | SYNOPSIS | OPTIONS | COMMAND LANGUAGE | INITIALIZATION FILE | MODES OF OPERATION | MAKING CONNECTIONS | TRANSFERRING FILES WITH KERMIT | KERMIT'S BUILT-IN FTP AND HTTP CLIENTS | INTERNET KERMIT SERVICE | SECURITY | ALTERNATIVE COMMAND-LINE PERSONALITIES | LICENSE | BUGS | OTHER TOPICS | DOCUMENTATION AND UPDATES | FILES | AUTHORS

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

home | help