RFC 74
Specifications for Network Use of the UCSB On-Line System
Network Working Group RFC 74, the UCSB On-Line System spec 🎀
okay bestie, RFC 74 is called Specifications for Network Use of the UCSB On-Line System 💖. It was written by J. White from UCSB and dated October 16, 1970 🦋. The header doesn't name a category, and it doesn't obsolete or update anything. Let's get into it ✨
Introduction 🌸
UCSB's On-Line System (OLS) is reachable for Network users at socket number x'101' on site 3 🧚. When you log in, use these OLS account parameters:
USER NUMBER = 196
ID NUMBER = 57372
USER NAME = site name -- UCLA, SRI, UTAH, BBN, MIT, SDC, RAND
-- whichever is appropriateSo users talk to OLS through a middleman process called the Interface 💅. The Interface lives at socket x'101' (the OLS "primary socket") and can be started through the Logger. This doc is for programmers who need to talk to the Interface and want to know what input it takes and what output it sends back. The reader is assumed to already know the Culler-Fried system at UCSB from a user's point of view. This is not a user's manual for OLS, so don't come here for that 🙈
The Interface does all its Network stuff through the NCP, which runs the Host-Host protocol from 3 August 70 🔥. The very first message the Interface sends is Type 0. The first eight bits are zeros, and after that, for the whole life of the connection, IMP-message boundaries don't matter. The Interface does the same thing in reverse: it expects the first message it gets to be Type 0, throws out those first eight zero bits, and then ignores IMP-message boundaries for the rest of the connection 💜
Quick terminology moment ✨. The 360/75 is a 32-bit machine, but its instruction set is byte-oriented. A byte is eight bits, numbered 0-7 from left to right. Words like "listen", "request connection", "accept a connection", and "reject a connection" get used a lot in here to describe the basic Network functions that a user at a foreign site presumably has through their NCP. They're used in the same senses they've usually had in the NWG literature 📚
Logging Into the Interface 🦋
To use the On-Line system, a Network user has to set up a full-duplex connection with the Interface 💖. The Interface only stays in core memory while at least one of those duplex connections exists (so while at least one Network user is connected). The rest of the time it sits on direct-access storage and has to be started through the Logger 😭. You can always start a login by requesting a connection to OLS's primary socket 🎀.
When the Interface is in core, it listens on that socket and accepts any call that comes in. When it isn't, the Logger is the one listening on that socket, and it will reject the first call it gets, load the Interface into core, and dispatch it. After that, the Interface goes back to listening on the primary socket like normal 🌈. So to log in, you request a connection to the primary socket. If it's accepted, you're talking to the Interface. If it's rejected, just send the request again, and once it's accepted you'll be connected to the Interface ✨. If you get rejected a second time, that means the On-Line System is inactive, or the Interface or the NCP has run out of resources 💀.
Over that first connection, the Interface sends eight bits of zeros (that's message type zero), followed by a 32-bit socket number. It picks that socket number from a pool of socket numbers it was given 🧚. Then it closes the connection right away and goes back to listening so other users can log in too 🫶. Next it requests a connection from the local socket whose number was sent to the user, to the foreign socket whose number is one greater than the user's socket. It also requests a connection from the local socket whose number is one greater than the one sent to the other user, to the user's socket 🍓. Once both connections are set up, the Interface considers the user logged in 👑.
Those two connections stay up indefinitely, managed by the Interface 💅. The receive connection (called the "Input Connection") is how the Interface takes input from OLS. The send connection (the "Output Connection") is how it relays OLS displays that were generated in response to that input 🦋. The Interface only tears them down if the On-Line System itself goes down. The user is supposed to close both connections when they're done, which frees up the local sockets for reuse. At that point, the Interface considers the user logged off 🌸.
The Input Connection 💜
Apart from the first two bytes, the Interface treats everything it gets over the Input Connection as one continuous stream of one-byte key codes, which could go on forever 🌈. The Interface passes each key code along without looking at it to the On-Line System, and OLS processes it exactly the same way it would if the key were typed on a keyboard plugged straight into the System ⭐. The valid key codes and how they map to the standard OLS keyboard are shown in Figure 1. The Interface doesn't check whether incoming data is valid, but OLS will catch and drop invalid key codes 🙈.
Normally, the first keys the Network user sends over the Input Connection should be the ones needed to log in to OLS 🫶. A user can log in and out as many times as they want during one Network connection, and the Interface doesn't notice any of that 🔥. The last key sent over the Input Connection should log the user off OLS (SYST DOWN). If you end the Network connection without logging off first, a later Network user could end up finding themselves already logged in 😭. Yikes.
The first byte the Interface receives over the Input Connection gets thrown out without being looked at. The Interface assumes it's zeros, meaning message type zero, which complies with the Host-Host protocol 🧚. IMP-message boundaries mean nothing here. The second byte is not passed to OLS. The Interface does look at it, though, and that's where you get to pick your vibe ✨. By choosing that second byte carefully, the user can have the Interface suppress any or all of the three classes of output that OLS can generate and send back over the Output Connection 💖. The byte is read like this:
Bit 0 = 1: suppress all alphanumeric output.
Bit 1 = 1: suppress all curvilinear output.
Bit 2 = 1: suppress all special character output.
Bits 3-7: not examined, should be zeros.Once you set this, it sticks for the whole life of the Network connection 💅. This is great because you can skip the output classes you can't handle anyway, which saves needless network traffic 🦋. For example, a user on a teletype that can only display alphameric output might send x'60' to suppress everything else 🎀.
Figure 1. Input Key Code Set [Please view PDF version.]
The Output Connection 🌈
Apart from the first byte, everything the Interface sends over the Output Connection is a continuous string of variable-length records 🌸. The very first byte is zeros (message type zero, to comply with the Host-Host protocol), and the user should throw it away 🫶. Right now there are three classes of records defined, one for each class of OLS output: alphameric, curvilinear, and special characters ✨. The only records that get sent are the ones in classes the user has enabled. Anything else gets suppressed locally by the Interface 💜.
Each record has four parts: a one-byte field for the output class, a one-byte output-class-dependent field, a variable-length data field, and a two-byte field holding the combined length in bits (unsigned) of the data field and the output-class-dependent field 🍓. Here's the layout:
1 2 1 L bits
---------------------------------------------------S-----------
|OUT- | | CLASS | |
|PUT | L+8 | DEP. | DATA |
|CLASS | | FIELD | |
---------------------------------------------------S-----------The number above each field is that field's length in bytes, unless it says otherwise 🎀. So the length of a record, in bits, is the value in the length field plus twenty-four 🧚. What each data and class-dependent field means, plus the output class assignments, is covered in the sections for each class below 🦋.
A. Alphameric Output (Class 1) 💖
For alphameric output, the output class field looks like this:
Bits 0-3: unpredictable
Bits 4-7: 0001The contents of the class-dependent field are unpredictable 🙈. The data field holds the alphameric display as a contiguous string of one-byte characters. Any character in Figure 2 can show up. That list includes the Greek and Latin alphabets, a bunch of special symbols, and carriage control characters like carriage return, line feed, backspace, and erase 🌈.
Alphameric output records carry system-generated messages, LIST mode displays, lower keyboard activity on the TYPE level, TYPE level operators like UP and DOWN, and so on ✨. The pair 'BACK ERASE' (x'59BC') in a record is a command to erase the display scope 💅. If BACK isn't immediately followed by ERASE, it means a backspace 🫶. 'BREAK' (x'79') is there to help format long messages that could be going to either a printer or a display scope 🔥. When you're generating scope display, where there are twenty-five characters per line, 'BREAK' should be read as a carriage return 💜. When you're generating printer output, where longer lines are possible, it should be read as a space or blank 🍓.
💖 Figure 2 is the full alphameric character set, so here it is, copied exactly as it appears 🎀
Figure 2. Alphameric Output Character Set 🔥
NAME Lower CODE NAME Upper CODE
Case Case
A C1 ALPHA 81
B C2 BETA 82
C C3 CHI 83
D C4 DELTA 84
E C5 EPSILON 85
F C6 PI 86
G C7 GAMMA 87
H C8 THETA 88
I C9 IOTA 89
J D1 SIGMA 91
K D2 KAPPA 92
L D3 LAMBDA 93
M D4 MU 94
N D5 ETA 95
O D6 OMICRON 96
P D7 PI 97
Q D8 PHI 98
R D9 RHO 99
S E2 SIGMA A2
T E3 TAU A3
U E4 UPSLION A4
V E5 NU A5
W E6 OMEGA A6
X E7 XI A7
Y E8 PSI A8
Z E9 ZETA A9
0 F0 ss 0 B0
1 F1 ss 1 B1
2 F2 ss 2 B2
3 F3 ss 3 B3
4 F4 ss 4 B4
5 F5 ss 5 B5
6 F6 ss 6 B6
7 F7 ss 7 B7
8 F8 ss 8 B8
9 F9 ss 9 B9
NAME CODE NAME CODE
PLUS + 4E UNDERSCORE _ 6D
MINUS - 60 AT SIGN @ 7C
SLASH / 61 POUND SIGN # 7B
APOSTROPHE ' 7D CENT SIGN [cent sign] 4A
LOGICAL AND & 50 DOLLAR SIGN $ 5B
ASTERISK * 5C PERCENT SIGN % 6C
EQUALS = 7E COLON : 7A
SEIM-COLON ; 5E LEFT BRACKET [ 73
LEFT PAREN ( 4D RIGHT BRACKET ] 74
RIGHT PAREN ) 5D LESS THAN < 4C
COMMA , 6B GREATER THAN > 6E
PERIOD . 4B QUOTE " 7F
QUESTION MARK ? 6F LOGICAL NOT [half arrow] 5F
LOGICAL OR | 4F EXCLAMATION ! 5A
Carriage Special List
Control Mode Characters
BACK (backspace) 59 SPACE _ 62
RETURN (carriage 49 POST LIST : 63
return) DIVIDE [0with /] 64
TAB (advance to next 77 MULTIPLY [0 with .] 65
line) SUBTRACT [0 with -] 66
UP (line feed up) 06 ADD [0 with +) 67
ENL (line feed up) 27 CARRIAGE RETURN
DOWN (line feed down) 07 [diagonal left down arrow] 68
DELETE [box with ///] 69
CON (line feed down) 28 Pointer _ 6A
RS (position to 13
upper left of Miscellaneous
display area)
ERASE BC
BREAK (for display 79
scope: RETURN DOT (curvilinear 78
for line display
printer: SPACE) dot-dot mode)
SPACE (blank) 40
Note:
Codes are specified in hexadecimal and are eight bits. 'ss' means
'superscript'B. Curvilinear Output (Class 2) 🦋
okay so for curvilinear output, the output class field is set up like this 💅
- Bits 0-1:
00indicates line segment mode (adjacent display points are to be connected by straight lines)01indicates dot mode10indicates character mode (the class-dependent field contains a character from Figure 2 which is to be displayed at each point ('dot-dot' mode is character mode with the display character 'DOT' (x'78')).
- Bits 2-3:
unpredictable - Bits 4-7:
0010
bestie, for character mode the class-dependent field holds the display character. In every other case, the contents of that field are unpredictable 🙈 The data field is a list of X-Y display coordinates, and it looks like this:
2 2 2 2 2 2
--------------------------------------S----------------------------
| X1 | Y1 | X2 | Y2 | ... | Xn | Yn |
--------------------------------------S----------------------------So Xi and Yi are the X and Y display coordinates (after scaling) of the ith component of the vector this record represents ✨ Each coordinate gets a two-byte field, so one component is four bytes. That means the context of the vector being displayed is given by the contents of the length field minus eight divided by thirty-two 🧚 The assumed display area is square, with the original at lower left, and both X and Y range between 0 and 4095. Lowkey the best part is that there is a one-to-one correspondence between vectors displayed and curvilinear output records transmitted 👑
C. Special Character Output (Class 3) ✨
For special character output, the output class field looks like this:
- Bits 0-3:
unpredictable - Bits 4-7:
0011
The contents of the class-dependent field are unpredictable 💀 The data field is a contiguous string of variable-length characters. Each one represents either a move in one of sixteen directions, or a change in position relative to the lower right corner of the last character frame (where for alphameric and special character display, the display area is square, 4096 units in extent vertically and horizontally, and a character frame is 160 units wide and 224 units high).
The sixteen characters that define move operations are listed in Figure 3, and each one is one byte long 🌸 Such a character indicates a move from the current position, in the specified direction, a distance equal to that of a move in the same direction from the center of a 64-unit square to its perimeter. So the length of the move is functionally related to its direction. It's giving math with a vibe 🦋
A change in position relative to the lower right corner of the last character frame is represented by a four-byte character of this form:
1 12 bits 12 bits
-----------------------------------------------
| x'70' | [delta] X | [delta] Y |
-----------------------------------------------Here [delta] X and [delta] Y are signed quantities, showing the number of units of change along each coordinate 🍓
Figure 3. Special Character Vector Character Set 🌈
Direction Code
000.0 47
022.5 48
045.0 51
067.5 52
090.0 53
112.5 54
135.0 55
157.5 56
180.0 57
202.5 58
225.0 41
247.5 42
270.0 43
292.5 44
315.0 45
337.5 46Note: Codes are specified in hexadecimal and are eight bits.
Directions are specified in degrees, increasing counter-clockwise from 0o at positive X in an X-Y coordinate system. Iconic behaviour 😭
- Text enclosed in brackets describe non-ascii characters that were present in the original document. Please see the PDF file for the actual representations. 🫶
📦 where this page comes from
- ietf: rfc74 1970-10
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms