Status: 2026-11-21. Read from the PowerPC code of the user's copy (PEF code offsets below; names such as IOSComm::ProcessLine are descriptive, the binary has no symbols). The 68k build is the same source. Facts are from the code unless marked UNVERIFIED. Strings in "quotes" are exact; LF is 0x0A, CR is 0x0D.
Classes: IOSComm (an LThread; vtable data 0xdadc) runs the session; MyTelnet (0x18308) owns the PowerPlant TCP endpoint and a receive buffer; the "Players & Command Window" (PPob 5: player list PLis, output text, command line, buttons Talk To / Observe / Match) handles the buttons in its ListenToMessage at 0xa598; one game window per game number.
- **Every command Eclipse sends ends in LF CR** (bytes 0A 0D; the string literals are "\n\r" in the binary). A server that splits on LF sees each command followed by an empty line that starts with CR; that is the "empty line after each command" seen in the log.
- Received lines are split on LF only. MyTelnet reads byte by byte (0x18698), notes when an LF arrives, and ReadLine (0x18c18) returns bytes up to and including the first LF. IOSComm::ReadLine (0x19bf8) then cuts the line at the first CR or LF. So CR LF and LF both work; a line ended by CR alone is never delivered (it waits for an LF).
- During the login phase (section 2) the client does not read lines: it reads single bytes and echoes each one except LF into the window, so there the CR is what breaks lines on screen.
- Lines longer than about 1000 bytes are cut (buffer 1000).
IOSComm::Run 0x19c70, after connecting:
- Reads single characters and matches three strings anywhere in the byte stream, each with its own counter (a mismatch resets that counter): login:, password:, <ios>.
- On login: it sends the user name + LF CR. On password: it sends the password + LF CR (empty if none was typed). It answers every occurrence, so a server that repeats login: after a refused name gets the same name again, forever.
- **The login phase ends only when <ios> has been seen.** Until then nothing else is sent and no line is parsed.
- Then it sends set trust 1 LF CR and posts 'Updt' to the Players window, which sends who LF CR, empties the player list and adds a placeholder row named -------- (double-clicking that row sends fi --------).
- Main loop: read a line, ProcessLine; repeat. Optional idle rule (a preference): 20 minutes (72000 ticks) after "Your Turn" with no move, it sends resign and quit.
The name is at most 8 characters and is compared case-sensitively with the names in board lines and prompts, so the server must use it exactly as typed.
All end in LF CR.
| when | text | code |
| prompt login: | <name> | 0x19e34 |
| prompt password: | <password> | 0x19eb0 |
| after <ios> | set trust 1 | 0x19ff8 |
| login done ('Updt') | who | 0xb710 |
| double-click a player row | fi <name> (row text up to the first space) | 0xa6bc |
| Match button, dialog OK | match <b> <OTim> <OInc> <ODef> <opponent> <YTim> <YInc> <YDef> <c> | 0xb36c |
| accept dialog for an offer | accept <name> or decline <name> | 0x1adac, 0x1ae10 |
| Talk To + typed text | tell <name> <text> | 0xb4bc, 0x9cf8 |
| command line | the typed text as is (the user typed help) | 0x9cf8 |
| Observe button | ob <n>, or board <n> if a window for game n is already open | 0xb690, 0xb678 |
| click a square on my turn | PM <sq> <value> <time>, %+5.2f %8.2f: PM D3 +0.00 4.27 | 0x735c |
| pass (menu) on my turn | PM ps +0.00 <time> | 0x51a0 |
| Resign (menu) | resign | 0x53a4 |
| close a game window | resign if I play in it, ob <n> if I watch it | 0x1b5cc, 0x1b67c |
| Log off command ('LoOf') / idle rule | quit (idle rule: resign then quit) | 0x161b4, 0x1a06c |
Details:
- match: the format is "match %s %ld %ld %ld %s %ld %ld %ld %s" with, in order: bronstein or an empty string (a checkbox), the opponent's time (minutes), increment (seconds), timeout (seconds), the opponent's name, then my time, increment, timeout, and the colour: b if "I play black" is checked, w if "opponent plays black" is checked, empty otherwise. With both strings empty it looks like match 20 0 120 steve 20 0 120 (two spaces after match, a trailing space). Defaults from the dialog's resource: 20 min, 0 s, 120 s for both.
- PM: sq is 'A' + column and '1' + row (row 1 is the first row of the PB board, see 5.4); value is 0.00 for a human; time is seconds since my turn started.
- ob <n> and board <n>: n comes from the player row's game column (section 5.2); a - there means not playing and nothing is sent.
- Prompt removal: while the line starts with <myname>%, skip strlen(myname) + 2 characters (the name, % and one more, normally a space).
- Empty line: ignored.
- Starts with login: and is longer than 20 characters: finger output, section 5.6.
- Starts with <ios>: look at the character at index 6 (after <ios> ):
- [ and [GAME: game created/ended, 5.3. Other [: connected/disconnected, 5.2.
- PB: board, 5.4.
- MATCH: match offer, 5.5.
- MOVES of GAME: ignored.
- <ios> <name> told...: ignored if a Talk window for <name> is open, else shown.
- anything else: shown in the window.
- Starts with login blitz stand (first 20 characters): who list, 5.1.
- Otherwise find the first of % [ ! ( : in the line:
- % at index 10 or more: the line is dropped. % before index 10: shown unless the line ends within two characters after it.
- [ before index 10 and not preceded by a space, ! before 10, ( before 10 (except a line starting ()|): shown.
- : before index 10: a tell, <name>: <text>; goes to that player's Talk window if one is open, else shown. A line starting ##:() - is ignored.
- none of them: shown, except lines starting A B C D E F G H, | | |... (from index 1), 4 | | | |()|##| | | , 5 | | | |##|()| | | , -> ## (these are dropped; they look like the server's help picture of the start position).
"Shown" means appended to the Players & Command window's text.
Only when the Players window asked for it (its 'Updt' flag; otherwise the same lines are just shown). After the header line:
- One line is read and thrown away.
- Each following line is a row, until a line whose text **after its first space starts with players on** (for example 3 players online). That line ends the list.
- These lines are read without prompt removal. Every row must contain a space: the end test scans for a space without checking for the end of the string, so an empty line inside the list makes it read stale memory.
- A row becomes a list entry of 12 characters: columns 0-7 (the name), a space, and columns 23-25 (the game number, right-aligned, or something ending in - when not playing). Rows are kept sorted by name, case-insensitively, and a second row for the same name only updates the game column.
If the end line never comes, every later line is eaten as a player row.
- <ios> [<name>(<anything>) connected : the first ) must be followed by connected. The name runs from after [ to the (. Adds the row <name> with game column ---.
- <ios> [<name> disconnected : the first space must be followed by disconnected. Removes the row (first 8 characters, case-insensitive).
- With no Players window open they show as Player X Connected / Player X DisConnected.
<ios> [GAME <n> (<black> vs. <white>) (<anything>) <word>
- <n> starts right after [GAME ; the names are read after ( up to the space and after vs. up to ), at most 9 characters each.
- If the text two characters after the second ) is ended, both rows get game column ---; anything else (for example created) sets both rows' game column to <n> (%3ld).
- These lines do not open a game window; only PB lines do.
<ios> PB followed by fields read with sscanf(line_after_PB_space, "%3ld %8s %8s %4ld %4ld %3ld %3ld %3ld %3ld %c %c %2ld %2ld %f %4ld") and 64 board characters at a fixed position: column 78 of the line (72 characters after PB), row by row, 8 per row.
| field | meaning |
| game | game number; indexes Eclipse's window table (keep it small) |
| black, white | names, at most 8 characters |
| tb, tw | seconds used so far by black and white (the window shows h:mm:ss and keeps counting for the side to move) |
| db, dw, ib, iw | timeout and increment, stored, not shown (UNVERIFIED use) |
| colour | * black to move, anything else white to move |
| turn | Y: it is the receiving player's turn (enables clicking and starts the idle clock); else N |
| move no | read, not used for the board |
| move | last move: row * 10 + column with row 1-8 and column 1-8 (A=1), so D3 = 34; -1 = none or pass (no marker) |
| value, time | read, not used |
| cells | * black, O white, - empty; the first 8 are row 1, A to H |
Behaviour: if no window exists for the game number (and memory allows), one opens. If my name (exactly as typed at login) equals black or white I am a player: closing the window sends resign, and I may move when turn is Y. Otherwise I am an observer and closing sends ob <n>. The title becomes Game <n> <black> vs <white>. plus Your Turn. or <name>s turn.. Each PB redraws the whole board. The textual <ios> BOARD of GAME block is not parsed: its lines are just shown (minus the few filtered lines of section 4).
A line that fits (78 characters before the cells):
<ios> PB 12 eric steve 0 0 120 120 0 0 * Y 0 -1 0.00 0---------------------------O*------*O---------------------------
Python: "<ios> PB %3d %-8s %-8s %4d %4d %3d %3d %3d %3d %c %c %2d %2d %6.2f %4d" % (...), then pad or cut to exactly 78 characters, then the 64 cells. Values must fit their widths (times up to 9999 s, the four small fields up to 999).
<ios> MATCH with, counting from the M:
- index 7 is s (stored game), r (rated) or anything else (unrated). A form that works: <ios> MATCH (u) ..., (r) for rated.
- Not stored: everything after the **first ) in the line** is read as %ld %ld %ld %s %s %ld %ld %ld %s = my time (min), my increment (s), my timeout (s), a word, the other player's name, their time, increment, timeout, and a colour word. A colour starting with b shows "You would play white", otherwise "You would play black" (so the colour is the challenger's). **The line must contain a ) before these fields**, or the parse reads from address 1.
- Eclipse then reads the next line (blocking, no prompt removal) and parses "%ld .. %ld %ld %ld .. %ld" starting at column 15 (rating change win/draw/loss). Always send this second line.
- Only if the word is exactly FROM (upper case) does Eclipse show the Accept dialog; OK sends accept <name>, Cancel sends decline <name>. Any other word (an echo of my own offer) is read and ignored.
- Stored game: sscanf(MATCH + 15, "%s %s"), word and name; the same dialog if the word is FROM.
Example pair:
<ios> MATCH (u) 20 0 120 FROM steve 20 0 120 black
20 .. 1 0 -1 .. -20
A reply whose first line starts with login: and is longer than 20 characters is shown line by line until a line starting gio=. Without that end line Eclipse waits for it forever, so either end the reply with a gio= line or do not start it with login:.
<name>: <text> (the : before index 10, nothing from % [ ! ( before it) goes to the Talk window for <name> if open. Anything else is plain text in the main window.
does not understand
- **No <ios> after login.** Eclipse stays in its login phase for the whole session: it never sends set trust 1 or who, parses nothing, and echoes raw characters (so without CR the text ran together). The help and fi -------- lines in the log came from the command line and the placeholder row, which work without the reader.
- Name refused or in use: the adapter writes login: again; Eclipse answers with the same name every time (a loop).
- Who list: no throw-away line after the header (the first player row is lost); the end line N players displayed. does not match players on, so every later line is eaten as a row; columns 23-25 hold 0] and p/- from the rating and flag fields, not a game number, so the Game column and Observe are wrong.
- No <ios> [name(...) connected / <ios> [name disconnected lines, and [GAME lines only go to the two players, so other users (steve at a web table) never appear in the list after login.
- Boards: only the <ios> BOARD of GAME block is sent. Eclipse never opens a game window without PB lines, so it cannot play or watch.
- MATCH line: no ) before the numbers (bad parse), and the word is from, not FROM (no Accept dialog).
- Eclipse's own match: the adapter takes the first word after match as the opponent; Eclipse puts bronstein/nothing and three numbers first, so the opponent comes out as 20. Its colour is b/w, not white/black.
- ob <n>, board <n>, fi <name> are unknown commands (board without a number is known).
- Tells arrive as X tells you: text, which never reaches a Talk window.
- The (told X) acknowledgement is harmless (shown).
- End of login: after a successful login send a line that begins with <ios>, for example <ios> [<name>(-) connected + CR LF (the login matcher consumes <ios>; the rest of the line is shown). Send it before any <ios> [GAME/PB lines of rejoin().
- Refused login: do not prompt login: again in the same connection (Eclipse repeats the same name); write the reason and close, or accept the name. Keep password: as is.
- Line ends: keep CR LF. Keep the name% prompt (Eclipse removes it) but never put it, or an empty line, inside a who list or between a MATCH line and its second line.
- **who reply:**
login blitz stand. G M idle on for from host
----------------------------------------------------
eric [ 0]+( 0) 12 ...
steve [ 0]+( 0) --- ...
2 players online
Rows: name %-8s at 0, then anything without empty lines, with **columns 23-25 = game number %3d or ---**; every row must contain a space. The last line: <count> players online (text after the first space starts with players on). List every player the core knows (IOS sessions, open-table creators, seated players), not only IOS sessions.
- Presence: broadcast to all IOS sessions <ios> [<name>(-) connected when a player appears (IOS login, or a new name in the core's table list) and <ios> [<name> disconnected when one leaves. Broadcast <ios> [GAME <n> (<black> vs. <white>) (unrated) created / ... (unrated) ended to all IOS sessions, not only the two players; keep <n> at 999 or below.
- Boards: send a PB line (5.4) at game start, after every move or pass, on board <n>, and to observers; Y only to the player whose turn it is, N to everyone else; move field row*10+col of the last move or -1; times in seconds used (0 is fine while parlord has no clock). Send the BOARD block only on request from humans (for example a set variable), since Eclipse just prints it. Send [GAME ... created before the first PB.
- Offers: <ios> MATCH (u) <t> <inc> <def> FROM <challenger> <t> <inc> <def> <black|white> followed immediately by <w> .. <w2> <d> <l2> .. <l> (numbers starting at column 15), colour = the challenger's colour. Times: minutes, seconds, seconds.
- **Parse Eclipse's match:** tokens after match: skip bronstein; take the first token that is not a number as the opponent; numbers before it are the opponent's time/inc/timeout, after it the challenger's; a final b means the challenger plays black, w white, none random. Keep the old match <name> [time inc def] [white|black] form for telnet users.
- New commands: ob <n> toggles watching game n (start sending PB lines with N; again stops); board <n> sends one PB for game n; fi <name> returns plain text lines that do not start with login: (or start with login: and end with a line starting gio=). Ignore fi --------.
- Tells: deliver as <sender>: <text> (sender at most 8 characters) so Eclipse routes them to its Talk window; table chat from web players can use the same form.
- Passes and resign: PM ps ... can stay a no-op (the core passes); resign when not playing (Eclipse sends it when a finished game's window is closed) should stay a quiet reply.
- How Eclipse draws the board (which row is at the top) was not traced; the move and marker arithmetic make row 1 of PB the digit 1 consistently (UNVERIFIED on screen).
- What the real IOS printed for these lines is not known beyond what this client accepts; the formats above are what Eclipse accepts, not a copy of IOS.
- db/dw/ib/iw in PB are stored but their use was not traced.
This doc on GitHub
| | These pages cover every ParlorNet server. | Source code | ParlorNet is free software. |