Try the Last Internet Kermit Server

$ grep kermit /etc/services
kermit          1649/tcp

What is this mysterious protocol? Who uses it and what is its story?

This story is a winding one, beginning in 1981. Kermit is, to the best of my knowledge, the oldest actively-maintained software package with an original developer still participating. It is also a scripting language, an Internet server, a (scriptable!) SSH client, and a file transfer protocol.

And my first use of it was talking to my HP-48GX calculator over a 9600bps serial link. Yes, that calculator had a Kermit server built in.

But let’s back up and talk about serial ports and Modems.

Serial Ports and Modems

In my piece The PC & Internet Revolution in Rural America, I recently talked about getting a modem – what an excitement it was to get one! I realize that many people today have never used a serial line or a modem, so let’s briefly discuss.

Before Ethernet and Wifi took off in a big way, in the 1990s-2000s, two computers would talk to each other over a serial line and a modem. By modern standards, these were slow; 300bps was a common early speed. They also (at least in the beginning) had no kind of error checking. Characters could be dropped or changed. Sometimes even those speeds were faster than the receiving device could handle. Some serial links were 7-bit, and wouldn’t even pass all 7-bit characters; for instance, sending a Ctrl-S could lock up a remote until you sent Ctrl-Q.

And computers back in the 1970s and 1980s weren’t as uniform as they are now. They used different character sets, different line endings, and even had different notions of what a file is. Today’s notion of a file as whatever set of binary bytes an application wants it to be was by no means universal; some systems treated a file as a set of fixed-length records, for instance.

So there were a lot of challenges in reliably moving files between systems. Kermit was introduced to reliably move files between systems using serial lines, automatically working around the varieties of serial lines, detecting errors and retransmitting, managing transmit speeds, and adapting between architectures as appropriate. Quite a task! And perhaps this explains why it was supported on a calculator with a primitive CPU by today’s standards.

Serial communication, by the way, is still commonplace, though now it isn’t prominent in everyone’s home PC setup. It’s used a lot in industrial equipment, avionics, embedded systems, and so forth.

The key point about serial lines is that they aren’t inherently multiplexed or packetized. Whereas an Ethernet network is designed to let many dozens of applications use it at once, a serial line typically runs only one (unless it is something like PPP, which is designed to do multiplexing over the serial line).

So it become useful to be able to both log in to a machine and transfer files with it. That is, incidentally, still useful today.

Kermit and XModem/ZModem

I wondered: why did we end up with two diverging sets of protocols, created at about the same time? The Kermit website has the answer: essentially, BBSs could assume 8-bit clean connections, so XModem and ZModem had much less complexity to worry about. Kermit, on the other hand, was highly flexible. Although ZModem came out a few years before Kermit had its performance optimizations, by about 1993 Kermit was on par or faster than ZModem.

Beyond serial ports

As LANs and the Internet came to be popular, people started to use telnet (and later ssh) to connect to remote systems, rather than serial lines and modems. FTP was an early way to transfer files across the Internet, but it had its challenges. Kermit added telnet support, as well as later support for ssh (as a wrapper around the ssh command you already know). Now you could easily log in to a machine and exchange files with it without missing a beat.

And so it was that the Internet Kermit Service Daemon (IKSD) came into existence. It allows a person to set up a Kermit server, which can authenticate against local accounts or present anonymous access akin to FTP.

And so I established the quux.org Kermit Server, which runs the Unix IKSD (part of the Debian ckermit package).

Trying Out the quux.org Kermit Server

There are more instructions on the quux.org Kermit Server page! You can connect to it using either telnet or the kermit program. I won’t duplicate all of the information here, but here’s what it looks like to connect:

$ kermit
C-Kermit 10.0 Beta.08, 15 Dec 2022, for Linux+SSL (64-bit)
 Copyright (C) 1985, 2022,
  Trustees of Columbia University in the City of New York.
  Open Source 3-clause BSD license since 2011.
Type ? or HELP for help.
(/tmp/t/) C-Kermit>iksd /user:anonymous kermit.quux.org
 DNS Lookup...  Trying 135.148.101.37...  Reverse DNS Lookup... (OK)
