<<>>
<<BridgeDriverImpl.mesa>>
<<Copyright Ó 1991, 1992 by Xerox Corporation.  All rights reserved.>>
    <<Demers, May 15, 1990 8:37 am PDT>>
    <<Christian Le Cocq September 29, 1987 4:58:16 pm PDT>>
    <<Eduardo Pelegri-Llopart April 4, 1989 5:10:40 pm PDT>>
    <<Peter B. Kessler February 22, 1988 3:49:50 pm PST>>
    <<Last changed by Pavel on September 20, 1989 5:16:40 pm PDT>>
    <<Willie-s, January 29, 1992 6:26 pm PST>>
    <<Foote, August 5, 1991 9:58 am PDT>>

    DIRECTORY
        Args,
        Ascii,
        BridgeExec,
        BridgeComm,
        BridgeDriver,
        Commander,
        CommanderOps,
        Convert,
        IO,
        NetworkName,
        NetworkStream,
        Process,
        RefTab,
        RefText,
        Rope,
        SymTab,
        SystemNames,
        TypeScript,
        UserProfile,
        ViewerIO
        ;

    BridgeDriverImpl: CEDAR MONITOR
        LOCKS h USING h: Handle
        IMPORTS Ascii, Args, BridgeExec, BridgeComm, Commander, CommanderOps, Convert, IO, NetworkName, NetworkStream, Process, RefTab, 
        RefText, Rope, SymTab, SystemNames, TypeScript, UserProfile, ViewerIO
        EXPORTS BridgeDriver
        ~ {

        NetworkStreamPair: TYPE ~ BridgeExec.NetworkStreamPair;
        ROPE: TYPE ~ Rope.ROPE;
        Session: TYPE ~ BridgeExec.Session;
        STREAM: TYPE ~ IO.STREAM;

        <<Note: Bridge and NetworkStream disagree about the meaning of "transport class" .  For Bridge, "transport class" denotes a 
        protocol family like $XNS, $ARPA, etc.  For NetworkStream, "transport class" denotes a kind of stream functionality like 
        $BasicStream or in this case $SPP, while the term "protocol family" is reserved for protocols like $XNS, $ARPA, etc.  This 
        is all very confusing ...>>

        bridgeWKSRope: ROPE Ź "3001";
        initialTransportClassRope: ROPE ~ Rope.Translate[
        base: UserProfile.Token[key: "Bridge.DefaultTransport", default: "ARPA"],
        translator: Upper];
        defaultTransportClass: ATOM Ź Convert.AtomFromRope[initialTransportClassRope]; 
        defaultInitialPutTimeout: NetworkStream.Milliseconds Ź 20000;
        defaultInitialGetTimeout: NetworkStream.Milliseconds Ź 40000;

        bridgeNetworkStreamTransportClass: ATOM ~ $SPP;

        Handle: TYPE ~ REF Object;
        Object: TYPE ~ MONITORED RECORD [
            session: Session Ź NIL,
            listener: NetworkStream.Listener Ź NIL,
            mgrStreams: NetworkStreamPair Ź [NIL, NIL],
            userName: ROPE,
            passwd: ROPE
            ];

        sessionTab: SymTab.Ref Ź SymTab.Create[];
        transportTab: RefTab.Ref Ź RefTab.Create[];

        Upper: PROC [old: CHAR] RETURNS [new: CHAR] ~ {
            RETURN [Ascii.Upper[old]];
            };

        SessionNameFromHostNameEtc: PUBLIC PROC [hostName: ROPE, etc: ROPE] RETURNS [sessionName: ROPE] ~ {
            RETURN [Rope.Cat[hostName, "(", etc, ")"]];
            };

        HostNameFromSessionName: PUBLIC PROC [sessionName: ROPE] RETURNS [hostName: ROPE] ~ {
            pos: INT Ź Rope.SkipTo[s~sessionName, pos~0, skip~"("];
            IF (pos < Rope.Length[sessionName]) AND (pos > 0) THEN {
                WHILE (pos > 0) AND (Rope.Fetch[sessionName, pos-1] = ' ) DO
                    pos Ź pos - 1;
                    ENDLOOP; 
                };
            RETURN [Rope.Substr[sessionName, 0, pos]] };


        CloseConnectionWrapper: PROC [nsp: NetworkStreamPair] ~ {
            BridgeComm.CloseConnection[nsp, initiate];
            };

        SessionWorker: NetworkStream.ListenerWorkerProc -- [listener, in, out] -- ~ {
            h: Handle ~ NARROW[listener.listenerWorkerClientData];
            msg: CHAR Ź 'X;
            rawArg, cmdName, cookedArg: ROPE;
            pos: INT;
            nsp: NetworkStreamPair Ź [in, out];
            [msg, rawArg] Ź BridgeComm.GetMsg[nsp ! BridgeComm.Error => CONTINUE];
            IF msg # 'E THEN GOTO Bad;
            pos Ź Rope.SkipTo[s~rawArg, pos~0, skip~argSeparator];
            cmdName Ź Rope.Substr[rawArg, 0, pos];
            pos Ź Rope.SkipOver[s~rawArg, pos~pos, skip~argSeparator];
            pos Ź Rope.SkipOver[s~rawArg, pos~pos, skip~" "];
            cookedArg Ź Rope.Substr[rawArg, pos];
            { len: INT ~ Rope.Length[cookedArg];
                IF len > 0 AND Rope.Equal[Rope.Substr[cookedArg, len-1, 1], argSeparator]
                    THEN cookedArg Ź Rope.Substr[cookedArg, 0, len-1];
                };
            IF BridgeExec.CreateInstance[cmdName, nsp, cookedArg, h.session, CloseConnectionWrapper] = NIL THEN GOTO Bad;
            EXITS
                Bad => { IO.Close[in]; IO.Close[out] }
            };


        defaultCmd: ROPE Ź "";

        StartSession: PUBLIC PROC [sessionName: ROPE, nameAndPasswordProc: BridgeDriver.NameAndPasswordProc, cmd: ROPE Ź NIL, 
        transportClass: ATOM Ź NIL] RETURNS [excuse: ROPE Ź NIL] ~ {
            h: Handle;
            userName: ROPE;
            passwd: ROPE;
            FetchOrCreateHandle: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
                handles: LIST OF Handle Ź IF found THEN NARROW[val] ELSE NIL;

                FOR tail: LIST OF Handle Ź handles, tail.rest UNTIL tail = NIL DO
                    IF Rope.Equal[tail.first.userName, userName] THEN {
                        h Ź tail.first;
                        <<The following check is commented out because it makes it impossible to use commands like RCopy, that don't accept a password, on 
                        hosts whose password is different from the one that UserCredentials knows about.  This was considered a 
                        worse bug than the fact that a user can now use connections made by other users even without knowing the 
                        correct password.  Of course, since a malicious user could just invoke the interpreter to read the 
                        sessionTab, it was never a very secure stance in the first place.>>
                        <<IF NOT Rope.Equal[tail.first.passwd, passwd] THEN>>
                            <<excuse _ "Incorrect password given.";>>
                        op Ź none;
                        RETURN;
                        };
                    ENDLOOP;

                h Ź NEW[Object Ź [userName~userName, passwd~passwd]];
                handles Ź CONS[h, handles];    -- work around compiler bug
                new Ź handles;
                op Ź store;
                RETURN;
                };

            StartSessionInner: ENTRY PROC [h: Handle] ~ {
                ENABLE UNWIND => NULL;
                IF h.session = NIL THEN {
                    hisName, theRemote, logonMsg, ansArg: ROPE Ź NIL;
                    ansChar: CHAR;
                    hisName Ź HostNameFromSessionName[sessionName];
                    [addr~theRemote] Ź NetworkName.AddressFromName[transportClass, hisName, bridgeWKSRope, hostAndPort, NIL ! NetworkName.Error => 
                    {theRemote Ź NIL; CONTINUE }];
                    IF Rope.IsEmpty[theRemote]
                        THEN { excuse Ź "name lookup failed"; GOTO CantCreate };
                    [h.mgrStreams.in, h.mgrStreams.out] Ź NetworkStream.CreateStreams[ protocolFamily~transportClass, remote~theRemote, 
                    transportClass~bridgeNetworkStreamTransportClass, timeout~defaultInitialGetTimeout
                        ! NetworkStream.Error => CONTINUE];
                    IF h.mgrStreams.in = NIL THEN {
                        excuse Ź "Can't connect"; GOTO CantCreate };
                    h.session Ź BridgeExec.CreateSession[sessionName];
                    h.listener Ź NetworkStream.CreateListener[
                    protocolFamily~transportClass, transportClass~bridgeNetworkStreamTransportClass, 
                    listenerWorkerProc~SessionWorker, listenerWorkerClientData~h];
                    logonMsg Ź Rope.Cat[NetworkStream.GetListenerInfo[h.listener].local, " ", userName, " ", passwd];
                    { ENABLE NetworkStream.Error, IO.Error => { excuse Ź "I/O error sending logon: "; GOTO CantCreate };
                        IO.PutRope[h.mgrStreams.out, logonMsg];
                        NetworkStream.SendEndOfMessage[h.mgrStreams.out];
                        };
                    [ansChar, ansArg] Ź BridgeComm.GetMsg[h.mgrStreams
                        ! BridgeComm.Error => {
                            excuse Ź Rope.Concat["I/O error reading logon response: ", msg];
                            GOTO CantCreate;
                            }
                        ];
                    excuse Ź SELECT ansChar FROM 'Y => NIL, 'N, 'Q => ansArg, ENDCASE => "Protocol error";
                    IF excuse # NIL THEN GOTO CantCreate;
                    EXITS
                        CantCreate => { KillSessionInternal[h, sessionName]; RETURN }
                    };
                IF BridgeExec.SessionIsDead[h.session] THEN {
                    excuse Ź "Session is dead"; RETURN };
                BridgeComm.PutMsgWithAck[h.mgrStreams, 'E,
                (IF Rope.IsEmpty[cmd] THEN defaultCmd ELSE cmd)
                    ! BridgeComm.Error => {
                    excuse Ź "Can't send cmd"; CONTINUE }];
                };

            IF nameAndPasswordProc # NIL
                THEN [userName, passwd] Ź nameAndPasswordProc[]
                ELSE [userName, passwd] Ź GetCurrentCredentials[ HostNameFromSessionName[sessionName], TRUE ];
            IF Rope.IsEmpty[userName] THEN RETURN["missing user name"];  
            IF transportClass = NIL THEN transportClass Ź defaultTransportClass;
            SymTab.Update[sessionTab, sessionName, FetchOrCreateHandle]; -- h Ź handle
            IF excuse # NIL THEN RETURN;
            StartSessionInner[h];
            };

        KillSessionInternal: INTERNAL PROC [h: Handle, sessionName: ROPE] ~ {
            DoDelete: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
                newHandles: LIST OF Handle Ź NIL;

                IF NOT found THEN RETURN [none, NIL];

                FOR handles: LIST OF Handle Ź NARROW[val], handles.rest UNTIL handles = NIL DO
                    IF handles.first # h THEN
                        newHandles Ź CONS[handles.first, newHandles];
                    ENDLOOP;

                IF newHandles # NIL
                    THEN RETURN [store, newHandles]
                    ELSE RETURN [delete, NIL];
                };

            SymTab.Update[sessionTab, sessionName, DoDelete];
            IF h.session # NIL THEN {
                BridgeExec.DestroySession[h.session];
                h.session Ź NIL;
                };
            IF h.listener # NIL THEN {
                NetworkStream.DestroyListener[h.listener];
                h.listener Ź NIL;
                };
            IF h.mgrStreams # [NIL, NIL] THEN {
                NetworkStream.SetTimeout[h.mgrStreams.in, 7500, FALSE
                ! NetworkStream.Error => CONTINUE];
                NetworkStream.SetTimeout[h.mgrStreams.out, 7500, FALSE
                ! NetworkStream.Error => CONTINUE];
                BridgeComm.PutMsg[h.mgrStreams, 'Q, ""
                ! BridgeComm.Error => CONTINUE];
                BridgeComm.CloseConnection[h.mgrStreams];
                h.mgrStreams Ź [NIL, NIL];
                }
            };

        EntryKillSession: ENTRY PROC [h: Handle, sessionName: ROPE] ~ {
            ENABLE UNWIND => NULL;
            KillSessionInternal[h, sessionName];
            };

        KillSession: PUBLIC PROC [sessionName: ROPE, userName: ROPE Ź NIL] RETURNS [excuse: ROPE] ~ {
            handles: LIST OF Handle;
            h: Handle;

            excuse Ź "No session with that name.";
            DO
                handles Ź NARROW[SymTab.Fetch[sessionTab, sessionName].val];
                WHILE handles # NIL DO
                    IF (h Ź handles.first) = NIL THEN ERROR;
                    IF userName = NIL OR Rope.Equal[userName, h.userName] THEN EXIT;
                    handles Ź handles.rest;
                    ENDLOOP;
                IF handles = NIL THEN EXIT;
                excuse Ź NIL;
                EntryKillSession[h, sessionName];
                ENDLOOP;
            };

        EnumerateSessions: PUBLIC PROC [procToApply: BridgeDriver.EachSession] ~ {
            EachSession: SymTab.EachPairAction -- [key, val] RETURNS [quit] -- ~ {
                FOR handles: LIST OF Handle Ź NARROW[val], handles.rest UNTIL handles = NIL DO
                    h: Handle ~ handles.first;
                    listener: NetworkStream.Listener ~ h.listener;
                    class: ATOM Ź IF listener # NIL
                        THEN NetworkStream.GetListenerInfo[listener].protocolFamily
                        ELSE $NONE;
                    IF procToApply[sessionName: key, userName: h.userName, class: class] THEN
                        RETURN[quit: TRUE];
                    ENDLOOP;
                };
            [] Ź SymTab.Pairs[sessionTab, EachSession];
            };


        UpdateDefaultTransportClass: PUBLIC PROC [newClass: ATOM Ź NIL]
        RETURNS [oldClass: ATOM] ~ {
            oldClass Ź defaultTransportClass;
            IF newClass # NIL THEN defaultTransportClass Ź newClass;
            };

        secondsBetweenKeepalives: INT Ź 300;

        Daemon: PROC ~ {
            EachSessionInner: ENTRY PROC [h: Handle] ~ {
                ENABLE UNWIND => NULL;
                IF h.mgrStreams # [NIL, NIL] THEN BridgeComm.PutMsgWithAck[h.mgrStreams, 'Z, Convert.RopeFromCard[2*secondsBetweenKeepalives]
                    ! BridgeComm.Error => CONTINUE];
                };
            EachSession: SymTab.EachPairAction ~ {
                FOR handles: LIST OF Handle Ź NARROW[val], handles.rest UNTIL handles = NIL DO
                    EachSessionInner[handles.first];
                    ENDLOOP;
                };

            DO
                Process.PauseMsec[INT[1000]*secondsBetweenKeepalives];
                [] Ź SymTab.Pairs[sessionTab, EachSession];
                ENDLOOP;
            };


        FixUserNameForUnix: PUBLIC PROC [name: ROPE] RETURNS [fixedName: ROPE] ~ {
            len: INT ~ MIN [8, Rope.Length[name], name.Index[pos1: 0, s2: "."]];
            text: REF TEXT ~ RefText.ObtainScratch[len];

            FOR i: INT IN [0..len) DO
                text[i] Ź name.Fetch[i];
                ENDLOOP;
            text.length Ź len;
            fixedName Ź Rope.FromRefText[text];
            RefText.ReleaseScratch[text];
            };

        argSeparator: ROPE ~ "\r";

        CmdFromRopes: PROC [r1, r2, r3, r4, r5: ROPE Ź NIL] RETURNS [cmd: ROPE] ~ {
            list: LIST OF ROPE Ź NIL;
            IF r5 # NIL THEN list Ź CONS[r5, list];
            IF r4 # NIL THEN list Ź CONS[r4, list];
            IF r3 # NIL THEN list Ź CONS[r3, list];
            IF r2 # NIL THEN list Ź CONS[r2, list];
            IF r1 # NIL THEN list Ź CONS[r1, list];
            RETURN [CmdFromListOfRope[list]];
            };

        CmdFromListOfRope: PUBLIC PROC [list: LIST OF ROPE] RETURNS [cmd: ROPE Ź NIL] ~ {
            FOR each: LIST OF ROPE Ź list, each.rest WHILE each # NIL DO
                IF cmd = NIL
                    THEN cmd Ź each.first
                    ELSE cmd Ź Rope.Cat[cmd, argSeparator, each.first];
                ENDLOOP;
            };

        ListOfRopeFromCmd: PUBLIC PROC [cmd: ROPE] RETURNS [list: LIST OF ROPE Ź NIL] ~ {
            separatorIndex: INT;
            temp: ROPE Ź cmd;
            len: INT Ź Rope.Length[cmd];
            IF len > 0 THEN {
                IF Rope.EqualSubstrs[s1~temp, start1~len-1, len1~1, s2~argSeparator] THEN {
                    temp Ź Rope.Substr[base~temp, len~len-1];
                    };
                };
            WHILE (separatorIndex Ź Rope.FindBackward[temp, argSeparator]) >= 0 DO
                list Ź CONS[ Rope.Substr[base~temp, start~separatorIndex+1], list ];
                temp Ź Rope.Substr[base~temp, len~separatorIndex];
                ENDLOOP;
            IF NOT Rope.IsEmpty[temp] THEN list Ź CONS[ temp, list ];
            };

        CredsEntry: TYPE ~ REF CredsEntryObject;
        CredsEntryObject: TYPE ~ RECORD [
            name: ROPE,
            password: ROPE
            ];

        credsTab: SymTab.Ref Ź SymTab.Create[case~FALSE];

        GetCurrentCredentials: PUBLIC PROC [machineName: ROPE, useGV: BOOL] RETURNS [name: ROPE Ź NIL, password: ROPE Ź NIL] ~ {
            credsEntry: CredsEntry;
            key: ROPE;
            IF Rope.IsEmpty[machineName] THEN machineName Ź "*";
            WITH SymTab.Fetch[credsTab, machineName].val SELECT FROM
                it: CredsEntry => {name Ź it.name; password Ź it.password};
                ENDCASE =>
                    WITH SymTab.Fetch[credsTab, "*"].val SELECT FROM
                        it: CredsEntry => {name Ź it.name; password Ź it.password};
                        ENDCASE;
            IF name = NIL AND useGV THEN {
                remoteMachine: ROPE ~ HostNameFromSessionName[sessionName~machineName];
                userProfileKey: ROPE ~ Rope.Cat["Bridge.", machineName, ".userName"];
                name Ź SystemNames.UserName[];
                name Ź UserProfile.Token[key~userProfileKey, default~name];
                };
            name Ź FixUserNameForUnix[name];
            <<IF password = NIL AND useGV THEN {>>
                <<password Ź UserCredentials.Get[].password;>>
                <<};>>
            };

        SetCurrentCredentials: PUBLIC PROC [machineName: ROPE, name: ROPE, password: ROPE] ~ {
            credsEntry: CredsEntry;
            key: ROPE; 
            SELECT TRUE FROM
                Rope.IsEmpty[machineName] => key Ź "*";
                ENDCASE => key Ź machineName;
            credsEntry Ź NEW[CredsEntryObject Ź [name, password]];
            [] Ź SymTab.Store[credsTab, key, credsEntry];
            };

        SmashBridgeCredentialsIfUserChanged: UserProfile.ProfileChangedProc ~ {
            IF reason = newUser THEN credsTab Ź SymTab.Create[case~FALSE];
            };

        BridgeStart: ROPE ~ "BridgeStart";
        BridgeStartShort: ROPE ~ "Bridge";
        BridgeStartDoc: ROPE ~ "<host> [-i]\nStart a Cornell Unix Bridge Session.\n-i => prompt for username and password.\n";
        BridgeStartUsage: ROPE ~ Rope.Concat["Usage: BridgeStart ", BridgeStartDoc];

        PromptForLine: PROC [
        stdin: STREAM, 
        stdout: STREAM, 
        prompt: ROPE, 
        echo: BOOL Ź TRUE]
        RETURNS [line: ROPE Ź NIL] ~ {
            lookHidden: IO.Value ~ IO.rope["h"];
            lookShiftHidden: IO.Value ~ IO.rope["H"];

            IO.PutF1[stdout, "  %g: ", [rope[prompt]]];
            IF NOT echo THEN {
                IO.PutF1[stdout, "%l", lookHidden];
                };
            BEGIN ENABLE UNWIND => IF NOT echo THEN stdout.PutF1["%l", lookShiftHidden];
                BEGIN ENABLE BEGIN
                    IO.EndOfStream => CONTINUE;
                    IO.Rubout => {
                        IF NOT echo THEN stdout.PutF1["%l", lookShiftHidden];
                        stdout.PutRope[" <del>\n"];
                        stdin.Reset[];
                        CONTINUE;
                        };
                    END;
                    line Ź IO.GetLineRope[stdin];
                    END;
                IF line = NIL THEN {
                    IF NOT echo THEN stdout.PutF1["%l", lookShiftHidden];
                    RETURN;
                    };

                IF NOT echo THEN {
                    viewer: ViewerIO.Viewer ~ ViewerIO.GetViewerFromStream[stdout];
                    IO.PutF1[stdout, "%l", lookShiftHidden];
                    IF TypeScript.IsATypeScript[viewer] THEN {
                        TypeScript.BackSpace[viewer, line.Length[] + 1];
                        IO.PutRope[stdout, "****\n"];
                        stdin.Reset[];
                        };
                    };
                END;
            };


        DoBridgeStart: Commander.CommandProc ~ {
            sessionName, iFlag: Args.Arg;
            bridgeCmd, name, password: ROPE;
            SupplyNameAndPassword: BridgeDriver.NameAndPasswordProc -- RETURNS [userName, passwd] -- ~ {
                RETURN [name, password];
                };
            IF Args.NArgs[cmd] = 0 THEN RETURN [$Failure, BridgeStartUsage];
            [sessionName, iFlag]
            Ź Args.ArgsGet[cmd: cmd, format: "%s-i%b", caseSensitive: FALSE
                ! Args.Error => {msg Ź reason; CONTINUE}];
            IF msg # NIL THEN RETURN [result~$Failure, msg~msg];
            IF NOT iFlag.bool THEN {
                [name, password] Ź GetCurrentCredentials[sessionName.rope, TRUE];
                };
            IF Rope.IsEmpty[name] THEN {
                name Ź PromptForLine[stdin~cmd.in, stdout~cmd.out, prompt~"user name", echo~TRUE];
                password Ź NIL;
                };
            name Ź FixUserNameForUnix[name];
            IF Rope.IsEmpty[password] THEN {
                password Ź PromptForLine[stdin~cmd.in, stdout~cmd.out, prompt~"password", echo~FALSE];
                };
            bridgeCmd Ź CmdFromListOfRope[LIST["RTTY", "LoginSh"]];
            msg Ź StartSession[sessionName.rope, SupplyNameAndPassword, bridgeCmd, NIL];
            IF msg # NIL THEN RETURN[result~$Failure, msg~msg];
            };


        BridgeChangeTransport: ROPE ~ "BridgeChangeTransport";
        BridgeChangeTransportDoc: ROPE ~ "\nChange the transport used by bridge.";
        BridgeChangeTransportUsage: ROPE ~ Rope.Concat["Usage: BridgeChangeTransport [XNS|TCP]", BridgeChangeTransportDoc];

        TransportIsRegistered: PROC [desiredFamily: ATOM] RETURNS [isRegistered: BOOL Ź FALSE] ~ {
            EachClass: NetworkStream.EnumerateCallbackProc -- [protocolFamily, transportClass] RETURNS [continue] -- ~ {
                IF transportClass # bridgeNetworkStreamTransportClass THEN ERROR;
                IF protocolFamily = desiredFamily
                    THEN {
                        isRegistered Ź TRUE;
                        continue Ź FALSE;
                        }
                    ELSE {
                        continue Ź TRUE;
                        }
                };
            NetworkStream.Enumerate[families~NIL, classes~bridgeNetworkStreamTransportClass, proc~EachClass];
            };

        DoBridgeChangeTransport: Commander.CommandProc ~ {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]>>
            transportClassArg: Args.Arg;
            oldTransportClass, newTransportClass: ATOM;
            IF Args.NArgs[cmd] # 1 THEN RETURN[$Failure, BridgeChangeTransportUsage];
            [transportClassArg] Ź Args.ArgsGet[cmd~cmd, format~"%s", caseSensitive~FALSE ! Args.Error => {result Ź $Failure; msg Ź reason; GOTO 
            Out }];
            newTransportClass Ź Convert.AtomFromRope[transportClassArg.rope];
            IF NOT TransportIsRegistered[newTransportClass]
                THEN { result Ź $Failure; msg Ź "Transport not registered"; GOTO Out };
            oldTransportClass Ź UpdateDefaultTransportClass[newTransportClass];
            msg Ź Rope.Concat["transport was ", Convert.RopeFromAtom[oldTransportClass]];
            EXITS
                Out => NULL;
            };

        BridgeCredentials: ROPE ~ "BridgeCredentials";
        BridgeCredentialsDoc: ROPE ~ "\n[name, [machine]]  Supply explicit Bridge credentials for machine";
        BridgeCredentialsUsage: ROPE ~ Rope.Concat["Usage: BridgeCredentials ", BridgeCredentialsDoc];

        DoBridgeCredentials: Commander.CommandProc ~ {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]>>
            argv: CommanderOps.ArgumentVector Ź CommanderOps.Parse[cmd
                ! CommanderOps.Failed => {msg Ź errorMsg; GO TO oops}];
            argc: NAT Ź argv.argc;
            name: ROPE Ź IF argc > 1 THEN argv[1] ELSE NIL; 
            machine: ROPE Ź IF argc > 2 THEN argv[2] ELSE NIL;
            password: ROPE Ź NIL;
            IF argc > 3 THEN GO TO usage;
            IF Rope.IsEmpty[name] THEN {
                name Ź PromptForLine[stdin~cmd.in, stdout~cmd.out, prompt~"name", echo~TRUE];
                };
            IF Rope.IsEmpty[password] THEN {
                password Ź PromptForLine[stdin~cmd.in, stdout~cmd.out, prompt~"password", echo~FALSE];
                };
            IF Rope.IsEmpty[machine] THEN machine Ź "*";
            SetCurrentCredentials[machine, name, password];
            msg Ź Rope.Cat["Credentials set for Bridge sessions to ", machine, ".\n"];
            EXITS
                usage => msg Ź BridgeCredentialsUsage;
                oops => result Ź $Failure;
            };


        BridgePrintTransport: ROPE ~ "BridgePrintTransport";
        BridgePrintTransportDoc: ROPE ~ "\nPrint the default transport currently being used by bridge.";
        BridgePrintTransportUsage: ROPE ~ Rope.Concat["Usage: BridgePrintTransport", BridgePrintTransportDoc];

        DoBridgePrintTransport: Commander.CommandProc ~ {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]>>
            IF Args.NArgs[cmd] # 0 THEN RETURN[$Failure, BridgePrintTransportUsage];
            msg Ź Rope.Concat["Transport is ", Convert.RopeFromAtom[defaultTransportClass]];
            RETURN[result: result, msg: msg];
            };


        BridgeList: ROPE ~ "BridgeList";
        BridgeListDoc: ROPE ~ "\nList active Bridge sessions.";
        BridgeListUsage: ROPE ~ Rope.Concat["Usage: BridgeList ", BridgeListDoc];

        DoBridgeList: Commander.CommandProc ~ {
            PrintSession: BridgeDriver.EachSession ~ {
                <<PROC [sessionName: ROPE, userName: ROPE, class: ATOM] RETURNS [quit: BOOL _ FALSE]>>
                IO.PutF[cmd.out, "%g on %g (%g)\n", [rope[userName]], [rope[sessionName]], [atom[class]]]
                };
            IF Args.NArgs[cmd] # 0 THEN RETURN[$Failure, BridgeListUsage];
            EnumerateSessions[PrintSession];
            };

        BridgeKill: ROPE ~ "BridgeKill";
        BridgeKillDoc: ROPE ~ "<host> [ <user> ]\nKill a Bridge session.";
        BridgeKillUsage: ROPE ~ Rope.Concat["Usage: BridgeKill ", BridgeKillDoc];

        DoBridgeKill: Commander.CommandProc ~ {
            sessionName, userName: Args.Arg;
            excuse: ROPE;
            [sessionName, userName] Ź Args.ArgsGet[cmd, "%s[s" ! Args.Error => {msg Ź reason; CONTINUE}];
            IF msg # NIL THEN RETURN[$Failure, BridgeKillUsage];
            excuse Ź KillSession[sessionName.rope, IF userName.ok THEN userName.rope ELSE NIL];
            IF excuse # NIL THEN RETURN[$Failure, excuse];
            };

        TRUSTED { Process.Detach[FORK Daemon[]] };
        UserProfile.CallWhenProfileChanges[SmashBridgeCredentialsIfUserChanged];
        Commander.Register[
            key: BridgeChangeTransport, 
            proc: DoBridgeChangeTransport, 
            doc: BridgeChangeTransportDoc];
        Commander.Register[
            key: BridgePrintTransport, 
            proc: DoBridgePrintTransport, 
            doc: BridgePrintTransportDoc];
        Commander.Register[
            key: BridgeList, 
            proc: DoBridgeList, 
            doc: BridgeListDoc];
        Commander.Register[
            key: BridgeKill, 
            proc: DoBridgeKill, 
            doc: BridgeKillDoc];
        Commander.Register[
            key: BridgeStart, 
            proc: DoBridgeStart, 
            doc: BridgeStartDoc];
        Commander.Register[
            key: BridgeStartShort, 
            proc: DoBridgeStart, 
            doc: BridgeStartDoc];
        Commander.Register[
            key: BridgeCredentials, 
            proc: DoBridgeCredentials, 
            doc: BridgeCredentialsDoc];

        }...