kermit - CKermit 8.0: transport and platformindependent interactive and scriptable communications software.

This document is intended to give the beginner sufficient information to make basic (if not advanced) use of CKermit 8.0. Although it might be rather long for a Unix manual page, it's still far shorter than the CKermit manual, which should be consulted for advanced topics such as customization, charactersets, scripting, etc. We also attempt to provide a clear structural overview of CKermit'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 8.0 from earlier releases.

This document is also available as a Web page at:

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

CKermit is an allpurpose communications software package from the Kermit Project at Columbia University that:

•	Is portable to many platforms, Unix and nonUnix 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 textfile file transfer.



•	Is customizable in every aspect of its operation.

CKermit 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 IETFapproved 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 farend filetransfer 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 CKermit, can be "scripted" (automated) using its builtin crossplatform transportindependent script programming language, which happens to be identical to its interactive command language.

This manual page offers an overview of CKermit 8.0 for Unix ("Unix" is an operating system family that includes AIX, DG/UX, FreeBSD, HPUX, 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 CKermit manual and supplements (see DOCUMENTATION below). For further information about CKermit, Kermit software for other platforms, and Kermit manuals, visit the Kermit Project website:

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

This is a longerthanaverage manual page, and yet it barely scratches the surface. Don't be daunted. CKermit 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 explained here with pointers to additional information elsewhere.

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

or:

kermit URL

If the first commandline argument is the name of a file, interactivemode 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 below). A second commandline 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 commandline URL (if any, and if so, execution stops here).

5.

Commandline options (if any).

6.

Interactive commands. Some commandline 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 CKermit can be built with selected features disabled, and also that certain features are not available on all platforms. For example, CKermit 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 lacks CKermit a feature mentioned here, use its SHOW FEATURES command to see what might have been excluded. CKermit has three kinds of commands: regular singleletter commandline options, extendedformat commandline options, and interactive commands. Like most Unix commands, CKermit can be be given options on the command line. But CKermit also can be used interactively by giving it commands composed of words, which are more intuitive than cryptic commandline options, and more flexible too. In other words, you don't have to use CKermit's commandline 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.) CKermit 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 commandline 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.)

Here is a list of CKermit's singleletter commandline 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 "inthemiddle" operation: 8 bits, no parity, no escape character, everything passes through.

-8

(digit eight) Connection is 8bit clean (this is the default in CKermit 8.0). 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: IPaddressorhostname[:optionalTCPport]. NOTE: CKermit also has a separate FTP commandline personality, with regular FTPlike commandline syntax. 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 terminal). To be used in case Kermit doesn't automatically sense its background status. Equivalent to the SET BACKGROUND ON command.

-C arg

Interactivemode 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 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: CKermit also has a separate Telnet commandline personality, with regular Telnetlike commandline 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). 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 CKermit 7.0 and later.

-R

