DIRECTORY Commander USING [ CommandProc, Register ], CommandTool USING [ NextArgument ], Convert USING [ IntFromRope ], IO, Lark -- USING [ -- CommandEvents, ConnectionSpec, Event, LarkModel, Passel, SHHH, StatusEvent, StatusEvents ]--, LarkRpcControl USING [ ImportNewInterface, InterfaceRecord ], LarkSmarts, LarkSmartsMonitorImpl, LarkSmartsRpcControl USING [ExportInterface, InterfaceName, UnexportInterface], Log USING [ DNFProc, RegisterWhereToReport, ReportFR, Problem, ProblemFR, WhereProc ], LupineRuntime, Names USING [CmdOrToken, CurrentPasskey, RnameToRspec, Rspec ], NamesGV USING [ GVGetAttribute ], NamesRPC USING [ StartConversation ], Nice USING [ LarkConLogStream ], Rope USING [Concat, Equal], RPC USING [ AuthenticateFailed, EncryptionKey, ExportFailed, GetCaller, ImportFailed ], SafeStorage USING [ GetCanonicalType, Type ], ThNet USING [ pd ], ThPartyPrivate USING [ DehandleSmarts, LocalSmartsInterface, RegisterLocal, SmartsBody, SmartsData ], ThParty USING [ CreateParty, Deregister, Enable ], Thrush USING [ CallUrgency, ConversationHandle, Disposition, epoch, Epoch, H, NetAddress, none, nullHandle, PartyHandle, PartyType, ROPE, SmartsHandle, ThHandle, unencrypted ], ThSmartsPrivate USING [ CheckHookState, EnterLarkState, GetSmartsInfo, LarkFailed, LarkInfo, LarkInfoBody, LarkParseEvent, LarkProgress, LarkSupervise, RegisterTrunk, SmartsInfo, SmartsInfoBody ], ThSmartsRpcControl, ThVersions, Triples USING [ Any, Erase, Foreach, ForeachProc, Make ], TU ; LarkSmartsInitImpl: CEDAR MONITOR LOCKS root IMPORTS IO, Commander, CommandTool, Convert, LarkRpcControl, LarkSmartsRpcControl, Log, Names, NamesGV, NamesRPC, root: LarkSmartsMonitorImpl, LupineRuntime, Nice, Rope, RPC, SafeStorage, ThNet, ThPartyPrivate, ThParty, Thrush, ThSmartsPrivate, ThSmartsRpcControl, ThVersions, Triples, TU EXPORTS LarkSmarts, ThSmartsPrivate SHARES LarkSmartsMonitorImpl = { OPEN IO; CallUrgency: TYPE = Thrush.CallUrgency; CommandEvents: TYPE = Lark.CommandEvents; ConversationHandle: TYPE = Thrush.ConversationHandle; H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; }; none: SHHH = Thrush.none; nullHandle: Thrush.ThHandle = Thrush.nullHandle; PartyHandle: TYPE = Thrush.PartyHandle; ROPE: TYPE = Thrush.ROPE; SHHH: TYPE = Lark.SHHH; -- Encrypts conv. if first arg to RPC PROC RTSmartsType: SafeStorage.Type = SafeStorage.GetCanonicalType[CODE[ThPartyPrivate.SmartsBody]]; SmartsHandle: TYPE = Thrush.SmartsHandle; SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo; SmartsInfoBody: TYPE = ThSmartsPrivate.SmartsInfoBody; StatusEvents: TYPE = Lark.StatusEvents; larkInterfaces: LIST OF LarkRpcControl.InterfaceRecord _ NIL; larkRegistry: ROPE_".lark"; thSmartsExported: BOOL_FALSE; Register: PUBLIC PROC[ shh: SHHH, -- encrypts connection oldSmartsID: Thrush.SmartsHandle, oldEpoch: Thrush.Epoch, netAddress: Thrush.NetAddress, -- machine name for registering Lark -- model: Lark.LarkModel, authenticated: BOOL_FALSE, clientInstance: ROPE ] RETURNS [ smartsID: Thrush.SmartsHandle_nullHandle, epoch: Thrush.Epoch_Thrush.epoch ] = { ENABLE UNWIND => NULL; larkSh: Lark.SHHH; partyID: PartyHandle; localSmarts: ThPartyPrivate.LocalSmartsInterface; info: SmartsInfo; larkInterface: LarkRpcControl.InterfaceRecord_NIL; smarts: ThPartyPrivate.SmartsData; fullRname: ROPE = RPC.GetCaller[shh]; partyRname: ROPE _ fullRname; dbRname: ROPE; serviceName: ROPE; partyType: Thrush.PartyType _ individual; s: Names.Rspec _ NIL; IF (s_Names.RnameToRspec[partyRname])#NIL AND Names.RnameToRspec[s.simpleName] # NIL THEN partyRname_s.simpleName; dbRname _ partyRname.Concat[larkRegistry]; serviceName _ NamesGV.GVGetAttribute[dbRname, $service, NIL]; IF serviceName#NIL THEN partyType _ service; DeregisterIfRegistered[netAddress]; partyID _ ThParty.CreateParty[type: partyType, rName: IF partyType=individual THEN partyRname ELSE serviceName]; IF partyID=nullHandle THEN { Log.ReportFR["Registering party %s not found", $System, NIL, rope[partyRname]]; RETURN[nullHandle, Thrush.epoch]; }; larkSh _ IF NOT ThNet.pd.encryptionRequested THEN Thrush.unencrypted ELSE NamesRPC.StartConversation [ caller: myName.instance, callee: fullRname, key: serverPassword, level: --<>--CBCCheck ! RPC.AuthenticateFailed=> { Log.ProblemFR["Can't authenticate %g to %g", $System, NIL, rope[myName.instance], rope[fullRname]]; GOTO NotSmart; }]; larkInterface _ LarkRpcControl.ImportNewInterface[ interfaceName: [type: "Lark.Lark", instance: clientInstance] ! RPC.ImportFailed=> { Log.ProblemFR["Can't import Lark interface from %g", $System, NIL, rope[clientInstance]]; GOTO NotSmart; }]; larkInterfaces _ CONS[larkInterface, larkInterfaces]; localSmarts _ ThSmartsRpcControl.NewInterfaceRecord[]; localSmarts.clientStubProgress _ ThSmartsPrivate.LarkProgress; smartsID_ThPartyPrivate.RegisterLocal[ partyID: partyID, interface: localSmarts, properties: [x: voiceTerminal[machine: netAddress]] ]; IF smartsID=nullHandle THEN {Log.ProblemFR["Can't register Lark: %g, %g",$System,NIL, rope[fullRname], rope[clientInstance]]; GOTO NotSmart; }; smarts _ ThPartyPrivate.DehandleSmarts[smartsID,TRUE]; info _ NEW[SmartsInfoBody_ [ smarts: smarts, ParseEvent: ThSmartsPrivate.LarkParseEvent, Supervise: ThSmartsPrivate.LarkSupervise, larkInfo: NEW[ThSmartsPrivate.LarkInfoBody _ [ interface: larkInterface, shh: larkSh, netAddress: netAddress, model: model, autoAnswer: NamesGV.GVGetAttribute[dbRname, $autoanswer, "FALSE"].Equal["TRUE", FALSE], radio: NamesGV.GVGetAttribute[dbRname, $radio, "FALSE"].Equal["TRUE", FALSE], textToSpeech: Rope.Equal[serviceName, "Text-to-Speech", FALSE] ]] ]]; info.larkInfo.scratchEv _ NEW[Lark.CommandEventSequence[15]]; Triples.Make[$SmartsData, smarts, info]; info.otherSmarts _ ThPartyPrivate.DehandleSmarts[ ThSmartsPrivate.RegisterTrunk[ partyID, smarts, info ]]; Log.ReportFR[" (%g = %g)", $Smarts, info, rope[clientInstance], TU.RefAddr[info.smarts]]; EnableSmartsE[info]; -- Ready to go, as long as phone is on hook EXITS NotSmart => RETURN; }; EnableSmartsE: ENTRY PROC[info: SmartsInfo] = { []_EnableSmarts[info]; }; EnableSmarts: PUBLIC INTERNAL PROC[info: SmartsInfo] RETURNS[enabled: BOOL] = { ENABLE UNWIND, ThSmartsPrivate.LarkFailed =>GOTO Failed; SELECT info.larkInfo.larkState FROM none, failed, recovering => NULL; ENDCASE=> RETURN[TRUE]; IF ThSmartsPrivate.CheckHookState[info.larkInfo].onHook=FALSE THEN RETURN[FALSE]; IF ThParty.Enable[ smartsID: H[info.smarts]]#success THEN RETURN[FALSE]; -- << REPORT!! >> -- IF ThParty.Enable[ smartsID: H[info.otherSmarts]]#success THEN Log.Problem["Impossible", $Smarts, info]; ThSmartsPrivate.EnterLarkState[ info.larkInfo, none, info ]; -- Clear any previous failure. ThSmartsPrivate.EnterLarkState[ info.larkInfo, idle, info ]; -- Reset the Lark RETURN[TRUE]; EXITS Failed => RETURN[FALSE]; }; DeregisterIfRegistered: PROC[netAddress: Thrush.NetAddress] = { DR: ENTRY PROC[info: SmartsInfo] = { Deregister[info]; }; ConsiderOne: Triples.ForeachProc = { smartsData: ThPartyPrivate.SmartsData _ NARROW[trip.val]; IF smartsData#NIL THEN WITH prop: smartsData.properties SELECT FROM voiceTerminal => IF netAddress = prop.machine THEN DR[ThSmartsPrivate.GetSmartsInfo[H[smartsData]]]; ENDCASE; }; Triples.Foreach[$LocatedTerminal, Triples.Any, Triples.Any, ConsiderOne]; Triples.Foreach[$AdjacentTerminal, Triples.Any, Triples.Any, ConsiderOne]; Triples.Foreach[$VoiceTerminal, Triples.Any, Triples.Any, ConsiderOne]; }; Deregister: PUBLIC INTERNAL PROC[info: SmartsInfo] = { IF info=NIL OR ThPartyPrivate.DehandleSmarts[H[info.smarts]] = NIL THEN RETURN; ThSmartsPrivate.EnterLarkState[ info.larkInfo, failed, info ]; -- prevent further action. SimpleDeregister[ThSmartsPrivate.GetSmartsInfo[smarts: info.otherSmarts]]; SimpleDeregister[info]; Log.ReportFR["Smarts %d (%g) is dead", $Smarts, info, card[H[info.smarts]], TU.RefAddr[info.smarts]]; }; SimpleDeregister: INTERNAL PROC[info: SmartsInfo] = { ThParty.Deregister[smartsID: H[info.smarts]]; Triples.Erase[$SmartsData, info.smarts, info]; }; Login: PUBLIC PROC[shh: SHHH, smartsID: SmartsHandle, authenticated: BOOL] = { NULL }; WhereIsSmartsLog: Log.WhereProc -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- = CHECKED { info: SmartsInfo=NARROW[whereData]; IF info#NIL THEN s_Nice.LarkConLogStream[info.larkInfo.netAddress]; IF s#NIL AND s=Nice.LarkConLogStream[[[0],[0]]] THEN s_NIL; -- use default stream unless debug viewer stream open. }; WhereIsLarkLog: Log.WhereProc -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- = CHECKED { info: ThSmartsPrivate.LarkInfo=NARROW[whereData]; IF info#NIL THEN s_Nice.LarkConLogStream[info.netAddress]; IF s#NIL AND s=Nice.LarkConLogStream[[[0],[0]]] THEN s_NIL; -- only want the debug viewer stream }; WhereIsLarkLogFerSherr: Log.WhereProc _ WhereIsLarkLog; FerSherrDefault: Log.DNFProc=TRUSTED{ RETURN[ThNet.pd.defaultLarkReports]; }; myName: LarkSmartsRpcControl.InterfaceName; serverPassword: RPC.EncryptionKey; KillLark: Commander.CommandProc = { DeregisterIfRegistered[[[173B],[Convert.IntFromRope[CommandTool.NextArgument[cmd], 8]]]]; }; LarkSmartsInit: Commander.CommandProc = { ENABLE { RPC.ExportFailed => { Log.Problem["LarkSmarts export failed", $System]; GOTO Failed; }; }; myName _ [ type: "LarkSmarts.Lark", instance: Names.CmdOrToken[cmd: cmd, key: "ThrushServerInstance", default: "Morley.Lark"], version: ThVersions.ThrushVR]; serverPassword _ Names.CurrentPasskey[Names.CmdOrToken[ cmd: cmd, key: "ThrushServerPassword", default: "MFLFLX"]]; IF thSmartsExported THEN RETURN; Log.RegisterWhereToReport[proc: WhereIsLarkLog, where: $Lark]; Log.RegisterWhereToReport[proc: WhereIsLarkLogFerSherr, where: $LarkDetailed, defaultIfNotFound: FerSherrDefault]; Log.RegisterWhereToReport[proc: WhereIsSmartsLog, where: $Smarts]; LarkSmartsRpcControl.ExportInterface[ interfaceName: myName, user: myName.instance, password: serverPassword]; Log.ReportFR["Export[LarkSmarts.Lark, %s]", $System, NIL, rope[myName.instance]]; thSmartsExported _ TRUE; EXITS Failed => LarkSmartsRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE]; }; Commander.Register["LarkSmarts", LarkSmartsInit, "LarkSmarts > -- Initialize and Export LarkSmarts"]; Commander.Register["KillLark", KillLark, "KillLark 110 -- deregisters lark 110"]; }. ”LarkSmartsInitImpl.mesa Copyright c 1985 by Xerox Corporation. All rights reserved. Last modified by D. Swinehart, May 23, 1985 3:44:07 pm PDT Last Edited by: Pier, May 3, 1984 2:52:59 pm PDT Copies Registration/Deregistration/Initialization Develop partyRname: the actual RName to be used to represent this party; and dbRname: the name under which database items are stored. The rName obtained from the conversation handle may have either form initially, since Finches will supply the former and Larks will supply the latter. Also, obtain the name of the service represented by this Rname, if any, from the database. Above converts from, say, Swinehart.pa.lark to Swinehart.pa. Also, from Swinehart.pa to Swinehart.pa. Strips one registry if there are two or more. The LarkSmarts interface definition suggests that a Lark could present enough information during registration to be simply re-validated (kind of like a hand stamp at a dance) without any great effort. That turns out not to be worth it. If a Lark registers when already registered, we get rid of any old information about it first. Produce a Party object for this RName, if none exists yet. Get encryption taken care of Make sure we can talk to the Lark << No way to deal with resumption of calls in progress, as yet. >> larkInterface.Reset[larkSh, NIL]; No further bad things are expected to happen. << Inefficient. Also knows too much about party linkages. Consider additional structure relating net addresses to smarts, or the equivalent, in next redesign. May 22, 1985 5:16:18 pm PDT>> Unimport the Lark interface (automatic, via finalization.) Other Utilities Initialization, export "LarkSmarts" Same as $Lark, except doesn't print at all if debugging viewer not found. Swinehart, May 22, 1985 5:03:50 pm PDT Cedar 6.0 New ways of defining service parties. autoAnswer (formerly hotLine), radio, and textToSpeech attributes obtained from data base. Text-To-Speech service contemplated. Deregistration works in the face of duplicate service names, etc. changes to: DIRECTORY, Register, DO changes to: DIRECTORY, Register, DO, DeregisterIfRegistered, ConsiderOne (local of DeregisterIfRegistered), Deregister Κ ˜šœ™Icodešœ Οmœ1™žœ˜_—Jšœžœ˜)Jšœ žœ˜.Jšœžœ"˜6Jšœžœ˜'—˜Jšœžœžœ"žœ˜=Jšœžœ ˜J˜Jšœžœžœ˜J˜—™*J˜šΟnœžœžœ˜JšœžœŸ˜!J˜!J˜JšœŸ'˜FJ˜Jšœžœžœ˜Jšœžœ˜JšžœS˜ZJšžœžœžœ˜Jšœ žœ˜J˜J˜1J˜Jšœ.žœ˜2J˜"Jšœ žœžœ˜%Jšœ žœ ˜Jšœ žœ˜Jšœ žœ˜J˜)Jšœžœ˜J˜J™ωšžœ$ž˜)Jšžœ$žœ˜HJ™žœžœ˜l——šœžœ ˜5J˜—JšœB™BJšœžœ™!J˜Jšœ6˜6J˜>šœ&˜&Jšœ˜J˜Jšœ3˜3Jšœ˜šžœžœ6žœ˜UJšœ(žœ ˜9——Jšœ-™-Jšœ0žœ˜6šœžœ˜Jšœ˜J˜+J˜)šœ žœ!˜.J˜J˜ J˜J˜ šœ ˜ JšœDžœ˜K—JšœFžœ˜MJšœ8žœ˜>J˜——Jšœžœ ˜=J˜(šœ1˜1Jšœ8˜8—šœ)˜)Jšœ/˜/—JšœŸ+˜@šž˜Jšœ žœ˜—Jšœ˜—J˜Jš  œžœžœ0˜Iš   œžœžœžœžœ žœ˜OJšžœžœžœ˜8šžœž˜#Jšœžœ˜!Jšžœžœžœ˜—Jš žœ6žœžœžœžœ˜QJš žœžœžœžœžœŸ˜]šžœžœž˜>Jšœ)˜)—Jšœ=Ÿ˜[Jšœ=Ÿ˜NJšžœžœ˜ šž˜Jšœ žœžœ˜—J˜J˜—š œžœ#˜?J™:J™‚Jšžœžœžœ+˜9˜$Jšœ(žœ ˜9š žœ žœžœžœžœž˜CJšœžœžœžœ/˜dJšžœ˜—J˜—J˜IJ˜JJ˜GJ˜J˜—š  œžœžœžœ˜6Jš žœžœžœ1žœžœžœ˜OJšœ?Ÿ˜YJ˜JJ˜J™:šœ5˜5Jšœžœžœ˜/—J˜—J˜š œžœžœ˜5Jšœžœ˜-J˜.J˜—J˜š  œžœžœžœ)žœžœ˜VJ˜——™J˜•StartOfExpansionO -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœΠckNœžœ˜zJšœžœ ˜#Jšžœžœ3˜CJš žœžœžœ$žœžœŸ6˜rJ˜—J˜–O -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœ‘Nœžœ˜xJšœžœ ˜1Jšžœžœžœ*˜:Jš žœžœžœ$žœžœŸ$˜`J˜J˜—J–O -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœ7˜7šœžœžœ!˜MJ˜——šœ#™#J˜J˜+Jšœ"˜"J˜š œ˜#J˜YJ˜J˜—š œ˜)šžœ˜JšžœEžœ ˜WJ˜—˜ J˜JšœZ˜ZJ˜—šœ7˜7J˜;—Jšžœžœžœ˜ Jšœ>˜>šœr˜rJ™I—JšœB˜B˜%J˜J˜J˜—Jšœ5žœ˜QJšœžœ˜šž˜˜ JšœDžœ˜N——J˜——˜J˜—šœ‘˜‘J˜J˜—šœQ˜QJ˜J˜—J˜™&K™ K™§K™AKšœ Οr™#Kšœ ’<œ"’ ™v—K™—…—(Ž<"