
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;


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;
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];
};

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 ~ {
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 ~ {
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 ~ {
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 ~ {
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];

}...

  Ü  
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
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 ...
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.";
IF password = NIL AND useGV THEN {
password Ź UserCredentials.Get[].password;
};
PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]
PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]
PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]
PROC [sessionName: ROPE, userName: ROPE, class: ATOM] RETURNS [quit: BOOL _ FALSE]
 Ęx  NewlineDelimiter
(cedarcode) style J
Ďe7BIcode K3K4K1K:K&K!K Ďk		KKKKKK

KKKKKKKKKKKKKKKK ĎnK
KHtĹKKK K 7KK	#KK KK K
KpK1OK=K=K K#/K K	!KK#'K!+K
KKK K)K+K 
/KKK cK%+KK UK/7"8'<KK	KK&,K K 9K*KK #ĎcMK$6KK!K	K#K<FK
K6K&K:K1K%$	;IK.2KKYmK	&KK K KK >
˛K
K
K $QK	
=K A*3KKö'1K%K
KKKK K.5K
 7KKKKK -KK&1K	K/Kd%K"8ĆK#K,K2KşKa2dK%'K11K2K@KKKK			VK
%K5=K%-K%,ZK3?KK K+/KS^K=K(DK=  JK
KKK E $FK
!K 
%K 

NK-KK KK
KK K11K%%KKK**KK#K0YK1ZK=GK))KKKK ?KK$KK 
]K	K
K K&K
,<K(K
"@KKKK	K!!KKK ,J F

NKK .K7;KCIKKKK+KK K \K!K"8KK K$K ,K\}K K&

NK  KKK K!6K+KKK K 
JKStartOfExpansion>[s1: ROPE, pos1: INT _ 0, s2: ROPE, case: BOOL _ TRUE]6DK,K 
KKKK#KKK KK KK	K'K'K'K'K'K!KK Q<KK/3KKK QKKK	CKK)KK?FK9DK2KK9KK K(!KK
KK K*1K 	xKK
K4)8K;
!0K;KK4GK1EKK;KK "K*KKK VKKK'KK&6K-KK #$GK>KK K"K"KbvK&LK 
	wK	$K	)K K)+K!#K%LKK%5KKK	KKKKK%5KK K??K&("*K00KKKKKKK K Đbn(KK #  \KKKĎb@OTK*K4K;AKKLRKKK  KOVKK7KGLK3KK K K K6K,JK9˘sK Z	&   lK4A!KKKKKKK!=aKK Ą2K
?KK&+K'IKG3KA)/K8GKCKMKKK K.KIcK,^K .K
?:K*7KK
	0K	
	2K
K
KGMK KOVKK,K//KJK&KKK K K4KC`K.fK Ą1K
?K&HKPK!KK K K
 K˘$7K˘%˘IK Ą'*K	RKWYKK˘>K KK KĄ K˘/BK˘%˘IK Ą'K  KKR]K
˘4K	'SK
.KK K*KHHKKKKKKKKKKKKKKKKKKKKKK KK      Il  gŔ  