<<>>
    <<TelnetViewerImpl.mesa>>
        <<Copyright Ó 1987, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Wes Irish, October 4, 1991 4:43 pm PDT>>
        <<Michael Plass, May 20, 1992 2:47 pm PDT>>
        <<Last tweaked by Mike Spreitzer April 14, 1992 12:57 pm PDT>>

        <<Originally created by Wes Irish with the name TelnetImpl.mesa>>

    DIRECTORY
        Atom USING[ MakeAtom ],
        Ascii,
        Commander USING [CommandProc, Register],
        CommanderOps,
        Convert,
        EditedStream,
        IO,
        Menus USING [AppendMenuEntry, ChangeNumberOfLines, CreateEntry, FindEntry, MenuEntry, MenuProc, ReplaceMenuEntry],
        MessageWindow USING [Append],
        NetworkName,
        NetworkStream,
        Process USING [Abort, Detach, EnableAborts, PauseMsec],
        Rope,
        TelnetCommands,
        TelnetOptions,
        TiogaOps USING [GetCaret, GetRope, Location],
        TIPLinking,
        TIPUser USING [InstantiateNewTIPTable, TIPTable],
        TypeScript USING [BackSpace, ChangeLooks],
        <<UserCredentials USING [Get, GetIdentity, Identity],>>
        UserProfile USING [Boolean, ListOfTokens, Token],
        ViewerClasses USING [MouseButton, Viewer],
        ViewerEvents USING[ EventProc, EventRegistration, RegisterEventProc, UnRegisterEventProc],
        ViewerIO USING [CreateViewerStreams, GetViewerFromStream, Viewer],
        ViewerOps USING [AddProp, BlinkViewer, ComputeColumn, FetchProp, FetchViewerClass, PaintViewer],
        ViewerTools USING [GetSelectionContents];

    TelnetViewerImpl: CEDAR MONITOR
        LOCKS h USING h: Handle
        IMPORTS Atom, Commander, CommanderOps, Convert, EditedStream, IO, Menus, MessageWindow, NetworkName, NetworkStream, Process, Rope, 
        TiogaOps, TIPLinking, TIPUser, TypeScript, <<UserCredentials,>> UserProfile, ViewerEvents, ViewerIO, ViewerOps, ViewerTools
        ~ {

        ROPE: TYPE ~ Rope.ROPE;
        STREAM: TYPE ~ IO.STREAM;

        telnetPort: CARDINAL ~ <<ArpaPortRegistry.TCPPORT.telnet.ORD>> 23;

        toolName: ROPE = "Telnet";
        telnetProp: ATOM = Atom.MakeAtom["TelnetProp"];

        documentationRope: ROPE ~ "[-p port] [-l] [-d] host\nTelnet\nSwitches:\n    -p  port number\n    -l  auto login\n    -d  do not 
        auto login";

        defaultEolSeq: ROPE ~ "\r\l";  -- <CR><LF>

        Direction: TYPE ~ IO.StreamVariety[input..output];
        Handle: TYPE ~ REF Object;
        Object: TYPE ~ MONITORED RECORD [
            keyboardStream: STREAM Ź NIL,
            viewerStream: STREAM Ź NIL,
            networkStream: ARRAY Direction OF STREAM Ź ALL[NIL],
            hostName: ROPE Ź NIL,
            state: State Ź disconnected,
            port: CARD Ź telnetPort,
            how: How Ź command,
            autoLogin: BOOL Ź FALSE,
            pusher: PROCESS Ź NIL,
            puller: PROCESS Ź NIL,
            optionsWatcher: PROCESS Ź NIL,
            nvtState: NVTState,
            negotiationEvent: CONDITION,
            lineBuffered: BOOL Ź TRUE,
            localEcho: BOOL Ź TRUE,
            heSendsGoAheads: BOOL Ź TRUE,
            sendGoAheads: BOOL Ź TRUE,
            gotGA: BOOL Ź TRUE,  -- it's not clear what to start with
            extraWills: CARD Ź 0,
            extraDos: CARD Ź 0,
            eolSeq: ROPE Ź defaultEolSeq,
            typescriptBackground: PROCESS Ź NIL,
            destructionEvent: ViewerEvents.EventRegistration,
            trace: TraceBuffer
            ];

        TraceBuffer: TYPE ~ REF TraceBufferRep;
        TraceBufferRep: TYPE ~ RECORD [
            first: NAT,
            next: NAT,
            buf: PACKED SEQUENCE size: NAT OF TraceBufferEntry
            ];

        TraceBufferEntry: TYPE ~ PACKED RECORD [
            side: Side,
            char: CHAR
            ];

        Trace: ENTRY PROC [h: Handle, side: Side, char: CHAR] ~ { TraceInternal[h, side, char] };

        TraceInternal: INTERNAL PROC [h: Handle, side: Side, char: CHAR] ~ {
            trace: TraceBuffer ~ h.trace;
            IF trace # NIL AND trace.size > 1 THEN {
            next: NAT Ź trace.next MOD trace.size;
            trace[next] Ź [side, char];
            trace.next Ź (next + 1) MOD trace.size;
                IF trace.first = trace.next THEN trace.first Ź (trace.first + 1) MOD trace.size;
                };
            };

        GetTrace: ENTRY PROC [h: Handle] RETURNS [t: TraceBuffer] ~ {
            t Ź h.trace;
            h.trace Ź NEW[TraceBufferRep[256]];
            };

        NVTState: TYPE ~ ARRAY CHAR OF OptionState;
        OptionState: TYPE ~ PACKED RECORD [
            desiredOfMySide: BOOL Ź FALSE,
            stateOfMySide: NegotiationState Ź inactive,
            desiredOfHisSide: BOOL Ź FALSE,
            stateOfHisSide: NegotiationState Ź inactive
            ];
        NegotiationState: TYPE ~ {inactive, requested, active};
        Side: TYPE ~ {mySide, hisSide};

        FuncMenuData: TYPE ~ REF FuncMenuDataObject;
        FuncMenuDataObject: TYPE ~ RECORD [
            name: ROPE,
            value: ROPE,
            handle: Handle
            ];

        procLine: INT Ź 0;
        funcLine: INT Ź 1;


        pushMeansFlush: BOOL Ź FALSE;  -- possible semantics problem with ArpaTCP.SendNow not setting the push bit (but IO.Flush waits for 
        acks, ugh...)

        openTimeout: NetworkStream.Milliseconds Ź NetworkStream.waitForever;

        State: TYPE ~ { disconnected, connecting, connected, disconnecting };
        How: TYPE ~ { command, connect, login, lfKey };
        Worker: TYPE ~ { none, pusher, puller };
        CloseAction: TYPE ~ { none, initiate, reply };


        TelnetMain: Commander.CommandProc
            <<[cmd: Commander.Handle] RETURNS [result: REF, msg]>>
            ~ {
            h: Handle;
            argv: CommanderOps.ArgumentVector;
            argv Ź CommanderOps.Parse[cmd
                ! CommanderOps.Failed => { msg Ź errorMsg; result Ź $Failure; CONTINUE }];
            IF argv = NIL THEN RETURN;
            h Ź NEW[Object];
            TRUSTED {
                Process.EnableAborts[@(h.negotiationEvent)];
                };
            msg Ź ProcessArgs[h, argv];
            IF msg # NIL THEN { result Ź $Failure; RETURN };
            TelnetMainInternal[h];
            };

        TelnetMainInternal: PROC [h: Handle]
            ~ {
            v: ViewerClasses.Viewer;
            [h.keyboardStream, h.viewerStream] Ź ViewerIO.CreateViewerStreams[name~toolName, <<backingFile~Rope.Concat[toolName, ".log"],>> 
            editedStream~FALSE];
            v Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            v.tipTable Ź telnetTIPTable;
            EditedStream.SetEcho[h.keyboardStream, NIL];
            TypeScript.ChangeLooks[v, 'f];
            AddMenuButtons[h];
            ViewerOps.AddProp[v, telnetProp, h];
            h.destructionEvent Ź ViewerEvents.RegisterEventProc[proc: NoteDestruction, event: destroy, filter: v, before: TRUE];
            <<-- hack to do "connect" from command line...>>
            TRUSTED {Process.Detach[h.typescriptBackground Ź FORK TypescriptWatcher[h]]};
            IF Rope.Length[h.hostName] > 0 THEN
                TRUSTED {Process.Detach[FORK DoConnect[h]]};
            RETURN;
            };

        AddMenuButtons: PROC [h: Handle] ~ {
            v: ViewerClasses.Viewer;
            v Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            AddButton[h, "Another", AnotherProc, "Create another instance of this tool."];
            AddButton[h, "Disconnect", DoDisconnect, "Close connection."];
            IF UserProfile.Boolean[Rope.Concat[toolName, ".LoginButton"], TRUE] THEN
                AddButton[h, "Login", LoginProc, "Open connection to selected host and login."];
            AddButton[h, "Connect", ConnectProc, "Open connection to selected host."];
            AddButton[h, "Break", DoSendBreak, "Send a Break code"];
            AddButton[h, "Synch", DoSynch, "Telnet Synch operation"];
            AddButton[h, "Interrupt", DoInterrupt, "Telnet Interrupt operation"];
            AddButton[h, "FlushLog", FlushLogProc, "Flush the typescript log to the backing file."];
            AddButton[h, "ShowOptions", ShowOptionsProc, "Show the current options state."];
            IF AddFunctions[h]
                THEN {
                    ViewerOps.ComputeColumn[v.column];
                    ViewerOps.PaintViewer[v, all];
                    }
                ELSE ViewerOps.PaintViewer[v, menu];
            };

        ProcessArgs: PROC [h: Handle, argv: CommanderOps.ArgumentVector]
        RETURNS [msg: ROPE Ź NIL] ~ {
            i: INT Ź 1;
            h.autoLogin Ź UserProfile.Boolean[Rope.Concat[toolName, ".AutoLogin"], FALSE];
            WHILE i < argv.argc DO
                len: INT ~ Rope.Length[argv[i]];
                IF len = 0 THEN { msg Ź "Null argument"; GOTO Bad };
                IF Rope.Fetch[argv[i], 0] = '-
                    THEN {
                        IF len = 1 THEN { msg Ź "Bad flag"; GOTO Bad };
                        SELECT Rope.Fetch[argv[i], 1] FROM
                            'p => {
                                i Ź i.SUCC; IF i >= argv.argc THEN GOTO Bad;
                                h.port Ź Convert.CardFromRope[argv[i]
                                    ! Convert.Error => {msg Ź "Bad Port Number"; GOTO Bad;}];
                                };
                            'l => {
                                h.autoLogin Ź TRUE;
                                };
                            'd => {
                                h.autoLogin Ź FALSE;
                                };
                            ENDCASE => { msg Ź "Bad flag"; GOTO Bad };
                        }
                    ELSE {
                        IF h.hostName # NIL THEN { msg Ź "Multiple hosts"; GOTO Bad };
                        h.hostName Ź argv[i];
                        };
                i Ź i.SUCC;
                ENDLOOP;
            EXITS
                Bad => NULL;
            };

        AddFunctions: PROC [h: Handle] RETURNS [someAdded: BOOL Ź FALSE] ~ {
            v: ViewerIO.Viewer Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            fName, fValue: ROPE;
            fButtons: LIST OF ROPE Ź UserProfile.ListOfTokens[Rope.Concat[toolName, ".FunctionButtons"]];
            IF fButtons = NIL OR fButtons.rest = NIL THEN RETURN;
            Menus.ChangeNumberOfLines[v.menu, funcLine+1];
            WHILE fButtons # NIL DO
                IF fButtons.rest = NIL THEN RETURN; -- odd number of TOKENs, not a pair
                fName Ź fButtons.first;
                fValue Ź fButtons.rest.first;
                IF Rope.Length[fName] = 0 THEN LOOP;  -- button has no name -> ignore it
                AddFuncButton[h, fName, fValue];
                someAdded Ź TRUE;
                fButtons Ź fButtons.rest.rest;
                ENDLOOP;
            };

        AddFuncButton: PROC [h: Handle, name, val: ROPE] ~ {
            v: ViewerIO.Viewer Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            IF v = NIL THEN RETURN;
            Menus.AppendMenuEntry[v.menu, Menus.CreateEntry[name, FunctionProc, NEW[FuncMenuDataObject Ź [name, val, h]]], funcLine];
            };

        AddButton: PROC [h: Handle, name: ROPE, proc: Menus.MenuProc, doc: ROPE, fork: BOOL Ź TRUE] ~ {
            v: ViewerIO.Viewer Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            IF v = NIL THEN ERROR;
            Menus.AppendMenuEntry[v.menu, Menus.CreateEntry[name, proc, h, doc, fork], procLine];
            };

        PutMsg: PROC [h: Handle, fmt: ROPE, msg: ROPE Ź NIL] ~ {
            ENABLE IO.Error => CONTINUE;
            s: STREAM ~ h.viewerStream;
            IF (s # NIL) THEN IO.PutF1[s, fmt, IF msg # NIL THEN [rope[msg]] ELSE [null[]]];
            };

        SetConnecting: ENTRY PROC [h: Handle] RETURNS [ok: BOOL] ~ {
            ENABLE UNWIND => NULL;
            IF h.state = disconnected
                THEN {
                    h.state Ź connecting;
                    RETURN [TRUE];
                    }
                ELSE { RETURN [FALSE] };
            };

        SetConnected: ENTRY PROC [h: Handle] ~ {
            ENABLE UNWIND => NULL;
            v: ViewerIO.Viewer = ViewerIO.GetViewerFromStream[h.viewerStream];
            h.state Ź connected;
            v.name Ź Rope.Cat[toolName, ": ", h.hostName];
            ViewerOps.PaintViewer[viewer: v, hint: caption];
            };

        SetDisconnecting: ENTRY PROC [h: Handle] RETURNS [ok: BOOL] ~ {
            ENABLE UNWIND => NULL;
            IF h.state = connected
                THEN {
                v: ViewerIO.Viewer = ViewerIO.GetViewerFromStream[h.viewerStream];
                h.state Ź disconnecting;
                v.name Ź Rope.Cat[toolName, " closing connection to: ", h.hostName];
                ViewerOps.PaintViewer[viewer: v, hint: caption];
                RETURN [TRUE];
                }
                ELSE { RETURN [FALSE] };
            };

        SetDisconnected: ENTRY PROC [h: Handle] ~ {
            ENABLE UNWIND => NULL;
            v: ViewerIO.Viewer = ViewerIO.GetViewerFromStream[h.viewerStream];
            h.state Ź disconnected;
            v.name Ź toolName;
            ViewerOps.PaintViewer[viewer: v, hint: caption];
            PutMsg[h, "\n~~~~~~~~ Connection Closed ~~~~~~~~\n\n"];
            };

        IsSep: PROC [c: CHAR] RETURNS [BOOL] = {
            IF c IN [Ascii.NUL..Ascii.SP) OR c = Ascii.DEL THEN RETURN[TRUE];
            RETURN[FALSE];
            };

        FindHostName: PROC [h: Handle] RETURNS [ROPE] ~ {
            hostName: ROPE Ź ViewerTools.GetSelectionContents[];
            SELECT h.how FROM
                command => RETURN[h.hostName];
                connect, login => RETURN[hostName];
                lfKey => RETURN[FindHostFromCaret[]];
                ENDCASE;
            RETURN[NIL];
            };

        FindHostFromCaret: PROC RETURNS [hostName: ROPE] ~ {
            caret: TiogaOps.Location;
            i: INT;
            caret Ź TiogaOps.GetCaret[];
            hostName Ź TiogaOps.GetRope[caret.node];
            i Ź caret.where;
            WHILE i > 0 DO
                char: CHAR = Rope.Fetch[hostName, i.PRED];
                IF IsSep[char] THEN EXIT;
                i Ź i.PRED;
                ENDLOOP;
            hostName Ź Rope.Substr[hostName, i, (caret.where - i)];
            };

        NoteDestruction: ViewerEvents.EventProc = {
            h: Handle Ź NARROW[ViewerOps.FetchProp[viewer, telnetProp]];
            IF event = destroy AND h # NIL THEN NoteDestructionInternal[h];
            };

        NoteDestructionInternal: PROC [h: Handle] = {
            ENABLE UNWIND => NULL;
            IF h # NIL THEN {
                TRUSTED {Process.Abort[h.typescriptBackground]};
                FinishConnection[h~h, me~none, msg~"Disconnecting.", closeAction~initiate];
                ViewerEvents.UnRegisterEventProc[h.destructionEvent, destroy];
                };
            };

        ReplaceAndRepaintMenuEntry: PROC [v: ViewerIO.Viewer, old: Menus.MenuEntry, new: Menus.MenuEntry] = {
            Menus.ReplaceMenuEntry[ v.menu, old, new];
            ViewerOps.PaintViewer[v, menu];
            };

        FunctionProc: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            md: FuncMenuData Ź NARROW[clientData];
            h: Handle Ź md.handle;
            v: ViewerIO.Viewer Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            SELECT TRUE FROM
                ~shift AND ~control => InterpretAndSend[h, md.value];
                shift AND ~control => {
                    me: Menus.MenuEntry;
                    selection: ROPE Ź ViewerTools.GetSelectionContents[];
                    IF mouseButton # yellow AND Rope.Length[selection] = 0 THEN {
                        MessageWindow.Append["Select something first.", TRUE];
                        RETURN;
                        };
                    SELECT mouseButton FROM
                        red => md.value Ź selection;
                        yellow => MessageWindow.Append[IO.PutFR["Function: \"%g\" = \"%g\"", [rope[md.name]], [rope[md.value]]], TRUE];
                        blue => {
                            IF Menus.FindEntry[parent.menu, selection] # NIL THEN {
                                MessageWindow.Append["That name alreay in use!", TRUE];
                                RETURN;
                                };
                            me Ź Menus.FindEntry[parent.menu, md.name];
                            md.name Ź selection;
                            TRUSTED {
                                Process.Detach[FORK
                                    ReplaceAndRepaintMenuEntry[ parent, me, Menus.CreateEntry[md.name, FunctionProc, NEW[FuncMenuDataObject Ź [md.name, md.value, 
                                    h]]]]]};
                            };
                        ENDCASE;
                    };
                control => {
                    me: Menus.MenuEntry;
                    selection: ROPE Ź ViewerTools.GetSelectionContents[];
                    IF mouseButton # yellow AND Rope.Length[selection] = 0 THEN {
                        MessageWindow.Append["Select something first.", TRUE];
                        RETURN;
                        };
                    SELECT mouseButton FROM
                        red => {
                            IF Rope.Length[selection] > 32 THEN {
                                MessageWindow.Append["Button name too long!", TRUE];
                                RETURN;
                                };
                            IF Menus.FindEntry[parent.menu, selection] # NIL THEN {
                                MessageWindow.Append["That name alreay in use!", TRUE];
                                RETURN;
                                };
                            Menus.AppendMenuEntry[parent.menu, Menus.CreateEntry[selection, FunctionProc, NEW[FuncMenuDataObject Ź [selection, "", h]]], 
                            funcLine];
                            MessageWindow.Append[IO.PutFR1["Added function button: \"%g\"", [rope[selection]]], TRUE];
                            };
                        yellow => MessageWindow.Append[IO.PutFR["Function: \"%g\" = \"%g\"", [rope[md.name]], [rope[md.value]]], TRUE];
                        blue => {
                            me Ź Menus.FindEntry[parent.menu, md.name];
                            MessageWindow.Append[IO.PutFR1["Deleting function button: \"%g\"", [rope[md.name]]], TRUE];
                            TRUSTED {
                                Process.Detach[FORK
                                    ReplaceAndRepaintMenuEntry[parent, me, NIL]]};
                            };
                        ENDCASE;
                    };
                ENDCASE;
            ViewerOps.PaintViewer[v, menu];
            };

        ConnectProc: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF NOT SetConnecting[h] THEN {
                ViewerOps.BlinkViewer[parent];
                MessageWindow.Append["Can't connect: viewer is busy", TRUE];
                RETURN;
                };
            h.how Ź connect;
            h.autoLogin Ź FALSE;
            TRUSTED {Process.Detach[FORK DoConnect[h]]};
            };

        LoginProc: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF NOT SetConnecting[h] THEN {
                ViewerOps.BlinkViewer[parent];
                MessageWindow.Append["Can't connect: viewer is busy", TRUE];
                RETURN;
                };
            h.how Ź login;
            h.autoLogin Ź TRUE;
            TRUSTED {Process.Detach[FORK DoConnect[h]]};
            };

        TryToConnect: PROC [h: Handle, autoLogin: BOOL Ź FALSE] = {
            IF NOT SetConnecting[h] THEN {
                MessageWindow.Append["Can't connect: viewer is busy", TRUE];
                RETURN;
                };
            h.how Ź lfKey;
            h.autoLogin Ź autoLogin;
            TRUSTED {Process.Detach[FORK DoConnect[h]]};
            };

        DoConnect: PROC [handle: Handle] = {
            v: ViewerIO.Viewer = ViewerIO.GetViewerFromStream[handle.viewerStream];
            hisName: ROPE Ź NIL;
            hisAddress: ROPE Ź NIL;
        openError: ROPE Ź NIL;
            [] Ź SetConnecting[handle];
            {
                hisName Ź FindHostName[handle];
                IF Rope.IsEmpty[hisName] THEN {
                    PutMsg[handle, "\n\nConnect: please select host name\n\n"];
                    GOTO Out };
                PutMsg[handle, "\nOpening connection to "];
                PutMsg[handle, "\"%g\"", hisName];
                v.name Ź IO.PutFR["%g opening connection to %g", [rope[toolName]], [rope[hisName]]];
                ViewerOps.PaintViewer[viewer: v, hint: caption];
                hisAddress Ź NetworkName.AddressFromName[family: $ARPA, name: hisName, portHint: Convert.RopeFromCard[handle.port], components: 
                hostAndPort ! NetworkName.Error => {openError Ź msg; CONTINUE}].addr;
                IF hisAddress = NIL THEN {
                    PutMsg[handle, Rope.Concat["... address lookup failure: ", openError]];
                    GOTO Out };
                PutMsg[handle, " at \"%g\" ", hisAddress];
                v.name Ź IO.PutFR["%g opening connection to %g at %g", [rope[toolName]], [rope[hisName]], [rope[hisAddress]]];
                ViewerOps.PaintViewer[viewer: v, hint: caption];
                <<IO.PutF1[handle.viewerStream, "%g ", [rope[ConvertExtras.RopeFromArpaAddress[hisAddress]]]];>>
                <<IF handle.port # telnetPort THEN IO.PutF1[handle.viewerStream, "(port %g) ", [cardinal[handle.port]]];>>
                <<IO.PutRope[handle.viewerStream, "... "];>>
                handle.hostName Ź hisName;
            <<tcpInfo _ [>>
            <<matchForeignAddr: TRUE,>>
            <<foreignAddress: hisAddress,>>
            <<matchForeignPort: TRUE,>>
            <<foreignPort: handle.port,>>
            <<active: TRUE,>>
            <<timeout: openTimeout,>>
            <<matchLocalPort: FALSE];>>
            [in: handle.networkStream[input], out: handle.networkStream[output]] Ź NetworkStream.CreateStreams[protocolFamily: $ARPA, remote: 
            hisAddress, transportClass: $TCP, timeout: 15000!
            NetworkStream.Error => {
            openError Ź msg;
            CONTINUE;
            };
            NetworkStream.Timeout => {
            openError Ź msg;
            CONTINUE;
            };
            ];
            <<IF openError = NIL THEN openError _ WaitUntilConnected[handle];>>
                IF openError # NIL THEN {
                    PutMsg[handle, "open failed: %g\n\n", openError];
                    GOTO Out;
                    };
                PutMsg[handle, "connected.\n\n"];
                SetConnected[handle];
                SetInitialDesiredOptions[handle];
                RunConnection[handle];
                EXITS
                    Out => NULL;
                };
            SetDisconnected[handle];
            };

        << WaitUntilConnected: PROC [h: Handle] RETURNS [error: ROPE] ~ {
            <<Yuck!  ArpaTCP.CreateTCPStream returns an "open" connection without ever hearing from the other end.  We'd like to make sure the 
            remote end is there before telling the user "connected".>>
            state: ArpaTCPOps.ConnectionState;
            tcpHandle: ArpaTCPOps.TCPHandle Ź NARROW[h.networkStream.streamData];
            DO
                state Ź tcpHandle.state;
                SELECT state FROM
                    synSent => Process.Pause[1];
                    synRcvd, established => RETURN[NIL];
                    ENDCASE => RETURN["unable to establish connection"];
                ENDLOOP;
            }; >>

        TypescriptWatcher: PROC [h: Handle] = {
            v: ViewerClasses.Viewer Ź ViewerIO.GetViewerFromStream[h.viewerStream];
            c: CHAR;
            {
                ENABLE {
                    IO.EndOfStream, ABORTED, IO.Error => GOTO done;
                    };
                DO
                    DO
                        IF h.state = disconnected
                            THEN EXIT
                            ELSE Process.PauseMsec[1500];
                        ENDLOOP;
                    IF IO.CharsAvail[h.keyboardStream, FALSE] = 0 THEN {
                        Process.PauseMsec[250];
                        LOOP;
                        };
                    c Ź IO.GetChar[h.keyboardStream];
                    SELECT c FROM
                        Ascii.LF => TryToConnect[h, FALSE];
                        Ascii.FF => TryToConnect[h, TRUE];
                        Ascii.BS => TypeScript.BackSpace[v];
                        ENDCASE => IO.PutChar[h.viewerStream, c];
                    ENDLOOP;
                };
            EXITS
                done => NULL;
            };

        SetInitialDesiredOptions: ENTRY PROC [h: Handle] ~ {
            OPEN TelnetOptions;
            ENABLE UNWIND => NULL;
            h.nvtState[echo].desiredOfHisSide Ź TRUE;
            h.nvtState[suppressGoAhead].desiredOfHisSide Ź TRUE;
            h.nvtState[suppressGoAhead].desiredOfMySide Ź TRUE;
            };

        NegotiateInitialOptions: PROC [h: Handle] ~ {
            IF NOT NegotiateOption[h, TelnetOptions.echo, hisSide] THEN {
            <<He refuses to echo, so set expectations differently...>>
                [] Ź DeactivateOption[h, TelnetOptions.echo, hisSide];
                [] Ź NegotiateOption[h, TelnetOptions.echo, mySide];
                };
            FOR option: CHAR IN [0C..377C] DO
                IF h.nvtState[option].desiredOfMySide THEN [] Ź NegotiateOption[h, option, mySide];
                IF h.nvtState[option].desiredOfHisSide THEN [] Ź NegotiateOption[h, option, hisSide];
                ENDLOOP;
            };

        RopeFromNVTState: ENTRY PROC [h: Handle] RETURNS [rope: ROPE] ~ {
            ENABLE UNWIND => NULL;
            FOR option: CHAR IN [0C..377C] DO
                optionState: OptionState Ź h.nvtState[option];
                thisRope: ROPE;
                IF optionState.desiredOfMySide
                    OR optionState.stateOfMySide # inactive
                    OR optionState.desiredOfHisSide
                    OR optionState.stateOfHisSide # inactive
                    THEN {
                        optionRope: ROPE Ź RopeFromOption[option];
                        IF optionRope # NIL
                            THEN thisRope Ź IO.PutFR["Option: %g (%g)", [rope[optionRope]], [cardinal[option-'\000]]]
                            ELSE thisRope Ź IO.PutFR1["Option: %g", [cardinal[option-'\000]]];
                        thisRope Ź Rope.Concat[thisRope, IO.PutFR["\n    mySide[desired: %g, state: %g]", [boolean[optionState.desiredOfMySide]], 
                        [rope[RopeFromNegotiationState[optionState.stateOfMySide]]]]];
                        thisRope Ź Rope.Concat[thisRope, IO.PutFR["\n    hisSide[desired: %g, state: %g]", [boolean[optionState.desiredOfHisSide]], 
                        [rope[RopeFromNegotiationState[optionState.stateOfHisSide]]]]];
                        rope Ź Rope.Cat[rope, thisRope, "\n"];
                        };
                ENDLOOP;
            };

        RopeFromOption: PROC [option: CHAR] RETURNS [ROPE] ~ {
            OPEN TelnetOptions;
            RETURN[SELECT option FROM
                transmitBinary => "transmitBinary",
                echo => "echo",
                suppressGoAhead => "suppressGoAhead",
                status => "status",
                timingMark => "timingMark",
                terminalType => "terminalType",
                endOfRecord => "endOfRecord",
                outMrk => "outMrk",
                naws => "naws",
                terminalSpeed => "terminalSpeed",
                toggleFlowControl => "toggleFlowControl",
                extendedOptionsList => "extendedOptionsList",
                ENDCASE => NIL];
            };

        RopeFromNegotiationState: PROC [state: NegotiationState] RETURNS [ROPE] ~ {
            RETURN[SELECT state FROM
                inactive => "inactive",
                active => "active",
                requested => "requested",
                ENDCASE => ERROR];
            };

        RunConnection: PROC [h: Handle] ~ {
            TRUSTED {
                h.optionsWatcher Ź FORK OptionsWatcher[h];
                h.pusher Ź FORK Pusher[h];
                h.puller Ź FORK Puller[h];
                NegotiateInitialOptions[h
                    ! IO.EndOfStream, IO.Error, NetworkStream.Error, NetworkStream.Timeout, ABORTED => CONTINUE];
                JOIN h.pusher; h.pusher Ź NIL;
                JOIN h.puller; h.puller Ź NIL;
                Process.Detach[h.optionsWatcher];
                Process.Abort[h.optionsWatcher];
                h.optionsWatcher Ź NIL;
                };
            CloseNetworkStreams[h];
            };

        CloseNetworkStreams: PROC [h: Handle] ~ {
            FOR d: Direction IN Direction DO
                IO.Close[h.networkStream[d] ! IO.Error => CONTINUE];  -- probably already closed
                ENDLOOP;
            };

        SendEndOfMessage: PROC [s: STREAM] ~ Push;

        Push: PROC [s: STREAM] ~ {
            IF pushMeansFlush
                THEN IO.Flush[s]
                ELSE NetworkStream.SendSoon[s];
            };

        FinishConnection: PROC [h: Handle, me: Worker, msg: ROPE Ź NIL, closeAction: CloseAction Ź none] ~ {
            IF SetDisconnecting[h] THEN {
                IF me # pusher THEN TRUSTED { Process.Abort[h.pusher] };
                IF me # puller THEN TRUSTED { Process.Abort[h.puller] };
                IF msg # NIL THEN PutMsg[h, "\n\n~~~~~~~~ %g ~~~~~~~~\n", msg];
                SELECT closeAction FROM
                    initiate, reply => CloseNetworkStreams[h];
                    ENDCASE;
                };
            };

        SplitGvName: PUBLIC PROC[name: ROPE] RETURNS[sn, reg: ROPE] = {
            length: INT = name.Length[];
            FOR i: INT DECREASING IN [0..length) DO
                IF name.Fetch[i] = '. THEN RETURN[
                    sn: name.Substr[start: 0, len: i],
                    reg: name.Substr[start: i+1, len: length-(i+1)] ];
                ENDLOOP;
            RETURN[sn: name, reg: NIL];
            };


        SplitThis: PROC [rope, sep: ROPE] RETURNS [ROPE, ROPE, BOOL] = {
            lrope: INT Ź Rope.Length[rope];
            lsep: INT Ź Rope.Length[sep];
            fi: INT Ź Rope.Find[rope, sep, 0, FALSE];
            IF fi = -1 THEN RETURN[rope, NIL, FALSE];
            RETURN[Rope.Substr[rope, 0, fi], Rope.Substr[rope, fi+lsep], TRUE]
            };

        ReplaceThisRope: PROC [r, d, n: ROPE, all: BOOL Ź TRUE, case: BOOL Ź FALSE, pos: INT Ź 0] RETURNS [ROPE] = {
            ld: INT Ź Rope.Length[d];
            ln: INT Ź Rope.Length[n];
            DO
                l: INT Ź Rope.Length[r];
                fi: INT Ź Rope.Find[r, d, pos, case];
                IF fi = -1 THEN EXIT;
                r Ź Rope.Replace[r, fi, ld, n];
                pos Ź fi + ln;
                IF NOT all THEN EXIT;
                ENDLOOP;
            RETURN[r];
            };

        InterpretAndSend: ENTRY PROC [h: Handle, format: ROPE] ~ {
            ENABLE UNWIND => NULL;
            delay: BOOL Ź FALSE;
            eomSent: BOOL;
            <<identity: UserCredentials.Identity;>>
            <<xnsFullName: XNSAuth.Name;>>
            unixName, xnsPassword, xnsLocalName, xnsDomainName, xnsOrgName: ROPE;
            selection: ROPE Ź ViewerTools.GetSelectionContents[];
            IF Rope.Length[format] = 0 THEN RETURN;
            unixName Ź WITH CommanderOps.GetProp[NIL, $USER] SELECT FROM rope: ROPE => rope ENDCASE => NIL;
            <<unixName _ UserCredentials.Get[].name;>>
            <<identity _ UserCredentials.GetIdentity[];>>
            <<[xnsFullName, xnsPassword, ] _ XNSAuth.GetIdentityDetails[identity];>>
            <<xnsLocalName Ź xnsFullName.object;>>
            <<xnsDomainName Ź xnsFullName.domain;>>
            <<xnsOrgName Ź xnsFullName.organization;>>
            format Ź ReplaceThisRope[format, "%unixName", unixName];
            format Ź ReplaceThisRope[format, "%xnsPassword", xnsPassword];
            format Ź ReplaceThisRope[format, "%xnsFullName", Rope.Cat[xnsLocalName, ":", xnsDomainName, ":", xnsOrgName]];
            format Ź ReplaceThisRope[format, "%xnsLocalName", xnsLocalName];
            format Ź ReplaceThisRope[format, "%xnsDomainName", xnsDomainName];
            format Ź ReplaceThisRope[format, "%xnsOrgName", xnsOrgName];
            format Ź ReplaceThisRope[format, "%%", "%"];
            format Ź ReplaceThisRope[format, "%currentSelection", selection];
            WHILE format # NIL DO
                sendThis: ROPE;
                eomSent Ź FALSE;
                [sendThis, format, delay] Ź SplitThis[format, "%d"];
                FOR i: INT IN [0..Rope.Length[sendThis]) DO
                    c: CHAR Ź Rope.Fetch[sendThis, i];
                    IF h.state = connected THEN SendChar[h, c] ELSE IO.PutChar[h.viewerStream, c];
                    IF c = '\n THEN {
                        IF h.state = connected THEN SendEndOfMessage[h.networkStream[output]];
                        eomSent Ź TRUE;
                        };
                    ENDLOOP;
                IF delay THEN {
                    IF sendThis # NIL AND ~eomSent THEN {
                        IF h.state = connected THEN SendEndOfMessage[h.networkStream[output]];
                        eomSent Ź TRUE;
                        };
                    Process.PauseMsec[2000];
                    };
                ENDLOOP;
            IF ~eomSent AND h.state = connected THEN SendEndOfMessage[h.networkStream[output]];
            };

        GetValueFromList: PROC [list: LIST OF ROPE, key: ROPE, eval: PROC [ROPE] RETURNS [ROPE] Ź NIL] RETURNS [ROPE, BOOL] ~ {
            thisItem: ROPE;
            WHILE list # NIL DO
                IF list.rest = NIL THEN RETURN[NIL, FALSE];  -- odd number of TOKENs, not a pair
                IF eval = NIL
                    THEN thisItem Ź list.first
                    ELSE thisItem Ź eval[list.first];
                IF Rope.Equal[thisItem, key, FALSE] THEN RETURN[list.rest.first, TRUE];
                list Ź list.rest.rest;  -- move through by pairs
                ENDLOOP;
            RETURN[NIL, FALSE];
            };

        GenerateLoginStuff: PROC [h: Handle] ~ {
            loginFormat: ROPE;
            formatFound: BOOL Ź FALSE;
            specialLogins: LIST OF ROPE Ź UserProfile.ListOfTokens[Rope.Concat[toolName, ".SpecialLogins"]];
            [loginFormat, formatFound] Ź GetValueFromList[specialLogins, h.hostName];
            IF ~formatFound THEN loginFormat Ź UserProfile.Token[Rope.Concat[toolName, ".DefaultLogin"], "%unixName\n%d%xnsPassword\n"];
            InterpretAndSend[h, loginFormat];
            };

        LockedSendEndOfMessage: ENTRY PROC [h: Handle, s: STREAM] ~ {
            ENABLE UNWIND => NULL;
            SendEndOfMessage[s];
            };

        LockedSendChar: ENTRY PROC [h: Handle, c: CHAR] ~ {
            ENABLE UNWIND => NULL;
            SendChar[h, c];
            };

        LockedPutRope: ENTRY PROC [h: Handle, r: ROPE, sendNow: BOOL Ź FALSE] ~ {
            ENABLE UNWIND => NULL;
            IO.PutRope[h.networkStream[output], r];
            IF sendNow THEN Push[h.networkStream[output]];
            };

        OptionsWatcher: ENTRY PROC [h: Handle] ~ {
            OPEN TelnetOptions;
            ENABLE UNWIND => NULL;
            DO
                IF h.nvtState[echo].stateOfHisSide = active
                    THEN h.localEcho Ź h.lineBuffered Ź FALSE
                    ELSE h.localEcho Ź h.lineBuffered Ź TRUE;
                IF h.nvtState[suppressGoAhead].stateOfHisSide = active
                    THEN h.heSendsGoAheads Ź FALSE
                    ELSE h.heSendsGoAheads Ź TRUE;
                IF h.nvtState[suppressGoAhead].stateOfMySide = active
                    THEN h.sendGoAheads Ź FALSE
                    ELSE h.sendGoAheads Ź TRUE;
                WAIT h.negotiationEvent;
                ENDLOOP;
            };

        Pusher: PROC [h: Handle] ~ {
            msg: ROPE Ź NIL;
            closeAction: CloseAction Ź none;
            c: CHAR Ź Ascii.NUL;
            {
                ENABLE {
                    IO.EndOfStream, ABORTED => { closeAction Ź initiate; CONTINUE };
                    IO.Error => { IF stream = h.networkStream[output] OR stream = h.networkStream[input] THEN msg Ź "Communication failure." ELSE 
                    closeAction Ź initiate; CONTINUE };
                    };
                IF h.autoLogin THEN GenerateLoginStuff[h];
                DO {
                    ENABLE IO.Rubout => { SendCommand[h, TelnetCommands.ip]; CONTINUE };
                    IF IO.CharsAvail[h.keyboardStream, FALSE] = 0
                        AND ((NOT h.lineBuffered) OR c = Ascii.CR OR c = Ascii.LF)
                        THEN LockedSendEndOfMessage[h, h.networkStream[output]];
                    c Ź IO.GetChar[h.keyboardStream];
                    IF h.localEcho THEN {
                        SELECT c FROM
                            Ascii.BS => IO.EraseChar[h.viewerStream, '?];
                            Ascii.CR, Ascii.LF => IO.PutChar[h.viewerStream, '\n];
                            ENDCASE => IO.PutChar[h.viewerStream, c];
                        };
                    IF c = Ascii.CR OR c = Ascii.LF
                        THEN GenerateEOL[h]
                        ELSE LockedSendChar[h, c];
                    } ENDLOOP;
                };
            FinishConnection[h, puller, msg, closeAction];
            };

        GenerateEOL: PROC [h: Handle] ~ {
            LockedPutRope[h, h.eolSeq];
            IF h.sendGoAheads THEN SendCommand[h, TelnetCommands.ga];
            };

        Puller: PROC [h: Handle] ~ {
            ch: CHAR Ź Ascii.NUL;
            col: INTEGER Ź 0;
            prevCh: CHAR Ź Ascii.NUL;
            msg: ROPE Ź NIL;
            closeAction: CloseAction Ź none;
            {
                ENABLE {
                    ABORTED => { closeAction Ź initiate; CONTINUE };
                    IO.EndOfStream => { IF stream = h.networkStream[output] THEN msg Ź "Stream Closed" ELSE closeAction Ź initiate; CONTINUE };
                    IO.Error => { IF stream = h.networkStream[output] THEN msg Ź "Communication failure" ELSE closeAction Ź initiate; CONTINUE };
                    NetworkStream.Timeout => { msg Ź "Stream Timeout"; CONTINUE };
                    };
                DO
                    prevCh Ź ch;
                    ch Ź IO.GetChar[h.networkStream[input]];
                    Trace[h, hisSide, ch];
                    SELECT ch FROM
                        IN [Ascii.SP..0176C], Ascii.TAB => { IO.PutChar[h.viewerStream, ch]; col Ź col+1 };
                        Ascii.LF => IF prevCh = Ascii.CR THEN NULL ELSE { IO.PutChar[h.viewerStream, '\n]; col Ź 0};
                        Ascii.CR => IF col # 0 THEN {IO.PutChar[h.viewerStream, '\n]; col Ź 0};
                        Ascii.BS => IF col # 0 THEN { IO.EraseChar[h.viewerStream, '?]; col Ź col-1 };
                        Ascii.BEL => ViewerOps.BlinkViewer[ViewerIO.GetViewerFromStream[h.viewerStream]];
                        TelnetCommands.iac => ProcessTelnetCommand[h];
                        ENDCASE => NULL;
                    ENDLOOP;
                };
            FinishConnection[h, puller, msg, closeAction];
            };

        ProcessTelnetCommand: PROC [h: Handle] ~ {
            OPEN TelnetCommands;
            command: CHAR Ź IO.GetChar[h.networkStream[input]];
            Trace[h, hisSide, command];
            SELECT command FROM
                ayt => LockedPutRope[h, "\n<Yes, I'm here.>\n", TRUE];
                ec => IO.EraseChar[h.viewerStream, '?];
                ga => h.gotGA Ź TRUE;
                will, wont, do, dont =>  ProcessTelnetOption[h, command];
                ENDCASE => NULL;
            };

        ProcessTelnetOption: ENTRY PROC [h: Handle, command: CHAR] ~ {
            <<From RFC 854:  In summary, WILL XXX is sent, by either party, to indicate that party's desire (offer) to begin performing option 
            XXX, DO XXX and DON'T XXX being its positive and negative acknowledgments; similarly, DO XXX is sent to indicate a 
            desire (request) that the other party (i.e., the recipient of the DO) begin performing option XXX, WILL XXX and WON'T 
            XXX being the positive and negative acknowledgments.  Since the NVT is what is left when no options are enabled, the 
            DON'T and WON'T responses are guaranteed to leave the connection in a state which both ends can handle.  Thus, all 
            hosts may implement their TELNET processes to be totally unaware of options that are not supported, simply returning a 
            rejection to (i.e., refusing) any option request that cannot be understood.>>
            OPEN TelnetCommands, TelnetOptions;
            ENABLE UNWIND => NULL;
            option: CHAR Ź IO.GetChar[h.networkStream[input]];
            optionState: OptionState Ź h.nvtState[option];
            TraceInternal[h, hisSide, option];
            SELECT command FROM
                will => {  -- Either an offer on his part to start performing option XXX or a positive acknowledgment of a previous DO request from 
                me.  (state = his side)
                    SELECT optionState.stateOfHisSide FROM
                        active => {  -- the RFC says you shouldn't send extra/gratuitious "will"s
                            h.extraWills Ź h.extraWills.SUCC;
                            };
                        inactive => {  -- he's offering to do XXX...
                            IF optionState.desiredOfHisSide
                                THEN {
                                    SendOptionInternal[h, do, option];  -- ack it
                                    h.nvtState[option].stateOfHisSide Ź active;
                                    }
                                ELSE {
                                    SendOptionInternal[h, dont, option];  -- nack it
                                    };
                            };
                        requested => {  -- we've requested so he's acking
                            h.nvtState[option].stateOfHisSide Ź active;
                            };
                        ENDCASE => ERROR;
                    };
                wont => {  -- Negative acknowledgment of a DO request from me.  (state = his side)
                    h.nvtState[option].stateOfHisSide Ź inactive;
                    };
                do => {  -- Either he is requesting that I begin performing option XXX or a positive acknowledgment of a previous WILL offer by me. 
                 (state = my side)
                    SELECT optionState.stateOfMySide FROM
                        active => {  -- the RFC says you shouldn't send extra/gratuitious "will"s
                            h.extraDos Ź h.extraDos.SUCC;
                            };
                        inactive => {  -- he's requesting that I do XXX...
                            IF optionState.desiredOfMySide
                                THEN {
                                    SendOptionInternal[h, will, option];  -- ack it
                                    h.nvtState[option].stateOfMySide Ź active;
                                    }
                                ELSE {
                                    SendOptionInternal[h, wont, option];  -- nack it
                                    };
                            };
                        requested => {  -- he's taking us up on our offer
                            h.nvtState[option].stateOfMySide Ź active;
                            };
                        ENDCASE => ERROR;
                    };
                dont => {  -- Negative acknowledgment of a WILL offer by me.  (state = my side)
                    h.nvtState[option].stateOfMySide Ź inactive;
                    };
                ENDCASE => ERROR;
            BROADCAST h.negotiationEvent;
            };

        NegotiateOption: ENTRY PROC [h: Handle, option: CHAR, side: Side] RETURNS [active: BOOL] ~ {
            OPEN TelnetCommands;
            ENABLE UNWIND => NULL;
            SELECT side FROM
                mySide => {
                    h.nvtState[option].desiredOfMySide Ź TRUE;
                    SELECT h.nvtState[option].stateOfMySide FROM
                        inactive => NULL;
                        active => RETURN[TRUE];
                        ENDCASE => ERROR;
                    h.nvtState[option].stateOfMySide Ź requested;
                    SendOptionInternal[h, will, option];
                    DO
                        IF h.nvtState[option].stateOfMySide # requested THEN RETURN[h.nvtState[option].stateOfMySide = active];
                        WAIT h.negotiationEvent;
                        ENDLOOP;
                    };
                hisSide => {
                    h.nvtState[option].desiredOfHisSide Ź TRUE;
                    SELECT h.nvtState[option].stateOfHisSide FROM
                        inactive => NULL;
                        active => RETURN[TRUE];
                        ENDCASE => ERROR;
                    h.nvtState[option].stateOfHisSide Ź requested;
                    SendOptionInternal[h, do, option];
                    DO
                        IF h.nvtState[option].stateOfHisSide # requested THEN RETURN[h.nvtState[option].stateOfHisSide = active];
                        WAIT h.negotiationEvent;
                        ENDLOOP;
                    };
                ENDCASE => ERROR;
            };

        DeactivateOption: ENTRY PROC [h: Handle, option: CHAR, side: Side] ~ {
            OPEN TelnetCommands;
            ENABLE UNWIND => NULL;
            SELECT side FROM
                mySide => {
                    h.nvtState[option].desiredOfMySide Ź FALSE;
                    SELECT h.nvtState[option].stateOfMySide FROM
                        inactive => RETURN;
                        active => NULL;
                        ENDCASE => ERROR;
                    h.nvtState[option].stateOfMySide Ź inactive;
                    SendOptionInternal[h, wont, option];
                    };
                hisSide => {
                    h.nvtState[option].desiredOfHisSide Ź FALSE;
                    SELECT h.nvtState[option].stateOfHisSide FROM
                        inactive => RETURN;
                        active => NULL;
                        ENDCASE => ERROR;
                    h.nvtState[option].stateOfHisSide Ź inactive;
                    SendOptionInternal[h, dont, option];
                    };
                ENDCASE => ERROR;
            };

        SendChar: INTERNAL PROC [h: Handle, char: CHAR] ~ {
            IO.PutChar[h.networkStream[output], char];
            TraceInternal[h, mySide, char];
            };

        SendOption: ENTRY PROC [h: Handle, command: CHAR, option: CHAR, misc: ROPE Ź NIL] = {
            ENABLE UNWIND => NULL;
            SendOptionInternal[h, command, option, misc];
            };

        SendOptionInternal: INTERNAL PROC [h: Handle, command: CHAR, option: CHAR, misc: ROPE Ź NIL] = {
            ENABLE UNWIND => NULL;
            SendChar[h, TelnetCommands.iac];
            SendChar[h, command];
            SendChar[h, option];
            FOR i: INT IN [0..Rope.Size[misc]) DO
                SendChar[h, Rope.Fetch[misc, i]];
                ENDLOOP;
            Push[h.networkStream[output]];
            };

        SendCommand: ENTRY PROC [h: Handle, command: CHAR, misc: ROPE Ź NIL] = {
            ENABLE UNWIND => NULL;
            SendChar[h, TelnetCommands.iac];
            SendChar[h, command];
            FOR i: INT IN [0..Rope.Size[misc]) DO
                SendChar[h, Rope.Fetch[misc, i]];
                ENDLOOP;
            Push[h.networkStream[output]];
            };

        DoSendBreak: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF h.state = connected THEN SendCommand[h, TelnetCommands.brk];
            };

        DoSynch: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF h.state = connected THEN SendSynch[h];
            };

        SendSynch: ENTRY PROC [h: Handle] = {
            ENABLE UNWIND => NULL;
            SendChar[h, TelnetCommands.iac];
            NetworkStream.SendAttention[h.networkStream[output], ORD[TelnetCommands.dm]];
                <<-- Is this right? It is a replacement for this:>>
                <<IO.PutChar[h.networkStream, TelnetCommands.iac];>>
                <<IO.PutChar[h.networkStream, TelnetCommands.dm];>>
                <<ArpaTCP.SetUrgent[h.networkStream];>>

            Push[h.networkStream[output]];
            };

        DoInterrupt: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF h.state = connected THEN SendCommand[h, TelnetCommands.ip];
            };

        DoDisconnect: Menus.MenuProc
            <<[parent, clientData, mouseButton, shift, control]>>
            ~ {
            h: Handle Ź NARROW[clientData];
            IF h.state = connected THEN FinishConnection[h~h, me~none, msg~"Disconnecting.", closeAction~initiate];
            };

        FlushLogProc: Menus.MenuProc ~ {
            h: Handle Ź NARROW[clientData];
            IF h.viewerStream # NIL THEN h.viewerStream.Flush[];
            };

        ShowOptionsProc: Menus.MenuProc ~ {
            h: Handle Ź NARROW[clientData];
            IF h = NIL THEN RETURN;
            IF control THEN {
            buf: TraceBuffer ~ GetTrace[h];
                IF buf = NIL THEN {
                    IO.PutRope[h.viewerStream, "\n*** Tracing Enabled ***\n"];
                    RETURN;
                    };
                IO.PutRope[h.viewerStream, " ***\n*** "];
                FOR i: NAT Ź buf.first, (i+1) MOD buf.size UNTIL i = buf.next DO
                    t: TraceBufferEntry ~ buf[i];
                    IO.PutF[h.viewerStream, "%L%03B %L", [rope[IF t.side = mySide THEN "oBi" ELSE "obI"]], [cardinal[ORD[t.char]]], [rope["OBI"]]];
                    ENDLOOP;
                IO.PutRope[h.viewerStream, "***\n"];
                RETURN;
                };
            IF h.state # connected THEN RETURN;
            IO.PutRope[h.viewerStream, Rope.Cat["\n\n<<<< Current Options Status >>>>\n", RopeFromNVTState[h], "<<<< End of Options Status 
            >>>>\n\n"]];
            };

        AnotherProc: Menus.MenuProc = {
            h: Handle Ź NEW[Object];
            [] Ź TelnetMainInternal[h];
            };

        telnetTIPTable: TIPUser.TIPTable ~ TIPUser.InstantiateNewTIPTable["TelnetViewer.tip"];

        [] _ TIPLinking.Append[telnetTIPTable, ViewerOps.FetchViewerClass[$Typescript].tipTable];

        Commander.Register["TelnetViewer", TelnetMain, documentationRope, NIL, FALSE];

        }...