The Columbia Crown The Kermit Project | Columbia University
612 West 115th Street, New York NY 10025 USA •
…since 1981

G - K e r m i t   1 . 0 0

New York City
Simple, Portable, Free File Transfer Software for UNIX

Version: 1.00   Download
Released:   25 December 1999
Also see: Kermit 95 for Windows,   C-Kermit for Unix and VMS,   Embedded Kermit

This page last updated: Wed Jul 27 16:03:48 2011 253 binaries and counting...




G-Kermit is a Unix program for transferring files with the Kermit protocol. G-Kermit is a product of the Kermit Project at Columbia University in New York city. It is free software under the GNU General Public License. See the COPYING file for details. Although G-Kermit was written for Unix, we are beginning to see ports of it to non-Unix platforms, so far including OS/2 and CP/M-68K.

This software is OSI Certified Open Source Software.
OSI Certified is a certification mark of the Open Source Initiative.

G-Kermit is:

Features include:

Kermit protocol features include:

Features selectable on command line:

Features not included (see Section 14):


G-Kermit is always on the "far end" of a connection, on a Unix system that you have made a connection to from a terminal emulator by dialup, network, or direct serial. If you have a direct or dialup serial connection into Unix, use the "stty -a" or "stty all" command to see if your Unix terminal driver is conditioned for the appropriate kind of flow control; if it isn't, very few applications (including gkermit) will work well, or at all. The command for setting terminal flow control varies from platform to platform, but it is usually something like this:

$ stty crtscts

(where "$ " is the shell prompt) for RTS/CTS hardware flow control, or:

$ stty ixon ixoff

for Xon/Xoff "software" flow control. When you have a network connection, flow control is usually nothing to worry about, since the network protocol (TCP or X.25) takes care of it automatically, but on certain platforms (such as HP-UX) the TCP/IP Telnet or Rlogin server uses this for flow control between itself and the underlying pseudoterminal in which your session runs, so Xon/Xoff might be required for these sessions too.

The G-Kermit binary is called "gkermit". It should be stored someplace in your Unix PATH, such as /usr/local/bin/gkermit or somewhere in the /opt tree on System V R4. To run G-Kermit, just type "gkermit" followed by command-line options that tell it what to do. If no options are given, G-Kermit prints a usage message listing the available options:

G-Kermit CU-1.00, Columbia University, 1999-12-25: POSIX.
Usage:  gkermit [ options ]
 -r      Receive files
 -s fn   Send files
 -g fn   Get files from server
 -a fn   As-name for single file
 -i      Image (binary) mode transfer
 -T      Text mode transfer
 -P      Path/filename conversion disabled
 -w      Write over existing files with same name
 -K      Keep incompletely received files
 -p x    Parity: x = o[dd],e[ven],m[ark],s[pace],n[one]
 -e n    Receive packet-length (40-9000)
 -b n    Timeout (sec, 0 = none)
 -x      Force Xon/Xoff (--x = Don't force Xon/Xoff)
 -S      Disable streaming
 -X      External protocol
 -q      Quiet (suppress messages)
 -d [fn] Debug to ./debug.log [or specified file]
 -h      Help (this message)
More info: <>

If an option takes an argument, the argument is required; if an option does not take an argument, no argument may be given (exceptions: -d may or may not take an argument; -s can take one or more arguments).

The action options are -r, -s, and -g. Only one action option may be given. If no action options are given, G-Kermit does nothing (except possibly printing its usage message or creating a debug.log file). Here are some examples (in which "$ " is the shell prompt):

$ gkermit -s hello.c       Sends the hello.c file.
$ gkermit -s hello.*       Sends all hello.* files.
$ gkermit -r               Waits for you to send a file to it.
$ gkermit -g hello.c       Gets the hello.c file from your computer.
$ gkermit -g \*.c          Gets all *.c files from your computer.

Options that do not take arguments can be "bundled" with other options. An option that takes an argument must always be followed by a space and then its argument(s). Examples:

$ gkermit -is hello.o      Sends hello.o in binary mode.
$ gkermit -dSr             Receives with debugging and no streaming.

G-Kermit's exit status is 0 if all operations succeeded and 1 if there were any failures. If a group of files was transferred, the exit status is 1 if one or more files were not successfully transferred and 0 if all of them were transferred successfully.


fn = filename; n = number.
-r RECEIVE: This option tells G-Kermit to receive a file or files; that is, to passively wait for you to send files from your terminal emulator.
-s  fn SEND: This tells G-Kermit to send the file or files specified by fn, which can be a filename, a regular expression, or a list of filenames and/or regular expressions (wildcards). Regular expressions are interpreted and expanded by your shell into the list of names of files that is given to G-Kermit. For example "*.c" expands to a list of all files in the current directory whose names end with ".c".
-g  fn GET: This option tells G-Kermit to get a file (or files) from a Kermit server. It is useful only when your terminal emulator supports the Kermit autodownload feature AND it includes a Kermit server mode. It is equivalent to "gkermit -r", escaping back, telling your terminal emulator to send the given files, and then reconnecting to Unix.
-a  fn AS-NAME: When used with -s, this option tells G-Kermit to send the file whose name is given as the first -s argument under the name fn. For example, "gkermit -s game -a work" sends the file called "game" under the name "work", so the receiver will think its name is "work". When given with the -r or -g command, the incoming file (or the first incoming file if there is more than one) is stored under the name fn. In all cases, the given name is used as-is; it is not converted.
-i IMAGE (binary) mode transfer. When used with -s, tells G-Kermit to send in binary mode. When used with -r, tells G-Kermit to receive in binary mode if the file sender does not specify the transfer mode (text or binary). When used with -g, tells G-Kermit to ask your terminal emulator's Kermit to send the given file in binary mode. See Section 6 for details.
-T TEXT mode transfer (note uppercase T). When used with -s, tells G-Kermit to send in text mode. When used with -r, tells G-Kermit to receive in text mode if the file sender does not specify the transfer mode (text or binary). When used with -g, tells G-Kermit to ask your emulator's Kermit to send the given file in text mode. See Section 6 for details.
-P PATH (filename) conversion disabled (note uppercase P). Normally when sending files, G-Kermit converts filenames to a form that should be acceptable to non-Unix platforms, primarily changing lowercase letters to uppercase, ensuring there is no more than one period, and replacing any "funny" characters by X or underscore (explained in Section 8).
-w WRITEOVER. When receiving, and an incoming file has the same name as an existing file, write over the existing file. By default G-Kermit backs up the existing file by adding a suffix to its name (see Section 9).
-K KEEP incompletely received files. Normally when receiving files, and a file transfer is interrupted, G-Kermit discards the partially received file so you won't think you have the whole file. Include -K on the command line to tell G-Kermit to keep partially received files, e.g. "gkermit -Kr".
-p  x PARITY: Use the given kind of parity, where x can be 'n' for None (which is the default, for use on 8-bit-clean connections); 's' for Space, 'e' for Even, 'o' for Odd, and 'm' for Mark. 's' might be needed on certain Telnet connections; 'e', 'o', and 'm' are only for serial connections; don't try them on TCP/IP connections.
-e  n PACKET LENGTH: Receive packet-length, where n can be any number between 40 and 9000. The default length on most platforms is 4000. Use this option to specify a different length; usually this would be necessary only if transfers fail using the default length due to some kind of buffering problem in the host or along the communication path. Example: "gkermit -e 240 -r".
-b  n TIMEOUT (sec, 0 = none). Specify the number of seconds to wait for a packet before timing out and retransmitting. By default, G-Kermit uses whatever timeout interval your terminal emulator's Kermit asks it to use. No need to change this unless the timeout action causes problems.
-x XON/XOFF. Force Xon/Xoff flow control in the Unix terminal driver. Try this if uploads fail without it. But don't use it if you don't need to; on some platforms or connections it hurts rather than helps.
--x Don't force Xon/Xoff; for use when G-Kermit was built with the SETXONXOFF compile-time option (Section 12), to override the automatic setting of Xon/Xoff in case it interferes with file transfers.
-S STREAMING disabled. Streaming is a high-performance option to be used on reliable connections, such as in Telnet or Rlogin sessions. It is used if your terminal emulator's Kermit requests it. Use the -S option (note: uppercase S) to suppress this feature in case it causes trouble. Details in Section 10.
-X EXTERNAL PROTOCOL. Include this option when invoking G-Kermit from another program that redirects G-Kermit's standard i/o, e.g. over a connection to another computer. If you omit this switch when using G-Kermit as an external protocol to another communications program, G-Kermit is likely to perform illegal operations and exit prematurely. If you include this switch when G-Kermit is NOT an external protocol to another program, file transfers will fail. G-Kermit has no way of determining automatically whether it is being used as an external protocol.
-q QUIET. Suppresses messages.
-d DEBUG. Use this for troubleshooting. It creates a file called debug.log in your current directory, to be used in conjunction with the source code, or sent to the Kermit support address for analysis. More about this in Section 11.
-d  fn DEBUG to specified file (rather than default ./debug.log).
-h HELP: Displays the usage message shown above.

You may supply options to G-Kermit on the command line or through the GKERMIT environment variable, which can contain any valid gkermit command-line options. These are processed before the actual command-line options and so can be overridden by them. Example for bash or ksh, which you can put in your profile if you want to always keep incomplete files, suppress streaming, suppress messages, and use Space parity:

  export GKERMIT="-K -S -q -p s"

G-Kermit's options are compatible with C-Kermit's, with the following exceptions:

-P (available only in C-Kermit 7.0 and later)
-K (currently not used in C-Kermit)
-b (used in C-Kermit for serial device speed)
-S (used in C-Kermit to force an interactive command prompt)
-x (used in C-Kermit to start server mode)
--x (currently not used in C-Kermit)
-X (currently not used in C-Kermit)


To transfer files with G-Kermit you must be connected through a terminal emulator to the Unix system where G-Kermit is installed, meaning you are online to Unix and have access to the shell prompt (or to some menu that has an option to invoke G-Kermit), and your terminal emulator must support the Kermit file transfer protocol. The connection can be serial (direct or dialed) or network (Telnet, Rlogin, X.25, etc).

Sending Files

When you tell G-Kermit to SEND a file (or files), e.g. with:

  $ gkermit -Ts oofa.txt

it pauses for a second and then sends its first packet. What happens next depends on the capabilities of your terminal emulator:

During file transfer, most terminal emulators put up some kind of running display of the file transfer progress.

Receiving Files

When you tell G-Kermit to RECEIVE, this requires you to escape back to your terminal emulator and instruct it to send the desired file(s). Autodownload is not effective in this case. When the transfer is complete, you'll need to instruct your emulator to return to its terminal screen.

Getting Files

If your terminal emulator supports Kermit autodownloads AND server mode, you can use GET ("gkermit -g files...") rather than RECEIVE ("gkermit -r"), and the rest happens automatically, as when G-Kermit is sending.


G-Kermit supports file and group interruption. The method for interrupting a transfer depends on your terminal emulator. For example, while the file-transfer display is active, you might type the letter 'x' to cancel the current file and go on to the next one (if any), and the letter 'z' to cancel the group. Or there might be buttons you can click with your mouse.

When G-Kermit is in packet mode and your terminal emulator is in its terminal screen, you can also type three (3) Ctrl-C characters in a row to make G-Kermit exit and restore the normal terminal modes.


When sending files in binary mode, G-Kermit sends every byte exactly as it appears in the file. This mode is appropriate for program binaries, graphics files, tar archives, compressed files, etc, and is G-Kermit's default file-transfer mode when sending. When receiving files in binary mode, G-Kermit simply copies each byte to disk. (Obviously the bytes are encoded for transmission, but the encoding and decoding procedures give a replica of the original file after transfer.)

When sending files in text mode, G-Kermit converts the record format to the common one that is defined for the Kermit protocol, namely lines terminated by carriage return and linefeed (CRLF); the receiver converts the CRLFs to whatever line-end or record-format convention is used on its platform. When receiving files in text mode, G-Kermit simply strips carriage returns, leaving only a linefeed at the end of each line, which is the Unix convention.

When receiving files, the sender's transfer mode (text or binary) predominates if the sender gives this information to G-Kermit in a Kermit File Attribute packet, which of course depends on whether your terminal emulator's Kermit protocol has this feature. Otherwise, if you gave a -i or -T option on the gkermit command line, the corresponding mode is used; otherwise the default mode (binary) is used.

Furthermore, when either sending or receiving, G-Kermit and your terminal emulator's Kermit can inform each other of their OS type (Unix in G-Kermit's case). If your emulator supports this capability, which is called "automatic peer recognition", and it tells G-Kermit that its platform is also Unix, G-Kermit and the emulator's Kermit automatically switch into binary mode, since no record-format conversion is necessary in this case. Automatic peer recognition is disabled automatically if you include the -i (image) or -T (text) option.

