5 Jul
2022
5 Jul
'22
3:17 a.m.
Something like what you mention: open(“/net/inet/any:80”, O_RDWR |
O_STREAM | O_CREAT, 0600), is actually to be found in an RFC from
around that time.
You can do that, but the 1980s tried it and it did not end well.
What's it mean, for example, when you rename("/net/harv") to
("/net/google") -- close and reopen socket? (there's a Lost Talk from,
I think, Rob, that addressed this very question)
While it has its flaws, https://9p.io/sys/doc/net/net.html in my view
is the best example to date of how to get it right. Addresses are
strings, just like paths -- well, they *are* paths in fact. Some of
this path-like nature can be seen in the Go net package today.
Oh, and, as regards how the synthetic file system looks: you never,
never, ever, put an address in the pathname. That's important.
Also consider that if you get it right, you can do all the network IO
you want with cat and echo -- people have written telnet in Plan 9
with those two commands. And, if you get it wrong, well -- you get
socat.
On Mon, Jul 4, 2022 at 1:10 PM Paul Ruizendaal via TUHS <tuhs(a)tuhs.org> wrote:
On Sun, Jul 3, 2022 at 1:33 PM Marc Donner
wrote:
I've been ruminating on the question of whether networks are different from
disks (and other devices). Here are a couple of observations:
[...]
From my perspective most of these things are not unique to networks, they happen with
disks and/or terminals. Only out-of-order delivery seems new. However, in many early
networking contexts (Spider/Arpanet/Datakit/UUCP) this aspect was not visible to the host
(and the same holds for a single segment ethernet).
To me, in some ways networks are like tty’s (e.g. completing i/o can take arbitrarily
long, doing a seek() does not make sense), in other ways they are like disks (raw devices
are organised into byte streams, they have a name space). Uniquely, they have two
end-points, only one of which is local (but pipes come close).
Conceptually, a file system does two things: (i) it organises raw blocks into multiple
files; these are the i-nodes and (ii) it provides a name space; these are directories and
the namei routine. A network stack certainly does the first: a raw network device is
organised into multiple pipe-like connections; depending on the network, it optionally
offers a naming service.
With the first aspect one could refer to any file by “major device number, minor device
number, i-node number”. This is not very different from referring to a network stream by
“network number, host number, port number” in tcp/ip (and in fact this is what bind() and
connect() in the sockets API do), or “switch / host / channel” in Datakit. For disks, Unix
offers a clean way to organise the name spaces of multiple devices into a unified whole.
How to do this with networks is not so easy, prior to the invention of the file system
switch.
Early on (Arpanet Unix), it was tried to incorporate host names into a net directory by
name (RFC 681) but this is not scalable. Another way would be to have a virtual directory
and include only names for active connections. The simple way would be to use a text
version of the numeric name as described above - but that is not much of an improvement.
Better to have a network variant of namei that looks up symbolic names in a hosts file or
in a network naming service. The latter does not look very performant on the hardware of
40 years ago, but it appears to have worked well on the Alto / PuPs network at Xerox
PARC.
With the above one could do
open(“/net/inet/org.tuhs.www:80”, O_RDWR | O_STREAM)
to connect to the TUHS web server, and do
open(“/net/inet/any:80”, O_RDWR | O_STREAM | O_CREAT, 0600)
to create a ‘listening’ (rendez-vous) socket.
Paul