Remoteonly (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 perfile text/binary switching. Equivalent to SET TRANSFER MODE MANUAL.

-Y

Skip (don't execute) the initialization file.

-a arg

Asname for file(s) in -s, -r, or -g. Argument: Asname string (alternative 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 second -d adds timestamps). Equivalent to LOG DEBUG but takes effect sooner.

-e arg

Maximum length for incoming Kermit filetransfer 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 singleletter commandline 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 optional 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 communications device. Equivalent to the SET LINE (SET PORT) command. Argument: 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. 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 halfduplex connections (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). Equivalanet 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 automatically sense its foreground status. Equivalent to the SET BACKGROUND OFF command.

Extended commandline options (necessary because singleletter 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 directory (filename is relative to the changedto 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 toplevel HELP command.

--nointerrupts

Disables keyboard interrupts.

--noperms

Disables the Kermit protocol file Permissions attribute, to prevent transmission of file permissions (protection) from sender to receiver.

--version

(ACTION) CKermit prints its version number.

Plus several other IKSDOnly options described at:

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

See the filetransfer section for examples of commandline invocation.

CKermit's interactive command language is the subject of a 622page 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 CKermit's interactive command prompt:

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

Begin by typing "help" (and then press the Return or Enter key) for a toplevel 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, usually 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 command for details.

CKermit has hundreds of commands, and they can be issued in infinite variety 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, ...)

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

  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 .
  }

Command List

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

Basic Commands

Local File Management

Making Connections

Using Connections

Closing Connections

File Transfer

Kermit Server

Client of Kermit or FTP Server

Script Programming

  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>

In its default configuration, CKermit executes commands from a file called .kermrc in your home directory when it starts, unless it is given the -Y or -y commandline option. Custom configurations might substitute a shared systemwide initialization file. The SHOW FILE command tells what initialization 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 CKermit take longer to start, it might be better not to have an initialization file, especially now that Kermit's default startup configuration 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 CKermit directly when you don't.

To put it another way... We still distribute the standard initialization 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 Kermit looks for them automatically each time you start it.

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 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 communicates 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 filetransfer 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 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 execute 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 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 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 escapelevel 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 filetransfer 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 filerelated task. And at the same time, it is displaying its progress on your screen and watching your keyboard for interruptions. In this state, the following singlekeystroke 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 filetransfer 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 filetransfer state

In this state, Kermit is exchanging filetransfer 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 Filetransfer 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 Kermit to Command state (Ctrl-\ C) and type "epacket" and then press the Return or Enter key; this forces a fatal Kermit protocol error.

Remote Server state

This is like Remote Filetransfer state, except it never returns automatically 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 RemoteServer state, but in local mode, and therefore with its filetransfer display showing, and listening for singlekey commands, as in Local Filetransfer state. Usually this state is entered automatically when a remote Kermit program gives a GET command. CKermit, Kermit 95, and MSDOS Kermit all can switch automatically from Connect state to Local Filetransfer 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 CKermit is not a terminal emulator. It is a communications 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 running CKermit. Kermit 95 and MSDOS Kermit, on the other hand, are true terminal emulators. Why is CKermit not a terminal emulator? CLICK HERE to read about it.

Here is how to make different kinds of connections using interactive Kermit commands (as noted above, you can also make connections with commandline 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 CKermit 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 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 builtin, but handled by running your external SSH client through a pseudoterminal. Using CKermit to control the SSH client gives you all of Kermit's features (file transfer, characterset 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 (straightthrough) 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 "generichighspeed", which should work for most modern ATcommandset 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 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 sequence is:

  set host ts.xxx.com 2000   ; Terminalserver 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 serialport 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 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 nullmodem adapter or modem 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 crossconnected
  set speed 57600       ; Or other desired speed
  set flow rts/cts      ; If RTS and CTS are crossconnected
  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 parity even" (or "mark" or "space") if it's a 7bit 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, CKermit also can make X.25 connections. See the manual for details.

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 overloaded the connection. Some extra commands (or commandline 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 nonKermitProject Kermit protocol implementations really ARE slow. The best filetransfer partners for CKermit are: another copy of CKermit (7.0 or later) and Kermit 95. These combinations work well and they work fast by default. MSDOS 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, CKermit and K95 also switch 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 transferred in the wrong mode.

What all of these words add up to is that now, when you use uptodate 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, CKermit, or MSDOS Kermit on your desktop computer, with a connection to a Unix computer that has CKermit 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 command 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 automatically to Connect state. No worries about escaping back, reconnecting, 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 oofa.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 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 OldFashioned Way

If your desktop communications software does not support autoupload 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 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 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 CKermit to wait passively 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 troubleshooting:

FAST

Use fast filetransfer settings. This has been the default since CKermit 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 CKermit'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 8bit connection. Obviously the success and performance of a file transfer also depends on CKermit's file transfer partner. Uptodate, 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 CKermit, or send email to kermitsupport@columbia.edu.

Advanced Kermit FileTransfer Features

Obviously there is a lot more to Kermit file transfer, including all sorts of interactive commands, preferences, options, logging, 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 perfile text/binary mode switching:

SET TRANSFER MODE { AUTOMATIC, MANUAL } (HELP SET TRANSFER).

Crossplatform 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, ...

Characterset 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).

NonKermit File Transfer

You can also use CKermit to transfer files with FTP or HTTP Internet protocols; 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 implementation 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 details), and you can upload files without any protocol at all with TRANSMIT (HELP TRANSMIT, HELP SET TRANSMIT).

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 until 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.

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 Kermit's FTPrelated 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.

CKermit 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. CKermit can be an Internet Kermit Server, or it can be a client of an IKSD. You can make connections from CKermit 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

All of CKermit's builtin TCP/IP networking methods (Telnet, Rlogin, IKSD, FTP, and HTTP) can be secured by one or more of the following IETFapproved methods:

• MIT Kerberos IV

• MIT Kerberos V

• SSL/TLS

• Stanford SRP

For complete instructions see:

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

And as noted previously, you can also make SSH connections with CKermit if you already have an SSH client installed.

When invoked as "kermit" or any other name besides "ftp" or "telnet", CKermit has the commandline options described above in the OPTIONS section. However, if you invoke CKermit as "telnet" or "ftp", it changes its commandline personality to match. This can be done (among other ways) with symbolic links (symlinks). For example, if you want CKermit 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 commandline 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 Telnetpersonality commandline options, 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 commandline 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 commandline option is a Telnet, 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/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

CKermit 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 license, not GPL, not Artistic, not commercial, not shareware, not freeware. It can be summed up like this: if you want CKermit for your own use, you can download and use it without cost or license (but we'd appreciate it if you would purchase the manual). But if you want to sell CKermit or bundle it with a product or otherwise distribute it in a commercial setting EXCEPT WITH AN OPENSOURCE OPERATING SYSTEM DISTRIBUTION 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 CKermit 7.0 or later, or download it from ftp://kermit.columbia.edu/kermit/c-kermit/COPYING.TXT Send licensing inquiries to kermit@columbia.edu.

See the following files for listings of known bugs, limitations, workarounds, hints and tips:

ckcbwr.txt

General CKermit bugs, hints, tips.

ckubwr.txt

Unixspecific CKermit 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 CKermit Frequently Asked Questions: http://www.columbia.edu/kermit/ckfaq.html

There's way more to CKermit 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 uptodate information 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.

The manual for CKermit is:

Using CKermit Frank da Cruz and Christine M. Gianone, Second Edition, Digital Press / ButterworthHeinemann, Woburn, MA, 1997, 622 pages, ISBN 1-55558-164-1. This is a printed book. It covers CKermit 6.0.

The CKermit 7.0 Supplement

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

The CKermit 8.0 Supplement

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

Visit CKermit 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 CKermit FAQ (Frequently Asked Questions about CKermit)

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

CKermit Telnet client documentation

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

CKermit 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).

COPYING.TXT

CKermit 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.columbia.edu/kermit/ckuins.html.

ckcbwr.txt

General CKermit bugs, hints, tips.

ckubwr.txt

Unixspecific CKermit bugs, hints, tips.

ckcplm.txt

CKermit program logic manual.

ckccfg.txt

CKermit compiletime 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).

Software

Frank da Cruz and Jeffrey E Altman,

1985present, with contributions from hundreds of others all over the world.

Documentation

Frank da Cruz and Christine M Gianone

Address

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

EMail

kermit@columbia.edu

Web

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