When sending, G-Kermit sends all files in the same mode, text or binary. There is no automatic per-file mode switching. When receiving, however, per-file switching occurs automatically based on the incoming Attribute packets, if any (explained below), that accompany each file, so if the file sender switches types between files, G-Kermit follows along.


When SENDING a file, G-Kermit obtains the filenames from the command line. It depends on the shell to expand metacharacters (wildcards and tilde).

G-Kermit uses the full pathname given to find and open the file, but then strips the pathname before sending the name to the receiver. For example:

  $ gkermit -s /etc/hosts

results in an arriving file called "HOSTS" or "hosts" (the directory part, "/etc/", is stripped; see next section about capitalization). However, if a pathname is included in the -a option, the directory part is not stripped:

  $ gkermit -s /etc/hosts -a /tmp/hosts

This example sends the /etc/hosts file but tells the receiver that its name is "/tmp/hosts". What the receiver does with the pathname is, of course, up to the receiver, which might have various options for dealing with incoming pathnames.

When RECEIVING a file, G-Kermit does NOT strip the pathname, since incoming files normally do not include a pathname unless you told your terminal to include them or gave an "as-name" including a path when sending to G-Kermit. If the incoming filename includes a path, G-Kermit tries to store the file in the specified place. If the path does not exist, the transfer fails. The incoming filename can, of course, be superseded with the -a option.


When sending a file, G-Kermit normally converts outbound filenames to common form: uppercase, no more than one period, and no funny characters. So, for example, gkermit.tar.gz would be sent as GKERMIT_TAR.GZ.

When receiving a file, if the name is all uppercase, G-Kermit converts it to all lowercase. If the name contains any lowercase letters, G-Kermit leaves the name alone. Otherwise G-Kermit accepts filename characters as they are, since Unix allows filenames to contain practically any characters.

If the automatic peer recognition feature is available in the terminal emulator, and G-Kermit recognizes the emulator's platform as Unix, G-Kermit automatically disables filename conversion and sends and accepts filenames literally.

You can force literal filenames by including the -P option on the command line.


When G-Kermit receives a file whose name is the same as that of an existing file, G-Kermit backs up the existing file by adding a unique suffix to its name. The suffix is ".~n~", where n is a number between 1 and 999. This the same kind of backup suffix used by GNU EMACS and C-Kermit (both of which can be used to prune excess backup files). But since G-Kermit does not read directories (see Implementation Notes), it can not guarantee that the number chosen will be higher than any other backup prefix number for the same file. In fact, the first free number, starting from 1, is chosen. If an incoming file already has a backup suffix, G-Kermit strips it before adding a new one, rather than creating a file that has two backup suffixes.

To defeat the backup feature and have incoming files overwrite existing files of the same name, include the -w (writeover) option on the command line.

If G-Kermit has not been given the -w option and it fails to create a backup file, the transfer fails.


Block check
G-Kermit uses the 3-byte, 16-bit CRC by default. If the other Kermit does not agree, both Kermits automatically drop down to the single-byte 6-bit checksum that is required of all Kermit implementations.

