[ih] FTP RIP

[Jack Haverty]

I can toss in a bit of recollections of the early days of FTP and MAIL...

In 1970, I was also a grad student in Lick's group at MIT.  Abhay's
office was down the hall from mine.  There was lots of ARPANET-related
activity, e.g., Abhay's FTP involvement, Bob Bressler's writing of NCP
for the MIT-DM machine, Bob Metcalfe's thesis work in "Thin-wire
communications" that led to Ethernet, etc.

My project at the time was to work on some of Lick's "Electronic Office"
visions.   It wasn't directly related to the ARPANET at first, but
quickly evolved into interoffice and intraoffice communications and
document handling -- or in other words, what we now call email.   At the
time, it was politically incorrect to use the term "mail" since that was
exclusively Postal Service responsibility, not ARPA.  So we called it
Electronic Messaging.

IIRC, it was common for computer systems of the era (1969/70) to have
some mechanism for interaction between users.  E.g., there was something
like a "Mail" command, that allowed one user to drop a message into
another user's file directory so it became accessible and could be
read.  Even in IBM batch processing, you could put cards in your input
deck that would send a message to the operator, e.g., to mount a
particular tape your job needed.   I had to do that on the 7094.

At the time, there were no "headers" in such messages.  The OS typically
put a line at the top saying something like "Message from <USER> on
<DATETIME>" for each message.  On the systems I dealt with, there was
just a file in each user's directory, and each incoming message was
simply appended to that file by the OS.  No network involved at all.  To
read your mail, you printed the file.  To send mail, you used your OS'
mail command.

As Abhay et al were doing FTP, of course things were implemented before
they were documented.   Someone noticed that you could send a message to
another user by simply using FTP to APPEND your message to that user's
mailbox file.

Although this worked fine on the ITS machine at DM, which had no
security at all, it surfaced issues on other machines which had a notion
of protecting user's files from others.  Multics was especially picky
about such stuff.

I don't recall if the APPEND command in FTP was created to enable such
message-delivery, or if it was already there and FTP became just a
convenient way to deliver a message to a mailbox.

But of course, to get a message to another user, you had to know how
that user's system stored messages, so you could append to the right
file.   You also often had to be able to log in to that other machine
(except for ITSes which let anybody log in...).

The "MAIL" command in FTP solved that problem, by giving each server the
responsibility of knowing where to put incoming messages for a
particular user on that system.  It used the ANONYMOUS account name to
let anybody send messages even without having an account.   As I recall,
Multics had especially bad heartburn with ANONYMOUS.

I clearly recall using FTP as a "mail client".  You would simply connect
to the remote machine, IIRC even by just using Telnet to the FTP port,
and you'd be typing directly to the FTP server.  You could then type
"MAIL <user>" and it would respond with something like "Type your
message, and end it with a line containing a single period".   Then you
type whatever you want, and as soon as you type a line with just a
period, the mail command terminated and your message went into that
other user's mailbox file.

This resulted in very free-form mailbox files, since everything came
from ANONYMOUS and there was no particular structure to what people sent.

Although you could simply type your message into the Telnet connection,
it wasn't very user friendly, since often there was no implementation of
backspace.   So typos remained, no way to fix it.  

But it was easy to write simple programs that allowed a user to create
the message text and then make the FTP connection and use the MAIL
command to send the message.

I didn't use Tenex at the time, but I suspect this is about when Ray (or
whoever did it) implemented the SNDMSG/CPYNET mechanism.

Mailbox files quickly became messy and hard to read.  Many programs
emerged to provide the UI for sending (and maybe also reading) mail.  

To make things better, programs inserted some text at the beginning of
each message to help identify it and provide a visual demarcation
between messages.  Spooler programs for line printers used a similar
technique, putting "banners" between print jobs, so it was easy(ier) to
find the end of one and beginning of the next.  

There was no standardization of what was in those "headers".  Some were
simply utilitarian (From: JFH at MIT-DM; Subject: Header syntax).  Others
could be creative (From: The eloquent keystrokes of Jack, concerning
Header syntax).   No rules.

Although humans could understand such stuff, it was challenging to write
a program that could correctly parse such free-form information.  I
know; I tried.

In addition, the "end your message with a line containing only a period"
element of the FTP protocol meant that any message might prematurely
abort the connection if the text contained the magic line.  To prevent
that, it was necessary to scan every outgoing message and do something
to alter wherever necessary to avoid <CRLF>.<CRLF> -- something that was
annoyingly common in documents (part of an ellipsis).

This situation was discussed extensively, of course by using email as
the medium, and triggering the formation of various lists such as
HEADER-PEOPLE where the pros and cons were debated ad nauseam.  

Sadly, I think little of those discussions was ever captured in RFCs,
and email archives seem elusive or incomplete.   I do recall that the
crux of the debate was simplicity of sending quick notes versus the
complexity of an office-automation machine.    So that may have been the
"other email discussions" that motivated Ray.

The end result was to do an interim first step of the simple design of
protocols and formats, and pursue the rest for a second release.  SMTP,
the various "header" RFCs et al defined the first step.  AFAIK, the
second is still in progress.

/Jack Haverty
MIT-DM 1970-1977

 



On 9/28/20 11:17 AM, Dave Crocker via Internet-history wrote:
> On 9/28/2020 8:48 AM, Miles Fidelman via Internet-history wrote:
>> As I recall, though, the first ARPANET email transfer was
>> accomplished gloming SNDMSG & CPYNET together - to
>
> Yes.  Well documented.  And there is a timeline and reference to
> relevant histories at http://emailhistory.net.
>
> Broadly, there was a flurry of activity in the early 1970s, with quite
> a lot of collaboration and cross-talk.
>
> So, almost 25 years ago I was chatting with Abhay about FTP's
> including the mail commands and he was quite clear that it had been
> planned all along.  Certainly the public documentation suggests that
> the topic was active in the midst of the flurry.
>
> As a result of the more recent pseudo-controversy about the
> 'invention' of email, Ray said that his midnight project with
> sndmsg/cpynet was in direct response to the other email discussions
> that were happening, of a more elaborate protocol, and a usage model
> of printing the message and sending it through office paper mail.  I
> had not heard this piece of his story before.  It's perhaps a bit
> facile to compare what he did, against what was in the works, to
> creating Unix and reaction to Multics. But maybe not.
>
> Anyhow, the earliest FTP rfc drafts don't contain email, but by the
> time the specification stabilized, it did.
>
>
>> If I recall my history correctly, FTP had (has?) a "mail" command
>> added that served to transfer email for a while.  Then came SMTP. 
>
> SMTP was written 10 years later.  And then it had to go through
> deployment startup.  The FTP Mail commands served us quite well, for
> quite awhile.
>
> d/
>