DIRECTORY 
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, LOG, LogProc, RegisterWhereToReport, Report, Problem, WhereProc ],
LupineRuntime,
Names USING
[--CurrentRName, -- CurrentPasskey, GetDefaultDetails, GVDetails, NetError, RnameToRspec, Rspec, StartConversation ],
Nice USING [ LarkConLogStream ],
RPC USING [ AuthenticateFailed, EncryptionKey, ExportFailed, GetCaller, ImportFailed ],
SafeStorage USING [ GetCanonicalType, Type ],
SpyLog USING [ Here ],
ThNet USING [ pd ],
ThPartyPrivate USING [ DehandleSmarts, LocalSmartsInterface, RegisterLocal, SmartsBody, SmartsData, GetPartySmarts ],
ThParty USING [ CreateParty, Deregister, Enable ],
Thrush USING [
CallUrgency, ConversationHandle, Disposition, epoch, Epoch, H, NetAddress, none, nullHandle, PartyHandle, ROPE, SmartsHandle, ThHandle, unencrypted ], 
ThSmartsPrivate USING [
CheckHookState, EnterLarkState, GetSmartsInfo, LarkFailed, LarkInfo, LarkInfoBody, LarkParseEvent, LarkProgress, LarkSupervise, RegisterTrunk, RingEnable, SmartsInfo, SetRingingParameters, SmartsInfoBody ],
ThSmartsRpcControl,
Triples USING [ Erase, Make ],
TU,
UserProfile USING [ Token ]
;

LarkSmartsInitImpl: CEDAR MONITOR LOCKS root
IMPORTS IO, 
LarkRpcControl,
LarkSmartsRpcControl,
Log,
Names,
root: LarkSmartsMonitorImpl,
LupineRuntime,
Nice,
RPC,
SafeStorage,
SpyLog,
ThNet,
ThPartyPrivate,
ThParty,
Thrush,
ThSmartsPrivate,
ThSmartsRpcControl,
Triples,
TU,
UserProfile
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;


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 ] = {
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;
s: Names.Rspec _ NIL;
gvDetails: Names.GVDetails;
ringEnable: ThSmartsPrivate.RingEnable _ on;
IF (s_Names.RnameToRspec[partyRname])#NIL
AND Names.RnameToRspec[s.simpleName] # NIL THEN partyRname_s.simpleName;
DO ENABLE UNWIND=>NULL;
partyID _ ThParty.CreateParty[
type: (SELECT model.genre FROM --<<>>-- ENDCASE=> individual),
rName: partyRname];
IF partyID=nullHandle THEN {
Log.Report[IO.PutFR["Registering party %s not found", rope[partyRname]], $System];
RETURN[nullHandle, Thrush.epoch];
};
smartsID _ ThPartyPrivate.GetPartySmarts[partyID, $VoiceTerminal];
IF smartsID#nullHandle THEN {
DR: ENTRY PROC = {
ENABLE UNWIND=>NULL;
Deregister[ThSmartsPrivate.GetSmartsInfo[smarts: smarts]];
};
smarts _ ThPartyPrivate.DehandleSmarts[smartsID];
IF oldSmartsID=smartsID AND epoch = Thrush.epoch AND smarts#NIL THEN
WITH smarts.properties SELECT FROM
voiceTerminal, manager =>
IF machine = netAddress THEN RETURN[oldSmartsID, Thrush.epoch];
ENDCASE;	-- oldHandle is a strange beast indeed.
IF smarts#NIL THEN DR[];
smartsID_nullHandle; partyID _ nullHandle; LOOP;
};

larkSh _ IF NOT ThNet.pd.encryptionRequested THEN Thrush.unencrypted
ELSE Names.StartConversation [
caller: myName.instance,
callee: fullRname,
key:	serverPassword,
level:	--<<ECB>>--CBCCheck !
RPC.AuthenticateFailed=>{ Log.Problem["Can't authenticate"]; GOTO NotSmart; }];

larkInterface _ LarkRpcControl.ImportNewInterface[
interfaceName: [type: "Lark.Lark", instance: clientInstance] !
RPC.ImportFailed=> { Log.Problem["Can't import Lark interface"]; GOTO NotSmart; }];
larkInterfaces _ CONS[larkInterface, larkInterfaces];