Connecting to host glockenspiel.complete.org:1649
 Escape character: Ctrl-\ (ASCII 28, FS): enabled
Type the escape character followed by C to get back,
or followed by ? to see other options.
----------------------------------------------------

 >>> Welcome to the Internet Kermit Service at kermit.quux.org <<<

To log in, use 'anonymous' as the username, and any non-empty password

Internet Kermit Service ready at Fri Aug  4 22:32:17 2023
C-Kermit 10.0 Beta.08, 15 Dec 2022
kermit

Enter e-mail address as Password: [redacted]

Anonymous login.

You are now connected to the quux kermit server.

Try commands like HELP, cd gopher, dir, and the like.  Use INTRO
for a nice introduction.

(~/) IKSD>

You can even recursively download the entire Kermit mirror: over 1GB of files!

Conclusions

So, have fun. Enjoy this experience from the 1980s.

And note that Kermit also makes a better ssh client than ssh in a lot of ways; see ideas on my Kermit page.

This page also has a permanent home on my website, where it may be periodically updated.

23 thoughts on “Try the Last Internet Kermit Server

  1. Gunnar Wolf says:

    Quite interesting. I live the BBS days, but never thought much of Kermit; in my mental model, it was there together with xmodem as one of the old, slow protocols (I was active as a BBS user and sysop between 1991 and 1996). I (think I) remember watching the interaction patterns in my modem’s LEDs; IIRC xmodem and Kermit waited for an ack/checksum for each block, while (I assumed) ymodem steamed the contents and checksums from the server to the client, and the client only interrupted when a checksum failed. And zmodem, oh the luxury, even started with an easily recognizable header, so I didn’t have to ask my terminal emulator to begin a transfer!

    1. John Goerzen says:

      I remember watching modem LEDs also! Yes, I could definitely tell the difference; with XModem, there was that pause in RX, while with ZModem it was constantly on.

      The thing about Kermit is that it’s an extensible protocol. The earliest versions were XModem-like in that they used small packets and required an ACK on each one before sending the next. But later versions introduced large packets (up to 9K, so larger than ZModem’s), sliding windows, and even no windows (“streaming” mode for running atop connections that are already supposed to be reliable, such as SSH or plain TCP). It seems a lot of BBSs, if they supported Kermit at all, only supported the very old XModem-era version. C-Kermit to this day can communicate with the oldest of Kermits from 1981 but if talking to a newer one, will be more efficient by default.

      I also remember a protocol called HS-Link. It was like ZModem but let me have keyboard-to-keyboard chat with a person on the other end simultaneously. That was fun!

  2. Ross Bamford says:

    Great post! Back when my home brew computer ( https://github.com/rosco-m68k/rosco_m68k ) was on breadboard Kermit was the only protocol I could get working reliably due to noise and dodgy connections, and it just kind of stuck – so we still use it daily over there πŸ˜…

  3. M. Langdon says:

    Kermit is wonderful. Back in the old days, we used it to connect IBM P/C’s to a DEC 20/20, and transfer files. I built a Z80 single-board computer, found Kermit for Linux, installed it on an old Redhat/Fedora box, and that is how I connect to the Z80 SBC. The baud-rate on the Z80 board is hard-coded at 38400. Kermit compiles and installs to /usr/local/bin, so you can just enter “kermit” from an xterm session, and with a null-modem cable (which just swaps the Rs-232 send and receive lines), I can access the serial port on the Z80, and get to it’s MS-BASIC.
    The commands to access the Linux serial port from Kermit are;

    set line /dev/ttyS1 (or /dev/ttyS0 depending on your port number)
    set baud 38400 (or whatever baud rate you want)
    set carrier_watch OFF (to keep line up, and not use Carrier-Detect)
    connect
    …. (you are now connected)

    (you use “ctrl-\ c” to disconnect and return to Kermit, where you can enter
    many commands, or just ‘”c” to reconnect, or “exit”)

    Local serial communication is fast, easy, simple and reliable with Kermit.
    If you want to build your own hardware and flash your own chips, with
    your own monitor and interpreter, and don’t want or need the overhead of
    a TCP/IP stack, serial port communication with Kermit works great.

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.