When sending files, G-Kermit conveys the file transfer mode and file size in bytes to the receiver in an Attribute (A) packet if the use of A-packets was negotiated. This allows the receiver to switch to the appropriate mode automatically, and to display the percent done, estimated time left, and/or a thermometer bar if it has that capability. When receiving, G-Kermit looks in the incoming A-packet, if any, for the transfer mode (text or binary) and switches itself accordingly on a per-file basis.

Handling of the Eighth Bit
G-Kermit normally treats the 8th bit of each byte as a normal data bit. But if you have a 7-bit connection, transfers of 8-bit files fail unless you tell one or both Kermits to use the appropriate kind of parity, in which case Kermit uses single-shift escaping for 8-bit bytes. Generally, telling either Kermit is sufficient; it tells the other. Use the -p option to tell G-Kermit which parity to use. Locking shifts are not included in G-Kermit.

Control-Character Encoding
G-Kermit escapes all control characters when sending (for example, Ctrl-A becomes #A). When receiving, it accepts both escaped and bare control characters, including NUL (0). However, unescaped control characters always present a danger, so if uploads to G-Kermit fail, tell your terminal emulator's Kermit to escape most or all control characters (in C-Kermit and Kermit 95 the command is SET PREFIXING CAUTIOUS or SET PREFIXING ALL).

Packet Length
All legal packet lengths, 40-9000, are supported although a lower maximum might be imposed on platforms where it is known that bigger ones don't work. When receiving, G-Kermit sends its receive packet length to the sender, and the sender must not send packets any longer than this length. The default length for most platforms is 4000 and it may be overridden with the -e command-line option.

Sliding Windows
G-Kermit does not support sliding windows. Streaming is used instead. If the other Kermit bids to use sliding windows, G-Kermit declines.

If the terminal emulator's Kermit informs G-Kermit that it has a reliable connection (such as TCP/IP or X.25), and the emulator's Kermit supports streaming, then a special form of the Kermit protocol is used in which data packets are not acknowledged; this allows the sender to transmit a steady stream of (framed and checksummed) data to the receiver without waiting for acknowledgements, allowing the fastest possible transfers. Streaming overcomes such obstacles as long round trip delays, unnecessary retransmissions on slow network connections, and most especially the TCP/IP Nagle and Delayed ACK heuristics which are deadly to a higher-level ACK/NAK protocol. When streaming is in use on a particular connection, Kermit speeds are comparable to FTP. The drawback of streaming is that transmission errors are fatal; that's why streaming is only used on reliable connections, which, by definition, guarantee there will be no transmission errors. However, watch out for the relatively rare circumstance in which the emulator thinks it has a reliable connection when it doesn't -- for example a Telnet connection to a terminal server, and a dialout from the terminal server to the host. Use the -S option on the command line to defeat streaming in such situations.

Using all defaults on a TCP/IP connection on 10BaseT (10Mbps) Ethernet from a modern Kermit program like C-Kermit 7.0 or Kermit 95, typical transfer rates are 150-1000Kcps, depending on the speed of the two computers and the network load.


If file transfers fail:

When receiving files in text mode, G-Kermit strips all carriage returns, even if they aren't part of a CRLF pair.

If you have a TCP/IP connection (e.g. Telnet or Rlogin) to Unix from a terminal emulator whose Kermit protocol does not support streaming, downloads from G-Kermit are likely to be as much as 10 or even 100 times slower than uploads if the TCP/IP stack engages in Nagle or Delayed ACK heuristics; typically, when your terminal emulator's Kermit protocol sends an acknowledgment, the TCP stack holds on to it for (say) 1/5 second before sending it, because it is "too small" to send right away.

As noted in Section 9, the backup prefix is not guaranteed to be the highest number. For example, if you have files oofa.txt, oofa.txt.~1~, and oofa.txt.~3~ in your directory, and a new oofa.txt file arrives, the old oofa.txt is backed up to oofa.txt.~2~, rather than oofa.txt.~4~ as you might expect. This is because gkermit lacks directory reading capabilities, for reasons noted in Section 14, and without this, finding the highest existing backup number for a file is impractical.

If you send a file to G-Kermit with streaming active when the connection is not truly reliable, all bets are off. A fatal error should occur promptly, but if huge amounts of data are lost, G-Kermit might never recognize a single data packet and therefore not diagnose a single error; yet your terminal emulator keeps sending packets since no acknowledgments are expected; the transfer eventually hangs at the end of file. Use -S on G-Kermit's command line to disable streaming in situations where the terminal emulator requests it in error.

You can use G-Kermit's debug log for troubleshooting; this is useful mainly in conjunction with the source code. But even if you aren't a C programmer, it should reveal any problem in enough detail to help pinpoint the cause of the failure. "gkermit -d" (with no action options) writes a short debug.log file that shows the build options and settings.

The debug log is also a packet log; to extract the packets from it, use:

  grep ^PKT debug.log

Packets in the log are truncated to avoid wrap-around on your screen, and they have the Ctrl-A packet-start converted to ^ and A to avoid triggering a spurious autodownload when displaying the log on your screen.

In certain circumstances it is not desirable or possible to use -d to create a log file called debug.log in the current directory; for example, if you don't have write access to the current directory, or you already have a debug.log file that you want to keep (or transfer). In this case, you can include a filename argument after -d:

  gkermit -d /tmp/testing.log -s *.c

(This is an exception to the rule that option arguments are not optional.)

If all else fails, you can contact the Kermit Project for technical support; see:

for instructions.


G-Kermit is written to require the absolute bare minimum in system services and C-language features and libraries, and therefore should be portable to practically any Unix platform at all with any C compiler.

When I wrote G-Kermit in 1999, I wanted it to serve as an example of a program that would last forever, and not need constant "updates" and "upgrades" and "patches" which are the hallmark of modern software culture, where stability is a forgotten concept in programming language design just as backwards compatibility is in operating system and library releases. But the world keeps changing out from under G-Kermit and every other software program on every modern platform (unlike, for example, the IBM OS/MVS operating system for which I wrote software in 1970-something that has never needed upgrades or updates or patches to keep working decade after decade). Anyway, in Unix the biggest change affecting G-Kermit is migration of the errno variable from a simple int to some kind of object or macro defined in a header file. Thus the most common complaint from those trying to build G-Kermit on Linux or wherever is fatal compilation or link-time errors involving errno. The solution is to include:


among the compilation flags (this has always been documented towards the end of this web page, but most people don't read that far). Other errors are increasingly reported that are solved by including ever more header files in gkermit.h or elsewhere, e.g.:

#include <malloc.h>
#include <string.h>
#include <stdlib.h>

I'm not inclined to make a new release just because of bureaucratic reshuffling of header files or requirement of prototypes where they weren't required before, because disregard for stability should not be rewarded. A program, once written, should stay written, so the programmer can go on to something new, rather than writing the same program over and over and over simply to "comply" with whatever new thing somebody dreamed up. Anyway, G-Kermit is GPL so anybody can change it however they want. (Yes, the whole thing could just be engineered for autoconf, but autoconf is not available on all the platforms where G-Kermit is built.)

The source files are:

  makefile   The build procedure
  gwart.c    Source code for a mini-lex substitute
  gproto.w   G-Kermit protocol state machine to be preprocessed by gwart
  gkermit.h  G-Kermit header file
  gkermit.c  G-Kermit main module and routines
  gcmdline.c G-Kermit command-line parser
  gunixio.c  Unix-specific i/o routines

A simple makefile is provided, which can be used with make or gmake. There are three main targets in the makefile:

Build for any POSIX.1 compliant platform (termios). This is the default target, used if you type "make" (or "gmake") alone. This target works for most modern Unixes, including GNU/Linux, FreeBSD, OpenBSD, NetBSD, BSDI, HP-UX, Solaris, SunOS, Unixware, AIX, etc.

Build for almost any AT&T System V platform (termio). Examples include AT&T Unix releases, e.g. for the AT&T 7300, HP-UX versions prior to 7.00.

Build for any BSD (pre-4.4) or Unix V7 platform (sgtty). Examples include NeXTSTEP 3.x, OSF/1, Ultrix-11, and 4.3BSD or earlier.

Note that the target names are all lowercase; "posix" is the default target (the one used if you just type "make"). If the build fails with a message like:

gunixio.c: 65: Can't find include file termios.h
*** Error code 1

then try "make sysv" or "make bsd". See the build list below for examples.

Some special build targets are also provided:

Like sysv but uses getchar()/putchar() for packet i/o rather than buffered nonblocking read()/write(); this is necessary for certain very old System V platforms (see description of USE_GETCHAR below).

When none of the other targets compiles successfully, try this one, which runs the external stty program rather than trying to use API calls to get/set terminal modes (system("stty raw -echo") and system("stty -raw echo")).

Several maintenance/management targets are also included:

Remove object and intermediate files.

Install gkermit (read the makefile before using this).

Uninstall gkermit from wherever "make install" installed it.
The default compiler is cc. To override (e.g. to force the use of gcc on computers that have both cc and gcc installed, or that don't have cc), use:

[g]make CC=gcc [target]

No other tools beyond make, the C compiler and linker, a short list of invariant header files, and the standard C library are needed or used. The resulting binary should be 100K or less on all hardware platforms (and 64K or less on most; see list below).

You may also specify certain build options by including a KFLAGS clause on the make command line, e.g.:


By default, nonblocking buffered read() is used for packets; this technique works on most platforms but other options -- USE_GETCHAR and DUMBIO -- are provided when it doesn't work or when nonblocking i/o is not available.

The build options include:

Include this when the compiler requires ANSI prototyping but does does not define __STDC__ itself. Conversely, you might need to include -U__STDC__ if the compiler defines __STDC__ but does not support minimum ANSI features.

Include this if compilation fails with "unknown type: unsigned long".

Include this if compilation fails with "unknown type: unsigned char".

Define this when building on or for a "small" platform, for example a 16-bit architecture.

Specifies that packet i/o should be done with (buffered) getchar() and putchar() rather than the default method of nonblocking, internally buffered read() and write(). Use this only when G-Kermit does not build or run otherwise, since if the default i/o code is not used, G-Kermit won't be able to do streaming.

Specifies that packet i/o should be done with blocking single-byte read() and write(). Use this only when G-Kermit doesn't build or run, even with USE_GETCHAR.

Change the maximum receive-packet length to something other than the default, which is about 9000. You should change this only to make it smaller; making it bigger is not supported by the Kermit protocol.

Change the default receive packet length to something other than the default, which is 4000. Making it any bigger than this is not advised.

On builds that use nonblocking buffered read(), override the default input buffer size of 4080.

On some platforms, mainly those based on System V R4 and earlier, it was found that receiving files was impossible on TCP/IP connections unless the terminal driver was told to use Xon/Xoff flow control. If downloads work but uploads consistently fail (or fail consistently whenever streaming is used or the packet length is greater than a certain number like 100, or 775), try adding this option. When gkermit is built with this option, it is equivalent to the user always giving the -x option on the command line. (Most versions of HP-UX need this; it is defined automatically at compile time if __hpux is defined.)

#include <errno.h> (rather than "extern int errno;"). Include this if you get Unresolved Extern complaints about errno at link time.

The data type of signal handlers is void. This is set automatically for System V and POSIX builds.

The data type of signal handlers is int. This is set automatically for BSD builds.

Add this to disable the feature in which G-Kermit gets options from the GKERMIT environment variable.

Add this to disable streaming.

This adds a lot (a LOT) of extra information to the debug log regarding packet and character-level i/o.

Show full packets in the debug log rather than truncating them.
Any compiler warnings should be harmless. Examples include:

"Passing arg 2 of `signal' from incompatible pointer"
(or "Argument incompatible with prototype"): Because no two Unix platforms agree about signal handlers. Harmless because the signal handler does not return a value that is used. We don't want to open the door to platform-specific #ifdefs just to silence this warning. However, you can include -DSIG_I or -DSIG_V on the CC command line to override the default definitions.

"blah declared but never used":
Some function parameters are not used because they are just placeholders or compatibility items, or even required by prototypes in system headers. Others might be declared in system header files (like mknod, lstat, etc, which are not used by G-Kermit).

"Do you mean equality?":
No, in "while ((c = *s++))" the assignment really is intentional.

"Condition is always true":
Yes, "while (1)" is always true.

"Flow between cases":

"No flow into statement":
In gproto.c, because it is a case statement generated by machine, not written by a human.

The coding conventions are aimed at maximum portability. For example:

Here are some sample builds:

 Platform                         Size  Target    Notes            
  Apple Mac OS X 1.0 gcc:          48K   posix    (AKA Rhapsody 5.5)
  AT&T 3B2/300 SVR2 cc:            52K   sysv     (4)
  AT&T 6300 PLUS cc:               61K   sysv     (6)
  AT&T 7300 UNIX PC cc:            43K   sysv
  AT&T 7300 UNIX PC gcc:           58K   sysv     (25K with shared lib)
  BSDI 4.0.1 gcc:                  34K   posix
  DEC 5000 MIPS Ultrix 4.3 cc:    104K   posix
  DEC Alpha Digital UNIX 3.2 cc:   98K   bsd      (AKA OSF/1) (1)
  DEC Alpha Tru64 UNIX 4.0e cc:    82K   bsd      (1)
  DEC PDP-11 2.11BSD cc:           40K   bsd211   (7)
  DEC PDP-11 Ultrix 3.0 cc:        40K   bsd211   (9)
  DEC VAX 4.3BSD cc:               46K   bsd
  DEC VAX Ultrix 3.0 cc:           43K   bsd
  DG/UX 5.4R4.11 gcc:              51K   posix
  DYNIX/ptx 4.4.2 cc:              43K   posix
  FreeBSD 3.3 gcc:                 34K   posix
  GNU/Linux RH 5.2 gcc:            35K   posix    (RH = Red Hat)
  GNU/Linux SW 3.5 gcc:            34K   posix    (SW = Slackware)
  HP-UX 5.21 cc:                   55K   sysv     (2)
  HP-UX 6.5 cc:                    40K   sysv     (5)
  HP-UX 7.05 cc:                   50K   posix
  HP-UX 8.00 gcc:                  33K   posix
  HP-UX 9.05 cc:                   57K   posix
  HP-UX 10.01 cc:                  57K   posix
  HP-UX 10.20 cc:                  61K   posix
  IBM AIX 2.2.1 RT PC IBM cc:      62K   sysv
  IBM AIX 3.2 IBM cc:              62K   posix
  IBM AIX 4.1.3 IBM cc:            67K   posix
  Intergraph Clipper acc:          80K   sysv     (8)
  Motorola 68K SV/68 R3.6 cc:      58K   sysv     (4)
  Motorola 88K SV/88 R4.3 cc:      45K   posix
  NetBSD 1.4.1 gcc:                41K   posix
  NeXTSTEP m68k 3.1 gcc:           77K   bsd      (3)
  OPENSTEP m68k 4.2 gcc:           77K   bsd      (3)
  OpenBSD 2.5 gcc:                 47K   posix
  QNX 4.25 cc:                     33K   posix
  Red Hat 9 i386 gcc:              47K   posix    KFLAGS=-DERRNO_H
  SCO XENIX 2.3.4 cc:              41K   sysv     (4)
  SCO UNIX 3.2v4.2 cc:             73K   posix
  SCO UNIX 3.2v4.2 gcc:            61K   posix
  SCO ODT 3.0 cc:                  97K   posix
  SCO OSR5.0.5 gcc:                42K   posix
  SCO Unixware 2.1.3 cc:           38K   posix
  SGI IRIX 5.3 cc:                 86K   posix
  SGI IRIX 6.5.4 cc:               91K   posix
  SINIX 5.42 MIPS cc:              57K   posix
  Solaris 2.4 cc:                  50K   posix
  Solaris 7 cc:                    52K   posix
  SunOS 4.1.3 cc:                  57K   posix
  SunOS 4.1.3 gcc:                 64K   posix                                     


  1. "make posix" builds without complaint on OSF/1 (Digital UNIX (Tru64)) but it doesn't work -- i/o hangs or program dumps core. "make bsd" works fine.

  2. POSIX APIs not available in this antique OS (circa 1983). Also due to limited terminal input buffering capacity, streaming must be disabled and relatively short packets must be used when receiving: "gkermit -Se 250 -r". However, it can use streaming when sending.

  3. POSIX APIs not available. Include KFLAGS=-DSIG_V if you get a lot of warnings about signal().

  4. On System V R3 and earlier, EWOULDBLOCK is not defined, so we use EGAIN instead. No special build procedures needed.

  5. Built with 'make -i "KFLAGS=-DDEFRP=512 -DUSE_GETCHAR" sysv'. It can be built without -DUSE_GETCHAR but doesn't work.

  6. Use 'make "CC=cc -Ml "KFLAGS=-DUSE_GETCHAR"sysv'. It builds but doesn't work, reason unknown, but probably because it was never designed to be accessed remotely in the first place.

  7. This is a 16-bit architecture. A special makefile target is needed because its make program does not expand the $(CC) value when invoking second-level makes. Packet and buffer sizes are reduced to keep static data within limits. Overlays are not needed.

  8. Use 'make "CC=acc" sysv'.

  9. Identifiers must be unique within the first 7 characters. Unfortunately, there is a conflict in gproto.w between streamon() and streamok. Build with 'make bsd211 "KFLAGS=-Dstreamon=strmon -DULONG=long -DSMALL"'. This was on a PDP-11/23+ without I&D space. -DSMALL might not be necessary with I&D space. When using, disable streaming and use shorter-than-usual packets.


The makefile creates a binary called "gkermit". Simply move this binary to the desired directory, such as /usr/local/bin. It needs no special permissions other than read, write, and execute for the desired users and groups: no setuid, no setgid, or any other form of privilege.

DO NOT give SETUID or SETGID privilege to G-Kermit. G-Kermit is not a dialout program. It does not access serial devices or UUCP lockfiles, and it does not do real/effective ID switching. If you give it SETUID or SETGID privilege, this will open restricted files and directories to users who otherwise do not have access, and incoming files will be created with the wrong owner and/or group.

The executable should be called "gkermit" and not "kermit", since "kermit" is the binary name for C-Kermit, and the two are likely to be installed side by side on the same computer; even when they are not, consistent naming is better for support and sanity purposes. There is also a short man page:

You can view it with:

nroff -man | more

Rename and store it appropriately so users can access it with 'man gkermit'. In addition, the README should be made available in a public documentation directory as:


The makefile includes a sample 'install' target that does all this. Please read it before use to be sure the appropriate directories and permissions are indicated. There is also an 'uninstall' target to undo an installation. Obviously you need write access to the relevant directories before you can install or uninstall G-Kermit.


A primary objective in developing G-Kermit is that it can be released and used forever without constant updates to account for platform idiosyncracies and changes. For this reason, certain features have been deliberately omitted:

Other features are omitted to keep the program small and simple, and to avoid creeping featurism:

All of the above can be found in C-Kermit, which is therefore bigger and more complicated, with more platform-specific code and #ifdef spaghetti. C-Kermit requires constant updates and patches to keep pace with changes in the underlying platforms, networking and security methods, and demands from its users for more features.

The goal for G-Kermit, on the other hand, is simplicity and stability, so we don't need thousands of #ifdefs like we have in C-Kermit, and we don't need to tweak the code every time a new release of each Unix variety comes out. G-Kermit is meant to be PORTABLE and LONG-LASTING so the stress is on a MINIMUM of platform dependencies.

If you make changes, please try to avoid adding anything platform-dependent or in any other way destabilizing. Bear in mind that the result of your changes should still build and run successfully on at least all the platforms where G-Kermit was built originally. In any case, you are encouraged to send any changes back to the Kermit Project to be considered for addition to the master G-Kermit distribution.


The Kermit protocol is specified in Kermit, A File Transfer Protocol by Frank da Cruz, Digital Press (1987). A correctness proof of the Kermit protocol appears in Specification and Validation Methods, edited by Egon Börger, Oxford University Press (1995). Using C-Kermit by Frank da Cruz and Christine M. Gianone, Digital Press (1997, or later edition) explains many of the terms and techniques referenced in this document in case you are not familiar with them, and also includes tutorials on data communications, extensive troubleshooting and performance tips, etc. Various other books on Kermit are available from Digital Press. Online resources include:     The Kermit Project website                 The GNU Project website
comp.protocols.kermit.misc         The unmoderated Kermit newsgroup
The ANNOUNCE file                  G-Kermit announcements        Kermit technical support

Please read before sending e-mail to the tech support address.


Install packages are available for the following platforms:

The AIX version is a self-extracting ZIP archive that produces a bff file that can be installed with smit.

Source-code archives are listed just below. If you have a C compiler, you should download the source archive, uncompress if it was compressed or gunzip if it was gzipped, unpack the tar archive with "tar xf gku100.tar", and then build from source code as explained in Section 12. If you don't have a C compiler, download the appropriate prebuilt binary, rename it to "gkermit", and give it execute permission ("chmod +x gkermit"). See Section 13 for installation instructions.

 Filename                           Description
  gku100.tar.gz                      G-Kermit source tar archive, gzipped (62K)
  gku100.tar.Z                       G-Kermit source tar archive, compressed (90K)
  gku100.tar                         G-Kermit source tar archive, not compressed (212K)                         G-Kermit source ZIP archive (81K)
  gkermit68k.tar.gz                  G-Kermit sources, binaries, docs for CP/M-68K (117K)
  kermit/g/                          Individual source and doc files (text)

Individual binaries are also available for those who need them (contact us if you can make any that are not listed):

 Filename                           Description
  gku100.alpha-osf1-1.3              DEC Alpha with OSF/1 1.3
  gku100.alpha-du-3.2                DEC Alpha with Digital UNIX 3.2
  gku100.alpha-du-3.2c               DEC Alpha with Digital UNIX 3.2C
  gku100.alpha-du-3.2d               DEC Alpha with Digital UNIX 3.2D
  gku100.alpha-du-3.2g               DEC Alpha with Digital UNIX 3.2G
  gku100.alpha-du-4.0b               DEC Alpha with Digital UNIX 4.0B
  gku100.alpha-du-4.0c               DEC Alpha with Digital UNIX 4.0C
  gku100.alpha-du-4.0d               DEC Alpha with Digital UNIX 4.0D
  gku100.alpha-tru64-4.0e            DEC Alpha with Tru64 UNIX 4.0E
  gku100.alpha-tru64-4.0f            DEC Alpha with Tru64 UNIX 4.0F
  gku100.alpha-tru64-5.0a            DEC Alpha with Tru64 UNIX 5.0A
  gku100.alpha-tru64-5.1             DEC Alpha with Tru64 UNIX 5.1
  gku100.alpha-tru64-5.1a            DEC Alpha with Tru64 UNIX 5.1A
  gku100.alpha-freebsd-3.4           DEC Alpha with FreeBSD 3.4
  gku100.alpha-freebsd-4.4           DEC Alpha with FreeBSD 4.4
  gku100.alpha-freebsd-4.5           DEC Alpha with FreeBSD 4.5
  gku100.alpha-freebsd-4.6           DEC Alpha with FreeBSD 4.6
  gku100.alpha-freebsd-4.7           DEC Alpha with FreeBSD 4.7
  gku100.alpha-freebsd-6.0           DEC (HP) Alpha with FreeBSD 6.0
  gku100.alpha-linux-db2.2           DEC Alpha with Linux Debian 2.2
  gku100.alpha-linux-db3.0           DEC Alpha with Linux Debian 3.0
  gku100.alpha-linux-rh5.2           DEC Alpha with Linux Red Hat 5.2
  gku100.alpha-linux-rh6.1           DEC Alpha with Linux Red Hat 6.1
  gku100.alpha-linux-rh6.2           DEC Alpha with Linux Red Hat 6.2
  gku100.alpha-linux-rh7.1           DEC Alpha with Linux Red Hat 7.1
  gku100.alpha-linux-su6.1           DEC Alpha with Linux SuSE 6.1
  gku100.alpha-linux-su6.3           DEC Alpha with Linux SuSE 6.3
  gku100.alpha-linux-su6.4           DEC Alpha with Linux SuSE 6.4
  gku100.alpha-linux-su7.1           DEC Alpha with Linux SuSE 7.1
  gku100.alpha-netbsd-1.4            DEC Alpha with NetBSD 1.4
  gku100.alpha-netbsd-1.5.1          DEC Alpha with NetBSD 1.5.1
  gku100.alpha-netbsd-1.5.2          DEC Alpha with NetBSD 1.5.2
  gku100.alpha-netbsd-1.6            DEC Alpha with NetBSD 1.6
  gku100.amd64-freebsd-6.1           AMD_64 with FreeBSD 6.1
  gku100.armle-qnx-6.21              ARM platforms (Little Endian) QNX 6.21B
  gku100.armv41-linux-ipaq-db2.1     Compaq iPAQ H3650 Debian 2.1
  gku100.armv41-linux-shark-db2.1    Compaq SA-110 Shark Palmtop
  gku100.armv41-linux-zaurus-sl550   Sharp Zaurus SL5500 Palmtop
  gku100.att3b2-sysv-3.1             AT&T 3B2/200 with System V R3.1
  gku100.att7300-sysv-3.51           AT&T 7300 UNIX PC (3B1) with System V R3.51
  gku100.clipper-clix-3.1            Intergraph InterPro 2020 with CLIX 3.1V7.6.27
  gku100.cray_ymp-unicos-9.0         Cray Y-MP EL with UNICOS
  gku100.hp9000s300-netbsd-1.3.1     HP 9000 Model 300 with NetBSD 1.3.1
  gku100.hp9000s500-hpux-5.21        HP 9000 Model 550 with HP-UX 5.21
  gku100.hp9000s300-hpux-6.5         HP 9000 Model 3xx with HP-UX 6.5
  gku100.hp9000s300-hpux-7.05        HP 9000 Model 3xx with HP-UX 7.05
  gku100.hp9000s300-hpux-8.00        HP 9000 Model 3xx with HP-UX 8.00
  gku100.hp9000s400-hpux-8.00        HP 9000 Model 4xx with HP-UX 8.00
  gku100.hp9000s300-hpux-9.03        HP 9000 Model 3xx with HP-UX 9.03
  gku100.hp9000s700-hpux-9.05        HP 9000 Model 7xx with HP-UX 9.05
  gku100.hp9000s700-hpux-9.07        HP 9000 Model 7xx with HP-UX 9.07
  gku100.hp9000s300-hpux-9.10        HP 9000 Model 3xx with HP-UX 9.10
  gku100.hp9000s700-hpux-10.01       HP 9000 Model 7xx with HP-UX 10.01
  gku100.hp9000s700-hpux-10.20       HP 9000 Model 7xx with HP-UX 10.20
  gku100.hp9000s800-hpux-10.20       HP 9000 Model 8xx with HP-UX 10.20
  gku100.hp9000s700-hpux-11.00       HP 9000 Model 7xx with HP-UX 11.00
  gku100.hp9000s800-hpux-11.00       HP 9000 Model 8xx with HP-UX 11.00
  gku100.hp9000s700-hpux-11.11       HP 9000 Model 7xx with HP-UX 11.11
  gku100.hp9000s800-hpux-11.11       HP 9000 Model 8xx with HP-UX 11.11
  gku100.hp9000s800-hpux-11i-v2      HP 9000 Model 8xx with HP-UX 11i v2
  gku100.i386-aix-1.2.1              PC (PS/2) with AIX 1.2.1
  gku100.i386-beos-4.5               PC with BeOS 4.5
  gku100.i386-bsdi-4.0.1             PC with BSDI/OS 4.0.1
  gku100.i386-bsdi-4.1               PC with BSDI/OS 4.1
  gku100.i386-bsdi-4.2               PC with BSDI/OS 4.2
  gku100.i386-bsdi-4.3               PC with BSDI/OS 4.3
  gku100.i386-coherent-4.2           PC with Mark Williams Coherent 4.2
  gku100.i386-dgux54420              PC with DG/UX 5.4R4.20
  gku100.i386-dynixptx-4.4.2         PC with Sequent DYNIX/ptx 4.4.2
  gku100.i386-freebsd-1.0            PC with FreeBSD 1.0
  gku100.i386-freebsd-2.2.7          PC with FreeBSD 2.2.7
  gku100.i386-freebsd-2.2.8          PC with FreeBSD 2.2.8
  gku100.i386-freebsd-3.1            PC with FreeBSD 3.1
  gku100.i386-freebsd-3.3            PC with FreeBSD 3.3
  gku100.i386-freebsd-3.4            PC with FreeBSD 3.4
  gku100.i386-freebsd-4.0            PC with FreeBSD 4.0
  gku100.i386-freebsd-4.2            PC with FreeBSD 4.2
  gku100.i386-freebsd-4.3            PC with FreeBSD 4.3
  gku100.i386-freebsd-4.4            PC with FreeBSD 4.4
  gku100.i386-freebsd-4.5            PC with FreeBSD 4.5
  gku100.i386-freebsd-4.6            PC with FreeBSD 4.6
  gku100.i386-freebsd-4.7            PC with FreeBSD 4.7
  gku100.i386-freebsd-4.8            PC with FreeBSD 4.8
  gku100.i386-freebsd-5.0            PC with FreeBSD 5.0
  gku100.i386-is5r3-4.1.1            PC with Interactive UNIX System V/386 R3.2 R4.1.1
  gku100.i386-linux-ca3.1            PC with Caldera GNU/Linux 3.1
  gku100.i386-linux-db2.1            PC with Debian GNU/Linux 2.1
  gku100.i386-linux-db2.2            PC with Debian GNU/Linux 2.2
  gku100.i386-linux-db3.0            PC with Debian GNU/Linux 3.0
  gku100.i386-linux-md9.0            PC with Mandrake GNU/Linux 9.0
  gku100.i386-linux-rh5.1            PC with Red Hat GNU/Linux 5.1
  gku100.i386-linux-rh5.2            PC with Red Hat GNU/Linux 5.2
  gku100.i386-linux-rh6.1            PC with Red Hat GNU/Linux 6.1
  gku100.i386-linux-rh6.2            PC with Red Hat GNU/Linux 6.2
  gku100.i386-linux-rh7.0            PC with Red Hat GNU/Linux 7.0
  gku100.i386-linux-rh7.1            PC with Red Hat GNU/Linux 7.1
  gku100.i386-linux-rh7.2            PC with Red Hat GNU/Linux 7.2
  gku100.i386-linux-rh8.0            PC with Red Hat GNU/Linux 8.0
  gku100.i386-linux-rh9              PC with Red Hat GNU/Linux 9
  gku100.i386-linux-ra2.1            PC with Red Hat Advanced Server 2.1
  gku100.i386-linux-su5.3            PC with SuSE GNU/Linux 5.3
  gku100.i386-linux-su6.1            PC with SuSE GNU/Linux 6.1
  gku100.i386-linux-su6.2            PC with SuSE GNU/Linux 6.2
  gku100.i386-linux-su6.3            PC with SuSE GNU/Linux 6.3
  gku100.i386-linux-su6.4            PC with SuSE GNU/Linux 6.4
  gku100.i386-linux-su7.0            PC with SuSE GNU/Linux 7.0
  gku100.i386-linux-su7.3            PC with SuSE GNU/Linux 7.3
  gku100.i386-linux-sw3.4            PC with Slackware GNU/Linux 3.4
  gku100.i386-linux-sw3.5            PC with Slackware GNU/Linux 3.5
  gku100.i386-linux-sw4.0            PC with Slackware GNU/Linux 4.0
  gku100.i386-linux-sw7.0            PC with Slackware GNU/Linux 7.0
  gku100.i386-linux-sw7.1            PC with Slackware GNU/Linux 7.1
  gku100.i386-linux-sw8.0            PC with Slackware GNU/Linux 8.0
  gku100.i386-linux-sw9.0            PC with Slackware GNU/Linux 9.0
  gku100.i386-linux-tu6.5            PC with TurboLinux 6.5
  gku100.i386-linux-tu7.0            PC with TurboLinux 7.0
  gku100.i386-minix-2.0.2            PC with Minix 2.0.2 (32-bit)
  gku100.i386-mpras-2.03             PC with NCR MP-RAS 2.03
  gku100.i386-mpras-3.02             PC with NCR MP-RAS 3.02
  gku100.i386-netbsd-1.4p            PC with NetBSD 1.4P (ELF)
  gku100.i386-netbsd-1.4.1           PC with NetBSD 1.4.1
  gku100.i386-netbsd-1.5.2           PC with NetBSD 1.5.2
  gku100.i386-netbsd-1.5.4           PC with NetBSD 1.5.4
  gku100.i386-netbsd-1.6             PC with NetBSD 1.6
  gku100.i386-openbsd-2.5            PC with OpenBSD 2.5
  gku100.i386-openbsd-2.9            PC with OpenBSD 2.9
  gku100.i386-openbsd-3.0            PC with OpenBSD 3.0
  gku100.i386-openbsd-3.1            PC with OpenBSD 3.1
  gku100.i386-openbsd-3.2            PC with OpenBSD 3.2
  gku100.i386-os2-3.0                PC with IBM OS/2 3.0 and EMX 0.9c
  gku100.i386-plan9                  PC with Plan 9 from Bell Labs
  gku100.i286-qnx-4.25               PC with QNX 4.x (16 bit)
  gku100.i386-qnx-4.25               PC with QNX 4.25 (32 bit)
  gku100.i386-qnxnto-2               PC with QNX Neutrino 2+
  gku100.i386-qnx-6.1                PC with QNX 6.1
  gku100.i386-qnx-6.21               PC with QNX 6.21B
  gku100.i386-scoxenix-2.3.4         PC with SCO XENIX 2.3.4
  gku100.i386-scounix-3.2v4.2        PC with SCO UNIX 3.2v4.2
  gku100.i386-scoodt-3.0             PC with SCO ODT 3.0
  gku100.i386-scoosr5-5.0.2          PC with SCO OSR5.0.2
  gku100.i386-scoosr5-5.0.4          PC with SCO OSR5.0.4
  gku100.i386-scoosr5-5.0.5          PC with SCO OSR5.0.5
  gku100.i386-scoosr5-5.0.6          PC with SCO OSR5.0.6
  gku100.i386-scoosr5-5.0.7          PC with SCO OSR5.0.7
  gku100.i386-scoosr6-6.0.0          PC with SCO OSR6.0.0
  gku100.i386-scoou8-8.0.0           PC with SCO Open Unix 8.0.0
  gku100.i386-scoou8-8.0.1           PC with SCO Open Unix 8.0.1
  gku100.i386-sinix-5.41             PC with Siemens Nixdorf SINIX-L 5.41
  gku100.i386-solaris-2.5.1          PC with Solaris 2.5.1
  gku100.i386-solaris-2.6            PC with Solaris 2.6
  gku100.i386-solaris-8              PC with Solaris 8
  gku100.i386-solaris-9              PC with Solaris 9
  gku100.i386-solaris-10             PC with Solaris 10
  gku100.i386-unixware-2.1.0         PC with UnixWare 2.1.0
  gku100.i386-unixware-2.1.3         PC with UnixWare 2.1.3
  gku100.i386-unixware-7.0.1         PC with UnixWare 7.0.1
  gku100.i386-unixware-7.1.0         PC with UnixWare 7.1.0
  gku100.i386-unixware-7.1.1         PC with UnixWare 7.1.1
  gku100.i386-unixware-7.1.3         PC with UnixWare 7.1.3
  gku100.ia64-hpux-11.22             IA64 (Itanium) with HP-UX 11.22i v2
  gku100.ia64-hpux-11.23             IA64 (Itanium) with HP-UX 11.23i v2
  gku100.ia64-linux-db3.0            IA64 (Itanium) with Debian Linux 3.0
  gku100.ia64-linux-rh7.1            IA64 (Itanium) with Red Hat Linux 7.1
  gku100.ia64-linux-rh7.2            IA64 (Itanium) with Red Hat Linux 7.2
  gku100.ia64-linux-su7.2            IA64 (Itanium) with SuSE Linux 7.2
  gku100.m68k-linux-db2.1            Motorola 680x0 with Linux Debian 2.1
  gku100.m68k-linux-db2.2            Motorola 680x0 with Linux Debian 2.2
  gku100.m68k-netbsd-1.4.2a          Motorola 680x0 with NetBSD 1.4.2-Alpha
  gku100.m68k-cpm68k-1.2             Motorola 68020 with CP/M-68K 1.2 (rename to gkermit.rel)
  gku100.m68k-sv68-r3.6              Motorola MVME 147 68K, System V/68 R3V6
  gku100.mvme68k-netbsd-1.5.2        Motorola MVME 147 or 167 m68k, NetBSD 1.5.2
  gku100.m68k-nextstep-3.1           NeXTstation with NeXTSTEP 3.1
  gku100.m68k-nextstep-3.3           NeXTstation with NeXTSTEP 3.3
  gku100.m68k-openstep-4.2           NeXTstation with OPENSTEP 4.2
  gku100.m68k-tandy6000-xenix-3.0    Tandy 16/6000 Microsoft XENIX 3.02.00
  gku100.m88k-dgux-5.4r3.10          Data General AViiON 88110 with DG/UX 5.4R3.10
  gku100.m88k-dgux-5.4r4.11          Data General AViiON 88110 with DG/UX 5.4R4.11
  gku100.m88k-sv88-r4.3              Motorola MVME 187 88K, System V R4 V4.3
  gku100.m88k-sv88-r4.4              Motorola MVME 187 88K, System V R4 V4.4
  gku100.mips-irix-5.3               SGI with IRIX 5.3 (MIPS-1)
  gku100.mips-irix-6.2               SGI with IRIX 6.2 (MIPS-2)
  gku100.mips-irix-6.3               SGI with IRIX 6.3 (MIPS-2)
  gku100.mips-irix-6.2-n32           SGI with IRIX 6.2 (MIPS-3)
  gku100.mips-irix-6.2-64            SGI with IRIX 6.2 (64-bit)
  gku100.mips-irix-6.5.2             SGI with IRIX 6.5.2
  gku100.mips-irix-6.5.4             SGI with IRIX 6.5.4
  gku100.mips-irix-6.5.6             SGI with IRIX 6.5.6
  gku100.mips-irix-6.5.10            SGI with IRIX 6.5.10
  gku100.mips-be-qnx-6.21            MIPS platforms (Big Endian) QNX 6.21B
  gku100.mips-le-qnx-6.21            MIPS platforms (Little Endian) QNX 6.21B
  gku100.mips-sinix-5.42             Siemens Nixdorf RM200 with SINIX 5.42
  gku100.mips-reliant-5.43           Siemens Nixdorf RM600 with Reliant UNIX 5.43
  gku100.mips-reliant-5.44           Siemens Nixdorf RM600 with Reliant UNIX 5.44
  gku100.mips-linux-db3.0            DECstation 5000 with Debian Linux 3.0
  gku100.mips-linux-gentoo-1.4.16    SGI Indy-200 with Gentoo Linux 1.4.16
  gku100.mips-netbsd-1.4.1           DECstation 5000 with NetBSD 1.4.1
  gku100.mips-ultrix-4.3             DECstation 5000 with Ultrix 4.3
  gku100.mips-ultrix-4.3a            DECstation 5000 with Ultrix 4.3A
  gku100.pdp11-bsd-2.11              DEC PDP-11/44(?) with 2.11BSD
  gku100.pdp11-ultrix11-3.0          DEC PDP-11/23+ with Ultrix-11 3.0 (no I&D)
  gku100.vax-bsd-4.2                 DEC VAX with 4.2BSD
  gku100.vax-bsd-4.3                 DEC VAX with 4.3BSD
  gku100.vax-ultrix-3.0              DEC VAX with Ultrix 3.0
  gku100.vax-ultrix-4.5              DEC VAX with Ultrix 4.5
  gku100.parisc-ftx-3.4              Stratus Continuum (PA-RISC), FTX 3.4
  gku100.ppc-linux-db2.2             Apple Power Mac with Linux Debian 2.2
  gku100.ppc-linux-yd2.3             Apple Power Mac with Linux Yellow Dog 2.3
  gku100.ppc-linuxppc-1999q2         Apple Power Mac with LinuxPPC 1999 Q2
  gku100.ppc-linuxppc-2000q4         Apple Power Mac with LinuxPPC 2000 Q4
  gku100.ppc-linux-su6.3             Apple Power Mac with Linux SuSE 6.3
  gku100.ppc-linux-su6.4             Apple Power Mac with Linux SuSE 6.4
  gku100.ppc-macosx-1.0              Apple Power Mac with Mac OS X 1.0 (Rhapsody 5.5)
  gku100.ppc-macosx-10.1.1           Apple Power Mac with Mac OS X 10.1.1
  gku100.ppc-darwin-1.3.3            Apple Power Mac with Apple Darwin 1.3.3
  gku100.ppc-darwin-5.3              Apple Power Mac with Apple Darwin 5.3
  gku100.ppc-macosx-10.2             Apple Power Mac with Mac OS X 10.2
  gku100.ppc-beos-4.5                BeBox, BeOS 4.5
  gku100.ppc-powermax-5.1            Concurrent PowerMAX OS 5.1
  gku100.ppc-qnx-6.21                PowerPC (Big Endian) QNX 6.21B
  gku100.rtpc-aix-2.2.1              IBM RT PC, AIX 2.2.1
  gku100.rtpc-aos-4.3                IBM RT PC, AOS 4.3BSD
  gku100.rs6000-aix-3.2.0            IBM Power Series with AIX 3.2.0
  gku100.rs6000-aix-3.2.5            IBM Power Series with AIX 3.2.5
  gku100.ppc-aix-4.1.3               IBM Power Series with AIX 4.1.3
  gku100.ppc-aix-4.1.5               IBM Power Series with AIX 4.1.5
  gku100.ppc-aix-4.2.1               IBM Power Series with AIX 4.2.1
  gku100.ppc-aix-4.3.2               IBM Power Series with AIX 4.3.2
  gku100.ppc-aix-4.3.3               IBM Power Series with AIX 4.3.3
  gku100.ppc-aix-5.1                 IBM Power Series with AIX 5.1
  gku100.pyramid-dcosx-1.1           Pyramid MIS-ES6/1024 SMP DC-OSx1.1-95c087.4
  gku100.s390-linux390               IBM System/390 with Linux/390
  gku100.s390-linux-su7.0            IBM System/390 with SuSE Linux 7.0
  gku100.sh4-qnx-6.21                SH4 platforms (Little Endian) QNX 6.21B
  gku100.sun3-sunos-4.1.1            Sun/3 with SunOS 4.1.1
  gku100.sparc-linux-db2.2           Sun Sparc with Linux Debian 2.2
  gku100.sparc-linux-rh6.1           Sun Sparc with Linux Red Hat 6.1
  gku100.sparc-linux-rh6.2           Sun Sparc with Linux Red Hat 6.2
  gku100.sparc-linux-su7.1           Sun Sparc with Linux SuSE Linux 7.1
  gku100.sparc-netbsd-1.4.1          Sun Sparc with NetBSD 1.4.1
  gku100.sparc-openbsd-2.3           Sun Sparc with OpenBSD 2.3
  gku100.sparc-sunos-4.1.1           Sun Sparc with SunOS 4.1.1
  gku100.sparc-sunos-4.1.3           Sun Sparc with SunOS 4.1.3
  gku100.sparc-solaris-1.0.1         Sun (Tadpole) SparcBook2 with Solaris 1.0.1
  gku100.sparc-solaris-2.4           Sun Sparc with Solaris 2.4
  gku100.sparc-solaris-2.5.1         Sun Sparc with Solaris 2.5.1
  gku100.sparc-solaris-2.6           Sun Sparc with Solaris 2.6
  gku100.sparc-solaris-7             Sun Sparc with Solaris 7
  gku100.sparc-solaris-8             Sun Sparc with Solaris 8
  gku100.sparc-solaris-9             Sun Sparc with Solaris 9
  gku100.sparc-solaris-10            Sun Sparc with Solaris 10
  gku100.x86_64-linux-rh3.0as        AMD Opteron x86 64-bit Red Hat Linux 3AS



G-Kermit is especially handy when your UNIX computer has no other file transfer method that you can use. In this case, it is often possible to "bootstrap" G-Kermit onto your computer because of its small size. Suppose Computer A is a UNIX computer on the Internet, and Computer B is the unconnected computer where you want to install G-Kermit. Download the binary for Computer B to Computer A from the Kermit website, then compress it on computer A, and then uuencode it, for example (the parts you type are underlined):

$ mv gku100.att7300-sysv-3.51 gkermit
$ compress gkermit
$ uuencode gkermit.Z gkermit.Z > gkermit.Z.uue

This gives a 35K text file having 573 lines. Now use a terminal emulator such as C-Kermit, Kermit 95, or MS-DOS Kermit to make a connection to Computer B, for example by modem or direct serial connection, log in, and give a "cat" command to copy incoming characters to a file; for example

C-Kermit> set line /dev/ttyS0
C-Kermit> set speed 57600
C-Kermit> set set flow-control none
C-Kermit> set carrier-watch off
C-Kermit> connect
login: youruserid
$ cat > gkermit.Z.uue

Now "escape back" from the connection by typing Ctrl-Backslash (hold down the Ctrl key and press the Backslash (\) key); now you should have the "C-Kermit>" prompt again. At the C-Kermit prompt give a TRANSMIT command for the uuencoded file, e.g.:

C-Kermit> transmit gkermit.Z.uue

If you are using a non-Kermit terminal program, it probably won't have a TRANSMIT command, but it is likely have an "upload with ASCII protocol" choice in its protocols menu, so use that.

When the upload is finished, connect back to Computer B and type Ctrl-D (hold down the Ctrl key and press the D key) to close the new file and return to the shell prompt, and then:

$ uudecode gkermit.Z.uue
$ uncompress gkermit.Z
$ chmod +x gkermit

Now you have a file transfer program on computer B. Of course this bootstrapping method is error prone since "ASCII" is not an error-correcting protocol, so you might have to try several times, perhaps reducing your serial speed. But once gkermit is successfully installed on Computer B, you can use it to transfer files into and out of Computer B to/from any computer that has a Kermit program and that can make a connection to Computer B. You can also use gkermit to receive the larger C-Kermit, which then gives Computer B dialout and scripting capabilities.

For those who need to bootstrap G-Kermit from a non-UNIX platform, each G-Kermit binary has been compressed and uuencoded for you. In fact, there is a dot-Z version (compressed with UNIX 'compress') and a dot-gz version (compressed with GNU gzip), for example:

 gku100.i386-scoxenix-2.3.4.Z.uue  (compress: 34K, 550 lines)
 gku100.i386-scoxenix-2.3.4.gz.uue (gzip:     25K, 408 lines)

The names correspond to those in the binaries list, but with ".Z.uue" added for compressed versions and ".gz.uue" added for gzip'd versions. CLICK HERE for FTP access.

Top   Kermit Home

G-Kermit 1.0 / Columbia University / / 1999-2006 / Reformatted: 2010 / Updated 2011