localSmarts _ ThSmartsRpcControl.NewInterfaceRecord[];
localSmarts.Progress _ ThSmartsPrivate.LarkProgress;
smartsID_ThPartyPrivate.RegisterLocal[
partyID: partyID,
interface: localSmarts,
properties: [x: voiceTerminal[machine: netAddress]] ! 
-- << If decide to return error code to caller, problem tells the story. >> --
Names.NetError=> { smartsID _ nullHandle; CONTINUE; }];
IF smartsID = nullHandle THEN { Log.Problem["Can't register Lark"]; 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]] ]];
info.larkInfo.scratchEv _ NEW[Lark.CommandEventSequence[15]];
IF ([,gvDetails] _ Names.GetDefaultDetails[info.larkInfo.netAddress]).results = ok AND
 gvDetails#NIL AND gvDetails.larkSpec THEN
ringEnable _ SELECT gvDetails.ringEnable FROM
'R => on,
'S => subdued,
'O => off,
ENDCASE => on;
ThSmartsPrivate.SetRingingParameters[
info: info.larkInfo, ringEnable: ringEnable, ringTune: gvDetails.ringTune]; -- set to current defaults
Triples.Make[$SmartsData, smarts, info];
info.otherSmarts _ ThPartyPrivate.DehandleSmarts[
ThSmartsPrivate.RegisterTrunk[ partyID, smarts, info ]];
Log.Report[IO.PutFR[" (%g = %g)",
rope[clientInstance], TU.RefAddr[info.smarts]], $Smarts, info];
EnableSmartsE[info]; -- Ready to go, as long as phone is on hook
EXIT;
REPEAT
NotSmart => RETURN; 
ENDLOOP;
};

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

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.Report[IO.PutFR["Smarts %d (%g) is dead", card[H[info.smarts]], TU.RefAddr[info.smarts]], $Smarts, info];
};

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

WhereIsLarkLogFerSherr: 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
};
FerSherrDefault: Log.DNFProc=TRUSTED{ RETURN[ThNet.pd.defaultLarkReports]; };

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

LOG: Log.LogProc = TRUSTED INLINE { Log.LOG[group]; };


myName: LarkSmartsRpcControl.InterfaceName = [
type: "LarkSmarts.Lark",
instance: UserProfile.Token[key: "ThrushServerInstance", default: "Morley.Lark"]];
serverPassword: RPC.EncryptionKey = Names.CurrentPasskey[UserProfile.Token[
key: "ThrushServerPassword", default: "MFLFLX"]];

LarkSmartsInit: PROC = {
ENABLE {
RPC.ExportFailed => GOTO Failed;
ANY => { Log.Problem["LarkSmarts export failed", $System]; GOTO Failed; };
};
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.Report[IO.PutFR["Export[LarkSmarts.Lark, %s]", rope[myName.instance]], $System];
EXITS
Failed =>
LarkSmartsRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
};

LarkSmartsInit[];

}.
|LarkSmartsInitImpl.mesa
Last modified by D. Swinehart, November 27, 1983 1:11 am
Last Edited by: Pier, May 3, 1984 2:52:59 pm PDT
Copies
Registration/Deregistration/Initialization
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.
Loop is for restart when had to deregister first.
Produce a Party object for this RName, if none exists yet.

