On 2026-01-11 09:36, Johnny Billquist wrote:
This became more confused and complicated than I
anticipated.
Welcome to sitting on a standards body*. I did some of that
in my DECUS days.
* It's a lot easier if the body is dead, because 1) if it's
dead, you're less likely to roll off and 2) if it's dead, it
is also likely that nobody cares because the body is dead al-
ready.
8-}
So I'll try and rephrase this, and hopefully
people can agree, and if
not we can take it from there.
Sounds like a plan.
First of all we have the TCP/IP finger protocol.
This is defined in RFC 1288.
This protocol talks over TCP, with the server listening on port 79. A
client opens the connection and sends a one line query, terminated by
CR+LF. The query as such is basically in the form user@host2@host1,
where all the parts are optional. However, note that the username is
the leftmost component before the first @, and the host to communicate
to is the rightmost component, after the last @.
Forwarding from host1 to host2 is up to host1 if it will do it or not.
But it really means that hosts are processed right to left, and the
optional username is the leftmost part. Any host that talks finger
over TCP really should follow this RFC. Anything else is fundamentally
bad, and I hope all would agree with that.
Agreed. I would just add that optional arguments (which the RFC hand-
waves as "Query Tokens" and only mentions in passing (but does not de-
scribe the function of) the /W token, so there are other possible arg-
uments, which a given server implementation may or may not implement.
Can we agree that one or more optional "tokens" (/foo) MAY appear in
the query, that implementations SHOULD ignore tokens they do not under-
stand/implement, SHOULD implement a /HELP token, and MUST pass the com-
plete query (after removing their own name), including any tokens, in-
cluding /HELP to the next host (if any). To clarify, if a system that
receives a Finger query is just "passing it along", it should not re-
spond to /HELP itself, but just pass it along as well.
Next we have finger over DECnet.
There are no formal standard for this. But there have existed
implementations since the 80s. Thomas tried to summarize how it should
work, which is aligned with those old implementations, and is also
what both him and me have tried to follow.
This protocol then talks over DECnet, with the server defined as the
DECnet object 117. A client opens the connection and sends a one line
query. The query as such is basically in the form host1::host2::user,
where all the parts are optional. However, note that the username is
the rightmost component, after the last ::, and the host to
communicate to is the leftmost component, before the first ::.
Forwarding from host1 to host2 is up to host1 if it will do it or not.
But it really means that hosts are processed left to right, and the
optional username is the rightmost part. Any host that talks finger
over DECnet really should follow this spec. Anything else is pretty
bad, and I hope all would agree with that.
Agreed, subject to my comments on RFC 1288 above.
I'd also add that "An implementation MAY decide to forward the re-
quest to another DECnet node if it does not have an node definition
for the host being queried.
So that's the basics. It's pretty straight
forward, and I hope very
uncontroversial. However, please note the complete different parsing
order of hosts and usernames in TCP/IP and DECnet. This is important!
Yup. At least since the UK moved off Grey Book (where the CS system
at Foo University was uk.ac.foou.cs instead of cs.foou.ac.uk - we used
to joke that "they drive on the wrong side of the Internet, too". 8-)
Gatewaying is implementation-specific and MAY be provided. If it is
provided, it SHOULD follow the appropriate rules for left-to-right and
right-to-left parsing as described above.
Before I go on I want to make a small comment on the
topic of
streaming connections in DECnet. DECnet is inherently packet based.
Some operating systems provide an abstraction to streams on top of
this, but not all OSes do. And this stream abstraction is not the same
thing as TCP, and it is important to understand this. If your host
pretends you use a stream, it can still arrive as packets on the peer
side. There is no explicit stream type, and the packing/unpacking of
data from a stream into packets are done at a layer above DECnet
itself. This became obvious when me and Thomas were doing some initial
work on interoperability between TOPS-20 and RSX. The problem being
that Thomas was letting TOPS-20 treat the connection as a stream, and
we got into trouble on the RSX side.
TOPS-20 were just putting all the data to send into one packet in the
end. In RSX when receiving, you give a buffer with a size where
received data should be placed. And if the packet contain more data
than fits in the buffer, the remaining data is not kept, but
discarded, and you get a data overrun status in the receive.
So it's not actually a problem with streaming as such, but the size of
packets you might end up with. If TOPS-20 streams would just limit the
actual eventual packet to no more than some certain size, RSX will
play just fine. The fact that TOPS-20 pretend it's a stream is not a
problem. The problem is identical if you use packets, and just use a
packet size that is larger than what the receiver is expecting.
So if there is a way for any streaming abstraction layer to just say
what the maximum size of the packets should be, then by all means, run
with a stream if you want to, and it will work fine (just let me know
what your upper limit is set to, and I can adjust the RSX code
correspondingly).
I'd never heard of streaming until this discussion came around the
first time (2024). I've always written lines as records in my imple-
mentation.
Ok. Final part. Things become "interesting"
when you start mixing
TCP/IP and DECnet. Since TCP/IP requests do hosts and users processing
right to left, and DECnet requests do hosts and users processing left
to right, and they also use different separators between hosts and
usernames, how do you get this to mix?
Terri's example:
finger terry@spc11d::
is a complete mess. How should this be parsed. If we go by TCP/IP
standard, anything to the right of the last @ should be the host,
which is "spc11d::". But that's not a host you would find in DNS.
But it's also not useful to process according to DECnet, because then
we say that everything before the first :: is the node, which would be
"terry@spc11d", which is clearly not a DECnet node.
So, please, drop that. That is pretty obviously illegal, no matter
which way you want to look at it.
This is entirely a matter of how the user command line is parsed
by the Finger client. It SHOULD be free to parse things however it
likes. but MUST only send a properly-formed query to a Finger server.
Back in the day, we had DECnet, BITNET, and TCP/IP (and some other
protocols). So you could say "finger user(a)node.decnet" (and use "fin-
ger user@node::" as a shortcut). Likewise for "finger user(a)node.bitnet"
- these were all treated as ".decnet" and ".bitnet" pseudo-TLDs. This
is also what PMDF (see prior references to Ned Freed) does.
Unless there were cases where DECnet host FOO::. BITNET host FOO,
and TCP/IP host
foo.example.com differed, you could just say "finger
user@host" and Finger would figure out the appropriate transport by
querying the host tables / DNS in that order - DECnet, BITNET, and
TCP/IP.
This made it easy for users (who often didn't know what sort of
network connection was used to talk to their buddy Fred on host
foobar). "finger fred@foobar" would just Do The Right Thing.
But note that all this optional work MUST be done entirely on the
user's local finger client, and what gets emitted as a Finger comm-
and line MUST be appropriate for the next hop's Finger server. It
SHOULD reject a message it considers ill-formed with an appropriate
error message.
To summarize, in addition to supporting canonical DNS (user@foo.
example.com) and DECnet (FOO::USER) address forms, a client MAY
support any other syntax, including (perhaps) user- or system-wide
mappings (for example, FOO::ERNIE -> FOO::ERNEST, or even joe@
oldjob.example.com -> Joseph.Lastname(a)otherjob.blah.org). This all
happens in the client, and as a server implementer you don't need
to worry about it at all.
All I'm asking for on the server side is:
1) If acting as a smarthost, remove your node from the command
line (if it wasn't already) and pass it along to the next host.
*** Otherwise ***
2) Support whatever restrictions the server wants as to whether
lists of logged-in users can be provided, whether queries
must match a specific username or can provide a list of users,
decide to show .plan (or site equivalent) data, etc.
3) At the implementations choice, handle unknown qualifiers via
one of these methods (from most preferred to least preferred):
a) Report "Unknown command qualifier /FOO" for each unknown
qualifier, one per line, but return the requested informa-
tion (see the example below).
b) As a) above, except exit without returning any user infor-
mation after reporting errors as in a) above.
c) Silently ignore unknown qualifiers and return output for
the requested information.
4) Implement the qualifier /HELP which will provide (at a mini-
mum) the list of supported qualifiers.
Example of 3a:
$ finger terry@spc11d/wumpus/fuzzy/noxact
[SPC11D.DECnet]
?FINGER - Unrecognized command qualifier '/WUMPUS'.
?FINGER - Unrecognized command qualifier '/FUZZY'.
?FINGER - Unrecognized command qualifier '/NOXACT'.
SPC11D RSTS/E, Monday, 11-Jan-1926 21:25
Job Username PPN Progrm Term Login CPU ST Location
TTType
7 TERRY 20,254 DCL KB0: 01:10 21:38 ^C PiDP-11 Console
VT100
Default directory: _SY0:[20,254]
Logged in since: Monday, 4-Jan-1926 01:11
Mail: (no new mail)
Plan:
Half of "The Bob & Terry Show", 1993-present
What I did in RSX is, what I think, the only
reasonable way to do this
right. So the request would be:
finger spc11d::terry
Which of course is a DECnet request. If you somehow wanted to involve
TCP/IP in this, the format would be
finger spc11d::terry@mim.softjar.se
as an example. And this will work on any system on TCP/IP that talks
finger (could be any Unix host in the world). It do not need to know
or understand anything about DECnet at all. Because it talks TCP/IP,
and it picks the rightmost host after the last @ as the machine to
connect to, and it passes to that the request "spc111d::terry", which
is then up to Mim.SoftJAR.SE to understand and do anything with. Which
boils down to the same DECnet request as the first example above.
The user's Finger client is stripping off the first host (DECnet or
DNS, let's forget about BITNET) and so your:
finger spc11d::terry@mim.softjar.se
gets turned into "open a connection to the finger server on mim.soft-
jar.se and send it the query 'spc11d::terry'". Whether or not it de-
cides to forward that request is an implementation and/or site-specif-
ic determination. As an example, while debugging this with the folks
at FNAL, it was important that their public-facing servers not allow
unrestricted DECnet Fingering of the various internal hosts, some of
which held classified data.
And guess what, here is how it looks on my MAC, right
now:
Gromit:/Users/bqt> finger spc11d::terry@mim.softjar.se
[mim.softjar.se]
[SPC11D::]
SPC Memorial PDP-11/70
SPC11D PDP-11/70, RSTS V10.1-L, Monday, 11-Jan-1926 09:29, 8 Jobs, 63
Max.
Uptime 7 08:54:20, since Monday, 4-Jan-1926 00:35
05-Sep-24 - Your message could be here! Edit FINGER$:FINGER.MSG to
change it.
Job Username PPN Progrm Term Login CPU ST Location TTType
1 SYSTEM 1,2 ERRCPY Det 00:00 SR - Detached -
2 SYSTEM 1,2 MAILQ Det 00:01 SR - Detached -
3 SYSTEM 1,2 OMS Det 00:06 SL - Detached -
4 SYSTEM 1,2 PBS... Det 00:14 SL - Detached -
5 SYSTEM 1,2 EVTLOG Det 00:00 SL - Detached -
6 SYSTEM 1,2 MESMAN Det 00:00 SL - Detached -
7 TERRY 20,254 DCL KB0: 01:10 21:38 ^C PiDP-11 Console
VT100
8 SYSTEM 1,2 FINSRV Det 00:00 RN - Detached -
Gromit:/Users/bqt>
Are you actually seeing blank lines in the output, or is this
just the way this message was formatted?
The implementation stuff as I've described it above is how RSTS/E
Finger currently operates (modulo a few bugs, which I'll fix) and
we can have a DECnet "bake-off" at some point in the future, once
we've settled on a spec.
The point I tried (and failed miserably) to make in earlier emails
is that whatever form of address the user gives the finger client on
their system is immaterial (beyond being something that generally
makes sense to users on that system) but what actually gets send as
a command line to a remote Finger server has to match the canonical
format, as described in the DECnet/E finger draft and (hopefully) as
amended by me above.
So I can actually finger a RSTS/E host from a MAC. How
fun isn't that?
(Don't ask me why I'm not getting information about Terry, though,
because I get the exact same result if I just do a "finger
spc11d::terry" on Mim directly.
I'm going to need to implement logging (as defined in the draft
spec).
More interesting is what I get back when I try fingering MIM::
from SPCPI2:: (running the same finger as SPC11D):
SPCPI2::$ finger mim::
[MIM.DECnet]
Unknown option: /IAM="TERRY~SPCPI2"
User FINGER not found!
SPCPI2::$ finger mim::billquist
[MIM.DECnet]
User BILLQUIST/IAM="TERRY~SPCPI2" not found!
The "/IAM" business I mentioned previously and that needs to go
away (never send, ignore on receipt). But I'm not sure why the
first request is being treated as a request for user "FINGER",
unless my RSTS/E client is mistakenly sending a request that had
the string "FINGER" in it. Johnny, does your server log these
requests?
"finger spc11d::terry" works here from spcpi2:
SPCPI2::$ finger spc11d::terry
[SPC11D.DECnet]
SPC11D RSTS/E, Monday, 11-Jan-1926 21:52
Job Username PPN Progrm Term Login CPU ST Location
TTType
7 TERRY 20,254 DCL KB0: 01:10 21:38 ^C PiDP-11 Console
VT100
Default directory: _SY0:[20,254]
Logged in since: Monday, 4-Jan-1926 01:11
Mail: (no new mail)
Plan:
Half of "The Bob & Terry Show", 1993-present
Maybe an example with VENTI2 would be more fun:
I'm wondering if we're using different end-of-line
characters or something.
Gromit:/Users/bqt> finger
venti2::slogin@mim.softjar.se
[mim.softjar.se]
[VENTI2::]
SLOGIN Thomas DeBellis 8 EMACS 9:58 44 iSnack.Jute:
Development, Larg
9 EXEC 11:55. 45 iSnack.Jute: Logging,
Wide
10 EXEC 10:58. 46 iSnack.Jute:
Secondary Testing
11 SYSDPY 10:02 47 iSnack.Jute: Testing
and Debug
12 EXEC 43:24. 50 Neptune.Jute: STAR
Testing, Sm
14 EXEC **:**. 51
IUUGAA4-Wireless.Jute: Bedroom
15 KERMIT 36:50 52 iSnack.Jute: CKermit
Testing
16 VIKING 23 Batch: Kermit
Loopback Testing
No new mail, last read on Sat 3-Jan-2026 4:12PM
Gromit:/Users/bqt>
It is pretty neat, if I ask me. :-)
Yup. It was wilder when we could add BITNET transport and MS-DOS
Finger servers to the equation. Yes, my MS-DOS Finger server did do
next-hop. At one time I also had Netware as a transport. All long
dead and gone protocols.
If you do this on MIM, it will by default first try to
process DECnet
nodes, so it will take the first node name, up to the first :: as the
node to connect to, and then pass everything after that to the server,
meaning "terry(a)mim.softjar.se" as the query. Now, if spc11d don't talk
TCP/IP, you'll get an error here. But if it do talk TCP/IP, and is
following the RFC, it will understand that query just fine, and should
do the right thing without any funniness.
If you were "on" MIM and not just passing through the finger request,
you'd just say "finger spc11d::terry". If you said "finger
terry(a)mim.soft-
jar.se" you'd get an error unless you actually had a user named terry.
If, on MIM, you actually want
spc11d::terry@mim.softjar.se to be doing the TCP/IP part first, then
you need to add a switch to make it so. And then it will be the same
as any other TCP/IP finger client, and work the same as described in
that bit above. So still all good.
Not sure I follow. But then again, cross-network routing is a more
complicated issue. Let's get the basic DECnet interoperability done
first.
Any other notations will break either the RFC or the
DECnet finger
spec. Now, as I said before, I'm not going to force anyone to change
their code. But I really do find it broken to have code which tries to
decide if something is TCP/IP or DECnet by guessing and some
heuristics. And since the inherent order of hosts are in the opposite
directions in TCP/IP and DECnet, no heuristics in the world can
actually make this actually work right according to the two specs.
You'll have to break compatibility with one or the other protocol.
Just about all of that is in the client, in what it decides to do
with the user's command line (but which it must convert into the stan-
dard format).
"Your client's broken" reports should only pertain to the client
emitting incorrect standard-format commands (which, in the case of
RSTS/E Finger, is doing the unwanted /IAM business).
"Your server's broken" reports can cover a wider range of subjects.
Ideally, I'd like to see other DECnet servers behave about the same
as the RSTS/E one (aside from any breakage I need to fix, like why
Johnny's Finger client can't request info on a specific username and
always gets the "who is logged in" display). The enhancements I sug-
gested above in #1-4 for servers are a request for things which are
mostly optional in the existing implementations. The only MUST from
the above list is #4, implementing /HELP.
Up to everyone of you how you want to look at that.
But I can tell you
that the RSX implementation will continue to try and follow both
specs. So TCP/IP hostnames will never be assumed for a node that ends
with ::, and DECnet nodenames will never be assumed for something that
starts with @. And this is also true for mail. And that is also how
the mail relaying on MIM is doing things, and how you can send mail
from HECnet to the internet by saying
MIM::user@host
And send mail from the internet to hosts on HECnet by
node::user@Mim.SoftJAR.SE
And please be aware that gmail reception is broken, and they don't
accept mails from HECnet because of that. Nothing I can do about it.
gmail basically do not accept mails with a from address in the form of
"node::user"@mim.softjar.se, although it is correct according to RFC
5321. Google apparently don't care that they are violating the RFC.
If Ned Freed was still alive we could sic him on them, but sadly not.
Google has a zillion screwball requirements for mail, many of which are
undocumented. And they don't do anything with spam reports (I think that
abuse@ goes directly into the bitbucket).