This reregistration should be a no-op, if all of the supplied parameters make sense.
Otherwise, if there is a previous smartsID for this Lark, it must be eliminated.
<< This may all cause trouble later when users log in at Larks -- WAIL.>>
There are no old Lark Smarts for this Lark.  New ones are needed.

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.
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.
�Ê
h˜Jš
œ™š
œ8™8J™0J˜—šÏk	œ
˜
Jš�œ
˜šœÏc
˜Jšž_œ
˜`—Jšœ�œ)˜=J˜J˜Jšœ�œ5˜OJšœ�œ�œ?˜WJ˜šœ�˜Jš
œu˜u—Jšœ�œ˜ Jš�œ
�œN˜WJšœ�œ˜-Jšœ�œ
˜Jšœ�œ˜Jšœ�œa˜uJš
œ2˜2Jšœ�œm�œ)˜¦
šœ�œ˜Jš
œÎ
˜Î
—J˜Jšœ�œ˜Jš�œ
˜Jšœ�œ
˜J˜
J˜—šœ�
œ
�œ˜,š�œ
�œ˜J˜J˜J˜J˜J˜J˜J˜Jš�œ
˜J˜J˜J˜J˜J˜J˜J˜J˜J˜Jš�œ
˜J˜—Jš�œ˜#Jš�œ˜ Jš�œ
�œ
˜J˜—š
œ™J˜Jšœ
�œ˜'Jšœ�œ˜)Jšœ�œ˜5Jš�
œ�œ�œ�œ�œ�œ�
œ˜JJšœ�œ˜J˜0Jšœ
�œ˜'Jš�œ�œ
�œ
˜š�œ�œ�œž*˜CJšœ>�œ˜_—Jšœ�œ˜)Jšœ�œ˜.Jšœ�œ"˜6Jšœ�œ˜'—˜Jšœ�œ
�œ"�œ
˜=J˜—™*J˜šÏnœ�œ
�œ
˜Jšœ�œž˜!J˜!J˜Jšœž'˜FJ˜Jšœ�œ
�œ
˜Jšœ�œ˜Jš�œS˜ZJšœ
�œ
˜J˜J˜1J˜Jšœ.�œ
˜2J˜"Jšœ�œ�œ˜%Jšœ�œ
˜Jšœ�œ
˜J˜J˜,š�œ$�˜)Jš�œ$�œ˜HJ™<J™W——š�œ
�œ
�œ�œ
˜J™1Jš
œ:™:˜Jš	œ�œ
�œ
žœ
�œ˜>J˜—š�œ�œ
�
˜Jšœ�œE˜RJš�œ˜!Jš
œ˜—J™J™TJ™PJ™IJš
œB˜Bš�œ�œ˜š�œ�œ
�œ˜Jš�œ
�œ�œ
˜Jš
œ:˜:Jš
œ˜—Jš
œ1˜1š	�œ�œ�œ�œ
�˜Dš�œ�œ
�˜"˜Jš�œ�œ
�œ˜?—Jš�œž'˜0——Jš�œ�œ
�œ
�œ˜Jšœ+�œ
˜0š
œ˜J˜——J™AJ™Jš
œ™Jšœ	�œ
�œ�œ˜Dš�œ˜J˜J˜J˜šœžœ
˜Jš�œ:�œ˜OJ˜——Jš
œ!™!˜2˜>Jš�œ>�œ˜S——šœ�œ ˜5J˜—Jš
œB™BJšœ�œ™!J˜Jš
œ6˜6J˜4š
œ&˜&Jš
œ˜J˜˜6Jšž0Ðbcž˜NJšœ*�œ˜7——Jš�œ�œ'�œ˜XJš
œ-™-Jšœ0�œ˜6šœ�œ˜Jš
œ˜J˜+J˜)šœ
�œ!˜.J˜J˜J˜J˜——Jšœ�œ ˜=Jš�œQ�˜Vš�
œ
�œ
�œ�˜*šœ
�œ�˜-J˜	J˜J˜
Jš�œ˜——š
œ%˜%JšœLž˜f—J˜(š
œ1˜1Jš
œ8˜8—˜!Jš
œ?˜?—Jšœž+˜@Jš�œ
˜š
�˜Jšœ�œ˜—Jš�œ
˜Jš
œ˜—J˜JšŸ
œ�œ
�œ0˜IšŸœ�œ
�œ
�œ�œ
�œ˜OJš�œ
�œ�œ˜8š�œ�˜#Jšœ�œ
˜!Jš�œ�œ
�œ˜—Jš
�œ6�œ
�œ
�œ
�œ˜QJš�œ�
œ�œ
�œ
�œž˜]š�œ�
œ�˜>Jš
œ)˜)—Jšœ=ž˜[Jšœ=ž˜NJš�œ
�œ˜
š
�˜Jšœ
�œ
�œ˜—J˜J˜—šŸ
œ�œ
�œ
�œ˜6Jš�œ�œ
�œ1�œ
�œ
�œ
˜OJšœ?ž˜YJ˜JJ˜J™:Jšœ�œ&�
œ�œ'˜mJ˜—J˜šŸœ�œ
�œ˜5Jšœ�
œ˜-J˜.J˜—J˜šŸœ�œ
�œ�œ)�œ�œ˜VJ˜——™J˜•StartOfExpansionO -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœÐckNœ�œ˜zJšœ�œ˜#Jš�œ�œ3˜CJ˜—J˜–O -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœ%¡Nœ�œ˜€
Jšœ�œ˜1Jš�œ�œ
�œ*˜:Jš�œ�œ
�œ$�œ�œž$˜`J˜—šœ�œ�œ!˜MJ˜—–O -- [fixedWhereData: REF ANY, whereData: REF ANY] RETURNS [s: STREAM _ NIL] -- šœ¡Nœ�œ˜xJšœ�œ˜1Jš�œ�œ
�œ*˜:J˜J˜—š�œ�œ�œ˜6J˜——š
œ#™#J˜˜.J˜J˜R—˜KJ˜1J˜—˜š�œ
�
˜Jš�œ�œ˜ Jš�œ8�œ˜JJ˜—Jš
œ>˜>š
œr˜rJ™I—Jš
œB˜B˜%J˜J˜J˜—J˜Tš
�˜˜	JšœD�œ˜N——J˜——˜J˜J˜—J˜—…—%þ4â